TheRock/rocm-libraries/projects/hipsparselt/clients/include/hipsparselt_common.yaml

# Data types are defined as either aliases to Python-recognized ctypes,
# or enums defined with c_int base clases and attributes.
Datatypes:
  - hipDataType:
      bases: [ c_int ]
      attr:
        default: 0
        f32_r: 0
        f16_r: 2
        i8_r: 3
        i32_r: 10
        bf16_r: 14
        f8_r: 28
        bf8_r: 29
        f8_fnuz_r: 1000
        bf8_fnuz_r: 1001

  - hipsparseLtComputetype_t:
      bases: [ c_int ]
      attr:
        c_f16_r: 0
        c_i32_r: 1
        c_f32_r: 2
  - { half: f16_r }
  - hipsparselt_initialization:
      bases: [ c_int ]
      attr:
        rand_int: 111
        trig_float: 222
        hpl: 333
        special: 444
  - hipsparselt_activation_type:
      bases: [ c_int ]
      attr:
        none: 0
        abs: 1
        clippedrelu: 2
        gelu: 3
        leakyrelu: 4
        relu: 5
        sigmoid: 6
        tanh: 7



Common threads and streams: &common_threads_streams
  - { threads: 0,  streams: 0}
  # - { threads: 0, streams: 1 }
  # - { threads: 1, streams: 0 }
  # - { threads: 3, streams: 3 }
  # - { threads: 5, streams: 5 }

Real precisions: &real_precisions
  - &hpa_half_precision
    { a_type: f16_r, b_type: f16_r, c_type: f16_r, d_type: f16_r, compute_type: c_f32_r }
  - &hpa_bf16_precision
    { a_type:  bf16_r, b_type:  bf16_r, c_type: bf16_r, d_type: bf16_r, compute_type: c_f32_r }
  - &hpa_int8_precision
    { a_type:  i8_r, b_type:  i8_r, c_type: i8_r, d_type: i8_r, compute_type: c_i32_r }
  - &hpa_int8_half_precision
    { a_type:  i8_r, b_type:  i8_r, c_type: f16_r, d_type: f16_r, compute_type: c_i32_r }
  - &hpa_int8_bf16_precision
    { a_type:  i8_r, b_type:  i8_r, c_type: bf16_r, d_type: bf16_r, compute_type: c_i32_r }
  - &hpa_int8_int32_precision
    { a_type:  i8_r, b_type:  i8_r, c_type: i32_r, d_type: i32_r, compute_type: c_i32_r }    
  - &hpa_e4m3_fp32_precision
    { a_type:  f8_r, b_type:  f8_r, c_type: f32_r, d_type: f32_r, compute_type: c_f32_r, gpu_arch: '(950|1250)'}
  - &hpa_e5m2_fp32_precision
    { a_type:  bf8_r, b_type:  bf8_r, c_type: f32_r, d_type: f32_r, compute_type: c_f32_r, gpu_arch: '(950|1250)'}
  - &hpa_e4m3_fnuz_fp32_precision
    { a_type:  f8_fnuz_r, b_type:  f8_fnuz_r, c_type: f32_r, d_type: f32_r, compute_type: c_f32_r, gpu_arch: '942'}
  - &hpa_e5m2_fnuz_fp32_precision
    { a_type:  bf8_fnuz_r, b_type:  bf8_fnuz_r, c_type: f32_r, d_type: f32_r, compute_type: c_f32_r, gpu_arch: '942'}    

Real precisions 2 bytes: &real_precisions_2b
  - *hpa_half_precision
  - *hpa_bf16_precision

Real precisions 1 bytes: &real_precisions_1b
  - *hpa_int8_precision
  - *hpa_int8_half_precision
  - *hpa_int8_bf16_precision
  - *hpa_int8_int32_precision
  - *hpa_e4m3_fp32_precision
  - *hpa_e5m2_fp32_precision
  - *hpa_e4m3_fnuz_fp32_precision
  - *hpa_e5m2_fnuz_fp32_precision  

Real precisions 1 bytes for input: &real_precisions_1b_input
  - *hpa_int8_precision
  - *hpa_e4m3_fp32_precision
  - *hpa_e5m2_fp32_precision
  - *hpa_e4m3_fnuz_fp32_precision
  - *hpa_e5m2_fnuz_fp32_precision

acvation_sigmoid_tanh precisions: &activation_sigmoid_tanh_precisions
  - *hpa_half_precision
  - *hpa_bf16_precision

# The Arguments struct passed directly to C++. See hipsparselt_arguments.hpp.
# The order of the entries is significant, so it can't simply be a dictionary.
# The types on the RHS are eval'd for Python-recognized types including ctypes
# and datatypes defined in Datatypes above. T*n represents array of length n.
Arguments:
  - function: c_char*64
  - name: c_char*64
  - category: c_char*64
  - known_bug_platforms: c_char*64
  - alpha: c_float
  - beta: c_float
  - stride_a: c_int64
  - stride_b: c_int64
  - stride_c: c_int64
  - stride_d: c_int64
  - stride_gate: c_int64
  - user_allocated_workspace: c_size_t
  - M: c_int64
  - N: c_int64
  - K: c_int64
  - lda: c_int64
  - ldb: c_int64
  - ldc: c_int64
  - ldd: c_int64
  - ldg: c_int64
  - batch_count: c_int32
  - iters: c_int32
  - cold_iters: c_int32
  - algo: c_uint32
  - solution_index: c_int32
  - prune_algo: c_uint32
  - a_type: hipDataType
  - b_type: hipDataType
  - c_type: hipDataType
  - d_type: hipDataType
  - compute_type: hipsparseLtComputetype_t
  - initialization: hipsparselt_initialization
  - gpu_arch: c_char*16
  - pad: c_uint32
  - threads: c_uint16
  - streams: c_uint16
  - devices: c_uint8
  - norm_check: c_int8
  - unit_check: c_int8
  - norm_check_assert: c_bool
  - timing: c_int8
  - transA: c_char
  - transB: c_char
  - activation_type: hipsparselt_activation_type
  - activation_arg1: c_float
  - activation_arg2: c_float
  - bias_vector: c_bool
  - bias_stride: c_int64
  - bias_type: hipDataType
  - gate_residual: c_bool
  - gate_type: hipDataType
  - c_noalias_d: c_bool
  - HMM: c_bool
  - search: c_bool
  - search_iters: c_int32
  - sparse_b: c_bool
  - func_version: c_int32
  - alpha_vector_scaling: c_bool
  - orderA: c_char
  - orderB: c_char
  - orderC: c_char
  - orderD: c_char
  - inEqualOut: c_bool
  - logging: c_int32

# These named dictionary lists [ {dict1}, {dict2}, etc. ] supply subsets of
# test arguments in a structured way. The dictionaries are applied to the test
# one at a time, to generate combinations.  If one of this table's entries is
# a dictionary of size one, it means that the argument named by its key takes
# on values paired with argument named by its value. For example:
#
# - function: precision
#
# when used with the code:
#
# function:
#   func1: prec1
#   func2: prec2
#   func3: prec3
#
# causes (function, precision) to take on the values (func1, prec1),
# (func2, prec2), (func3, prec3), etc.

Dictionary lists to expand:
  - arguments
  - transA_transB
  - alpha_beta
  - alphai_betai
  - incx_incy
  - matrix_size
  - precision
  - function: precision
  - threads_streams

# In case an array argument needs to be passed directly to C as an array,
# it needs to be listed here to avoid being expanded into multiple test
# cases with each of its elements.
Lists to not expand:
  - e.g., an array argument not to be expanded

# Defaults
Defaults:
  M: 128
  N: 128
  K: 128
  alpha: 1.0
  beta: 0.0
  transA: '*'
  transB: '*'
  batch_count: 1
  HMM: false
  pad: 4096
  threads: 0
  streams: 0
  devices: 0
  gpu_arch: ''
  norm_check: 0
  unit_check: 1
  norm_check_assert: true
  timing: 0
  iters: 10
  cold_iters: 2
  algo: 0
  solution_index: 0
  prune_algo: 1
  workspace_size: 0
  initialization: rand_int
  category: nightly
  known_bug_platforms: ''
  name: hipsparselt-bench
  c_noalias_d: false
  user_allocated_workspace: 0
  activation_type: none
  activation_arg1: 0
  activation_arg2: 0
  bias_vector: false
  bias_stride: -1
  bias_type: f32_r
  gate_residual: false
  gate_type: f16_r
  ldg: -1
  stride_gate: -1
  search: false
  search_iters: 10
  sparse_b: false
  func_version: 1
  alpha_vector_scaling: false
  orderA: C
  orderB: C
  orderC: C
  orderD: C
  inEqualOut: false
  logging: -1