modules/ocl/cl_device.cpp

/*
 * cl_device.cpp - CL device
 *
 *  Copyright (c) 2015 Intel Corporation
 *
 * 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.
 *
 * Author: Wind Yuan <feng.yuan@intel.com>
 */

#include "cl_device.h"
#include "cl_context.h"
#if HAVE_LIBDRM
#include "intel/cl_intel_context.h"
#endif

namespace XCam {

SmartPtr<CLDevice> CLDevice::_instance;
Mutex CLDevice::_instance_mutex;

SmartPtr<CLDevice>
CLDevice::instance ()
{
    SmartLock locker(_instance_mutex);
    if (_instance.ptr())
        return _instance;

    _instance = new CLDevice ();
    // create default context
    if (_instance->is_inited() &&
            !_instance->create_default_context ()) {
        XCAM_LOG_WARNING ("CL device create default context failed");
    }

    return _instance;
}

CLDevice::CLDevice()
    : _platform_id (NULL)
    , _device_id (NULL)
    , _inited (false)
{
    if (!init()) {
        XCAM_LOG_WARNING ("CL device init failed");
    }
    XCAM_LOG_DEBUG ("CL device constructed");
}

CLDevice::~CLDevice ()
{
    XCAM_LOG_DEBUG ("CL device destructed");
}

SmartPtr<CLContext>
CLDevice::get_context ()
{
    //created in CLDevice construction
    return _default_context;
}

void *
CLDevice::get_extension_function (const char *func_name)
{
    XCAM_ASSERT (func_name);
    void *ext_func = NULL;

#if defined (CL_VERSION_1_2) && (CL_VERSION_1_2 == 1)
    ext_func = (void *) clGetExtensionFunctionAddressForPlatform (_platform_id, func_name);
#else
    ext_func = (void *) clGetExtensionFunctionAddress (func_name);
#endif
    if (!ext_func)
        XCAM_LOG_ERROR ("ocl driver get extension function (%s) failed", func_name);

    return ext_func;
}

void
CLDevice::terminate ()
{
    if (_default_context.ptr ()) {
        _default_context->terminate ();
        _default_context.release ();
    }
}

bool
CLDevice::init ()
{
    cl_platform_id platform_id = NULL;
    cl_device_id   device_id = NULL;
    cl_uint num_platform = 0;
    cl_uint num_device = 0;
    CLDevieInfo device_info;

    if (clGetPlatformIDs (1, &platform_id, &num_platform) != CL_SUCCESS)
    {
        XCAM_LOG_WARNING ("get cl platform ID failed");
        return false;
    }
    XCAM_ASSERT (num_platform >= 1);

    if (clGetDeviceIDs (platform_id, CL_DEVICE_TYPE_GPU, 1, &device_id, &num_device) != CL_SUCCESS)
    {
        XCAM_LOG_WARNING ("get cl device ID failed");
        return false;
    }
    XCAM_ASSERT (num_device >= 1);

    // only query first device info
    if (!query_device_info (device_id, device_info)) {
        //continue
        XCAM_LOG_WARNING ("cl get device info failed but continue");
    } else {
        XCAM_LOG_INFO (
            "cl get device info,\n"
            "\tmax_compute_unit:%" PRIu32
            "\tmax_work_item_dims:%" PRIu32
            "\tmax_work_item_sizes:{%" PRIuS ", %" PRIuS ", %" PRIuS "}"
            "\tmax_work_group_size:%" PRIuS
            "\timage_pitch_alignment:%" PRIu32,
            device_info.max_compute_unit,
            device_info.max_work_item_dims,
            device_info.max_work_item_sizes[0], device_info.max_work_item_sizes[1], device_info.max_work_item_sizes[2],
            device_info.max_work_group_size,
            device_info.image_pitch_alignment);
    }

    // get platform name string length
    size_t sz = 0;
    if (clGetPlatformInfo(platform_id, CL_PLATFORM_NAME, 0, 0, &sz) != CL_SUCCESS)
    {
        XCAM_LOG_WARNING ("get cl platform name failed");
        return false;
    }

    // get platform name string
    if (sz >= XCAM_CL_MAX_STR_SIZE) {
        sz = XCAM_CL_MAX_STR_SIZE - 1;
    }
    if (clGetPlatformInfo(platform_id, CL_PLATFORM_NAME, sz, _platform_name, 0) != CL_SUCCESS)
    {
        XCAM_LOG_WARNING ("get cl platform name failed");
        return false;
    }

    _platform_id = platform_id;
    _device_id = device_id;
    _device_info = device_info;
    _platform_name[sz] = 0;
    _inited = true;
    return true;
}

bool
CLDevice::query_device_info (cl_device_id device_id, CLDevieInfo &info)
{
#undef XCAM_CL_GET_DEVICE_INFO
#define XCAM_CL_GET_DEVICE_INFO(name, val)                            \
    do {                                                              \
    if (clGetDeviceInfo (device_id, name, sizeof (val), &(val), NULL) != CL_SUCCESS) {   \
        XCAM_LOG_WARNING ("cl get device info(%s) failed", #name);    \
    } } while (0)

    XCAM_CL_GET_DEVICE_INFO (CL_DEVICE_MAX_COMPUTE_UNITS, info.max_compute_unit);
    XCAM_CL_GET_DEVICE_INFO (CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, info.max_work_item_dims);
    XCAM_CL_GET_DEVICE_INFO (CL_DEVICE_MAX_WORK_ITEM_SIZES, info.max_work_item_sizes);
    XCAM_CL_GET_DEVICE_INFO (CL_DEVICE_MAX_WORK_GROUP_SIZE, info.max_work_group_size);
    XCAM_CL_GET_DEVICE_INFO (CL_DEVICE_MAX_WORK_GROUP_SIZE, info.max_work_group_size);

    cl_uint alignment = 0;
    XCAM_CL_GET_DEVICE_INFO (CL_DEVICE_IMAGE_PITCH_ALIGNMENT, alignment);
    if (alignment)
        info.image_pitch_alignment = alignment;
    else
        info.image_pitch_alignment = 4;
    return true;
}

bool
CLDevice::create_default_context ()
{
    SmartPtr<CLContext> context;

#if HAVE_LIBDRM
    context = new CLIntelContext (_instance);
#else
    context = new CLContext (_instance);
#endif
    if (!context->is_valid())
        return false;

    // init first cmdqueue
    if (context->is_valid () && !context->init_cmd_queue (context)) {
        XCAM_LOG_ERROR ("CL context init cmd queue failed");
    }
    _default_context = context;
    return true;
}

};