spmv calculation error at one-base, correct calculation at zero-base

[RustLyu]

Hi.

• aocl version:5.3
• os:llinux
• compile:gcc 16.1.1

Here is the code:
`#define M 5
#define N 5
#define NNZ 8

int test_example(void)
{
aoclsparse_status status;
aoclsparse_matrix A = NULL;
aoclsparse_mat_descr descr = NULL;
aoclsparse_operation trans = aoclsparse_operation_none;
//aoclsparse_index_base base = aoclsparse_index_base_zero;
aoclsparse_index_base base = aoclsparse_index_base_one;

double alpha = 1.0;
double beta  = 0.0;

// Original matrix
//  1  0  0  2  0
//  0  3  0  0  0
//  0  0  4  0  0
//  0  5  0  6  7
//  0  0  0  0  8
// aoclsparse_int coo_row_ind[NNZ] = {0, 0, 1, 2, 3, 3, 3, 4};
// aoclsparse_int coo_col_ind[NNZ] = {0, 3, 1, 2, 1, 3, 4, 4};
aoclsparse_int coo_row_ind[NNZ] = {1, 1, 2, 3, 4, 4, 4, 5};
aoclsparse_int coo_col_ind[NNZ] = {1, 4, 2, 4, 2, 4, 5, 5};
double         coo_val[NNZ]     = {1, 2, 3, 4, 5, 6, 7, 8};

// Input vectors
double x[N] = {1.0, 2.0, 3.0, 4.0, 5.0};
double y[M];

// Expected reference result & tolerance
double         y_exp[M] = {9.0, 6.0, 12.0, 69.0, 40.0};
double         tol      = 1e-12;
aoclsparse_int oki, ok = 1;

// Print aoclsparse version
printf("%s\n", aoclsparse_get_version());

// Create matrix descriptor
aoclsparse_create_mat_descr(&descr);

status = aoclsparse_create_dcoo(&A, base, M, N, NNZ, coo_row_ind, coo_col_ind, coo_val);
if(status != aoclsparse_status_success)
{
    printf("Error while creating COO sparse matrix, status = %i\n", status);
    return 1;
}
aoclsparse_matrix csr;

status = aoclsparse_convert_csr(
    A,
    aoclsparse_operation_none,
    &csr
    );
// Hint the system what operation to expect
status = aoclsparse_set_mv_hint(csr, trans, descr, 1);
if(status != aoclsparse_status_success)
{
    printf("Error while hinting operation, status = %i\n", status);
    return 1;
}

status = aoclsparse_optimize(csr);
if(status != aoclsparse_status_success)
{
    printf("Error while optimizing the matrix, status = %i\n", status);
    return 1;
}

// Invoke SPMV API (double precision)
printf("Invoking aoclsparse_dmv after COO->CSR optimize...\n");
status = aoclsparse_dmv(trans, &alpha, csr, descr, x, &beta, y);
if(status != aoclsparse_status_success)
{
    printf("Error while computing SPMV, status = %i\n", status);
    return 1;
}

// Print and check the results
printf("Output vector:\n");
for(aoclsparse_int i = 0; i < M; i++)
{
    oki = fabs(y[i] - y_exp[i]) <= tol;
    printf("  %lf %c\n", y[i], oki ? ' ' : '!');
    ok = ok && oki;
}

// Cleanup
aoclsparse_destroy_mat_descr(descr);
aoclsparse_destroy(&A);
return ok ? 0 : 2;

}
`
Everything is normal at 0 base, but when I just changed the matrix to 1-base, aoclsparse_det_mv_cint funtion returns aoclsparse_stus_invalid_value, Does this interface not support 1base？
Best regards!

[RustLyu]

Hi.
One base needs to be set separately using aoclsparse_set_mat_index_base. After setting it, it works. But isn't this base stored in a sparse matrix structure?

[RustLyu]

I found that when using COO to create aoclsparse_matrix and then converting it to CSR format, the aoclsparse_matrix of the CSR created in this way occasionally fails to calculate mv with the prompt aoclsparse_stus_not_implemented, but sometimes it succeeds.
Here is convert function code:
void SPARSE_MATRIX::ensure_csr() { if (syn_state && A != NULL) return; aoclsparse_matrix cooA = nullptr; aoclsparse_status status = aoclsparse_create_dcoo(&cooA, aoclsparse_index_base_one, m, n, nnz, rows, columns, values); if (A != NULL) aoclsparse_destroy((aoclsparse_matrix*)&A); status = aoclsparse_convert_csr(cooA, aoclsparse_operation_none, (aoclsparse_matrix*)&A); if (status != aoclsparse_status_success) { std::cout << "aocl coo 2 csr error. code:" << status << std::endl; } aoclsparse_destroy(&cooA); syn_state = true; }

[vchunchu-amd]

Hi @RustLyu, thanks for the detailed report and the clear reproducer — and for following up with your own findings.

On issue 1 (one-base returns aoclsparse_status_invalid_value)

This is expected with the current design. In AOCL-Sparse the index base is carried in two places:

the matrix (set via aoclsparse_create_dcoo(..., aoclsparse_index_base_one, ...), and preserved through aoclsparse_convert_csr), and
the matrix descriptor (aoclsparse_mat_descr), whose base defaults to aoclsparse_index_base_zero.
The SpMV path currently requires the descriptor's base to match the matrix's base, so a base-one matrix used with a default (base-zero) descriptor is rejected with aoclsparse_status_invalid_value. That's why your workaround is the right one:

aoclsparse_create_mat_descr(&descr);
aoclsparse_set_mat_index_base(descr, aoclsparse_index_base_one);
Your underlying question — "isn't the base already stored in the matrix?" — is a fair one. Requiring the descriptor to also specify the base is a deliberate design choice at the moment, but we agree it's worth reconsidering, and we'll discuss internally whether SpMV should honor the matrix's stored base when the descriptor is left at its default. For now, please set the descriptor's index base to match the matrix (as above).

On issue 2 (intermittent aoclsparse_status_not_implemented after COO → CSR)

We tried to reproduce this using the matrix and flow you described — repeatedly creating a one-base COO, converting to CSR, hinting/optimizing, and calling mv in a loop (thousands of iterations, both Release and an AddressSanitizer debug build). We were not able to trigger the not_implemented status; every call succeeded.

To help us dig further, could you please share a complete, self-contained reproducer for this second symptom, including:

the full source (your SPARSE_MATRIX::ensure_csr() plus the surrounding code that calls mv, and how rows/columns/values/m/n/nnz are populated),
the exact AOCL-Sparse version/build (and whether it's LP64/ILP64, single/multi-threaded), compiler and flags, and
whether the failures correlate with multithreading or specific matrices.
aoclsparse_status_not_implemented from mv usually points to a matrix format/state that the requested operation doesn't support, so the surrounding setup will be important. The intermittent nature suggests it may depend on state we can only see with your full flow.

Thanks again — we'll update here once we've discussed the base-handling behavior for issue 1.

[RustLyu]

Thanks for the reply. @vchunchu-amd Apologies for conflating multiple issues. I didn't describe the second issue clearly; I work in multiple environments, requiring compatibility with both Win+MSVC and Linux+GCC. Here are the details for the second issue:

OS: Windows
Compiler: MSVC143
AOCL Lib: 5.3 (MT) LP

I suspect the problem was caused by a runtime library mismatch—specifically, using the Release version of the AOCL library (downloaded directly from the official site, which only offers Release versions) while running in Debug mode. I was also experiencing crashes related to memory management; switching to Release mode resolved the DMV issues and stopped the crashes. However, the problem with aoclsparse_dsp2md persists (it was already an issue before the switch to Release mode, return aoclsparse_status_not_implemented). Below is my test code:

`void test_aocl_dsp2md()
{
int32_t m = 2, n = 2, nnz = 2;
// matrix A COO
std::vector<int32_t> rows_A{1,1};
std::vector<int32_t> columns_A{1,2};
std::vector values_A{2.0,1.0};

// convert A (COO -> CSR) 
aoclsparse_matrix cooA = nullptr;
aoclsparse_status status = aoclsparse_create_dcoo(&cooA, aoclsparse_index_base_one, m, n, nnz, rows_A.data(), columns_A.data(), values_A.data());
aoclsparse_matrix csrA = nullptr;
status = aoclsparse_convert_csr(cooA, aoclsparse_operation_none, &csrA);
if (status != aoclsparse_status_success)
{
	std::cerr << "mtx A aocl coo 2 csr error. code:" << status << std::endl;
}

// matrix B COO
std::vector<int32_t> rows_B{1,1};
std::vector<int32_t> columns_B{1,2};
std::vector<double> values_B{1.0,3.0};

// convert B (COO -> CSR) 
aoclsparse_matrix cooB = nullptr;
status = aoclsparse_create_dcoo(&cooB, aoclsparse_index_base_one, m, n, nnz, rows_B.data(), columns_B.data(), values_B.data());
aoclsparse_matrix csrB = nullptr;
status = aoclsparse_convert_csr(cooB, aoclsparse_operation_none, &csrB);

if (status != aoclsparse_status_success)
{
	std::cerr << "mtx B aocl coo 2 csr error. code:" << status << std::endl;
}
aoclsparse_mat_descr descrA;
aoclsparse_create_mat_descr(&descrA);
aoclsparse_set_mat_index_base(descrA, aoclsparse_index_base_one);
aoclsparse_mat_descr descrB;
aoclsparse_create_mat_descr(&descrB);
aoclsparse_set_mat_index_base(descrB, aoclsparse_index_base_one);

status = aoclsparse_set_mm_hint(csrA, aoclsparse_operation_none, descrA, 1);

status = aoclsparse_set_mm_hint(csrB, aoclsparse_operation_none, descrB, 1);

double alpha = 1.0;
double beta = 0.0;
double dense_c[4];
// cal. dsp2md
status = aoclsparse_dsp2md(aoclsparse_operation_none, descrA, csrA, aoclsparse_operation_none, descrB, 
	csrB, alpha, beta, dense_c, aoclsparse_order_column, 2);
if (status != aoclsparse_status_success)
{
	std::cerr << "aoclsparse_dsp2md error. code:" << status << std::endl;
}

}`
aoclsparse_dsp2md return aoclsparse_status_not_implemented.
Thank you!

[RustLyu]

I used aoclsparse_export_dcsr, and the export worked fine.
However, after recompiling the AOCL library from source on Windows, debugging revealed that the mat_type of the aoclsparse_matrix appeared to be uninitialized—holding an invalid value (-842150451) on debug mode. The operation failed at line 262 of aoclsparse_sp2md.hpp; it seems this attribute was not assigned a value during the conversion from COO to CSR format in aoclsparse_convert_csr function.
In aoclsparse_auxiliary.cpp at line 1008, the aoclsparse_init_mat method fails to initialize the mat_type field of the aoclsparse_matrix structure.

[RustLyu]

This is ensure_csr function:
`void ensure_csr()
{
if (syn_state && A != NULL)
return;
aoclsparse_matrix cooA = nullptr;
aoclsparse_status status = aoclsparse_create_dcoo(&cooA, aoclsparse_index_base_one, m, n, nnz, rows, columns, values);
if (A != NULL)
aoclsparse_destroy((aoclsparse_matrix*)&A);
status = aoclsparse_convert_csr(cooA, aoclsparse_operation_none, (aoclsparse_matrix*)&A);

int mat_type = ((_aoclsparse_matrix_kk*)A)->mat_type;
std::cerr << "mat type:" << mat_type << std::endl;
if (status != aoclsparse_status_success)
{
	std::cerr << "aocl coo 2 csr error. code:" << status << std::endl;
}
aoclsparse_destroy(&cooA);
syn_state = true;

}It is simply constructed using COO triples: Step 1: ConstructcooAusing the COO format. Step 2: ConvertcooAinto anaoclsparse_matrixin CSR format usingaoclsparse_convert_csr, and verify the mat_type` via the log output.

Logging reveals that mat_type holds an invalid value: in debug mode, it is -842150451, while in release mode, it is sometimes 0 and sometimes 7 (the enum value for the COO format).Everything works correctly when the value is 0, but dsp2md returns an error when it is
7.

_aoclsparse_matrix_kk is a structure I copied from the AOCL source code and re-mapped to make it easier to inspect internal values; this does not affect the field attributes.

[vchunchu-amd]

Hi @RustLyu, following your own investigation (rebuilding AOCL-Sparse from source and tracing mat_type after aoclsparse_convert_csr), we can now confirm the root cause, and it matches your finding exactly.

Every matrix carries an internal format tag (mat_type) that dispatch routines read to pick the right kernel (CSR, COO, etc.). When you build a matrix directly (aoclsparse_create_dcoo / _dcsr) this tag is set correctly. But the COO → CSR conversion path (aoclsparse_convert_csr) fills in the dimensions, values, and data type yet never sets mat_type on the new CSR matrix — so it is left uninitialized. Reading an uninitialized field is undefined behavior, which is exactly why the symptom is intermittent and platform-dependent:

• On Linux the freshly allocated memory is typically zero, and zero happens to equal the code for "CSR", so it works by accident.
• On your Windows/MSVC build the memory holds a debug fill (0xCDCDCDCD, i.e. -842150451) in Debug, or stale data in Release (you saw 0 = works vs 7 = the code for COO = fails) — a non-CSR value trips the dispatch and returns aoclsparse_status_not_implemented.

We reproduced this deterministically on Linux as well: building with AddressSanitizer (which fills new allocations with the byte 0xBE by default) makes mat_type read back as 0xBEBEBEBE, and our unit test then fails every time — the same failure you saw on Windows, now on demand. This confirms it's a genuine library defect, not something in your code: the CSR matrix produced by aoclsparse_convert_csr is otherwise correct.

The fix is straightforward — initialize mat_type during conversion (and give the field a safe default so it can never be left indeterminate). Alongside this, we will make further edits to harden the code against any mat_type-related issues more broadly: giving the field a guaranteed default so it is not indeterminate, and making sure every conversion/creation path sets it explicitly, so a similar gap cannot resurface elsewhere. We will address this in the next development push. In the meantime, building your matrix directly as CSR (aoclsparse_create_dcsr) avoids the conversion path and is a safe workaround.

Thanks again for the debugging — it made pinning this down much faster.

[RustLyu]

Hi，@vchunchu-amd I’d like to ask about a performance issue regarding aocl-sparse: is there a performance difference between the dynamic libraries produced by GCC and AOCC, and does AOCC offer better performance?
Best regards!

[vchunchu-amd]

Hi @RustLyu,

We provide both AOCC and GCC builds of AOCL-Sparse to support a wide range of user applications, so either can be used depending on your requirement and toolchain preference. That said, AOCC (AMD's Optimizing C/C++ Compiler) generally has the edge, as it is tuned for AMD "Zen" processors and tends to make the most of AOCL libraries on AMD hardware.

For more details and support, please feel free to reach out to the toolchain support team at toolchainsupport@amd.com.

Best regards