1

tier0/PMELib.cpp

@@ -0,0 +1,665 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//===========================================================================//
+
+#ifdef _WIN32
+#include <windows.h>
+
+#pragma warning( disable : 4530 )   // warning: exception handler -GX option
+
+#include "tier0/valve_off.h"
+#include "tier0/pmelib.h"
+#if _MSC_VER >=1300
+#else
+#include "winioctl.h"
+#endif
+#include "tier0/valve_on.h"
+
+#include "tier0/ioctlcodes.h"
+
+// NOTE: This has to be the last file included!
+#include "tier0/memdbgon.h"
+
+
+PME* PME::_singleton = 0;
+
+// Single interface.
+PME* PME::Instance()
+{
+   if (_singleton == 0)
+   {
+      _singleton = new PME;
+   }      
+   return _singleton;
+}    
+
+//---------------------------------------------------------------------------
+// Open the device driver and detect the processor
+//---------------------------------------------------------------------------
+HRESULT PME::Init( void )
+{
+    OSVERSIONINFO	OS;
+
+    if ( bDriverOpen )
+        return E_DRIVER_ALREADY_OPEN;
+
+    switch( vendor )
+    {
+    case INTEL:
+    case AMD:
+        break;
+    default:
+        bDriverOpen = FALSE;		// not an Intel or Athlon processor so return false
+        return E_UNKNOWN_CPU_VENDOR;
+    }
+
+    //-----------------------------------------------------------------------
+    // Get the operating system version
+    //-----------------------------------------------------------------------
+    OS.dwOSVersionInfoSize = sizeof( OSVERSIONINFO );
+    GetVersionEx( &OS );
+
+    if ( OS.dwPlatformId == VER_PLATFORM_WIN32_NT )
+    {
+        hFile = CreateFile(						// WINDOWS NT
+            "\\\\.\\GDPERF",
+            GENERIC_READ,
+            0,
+            NULL,
+            OPEN_EXISTING,
+            FILE_ATTRIBUTE_NORMAL,
+            NULL);
+    }
+    else
+    {
+        hFile = CreateFile(						// WINDOWS 95
+            "\\\\.\\GDPERF.VXD",
+            GENERIC_READ,
+            0,
+            NULL,
+            OPEN_EXISTING,
+            FILE_ATTRIBUTE_NORMAL,
+            NULL);
+    }
+
+    if (hFile == INVALID_HANDLE_VALUE )
+        return E_CANT_OPEN_DRIVER;
+
+
+    bDriverOpen = TRUE;
+
+
+    //-------------------------------------------------------------------
+    // We have successfully opened the device driver, get the family
+    // of the processor.
+    //-------------------------------------------------------------------
+
+
+
+    //-------------------------------------------------------------------
+    // We need to write to counter 0 on the pro family to enable both
+    // of the performance counters. We write to both so they start in a
+    // known state. For the pentium this is not necessary.
+    //-------------------------------------------------------------------
+    if (vendor == INTEL && version.Family == PENTIUMPRO_FAMILY)
+    {
+        SelectP5P6PerformanceEvent(P6_CLOCK, 0, TRUE, TRUE);
+        SelectP5P6PerformanceEvent(P6_CLOCK, 1, TRUE, TRUE);
+    }
+
+    return S_OK;
+
+
+}
+
+
+
+//---------------------------------------------------------------------------
+// Close the device driver
+//---------------------------------------------------------------------------
+HRESULT PME::Close(void)
+{
+	if (bDriverOpen == false)				// driver is not going
+		return E_DRIVER_NOT_OPEN;
+
+    bDriverOpen = false;
+
+	if (hFile)					// if we have no driver handle, return FALSE
+	{
+        BOOL result = CloseHandle(hFile);
+
+        hFile = NULL;
+		return result ? S_OK : HRESULT_FROM_WIN32( GetLastError() );
+	}  
+    else
+	    return E_DRIVER_NOT_OPEN;
+
+
+}
+
+//---------------------------------------------------------------------------
+// Select the event to monitor with counter 0
+//
+HRESULT PME::SelectP5P6PerformanceEvent(uint32 dw_event, uint32 dw_counter,
+								  bool b_user, bool b_kernel)
+{
+	HRESULT	hr = S_OK;
+
+	if (dw_counter>1)		// is the counter valid
+		return E_BAD_COUNTER;
+
+	if (bDriverOpen == false)				// driver is not going
+		return E_DRIVER_NOT_OPEN;
+
+	if ( ((dw_event>>28)&0xF) != (uint32)version.Family)
+	{
+		return E_ILLEGAL_OPERATION;		// this operation is not for this processor
+	}
+
+	if ( (((dw_event & 0x300)>>8) & (dw_counter+1)) == 0 )
+	{
+		return E_ILLEGAL_OPERATION;		// this operation is not for this counter
+	}
+
+    switch(version.Family)
+    {
+    case PENTIUM_FAMILY:
+        {
+            uint64	i64_cesr;
+            int	i_kernel_bit,i_user_bit;
+            BYTE u1_event = (BYTE)((dw_event & (0x3F0000))>>16);
+
+            if (dw_counter==0)		// the kernel and user mode bits depend on
+            {						// counter being used.
+                i_kernel_bit = 6;
+                i_user_bit = 7;
+            }
+            else
+            {
+                i_kernel_bit = 22;
+                i_user_bit = 23;
+            }
+
+            ReadMSR(0x11, &i64_cesr);	// get current P5 event select (cesr)
+
+            // top 32bits of cesr are not valid so ignore them
+            i64_cesr &= ((dw_counter == 0)?0xffff0000:0x0000ffff); 
+            WriteMSR(0x11,i64_cesr); 				// stop the counter
+            WriteMSR((dw_counter==0)?0x12:0x13,0ui64);	// clear the p.counter
+
+            // set the user and kernel mode bits
+            i64_cesr |= ( b_user?(1<<7):0 ) | ( b_kernel?(1<<6):0 );
+
+            // is this the special P5 value that signals count clocks??
+            if (u1_event == 0x3f)
+            {
+                WriteMSR(0x11, i64_cesr|0x100);	// Count clocks
+            }
+            else
+            {
+                WriteMSR(0x11, i64_cesr|u1_event);	// Count events
+            }
+
+        }
+        break;
+
+    case PENTIUMPRO_FAMILY:
+
+        {
+            BYTE u1_event = (BYTE)((dw_event & (0xFF0000))>>16);
+            BYTE u1_mask = (BYTE)((dw_event & 0xFF));
+
+            // Event select 0 and 1 are identical.
+            hr = WriteMSR((dw_counter==0)?0x186:0x187,
+                
+                
+                uint64((u1_event | (b_user?(1<<16):0) | (b_kernel?(1<<17):0) | (1<<22) | (1<<18) | (u1_mask<<8)) ) 
+                );
+        }
+        break;
+
+    case PENTIUM4_FAMILY:
+        // use the p4 path
+        break;
+
+    default:
+		return E_UNKNOWN_CPU;
+	}
+
+	return hr;
+}
+
+//---------------------------------------------------------------------------
+// Read model specific register
+//---------------------------------------------------------------------------
+HRESULT PME::ReadMSR(uint32 dw_reg, int64 * pi64_value)
+{
+	DWORD	dw_ret_len;
+
+	if (bDriverOpen == false)				// driver is not going
+		return E_DRIVER_NOT_OPEN;
+
+	BOOL result = DeviceIoControl
+	(
+		hFile,						// Handle to device
+		(DWORD) IOCTL_READ_MSR,		// IO Control code for Read
+		&dw_reg,					// Input Buffer to driver.
+		sizeof(uint32),				// Length of input buffer.
+		pi64_value,					// Output Buffer from driver.
+		sizeof(int64),			// Length of output buffer in bytes.
+		&dw_ret_len,				// Bytes placed in output buffer.
+		NULL						// NULL means wait till op. completes
+	);
+
+	HRESULT hr = result ? S_OK : HRESULT_FROM_WIN32( GetLastError() );
+	if (hr == S_OK && dw_ret_len != sizeof(int64))
+		hr = E_BAD_DATA;
+
+	return hr;
+}
+
+HRESULT PME::ReadMSR(uint32 dw_reg, uint64 * pi64_value)
+{
+	DWORD	dw_ret_len;
+
+	if (bDriverOpen == false)				// driver is not going
+		return E_DRIVER_NOT_OPEN;
+
+	BOOL result = DeviceIoControl
+	(
+		hFile,						// Handle to device
+		(DWORD) IOCTL_READ_MSR,		// IO Control code for Read
+		&dw_reg,					// Input Buffer to driver.
+		sizeof(uint32),				// Length of input buffer.
+		pi64_value,					// Output Buffer from driver.
+		sizeof(uint64),			    // Length of output buffer in bytes.
+		&dw_ret_len,				// Bytes placed in output buffer.
+		NULL						// NULL means wait till op. completes
+	);
+
+	HRESULT hr = result ? S_OK : HRESULT_FROM_WIN32( GetLastError() );
+	if (hr == S_OK && dw_ret_len != sizeof(uint64))
+		hr = E_BAD_DATA;
+
+	return hr;
+}
+
+//---------------------------------------------------------------------------
+// Write model specific register
+//---------------------------------------------------------------------------
+HRESULT PME::WriteMSR(uint32 dw_reg, const int64 & i64_value)
+{
+	DWORD	dw_buffer[3];
+	DWORD	dw_ret_len;
+
+	if (bDriverOpen == false)				// driver is not going
+		return E_DRIVER_NOT_OPEN;
+
+	dw_buffer[0]				= dw_reg;			// setup the 12 byte input
+	*((int64*)(&dw_buffer[1]))= i64_value;
+
+	BOOL result = DeviceIoControl
+	(
+		hFile,						// Handle to device
+		(DWORD) IOCTL_WRITE_MSR,	// IO Control code for Read
+		dw_buffer,					// Input Buffer to driver.
+		12,							// Length of Input buffer
+		NULL,						// Buffer from driver, None for WRMSR
+		0,							// Length of output buffer in bytes.
+		&dw_ret_len,			// Bytes placed in DataBuffer.
+		NULL					  	// NULL means wait till op. completes.
+	);
+
+	HRESULT hr = result ? S_OK : HRESULT_FROM_WIN32( GetLastError() );
+	if (hr == S_OK && dw_ret_len != 0)
+		hr = E_BAD_DATA;
+
+	return hr;
+}
+
+
+
+HRESULT PME::WriteMSR(uint32 dw_reg, const uint64 & i64_value)
+{
+	DWORD	dw_buffer[3];
+	DWORD	dw_ret_len;
+
+	if (bDriverOpen == false)				// driver is not going
+		return E_DRIVER_NOT_OPEN;
+
+	dw_buffer[0]				= dw_reg;			// setup the 12 byte input
+	*((uint64*)(&dw_buffer[1]))= i64_value;
+
+	BOOL result = DeviceIoControl
+	(
+		hFile,						// Handle to device
+		(DWORD) IOCTL_WRITE_MSR,	// IO Control code for Read
+		dw_buffer,					// Input Buffer to driver.
+		12,							// Length of Input buffer
+		NULL,						// Buffer from driver, None for WRMSR
+		0,							// Length of output buffer in bytes.
+		&dw_ret_len,			// Bytes placed in DataBuffer.
+		NULL					  	// NULL means wait till op. completes.
+	);
+
+    //E_POINTER
+	HRESULT hr = result ? S_OK : HRESULT_FROM_WIN32( GetLastError() );
+	if (hr == S_OK && dw_ret_len != 0)
+		hr = E_BAD_DATA;
+
+	return hr;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+#pragma hdrstop
+
+
+
+
+//---------------------------------------------------------------------------
+// Return the frequency of the processor in Hz.
+//
+
+double PME::GetCPUClockSpeedFast(void)
+{
+	int64	i64_perf_start, i64_perf_freq, i64_perf_end;
+	int64	i64_clock_start,i64_clock_end;
+	double d_loop_period, d_clock_freq;
+
+	//-----------------------------------------------------------------------
+	// Query the performance of the Windows high resolution timer.
+	//-----------------------------------------------------------------------
+	QueryPerformanceFrequency((LARGE_INTEGER*)&i64_perf_freq);
+
+	//-----------------------------------------------------------------------
+	// Query the current value of the Windows high resolution timer.
+	//-----------------------------------------------------------------------
+	QueryPerformanceCounter((LARGE_INTEGER*)&i64_perf_start);
+	i64_perf_end = 0;
+
+	//-----------------------------------------------------------------------
+	// Time of loop of 250000 windows cycles with RDTSC
+	//-----------------------------------------------------------------------
+	RDTSC(i64_clock_start);
+	while(i64_perf_end<i64_perf_start+250000)
+	{
+		QueryPerformanceCounter((LARGE_INTEGER*)&i64_perf_end);
+	}
+	RDTSC(i64_clock_end);
+
+	//-----------------------------------------------------------------------
+	// Caclulate the frequency of the RDTSC timer and therefore calculate
+	// the frequency of the processor.
+	//-----------------------------------------------------------------------
+	i64_clock_end -= i64_clock_start;
+
+	d_loop_period = ((double)(i64_perf_freq)) / 250000.0;
+	d_clock_freq = ((double)(i64_clock_end & 0xffffffff))*d_loop_period;
+
+	return (float)d_clock_freq;
+}
+
+
+
+// takes 1 second
+double PME::GetCPUClockSpeedSlow(void)
+{
+
+    if (m_CPUClockSpeed != 0)
+        return m_CPUClockSpeed;
+
+    unsigned long start_ms, stop_ms;
+    unsigned long start_tsc,stop_tsc;
+
+    // boosting priority helps with noise. its optional and i dont think
+    //  it helps all that much
+
+    PME * pme = PME::Instance();
+
+    pme->SetProcessPriority(ProcessPriorityHigh);
+
+    // wait for millisecond boundary
+    start_ms = GetTickCount() + 5;
+    while (start_ms <= GetTickCount());
+
+    // read timestamp (you could use QueryPerformanceCounter in hires mode if you want)
+#ifdef COMPILER_MSVC64 
+    RDTSC(start_tsc);
+#else
+    __asm
+    {
+        rdtsc
+        mov dword ptr [start_tsc+0],eax
+        mov dword ptr [start_tsc+4],edx
+    }
+#endif
+
+    // wait for end
+    stop_ms = start_ms + 1000; // longer wait gives better resolution
+    while (stop_ms > GetTickCount());
+
+    // read timestamp (you could use QueryPerformanceCounter in hires mode if you want)
+#ifdef COMPILER_MSVC64
+    RDTSC(stop_tsc);
+#else
+    __asm
+    {
+        rdtsc
+        mov dword ptr [stop_tsc+0],eax
+        mov dword ptr [stop_tsc+4],edx
+    }
+#endif
+
+
+    // normalize priority
+    pme->SetProcessPriority(ProcessPriorityNormal);
+
+    // return clock speed
+    //  optionally here you could round to known clocks, like speeds that are multimples
+    //  of 100, 133, 166, etc.
+    m_CPUClockSpeed =  ((stop_tsc - start_tsc) * 1000.0) / (double)(stop_ms - start_ms);
+    return m_CPUClockSpeed;
+
+}
+
+
+
+const unsigned short cccr_escr_map[NCOUNTERS][8] = 
+{
+      {       
+      0x3B2,
+      0x3B4,
+      0x3AA,
+      0x3B6,
+      0x3AC,
+      0x3C8,
+      0x3A2,
+      0x3A0,
+      },
+      {   
+      0x3B2,
+      0x3B4,
+      0x3AA,
+      0x3B6,
+      0x3AC,
+      0x3C8, 
+      0x3A2,
+      0x3A0,
+      },
+      {       
+      0x3B3,
+      0x3B5,
+      0x3AB,
+      0x3B7,
+      0x3AD,
+      0x3C9, 
+      0x3A3,
+      0x3A1,
+      },
+      {   
+      0x3B3,
+      0x3B5,
+      0x3AB,
+      0x3B7,
+      0x3AD,
+      0x3C9, 
+      0x3A3,
+      0x3A1,
+      },
+      {       
+          
+      0x3C0,
+      0x3C4, 
+      0x3C2,
+      },
+      {   
+      0x3C0,
+      0x3C4, 
+      0x3C2,
+      },
+      {       
+      0x3C1,
+      0x3C5, 
+      0x3C3,
+      },
+      {   
+      0x3C1,
+      0x3C5,
+      0x3C3,
+      },
+      {       
+      0x3A6,
+      0x3A4,
+      0x3AE,
+      0x3B0, 
+      0,
+      0x3A8,
+      },
+      {   
+      0x3A6,
+      0x3A4,
+      0x3AE,
+      0x3B0, 
+      0,
+      0x3A8,
+      },
+      {       
+        
+      0x3A7,
+      0x3A5,
+      0x3AF,
+      0x3B1, 
+      0,
+      0x3A9,
+      },
+      {   
+          
+      0x3A7,
+      0x3A5,
+      0x3AF,
+      0x3B1, 
+      0,
+      0x3A9,
+      },
+      {       
+
+      0x3BA,
+      0x3CA, 
+      0x3BC,
+      0x3BE,
+      0x3B8,
+      0x3CC,
+      0x3E0,
+      },
+      {   
+
+      0x3BA,
+      0x3CA, 
+      0x3BC,
+      0x3BE,
+      0x3B8,
+      0x3CC,
+      0x3E0,
+      },
+      {       
+
+      0x3BB,
+      0x3CB, 
+      0x3BD,
+      0,
+      0x3B9,
+      0x3CD,
+      0x3E1,
+      },
+      {   
+          
+
+      0x3BB,
+      0x3CB, 
+      0x3BD,
+      0,
+      0x3B9,
+      0x3CD,
+      0x3E1,
+      },
+      {       
+      0x3BA,
+      0x3CA, 
+      0x3BC,
+      0x3BE,
+      0x3B8,
+      0x3CC,
+      0x3E0,
+      },
+      {    
+
+      0x3BB,
+      0x3CB,
+      0x3BD,
+      0,
+      0x3B9,
+      0x3CD,
+      0x3E1,
+      },
+};
+
+#ifdef DBGFLAG_VALIDATE
+//-----------------------------------------------------------------------------
+// Purpose: Ensure that all of our internal structures are consistent, and
+//			account for all memory that we've allocated.
+// Input:	validator -		Our global validator object
+//			pchName -		Our name (typically a member var in our container)
+//-----------------------------------------------------------------------------
+void PME::Validate( CValidator &validator, tchar *pchName )
+{
+	validator.Push( _T("PME"), this, pchName );
+
+	validator.ClaimMemory( this );
+
+	validator.ClaimMemory( cache );
+
+	validator.ClaimMemory( ( void * ) vendor_name.c_str( ) );
+	validator.ClaimMemory( ( void * ) brand.c_str( ) );
+
+	validator.Pop( );
+}
+#endif // DBGFLAG_VALIDATE
+
+#pragma warning( default : 4530 )   // warning: exception handler -GX option
+#endif
+