src/libANGLE/CLProgram.cpp

//
// Copyright 2021 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// CLProgram.cpp: Implements the cl::Program class.

#include "libANGLE/CLProgram.h"

#include "libANGLE/CLContext.h"
#include "libANGLE/CLPlatform.h"

#include <cstring>

namespace cl
{

cl_int Program::build(cl_uint numDevices,
                      const cl_device_id *deviceList,
                      const char *options,
                      ProgramCB pfnNotify,
                      void *userData)
{
    DevicePtrs devices;
    devices.reserve(numDevices);
    while (numDevices-- != 0u)
    {
        devices.emplace_back(&(*deviceList++)->cast<Device>());
    }
    Program *notify = nullptr;
    if (pfnNotify != nullptr)
    {
        // This program has to be retained until the notify callback is called.
        retain();
        *mCallback = CallbackData(pfnNotify, userData);
        notify     = this;
    }
    return mImpl->build(devices, options, notify);
}

cl_int Program::compile(cl_uint numDevices,
                        const cl_device_id *deviceList,
                        const char *options,
                        cl_uint numInputHeaders,
                        const cl_program *inputHeaders,
                        const char **headerIncludeNames,
                        ProgramCB pfnNotify,
                        void *userData)
{
    DevicePtrs devices;
    devices.reserve(numDevices);
    while (numDevices-- != 0u)
    {
        devices.emplace_back(&(*deviceList++)->cast<Device>());
    }
    ProgramPtrs programs;
    programs.reserve(numInputHeaders);
    while (numInputHeaders-- != 0u)
    {
        programs.emplace_back(&(*inputHeaders++)->cast<Program>());
    }
    Program *notify = nullptr;
    if (pfnNotify != nullptr)
    {
        // This program has to be retained until the notify callback is called.
        retain();
        *mCallback = CallbackData(pfnNotify, userData);
        notify     = this;
    }
    return mImpl->compile(devices, options, programs, headerIncludeNames, notify);
}

cl_int Program::getInfo(ProgramInfo name, size_t valueSize, void *value, size_t *valueSizeRet) const
{
    std::vector<cl_device_id> devices;
    cl_uint valUInt       = 0u;
    void *valPointer      = nullptr;
    const void *copyValue = nullptr;
    size_t copySize       = 0u;

    switch (name)
    {
        case ProgramInfo::ReferenceCount:
            valUInt   = getRefCount();
            copyValue = &valUInt;
            copySize  = sizeof(valUInt);
            break;
        case ProgramInfo::Context:
            valPointer = mContext->getNative();
            copyValue  = &valPointer;
            copySize   = sizeof(valPointer);
            break;
        case ProgramInfo::NumDevices:
            valUInt   = static_cast<decltype(valUInt)>(mDevices.size());
            copyValue = &valUInt;
            copySize  = sizeof(valUInt);
            break;
        case ProgramInfo::Devices:
            devices.reserve(mDevices.size());
            for (const DevicePtr &device : mDevices)
            {
                devices.emplace_back(device->getNative());
            }
            copyValue = devices.data();
            copySize  = devices.size() * sizeof(decltype(devices)::value_type);
            break;
        case ProgramInfo::Source:
            copyValue = mSource.c_str();
            copySize  = mSource.length() + 1u;
            break;
        case ProgramInfo::IL:
            copyValue = mIL.c_str();
            copySize  = mIL.length() + 1u;
            break;
        case ProgramInfo::BinarySizes:
        case ProgramInfo::Binaries:
        case ProgramInfo::NumKernels:
        case ProgramInfo::KernelNames:
        case ProgramInfo::ScopeGlobalCtorsPresent:
        case ProgramInfo::ScopeGlobalDtorsPresent:
            return mImpl->getInfo(name, valueSize, value, valueSizeRet);
        default:
            return CL_INVALID_VALUE;
    }

    if (value != nullptr)
    {
        // CL_INVALID_VALUE if size in bytes specified by param_value_size is < size of return type
        // as described in the Program Object Queries table and param_value is not NULL.
        if (valueSize < copySize)
        {
            return CL_INVALID_VALUE;
        }
        if (copyValue != nullptr)
        {
            std::memcpy(value, copyValue, copySize);
        }
    }
    if (valueSizeRet != nullptr)
    {
        *valueSizeRet = copySize;
    }
    return CL_SUCCESS;
}

cl_int Program::getBuildInfo(cl_device_id device,
                             ProgramBuildInfo name,
                             size_t valueSize,
                             void *value,
                             size_t *valueSizeRet) const
{
    return mImpl->getBuildInfo(device->cast<Device>(), name, valueSize, value, valueSizeRet);
}

cl_kernel Program::createKernel(const char *kernel_name, cl_int &errorCode)
{
    return Object::Create<Kernel>(errorCode, *this, kernel_name);
}

cl_int Program::createKernels(cl_uint numKernels, cl_kernel *kernels, cl_uint *numKernelsRet)
{
    if (kernels == nullptr)
    {
        numKernels = 0u;
    }
    rx::CLKernelImpl::CreateFuncs createFuncs;
    cl_int errorCode = mImpl->createKernels(numKernels, createFuncs, numKernelsRet);
    if (errorCode == CL_SUCCESS)
    {
        KernelPtrs krnls;
        krnls.reserve(createFuncs.size());
        while (!createFuncs.empty())
        {
            krnls.emplace_back(new Kernel(*this, createFuncs.front(), errorCode));
            if (errorCode != CL_SUCCESS)
            {
                return CL_INVALID_VALUE;
            }
            createFuncs.pop_front();
        }
        for (KernelPtr &kernel : krnls)
        {
            *kernels++ = kernel.release();
        }
    }
    return errorCode;
}

Program::~Program() = default;

void Program::callback()
{
    CallbackData callbackData;
    mCallback->swap(callbackData);
    const ProgramCB callback = callbackData.first;
    void *const userData     = callbackData.second;
    ASSERT(callback != nullptr);
    callback(this, userData);
    // This program can be released after the callback was called.
    if (release())
    {
        delete this;
    }
}

Program::Program(Context &context, std::string &&source, cl_int &errorCode)
    : mContext(&context),
      mDevices(context.getDevices()),
      mNumAttachedKernels(0u),
      mImpl(context.getImpl().createProgramWithSource(*this, source, errorCode)),
      mSource(std::move(source))
{}

Program::Program(Context &context, const void *il, size_t length, cl_int &errorCode)
    : mContext(&context),
      mDevices(context.getDevices()),
      mIL(static_cast<const char *>(il), length),
      mNumAttachedKernels(0u),
      mImpl(context.getImpl().createProgramWithIL(*this, il, length, errorCode)),
      mSource(mImpl ? mImpl->getSource(errorCode) : std::string{})
{}

Program::Program(Context &context,
                 DevicePtrs &&devices,
                 const size_t *lengths,
                 const unsigned char **binaries,
                 cl_int *binaryStatus,
                 cl_int &errorCode)
    : mContext(&context),
      mDevices(std::move(devices)),
      mNumAttachedKernels(0u),
      mImpl(context.getImpl()
                .createProgramWithBinary(*this, lengths, binaries, binaryStatus, errorCode)),
      mSource(mImpl ? mImpl->getSource(errorCode) : std::string{})
{}

Program::Program(Context &context, DevicePtrs &&devices, const char *kernelNames, cl_int &errorCode)
    : mContext(&context),
      mDevices(std::move(devices)),
      mNumAttachedKernels(0u),
      mImpl(context.getImpl().createProgramWithBuiltInKernels(*this, kernelNames, errorCode)),
      mSource(mImpl ? mImpl->getSource(errorCode) : std::string{})
{}

Program::Program(Context &context,
                 const DevicePtrs &devices,
                 const char *options,
                 const cl::ProgramPtrs &inputPrograms,
                 ProgramCB pfnNotify,
                 void *userData,
                 cl_int &errorCode)
    : mContext(&context),
      mDevices(!devices.empty() ? devices : context.getDevices()),
      // This program has to be retained until the notify callback is called.
      mCallback(pfnNotify != nullptr ? (retain(), CallbackData(pfnNotify, userData))
                                     : CallbackData()),
      mNumAttachedKernels(0u),
      mImpl(context.getImpl().linkProgram(*this,
                                          devices,
                                          options,
                                          inputPrograms,
                                          pfnNotify != nullptr ? this : nullptr,
                                          errorCode)),
      mSource(mImpl ? mImpl->getSource(errorCode) : std::string{})
{}

}  // namespace cl