Skip to content

Commit baa805f

Browse files
steffenlarsensteffenlarsen
committed
Adjust for UR changes
Signed-off-by: Larsen, Steffen <[email protected]>
1 parent 29cbc37 commit baa805f

File tree

6 files changed

+74
-125
lines changed

6 files changed

+74
-125
lines changed

‎sycl/doc/extensions/experimental/sycl_ext_oneapi_inter_process_communication.asciidoc‎

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -107,14 +107,17 @@ in the SYCL 2020 specification.
107107

108108
```
109109
namespace sycl::ext::oneapi::experimental {
110+
using ipc_memory_handle_data_t = span<char, sycl::dynamic_extent>;
110111

111112
class ipc_memory {
112113
public:
113114
ipc_memory(void *ptr, sycl::context &ctx);
114-
ipc_memory(span<const char, sycl::dynamic_extent> ipc_memory_handle_data,
115-
const sycl::context &ctx, const sycl::device &dev);
116115

117-
span<const char, sycl::dynamic_extent> get_handle_data() const;
116+
static void *open(ipc_memory_handle_data_t ipc_memory_handle_data,
117+
const sycl::context &ctx, const sycl::device &dev);
118+
static void close(void *ptr, const sycl::context &ctx);
119+
120+
ipc_memory_handle_data_t get_handle_data() const;
118121

119122
void *get_ptr() const;
120123
};

‎sycl/include/sycl/ext/oneapi/experimental/ipc_memory.hpp‎

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -26,14 +26,18 @@ class ipc_memory_impl;
2626
}
2727

2828
namespace ext::oneapi::experimental {
29+
using ipc_memory_handle_data_t = span<char, sycl::dynamic_extent>;
30+
2931
class __SYCL_EXPORT ipc_memory
3032
: public sycl::detail::OwnerLessBase<ipc_memory> {
3133
public:
3234
ipc_memory(void *Ptr, const sycl::context &Ctx);
33-
ipc_memory(const span<const char, sycl::dynamic_extent> IPCMemoryHandleData,
34-
const sycl::context &Ctx, const sycl::device &Dev);
3535

36-
sycl::span<const char, sycl::dynamic_extent> get_handle_data() const;
36+
static void *open(ipc_memory_handle_data_t IPCMemoryHandleData,
37+
const sycl::context &Ctx, const sycl::device &Dev);
38+
static void close(void *Ptr, const sycl::context &Ctx);
39+
40+
ipc_memory_handle_data_t get_handle_data() const;
3741

3842
void *get_ptr() const;
3943

‎sycl/source/detail/ipc_memory_impl.hpp‎

Lines changed: 9 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@
1111
#include <detail/context_impl.hpp>
1212
#include <detail/device_impl.hpp>
1313
#include <sycl/detail/defines_elementary.hpp>
14-
#include <sycl/sycl_span.hpp>
14+
#include <sycl/ext/oneapi/experimental/ipc_memory.hpp>
1515

1616
#include <memory>
1717

@@ -26,51 +26,20 @@ class ipc_memory_impl {
2626

2727
public:
2828
ipc_memory_impl(void *Ptr, const sycl::context &Ctx, private_tag)
29-
: MRelationship{HandleRelationship::Owner}, MContext{getSyclObjImpl(Ctx)},
30-
MPtr{Ptr} {
29+
: MContext{getSyclObjImpl(Ctx)}, MPtr{Ptr} {
3130
adapter_impl &Adapter = MContext->getAdapter();
3231
Adapter.call<UrApiKind::urIPCGetMemHandleExp>(MContext->getHandleRef(), Ptr,
3332
&MUrHandle);
3433
}
3534

36-
ipc_memory_impl(span<const char, sycl::dynamic_extent> IPCMemoryHandleData,
37-
const sycl::context &Ctx, const sycl::device &Dev,
38-
private_tag)
39-
: MRelationship{HandleRelationship::Adopted},
40-
MContext{getSyclObjImpl(Ctx)} {
41-
adapter_impl &Adapter = MContext->getAdapter();
42-
43-
// First recreate the IPC handle.
44-
ur_result_t UrRes =
45-
Adapter.call_nocheck<UrApiKind::urIPCCreateMemHandleFromDataExp>(
46-
MContext->getHandleRef(), getSyclObjImpl(Dev)->getHandleRef(),
47-
IPCMemoryHandleData.data(), IPCMemoryHandleData.size(), &MUrHandle);
48-
if (UrRes == UR_RESULT_ERROR_INVALID_VALUE)
49-
throw sycl::exception(sycl::make_error_code(errc::invalid),
50-
"IPCMemoryHandleData data size does not correspond "
51-
"to the target platform's IPC memory handle size.");
52-
Adapter.checkUrResult(UrRes);
53-
54-
// Then open it and retrieve the pointer.
55-
Adapter.call<UrApiKind::urIPCOpenMemHandleExp>(MContext->getHandleRef(),
56-
MUrHandle, &MPtr);
57-
}
58-
5935
ipc_memory_impl(const ipc_memory_impl &) = delete;
6036
ipc_memory_impl(ipc_memory_impl &&) = default;
6137

6238
~ipc_memory_impl() {
6339
try {
6440
adapter_impl &Adapter = MContext->getAdapter();
65-
if (MRelationship == HandleRelationship::Owner) {
66-
Adapter.call_nocheck<UrApiKind::urIPCPutMemHandleExp>(
67-
MContext->getHandleRef(), MUrHandle);
68-
} else {
69-
Adapter.call_nocheck<UrApiKind::urIPCCloseMemHandleExp>(
70-
MContext->getHandleRef(), MPtr);
71-
Adapter.call_nocheck<UrApiKind::urIPCDestroyMemHandleExp>(
72-
MContext->getHandleRef(), MUrHandle);
73-
}
41+
Adapter.call_nocheck<UrApiKind::urIPCPutMemHandleExp>(
42+
MContext->getHandleRef(), MUrHandle);
7443
} catch (std::exception &e) {
7544
__SYCL_REPORT_EXCEPTION_TO_STREAM("exception in ~ipc_memory_impl", e);
7645
}
@@ -85,20 +54,20 @@ class ipc_memory_impl {
8554
private_tag{});
8655
}
8756

88-
sycl::span<const char, sycl::dynamic_extent> get_handle_data() const {
57+
sycl::ext::oneapi::experimental::ipc_memory_handle_data_t
58+
get_handle_data() const {
8959
adapter_impl &Adapter = MContext->getAdapter();
90-
const void *HandleDataPtr = nullptr;
60+
void *HandleDataPtr = nullptr;
9161
size_t HandleDataSize = 0;
9262
Adapter.call<UrApiKind::urIPCGetMemHandleDataExp>(
9363
MContext->getHandleRef(), MUrHandle, &HandleDataPtr, &HandleDataSize);
94-
return sycl::span<const char, sycl::dynamic_extent>{
95-
reinterpret_cast<const char *>(HandleDataPtr), HandleDataSize};
64+
return sycl::span<char, sycl::dynamic_extent>{
65+
reinterpret_cast<char *>(HandleDataPtr), HandleDataSize};
9666
}
9767

9868
void *get_ptr() const { return MPtr; }
9969

10070
private:
101-
enum class HandleRelationship { Owner, Adopted } MRelationship;
10271
std::shared_ptr<context_impl> MContext;
10372
void *MPtr = nullptr;
10473
ur_exp_ipc_mem_handle_t MUrHandle = nullptr;

‎sycl/source/ipc_memory.cpp‎

Lines changed: 27 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,8 @@
66
//
77
//===----------------------------------------------------------------------===//
88

9+
#include <detail/adapter_impl.hpp>
10+
#include <detail/context_impl.hpp>
911
#include <detail/ipc_memory_impl.hpp>
1012
#include <sycl/context.hpp>
1113
#include <sycl/ext/oneapi/experimental/ipc_memory.hpp>
@@ -17,12 +19,32 @@ namespace ext::oneapi::experimental {
1719
ipc_memory::ipc_memory(void *Ptr, const sycl::context &Ctx)
1820
: impl(detail::ipc_memory_impl::create(Ptr, Ctx)) {}
1921

20-
ipc_memory::ipc_memory(
21-
span<const char, sycl::dynamic_extent> IPCMemoryHandleData,
22-
const sycl::context &Ctx, const sycl::device &Dev)
23-
: impl(detail::ipc_memory_impl::create(IPCMemoryHandleData, Ctx, Dev)) {}
22+
void *ipc_memory::open(ipc_memory_handle_data_t IPCMemoryHandleData,
23+
const sycl::context &Ctx, const sycl::device &Dev) {
24+
auto CtxImpl = sycl::detail::getSyclObjImpl(Ctx);
25+
sycl::detail::adapter_impl &Adapter = CtxImpl->getAdapter();
2426

25-
span<const char, sycl::dynamic_extent> ipc_memory::get_handle_data() const {
27+
void *Ptr = nullptr;
28+
ur_result_t UrRes =
29+
Adapter.call_nocheck<sycl::detail::UrApiKind::urIPCOpenMemHandleExp>(
30+
CtxImpl->getHandleRef(), getSyclObjImpl(Dev)->getHandleRef(),
31+
IPCMemoryHandleData.data(), IPCMemoryHandleData.size(), &Ptr);
32+
if (UrRes == UR_RESULT_ERROR_INVALID_VALUE)
33+
throw sycl::exception(sycl::make_error_code(errc::invalid),
34+
"IPCMemoryHandleData data size does not correspond "
35+
"to the target platform's IPC memory handle size.");
36+
Adapter.checkUrResult(UrRes);
37+
return Ptr;
38+
}
39+
40+
void ipc_memory::close(void *Ptr, const sycl::context &Ctx) {
41+
auto CtxImpl = sycl::detail::getSyclObjImpl(Ctx);
42+
sycl::detail::adapter_impl &Adapter = CtxImpl->getAdapter();
43+
Adapter.call<sycl::detail::UrApiKind::urIPCCloseMemHandleExp>(
44+
CtxImpl->getHandleRef(), Ptr);
45+
}
46+
47+
ipc_memory_handle_data_t ipc_memory::get_handle_data() const {
2648
return impl->get_handle_data();
2749
}
2850

‎sycl/test-e2e/Experimental/ipc_memory.cpp‎

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -51,8 +51,7 @@ int spawner(int argc, char *argv[]) {
5151

5252
// Write handle data to file.
5353
{
54-
sycl::span<const char, sycl::dynamic_extent> HandleData =
55-
IPCMem.get_handle_data();
54+
syclexp::ipc_memory_handle_data_t HandleData = IPCMem.get_handle_data();
5655
size_t HandleDataSize = HandleData.size();
5756
std::fstream FS(CommsFile, std::ios_base::out | std::ios_base::binary);
5857
FS.write(reinterpret_cast<const char *>(&HandleDataSize), sizeof(size_t));
@@ -89,11 +88,10 @@ int consumer() {
8988
std::unique_ptr<char[]> HandleData{new char[HandleSize]};
9089
FS.read(HandleData.get(), HandleSize);
9190

92-
// Re-create the IPC handle.
93-
sycl::span<const char, sycl::dynamic_extent> Handle{HandleData.get(),
94-
HandleSize};
95-
syclexp::ipc_memory IPCMem{Handle, Q.get_context(), Q.get_device()};
96-
int *DataPtr = reinterpret_cast<int *>(IPCMem.get_ptr());
91+
// Open IPC handle.
92+
syclexp::ipc_memory_handle_data_t Handle{HandleData.get(), HandleSize};
93+
int *DataPtr = reinterpret_cast<int *>(
94+
syclexp::ipc_memory::open(Handle, Q.get_context(), Q.get_device()));
9795

9896
// Test the data already in the USM pointer.
9997
// TODO: This is currently disabled for L0 due to a bug in the original data
@@ -115,6 +113,9 @@ int consumer() {
115113
DataPtr[I] = static_cast<int>(N - I.get_linear_id());
116114
}).wait();
117115

116+
// Close the IPC pointer.
117+
syclexp::ipc_memory::close(DataPtr, Q.get_context());
118+
118119
return Failures;
119120
}
120121

‎sycl/unittests/Extensions/IPC.cpp‎

Lines changed: 17 additions & 67 deletions
Original file line numberDiff line numberDiff line change
@@ -32,8 +32,6 @@ thread_local int urIPCGetMemHandleExp_counter = 0;
3232
thread_local int urIPCPutMemHandleExp_counter = 0;
3333
thread_local int urIPCOpenMemHandleExp_counter = 0;
3434
thread_local int urIPCCloseMemHandleExp_counter = 0;
35-
thread_local int urIPCCreateMemHandleFromDataExp_counter = 0;
36-
thread_local int urIPCDestroyMemHandleExp_counter = 0;
3735
thread_local int urIPCGetMemHandleDataExp_counter = 0;
3836

3937
ur_result_t replace_urIPCGetMemHandleExp(void *pParams) {
@@ -54,7 +52,8 @@ ur_result_t replace_urIPCPutMemHandleExp(void *pParams) {
5452
ur_result_t replace_urIPCOpenMemHandleExp(void *pParams) {
5553
++urIPCOpenMemHandleExp_counter;
5654
auto params = *static_cast<ur_ipc_open_mem_handle_exp_params_t *>(pParams);
57-
EXPECT_EQ(*params.phIPCMem, DummyMemHandle);
55+
EXPECT_EQ(*params.pipcMemHandleData, DummyHandleData);
56+
EXPECT_EQ(*params.pipcMemHandleDataSize, DummyHandleDataSize);
5857
**params.pppMem = DummyPtr;
5958
return UR_RESULT_SUCCESS;
6059
}
@@ -66,23 +65,6 @@ ur_result_t replace_urIPCCloseMemHandleExp(void *pParams) {
6665
return UR_RESULT_SUCCESS;
6766
}
6867

69-
ur_result_t replace_urIPCCreateMemHandleFromDataExp(void *pParams) {
70-
++urIPCCreateMemHandleFromDataExp_counter;
71-
auto params =
72-
*static_cast<ur_ipc_create_mem_handle_from_data_exp_params_t *>(pParams);
73-
EXPECT_EQ(*params.pipcMemHandleData, DummyHandleData);
74-
EXPECT_EQ(*params.pipcMemHandleDataSize, DummyHandleDataSize);
75-
**params.pphIPCMem = DummyMemHandle;
76-
return UR_RESULT_SUCCESS;
77-
}
78-
79-
ur_result_t replace_urIPCDestroyMemHandleExp(void *pParams) {
80-
++urIPCDestroyMemHandleExp_counter;
81-
auto params = *static_cast<ur_ipc_destroy_mem_handle_exp_params_t *>(pParams);
82-
EXPECT_EQ(*params.phIPCMem, DummyMemHandle);
83-
return UR_RESULT_SUCCESS;
84-
}
85-
8668
ur_result_t replace_urIPCGetMemHandleDataExp(void *pParams) {
8769
++urIPCGetMemHandleDataExp_counter;
8870
auto params =
@@ -103,8 +85,6 @@ class IPCTests : public ::testing::Test {
10385
urIPCPutMemHandleExp_counter = 0;
10486
urIPCOpenMemHandleExp_counter = 0;
10587
urIPCCloseMemHandleExp_counter = 0;
106-
urIPCCreateMemHandleFromDataExp_counter = 0;
107-
urIPCDestroyMemHandleExp_counter = 0;
10888
urIPCGetMemHandleDataExp_counter = 0;
10989

11090
mock::getCallbacks().set_replace_callback("urIPCGetMemHandleExp",
@@ -115,11 +95,6 @@ class IPCTests : public ::testing::Test {
11595
replace_urIPCOpenMemHandleExp);
11696
mock::getCallbacks().set_replace_callback("urIPCCloseMemHandleExp",
11797
replace_urIPCCloseMemHandleExp);
118-
mock::getCallbacks().set_replace_callback(
119-
"urIPCCreateMemHandleFromDataExp",
120-
replace_urIPCCreateMemHandleFromDataExp);
121-
mock::getCallbacks().set_replace_callback("urIPCDestroyMemHandleExp",
122-
replace_urIPCDestroyMemHandleExp);
12398
mock::getCallbacks().set_replace_callback("urIPCGetMemHandleDataExp",
12499
replace_urIPCGetMemHandleDataExp);
125100
}
@@ -137,11 +112,9 @@ TEST_F(IPCTests, IPCGetPut) {
137112
EXPECT_EQ(urIPCPutMemHandleExp_counter, 0);
138113
EXPECT_EQ(urIPCOpenMemHandleExp_counter, 0);
139114
EXPECT_EQ(urIPCCloseMemHandleExp_counter, 0);
140-
EXPECT_EQ(urIPCCreateMemHandleFromDataExp_counter, 0);
141-
EXPECT_EQ(urIPCDestroyMemHandleExp_counter, 0);
142115
EXPECT_EQ(urIPCGetMemHandleDataExp_counter, 0);
143116

144-
sycl::span<const char, sycl::dynamic_extent> IPCMemHandleData =
117+
syclexp::ipc_memory_handle_data_t IPCMemHandleData =
145118
IPCMem.get_handle_data();
146119
EXPECT_EQ(IPCMemHandleData.data(), DummyHandleData);
147120
EXPECT_EQ(IPCMemHandleData.size(), DummyHandleDataSize);
@@ -151,8 +124,6 @@ TEST_F(IPCTests, IPCGetPut) {
151124
EXPECT_EQ(urIPCPutMemHandleExp_counter, 0);
152125
EXPECT_EQ(urIPCOpenMemHandleExp_counter, 0);
153126
EXPECT_EQ(urIPCCloseMemHandleExp_counter, 0);
154-
EXPECT_EQ(urIPCCreateMemHandleFromDataExp_counter, 0);
155-
EXPECT_EQ(urIPCDestroyMemHandleExp_counter, 0);
156127
EXPECT_EQ(urIPCGetMemHandleDataExp_counter, 1);
157128
}
158129

@@ -162,52 +133,31 @@ TEST_F(IPCTests, IPCGetPut) {
162133
EXPECT_EQ(urIPCPutMemHandleExp_counter, 1);
163134
EXPECT_EQ(urIPCOpenMemHandleExp_counter, 0);
164135
EXPECT_EQ(urIPCCloseMemHandleExp_counter, 0);
165-
EXPECT_EQ(urIPCCreateMemHandleFromDataExp_counter, 0);
166-
EXPECT_EQ(urIPCDestroyMemHandleExp_counter, 0);
167136
EXPECT_EQ(urIPCGetMemHandleDataExp_counter, 1);
168137
}
169138

170139
TEST_F(IPCTests, IPCOpenClose) {
171-
{
172-
sycl::span<const char, sycl::dynamic_extent> HandleData{
173-
DummyHandleData, DummyHandleDataSize};
174-
syclexp::ipc_memory IPCMem{HandleData, Ctxt, Ctxt.get_devices()[0]};
175-
EXPECT_EQ(IPCMem.get_ptr(), DummyPtr);
176-
177-
// Creating the IPC memory from handle data should first re-create the
178-
// handle and then call open on it.
179-
EXPECT_EQ(urIPCGetMemHandleExp_counter, 0);
180-
EXPECT_EQ(urIPCPutMemHandleExp_counter, 0);
181-
EXPECT_EQ(urIPCOpenMemHandleExp_counter, 1);
182-
EXPECT_EQ(urIPCCloseMemHandleExp_counter, 0);
183-
EXPECT_EQ(urIPCCreateMemHandleFromDataExp_counter, 1);
184-
EXPECT_EQ(urIPCDestroyMemHandleExp_counter, 0);
185-
EXPECT_EQ(urIPCGetMemHandleDataExp_counter, 0);
140+
syclexp::ipc_memory_handle_data_t HandleData{DummyHandleData,
141+
DummyHandleDataSize};
142+
void *Ptr =
143+
syclexp::ipc_memory::open(HandleData, Ctxt, Ctxt.get_devices()[0]);
144+
EXPECT_EQ(Ptr, DummyPtr);
186145

187-
sycl::span<const char, sycl::dynamic_extent> IPCMemHandleData =
188-
IPCMem.get_handle_data();
189-
EXPECT_EQ(IPCMemHandleData.data(), DummyHandleData);
190-
EXPECT_EQ(IPCMemHandleData.size(), DummyHandleDataSize);
146+
// Opening an IPC handle should call open.
147+
EXPECT_EQ(urIPCGetMemHandleExp_counter, 0);
148+
EXPECT_EQ(urIPCPutMemHandleExp_counter, 0);
149+
EXPECT_EQ(urIPCOpenMemHandleExp_counter, 1);
150+
EXPECT_EQ(urIPCCloseMemHandleExp_counter, 0);
151+
EXPECT_EQ(urIPCGetMemHandleDataExp_counter, 0);
191152

192-
// Getting the underlying data should call the backend.
193-
EXPECT_EQ(urIPCGetMemHandleExp_counter, 0);
194-
EXPECT_EQ(urIPCPutMemHandleExp_counter, 0);
195-
EXPECT_EQ(urIPCOpenMemHandleExp_counter, 1);
196-
EXPECT_EQ(urIPCCloseMemHandleExp_counter, 0);
197-
EXPECT_EQ(urIPCCreateMemHandleFromDataExp_counter, 1);
198-
EXPECT_EQ(urIPCDestroyMemHandleExp_counter, 0);
199-
EXPECT_EQ(urIPCGetMemHandleDataExp_counter, 1);
200-
}
153+
syclexp::ipc_memory::close(Ptr, Ctxt);
201154

202-
// When the IPC memory object dies, it should release the handle, calling
203-
// "close" and then destroying it.
155+
// When we close an IPC memory pointer, it should call close.
204156
EXPECT_EQ(urIPCGetMemHandleExp_counter, 0);
205157
EXPECT_EQ(urIPCPutMemHandleExp_counter, 0);
206158
EXPECT_EQ(urIPCOpenMemHandleExp_counter, 1);
207159
EXPECT_EQ(urIPCCloseMemHandleExp_counter, 1);
208-
EXPECT_EQ(urIPCCreateMemHandleFromDataExp_counter, 1);
209-
EXPECT_EQ(urIPCDestroyMemHandleExp_counter, 1);
210-
EXPECT_EQ(urIPCGetMemHandleDataExp_counter, 1);
160+
EXPECT_EQ(urIPCGetMemHandleDataExp_counter, 0);
211161
}
212162

213163
} // namespace

0 commit comments

Comments
 (0)