/* * Copyright (c) 2017, Intel Corporation * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #include "cl_api_tests.h" #include "runtime/context/context.h" using namespace OCLRT; namespace ULT { template class clCreateSubBufferTemplateTests : public api_fixture, public testing::TestWithParam { void SetUp() override { api_fixture::SetUp(); cl_mem_flags flg = parentFlags; void *ptr = nullptr; if (hasHostPtr == true) { flg |= CL_MEM_USE_HOST_PTR; ptr = pHostPtr; } buffer = clCreateBuffer(pContext, flg, 64, ptr, &retVal); EXPECT_NE(nullptr, buffer); EXPECT_EQ(CL_SUCCESS, retVal); } void TearDown() override { clReleaseMemObject(buffer); api_fixture::TearDown(); } protected: cl_mem buffer; cl_uchar pHostPtr[64]; }; struct clCreateSubBufferValidFlagsNoHostPtrTests : public clCreateSubBufferTemplateTests { }; TEST_P(clCreateSubBufferValidFlagsNoHostPtrTests, validFlags) { cl_buffer_region region = {0, 12}; cl_mem_flags flags = GetParam(); auto subBuffer = clCreateSubBuffer(buffer, flags, CL_BUFFER_CREATE_TYPE_REGION, ®ion, &retVal); EXPECT_NE(nullptr, subBuffer); EXPECT_EQ(CL_SUCCESS, retVal); clReleaseMemObject(subBuffer); }; static cl_mem_flags validFlags[] = { CL_MEM_READ_WRITE, CL_MEM_WRITE_ONLY, CL_MEM_READ_ONLY, CL_MEM_HOST_READ_ONLY, CL_MEM_HOST_WRITE_ONLY, CL_MEM_HOST_NO_ACCESS, }; INSTANTIATE_TEST_CASE_P( CreateSubBufferCheckFlags, clCreateSubBufferValidFlagsNoHostPtrTests, testing::ValuesIn(validFlags)); struct clCreateSubBufferInvalidFlagsHostPtrTests : public clCreateSubBufferTemplateTests { }; TEST_P(clCreateSubBufferInvalidFlagsHostPtrTests, invalidFlags) { cl_buffer_region region = {4, 12}; cl_mem_flags flags = GetParam(); auto subBuffer = clCreateSubBuffer(buffer, flags, CL_BUFFER_CREATE_TYPE_REGION, ®ion, &retVal); EXPECT_EQ(nullptr, subBuffer); EXPECT_EQ(CL_INVALID_VALUE, retVal); }; cl_mem_flags invalidFlags[] = { CL_MEM_READ_WRITE, CL_MEM_WRITE_ONLY, CL_MEM_HOST_WRITE_ONLY, CL_MEM_HOST_READ_ONLY, CL_MEM_USE_HOST_PTR, CL_MEM_ALLOC_HOST_PTR, CL_MEM_COPY_HOST_PTR, 0xffcc, }; INSTANTIATE_TEST_CASE_P( CreateSubBufferCheckFlags, clCreateSubBufferInvalidFlagsHostPtrTests, testing::ValuesIn(invalidFlags)); class clCreateSubBufferTests : public api_tests { void SetUp() override { api_tests::SetUp(); cl_mem_flags flg = CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS; buffer = clCreateBuffer(pContext, flg, 64, pHostPtr, &retVal); EXPECT_NE(nullptr, buffer); EXPECT_EQ(CL_SUCCESS, retVal); } void TearDown() override { clReleaseMemObject(buffer); api_fixture::TearDown(); } protected: cl_mem buffer; cl_uchar pHostPtr[64]; }; TEST_F(clCreateSubBufferTests, inRange) { cl_buffer_region region = {0, 12}; auto subBuffer = clCreateSubBuffer(buffer, CL_MEM_READ_WRITE, CL_BUFFER_CREATE_TYPE_REGION, ®ion, &retVal); EXPECT_NE(nullptr, subBuffer); EXPECT_EQ(CL_SUCCESS, retVal); clReleaseMemObject(subBuffer); } TEST_F(clCreateSubBufferTests, outOfRange) { cl_buffer_region region = {4, 68}; auto subBuffer = clCreateSubBuffer(buffer, CL_MEM_READ_WRITE, CL_BUFFER_CREATE_TYPE_REGION, ®ion, &retVal); EXPECT_EQ(nullptr, subBuffer); EXPECT_EQ(CL_INVALID_VALUE, retVal); } TEST_F(clCreateSubBufferTests, subFromSub) { cl_buffer_region region0 = {0, 60}; cl_buffer_region region1 = {8, 20}; auto subBuffer = clCreateSubBuffer(buffer, CL_MEM_READ_WRITE, CL_BUFFER_CREATE_TYPE_REGION, ®ion0, &retVal); EXPECT_NE(nullptr, subBuffer); EXPECT_EQ(CL_SUCCESS, retVal); auto subsubBuffer = clCreateSubBuffer(subBuffer, CL_MEM_READ_WRITE, CL_BUFFER_CREATE_TYPE_REGION, ®ion1, &retVal); EXPECT_EQ(nullptr, subsubBuffer); EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal); clReleaseMemObject(subBuffer); } TEST_F(clCreateSubBufferTests, invalidParent) { cl_buffer_region region = {4, 60}; cl_int trash[] = {0x01, 0x08, 0x88, 0xcc, 0xab, 0x55}; auto subBuffer = clCreateSubBuffer(reinterpret_cast(trash), CL_MEM_READ_WRITE, CL_BUFFER_CREATE_TYPE_REGION, ®ion, &retVal); EXPECT_EQ(nullptr, subBuffer); EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal); } TEST_F(clCreateSubBufferTests, invalidOffset) { cl_buffer_region region = {1, 60}; auto subBuffer = clCreateSubBuffer(buffer, CL_MEM_READ_WRITE, CL_BUFFER_CREATE_TYPE_REGION, ®ion, &retVal); EXPECT_EQ(nullptr, subBuffer); EXPECT_EQ(CL_MISALIGNED_SUB_BUFFER_OFFSET, retVal); } TEST_F(clCreateSubBufferTests, noRegion) { cl_buffer_region region = {4, 60}; auto subBuffer = clCreateSubBuffer(buffer, CL_MEM_READ_WRITE, CL_BUFFER_CREATE_TYPE_REGION, nullptr, &retVal); EXPECT_EQ(nullptr, subBuffer); EXPECT_EQ(CL_INVALID_VALUE, retVal); subBuffer = clCreateSubBuffer(buffer, CL_MEM_READ_WRITE, 0, ®ion, &retVal); EXPECT_EQ(nullptr, subBuffer); EXPECT_EQ(CL_INVALID_VALUE, retVal); subBuffer = clCreateSubBuffer(buffer, CL_MEM_READ_WRITE, 0, nullptr, &retVal); EXPECT_EQ(nullptr, subBuffer); EXPECT_EQ(CL_INVALID_VALUE, retVal); } TEST_F(clCreateSubBufferTests, inheritFlags) { cl_buffer_region region = {0, 60}; auto subBuffer = clCreateSubBuffer(buffer, CL_MEM_READ_ONLY, CL_BUFFER_CREATE_TYPE_REGION, ®ion, &retVal); EXPECT_NE(nullptr, subBuffer); EXPECT_EQ(CL_SUCCESS, retVal); cl_mem_flags retFlag; size_t retSZ; retVal = clGetMemObjectInfo(subBuffer, CL_MEM_FLAGS, sizeof(cl_mem_flags), &retFlag, &retSZ); EXPECT_EQ(CL_SUCCESS, retVal); EXPECT_EQ(sizeof(cl_mem_flags), retSZ); EXPECT_EQ(static_cast(CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS), retFlag); clReleaseMemObject(subBuffer); } } // namespace ULT