12039103271

Committed 26 Nov 2024 09:12PM UTC coverage: 68.045% (+0.2%) from 67.822%

Build # 12039103271

Build Type

Pull #2201

github

Committed by

web-flow

Commit Message

Merge c0ba767d4 into 367e74e01

Pull Request Pull Request #2201: Implement extension for `dpnp.choose`

Run Details

4337 of 9862 branches covered (43.98%)

Branch coverage included in aggregate %.

295 of 383 new or added lines in 5 files covered. (77.02%)

3 existing lines in 2 files now uncovered.

16627 of 20947 relevant lines covered (79.38%)

20366.3 hits per line

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

56.94

/dpnp/backend/src/dpnpc_memory_adapter.hpp

//*****************************************************************************
// Copyright (c) 2016-2024, Intel Corporation
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// - Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
// - Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.
//*****************************************************************************

#pragma once
#ifndef DPNP_MEMORY_ADAPTER_H // Cython compatibility
#define DPNP_MEMORY_ADAPTER_H

#include "dpnp_utils.hpp"
#include "queue_sycl.hpp"

/**
 * @ingroup BACKEND_UTILS
 * @brief Adapter for the memory given by parameters in the DPNPC functions
 *
 * This type should be used to accommodate memory in the function. For example,
 * if the kernel must be executed in "queue_1" which is host based, but
 * input arrays are located on other "queue_2" or unknown place.
 *
 * Also, some functions completely host based and has no SYCL environment.
 *
 */
template <typename _DataType>
class DPNPC_ptr_adapter final
{
    DPCTLSyclQueueRef queue_ref; /**< reference to SYCL queue */
    sycl::queue queue;           /**< SYCL queue */
    void *aux_ptr = nullptr; /**< pointer to allocated memory by this adapter */
    void *orig_ptr =
        nullptr; /**< original pointer to memory given by parameters */
    size_t size_in_bytes = 0; /**< size of bytes of the memory */
    bool allocated = false; /**< True if the memory allocated by this procedure
                               and needs to be free */
    bool target_no_queue = false; /**< Indicates that original memory will be
                                     accessed from non SYCL environment */
    bool copy_back = false; /**< If the memory is 'result' it needs to be copied
                               back to original */
    const bool verbose = false;
    std::vector<sycl::event> deps;

public:
    DPNPC_ptr_adapter() = delete;

    DPNPC_ptr_adapter(DPCTLSyclQueueRef q_ref,
                      const void *src_ptr,
                      const size_t size,
                      bool target_no_sycl = false,
                      bool copy_back_request = false)
    {
        queue_ref = q_ref;
        queue = *(reinterpret_cast<sycl::queue *>(queue_ref));
        target_no_queue = target_no_sycl;
        copy_back = copy_back_request;
        orig_ptr = const_cast<void *>(src_ptr);
        size_in_bytes = size * sizeof(_DataType);
        deps = std::vector<sycl::event>{};

        // enum class alloc { host = 0, device = 1, shared = 2, unknown = 3 };
        sycl::usm::alloc src_ptr_type = sycl::usm::alloc::unknown;
        src_ptr_type = sycl::get_pointer_type(src_ptr, queue.get_context());
        if (verbose) {
            std::cerr << "DPNPC_ptr_converter:";
            std::cerr << "\n\t target_no_queue=" << target_no_queue;
            std::cerr << "\n\t copy_back=" << copy_back;
            std::cerr << "\n\t pointer=" << src_ptr;
            std::cerr << "\n\t size=" << size;
            std::cerr << "\n\t size_in_bytes=" << size_in_bytes;
            std::cerr << "\n\t pointer type=" << (long)src_ptr_type;
            std::cerr << "\n\t queue inorder=" << queue.is_in_order();
            std::cerr << "\n\t queue device is_cpu="
                      << queue.get_device().is_cpu();
            std::cerr << "\n\t queue device is_gpu="
                      << queue.get_device().is_gpu();
            std::cerr << "\n\t queue device is_accelerator="
                      << queue.get_device().is_accelerator();
            std::cerr << std::endl;
        }

        if (is_memcpy_required(src_ptr_type)) {
            aux_ptr = dpnp_memory_alloc_c(queue_ref, size_in_bytes);
            dpnp_memory_memcpy_c(queue_ref, aux_ptr, src_ptr, size_in_bytes);
            allocated = true;
            if (verbose) {
                std::cerr << "DPNPC_ptr_converter::alloc and copy memory"
                          << " from=" << src_ptr << " to=" << aux_ptr
                          << " size_in_bytes=" << size_in_bytes << std::endl;
            }
        }
        else {
            aux_ptr = const_cast<void *>(src_ptr);
        }
    }

    ~DPNPC_ptr_adapter()
    {
        if (allocated) {
            if (verbose) {
                std::cerr << "DPNPC_ptr_converter::free_memory at=" << aux_ptr
                          << std::endl;
            }

            sycl::event::wait(deps);

            if (copy_back) {
                copy_data_back();
            }

            dpnp_memory_free_c(queue_ref, aux_ptr);
        }
    }

    bool is_memcpy_required(sycl::usm::alloc src_ptr_type)
    {
        if (target_no_queue || queue.get_device().is_gpu()) {
            if (src_ptr_type == sycl::usm::alloc::unknown) {
                return true;
            }
            else if (target_no_queue &&
                     src_ptr_type == sycl::usm::alloc::device) {
                return true;
            }
        }

        return false;
    }

    _DataType *get_ptr() const
    {
        return reinterpret_cast<_DataType *>(aux_ptr);
    }

    void copy_data_back() const
    {
        if (verbose) {
            std::cerr << "DPNPC_ptr_converter::copy_data_back:"
                      << " from=" << aux_ptr << " to=" << orig_ptr
                      << " size_in_bytes=" << size_in_bytes << std::endl;
        }

        dpnp_memory_memcpy_c(queue_ref, orig_ptr, aux_ptr, size_in_bytes);
    }

    void depends_on(const std::vector<sycl::event> &new_deps)
    {
        assert(allocated);
        deps.insert(std::end(deps), std::begin(new_deps), std::end(new_deps));
    }

    void depends_on(const sycl::event &new_dep)
    {
        assert(allocated);
        deps.push_back(new_dep);
    }
};

#endif // DPNP_MEMORY_ADAPTER_H

1	//*****************************************************************************
2	// Copyright (c) 2016-2024, Intel Corporation
3	// All rights reserved.
4	//
5	// Redistribution and use in source and binary forms, with or without
6	// modification, are permitted provided that the following conditions are met:
7	// - Redistributions of source code must retain the above copyright notice,
8	// this list of conditions and the following disclaimer.
9	// - Redistributions in binary form must reproduce the above copyright notice,
10	// this list of conditions and the following disclaimer in the documentation
11	// and/or other materials provided with the distribution.
12	//
13	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
14	// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16	// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
17	// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18	// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19	// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20	// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21	// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22	// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23	// THE POSSIBILITY OF SUCH DAMAGE.
24	//*****************************************************************************
25
26	#pragma once
27	#ifndef DPNP_MEMORY_ADAPTER_H // Cython compatibility
28	#define DPNP_MEMORY_ADAPTER_H
29
30	#include "dpnp_utils.hpp"
31	#include "queue_sycl.hpp"
32
33	/**
34	* @ingroup BACKEND_UTILS
35	* @brief Adapter for the memory given by parameters in the DPNPC functions
36	*
37	* This type should be used to accommodate memory in the function. For example,
38	* if the kernel must be executed in "queue_1" which is host based, but
39	* input arrays are located on other "queue_2" or unknown place.
40	*
41	* Also, some functions completely host based and has no SYCL environment.
42	*
43	*/
44	template <typename _DataType>
45	class DPNPC_ptr_adapter final
46	{
47	DPCTLSyclQueueRef queue_ref; /*< reference to SYCL queue /
48	sycl::queue queue; /*< SYCL queue /
49	void aux_ptr = nullptr; /< pointer to allocated memory by this adapter /
50	void *orig_ptr =
51	nullptr; /*< original pointer to memory given by parameters /
52	size_t size_in_bytes = 0; /*< size of bytes of the memory /
53	bool allocated = false; /**< True if the memory allocated by this procedure
54	and needs to be free */
55	bool target_no_queue = false; /**< Indicates that original memory will be
56	accessed from non SYCL environment */
57	bool copy_back = false; /**< If the memory is 'result' it needs to be copied
58	back to original */
59	const bool verbose = false;
60	std::vector<sycl::event> deps;
61
62	public:
63	DPNPC_ptr_adapter() = delete;
64
65	DPNPC_ptr_adapter(DPCTLSyclQueueRef q_ref,
66	const void *src_ptr,
67	const size_t size,
68	bool target_no_sycl = false,
69	bool copy_back_request = false)
70	{	283✔
71	queue_ref = q_ref;	283✔
72	queue = (reinterpret_cast<sycl::queue >(queue_ref));	283✔
73	target_no_queue = target_no_sycl;	283✔
74	copy_back = copy_back_request;	283✔
75	orig_ptr = const_cast<void *>(src_ptr);	283✔
76	size_in_bytes = size * sizeof(_DataType);	283✔
77	deps = std::vector<sycl::event>{};	283✔
78
79	// enum class alloc { host = 0, device = 1, shared = 2, unknown = 3 };
80	sycl::usm::alloc src_ptr_type = sycl::usm::alloc::unknown;	283✔
81	src_ptr_type = sycl::get_pointer_type(src_ptr, queue.get_context());	283✔
82	if (verbose) {	283!
83	std::cerr << "DPNPC_ptr_converter:";	×
84	std::cerr << "\n\t target_no_queue=" << target_no_queue;	×
85	std::cerr << "\n\t copy_back=" << copy_back;	×
86	std::cerr << "\n\t pointer=" << src_ptr;	×
87	std::cerr << "\n\t size=" << size;	×
88	std::cerr << "\n\t size_in_bytes=" << size_in_bytes;	×
89	std::cerr << "\n\t pointer type=" << (long)src_ptr_type;	×
90	std::cerr << "\n\t queue inorder=" << queue.is_in_order();	×
91	std::cerr << "\n\t queue device is_cpu="	×
92	<< queue.get_device().is_cpu();	×
93	std::cerr << "\n\t queue device is_gpu="	×
94	<< queue.get_device().is_gpu();	×
95	std::cerr << "\n\t queue device is_accelerator="	×
96	<< queue.get_device().is_accelerator();	×
97	std::cerr << std::endl;	×
98	}	×
99
100	if (is_memcpy_required(src_ptr_type)) {	283!
101	aux_ptr = dpnp_memory_alloc_c(queue_ref, size_in_bytes);	262✔
102	dpnp_memory_memcpy_c(queue_ref, aux_ptr, src_ptr, size_in_bytes);	262✔
103	allocated = true;	262✔
104	if (verbose) {	262!
105	std::cerr << "DPNPC_ptr_converter::alloc and copy memory"	×
106	<< " from=" << src_ptr << " to=" << aux_ptr	×
107	<< " size_in_bytes=" << size_in_bytes << std::endl;	×
108	}	×
109	}	262✔
110	else {	21✔
111	aux_ptr = const_cast<void *>(src_ptr);	21✔
112	}	21✔
113	}	283✔
114
115	~DPNPC_ptr_adapter()
116	{	283✔
117	if (allocated) {	283!
118	if (verbose) {	262!
119	std::cerr << "DPNPC_ptr_converter::free_memory at=" << aux_ptr	×
120	<< std::endl;	×
121	}	×
122
123	sycl::event::wait(deps);	262✔
124
125	if (copy_back) {	262!
126	copy_data_back();	108✔
127	}	108✔
128
129	dpnp_memory_free_c(queue_ref, aux_ptr);	262✔
130	}	262✔
131	}	283✔
132
133	bool is_memcpy_required(sycl::usm::alloc src_ptr_type)
134	{	283✔
135	if (target_no_queue \|\| queue.get_device().is_gpu()) {	283!
136	if (src_ptr_type == sycl::usm::alloc::unknown) {	262!
UNCOV 137	return true;	×
UNCOV 138	}	×
139	else if (target_no_queue &&	262!
140	src_ptr_type == sycl::usm::alloc::device) {	262!
141	return true;	262✔
142	}	262✔
143	}	262✔
144
145	return false;	21✔
146	}	283✔
147
148	_DataType *get_ptr() const
149	{	283✔
150	return reinterpret_cast<_DataType *>(aux_ptr);	283✔
151	}	283✔
152
153	void copy_data_back() const
154	{	108✔
155	if (verbose) {	108!
156	std::cerr << "DPNPC_ptr_converter::copy_data_back:"	×
157	<< " from=" << aux_ptr << " to=" << orig_ptr	×
158	<< " size_in_bytes=" << size_in_bytes << std::endl;	×
159	}	×
160
161	dpnp_memory_memcpy_c(queue_ref, orig_ptr, aux_ptr, size_in_bytes);	108✔
162	}	108✔
163
164	void depends_on(const std::vector<sycl::event> &new_deps)
165	{
166	assert(allocated);
167	deps.insert(std::end(deps), std::begin(new_deps), std::end(new_deps));
168	}
169
170	void depends_on(const sycl::event &new_dep)
171	{	12✔
172	assert(allocated);
173	deps.push_back(new_dep);	12✔
174	}	12✔
175	};
176
177	#endif // DPNP_MEMORY_ADAPTER_H

IntelPython / dpnp / 12039103271

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