Skip to content

Commit

Permalink
Merge pull request #1801 from aakanksha555/amd-staging
Browse files Browse the repository at this point in the history 
[HIPIFY][Tensor] hipTensor support - test coverage from version 1.0.1 to 2.0.2.1 - Part 13
  • Loading branch information
@emankov
emankov authored Dec 17, 2024
2 parents 2b6b6ad + 6ee0e1e commit 8b06420
Showing 1 changed file with 61 additions and 45 deletions.
106 changes: 61 additions & 45 deletions tests/unit_tests/synthetic/libraries/cutensor2hiptensor.cu
View file
Original file line number Diff line number Diff line change
Expand Up @@ -10,7 +10,11 @@
int main() {

// CHECK: hiptensorHandle_t handle;
// CHECK-NEXT: const hiptensorHandle_t *handle_c = nullptr;
// CHECK-NEXT: hiptensorHandle_t *handle2 = nullptr;
cutensorHandle_t handle;
const cutensorHandle_t *handle_c = nullptr;
cutensorHandle_t *handle2 = nullptr;

//CHECK: hiptensorStatus_t status;
cutensorStatus_t status;
Expand All @@ -32,9 +36,6 @@ int main() {
// CHECK: hipStream_t stream_t;
cudaStream_t stream_t;

// CHECK: hiptensorLoggerCallback_t callback;
cutensorLoggerCallback_t callback;

const uint32_t numModes = 0;
const int64_t* extent = nullptr;
const int64_t* stride = nullptr;
Expand All @@ -60,7 +61,6 @@ int main() {
int32_t mask = 0;

#if CUTENSOR_MAJOR >= 2

// CHECK: hiptensorComputeType_t tensorDataType_t;
// CHECK-NEXT hiptensorComputeType_t TENSOR_R_16F = HIPTENSOR_COMPUTE_16F;
// CHECK-NEXT hiptensorComputeType_t TENSOR_R_16BF = HIPTENSOR_COMPUTE_16BF;
Expand Down Expand Up @@ -91,10 +91,19 @@ int main() {
// HIP: hiptensorStatus_t hiptensorContraction(const hiptensorHandle_t* handle, const hiptensorContractionPlan_t* plan, const void* alpha, const void* A, const void* B, const void* beta, const void* C, void* D, void* workspace, uint64_t workspaceSize, hipStream_t stream);
// CHECK: status = hiptensorContraction(handle, tensorPlan2_t, alpha, A, B_1, beta, C, D, workspace, workspaceSize2, stream_t);
status = cutensorContract(handle, tensorPlan2_t, alpha, A, B_1, beta, C, D, workspace, workspaceSize2, stream_t);

// CUDA: cutensorStatus_t cutensorCreate(cutensorHandle_t* handle);
// HIP: hiptensorStatus_t hiptensorCreate(hiptensorHandle_t** handle);
// CHECK: status = hiptensorCreate(&handle);
status = cutensorCreate(&handle);

// CUDA: cutensorStatus_t cutensorDestroy(cutensorHandle_t handle);
// HIP: hiptensorStatus_t hiptensorDestroy(hiptensorHandle_t* handle);
// CHECK: status = hiptensorDestroy(handle);
status = cutensorDestroy(handle);
#endif

#if CUTENSOR_MAJOR >= 1

// CHECK: hiptensorOperator_t tensorOperator_t;
// CHECK-NEXT hiptensorOperator_t TENSOR_OP_IDENTITY = HIPTENSOR_OP_IDENTITY;
// CHECK-NEXT hiptensorOperator_t TENSOR_OP_SQRT = HIPTENSOR_OP_SQRT;
Expand Down Expand Up @@ -123,7 +132,6 @@ int main() {
// CHECK-NEXT hiptensorStatus_t TENSOR_STATUS_NOT_SUPPORTED = HIPTENSOR_STATUS_NOT_SUPPORTED;
// CHECK-NEXT hiptensorStatus_t TENSOR_STATUS_INSUFFICIENT_WORKSPACE = HIPTENSOR_STATUS_INSUFFICIENT_WORKSPACE;
// CHECK-NEXT hiptensorStatus_t TENSOR_STATUS_INSUFFICIENT_DRIVER = HIPTENSOR_STATUS_INSUFFICIENT_DRIVER;
// CHECK-NEXT hiptensorStatus_t TENSOR_STATUS_IO_ERROR = HIPTENSOR_STATUS_IO_ERROR;
cutensorStatus_t tensorStatus_t;
cutensorStatus_t TENSOR_STATUS_SUCCESS = CUTENSOR_STATUS_SUCCESS;
cutensorStatus_t TENSOR_STATUS_NOT_INITIALIZED = CUTENSOR_STATUS_NOT_INITIALIZED;
Expand All @@ -135,7 +143,10 @@ int main() {
cutensorStatus_t TENSOR_STATUS_NOT_SUPPORTED = CUTENSOR_STATUS_NOT_SUPPORTED;
cutensorStatus_t TENSOR_STATUS_INSUFFICIENT_WORKSPACE = CUTENSOR_STATUS_INSUFFICIENT_WORKSPACE;
cutensorStatus_t TENSOR_STATUS_INSUFFICIENT_DRIVER = CUTENSOR_STATUS_INSUFFICIENT_DRIVER;
#if CUTENSOR_MINOR >= 2
// CHECK: hiptensorStatus_t TENSOR_STATUS_IO_ERROR = HIPTENSOR_STATUS_IO_ERROR;
cutensorStatus_t TENSOR_STATUS_IO_ERROR = CUTENSOR_STATUS_IO_ERROR;
#endif

// CHECK: hiptensorAlgo_t tensorAlgo_t;
// CHECK-NEXT hiptensorAlgo_t TENSOR_ALGO_DEFAULT = HIPTENSOR_ALGO_DEFAULT;
Expand Down Expand Up @@ -166,66 +177,72 @@ int main() {
#endif

#if (CUTENSOR_MAJOR >= 1 && CUTENSOR_MAJOR < 2)
// CHECK: hiptensorWorksizePreference_t TENSOR_WORKSPACE_RECOMMENDED = HIPTENSOR_WORKSPACE_RECOMMENDED;
cutensorWorksizePreference_t TENSOR_WORKSPACE_RECOMMENDED = CUTENSOR_WORKSPACE_RECOMMENDED;

// CHECK: hiptensorComputeType_t tensorComputeType_t;
// CHECK-NEXT hiptensorComputeType_t TENSOR_R_16F = HIPTENSOR_COMPUTE_16F;
// CHECK-NEXT hiptensorComputeType_t TENSOR_R_16BF = HIPTENSOR_COMPUTE_16BF;
// CHECK-NEXT hiptensorComputeType_t TENSOR_R_32F = HIPTENSOR_COMPUTE_32F;
// CHECK-NEXT hiptensorComputeType_t TENSOR_C_32F = HIPTENSOR_COMPUTE_C32F;
// CHECK-NEXT hiptensorComputeType_t TENSOR_R_64F = HIPTENSOR_COMPUTE_64F;
// CHECK-NEXT hiptensorComputeType_t TENSOR_C_64F = HIPTENSOR_COMPUTE_C64F;
// CHECK-NEXT hiptensorComputeType_t TENSOR_R_8I = HIPTENSOR_COMPUTE_8I;
// CHECK-NEXT hiptensorComputeType_t TENSOR_R_8U = HIPTENSOR_COMPUTE_8U;
// CHECK-NEXT hiptensorComputeType_t TENSOR_R_32I = HIPTENSOR_COMPUTE_32I;
// CHECK-NEXT hiptensorComputeType_t TENSOR_R_32U = HIPTENSOR_COMPUTE_32U;
cutensorComputeType_t tensorComputeType_t;
cutensorComputeType_t TENSOR_R_16F = CUTENSOR_R_16F;
cutensorComputeType_t TENSOR_R_16BF = CUTENSOR_R_16BF;
cutensorComputeType_t TENSOR_R_32F = CUTENSOR_R_32F;
cutensorComputeType_t TENSOR_C_32F = CUTENSOR_C_32F;
cutensorComputeType_t TENSOR_R_64F = CUTENSOR_R_64F;
cutensorComputeType_t TENSOR_C_64F = CUTENSOR_C_64F;
cutensorComputeType_t TENSOR_R_8I = CUTENSOR_R_8I;
cutensorComputeType_t TENSOR_R_8U = CUTENSOR_R_8U;
cutensorComputeType_t TENSOR_R_32I = CUTENSOR_R_32I;
cutensorComputeType_t TENSOR_R_32U = CUTENSOR_R_32U;

#if CUTENSOR_MINOR >= 2
// CHECK hiptensorComputeType_t TENSOR_COMPUTE_16F = HIPTENSOR_COMPUTE_16F;
// CHECK-NEXT hiptensorComputeType_t TENSOR_COMPUTE_16BF = HIPTENSOR_COMPUTE_16BF;
// CHECK-NEXT hiptensorComputeType_t TENSOR_COMPUTE_32F = HIPTENSOR_COMPUTE_32F;
// CHECK-NEXT hiptensorComputeType_t TENSOR_COMPUTE_64F = HIPTENSOR_COMPUTE_64F;
// CHECK-NEXT hiptensorComputeType_t TENSOR_COMPUTE_8U = HIPTENSOR_COMPUTE_8U;
// CHECK-NEXT hiptensorComputeType_t TENSOR_COMPUTE_8I = HIPTENSOR_COMPUTE_8I;
// CHECK-NEXT hiptensorComputeType_t TENSOR_COMPUTE_32U = HIPTENSOR_COMPUTE_32U;
// CHECK-NEXT hiptensorComputeType_t TENSOR_COMPUTE_32I = HIPTENSOR_COMPUTE_32I;
cutensorComputeType_t TENSOR_COMPUTE_16F = CUTENSOR_COMPUTE_16F;
cutensorComputeType_t TENSOR_COMPUTE_16BF = CUTENSOR_COMPUTE_16BF;
cutensorComputeType_t TENSOR_COMPUTE_32F = CUTENSOR_COMPUTE_32F;
cutensorComputeType_t TENSOR_COMPUTE_64F = CUTENSOR_COMPUTE_64F;
cutensorComputeType_t TENSOR_COMPUTE_8U = CUTENSOR_COMPUTE_8U;
cutensorComputeType_t TENSOR_COMPUTE_8I = CUTENSOR_COMPUTE_8I;
cutensorComputeType_t TENSOR_COMPUTE_32U = CUTENSOR_COMPUTE_32U;
cutensorComputeType_t TENSOR_COMPUTE_32I = CUTENSOR_COMPUTE_32I;
#endif

// CHECK: const hiptensorContractionPlan_t *plan_c = nullptr;
const cutensorContractionPlan_t *plan_c = nullptr;

// CHECK: hiptensorWorksizePreference_t TENSOR_WORKSPACE_RECOMMENDED = HIPTENSOR_WORKSPACE_RECOMMENDED;
cutensorWorksizePreference_t TENSOR_WORKSPACE_RECOMMENDED = CUTENSOR_WORKSPACE_RECOMMENDED;

// CUDA: cutensorStatus_t cutensorInitTensorDescriptor(const cutensorHandle_t* handle, cutensorTensorDescriptor_t* desc, const uint32_t numModes, const int64_t extent[], const int64_t stride[], cudaDataType_t dataType, cutensorOperator_t unaryOp);
// HIP: hiptensorStatus_t hiptensorInitTensorDescriptor(const hiptensorHandle_t* handle, hiptensorTensorDescriptor_t* desc, const uint32_t numModes, const int64_t lens[], const int64_t strides[], hipDataType dataType, hiptensorOperator_t unaryOp);
// CHECK: status = hiptensorInitTensorDescriptor(handle, tensorDescriptor, numModes, extent, stride, dataType, tensorOperator_t);
status = cutensorInitTensorDescriptor(handle, tensorDescriptor, numModes, extent, stride, dataType, tensorOperator_t);
// CHECK: status = hiptensorInitTensorDescriptor(handle_c, tensorDescriptor, numModes, extent, stride, dataType, tensorOperator_t);
status = cutensorInitTensorDescriptor(handle_c, tensorDescriptor, numModes, extent, stride, dataType, tensorOperator_t);

// CUDA: cutensorStatus_t cutensorPermutation(const cutensorHandle_t* handle, const void* alpha, const void* A, const cutensorTensorDescriptor_t* descA, const int32_t modeA[], void* B, const cutensorTensorDescriptor_t* descB, const int32_t modeB[], const cudaDataType_t typeScalar, const cudaStream_t stream);
// HIP: hiptensorStatus_t hiptensorPermutation(const hiptensorHandle_t* handle, const void* alpha, const void* A, const hiptensorTensorDescriptor_t* descA, const int32_t modeA[], void* B, const hiptensorTensorDescriptor_t* descB, const int32_t modeB[], const hipDataType typeScalar, const hipStream_t stream);
// CHECK: status = hiptensorPermutation(handle, alpha, A, descA, modeA, B, descB, modeB, dataType, stream_t;
status = hiptensorPermutation(handle, alpha, A, descA, modeA, B, descB, modeB, dataType, stream_t;
// CHECK: status = hiptensorPermutation(handle_c, alpha, A, descA, modeA, B, descB, modeB, dataType, stream_t);
status = cutensorPermutation(handle_c, alpha, A, descA, modeA, B, descB, modeB, dataType, stream_t);

// CUDA: cutensorStatus_t cutensorContraction(const cutensorHandle_t* handle, const cutensorContractionPlan_t* plan, const void* alpha, const void* A, const void* B, const void* beta, const void* C, void* D, void *workspace, uint64_t workspaceSize, cudaStream_t stream);
// HIP: hiptensorStatus_t hiptensorContraction(const hiptensorHandle_t* handle, const hiptensorContractionPlan_t* plan, const void* alpha, const void* A, const void* B, const void* beta, const void* C, void* D, void* workspace, uint64_t workspaceSize, hipStream_t stream);
// CHECK: status = hiptensorContraction(handle, plan, alpha, A, B_1, beta, C, D, workspaceSize, stream_t);
status = cutensorContraction(handle, plan, alpha, A, B_1, beta, C, D, workspaceSize, stream_t);
// CHECK: status = hiptensorContraction(handle_c, plan_c, alpha, A, B_1, beta, C, D, workspace, workspaceSize, stream_t);
status = cutensorContraction(handle_c, plan_c, alpha, A, B_1, beta, C, D, workspace, workspaceSize, stream_t);

// CUDA: cutensorStatus_t cutensorReduction(const cutensorHandle_t* handle, const void* alpha, const void* A, const cutensorTensorDescriptor_t* descA, const int32_t modeA[], const void* beta, const void* C, const cutensorTensorDescriptor_t* descC, const int32_t modeC[], void* D, const cutensorTensorDescriptor_t* descD, const int32_t modeD[], cutensorOperator_t opReduce, cutensorComputeType_t typeCompute, void *workspace, uint64_t workspaceSize, cudaStream_t stream);
// HIP: hiptensorStatus_t hiptensorReduction(const hiptensorHandle_t* handle, const void* alpha, const void* A, const hiptensorTensorDescriptor_t* descA, const int32_t modeA[], const void* beta, const void* C, const hiptensorTensorDescriptor_t* descC, const int32_t modeC[], void* D, const hiptensorTensorDescriptor_t* descD, const int32_t modeD[], hiptensorOperator_t opReduce, hiptensorComputeType_t typeCompute, void* workspace, uint64_t workspaceSize, hipStream_t stream);
// CHECK: status = hiptensorReduction(handle, alpha, A, descA, modeA, beta, C, descC, modeC, D, descD, modeD, tensorOperator_t, workspace, workspaceSize2, stream);
status = cutensorReduction(handle, alpha, A, descA, modeA, beta, C, descC, modeC, D, descD, modeD, tensorOperator_t, workspace, workspaceSize2, stream);
// CHECK: status = hiptensorReduction(handle_c, alpha, A, descA, modeA, beta, C, descC, modeC, D, descD, modeD, tensorOperator_t, tensorComputeType_t, workspace, workspaceSize2, stream_t);
status = cutensorReduction(handle_c, alpha, A, descA, modeA, beta, C, descC, modeC, D, descD, modeD, tensorOperator_t, tensorComputeType_t, workspace, workspaceSize2, stream_t);
#endif

#if (CUTENSOR_MAJOR == 1 && CUTENSOR_MINOR >= 7) || CUTENSOR_MAJOR >= 2
#if (CUTENSOR_MAJOR == 1 && CUTENSOR_MINOR >= 7)
// CUDA: cutensorStatus_t cutensorCreate(cutensorHandle_t* handle);
// HIP: hiptensorStatus_t hiptensorCreate(hiptensorHandle_t** handle);
// CHECK: status = hiptensorCreate(&handle);
status = cutensorCreate(&handle);
// CHECK: status = hiptensorCreate(&handle2);
status = cutensorCreate(&handle2);

// CUDA: cutensorStatus_t cutensorDestroy(cutensorHandle_t handle);
// HIP: hiptensorStatus_t hiptensorDestroy(hiptensorHandle_t* handle);
// CHECK: status = hiptensorDestroy(handle);
status = cutensorDestroy(handle);
#endif
// CHECK: status = hiptensorDestroy(handle2);
status = cutensorDestroy(handle2);
#endif


#if (CUTENSOR_MAJOR == 1 && CUTENSOR_MINOR >= 3 && CUTENSOR_PATCH >= 2) || CUTENSOR_MAJOR >= 2
// CHECK: hiptensorLoggerCallback_t callback;
cutensorLoggerCallback_t callback;

#if (CUTENSOR_MAJOR == 1 && CUTENSOR_MINOR >= 3) || CUTENSOR_MAJOR >= 2
// CUDA: cutensorStatus_t cutensorLoggerSetCallback(cutensorLoggerCallback_t callback);
// HIP: hiptensorStatus_t hiptensorLoggerSetCallback(hiptensorLoggerCallback_t callback);
// CHECK: status = hiptensorLoggerSetCallback(callback);
Expand Down Expand Up @@ -255,7 +272,6 @@ int main() {
// HIP: hiptensorStatus_t hiptensorLoggerForceDisable();
// CHECK: status = hiptensorLoggerForceDisable();
status = cutensorLoggerForceDisable();

#endif

return 0;
Expand Down

0 comments on commit 8b06420

Please sign in to comment.