This is an archive of the discontinued LLVM Phabricator instance.

Differential D24368

[StreamExecutor] Make SE work with an in-tree LLVM build.
ClosedPublic

Authored by jlebar on Sep 8 2016, 5:04 PM.

Details

Reviewers
jhen
Commits
rGb9e51397bfe1: [StreamExecutor] Make SE work with an in-tree LLVM build.
rL281091: [StreamExecutor] Make SE work with an in-tree LLVM build.
Summary

With these changes, we can put parallel-libs within llvm/projects and
build as normal.

This is kind of the minimal change I could figure out how to make while
still making us compatible with llvm's build system. Some things I'm
not thrilled about include:

  • The creation of a CoreTests directory (the macros really seemed to want this)
  • Pulling SimpleHostPlatformDevice.h into CoreTests. It seems to me this should live inside unittests/include, or maybe tests/include, but I didn't want to make that change in this patch.

One important piece of work that remains to be done is to make

$ ninja check-streamexecutor

run all the tests. Right now the only way I've figured out to run the
tests is

$ ninja projects/parallel-libs/streamexecutor/unittests/StreamExecutorUnitTests
$ projects/parallel-libs/streamexecutor/unittests/CoreTests/CoreTests

Diff Detail

Repository
rL LLVM

Event Timeline

jlebar updated this revision to Diff 70768.Sep 8 2016, 5:04 PM
jlebar retitled this revision from to [StreamExecutor] Make SE work with an in-tree LLVM build..
jlebar updated this object.
jlebar added a reviewer: jhen.
jlebar added subscribers: jprice, parallel_libs-commits.
Herald added a subscriber: beanz. · View Herald TranscriptSep 8 2016, 5:04 PM
jhen edited edge metadata.Sep 8 2016, 6:11 PM
streamexecutor/lib/CMakeLists.txt
2 ↗(On Diff #70768)

This breaks the standalone build because it doesn't recognize add_llvm_library.

streamexecutor/unittests/CMakeLists.txt
5 ↗(On Diff #70768)

I think add_unittest is also defined by the LLVM cmake files, so the standalone build will break here too.

jlebar added inline comments.Sep 8 2016, 6:17 PM
streamexecutor/lib/CMakeLists.txt
2 ↗(On Diff #70768)

Right.

I am not entirely hep to this jive, so I know I'm missing some stuff. But lld uses add_llvm_library, and clang uses llvm_add_library (which would have the same problem?).

So my question is whether we can't do whatever they do, and be compatible with whatever types of builds they are compatible with?

If the standalone build uses llvm's headers, can it not also use its CMake files?

Same for add_unittest.

jprice added inline comments.Sep 9 2016, 9:27 AM
streamexecutor/lib/CMakeLists.txt
2 ↗(On Diff #70768)

Looking at the Clang CMakeLists.txt, I believe the three magic lines that do this for standalone builds are these:

set(LLVM_CMAKE_PATH "${LLVM_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm")
list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_PATH}")
include(AddLLVM)

If I add these to this patch, I can successfully build SE both standalone and in-tree. Disclaimer: I'm no CMake expert.

jhen added inline comments.Sep 9 2016, 10:35 AM
streamexecutor/CMakeLists.txt
40 ↗(On Diff #70768)

I added jprice's suggested three line fix here, and it got the standalone build working:

set(LLVM_CMAKE_PATH "${LLVM_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm")
list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_PATH}")
include(AddLLVM)
streamexecutor/lib/CMakeLists.txt
2 ↗(On Diff #70768)

Those three lines work for me as well. Thanks jprice! I put in another comment to indicate exactly where I put those lines to make it work.

One downside from my standpoint is that I can't run ninja test to run the tests, I have to run the following two commands:

$ ninja unittests/StreamExecutorUnitTests
$ unittests/CoreTests/CoreTests

But we can figure that out in another patch (probably when we figure out how to support check-streamexecutor for the in-tree build), so I would say this is good to go in after those three lines are added.

jhen accepted this revision.Sep 9 2016, 10:36 AM
jhen edited edge metadata.
This revision is now accepted and ready to land.Sep 9 2016, 10:36 AM
jlebar marked 6 inline comments as done.Sep 9 2016, 2:08 PM

Thanks for all the help, folks. Submitting this now.

Closed by commit rL281091: [StreamExecutor] Make SE work with an in-tree LLVM build. (authored by jlebar). · Explain WhySep 9 2016, 2:09 PM
This revision was automatically updated to reflect the committed changes.
jprice added a comment.Sep 9 2016, 4:06 PM

I've just noticed that this patch split the Utils target into a separate installed library (libutils.a), which breaks things building against SE using streamexecutor-config.

Was this intentional? If it was, I guess it needs to be added to streamexecutor-config, but maybe also renamed to something less generic (e.g. libstreamexecutor-utils.a)?

jlebar added a comment.Sep 9 2016, 4:26 PM
In D24368#539129, @jprice wrote:

I've just noticed that this patch split the Utils target into a separate installed library (libutils.a), which breaks things building against SE using streamexecutor-config.

Was this intentional? If it was, I guess it needs to be added to streamexecutor-config, but maybe also renamed to something less generic (e.g. libstreamexecutor-utils.a)?

Hm. My intent was for the utils to be statically linked into the main static library. But clearly that didn't happen.

Jason, what if we just merged everything into one big directory (for now)?

jhen added a comment.Sep 9 2016, 4:27 PM
In D24368#539129, @jprice wrote:

I've just noticed that this patch split the Utils target into a separate installed library (libutils.a), which breaks things building against SE using streamexecutor-config.

Was this intentional? If it was, I guess it needs to be added to streamexecutor-config, but maybe also renamed to something less generic (e.g. libstreamexecutor-utils.a)?

Thanks for catching that! We could fix it in the make files, but instead I'll just put up a patch to get rid of Utils entirely. The error stuff should just be with the other stuff, and I blame myself for not fixing it up until now.

Revision Contents

PathSize
parallel-libs/
trunk/
3 lines
streamexecutor/
14 lines
lib/
24 lines
Utils/
3 lines
unittests/
41 lines
414 lines
132 lines
150 lines
148 lines
362 lines
unittests/
9 lines
CoreTests/
7 lines
414 lines
132 lines
150 lines
148 lines
362 lines

Diff 70904

parallel-libs/trunk/CMakeLists.txt

cmake_minimum_required(VERSION 3.1)
add_subdirectory(streamexecutor)

parallel-libs/trunk/streamexecutor/CMakeLists.txt

Show All 32 Lines execute_process(
COMMAND COMMAND
"${LLVM_BINARY_DIR}/bin/llvm-config" "${LLVM_BINARY_DIR}/bin/llvm-config"
--cxxflags --cxxflags
OUTPUT_VARIABLE OUTPUT_VARIABLE
LLVM_CXXFLAGS LLVM_CXXFLAGS
OUTPUT_STRIP_TRAILING_WHITESPACE) OUTPUT_STRIP_TRAILING_WHITESPACE)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LLVM_CXXFLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LLVM_CXXFLAGS}")
# Find the libraries that correspond to the LLVM components set(LLVM_CMAKE_PATH "${LLVM_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX}/cmake/llvm")
# that we wish to use list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_PATH}")
llvm_map_components_to_libnames(llvm_libs support symbolize) include(AddLLVM)
if(STREAM_EXECUTOR_UNIT_TESTS) if(STREAM_EXECUTOR_UNIT_TESTS)
enable_testing() enable_testing()
find_package(GTest REQUIRED) find_package(GTest REQUIRED)
include_directories(${GTEST_INCLUDE_DIRS}) include_directories(${GTEST_INCLUDE_DIRS})
find_package(Threads REQUIRED) find_package(Threads REQUIRED)
endif() endif()
else(NOT STREAM_EXECUTOR_STANDALONE) else(NOT STREAM_EXECUTOR_STANDALONE)
if(STREAM_EXECUTOR_UNIT_TESTS) if(STREAM_EXECUTOR_UNIT_TESTS)
include_directories( include_directories(
"${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest/include") "${LLVM_MAIN_SRC_DIR}/utils/unittest/googletest/include")
endif() endif()
endif(STREAM_EXECUTOR_STANDALONE) endif(STREAM_EXECUTOR_STANDALONE)
# Find the libraries that correspond to the LLVM components
# that we wish to use
llvm_map_components_to_libnames(llvm_libs support symbolize)
# Insist on C++ 11 features. # Insist on C++ 11 features.
set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Add warning flags. # Add warning flags.
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-unused-parameter") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wno-unused-parameter")
add_subdirectory(lib) add_subdirectory(lib)
add_subdirectory(examples) add_subdirectory(examples)
if(STREAM_EXECUTOR_UNIT_TESTS)
add_subdirectory(unittests)
endif()
if(STREAM_EXECUTOR_ENABLE_CONFIG_TOOL ) if(STREAM_EXECUTOR_ENABLE_CONFIG_TOOL )
add_subdirectory(tools/streamexecutor-config) add_subdirectory(tools/streamexecutor-config)
endif(STREAM_EXECUTOR_ENABLE_CONFIG_TOOL ) endif(STREAM_EXECUTOR_ENABLE_CONFIG_TOOL )
install(DIRECTORY include/ DESTINATION include) install(DIRECTORY include/ DESTINATION include)
if (STREAM_EXECUTOR_ENABLE_DOXYGEN) if (STREAM_EXECUTOR_ENABLE_DOXYGEN)
find_package(Doxygen REQUIRED) find_package(Doxygen REQUIRED)
Show All 11 Lines

parallel-libs/trunk/streamexecutor/lib/CMakeLists.txt

add_library( macro(add_se_library name)
utils add_llvm_library(${name} ${ARGN})
OBJECT set_target_properties(${name} PROPERTIES FOLDER "streamexecutor libraries")
Utils/Error.cpp) endmacro(add_se_library)
add_subdirectory(Utils)
add_library( add_se_library(
streamexecutor streamexecutor
$<TARGET_OBJECTS:utils>
Device.cpp Device.cpp
DeviceMemory.cpp DeviceMemory.cpp
Kernel.cpp Kernel.cpp
KernelSpec.cpp KernelSpec.cpp
PackedKernelArgumentArray.cpp PackedKernelArgumentArray.cpp
Platform.cpp Platform.cpp
PlatformDevice.cpp PlatformDevice.cpp
PlatformManager.cpp PlatformManager.cpp
Stream.cpp) Stream.cpp
target_link_libraries(streamexecutor ${llvm_libs})
install(TARGETS streamexecutor DESTINATION lib) LINK_LIBS
utils
)
if(STREAM_EXECUTOR_UNIT_TESTS) install(TARGETS streamexecutor DESTINATION lib)
add_subdirectory(unittests)
endif()

parallel-libs/trunk/streamexecutor/lib/Utils/CMakeLists.txt

add_se_library(
utils
Error.cpp)

parallel-libs/trunk/streamexecutor/lib/unittests/CMakeLists.txt

add_executable(
device_test
DeviceTest.cpp)
target_link_libraries(
device_test
streamexecutor
${GTEST_BOTH_LIBRARIES}
${CMAKE_THREAD_LIBS_INIT})
add_test(DeviceTest device_test)
add_executable(
kernel_spec_test
KernelSpecTest.cpp)
target_link_libraries(
kernel_spec_test
streamexecutor
${GTEST_BOTH_LIBRARIES}
${CMAKE_THREAD_LIBS_INIT})
add_test(KernelSpecTest kernel_spec_test)
add_executable(
packed_kernel_argument_array_test
PackedKernelArgumentArrayTest.cpp)
target_link_libraries(
packed_kernel_argument_array_test
streamexecutor
${llvm_libs}
${GTEST_BOTH_LIBRARIES}
${CMAKE_THREAD_LIBS_INIT})
add_test(PackedKernelArgumentArrayTest packed_kernel_argument_array_test)
add_executable(
stream_test
StreamTest.cpp)
target_link_libraries(
stream_test
streamexecutor
${llvm_libs}
${GTEST_BOTH_LIBRARIES}
${CMAKE_THREAD_LIBS_INIT})
add_test(StreamTest stream_test)

parallel-libs/trunk/streamexecutor/lib/unittests/DeviceTest.cpp

//===-- DeviceTest.cpp - Tests for Device ---------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file contains the unit tests for Device code.
///
//===----------------------------------------------------------------------===//
#include <cstdlib>
#include <cstring>
#include "SimpleHostPlatformDevice.h"
#include "streamexecutor/Device.h"
#include "streamexecutor/PlatformDevice.h"
#include "gtest/gtest.h"
namespace {
namespace se = ::streamexecutor;
const auto &getDeviceValue =
se::test::SimpleHostPlatformDevice::getDeviceValue<int>;
/// Test fixture to hold objects used by tests.
class DeviceTest : public ::testing::Test {
public:
DeviceTest()
: Device(&PDevice), HostA5{0, 1, 2, 3, 4}, HostB5{5, 6, 7, 8, 9},
HostA7{10, 11, 12, 13, 14, 15, 16}, HostB7{17, 18, 19, 20, 21, 22, 23},
DeviceA5(getOrDie(Device.allocateDeviceMemory<int>(5))),
DeviceB5(getOrDie(Device.allocateDeviceMemory<int>(5))),
DeviceA7(getOrDie(Device.allocateDeviceMemory<int>(7))),
DeviceB7(getOrDie(Device.allocateDeviceMemory<int>(7))),
Host5{24, 25, 26, 27, 28}, Host7{29, 30, 31, 32, 33, 34, 35} {
se::dieIfError(Device.synchronousCopyH2D<int>(HostA5, DeviceA5));
se::dieIfError(Device.synchronousCopyH2D<int>(HostB5, DeviceB5));
se::dieIfError(Device.synchronousCopyH2D<int>(HostA7, DeviceA7));
se::dieIfError(Device.synchronousCopyH2D<int>(HostB7, DeviceB7));
}
se::test::SimpleHostPlatformDevice PDevice;
se::Device Device;
// Device memory is backed by host arrays.
int HostA5[5];
int HostB5[5];
int HostA7[7];
int HostB7[7];
se::GlobalDeviceMemory<int> DeviceA5;
se::GlobalDeviceMemory<int> DeviceB5;
se::GlobalDeviceMemory<int> DeviceA7;
se::GlobalDeviceMemory<int> DeviceB7;
// Host memory to be used as actual host memory.
int Host5[5];
int Host7[7];
};
#define EXPECT_NO_ERROR(E) EXPECT_FALSE(static_cast<bool>(E))
#define EXPECT_ERROR(E) \
do { \
se::Error E__ = E; \
EXPECT_TRUE(static_cast<bool>(E__)); \
consumeError(std::move(E__)); \
} while (false)
using llvm::ArrayRef;
using llvm::MutableArrayRef;
TEST_F(DeviceTest, GetName) {
EXPECT_EQ(Device.getName(), "SimpleHostPlatformDevice");
}
TEST_F(DeviceTest, AllocateAndFreeDeviceMemory) {
se::Expected<se::GlobalDeviceMemory<int>> MaybeMemory =
Device.allocateDeviceMemory<int>(10);
EXPECT_TRUE(static_cast<bool>(MaybeMemory));
}
TEST_F(DeviceTest, AllocateAndFreeHostMemory) {
se::Expected<int *> MaybeMemory = Device.allocateHostMemory<int>(10);
EXPECT_TRUE(static_cast<bool>(MaybeMemory));
EXPECT_NO_ERROR(Device.freeHostMemory(*MaybeMemory));
}
TEST_F(DeviceTest, RegisterAndUnregisterHostMemory) {
std::vector<int> Data(10);
EXPECT_NO_ERROR(Device.registerHostMemory(Data.data(), 10));
EXPECT_NO_ERROR(Device.unregisterHostMemory(Data.data()));
}
// D2H tests
TEST_F(DeviceTest, SyncCopyD2HToMutableArrayRefByCount) {
EXPECT_NO_ERROR(
Device.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host5), 5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
EXPECT_NO_ERROR(
Device.synchronousCopyD2H(DeviceB5, MutableArrayRef<int>(Host5), 2));
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(HostB5[I], Host5[I]);
}
EXPECT_ERROR(
Device.synchronousCopyD2H(DeviceA7, MutableArrayRef<int>(Host5), 7));
EXPECT_ERROR(
Device.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host7), 7));
EXPECT_ERROR(
Device.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host5), 7));
}
TEST_F(DeviceTest, SyncCopyD2HToMutableArrayRef) {
EXPECT_NO_ERROR(
Device.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host5)));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
EXPECT_ERROR(
Device.synchronousCopyD2H(DeviceA7, MutableArrayRef<int>(Host5)));
EXPECT_ERROR(
Device.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host7)));
}
TEST_F(DeviceTest, SyncCopyD2HToPointer) {
EXPECT_NO_ERROR(Device.synchronousCopyD2H(DeviceA5, Host5, 5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5, Host7, 7));
}
TEST_F(DeviceTest, SyncCopyD2HSliceToMutableArrayRefByCount) {
EXPECT_NO_ERROR(Device.synchronousCopyD2H(
DeviceA5.asSlice().drop_front(1), MutableArrayRef<int>(Host5 + 1, 4), 4));
for (int I = 1; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
EXPECT_NO_ERROR(Device.synchronousCopyD2H(DeviceB5.asSlice().drop_back(1),
MutableArrayRef<int>(Host5), 2));
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(HostB5[I], Host5[I]);
}
EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA7.asSlice(),
MutableArrayRef<int>(Host5), 7));
EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice(),
MutableArrayRef<int>(Host7), 7));
EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice(),
MutableArrayRef<int>(Host5), 7));
}
TEST_F(DeviceTest, SyncCopyD2HSliceToMutableArrayRef) {
EXPECT_NO_ERROR(Device.synchronousCopyD2H(DeviceA7.asSlice().slice(1, 5),
MutableArrayRef<int>(Host5)));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(HostA7[I + 1], Host5[I]);
}
EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA7.asSlice().drop_back(1),
MutableArrayRef<int>(Host5)));
EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice(),
MutableArrayRef<int>(Host7)));
}
TEST_F(DeviceTest, SyncCopyD2HSliceToPointer) {
EXPECT_NO_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice().drop_front(1),
Host5 + 1, 4));
for (int I = 1; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice(), Host7, 7));
}
// H2D tests
TEST_F(DeviceTest, SyncCopyH2DToArrayRefByCount) {
EXPECT_NO_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5, 5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
EXPECT_NO_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceB5, 2));
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceB5, I), Host5[I]);
}
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), DeviceA5, 7));
}
TEST_F(DeviceTest, SyncCopyH2DToArrayRef) {
EXPECT_NO_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7));
EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5));
}
TEST_F(DeviceTest, SyncCopyH2DToPointer) {
EXPECT_NO_ERROR(Device.synchronousCopyH2D(Host5, DeviceA5, 5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
EXPECT_ERROR(Device.synchronousCopyH2D(Host7, DeviceA5, 7));
}
TEST_F(DeviceTest, SyncCopyH2DSliceToArrayRefByCount) {
EXPECT_NO_ERROR(Device.synchronousCopyH2D(
ArrayRef<int>(Host5 + 1, 4), DeviceA5.asSlice().drop_front(1), 4));
for (int I = 1; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
EXPECT_NO_ERROR(Device.synchronousCopyH2D(
ArrayRef<int>(Host5), DeviceB5.asSlice().drop_back(1), 2));
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceB5, I), Host5[I]);
}
EXPECT_ERROR(
Device.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5.asSlice(), 7));
EXPECT_ERROR(
Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7.asSlice(), 7));
EXPECT_ERROR(
Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5.asSlice(), 7));
}
TEST_F(DeviceTest, SyncCopyH2DSliceToArrayRef) {
EXPECT_NO_ERROR(
Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5.asSlice()));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
EXPECT_ERROR(
Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7.asSlice()));
EXPECT_ERROR(
Device.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5.asSlice()));
}
TEST_F(DeviceTest, SyncCopyH2DSliceToPointer) {
EXPECT_NO_ERROR(Device.synchronousCopyH2D(Host5, DeviceA5.asSlice(), 5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
EXPECT_ERROR(Device.synchronousCopyH2D(Host7, DeviceA5.asSlice(), 7));
}
// D2D tests
TEST_F(DeviceTest, SyncCopyD2DByCount) {
EXPECT_NO_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5, 5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
}
EXPECT_NO_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB7, 2));
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
}
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5, 7));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB5, 7));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB7, 7));
}
TEST_F(DeviceTest, SyncCopyD2D) {
EXPECT_NO_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
}
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB5));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB7));
}
TEST_F(DeviceTest, SyncCopySliceD2DByCount) {
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA5.asSlice().drop_front(1), DeviceB5, 4));
for (int I = 0; I < 4; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I + 1), getDeviceValue(DeviceB5, I));
}
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA7.asSlice().drop_back(1), DeviceB7, 2));
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
}
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5, 7));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB5, 7));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB7, 7));
}
TEST_F(DeviceTest, SyncCopySliceD2D) {
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA7.asSlice().drop_back(2), DeviceB5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB5, I));
}
EXPECT_ERROR(
Device.synchronousCopyD2D(DeviceA7.asSlice().drop_front(1), DeviceB5));
EXPECT_ERROR(
Device.synchronousCopyD2D(DeviceA5.asSlice().drop_back(1), DeviceB7));
}
TEST_F(DeviceTest, SyncCopyD2DSliceByCount) {
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice().drop_front(2), 5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB7, I + 2));
}
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA7, DeviceB7.asSlice().drop_back(3), 2));
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
}
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5.asSlice(), 7));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB5.asSlice(), 7));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice(), 7));
}
TEST_F(DeviceTest, SyncCopyD2DSlice) {
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice().drop_back(2)));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB7, I));
}
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB5.asSlice()));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice()));
}
TEST_F(DeviceTest, SyncCopySliceD2DSliceByCount) {
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5.asSlice(), 5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
}
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB7.asSlice(), 2));
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
}
EXPECT_ERROR(
Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5.asSlice(), 7));
EXPECT_ERROR(
Device.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB5.asSlice(), 7));
EXPECT_ERROR(
Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB7.asSlice(), 7));
}
TEST_F(DeviceTest, SyncCopySliceD2DSlice) {
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5.asSlice()));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
}
EXPECT_ERROR(
Device.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB5.asSlice()));
EXPECT_ERROR(
Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB7.asSlice()));
}
} // namespace

parallel-libs/trunk/streamexecutor/lib/unittests/KernelSpecTest.cpp

//===-- KernelSpecTest.cpp - Tests for KernelSpec -------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file contains the unit tests for the code in KernelSpec.
///
//===----------------------------------------------------------------------===//
#include "streamexecutor/KernelSpec.h"
#include "gtest/gtest.h"
namespace {
namespace se = ::streamexecutor;
TEST(CUDAPTXInMemorySpec, NoCode) {
se::CUDAPTXInMemorySpec Spec("KernelName", {});
EXPECT_EQ("KernelName", Spec.getKernelName());
EXPECT_EQ(nullptr, Spec.getCode(1, 0));
}
TEST(CUDAPTXInMemorySpec, SingleComputeCapability) {
const char *PTXCodeString = "Dummy PTX code";
se::CUDAPTXInMemorySpec Spec("KernelName", {{{1, 0}, PTXCodeString}});
EXPECT_EQ("KernelName", Spec.getKernelName());
EXPECT_EQ(PTXCodeString, Spec.getCode(1, 0));
EXPECT_EQ(nullptr, Spec.getCode(2, 0));
}
TEST(CUDAPTXInMemorySpec, TwoComputeCapabilities) {
const char *PTXCodeString10 = "Dummy PTX code 10";
const char *PTXCodeString30 = "Dummy PTX code 30";
se::CUDAPTXInMemorySpec Spec(
"KernelName", {{{1, 0}, PTXCodeString10}, {{3, 0}, PTXCodeString30}});
EXPECT_EQ("KernelName", Spec.getKernelName());
EXPECT_EQ(PTXCodeString10, Spec.getCode(1, 0));
EXPECT_EQ(PTXCodeString30, Spec.getCode(3, 0));
EXPECT_EQ(nullptr, Spec.getCode(2, 0));
}
TEST(CUDAFatbinInMemorySpec, BasicUsage) {
const char *FatbinBytes = "Dummy fatbin bytes";
se::CUDAFatbinInMemorySpec Spec("KernelName", FatbinBytes);
EXPECT_EQ("KernelName", Spec.getKernelName());
EXPECT_EQ(FatbinBytes, Spec.getBytes());
}
TEST(OpenCLTextInMemorySpec, BasicUsage) {
const char *OpenCLText = "Dummy OpenCL text";
se::OpenCLTextInMemorySpec Spec("KernelName", OpenCLText);
EXPECT_EQ("KernelName", Spec.getKernelName());
EXPECT_EQ(OpenCLText, Spec.getText());
}
TEST(MultiKernelLoaderSpec, NoCode) {
se::MultiKernelLoaderSpec MultiSpec;
EXPECT_FALSE(MultiSpec.hasCUDAPTXInMemory());
EXPECT_FALSE(MultiSpec.hasCUDAFatbinInMemory());
EXPECT_FALSE(MultiSpec.hasOpenCLTextInMemory());
EXPECT_DEBUG_DEATH(MultiSpec.getCUDAPTXInMemory(),
"getting spec that is not present");
EXPECT_DEBUG_DEATH(MultiSpec.getCUDAFatbinInMemory(),
"getting spec that is not present");
EXPECT_DEBUG_DEATH(MultiSpec.getOpenCLTextInMemory(),
"getting spec that is not present");
}
TEST(MultiKernelLoaderSpec, Registration) {
se::MultiKernelLoaderSpec MultiSpec;
const char *KernelName = "KernelName";
const char *PTXCodeString = "Dummy PTX code";
const char *FatbinBytes = "Dummy fatbin bytes";
const char *OpenCLText = "Dummy OpenCL text";
MultiSpec.addCUDAPTXInMemory(KernelName, {{{1, 0}, PTXCodeString}})
.addCUDAFatbinInMemory(KernelName, FatbinBytes)
.addOpenCLTextInMemory(KernelName, OpenCLText);
EXPECT_TRUE(MultiSpec.hasCUDAPTXInMemory());
EXPECT_TRUE(MultiSpec.hasCUDAFatbinInMemory());
EXPECT_TRUE(MultiSpec.hasOpenCLTextInMemory());
EXPECT_EQ(KernelName, MultiSpec.getCUDAPTXInMemory().getKernelName());
EXPECT_EQ(PTXCodeString, MultiSpec.getCUDAPTXInMemory().getCode(1, 0));
EXPECT_EQ(nullptr, MultiSpec.getCUDAPTXInMemory().getCode(2, 0));
EXPECT_EQ(KernelName, MultiSpec.getCUDAFatbinInMemory().getKernelName());
EXPECT_EQ(FatbinBytes, MultiSpec.getCUDAFatbinInMemory().getBytes());
EXPECT_EQ(KernelName, MultiSpec.getOpenCLTextInMemory().getKernelName());
EXPECT_EQ(OpenCLText, MultiSpec.getOpenCLTextInMemory().getText());
}
TEST(MultiKernelLoaderSpec, RegisterTwice) {
se::MultiKernelLoaderSpec MultiSpec;
const char *KernelName = "KernelName";
const char *FatbinBytes = "Dummy fatbin bytes";
MultiSpec.addCUDAFatbinInMemory(KernelName, FatbinBytes);
EXPECT_DEBUG_DEATH(MultiSpec.addCUDAFatbinInMemory(KernelName, FatbinBytes),
"illegal loader spec overwrite");
}
TEST(MultiKernelLoaderSpec, ConflictingKernelNames) {
se::MultiKernelLoaderSpec MultiSpec;
const char *KernelNameA = "KernelName";
std::string KernelNameB = KernelNameA;
const char *PTXCodeString = "Dummy PTX code";
const char *FatbinBytes = "Dummy fatbin bytes";
// Check that names don't conflict if they are equivalent strings in different
// locations.
MultiSpec.addCUDAPTXInMemory(KernelNameA, {{{1, 0}, PTXCodeString}})
.addCUDAFatbinInMemory(KernelNameB, FatbinBytes);
const char *OtherKernelName = "OtherKernelName";
const char *OpenCLText = "Dummy OpenCL text";
EXPECT_DEBUG_DEATH(
MultiSpec.addOpenCLTextInMemory(OtherKernelName, OpenCLText),
"different kernel names in one MultiKernelLoaderSpec");
}
} // namespace

parallel-libs/trunk/streamexecutor/lib/unittests/PackedKernelArgumentArrayTest.cpp

//===-- PackedKernelArgumentArrayTest.cpp - tests for kernel arg packing --===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// Unit tests for kernel argument packing.
///
//===----------------------------------------------------------------------===//
#include "SimpleHostPlatformDevice.h"
#include "streamexecutor/Device.h"
#include "streamexecutor/DeviceMemory.h"
#include "streamexecutor/PackedKernelArgumentArray.h"
#include "streamexecutor/PlatformDevice.h"
#include "llvm/ADT/Twine.h"
#include "gtest/gtest.h"
namespace {
namespace se = ::streamexecutor;
using Type = se::KernelArgumentType;
// Test fixture class for testing argument packing.
//
// Basically defines a bunch of types to be packed so they don't have to be
// defined separately in each test.
class DeviceMemoryPackingTest : public ::testing::Test {
public:
DeviceMemoryPackingTest()
: Device(&PDevice), Value(42), Handle(&Value), ByteCount(15),
ElementCount(5),
TypedGlobal(getOrDie(Device.allocateDeviceMemory<int>(ElementCount))),
TypedShared(
se::SharedDeviceMemory<int>::makeFromElementCount(ElementCount)) {}
se::test::SimpleHostPlatformDevice PDevice;
se::Device Device;
int Value;
void *Handle;
size_t ByteCount;
size_t ElementCount;
se::GlobalDeviceMemory<int> TypedGlobal;
se::SharedDeviceMemory<int> TypedShared;
};
// Utility method to check the expected address, size, and type for a packed
// argument at the given index of a PackedKernelArgumentArray.
template <typename... ParameterTs>
static void
ExpectEqual(const void *ExpectedAddress, size_t ExpectedSize, Type ExpectedType,
const se::PackedKernelArgumentArray<ParameterTs...> &Observed,
size_t Index) {
SCOPED_TRACE(("Index = " + llvm::Twine(Index)).str());
EXPECT_EQ(ExpectedAddress, Observed.getAddress(Index));
EXPECT_EQ(ExpectedAddress, Observed.getAddresses()[Index]);
EXPECT_EQ(ExpectedSize, Observed.getSize(Index));
EXPECT_EQ(ExpectedSize, Observed.getSizes()[Index]);
EXPECT_EQ(ExpectedType, Observed.getType(Index));
EXPECT_EQ(ExpectedType, Observed.getTypes()[Index]);
}
TEST_F(DeviceMemoryPackingTest, SingleValue) {
auto Array = se::make_kernel_argument_pack(Value);
ExpectEqual(&Value, sizeof(Value), Type::VALUE, Array, 0);
EXPECT_EQ(1u, Array.getArgumentCount());
EXPECT_EQ(0u, Array.getSharedCount());
}
TEST_F(DeviceMemoryPackingTest, SingleTypedGlobal) {
auto Array = se::make_kernel_argument_pack(TypedGlobal);
ExpectEqual(TypedGlobal.getHandle(), sizeof(void *),
Type::GLOBAL_DEVICE_MEMORY, Array, 0);
EXPECT_EQ(1u, Array.getArgumentCount());
EXPECT_EQ(0u, Array.getSharedCount());
}
TEST_F(DeviceMemoryPackingTest, SingleTypedGlobalPointer) {
auto Array = se::make_kernel_argument_pack(&TypedGlobal);
ExpectEqual(TypedGlobal.getHandle(), sizeof(void *),
Type::GLOBAL_DEVICE_MEMORY, Array, 0);
EXPECT_EQ(1u, Array.getArgumentCount());
EXPECT_EQ(0u, Array.getSharedCount());
}
TEST_F(DeviceMemoryPackingTest, SingleConstTypedGlobalPointer) {
const se::GlobalDeviceMemory<int> *ArgumentPointer = &TypedGlobal;
auto Array = se::make_kernel_argument_pack(ArgumentPointer);
ExpectEqual(TypedGlobal.getHandle(), sizeof(void *),
Type::GLOBAL_DEVICE_MEMORY, Array, 0);
EXPECT_EQ(1u, Array.getArgumentCount());
EXPECT_EQ(0u, Array.getSharedCount());
}
TEST_F(DeviceMemoryPackingTest, SingleTypedShared) {
auto Array = se::make_kernel_argument_pack(TypedShared);
ExpectEqual(nullptr, TypedShared.getByteCount(), Type::SHARED_DEVICE_MEMORY,
Array, 0);
EXPECT_EQ(1u, Array.getArgumentCount());
EXPECT_EQ(1u, Array.getSharedCount());
}
TEST_F(DeviceMemoryPackingTest, SingleTypedSharedPointer) {
auto Array = se::make_kernel_argument_pack(&TypedShared);
ExpectEqual(nullptr, TypedShared.getByteCount(), Type::SHARED_DEVICE_MEMORY,
Array, 0);
EXPECT_EQ(1u, Array.getArgumentCount());
EXPECT_EQ(1u, Array.getSharedCount());
}
TEST_F(DeviceMemoryPackingTest, SingleConstTypedSharedPointer) {
const se::SharedDeviceMemory<int> *ArgumentPointer = &TypedShared;
auto Array = se::make_kernel_argument_pack(ArgumentPointer);
ExpectEqual(nullptr, TypedShared.getByteCount(), Type::SHARED_DEVICE_MEMORY,
Array, 0);
EXPECT_EQ(1u, Array.getArgumentCount());
EXPECT_EQ(1u, Array.getSharedCount());
}
TEST_F(DeviceMemoryPackingTest, PackSeveralArguments) {
const se::GlobalDeviceMemory<int> *TypedGlobalPointer = &TypedGlobal;
const se::SharedDeviceMemory<int> *TypedSharedPointer = &TypedShared;
auto Array = se::make_kernel_argument_pack(Value, TypedGlobal, &TypedGlobal,
TypedGlobalPointer, TypedShared,
&TypedShared, TypedSharedPointer);
ExpectEqual(&Value, sizeof(Value), Type::VALUE, Array, 0);
ExpectEqual(TypedGlobal.getHandle(), sizeof(void *),
Type::GLOBAL_DEVICE_MEMORY, Array, 1);
ExpectEqual(TypedGlobal.getHandle(), sizeof(void *),
Type::GLOBAL_DEVICE_MEMORY, Array, 2);
ExpectEqual(TypedGlobal.getHandle(), sizeof(void *),
Type::GLOBAL_DEVICE_MEMORY, Array, 3);
ExpectEqual(nullptr, TypedShared.getByteCount(), Type::SHARED_DEVICE_MEMORY,
Array, 4);
ExpectEqual(nullptr, TypedShared.getByteCount(), Type::SHARED_DEVICE_MEMORY,
Array, 5);
ExpectEqual(nullptr, TypedShared.getByteCount(), Type::SHARED_DEVICE_MEMORY,
Array, 6);
EXPECT_EQ(7u, Array.getArgumentCount());
EXPECT_EQ(3u, Array.getSharedCount());
}
} // namespace

parallel-libs/trunk/streamexecutor/lib/unittests/SimpleHostPlatformDevice.h

//===-- SimpleHostPlatformDevice.h - Host device for testing ----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// The SimpleHostPlatformDevice class is a streamexecutor::PlatformDevice that
/// is really just the host processor and memory. It is useful for testing
/// because no extra device platform is required.
///
//===----------------------------------------------------------------------===//
#ifndef STREAMEXECUTOR_LIB_UNITTESTS_SIMPLEHOSTPLATFORMDEVICE_H
#define STREAMEXECUTOR_LIB_UNITTESTS_SIMPLEHOSTPLATFORMDEVICE_H
#include <cstdlib>
#include <cstring>
#include "streamexecutor/PlatformDevice.h"
namespace streamexecutor {
namespace test {
/// A streamexecutor::PlatformDevice that simply forwards all operations to the
/// host platform.
///
/// The allocate and copy methods are simple wrappers for std::malloc and
/// std::memcpy.
class SimpleHostPlatformDevice : public streamexecutor::PlatformDevice {
public:
std::string getName() const override { return "SimpleHostPlatformDevice"; }
streamexecutor::Expected<const void *> createStream() override {
return nullptr;
}
streamexecutor::Expected<void *>
allocateDeviceMemory(size_t ByteCount) override {
return std::malloc(ByteCount);
}
streamexecutor::Error freeDeviceMemory(const void *Handle) override {
std::free(const_cast<void *>(Handle));
return streamexecutor::Error::success();
}
streamexecutor::Expected<void *>
allocateHostMemory(size_t ByteCount) override {
return std::malloc(ByteCount);
}
streamexecutor::Error freeHostMemory(void *Memory) override {
std::free(const_cast<void *>(Memory));
return streamexecutor::Error::success();
}
streamexecutor::Error registerHostMemory(void *Memory,
size_t ByteCount) override {
return streamexecutor::Error::success();
}
streamexecutor::Error unregisterHostMemory(void *Memory) override {
return streamexecutor::Error::success();
}
streamexecutor::Error copyD2H(const void *StreamHandle,
const void *DeviceHandleSrc,
size_t SrcByteOffset, void *HostDst,
size_t DstByteOffset,
size_t ByteCount) override {
std::memcpy(static_cast<char *>(HostDst) + DstByteOffset,
static_cast<const char *>(DeviceHandleSrc) + SrcByteOffset,
ByteCount);
return streamexecutor::Error::success();
}
streamexecutor::Error copyH2D(const void *StreamHandle, const void *HostSrc,
size_t SrcByteOffset,
const void *DeviceHandleDst,
size_t DstByteOffset,
size_t ByteCount) override {
std::memcpy(static_cast<char *>(const_cast<void *>(DeviceHandleDst)) +
DstByteOffset,
static_cast<const char *>(HostSrc) + SrcByteOffset, ByteCount);
return streamexecutor::Error::success();
}
streamexecutor::Error
copyD2D(const void *StreamHandle, const void *DeviceHandleSrc,
size_t SrcByteOffset, const void *DeviceHandleDst,
size_t DstByteOffset, size_t ByteCount) override {
std::memcpy(static_cast<char *>(const_cast<void *>(DeviceHandleDst)) +
DstByteOffset,
static_cast<const char *>(DeviceHandleSrc) + SrcByteOffset,
ByteCount);
return streamexecutor::Error::success();
}
streamexecutor::Error synchronousCopyD2H(const void *DeviceHandleSrc,
size_t SrcByteOffset, void *HostDst,
size_t DstByteOffset,
size_t ByteCount) override {
std::memcpy(static_cast<char *>(HostDst) + DstByteOffset,
static_cast<const char *>(DeviceHandleSrc) + SrcByteOffset,
ByteCount);
return streamexecutor::Error::success();
}
streamexecutor::Error synchronousCopyH2D(const void *HostSrc,
size_t SrcByteOffset,
const void *DeviceHandleDst,
size_t DstByteOffset,
size_t ByteCount) override {
std::memcpy(static_cast<char *>(const_cast<void *>(DeviceHandleDst)) +
DstByteOffset,
static_cast<const char *>(HostSrc) + SrcByteOffset, ByteCount);
return streamexecutor::Error::success();
}
streamexecutor::Error synchronousCopyD2D(const void *DeviceHandleSrc,
size_t SrcByteOffset,
const void *DeviceHandleDst,
size_t DstByteOffset,
size_t ByteCount) override {
std::memcpy(static_cast<char *>(const_cast<void *>(DeviceHandleDst)) +
DstByteOffset,
static_cast<const char *>(DeviceHandleSrc) + SrcByteOffset,
ByteCount);
return streamexecutor::Error::success();
}
/// Gets the value at the given index from a GlobalDeviceMemory<T> instance
/// created by this class.
template <typename T>
static T getDeviceValue(const streamexecutor::GlobalDeviceMemory<T> &Memory,
size_t Index) {
return static_cast<const T *>(Memory.getHandle())[Index];
}
};
} // namespace test
} // namespace streamexecutor
#endif // STREAMEXECUTOR_LIB_UNITTESTS_SIMPLEHOSTPLATFORMDEVICE_H

parallel-libs/trunk/streamexecutor/lib/unittests/StreamTest.cpp

//===-- StreamTest.cpp - Tests for Stream ---------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file contains the unit tests for Stream code.
///
//===----------------------------------------------------------------------===//
#include <cstring>
#include "SimpleHostPlatformDevice.h"
#include "streamexecutor/Device.h"
#include "streamexecutor/Kernel.h"
#include "streamexecutor/KernelSpec.h"
#include "streamexecutor/PlatformDevice.h"
#include "streamexecutor/Stream.h"
#include "gtest/gtest.h"
namespace {
namespace se = ::streamexecutor;
const auto &getDeviceValue =
se::test::SimpleHostPlatformDevice::getDeviceValue<int>;
/// Test fixture to hold objects used by tests.
class StreamTest : public ::testing::Test {
public:
StreamTest()
: DummyPlatformStream(1), Device(&PDevice),
Stream(&PDevice, &DummyPlatformStream), HostA5{0, 1, 2, 3, 4},
HostB5{5, 6, 7, 8, 9}, HostA7{10, 11, 12, 13, 14, 15, 16},
HostB7{17, 18, 19, 20, 21, 22, 23}, Host5{24, 25, 26, 27, 28},
Host7{29, 30, 31, 32, 33, 34, 35},
DeviceA5(getOrDie(Device.allocateDeviceMemory<int>(5))),
DeviceB5(getOrDie(Device.allocateDeviceMemory<int>(5))),
DeviceA7(getOrDie(Device.allocateDeviceMemory<int>(7))),
DeviceB7(getOrDie(Device.allocateDeviceMemory<int>(7))) {
se::dieIfError(Device.synchronousCopyH2D<int>(HostA5, DeviceA5));
se::dieIfError(Device.synchronousCopyH2D<int>(HostB5, DeviceB5));
se::dieIfError(Device.synchronousCopyH2D<int>(HostA7, DeviceA7));
se::dieIfError(Device.synchronousCopyH2D<int>(HostB7, DeviceB7));
}
protected:
int DummyPlatformStream; // Mimicking a platform where the platform stream
// handle is just a stream number.
se::test::SimpleHostPlatformDevice PDevice;
se::Device Device;
se::Stream Stream;
// Device memory is matched by host arrays.
int HostA5[5];
int HostB5[5];
int HostA7[7];
int HostB7[7];
// Host memory to be used as actual host memory.
int Host5[5];
int Host7[7];
// Device memory.
se::GlobalDeviceMemory<int> DeviceA5;
se::GlobalDeviceMemory<int> DeviceB5;
se::GlobalDeviceMemory<int> DeviceA7;
se::GlobalDeviceMemory<int> DeviceB7;
};
using llvm::ArrayRef;
using llvm::MutableArrayRef;
// D2H tests
TEST_F(StreamTest, CopyD2HToMutableArrayRefByCount) {
Stream.thenCopyD2H(DeviceA5, MutableArrayRef<int>(Host5), 5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
Stream.thenCopyD2H(DeviceB5, MutableArrayRef<int>(Host5), 2);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(HostB5[I], Host5[I]);
}
Stream.thenCopyD2H(DeviceA7, MutableArrayRef<int>(Host5), 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyD2HToMutableArrayRef) {
Stream.thenCopyD2H(DeviceA5, MutableArrayRef<int>(Host5));
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
Stream.thenCopyD2H(DeviceA5, MutableArrayRef<int>(Host7));
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyD2HToPointer) {
Stream.thenCopyD2H(DeviceA5, Host5, 5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
Stream.thenCopyD2H(DeviceA5, Host7, 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyD2HSliceToMutableArrayRefByCount) {
Stream.thenCopyD2H(DeviceA5.asSlice().drop_front(1),
MutableArrayRef<int>(Host5 + 1, 4), 4);
EXPECT_TRUE(Stream.isOK());
for (int I = 1; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
Stream.thenCopyD2H(DeviceB5.asSlice().drop_back(1),
MutableArrayRef<int>(Host5), 2);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(HostB5[I], Host5[I]);
}
Stream.thenCopyD2H(DeviceA5.asSlice(), MutableArrayRef<int>(Host7), 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyD2HSliceToMutableArrayRef) {
Stream.thenCopyD2H(DeviceA7.asSlice().slice(1, 5),
MutableArrayRef<int>(Host5));
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(HostA7[I + 1], Host5[I]);
}
Stream.thenCopyD2H(DeviceA5.asSlice(), MutableArrayRef<int>(Host7));
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyD2HSliceToPointer) {
Stream.thenCopyD2H(DeviceA5.asSlice().drop_front(1), Host5 + 1, 4);
EXPECT_TRUE(Stream.isOK());
for (int I = 1; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
Stream.thenCopyD2H(DeviceA5.asSlice(), Host7, 7);
EXPECT_FALSE(Stream.isOK());
}
// H2D tests
TEST_F(StreamTest, CopyH2DToArrayRefByCount) {
Stream.thenCopyH2D(ArrayRef<int>(Host5), DeviceA5, 5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
Stream.thenCopyH2D(ArrayRef<int>(Host5), DeviceB5, 2);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceB5, I), Host5[I]);
}
Stream.thenCopyH2D(ArrayRef<int>(Host7), DeviceA5, 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyH2DToArrayRef) {
Stream.thenCopyH2D(ArrayRef<int>(Host5), DeviceA5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
Stream.thenCopyH2D(ArrayRef<int>(Host7), DeviceA5);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyH2DToPointer) {
Stream.thenCopyH2D(Host5, DeviceA5, 5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
Stream.thenCopyH2D(Host7, DeviceA5, 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyH2DSliceToArrayRefByCount) {
Stream.thenCopyH2D(ArrayRef<int>(Host5 + 1, 4),
DeviceA5.asSlice().drop_front(1), 4);
EXPECT_TRUE(Stream.isOK());
for (int I = 1; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
Stream.thenCopyH2D(ArrayRef<int>(Host5), DeviceB5.asSlice().drop_back(1), 2);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceB5, I), Host5[I]);
}
Stream.thenCopyH2D(ArrayRef<int>(Host5), DeviceA5.asSlice(), 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyH2DSliceToArrayRef) {
Stream.thenCopyH2D(ArrayRef<int>(Host5), DeviceA5.asSlice());
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
Stream.thenCopyH2D(ArrayRef<int>(Host7), DeviceA5.asSlice());
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyH2DSliceToPointer) {
Stream.thenCopyH2D(Host5, DeviceA5.asSlice(), 5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
Stream.thenCopyH2D(Host7, DeviceA5.asSlice(), 7);
EXPECT_FALSE(Stream.isOK());
}
// D2D tests
TEST_F(StreamTest, CopyD2DByCount) {
Stream.thenCopyD2D(DeviceA5, DeviceB5, 5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
}
Stream.thenCopyD2D(DeviceA7, DeviceB7, 2);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
}
Stream.thenCopyD2D(DeviceA7, DeviceB5, 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyD2D) {
Stream.thenCopyD2D(DeviceA5, DeviceB5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
}
Stream.thenCopyD2D(DeviceA7, DeviceB5);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopySliceD2DByCount) {
Stream.thenCopyD2D(DeviceA5.asSlice().drop_front(1), DeviceB5, 4);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 4; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I + 1), getDeviceValue(DeviceB5, I));
}
Stream.thenCopyD2D(DeviceA7.asSlice().drop_back(1), DeviceB7, 2);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
}
Stream.thenCopyD2D(DeviceA5.asSlice(), DeviceB5, 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopySliceD2D) {
Stream.thenCopyD2D(DeviceA7.asSlice().drop_back(2), DeviceB5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB5, I));
}
Stream.thenCopyD2D(DeviceA5.asSlice().drop_back(1), DeviceB7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyD2DSliceByCount) {
Stream.thenCopyD2D(DeviceA5, DeviceB7.asSlice().drop_front(2), 5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB7, I + 2));
}
Stream.thenCopyD2D(DeviceA7, DeviceB7.asSlice().drop_back(3), 2);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
}
Stream.thenCopyD2D(DeviceA5, DeviceB7.asSlice(), 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyD2DSlice) {
Stream.thenCopyD2D(DeviceA5, DeviceB7.asSlice().drop_back(2));
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB7, I));
}
Stream.thenCopyD2D(DeviceA5, DeviceB7.asSlice());
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopySliceD2DSliceByCount) {
Stream.thenCopyD2D(DeviceA5.asSlice(), DeviceB5.asSlice(), 5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
}
Stream.thenCopyD2D(DeviceA7.asSlice(), DeviceB7.asSlice(), 2);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
}
Stream.thenCopyD2D(DeviceA7.asSlice(), DeviceB5.asSlice(), 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopySliceD2DSlice) {
Stream.thenCopyD2D(DeviceA5.asSlice(), DeviceB5.asSlice());
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
}
Stream.thenCopyD2D(DeviceA5.asSlice(), DeviceB7.asSlice());
EXPECT_FALSE(Stream.isOK());
}
} // namespace

parallel-libs/trunk/streamexecutor/unittests/CMakeLists.txt

add_custom_target(StreamExecutorUnitTests)
set_target_properties(StreamExecutorUnitTests PROPERTIES FOLDER "streamexecutor tests")
function(add_se_unittest testdir_name)
add_unittest(StreamExecutorUnitTests ${testdir_name} ${ARGN})
target_link_libraries(${testdir_name} streamexecutor)
endfunction()
add_subdirectory(CoreTests)

parallel-libs/trunk/streamexecutor/unittests/CoreTests/CMakeLists.txt

add_se_unittest(
CoreTests
DeviceTest.cpp
KernelSpecTest.cpp
PackedKernelArgumentArrayTest.cpp
StreamTest.cpp
)

parallel-libs/trunk/streamexecutor/unittests/CoreTests/DeviceTest.cpp

//===-- DeviceTest.cpp - Tests for Device ---------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file contains the unit tests for Device code.
///
//===----------------------------------------------------------------------===//
#include <cstdlib>
#include <cstring>
#include "SimpleHostPlatformDevice.h"
#include "streamexecutor/Device.h"
#include "streamexecutor/PlatformDevice.h"
#include "gtest/gtest.h"
namespace {
namespace se = ::streamexecutor;
const auto &getDeviceValue =
se::test::SimpleHostPlatformDevice::getDeviceValue<int>;
/// Test fixture to hold objects used by tests.
class DeviceTest : public ::testing::Test {
public:
DeviceTest()
: Device(&PDevice), HostA5{0, 1, 2, 3, 4}, HostB5{5, 6, 7, 8, 9},
HostA7{10, 11, 12, 13, 14, 15, 16}, HostB7{17, 18, 19, 20, 21, 22, 23},
DeviceA5(getOrDie(Device.allocateDeviceMemory<int>(5))),
DeviceB5(getOrDie(Device.allocateDeviceMemory<int>(5))),
DeviceA7(getOrDie(Device.allocateDeviceMemory<int>(7))),
DeviceB7(getOrDie(Device.allocateDeviceMemory<int>(7))),
Host5{24, 25, 26, 27, 28}, Host7{29, 30, 31, 32, 33, 34, 35} {
se::dieIfError(Device.synchronousCopyH2D<int>(HostA5, DeviceA5));
se::dieIfError(Device.synchronousCopyH2D<int>(HostB5, DeviceB5));
se::dieIfError(Device.synchronousCopyH2D<int>(HostA7, DeviceA7));
se::dieIfError(Device.synchronousCopyH2D<int>(HostB7, DeviceB7));
}
se::test::SimpleHostPlatformDevice PDevice;
se::Device Device;
// Device memory is backed by host arrays.
int HostA5[5];
int HostB5[5];
int HostA7[7];
int HostB7[7];
se::GlobalDeviceMemory<int> DeviceA5;
se::GlobalDeviceMemory<int> DeviceB5;
se::GlobalDeviceMemory<int> DeviceA7;
se::GlobalDeviceMemory<int> DeviceB7;
// Host memory to be used as actual host memory.
int Host5[5];
int Host7[7];
};
#define EXPECT_NO_ERROR(E) EXPECT_FALSE(static_cast<bool>(E))
#define EXPECT_ERROR(E) \
do { \
se::Error E__ = E; \
EXPECT_TRUE(static_cast<bool>(E__)); \
consumeError(std::move(E__)); \
} while (false)
using llvm::ArrayRef;
using llvm::MutableArrayRef;
TEST_F(DeviceTest, GetName) {
EXPECT_EQ(Device.getName(), "SimpleHostPlatformDevice");
}
TEST_F(DeviceTest, AllocateAndFreeDeviceMemory) {
se::Expected<se::GlobalDeviceMemory<int>> MaybeMemory =
Device.allocateDeviceMemory<int>(10);
EXPECT_TRUE(static_cast<bool>(MaybeMemory));
}
TEST_F(DeviceTest, AllocateAndFreeHostMemory) {
se::Expected<int *> MaybeMemory = Device.allocateHostMemory<int>(10);
EXPECT_TRUE(static_cast<bool>(MaybeMemory));
EXPECT_NO_ERROR(Device.freeHostMemory(*MaybeMemory));
}
TEST_F(DeviceTest, RegisterAndUnregisterHostMemory) {
std::vector<int> Data(10);
EXPECT_NO_ERROR(Device.registerHostMemory(Data.data(), 10));
EXPECT_NO_ERROR(Device.unregisterHostMemory(Data.data()));
}
// D2H tests
TEST_F(DeviceTest, SyncCopyD2HToMutableArrayRefByCount) {
EXPECT_NO_ERROR(
Device.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host5), 5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
EXPECT_NO_ERROR(
Device.synchronousCopyD2H(DeviceB5, MutableArrayRef<int>(Host5), 2));
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(HostB5[I], Host5[I]);
}
EXPECT_ERROR(
Device.synchronousCopyD2H(DeviceA7, MutableArrayRef<int>(Host5), 7));
EXPECT_ERROR(
Device.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host7), 7));
EXPECT_ERROR(
Device.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host5), 7));
}
TEST_F(DeviceTest, SyncCopyD2HToMutableArrayRef) {
EXPECT_NO_ERROR(
Device.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host5)));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
EXPECT_ERROR(
Device.synchronousCopyD2H(DeviceA7, MutableArrayRef<int>(Host5)));
EXPECT_ERROR(
Device.synchronousCopyD2H(DeviceA5, MutableArrayRef<int>(Host7)));
}
TEST_F(DeviceTest, SyncCopyD2HToPointer) {
EXPECT_NO_ERROR(Device.synchronousCopyD2H(DeviceA5, Host5, 5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5, Host7, 7));
}
TEST_F(DeviceTest, SyncCopyD2HSliceToMutableArrayRefByCount) {
EXPECT_NO_ERROR(Device.synchronousCopyD2H(
DeviceA5.asSlice().drop_front(1), MutableArrayRef<int>(Host5 + 1, 4), 4));
for (int I = 1; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
EXPECT_NO_ERROR(Device.synchronousCopyD2H(DeviceB5.asSlice().drop_back(1),
MutableArrayRef<int>(Host5), 2));
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(HostB5[I], Host5[I]);
}
EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA7.asSlice(),
MutableArrayRef<int>(Host5), 7));
EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice(),
MutableArrayRef<int>(Host7), 7));
EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice(),
MutableArrayRef<int>(Host5), 7));
}
TEST_F(DeviceTest, SyncCopyD2HSliceToMutableArrayRef) {
EXPECT_NO_ERROR(Device.synchronousCopyD2H(DeviceA7.asSlice().slice(1, 5),
MutableArrayRef<int>(Host5)));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(HostA7[I + 1], Host5[I]);
}
EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA7.asSlice().drop_back(1),
MutableArrayRef<int>(Host5)));
EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice(),
MutableArrayRef<int>(Host7)));
}
TEST_F(DeviceTest, SyncCopyD2HSliceToPointer) {
EXPECT_NO_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice().drop_front(1),
Host5 + 1, 4));
for (int I = 1; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
EXPECT_ERROR(Device.synchronousCopyD2H(DeviceA5.asSlice(), Host7, 7));
}
// H2D tests
TEST_F(DeviceTest, SyncCopyH2DToArrayRefByCount) {
EXPECT_NO_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5, 5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
EXPECT_NO_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceB5, 2));
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceB5, I), Host5[I]);
}
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), DeviceA5, 7));
}
TEST_F(DeviceTest, SyncCopyH2DToArrayRef) {
EXPECT_NO_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7));
EXPECT_ERROR(Device.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5));
}
TEST_F(DeviceTest, SyncCopyH2DToPointer) {
EXPECT_NO_ERROR(Device.synchronousCopyH2D(Host5, DeviceA5, 5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
EXPECT_ERROR(Device.synchronousCopyH2D(Host7, DeviceA5, 7));
}
TEST_F(DeviceTest, SyncCopyH2DSliceToArrayRefByCount) {
EXPECT_NO_ERROR(Device.synchronousCopyH2D(
ArrayRef<int>(Host5 + 1, 4), DeviceA5.asSlice().drop_front(1), 4));
for (int I = 1; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
EXPECT_NO_ERROR(Device.synchronousCopyH2D(
ArrayRef<int>(Host5), DeviceB5.asSlice().drop_back(1), 2));
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceB5, I), Host5[I]);
}
EXPECT_ERROR(
Device.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5.asSlice(), 7));
EXPECT_ERROR(
Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7.asSlice(), 7));
EXPECT_ERROR(
Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5.asSlice(), 7));
}
TEST_F(DeviceTest, SyncCopyH2DSliceToArrayRef) {
EXPECT_NO_ERROR(
Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA5.asSlice()));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
EXPECT_ERROR(
Device.synchronousCopyH2D(ArrayRef<int>(Host5), DeviceA7.asSlice()));
EXPECT_ERROR(
Device.synchronousCopyH2D(ArrayRef<int>(Host7), DeviceA5.asSlice()));
}
TEST_F(DeviceTest, SyncCopyH2DSliceToPointer) {
EXPECT_NO_ERROR(Device.synchronousCopyH2D(Host5, DeviceA5.asSlice(), 5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
EXPECT_ERROR(Device.synchronousCopyH2D(Host7, DeviceA5.asSlice(), 7));
}
// D2D tests
TEST_F(DeviceTest, SyncCopyD2DByCount) {
EXPECT_NO_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5, 5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
}
EXPECT_NO_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB7, 2));
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
}
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5, 7));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB5, 7));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB7, 7));
}
TEST_F(DeviceTest, SyncCopyD2D) {
EXPECT_NO_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
}
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB5));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB7));
}
TEST_F(DeviceTest, SyncCopySliceD2DByCount) {
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA5.asSlice().drop_front(1), DeviceB5, 4));
for (int I = 0; I < 4; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I + 1), getDeviceValue(DeviceB5, I));
}
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA7.asSlice().drop_back(1), DeviceB7, 2));
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
}
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5, 7));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB5, 7));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB7, 7));
}
TEST_F(DeviceTest, SyncCopySliceD2D) {
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA7.asSlice().drop_back(2), DeviceB5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB5, I));
}
EXPECT_ERROR(
Device.synchronousCopyD2D(DeviceA7.asSlice().drop_front(1), DeviceB5));
EXPECT_ERROR(
Device.synchronousCopyD2D(DeviceA5.asSlice().drop_back(1), DeviceB7));
}
TEST_F(DeviceTest, SyncCopyD2DSliceByCount) {
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice().drop_front(2), 5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB7, I + 2));
}
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA7, DeviceB7.asSlice().drop_back(3), 2));
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
}
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB5.asSlice(), 7));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB5.asSlice(), 7));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice(), 7));
}
TEST_F(DeviceTest, SyncCopyD2DSlice) {
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice().drop_back(2)));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB7, I));
}
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA7, DeviceB5.asSlice()));
EXPECT_ERROR(Device.synchronousCopyD2D(DeviceA5, DeviceB7.asSlice()));
}
TEST_F(DeviceTest, SyncCopySliceD2DSliceByCount) {
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5.asSlice(), 5));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
}
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB7.asSlice(), 2));
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
}
EXPECT_ERROR(
Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5.asSlice(), 7));
EXPECT_ERROR(
Device.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB5.asSlice(), 7));
EXPECT_ERROR(
Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB7.asSlice(), 7));
}
TEST_F(DeviceTest, SyncCopySliceD2DSlice) {
EXPECT_NO_ERROR(
Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB5.asSlice()));
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
}
EXPECT_ERROR(
Device.synchronousCopyD2D(DeviceA7.asSlice(), DeviceB5.asSlice()));
EXPECT_ERROR(
Device.synchronousCopyD2D(DeviceA5.asSlice(), DeviceB7.asSlice()));
}
} // namespace

parallel-libs/trunk/streamexecutor/unittests/CoreTests/KernelSpecTest.cpp

//===-- KernelSpecTest.cpp - Tests for KernelSpec -------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file contains the unit tests for the code in KernelSpec.
///
//===----------------------------------------------------------------------===//
#include "streamexecutor/KernelSpec.h"
#include "gtest/gtest.h"
namespace {
namespace se = ::streamexecutor;
TEST(CUDAPTXInMemorySpec, NoCode) {
se::CUDAPTXInMemorySpec Spec("KernelName", {});
EXPECT_EQ("KernelName", Spec.getKernelName());
EXPECT_EQ(nullptr, Spec.getCode(1, 0));
}
TEST(CUDAPTXInMemorySpec, SingleComputeCapability) {
const char *PTXCodeString = "Dummy PTX code";
se::CUDAPTXInMemorySpec Spec("KernelName", {{{1, 0}, PTXCodeString}});
EXPECT_EQ("KernelName", Spec.getKernelName());
EXPECT_EQ(PTXCodeString, Spec.getCode(1, 0));
EXPECT_EQ(nullptr, Spec.getCode(2, 0));
}
TEST(CUDAPTXInMemorySpec, TwoComputeCapabilities) {
const char *PTXCodeString10 = "Dummy PTX code 10";
const char *PTXCodeString30 = "Dummy PTX code 30";
se::CUDAPTXInMemorySpec Spec(
"KernelName", {{{1, 0}, PTXCodeString10}, {{3, 0}, PTXCodeString30}});
EXPECT_EQ("KernelName", Spec.getKernelName());
EXPECT_EQ(PTXCodeString10, Spec.getCode(1, 0));
EXPECT_EQ(PTXCodeString30, Spec.getCode(3, 0));
EXPECT_EQ(nullptr, Spec.getCode(2, 0));
}
TEST(CUDAFatbinInMemorySpec, BasicUsage) {
const char *FatbinBytes = "Dummy fatbin bytes";
se::CUDAFatbinInMemorySpec Spec("KernelName", FatbinBytes);
EXPECT_EQ("KernelName", Spec.getKernelName());
EXPECT_EQ(FatbinBytes, Spec.getBytes());
}
TEST(OpenCLTextInMemorySpec, BasicUsage) {
const char *OpenCLText = "Dummy OpenCL text";
se::OpenCLTextInMemorySpec Spec("KernelName", OpenCLText);
EXPECT_EQ("KernelName", Spec.getKernelName());
EXPECT_EQ(OpenCLText, Spec.getText());
}
TEST(MultiKernelLoaderSpec, NoCode) {
se::MultiKernelLoaderSpec MultiSpec;
EXPECT_FALSE(MultiSpec.hasCUDAPTXInMemory());
EXPECT_FALSE(MultiSpec.hasCUDAFatbinInMemory());
EXPECT_FALSE(MultiSpec.hasOpenCLTextInMemory());
EXPECT_DEBUG_DEATH(MultiSpec.getCUDAPTXInMemory(),
"getting spec that is not present");
EXPECT_DEBUG_DEATH(MultiSpec.getCUDAFatbinInMemory(),
"getting spec that is not present");
EXPECT_DEBUG_DEATH(MultiSpec.getOpenCLTextInMemory(),
"getting spec that is not present");
}
TEST(MultiKernelLoaderSpec, Registration) {
se::MultiKernelLoaderSpec MultiSpec;
const char *KernelName = "KernelName";
const char *PTXCodeString = "Dummy PTX code";
const char *FatbinBytes = "Dummy fatbin bytes";
const char *OpenCLText = "Dummy OpenCL text";
MultiSpec.addCUDAPTXInMemory(KernelName, {{{1, 0}, PTXCodeString}})
.addCUDAFatbinInMemory(KernelName, FatbinBytes)
.addOpenCLTextInMemory(KernelName, OpenCLText);
EXPECT_TRUE(MultiSpec.hasCUDAPTXInMemory());
EXPECT_TRUE(MultiSpec.hasCUDAFatbinInMemory());
EXPECT_TRUE(MultiSpec.hasOpenCLTextInMemory());
EXPECT_EQ(KernelName, MultiSpec.getCUDAPTXInMemory().getKernelName());
EXPECT_EQ(PTXCodeString, MultiSpec.getCUDAPTXInMemory().getCode(1, 0));
EXPECT_EQ(nullptr, MultiSpec.getCUDAPTXInMemory().getCode(2, 0));
EXPECT_EQ(KernelName, MultiSpec.getCUDAFatbinInMemory().getKernelName());
EXPECT_EQ(FatbinBytes, MultiSpec.getCUDAFatbinInMemory().getBytes());
EXPECT_EQ(KernelName, MultiSpec.getOpenCLTextInMemory().getKernelName());
EXPECT_EQ(OpenCLText, MultiSpec.getOpenCLTextInMemory().getText());
}
TEST(MultiKernelLoaderSpec, RegisterTwice) {
se::MultiKernelLoaderSpec MultiSpec;
const char *KernelName = "KernelName";
const char *FatbinBytes = "Dummy fatbin bytes";
MultiSpec.addCUDAFatbinInMemory(KernelName, FatbinBytes);
EXPECT_DEBUG_DEATH(MultiSpec.addCUDAFatbinInMemory(KernelName, FatbinBytes),
"illegal loader spec overwrite");
}
TEST(MultiKernelLoaderSpec, ConflictingKernelNames) {
se::MultiKernelLoaderSpec MultiSpec;
const char *KernelNameA = "KernelName";
std::string KernelNameB = KernelNameA;
const char *PTXCodeString = "Dummy PTX code";
const char *FatbinBytes = "Dummy fatbin bytes";
// Check that names don't conflict if they are equivalent strings in different
// locations.
MultiSpec.addCUDAPTXInMemory(KernelNameA, {{{1, 0}, PTXCodeString}})
.addCUDAFatbinInMemory(KernelNameB, FatbinBytes);
const char *OtherKernelName = "OtherKernelName";
const char *OpenCLText = "Dummy OpenCL text";
EXPECT_DEBUG_DEATH(
MultiSpec.addOpenCLTextInMemory(OtherKernelName, OpenCLText),
"different kernel names in one MultiKernelLoaderSpec");
}
} // namespace

parallel-libs/trunk/streamexecutor/unittests/CoreTests/PackedKernelArgumentArrayTest.cpp

//===-- PackedKernelArgumentArrayTest.cpp - tests for kernel arg packing --===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// Unit tests for kernel argument packing.
///
//===----------------------------------------------------------------------===//
#include "SimpleHostPlatformDevice.h"
#include "streamexecutor/Device.h"
#include "streamexecutor/DeviceMemory.h"
#include "streamexecutor/PackedKernelArgumentArray.h"
#include "streamexecutor/PlatformDevice.h"
#include "llvm/ADT/Twine.h"
#include "gtest/gtest.h"
namespace {
namespace se = ::streamexecutor;
using Type = se::KernelArgumentType;
// Test fixture class for testing argument packing.
//
// Basically defines a bunch of types to be packed so they don't have to be
// defined separately in each test.
class DeviceMemoryPackingTest : public ::testing::Test {
public:
DeviceMemoryPackingTest()
: Device(&PDevice), Value(42), Handle(&Value), ByteCount(15),
ElementCount(5),
TypedGlobal(getOrDie(Device.allocateDeviceMemory<int>(ElementCount))),
TypedShared(
se::SharedDeviceMemory<int>::makeFromElementCount(ElementCount)) {}
se::test::SimpleHostPlatformDevice PDevice;
se::Device Device;
int Value;
void *Handle;
size_t ByteCount;
size_t ElementCount;
se::GlobalDeviceMemory<int> TypedGlobal;
se::SharedDeviceMemory<int> TypedShared;
};
// Utility method to check the expected address, size, and type for a packed
// argument at the given index of a PackedKernelArgumentArray.
template <typename... ParameterTs>
static void
ExpectEqual(const void *ExpectedAddress, size_t ExpectedSize, Type ExpectedType,
const se::PackedKernelArgumentArray<ParameterTs...> &Observed,
size_t Index) {
SCOPED_TRACE(("Index = " + llvm::Twine(Index)).str());
EXPECT_EQ(ExpectedAddress, Observed.getAddress(Index));
EXPECT_EQ(ExpectedAddress, Observed.getAddresses()[Index]);
EXPECT_EQ(ExpectedSize, Observed.getSize(Index));
EXPECT_EQ(ExpectedSize, Observed.getSizes()[Index]);
EXPECT_EQ(ExpectedType, Observed.getType(Index));
EXPECT_EQ(ExpectedType, Observed.getTypes()[Index]);
}
TEST_F(DeviceMemoryPackingTest, SingleValue) {
auto Array = se::make_kernel_argument_pack(Value);
ExpectEqual(&Value, sizeof(Value), Type::VALUE, Array, 0);
EXPECT_EQ(1u, Array.getArgumentCount());
EXPECT_EQ(0u, Array.getSharedCount());
}
TEST_F(DeviceMemoryPackingTest, SingleTypedGlobal) {
auto Array = se::make_kernel_argument_pack(TypedGlobal);
ExpectEqual(TypedGlobal.getHandle(), sizeof(void *),
Type::GLOBAL_DEVICE_MEMORY, Array, 0);
EXPECT_EQ(1u, Array.getArgumentCount());
EXPECT_EQ(0u, Array.getSharedCount());
}
TEST_F(DeviceMemoryPackingTest, SingleTypedGlobalPointer) {
auto Array = se::make_kernel_argument_pack(&TypedGlobal);
ExpectEqual(TypedGlobal.getHandle(), sizeof(void *),
Type::GLOBAL_DEVICE_MEMORY, Array, 0);
EXPECT_EQ(1u, Array.getArgumentCount());
EXPECT_EQ(0u, Array.getSharedCount());
}
TEST_F(DeviceMemoryPackingTest, SingleConstTypedGlobalPointer) {
const se::GlobalDeviceMemory<int> *ArgumentPointer = &TypedGlobal;
auto Array = se::make_kernel_argument_pack(ArgumentPointer);
ExpectEqual(TypedGlobal.getHandle(), sizeof(void *),
Type::GLOBAL_DEVICE_MEMORY, Array, 0);
EXPECT_EQ(1u, Array.getArgumentCount());
EXPECT_EQ(0u, Array.getSharedCount());
}
TEST_F(DeviceMemoryPackingTest, SingleTypedShared) {
auto Array = se::make_kernel_argument_pack(TypedShared);
ExpectEqual(nullptr, TypedShared.getByteCount(), Type::SHARED_DEVICE_MEMORY,
Array, 0);
EXPECT_EQ(1u, Array.getArgumentCount());
EXPECT_EQ(1u, Array.getSharedCount());
}
TEST_F(DeviceMemoryPackingTest, SingleTypedSharedPointer) {
auto Array = se::make_kernel_argument_pack(&TypedShared);
ExpectEqual(nullptr, TypedShared.getByteCount(), Type::SHARED_DEVICE_MEMORY,
Array, 0);
EXPECT_EQ(1u, Array.getArgumentCount());
EXPECT_EQ(1u, Array.getSharedCount());
}
TEST_F(DeviceMemoryPackingTest, SingleConstTypedSharedPointer) {
const se::SharedDeviceMemory<int> *ArgumentPointer = &TypedShared;
auto Array = se::make_kernel_argument_pack(ArgumentPointer);
ExpectEqual(nullptr, TypedShared.getByteCount(), Type::SHARED_DEVICE_MEMORY,
Array, 0);
EXPECT_EQ(1u, Array.getArgumentCount());
EXPECT_EQ(1u, Array.getSharedCount());
}
TEST_F(DeviceMemoryPackingTest, PackSeveralArguments) {
const se::GlobalDeviceMemory<int> *TypedGlobalPointer = &TypedGlobal;
const se::SharedDeviceMemory<int> *TypedSharedPointer = &TypedShared;
auto Array = se::make_kernel_argument_pack(Value, TypedGlobal, &TypedGlobal,
TypedGlobalPointer, TypedShared,
&TypedShared, TypedSharedPointer);
ExpectEqual(&Value, sizeof(Value), Type::VALUE, Array, 0);
ExpectEqual(TypedGlobal.getHandle(), sizeof(void *),
Type::GLOBAL_DEVICE_MEMORY, Array, 1);
ExpectEqual(TypedGlobal.getHandle(), sizeof(void *),
Type::GLOBAL_DEVICE_MEMORY, Array, 2);
ExpectEqual(TypedGlobal.getHandle(), sizeof(void *),
Type::GLOBAL_DEVICE_MEMORY, Array, 3);
ExpectEqual(nullptr, TypedShared.getByteCount(), Type::SHARED_DEVICE_MEMORY,
Array, 4);
ExpectEqual(nullptr, TypedShared.getByteCount(), Type::SHARED_DEVICE_MEMORY,
Array, 5);
ExpectEqual(nullptr, TypedShared.getByteCount(), Type::SHARED_DEVICE_MEMORY,
Array, 6);
EXPECT_EQ(7u, Array.getArgumentCount());
EXPECT_EQ(3u, Array.getSharedCount());
}
} // namespace

parallel-libs/trunk/streamexecutor/unittests/CoreTests/SimpleHostPlatformDevice.h

//===-- SimpleHostPlatformDevice.h - Host device for testing ----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// The SimpleHostPlatformDevice class is a streamexecutor::PlatformDevice that
/// is really just the host processor and memory. It is useful for testing
/// because no extra device platform is required.
///
//===----------------------------------------------------------------------===//
#ifndef STREAMEXECUTOR_LIB_UNITTESTS_SIMPLEHOSTPLATFORMDEVICE_H
#define STREAMEXECUTOR_LIB_UNITTESTS_SIMPLEHOSTPLATFORMDEVICE_H
#include <cstdlib>
#include <cstring>
#include "streamexecutor/PlatformDevice.h"
namespace streamexecutor {
namespace test {
/// A streamexecutor::PlatformDevice that simply forwards all operations to the
/// host platform.
///
/// The allocate and copy methods are simple wrappers for std::malloc and
/// std::memcpy.
class SimpleHostPlatformDevice : public streamexecutor::PlatformDevice {
public:
std::string getName() const override { return "SimpleHostPlatformDevice"; }
streamexecutor::Expected<const void *> createStream() override {
return nullptr;
}
streamexecutor::Expected<void *>
allocateDeviceMemory(size_t ByteCount) override {
return std::malloc(ByteCount);
}
streamexecutor::Error freeDeviceMemory(const void *Handle) override {
std::free(const_cast<void *>(Handle));
return streamexecutor::Error::success();
}
streamexecutor::Expected<void *>
allocateHostMemory(size_t ByteCount) override {
return std::malloc(ByteCount);
}
streamexecutor::Error freeHostMemory(void *Memory) override {
std::free(const_cast<void *>(Memory));
return streamexecutor::Error::success();
}
streamexecutor::Error registerHostMemory(void *Memory,
size_t ByteCount) override {
return streamexecutor::Error::success();
}
streamexecutor::Error unregisterHostMemory(void *Memory) override {
return streamexecutor::Error::success();
}
streamexecutor::Error copyD2H(const void *StreamHandle,
const void *DeviceHandleSrc,
size_t SrcByteOffset, void *HostDst,
size_t DstByteOffset,
size_t ByteCount) override {
std::memcpy(static_cast<char *>(HostDst) + DstByteOffset,
static_cast<const char *>(DeviceHandleSrc) + SrcByteOffset,
ByteCount);
return streamexecutor::Error::success();
}
streamexecutor::Error copyH2D(const void *StreamHandle, const void *HostSrc,
size_t SrcByteOffset,
const void *DeviceHandleDst,
size_t DstByteOffset,
size_t ByteCount) override {
std::memcpy(static_cast<char *>(const_cast<void *>(DeviceHandleDst)) +
DstByteOffset,
static_cast<const char *>(HostSrc) + SrcByteOffset, ByteCount);
return streamexecutor::Error::success();
}
streamexecutor::Error
copyD2D(const void *StreamHandle, const void *DeviceHandleSrc,
size_t SrcByteOffset, const void *DeviceHandleDst,
size_t DstByteOffset, size_t ByteCount) override {
std::memcpy(static_cast<char *>(const_cast<void *>(DeviceHandleDst)) +
DstByteOffset,
static_cast<const char *>(DeviceHandleSrc) + SrcByteOffset,
ByteCount);
return streamexecutor::Error::success();
}
streamexecutor::Error synchronousCopyD2H(const void *DeviceHandleSrc,
size_t SrcByteOffset, void *HostDst,
size_t DstByteOffset,
size_t ByteCount) override {
std::memcpy(static_cast<char *>(HostDst) + DstByteOffset,
static_cast<const char *>(DeviceHandleSrc) + SrcByteOffset,
ByteCount);
return streamexecutor::Error::success();
}
streamexecutor::Error synchronousCopyH2D(const void *HostSrc,
size_t SrcByteOffset,
const void *DeviceHandleDst,
size_t DstByteOffset,
size_t ByteCount) override {
std::memcpy(static_cast<char *>(const_cast<void *>(DeviceHandleDst)) +
DstByteOffset,
static_cast<const char *>(HostSrc) + SrcByteOffset, ByteCount);
return streamexecutor::Error::success();
}
streamexecutor::Error synchronousCopyD2D(const void *DeviceHandleSrc,
size_t SrcByteOffset,
const void *DeviceHandleDst,
size_t DstByteOffset,
size_t ByteCount) override {
std::memcpy(static_cast<char *>(const_cast<void *>(DeviceHandleDst)) +
DstByteOffset,
static_cast<const char *>(DeviceHandleSrc) + SrcByteOffset,
ByteCount);
return streamexecutor::Error::success();
}
/// Gets the value at the given index from a GlobalDeviceMemory<T> instance
/// created by this class.
template <typename T>
static T getDeviceValue(const streamexecutor::GlobalDeviceMemory<T> &Memory,
size_t Index) {
return static_cast<const T *>(Memory.getHandle())[Index];
}
};
} // namespace test
} // namespace streamexecutor
#endif // STREAMEXECUTOR_LIB_UNITTESTS_SIMPLEHOSTPLATFORMDEVICE_H

parallel-libs/trunk/streamexecutor/unittests/CoreTests/StreamTest.cpp

//===-- StreamTest.cpp - Tests for Stream ---------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file contains the unit tests for Stream code.
///
//===----------------------------------------------------------------------===//
#include <cstring>
#include "SimpleHostPlatformDevice.h"
#include "streamexecutor/Device.h"
#include "streamexecutor/Kernel.h"
#include "streamexecutor/KernelSpec.h"
#include "streamexecutor/PlatformDevice.h"
#include "streamexecutor/Stream.h"
#include "gtest/gtest.h"
namespace {
namespace se = ::streamexecutor;
const auto &getDeviceValue =
se::test::SimpleHostPlatformDevice::getDeviceValue<int>;
/// Test fixture to hold objects used by tests.
class StreamTest : public ::testing::Test {
public:
StreamTest()
: DummyPlatformStream(1), Device(&PDevice),
Stream(&PDevice, &DummyPlatformStream), HostA5{0, 1, 2, 3, 4},
HostB5{5, 6, 7, 8, 9}, HostA7{10, 11, 12, 13, 14, 15, 16},
HostB7{17, 18, 19, 20, 21, 22, 23}, Host5{24, 25, 26, 27, 28},
Host7{29, 30, 31, 32, 33, 34, 35},
DeviceA5(getOrDie(Device.allocateDeviceMemory<int>(5))),
DeviceB5(getOrDie(Device.allocateDeviceMemory<int>(5))),
DeviceA7(getOrDie(Device.allocateDeviceMemory<int>(7))),
DeviceB7(getOrDie(Device.allocateDeviceMemory<int>(7))) {
se::dieIfError(Device.synchronousCopyH2D<int>(HostA5, DeviceA5));
se::dieIfError(Device.synchronousCopyH2D<int>(HostB5, DeviceB5));
se::dieIfError(Device.synchronousCopyH2D<int>(HostA7, DeviceA7));
se::dieIfError(Device.synchronousCopyH2D<int>(HostB7, DeviceB7));
}
protected:
int DummyPlatformStream; // Mimicking a platform where the platform stream
// handle is just a stream number.
se::test::SimpleHostPlatformDevice PDevice;
se::Device Device;
se::Stream Stream;
// Device memory is matched by host arrays.
int HostA5[5];
int HostB5[5];
int HostA7[7];
int HostB7[7];
// Host memory to be used as actual host memory.
int Host5[5];
int Host7[7];
// Device memory.
se::GlobalDeviceMemory<int> DeviceA5;
se::GlobalDeviceMemory<int> DeviceB5;
se::GlobalDeviceMemory<int> DeviceA7;
se::GlobalDeviceMemory<int> DeviceB7;
};
using llvm::ArrayRef;
using llvm::MutableArrayRef;
// D2H tests
TEST_F(StreamTest, CopyD2HToMutableArrayRefByCount) {
Stream.thenCopyD2H(DeviceA5, MutableArrayRef<int>(Host5), 5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
Stream.thenCopyD2H(DeviceB5, MutableArrayRef<int>(Host5), 2);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(HostB5[I], Host5[I]);
}
Stream.thenCopyD2H(DeviceA7, MutableArrayRef<int>(Host5), 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyD2HToMutableArrayRef) {
Stream.thenCopyD2H(DeviceA5, MutableArrayRef<int>(Host5));
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
Stream.thenCopyD2H(DeviceA5, MutableArrayRef<int>(Host7));
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyD2HToPointer) {
Stream.thenCopyD2H(DeviceA5, Host5, 5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
Stream.thenCopyD2H(DeviceA5, Host7, 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyD2HSliceToMutableArrayRefByCount) {
Stream.thenCopyD2H(DeviceA5.asSlice().drop_front(1),
MutableArrayRef<int>(Host5 + 1, 4), 4);
EXPECT_TRUE(Stream.isOK());
for (int I = 1; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
Stream.thenCopyD2H(DeviceB5.asSlice().drop_back(1),
MutableArrayRef<int>(Host5), 2);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(HostB5[I], Host5[I]);
}
Stream.thenCopyD2H(DeviceA5.asSlice(), MutableArrayRef<int>(Host7), 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyD2HSliceToMutableArrayRef) {
Stream.thenCopyD2H(DeviceA7.asSlice().slice(1, 5),
MutableArrayRef<int>(Host5));
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(HostA7[I + 1], Host5[I]);
}
Stream.thenCopyD2H(DeviceA5.asSlice(), MutableArrayRef<int>(Host7));
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyD2HSliceToPointer) {
Stream.thenCopyD2H(DeviceA5.asSlice().drop_front(1), Host5 + 1, 4);
EXPECT_TRUE(Stream.isOK());
for (int I = 1; I < 5; ++I) {
EXPECT_EQ(HostA5[I], Host5[I]);
}
Stream.thenCopyD2H(DeviceA5.asSlice(), Host7, 7);
EXPECT_FALSE(Stream.isOK());
}
// H2D tests
TEST_F(StreamTest, CopyH2DToArrayRefByCount) {
Stream.thenCopyH2D(ArrayRef<int>(Host5), DeviceA5, 5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
Stream.thenCopyH2D(ArrayRef<int>(Host5), DeviceB5, 2);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceB5, I), Host5[I]);
}
Stream.thenCopyH2D(ArrayRef<int>(Host7), DeviceA5, 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyH2DToArrayRef) {
Stream.thenCopyH2D(ArrayRef<int>(Host5), DeviceA5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
Stream.thenCopyH2D(ArrayRef<int>(Host7), DeviceA5);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyH2DToPointer) {
Stream.thenCopyH2D(Host5, DeviceA5, 5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
Stream.thenCopyH2D(Host7, DeviceA5, 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyH2DSliceToArrayRefByCount) {
Stream.thenCopyH2D(ArrayRef<int>(Host5 + 1, 4),
DeviceA5.asSlice().drop_front(1), 4);
EXPECT_TRUE(Stream.isOK());
for (int I = 1; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
Stream.thenCopyH2D(ArrayRef<int>(Host5), DeviceB5.asSlice().drop_back(1), 2);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceB5, I), Host5[I]);
}
Stream.thenCopyH2D(ArrayRef<int>(Host5), DeviceA5.asSlice(), 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyH2DSliceToArrayRef) {
Stream.thenCopyH2D(ArrayRef<int>(Host5), DeviceA5.asSlice());
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
Stream.thenCopyH2D(ArrayRef<int>(Host7), DeviceA5.asSlice());
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyH2DSliceToPointer) {
Stream.thenCopyH2D(Host5, DeviceA5.asSlice(), 5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), Host5[I]);
}
Stream.thenCopyH2D(Host7, DeviceA5.asSlice(), 7);
EXPECT_FALSE(Stream.isOK());
}
// D2D tests
TEST_F(StreamTest, CopyD2DByCount) {
Stream.thenCopyD2D(DeviceA5, DeviceB5, 5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
}
Stream.thenCopyD2D(DeviceA7, DeviceB7, 2);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
}
Stream.thenCopyD2D(DeviceA7, DeviceB5, 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyD2D) {
Stream.thenCopyD2D(DeviceA5, DeviceB5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
}
Stream.thenCopyD2D(DeviceA7, DeviceB5);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopySliceD2DByCount) {
Stream.thenCopyD2D(DeviceA5.asSlice().drop_front(1), DeviceB5, 4);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 4; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I + 1), getDeviceValue(DeviceB5, I));
}
Stream.thenCopyD2D(DeviceA7.asSlice().drop_back(1), DeviceB7, 2);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
}
Stream.thenCopyD2D(DeviceA5.asSlice(), DeviceB5, 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopySliceD2D) {
Stream.thenCopyD2D(DeviceA7.asSlice().drop_back(2), DeviceB5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB5, I));
}
Stream.thenCopyD2D(DeviceA5.asSlice().drop_back(1), DeviceB7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyD2DSliceByCount) {
Stream.thenCopyD2D(DeviceA5, DeviceB7.asSlice().drop_front(2), 5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB7, I + 2));
}
Stream.thenCopyD2D(DeviceA7, DeviceB7.asSlice().drop_back(3), 2);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
}
Stream.thenCopyD2D(DeviceA5, DeviceB7.asSlice(), 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopyD2DSlice) {
Stream.thenCopyD2D(DeviceA5, DeviceB7.asSlice().drop_back(2));
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB7, I));
}
Stream.thenCopyD2D(DeviceA5, DeviceB7.asSlice());
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopySliceD2DSliceByCount) {
Stream.thenCopyD2D(DeviceA5.asSlice(), DeviceB5.asSlice(), 5);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
}
Stream.thenCopyD2D(DeviceA7.asSlice(), DeviceB7.asSlice(), 2);
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 2; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA7, I), getDeviceValue(DeviceB7, I));
}
Stream.thenCopyD2D(DeviceA7.asSlice(), DeviceB5.asSlice(), 7);
EXPECT_FALSE(Stream.isOK());
}
TEST_F(StreamTest, CopySliceD2DSlice) {
Stream.thenCopyD2D(DeviceA5.asSlice(), DeviceB5.asSlice());
EXPECT_TRUE(Stream.isOK());
for (int I = 0; I < 5; ++I) {
EXPECT_EQ(getDeviceValue(DeviceA5, I), getDeviceValue(DeviceB5, I));
}
Stream.thenCopyD2D(DeviceA5.asSlice(), DeviceB7.asSlice());
EXPECT_FALSE(Stream.isOK());
}
} // namespace
parallel-libs/trunk/streamexecutor/lib/unittests/SimpleHostPlatformDevice.h