OpenCL-CTS/test_conformance/mem_host_flags/mem_host_buffer.cpp

//
// Copyright (c) 2017 The Khronos Group Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include "harness/compat.h"

#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "checker_mem_host_read_only.hpp"
#include "checker_mem_host_write_only.hpp"
#include "checker_mem_host_no_access.hpp"

static int test_mem_host_read_only_buffer_RW(
    cl_device_id device, cl_context context, cl_command_queue queue,
    cl_bool blocking, cl_mem_flags buffer_mem_flag,
    cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
{
    log_info("%s\n", __FUNCTION__);
    cBuffer_check_mem_host_read_only<TEST_ELEMENT_TYPE> checker(device, context,
                                                                queue);
    checker.m_blocking = blocking;
    checker.buffer_mem_flag = buffer_mem_flag;
    cl_int err;
    switch (buffer_type)
    {
        case _BUFFER: err = checker.SetupBuffer(); break;
        case _Sub_BUFFER:
            err = checker.SetupASSubBuffer(parent_buffer_flag);
            break;
    }

    test_error(err, __FUNCTION__);
    checker.Setup_Test_Environment();
    err = checker.verify_RW_Buffer();
    test_error(err, __FUNCTION__);
    clFinish(queue);

    return err;
}

static int test_mem_host_read_only_buffer_RW_Rect(
    cl_device_id device, cl_context context, cl_command_queue queue,
    cl_bool blocking, cl_mem_flags buffer_mem_flag,
    cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
{
    log_info("%s\n", __FUNCTION__);

    cBuffer_check_mem_host_read_only<TEST_ELEMENT_TYPE> checker(device, context,
                                                                queue);
    checker.m_blocking = blocking;
    checker.buffer_mem_flag = buffer_mem_flag;
    cl_int err;
    switch (buffer_type)
    {
        case _BUFFER: err = checker.SetupBuffer(); break;
        case _Sub_BUFFER:
            err = checker.SetupASSubBuffer(parent_buffer_flag);
            break;
    }

    test_error(err, __FUNCTION__);
    checker.Setup_Test_Environment();
    err = checker.verify_RW_Buffer_rect();
    test_error(err, __FUNCTION__);
    clFinish(queue);

    return err;
}

static int test_mem_host_read_only_buffer_RW_Mapping(
    cl_device_id device, cl_context context, cl_command_queue queue,
    cl_bool blocking, cl_mem_flags buffer_mem_flag,
    cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
{
    log_info("%s\n", __FUNCTION__);

    cBuffer_check_mem_host_read_only<TEST_ELEMENT_TYPE> checker(device, context,
                                                                queue);
    checker.m_blocking = blocking;
    checker.buffer_mem_flag = buffer_mem_flag;
    cl_int err;
    switch (buffer_type)
    {
        case _BUFFER: err = checker.SetupBuffer(); break;
        case _Sub_BUFFER:
            err = checker.SetupASSubBuffer(parent_buffer_flag);
            break;
    }

    test_error(err, __FUNCTION__);
    checker.Setup_Test_Environment();
    err = checker.verify_RW_Buffer_mapping();
    test_error(err, __FUNCTION__);
    clFinish(queue);

    return err;
}

REGISTER_TEST(mem_host_read_only_buffer)
{
    cl_mem_flags buffer_mem_flags[2] = {
        CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_READ_ONLY,
        CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_READ_ONLY
    };

    cl_int err = CL_SUCCESS;

    cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
    for (int k = 0; k < 2; k++)
        for (int i = 0; i < 2; i++)
        {

            err = test_mem_host_read_only_buffer_RW(
                device, context, queue, blocking[i], buffer_mem_flags[k], 0,
                _BUFFER);
            test_error(err, __FUNCTION__);

            err = test_mem_host_read_only_buffer_RW_Rect(
                device, context, queue, blocking[i], buffer_mem_flags[k], 0,
                _BUFFER);
            test_error(err, __FUNCTION__);

            err = test_mem_host_read_only_buffer_RW_Mapping(
                device, context, queue, blocking[i], buffer_mem_flags[k], 0,
                _BUFFER);
            test_error(err, __FUNCTION__);
        }

    return err;
}

REGISTER_TEST(mem_host_read_only_subbuffer)
{
    cl_mem_flags parent_buffer_mem_flags[1] = { CL_MEM_READ_WRITE
                                                | CL_MEM_USE_HOST_PTR
                                                | CL_MEM_HOST_READ_ONLY };

    cl_mem_flags buffer_mem_flags[4] = {
        0, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
        CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
        CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR
    };

    cl_int err = CL_SUCCESS;

    cl_bool blocking[2] = { CL_TRUE, CL_FALSE };

    for (int p = 0; p < 1; p++)
    {
        for (int k = 0; k < 4; k++)
            for (int i = 0; i < 2; i++)
            {
                err = test_mem_host_read_only_buffer_RW(
                    device, context, queue, blocking[i], buffer_mem_flags[k],
                    parent_buffer_mem_flags[p], _Sub_BUFFER);
                test_error(err, __FUNCTION__);

                err = test_mem_host_read_only_buffer_RW_Rect(
                    device, context, queue, blocking[i], buffer_mem_flags[k],
                    parent_buffer_mem_flags[p], _Sub_BUFFER);
                test_error(err, __FUNCTION__);

                err = test_mem_host_read_only_buffer_RW_Mapping(
                    device, context, queue, blocking[i], buffer_mem_flags[k],
                    parent_buffer_mem_flags[p], _Sub_BUFFER);
                test_error(err, __FUNCTION__);
            }
    }

    return err;
}

//=============================== Write only

static cl_int test_mem_host_write_only_buffer_RW(
    cl_device_id device, cl_context context, cl_command_queue queue,
    cl_bool blocking, cl_mem_flags buffer_mem_flag,
    cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
{
    log_info("%s\n", __FUNCTION__);

    cBuffer_check_mem_host_write_only<TEST_ELEMENT_TYPE> checker(
        device, context, queue);

    checker.m_blocking = blocking;
    checker.buffer_mem_flag = buffer_mem_flag;
    cl_int err;
    switch (buffer_type)
    {
        case _BUFFER: err = checker.SetupBuffer(); break;
        case _Sub_BUFFER:
            err = checker.SetupASSubBuffer(parent_buffer_flag);
            break;
    }

    test_error(err, __FUNCTION__);
    checker.Setup_Test_Environment();
    err = checker.verify_RW_Buffer();
    test_error(err, __FUNCTION__);
    clFinish(queue);

    return err;
}

static cl_int test_mem_host_write_only_buffer_RW_Rect(
    cl_device_id device, cl_context context, cl_command_queue queue,
    cl_bool blocking, cl_mem_flags buffer_mem_flag,
    cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
{
    log_info("%s\n", __FUNCTION__);

    cBuffer_check_mem_host_write_only<TEST_ELEMENT_TYPE> checker(
        device, context, queue);
    checker.m_blocking = blocking;
    checker.buffer_mem_flag = buffer_mem_flag;
    cl_int err;
    switch (buffer_type)
    {
        case _BUFFER: err = checker.SetupBuffer(); break;
        case _Sub_BUFFER:
            err = checker.SetupASSubBuffer(parent_buffer_flag);
            break;
    }

    test_error(err, __FUNCTION__);
    checker.Setup_Test_Environment();
    err = checker.verify_RW_Buffer_rect();
    test_error(err, __FUNCTION__);
    clFinish(queue);

    return err;
}

static cl_int test_mem_host_write_only_buffer_RW_Mapping(
    cl_device_id device, cl_context context, cl_command_queue queue,
    cl_bool blocking, cl_mem_flags buffer_mem_flag,
    cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
{
    log_info("%s\n", __FUNCTION__);

    cBuffer_check_mem_host_write_only<TEST_ELEMENT_TYPE> checker(
        device, context, queue);
    checker.m_blocking = blocking;
    checker.buffer_mem_flag = buffer_mem_flag;
    cl_int err;
    switch (buffer_type)
    {
        case _BUFFER: err = checker.SetupBuffer(); break;
        case _Sub_BUFFER:
            err = checker.SetupASSubBuffer(parent_buffer_flag);
            break;
    }

    test_error(err, __FUNCTION__);
    checker.Setup_Test_Environment();
    err = checker.verify_RW_Buffer_mapping();
    test_error(err, __FUNCTION__);
    clFinish(queue);

    return err;
}

REGISTER_TEST(mem_host_write_only_buffer)
{
    cl_mem_flags buffer_mem_flags[2] = {
        CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_WRITE_ONLY,
        CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_WRITE_ONLY
    };

    cl_int err = CL_SUCCESS;

    cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
    for (int k = 0; k < 2; k++)
        for (int i = 0; i < 2; i++)
        {
            err = test_mem_host_write_only_buffer_RW(
                device, context, queue, blocking[i], buffer_mem_flags[k], 0,
                _BUFFER);
            test_error(err, __FUNCTION__);

            err = test_mem_host_write_only_buffer_RW_Rect(
                device, context, queue, blocking[i], buffer_mem_flags[k], 0,
                _BUFFER);
            test_error(err, __FUNCTION__);

            err = test_mem_host_write_only_buffer_RW_Mapping(
                device, context, queue, blocking[i], buffer_mem_flags[k], 0,
                _BUFFER);
            test_error(err, __FUNCTION__);
        }

    return err;
}

REGISTER_TEST(mem_host_write_only_subbuffer)
{
    cl_mem_flags parent_buffer_mem_flags[1] = { CL_MEM_READ_WRITE
                                                | CL_MEM_USE_HOST_PTR
                                                | CL_MEM_HOST_WRITE_ONLY };

    cl_mem_flags buffer_mem_flags[4] = {
        0, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
        CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
        CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR
    };

    cl_int err = CL_SUCCESS;

    cl_bool blocking[2] = { CL_TRUE, CL_FALSE };

    for (int p = 0; p < 1; p++)
    {
        for (int m = 0; m < 4; m++)
        {
            for (int i = 0; i < 2; i++)
            {
                err = test_mem_host_write_only_buffer_RW(
                    device, context, queue, blocking[i], buffer_mem_flags[m],
                    parent_buffer_mem_flags[p], _Sub_BUFFER);
                test_error(err, __FUNCTION__);

                err = test_mem_host_write_only_buffer_RW_Rect(
                    device, context, queue, blocking[i], buffer_mem_flags[m],
                    parent_buffer_mem_flags[p], _Sub_BUFFER);
                test_error(err, __FUNCTION__);

                err = test_mem_host_write_only_buffer_RW_Mapping(
                    device, context, queue, blocking[i], buffer_mem_flags[m],
                    parent_buffer_mem_flags[p], _Sub_BUFFER);
                test_error(err, __FUNCTION__);
            }
        }
    }

    return err;
}

//=====================  NO ACCESS

static cl_int test_mem_host_no_access_buffer_RW(
    cl_device_id device, cl_context context, cl_command_queue queue,
    cl_bool blocking, cl_mem_flags buffer_mem_flag,
    cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
{
    log_info("%s\n", __FUNCTION__);

    cBuffer_check_mem_host_no_access<TEST_ELEMENT_TYPE> checker(device, context,
                                                                queue);
    checker.m_blocking = blocking;
    checker.buffer_mem_flag = buffer_mem_flag;

    cl_int err = CL_SUCCESS;
    switch (buffer_type)
    {
        case _BUFFER: err = checker.SetupBuffer(); break;
        case _Sub_BUFFER:
            err = checker.SetupASSubBuffer(parent_buffer_flag);
            break;
    }

    test_error(err, __FUNCTION__);
    checker.Setup_Test_Environment();
    err = checker.verify_RW_Buffer_mapping();
    test_error(err, __FUNCTION__);
    clFinish(queue);

    return err;
}

static cl_int test_mem_host_no_access_buffer_RW_Rect(
    cl_device_id device, cl_context context, cl_command_queue queue,
    cl_bool blocking, cl_mem_flags buffer_mem_flag,
    cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
{
    log_info("%s\n", __FUNCTION__);

    cBuffer_check_mem_host_no_access<TEST_ELEMENT_TYPE> checker(device, context,
                                                                queue);
    checker.m_blocking = blocking;
    checker.buffer_mem_flag = buffer_mem_flag;
    cl_int err;
    switch (buffer_type)
    {
        case _BUFFER: err = checker.SetupBuffer(); break;
        case _Sub_BUFFER:
            err = checker.SetupASSubBuffer(parent_buffer_flag);
            break;
    }

    test_error(err, __FUNCTION__);
    checker.Setup_Test_Environment();
    err = checker.verify_RW_Buffer_mapping();
    test_error(err, __FUNCTION__);
    clFinish(queue);

    return err;
}

static cl_int test_mem_host_no_access_buffer_RW_Mapping(
    cl_device_id device, cl_context context, cl_command_queue queue,
    cl_bool blocking, cl_mem_flags buffer_mem_flag,
    cl_mem_flags parent_buffer_flag, enum BUFFER_TYPE buffer_type)
{
    log_info("%s\n", __FUNCTION__);

    cBuffer_check_mem_host_no_access<TEST_ELEMENT_TYPE> checker(device, context,
                                                                queue);

    checker.m_blocking = blocking;
    checker.buffer_mem_flag = buffer_mem_flag;
    cl_int err;
    switch (buffer_type)
    {
        case _BUFFER: err = checker.SetupBuffer(); break;
        case _Sub_BUFFER:
            err = checker.SetupASSubBuffer(parent_buffer_flag);
            break;
    }

    test_error(err, __FUNCTION__);
    checker.Setup_Test_Environment();
    err = checker.verify_RW_Buffer_mapping();
    test_error(err, __FUNCTION__);
    clFinish(queue);

    return err;
}

REGISTER_TEST(mem_host_no_access_buffer)
{
    cl_mem_flags buffer_mem_flag[2] = {
        CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS,
        CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR | CL_MEM_HOST_NO_ACCESS
    };

    cl_int err = CL_SUCCESS;

    cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
    for (int k = 0; k < 2; k++)
        for (int i = 0; i < 2; i++)
        {
            err = test_mem_host_no_access_buffer_RW(
                device, context, queue, blocking[i], buffer_mem_flag[k], 0,
                _BUFFER);
            test_error(err, __FUNCTION__);

            err = test_mem_host_no_access_buffer_RW_Rect(
                device, context, queue, blocking[i], buffer_mem_flag[k], 0,
                _BUFFER);
            test_error(err, __FUNCTION__);

            err = test_mem_host_no_access_buffer_RW_Mapping(
                device, context, queue, blocking[i], buffer_mem_flag[k], 0,
                _BUFFER);
            test_error(err, __FUNCTION__);
        }

    return err;
}

REGISTER_TEST(mem_host_no_access_subbuffer)
{
    cl_mem_flags parent_buffer_mem_flags[3] = {
        CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS,
        CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS,
        CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR | CL_MEM_HOST_NO_ACCESS
    };

    cl_mem_flags buffer_mem_flags[4] = {
        0, CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
        CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
        CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR
    };

    cl_int err = CL_SUCCESS;

    cl_bool blocking[2] = { CL_TRUE, CL_FALSE };
    for (int p = 0; p < 3; p++)
    {
        for (int k = 0; k < 4; k++)
        {
            for (int i = 0; i < 2; i++)
            {
                err += test_mem_host_no_access_buffer_RW(
                    device, context, queue, blocking[i], buffer_mem_flags[k],
                    parent_buffer_mem_flags[p], _Sub_BUFFER);

                err += test_mem_host_no_access_buffer_RW_Rect(
                    device, context, queue, blocking[i], buffer_mem_flags[k],
                    parent_buffer_mem_flags[p], _Sub_BUFFER);

                err += test_mem_host_no_access_buffer_RW_Mapping(
                    device, context, queue, blocking[i], buffer_mem_flags[k],
                    parent_buffer_mem_flags[p], _Sub_BUFFER);
            }
        }
    }

    return err;
}