cache.cpp

/** @file
 * Testing utilities which create Quregs across all
 * available hardware deployments
 *
 * @author Tyson Jones
 */
 
#include "quest.h"
 
#include "macros.hpp"
#include "qvector.hpp"
#include "qmatrix.hpp"
#include "macros.hpp"
#include "linalg.hpp"
#include "config.hpp"
#include "cache.hpp"
 
#include <unordered_map>
#include <tuple>
#include <vector>
#include <string>
 
using std::tuple;
using std::vector;
using std::string;
 
 
 
/*
 * caches of Quregs and FullStateDiagMatr
 * which persist between calls of get-cache()
 */
 
quregCache statevecs1;
quregCache statevecs2;
quregCache densmatrs1;
quregCache densmatrs2;
matrixCache matrices;
 
int getNumCachedQubits() {
 
    // we are merely aliasing the below env-var fetching function
    // to minimise a diff since pre-runtime controlling the tested
    // Qureg sizes is experimental and not fully designed (we may
    // eventually wish to specify different sizes for statevectors
    // vs density matrices, or control integration test Qureg sizes
    // also through environment variables, etc)
    return getNumQubitsInUnitTestedQuregs();
}
 
 
 
/*
 * deployments in cache
 */
 
deployInfo getSupportedDeployments() {
 
    deployInfo out;
 
    // determine which Qureg deployments are supported
    QuESTEnv env = getQuESTEnv();
    bool omp = env.isMultithreaded;
    bool mpi = env.isDistributed;
    bool gpu = env.isGpuAccelerated;
 
    // return only the "most-accelerated" deployment, unless all are desired
    bool one = ! getWhetherToTestAllDeployments();
 
    // add only those supported to the output list, in order of preference.
    // flag order is (MPI, GPU, OMP), matching createCustomQureg
    if (gpu && omp && mpi) { out.push_back({"GPU + OMP + MPI", 1, 1, 1}); if (one) return out; }
    if (gpu && mpi)        { out.push_back({"GPU + MPI",       1, 1, 0}); if (one) return out; }
    if (gpu && omp)        { out.push_back({"GPU + OMP",       0, 1, 1}); if (one) return out; }
    if (gpu)               { out.push_back({"GPU",             0, 1, 0}); if (one) return out; }
    if (mpi && omp)        { out.push_back({"CPU + OMP + MPI", 1, 0, 1}); if (one) return out; }
    if (mpi)               { out.push_back({"CPU + MPI",       1, 0, 0}); if (one) return out; }
    if (omp)               { out.push_back({"CPU + OMP",       0, 0, 1}); if (one) return out; }
    if (true)              { out.push_back({"CPU",             0, 0, 0}); if (one) return out; }
 
    // always contains CPU obviously, but this makes it explicit
    DEMAND( !out.empty() );
    
    // return all supported deployments
    return out;
}
 
 
 
/*
 * manage cached quregs
 */
 
quregCache createCachedStatevecsOrDensmatrs(bool isDensMatr) {
 
    quregCache out;
 
    // only add supported-deployment quregs to the cache
    for (auto [label, mpi, gpu, omp] : getSupportedDeployments())
        out[label] = createCustomQureg(getNumCachedQubits(), isDensMatr, mpi, gpu, omp);
 
    return out;
}
 
void createCachedQuregs() {
 
    // must not be called twice nor pre-creation
    DEMAND( statevecs1.empty() );
    DEMAND( statevecs2.empty() );
    DEMAND( densmatrs1.empty() );
    DEMAND( densmatrs2.empty() );
 
    statevecs1 = createCachedStatevecsOrDensmatrs(false);
    statevecs2 = createCachedStatevecsOrDensmatrs(false);
    densmatrs1 = createCachedStatevecsOrDensmatrs(true);
    densmatrs2 = createCachedStatevecsOrDensmatrs(true);
}
 
void destroyCachedQuregs() {
 
    // must not be called twice nor pre-creation
    DEMAND( ! statevecs1.empty() );
    DEMAND( ! statevecs2.empty() );
    DEMAND( ! densmatrs1.empty() );
    DEMAND( ! densmatrs2.empty() );
 
    auto caches = {
        statevecs1, statevecs2, 
        densmatrs1, densmatrs2};
 
    for (auto& cache : caches)
        for (auto& [label, qureg]: cache)
            destroyQureg(qureg);
 
    statevecs1.clear();
    statevecs2.clear();
    densmatrs1.clear();
    densmatrs2.clear();
}
 
quregCache getCachedStatevecs() {
 
    // must not be called pre-creation nor post-destruction
    DEMAND( !statevecs1.empty() );
 
    return statevecs1;
}
quregCache getCachedDensmatrs() {
 
    // must not be called pre-creation nor post-destruction
    DEMAND( !densmatrs1.empty() );
 
    return densmatrs1;
}
 
quregCache getAltCachedStatevecs() {
 
    // must not be called pre-creation nor post-destruction
    DEMAND( !statevecs2.empty() );
 
    return statevecs2;
}
quregCache getAltCachedDensmatrs() {
 
    // must not be called pre-creation nor post-destruction
    DEMAND( !densmatrs2.empty() );
 
    return densmatrs2;
}
 
 
 
/*
 * manage cached FullStateDiagMatr
 */
 
void createCachedFullStateDiagMatrs() {
 
    // must not be called twice
    DEMAND( matrices.empty() );
 
    // only add supported-deployment matrices to the cache
    for (auto [label, mpi, gpu, omp] : getSupportedDeployments())
        matrices[label] = createCustomFullStateDiagMatr(getNumCachedQubits(), mpi, gpu, omp);
}
 
void destroyCachedFullStateDiagMatrs() {
 
    // must not be called twice
    DEMAND( !matrices.empty() );
 
    for (auto& [label, matrix]: matrices)
        destroyFullStateDiagMatr(matrix);
 
    matrices.clear();
}
 
matrixCache getCachedFullStateDiagMatrs() {
 
    // must not be called pre-creation nor post-destruction
    DEMAND( !matrices.empty() );
 
    return matrices;
}
 
 
/*
 * reference states of equivalent 
 * dimension to the cached quregs
 */
 
qvector getRefStatevec() {
    return getZeroVector(getPow2(getNumCachedQubits()));
}
qmatrix getRefDensmatr() {
    return getZeroMatrix(getPow2(getNumCachedQubits()));
}