3DNOW MMX CPU Extensionen mit c/c++ abzufragen???

[ABC++ 0]

Hallöchen ,
ich möchte mich ein bisschen mit inline Assembler in Visual 6 auseinandersetzen, und suche eine Möglichkeit, zuverlässig 3DNOW bzw. MMX CPU Extensionen mit c/c++ abzufragen.
Vielleicht hat ja Wer ein bisschen Source zur Hand.

Gruß Jens

[TGGC]

c/c++ kennt kein mmx und 3dnow.

Bye, TGGC

[Vertexwahn]

aber c/c++ kennt inline assembler

such mal in der msdn nach cpu detection unter intel (glaub auch unter amd) hilft dir der Befehl cpuid weiter

[ABC++ 0]

Jo danke der Tipp mit "Cpuid" war gut .

Gruß Jens

[rapso]

der beste weg laut intel und amd ist, einfach vom gewünschten befehlssatz einen befehl ausführen und schauen ob es gelinkt.

z.B.

bool SSE2Support=true;
	try
	{
		__m128d a={0.f,0.f};
		a=_mm_add_sd(a,a);
	}
	catch(...)
	{
		SSE2Support=false;
	}

rapso->greets();

[C++ Forumbot]

Dieser Thread wurde von Moderator/in rapso aus dem Forum Spiele-/Grafikprogrammierung in das Forum Assembler verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

[miller_m]

bestimmt haben ein paar assembler cracks ein paar verbesserungen aber für den anfang taugt es.

//! \brief Klasse um CPU Features auszulesen
	class Cpu
	{
		public:
			//! \brief Standard Konstruktor
			Cpu()
			:	m_strVendor("Unkown"),
				m_strName("Unkown")
			{ }

			//! \brief Liest die CPU aus
			void Detect()
			{
				char szVendor[13];
				unsigned long eax, ebx, edx, unused;

				Cpuid(0, eax, ebx, unused, edx);

				*(unsigned long *)(szVendor) = ebx;
				*(unsigned long *)(szVendor + 4) = edx;
				*(unsigned long *)(szVendor + 8) = unused;

				szVendor[12] = '\0';

				m_strVendor = szVendor;

				Cpuid(1, eax, ebx, unused, edx);

				m_bMMX  	= ((edx & 0x800000) != 0);
				m_bSSE  	= ((edx & 0x2000000L) != 0);
				m_bSSE2 	= ((edx & 0x040000000) != 0);

				// amd 3dnow
				Cpuid(0x80000000, eax, ebx, unused, edx);

				if(eax >= 0x80000001)
				{
					Cpuid(0x80000001, eax, ebx, unused, edx);

					m_b3DNowEx = ((edx & 1<<29) != 0);
					m_b3DNow = ((edx & 1<<31) != 0);
				}

				CalculateSpeed();
			}

			const std::string &GetVendor() const		{ return m_strVendor; }
			const std::string &GetName() const			{ return m_strName; }

			static unsigned long GetSpeed() 			{ return m_nSpeed; }

			static bool IsMMX()							{ return m_bMMX; }
			static bool IsSSE()							{ return m_bSSE; }
			static bool IsSSE2()						{ return m_bSSE2; }
			static bool Is3dNow()						{ return m_b3DNowEx; }
			static bool Is3dNowEx()						{ return m_b3DNow; }

			//! \brief überladener Ausgabeoperator
			//! \param s Ausgabestream
			//! \param a Referenz auf ein Objekt
			//! \return Stream
			friend std::ostream &operator << (std::ostream &s, const Cpu &c)
			{
				s << "Cpu < " << c.m_strVendor << " ";
				s << c.m_strName << " ";
				s << c.m_nSpeed << "Mhz > ";
				s << "Supports < ";
				s << (c.m_bMMX ? "MMX " : "");
				s << (c.m_bSSE ? "SSE " : "");
				s << (c.m_bSSE2 ? "SSE2 " : "");
				s << (c.m_b3DNowEx ? "3dNowEx " : "");
				s << (c.m_b3DNow ? "3dNow " : "");
				s << ">" << std::endl;

				return s;
			}

		private:
			//! \brief CPU Geschwindigkeit ermitteln
			void CalculateSpeed()
			{
				unsigned int nStartLow, nStartHigh;
				unsigned int nEndLow, nEndHigh;
				unsigned long long nStart = 0, nEnd = 0;

#if defined(_MSC_VER)
				_asm
				{
					rdtsc
					mov [nStartLow], eax
					mov [nStartHigh], edx
				}
#else
				asm volatile("rdtsc" : "=a"(nStartLow), "=d"(nStartHigh));
#endif

#ifdef _WIN32
				Sleep(1000);
#else
				sleep(1);
#endif

#if defined(_MSC_VER)
				_asm
				{
					rdtsc
					mov [nEndLow], eax
					mov [nEndHigh], edx
				}
#else
				asm volatile("rdtsc" : "=a"(nEndLow), "=d"(nEndHigh));
#endif

				nStart |= nStartHigh;
				nStart <<= 32;
				nStart |= nStartLow;

				nEnd |= nEndHigh;
				nEnd <<= 32;
				nEnd |= nEndLow;

				m_nSpeed = static_cast<unsigned long>(((nEnd - nStart) / 1) / 1000000);
			}

			//! \brief CPUID Wrapper Funktion
			void Cpuid(
				unsigned long function,
				unsigned long &out_eax,
				unsigned long &out_ebx,
				unsigned long &out_ecx,
				unsigned long &out_edx)
			{
#if defined(_MSC_VER)
				_asm
				{
					cpuid
					mov [out_eax], eax
					mov [out_ebx], ebx
					mov [out_ecx], ecx
					mov [out_edx], edx
				}
#else
				asm volatile("push %%ebx; cpuid; mov %%ebx, %%esi; pop %%ebx"
					: "=a"(out_eax), "=S"(out_ebx), "=c"(out_ecx), "=d"(out_edx)
					: "a"(function));
#endif
			}

		private:
			//! \brief CPU Vendor
			std::string 			m_strVendor;
			//! \brief CPU Name
			std::string				m_strName;

			//! \brief ungefähre Taktfrequenz
			static unsigned long	m_nSpeed;
			//! \brief MMX support
			static bool 			m_bMMX;
			//! \brief Streaming SIMD Extensions
			static bool 			m_bSSE;
			//! \brief Streaming SIMD Extensions 2
			static bool 			m_bSSE2;
			//! \brief 3DNow! (AMD specific extensions)
			static bool 			m_b3DNowEx;
			//! \brief 3DNow! (vendor independant)
			static bool				m_b3DNow;
	};

        unsigned long	Cpu::m_nSpeed	= 0;
	bool 			Cpu::m_bMMX		= false;
	bool 			Cpu::m_bSSE		= false;
	bool 			Cpu::m_bSSE2	= false;
	bool 			Cpu::m_b3DNowEx	= false;
	bool			Cpu::m_b3DNow	= false;

[ABC++ 0]

Ja super very danke ,das ist doch was.

Gruß Jens