Backups/csgo-2018-source
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
main
csgo-2018-source/tier0/PMELib.cpp

666 lines
15 KiB
C++
Raw Permalink Normal View History

uid issue
2021-07-25 12:11:47 +08:00
//===== Copyright <20> 1996-2005, 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
Reference in New Issue Copy Permalink