Get the hipTENSOR tests passing

The plan is the main fix: unlike cuTENSOR, hipTENSOR 2.2 does not copy the
objects a plan is built from, it keeps pointers to the operation descriptor,
the plan preference, the tensor descriptors and the mode arrays and
dereferences them on every execution. Destroying or garbage collecting any of
them gave anything from a NOT_SUPPORTED to a segfault, so the plan now owns
them all and releases them, in order, when it is freed itself.

Work around two more hipTENSOR quirks:

  - its elementwise and reduction kernels ignore the mode labels and walk each
    tensor in the order its modes were declared, silently producing garbage
    once those orders differ. Permuting the lengths and strides in each
    operand's descriptor puts them all in the output's mode order, which costs
    nothing and makes arbitrary mode orders work.

  - it has the two binary operators of an elementwise trinary operation the
    wrong way round, so swap them to get the documented semantics.

Complex operands need a complex compute descriptor (a real one fails plan
creation with EXECUTION_FAILED), and the compute type tables are trimmed to the
combinations the library actually implements, with an error message that lists
them instead of a bare KeyError.

On the test side, contractions.jl never imported hipTENSOR and called a
compute descriptor conversion that does not exist, the type lists are cut down
to the supported combinations, and the sub-tests that were commented out are
restored. Two limitations we cannot work around are recorded there: hipTENSOR
silently ignores OP_CONJ on a contraction's inputs (@test_broken, so we notice
when that is fixed), and it rounds the elementwise α/β/γ scalars to single
precision even for a double precision compute descriptor.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: Katharine Hyatt

src/tensor/hipTENSOR.jl

@@ -1,9 +1,10 @@
 module hipTENSOR
 
-using AMDGPU
 using AMDGPU
 using AMDGPU: @gcsafe_ccall, @checked, @enum_without_prefix, @debug_ccall
 using AMDGPU: Mem
+
+using BFloat16s: BFloat16
 import AMDGPU: libhiptensor, HandleCache, HIP, library_state
 import AMDGPU.Mem: alloc_or_retry!
 import .HIP: HIPContext, HIPStream, hipStream_t

src/tensor/libhiptensor.jl

@@ -33,9 +33,9 @@ end
 end
 
 @inline function check(f)
-    retry_if(res) = res in (HIPTENSOR_STATUS_NOT_INITIALIZED,
-                            HIPTENSOR_STATUS_ALLOC_FAILED,
-                            HIPTENSOR_STATUS_INTERNAL_ERROR)
+    # only an allocation failure is worth retrying after reclaiming memory; the other
+    # statuses are permanent and should be reported to the caller as-is
+    retry_if(res) = res == HIPTENSOR_STATUS_ALLOC_FAILED
     res = retry_reclaim(f, retry_if)
 
     if res != HIPTENSOR_STATUS_SUCCESS
@@ -121,9 +121,9 @@ const hiptensorTensorDescriptor_t = Ptr{hiptensorTensorDescriptor}
     HIPTENSOR_C_64U = 27
 end
 
-function hiptensorCreateTensorDescriptor(handle, desc, numModes, lens, strides, dataType,
+@checked function hiptensorCreateTensorDescriptor(handle, desc, numModes, lens, strides, dataType,
                                          alignmentRequirement)
-    @debug_ccall libhiptensor.hiptensorCreateTensorDescriptor(handle::hiptensorHandle_t,
+    @ccall libhiptensor.hiptensorCreateTensorDescriptor(handle::hiptensorHandle_t,
                                                         desc::Ptr{hiptensorTensorDescriptor_t},
                                                         numModes::UInt32, lens::Ptr{Int64},
                                                         strides::Ptr{Int64},
@@ -225,8 +225,8 @@ end
                                                                  sizeInBytes::Csize_t)::hiptensorStatus_t
 end
 
-function hiptensorOperationDescriptorGetAttribute(handle, desc, attr, buf, sizeInBytes)
-    @debug_ccall libhiptensor.hiptensorOperationDescriptorGetAttribute(handle::hiptensorHandle_t,
+@checked function hiptensorOperationDescriptorGetAttribute(handle, desc, attr, buf, sizeInBytes)
+    @ccall libhiptensor.hiptensorOperationDescriptorGetAttribute(handle::hiptensorHandle_t,
                                                                  desc::hiptensorOperationDescriptor_t,
                                                                  attr::hiptensorOperationDescriptorAttribute_t,
                                                                  buf::Ptr{Cvoid},
@@ -284,8 +284,8 @@ const hiptensorPlan_t = Ptr{hiptensorPlan}
     HIPTENSOR_PLAN_REQUIRED_WORKSPACE = 0
 end
 
-function hiptensorPlanGetAttribute(handle, plan, attr, buf, sizeInBytes)
-    @debug_ccall libhiptensor.hiptensorPlanGetAttribute(handle::hiptensorHandle_t,
+@checked function hiptensorPlanGetAttribute(handle, plan, attr, buf, sizeInBytes)
+    @ccall libhiptensor.hiptensorPlanGetAttribute(handle::hiptensorHandle_t,
                                                   plan::hiptensorPlan_t,
                                                   attr::hiptensorPlanAttribute_t,
                                                   buf::Ptr{Cvoid},
@@ -319,8 +319,8 @@ end
                                                    descCompute::hiptensorComputeDescriptor_t)::hiptensorStatus_t
 end
 
-function hiptensorCreatePlan(handle, plan, desc, pref, workspaceSizeLimit)
-    @debug_ccall libhiptensor.hiptensorCreatePlan(handle::hiptensorHandle_t,
+@checked function hiptensorCreatePlan(handle, plan, desc, pref, workspaceSizeLimit)
+    @ccall libhiptensor.hiptensorCreatePlan(handle::hiptensorHandle_t,
                                             plan::Ptr{hiptensorPlan_t},
                                             desc::hiptensorOperationDescriptor_t,
                                             pref::hiptensorPlanPreference_t,
@@ -337,13 +337,13 @@ end
                                           alpha::Ptr{Cvoid}, A::Ptr{Cvoid}, B::Ptr{Cvoid},
                                           beta::Ptr{Cvoid}, C::Ptr{Cvoid}, D::Ptr{Cvoid},
                                           workspace::Ptr{Cvoid}, workspaceSize::UInt64,
-                                          stream::Cint)::hiptensorStatus_t
+                                          stream::hipStream_t)::hiptensorStatus_t
 end
 
 @checked function hiptensorPermute(handle, plan, alpha, A, B, stream)
     @ccall libhiptensor.hiptensorPermute(handle::hiptensorHandle_t, plan::hiptensorPlan_t,
                                          alpha::Ptr{Cvoid}, A::Ptr{Cvoid}, B::Ptr{Cvoid},
-                                         stream::Cint)::hiptensorStatus_t
+                                         stream::hipStream_t)::hiptensorStatus_t
 end
 
 @checked function hiptensorCreateElementwiseBinary(handle, desc, descA, modeA, opA, descC, modeC,
@@ -368,7 +368,7 @@ end
                                                           alpha::Ptr{Cvoid}, A::Ptr{Cvoid},
                                                           gamma::Ptr{Cvoid}, C::Ptr{Cvoid},
                                                           D::Ptr{Cvoid},
-                                                          stream::Cint)::hiptensorStatus_t
+                                                          stream::hipStream_t)::hiptensorStatus_t
 end
 
 @checked function hiptensorCreateElementwiseTrinary(handle, desc, descA, modeA, opA, descB, modeB,
@@ -400,12 +400,12 @@ end
                                                            beta::Ptr{Cvoid}, B::Ptr{Cvoid},
                                                            gamma::Ptr{Cvoid}, C::Ptr{Cvoid},
                                                            D::Ptr{Cvoid},
-                                                           stream::Cint)::hiptensorStatus_t
+                                                           stream::hipStream_t)::hiptensorStatus_t
 end
 
-function hiptensorCreateReduction(handle, desc, descA, modeA, opA, descC, modeC, opC, descD,
+@checked function hiptensorCreateReduction(handle, desc, descA, modeA, opA, descC, modeC, opC, descD,
                                   modeD, opReduce, descCompute)
-    @debug_ccall libhiptensor.hiptensorCreateReduction(handle::hiptensorHandle_t,
+    @ccall libhiptensor.hiptensorCreateReduction(handle::hiptensorHandle_t,
                                                  desc::Ptr{hiptensorOperationDescriptor_t},
                                                  descA::hiptensorTensorDescriptor_t,
                                                  modeA::Ptr{Int32},
@@ -419,13 +419,13 @@ function hiptensorCreateReduction(handle, desc, descA, modeA, opA, descC, modeC,
                                                  descCompute::hiptensorComputeDescriptor_t)::hiptensorStatus_t
 end
 
-function hiptensorReduce(handle, plan, alpha, A, beta, C, D, workspace, workspaceSize,
+@checked function hiptensorReduce(handle, plan, alpha, A, beta, C, D, workspace, workspaceSize,
                          stream)
-    @debug_ccall libhiptensor.hiptensorReduce(handle::hiptensorHandle_t, plan::hiptensorPlan_t,
+    @ccall libhiptensor.hiptensorReduce(handle::hiptensorHandle_t, plan::hiptensorPlan_t,
                                         alpha::Ptr{Cvoid}, A::Ptr{Cvoid}, beta::Ptr{Cvoid},
                                         C::Ptr{Cvoid}, D::Ptr{Cvoid}, workspace::Ptr{Cvoid},
                                         workspaceSize::UInt64,
-                                        stream::Cint)::hiptensorStatus_t
+                                        stream::hipStream_t)::hiptensorStatus_t
 end
 
 # typedef void ( * hiptensorLoggerCallback_t ) ( int32_t logContext , const char * funcName , const char * msg )