iframe-proxy | Sunbelt Computer Software

158 lines (152 loc) · 4.74 KB
//===-- dpctl_vector_templ.cpp - Wrapper functions for opaque vector types ===//
//                      Data Parallel Control (dpctl)
// Copyright 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.
//===----------------------------------------------------------------------===//
/// This file is meant to be directly included inside other source files to add
/// the wrapper functions for vector operations.
//===----------------------------------------------------------------------===//
#include "Support/MemOwnershipAttrs.h"
#include "dpctl_error_handlers.h"
#include "dpctl_sycl_type_casters.hpp"
#include "dpctl_vector_macros.h"
#include <stddef.h>
#include <type_traits>
#include <vector>
 * @brief Creates a new std::vector of the opaque SYCL pointer types.
 * @return   A new dynamically allocated std::vector of opaque pointer types.
__dpctl_give VECTOR(EL) FN(EL, Create)()
    using vecTy = std::vector<SYCLREF(EL)>;
    vecTy *Vec = nullptr;
        Vec = new std::vector<SYCLREF(EL)>();
        return ::dpctl::syclinterface::wrap<vecTy>(Vec);
    } catch (std::exception const &e) {
        delete Vec;
        error_handler(e, __FILE__, __func__, __LINE__);
        return nullptr;
 * @brief Creates a new std::vector of the opaque SYCL pointer types from given
 * C array with deep copy.
 * @return   A new dynamically allocated std::vector of opaque pointer types.
__dpctl_give VECTOR(EL)
    FN(EL, CreateFromArray)(size_t n, __dpctl_keep SYCLREF(EL) * elems)
    using vecTy = std::vector<SYCLREF(EL)>;
    vecTy *Vec = nullptr;
        Vec = new vecTy();
        for (size_t i = 0; i < n; ++i) {
            auto Ref = ::dpctl::syclinterface::unwrap<EL_SYCL_TYPE>(elems[i]);
            Vec->emplace_back(::dpctl::syclinterface::wrap<EL_SYCL_TYPE>(
                new EL_SYCL_TYPE(*Ref)));
        return ::dpctl::syclinterface::wrap<vecTy>(Vec);
    } catch (std::exception const &e) {
        delete Vec;
        error_handler(e, __FILE__, __func__, __LINE__);
        return nullptr;
 * @brief Frees all the elements of the passed in std::vector and then frees the
 * std::vector pointer.
void FN(EL, Delete)(__dpctl_take VECTOR(EL) VRef)
    using vecTy = std::vector<SYCLREF(EL)>;
    auto Vec = ::dpctl::syclinterface::unwrap<vecTy>(VRef);
    if (Vec) {
        for (auto i = 0ul; i < Vec->size(); ++i) {
            auto D = ::dpctl::syclinterface::unwrap<EL_SYCL_TYPE>((*Vec)[i]);
            delete D;
    delete Vec;
 * @brief Frees all the elements of the vector and then calls clear().
void FN(EL, Clear)(__dpctl_keep VECTOR(EL) VRef)
    using vecTy = std::vector<SYCLREF(EL)>;
    auto Vec = ::dpctl::syclinterface::unwrap<vecTy>(VRef);
    if (Vec) {
        for (auto i = 0ul; i < Vec->size(); ++i) {
            auto D = ::dpctl::syclinterface::unwrap<EL_SYCL_TYPE>((*Vec)[i]);
            delete D;
        Vec->clear();
 * @brief Returns the number of elements in the vector.
size_t FN(EL, Size)(__dpctl_keep VECTOR(EL) VRef)
    using vecTy = std::vector<SYCLREF(EL)>;
    auto V = ::dpctl::syclinterface::unwrap<vecTy>(VRef);
        return V->size();
        return 0;
 * @brief Returns a copy of the opaque pointer at specified index, and throws
 * an out_of_range exception if the index is incorrect.
SYCLREF(EL) FN(EL, GetAt)(__dpctl_keep VECTOR(EL) VRef, size_t index)
    using vecTy = std::vector<SYCLREF(EL)>;
    auto Vec = ::dpctl::syclinterface::unwrap<vecTy>(VRef);
    SYCLREF(EL) copy = nullptr;
    if (Vec) {
        SYCLREF(EL) ret;
        try {
            ret = Vec->at(index);
        } catch (std::exception const &e) {
            error_handler(e, __FILE__, __func__, __LINE__);
            return nullptr;
        auto Ref = ::dpctl::syclinterface::unwrap<EL_SYCL_TYPE>(ret);
        EL_SYCL_TYPE *elPtr = nullptr;
        try {
            elPtr = new EL_SYCL_TYPE(*Ref);
            copy = ::dpctl::syclinterface::wrap<EL_SYCL_TYPE>(elPtr);
        } catch (std::exception const &e) {
            delete elPtr;
            error_handler(e, __FILE__, __func__, __LINE__);
            return nullptr;
    return copy;
Sunbelt Computer Software

PL/B Language Development and Support

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

FilesExpand file tree

dpctl_vector_templ.cpp

Latest commit

History

dpctl_vector_templ.cpp

File metadata and controls
