Function assertAdditionalHeapMatrixFieldsAreValid

quest/src/core/validation.cpp:2298–2365

// T can be CompMatr, DiagMatr, FullStateDiagMatr
template <class T>
void assertAdditionalHeapMatrixFieldsAreValid(T matr, const char* caller) {

    // assert heap pointers are not NULL
    assertThat(mem_isAllocated(matr.isApproxUnitary),     report::INVALID_HEAP_FLAG_PTR, caller);
    assertThat(mem_isAllocated(matr.isApproxHermitian),   report::INVALID_HEAP_FLAG_PTR, caller);
    assertThat(mem_isAllocated(matr.wasGpuSynced),  report::INVALID_HEAP_FLAG_PTR, caller);

    // only diagonal matrices (which can be exponentiated) have these additional flags
    if constexpr (!util_isDenseMatrixType<T>()) {
        assertThat(mem_isAllocated(matr.isApproxNonZero),       report::INVALID_HEAP_FLAG_PTR, caller);
        assertThat(mem_isAllocated(matr.isStrictlyNonNegative), report::INVALID_HEAP_FLAG_PTR, caller);
    }

    tokenSubs vars = {{"${BAD_FLAG}", 0}, {"${UNKNOWN_FLAG}", validate_STRUCT_PROPERTY_UNKNOWN_FLAG}};

    // assert isApproxUnitary has valid value
    int flag = *matr.isApproxUnitary;
    vars["${BAD_FLAG}"] = flag;
    assertThat(flag == 0 || flag == 1 || flag == validate_STRUCT_PROPERTY_UNKNOWN_FLAG, report::INVALID_HEAP_FLAG_VALUE, vars, caller);

    // assert isApproxHermitian has valid value
    flag = *matr.isApproxHermitian;
    vars["${BAD_FLAG}"] = flag;
    assertThat(flag == 0 || flag == 1 || flag == validate_STRUCT_PROPERTY_UNKNOWN_FLAG, report::INVALID_HEAP_FLAG_VALUE, vars, caller);

    // assert wasGpuSynced has a valid value
    flag = *matr.wasGpuSynced;
    vars["${BAD_FLAG}"] = flag;
    assertThat(flag == 0 || flag == 1, report::INVALID_HEAP_FLAG_VALUE, vars, caller);

    // assert isApproxNonZero and isStrictlyNonNegative have valid values (only bound to diagonal matrices)
    if constexpr (!util_isDenseMatrixType<T>()) {
        flag = *matr.isApproxNonZero;
        vars["${BAD_FLAG}"] = flag;
        assertThat(flag == 0 || flag == 1 || flag == validate_STRUCT_PROPERTY_UNKNOWN_FLAG, report::INVALID_HEAP_FLAG_VALUE, vars, caller);

        flag = *matr.isStrictlyNonNegative;
        vars["${BAD_FLAG}"] = flag;
        assertThat(flag == 0 || flag == 1 || flag == validate_STRUCT_PROPERTY_UNKNOWN_FLAG, report::INVALID_HEAP_FLAG_VALUE, vars, caller);
    }

    // checks whether users have, after destroying their struct, manually set the outer
    // heap-memory pointers to NULL. We do not check inner pointers of 2D structures (which may
    // be too expensive to enumerate), and we cannot determine whether the struct was not validly
    // created because un-initialised structs will have random non-NULL pointers.
    assertThat(mem_isOuterAllocated(matr.cpuElems), report::INVALID_MATRIX_CPU_ELEMS_PTR, caller);

    // check whether GPU status/memory pointers are consistent with env
    validate_envIsInit(caller);
    bool envIsGpuAccel = getQuESTEnv().isGpuAccelerated;
    bool matrHasGpuAlloc = mem_isOuterAllocated(util_getGpuMemPtr(matr));

    // FullStateDiagMatr can disable GPU-accel even in GPU-accelerated environments
    if constexpr (util_isFullStateDiagMatr<T>()) {
        if (matr.isGpuAccelerated) {
            assertThat(envIsGpuAccel, report::FULL_STATE_DIAG_MATR_GPU_ACCEL_IN_NON_GPU_ENV, caller);
            assertThat(matrHasGpuAlloc, report::MATRIX_GPU_ELEMS_PTR_UNEXPECTEDLY_NULL, caller);
        } else