AI/rocm-systems
2
0
Fork 0
Koodi Ongelmat Pull-pyynnöt Actions Paketit Projektit Julkaisut Wiki Toiminta

Fixed texture 2D mapping for pitched arrays & 3D Texture read (#1415)

Selaa lähdekoodia 
Texture 2D image mapping for pitched arrays:
github issue: Texture Object's Buffer seems to be Misaligned #886
JIRA ticket: SWDEV-199313

SWDEV-151670 : Fixed issue with 3D texture with 4 components
SWDEV-151671 : Issue with 2D layered texture with 4 components
This commit is contained in:
ansurya
2019-11-07 13:17:46 +05:30
committed by Maneesh Gupta
vanhempi 579a4f36fa
commit e07926ce0f
9 muutettua tiedostoa jossa 698 lisäystä ja 414 poistoa
Download Patch File Download Diff File Expand all files Collapse all files
tests/src/test_common.h
+30
Näytä tiedosto
@@ -153,6 +153,36 @@ int parseStandardArguments(int argc, char* argv[], bool failOnUndefinedArg);
unsigned setNumBlocks(unsigned blocksPerCU, unsigned threadsPerBlock, size_t N);
template<typename T> // pointer type
void checkArray(T hData, T hOutputData, size_t width, size_t height,size_t depth)
{
for (int i = 0; i < depth; i++) {
for (int j = 0; j < height; j++) {
for (int k = 0; k < width; k++) {
int offset = i*width*height + j*width + k;
if (hData[offset] != hOutputData[offset]) {
std::cerr << '[' << i << ',' << j << ',' << k << "]:" << hData[offset] << "----" << hOutputData[offset]<<" ";
failed("mistmatch at:%d %d %d",i,j,k);
}
}
}
}
}
template<typename T>
void checkArray(T input, T output, size_t height, size_t width)
{
for(int i=0; i<height; i++ ){
for(int j=0; j<width; j++ ){
int offset = i*width + j;
if( input[offset] != output[offset] ){
std::cerr << '[' << i << ',' << j << ',' << "]:" << input[offset] << "----" << output[offset]<<" ";
failed("mistmatch at:%d %d",i,j);
}
}
}
}
template <typename T>
__global__ void vectorADD(const T* A_d, const T* B_d, T* C_d, size_t NELEM) {
tests/src/texture/hipBindTex2DPitch.cpp
+87
Näytä tiedosto
@@ -0,0 +1,87 @@
/*
Copyright (c) 2015 - 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 ../test_common.cpp
* TEST: %t
* HIT_END
*/
#include "test_common.h"
#define SIZE_H 8
#define SIZE_W 12
#define TYPE_t float
texture<TYPE_t, 2, hipReadModeElementType> tex;
// texture object is a kernel argument
__global__ void texture2dCopyKernel( TYPE_t* dst) {
int x = hipThreadIdx_x + hipBlockIdx_x * hipBlockDim_x;
int y = hipThreadIdx_y + hipBlockIdx_y * hipBlockDim_y;
if ( (x< SIZE_W) && (y< SIZE_H) ){
dst[SIZE_W*y+x] = tex2D(tex, x, y);
}
}
int main (void)
{
TYPE_t* B;
TYPE_t* A;
TYPE_t* devPtrB;
TYPE_t* devPtrA;
B = new TYPE_t[SIZE_H*SIZE_W];
A = new TYPE_t[SIZE_H*SIZE_W];
for(size_t i=1; i <= (SIZE_H*SIZE_W); i++){
A[i-1] = i;
}
size_t devPitchA, tex_ofs;
HIPCHECK(hipMallocPitch((void**)&devPtrA, &devPitchA ,SIZE_W*sizeof(TYPE_t), SIZE_H)) ;
HIPCHECK(hipMemcpy2D(devPtrA, devPitchA, A, SIZE_W*sizeof(TYPE_t),
SIZE_W*sizeof(TYPE_t), SIZE_H, hipMemcpyHostToDevice));
tex.normalized = false;
#if defined(__HIP_PLATFORM_NVCC__)
cudaError_t status = cudaBindTexture2D(&tex_ofs, &tex, devPtrA, &tex.channelDesc,
SIZE_W, SIZE_H, devPitchA);
if (status != cudaSuccess) {
printf("%serror: '%s'(%d) at %s:%d%s\n", KRED, cudaGetErrorString(status),
status,__FILE__, __LINE__, KNRM);
failed("API returned error code.");
}
#else
HIPCHECK(hipBindTexture2D(&tex_ofs, &tex, devPtrA, &tex.channelDesc,
SIZE_W, SIZE_H, devPitchA));
#endif
HIPCHECK(hipMalloc((void**)&devPtrB, SIZE_W*sizeof(TYPE_t)*SIZE_H)) ;
hipLaunchKernelGGL(texture2dCopyKernel, dim3(4,4,1), dim3(32,32,1), 0, 0, devPtrB);
hipDeviceSynchronize();
HIPCHECK(hipMemcpy2D(B, SIZE_W*sizeof(TYPE_t), devPtrB, SIZE_W*sizeof(TYPE_t),
SIZE_W*sizeof(TYPE_t), SIZE_H, hipMemcpyDeviceToHost));
HipTest::checkArray(A, B, SIZE_H, SIZE_W);
delete []A;
delete []B;
hipFree(devPtrA);
hipFree(devPtrB);
passed();
}
tests/src/texture/hipNormalizedFloatValueTex.cpp
+12 -21
Näytä tiedosto
@@ -26,15 +26,6 @@ THE SOFTWARE.
* HIT_END
*/
#define CHECK(cmd) \
{\
hipError_t error = cmd;\
if(error != hipSuccess) {\
fprintf(stderr, "error: '%s' (%d) at %s:%d\n", hipGetErrorString(error), error, __FILE__, __LINE__);\
exit(EXIT_FAILURE);\
}\
}
#include "hip/hip_runtime.h"
#include "test_common.h"
#define SIZE 10
@@ -54,31 +45,31 @@ bool textureTest(enum hipArray_Format texFormat)
{
T hData[] = {65, 66, 67, 68, 69, 70, 71, 72,73,74};
T *dData = NULL;
CHECK(hipMalloc((void **) &dData, sizeof(T)*SIZE));
CHECK(hipMemcpyHtoD((hipDeviceptr_t)dData, hData, sizeof(T)*SIZE));
HIPCHECK(hipMalloc((void **) &dData, sizeof(T)*SIZE));
HIPCHECK(hipMemcpyHtoD((hipDeviceptr_t)dData, hData, sizeof(T)*SIZE));
textureReference* texRef = &textureNormalizedVal_1D;
CHECK(hipTexRefSetAddressMode(texRef, 0, hipAddressModeClamp));
CHECK(hipTexRefSetAddressMode(texRef, 1, hipAddressModeClamp));
CHECK(hipTexRefSetFilterMode(texRef, hipFilterModePoint));
CHECK(hipTexRefSetFlags(texRef, HIP_TRSF_NORMALIZED_COORDINATES));
CHECK(hipTexRefSetFormat(texRef, texFormat, 1));
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;
CHECK(hipTexRefSetAddress2D(texRef, &desc, (hipDeviceptr_t)dData, sizeof(T)*SIZE));
HIPCHECK(hipTexRefSetAddress2D(texRef, &desc, (hipDeviceptr_t)dData, sizeof(T)*SIZE));
bool testResult = true;
float *dOutputData = NULL;
CHECK(hipMalloc((void **) &dOutputData, sizeof(float)*SIZE));
HIPCHECK(hipMalloc((void **) &dOutputData, sizeof(float)*SIZE));
hipLaunchKernelGGL(HIP_KERNEL_NAME(normalizedValTextureTest), dim3(1,1,1), dim3(SIZE,1,1), 0, 0, SIZE, dOutputData);
float *hOutputData = new float[SIZE];
CHECK(hipMemcpyDtoH(hOutputData, (hipDeviceptr_t)dOutputData, (sizeof(float)*SIZE)));
HIPCHECK(hipMemcpyDtoH(hOutputData, (hipDeviceptr_t)dOutputData, (sizeof(float)*SIZE)));
for(int i = 0; i < SIZE; i++)
{
@@ -100,9 +91,9 @@ int main(int argc, char** argv)
{
int device = 0;
bool status = true;
CHECK(hipSetDevice(device));
HIPCHECK(hipSetDevice(device));
hipDeviceProp_t props;
CHECK(hipGetDeviceProperties(&props, device));
HIPCHECK(hipGetDeviceProperties(&props, device));
std::cout << "Device :: " << props.name << std::endl;
#ifdef __HIP_PLATFORM_HCC__
std::cout << "Arch - AMD GPU :: " << props.gcnArch << std::endl;
tests/src/texture/hipTexObjPitch.cpp
+106
Näytä tiedosto
@@ -0,0 +1,106 @@
/*
Copyright (c) 2015 - 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 ../test_common.cpp
* TEST: %t
* HIT_END
*/
#include "test_common.h"
#define SIZE_H 20
#define SIZE_W 179
// texture object is a kernel argument
template <typename TYPE_t>
__global__ void texture2dCopyKernel( hipTextureObject_t texObj, TYPE_t* dst,TYPE_t* A) {
for(int i =0;i<SIZE_H;i++)
for(int j = 0;j<SIZE_W;j++)
dst[SIZE_W*i+j] = tex2D<TYPE_t>(texObj, j, i);
__syncthreads();
}
template <typename TYPE_t>
void texture2Dtest()
{
TYPE_t* B;
TYPE_t* A;
TYPE_t* devPtrB;
TYPE_t* devPtrA;
B = new TYPE_t[SIZE_H*SIZE_W];
A = new TYPE_t[SIZE_H*SIZE_W];
for(size_t i=1; i <= (SIZE_H*SIZE_W); i++){
A[i-1] = i;
}
size_t devPitchA;
HIPCHECK(hipMallocPitch((void**)&devPtrA, &devPitchA ,SIZE_W*sizeof(TYPE_t), SIZE_H)) ;
HIPCHECK(hipMemcpy2D(devPtrA, devPitchA, A, SIZE_W*sizeof(TYPE_t),
SIZE_W*sizeof(TYPE_t), SIZE_H, hipMemcpyHostToDevice));
// Use the texture object
hipResourceDesc texRes;
hipMemset(&texRes, 0, sizeof(texRes));
texRes.resType = hipResourceTypePitch2D;
texRes.res.pitch2D.devPtr = devPtrA;
texRes.res.pitch2D.height = SIZE_H;
texRes.res.pitch2D.width = SIZE_W;
texRes.res.pitch2D.pitchInBytes = devPitchA;
texRes.res.pitch2D.desc = hipCreateChannelDesc<TYPE_t>();
hipTextureDesc texDescr;
hipMemset(&texDescr, 0, sizeof(texDescr));
texDescr.normalizedCoords = false;
texDescr.filterMode = hipFilterModePoint;
texDescr.mipmapFilterMode = hipFilterModePoint;
texDescr.addressMode[0] = hipAddressModeClamp;
texDescr.addressMode[1] = hipAddressModeClamp;
texDescr.addressMode[2] = hipAddressModeClamp;
texDescr.readMode = hipReadModeElementType;
hipTextureObject_t texObj;
hipResourceViewDesc resDesc;
HIPCHECK( hipCreateTextureObject(&texObj, &texRes, &texDescr, &resDesc));
HIPCHECK(hipMalloc((void**)&devPtrB, SIZE_W*sizeof(TYPE_t)*SIZE_H)) ;
hipLaunchKernelGGL(texture2dCopyKernel, dim3(1,1,1), dim3(1,1,1), 0, 0,
texObj, devPtrB, devPtrA);
HIPCHECK(hipMemcpy2D(B, SIZE_W*sizeof(TYPE_t), devPtrB, SIZE_W*sizeof(TYPE_t),
SIZE_W*sizeof(TYPE_t), SIZE_H, hipMemcpyDeviceToHost));
HipTest::checkArray(A, B, SIZE_H, SIZE_W);
delete []A;
delete []B;
hipFree(devPtrA);
hipFree(devPtrB);
}
int main()
{
texture2Dtest<float>();
texture2Dtest<int>();
texture2Dtest<unsigned char>();
texture2Dtest<short>();
texture2Dtest<char>();
texture2Dtest<unsigned int>();
passed();
}
tests/src/texture/simpleTexture2DLayered.cpp
+106
Näytä tiedosto
@@ -0,0 +1,106 @@
/*
Copyright (c) 2019-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 ../test_common.cpp
* TEST: %t
* HIT_END
*/
#include "test_common.h"
typedef float T;
// Texture reference for 2D Layered texture
texture<float, hipTextureType2DLayered> tex2DL;
__global__ void simpleKernelLayeredArray(T* outputData,int width,int height,int layer)
{
unsigned int x = blockIdx.x*blockDim.x + threadIdx.x;
unsigned int y = blockIdx.y*blockDim.y + threadIdx.y;
outputData[layer*width*height + y*width + x] = tex2DLayered(tex2DL, x, y, layer);
}
////////////////////////////////////////////////////////////////////////////////
void runTest(int width,int height,int num_layers,texture<T, hipTextureType2DLayered> *tex)
{
unsigned int size = width * height * num_layers * sizeof(T);
T* hData = (T*) malloc(size);
memset(hData, 0, size);
for (unsigned int layer = 0; layer < num_layers; layer++){
for (int i = 0; i < (int)(width * height); i++){
hData[layer*width*height + i] = i;
}
}
hipChannelFormatDesc channelDesc;
// Allocate array and copy image data
channelDesc = hipCreateChannelDesc(sizeof(T)*8, 0, 0, 0, hipChannelFormatKindFloat);
hipArray *arr;
HIPCHECK(hipMalloc3DArray(&arr, &channelDesc, make_hipExtent(width, height, num_layers), hipArrayLayered));
hipMemcpy3DParms myparms = {0};
myparms.srcPos = make_hipPos(0,0,0);
myparms.dstPos = make_hipPos(0,0,0);
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T), width, height);
myparms.dstArray = arr;
myparms.extent = make_hipExtent(width, height, num_layers);
//myparms.kind = hipMemcpyHostToDevice;
HIPCHECK(hipMemcpy3D(&myparms));
// set texture parameters
tex->addressMode[0] = hipAddressModeWrap;
tex->addressMode[1] = hipAddressModeWrap;
tex->filterMode = hipFilterModePoint;
tex->normalized = false;
// Bind the array to the texture
HIPCHECK(hipBindTextureToArray(*tex, arr, channelDesc));
// Allocate device memory for result
T* dData = NULL;
hipMalloc((void **) &dData, size);
dim3 dimBlock(8, 8, 1);
dim3 dimGrid(width / dimBlock.x, height / dimBlock.y, 1);
for (unsigned int layer = 0; layer < num_layers; layer++)
hipLaunchKernelGGL(simpleKernelLayeredArray, dimGrid, dimBlock, 0, 0, dData, width, height, layer);
HIPCHECK(hipDeviceSynchronize());
// Allocate mem for the result on host side
T *hOutputData = (T*) malloc(size);
memset(hOutputData, 0, size);
// copy result from device to host
HIPCHECK(hipMemcpy(hOutputData, dData, size, hipMemcpyDeviceToHost));
HipTest::checkArray(hData,hOutputData,width,height,num_layers);
hipFree(dData);
hipFreeArray(arr);
free(hData);
free(hOutputData);
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
runTest(512,512,5,&tex2DL);
passed();
}
tests/src/texture/simpleTexture3D.cpp
+133
Näytä tiedosto
@@ -0,0 +1,133 @@
/*
Copyright (c) 2019-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 ../test_common.cpp EXCLUDE_HIP_PLATFORM nvcc
* TEST: %t
* HIT_END
*/
#include "test_common.h"
//typedef char T;
const char *sampleName = "simpleTexture3D";
// Texture reference for 3D texture
texture<float, hipTextureType3D, hipReadModeElementType> texf;
texture<int, hipTextureType3D, hipReadModeElementType> texi;
texture<char, hipTextureType3D, hipReadModeElementType> texc;
template <typename T>
__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, texf.textureObject, k, j, i);
else if(std::is_same<T, int>::value)
outputData[i*width*height + j*width + k] = tex3D(texi, texi.textureObject, k, j, i);
else if(std::is_same<T, char>::value)
outputData[i*width*height + j*width + k] = tex3D(texc, texc.textureObject, 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)
{
unsigned int size = width * height * depth * sizeof(T);
T* hData = (T*) malloc(size);
memset(hData, 0, size);
for (int i = 0; i < depth; i++) {
for (int j = 0; j < height; j++) {
for (int k = 0; k < width; k++) {
hData[i*width*height + j*width +k] = i*width*height + j*width + k;
}
}
}
// Allocate array and copy image data
hipChannelFormatDesc channelDesc = hipCreateChannelDesc(sizeof(T)*8, 0, 0, 0, hipChannelFormatKindSigned);
hipArray *arr;
HIPCHECK(hipMalloc3DArray(&arr, &channelDesc, make_hipExtent(width, height, depth), hipArrayCubemap));
hipMemcpy3DParms myparms = {0};
myparms.srcPos = make_hipPos(0,0,0);
myparms.dstPos = make_hipPos(0,0,0);
myparms.srcPtr = make_hipPitchedPtr(hData, width * sizeof(T), width, height);
myparms.dstArray = arr;
myparms.extent = make_hipExtent(width, height, depth);
myparms.kind = hipMemcpyHostToDevice;
HIPCHECK(hipMemcpy3D(&myparms));
// set texture parameters
tex->addressMode[0] = hipAddressModeWrap;
tex->addressMode[1] = hipAddressModeWrap;
tex->filterMode = hipFilterModePoint;
tex->normalized = false;
// Bind the array to the texture
HIPCHECK(hipBindTextureToArray(*tex, arr, channelDesc));
// Allocate device memory for result
T* dData = NULL;
hipMalloc((void **) &dData, size);
hipLaunchKernelGGL(simpleKernel3DArray, dim3(1,1,1), dim3(1,1,1), 0, 0, dData, width, height, depth);
HIPCHECK(hipDeviceSynchronize());
// Allocate mem for the result on host side
T *hOutputData = (T*) malloc(size);
memset(hOutputData, 0, size);
// copy result from device to host
HIPCHECK(hipMemcpy(hOutputData, dData, size, hipMemcpyDeviceToHost));
HipTest::checkArray(hData,hOutputData,width,height,depth);
hipFree(dData);
hipFreeArray(arr);
free(hData);
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);
runTest<int>(i+1,i,i,&texi);
runTest<char>(i,i+1,i,&texc);
}
passed();
}