This is an archive of the discontinued LLVM Phabricator instance.

Differential D24172

[StreamExecutor] Pass device memory by ref
ClosedPublic

Authored by jhen on Sep 1 2016, 4:43 PM.

Details

Reviewers
jlebar
Commits
rGc15c9ebb1d51: [StreamExecutor] Pass device memory by ref
rL280439: [StreamExecutor] Pass device memory by ref
Summary

Step 3 of getting GlobalDeviceMemory to own its handle.

Since GlobalDeviceMemory will no longer by copy-constructible, we must
pass instances by reference rather than by value.

Diff Detail

Event Timeline

jhen updated this revision to Diff 70101.Sep 1 2016, 4:43 PM
jhen retitled this revision from to [StreamExecutor] Pass device memory by ref.
jhen updated this object.
jhen added a reviewer: jlebar.
jhen added subscribers: parallel_libs-commits, jprice.
jhen updated this revision to Diff 70109.Sep 1 2016, 5:13 PM
  • clang-format
jlebar added inline comments.Sep 1 2016, 5:16 PM
streamexecutor/include/streamexecutor/Device.h
223

I wonder if we should take by non-const reference. This "pass mutable things by pointer" idiom is kind of a Google-ism; I am not sure it will make a lot of sense to other people reading the code.

jhen updated this revision to Diff 70112.Sep 1 2016, 5:28 PM
  • Use ref instead of pointer for dst
jlebar accepted this revision.Sep 1 2016, 5:29 PM
jlebar edited edge metadata.
This revision is now accepted and ready to land.Sep 1 2016, 5:29 PM
jhen added inline comments.Sep 1 2016, 5:29 PM
streamexecutor/include/streamexecutor/Device.h
223

Yeah, you're right. It could be confusing. I've changed all the destinations to pass-by-non-const-ref now instead of pass-by-pointer.

Closed by commit rL280439: [StreamExecutor] Pass device memory by ref (authored by jhen). · Explain WhySep 1 2016, 5:34 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
streamexecutor/
include/
streamexecutor/
42 lines
2 lines
41 lines
lib/
unittests/
52 lines
34 lines

Diff 70101

streamexecutor/include/streamexecutor/Device.h

Show First 20 Lines • Show All 159 Lines • ▼ Show 20 Linespublic:
template <typename T> template <typename T>
Error synchronousCopyD2H(GlobalDeviceMemorySlice<T> Src, T *Dst, Error synchronousCopyD2H(GlobalDeviceMemorySlice<T> Src, T *Dst,
size_t ElementCount) { size_t ElementCount) {
return synchronousCopyD2H(Src, llvm::MutableArrayRef<T>(Dst, ElementCount), return synchronousCopyD2H(Src, llvm::MutableArrayRef<T>(Dst, ElementCount),
ElementCount); ElementCount);
} }
template <typename T> template <typename T>
Error synchronousCopyD2H(GlobalDeviceMemory<T> Src, Error synchronousCopyD2H(const GlobalDeviceMemory<T> &Src,
llvm::MutableArrayRef<T> Dst, size_t ElementCount) { llvm::MutableArrayRef<T> Dst, size_t ElementCount) {
return synchronousCopyD2H(Src.asSlice(), Dst, ElementCount); return synchronousCopyD2H(Src.asSlice(), Dst, ElementCount);
} }
template <typename T> template <typename T>
Error synchronousCopyD2H(GlobalDeviceMemory<T> Src, Error synchronousCopyD2H(const GlobalDeviceMemory<T> &Src,
llvm::MutableArrayRef<T> Dst) { llvm::MutableArrayRef<T> Dst) {
return synchronousCopyD2H(Src.asSlice(), Dst); return synchronousCopyD2H(Src.asSlice(), Dst);
} }
template <typename T> template <typename T>
Error synchronousCopyD2H(GlobalDeviceMemory<T> Src, T *Dst, Error synchronousCopyD2H(const GlobalDeviceMemory<T> &Src, T *Dst,
size_t ElementCount) { size_t ElementCount) {
return synchronousCopyD2H(Src.asSlice(), Dst, ElementCount); return synchronousCopyD2H(Src.asSlice(), Dst, ElementCount);
} }
template <typename T> template <typename T>
Error synchronousCopyH2D(llvm::ArrayRef<T> Src, Error synchronousCopyH2D(llvm::ArrayRef<T> Src,
GlobalDeviceMemorySlice<T> Dst, GlobalDeviceMemorySlice<T> Dst,
size_t ElementCount) { size_t ElementCount) {
Show All 26 Linespublic:
template <typename T> template <typename T>
Error synchronousCopyH2D(T *Src, GlobalDeviceMemorySlice<T> Dst, Error synchronousCopyH2D(T *Src, GlobalDeviceMemorySlice<T> Dst,
size_t ElementCount) { size_t ElementCount) {
return synchronousCopyH2D(llvm::ArrayRef<T>(Src, ElementCount), Dst, return synchronousCopyH2D(llvm::ArrayRef<T>(Src, ElementCount), Dst,
ElementCount); ElementCount);
} }
template <typename T> template <typename T>
Error synchronousCopyH2D(llvm::ArrayRef<T> Src, GlobalDeviceMemory<T> Dst, Error synchronousCopyH2D(llvm::ArrayRef<T> Src, GlobalDeviceMemory<T> *Dst,
jlebarUnsubmitted
Not Done
ReplyInline Actions

I wonder if we should take by non-const reference. This "pass mutable things by pointer" idiom is kind of a Google-ism; I am not sure it will make a lot of sense to other people reading the code.

jlebar: I wonder if we should take by non-const reference. This "pass mutable things by pointer" idiom…
jhenAuthorUnsubmitted
Not Done
ReplyInline Actions

Yeah, you're right. It could be confusing. I've changed all the destinations to pass-by-non-const-ref now instead of pass-by-pointer.

jhen: Yeah, you're right. It could be confusing. I've changed all the destinations to pass-by-non…
size_t ElementCount) { size_t ElementCount) {
return synchronousCopyH2D(Src, Dst.asSlice(), ElementCount); return synchronousCopyH2D(Src, Dst->asSlice(), ElementCount);
} }
template <typename T> template <typename T>
Error synchronousCopyH2D(llvm::ArrayRef<T> Src, GlobalDeviceMemory<T> Dst) { Error synchronousCopyH2D(llvm::ArrayRef<T> Src, GlobalDeviceMemory<T> *Dst) {
return synchronousCopyH2D(Src, Dst.asSlice()); return synchronousCopyH2D(Src, Dst->asSlice());
} }
template <typename T> template <typename T>
Error synchronousCopyH2D(T *Src, GlobalDeviceMemory<T> Dst, Error synchronousCopyH2D(T *Src, GlobalDeviceMemory<T> *Dst,
size_t ElementCount) { size_t ElementCount) {
return synchronousCopyH2D(Src, Dst.asSlice(), ElementCount); return synchronousCopyH2D(Src, Dst->asSlice(), ElementCount);
} }
template <typename T> template <typename T>
Error synchronousCopyD2D(GlobalDeviceMemorySlice<T> Src, Error synchronousCopyD2D(GlobalDeviceMemorySlice<T> Src,
GlobalDeviceMemorySlice<T> Dst, GlobalDeviceMemorySlice<T> Dst,
size_t ElementCount) { size_t ElementCount) {
if (ElementCount > Src.getElementCount()) if (ElementCount > Src.getElementCount())
return make_error("copying too many elements, " + return make_error("copying too many elements, " +
Show All 19 Lines if (Src.getElementCount() != Dst.getElementCount())
"array size mismatch for D2D, device source has element count " + "array size mismatch for D2D, device source has element count " +
llvm::Twine(Src.getElementCount()) + llvm::Twine(Src.getElementCount()) +
" but device destination has element count " + " but device destination has element count " +
llvm::Twine(Dst.getElementCount())); llvm::Twine(Dst.getElementCount()));
return synchronousCopyD2D(Src, Dst, Src.getElementCount()); return synchronousCopyD2D(Src, Dst, Src.getElementCount());
} }
template <typename T> template <typename T>
Error synchronousCopyD2D(GlobalDeviceMemory<T> Src, Error synchronousCopyD2D(const GlobalDeviceMemory<T> &Src,
GlobalDeviceMemorySlice<T> Dst, GlobalDeviceMemorySlice<T> Dst,
size_t ElementCount) { size_t ElementCount) {
return synchronousCopyD2D(Src.asSlice(), Dst, ElementCount); return synchronousCopyD2D(Src.asSlice(), Dst, ElementCount);
} }
template <typename T> template <typename T>
Error synchronousCopyD2D(GlobalDeviceMemory<T> Src, Error synchronousCopyD2D(const GlobalDeviceMemory<T> &Src,
GlobalDeviceMemorySlice<T> Dst) { GlobalDeviceMemorySlice<T> Dst) {
return synchronousCopyD2D(Src.asSlice(), Dst); return synchronousCopyD2D(Src.asSlice(), Dst);
} }
template <typename T> template <typename T>
Error synchronousCopyD2D(GlobalDeviceMemorySlice<T> Src, Error synchronousCopyD2D(GlobalDeviceMemorySlice<T> Src,
GlobalDeviceMemory<T> Dst, size_t ElementCount) { GlobalDeviceMemory<T> *Dst, size_t ElementCount) {
return synchronousCopyD2D(Src, Dst.asSlice(), ElementCount); return synchronousCopyD2D(Src, Dst->asSlice(), ElementCount);
} }
template <typename T> template <typename T>
Error synchronousCopyD2D(GlobalDeviceMemorySlice<T> Src, Error synchronousCopyD2D(GlobalDeviceMemorySlice<T> Src,
GlobalDeviceMemory<T> Dst) { GlobalDeviceMemory<T> *Dst) {
return synchronousCopyD2D(Src, Dst.asSlice()); return synchronousCopyD2D(Src, Dst->asSlice());
} }
template <typename T> template <typename T>
Error synchronousCopyD2D(GlobalDeviceMemory<T> Src, GlobalDeviceMemory<T> Dst, Error synchronousCopyD2D(const GlobalDeviceMemory<T> &Src,
size_t ElementCount) { GlobalDeviceMemory<T> *Dst, size_t ElementCount) {
return synchronousCopyD2D(Src.asSlice(), Dst.asSlice(), ElementCount); return synchronousCopyD2D(Src.asSlice(), Dst->asSlice(), ElementCount);
} }
template <typename T> template <typename T>
Error synchronousCopyD2D(GlobalDeviceMemory<T> Src, Error synchronousCopyD2D(const GlobalDeviceMemory<T> &Src,
GlobalDeviceMemory<T> Dst) { GlobalDeviceMemory<T> *Dst) {
return synchronousCopyD2D(Src.asSlice(), Dst.asSlice()); return synchronousCopyD2D(Src.asSlice(), Dst->asSlice());
} }
///@} End host-synchronous device memory copying functions ///@} End host-synchronous device memory copying functions
private: private:
PlatformDevice *PDevice; PlatformDevice *PDevice;
}; };
} // namespace streamexecutor } // namespace streamexecutor
#endif // STREAMEXECUTOR_DEVICE_H #endif // STREAMEXECUTOR_DEVICE_H

streamexecutor/include/streamexecutor/DeviceMemory.h

Show First 20 Lines • Show All 186 Lines • ▼ Show 20 Linespublic:
/// Copy-assignable like a pointer. /// Copy-assignable like a pointer.
GlobalDeviceMemory &operator=(const GlobalDeviceMemory &) = default; GlobalDeviceMemory &operator=(const GlobalDeviceMemory &) = default;
/// Returns the number of elements of type ElemT that constitute this /// Returns the number of elements of type ElemT that constitute this
/// allocation. /// allocation.
size_t getElementCount() const { return getByteCount() / sizeof(ElemT); } size_t getElementCount() const { return getByteCount() / sizeof(ElemT); }
/// Converts this memory object into a slice. /// Converts this memory object into a slice.
GlobalDeviceMemorySlice<ElemT> asSlice() { GlobalDeviceMemorySlice<ElemT> asSlice() const {
return GlobalDeviceMemorySlice<ElemT>(*this); return GlobalDeviceMemorySlice<ElemT>(*this);
} }
private: private:
/// Constructs a GlobalDeviceMemory instance from an opaque handle and an /// Constructs a GlobalDeviceMemory instance from an opaque handle and an
/// element count. /// element count.
/// ///
/// This constructor is not public because there is a potential for confusion /// This constructor is not public because there is a potential for confusion
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

streamexecutor/include/streamexecutor/Stream.h

Show First 20 Lines • Show All 158 Lines • ▼ Show 20 Linespublic:
template <typename T> template <typename T>
Stream &thenCopyD2H(GlobalDeviceMemorySlice<T> Src, T *Dst, Stream &thenCopyD2H(GlobalDeviceMemorySlice<T> Src, T *Dst,
size_t ElementCount) { size_t ElementCount) {
thenCopyD2H(Src, llvm::MutableArrayRef<T>(Dst, ElementCount), ElementCount); thenCopyD2H(Src, llvm::MutableArrayRef<T>(Dst, ElementCount), ElementCount);
return *this; return *this;
} }
template <typename T> template <typename T>
Stream &thenCopyD2H(GlobalDeviceMemory<T> Src, llvm::MutableArrayRef<T> Dst, Stream &thenCopyD2H(const GlobalDeviceMemory<T> &Src, llvm::MutableArrayRef<T> Dst,
size_t ElementCount) { size_t ElementCount) {
thenCopyD2H(Src.asSlice(), Dst, ElementCount); thenCopyD2H(Src.asSlice(), Dst, ElementCount);
return *this; return *this;
} }
template <typename T> template <typename T>
Stream &thenCopyD2H(GlobalDeviceMemory<T> Src, llvm::MutableArrayRef<T> Dst) { Stream &thenCopyD2H(const GlobalDeviceMemory<T> &Src, llvm::MutableArrayRef<T> Dst) {
thenCopyD2H(Src.asSlice(), Dst); thenCopyD2H(Src.asSlice(), Dst);
return *this; return *this;
} }
template <typename T> template <typename T>
Stream &thenCopyD2H(GlobalDeviceMemory<T> Src, T *Dst, size_t ElementCount) { Stream &thenCopyD2H(const GlobalDeviceMemory<T> &Src, T *Dst, size_t ElementCount) {
thenCopyD2H(Src.asSlice(), Dst, ElementCount); thenCopyD2H(Src.asSlice(), Dst, ElementCount);
return *this; return *this;
} }
template <typename T> template <typename T>
Stream &thenCopyH2D(llvm::ArrayRef<T> Src, GlobalDeviceMemorySlice<T> Dst, Stream &thenCopyH2D(llvm::ArrayRef<T> Src, GlobalDeviceMemorySlice<T> Dst,
size_t ElementCount) { size_t ElementCount) {
if (ElementCount > Src.size()) if (ElementCount > Src.size())
Show All 27 Linespublic:
template <typename T> template <typename T>
Stream &thenCopyH2D(T *Src, GlobalDeviceMemorySlice<T> Dst, Stream &thenCopyH2D(T *Src, GlobalDeviceMemorySlice<T> Dst,
size_t ElementCount) { size_t ElementCount) {
thenCopyH2D(llvm::ArrayRef<T>(Src, ElementCount), Dst, ElementCount); thenCopyH2D(llvm::ArrayRef<T>(Src, ElementCount), Dst, ElementCount);
return *this; return *this;
} }
template <typename T> template <typename T>
Stream &thenCopyH2D(llvm::ArrayRef<T> Src, GlobalDeviceMemory<T> Dst, Stream &thenCopyH2D(llvm::ArrayRef<T> Src, GlobalDeviceMemory<T> *Dst,
size_t ElementCount) { size_t ElementCount) {
thenCopyH2D(Src, Dst.asSlice(), ElementCount); thenCopyH2D(Src, Dst->asSlice(), ElementCount);
return *this; return *this;
} }
template <typename T> template <typename T>
Stream &thenCopyH2D(llvm::ArrayRef<T> Src, GlobalDeviceMemory<T> Dst) { Stream &thenCopyH2D(llvm::ArrayRef<T> Src, GlobalDeviceMemory<T> *Dst) {
thenCopyH2D(Src, Dst.asSlice()); thenCopyH2D(Src, Dst->asSlice());
return *this; return *this;
} }
template <typename T> template <typename T>
Stream &thenCopyH2D(T *Src, GlobalDeviceMemory<T> Dst, size_t ElementCount) { Stream &thenCopyH2D(T *Src, GlobalDeviceMemory<T> *Dst, size_t ElementCount) {
thenCopyH2D(Src, Dst.asSlice(), ElementCount); thenCopyH2D(Src, Dst->asSlice(), ElementCount);
return *this; return *this;
} }
template <typename T> template <typename T>
Stream &thenCopyD2D(GlobalDeviceMemorySlice<T> Src, Stream &thenCopyD2D(GlobalDeviceMemorySlice<T> Src,
GlobalDeviceMemorySlice<T> Dst, size_t ElementCount) { GlobalDeviceMemorySlice<T> Dst, size_t ElementCount) {
if (ElementCount > Src.getElementCount()) if (ElementCount > Src.getElementCount())
setError("copying too many elements, " + llvm::Twine(ElementCount) + setError("copying too many elements, " + llvm::Twine(ElementCount) +
Show All 20 Lines if (Src.getElementCount() != Dst.getElementCount())
" but device destination has element count " + " but device destination has element count " +
llvm::Twine(Dst.getElementCount())); llvm::Twine(Dst.getElementCount()));
else else
thenCopyD2D(Src, Dst, Src.getElementCount()); thenCopyD2D(Src, Dst, Src.getElementCount());
return *this; return *this;
} }
template <typename T> template <typename T>
Stream &thenCopyD2D(GlobalDeviceMemory<T> Src, GlobalDeviceMemorySlice<T> Dst, Stream &thenCopyD2D(const GlobalDeviceMemory<T> &Src, GlobalDeviceMemorySlice<T> Dst,
size_t ElementCount) { size_t ElementCount) {
thenCopyD2D(Src.asSlice(), Dst, ElementCount); thenCopyD2D(Src.asSlice(), Dst, ElementCount);
return *this; return *this;
} }
template <typename T> template <typename T>
Stream &thenCopyD2D(GlobalDeviceMemory<T> Src, Stream &thenCopyD2D(const GlobalDeviceMemory<T> &Src,
GlobalDeviceMemorySlice<T> Dst) { GlobalDeviceMemorySlice<T> Dst) {
thenCopyD2D(Src.asSlice(), Dst); thenCopyD2D(Src.asSlice(), Dst);
return *this; return *this;
} }
template <typename T> template <typename T>
Stream &thenCopyD2D(GlobalDeviceMemorySlice<T> Src, GlobalDeviceMemory<T> Dst, Stream &thenCopyD2D(GlobalDeviceMemorySlice<T> Src, GlobalDeviceMemory<T> *Dst,
size_t ElementCount) { size_t ElementCount) {
thenCopyD2D(Src, Dst.asSlice(), ElementCount); thenCopyD2D(Src, Dst->asSlice(), ElementCount);
return *this; return *this;
} }
template <typename T> template <typename T>
Stream &thenCopyD2D(GlobalDeviceMemorySlice<T> Src, Stream &thenCopyD2D(GlobalDeviceMemorySlice<T> Src,
GlobalDeviceMemory<T> Dst) { GlobalDeviceMemory<T> *Dst) {
thenCopyD2D(Src, Dst.asSlice()); thenCopyD2D(Src, Dst->asSlice());
return *this; return *this;
} }
template <typename T> template <typename T>
Stream &thenCopyD2D(GlobalDeviceMemory<T> Src, GlobalDeviceMemory<T> Dst, Stream &thenCopyD2D(const GlobalDeviceMemory<T> &Src,
size_t ElementCount) { GlobalDeviceMemory<T> *Dst, size_t ElementCount) {
thenCopyD2D(Src.asSlice(), Dst.asSlice(), ElementCount); thenCopyD2D(Src.asSlice(), Dst->asSlice(), ElementCount);
return *this; return *this;
} }
template <typename T> template <typename T>
Stream &thenCopyD2D(GlobalDeviceMemory<T> Src, GlobalDeviceMemory<T> Dst) { Stream &thenCopyD2D(const GlobalDeviceMemory<T> &Src,
thenCopyD2D(Src.asSlice(), Dst.asSlice()); GlobalDeviceMemory<T> *Dst) {
thenCopyD2D(Src.asSlice(), Dst->asSlice());
return *this; return *this;
} }
///@} End device memory copying functions ///@} End device memory copying functions
private: private:
/// Sets the error state from an Error object. /// Sets the error state from an Error object.
/// ///
Show All 38 Lines

streamexecutor/lib/unittests/DeviceTest.cpp

Show First 20 Lines • Show All 185 Lines • ▼ Show 20 LinesTEST_F(DeviceTest, SyncCopyD2HSliceToPointer) {
} }
EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice(), Host7, 7)); EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice(), Host7, 7));
} }
// H2D tests // H2D tests
TEST_F(DeviceTest, SyncCopyH2DToArrayRefByCount) { TEST_F(DeviceTest, SyncCopyH2DToArrayRefByCount) {
EXPECT_NO_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5, 5)); EXPECT_NO_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), &DeviceA5, 5));
for (int I = 0; I < 5; ++I) { for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]); EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
} }
EXPECT_NO_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceB5, 2)); EXPECT_NO_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), &DeviceB5, 2));
for (int I = 0; I < 2; ++I) { for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceB5, I), Host5[I]); EXPECT_EQ(getDeviceValue(DeviceB5, I), Host5[I]);
} }
EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5, 7)); EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host7), &DeviceA5, 7));
EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7, 7)); EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), &DeviceA7, 7));
EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5, 7)); EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), &DeviceA5, 7));
} }
TEST_F(DeviceTest, SyncCopyH2DToArrayRef) { TEST_F(DeviceTest, SyncCopyH2DToArrayRef) {
EXPECT_NO_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5)); EXPECT_NO_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), &DeviceA5));
for (int I = 0; I < 5; ++I) { for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]); EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
} }
EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7)); EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), &DeviceA7));
EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5)); EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host7), &DeviceA5));
} }
TEST_F(DeviceTest, SyncCopyH2DToPointer) { TEST_F(DeviceTest, SyncCopyH2DToPointer) {
EXPECT_NO_ERROR(Device.synchronousCopyH2D(Host5, DeviceA5, 5)); EXPECT_NO_ERROR(Device.synchronousCopyH2D(Host5, &DeviceA5, 5));
for (int I = 0; I < 5; ++I) { for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]); EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
} }
EXPECT_ERROR(Device.synchronousCopyH2D(Host7, DeviceA5, 7)); EXPECT_ERROR(Device.synchronousCopyH2D(Host7, &DeviceA5, 7));
} }
TEST_F(DeviceTest, SyncCopyH2DSliceToArrayRefByCount) { TEST_F(DeviceTest, SyncCopyH2DSliceToArrayRefByCount) {
EXPECT_NO_ERROR(Device.synchronousCopyH2D( EXPECT_NO_ERROR(Device.synchronousCopyH2D(
ArrayRef<int>(Host5 + 1, 4), DeviceA5.asSlice().drop_front(1), 4)); ArrayRef<int>(Host5 + 1, 4), DeviceA5.asSlice().drop_front(1), 4));
for (int I = 1; I < 5; ++I) { for (int I = 1; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]); EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
} }
Show All 35 LinesTEST_F(DeviceTest, SyncCopyH2DSliceToPointer) {
} }
EXPECT_ERROR(Device.synchronousCopyH2D(Host7, DeviceA5.asSlice(), 7)); EXPECT_ERROR(Device.synchronousCopyH2D(Host7, DeviceA5.asSlice(), 7));
} }
// D2D tests // D2D tests
TEST_F(DeviceTest, SyncCopyD2DByCount) { TEST_F(DeviceTest, SyncCopyD2DByCount) {
EXPECT_NO_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5, 5)); EXPECT_NO_ERROR(Device.synchronousCopyD2D(DeviceA5, &DeviceB5, 5));
for (int I = 0; I < 5; ++I) { for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I)); EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
} }
EXPECT_NO_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB7, 2)); EXPECT_NO_ERROR(Device.synchronousCopyD2D(DeviceA7, &DeviceB7, 2));
for (int I = 0; I < 2; ++I) { for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I)); EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
} }
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5, 7)); EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, &DeviceB5, 7));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB5, 7)); EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7, &DeviceB5, 7));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB7, 7)); EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, &DeviceB7, 7));
} }
TEST_F(DeviceTest, SyncCopyD2D) { TEST_F(DeviceTest, SyncCopyD2D) {
EXPECT_NO_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5)); EXPECT_NO_ERROR(Device.synchronousCopyD2D(DeviceA5, &DeviceB5));
for (int I = 0; I < 5; ++I) { for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I)); EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
} }
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB5)); EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7, &DeviceB5));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB7)); EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, &DeviceB7));
} }
TEST_F(DeviceTest, SyncCopySliceD2DByCount) { TEST_F(DeviceTest, SyncCopySliceD2DByCount) {
EXPECT_NO_ERROR( EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA5.asSlice().drop_front(1), DeviceB5, 4)); Device.synchronousCopyD2D(DeviceA5.asSlice().drop_front(1), &DeviceB5, 4));
for (int I = 0; I < 4; ++I) { for (int I = 0; I < 4; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I + 1), getDeviceValue(DeviceB5, I)); EXPECT_EQ(getDeviceValue(DeviceA5, I + 1), getDeviceValue(DeviceB5, I));
} }
EXPECT_NO_ERROR( EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA7.asSlice().drop_back(1), DeviceB7, 2)); Device.synchronousCopyD2D(DeviceA7.asSlice().drop_back(1), &DeviceB7, 2));
for (int I = 0; I < 2; ++I) { for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I)); EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
} }
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5, 7)); EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5.asSlice(), &DeviceB5, 7));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB5, 7)); EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7.asSlice(), &DeviceB5, 7));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB7, 7)); EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5.asSlice(), &DeviceB7, 7));
} }
TEST_F(DeviceTest, SyncCopySliceD2D) { TEST_F(DeviceTest, SyncCopySliceD2D) {
EXPECT_NO_ERROR( EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA7.asSlice().drop_back(2), DeviceB5)); Device.synchronousCopyD2D(DeviceA7.asSlice().drop_back(2), &DeviceB5));
for (int I = 0; I < 5; ++I) { for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB5, I)); EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB5, I));
} }
EXPECT_ERROR( EXPECT_ERROR(
Device.synchronousCopyD2D(DeviceA7.asSlice().drop_front(1), DeviceB5)); Device.synchronousCopyD2D(DeviceA7.asSlice().drop_front(1), &DeviceB5));
EXPECT_ERROR( EXPECT_ERROR(
Device.synchronousCopyD2D(DeviceA5.asSlice().drop_back(1), DeviceB7)); Device.synchronousCopyD2D(DeviceA5.asSlice().drop_back(1), &DeviceB7));
} }
TEST_F(DeviceTest, SyncCopyD2DSliceByCount) { TEST_F(DeviceTest, SyncCopyD2DSliceByCount) {
EXPECT_NO_ERROR( EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice().drop_front(2), 5)); Device.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice().drop_front(2), 5));
for (int I = 0; I < 5; ++I) { for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB7, I + 2)); EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB7, I + 2));
} }
▲ Show 20 Lines • Show All 64 Lines • Show Last 20 Lines

streamexecutor/lib/unittests/StreamTest.cpp

Show First 20 Lines • Show All 154 Lines • ▼ Show 20 LinesTEST_F(StreamTest, CopyD2HSliceToPointer) {
Stream.thenCopyD2H(DeviceA5.asSlice(), Host7, 7); Stream.thenCopyD2H(DeviceA5.asSlice(), Host7, 7);
EXPECT_FALSE(Stream.isOK()); EXPECT_FALSE(Stream.isOK());
} }
// H2D tests // H2D tests
TEST_F(StreamTest, CopyH2DToArrayRefByCount) { TEST_F(StreamTest, CopyH2DToArrayRefByCount) {
Stream.thenCopyH2D(ArrayRef<int>(Host5), DeviceA5, 5); Stream.thenCopyH2D(ArrayRef<int>(Host5), &DeviceA5, 5);
EXPECT_TRUE(Stream.isOK()); EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) { for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]); EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
} }
Stream.thenCopyH2D(ArrayRef<int>(Host5), DeviceB5, 2); Stream.thenCopyH2D(ArrayRef<int>(Host5), &DeviceB5, 2);
EXPECT_TRUE(Stream.isOK()); EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) { for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceB5, I), Host5[I]); EXPECT_EQ(getDeviceValue(DeviceB5, I), Host5[I]);
} }
Stream.thenCopyH2D(ArrayRef<int>(Host7), DeviceA5, 7); Stream.thenCopyH2D(ArrayRef<int>(Host7), &DeviceA5, 7);
EXPECT_FALSE(Stream.isOK()); EXPECT_FALSE(Stream.isOK());
} }
TEST_F(StreamTest, CopyH2DToArrayRef) { TEST_F(StreamTest, CopyH2DToArrayRef) {
Stream.thenCopyH2D(ArrayRef<int>(Host5), DeviceA5); Stream.thenCopyH2D(ArrayRef<int>(Host5), &DeviceA5);
EXPECT_TRUE(Stream.isOK()); EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) { for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]); EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
} }
Stream.thenCopyH2D(ArrayRef<int>(Host7), DeviceA5); Stream.thenCopyH2D(ArrayRef<int>(Host7), &DeviceA5);
EXPECT_FALSE(Stream.isOK()); EXPECT_FALSE(Stream.isOK());
} }
TEST_F(StreamTest, CopyH2DToPointer) { TEST_F(StreamTest, CopyH2DToPointer) {
Stream.thenCopyH2D(Host5, DeviceA5, 5); Stream.thenCopyH2D(Host5, &DeviceA5, 5);
EXPECT_TRUE(Stream.isOK()); EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) { for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]); EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
} }
Stream.thenCopyH2D(Host7, DeviceA5, 7); Stream.thenCopyH2D(Host7, &DeviceA5, 7);
EXPECT_FALSE(Stream.isOK()); EXPECT_FALSE(Stream.isOK());
} }
TEST_F(StreamTest, CopyH2DSliceToArrayRefByCount) { TEST_F(StreamTest, CopyH2DSliceToArrayRefByCount) {
Stream.thenCopyH2D(ArrayRef<int>(Host5 + 1, 4), Stream.thenCopyH2D(ArrayRef<int>(Host5 + 1, 4),
DeviceA5.asSlice().drop_front(1), 4); DeviceA5.asSlice().drop_front(1), 4);
EXPECT_TRUE(Stream.isOK()); EXPECT_TRUE(Stream.isOK());
for (int I = 1; I < 5; ++I) { for (int I = 1; I < 5; ++I) {
Show All 31 LinesTEST_F(StreamTest, CopyH2DSliceToPointer) {
Stream.thenCopyH2D(Host7, DeviceA5.asSlice(), 7); Stream.thenCopyH2D(Host7, DeviceA5.asSlice(), 7);
EXPECT_FALSE(Stream.isOK()); EXPECT_FALSE(Stream.isOK());
} }
// D2D tests // D2D tests
TEST_F(StreamTest, CopyD2DByCount) { TEST_F(StreamTest, CopyD2DByCount) {
Stream.thenCopyD2D(DeviceA5, DeviceB5, 5); Stream.thenCopyD2D(DeviceA5, &DeviceB5, 5);
EXPECT_TRUE(Stream.isOK()); EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) { for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I)); EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
} }
Stream.thenCopyD2D(DeviceA7, DeviceB7, 2); Stream.thenCopyD2D(DeviceA7, &DeviceB7, 2);
EXPECT_TRUE(Stream.isOK()); EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) { for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I)); EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
} }
Stream.thenCopyD2D(DeviceA7, DeviceB5, 7); Stream.thenCopyD2D(DeviceA7, &DeviceB5, 7);
EXPECT_FALSE(Stream.isOK()); EXPECT_FALSE(Stream.isOK());
} }
TEST_F(StreamTest, CopyD2D) { TEST_F(StreamTest, CopyD2D) {
Stream.thenCopyD2D(DeviceA5, DeviceB5); Stream.thenCopyD2D(DeviceA5, &DeviceB5);
EXPECT_TRUE(Stream.isOK()); EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) { for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I)); EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
} }
Stream.thenCopyD2D(DeviceA7, DeviceB5); Stream.thenCopyD2D(DeviceA7, &DeviceB5);
EXPECT_FALSE(Stream.isOK()); EXPECT_FALSE(Stream.isOK());
} }
TEST_F(StreamTest, CopySliceD2DByCount) { TEST_F(StreamTest, CopySliceD2DByCount) {
Stream.thenCopyD2D(DeviceA5.asSlice().drop_front(1), DeviceB5, 4); Stream.thenCopyD2D(DeviceA5.asSlice().drop_front(1), &DeviceB5, 4);
EXPECT_TRUE(Stream.isOK()); EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 4; ++I) { for (int I = 0; I < 4; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I + 1), getDeviceValue(DeviceB5, I)); EXPECT_EQ(getDeviceValue(DeviceA5, I + 1), getDeviceValue(DeviceB5, I));
} }
Stream.thenCopyD2D(DeviceA7.asSlice().drop_back(1), DeviceB7, 2); Stream.thenCopyD2D(DeviceA7.asSlice().drop_back(1), &DeviceB7, 2);
EXPECT_TRUE(Stream.isOK()); EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) { for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I)); EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
} }
Stream.thenCopyD2D(DeviceA5.asSlice(), DeviceB5, 7); Stream.thenCopyD2D(DeviceA5.asSlice(), &DeviceB5, 7);
EXPECT_FALSE(Stream.isOK()); EXPECT_FALSE(Stream.isOK());
} }
TEST_F(StreamTest, CopySliceD2D) { TEST_F(StreamTest, CopySliceD2D) {
Stream.thenCopyD2D(DeviceA7.asSlice().drop_back(2), DeviceB5); Stream.thenCopyD2D(DeviceA7.asSlice().drop_back(2), &DeviceB5);
EXPECT_TRUE(Stream.isOK()); EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) { for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB5, I)); EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB5, I));
} }
Stream.thenCopyD2D(DeviceA5.asSlice().drop_back(1), DeviceB7); Stream.thenCopyD2D(DeviceA5.asSlice().drop_back(1), &DeviceB7);
EXPECT_FALSE(Stream.isOK()); EXPECT_FALSE(Stream.isOK());
} }
TEST_F(StreamTest, CopyD2DSliceByCount) { TEST_F(StreamTest, CopyD2DSliceByCount) {
Stream.thenCopyD2D(DeviceA5, DeviceB7.asSlice().drop_front(2), 5); Stream.thenCopyD2D(DeviceA5, DeviceB7.asSlice().drop_front(2), 5);
EXPECT_TRUE(Stream.isOK()); EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) { for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB7, I + 2)); EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB7, I + 2));
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines