memorytest.h

获得多核硬件所有的相关信息。汇编源代码。Visual Studio2003、2005环境皆可。速度快。

//---------------------------------------------------------------------------
//
// MemoryTest.h: CMemoryTest Abstract Class Header
//
//---------------------------------------------------------------------------

#ifndef MemoryTestH
#define MemoryTestH

const DWORD MAX_POINTS = 512;
const DWORD MAX_MEMORY_BLOCK_SIZE = 64 << 20;
const DWORD DEF_PAGE_SIZE = 4096;

enum TESTTYPE
{
    TT_MEMORY_BANDWIDTH = 0,
    TT_DATA_CACHE_LATENCY,
    TT_MEMORY_WALK,
    TT_DATA_CACHE_BANDWIDTH,
    TT_DATA_CACHE_ARRIVAL,
    TT_DECODE_BANDWIDTH,
    TT_INSTRUCTIONS_CACHE_LATENCY,
    TT_INSTRUCTIONS_REORDER_BUFFER,
    TT_DATA_TLB,
    TT_INSTRUCTIONS_TLB,
    TT_RAM_PERFORMANCE_STREAM,
    TT_RAM_PERFORMANCE_CHECKSUM,
    TT_RAM_PERFORMANCE_SUBSTRING,
    TT_RAM_STABILITY,
    TT_FORCE_DWORD = 0x7FFFFFFF
};

enum VARIABLEPARAMETER
{
    VP_BLOCK_SIZE = 0,
    VP_PREFETCH_DISTANCE,
    VP_BLOCK_PREFETCH_SIZE,
    VP_STRIDE_SIZE,
    VP_SEGMENTS_COUNT,
    VP_NOP_COUNT,
    VP_SYNC_NOP_COUNT,
    VP_FIRST_DWORD_OFFSET,
    VP_SECOND_DWORD_OFFSET,
    VP_PREFIXES_COUNT,
    VP_NOTHING,
    VP_FORCE_DWORD = 0x7FFFFFFF
};

enum SELECTEDTESTS
{
    ST_NONE = 0x0,
    ST_READ = 0x1,
    ST_WRITE = 0x2,
    ST_COPY = 0x4,
    ST_FORWARD = 0x8,
    ST_BACKWARD = 0x10,
    ST_RANDOM = 0x20,
    ST_PSEUDORANDOM = 0x40,
    ST_READ_FORWARD = ST_READ,
    ST_READ_BACKWARD = 0x80,
    ST_WRITE_FORWARD = ST_WRITE,
    ST_WRITE_BACKWARD = 0x100,
    ST_SCALE = 0x200,
    ST_ADD = 0x400,
    ST_TRIAD = 0x800,
    ST_CRC32 = 0x1000,
    ST_ADLER32 = 0x2000,
    ST_CASE_SENSITIVE = 0x4000,
    ST_CASE_INSENSITIVE = 0x8000,
    ST_FORCE_DWORD = 0x7FFFFFFF
};

enum REGISTERTYPE
{
    RT_64_BIT_MMX = 0,
    RT_128_BIT_SSE,
    RT_128_BIT_SSE2,
    RT_FORCE_DWORD = 0x7FFFFFFF
};

enum PREFETCHTYPE
{
    PT_PREFETCHNTA = 0,
    PT_PREFETCHT0,
    PT_PREFETCHT1,
    PT_PREFETCHT2,
    PT_BLOCK_PREFETCH_1,
    PT_BLOCK_PREFETCH_2,
    PT_FORCE_DWORD = 0x7FFFFFFF
};

enum INSTRUCTIONSTYPE
{
    // ALU instructions
    IT_NOP_1BYTE = 0,
    IT_LEA_2BYTE,
    IT_MOV_2BYTE,
    IT_ADD_2BYTE,
    IT_SUB_2BYTE,
    IT_OR_2BYTE,
    IT_XOR_2BYTE,
    IT_TEST_2BYTE,
    IT_CMP_2BYTE,
    IT_SHL_3BYTE,
    IT_ROL_3BYTE,
    IT_XOR_ADD_4BYTE,
    IT_CMP_4BYTE,
    IT_CMP_0_6BYTE,
    IT_CMP_8_6BYTE,
    IT_CMP_16_6BYTE,
    IT_CMP_32_6BYTE,
    IT_CMP_0_8BYTE,
    IT_CMP_8_8BYTE,
    IT_CMP_16_8BYTE,
    IT_CMP_32_8BYTE,
    // FPU instructions
    IT_WAIT_1BYTE,
    IT_FADD_2BYTE,
    IT_FMUL_2BYTE,
    IT_FSUB_2BYTE,
    IT_FSUBR_2BYTE,
    IT_FCHS_2BYTE,
    IT_FABS_2BYTE,
    IT_FTST_2BYTE,
    IT_FXAM_2BYTE,
    IT_FCOM_2BYTE,
    IT_FCOMI_2BYTE,
    IT_FST_2BYTE,
    IT_FXCH_2BYTE,
    IT_FDECSTP_2BYTE,
    IT_FINCSTP_2BYTE,
    IT_FFREE_2BYTE,
    IT_FFREEP_2BYTE,
    // MMX instructions
    IT_EMMS_2BYTE,
    IT_MOVQ_3BYTE,
    IT_POR_3BYTE,
    IT_PXOR_3BYTE,
    IT_PADDD_3BYTE,
    IT_PSUBD_3BYTE,
    IT_PCMPEQD_3BYTE,
    IT_PUNPCKLDQ_3BYTE,
    IT_PSLLQ_4BYTE,
    // Jumps
    IT_JUMP_NEAR = 0,
    IT_JUMP_FAR = 1,
    IT_FORCE_DWORD = 0x7FFFFFFF
};

enum LATENCYMEASUREMENT
{
    LM_METHOD_1 = 0,
    LM_METHOD_2,
    LM_FORCE_DWORD = 0x7FFFFFFF
};

enum TESTMODE
{
    TM_MEM_BANDWIDTH_READ = 0,
    TM_MEM_BANDWIDTH_WRITE = 1,
    TM_MEM_BANDWIDTH_COPY = 2,
    TM_DCACHE_LATENCY_FORWARD = 0,
    TM_DCACHE_LATENCY_BACKWARD = 1,
    TM_DCACHE_LATENCY_RANDOM = 2,
    TM_DCACHE_LATENCY_PSEUDORANDOM = 3,
    TM_MEMORY_WALK_FORWARD = 0,
    TM_MEMORY_WALK_BACKWARD = 1,
    TM_MEMORY_WALK_RANDOM = 2,
    TM_DCACHE_BANDWIDTH_READ_FORWARD = 0,
    TM_DCACHE_BANDWIDTH_READ_BACKWARD = 1,
    TM_DCACHE_BANDWIDTH_WRITE_FORWARD = 2,
    TM_DCACHE_BANDWIDTH_WRITE_BACKWARD = 3,
    TM_DCACHE_ARRIVAL_FORWARD = 0,
    TM_DCACHE_ARRIVAL_BACKWARD = 1,
    TM_DCACHE_ARRIVAL_RANDOM = 2,
    TM_DCACHE_ARRIVAL_PSEUDORANDOM = 3,
    TM_DECODE = 0,
    TM_ICACHE_LATENCY_FORWARD = 0,
    TM_ICACHE_LATENCY_BACKWARD = 1,
    TM_ICACHE_LATENCY_RANDOM = 2,
    TM_ICACHE_LATENCY_PSEUDORANDOM = 3,
    TM_IROB_FORWARD = 0,
    TM_IROB_BACKWARD = 1,
    TM_IROB_RANDOM = 2,
    TM_IROB_PSEUDORANDOM = 3,
    TM_DTLB_FORWARD = 0,
    TM_DTLB_BACKWARD = 1,
    TM_DTLB_RANDOM = 2,
    TM_ITLB_FORWARD = 0,
    TM_ITLB_BACKWARD = 1,
    TM_ITLB_RANDOM = 2,
    TM_STREAM_COPY = 0,
    TM_STREAM_SCALE = 1,
    TM_STREAM_ADD = 2,
    TM_STREAM_TRIAD = 3,
    TM_CHECKSUM_CRC32 = 0,
    TM_CHECKSUM_ADLER32 = 1,
    TM_SUBSTRING_CASE_SENSITIVE = 0,
    TM_SUBSTRING_CASE_INSENSITIVE = 1,
    TM_FORCE_DWORD = 0x7FFFFFFF
};

enum MEMORYALLOCATION
{
    MA_STANDARD = 0,
    MA_VIRTUALLOCK,
    MA_AWE,
    MA_NONE,
    MA_FORCE_DWORD = 0x7FFFFFFF
};

struct TESTDATA
{
    TESTTYPE TestType;
    SELECTEDTESTS SelectedTests;
    VARIABLEPARAMETER VariableParameter;
    DWORD DataSetSize;      // bytes
    DWORD LogStrideSize[2]; // Log(StrideSize)
    DWORD BlockSize[2];     // Min, Max (bytes)
    // Memory Bandwidth tests
    REGISTERTYPE RegisterType;
    union
    {
        PREFETCHTYPE PrefetchType;
        LATENCYMEASUREMENT LatencyMeasurement;
    };
    BOOL UseNonTemporalStore;
    BOOL UseCopyToSelf;
    union
    {
        DWORD PrefetchDistance[2];
        DWORD SubStringSize[2];
    };
    DWORD BlockPrefetchSize[2];
    // Memory Latency tests
    DWORD SegmentsCount[2];  // 1..32
    DWORD NopCount[2];       // 0..511
    DWORD SyncNopCount[2];   // 0..511
    DWORD FirstOffset[2];
    DWORD SecondOffset[2];
    // Decode Bandwidth test
    INSTRUCTIONSTYPE InstructionsType;
    // Misc
    BOOL IsLogScale;
    BOOL IsWhiteBackground;
    // Stability test
    DWORD TestTime;
    DWORD LogInterval;
    DWORD Reserved;
};

struct MEASUREMENTDATA
{
    TESTMODE TestMode;
    DWORD BlockSize;
    DWORD RepeatCount;
    DWORD LogStrideSize;
    DWORD NopCount;
    DWORD SyncNopCount;
    DWORD SegmentsCount;
    union
    {
        DWORD PrefetchDistance;
        DWORD SubStringSize;
    };
    DWORD BlockPrefetchSize;
    DWORD FirstOffset;
    DWORD SecondOffset;
};

struct GRAPHDATA
{
    DWORD Size;
    int xVal;
    float Value;
    DWORD reserved;
};

struct TESTRESULTS
{
    int NumPoints;
    GRAPHDATA GraphData[MAX_POINTS];
};

class CAbsMemoryTest
{
public:
    virtual ~CAbsMemoryTest() = 0;
    virtual HRESULT __stdcall GetNopLatency(double* pdNopLatency) = 0;
    virtual HRESULT __stdcall SetNopLatency(double dNopLatency) = 0;
    virtual HRESULT __stdcall GetCacheLineSize(DWORD dwLevel, DWORD* pLineSize) = 0;
    virtual HRESULT __stdcall SetCacheLineSize(DWORD dwLevel, DWORD dwLineSize) = 0;
    virtual HRESULT __stdcall GetCpuModelData(LPSTR szModel, LPSTR szCore) = 0;
    virtual HRESULT __stdcall SetCpuModelData(LPCSTR szModel, LPCSTR szCore) = 0;
    virtual HRESULT __stdcall GetCpuFrequencyData(double* freq) = 0;
    virtual HRESULT __stdcall SetCpuFrequencyData(double freq) = 0;
    virtual HRESULT __stdcall GetMemoryTypeData(LPSTR szType) = 0;
    virtual HRESULT __stdcall SetMemoryTypeData(LPCSTR szType) = 0;
    virtual HRESULT __stdcall GetMemoryTimingsData(DWORD* tCL, DWORD* tRCD, DWORD* tRP, DWORD* tRAS) = 0;
    virtual HRESULT __stdcall SetMemoryTimingsData(DWORD tCL, DWORD tRCD, DWORD tRP, DWORD tRAS) = 0;
    virtual HRESULT __stdcall GetMemoryFrequencyData(double* freq) = 0;
    virtual HRESULT __stdcall SetMemoryFrequencyData(double freq) = 0;
    virtual HRESULT __stdcall MeasureCacheLineSize(DWORD dwLevel) = 0;
    virtual HRESULT __stdcall CreateBMPFile(LPCSTR pszFile) = 0;
    virtual HRESULT __stdcall Initialize(MEMORYALLOCATION memAlloc, char* pError) = 0;
    virtual HRESULT __stdcall Connect(HWND hWnd) = 0;
    virtual HRESULT __stdcall SetPriority(DWORD dwCpuIndex) = 0;
    virtual HRESULT __stdcall Lock(DWORD dwCpuIndex) = 0;
    virtual HRESULT __stdcall SetData(TESTDATA* pTD) = 0;
    virtual HRESULT __stdcall RunTest() = 0;
    virtual HRESULT __stdcall ShowGraph() = 0;
    virtual HRESULT __stdcall PaintGraph() = 0;
    virtual HRESULT __stdcall GetResults(TESTRESULTS* pTR, DWORD dwTestNum) = 0;
    virtual HRESULT __stdcall SetResults(TESTRESULTS* pTR, DWORD dwTestNum) = 0;
    virtual HRESULT __stdcall Unlock() = 0;
    virtual HRESULT __stdcall ResetPriority() = 0;
    virtual HRESULT __stdcall Disconnect() = 0;
    virtual HRESULT __stdcall Terminate(MEMORYALLOCATION memAlloc, char* pError) = 0;
};

#endif