MaestroExe.cpp

Go to the documentation of this file.

#include <algorithm>
#include <boost/program_options.hpp>
#include <iostream>
#include <optional>
 
#include <fstream>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
 
#include "../Simulators/Interfaces/State.h"
#include "Simulator.hpp"
 
static std::string _get_env_var(const char *envs)
{
    std::string val;
 
#ifdef _WIN32
    size_t sz;
 
    getenv_s(&sz, NULL, 0, envs);
    if (sz == 0 || sz > 49)
        return val;
 
    char buf[50];
 
    getenv_s(&sz, buf, sz, envs);
 
    buf[49] = 0;
    val = buf;
#else
    const char *env = getenv(envs);
    if (env)
        val = env;
#endif
 
    return val;
}
 
// CLI selection uses the historical option numbers; the native enum omits
// Aer entries in builds without Aer, so translate at the ABI boundary.
static int BackendId(int option)
{
    using Backend = Simulators::SimulatorType;
    switch (option)
    {
#ifndef NO_QISKIT_AER
    case 0:
        return static_cast<int>(Backend::kQiskitAer);
    case 2:
        return static_cast<int>(Backend::kCompositeQiskitAer);
#endif
    case 1:
        return static_cast<int>(Backend::kQCSim);
    case 3:
        return static_cast<int>(Backend::kCompositeQCSim);
    case 4:
        return static_cast<int>(Backend::kGpuSim);
    case 5:
        return static_cast<int>(Backend::kQuestSim);
    default:
        throw std::invalid_argument("Requested backend is unavailable in this build");
    }
}
 
// An absent gateFusion leaves the backend default in place.
static std::string GetConfigJson(int num_shots, int maxBondDim, std::optional<bool> gateFusion)
{
    std::string config = "{\"shots\": ";
 
    config += std::to_string(num_shots);
 
    if (maxBondDim != 0)
        config += ", \"matrix_product_state_max_bond_dimension\": " + std::to_string(maxBondDim);
 
    if (gateFusion)
        config += *gateFusion ? ", \"gate_fusion\": true" : ", \"gate_fusion\": false";
 
    return config + "}";
}
 
int main(int argc, char **argv)
{
    try
    {
        std::ios_base::sync_with_stdio(false);
        std::cin.tie(nullptr);
 
        boost::program_options::options_description desc("Allowed options");
        desc.add_options()("help,h", "Print a help description")("version,v", "Print version information")(
            "nrqubits,n", boost::program_options::value<int>(), "Specify the number of qubits")("shots,s", boost::program_options::value<int>(),
                                                                                                "Specify the number of shots for execution")(
            "gate-fusion", boost::program_options::value<bool>(),
            "Force Maestro gate fusion on or off on supported simulators "
            "(default: on, except for small CPU statevectors and density "
            "matrices)")("mbd,m", boost::program_options::value<int>(), "Specify the max bond dimension for the MPS simulator")(
            "simulator,r", boost::program_options::value<std::string>(),
            "Simulator type, either aer, qcsim, composite_aer, composite_qcsim, "
            "gpu "
            "or quest")("type,t", boost::program_options::value<std::string>(),
                        "Simulation type, either statevector, mps, stabilizer, "
                        "tensor or pauli_propagation")("file,f", boost::program_options::value<std::string>(), "Provide a qasm file for execution")(
            "output,o", boost::program_options::value<std::string>(), "Specify the json output file")("expectations,e",
                                                                                                      "Compute expectation values of observables");
 
        boost::program_options::positional_options_description pos_desc;
        pos_desc.add("file", 1);
        pos_desc.add("output", 1);
 
        boost::program_options::variables_map vars;
        try
        {
            boost::program_options::basic_command_line_parser<char> parser(argc, argv);
            parser.positional(pos_desc);
            parser.options(desc);
 
            boost::program_options::store(parser.run(), vars);
            boost::program_options::notify(vars);
        }
        catch (boost::program_options::error &e)
        {
            std::cerr << "ERROR: " << e.what() << "\n";
            return 1;
        }
 
        if (vars.count("version"))
            std::cout << "Version 1.0\n";
 
        if (vars.count("help"))
            std::cout << desc << "\n";
 
        int nrQubits = 64;
        int nrShots = 1;
        int maxBondDim = 0;
#ifdef NO_QISKIT_AER
        int simulatorType = 1;
#else
        int simulatorType = 0;
#endif
        int simulationType = 0;
 
        if (vars.count("nrqubits"))
        {
            nrQubits = vars["nrqubits"].as<int>();
 
            const std::string qstr = _get_env_var("maestro_nrqubits");
            if (!qstr.empty())
            {
                const int nrQubitsMax = std::stoi(qstr);
                if (nrQubits > nrQubitsMax)
                    nrQubits = nrQubitsMax;
            }
        }
        else
        {
            const std::string qstr = _get_env_var("maestro_nrqubits");
            if (!qstr.empty())
                nrQubits = std::stoi(qstr);
        }
 
        if (nrQubits <= 0)
        {
            std::cerr << "Invalid number of qubits" << std::endl;
            return 2;
        }
 
        if (vars.count("shots"))
        {
            nrShots = vars["shots"].as<int>();
 
            const std::string sstr = _get_env_var("maestro_shots");
            if (!sstr.empty())
            {
                const int nrShotsMax = std::stoi(sstr);
                if (nrShots > nrShotsMax)
                    nrShots = nrShotsMax;
            }
        }
        else
        {
            const std::string sstr = _get_env_var("maestro_shots");
            if (!sstr.empty())
                nrShots = std::stoi(sstr);
        }
 
        if (nrShots <= 0)
            nrShots = 1;
 
        if (vars.count("mbd"))
        {
            maxBondDim = vars["mbd"].as<int>();
 
            const std::string mbds = _get_env_var("maestro_max_bond_dim");
            if (!mbds.empty())
            {
                const int mbdMax = std::stoi(mbds);
                if (maxBondDim > mbdMax || (maxBondDim <= 0 && mbdMax > 0))
                    maxBondDim = mbdMax;
            }
        }
        else
        {
            const std::string mbds = _get_env_var("maestro_max_bond_dim");
            if (!mbds.empty())
                maxBondDim = std::stoi(mbds);
        }
 
        if (maxBondDim < 0)
            maxBondDim = 0;
 
        std::string stype;
        if (vars.count("simulator"))
            stype = vars["simulator"].as<std::string>();
        else
            stype = _get_env_var("maestro_simulator_type");
 
        if (!stype.empty())
        {
            std::transform(stype.begin(), stype.end(), stype.begin(), [](unsigned char chr) { return std::tolower(chr); });
 
            if (stype == "aer")
                simulatorType = 0;
            else if (stype == "qcsim")
                simulatorType = 1;
            else if (stype == "composite_aer" || stype == "pblocks_aer")
                simulatorType = 2;
            else if (stype == "composite_qcsim" || stype == "pblocks_qcsim")
                simulatorType = 3;
            else if (stype == "gpu")
                simulatorType = 4;
            else if (stype == "quest")
                simulatorType = 5;
            else
                simulatorType = 1000; // something big, so it won't be set
        }
 
        if (simulatorType != 2 && simulatorType != 3)
        {
            stype.clear();
            if (vars.count("type"))
                stype = vars["type"].as<std::string>();
            else
                stype = _get_env_var("maestro_simulation_type");
 
            if (!stype.empty())
            {
                std::transform(stype.begin(), stype.end(), stype.begin(), [](unsigned char chr) { return std::tolower(chr); });
 
                if (stype == "statevector" || stype == "sv")
                    simulationType = 0;
                else if (stype == "mps" || stype == "matrix_product_state")
                    simulationType = 1;
                else if (stype == "stabilizer" || stype == "clifford")
                    simulationType = 2;
                else if (stype == "tensor" || stype == "tensor_network" || stype == "tn")
                    simulationType = 3;
                else if (stype == "pauli_propagation" || stype == "pauli" || stype == "pprop")
                    simulationType = 4;
                else
                    simulationType = 1000;
            }
        }
        else
            simulationType = 0; // statevector for composite
 
        if (vars.count("file") == 0)
        {
            std::cerr << "No qasm file provided" << std::endl;
            return 3;
        }
 
        const std::string qasmFileName = vars["file"].as<std::string>();
        if (qasmFileName.empty())
        {
            std::cerr << "Invalid qasm file" << std::endl;
            return 4;
        }
 
        std::ifstream file(qasmFileName);
        if (!file.is_open())
        {
            std::cerr << "Couldn't read the qasm file" << std::endl;
            return 5;
        }
 
        std::string qasmStr((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
        if (qasmStr.empty())
        {
            std::cerr << "Empty qasm" << std::endl;
            return 6;
        }
 
        bool computeExpectations = false;
        if (vars.count("expectations"))
            computeExpectations = true;
        else
        {
            const std::string estr = _get_env_var("maestro_expectations");
            if (!estr.empty())
                computeExpectations = (std::stoi(estr) != 0);
        }
 
        // after getting all params and so on, execute:
 
        SimpleSimulator simulator;
        if (!simulator.Init(
#if defined(_WIN32)
                "maestro.dll"
#else
                "libmaestro.so"
 
#endif
                ))
        {
            std::cerr << "Couldn't load maestro library" << std::endl;
            return 6;
        }
 
        simulator.CreateSimpleSimulator(nrQubits);
 
        if (simulatorType < 2) // qcsim or aer
        {
            if (simulationType < 4 || (simulatorType == 1 && simulationType == 4)) // qcsim also supports pauli propagation
                simulator.RemoveAllOptimizationSimulatorsAndAdd(BackendId(simulatorType), static_cast<int>(simulationType));
            else
            {
                simulator.RemoveAllOptimizationSimulatorsAndAdd(BackendId(simulatorType), 0);
                simulator.AddOptimizationSimulator(BackendId(simulatorType), 1);
                simulator.AddOptimizationSimulator(BackendId(simulatorType), 2);
            }
        }
        else if (simulatorType < 4) // composite, ignore exec type and set statevector
        {
            simulator.RemoveAllOptimizationSimulatorsAndAdd(BackendId(simulatorType), 0);
        }
        else if (simulatorType == 4) // gpu
        {
            if (simulationType < 2 || simulationType == 3 || simulationType == 4) // statevector or mps, or tensor or pauli propagation
                simulator.RemoveAllOptimizationSimulatorsAndAdd(BackendId(simulatorType), static_cast<int>(simulationType));
            else // other types are not supported yet on gpu, set statevector
                simulator.RemoveAllOptimizationSimulatorsAndAdd(BackendId(simulatorType), 0);
        }
        else if (simulatorType == 5) // quest, only supports statevector for now
        {
            simulator.RemoveAllOptimizationSimulatorsAndAdd(BackendId(simulatorType), 0);
        }
 
        static std::string configStr =
            GetConfigJson(nrShots, maxBondDim, vars.count("gate-fusion") ? std::optional<bool>(vars["gate-fusion"].as<bool>()) : std::nullopt);
 
        std::string result;
        if (!qasmStr.empty())
        {
            if (computeExpectations)
            {
                std::string obsFileName = qasmFileName;
                size_t lastDot = obsFileName.find_last_of(".");
                if (lastDot != std::string::npos)
                {
                    obsFileName = obsFileName.substr(0, lastDot);
                }
                obsFileName += ".obs";
 
                std::ifstream obsFile(obsFileName);
                if (obsFile.is_open())
                {
                    std::string obsStr((std::istreambuf_iterator<char>(obsFile)), std::istreambuf_iterator<char>());
                    obsStr.erase(std::remove(obsStr.begin(), obsStr.end(), '\n'), obsStr.end());
                    obsStr.erase(std::remove(obsStr.begin(), obsStr.end(), '\r'), obsStr.end());
                    if (!obsStr.empty())
                    {
                        char *res = simulator.SimpleEstimate(qasmStr.c_str(), obsStr.c_str(), configStr.c_str());
                        if (res)
                        {
                            result = res;
                            simulator.FreeResult(res);
                        }
                    }
                    else
                    {
                        std::cerr << "Empty .obs file" << std::endl;
                    }
                }
                else
                {
                    std::cerr << "Couldn't read the .obs file: " << obsFileName << std::endl;
                }
            }
            else
            {
                char *res = simulator.SimpleExecute(qasmStr.c_str(), configStr.c_str());
                if (res)
                {
                    result = res;
                    simulator.FreeResult(res);
                }
            }
        }
 
        // depending on params, write it on stdout or in a file
 
        if (vars.count("output"))
        {
            const std::string fileName = vars["output"].as<std::string>();
            if (!fileName.empty())
            {
                std::ofstream outFile(fileName);
                outFile << result;
            }
        }
        else
            std::cout << result << std::endl;
    }
    catch (std::exception &e)
    {
        std::cerr << "ERROR: " << e.what() << std::endl;
        return 7;
    }
    catch (...)
    {
        std::cerr << "Exception of unknown type!" << std::endl;
        return 8;
    }
 
    return 0;
}