XStateSave.c File Reference

#include "precomp.h"
#include <windows.h>

Include dependency graph for XStateSave.c:

Go to the source code of this file.

Macros
#define	REG_COUNT_SSE   16
#define	REG_COUNT_AVX   16
#define	REG_COUNT_AVX512   32
#define	ok_eq_m128i(a, b)   ok_eq_m128i_(a, b, #a, __LINE__)
#define	ok_eq_m256i(a, b)   ok_eq_m256i_(a, b, #a, __LINE__)
#define	ok_eq_m512i(a, b)   ok_eq_m512i_(a, b, #a, __LINE__)

Functions
static VOID	AdjustAffinity (VOID)
struct _DECLSPEC_INTRIN_TYPE	_CRT_ALIGN (16)
struct _DECLSPEC_INTRIN_TYPE	_CRT_ALIGN (32)
struct _DECLSPEC_INTRIN_TYPE	_CRT_ALIGN (64)
void __fastcall	set_SSE_state (const M128U64 data[REG_COUNT_SSE])
void __fastcall	get_SSE_state (M128U64 data[REG_COUNT_SSE])
void __fastcall	set_AVX_state (const M256U64 data[REG_COUNT_AVX])
void __fastcall	get_AVX_state (M256U64 data[REG_COUNT_AVX])
void __fastcall	set_AVX512_state (const M512U64 data[REG_COUNT_AVX512])
void __fastcall	get_AVX512_state (M512U64 data[REG_COUNT_AVX512])
BOOL	ok_eq_m128i_ (M128U64 a, M128U64 b, const char *variable, unsigned int line)
BOOL	ok_eq_m256i_ (M256U64 a, M256U64 b, const char *variable, unsigned int line)
BOOL	ok_eq_m512i_ (M512U64 a, M512U64 b, const char *variable, unsigned int line)
ULONG64	GenRandom64 (VOID)
VOID	RandomFill128 (M128U64 *Data128, ULONG Count)
VOID	RandomFill256 (M256U64 *Data256, ULONG Count)
VOID	RandomFill512 (M512U64 *Data512, ULONG Count)
static DWORD WINAPI	Thread_SSE (LPVOID Parameter)
void	Test_SSE (void)
static DWORD WINAPI	Thread_AVX (LPVOID Parameter)
void	Test_AVX (void)
static DWORD WINAPI	Thread_AVX512 (LPVOID Parameter)
void	Test_AVX512 (void)
	START_TEST (XStateSave)

Variables
static ULONG	s_ProcessorNumber
	M128U64
	M256U64
	M512U64
ULONG	g_randomSeed = 0x12345678

Macro Definition Documentation

ok_eq_m128i

#define ok_eq_m128i	(		a,
			b
	)		ok_eq_m128i_(a, b, #a, __LINE__)

Definition at line 66 of file XStateSave.c.

ok_eq_m256i

#define ok_eq_m256i	(		a,
			b
	)		ok_eq_m256i_(a, b, #a, __LINE__)

Definition at line 76 of file XStateSave.c.

ok_eq_m512i

#define ok_eq_m512i	(		a,
			b
	)		ok_eq_m512i_(a, b, #a, __LINE__)

Definition at line 89 of file XStateSave.c.

REG_COUNT_AVX

#define REG_COUNT_AVX   16

Definition at line 46 of file XStateSave.c.

REG_COUNT_AVX512

#define REG_COUNT_AVX512   32

Definition at line 47 of file XStateSave.c.

REG_COUNT_SSE

#define REG_COUNT_SSE   16

Definition at line 45 of file XStateSave.c.

Function Documentation

_CRT_ALIGN() [1/3]

const unsigned long long _CRT_ALIGN

(

16

)

Definition at line 25 of file XStateSave.c.

{
    unsigned __int64 u64[2];
} M128U64;

_CRT_ALIGN() [2/3]

struct _DECLSPEC_INTRIN_TYPE _CRT_ALIGN

(

32

)

Definition at line 30 of file XStateSave.c.

{
    unsigned __int64 u64[4];
} M256U64;

_CRT_ALIGN() [3/3]

struct _DECLSPEC_INTRIN_TYPE _CRT_ALIGN

(

64

)

Definition at line 35 of file XStateSave.c.

{
    unsigned __int64 u64[8];
} M512U64;

AdjustAffinity()

static VOID AdjustAffinity ( VOID  )

static

Definition at line 15 of file XStateSave.c.

{
    KAFFINITY OldAffinity, NewAffinity;
 
    /* Set affinity to the current test processor */
    NewAffinity = (KAFFINITY)1 << s_ProcessorNumber;
    OldAffinity = SetThreadAffinityMask(GetCurrentThread(), NewAffinity);
    ok(OldAffinity != 0, "SetThreadAffinityMask(0x%Ix) failed\n", NewAffinity);
}

Referenced by START_TEST(), Thread_AVX(), Thread_AVX512(), and Thread_SSE().

GenRandom64()

ULONG64 GenRandom64

(

VOID

)

Definition at line 93 of file XStateSave.c.

{
    ULONG Low32 = RtlRandom(&g_randomSeed);
    ULONG High32 = RtlRandom(&g_randomSeed);
    return ((ULONG64)High32 << 32) | Low32;
}

Referenced by RandomFill128(), RandomFill256(), and RandomFill512().

get_AVX512_state()

void __fastcall get_AVX512_state

(

M512U64

data[REG_COUNT_AVX512]

)

Referenced by Test_AVX512(), and Thread_AVX512().

get_AVX_state()

void __fastcall get_AVX_state

(

M256U64

data[REG_COUNT_AVX]

)

Referenced by Test_AVX(), and Thread_AVX().

get_SSE_state()

void __fastcall get_SSE_state

(

M128U64

data[REG_COUNT_SSE]

)

Referenced by Test_SSE(), and Thread_SSE().

ok_eq_m128i_()

BOOL ok_eq_m128i_	(	M128U64	a,
		M128U64	b,
		const char *	variable,
		unsigned int	line
	)

Definition at line 59 of file XStateSave.c.

{
    BOOL equal = !memcmp(&a, &b, sizeof(M128U64));
    ok_(__FILE__, line)(equal, "Variable %s Expected %I64x %I64x, got %I64x %I64x\n",
        variable, b.u64[1], b.u64[0], a.u64[1], a.u64[0]);
    return TRUE;
}

ok_eq_m256i_()

BOOL ok_eq_m256i_	(	M256U64	a,
		M256U64	b,
		const char *	variable,
		unsigned int	line
	)

Definition at line 68 of file XStateSave.c.

{
    BOOL equal = !memcmp(&a, &b, sizeof(M256U64));
    ok_(__FILE__, line)(equal, "Variable %s Expected %I64x %I64x %I64x %I64x, got %I64x %I64x %I64x %I64x\n",
        variable, b.u64[3], b.u64[2], b.u64[1], b.u64[0],
        a.u64[3], a.u64[2], a.u64[1], a.u64[0]);
    return TRUE;
}

ok_eq_m512i_()

BOOL ok_eq_m512i_	(	M512U64	a,
		M512U64	b,
		const char *	variable,
		unsigned int	line
	)

Definition at line 78 of file XStateSave.c.

{
    BOOL equal = !memcmp(&a, &b, sizeof(M512U64));
    ok_(__FILE__, line)(equal, "Variable %s Expected %I64x %I64x %I64x %I64x %I64x %I64x %I64x %I64x, got %I64x %I64x %I64x %I64x %I64x %I64x %I64x %I64x\n",
        variable,
        b.u64[7], b.u64[6], b.u64[5], b.u64[4],
        b.u64[3], b.u64[2], b.u64[1], b.u64[0],
        a.u64[7], a.u64[6], a.u64[5], a.u64[4],
        a.u64[3], a.u64[2], a.u64[1], a.u64[0]);
    return TRUE;
}

RandomFill128()

VOID RandomFill128	(	M128U64 *	Data128,
		ULONG	Count
	)

Definition at line 100 of file XStateSave.c.

{
    for (ULONG i = 0; i < Count; i++)
    {
        Data128[i].u64[0] = GenRandom64();
        Data128[i].u64[1] = GenRandom64();
    }
}

Referenced by Test_SSE(), and Thread_SSE().

RandomFill256()

VOID RandomFill256	(	M256U64 *	Data256,
		ULONG	Count
	)

Definition at line 109 of file XStateSave.c.

{
    for (ULONG i = 0; i < Count; i++)
    {
        Data256[i].u64[0] = GenRandom64();
        Data256[i].u64[1] = GenRandom64();
        Data256[i].u64[2] = GenRandom64();
        Data256[i].u64[3] = GenRandom64();
    }
}

Referenced by Test_AVX(), and Thread_AVX().

RandomFill512()

VOID RandomFill512	(	M512U64 *	Data512,
		ULONG	Count
	)

Definition at line 120 of file XStateSave.c.

{
    for (ULONG i = 0; i < Count; i++)
    {
        Data512[i].u64[0] = GenRandom64();
        Data512[i].u64[1] = GenRandom64();
        Data512[i].u64[2] = GenRandom64();
        Data512[i].u64[3] = GenRandom64();
        Data512[i].u64[4] = GenRandom64();
        Data512[i].u64[5] = GenRandom64();
        Data512[i].u64[6] = GenRandom64();
        Data512[i].u64[7] = GenRandom64();
    }
}

Referenced by Test_AVX512(), and Thread_AVX512().

set_AVX512_state()

void __fastcall set_AVX512_state

(

const M512U64

data[REG_COUNT_AVX512]

)

Referenced by Test_AVX512(), and Thread_AVX512().

set_AVX_state()

void __fastcall set_AVX_state

(

const M256U64

data[REG_COUNT_AVX]

)

Referenced by Test_AVX(), and Thread_AVX().

set_SSE_state()

void __fastcall set_SSE_state

(

const M128U64

data[REG_COUNT_SSE]

)

Referenced by Test_SSE(), and Thread_SSE().

START_TEST()

START_TEST

(

XStateSave

)

Definition at line 339 of file XStateSave.c.

{
    SYSTEM_INFO sysinfo;
 
    GetSystemInfo(&sysinfo);
 
    for (s_ProcessorNumber = 0;
         s_ProcessorNumber < sysinfo.dwNumberOfProcessors;
         s_ProcessorNumber++)
    {
        AdjustAffinity();
 
        Test_SSE();
        Test_AVX();
        Test_AVX512();
    }
}

Test_AVX()

void Test_AVX

(

void

)

Definition at line 224 of file XStateSave.c.

{
    if (!IsProcessorFeaturePresent(PF_AVX_INSTRUCTIONS_AVAILABLE))
    {
        skip("AVX not supported\n");
        return;
    }
 
    // Fill the array with random numbers
    M256U64 InAvxState[REG_COUNT_AVX];
    RandomFill256(InAvxState, ARRAYSIZE(InAvxState));
 
    _SEH2_TRY
    {
        // Set the state
        set_AVX_state(InAvxState);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ok(FALSE, "Failed to set AVX state\n");
        return;
    }
    _SEH2_END;
 
    // Run a different thread that uses AVX
    HANDLE hThread = CreateThread(NULL, 0, Thread_AVX, NULL, 0, NULL);
    ok(hThread != NULL, "CreateThread failed\n");
    if (hThread == NULL)
    {
        skip("CreateThread failed\n");
        return;
    }
 
    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);
 
    // Get the state
    M256U64 OutAvxState[REG_COUNT_AVX] = { 0 };
    get_AVX_state(OutAvxState);
 
    // Validte the state of the non-volatile registers
    for (ULONG i = 6; i < ARRAYSIZE(OutAvxState); i++)
    {
        ok_eq_m256i(OutAvxState[i], InAvxState[i]);
    }
}

Referenced by START_TEST().

Test_AVX512()

void Test_AVX512

(

void

)

Definition at line 292 of file XStateSave.c.

{
    if (!IsProcessorFeaturePresent(PF_AVX512F_INSTRUCTIONS_AVAILABLE))
    {
        skip("AVX512 not supported\n");
        return;
    }
 
    // Fill the array with random numbers
    M512U64 InAvx512State[REG_COUNT_AVX512];
    RandomFill512(InAvx512State, ARRAYSIZE(InAvx512State));
 
    _SEH2_TRY
    {
        // Set the state
        set_AVX512_state(InAvx512State);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ok(FALSE, "Failed to set AVX512 state\n");
        return;
    }
    _SEH2_END;
 
    // Run a different thread that uses AVX512
    HANDLE hThread = CreateThread(NULL, 0, Thread_AVX512, NULL, 0, NULL);
    ok(hThread != NULL, "CreateThread failed\n");
    if (hThread == NULL)
    {
        skip("CreateThread failed\n");
        return;
    }
 
    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);
 
    // Get the state
    M512U64 OutAvx512State[REG_COUNT_AVX512] = { 0 };
    get_AVX512_state(OutAvx512State);
 
    // Validte the state of the non-volatile registers
    for (ULONG i = 6; i < ARRAYSIZE(OutAvx512State); i++)
    {
        ok_eq_m512i(OutAvx512State[i], InAvx512State[i]);
    }
}

Referenced by START_TEST().

Test_SSE()

void Test_SSE

(

void

)

Definition at line 156 of file XStateSave.c.

{
    if (!IsProcessorFeaturePresent(PF_XMMI_INSTRUCTIONS_AVAILABLE))
    {
        skip("SSE not supported\n");
        return;
    }
 
    // Fill the array with random numbers
    M128U64 InSseState[REG_COUNT_SSE];
    RandomFill128(InSseState, ARRAYSIZE(InSseState));
 
    _SEH2_TRY
    {
        // Set the state
        set_SSE_state(InSseState);
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        ok(FALSE, "Failed to set SSE state\n");
        return;
    }
    _SEH2_END;
 
    // Run a different thread that uses SSE
    HANDLE hThread = CreateThread(NULL, 0, Thread_SSE, NULL, 0, NULL);
    ok(hThread != NULL, "CreateThread failed\n");
    if (hThread == NULL)
    {
        skip("CreateThread failed\n");
        return;
    }
 
    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);
 
    // Get the state
    M128U64 OutSseState[REG_COUNT_SSE] = { 0 };
    get_SSE_state(OutSseState);
 
    // Validte the state of the non-volatile registers
    for (ULONG i = 6; i < REG_COUNT_SSE; i++)
    {
        ok_eq_m128i(OutSseState[i], InSseState[i]);
    }
}

Referenced by START_TEST().

Thread_AVX()

static DWORD WINAPI Thread_AVX ( LPVOID  Parameter )

static

Definition at line 203 of file XStateSave.c.

{
    AdjustAffinity();
 
    // Get the current (fresh) state
    M256U64 AvxState[REG_COUNT_AVX];
    get_AVX_state(AvxState);
 
    // Make sure it's all zero
    static const M256U64 Zero256 = { 0 };
    for (ULONG i = 0; i < ARRAYSIZE(AvxState); i++)
    {
        ok_eq_m256i(AvxState[i], Zero256);
    }
 
    // Set a new "random" state
    RandomFill256(AvxState, ARRAYSIZE(AvxState));
    set_AVX_state(AvxState);
    return 0;
}

Referenced by Test_AVX().

Thread_AVX512()

static DWORD WINAPI Thread_AVX512 ( LPVOID  Parameter )

static

Definition at line 271 of file XStateSave.c.

{
    AdjustAffinity();
 
    // Get the current (fresh) state
    M512U64 Avx512State[REG_COUNT_AVX512];
    get_AVX512_state(Avx512State);
 
    // Make sure it's all zero
    static const M512U64 Zero512 = { 0 };
    for (ULONG i = 0; i < ARRAYSIZE(Avx512State); i++)
    {
        ok_eq_m512i(Avx512State[i], Zero512);
    }
 
    // Set a new "random" state
    RandomFill512(Avx512State, ARRAYSIZE(Avx512State));
    set_AVX512_state(Avx512State);
    return 0;
}

Referenced by Test_AVX512().

Thread_SSE()

static DWORD WINAPI Thread_SSE ( LPVOID  Parameter )

static

Definition at line 135 of file XStateSave.c.

{
    AdjustAffinity();
 
    // Get the current (fresh) state
    M128U64 SseState[REG_COUNT_SSE] = { 0 };
    get_SSE_state(SseState);
 
    // Make sure it's all zero
    static const M128U64 Zero128 = { 0 };
    for (ULONG i = 0; i < ARRAYSIZE(SseState); i++)
    {
        ok_eq_m128i(SseState[i], Zero128);
    }
 
    // Set a new "random" state
    RandomFill128(SseState, ARRAYSIZE(SseState));
    set_SSE_state(SseState);
    return 0;
}

Referenced by Test_SSE().

Variable Documentation

g_randomSeed

ULONG g_randomSeed = 0x12345678

Definition at line 91 of file XStateSave.c.

Referenced by GenRandom64().

M128U64

M128U64

Definition at line 28 of file XStateSave.c.

Referenced by ok_eq_m128i_(), Test_SSE(), and Thread_SSE().

M256U64

M256U64

Definition at line 33 of file XStateSave.c.

Referenced by ok_eq_m256i_(), Test_AVX(), and Thread_AVX().

M512U64

M512U64

Definition at line 38 of file XStateSave.c.

Referenced by ok_eq_m512i_(), Test_AVX512(), and Thread_AVX512().

s_ProcessorNumber

ULONG s_ProcessorNumber

static

Definition at line 11 of file XStateSave.c.

Referenced by AdjustAffinity(), and START_TEST().