Function assertNewMatrixAllocsSucceeded

quest/src/core/validation.cpp:2061–2119

// T can be CompMatr, DiagMatr, FullStateDiagMatr (i.e. heap-based matrices)
template <typename T>
void assertNewMatrixAllocsSucceeded(T matr, size_t numBytes, const char* caller) {

    // this validation is called AFTER the caller has checked for failed
    // allocs and (in that scenario) freed every pointer, but does not 
    // overwrite any pointers to nullptr, so the failed alloc is known.
    // This is only safe to do so (rather than making the caller set ptrs
    // to nullptr) because the structs contains only 1D pointer; even 
    // CompMatr which "fakes" a 2D ptr via offsets of a contiguous array.

    // we expensively get node consensus about malloc failure, in case of heterogeneous hardware/loads,
    // but we avoid this potetially expensive synchronisation if validation is anyway disabled
    // (which also avoids us enumerating the matrix rows)
    if (!global_isValidationEnabled)
        return;

    /// @todo
    /// fix this abhorrent hackiness! Presently, tokenSubs accepts only qindex (in lieu of 
    /// unsigned size_t) in order to be able to report negative numbers. But alas, the max
    /// size_t is bigger than max qindex, due to the sign-bit. So trying to report numBytes
    /// can cause a size_t -> qindex overflow. This is a realistic scenario, occurring when
    /// when the user tries to allocate the max-size memory for which malloc incidentally
    /// fails. This is when numBytes is +1 too big to be a qindex; we simply reduce by 2!
    /// We under-report the memory by 2 bytes, instead of 1, just to avoid an odd number 
    /// which an astute user would immediately notice is not a power-of-2 and be confused by.
    /// This is a hacky evil, but it is better than reporting a negative memory size!
    tokenSubs vars;
    vars["${NUM_BYTES}"] = ((qindex) numBytes <= 0)?
        numBytes - 2 : numBytes;

    // assert CPU array (which may be nested arrays) all allocated successfully
    bool isAlloc;
    if constexpr (util_isDenseMatrixType<T>()) {
        // size of .cpuElems isn't included in numBytes report which is fine; it's
        // quadratically smaller than .cpuElemsFlat so quickly negligible
        isAlloc = mem_isAllocated(matr.cpuElemsFlat) && mem_isOuterAllocated(matr.cpuElems);
    } else
        isAlloc = mem_isAllocated(matr.cpuElems);
    assertAllNodesAgreeThat(isAlloc, report::NEW_MATRIX_CPU_ELEMS_ALLOC_FAILED, vars, caller);

    // optionally assert GPU memory was malloc'd successfully
    bool gpuShouldBeAlloc = getQuESTEnv().isGpuAccelerated;
    if constexpr (util_isFullStateDiagMatr<T>())
        gpuShouldBeAlloc &= matr.isGpuAccelerated;
        
    if (gpuShouldBeAlloc)
        assertAllNodesAgreeThat(mem_isAllocated(util_getGpuMemPtr(matr)), report::NEW_MATRIX_GPU_ELEMS_ALLOC_FAILED, vars, caller);

    // assert the teeny-tiny heap flags are alloc'd
    vars["${NUM_BYTES}"] = sizeof(*(matr.isApproxUnitary)); // all fields are same-size
    assertAllNodesAgreeThat(mem_isAllocated(matr.isApproxUnitary),     report::NEW_HEAP_FLAG_ALLOC_FAILED, vars, caller);
    assertAllNodesAgreeThat(mem_isAllocated(matr.isApproxHermitian),   report::NEW_HEAP_FLAG_ALLOC_FAILED, vars, caller);
    assertAllNodesAgreeThat(mem_isAllocated(matr.wasGpuSynced),  report::NEW_HEAP_FLAG_ALLOC_FAILED, vars, caller);

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