1177780828

Build Type

github

Committed by GitHub

Commit Message

Merge e69da3e86 into 8e716ae17

Pull Request Pull Request #557: DPCTLQueue_Memcpy, _Prefetch, _Memadvise are not asynchronous

Run Details

507 of 842 branches covered (60.21%)

Branch coverage included in aggregate %.

35 of 74 new or added lines in 3 files covered. (47.3%)

9 existing lines in 3 files now uncovered.

3470 of 5191 relevant lines covered (66.85%)

11.09 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

56.88

/dpctl-capi/source/dpctl_sycl_queue_interface.cpp

//===----- dpctl_sycl_queue_interface.cpp - Implements C API for sycl::queue =//
//
//                      Data Parallel Control (dpctl)
//
// Copyright 2020-2021 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.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file implements the data types and functions declared in
/// dpctl_sycl_queue_interface.h.
///
//===----------------------------------------------------------------------===//

#include "dpctl_sycl_queue_interface.h"
#include "../helper/include/dpctl_async_error_handler.h"
#include "Support/CBindingWrapping.h"
#include "dpctl_sycl_context_interface.h"
#include "dpctl_sycl_device_interface.h"
#include "dpctl_sycl_device_manager.h"
#include <CL/sycl.hpp> /* SYCL headers   */
#include <exception>
#include <stdexcept>

using namespace cl::sycl;

namespace
{
// Create wrappers for C Binding types (see CBindingWrapping.h).
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(context, DPCTLSyclContextRef)
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(device, DPCTLSyclDeviceRef)
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(event, DPCTLSyclEventRef)
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(kernel, DPCTLSyclKernelRef)
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(queue, DPCTLSyclQueueRef)

/*!
 * @brief Set the kernel arg object
 *
 * @param    cgh            My Param doc
 * @param    Arg            My Param doc
 */
bool set_kernel_arg(handler &cgh,
                    size_t idx,
                    __dpctl_keep void *Arg,
                    DPCTLKernelArgType ArgTy)
{
    bool arg_set = true;

    switch (ArgTy) {
    case DPCTL_CHAR:
        cgh.set_arg(idx, *(char *)Arg);
        break;
    case DPCTL_SIGNED_CHAR:
        cgh.set_arg(idx, *(signed char *)Arg);
        break;
    case DPCTL_UNSIGNED_CHAR:
        cgh.set_arg(idx, *(unsigned char *)Arg);
        break;
    case DPCTL_SHORT:
        cgh.set_arg(idx, *(short *)Arg);
        break;
    case DPCTL_INT:
        cgh.set_arg(idx, *(int *)Arg);
        break;
    case DPCTL_UNSIGNED_INT:
        cgh.set_arg(idx, *(unsigned int *)Arg);
        break;
    case DPCTL_UNSIGNED_INT8:
        cgh.set_arg(idx, *(uint8_t *)Arg);
        break;
    case DPCTL_LONG:
        cgh.set_arg(idx, *(long *)Arg);
        break;
    case DPCTL_UNSIGNED_LONG:
        cgh.set_arg(idx, *(unsigned long *)Arg);
        break;
    case DPCTL_LONG_LONG:
        cgh.set_arg(idx, *(long long *)Arg);
        break;
    case DPCTL_UNSIGNED_LONG_LONG:
        cgh.set_arg(idx, *(unsigned long long *)Arg);
        break;
    case DPCTL_SIZE_T:
        cgh.set_arg(idx, *(size_t *)Arg);
        break;
    case DPCTL_FLOAT:
        cgh.set_arg(idx, *(float *)Arg);
        break;
    case DPCTL_DOUBLE:
        cgh.set_arg(idx, *(double *)Arg);
        break;
    case DPCTL_LONG_DOUBLE:
        cgh.set_arg(idx, *(long double *)Arg);
        break;
    case DPCTL_VOID_PTR:
        cgh.set_arg(idx, Arg);
        break;
    default:
        // \todo handle errors
        arg_set = false;
        std::cerr << "Kernel argument could not be created.\n";
        break;
    }
    return arg_set;
}

std::unique_ptr<property_list> create_property_list(int properties)
{
    std::unique_ptr<property_list> propList;
    int _prop = properties;
    if (_prop & DPCTL_ENABLE_PROFILING) {
        _prop = _prop ^ DPCTL_ENABLE_PROFILING;
        if (_prop & DPCTL_IN_ORDER) {
            _prop = _prop ^ DPCTL_IN_ORDER;
            propList = std::make_unique<property_list>(
                sycl::property::queue::enable_profiling(),
                sycl::property::queue::in_order());
        }
        else {
            propList = std::make_unique<property_list>(
                sycl::property::queue::enable_profiling());
        }
    }
    else if (_prop & DPCTL_IN_ORDER) {
        _prop = _prop ^ DPCTL_IN_ORDER;
        propList =
            std::make_unique<property_list>(sycl::property::queue::in_order());
    }

    if (_prop) {
        // todo: log error
        std::cerr << "Invalid queue property argument (" << std::hex
                  << properties << "), interpreted as (" << (properties ^ _prop)
                  << ")" << '\n';
    }
    return propList;
}

__dpctl_give DPCTLSyclQueueRef
getQueueImpl(__dpctl_keep DPCTLSyclContextRef cRef,
             __dpctl_keep DPCTLSyclDeviceRef dRef,
             error_handler_callback *handler,
             int properties)
{
    DPCTLSyclQueueRef qRef = nullptr;
    qRef = DPCTLQueue_Create(cRef, dRef, handler, properties);
    return qRef;
}

} /* end of anonymous namespace */

DPCTL_API
__dpctl_give DPCTLSyclQueueRef
DPCTLQueue_Create(__dpctl_keep const DPCTLSyclContextRef CRef,
                  __dpctl_keep const DPCTLSyclDeviceRef DRef,
                  error_handler_callback *error_handler,
                  int properties)
{
    DPCTLSyclQueueRef q = nullptr;
    auto dev = unwrap(DRef);
    auto ctx = unwrap(CRef);

    if (!(dev && ctx)) {
        /* \todo handle error */
        return q;
    }
    auto propList = create_property_list(properties);

    if (propList && error_handler) {
        try {
            auto Queue = new queue(
                *ctx, *dev, DPCTL_AsyncErrorHandler(error_handler), *propList);
            q = wrap(Queue);
        } catch (std::bad_alloc const &ba) {
            std::cerr << ba.what() << '\n';
        } catch (runtime_error &re) {
            std::cerr << re.what() << '\n';
        }
    }
    else if (properties) {
        try {
            auto Queue = new queue(*ctx, *dev, *propList);
            q = wrap(Queue);
        } catch (std::bad_alloc const &ba) {
            std::cerr << ba.what() << '\n';
        } catch (runtime_error &re) {
            std::cerr << re.what() << '\n';
        }
    }
    else if (error_handler) {
        try {
            auto Queue =
                new queue(*ctx, *dev, DPCTL_AsyncErrorHandler(error_handler));
            q = wrap(Queue);
        } catch (std::bad_alloc const &ba) {
            std::cerr << ba.what() << '\n';
        } catch (runtime_error &re) {
            std::cerr << re.what() << '\n';
        }
    }
    else {
        try {
            auto Queue = new queue(*ctx, *dev);
            q = wrap(Queue);
        } catch (std::bad_alloc const &ba) {
            std::cerr << ba.what() << '\n';
        } catch (runtime_error &re) {
            std::cerr << re.what() << '\n';
        }
    }

    return q;
}

__dpctl_give DPCTLSyclQueueRef
DPCTLQueue_CreateForDevice(__dpctl_keep const DPCTLSyclDeviceRef DRef,
                           error_handler_callback *handler,
                           int properties)
{
    DPCTLSyclContextRef CRef = nullptr;
    DPCTLSyclQueueRef QRef = nullptr;
    auto Device = unwrap(DRef);

    if (!Device) {
        std::cerr << "Cannot create queue from NULL device reference.\n";
        return QRef;
    }
    // Check if a cached default context exists for the device.
    CRef = DPCTLDeviceMgr_GetCachedContext(DRef);
    // If a cached default context was found, that context will be used to use
    // create the new queue. When a default cached context was not found, as
    // will be the case for non-root devices, i.e., sub-devices, a new context
    // will be allocated. Note that any newly allocated context is not cached.
    if (!CRef) {
        context *ContextPtr = nullptr;
        try {
            ContextPtr = new context(*Device);
            CRef = wrap(ContextPtr);
        } catch (std::bad_alloc const &ba) {
            std::cerr << ba.what() << std::endl;
            delete ContextPtr;
            return QRef;
        }
    }
    // At this point we have a valid context and the queue can be allocated.
    QRef = getQueueImpl(CRef, DRef, handler, properties);
    // Free the context
    DPCTLContext_Delete(CRef);
    return QRef;
}

/*!
 * Delete the passed in pointer after verifying it points to a sycl::queue.
 */
void DPCTLQueue_Delete(__dpctl_take DPCTLSyclQueueRef QRef)
{
    delete unwrap(QRef);
}

/*!
 * Make copy of sycl::queue referenced by passed pointer
 */
__dpctl_give DPCTLSyclQueueRef
DPCTLQueue_Copy(__dpctl_keep const DPCTLSyclQueueRef QRef)
{
    auto Queue = unwrap(QRef);
    if (Queue) {
        try {
            auto CopiedQueue = new queue(*Queue);
            return wrap(CopiedQueue);
        } catch (std::bad_alloc &ba) {
            std::cerr << ba.what() << std::endl;
            return nullptr;
        }
    }
    else {
        std::cerr << "Can not copy DPCTLSyclQueueRef as input is a nullptr"
                  << std::endl;
        return nullptr;
    }
}

bool DPCTLQueue_AreEq(__dpctl_keep const DPCTLSyclQueueRef QRef1,
                      __dpctl_keep const DPCTLSyclQueueRef QRef2)
{
    if (!(QRef1 && QRef2))
        // \todo handle error
        return false;
    return (*unwrap(QRef1) == *unwrap(QRef2));
}

DPCTLSyclBackendType DPCTLQueue_GetBackend(__dpctl_keep DPCTLSyclQueueRef QRef)
{
    auto Q = unwrap(QRef);
    if (Q) {
        try {
            auto C = Q->get_context();
            return DPCTLContext_GetBackend(wrap(&C));
        } catch (runtime_error &re) {
            std::cerr << re.what() << '\n';
            // store error message
            return DPCTL_UNKNOWN_BACKEND;
        }
    }
    else
        return DPCTL_UNKNOWN_BACKEND;
}

__dpctl_give DPCTLSyclDeviceRef
DPCTLQueue_GetDevice(__dpctl_keep const DPCTLSyclQueueRef QRef)
{
    DPCTLSyclDeviceRef DRef = nullptr;
    auto Q = unwrap(QRef);
    if (Q) {
        try {
            auto Device = new device(Q->get_device());
            DRef = wrap(Device);
        } catch (std::bad_alloc const &ba) {
            std::cerr << ba.what() << '\n';
        }
    }
    else {
        std::cerr << "Could not get the device for this queue.\n";
    }
    return DRef;
}

__dpctl_give DPCTLSyclContextRef
DPCTLQueue_GetContext(__dpctl_keep const DPCTLSyclQueueRef QRef)
{
    auto Q = unwrap(QRef);
    DPCTLSyclContextRef CRef = nullptr;
    if (Q)
        CRef = wrap(new context(Q->get_context()));
    else {
        std::cerr << "Could not get the context for this queue.\n";
    }
    return CRef;
}

__dpctl_give DPCTLSyclEventRef
DPCTLQueue_SubmitRange(__dpctl_keep const DPCTLSyclKernelRef KRef,
                       __dpctl_keep const DPCTLSyclQueueRef QRef,
                       __dpctl_keep void **Args,
                       __dpctl_keep const DPCTLKernelArgType *ArgTypes,
                       size_t NArgs,
                       __dpctl_keep const size_t Range[3],
                       size_t NDims,
                       __dpctl_keep const DPCTLSyclEventRef *DepEvents,
                       size_t NDepEvents)
{
    auto Kernel = unwrap(KRef);
    auto Queue = unwrap(QRef);
    event e;

    try {
        e = Queue->submit([&](handler &cgh) {
            // Depend on any event that was specified by the caller.
            if (NDepEvents)
                for (auto i = 0ul; i < NDepEvents; ++i)
                    cgh.depends_on(*unwrap(DepEvents[i]));

            for (auto i = 0ul; i < NArgs; ++i) {
                // \todo add support for Sycl buffers
                // \todo handle errors properly
                if (!set_kernel_arg(cgh, i, Args[i], ArgTypes[i]))
                    exit(1);
            }
            switch (NDims) {
            case 1:
                cgh.parallel_for(range<1>{Range[0]}, *Kernel);
                break;
            case 2:
                cgh.parallel_for(range<2>{Range[0], Range[1]}, *Kernel);
                break;
            case 3:
                cgh.parallel_for(range<3>{Range[0], Range[1], Range[2]},
                                 *Kernel);
                break;
            default:
                // \todo handle the error
                throw std::runtime_error("Range cannot be greater than three "
                                         "dimensions.");
            }
        });
    } catch (runtime_error &re) {
        // \todo fix error handling
        std::cerr << re.what() << '\n';
        return nullptr;
    } catch (std::runtime_error &sre) {
        std::cerr << sre.what() << '\n';
        return nullptr;
    }

    return wrap(new event(e));
}

DPCTLSyclEventRef
DPCTLQueue_SubmitNDRange(__dpctl_keep const DPCTLSyclKernelRef KRef,
                         __dpctl_keep const DPCTLSyclQueueRef QRef,
                         __dpctl_keep void **Args,
                         __dpctl_keep const DPCTLKernelArgType *ArgTypes,
                         size_t NArgs,
                         __dpctl_keep const size_t gRange[3],
                         __dpctl_keep const size_t lRange[3],
                         size_t NDims,
                         __dpctl_keep const DPCTLSyclEventRef *DepEvents,
                         size_t NDepEvents)
{
    auto Kernel = unwrap(KRef);
    auto Queue = unwrap(QRef);
    event e;

    try {
        e = Queue->submit([&](handler &cgh) {
            // Depend on any event that was specified by the caller.
            if (NDepEvents)
                for (auto i = 0ul; i < NDepEvents; ++i)
                    cgh.depends_on(*unwrap(DepEvents[i]));

            for (auto i = 0ul; i < NArgs; ++i) {
                // \todo add support for Sycl buffers
                // \todo handle errors properly
                if (!set_kernel_arg(cgh, i, Args[i], ArgTypes[i]))
                    exit(1);
            }
            switch (NDims) {
            case 1:
                cgh.parallel_for(nd_range<1>{{gRange[0]}, {lRange[0]}},
                                 *Kernel);
                break;
            case 2:
                cgh.parallel_for(
                    nd_range<2>{{gRange[0], gRange[1]}, {lRange[0], lRange[1]}},
                    *Kernel);
                break;
            case 3:
                cgh.parallel_for(nd_range<3>{{gRange[0], gRange[1], gRange[2]},
                                             {lRange[0], lRange[1], lRange[2]}},
                                 *Kernel);
                break;
            default:
                // \todo handle the error
                throw std::runtime_error("Range cannot be greater than three "
                                         "dimensions.");
            }
        });
    } catch (runtime_error &re) {
        // \todo fix error handling
        std::cerr << re.what() << '\n';
        return nullptr;
    } catch (std::runtime_error &sre) {
        std::cerr << sre.what() << '\n';
        return nullptr;
    }

    return wrap(new event(e));
}

void DPCTLQueue_Wait(__dpctl_keep DPCTLSyclQueueRef QRef)
{
    // \todo what happens if the QRef is null or a pointer to a valid sycl
    // queue
    if (QRef) {
        auto SyclQueue = unwrap(QRef);
        if (SyclQueue)
            SyclQueue->wait();
    }
    else {
        // todo: log error
        std::cerr << "Argument QRef is NULL" << '\n';
    }
}

DPCTLSyclEventRef DPCTLQueue_Memcpy(__dpctl_keep const DPCTLSyclQueueRef QRef,
                                    void *Dest,
                                    const void *Src,
                                    size_t Count)
{
    auto Q = unwrap(QRef);
    if (Q) {
        sycl::event ev;
        try {
            ev = Q->memcpy(Dest, Src, Count);
        } catch (const sycl::runtime_error &re) {
            // todo: log error
            std::cerr << re.what() << '\n';
            return nullptr;
        }
        return wrap(new event(ev));
    }
    else {
        // todo: log error
        std::cerr << "QRef passed to memcpy was NULL" << '\n';
        return nullptr;
    }
}

DPCTLSyclEventRef DPCTLQueue_Prefetch(__dpctl_keep DPCTLSyclQueueRef QRef,
                                      const void *Ptr,
                                      size_t Count)
{
    auto Q = unwrap(QRef);
    if (Q) {
        sycl::event ev;
        try {
            ev = Q->prefetch(Ptr, Count);
        } catch (sycl::runtime_error &re) {
            // todo: log error
            std::cerr << re.what() << '\n';
            return nullptr;
        }
        return wrap(new event(ev));
    }
    else {
        // todo: log error
        std::cerr << "QRef passed to prefetch was NULL" << '\n';
        return nullptr;
    }
}

DPCTLSyclEventRef DPCTLQueue_MemAdvise(__dpctl_keep DPCTLSyclQueueRef QRef,
                                       const void *Ptr,
                                       size_t Count,
                                       int Advice)
{
    auto Q = unwrap(QRef);
    if (Q) {
        sycl::event ev;
        try {
            ev = Q->mem_advise(Ptr, Count, static_cast<pi_mem_advice>(Advice));
        } catch (const sycl::runtime_error &re) {
            // todo: log error
            std::cerr << re.what() << '\n';
            return nullptr;
        }
        return wrap(new event(ev));
    }
    else {
        // todo: log error
        std::cerr << "QRef passed to prefetch was NULL" << '\n';
        return nullptr;
    }
}

bool DPCTLQueue_IsInOrder(__dpctl_keep const DPCTLSyclQueueRef QRef)
{
    auto Q = unwrap(QRef);
    if (Q) {
        return Q->is_in_order();
    }
    else
        return false;
}

bool DPCTLQueue_HasEnableProfiling(__dpctl_keep const DPCTLSyclQueueRef QRef)
{
    auto Q = unwrap(QRef);
    if (Q) {
        return Q->has_property<sycl::property::queue::enable_profiling>();
    }
    else
        return false;
}

size_t DPCTLQueue_Hash(__dpctl_keep const DPCTLSyclQueueRef QRef)
{
    auto Q = unwrap(QRef);
    if (Q) {
        std::hash<queue> hash_fn;
        return hash_fn(*Q);
    }
    else {
        // todo: log error
        std::cerr << "Argument QRef is null" << '\n';
        return 0;
    }
}

__dpctl_give DPCTLSyclEventRef DPCTLQueue_SubmitBarrierForEvents(
    __dpctl_keep const DPCTLSyclQueueRef QRef,
    __dpctl_keep const DPCTLSyclEventRef *DepEvents,
    size_t NDepEvents)
{
    auto Q = unwrap(QRef);
    event e;
    if (Q) {
        try {
            e = Q->submit([&](handler &cgh) {
                // Depend on any event that was specified by the caller.
                if (NDepEvents)
                    for (auto i = 0ul; i < NDepEvents; ++i)
                        cgh.depends_on(*unwrap(DepEvents[i]));

                cgh.barrier();
            });
        } catch (runtime_error &re) {
            // \todo fix error handling
            std::cerr << re.what() << '\n';
            return nullptr;
        } catch (std::runtime_error &sre) {
            std::cerr << sre.what() << '\n';
            return nullptr;
        }

        return wrap(new event(e));
    }
    else {
        // todo: log error
        std::cerr << "Argument QRef is null" << '\n';
        return nullptr;
    }
}

__dpctl_give DPCTLSyclEventRef
DPCTLQueue_SubmitBarrier(__dpctl_keep const DPCTLSyclQueueRef QRef)
{
    return DPCTLQueue_SubmitBarrierForEvents(QRef, nullptr, 0);
}

1	//===----- dpctl_sycl_queue_interface.cpp - Implements C API for sycl::queue =//
2	//
3	// Data Parallel Control (dpctl)
4	//
5	// Copyright 2020-2021 Intel Corporation
6	//
7	// Licensed under the Apache License, Version 2.0 (the "License");
8	// you may not use this file except in compliance with the License.
9	// You may obtain a copy of the License at
10	//
11	// http://www.apache.org/licenses/LICENSE-2.0
12	//
13	// Unless required by applicable law or agreed to in writing, software
14	// distributed under the License is distributed on an "AS IS" BASIS,
15	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	// See the License for the specific language governing permissions and
17	// limitations under the License.
18	//
19	//===----------------------------------------------------------------------===//
20	///
21	/// \file
22	/// This file implements the data types and functions declared in
23	/// dpctl_sycl_queue_interface.h.
24	///
25	//===----------------------------------------------------------------------===//
26
27	#include "dpctl_sycl_queue_interface.h"
28	#include "../helper/include/dpctl_async_error_handler.h"
29	#include "Support/CBindingWrapping.h"
30	#include "dpctl_sycl_context_interface.h"
31	#include "dpctl_sycl_device_interface.h"
32	#include "dpctl_sycl_device_manager.h"
33	#include <CL/sycl.hpp> /* SYCL headers */
34	#include <exception>
35	#include <stdexcept>
36
37	using namespace cl::sycl;
38
39	namespace
40	{
41	// Create wrappers for C Binding types (see CBindingWrapping.h).
42	DEFINE_SIMPLE_CONVERSION_FUNCTIONS(context, DPCTLSyclContextRef)
43	DEFINE_SIMPLE_CONVERSION_FUNCTIONS(device, DPCTLSyclDeviceRef)
44	DEFINE_SIMPLE_CONVERSION_FUNCTIONS(event, DPCTLSyclEventRef)
45	DEFINE_SIMPLE_CONVERSION_FUNCTIONS(kernel, DPCTLSyclKernelRef)
46	DEFINE_SIMPLE_CONVERSION_FUNCTIONS(queue, DPCTLSyclQueueRef)
47
48	/*!
49	* @brief Set the kernel arg object
50	*
51	* @param cgh My Param doc
52	* @param Arg My Param doc
53	*/
54	bool set_kernel_arg(handler &cgh,
55	size_t idx,
56	__dpctl_keep void *Arg,
57	DPCTLKernelArgType ArgTy)
58	{	4✔
59	bool arg_set = true;	4✔
60
61	switch (ArgTy) {	4✔
62	case DPCTL_CHAR:	×
63	cgh.set_arg(idx, (char )Arg);	×
64	break;	×
65	case DPCTL_SIGNED_CHAR:	×
66	cgh.set_arg(idx, (signed char )Arg);	×
67	break;	×
68	case DPCTL_UNSIGNED_CHAR:	×
69	cgh.set_arg(idx, (unsigned char )Arg);	×
70	break;	×
71	case DPCTL_SHORT:	×
72	cgh.set_arg(idx, (short )Arg);	×
73	break;	×
74	case DPCTL_INT:	×
75	cgh.set_arg(idx, (int )Arg);	×
76	break;	×
77	case DPCTL_UNSIGNED_INT:	×
78	cgh.set_arg(idx, (unsigned int )Arg);	×
79	break;	×
80	case DPCTL_UNSIGNED_INT8:	×
81	cgh.set_arg(idx, (uint8_t )Arg);	×
82	break;	×
83	case DPCTL_LONG:	×
84	cgh.set_arg(idx, (long )Arg);	×
85	break;	×
86	case DPCTL_UNSIGNED_LONG:	×
87	cgh.set_arg(idx, (unsigned long )Arg);	×
88	break;	×
89	case DPCTL_LONG_LONG:	×
90	cgh.set_arg(idx, (long long )Arg);	×
91	break;	×
92	case DPCTL_UNSIGNED_LONG_LONG:	×
93	cgh.set_arg(idx, (unsigned long long )Arg);	×
94	break;	×
95	case DPCTL_SIZE_T:	×
96	cgh.set_arg(idx, (size_t )Arg);	×
97	break;	×
98	case DPCTL_FLOAT:	1✔
99	cgh.set_arg(idx, (float )Arg);	1✔
100	break;	1✔
101	case DPCTL_DOUBLE:	×
102	cgh.set_arg(idx, (double )Arg);	×
103	break;	×
104	case DPCTL_LONG_DOUBLE:	×
105	cgh.set_arg(idx, (long double )Arg);	×
106	break;	×
107	case DPCTL_VOID_PTR:	3✔
108	cgh.set_arg(idx, Arg);	3✔
109	break;	3✔
110	default:	×
111	// \todo handle errors
112	arg_set = false;	×
113	std::cerr << "Kernel argument could not be created.\n";	×
114	break;	×
115	}	4✔
116	return arg_set;	4✔
117	}	4✔
118
119	std::unique_ptr<property_list> create_property_list(int properties)
120	{	47✔
121	std::unique_ptr<property_list> propList;	47✔
122	int _prop = properties;	47✔
123	if (_prop & DPCTL_ENABLE_PROFILING) {	47✔
124	_prop = _prop ^ DPCTL_ENABLE_PROFILING;	14✔
125	if (_prop & DPCTL_IN_ORDER) {	14✔
126	_prop = _prop ^ DPCTL_IN_ORDER;	7✔
127	propList = std::make_unique<property_list>(	7✔
128	sycl::property::queue::enable_profiling(),	7✔
129	sycl::property::queue::in_order());	7✔
130	}	7✔
131	else {	7✔
132	propList = std::make_unique<property_list>(	7✔
133	sycl::property::queue::enable_profiling());	7✔
134	}	7✔
135	}	14✔
136	else if (_prop & DPCTL_IN_ORDER) {	33✔
137	_prop = _prop ^ DPCTL_IN_ORDER;	7✔
138	propList =	7✔
139	std::make_unique<property_list>(sycl::property::queue::in_order());	7✔
140	}	7✔
141
142	if (_prop) {	47✔
143	// todo: log error
144	std::cerr << "Invalid queue property argument (" << std::hex	1✔
145	<< properties << "), interpreted as (" << (properties ^ _prop)	1✔
146	<< ")" << '\n';	1✔
147	}	1✔
148	return propList;	47✔
149	}	47✔
150
151	__dpctl_give DPCTLSyclQueueRef
152	getQueueImpl(__dpctl_keep DPCTLSyclContextRef cRef,
153	__dpctl_keep DPCTLSyclDeviceRef dRef,
154	error_handler_callback *handler,
155	int properties)
156	{	40✔
157	DPCTLSyclQueueRef qRef = nullptr;	40✔
158	qRef = DPCTLQueue_Create(cRef, dRef, handler, properties);	40✔
159	return qRef;	40✔
160	}	40✔
161
162	} /* end of anonymous namespace */
163
164	DPCTL_API
165	__dpctl_give DPCTLSyclQueueRef
166	DPCTLQueue_Create(__dpctl_keep const DPCTLSyclContextRef CRef,
167	__dpctl_keep const DPCTLSyclDeviceRef DRef,
168	error_handler_callback *error_handler,
169	int properties)
170	{	57✔
171	DPCTLSyclQueueRef q = nullptr;	57✔
172	auto dev = unwrap(DRef);	57✔
173	auto ctx = unwrap(CRef);	57✔
174
175	if (!(dev && ctx)) {	57!
176	/* \todo handle error */
177	return q;	10✔
178	}	10✔
179	auto propList = create_property_list(properties);	47✔
180
181	if (propList && error_handler) {	47✔
182	try {	9✔
183	auto Queue = new queue(	9✔
184	ctx, dev, DPCTL_AsyncErrorHandler(error_handler), *propList);	9✔
185	q = wrap(Queue);	9✔
186	} catch (std::bad_alloc const &ba) {	9✔
187	std::cerr << ba.what() << '\n';	×
188	} catch (runtime_error &re) {	×
189	std::cerr << re.what() << '\n';	×
190	}	×
191	}	9✔
192	else if (properties) {	38✔
193	try {	12✔
194	auto Queue = new queue(ctx, dev, *propList);	12✔
195	q = wrap(Queue);	12✔
196	} catch (std::bad_alloc const &ba) {	12✔
197	std::cerr << ba.what() << '\n';	×
198	} catch (runtime_error &re) {	×
199	std::cerr << re.what() << '\n';	×
200	}	×
201	}	12✔
202	else if (error_handler) {	26✔
203	try {	3✔
204	auto Queue =	3✔
205	new queue(ctx, dev, DPCTL_AsyncErrorHandler(error_handler));	3✔
206	q = wrap(Queue);	3✔
207	} catch (std::bad_alloc const &ba) {	3✔
208	std::cerr << ba.what() << '\n';	×
209	} catch (runtime_error &re) {	×
210	std::cerr << re.what() << '\n';	×
211	}	×
212	}	3✔
213	else {	23✔
214	try {	23✔
215	auto Queue = new queue(ctx, dev);	23✔
216	q = wrap(Queue);	23✔
217	} catch (std::bad_alloc const &ba) {	23✔
218	std::cerr << ba.what() << '\n';	×
219	} catch (runtime_error &re) {	×
220	std::cerr << re.what() << '\n';	×
221	}	×
222	}	23✔
223
224	return q;	47✔
225	}	47✔
226
227	__dpctl_give DPCTLSyclQueueRef
228	DPCTLQueue_CreateForDevice(__dpctl_keep const DPCTLSyclDeviceRef DRef,
229	error_handler_callback *handler,
230	int properties)
231	{	89✔
232	DPCTLSyclContextRef CRef = nullptr;	89✔
233	DPCTLSyclQueueRef QRef = nullptr;	89✔
234	auto Device = unwrap(DRef);	89✔
235
236	if (!Device) {	89✔
237	std::cerr << "Cannot create queue from NULL device reference.\n";	49✔
238	return QRef;	49✔
239	}	49✔
240	// Check if a cached default context exists for the device.
241	CRef = DPCTLDeviceMgr_GetCachedContext(DRef);	40✔
242	// If a cached default context was found, that context will be used to use
243	// create the new queue. When a default cached context was not found, as
244	// will be the case for non-root devices, i.e., sub-devices, a new context
245	// will be allocated. Note that any newly allocated context is not cached.
246	if (!CRef) {	40✔
247	context *ContextPtr = nullptr;	2✔
248	try {	2✔
249	ContextPtr = new context(*Device);	2✔
250	CRef = wrap(ContextPtr);	2✔
251	} catch (std::bad_alloc const &ba) {	2✔
252	std::cerr << ba.what() << std::endl;	×
253	delete ContextPtr;	×
254	return QRef;	×
255	}	×
256	}	2✔
257	// At this point we have a valid context and the queue can be allocated.
258	QRef = getQueueImpl(CRef, DRef, handler, properties);	40✔
259	// Free the context
260	DPCTLContext_Delete(CRef);	40✔
261	return QRef;	40✔
262	}	40✔
263
264	/*!
265	* Delete the passed in pointer after verifying it points to a sycl::queue.
266	*/
267	void DPCTLQueue_Delete(__dpctl_take DPCTLSyclQueueRef QRef)
268	{	115✔
269	delete unwrap(QRef);	115✔
270	}	115✔
271
272	/*!
273	* Make copy of sycl::queue referenced by passed pointer
274	*/
275	__dpctl_give DPCTLSyclQueueRef
276	DPCTLQueue_Copy(__dpctl_keep const DPCTLSyclQueueRef QRef)
277	{	3✔
278	auto Queue = unwrap(QRef);	3✔
279	if (Queue) {	3✔
280	try {	2✔
281	auto CopiedQueue = new queue(*Queue);	2✔
282	return wrap(CopiedQueue);	2✔
283	} catch (std::bad_alloc &ba) {	2✔
284	std::cerr << ba.what() << std::endl;	×
285	return nullptr;	×
286	}	×
287	}	2✔
288	else {	1✔
289	std::cerr << "Can not copy DPCTLSyclQueueRef as input is a nullptr"	1✔
290	<< std::endl;	1✔
291	return nullptr;	1✔
292	}	1✔
293	}	3✔
294
295	bool DPCTLQueue_AreEq(__dpctl_keep const DPCTLSyclQueueRef QRef1,
296	__dpctl_keep const DPCTLSyclQueueRef QRef2)
297	{	4✔
298	if (!(QRef1 && QRef2))	4✔
299	// \todo handle error
300	return false;	2✔
301	return (unwrap(QRef1) == unwrap(QRef2));	2✔
302	}	4✔
303
304	DPCTLSyclBackendType DPCTLQueue_GetBackend(__dpctl_keep DPCTLSyclQueueRef QRef)
305	{	9✔
306	auto Q = unwrap(QRef);	9✔
307	if (Q) {	9✔
308	try {	8✔
309	auto C = Q->get_context();	8✔
310	return DPCTLContext_GetBackend(wrap(&C));	8✔
311	} catch (runtime_error &re) {	8✔
312	std::cerr << re.what() << '\n';	×
313	// store error message
314	return DPCTL_UNKNOWN_BACKEND;	×
315	}	×
316	}	8✔
317	else	1✔
318	return DPCTL_UNKNOWN_BACKEND;	1✔
319	}	9✔
320
321	__dpctl_give DPCTLSyclDeviceRef
322	DPCTLQueue_GetDevice(__dpctl_keep const DPCTLSyclQueueRef QRef)
323	{	15✔
324	DPCTLSyclDeviceRef DRef = nullptr;	15✔
325	auto Q = unwrap(QRef);	15✔
326	if (Q) {	15✔
327	try {	14✔
328	auto Device = new device(Q->get_device());	14✔
329	DRef = wrap(Device);	14✔
330	} catch (std::bad_alloc const &ba) {	14✔
331	std::cerr << ba.what() << '\n';	×
332	}	×
333	}	14✔
334	else {	1✔
335	std::cerr << "Could not get the device for this queue.\n";	1✔
336	}	1✔
337	return DRef;	15✔
338	}	15✔
339
340	__dpctl_give DPCTLSyclContextRef
341	DPCTLQueue_GetContext(__dpctl_keep const DPCTLSyclQueueRef QRef)
342	{	20✔
343	auto Q = unwrap(QRef);	20✔
344	DPCTLSyclContextRef CRef = nullptr;	20✔
345	if (Q)	20✔
346	CRef = wrap(new context(Q->get_context()));	19✔
347	else {	1✔
348	std::cerr << "Could not get the context for this queue.\n";	1✔
349	}	1✔
350	return CRef;	20✔
351	}	20✔
352
353	__dpctl_give DPCTLSyclEventRef
354	DPCTLQueue_SubmitRange(__dpctl_keep const DPCTLSyclKernelRef KRef,
355	__dpctl_keep const DPCTLSyclQueueRef QRef,
356	__dpctl_keep void **Args,
357	__dpctl_keep const DPCTLKernelArgType *ArgTypes,
358	size_t NArgs,
359	__dpctl_keep const size_t Range[3],
360	size_t NDims,
361	__dpctl_keep const DPCTLSyclEventRef *DepEvents,
362	size_t NDepEvents)
363	{	1✔
364	auto Kernel = unwrap(KRef);	1✔
365	auto Queue = unwrap(QRef);	1✔
366	event e;	1✔
367
368	try {	1✔
369	e = Queue->submit([&](handler &cgh) {	1✔
370	// Depend on any event that was specified by the caller.
371	if (NDepEvents)	1!
372	for (auto i = 0ul; i < NDepEvents; ++i)	×
373	cgh.depends_on(*unwrap(DepEvents[i]));	×
374
375	for (auto i = 0ul; i < NArgs; ++i) {	5✔
376	// \todo add support for Sycl buffers
377	// \todo handle errors properly
378	if (!set_kernel_arg(cgh, i, Args[i], ArgTypes[i]))	4!
379	exit(1);	×
380	}	4✔
381	switch (NDims) {	1✔
382	case 1:	1!
383	cgh.parallel_for(range<1>{Range[0]}, *Kernel);	1✔
384	break;	1✔
385	case 2:	×
386	cgh.parallel_for(range<2>{Range[0], Range[1]}, *Kernel);	×
387	break;	×
388	case 3:	×
389	cgh.parallel_for(range<3>{Range[0], Range[1], Range[2]},	×
390	*Kernel);	×
391	break;	×
392	default:	×
393	// \todo handle the error
394	throw std::runtime_error("Range cannot be greater than three "	×
395	"dimensions.");	×
396	}	1✔
397	});	1✔
398	} catch (runtime_error &re) {	1✔
399	// \todo fix error handling
400	std::cerr << re.what() << '\n';	×
401	return nullptr;	×
402	} catch (std::runtime_error &sre) {	×
403	std::cerr << sre.what() << '\n';	×
404	return nullptr;	×
405	}	×
406
407	return wrap(new event(e));	1✔
408	}	1✔
409
410	DPCTLSyclEventRef
411	DPCTLQueue_SubmitNDRange(__dpctl_keep const DPCTLSyclKernelRef KRef,
412	__dpctl_keep const DPCTLSyclQueueRef QRef,
413	__dpctl_keep void **Args,
414	__dpctl_keep const DPCTLKernelArgType *ArgTypes,
415	size_t NArgs,
416	__dpctl_keep const size_t gRange[3],
417	__dpctl_keep const size_t lRange[3],
418	size_t NDims,
419	__dpctl_keep const DPCTLSyclEventRef *DepEvents,
420	size_t NDepEvents)
421	{	×
422	auto Kernel = unwrap(KRef);	×
423	auto Queue = unwrap(QRef);	×
424	event e;	×
425
426	try {	×
427	e = Queue->submit([&](handler &cgh) {	×
428	// Depend on any event that was specified by the caller.
429	if (NDepEvents)	×
430	for (auto i = 0ul; i < NDepEvents; ++i)	×
431	cgh.depends_on(*unwrap(DepEvents[i]));	×
432
433	for (auto i = 0ul; i < NArgs; ++i) {	×
434	// \todo add support for Sycl buffers
435	// \todo handle errors properly
436	if (!set_kernel_arg(cgh, i, Args[i], ArgTypes[i]))	×
437	exit(1);	×
438	}	×
439	switch (NDims) {	×
440	case 1:	×
441	cgh.parallel_for(nd_range<1>{{gRange[0]}, {lRange[0]}},	×
442	*Kernel);	×
443	break;	×
444	case 2:	×
445	cgh.parallel_for(	×
446	nd_range<2>{{gRange[0], gRange[1]}, {lRange[0], lRange[1]}},	×
447	*Kernel);	×
448	break;	×
449	case 3:	×
450	cgh.parallel_for(nd_range<3>{{gRange[0], gRange[1], gRange[2]},	×
451	{lRange[0], lRange[1], lRange[2]}},	×
452	*Kernel);	×
453	break;	×
454	default:	×
455	// \todo handle the error
456	throw std::runtime_error("Range cannot be greater than three "	×
457	"dimensions.");	×
458	}	×
459	});	×
460	} catch (runtime_error &re) {	×
461	// \todo fix error handling
462	std::cerr << re.what() << '\n';	×
463	return nullptr;	×
464	} catch (std::runtime_error &sre) {	×
465	std::cerr << sre.what() << '\n';	×
466	return nullptr;	×
467	}	×
468
469	return wrap(new event(e));	×
470	}	×
471
472	void DPCTLQueue_Wait(__dpctl_keep DPCTLSyclQueueRef QRef)
473	{	1✔
474	// \todo what happens if the QRef is null or a pointer to a valid sycl
475	// queue
476	if (QRef) {	1!
477	auto SyclQueue = unwrap(QRef);	1✔
478	if (SyclQueue)	1!
479	SyclQueue->wait();	1✔
480	}	1✔
481	else {	×
482	// todo: log error
483	std::cerr << "Argument QRef is NULL" << '\n';	×
484	}	×
485	}	1✔
486
487	DPCTLSyclEventRef DPCTLQueue_Memcpy(__dpctl_keep const DPCTLSyclQueueRef QRef,
488	void *Dest,
489	const void *Src,
490	size_t Count)
491	{	6✔
492	auto Q = unwrap(QRef);	6✔
493	if (Q) {	6!
494	sycl::event ev;	6✔
495	try {	6✔
496	ev = Q->memcpy(Dest, Src, Count);	6✔
497	} catch (const sycl::runtime_error &re) {	6✔
498	// todo: log error
NEW 499	std::cerr << re.what() << '\n';	×
NEW 500	return nullptr;	×
NEW 501	}	×
502	return wrap(new event(ev));	6✔
503	}	6✔
NEW 504	else {	×
505	// todo: log error
NEW 506	std::cerr << "QRef passed to memcpy was NULL" << '\n';	×
NEW 507	return nullptr;	×
UNCOV 508	}	×
509	}	6✔
510
511	DPCTLSyclEventRef DPCTLQueue_Prefetch(__dpctl_keep DPCTLSyclQueueRef QRef,
512	const void *Ptr,
513	size_t Count)
514	{	6✔
515	auto Q = unwrap(QRef);	6✔
516	if (Q) {	6!
517	sycl::event ev;	6✔
518	try {	6✔
519	ev = Q->prefetch(Ptr, Count);	6✔
520	} catch (sycl::runtime_error &re) {	6✔
521	// todo: log error
NEW 522	std::cerr << re.what() << '\n';	×
NEW 523	return nullptr;	×
NEW 524	}	×
525	return wrap(new event(ev));	6✔
526	}	6✔
NEW 527	else {	×
528	// todo: log error
NEW 529	std::cerr << "QRef passed to prefetch was NULL" << '\n';	×
NEW 530	return nullptr;	×
UNCOV 531	}	×
532	}	6✔
533
534	DPCTLSyclEventRef DPCTLQueue_MemAdvise(__dpctl_keep DPCTLSyclQueueRef QRef,
535	const void *Ptr,
536	size_t Count,
537	int Advice)
538	{	6✔
539	auto Q = unwrap(QRef);	6✔
540	if (Q) {	6!
541	sycl::event ev;	6✔
542	try {	6✔
543	ev = Q->mem_advise(Ptr, Count, static_cast<pi_mem_advice>(Advice));	6✔
544	} catch (const sycl::runtime_error &re) {	6✔
545	// todo: log error
NEW 546	std::cerr << re.what() << '\n';	×
NEW 547	return nullptr;	×
NEW 548	}	×
549	return wrap(new event(ev));	6✔
550	}	6✔
NEW 551	else {	×
552	// todo: log error
NEW 553	std::cerr << "QRef passed to prefetch was NULL" << '\n';	×
NEW 554	return nullptr;	×
UNCOV 555	}	×
556	}	6✔
557
558	bool DPCTLQueue_IsInOrder(__dpctl_keep const DPCTLSyclQueueRef QRef)
559	{	5✔
560	auto Q = unwrap(QRef);	5✔
561	if (Q) {	5✔
562	return Q->is_in_order();	4✔
563	}	4✔
564	else	1✔
565	return false;	1✔
566	}	5✔
567
568	bool DPCTLQueue_HasEnableProfiling(__dpctl_keep const DPCTLSyclQueueRef QRef)
569	{	5✔
570	auto Q = unwrap(QRef);	5✔
571	if (Q) {	5✔
572	return Q->has_property<sycl::property::queue::enable_profiling>();	4✔
573	}	4✔
574	else	1✔
575	return false;	1✔
576	}	5✔
577
578	size_t DPCTLQueue_Hash(__dpctl_keep const DPCTLSyclQueueRef QRef)
579	{	8✔
580	auto Q = unwrap(QRef);	8✔
581	if (Q) {	8✔
582	std::hash<queue> hash_fn;	5✔
583	return hash_fn(*Q);	5✔
584	}	5✔
585	else {	3✔
586	// todo: log error
587	std::cerr << "Argument QRef is null" << '\n';	3✔
588	return 0;	3✔
589	}	3✔
590	}	8✔
591
592	__dpctl_give DPCTLSyclEventRef DPCTLQueue_SubmitBarrierForEvents(
593	__dpctl_keep const DPCTLSyclQueueRef QRef,
594	__dpctl_keep const DPCTLSyclEventRef *DepEvents,
595	size_t NDepEvents)
596	{	×
597	auto Q = unwrap(QRef);	×
598	event e;	×
599	if (Q) {	×
600	try {	×
601	e = Q->submit([&](handler &cgh) {	×
602	// Depend on any event that was specified by the caller.
603	if (NDepEvents)	×
604	for (auto i = 0ul; i < NDepEvents; ++i)	×
605	cgh.depends_on(*unwrap(DepEvents[i]));	×
606
607	cgh.barrier();	×
608	});	×
609	} catch (runtime_error &re) {	×
610	// \todo fix error handling
611	std::cerr << re.what() << '\n';	×
612	return nullptr;	×
613	} catch (std::runtime_error &sre) {	×
614	std::cerr << sre.what() << '\n';	×
615	return nullptr;	×
616	}	×
617
618	return wrap(new event(e));	×
619	}	×
620	else {	×
621	// todo: log error
622	std::cerr << "Argument QRef is null" << '\n';	×
623	return nullptr;	×
624	}	×
625	}	×
626
627	__dpctl_give DPCTLSyclEventRef
628	DPCTLQueue_SubmitBarrier(__dpctl_keep const DPCTLSyclQueueRef QRef)
629	{	×
630	return DPCTLQueue_SubmitBarrierForEvents(QRef, nullptr, 0);	×
631	}	×

IntelPython / dpctl / 1177780828

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous