Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-10 12:53:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

style: correct variable naming

Browse Source 
Signed-off-by: Artur Harasimiuk <artur.harasimiuk@intel.com>
This commit is contained in:
Artur Harasimiuk
2022-05-16 15:15:59 +00:00
committed by Compute-Runtime-Automation
parent 06517f429f
commit 4c98e98011
13 changed files with 437 additions and 437 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
opencl/test/unit_test/api/cl_enqueue_task_tests.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -51,11 +51,11 @@ TEST_F(EnqueueTaskWithRequiredWorkGroupSize, GivenRequiredWorkGroupSizeWhenEnque
cl_uint numEventsInWaitList = 0;
cl_event *eventWaitList = nullptr;
cl_event *event = nullptr;
cl_command_queue command_queue = static_cast<cl_command_queue>(pCmdQ);
cl_command_queue commandQueue = static_cast<cl_command_queue>(pCmdQ);
cl_kernel kernel = static_cast<cl_kernel>(pMultiDeviceKernel);
retVal = clEnqueueTask(
command_queue,
commandQueue,
kernel,
numEventsInWaitList,
eventWaitList,

74
opencl/test/unit_test/api/cl_get_device_and_host_timer.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -36,85 +36,85 @@ typedef api_tests clGetHostTimerTest;
namespace ULT {
TEST_F(clGetDeviceAndHostTimerTest, GivenNullDeviceWhenGettingDeviceAndHostTimerThenInvalidDeviceErrorIsReturned) {
cl_ulong device_timestamp = 0;
cl_ulong host_timestamp = 0;
cl_ulong deviceTimestamp = 0;
cl_ulong hostTimestamp = 0;
retVal = clGetDeviceAndHostTimer(
nullptr,
&device_timestamp,
&host_timestamp);
&deviceTimestamp,
&hostTimestamp);
EXPECT_EQ(CL_INVALID_DEVICE, retVal);
}
TEST_F(clGetDeviceAndHostTimerTest, GivenNullHostTimerWhenGettingDeviceAndHostTimerThenInvalidValueErrorIsReturned) {
cl_ulong device_timestamp = 0;
cl_ulong deviceTimestamp = 0;
retVal = clGetDeviceAndHostTimer(
testedClDevice,
&device_timestamp,
&deviceTimestamp,
nullptr);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clGetDeviceAndHostTimerTest, GivenNullDevicesTimerWhenGettingDeviceAndHostTimerThenInvalidValueErrorIsReturned) {
cl_ulong host_timestamp = 0;
cl_ulong hostTimestamp = 0;
retVal = clGetDeviceAndHostTimer(
testedClDevice,
nullptr,
&host_timestamp);
&hostTimestamp);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
}
TEST_F(clGetDeviceAndHostTimerTest, GivenValidOSTimeWhenGettingDeviceAndHostTimerThenSuccessIsReturned) {
cl_ulong device_timestamp = 0;
cl_ulong host_timestamp = 0;
cl_ulong zero_timestamp = 0;
cl_ulong deviceTimestamp = 0;
cl_ulong hostTimestamp = 0;
cl_ulong zeroTimestamp = 0;
auto mDev = new MockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr)};
mDev->setOSTime(new MockOSTime());
retVal = clGetDeviceAndHostTimer(
mDev,
&device_timestamp,
&host_timestamp);
&deviceTimestamp,
&hostTimestamp);
EXPECT_GT(device_timestamp, zero_timestamp);
EXPECT_GT(host_timestamp, zero_timestamp);
EXPECT_GT(deviceTimestamp, zeroTimestamp);
EXPECT_GT(hostTimestamp, zeroTimestamp);
EXPECT_EQ(retVal, CL_SUCCESS);
delete mDev;
}
TEST_F(clGetDeviceAndHostTimerTest, GivenInvalidOSTimeWhenGettingDeviceAndHostTimerThenOutOfResourcesErrorIsReturned) {
cl_ulong device_timestamp = 0;
cl_ulong host_timestamp = 0;
cl_ulong zero_timestamp = 0;
cl_ulong deviceTimestamp = 0;
cl_ulong hostTimestamp = 0;
cl_ulong zeroTimestamp = 0;
auto mDev = new MockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr)};
mDev->setOSTime(new FailOSTime());
retVal = clGetDeviceAndHostTimer(
mDev,
&device_timestamp,
&host_timestamp);
&deviceTimestamp,
&hostTimestamp);
EXPECT_EQ(device_timestamp, zero_timestamp);
EXPECT_EQ(host_timestamp, zero_timestamp);
EXPECT_EQ(deviceTimestamp, zeroTimestamp);
EXPECT_EQ(hostTimestamp, zeroTimestamp);
EXPECT_EQ(retVal, CL_OUT_OF_RESOURCES);
delete mDev;
}
TEST_F(clGetHostTimerTest, GivenNullDeviceWhenGettingHostTimerThenInvalidDeviceErrorIsReturned) {
cl_ulong host_timestamp = 0;
cl_ulong hostTimestamp = 0;
retVal = clGetHostTimer(
nullptr,
&host_timestamp);
&hostTimestamp);
EXPECT_EQ(CL_INVALID_DEVICE, retVal);
}
@ -128,46 +128,46 @@ TEST_F(clGetHostTimerTest, GivenNullHostTimerWhenGettingHostTimerThenInvalidValu
}
TEST_F(clGetHostTimerTest, GivenCorrectParametersWhenGettingHostTimerThenSuccessIsReturned) {
cl_ulong host_timestamp = 0;
cl_ulong zero_timestamp = 0;
cl_ulong hostTimestamp = 0;
cl_ulong zeroTimestamp = 0;
retVal = clGetHostTimer(
testedClDevice,
&host_timestamp);
&hostTimestamp);
EXPECT_GE(host_timestamp, zero_timestamp);
EXPECT_GE(hostTimestamp, zeroTimestamp);
EXPECT_EQ(retVal, CL_SUCCESS);
}
TEST_F(clGetHostTimerTest, GivenValidOSTimeWhenGettingHostTimerThenSuccessIsReturned) {
cl_ulong host_timestamp = 0;
cl_ulong zero_timestamp = 0;
cl_ulong hostTimestamp = 0;
cl_ulong zeroTimestamp = 0;
auto mDev = new MockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr)};
mDev->setOSTime(new MockOSTime());
retVal = clGetHostTimer(
mDev,
&host_timestamp);
&hostTimestamp);
EXPECT_GE(host_timestamp, zero_timestamp);
EXPECT_GE(hostTimestamp, zeroTimestamp);
EXPECT_EQ(retVal, CL_SUCCESS);
delete mDev;
}
TEST_F(clGetHostTimerTest, GivenInvalidOSTimeWhenGettingHostTimerThenOutOfResourcesErrorIsReturned) {
cl_ulong host_timestamp = 0;
cl_ulong zero_timestamp = 0;
cl_ulong hostTimestamp = 0;
cl_ulong zeroTimestamp = 0;
auto mDev = new MockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr)};
mDev->setOSTime(new FailOSTime());
retVal = clGetHostTimer(
mDev,
&host_timestamp);
&hostTimestamp);
EXPECT_EQ(host_timestamp, zero_timestamp);
EXPECT_EQ(hostTimestamp, zeroTimestamp);
EXPECT_EQ(retVal, CL_OUT_OF_RESOURCES);
delete mDev;

94
opencl/test/unit_test/api/cl_get_event_profiling_info_tests.inl
View File

@ -42,18 +42,18 @@ cl_int ProfilingInfo[] = {
TEST_F(clEventProfilingTests, GivenInvalidParamNameWhenGettingEventProfilingInfoThenInvalidValueErrorIsReturned) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
pEvent->setStatus(CL_COMPLETE);
size_t param_value_size = sizeof(cl_ulong);
cl_ulong param_value;
size_t param_value_size_ret;
size_t paramValueSize = sizeof(cl_ulong);
cl_ulong paramValue;
size_t paramValueSizeRet;
cl_int retVal = CL_PROFILING_INFO_NOT_AVAILABLE;
cl_event event = (cl_event)pEvent;
pEvent->setProfilingEnabled(true);
retVal = clGetEventProfilingInfo(event,
0,
param_value_size,
&param_value,
&param_value_size_ret);
paramValueSize,
&paramValue,
&paramValueSizeRet);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
delete pEvent;
@ -80,18 +80,18 @@ TEST_F(clEventProfilingTests, GivenInvalidParametersWhenGettingEventProfilingInf
TEST_F(clEventProfilingTests, GivenInvalidParamValueSizeWhenGettingEventProfilingInfoThenInvalidValueErrorIsReturned) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
pEvent->setStatus(CL_COMPLETE);
size_t param_value_size = sizeof(cl_ulong);
cl_ulong param_value;
size_t param_value_size_ret;
size_t paramValueSize = sizeof(cl_ulong);
cl_ulong paramValue;
size_t paramValueSizeRet;
cl_int retVal = CL_PROFILING_INFO_NOT_AVAILABLE;
cl_event event = (cl_event)pEvent;
pEvent->setProfilingEnabled(true);
retVal = clGetEventProfilingInfo(event,
ProfilingInfo[0],
param_value_size - 1,
&param_value,
&param_value_size_ret);
paramValueSize - 1,
&paramValue,
&paramValueSizeRet);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
delete pEvent;
@ -100,18 +100,18 @@ TEST_F(clEventProfilingTests, GivenInvalidParamValueSizeWhenGettingEventProfilin
TEST_F(clEventProfilingTests, GivenValidParametersWhenGettingEventProfilingInfoThenSuccessIsReturned) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
pEvent->setStatus(CL_COMPLETE);
size_t param_value_size = sizeof(cl_ulong);
cl_ulong param_value;
size_t param_value_size_ret;
size_t paramValueSize = sizeof(cl_ulong);
cl_ulong paramValue;
size_t paramValueSizeRet;
cl_event event = (cl_event)pEvent;
pEvent->setProfilingEnabled(true);
for (auto infoId : ::ProfilingInfo) {
cl_int retVal = clGetEventProfilingInfo(event,
infoId,
param_value_size,
&param_value,
&param_value_size_ret);
paramValueSize,
&paramValue,
&paramValueSizeRet);
EXPECT_EQ(CL_SUCCESS, retVal);
}
@ -121,16 +121,16 @@ TEST_F(clEventProfilingTests, GivenValidParametersWhenGettingEventProfilingInfoT
TEST_F(clEventProfilingTests, GivenNullParamValueSizeRetWhenGettingEventProfilingInfoThenSuccessIsReturned) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
pEvent->setStatus(CL_COMPLETE);
size_t param_value_size = sizeof(cl_ulong);
cl_ulong param_value;
size_t paramValueSize = sizeof(cl_ulong);
cl_ulong paramValue;
cl_event event = (cl_event)pEvent;
pEvent->setProfilingEnabled(true);
cl_int retVal = clGetEventProfilingInfo(event,
ProfilingInfo[0],
param_value_size,
&param_value,
paramValueSize,
&paramValue,
nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -145,7 +145,7 @@ TEST_F(clEventProfilingTests, GivenNullEventWhenGettingEventProfilingInfoThenInv
TEST_F(clEventProfilingTests, GivenNullParamValueAndZeroParamValueSizeWhenGettingEventProfilingInfoThenSuccessIsReturned) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
size_t param_value_size = 0;
size_t paramValueSize = 0;
pEvent->setStatus(CL_COMPLETE);
pEvent->setProfilingEnabled(true);
@ -153,7 +153,7 @@ TEST_F(clEventProfilingTests, GivenNullParamValueAndZeroParamValueSizeWhenGettin
cl_event event = (cl_event)pEvent;
cl_int retVal = clGetEventProfilingInfo(event,
CL_PROFILING_COMMAND_QUEUED,
param_value_size,
paramValueSize,
nullptr,
nullptr);
@ -164,7 +164,7 @@ TEST_F(clEventProfilingTests, GivenNullParamValueAndZeroParamValueSizeWhenGettin
TEST_F(clEventProfilingTests, GivenNullParamValueAndCorrectParamValueSizeWhenGettingEventProfilingInfoThenSuccessIsReturned) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
size_t param_value_size = sizeof(cl_ulong);
size_t paramValueSize = sizeof(cl_ulong);
pEvent->setStatus(CL_COMPLETE);
pEvent->setProfilingEnabled(true);
@ -172,7 +172,7 @@ TEST_F(clEventProfilingTests, GivenNullParamValueAndCorrectParamValueSizeWhenGet
cl_event event = (cl_event)pEvent;
cl_int retVal = clGetEventProfilingInfo(event,
CL_PROFILING_COMMAND_QUEUED,
param_value_size,
paramValueSize,
nullptr,
nullptr);
@ -183,17 +183,17 @@ TEST_F(clEventProfilingTests, GivenNullParamValueAndCorrectParamValueSizeWhenGet
TEST_F(clEventProfilingTests, GivenUserEventWhenGettingEventProfilingInfoThenProfilingInfoNotAvailableErrorIsReturned) {
UserEvent *ue = new UserEvent();
size_t param_value_size = sizeof(cl_ulong);
cl_ulong param_value;
size_t param_value_size_ret;
size_t paramValueSize = sizeof(cl_ulong);
cl_ulong paramValue;
size_t paramValueSizeRet;
cl_event event = (cl_event)ue;
for (auto infoId : ::ProfilingInfo) {
cl_int retVal = clGetEventProfilingInfo(event,
infoId,
param_value_size,
&param_value,
&param_value_size_ret);
paramValueSize,
&paramValue,
&paramValueSizeRet);
EXPECT_EQ(CL_PROFILING_INFO_NOT_AVAILABLE, retVal);
}
delete ue;
@ -225,14 +225,14 @@ TEST_F(clEventProfilingTests, GivenStartTimeGreaterThenEndTimeWhenGettingDeltaTh
TEST_F(clEventProfilingTests, givenTimestampThatOverlapWhenGetDeltaIsCalledThenProperDeltaIsComputed) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
cl_ulong TimeMax = maxNBitValue(pDevice->getHardwareInfo().capabilityTable.kernelTimestampValidBits);
cl_ulong timeMax = maxNBitValue(pDevice->getHardwareInfo().capabilityTable.kernelTimestampValidBits);
cl_ulong realDelta = 10;
cl_ulong startTime = TimeMax - realDelta;
cl_ulong startTime = timeMax - realDelta;
cl_ulong endTime = 2;
cl_ulong Delta = 0;
Delta = pEvent->getDelta(startTime, endTime);
EXPECT_EQ(realDelta + endTime, Delta);
cl_ulong delta = 0;
delta = pEvent->getDelta(startTime, endTime);
EXPECT_EQ(realDelta + endTime, delta);
delete pEvent;
}
@ -244,28 +244,28 @@ TEST_F(clEventProfilingTests, GivenProfilingDisabledWhenCalculatingProfilingData
TEST_F(clEventProfilingTests, GivenProfilingEnabledWhenCalculatingProfilingDataThenFalseIsNotReturned) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
cl_bool Result = pEvent->isProfilingEnabled();
EXPECT_EQ(((cl_bool)CL_FALSE), Result);
cl_bool result = pEvent->isProfilingEnabled();
EXPECT_EQ(((cl_bool)CL_FALSE), result);
pEvent->setProfilingEnabled(true);
Result = pEvent->isProfilingEnabled();
EXPECT_NE(((cl_bool)CL_FALSE), Result);
result = pEvent->isProfilingEnabled();
EXPECT_NE(((cl_bool)CL_FALSE), result);
delete pEvent;
}
TEST_F(clEventProfilingTests, GivenProfilingEnabledAndUserEventsWhenCalculatingProfilingDataThenFalseIsReturned) {
Event *pEvent = new UserEvent();
cl_bool Result = pEvent->isProfilingEnabled();
EXPECT_EQ(((cl_bool)CL_FALSE), Result);
cl_bool result = pEvent->isProfilingEnabled();
EXPECT_EQ(((cl_bool)CL_FALSE), result);
delete pEvent;
}
TEST_F(clEventProfilingTests, GivenPerfCountersEnabledWhenCheckingPerfCountersThenTrueIsReturned) {
Event *pEvent = new Event(pCommandQueue, 0, 0, 0);
bool Result = pEvent->isPerfCountersEnabled();
EXPECT_FALSE(Result);
bool result = pEvent->isPerfCountersEnabled();
EXPECT_FALSE(result);
pEvent->setPerfCountersEnabled(true);
Result = pEvent->isPerfCountersEnabled();
EXPECT_TRUE(Result);
result = pEvent->isPerfCountersEnabled();
EXPECT_TRUE(result);
delete pEvent;
}

20
opencl/test/unit_test/api/cl_get_kernel_work_group_info_tests.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -76,7 +76,7 @@ TEST_F(clGetKernelWorkGroupInfoTest, GivenNullDeviceWhenGettingWorkGroupInfoFrom
}
TEST_F(clGetKernelWorkGroupInfoTests, GivenKernelRequiringScratchSpaceWhenGettingKernelWorkGroupInfoThenCorrectSpillMemSizeIsReturned) {
size_t paramValueSizeRet;
cl_ulong param_value;
cl_ulong paramValue;
auto pDevice = castToObject<ClDevice>(testedClDevice);
MockKernelWithInternals mockKernel(*pDevice);
@ -90,18 +90,18 @@ TEST_F(clGetKernelWorkGroupInfoTests, GivenKernelRequiringScratchSpaceWhenGettin
pDevice,
CL_KERNEL_SPILL_MEM_SIZE_INTEL,
sizeof(cl_ulong),
&param_value,
&paramValue,
&paramValueSizeRet);
EXPECT_EQ(retVal, CL_SUCCESS);
EXPECT_EQ(paramValueSizeRet, sizeof(cl_ulong));
EXPECT_EQ(param_value, scratchSpaceSize);
EXPECT_EQ(paramValue, scratchSpaceSize);
}
using matcher = IsWithinProducts<IGFX_SKYLAKE, IGFX_DG1>;
HWTEST2_F(clGetKernelWorkGroupInfoTests, givenKernelHavingPrivateMemoryAllocationWhenAskedForPrivateAllocationSizeThenProperSizeIsReturned, matcher) {
size_t paramValueSizeRet;
cl_ulong param_value;
cl_ulong paramValue;
auto pDevice = castToObject<ClDevice>(testedClDevice);
MockKernelWithInternals mockKernel(*pDevice);
@ -112,17 +112,17 @@ HWTEST2_F(clGetKernelWorkGroupInfoTests, givenKernelHavingPrivateMemoryAllocatio
pDevice,
CL_KERNEL_PRIVATE_MEM_SIZE,
sizeof(cl_ulong),
&param_value,
&paramValue,
&paramValueSizeRet);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(sizeof(cl_ulong), paramValueSizeRet);
EXPECT_EQ(1024U, param_value);
EXPECT_EQ(1024U, paramValue);
}
TEST_F(clGetKernelWorkGroupInfoTests, givenKernelNotHavingPrivateMemoryAllocationWhenAskedForPrivateAllocationSizeThenZeroIsReturned) {
size_t paramValueSizeRet;
cl_ulong param_value;
cl_ulong paramValue;
auto pDevice = castToObject<ClDevice>(testedClDevice);
MockKernelWithInternals mockKernel(*pDevice);
@ -132,12 +132,12 @@ TEST_F(clGetKernelWorkGroupInfoTests, givenKernelNotHavingPrivateMemoryAllocatio
pDevice,
CL_KERNEL_PRIVATE_MEM_SIZE,
sizeof(cl_ulong),
&param_value,
&paramValue,
&paramValueSizeRet);
EXPECT_EQ(retVal, CL_SUCCESS);
EXPECT_EQ(paramValueSizeRet, sizeof(cl_ulong));
EXPECT_EQ(param_value, 0u);
EXPECT_EQ(paramValue, 0u);
}
static cl_kernel_work_group_info paramNames[] = {

46
opencl/test/unit_test/api/cl_intel_accelerator_tests.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -52,11 +52,11 @@ struct IntelAcceleratorTestWithValidDescriptor : IntelAcceleratorTest {
};
TEST_F(IntelAcceleratorTestWithValidDescriptor, GivenInvalidAcceleratorTypeWhenCreatingAcceleratorThenClInvalidAcceleratorTypeIntelErrorIsReturned) {
auto INVALID_ACCELERATOR_TYPE = static_cast<cl_accelerator_type_intel>(0xEEEEEEEE);
auto invalidAcceleratorType = static_cast<cl_accelerator_type_intel>(0xEEEEEEEE);
accelerator = clCreateAcceleratorINTEL(
pContext,
INVALID_ACCELERATOR_TYPE,
invalidAcceleratorType,
sizeof(cl_motion_estimation_desc_intel),
&desc,
&retVal);
@ -161,42 +161,42 @@ TEST_F(IntelAcceleratorGetInfoTest, GivenClAcceleratorReferenceCountIntelWhenGet
}
TEST_F(IntelAcceleratorGetInfoTest, GivenClAcceleratorReferenceCountIntelWhenGettingAcceleratorInfoThenParamValueIsOne) {
cl_uint param_value = static_cast<cl_uint>(-1);
cl_uint paramValue = static_cast<cl_uint>(-1);
result = clGetAcceleratorInfoINTEL(
accelerator,
CL_ACCELERATOR_REFERENCE_COUNT_INTEL,
sizeof(cl_uint),
&param_value,
&paramValue,
nullptr);
EXPECT_EQ(CL_SUCCESS, result);
EXPECT_EQ(1u, param_value);
EXPECT_EQ(1u, paramValue);
}
TEST_F(IntelAcceleratorGetInfoTest, GivenLongForDescriptorSizeWhenGettingAcceleratorInfoThenCorrectValuesAreReturned) {
cl_uint param_value = static_cast<cl_uint>(-1);
cl_uint paramValue = static_cast<cl_uint>(-1);
result = clGetAcceleratorInfoINTEL(
accelerator,
CL_ACCELERATOR_REFERENCE_COUNT_INTEL,
sizeof(cl_uint) + 1,
&param_value,
&paramValue,
&param_value_size_ret);
EXPECT_EQ(CL_SUCCESS, result);
EXPECT_EQ(sizeof(cl_uint), param_value_size_ret);
EXPECT_EQ(1u, param_value);
EXPECT_EQ(1u, paramValue);
}
TEST_F(IntelAcceleratorGetInfoTest, GivenShortForDescriptorSizeWhenGettingAcceleratorInfoThenClInvalidValueErrorIsReturned) {
cl_uint param_value = static_cast<cl_uint>(-1);
cl_uint paramValue = static_cast<cl_uint>(-1);
result = clGetAcceleratorInfoINTEL(
accelerator,
CL_ACCELERATOR_REFERENCE_COUNT_INTEL,
sizeof(cl_uint) - 1,
&param_value,
&paramValue,
&param_value_size_ret);
EXPECT_EQ(CL_INVALID_VALUE, result);
@ -215,7 +215,7 @@ TEST_F(IntelAcceleratorGetInfoTest, GivenZeroForDescriptorSizeGivenLongForDescri
}
TEST_F(IntelAcceleratorGetInfoTest, GivenCallToRetainAcceleratorWhenGettingAcceleratorInfoThenParamValueIsTwo) {
cl_uint param_value = static_cast<cl_uint>(-1);
cl_uint paramValue = static_cast<cl_uint>(-1);
result = clRetainAcceleratorINTEL(accelerator);
ASSERT_EQ(CL_SUCCESS, result);
@ -224,11 +224,11 @@ TEST_F(IntelAcceleratorGetInfoTest, GivenCallToRetainAcceleratorWhenGettingAccel
accelerator,
CL_ACCELERATOR_REFERENCE_COUNT_INTEL,
sizeof(cl_uint),
&param_value,
&paramValue,
&param_value_size_ret);
EXPECT_EQ(CL_SUCCESS, result);
EXPECT_EQ(2u, param_value);
EXPECT_EQ(2u, paramValue);
result = clReleaseAcceleratorINTEL(accelerator);
@ -238,11 +238,11 @@ TEST_F(IntelAcceleratorGetInfoTest, GivenCallToRetainAcceleratorWhenGettingAccel
accelerator,
CL_ACCELERATOR_REFERENCE_COUNT_INTEL,
sizeof(cl_uint),
&param_value,
&paramValue,
&param_value_size_ret);
EXPECT_EQ(CL_SUCCESS, result);
EXPECT_EQ(1u, param_value);
EXPECT_EQ(1u, paramValue);
}
TEST_F(IntelAcceleratorGetInfoTest, GivenNullPtrForParamValueWhenGettingAcceleratorInfoThenClSuccessIsReturned) {
@ -258,13 +258,13 @@ TEST_F(IntelAcceleratorGetInfoTest, GivenNullPtrForParamValueWhenGettingAccelera
}
TEST_F(IntelAcceleratorGetInfoTest, GivenLongForDescriptorSizeWhenGettingAcceleratorContextInfoThenCorrectValuesAreReturned) {
cl_context param_value = reinterpret_cast<cl_context>(-1);
cl_context paramValue = reinterpret_cast<cl_context>(-1);
result = clGetAcceleratorInfoINTEL(
accelerator,
CL_ACCELERATOR_CONTEXT_INTEL,
sizeof(cl_context) + 1,
&param_value,
&paramValue,
&param_value_size_ret);
EXPECT_EQ(CL_SUCCESS, result);
@ -272,30 +272,30 @@ TEST_F(IntelAcceleratorGetInfoTest, GivenLongForDescriptorSizeWhenGettingAcceler
}
TEST_F(IntelAcceleratorGetInfoTest, GivenAcceleratorContextIntelWhenGettingAcceleratorInfoThenCorrectValuesAreReturned) {
cl_context param_value = reinterpret_cast<cl_context>(-1);
cl_context paramValue = reinterpret_cast<cl_context>(-1);
result = clGetAcceleratorInfoINTEL(
accelerator,
CL_ACCELERATOR_CONTEXT_INTEL,
sizeof(cl_context),
&param_value,
&paramValue,
&param_value_size_ret);
EXPECT_EQ(CL_SUCCESS, result);
EXPECT_EQ(sizeof(cl_context), param_value_size_ret);
cl_context referenceContext = static_cast<cl_context>(pContext);
EXPECT_EQ(referenceContext, param_value);
EXPECT_EQ(referenceContext, paramValue);
}
TEST_F(IntelAcceleratorGetInfoTest, GivenShortForDescriptorSizeWhenGettingAcceleratorContextInfoThenClInvalidValueErrorIsReturned) {
cl_context param_value = reinterpret_cast<cl_context>(-1);
cl_context paramValue = reinterpret_cast<cl_context>(-1);
result = clGetAcceleratorInfoINTEL(
accelerator,
CL_ACCELERATOR_CONTEXT_INTEL,
sizeof(cl_context) - 1,
&param_value,
&paramValue,
&param_value_size_ret);
EXPECT_EQ(CL_INVALID_VALUE, result);

44
opencl/test/unit_test/api/cl_set_kernel_exec_info_tests.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -102,12 +102,12 @@ TEST_F(clSetKernelExecInfoTests, GivenDeviceNotSupportingSvmWhenSettingKernelExe
TEST_F(clSetKernelExecInfoTests, GivenNullParamValueWhenSettingAdditionalKernelInfoThenInvalidValueErrorIsReturned) {
REQUIRE_SVM_OR_SKIP(defaultHwInfo);
void **pSvmPtrList = nullptr;
size_t SvmPtrListSizeInBytes = 1 * sizeof(void *);
size_t svmPtrListSizeInBytes = 1 * sizeof(void *);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
@ -116,12 +116,12 @@ TEST_F(clSetKernelExecInfoTests, GivenNullParamValueWhenSettingAdditionalKernelI
TEST_F(clSetKernelExecInfoTests, GivenNullPointerInParamValueWhenSettingAdditionalKernelInfoThenInvalidValueErrorIsReturned) {
REQUIRE_SVM_OR_SKIP(defaultHwInfo);
void *pSvmPtrList[] = {nullptr};
size_t SvmPtrListSizeInBytes = 1 * sizeof(void *);
size_t svmPtrListSizeInBytes = 1 * sizeof(void *);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
@ -130,12 +130,12 @@ TEST_F(clSetKernelExecInfoTests, GivenNullPointerInParamValueWhenSettingAddition
TEST_F(clSetKernelExecInfoTests, GivenParamSizeZeroWhenSettingAdditionalKernelInfoThenInvalidValueErrorIsReturned) {
REQUIRE_SVM_OR_SKIP(defaultHwInfo);
void *pSvmPtrList[] = {ptrSvm};
size_t SvmPtrListSizeInBytes = 0;
size_t svmPtrListSizeInBytes = 0;
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
@ -144,12 +144,12 @@ TEST_F(clSetKernelExecInfoTests, GivenParamSizeZeroWhenSettingAdditionalKernelIn
TEST_F(clSetKernelExecInfoTests, GivenInvalidParamSizeWhenSettingAdditionalKernelInfoThenInvalidValueErrorIsReturned) {
REQUIRE_SVM_OR_SKIP(defaultHwInfo);
void *pSvmPtrList[] = {ptrSvm};
size_t SvmPtrListSizeInBytes = (size_t)(-1);
size_t svmPtrListSizeInBytes = (size_t)(-1);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
@ -157,12 +157,12 @@ TEST_F(clSetKernelExecInfoTests, GivenInvalidParamSizeWhenSettingAdditionalKerne
TEST_F(clSetKernelExecInfoTests, GivenInvalidParamNameWhenSettingAdditionalKernelInfoThenInvalidValueErrorIsReturned) {
void *pSvmPtrList[] = {ptrSvm};
size_t SvmPtrListSizeInBytes = 1 * sizeof(void *);
size_t svmPtrListSizeInBytes = 1 * sizeof(void *);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
0, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_INVALID_VALUE, retVal);
@ -170,12 +170,12 @@ TEST_F(clSetKernelExecInfoTests, GivenInvalidParamNameWhenSettingAdditionalKerne
TEST_F(clSetKernelExecInfoTests, GivenInvalidOperationWhenSettingAdditionalKernelInfoThenInvalidOperationErrorIsReturned) {
void *pSvmPtrList[] = {ptrSvm};
size_t SvmPtrListSizeInBytes = 1 * sizeof(void *);
size_t svmPtrListSizeInBytes = 1 * sizeof(void *);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_INVALID_OPERATION, retVal);
@ -184,12 +184,12 @@ TEST_F(clSetKernelExecInfoTests, GivenInvalidOperationWhenSettingAdditionalKerne
TEST_F(clSetKernelExecInfoTests, GivenValidPointerListWithOnePointerWhenSettingAdditionalKernelInfoThenSuccessIsReturned) {
if (svmCapabilities != 0) {
void *pSvmPtrList[] = {ptrSvm};
size_t SvmPtrListSizeInBytes = 1 * sizeof(void *);
size_t svmPtrListSizeInBytes = 1 * sizeof(void *);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -207,12 +207,12 @@ TEST_F(clSetKernelExecInfoTests, GivenValidPointerListWithMultiplePointersWhenSe
EXPECT_NE(nullptr, ptrSvm2);
void *pSvmPtrList[] = {ptrSvm, ptrSvm1, ptrSvm2};
size_t SvmPtrListSizeInBytes = 3 * sizeof(void *);
size_t svmPtrListSizeInBytes = 3 * sizeof(void *);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -234,12 +234,12 @@ TEST_F(clSetKernelExecInfoTests, givenReadOnlySvmPtrListWhenUsedAsKernelPointers
EXPECT_NE(nullptr, ptrSvm2);
void *pSvmPtrList[] = {ptrSvm1, ptrSvm2};
size_t SvmPtrListSizeInBytes = 2 * sizeof(void *);
size_t svmPtrListSizeInBytes = 2 * sizeof(void *);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -255,12 +255,12 @@ TEST_F(clSetKernelExecInfoTests, givenReadOnlySvmPtrListWhenUsedAsKernelPointers
TEST_F(clSetKernelExecInfoTests, GivenMultipleSettingKernelInfoOperationsWhenSettingAdditionalKernelInfoThenSuccessIsReturned) {
if (svmCapabilities != 0) {
void *pSvmPtrList[] = {ptrSvm};
size_t SvmPtrListSizeInBytes = 1 * sizeof(void *);
size_t svmPtrListSizeInBytes = 1 * sizeof(void *);
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_SUCCESS, retVal);
@ -270,7 +270,7 @@ TEST_F(clSetKernelExecInfoTests, GivenMultipleSettingKernelInfoOperationsWhenSet
retVal = clSetKernelExecInfo(
pMockMultiDeviceKernel, // cl_kernel kernel
CL_KERNEL_EXEC_INFO_SVM_PTRS, // cl_kernel_exec_info param_name
SvmPtrListSizeInBytes, // size_t param_value_size
svmPtrListSizeInBytes, // size_t param_value_size
pSvmPtrList // const void *param_value
);
EXPECT_EQ(CL_SUCCESS, retVal);

80
opencl/test/unit_test/api/cl_svm_alloc_tests.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -53,10 +53,10 @@ TEST(clSVMAllocTest, givenPlatformWithoutDevicesWhenClSVMAllocIsCalledThenDevice
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(0u, platform()->getNumDevices());
auto SVMPtr = clSVMAlloc(context.get(), 0u, 4096, 128);
EXPECT_NE(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(context.get(), 0u, 4096, 128);
EXPECT_NE(nullptr, svmPtr);
clSVMFree(context.get(), SVMPtr);
clSVMFree(context.get(), svmPtr);
}
TEST_P(clSVMAllocValidFlagsTests, GivenSvmSupportWhenAllocatingSvmThenSvmIsAllocated) {
@ -68,28 +68,28 @@ TEST_P(clSVMAllocValidFlagsTests, GivenSvmSupportWhenAllocatingSvmThenSvmIsAlloc
if (flags & CL_MEM_SVM_FINE_GRAIN_BUFFER) {
//fg svm flag, fg svm support - expected success
if (devInfo.svmCapabilities & CL_DEVICE_SVM_FINE_GRAIN_BUFFER) {
auto SVMPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_NE(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_NE(nullptr, svmPtr);
clSVMFree(pContext, SVMPtr);
clSVMFree(pContext, svmPtr);
}
//fg svm flag no fg svm support
else {
auto SVMPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, svmPtr);
}
}
//no fg svm flag, svm support - expected success
else {
auto SVMPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_NE(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_NE(nullptr, svmPtr);
clSVMFree(pContext, SVMPtr);
clSVMFree(pContext, svmPtr);
}
} else {
//no svm support -expected fail
auto SVMPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, svmPtr);
}
};
@ -123,32 +123,32 @@ TEST_P(clSVMAllocFtrFlagsTests, GivenCorrectFlagsWhenAllocatingSvmThenSvmIsAlloc
HardwareInfo *pHwInfo = pDevice->getExecutionEnvironment()->rootDeviceEnvironments[testedRootDeviceIndex]->getMutableHardwareInfo();
cl_mem_flags flags = GetParam();
void *SVMPtr = nullptr;
void *svmPtr = nullptr;
//1: no svm - no flags supported
pHwInfo->capabilityTable.ftrSvm = false;
pHwInfo->capabilityTable.ftrSupportsCoherency = false;
SVMPtr = clSVMAlloc(pContext, flags, 4096, 128);
EXPECT_EQ(nullptr, SVMPtr);
svmPtr = clSVMAlloc(pContext, flags, 4096, 128);
EXPECT_EQ(nullptr, svmPtr);
//2: coarse svm - normal flags supported
pHwInfo->capabilityTable.ftrSvm = true;
SVMPtr = clSVMAlloc(pContext, flags, 4096, 128);
svmPtr = clSVMAlloc(pContext, flags, 4096, 128);
if (flags & CL_MEM_SVM_FINE_GRAIN_BUFFER) {
//fg svm flags not supported
EXPECT_EQ(nullptr, SVMPtr);
EXPECT_EQ(nullptr, svmPtr);
} else {
//no fg svm flags supported
EXPECT_NE(nullptr, SVMPtr);
clSVMFree(pContext, SVMPtr);
EXPECT_NE(nullptr, svmPtr);
clSVMFree(pContext, svmPtr);
}
//3: fg svm - all flags supported
pHwInfo->capabilityTable.ftrSupportsCoherency = true;
SVMPtr = clSVMAlloc(pContext, flags, 4096, 128);
EXPECT_NE(nullptr, SVMPtr);
clSVMFree(pContext, SVMPtr);
svmPtr = clSVMAlloc(pContext, flags, 4096, 128);
EXPECT_NE(nullptr, svmPtr);
clSVMFree(pContext, svmPtr);
};
struct clSVMAllocInvalidFlagsTests : public clSVMAllocTemplateTests {
@ -157,8 +157,8 @@ struct clSVMAllocInvalidFlagsTests : public clSVMAllocTemplateTests {
TEST_P(clSVMAllocInvalidFlagsTests, GivenInvalidFlagsWhenAllocatingSvmThenSvmIsNotAllocated) {
cl_mem_flags flags = GetParam();
auto SVMPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(pContext, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, svmPtr);
};
cl_mem_flags SVMAllocInvalidFlags[] = {
@ -174,23 +174,23 @@ INSTANTIATE_TEST_CASE_P(
TEST_F(clSVMAllocTests, GivenNullContextWhenAllocatingSvmThenSvmIsNotAllocated) {
cl_mem_flags flags = CL_MEM_READ_WRITE;
auto SVMPtr = clSVMAlloc(nullptr /* cl_context */, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(nullptr /* cl_context */, flags, 4096 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, svmPtr);
}
TEST_F(clSVMAllocTests, GivenZeroSizeWhenAllocatingSvmThenSvmIsNotAllocated) {
cl_mem_flags flags = CL_MEM_READ_WRITE;
auto SVMPtr = clSVMAlloc(pContext /* cl_context */, flags, 0 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(pContext /* cl_context */, flags, 0 /* Size*/, 128 /* alignment */);
EXPECT_EQ(nullptr, svmPtr);
}
TEST_F(clSVMAllocTests, GivenZeroAlignmentWhenAllocatingSvmThenSvmIsAllocated) {
const ClDeviceInfo &devInfo = pDevice->getDeviceInfo();
if (devInfo.svmCapabilities != 0) {
cl_mem_flags flags = CL_MEM_READ_WRITE;
auto SVMPtr = clSVMAlloc(pContext /* cl_context */, flags, 4096 /* Size*/, 0 /* alignment */);
EXPECT_NE(nullptr, SVMPtr);
clSVMFree(pContext, SVMPtr);
auto svmPtr = clSVMAlloc(pContext /* cl_context */, flags, 4096 /* Size*/, 0 /* alignment */);
EXPECT_NE(nullptr, svmPtr);
clSVMFree(pContext, svmPtr);
}
}
@ -243,21 +243,21 @@ TEST_F(clSVMAllocTests, GivenUnalignedSizeAndDefaultAlignmentWhenAllocatingSvmTh
const ClDeviceInfo &devInfo = pDevice->getDeviceInfo();
if (devInfo.svmCapabilities != 0) {
cl_mem_flags flags = CL_MEM_READ_WRITE;
auto SVMPtr = clSVMAlloc(pContext /* cl_context */, flags, 4095 /* Size*/, 0 /* alignment */);
EXPECT_NE(nullptr, SVMPtr);
clSVMFree(pContext, SVMPtr);
auto svmPtr = clSVMAlloc(pContext /* cl_context */, flags, 4095 /* Size*/, 0 /* alignment */);
EXPECT_NE(nullptr, svmPtr);
clSVMFree(pContext, svmPtr);
}
}
TEST_F(clSVMAllocTests, GivenAlignmentNotPowerOfTwoWhenAllocatingSvmThenSvmIsNotAllocated) {
cl_mem_flags flags = CL_MEM_READ_WRITE;
auto SVMPtr = clSVMAlloc(pContext /* cl_context */, flags, 4096 /* Size*/, 129 /* alignment */);
EXPECT_EQ(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(pContext /* cl_context */, flags, 4096 /* Size*/, 129 /* alignment */);
EXPECT_EQ(nullptr, svmPtr);
}
TEST_F(clSVMAllocTests, GivenAlignmentTooLargeWhenAllocatingSvmThenSvmIsNotAllocated) {
auto SVMPtr = clSVMAlloc(pContext, CL_MEM_READ_WRITE, 4096 /* Size */, 4096 /* alignment */);
EXPECT_EQ(nullptr, SVMPtr);
auto svmPtr = clSVMAlloc(pContext, CL_MEM_READ_WRITE, 4096 /* Size */, 4096 /* alignment */);
EXPECT_EQ(nullptr, svmPtr);
};
TEST_F(clSVMAllocTests, GivenForcedFineGrainedSvmWhenCreatingSvmAllocThenAllocationIsCreated) {

80
opencl/test/unit_test/aub_tests/gen9/skl/command_queue/run_kernel_aub_tests_skl.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -75,30 +75,30 @@ SKLTEST_F(AUBRunKernelIntegrateTest, GivenOoqExecutionThenExpectationsMet) {
&retVal);
ASSERT_NE(nullptr, pMultiDeviceKernel2);
const cl_int NUM_ELEMS = 64;
const size_t BUFFER_SIZE = NUM_ELEMS * sizeof(cl_uint);
const cl_int numElems = 64;
const size_t bufferSize = numElems * sizeof(cl_uint);
cl_uint *destinationMemory1;
cl_uint *destinationMemory2;
cl_uint expectedMemory1[NUM_ELEMS];
cl_uint expectedMemory2[NUM_ELEMS];
cl_uint expectedMemory1[numElems];
cl_uint expectedMemory2[numElems];
cl_uint arg0 = 2;
cl_float arg1 = 3.0f;
cl_uint arg3 = 4;
cl_uint arg5 = 0xBBBBBBBB;
cl_uint bad_value = 0; // set to non-zero to force failure
cl_uint badValue = 0; // set to non-zero to force failure
destinationMemory1 = (cl_uint *)::alignedMalloc(BUFFER_SIZE, 4096);
destinationMemory1 = (cl_uint *)::alignedMalloc(bufferSize, 4096);
ASSERT_NE(nullptr, destinationMemory1);
destinationMemory2 = (cl_uint *)::alignedMalloc(BUFFER_SIZE, 4096);
destinationMemory2 = (cl_uint *)::alignedMalloc(bufferSize, 4096);
ASSERT_NE(nullptr, destinationMemory2);
for (cl_int i = 0; i < NUM_ELEMS; i++) {
for (cl_int i = 0; i < numElems; i++) {
destinationMemory1[i] = 0xA1A1A1A1;
destinationMemory2[i] = 0xA2A2A2A2;
expectedMemory1[i] = (arg0 + static_cast<cl_uint>(arg1) + arg3 + bad_value);
expectedMemory2[i] = arg5 + bad_value;
expectedMemory1[i] = (arg0 + static_cast<cl_uint>(arg1) + arg3 + badValue);
expectedMemory2[i] = arg5 + badValue;
}
auto pDestinationMemory1 = &destinationMemory1[0];
@ -109,7 +109,7 @@ SKLTEST_F(AUBRunKernelIntegrateTest, GivenOoqExecutionThenExpectationsMet) {
auto intermediateBuffer = Buffer::create(
context,
CL_MEM_READ_WRITE,
BUFFER_SIZE,
bufferSize,
nullptr,
retVal);
ASSERT_NE(nullptr, intermediateBuffer);
@ -117,7 +117,7 @@ SKLTEST_F(AUBRunKernelIntegrateTest, GivenOoqExecutionThenExpectationsMet) {
auto destinationBuffer1 = Buffer::create(
context,
CL_MEM_USE_HOST_PTR,
BUFFER_SIZE,
bufferSize,
pDestinationMemory1,
retVal);
ASSERT_NE(nullptr, destinationBuffer1);
@ -128,7 +128,7 @@ SKLTEST_F(AUBRunKernelIntegrateTest, GivenOoqExecutionThenExpectationsMet) {
auto destinationBuffer2 = Buffer::create(
context,
CL_MEM_USE_HOST_PTR,
BUFFER_SIZE,
bufferSize,
pDestinationMemory2,
retVal);
ASSERT_NE(nullptr, destinationBuffer2);
@ -217,8 +217,8 @@ SKLTEST_F(AUBRunKernelIntegrateTest, GivenOoqExecutionThenExpectationsMet) {
AUBCommandStreamFixture::expectMemory<FamilyType>(pDestinationMemory2, pExpectedMemory2, sizeWritten);
// ensure we didn't overwrite existing memory
if (sizeWritten < BUFFER_SIZE) {
auto sizeRemaining = BUFFER_SIZE - sizeWritten;
if (sizeWritten < bufferSize) {
auto sizeRemaining = bufferSize - sizeWritten;
auto pUnwrittenMemory1 = (pDestinationMemory1 + sizeWritten / sizeof(cl_uint));
auto pUnwrittenMemory2 = (pDestinationMemory2 + sizeWritten / sizeof(cl_uint));
auto pExpectedUnwrittenMemory1 = &destinationMemory1[globalWorkItems];
@ -253,12 +253,12 @@ SKLTEST_F(AUBRunKernelIntegrateTest, GivenDeviceSideVmeThenExpectationsMet) {
const cl_int mbHeight = testHeight / 16;
// 1 per macroblock (there is 1 macroblock in this test):
const int PRED_BUFFER_SIZE = mbWidth * mbHeight;
const int SHAPES_BUFFER_SIZE = mbWidth * mbHeight;
const int predBufferSize = mbWidth * mbHeight;
const int shapesBufferSize = mbWidth * mbHeight;
// 4 per macroblock (valid for 8x8 mode only):
const int MV_BUFFER_SIZE = testWidth * mbHeight / 4;
const int RESIDUALS_BUFFER_SIZE = MV_BUFFER_SIZE;
const int mvBufferSize = testWidth * mbHeight / 4;
const int residualsBufferSize = mvBufferSize;
std::string kernelFilename;
retrieveBinaryKernelFilename(kernelFilename, "vme_kernels_", ".bin");
@ -299,16 +299,16 @@ SKLTEST_F(AUBRunKernelIntegrateTest, GivenDeviceSideVmeThenExpectationsMet) {
imageDesc.num_samples = 0;
imageDesc.mem_object = nullptr;
const int INPUT_SIZE = testWidth * testHeight;
ASSERT_GT(INPUT_SIZE, 0);
const int inputSize = testWidth * testHeight;
ASSERT_GT(inputSize, 0);
auto srcMemory = (cl_uchar *)::alignedMalloc(INPUT_SIZE, 4096);
auto srcMemory = (cl_uchar *)::alignedMalloc(inputSize, 4096);
ASSERT_NE(srcMemory, nullptr);
memset(srcMemory, 0x00, INPUT_SIZE);
memset(srcMemory, 0x00, inputSize);
auto refMemory = (cl_uchar *)::alignedMalloc(INPUT_SIZE, 4096);
auto refMemory = (cl_uchar *)::alignedMalloc(inputSize, 4096);
ASSERT_NE(refMemory, nullptr);
memset(refMemory, 0x00, INPUT_SIZE);
memset(refMemory, 0x00, inputSize);
int xMovement = 7;
int yMovement = 9;
@ -343,8 +343,8 @@ SKLTEST_F(AUBRunKernelIntegrateTest, GivenDeviceSideVmeThenExpectationsMet) {
retVal);
ASSERT_NE(nullptr, refImage);
cl_short2 *predMem = new cl_short2[PRED_BUFFER_SIZE];
for (int i = 0; i < PRED_BUFFER_SIZE; i++) {
cl_short2 *predMem = new cl_short2[predBufferSize];
for (int i = 0; i < predBufferSize; i++) {
predMem[i].s[0] = 0;
predMem[i].s[1] = 0;
}
@ -352,7 +352,7 @@ SKLTEST_F(AUBRunKernelIntegrateTest, GivenDeviceSideVmeThenExpectationsMet) {
auto predMvBuffer = Buffer::create(
context,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
PRED_BUFFER_SIZE * sizeof(cl_short2),
predBufferSize * sizeof(cl_short2),
predMem,
retVal);
ASSERT_NE(nullptr, predMvBuffer);
@ -360,7 +360,7 @@ SKLTEST_F(AUBRunKernelIntegrateTest, GivenDeviceSideVmeThenExpectationsMet) {
auto motionVectorBuffer = Buffer::create(
context,
CL_MEM_WRITE_ONLY,
MV_BUFFER_SIZE * sizeof(cl_short2),
mvBufferSize * sizeof(cl_short2),
nullptr,
retVal);
ASSERT_NE(nullptr, motionVectorBuffer);
@ -368,7 +368,7 @@ SKLTEST_F(AUBRunKernelIntegrateTest, GivenDeviceSideVmeThenExpectationsMet) {
auto residualsBuffer = Buffer::create(
context,
CL_MEM_WRITE_ONLY,
RESIDUALS_BUFFER_SIZE * sizeof(cl_short),
residualsBufferSize * sizeof(cl_short),
nullptr,
retVal);
ASSERT_NE(nullptr, residualsBuffer);
@ -376,7 +376,7 @@ SKLTEST_F(AUBRunKernelIntegrateTest, GivenDeviceSideVmeThenExpectationsMet) {
auto shapesBuffer = Buffer::create(
context,
CL_MEM_WRITE_ONLY,
SHAPES_BUFFER_SIZE * sizeof(cl_char2),
shapesBufferSize * sizeof(cl_char2),
nullptr,
retVal);
ASSERT_NE(nullptr, shapesBuffer);
@ -429,9 +429,9 @@ SKLTEST_F(AUBRunKernelIntegrateTest, GivenDeviceSideVmeThenExpectationsMet) {
nullptr);
ASSERT_EQ(CL_SUCCESS, retVal);
cl_short2 destinationMV[MV_BUFFER_SIZE];
cl_short destinationResiduals[RESIDUALS_BUFFER_SIZE];
cl_uchar2 destinationShapes[SHAPES_BUFFER_SIZE];
cl_short2 destinationMV[mvBufferSize];
cl_short destinationResiduals[residualsBufferSize];
cl_uchar2 destinationShapes[shapesBufferSize];
motionVectorBuffer->forceDisallowCPUCopy = true;
residualsBuffer->forceDisallowCPUCopy = true;
@ -445,17 +445,17 @@ SKLTEST_F(AUBRunKernelIntegrateTest, GivenDeviceSideVmeThenExpectationsMet) {
ASSERT_EQ(CL_SUCCESS, retVal);
// Check if our buffers matches expectations
cl_short2 expectedMV[MV_BUFFER_SIZE];
cl_short expectedResiduals[RESIDUALS_BUFFER_SIZE];
cl_uchar2 expectedShapes[SHAPES_BUFFER_SIZE];
cl_short2 expectedMV[mvBufferSize];
cl_short expectedResiduals[residualsBufferSize];
cl_uchar2 expectedShapes[shapesBufferSize];
// This test uses 8x8 sub blocks (4 per macroblock)
for (int i = 0; i < SHAPES_BUFFER_SIZE; i++) {
for (int i = 0; i < shapesBufferSize; i++) {
expectedShapes[i].s0 = CL_AVC_ME_MAJOR_8x8_INTEL;
expectedShapes[i].s1 = CL_AVC_ME_MINOR_8x8_INTEL;
}
for (int i = 0; i < MV_BUFFER_SIZE; i++) {
for (int i = 0; i < mvBufferSize; i++) {
expectedResiduals[i] = 0;
// Second and fourth block not moved, set 0 as default.

20
opencl/test/unit_test/mt_tests/api/cl_create_user_event_tests_mt.inl
View File

@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2021 Intel Corporation
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@ -19,30 +19,30 @@ TEST_F(clCreateUserEventMtTests, GivenClCompleteEventWhenWaitingForEventThenWait
pContext,
&retVal);
std::atomic<bool> ThreadStarted(false);
std::atomic<bool> WaitForEventsCompleted(false);
std::atomic<bool> threadStarted(false);
std::atomic<bool> waitForEventsCompleted(false);
int counter = 0;
int Deadline = 2000;
int deadline = 2000;
std::thread t([&]() {
ThreadStarted = true;
threadStarted = true;
clWaitForEvents(1, &userEvent);
WaitForEventsCompleted = true;
waitForEventsCompleted = true;
});
//wait for the thread to start
while (!ThreadStarted)
while (!threadStarted)
;
//now wait a while.
while (!WaitForEventsCompleted && counter++ < Deadline)
while (!waitForEventsCompleted && counter++ < deadline)
;
ASSERT_EQ(WaitForEventsCompleted, false) << "WaitForEvents returned while user event is not signaled!";
ASSERT_EQ(waitForEventsCompleted, false) << "WaitForEvents returned while user event is not signaled!";
//set event to CL_COMPLETE
retVal = clSetUserEventStatus(userEvent, CL_COMPLETE);
t.join();
ASSERT_EQ(WaitForEventsCompleted, true);
ASSERT_EQ(waitForEventsCompleted, true);
retVal = clReleaseEvent(userEvent);
EXPECT_EQ(CL_SUCCESS, retVal);

4
shared/test/common/gen11/test_preamble_gen11.cpp
View File

@ -29,8 +29,8 @@ GEN11TEST_F(IclSlm, WhenL3ConfigIsDispatchedThenProperRegisterAddressAndValueAre
ASSERT_NE(cmdList.end(), itorLRI);
const auto &lri = *reinterpret_cast<MI_LOAD_REGISTER_IMM *>(*itorLRI);
auto RegisterOffset = L3CNTLRegisterOffset<FamilyType>::registerOffset;
EXPECT_EQ(RegisterOffset, lri.getRegisterOffset());
auto registerOffset = L3CNTLRegisterOffset<FamilyType>::registerOffset;
EXPECT_EQ(registerOffset, lri.getRegisterOffset());
EXPECT_EQ(0u, lri.getDataDword() & 1);
}

4
shared/test/common/gen8/test_preamble_gen8.cpp
View File

@ -28,8 +28,8 @@ BDWTEST_F(BdwSlm, WhenL3ConfigIsDispatchedThenProperRegisterAddressAndValueArePr
ASSERT_NE(cmdList.end(), itorLRI);
const auto &lri = *reinterpret_cast<MI_LOAD_REGISTER_IMM *>(*itorLRI);
auto RegisterOffset = L3CNTLRegisterOffset<BDWFamily>::registerOffset;
EXPECT_EQ(RegisterOffset, lri.getRegisterOffset());
auto registerOffset = L3CNTLRegisterOffset<BDWFamily>::registerOffset;
EXPECT_EQ(registerOffset, lri.getRegisterOffset());
EXPECT_EQ(1u, lri.getDataDword() & 1);
}

4
shared/test/unit_test/gen9/test_preamble_gen9.cpp
View File

@ -31,8 +31,8 @@ GEN9TEST_F(Gen9Slm, WhenL3ConfigIsDispatchedThenProperRegisterAddressAndValueAre
ASSERT_NE(cmdList.end(), itorLRI);
const auto &lri = *reinterpret_cast<MI_LOAD_REGISTER_IMM *>(*itorLRI);
auto RegisterOffset = L3CNTLRegisterOffset<FamilyType>::registerOffset;
EXPECT_EQ(RegisterOffset, lri.getRegisterOffset());
auto registerOffset = L3CNTLRegisterOffset<FamilyType>::registerOffset;
EXPECT_EQ(registerOffset, lri.getRegisterOffset());
EXPECT_EQ(1u, lri.getDataDword() & 1);
}

398
shared/wsl_compute_helper/source/wsl_compute_helper_types_demarshall.h
View File

@ -6660,54 +6660,54 @@ struct Demarshaller<TOK_S_GMM_TEXTURE_INFO_REC> {
} break;
case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: {
#if !(_DEBUG || _RELEASE_INTERNAL)
const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>();
const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tok__Platform < tok__PlatformEnd) {
if (false == tok__Platform->flags.flag4IsVariableLength) {
switch (tok__Platform->id) {
const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>();
const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tokPlatform < tokPlatformEnd) {
if (false == tokPlatform->flags.flag4IsVariableLength) {
switch (tokPlatform->id) {
default:
if (tok__Platform->flags.flag3IsMandatory) {
if (tokPlatform->flags.flag3IsMandatory) {
return false;
}
break;
case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
dst.__Platform.eProductFamily = readTokValue<decltype(dst.__Platform.eProductFamily)>(*tok__Platform);
dst.__Platform.eProductFamily = readTokValue<decltype(dst.__Platform.eProductFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
dst.__Platform.ePCHProductFamily = readTokValue<decltype(dst.__Platform.ePCHProductFamily)>(*tok__Platform);
dst.__Platform.ePCHProductFamily = readTokValue<decltype(dst.__Platform.ePCHProductFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
dst.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.__Platform.eDisplayCoreFamily)>(*tok__Platform);
dst.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.__Platform.eDisplayCoreFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
dst.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.__Platform.eRenderCoreFamily)>(*tok__Platform);
dst.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.__Platform.eRenderCoreFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
dst.__Platform.ePlatformType = readTokValue<decltype(dst.__Platform.ePlatformType)>(*tok__Platform);
dst.__Platform.ePlatformType = readTokValue<decltype(dst.__Platform.ePlatformType)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
dst.__Platform.usDeviceID = readTokValue<decltype(dst.__Platform.usDeviceID)>(*tok__Platform);
dst.__Platform.usDeviceID = readTokValue<decltype(dst.__Platform.usDeviceID)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_REV_ID: {
dst.__Platform.usRevId = readTokValue<decltype(dst.__Platform.usRevId)>(*tok__Platform);
dst.__Platform.usRevId = readTokValue<decltype(dst.__Platform.usRevId)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
dst.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.__Platform.usDeviceID_PCH)>(*tok__Platform);
dst.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.__Platform.usDeviceID_PCH)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
dst.__Platform.usRevId_PCH = readTokValue<decltype(dst.__Platform.usRevId_PCH)>(*tok__Platform);
dst.__Platform.usRevId_PCH = readTokValue<decltype(dst.__Platform.usRevId_PCH)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_GTTYPE: {
dst.__Platform.eGTType = readTokValue<decltype(dst.__Platform.eGTType)>(*tok__Platform);
dst.__Platform.eGTType = readTokValue<decltype(dst.__Platform.eGTType)>(*tokPlatform);
} break;
};
tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount;
tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount;
} else {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform);
if (tok__Platform->flags.flag3IsMandatory) {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform);
if (tokPlatform->flags.flag3IsMandatory) {
return false;
}
tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
}
}
WCH_ASSERT(tok__Platform == tok__PlatformEnd);
@ -7741,54 +7741,54 @@ struct Demarshaller<TOK_S_GMM_RESOURCE_INFO_COMMON_STRUCT> {
} break;
case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: {
#if !(_DEBUG || _RELEASE_INTERNAL)
const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>();
const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tok__Platform < tok__PlatformEnd) {
if (false == tok__Platform->flags.flag4IsVariableLength) {
switch (tok__Platform->id) {
const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>();
const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tokPlatform < tokPlatformEnd) {
if (false == tokPlatform->flags.flag4IsVariableLength) {
switch (tokPlatform->id) {
default:
if (tok__Platform->flags.flag3IsMandatory) {
if (tokPlatform->flags.flag3IsMandatory) {
return false;
}
break;
case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
dst.Surf.__Platform.eProductFamily = readTokValue<decltype(dst.Surf.__Platform.eProductFamily)>(*tok__Platform);
dst.Surf.__Platform.eProductFamily = readTokValue<decltype(dst.Surf.__Platform.eProductFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
dst.Surf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.Surf.__Platform.ePCHProductFamily)>(*tok__Platform);
dst.Surf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.Surf.__Platform.ePCHProductFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
dst.Surf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.Surf.__Platform.eDisplayCoreFamily)>(*tok__Platform);
dst.Surf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.Surf.__Platform.eDisplayCoreFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
dst.Surf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.Surf.__Platform.eRenderCoreFamily)>(*tok__Platform);
dst.Surf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.Surf.__Platform.eRenderCoreFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
dst.Surf.__Platform.ePlatformType = readTokValue<decltype(dst.Surf.__Platform.ePlatformType)>(*tok__Platform);
dst.Surf.__Platform.ePlatformType = readTokValue<decltype(dst.Surf.__Platform.ePlatformType)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
dst.Surf.__Platform.usDeviceID = readTokValue<decltype(dst.Surf.__Platform.usDeviceID)>(*tok__Platform);
dst.Surf.__Platform.usDeviceID = readTokValue<decltype(dst.Surf.__Platform.usDeviceID)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_REV_ID: {
dst.Surf.__Platform.usRevId = readTokValue<decltype(dst.Surf.__Platform.usRevId)>(*tok__Platform);
dst.Surf.__Platform.usRevId = readTokValue<decltype(dst.Surf.__Platform.usRevId)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
dst.Surf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.Surf.__Platform.usDeviceID_PCH)>(*tok__Platform);
dst.Surf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.Surf.__Platform.usDeviceID_PCH)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
dst.Surf.__Platform.usRevId_PCH = readTokValue<decltype(dst.Surf.__Platform.usRevId_PCH)>(*tok__Platform);
dst.Surf.__Platform.usRevId_PCH = readTokValue<decltype(dst.Surf.__Platform.usRevId_PCH)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_GTTYPE: {
dst.Surf.__Platform.eGTType = readTokValue<decltype(dst.Surf.__Platform.eGTType)>(*tok__Platform);
dst.Surf.__Platform.eGTType = readTokValue<decltype(dst.Surf.__Platform.eGTType)>(*tokPlatform);
} break;
};
tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount;
tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount;
} else {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform);
if (tok__Platform->flags.flag3IsMandatory) {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform);
if (tokPlatform->flags.flag3IsMandatory) {
return false;
}
tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
}
}
WCH_ASSERT(tok__Platform == tok__PlatformEnd);
@ -8727,54 +8727,54 @@ struct Demarshaller<TOK_S_GMM_RESOURCE_INFO_COMMON_STRUCT> {
} break;
case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: {
#if !(_DEBUG || _RELEASE_INTERNAL)
const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>();
const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tok__Platform < tok__PlatformEnd) {
if (false == tok__Platform->flags.flag4IsVariableLength) {
switch (tok__Platform->id) {
const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>();
const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tokPlatform < tokPlatformEnd) {
if (false == tokPlatform->flags.flag4IsVariableLength) {
switch (tokPlatform->id) {
default:
if (tok__Platform->flags.flag3IsMandatory) {
if (tokPlatform->flags.flag3IsMandatory) {
return false;
}
break;
case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
dst.AuxSurf.__Platform.eProductFamily = readTokValue<decltype(dst.AuxSurf.__Platform.eProductFamily)>(*tok__Platform);
dst.AuxSurf.__Platform.eProductFamily = readTokValue<decltype(dst.AuxSurf.__Platform.eProductFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
dst.AuxSurf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.AuxSurf.__Platform.ePCHProductFamily)>(*tok__Platform);
dst.AuxSurf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.AuxSurf.__Platform.ePCHProductFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
dst.AuxSurf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.AuxSurf.__Platform.eDisplayCoreFamily)>(*tok__Platform);
dst.AuxSurf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.AuxSurf.__Platform.eDisplayCoreFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
dst.AuxSurf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.AuxSurf.__Platform.eRenderCoreFamily)>(*tok__Platform);
dst.AuxSurf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.AuxSurf.__Platform.eRenderCoreFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
dst.AuxSurf.__Platform.ePlatformType = readTokValue<decltype(dst.AuxSurf.__Platform.ePlatformType)>(*tok__Platform);
dst.AuxSurf.__Platform.ePlatformType = readTokValue<decltype(dst.AuxSurf.__Platform.ePlatformType)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
dst.AuxSurf.__Platform.usDeviceID = readTokValue<decltype(dst.AuxSurf.__Platform.usDeviceID)>(*tok__Platform);
dst.AuxSurf.__Platform.usDeviceID = readTokValue<decltype(dst.AuxSurf.__Platform.usDeviceID)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_REV_ID: {
dst.AuxSurf.__Platform.usRevId = readTokValue<decltype(dst.AuxSurf.__Platform.usRevId)>(*tok__Platform);
dst.AuxSurf.__Platform.usRevId = readTokValue<decltype(dst.AuxSurf.__Platform.usRevId)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
dst.AuxSurf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.AuxSurf.__Platform.usDeviceID_PCH)>(*tok__Platform);
dst.AuxSurf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.AuxSurf.__Platform.usDeviceID_PCH)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
dst.AuxSurf.__Platform.usRevId_PCH = readTokValue<decltype(dst.AuxSurf.__Platform.usRevId_PCH)>(*tok__Platform);
dst.AuxSurf.__Platform.usRevId_PCH = readTokValue<decltype(dst.AuxSurf.__Platform.usRevId_PCH)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_GTTYPE: {
dst.AuxSurf.__Platform.eGTType = readTokValue<decltype(dst.AuxSurf.__Platform.eGTType)>(*tok__Platform);
dst.AuxSurf.__Platform.eGTType = readTokValue<decltype(dst.AuxSurf.__Platform.eGTType)>(*tokPlatform);
} break;
};
tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount;
tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount;
} else {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform);
if (tok__Platform->flags.flag3IsMandatory) {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform);
if (tokPlatform->flags.flag3IsMandatory) {
return false;
}
tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
}
}
WCH_ASSERT(tok__Platform == tok__PlatformEnd);
@ -9713,54 +9713,54 @@ struct Demarshaller<TOK_S_GMM_RESOURCE_INFO_COMMON_STRUCT> {
} break;
case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: {
#if !(_DEBUG || _RELEASE_INTERNAL)
const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>();
const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tok__Platform < tok__PlatformEnd) {
if (false == tok__Platform->flags.flag4IsVariableLength) {
switch (tok__Platform->id) {
const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>();
const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tokPlatform < tokPlatformEnd) {
if (false == tokPlatform->flags.flag4IsVariableLength) {
switch (tokPlatform->id) {
default:
if (tok__Platform->flags.flag3IsMandatory) {
if (tokPlatform->flags.flag3IsMandatory) {
return false;
}
break;
case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
dst.AuxSecSurf.__Platform.eProductFamily = readTokValue<decltype(dst.AuxSecSurf.__Platform.eProductFamily)>(*tok__Platform);
dst.AuxSecSurf.__Platform.eProductFamily = readTokValue<decltype(dst.AuxSecSurf.__Platform.eProductFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
dst.AuxSecSurf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.AuxSecSurf.__Platform.ePCHProductFamily)>(*tok__Platform);
dst.AuxSecSurf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.AuxSecSurf.__Platform.ePCHProductFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
dst.AuxSecSurf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.AuxSecSurf.__Platform.eDisplayCoreFamily)>(*tok__Platform);
dst.AuxSecSurf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.AuxSecSurf.__Platform.eDisplayCoreFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
dst.AuxSecSurf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.AuxSecSurf.__Platform.eRenderCoreFamily)>(*tok__Platform);
dst.AuxSecSurf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.AuxSecSurf.__Platform.eRenderCoreFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
dst.AuxSecSurf.__Platform.ePlatformType = readTokValue<decltype(dst.AuxSecSurf.__Platform.ePlatformType)>(*tok__Platform);
dst.AuxSecSurf.__Platform.ePlatformType = readTokValue<decltype(dst.AuxSecSurf.__Platform.ePlatformType)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
dst.AuxSecSurf.__Platform.usDeviceID = readTokValue<decltype(dst.AuxSecSurf.__Platform.usDeviceID)>(*tok__Platform);
dst.AuxSecSurf.__Platform.usDeviceID = readTokValue<decltype(dst.AuxSecSurf.__Platform.usDeviceID)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_REV_ID: {
dst.AuxSecSurf.__Platform.usRevId = readTokValue<decltype(dst.AuxSecSurf.__Platform.usRevId)>(*tok__Platform);
dst.AuxSecSurf.__Platform.usRevId = readTokValue<decltype(dst.AuxSecSurf.__Platform.usRevId)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
dst.AuxSecSurf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.AuxSecSurf.__Platform.usDeviceID_PCH)>(*tok__Platform);
dst.AuxSecSurf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.AuxSecSurf.__Platform.usDeviceID_PCH)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
dst.AuxSecSurf.__Platform.usRevId_PCH = readTokValue<decltype(dst.AuxSecSurf.__Platform.usRevId_PCH)>(*tok__Platform);
dst.AuxSecSurf.__Platform.usRevId_PCH = readTokValue<decltype(dst.AuxSecSurf.__Platform.usRevId_PCH)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_GTTYPE: {
dst.AuxSecSurf.__Platform.eGTType = readTokValue<decltype(dst.AuxSecSurf.__Platform.eGTType)>(*tok__Platform);
dst.AuxSecSurf.__Platform.eGTType = readTokValue<decltype(dst.AuxSecSurf.__Platform.eGTType)>(*tokPlatform);
} break;
};
tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount;
tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount;
} else {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform);
if (tok__Platform->flags.flag3IsMandatory) {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform);
if (tokPlatform->flags.flag3IsMandatory) {
return false;
}
tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
}
}
WCH_ASSERT(tok__Platform == tok__PlatformEnd);
@ -10841,54 +10841,54 @@ struct Demarshaller<TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT> {
} break;
case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: {
#if !(_DEBUG || _RELEASE_INTERNAL)
const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>();
const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tok__Platform < tok__PlatformEnd) {
if (false == tok__Platform->flags.flag4IsVariableLength) {
switch (tok__Platform->id) {
const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>();
const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tokPlatform < tokPlatformEnd) {
if (false == tokPlatform->flags.flag4IsVariableLength) {
switch (tokPlatform->id) {
default:
if (tok__Platform->flags.flag3IsMandatory) {
if (tokPlatform->flags.flag3IsMandatory) {
return false;
}
break;
case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
dst.GmmResourceInfoCommon.Surf.__Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.eProductFamily)>(*tok__Platform);
dst.GmmResourceInfoCommon.Surf.__Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.eProductFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
dst.GmmResourceInfoCommon.Surf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.ePCHProductFamily)>(*tok__Platform);
dst.GmmResourceInfoCommon.Surf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.ePCHProductFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
dst.GmmResourceInfoCommon.Surf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.eDisplayCoreFamily)>(*tok__Platform);
dst.GmmResourceInfoCommon.Surf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.eDisplayCoreFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
dst.GmmResourceInfoCommon.Surf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.eRenderCoreFamily)>(*tok__Platform);
dst.GmmResourceInfoCommon.Surf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.eRenderCoreFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
dst.GmmResourceInfoCommon.Surf.__Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.ePlatformType)>(*tok__Platform);
dst.GmmResourceInfoCommon.Surf.__Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.ePlatformType)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID)>(*tok__Platform);
dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_REV_ID: {
dst.GmmResourceInfoCommon.Surf.__Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.usRevId)>(*tok__Platform);
dst.GmmResourceInfoCommon.Surf.__Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.usRevId)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID_PCH)>(*tok__Platform);
dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID_PCH)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
dst.GmmResourceInfoCommon.Surf.__Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.usRevId_PCH)>(*tok__Platform);
dst.GmmResourceInfoCommon.Surf.__Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.usRevId_PCH)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_GTTYPE: {
dst.GmmResourceInfoCommon.Surf.__Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.eGTType)>(*tok__Platform);
dst.GmmResourceInfoCommon.Surf.__Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.eGTType)>(*tokPlatform);
} break;
};
tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount;
tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount;
} else {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform);
if (tok__Platform->flags.flag3IsMandatory) {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform);
if (tokPlatform->flags.flag3IsMandatory) {
return false;
}
tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
}
}
WCH_ASSERT(tok__Platform == tok__PlatformEnd);
@ -11827,54 +11827,54 @@ struct Demarshaller<TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT> {
} break;
case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: {
#if !(_DEBUG || _RELEASE_INTERNAL)
const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>();
const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tok__Platform < tok__PlatformEnd) {
if (false == tok__Platform->flags.flag4IsVariableLength) {
switch (tok__Platform->id) {
const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>();
const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tokPlatform < tokPlatformEnd) {
if (false == tokPlatform->flags.flag4IsVariableLength) {
switch (tokPlatform->id) {
default:
if (tok__Platform->flags.flag3IsMandatory) {
if (tokPlatform->flags.flag3IsMandatory) {
return false;
}
break;
case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
dst.GmmResourceInfoCommon.AuxSurf.__Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.eProductFamily)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSurf.__Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.eProductFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePCHProductFamily)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePCHProductFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
dst.GmmResourceInfoCommon.AuxSurf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.eDisplayCoreFamily)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSurf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.eDisplayCoreFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
dst.GmmResourceInfoCommon.AuxSurf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.eRenderCoreFamily)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSurf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.eRenderCoreFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePlatformType)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePlatformType)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_REV_ID: {
dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID_PCH)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID_PCH)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId_PCH)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId_PCH)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_GTTYPE: {
dst.GmmResourceInfoCommon.AuxSurf.__Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.eGTType)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSurf.__Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.eGTType)>(*tokPlatform);
} break;
};
tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount;
tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount;
} else {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform);
if (tok__Platform->flags.flag3IsMandatory) {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform);
if (tokPlatform->flags.flag3IsMandatory) {
return false;
}
tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
}
}
WCH_ASSERT(tok__Platform == tok__PlatformEnd);
@ -12813,54 +12813,54 @@ struct Demarshaller<TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT> {
} break;
case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: {
#if !(_DEBUG || _RELEASE_INTERNAL)
const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>();
const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tok__Platform < tok__PlatformEnd) {
if (false == tok__Platform->flags.flag4IsVariableLength) {
switch (tok__Platform->id) {
const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>();
const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tokPlatform < tokPlatformEnd) {
if (false == tokPlatform->flags.flag4IsVariableLength) {
switch (tokPlatform->id) {
default:
if (tok__Platform->flags.flag3IsMandatory) {
if (tokPlatform->flags.flag3IsMandatory) {
return false;
}
break;
case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eProductFamily)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eProductFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePCHProductFamily)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePCHProductFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eDisplayCoreFamily)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eDisplayCoreFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eRenderCoreFamily)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eRenderCoreFamily)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePlatformType)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePlatformType)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_REV_ID: {
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID_PCH)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID_PCH)>(*tokPlatform);
} break;
case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId_PCH)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId_PCH)>(*tokPlatform);
} break;
case TOK_FE_PLATFORM_STR__E_GTTYPE: {
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eGTType)>(*tok__Platform);
dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eGTType)>(*tokPlatform);
} break;
};
tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount;
tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount;
} else {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform);
if (tok__Platform->flags.flag3IsMandatory) {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform);
if (tokPlatform->flags.flag3IsMandatory) {
return false;
}
tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
}
}
WCH_ASSERT(tok__Platform == tok__PlatformEnd);
@ -13144,141 +13144,141 @@ struct Demarshaller<TOK_S_TIME_STAMP_DATA_HEADER> {
}
break;
case TOK_FS_TIME_STAMP_DATA_HEADER__M_HEADER: {
const TokenHeader *tokM_Header = varLen->getValue<TokenHeader>();
const TokenHeader *tokM_HeaderEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tokM_Header < tokM_HeaderEnd) {
if (false == tokM_Header->flags.flag4IsVariableLength) {
switch (tokM_Header->id) {
const TokenHeader *tokMHeader = varLen->getValue<TokenHeader>();
const TokenHeader *tokMHeaderEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tokMHeader < tokMHeaderEnd) {
if (false == tokMHeader->flags.flag4IsVariableLength) {
switch (tokMHeader->id) {
default:
if (tokM_Header->flags.flag3IsMandatory) {
if (tokMHeader->flags.flag3IsMandatory) {
return false;
}
break;
case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__SIZE: {
dst.m_Header.Size = readTokValue<decltype(dst.m_Header.Size)>(*tokM_Header);
dst.m_Header.Size = readTokValue<decltype(dst.m_Header.Size)>(*tokMHeader);
} break;
case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__CHECK_SUM: {
dst.m_Header.CheckSum = readTokValue<decltype(dst.m_Header.CheckSum)>(*tokM_Header);
dst.m_Header.CheckSum = readTokValue<decltype(dst.m_Header.CheckSum)>(*tokMHeader);
} break;
case TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__ESCAPE_CODE: {
dst.m_Header.EscapeCode = readTokValue<decltype(dst.m_Header.EscapeCode)>(*tokM_Header);
dst.m_Header.EscapeCode = readTokValue<decltype(dst.m_Header.EscapeCode)>(*tokMHeader);
} break;
case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__UL_RESERVED: {
dst.m_Header.ulReserved = readTokValue<decltype(dst.m_Header.ulReserved)>(*tokM_Header);
dst.m_Header.ulReserved = readTokValue<decltype(dst.m_Header.ulReserved)>(*tokMHeader);
} break;
case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_RESERVED1: {
dst.m_Header.ulReserved1 = readTokValue<decltype(dst.m_Header.ulReserved1)>(*tokM_Header);
dst.m_Header.ulReserved1 = readTokValue<decltype(dst.m_Header.ulReserved1)>(*tokMHeader);
} break;
case TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_ESCAPE_VERSION: {
dst.m_Header.usEscapeVersion = readTokValue<decltype(dst.m_Header.usEscapeVersion)>(*tokM_Header);
dst.m_Header.usEscapeVersion = readTokValue<decltype(dst.m_Header.usEscapeVersion)>(*tokMHeader);
} break;
case TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_FILE_VERSION: {
dst.m_Header.usFileVersion = readTokValue<decltype(dst.m_Header.usFileVersion)>(*tokM_Header);
dst.m_Header.usFileVersion = readTokValue<decltype(dst.m_Header.usFileVersion)>(*tokMHeader);
} break;
case TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_MAJOR_ESCAPE_CODE: {
dst.m_Header.ulMajorEscapeCode = readTokValue<decltype(dst.m_Header.ulMajorEscapeCode)>(*tokM_Header);
dst.m_Header.ulMajorEscapeCode = readTokValue<decltype(dst.m_Header.ulMajorEscapeCode)>(*tokMHeader);
} break;
case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UI_MINOR_ESCAPE_CODE: {
dst.m_Header.uiMinorEscapeCode = readTokValue<decltype(dst.m_Header.uiMinorEscapeCode)>(*tokM_Header);
dst.m_Header.uiMinorEscapeCode = readTokValue<decltype(dst.m_Header.uiMinorEscapeCode)>(*tokMHeader);
} break;
};
tokM_Header = tokM_Header + 1 + tokM_Header->valueDwordCount;
tokMHeader = tokMHeader + 1 + tokMHeader->valueDwordCount;
} else {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tokM_Header);
if (tokM_Header->flags.flag3IsMandatory) {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMHeader);
if (tokMHeader->flags.flag3IsMandatory) {
return false;
}
tokM_Header = tokM_Header + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
tokMHeader = tokMHeader + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
}
}
WCH_ASSERT(tokM_Header == tokM_HeaderEnd);
WCH_ASSERT(tokMHeader == tokMHeaderEnd);
} break;
case TOK_FS_TIME_STAMP_DATA_HEADER__M_DATA: {
const TokenHeader *tokM_Data = varLen->getValue<TokenHeader>();
const TokenHeader *tokM_DataEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tokM_Data < tokM_DataEnd) {
if (false == tokM_Data->flags.flag4IsVariableLength) {
if (tokM_Data->flags.flag3IsMandatory) {
const TokenHeader *tokMData = varLen->getValue<TokenHeader>();
const TokenHeader *tokMDataEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tokMData < tokMDataEnd) {
if (false == tokMData->flags.flag4IsVariableLength) {
if (tokMData->flags.flag3IsMandatory) {
return false;
}
tokM_Data = tokM_Data + 1 + tokM_Data->valueDwordCount;
tokMData = tokMData + 1 + tokMData->valueDwordCount;
} else {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tokM_Data);
switch (tokM_Data->id) {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMData);
switch (tokMData->id) {
default:
if (tokM_Data->flags.flag3IsMandatory) {
if (tokMData->flags.flag3IsMandatory) {
return false;
}
break;
case TOK_FXS_TIME_STAMP_DATA_HEADER__ANONYMOUS2466__M_IN: {
const TokenHeader *tokM_In = varLen->getValue<TokenHeader>();
const TokenHeader *tokM_InEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tokM_In < tokM_InEnd) {
if (false == tokM_In->flags.flag4IsVariableLength) {
switch (tokM_In->id) {
const TokenHeader *tokMIn = varLen->getValue<TokenHeader>();
const TokenHeader *tokMInEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tokMIn < tokMInEnd) {
if (false == tokMIn->flags.flag4IsVariableLength) {
switch (tokMIn->id) {
default:
if (tokM_In->flags.flag3IsMandatory) {
if (tokMIn->flags.flag3IsMandatory) {
return false;
}
break;
case TOK_FE_GTDIBASE_IN_STRUCT__FUNCTION: {
dst.m_Data.m_In.Function = readTokValue<decltype(dst.m_Data.m_In.Function)>(*tokM_In);
dst.m_Data.m_In.Function = readTokValue<decltype(dst.m_Data.m_In.Function)>(*tokMIn);
} break;
};
tokM_In = tokM_In + 1 + tokM_In->valueDwordCount;
tokMIn = tokMIn + 1 + tokMIn->valueDwordCount;
} else {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tokM_In);
if (tokM_In->flags.flag3IsMandatory) {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMIn);
if (tokMIn->flags.flag3IsMandatory) {
return false;
}
tokM_In = tokM_In + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
tokMIn = tokMIn + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
}
}
WCH_ASSERT(tokM_In == tokM_InEnd);
WCH_ASSERT(tokMIn == tokMInEnd);
} break;
case TOK_FS_TIME_STAMP_DATA_HEADER__ANONYMOUS2466__M_OUT: {
const TokenHeader *tokM_Out = varLen->getValue<TokenHeader>();
const TokenHeader *tokM_OutEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tokM_Out < tokM_OutEnd) {
if (false == tokM_Out->flags.flag4IsVariableLength) {
switch (tokM_Out->id) {
const TokenHeader *tokMOut = varLen->getValue<TokenHeader>();
const TokenHeader *tokMOutEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
while (tokMOut < tokMOutEnd) {
if (false == tokMOut->flags.flag4IsVariableLength) {
switch (tokMOut->id) {
default:
if (tokM_Out->flags.flag3IsMandatory) {
if (tokMOut->flags.flag3IsMandatory) {
return false;
}
break;
case TOK_FE_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__RET_CODE: {
dst.m_Data.m_Out.RetCode = readTokValue<decltype(dst.m_Data.m_Out.RetCode)>(*tokM_Out);
dst.m_Data.m_Out.RetCode = readTokValue<decltype(dst.m_Data.m_Out.RetCode)>(*tokMOut);
} break;
case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_TICKS: {
dst.m_Data.m_Out.gpuPerfTicks = readTokValue<decltype(dst.m_Data.m_Out.gpuPerfTicks)>(*tokM_Out);
dst.m_Data.m_Out.gpuPerfTicks = readTokValue<decltype(dst.m_Data.m_Out.gpuPerfTicks)>(*tokMOut);
} break;
case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_TICKS: {
dst.m_Data.m_Out.cpuPerfTicks = readTokValue<decltype(dst.m_Data.m_Out.cpuPerfTicks)>(*tokM_Out);
dst.m_Data.m_Out.cpuPerfTicks = readTokValue<decltype(dst.m_Data.m_Out.cpuPerfTicks)>(*tokMOut);
} break;
case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_FREQ: {
dst.m_Data.m_Out.gpuPerfFreq = readTokValue<decltype(dst.m_Data.m_Out.gpuPerfFreq)>(*tokM_Out);
dst.m_Data.m_Out.gpuPerfFreq = readTokValue<decltype(dst.m_Data.m_Out.gpuPerfFreq)>(*tokMOut);
} break;
case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_FREQ: {
dst.m_Data.m_Out.cpuPerfFreq = readTokValue<decltype(dst.m_Data.m_Out.cpuPerfFreq)>(*tokM_Out);
dst.m_Data.m_Out.cpuPerfFreq = readTokValue<decltype(dst.m_Data.m_Out.cpuPerfFreq)>(*tokMOut);
} break;
};
tokM_Out = tokM_Out + 1 + tokM_Out->valueDwordCount;
tokMOut = tokMOut + 1 + tokMOut->valueDwordCount;
} else {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tokM_Out);
if (tokM_Out->flags.flag3IsMandatory) {
auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMOut);
if (tokMOut->flags.flag3IsMandatory) {
return false;
}
tokM_Out = tokM_Out + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
tokMOut = tokMOut + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
}
}
WCH_ASSERT(tokM_Out == tokM_OutEnd);
WCH_ASSERT(tokMOut == tokMOutEnd);
} break;
};
tokM_Data = tokM_Data + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
tokMData = tokMData + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
}
}
WCH_ASSERT(tokM_Data == tokM_DataEnd);
WCH_ASSERT(tokMData == tokMDataEnd);
} break;
};
tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;