AI/rocm-systems
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge in the rocclr based hip runtime (#2032)

Browse Source 
* Merge master-next changes in master (include vdi development in master branch)
This commit is contained in:
Maneesh Gupta
2020-04-23 21:42:06 +05:30
committed by GitHub
parent 08147681d0
commit f2e1118d7a
136 changed files with 29756 additions and 307 deletions
Download Patch File Download Diff File Expand all files Collapse all files
hipamd/tests/src/Negative/memory/hipMemory.cpp
+1 -1
View File
@@ -18,7 +18,7 @@ THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s ../../test_common.cpp
* BUILD: %t %s ../../test_common.cpp EXCLUDE_HIP_PLATFORM vdi
* TEST: %t
* HIT_END
*/
hipamd/tests/src/Negative/stream/hipStreamCreateWithFlags.cpp
+1 -1
View File
@@ -18,7 +18,7 @@ THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s ../../test_common.cpp
* BUILD: %t %s ../../test_common.cpp EXCLUDE_HIP_PLATFORM vdi
* TEST: %t
* HIT_END
*/
hipamd/tests/src/dynamicLoading/complex_loading_behavior.cpp
+1 -1
View File
@@ -22,7 +22,7 @@ THE SOFTWARE.
/* HIT_START
* BUILD_CMD: libfoo_amd %hc %S/%s -o libfoo.so -Xcompiler -fPIC -lpthread -shared -DTEST_SHARED_LIBRARY EXCLUDE_HIP_PLATFORM nvcc
* BUILD_CMD: libfoo_nvidia %hc %S/%s -o libfoo.so -Xcompiler -fPIC -lpthread -shared -DTEST_SHARED_LIBRARY EXCLUDE_HIP_PLATFORM hcc
* BUILD_CMD: libfoo_nvidia %hc %S/%s -o libfoo.so -Xcompiler -fPIC -lpthread -shared -DTEST_SHARED_LIBRARY EXCLUDE_HIP_PLATFORM hcc vdi
* BUILD_CMD: %t %hc %S/%s -o %T/%t -ldl
* TEST: %t
* HIT_END
hipamd/tests/src/gcc/LaunchKernel.c
+9 -9
View File
@@ -19,10 +19,10 @@
/* HIT_START
* BUILD_CMD: gpu.o %hc -I%hip-path/include -g -c %S/gpu.cpp -o %T/gpu.o EXCLUDE_HIP_PLATFORM nvcc
* BUILD_CMD: launchkernel.o %cc -D__HIP_PLATFORM_HCC__ -g -I%hip-path/include -c %S/LaunchKernel.c -o %T/launchkernel.o EXCLUDE_HIP_PLATFORM nvcc
* BUILD_CMD: LaunchKernel %hc %T/launchkernel.o %T/gpu.o -g -Wl,--rpath=%hip-path/lib %hip-path/lib/libhip_hcc.so -o %T/%t DEPENDS gpu.o launchkernel.o EXCLUDE_HIP_PLATFORM nvcc
* TEST: %t EXCLUDE_HIP_PLATFORM nvcc
* BUILD_CMD: gpu.o %hc -I%hip-path/include -g -c %S/gpu.cpp -o %T/gpu.o EXCLUDE_HIP_PLATFORM nvcc vdi
* BUILD_CMD: launchkernel.o %hc -D__HIP_PLATFORM_HCC__ -g -I%hip-path/include -c %S/LaunchKernel.c -o %T/launchkernel.o EXCLUDE_HIP_PLATFORM nvcc vdi
* BUILD_CMD: LaunchKernel %hc %T/launchkernel.o %T/gpu.o -g -Wl,--rpath=%hip-path/lib %hip-path/lib/libhip_hcc.so -o %T/%t DEPENDS gpu.o launchkernel.o EXCLUDE_HIP_PLATFORM nvcc vdi
* TEST: %t EXCLUDE_HIP_PLATFORM nvcc vdi
* HIT_END
*/
@@ -36,7 +36,7 @@ bool LaunchKernelArg()
dim3 blocks = {1,1,1};
dim3 threads = {1,1,1};
HIPCHECK(hipLaunchKernel(kernel, blocks, threads, NULL, 0, 0));
HIPCHECK(hipLaunchKernel((const void *)kernel, blocks, threads, NULL, 0, 0));
return true;
}
@@ -52,7 +52,7 @@ bool LaunchKernelArg1()
HIPCHECK(hipMalloc((void**)&A_d, sizeof(int)));
void* Args[]={&A_d};
HIPCHECK(hipLaunchKernel(kernel1, blocks, threads, Args, 0, 0));
HIPCHECK(hipLaunchKernel((const void *)kernel1, blocks, threads, Args, 0, 0));
// Get the result back to host memory
HIPCHECK(hipMemcpy(&A, A_d, sizeof(int), hipMemcpyDeviceToHost));
@@ -84,7 +84,7 @@ bool LaunchKernelArg2()
HIPCHECK(hipMemcpy(B_d, &B, sizeof(int), hipMemcpyHostToDevice));
void* Args[]={&A_d, &B_d};
HIPCHECK(hipLaunchKernel(kernel2, blocks, threads, Args,0,0));
HIPCHECK(hipLaunchKernel((const void *)kernel2, blocks, threads, Args,0,0));
// Get the result back to host memory
HIPCHECK(hipMemcpy(&A, A_d, sizeof(int), hipMemcpyDeviceToHost));
@@ -123,7 +123,7 @@ bool LaunchKernelArg3()
HIPCHECK(hipMemcpy(B_d, &B, sizeof(int), hipMemcpyHostToDevice));
void* Args[]={&A_d, &B_d, &C_d};
HIPCHECK(hipLaunchKernel(kernel3, blocks, threads, Args,0,0));
HIPCHECK(hipLaunchKernel((const void *)kernel3, blocks, threads, Args,0,0));
// Get the result back to host memory
HIPCHECK(hipMemcpy(&C, C_d, sizeof(int), hipMemcpyDeviceToHost));
@@ -154,7 +154,7 @@ bool LaunchKernelArg4()
struct things t = {2,20,200};
void* Args[]={&A_d, &c, &s, &i, &t};
HIPCHECK(hipLaunchKernel(kernel4, blocks, threads, Args, 0, 0));
HIPCHECK(hipLaunchKernel((const void *)kernel4, blocks, threads, Args, 0, 0));
// Get the result back to host memory
HIPCHECK(hipMemcpy(&A, A_d, sizeof(int), hipMemcpyDeviceToHost));
hipamd/tests/src/gcc/hipMalloc.c
+4 -4
View File
@@ -18,10 +18,10 @@
* */
/* HIT_START
* BUILD_CMD: hipMalloc %cc -D__HIP_PLATFORM_NVCC__ -I%hip-path/include -I/usr/local/cuda/include %S/%s -o %T/hipMalloc_nv -L/usr/local/cuda/lib64 -lcudart EXCLUDE_HIP_PLATFORM hcc
* BUILD_CMD: hipMalloc %cc -D__HIP_PLATFORM_HCC__ -I%hip-path/include %S/%s -Wl,--rpath=%hip-path/lib %hip-path/lib/libhip_hcc.so -o %T/hipMalloc_hcc EXCLUDE_HIP_PLATFORM nvcc
* TEST: hipMalloc_nv EXCLUDE_HIP_PLATFORM hcc
* TEST: hipMalloc_hcc EXCLUDE_HIP_PLATFORM nvcc
* BUILD_CMD: hipMalloc %cc -D__HIP_PLATFORM_NVCC__ -I%hip-path/include -I/usr/local/cuda/include %S/%s -o %T/hipMalloc_nv -L/usr/local/cuda/lib64 -lcudart EXCLUDE_HIP_PLATFORM hcc vdi
* BUILD_CMD: hipMalloc %cc -D__HIP_PLATFORM_HCC__ -I%hip-path/include %S/%s -Wl,--rpath=%hip-path/lib %hip-path/lib/libhip_hcc.so -o %T/hipMalloc_hcc EXCLUDE_HIP_PLATFORM nvcc vdi
* TEST: hipMalloc_nv EXCLUDE_HIP_PLATFORM hcc vdi
* TEST: hipMalloc_hcc EXCLUDE_HIP_PLATFORM nvcc vdi
* HIT_END
*/
hipamd/tests/src/hiprtc/hiprtcGetLoweredName.cpp
+1 -1
View File
@@ -20,7 +20,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s ../test_common.cpp LINK_OPTIONS hiprtc EXCLUDE_HIP_PLATFORM nvcc
* BUILD: %t %s ../test_common.cpp LINK_OPTIONS hiprtc EXCLUDE_HIP_PLATFORM nvcc vdi
* TEST: %t
* HIT_END
*/
hipamd/tests/src/hiprtc/saxpy.cpp
+2 -2
View File
@@ -20,7 +20,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s ../test_common.cpp LINK_OPTIONS hiprtc EXCLUDE_HIP_PLATFORM nvcc
* BUILD: %t %s ../test_common.cpp LINK_OPTIONS hiprtc EXCLUDE_HIP_PLATFORM nvcc vdi
* TEST: %t
* HIT_END
*/
@@ -143,7 +143,7 @@ int main()
hipMemcpyDtoH(hOut.get(), dOut, bufferSize);
for (size_t i = 0; i < n; ++i) {
if (a * hX[i] + hY[i] != hOut[i]) { failed("Validation failed."); }
if (fabs(a * hX[i] + hY[i] - hOut[i]) > fabs(hOut[i])* 1e-6) { failed("Validation failed."); }
}
hipFree(dX);
hipamd/tests/src/hostcall/hipHostcallFuncCall.cpp
+1 -1
View File
@@ -21,7 +21,7 @@ THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s EXCLUDE_HIP_PLATFORM all
* BUILD: %t %s EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* HIT_END
*/
hipamd/tests/src/hostcall/hipHostcallPrintThings.cpp
+1 -1
View File
@@ -21,7 +21,7 @@ THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s EXCLUDE_HIP_PLATFORM all
* BUILD: %t %s EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* HIT_END
*/
hipamd/tests/src/kernel/hipExtLaunchKernelGGL.cpp
+2 -1
View File
@@ -30,7 +30,7 @@ THE SOFTWARE.
void test(size_t N) {
size_t Nbytes = N * sizeof(int);
#if defined(__HIP_PLATFORM_HCC__) && GENERIC_GRID_LAUNCH == 1 && defined(__HCC__)
int *A_d, *B_d, *C_d;
int *A_h, *B_h, *C_h;
@@ -51,6 +51,7 @@ void test(size_t N) {
HIPCHECK(hipDeviceSynchronize());
HipTest::checkVectorADD(A_h, B_h, C_h, N);
#endif
}
int main(int argc, char* argv[]) {
hipamd/tests/src/p2p/hipPeerToPeer_simple.cpp
+3 -3
View File
@@ -24,9 +24,9 @@ THE SOFTWARE.
/* HIT_START
* BUILD: %t %s ../test_common.cpp
* TEST: %t EXCLUDE_HIP_PLATFORM hcc
* TEST: %t --memcpyWithPeer EXCLUDE_HIP_PLATFORM hcc
* TEST: %t --mirrorPeers EXCLUDE_HIP_PLATFORM hcc
* TEST: %t EXCLUDE_HIP_PLATFORM hcc vdi
* TEST: %t --memcpyWithPeer EXCLUDE_HIP_PLATFORM hcc vdi
* TEST: %t --mirrorPeers EXCLUDE_HIP_PLATFORM hcc vdi
* HIT_END
*/
hipamd/tests/src/printf/hipPrintfAltForms.cpp
+76
View File
@@ -0,0 +1,76 @@
/*
Copyright (c) 2020 - present Advanced Micro Devices, Inc. All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* TEST: %t EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* HIT_END
*/
#include "test_common.h"
#include "printf_common.h"
__global__ void test_kernel() {
printf("%#o\n", 042);
printf("%#x\n", 0x42);
printf("%#X\n", 0x42);
printf("%#08x\n", 0x42);
printf("%#f\n", -123.456);
printf("%#F\n", 123.456);
printf("%#e\n", 123.456);
printf("%#E\n", -123.456);
printf("%#g\n", -123.456);
printf("%#G\n", 123.456);
printf("%#a\n", 123.456);
printf("%#A\n", -123.456);
printf("%#.8x\n", 0x42);
printf("%#16.8x\n", 0x42);
printf("%-#16.8x\n", 0x42);
}
int main(int argc, char **argv) {
std::string reference(R"here(042
0x42
0X42
0x000042
-123.456000
123.456000
1.234560e+02
-1.234560E+02
-123.456
123.456
0x1.edd2f1a9fbe77p+6
-0X1.EDD2F1A9FBE77P+6
0x00000042
0x00000042
0x00000042
)here");
CaptureStream captured(stdout);
hipLaunchKernelGGL(test_kernel, dim3(1), dim3(1), 0, 0);
hipStreamSynchronize(0);
auto CapturedData = captured.getCapturedData();
std::string device_output = gulp(CapturedData);
HIPASSERT(device_output == reference);
passed();
}
hipamd/tests/src/printf/hipPrintfBasic.cpp
+275
View File
@@ -0,0 +1,275 @@
/*
Copyright (c) 2020 - present Advanced Micro Devices, Inc. All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* TEST: %t EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* HIT_END
*/
#include "test_common.h"
#include "printf_common.h"
#include <vector>
// Global string constants don't work inside device functions, so we
// use a macro to repeat the declaration in host and device contexts.
DECLARE_DATA();
__global__ void kernel_uniform0(int *retval) {
uint tid = hipThreadIdx_x + hipBlockIdx_x * hipBlockDim_x;
retval[tid] = printf("Hello World\n");
}
static void test_uniform0(int *retval, uint num_blocks,
uint threads_per_block) {
CaptureStream captured(stdout);
uint num_threads = num_blocks * threads_per_block;
for (uint i = 0; i != num_threads; ++i) {
retval[i] = 0x23232323;
}
hipLaunchKernelGGL(kernel_uniform0, dim3(num_blocks), dim3(threads_per_block),
0, 0, retval);
hipStreamSynchronize(0);
auto CapturedData = captured.getCapturedData();
for (uint ii = 0; ii != num_threads; ++ii) {
HIPASSERT(retval[ii] == strlen("Hello World\n"));
}
std::map<std::string, int> linecount;
for (std::string line; std::getline(CapturedData, line);) {
linecount[line]++;
}
HIPASSERT(linecount.size() == 1);
HIPASSERT(linecount["Hello World"] == num_threads);
}
__global__ void kernel_uniform1(int *retval) {
uint tid = hipThreadIdx_x + hipBlockIdx_x * hipBlockDim_x;
retval[tid] = printf("Six times Eight is %d\n", 42);
}
static void test_uniform1(int *retval, uint num_blocks,
uint threads_per_block) {
CaptureStream captured(stdout);
uint num_threads = num_blocks * threads_per_block;
for (uint i = 0; i != num_threads; ++i) {
retval[i] = 0x23232323;
}
hipLaunchKernelGGL(kernel_uniform1, dim3(num_blocks), dim3(threads_per_block),
0, 0, retval);
hipStreamSynchronize(0);
auto CapturedData = captured.getCapturedData();
for (uint ii = 0; ii != num_threads; ++ii) {
HIPASSERT(retval[ii] == strlen("Six times Eight is 42") + 1);
}
std::map<std::string, int> linecount;
for (std::string line; std::getline(CapturedData, line);) {
linecount[line]++;
}
HIPASSERT(linecount.size() == 1);
HIPASSERT(linecount["Six times Eight is 42"] == num_threads);
}
__global__ void kernel_divergent0(int *retval) {
uint tid = hipThreadIdx_x + hipBlockIdx_x * hipBlockDim_x;
retval[tid] = printf("Thread ID: %d\n", tid);
}
static void test_divergent0(int *retval, uint num_blocks,
uint threads_per_block) {
CaptureStream captured(stdout);
uint num_threads = num_blocks * threads_per_block;
for (uint i = 0; i != num_threads; ++i) {
retval[i] = 0x23232323;
}
hipLaunchKernelGGL(kernel_divergent0, dim3(num_blocks),
dim3(threads_per_block), 0, 0, retval);
hipStreamSynchronize(0);
auto CapturedData = captured.getCapturedData();
for (uint ii = 0; ii != 10; ++ii) {
HIPASSERT(retval[ii] == 13);
}
for (uint ii = 10; ii != num_threads; ++ii) {
HIPASSERT(retval[ii] == 14);
}
std::vector<uint> threadIds;
for (std::string line; std::getline(CapturedData, line);) {
auto pos = line.find(':');
HIPASSERT(line.substr(0, pos) == "Thread ID");
threadIds.push_back(std::stoul(line.substr(pos + 2)));
}
std::sort(threadIds.begin(), threadIds.end());
HIPASSERT(threadIds.size() == num_threads);
HIPASSERT(threadIds.back() == num_threads - 1);
}
__global__ void kernel_divergent1(int *retval) {
uint tid = hipThreadIdx_x + hipBlockIdx_x * hipBlockDim_x;
if (tid % 2) {
retval[tid] = printf("Hello World\n");
} else {
retval[tid] = -1;
}
}
static void test_divergent1(int *retval, uint num_blocks,
uint threads_per_block) {
CaptureStream captured(stdout);
uint num_threads = num_blocks * threads_per_block;
for (uint i = 0; i != num_threads; ++i) {
retval[i] = 0x23232323;
}
hipLaunchKernelGGL(kernel_divergent1, dim3(num_blocks),
dim3(threads_per_block), 0, 0, retval);
hipStreamSynchronize(0);
auto CapturedData = captured.getCapturedData();
for (uint ii = 0; ii != num_threads; ++ii) {
if (ii % 2) {
HIPASSERT(retval[ii] == strlen("Hello World\n"));
} else {
HIPASSERT(retval[ii] == -1);
}
}
std::map<std::string, int> linecount;
for (std::string line; std::getline(CapturedData, line);) {
linecount[line]++;
}
HIPASSERT(linecount.size() == 1);
HIPASSERT(linecount["Hello World"] == num_threads / 2);
}
__global__ void kernel_series(int *retval) {
DECLARE_DATA();
const uint tid = hipThreadIdx_x + hipBlockIdx_x * hipBlockDim_x;
int result = 0;
result += printf("%s\n", msg_long1);
result += printf("%s\n", msg_short);
result += printf("%s\n", msg_long2);
retval[tid] = result;
}
static void test_series(int *retval, uint num_blocks, uint threads_per_block) {
CaptureStream captured(stdout);
uint num_threads = num_blocks * threads_per_block;
for (uint i = 0; i != num_threads; ++i) {
retval[i] = 0x23232323;
}
hipLaunchKernelGGL(kernel_series, dim3(num_blocks), dim3(threads_per_block),
0, 0, retval);
hipStreamSynchronize(0);
auto CapturedData = captured.getCapturedData();
for (uint ii = 0; ii != num_threads; ++ii) {
HIPASSERT(retval[ii] ==
strlen(msg_long1) + strlen(msg_short) + strlen(msg_long2) + 3);
}
std::map<std::string, int> linecount;
for (std::string line; std::getline(CapturedData, line);) {
linecount[line]++;
}
HIPASSERT(linecount.size() == 3);
HIPASSERT(linecount[msg_long1] == num_threads);
HIPASSERT(linecount[msg_long2] == num_threads);
HIPASSERT(linecount[msg_short] == num_threads);
}
__global__ void kernel_divergent_loop() {
DECLARE_DATA();
const uint tid = hipThreadIdx_x + hipBlockIdx_x * hipBlockDim_x;
int result = 0;
for (int i = 0; i <= tid; ++i) {
printf("%d\n", i);
}
}
static void test_divergent_loop(uint num_blocks, uint threads_per_block) {
CaptureStream captured(stdout);
uint num_threads = num_blocks * threads_per_block;
hipLaunchKernelGGL(kernel_divergent_loop, dim3(num_blocks), dim3(threads_per_block),
0, 0);
hipStreamSynchronize(0);
auto CapturedData = captured.getCapturedData();
std::map<int, int> count;
while (true) {
int i;
CapturedData >> i;
if (CapturedData.fail())
break;
count[i]++;
}
HIPASSERT(count.size() == num_threads);
for (int i = 0; i != num_threads; ++i) {
HIPASSERT(count[i] == num_threads - i);
}
}
int main() {
uint num_blocks = 1;
uint threads_per_block = 64;
uint num_threads = num_blocks * threads_per_block;
void *retval_void;
HIPCHECK(hipHostMalloc(&retval_void, 4 * num_threads));
auto retval = reinterpret_cast<int *>(retval_void);
test_uniform0(retval, num_blocks, threads_per_block);
test_uniform1(retval, num_blocks, threads_per_block);
test_divergent0(retval, num_blocks, threads_per_block);
test_divergent1(retval, num_blocks, threads_per_block);
test_series(retval, num_blocks, threads_per_block);
test_divergent_loop(num_blocks, threads_per_block);
passed();
}
hipamd/tests/src/printf/hipPrintfFlags.cpp
+68
View File
@@ -0,0 +1,68 @@
/*
Copyright (c) 2020 - present Advanced Micro Devices, Inc. All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* TEST: %t EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* HIT_END
*/
#include "test_common.h"
#include "printf_common.h"
__global__ void test_kernel() {
printf("%08d\n", 42);
printf("%08i\n", -42);
printf("%08u\n", 42);
printf("%08g\n", 123.456);
printf("%0+8d\n", 42);
printf("%+d\n", -42);
printf("%+08d\n", 42);
printf("%-8s\n", "xyzzy");
printf("% i\n", -42);
printf("%-16.8d\n", 42);
printf("%16.8d\n", 42);
}
int main(int argc, char **argv) {
std::string reference(R"here(00000042
-0000042
00000042
0123.456
+0000042
-42
+0000042
xyzzy
-42
00000042
00000042
)here");
CaptureStream captured(stdout);
hipLaunchKernelGGL(test_kernel, dim3(1), dim3(1), 0, 0);
hipStreamSynchronize(0);
auto CapturedData = captured.getCapturedData();
std::string device_output = gulp(CapturedData);
HIPASSERT(device_output == reference);
passed();
}
hipamd/tests/src/printf/hipPrintfManyDevices.cpp
+77
View File
@@ -0,0 +1,77 @@
/*
Copyright (c) 2020 - present Advanced Micro Devices, Inc. All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* TEST: %t EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* HIT_END
*/
#include "test_common.h"
#include "printf_common.h"
DECLARE_DATA();
__global__ void print_things() {
DECLARE_DATA();
uint tid = hipThreadIdx_x + hipBlockIdx_x * hipBlockDim_x;
const char *msg[] = {msg_short, msg_long1, msg_long2};
printf("%s\n", msg[tid % 3]);
if (tid % 3 == 0)
printf("%s\n", msg_short);
printf("%s\n", msg[(tid + 1) % 3]);
printf("%s\n", msg[(tid + 2) % 3]);
}
int main() {
uint num_blocks = 14;
uint threads_per_block = 250;
uint threads_per_device = num_blocks * threads_per_block;
int num_devices = 0;
hipGetDeviceCount(&num_devices);
CaptureStream captured(stdout);
for (int i = 0; i != num_devices; ++i) {
hipSetDevice(i);
hipLaunchKernelGGL(print_things, dim3(num_blocks), dim3(threads_per_block),
0, 0);
hipDeviceSynchronize();
}
auto CapturedData = captured.getCapturedData();
std::map<std::string, int> linecount;
for (std::string line; std::getline(CapturedData, line);) {
linecount[line]++;
}
uint num_threads = threads_per_device * num_devices;
HIPASSERT(linecount.size() == 3);
HIPASSERT(linecount[msg_long1] == num_threads);
HIPASSERT(linecount[msg_long2] == num_threads);
HIPASSERT(linecount[msg_short] ==
num_threads + ((threads_per_device + 2) / 3) * num_devices);
passed();
}
hipamd/tests/src/printf/hipPrintfManyWaves.cpp
+301
View File
@@ -0,0 +1,301 @@
/*
Copyright (c) 2020 - present Advanced Micro Devices, Inc. All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* TEST: %t EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* HIT_END
*/
#include "test_common.h"
#include "printf_common.h"
#include <vector>
// Global string constants don't work inside device functions, so we
// use a macro to repeat the declaration in host and device contexts.
DECLARE_DATA();
__global__ void kernel_mixed0(int *retval) {
DECLARE_DATA();
uint tid = hipThreadIdx_x + hipBlockIdx_x * hipBlockDim_x;
ulong result = 0;
// Three strings passed as divergent values to the same hostcall.
const char *msg;
switch (tid % 3) {
case 0:
msg = msg_short;
break;
case 1:
msg = msg_long1;
break;
case 2:
msg = msg_long2;
break;
}
retval[tid] = printf("%s\n", msg);
}
static void test_mixed0(int *retval, uint num_blocks, uint threads_per_block) {
CaptureStream captured(stdout);
uint num_threads = num_blocks * threads_per_block;
for (uint i = 0; i != num_threads; ++i) {
retval[i] = 0x23232323;
}
hipLaunchKernelGGL(kernel_mixed0, dim3(num_blocks), dim3(threads_per_block),
0, 0, retval);
hipStreamSynchronize(0);
auto CapturedData = captured.getCapturedData();
for (uint ii = 0; ii != num_threads; ++ii) {
switch (ii % 3) {
case 0:
HIPASSERT(retval[ii] == strlen(msg_short) + 1);
break;
case 1:
HIPASSERT(retval[ii] == strlen(msg_long1) + 1);
break;
case 2:
HIPASSERT(retval[ii] == strlen(msg_long2) + 1);
break;
}
}
std::map<std::string, int> linecount;
for (std::string line; std::getline(CapturedData, line);) {
linecount[line]++;
}
HIPASSERT(linecount.size() == 3);
HIPASSERT(linecount[msg_short] == (num_threads + 2) / 3);
HIPASSERT(linecount[msg_long1] == (num_threads + 1) / 3);
HIPASSERT(linecount[msg_long2] == (num_threads + 0) / 3);
}
__global__ void kernel_mixed1(int *retval) {
DECLARE_DATA();
const uint tid = hipThreadIdx_x + hipBlockIdx_x * hipBlockDim_x;
// Three strings passed to divergent hostcalls.
switch (tid % 3) {
case 0:
retval[tid] = printf("%s\n", msg_short);
break;
case 1:
retval[tid] = printf("%s\n", msg_long1);
break;
case 2:
retval[tid] = printf("%s\n", msg_long2);
break;
}
}
static void test_mixed1(int *retval, uint num_blocks, uint threads_per_block) {
CaptureStream captured(stdout);
uint num_threads = num_blocks * threads_per_block;
for (uint i = 0; i != num_threads; ++i) {
retval[i] = 0x23232323;
}
hipLaunchKernelGGL(kernel_mixed1, dim3(num_blocks), dim3(threads_per_block),
0, 0, retval);
hipStreamSynchronize(0);
auto CapturedData = captured.getCapturedData();
for (uint ii = 0; ii != num_threads; ++ii) {
switch (ii % 3) {
case 0:
HIPASSERT(retval[ii] == strlen(msg_short) + 1);
break;
case 1:
HIPASSERT(retval[ii] == strlen(msg_long1) + 1);
break;
case 2:
HIPASSERT(retval[ii] == strlen(msg_long2) + 1);
break;
}
}
std::map<std::string, int> linecount;
for (std::string line; std::getline(CapturedData, line);) {
linecount[line]++;
}
HIPASSERT(linecount.size() == 3);
HIPASSERT(linecount[msg_short] == (num_threads + 2) / 3);
HIPASSERT(linecount[msg_long1] == (num_threads + 1) / 3);
HIPASSERT(linecount[msg_long2] == (num_threads + 0) / 3);
}
__global__ void kernel_mixed2(int *retval) {
DECLARE_DATA();
const uint tid = hipThreadIdx_x + hipBlockIdx_x * hipBlockDim_x;
// Three different strings. All workitems print all three, but
// in different orders.
const char *msg[] = {msg_short, msg_long1, msg_long2};
retval[tid] =
printf("%s%s%s\n", msg[tid % 3], msg[(tid + 1) % 3], msg[(tid + 2) % 3]);
}
static void test_mixed2(int *retval, uint num_blocks, uint threads_per_block) {
CaptureStream captured(stdout);
uint num_threads = num_blocks * threads_per_block;
for (uint i = 0; i != num_threads; ++i) {
retval[i] = 0x23232323;
}
hipLaunchKernelGGL(kernel_mixed2, dim3(num_blocks), dim3(threads_per_block),
0, 0, retval);
hipStreamSynchronize(0);
auto CapturedData = captured.getCapturedData();
for (uint ii = 0; ii != num_threads; ++ii) {
HIPASSERT(retval[ii] ==
strlen(msg_short) + strlen(msg_long1) + strlen(msg_long2) + 1);
}
std::map<std::string, int> linecount;
for (std::string line; std::getline(CapturedData, line);) {
linecount[line]++;
}
std::string str1 =
std::string(msg_short) + std::string(msg_long1) + std::string(msg_long2);
std::string str2 =
std::string(msg_long1) + std::string(msg_long2) + std::string(msg_short);
std::string str3 =
std::string(msg_long2) + std::string(msg_short) + std::string(msg_long1);
HIPASSERT(linecount.size() == 3);
HIPASSERT(linecount[str1] == (num_threads + 2) / 3);
HIPASSERT(linecount[str2] == (num_threads + 1) / 3);
HIPASSERT(linecount[str3] == (num_threads + 0) / 3);
}
__global__ void kernel_mixed3(int *retval) {
DECLARE_DATA();
const uint tid = hipThreadIdx_x + hipBlockIdx_x * hipBlockDim_x;
int result = 0;
result += printf("%s\n", msg_long1);
if (tid % 3 == 0) {
result += printf("%s\n", msg_short);
}
result += printf("%s\n", msg_long2);
retval[tid] = result;
}
static void test_mixed3(int *retval, uint num_blocks, uint threads_per_block) {
CaptureStream captured(stdout);
uint num_threads = num_blocks * threads_per_block;
for (uint i = 0; i != num_threads; ++i) {
retval[i] = 0x23232323;
}
hipLaunchKernelGGL(kernel_mixed3, dim3(num_blocks), dim3(threads_per_block),
0, 0, retval);
hipStreamSynchronize(0);
auto CapturedData = captured.getCapturedData();
for (uint ii = 0; ii != num_threads; ++ii) {
if (ii % 3 == 0) {
HIPASSERT(retval[ii] ==
strlen(msg_long1) + strlen(msg_short) + strlen(msg_long2) + 3);
} else {
HIPASSERT(retval[ii] == strlen(msg_long1) + strlen(msg_long2) + 2);
}
}
std::map<std::string, int> linecount;
for (std::string line; std::getline(CapturedData, line);) {
linecount[line]++;
}
HIPASSERT(linecount.size() == 3);
HIPASSERT(linecount[msg_long1] == num_threads);
HIPASSERT(linecount[msg_long2] == num_threads);
HIPASSERT(linecount[msg_short] == (num_threads + 2) / 3);
}
__global__ void kernel_numbers() {
uint tid = hipThreadIdx_x + hipBlockIdx_x * hipBlockDim_x;
for (uint i = 0; i != 7; ++i) {
uint base = tid * 21 + i * 3;
printf("%d %d %d\n", base, base + 1, base + 2);
}
}
static void test_numbers(uint num_blocks, uint threads_per_block) {
CaptureStream captured(stdout);
uint num_threads = num_blocks * threads_per_block;
hipLaunchKernelGGL(kernel_numbers, dim3(num_blocks), dim3(threads_per_block),
0, 0);
hipStreamSynchronize(0);
auto CapturedData = captured.getCapturedData();
std::vector<uint> points;
while (true) {
uint i;
CapturedData >> i;
if (CapturedData.fail())
break;
points.push_back(i);
}
std::sort(points.begin(), points.end());
points.erase(std::unique(points.begin(), points.end()), points.end());
HIPASSERT(points.size() == 21 * num_threads);
HIPASSERT(points.back() == 21 * num_threads - 1);
passed();
}
int main(int argc, char **argv) {
uint num_blocks = 150;
uint threads_per_block = 250;
uint num_threads = num_blocks * threads_per_block;
void *retval_void;
HIPCHECK(hipHostMalloc(&retval_void, 4 * num_threads));
auto retval = reinterpret_cast<int *>(retval_void);
test_mixed0(retval, num_blocks, threads_per_block);
test_mixed1(retval, num_blocks, threads_per_block);
test_mixed2(retval, num_blocks, threads_per_block);
test_mixed3(retval, num_blocks, threads_per_block);
test_numbers(num_blocks, threads_per_block);
passed();
}
hipamd/tests/src/printf/hipPrintfSpecifiers.cpp
+90
View File
@@ -0,0 +1,90 @@
/*
Copyright (c) 2020 - present Advanced Micro Devices, Inc. All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* TEST: %t EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* HIT_END
*/
#include "test_common.h"
#include "printf_common.h"
__global__ void test_kernel() {
const char *N = nullptr;
const char *s = "hello world";
printf("xyzzy\n");
printf("%%\n");
printf("hello %% world\n");
printf("%%s\n");
// Two special tests to make sure that the compiler pass correctly
// skips over a '%%' without affecting the logic for locating
// string arguments.
printf("%%s%p\n", (void *)0xf01dab1eca55e77e);
printf("%%c%s\n", "xyzzy");
printf("%c%c%c\n", 's', 'e', 'p');
printf("%d\n", -42);
printf("%u\n", 42);
printf("%f\n", 123.456);
printf("%F\n", -123.456);
printf("%e\n", -123.456);
printf("%E\n", 123.456);
printf("%g\n", 123.456);
printf("%G\n", -123.456);
printf("%c\n", 'x');
printf("%s\n", N);
printf("%p\n", N);
printf("%.*f %*.*s %p\n", 8, 3.14159, 8, 5, s, (void *)0xf01dab1eca55e77e);
}
int main(int argc, char **argv) {
std::string reference(R"here(xyzzy
%
hello % world
%s
%s0xf01dab1eca55e77e
%cxyzzy
sep
-42
42
123.456000
-123.456000
-1.234560e+02
1.234560E+02
123.456
-123.456
x
(nil)
3.14159000 hello 0xf01dab1eca55e77e
)here");
CaptureStream captured(stdout);
hipLaunchKernelGGL(test_kernel, dim3(1), dim3(1), 0, 0);
hipStreamSynchronize(0);
auto CapturedData = captured.getCapturedData();
std::string device_output = gulp(CapturedData);
HIPASSERT(device_output == reference);
passed();
}
hipamd/tests/src/printf/hipPrintfStar.cpp
+54
View File
@@ -0,0 +1,54 @@
/*
Copyright (c) 2020 - present Advanced Micro Devices, Inc. All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* TEST: %t EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* HIT_END
*/
#include "test_common.h"
#include "printf_common.h"
__global__ void test_kernel() {
printf("%*d\n", 16, 42);
printf("%.*d\n", 8, 42);
printf("%*.*d\n", -16, 8, 42);
printf("%*.*f %s * %.*s\n", 16, 8, 123.456, "hello", 5, "worldxyz");
}
int main(int argc, char **argv) {
std::string reference(R"here( 42
00000042
00000042
123.45600000 hello * world
)here");
CaptureStream captured(stdout);
hipLaunchKernelGGL(test_kernel, dim3(1), dim3(1), 0, 0);
hipStreamSynchronize(0);
auto CapturedData = captured.getCapturedData();
std::string device_output = gulp(CapturedData);
HIPASSERT(device_output == reference);
passed();
}
hipamd/tests/src/printf/hipPrintfWidthPrecision.cpp
+74
View File
@@ -0,0 +1,74 @@
/*
Copyright (c) 2020 - present Advanced Micro Devices, Inc. All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* TEST: %t EXCLUDE_HIP_PLATFORM nvcc EXCLUDE_HIP_RUNTIME HCC EXCLUDE_HIP_COMPILER hcc
* HIT_END
*/
#include "test_common.h"
#include "printf_common.h"
__global__ void test_kernel() {
printf("%16d\n", 42);
printf("%.8d\n", 42);
printf("%16.5d\n", -42);
printf("%.8x\n", 0x42);
printf("%.8o\n", 042);
printf("%16.8e\n", 12345.67891);
printf("%16.8f\n", -12345.67891);
printf("%16.8g\n", 12345.67891);
printf("%8.4e\n", -12345.67891);
printf("%8.4f\n", 12345.67891);
printf("%8.4g\n", 12345.67891);
printf("%4.2f\n", 12345.67891);
printf("%.1f\n", 12345.67891);
printf("%.5s\n", "helloxyz");
}
int main(int argc, char **argv) {
std::string reference(R"here( 42
00000042
-00042
00000042
00000042
1.23456789e+04
-12345.67891000
12345.679
-1.2346e+04
12345.6789
1.235e+04
12345.68
12345.7
hello
)here");
CaptureStream captured(stdout);
hipLaunchKernelGGL(test_kernel, dim3(1), dim3(1), 0, 0);
hipStreamSynchronize(0);
auto CapturedData = captured.getCapturedData();
std::string device_output = gulp(CapturedData);
HIPASSERT(device_output == reference);
passed();
}
hipamd/tests/src/printf/printf_common.h
+94
View File
@@ -0,0 +1,94 @@
#ifndef COMMON_H
#define COMMON_H
#include <errno.h>
#include <error.h>
#include <fstream>
#include <iostream>
#include <map>
#include <stdlib.h>
#include <string>
#include <unistd.h>
struct CaptureStream {
int saved_fd;
int orig_fd;
int temp_fd;
char tempname[13] = "mytestXXXXXX";
CaptureStream(FILE *original) {
orig_fd = fileno(original);
saved_fd = dup(orig_fd);
temp_fd = mkstemp(tempname);
if (errno) {
error(0, errno, "Error");
assert(false);
}
fflush(nullptr);
dup2(temp_fd, orig_fd);
if (errno) {
error(0, errno, "Error");
assert(false);
}
close(temp_fd);
if (errno) {
error(0, errno, "Error");
assert(false);
}
}
void restoreStream() {
if (saved_fd == -1)
return;
fflush(nullptr);
dup2(saved_fd, orig_fd);
if (errno) {
error(0, errno, "Error");
assert(false);
}
close(saved_fd);
if (errno) {
error(0, errno, "Error");
assert(false);
}
saved_fd = -1;
}
std::ifstream getCapturedData() {
restoreStream();
std::ifstream temp(tempname);
return temp;
}
~CaptureStream() {
restoreStream();
remove(tempname);
if (errno) {
error(0, errno, "Error");
assert(false);
}
}
};
static std::string gulp(std::ifstream &input) {
std::string retval;
input.seekg(0, std::ios_base::end);
retval.resize(input.tellg());
input.seekg(0, std::ios_base::beg);
input.read(&retval[0], retval.size());
input.close();
return retval;
}
#define DECLARE_DATA() \
const char *msg_short = "Carpe diem."; \
const char *msg_long1 = "Lorem ipsum dolor sit amet, consectetur nullam. " \
"In mollis imperdiet nibh nec ullamcorper."; \
const char *msg_long2 = "Curabitur nec metus sit amet augue vehicula " \
"ultrices ut id leo. Lorem ipsum dolor sit amet, " \
"consectetur adipiscing elit amet.";
#endif
hipamd/tests/src/runtimeApi/event/hipEventIpc.cpp
+1 -1
View File
@@ -24,7 +24,7 @@ THE SOFTWARE.
// forces synchronization : set
/* HIT_START
* BUILD: %t %s ../../test_common.cpp EXCLUDE_HIP_PLATFORM nvcc
* BUILD: %t %s ../../test_common.cpp EXCLUDE_HIP_PLATFORM nvcc vdi
* TEST: %t --iterations 10
* HIT_END
*/
hipamd/tests/src/runtimeApi/memory/hipMemcpyNegetiveTests.cpp
+1 -1
View File
@@ -18,7 +18,7 @@
* */
/* HIT_START
* BUILD: %t %s ../../test_common.cpp EXCLUDE_HIP_PLATFORM nvcc
* BUILD: %t %s ../../test_common.cpp EXCLUDE_HIP_PLATFORM nvcc vdi
* TEST: %t
* HIT_END
*/
hipamd/tests/src/runtimeApi/memory/hipMemcpyPeerAsync.cpp
+2 -2
View File
@@ -60,16 +60,16 @@ int main() {
HIPCHECK(hipDeviceSynchronize());
HipTest::checkVectorADD(A_h, B_h, C_h, N);
HIPCHECK(hipStreamCreate(&s));
HIPCHECK(hipSetDevice(1));
HIPCHECK(hipStreamCreate(&s));
HIPCHECK(hipMemcpyPeerAsync(X_d, 1, A_d, 0, Nbytes, s));
HIPCHECK(hipMemcpyPeerAsync(Y_d, 1, B_d, 0, Nbytes, s));
hipLaunchKernelGGL(HipTest::vectorADD, dim3(blocks), dim3(threadsPerBlock), 0, 0,
static_cast<const int*>(X_d), static_cast<const int*>(Y_d), Z_d, N);
HIPCHECK(hipMemcpy(C_h, Z_d, Nbytes, hipMemcpyDeviceToHost));
HIPCHECK(hipDeviceSynchronize());
HIPCHECK(hipStreamSynchronize(s));
HIPCHECK(hipDeviceSynchronize());
HipTest::checkVectorADD(A_h, B_h, C_h, N);
HIPCHECK(hipStreamDestroy(s));
hipamd/tests/src/runtimeApi/memory/p2p_copy_coherency.cpp
+8 -5
View File
@@ -26,17 +26,19 @@ THE SOFTWARE.
* BUILD: %t %s ../../test_common.cpp NVCC_OPTIONS --std=c++11
* TEST: %t EXCLUDE_HIP_PLATFORM all
* HIT_END
*/
#include "hip/hip_runtime.h"
#include "test_common.h"
#ifdef __HIP_PLATFORM_HCC__
#include <hc_am.hpp>
#endif
#define USE_HCC_MEMTRACKER 0 /* Debug flag to show the memtracker periodically */
#if defined(__HIP_PLATFORM_HCC__) && !defined(__HIP_VDI__)
#include <hc_am.hpp>
#else
#define USE_HCC_MEMTRACKER 0
#endif
int elementSizes[] = {1, 16, 1024, 524288, 16 * 1000 * 1000};
int nSizes = sizeof(elementSizes) / sizeof(int);
@@ -201,7 +203,8 @@ int main(int argc, char* argv[]) {
};
for (int index = 0; index < nSizes; index++) {
testMultiGpu(dev0, dev1, elementSizes[index], false /*GPU Synchronization*/);
//ToDo: Enable when verified on all platforms
//testMultiGpu(dev0, dev1, elementSizes[index], false /*GPU Synchronization*/);
testMultiGpu(dev0, dev1, elementSizes[index], true /*Host Synchronization*/);
}
hipamd/tests/src/runtimeApi/module/hipExtModuleLaunchKernel.cpp
+1 -1
View File
@@ -19,7 +19,7 @@ THE SOFTWARE.
/* HIT_START
* BUILD_CMD: matmul.code %hc --genco %S/matmul.cpp -o matmul.code EXCLUDE_HIP_PLATFORM nvcc
* BUILD: %t %s ../../test_common.cpp EXCLUDE_HIP_PLATFORM nvcc
* BUILD: %t %s ../../test_common.cpp EXCLUDE_HIP_PLATFORM nvcc vdi
* TEST: %t
* HIT_END
*/
hipamd/tests/src/runtimeApi/module/hipLaunchCoopMultiKernel.cpp
+1 -3
View File
@@ -20,7 +20,7 @@ THE SOFTWARE.
// Simple test for hipLaunchCooperativeKernelMultiDevice API.
/* HIT_START
* BUILD: %t %s ../../test_common.cpp EXCLUDE_HIP_PLATFORM all
* BUILD: %t %s ../../test_common.cpp EXCLUDE_HIP_PLATFORM nvcc
* TEST: %t
* HIT_END
*/
@@ -178,8 +178,6 @@ int main() {
hipLaunchCooperativeKernelMultiDevice(launchParamsList, nGpu, 0);
HIPCHECK(hipMemcpy(init, dC, sizeof(long), hipMemcpyDeviceToHost));
if (*dC != (((long)(BufferSizeInDwords) * (BufferSizeInDwords - 1)) / 2)) {
std::cout << "Data validation failed for grid size = " << dimGrid.x << " and block size = " << dimBlock.x << "\n";
std::cout << "Test failed! \n";
hipamd/tests/src/runtimeApi/module/hipLaunchCooperativeKernel.cpp
+1 -1
View File
@@ -22,7 +22,7 @@ THE SOFTWARE.
// Simple test for hipLaunchCooperativeKernel API.
/* HIT_START
* BUILD: %t %s ../../test_common.cpp EXCLUDE_HIP_PLATFORM all
* BUILD: %t %s ../../test_common.cpp EXCLUDE_HIP_PLATFORM nvcc
* TEST: %t
* HIT_END
*/
hipamd/tests/src/runtimeApi/module/hipModuleLoadDataMultThreaded.cpp
+1 -1
View File
@@ -18,7 +18,7 @@ THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s ../../test_common.cpp NVCC_OPTIONS -std=c++11
* BUILD: %t %s ../../test_common.cpp NVCC_OPTIONS -std=c++11 EXCLUDE_HIP_PLATFORM vdi
* TEST: %t
* HIT_END
*/
hipamd/tests/src/runtimeApi/module/hipModuleTexture2dDrv.cpp
+4 -1
View File
@@ -21,7 +21,7 @@ THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s ../../test_common.cpp EXCLUDE_HIP_PLATFORM nvcc
* BUILD: %t %s ../../test_common.cpp EXCLUDE_HIP_PLATFORM nvcc vdi
* TEST: %t
* HIT_END
*/
@@ -33,6 +33,9 @@ THE SOFTWARE.
#define fileName "tex2d_kernel.code"
#if __HIP__
__hip_pinned_shadow__
#endif
texture<float, 2, hipReadModeElementType> tex;
bool testResult = false;
hipamd/tests/src/runtimeApi/module/tex2d_kernel.cpp
+5 -1
View File
@@ -21,11 +21,15 @@ THE SOFTWARE.
*/
/* HIT_START
* BUILD_CMD: tex2d_kernel.code %hc --genco %S/tex2d_kernel.cpp -o tex2d_kernel.code
* BUILD_CMD: tex2d_kernel.code %hc --genco %S/tex2d_kernel.cpp -o tex2d_kernel.code EXCLUDE_HIP_PLATFORM vdi
* HIT_END
*/
#include "hip/hip_runtime.h"
#if __HIP__
__hip_pinned_shadow__
#endif
extern texture<float, 2, hipReadModeElementType> tex;
extern "C" __global__ void tex2dKernel(float* outputData, int width, int height) {
hipamd/tests/src/runtimeApi/occupancy/hipOccupancyMaxActiveBlocksPerMultiprocessor.cpp
+1 -1
View File
@@ -22,7 +22,7 @@ THE SOFTWARE.
// Test the Grid_Launch syntax.
/* HIT_START
* BUILD: %t %s ../../test_common.cpp
* BUILD: %t %s ../../test_common.cpp EXCLUDE_HIP_PLATFORM vdi
* TEST: %t
* HIT_END
*/
hipamd/tests/src/runtimeApi/stream/hipStreamAddCallbackCatch.cpp
+1 -1
View File
@@ -11,7 +11,7 @@
#include "test_common.h"
/* HIT_START
* BUILD: %t %s ../../test_common.cpp NVCC_OPTIONS -std=c++11
* BUILD: %t %s ../../test_common.cpp NVCC_OPTIONS -std=c++11 EXCLUDE_HIP_PLATFORM vdi
* TEST: %t
* HIT_END
*/
hipamd/tests/src/surface/hipSurfaceObj2D.cpp
+1 -1
View File
@@ -1,5 +1,5 @@
/* HIT_START
* BUILD: %t %s ../test_common.cpp
* BUILD: %t %s ../test_common.cpp EXCLUDE_HIP_PLATFORM vdi
* TEST: %t
* HIT_END
*/
hipamd/tests/src/test_common.h
+4
View File
@@ -55,11 +55,15 @@ THE SOFTWARE.
printf("%sPASSED!%s\n", KGRN, KNRM); \
exit(0);
// The real "assert" would have written to stderr. But it is
// sufficient to just fflush here without getting pedantic. This also
// ensures that we don't lose any earlier writes to stdout.
#define failed(...) \
printf("%serror: ", KRED); \
printf(__VA_ARGS__); \
printf("\n"); \
printf("error: TEST FAILED\n%s", KNRM); \
fflush(NULL); \
abort();
#define warn(...) \
hipamd/tests/src/texture/hipBindTex2DPitch.cpp
+1 -1
View File
@@ -18,7 +18,7 @@ THE SOFTWARE.
*/
/*HIT_START
* BUILD: %t %s ../test_common.cpp
* BUILD: %t %s ../test_common.cpp EXCLUDE_HIP_PLATFORM vdi
* TEST: %t
* HIT_END
*/
hipamd/tests/src/texture/hipBindTexRef1DFetch.cpp
+1 -1
View File
@@ -22,7 +22,7 @@ THE SOFTWARE.
/* HIT_START
* BUILD: %t %s ../test_common.cpp
* BUILD: %t %s ../test_common.cpp EXCLUDE_HIP_PLATFORM vdi
* TEST: %t
* HIT_END
*/
hipamd/tests/src/texture/hipNormalizedFloatValueTex.cpp
+67 -54
View File
@@ -21,7 +21,7 @@ THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s ../test_common.cpp EXCLUDE_HIP_PLATFORM nvcc
* BUILD: %t %s ../test_common.cpp EXCLUDE_HIP_PLATFORM nvcc hcc vdi
* TEST: %t
* HIT_END
*/
@@ -30,78 +30,92 @@ THE SOFTWARE.
#define SIZE 10
static float getNormalizedValue(const float value,
const enum hipArray_Format texFormat) {
switch (texFormat) {
case HIP_AD_FORMAT_SIGNED_INT8:
return (value / SCHAR_MAX);
case HIP_AD_FORMAT_UNSIGNED_INT8:
return (value / UCHAR_MAX);
case HIP_AD_FORMAT_SIGNED_INT16:
return (value / SHRT_MAX);
case HIP_AD_FORMAT_UNSIGNED_INT16:
return (value / USHRT_MAX);
default:
return value;
}
const hipChannelFormatDesc& desc) {
if ((desc.x == 8) && (desc.f == hipChannelFormatKindSigned))
return (value / SCHAR_MAX);
if ((desc.x == 8) && (desc.f == hipChannelFormatKindUnsigned))
return (value / UCHAR_MAX);
if ((desc.x == 16) && (desc.f == hipChannelFormatKindSigned))
return (value / SHRT_MAX);
if ((desc.x == 16) && (desc.f == hipChannelFormatKindUnsigned))
return (value / USHRT_MAX);
return value;
}
#if __HIP__
__hip_pinned_shadow__
#endif
texture<float, hipTextureType1D, hipReadModeElementType> textureNormalizedVal_1D;
texture<char, hipTextureType1D, hipReadModeNormalizedFloat> texc;
#if __HIP__
__hip_pinned_shadow__
#endif
texture<unsigned char, hipTextureType1D, hipReadModeNormalizedFloat> texuc;
#if __HIP__
__hip_pinned_shadow__
#endif
texture<short, hipTextureType1D, hipReadModeNormalizedFloat> texs;
#if __HIP__
__hip_pinned_shadow__
#endif
texture<unsigned short, hipTextureType1D, hipReadModeNormalizedFloat> texus;
template<typename T>
__global__ void normalizedValTextureTest(unsigned int numElements, float* pDst)
{
unsigned int elementID = hipThreadIdx_x;
if(elementID >= numElements)
return;
float coord =(float) elementID/(numElements-1);
pDst[elementID] = tex1D(textureNormalizedVal_1D, coord);
return;
float coord =(float) elementID/numElements;
if(std::is_same<T, char>::value)
pDst[elementID] = tex1D(texc, coord);
else if(std::is_same<T, unsigned char>::value)
pDst[elementID] = tex1D(texuc, coord);
else if(std::is_same<T, short>::value)
pDst[elementID] = tex1D(texs, coord);
else if(std::is_same<T, unsigned short>::value)
pDst[elementID] = tex1D(texus, coord);
}
template<typename T>
bool textureTest(enum hipArray_Format texFormat)
bool textureTest(texture<T, hipTextureType1D, hipReadModeNormalizedFloat> *tex)
{
T hData[] = {65, 66, 67, 68, 69, 70, 71, 72,73,74};
T *dData = NULL;
HIPCHECK(hipMalloc((void **) &dData, sizeof(T)*SIZE));
HIPCHECK(hipMemcpyHtoD((hipDeviceptr_t)dData, hData, sizeof(T)*SIZE));
textureReference* texRef = &textureNormalizedVal_1D;
HIPCHECK(hipTexRefSetAddressMode(texRef, 0, hipAddressModeClamp));
HIPCHECK(hipTexRefSetAddressMode(texRef, 1, hipAddressModeClamp));
HIPCHECK(hipTexRefSetFilterMode(texRef, hipFilterModePoint));
HIPCHECK(hipTexRefSetFlags(texRef, HIP_TRSF_NORMALIZED_COORDINATES));
HIPCHECK(hipTexRefSetFormat(texRef, texFormat, 1));
HIP_ARRAY_DESCRIPTOR desc;
desc.Width = SIZE;
desc.Height = 1;
desc.Format = texFormat;
desc.NumChannels = 1;
HIPCHECK(hipTexRefSetAddress2D(texRef, &desc, (hipDeviceptr_t)dData, sizeof(T)*SIZE));
bool testResult = true;
hipChannelFormatDesc desc = hipCreateChannelDesc<T>();
hipArray_t dData;
HIPCHECK(hipMallocArray(&dData, &desc, SIZE, 1, hipArrayDefault));
T hData[] = {65, 66, 67, 68, 69, 70, 71, 72, 73, 74};
HIPCHECK(hipMemcpy2DToArray(dData, 0, 0, hData, sizeof(T)*SIZE, sizeof(T)*SIZE, 1, hipMemcpyHostToDevice));
tex->normalized = true;
tex->channelDesc = desc;
HIPCHECK(hipBindTextureToArray(tex, dData, &desc));
float *dOutputData = NULL;
HIPCHECK(hipMalloc((void **) &dOutputData, sizeof(float)*SIZE));
hipLaunchKernelGGL(HIP_KERNEL_NAME(normalizedValTextureTest), dim3(1,1,1), dim3(SIZE,1,1), 0, 0, SIZE, dOutputData);
hipLaunchKernelGGL(normalizedValTextureTest<T>, dim3(1,1,1), dim3(SIZE,1,1), 0, 0, SIZE, dOutputData);
float *hOutputData = new float[SIZE];
HIPCHECK(hipMemcpyDtoH(hOutputData, (hipDeviceptr_t)dOutputData, (sizeof(float)*SIZE)));
HIPCHECK(hipMemcpy(hOutputData, dOutputData, (sizeof(float)*SIZE), hipMemcpyDeviceToHost));
bool testResult = true;
for(int i = 0; i < SIZE; i++)
{
float expected = getNormalizedValue(float(hData[i]), texFormat);
float expected = getNormalizedValue(float(hData[i]), desc);
if(expected != hOutputData[i])
{
printf("mismatch at index:%d for texType:%d output:%f\n",i,texFormat,hOutputData[i]);
printf("mismatch at index:%d output:%f expected:%f\n",i,hOutputData[i],expected);
testResult = false;
break;
break;
}
}
hipFree(dData);
hipFree(dOutputData);
hipUnbindTexture(textureNormalizedVal_1D);
HIPCHECK(hipFreeArray(dData));
HIPCHECK(hipFree(dOutputData));
delete [] hOutputData;
return testResult;
}
@@ -118,12 +132,11 @@ int main(int argc, char** argv)
std::cout << "Arch - AMD GPU :: " << props.gcnArch << std::endl;
#endif
status &= textureTest<char> (HIP_AD_FORMAT_SIGNED_INT8);
status &= textureTest<unsigned char> (HIP_AD_FORMAT_UNSIGNED_INT8);
status &= textureTest<short> (HIP_AD_FORMAT_SIGNED_INT16);
status &= textureTest<unsigned short>(HIP_AD_FORMAT_UNSIGNED_INT16);
status &= textureTest<float> (HIP_AD_FORMAT_FLOAT);
status &= textureTest<char> (&texc);
status &= textureTest<unsigned char> (&texuc);
status &= textureTest<short> (&texs);
status &= textureTest<unsigned short>(&texus);
if(status){
passed();
}
hipamd/tests/src/texture/hipTex1DFetchCheckModes.cpp
+2 -2
View File
@@ -17,8 +17,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
/*HIT_START
* BUILD: %t %s ../test_common.cpp
/* HIT_START
* BUILD: %t %s ../test_common.cpp EXCLUDE_HIP_PLATFORM vdi
* TEST: %t
* HIT_END
*/
hipamd/tests/src/texture/hipTextureRef2D.cpp
+1 -1
View File
@@ -1,5 +1,5 @@
/* HIT_START
* BUILD: %t %s ../test_common.cpp
* BUILD: %t %s ../test_common.cpp EXCLUDE_HIP_PLATFORM vdi
* TEST: %t
* HIT_END
*/
hipamd/tests/src/texture/simpleTexture2DLayered.cpp
+1 -1
View File
@@ -21,7 +21,7 @@ THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s ../test_common.cpp
* BUILD: %t %s ../test_common.cpp EXCLUDE_HIP_PLATFORM vdi
* TEST: %t
* HIT_END
*/
hipamd/tests/src/texture/simpleTexture3D.cpp
+29 -22
View File
@@ -21,12 +21,15 @@ THE SOFTWARE.
*/
/* HIT_START
* BUILD: %t %s ../test_common.cpp NVCC_OPTIONS -std=c++11
* BUILD: %t %s ../test_common.cpp EXCLUDE_HIP_PLATFORM nvcc vdi
* TEST: %t
* HIT_END
*/
#include "test_common.h"
//typedef char T;
const char *sampleName = "simpleTexture3D";
// Texture reference for 3D texture
#if __HIP__
__hip_pinned_shadow__
@@ -44,26 +47,29 @@ __hip_pinned_shadow__
texture<char, hipTextureType3D, hipReadModeElementType> texc;
template <typename T>
__global__ void simpleKernel3DArray(T* outputData,
__global__ void simpleKernel3DArray(T* outputData,
int width,
int height,int depth)
{
for (int i = 0; i < depth; i++) {
for (int j = 0; j < height; j++) {
for (int k = 0; k < width; k++) {
if(std::is_same<T, float>::value)
outputData[i*width*height + j*width + k] = tex3D(texf, k, j, i);
else if(std::is_same<T, int>::value)
outputData[i*width*height + j*width + k] = tex3D(texi, k, j, i);
else if(std::is_same<T, char>::value)
outputData[i*width*height + j*width + k] = tex3D(texc, k, j, i);
}
}
for (int j = 0; j < height; j++) {
for (int k = 0; k < width; k++) {
if(std::is_same<T, float>::value)
outputData[i*width*height + j*width + k] = tex3D(texf, k, j, i);
else if(std::is_same<T, int>::value)
outputData[i*width*height + j*width + k] = tex3D(texi, k, j, i);
else if(std::is_same<T, char>::value)
outputData[i*width*height + j*width + k] = tex3D(texc, k, j, i);
}
}
}
}
////////////////////////////////////////////////////////////////////////////////
//! Run a simple test for tex3D
////////////////////////////////////////////////////////////////////////////////
template <typename T>
void runTest(int width,int height,int depth,texture<T, hipTextureType3D, hipReadModeElementType> *tex, hipChannelFormatKind formatKind)
void runTest(int width,int height,int depth,texture<T, hipTextureType3D, hipReadModeElementType> *tex)
{
unsigned int size = width * height * depth * sizeof(T);
T* hData = (T*) malloc(size);
@@ -78,7 +84,7 @@ void runTest(int width,int height,int depth,texture<T, hipTextureType3D, hipRead
}
// Allocate array and copy image data
hipChannelFormatDesc channelDesc = hipCreateChannelDesc(sizeof(T)*8, 0, 0, 0, formatKind);
hipChannelFormatDesc channelDesc = hipCreateChannelDesc<T>();
hipArray *arr;
HIPCHECK(hipMalloc3DArray(&arr, &channelDesc, make_hipExtent(width, height, depth), hipArrayDefault));
@@ -88,11 +94,7 @@ void runTest(int width,int height,int depth,texture<T, hipTextureType3D, hipRead
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T), width, height);
myparms.dstArray = arr;
myparms.extent = make_hipExtent(width, height, depth);
#ifdef __HIP_PLATFORM_NVCC__
myparms.kind = cudaMemcpyHostToDevice;
#else
myparms.kind = hipMemcpyHostToDevice;
#endif
HIPCHECK(hipMemcpy3D(&myparms));
// set texture parameters
@@ -117,7 +119,7 @@ void runTest(int width,int height,int depth,texture<T, hipTextureType3D, hipRead
// copy result from device to host
HIPCHECK(hipMemcpy(hOutputData, dData, size, hipMemcpyDeviceToHost));
HipTest::checkArray(hData,hOutputData,width,height,depth);
HipTest::checkArray(hData,hOutputData,width,height,depth);
hipFree(dData);
hipFreeArray(arr);
@@ -125,13 +127,18 @@ void runTest(int width,int height,int depth,texture<T, hipTextureType3D, hipRead
free(hOutputData);
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
printf("%s starting...\n", sampleName);
for(int i=1;i<25;i++)
{
runTest<float>(i,i,i,&texf, hipChannelFormatKindFloat);
runTest<int>(i+1,i,i,&texi, hipChannelFormatKindSigned);
runTest<char>(i,i+1,i,&texc, hipChannelFormatKindSigned);
runTest<float>(i,i,i,&texf);
runTest<int>(i+1,i,i,&texi);
runTest<char>(i,i+1,i,&texc);
}
passed();
}