diff --git a/opencl/test/unit_test/api/cl_enqueue_task_tests.inl b/opencl/test/unit_test/api/cl_enqueue_task_tests.inl index febe690645..5371022517 100644 --- a/opencl/test/unit_test/api/cl_enqueue_task_tests.inl +++ b/opencl/test/unit_test/api/cl_enqueue_task_tests.inl @@ -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(pCmdQ); + cl_command_queue commandQueue = static_cast(pCmdQ); cl_kernel kernel = static_cast(pMultiDeviceKernel); retVal = clEnqueueTask( - command_queue, + commandQueue, kernel, numEventsInWaitList, eventWaitList, diff --git a/opencl/test/unit_test/api/cl_get_device_and_host_timer.inl b/opencl/test/unit_test/api/cl_get_device_and_host_timer.inl index e539649171..6b1bb88fc8 100644 --- a/opencl/test/unit_test/api/cl_get_device_and_host_timer.inl +++ b/opencl/test/unit_test/api/cl_get_device_and_host_timer.inl @@ -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(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(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(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(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; diff --git a/opencl/test/unit_test/api/cl_get_event_profiling_info_tests.inl b/opencl/test/unit_test/api/cl_get_event_profiling_info_tests.inl index db0fbdfc00..8407fdf5d1 100644 --- a/opencl/test/unit_test/api/cl_get_event_profiling_info_tests.inl +++ b/opencl/test/unit_test/api/cl_get_event_profiling_info_tests.inl @@ -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, - ¶m_value, - ¶m_value_size_ret); + paramValueSize, + ¶mValue, + ¶mValueSizeRet); 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, - ¶m_value, - ¶m_value_size_ret); + paramValueSize - 1, + ¶mValue, + ¶mValueSizeRet); 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, - ¶m_value, - ¶m_value_size_ret); + paramValueSize, + ¶mValue, + ¶mValueSizeRet); 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, - ¶m_value, + paramValueSize, + ¶mValue, 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, - ¶m_value, - ¶m_value_size_ret); + paramValueSize, + ¶mValue, + ¶mValueSizeRet); 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; } diff --git a/opencl/test/unit_test/api/cl_get_kernel_work_group_info_tests.inl b/opencl/test/unit_test/api/cl_get_kernel_work_group_info_tests.inl index d308f16fc7..a526c2662b 100644 --- a/opencl/test/unit_test/api/cl_get_kernel_work_group_info_tests.inl +++ b/opencl/test/unit_test/api/cl_get_kernel_work_group_info_tests.inl @@ -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(testedClDevice); MockKernelWithInternals mockKernel(*pDevice); @@ -90,18 +90,18 @@ TEST_F(clGetKernelWorkGroupInfoTests, GivenKernelRequiringScratchSpaceWhenGettin pDevice, CL_KERNEL_SPILL_MEM_SIZE_INTEL, sizeof(cl_ulong), - ¶m_value, + ¶mValue, ¶mValueSizeRet); EXPECT_EQ(retVal, CL_SUCCESS); EXPECT_EQ(paramValueSizeRet, sizeof(cl_ulong)); - EXPECT_EQ(param_value, scratchSpaceSize); + EXPECT_EQ(paramValue, scratchSpaceSize); } using matcher = IsWithinProducts; HWTEST2_F(clGetKernelWorkGroupInfoTests, givenKernelHavingPrivateMemoryAllocationWhenAskedForPrivateAllocationSizeThenProperSizeIsReturned, matcher) { size_t paramValueSizeRet; - cl_ulong param_value; + cl_ulong paramValue; auto pDevice = castToObject(testedClDevice); MockKernelWithInternals mockKernel(*pDevice); @@ -112,17 +112,17 @@ HWTEST2_F(clGetKernelWorkGroupInfoTests, givenKernelHavingPrivateMemoryAllocatio pDevice, CL_KERNEL_PRIVATE_MEM_SIZE, sizeof(cl_ulong), - ¶m_value, + ¶mValue, ¶mValueSizeRet); 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(testedClDevice); MockKernelWithInternals mockKernel(*pDevice); @@ -132,12 +132,12 @@ TEST_F(clGetKernelWorkGroupInfoTests, givenKernelNotHavingPrivateMemoryAllocatio pDevice, CL_KERNEL_PRIVATE_MEM_SIZE, sizeof(cl_ulong), - ¶m_value, + ¶mValue, ¶mValueSizeRet); 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[] = { diff --git a/opencl/test/unit_test/api/cl_intel_accelerator_tests.inl b/opencl/test/unit_test/api/cl_intel_accelerator_tests.inl index 1bd2335956..f583b5e875 100644 --- a/opencl/test/unit_test/api/cl_intel_accelerator_tests.inl +++ b/opencl/test/unit_test/api/cl_intel_accelerator_tests.inl @@ -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(0xEEEEEEEE); + auto invalidAcceleratorType = static_cast(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(-1); + cl_uint paramValue = static_cast(-1); result = clGetAcceleratorInfoINTEL( accelerator, CL_ACCELERATOR_REFERENCE_COUNT_INTEL, sizeof(cl_uint), - ¶m_value, + ¶mValue, 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(-1); + cl_uint paramValue = static_cast(-1); result = clGetAcceleratorInfoINTEL( accelerator, CL_ACCELERATOR_REFERENCE_COUNT_INTEL, sizeof(cl_uint) + 1, - ¶m_value, + ¶mValue, ¶m_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(-1); + cl_uint paramValue = static_cast(-1); result = clGetAcceleratorInfoINTEL( accelerator, CL_ACCELERATOR_REFERENCE_COUNT_INTEL, sizeof(cl_uint) - 1, - ¶m_value, + ¶mValue, ¶m_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(-1); + cl_uint paramValue = static_cast(-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), - ¶m_value, + ¶mValue, ¶m_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), - ¶m_value, + ¶mValue, ¶m_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(-1); + cl_context paramValue = reinterpret_cast(-1); result = clGetAcceleratorInfoINTEL( accelerator, CL_ACCELERATOR_CONTEXT_INTEL, sizeof(cl_context) + 1, - ¶m_value, + ¶mValue, ¶m_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(-1); + cl_context paramValue = reinterpret_cast(-1); result = clGetAcceleratorInfoINTEL( accelerator, CL_ACCELERATOR_CONTEXT_INTEL, sizeof(cl_context), - ¶m_value, + ¶mValue, ¶m_value_size_ret); EXPECT_EQ(CL_SUCCESS, result); EXPECT_EQ(sizeof(cl_context), param_value_size_ret); cl_context referenceContext = static_cast(pContext); - EXPECT_EQ(referenceContext, param_value); + EXPECT_EQ(referenceContext, paramValue); } TEST_F(IntelAcceleratorGetInfoTest, GivenShortForDescriptorSizeWhenGettingAcceleratorContextInfoThenClInvalidValueErrorIsReturned) { - cl_context param_value = reinterpret_cast(-1); + cl_context paramValue = reinterpret_cast(-1); result = clGetAcceleratorInfoINTEL( accelerator, CL_ACCELERATOR_CONTEXT_INTEL, sizeof(cl_context) - 1, - ¶m_value, + ¶mValue, ¶m_value_size_ret); EXPECT_EQ(CL_INVALID_VALUE, result); diff --git a/opencl/test/unit_test/api/cl_set_kernel_exec_info_tests.inl b/opencl/test/unit_test/api/cl_set_kernel_exec_info_tests.inl index ba193178e3..346aa21e4d 100644 --- a/opencl/test/unit_test/api/cl_set_kernel_exec_info_tests.inl +++ b/opencl/test/unit_test/api/cl_set_kernel_exec_info_tests.inl @@ -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); diff --git a/opencl/test/unit_test/api/cl_svm_alloc_tests.inl b/opencl/test/unit_test/api/cl_svm_alloc_tests.inl index 2d5fcb978c..d2e3c790af 100644 --- a/opencl/test/unit_test/api/cl_svm_alloc_tests.inl +++ b/opencl/test/unit_test/api/cl_svm_alloc_tests.inl @@ -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) { diff --git a/opencl/test/unit_test/aub_tests/gen9/skl/command_queue/run_kernel_aub_tests_skl.cpp b/opencl/test/unit_test/aub_tests/gen9/skl/command_queue/run_kernel_aub_tests_skl.cpp index edc422d232..d0daa98cb5 100644 --- a/opencl/test/unit_test/aub_tests/gen9/skl/command_queue/run_kernel_aub_tests_skl.cpp +++ b/opencl/test/unit_test/aub_tests/gen9/skl/command_queue/run_kernel_aub_tests_skl.cpp @@ -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(arg1) + arg3 + bad_value); - expectedMemory2[i] = arg5 + bad_value; + expectedMemory1[i] = (arg0 + static_cast(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(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. diff --git a/opencl/test/unit_test/mt_tests/api/cl_create_user_event_tests_mt.inl b/opencl/test/unit_test/mt_tests/api/cl_create_user_event_tests_mt.inl index ffcb7fe4fb..07897d158e 100644 --- a/opencl/test/unit_test/mt_tests/api/cl_create_user_event_tests_mt.inl +++ b/opencl/test/unit_test/mt_tests/api/cl_create_user_event_tests_mt.inl @@ -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 ThreadStarted(false); - std::atomic WaitForEventsCompleted(false); + std::atomic threadStarted(false); + std::atomic 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); diff --git a/shared/test/common/gen11/test_preamble_gen11.cpp b/shared/test/common/gen11/test_preamble_gen11.cpp index 37e3f3a814..2873a0cb06 100644 --- a/shared/test/common/gen11/test_preamble_gen11.cpp +++ b/shared/test/common/gen11/test_preamble_gen11.cpp @@ -29,8 +29,8 @@ GEN11TEST_F(IclSlm, WhenL3ConfigIsDispatchedThenProperRegisterAddressAndValueAre ASSERT_NE(cmdList.end(), itorLRI); const auto &lri = *reinterpret_cast(*itorLRI); - auto RegisterOffset = L3CNTLRegisterOffset::registerOffset; - EXPECT_EQ(RegisterOffset, lri.getRegisterOffset()); + auto registerOffset = L3CNTLRegisterOffset::registerOffset; + EXPECT_EQ(registerOffset, lri.getRegisterOffset()); EXPECT_EQ(0u, lri.getDataDword() & 1); } diff --git a/shared/test/common/gen8/test_preamble_gen8.cpp b/shared/test/common/gen8/test_preamble_gen8.cpp index 4818d7e602..269867f283 100644 --- a/shared/test/common/gen8/test_preamble_gen8.cpp +++ b/shared/test/common/gen8/test_preamble_gen8.cpp @@ -28,8 +28,8 @@ BDWTEST_F(BdwSlm, WhenL3ConfigIsDispatchedThenProperRegisterAddressAndValueArePr ASSERT_NE(cmdList.end(), itorLRI); const auto &lri = *reinterpret_cast(*itorLRI); - auto RegisterOffset = L3CNTLRegisterOffset::registerOffset; - EXPECT_EQ(RegisterOffset, lri.getRegisterOffset()); + auto registerOffset = L3CNTLRegisterOffset::registerOffset; + EXPECT_EQ(registerOffset, lri.getRegisterOffset()); EXPECT_EQ(1u, lri.getDataDword() & 1); } diff --git a/shared/test/unit_test/gen9/test_preamble_gen9.cpp b/shared/test/unit_test/gen9/test_preamble_gen9.cpp index 01759d080f..82e98641a6 100644 --- a/shared/test/unit_test/gen9/test_preamble_gen9.cpp +++ b/shared/test/unit_test/gen9/test_preamble_gen9.cpp @@ -31,8 +31,8 @@ GEN9TEST_F(Gen9Slm, WhenL3ConfigIsDispatchedThenProperRegisterAddressAndValueAre ASSERT_NE(cmdList.end(), itorLRI); const auto &lri = *reinterpret_cast(*itorLRI); - auto RegisterOffset = L3CNTLRegisterOffset::registerOffset; - EXPECT_EQ(RegisterOffset, lri.getRegisterOffset()); + auto registerOffset = L3CNTLRegisterOffset::registerOffset; + EXPECT_EQ(registerOffset, lri.getRegisterOffset()); EXPECT_EQ(1u, lri.getDataDword() & 1); } diff --git a/shared/wsl_compute_helper/source/wsl_compute_helper_types_demarshall.h b/shared/wsl_compute_helper/source/wsl_compute_helper_types_demarshall.h index a43dfc0a97..7ff5d47d05 100644 --- a/shared/wsl_compute_helper/source/wsl_compute_helper_types_demarshall.h +++ b/shared/wsl_compute_helper/source/wsl_compute_helper_types_demarshall.h @@ -6660,54 +6660,54 @@ struct Demarshaller { } break; case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { #if !(_DEBUG || _RELEASE_INTERNAL) - const TokenHeader *tok__Platform = varLen->getValue(); - const TokenHeader *tok__PlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); - while (tok__Platform < tok__PlatformEnd) { - if (false == tok__Platform->flags.flag4IsVariableLength) { - switch (tok__Platform->id) { + const TokenHeader *tokPlatform = varLen->getValue(); + const TokenHeader *tokPlatformEnd = varLen->getValue() + 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(*tok__Platform); + dst.__Platform.eProductFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { - dst.__Platform.ePCHProductFamily = readTokValue(*tok__Platform); + dst.__Platform.ePCHProductFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { - dst.__Platform.eDisplayCoreFamily = readTokValue(*tok__Platform); + dst.__Platform.eDisplayCoreFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { - dst.__Platform.eRenderCoreFamily = readTokValue(*tok__Platform); + dst.__Platform.eRenderCoreFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { - dst.__Platform.ePlatformType = readTokValue(*tok__Platform); + dst.__Platform.ePlatformType = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { - dst.__Platform.usDeviceID = readTokValue(*tok__Platform); + dst.__Platform.usDeviceID = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_REV_ID: { - dst.__Platform.usRevId = readTokValue(*tok__Platform); + dst.__Platform.usRevId = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { - dst.__Platform.usDeviceID_PCH = readTokValue(*tok__Platform); + dst.__Platform.usDeviceID_PCH = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { - dst.__Platform.usRevId_PCH = readTokValue(*tok__Platform); + dst.__Platform.usRevId_PCH = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_GTTYPE: { - dst.__Platform.eGTType = readTokValue(*tok__Platform); + dst.__Platform.eGTType = readTokValue(*tokPlatform); } break; }; - tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; + tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; } else { - auto varLen = reinterpret_cast(tok__Platform); - if (tok__Platform->flags.flag3IsMandatory) { + auto varLen = reinterpret_cast(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 { } break; case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { #if !(_DEBUG || _RELEASE_INTERNAL) - const TokenHeader *tok__Platform = varLen->getValue(); - const TokenHeader *tok__PlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); - while (tok__Platform < tok__PlatformEnd) { - if (false == tok__Platform->flags.flag4IsVariableLength) { - switch (tok__Platform->id) { + const TokenHeader *tokPlatform = varLen->getValue(); + const TokenHeader *tokPlatformEnd = varLen->getValue() + 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(*tok__Platform); + dst.Surf.__Platform.eProductFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { - dst.Surf.__Platform.ePCHProductFamily = readTokValue(*tok__Platform); + dst.Surf.__Platform.ePCHProductFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { - dst.Surf.__Platform.eDisplayCoreFamily = readTokValue(*tok__Platform); + dst.Surf.__Platform.eDisplayCoreFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { - dst.Surf.__Platform.eRenderCoreFamily = readTokValue(*tok__Platform); + dst.Surf.__Platform.eRenderCoreFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { - dst.Surf.__Platform.ePlatformType = readTokValue(*tok__Platform); + dst.Surf.__Platform.ePlatformType = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { - dst.Surf.__Platform.usDeviceID = readTokValue(*tok__Platform); + dst.Surf.__Platform.usDeviceID = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_REV_ID: { - dst.Surf.__Platform.usRevId = readTokValue(*tok__Platform); + dst.Surf.__Platform.usRevId = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { - dst.Surf.__Platform.usDeviceID_PCH = readTokValue(*tok__Platform); + dst.Surf.__Platform.usDeviceID_PCH = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { - dst.Surf.__Platform.usRevId_PCH = readTokValue(*tok__Platform); + dst.Surf.__Platform.usRevId_PCH = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_GTTYPE: { - dst.Surf.__Platform.eGTType = readTokValue(*tok__Platform); + dst.Surf.__Platform.eGTType = readTokValue(*tokPlatform); } break; }; - tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; + tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; } else { - auto varLen = reinterpret_cast(tok__Platform); - if (tok__Platform->flags.flag3IsMandatory) { + auto varLen = reinterpret_cast(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 { } break; case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { #if !(_DEBUG || _RELEASE_INTERNAL) - const TokenHeader *tok__Platform = varLen->getValue(); - const TokenHeader *tok__PlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); - while (tok__Platform < tok__PlatformEnd) { - if (false == tok__Platform->flags.flag4IsVariableLength) { - switch (tok__Platform->id) { + const TokenHeader *tokPlatform = varLen->getValue(); + const TokenHeader *tokPlatformEnd = varLen->getValue() + 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(*tok__Platform); + dst.AuxSurf.__Platform.eProductFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { - dst.AuxSurf.__Platform.ePCHProductFamily = readTokValue(*tok__Platform); + dst.AuxSurf.__Platform.ePCHProductFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { - dst.AuxSurf.__Platform.eDisplayCoreFamily = readTokValue(*tok__Platform); + dst.AuxSurf.__Platform.eDisplayCoreFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { - dst.AuxSurf.__Platform.eRenderCoreFamily = readTokValue(*tok__Platform); + dst.AuxSurf.__Platform.eRenderCoreFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { - dst.AuxSurf.__Platform.ePlatformType = readTokValue(*tok__Platform); + dst.AuxSurf.__Platform.ePlatformType = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { - dst.AuxSurf.__Platform.usDeviceID = readTokValue(*tok__Platform); + dst.AuxSurf.__Platform.usDeviceID = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_REV_ID: { - dst.AuxSurf.__Platform.usRevId = readTokValue(*tok__Platform); + dst.AuxSurf.__Platform.usRevId = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { - dst.AuxSurf.__Platform.usDeviceID_PCH = readTokValue(*tok__Platform); + dst.AuxSurf.__Platform.usDeviceID_PCH = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { - dst.AuxSurf.__Platform.usRevId_PCH = readTokValue(*tok__Platform); + dst.AuxSurf.__Platform.usRevId_PCH = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_GTTYPE: { - dst.AuxSurf.__Platform.eGTType = readTokValue(*tok__Platform); + dst.AuxSurf.__Platform.eGTType = readTokValue(*tokPlatform); } break; }; - tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; + tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; } else { - auto varLen = reinterpret_cast(tok__Platform); - if (tok__Platform->flags.flag3IsMandatory) { + auto varLen = reinterpret_cast(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 { } break; case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { #if !(_DEBUG || _RELEASE_INTERNAL) - const TokenHeader *tok__Platform = varLen->getValue(); - const TokenHeader *tok__PlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); - while (tok__Platform < tok__PlatformEnd) { - if (false == tok__Platform->flags.flag4IsVariableLength) { - switch (tok__Platform->id) { + const TokenHeader *tokPlatform = varLen->getValue(); + const TokenHeader *tokPlatformEnd = varLen->getValue() + 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(*tok__Platform); + dst.AuxSecSurf.__Platform.eProductFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { - dst.AuxSecSurf.__Platform.ePCHProductFamily = readTokValue(*tok__Platform); + dst.AuxSecSurf.__Platform.ePCHProductFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { - dst.AuxSecSurf.__Platform.eDisplayCoreFamily = readTokValue(*tok__Platform); + dst.AuxSecSurf.__Platform.eDisplayCoreFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { - dst.AuxSecSurf.__Platform.eRenderCoreFamily = readTokValue(*tok__Platform); + dst.AuxSecSurf.__Platform.eRenderCoreFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { - dst.AuxSecSurf.__Platform.ePlatformType = readTokValue(*tok__Platform); + dst.AuxSecSurf.__Platform.ePlatformType = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { - dst.AuxSecSurf.__Platform.usDeviceID = readTokValue(*tok__Platform); + dst.AuxSecSurf.__Platform.usDeviceID = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_REV_ID: { - dst.AuxSecSurf.__Platform.usRevId = readTokValue(*tok__Platform); + dst.AuxSecSurf.__Platform.usRevId = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { - dst.AuxSecSurf.__Platform.usDeviceID_PCH = readTokValue(*tok__Platform); + dst.AuxSecSurf.__Platform.usDeviceID_PCH = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { - dst.AuxSecSurf.__Platform.usRevId_PCH = readTokValue(*tok__Platform); + dst.AuxSecSurf.__Platform.usRevId_PCH = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_GTTYPE: { - dst.AuxSecSurf.__Platform.eGTType = readTokValue(*tok__Platform); + dst.AuxSecSurf.__Platform.eGTType = readTokValue(*tokPlatform); } break; }; - tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; + tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; } else { - auto varLen = reinterpret_cast(tok__Platform); - if (tok__Platform->flags.flag3IsMandatory) { + auto varLen = reinterpret_cast(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 { } break; case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { #if !(_DEBUG || _RELEASE_INTERNAL) - const TokenHeader *tok__Platform = varLen->getValue(); - const TokenHeader *tok__PlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); - while (tok__Platform < tok__PlatformEnd) { - if (false == tok__Platform->flags.flag4IsVariableLength) { - switch (tok__Platform->id) { + const TokenHeader *tokPlatform = varLen->getValue(); + const TokenHeader *tokPlatformEnd = varLen->getValue() + 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(*tok__Platform); + dst.GmmResourceInfoCommon.Surf.__Platform.eProductFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { - dst.GmmResourceInfoCommon.Surf.__Platform.ePCHProductFamily = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.Surf.__Platform.ePCHProductFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { - dst.GmmResourceInfoCommon.Surf.__Platform.eDisplayCoreFamily = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.Surf.__Platform.eDisplayCoreFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { - dst.GmmResourceInfoCommon.Surf.__Platform.eRenderCoreFamily = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.Surf.__Platform.eRenderCoreFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { - dst.GmmResourceInfoCommon.Surf.__Platform.ePlatformType = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.Surf.__Platform.ePlatformType = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { - dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_REV_ID: { - dst.GmmResourceInfoCommon.Surf.__Platform.usRevId = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.Surf.__Platform.usRevId = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { - dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID_PCH = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID_PCH = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { - dst.GmmResourceInfoCommon.Surf.__Platform.usRevId_PCH = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.Surf.__Platform.usRevId_PCH = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_GTTYPE: { - dst.GmmResourceInfoCommon.Surf.__Platform.eGTType = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.Surf.__Platform.eGTType = readTokValue(*tokPlatform); } break; }; - tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; + tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; } else { - auto varLen = reinterpret_cast(tok__Platform); - if (tok__Platform->flags.flag3IsMandatory) { + auto varLen = reinterpret_cast(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 { } break; case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { #if !(_DEBUG || _RELEASE_INTERNAL) - const TokenHeader *tok__Platform = varLen->getValue(); - const TokenHeader *tok__PlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); - while (tok__Platform < tok__PlatformEnd) { - if (false == tok__Platform->flags.flag4IsVariableLength) { - switch (tok__Platform->id) { + const TokenHeader *tokPlatform = varLen->getValue(); + const TokenHeader *tokPlatformEnd = varLen->getValue() + 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(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.eProductFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { - dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePCHProductFamily = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePCHProductFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { - dst.GmmResourceInfoCommon.AuxSurf.__Platform.eDisplayCoreFamily = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.eDisplayCoreFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { - dst.GmmResourceInfoCommon.AuxSurf.__Platform.eRenderCoreFamily = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.eRenderCoreFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { - dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePlatformType = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePlatformType = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { - dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_REV_ID: { - dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { - dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID_PCH = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID_PCH = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { - dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId_PCH = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId_PCH = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_GTTYPE: { - dst.GmmResourceInfoCommon.AuxSurf.__Platform.eGTType = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSurf.__Platform.eGTType = readTokValue(*tokPlatform); } break; }; - tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; + tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; } else { - auto varLen = reinterpret_cast(tok__Platform); - if (tok__Platform->flags.flag3IsMandatory) { + auto varLen = reinterpret_cast(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 { } break; case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: { #if !(_DEBUG || _RELEASE_INTERNAL) - const TokenHeader *tok__Platform = varLen->getValue(); - const TokenHeader *tok__PlatformEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); - while (tok__Platform < tok__PlatformEnd) { - if (false == tok__Platform->flags.flag4IsVariableLength) { - switch (tok__Platform->id) { + const TokenHeader *tokPlatform = varLen->getValue(); + const TokenHeader *tokPlatformEnd = varLen->getValue() + 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(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eProductFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: { - dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePCHProductFamily = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePCHProductFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: { - dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eDisplayCoreFamily = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eDisplayCoreFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: { - dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eRenderCoreFamily = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eRenderCoreFamily = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: { - dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePlatformType = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePlatformType = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: { - dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_REV_ID: { - dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: { - dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID_PCH = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID_PCH = readTokValue(*tokPlatform); } break; case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: { - dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId_PCH = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId_PCH = readTokValue(*tokPlatform); } break; case TOK_FE_PLATFORM_STR__E_GTTYPE: { - dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eGTType = readTokValue(*tok__Platform); + dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eGTType = readTokValue(*tokPlatform); } break; }; - tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount; + tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount; } else { - auto varLen = reinterpret_cast(tok__Platform); - if (tok__Platform->flags.flag3IsMandatory) { + auto varLen = reinterpret_cast(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 { } break; case TOK_FS_TIME_STAMP_DATA_HEADER__M_HEADER: { - const TokenHeader *tokM_Header = varLen->getValue(); - const TokenHeader *tokM_HeaderEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); - while (tokM_Header < tokM_HeaderEnd) { - if (false == tokM_Header->flags.flag4IsVariableLength) { - switch (tokM_Header->id) { + const TokenHeader *tokMHeader = varLen->getValue(); + const TokenHeader *tokMHeaderEnd = varLen->getValue() + 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(*tokM_Header); + dst.m_Header.Size = readTokValue(*tokMHeader); } break; case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__CHECK_SUM: { - dst.m_Header.CheckSum = readTokValue(*tokM_Header); + dst.m_Header.CheckSum = readTokValue(*tokMHeader); } break; case TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__ESCAPE_CODE: { - dst.m_Header.EscapeCode = readTokValue(*tokM_Header); + dst.m_Header.EscapeCode = readTokValue(*tokMHeader); } break; case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__UL_RESERVED: { - dst.m_Header.ulReserved = readTokValue(*tokM_Header); + dst.m_Header.ulReserved = readTokValue(*tokMHeader); } break; case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_RESERVED1: { - dst.m_Header.ulReserved1 = readTokValue(*tokM_Header); + dst.m_Header.ulReserved1 = readTokValue(*tokMHeader); } break; case TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_ESCAPE_VERSION: { - dst.m_Header.usEscapeVersion = readTokValue(*tokM_Header); + dst.m_Header.usEscapeVersion = readTokValue(*tokMHeader); } break; case TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_FILE_VERSION: { - dst.m_Header.usFileVersion = readTokValue(*tokM_Header); + dst.m_Header.usFileVersion = readTokValue(*tokMHeader); } break; case TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_MAJOR_ESCAPE_CODE: { - dst.m_Header.ulMajorEscapeCode = readTokValue(*tokM_Header); + dst.m_Header.ulMajorEscapeCode = readTokValue(*tokMHeader); } break; case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UI_MINOR_ESCAPE_CODE: { - dst.m_Header.uiMinorEscapeCode = readTokValue(*tokM_Header); + dst.m_Header.uiMinorEscapeCode = readTokValue(*tokMHeader); } break; }; - tokM_Header = tokM_Header + 1 + tokM_Header->valueDwordCount; + tokMHeader = tokMHeader + 1 + tokMHeader->valueDwordCount; } else { - auto varLen = reinterpret_cast(tokM_Header); - if (tokM_Header->flags.flag3IsMandatory) { + auto varLen = reinterpret_cast(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(); - const TokenHeader *tokM_DataEnd = varLen->getValue() + 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(); + const TokenHeader *tokMDataEnd = varLen->getValue() + 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(tokM_Data); - switch (tokM_Data->id) { + auto varLen = reinterpret_cast(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(); - const TokenHeader *tokM_InEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); - while (tokM_In < tokM_InEnd) { - if (false == tokM_In->flags.flag4IsVariableLength) { - switch (tokM_In->id) { + const TokenHeader *tokMIn = varLen->getValue(); + const TokenHeader *tokMInEnd = varLen->getValue() + 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(*tokM_In); + dst.m_Data.m_In.Function = readTokValue(*tokMIn); } break; }; - tokM_In = tokM_In + 1 + tokM_In->valueDwordCount; + tokMIn = tokMIn + 1 + tokMIn->valueDwordCount; } else { - auto varLen = reinterpret_cast(tokM_In); - if (tokM_In->flags.flag3IsMandatory) { + auto varLen = reinterpret_cast(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(); - const TokenHeader *tokM_OutEnd = varLen->getValue() + varLen->valueLengthInBytes / sizeof(TokenHeader); - while (tokM_Out < tokM_OutEnd) { - if (false == tokM_Out->flags.flag4IsVariableLength) { - switch (tokM_Out->id) { + const TokenHeader *tokMOut = varLen->getValue(); + const TokenHeader *tokMOutEnd = varLen->getValue() + 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(*tokM_Out); + dst.m_Data.m_Out.RetCode = readTokValue(*tokMOut); } break; case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_TICKS: { - dst.m_Data.m_Out.gpuPerfTicks = readTokValue(*tokM_Out); + dst.m_Data.m_Out.gpuPerfTicks = readTokValue(*tokMOut); } break; case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_TICKS: { - dst.m_Data.m_Out.cpuPerfTicks = readTokValue(*tokM_Out); + dst.m_Data.m_Out.cpuPerfTicks = readTokValue(*tokMOut); } break; case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_FREQ: { - dst.m_Data.m_Out.gpuPerfFreq = readTokValue(*tokM_Out); + dst.m_Data.m_Out.gpuPerfFreq = readTokValue(*tokMOut); } break; case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_FREQ: { - dst.m_Data.m_Out.cpuPerfFreq = readTokValue(*tokM_Out); + dst.m_Data.m_Out.cpuPerfFreq = readTokValue(*tokMOut); } break; }; - tokM_Out = tokM_Out + 1 + tokM_Out->valueDwordCount; + tokMOut = tokMOut + 1 + tokMOut->valueDwordCount; } else { - auto varLen = reinterpret_cast(tokM_Out); - if (tokM_Out->flags.flag3IsMandatory) { + auto varLen = reinterpret_cast(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;