Simulators/Core/Configuration.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _SIMULATOR_CONFIGURATION_H_
#define _SIMULATOR_CONFIGURATION_H_
 
#include <stdexcept>
#include <string>
#include <unordered_map>
 
#include "../Interfaces/State.h"
#include "../TensorNetworks/RoutingConfig.h"
#include <charconv>
#include <stdexcept>
 
namespace Simulators
{
 
class Configuration
{
  public:
    Configuration() = default;

    virtual ~Configuration() = default;

    Configuration(const Configuration &) = default;

    Configuration(Configuration &&) = default;

    Configuration &operator=(const Configuration &) = default;

    Configuration &operator=(Configuration &&) = default;

    static int ParseGpuDevice(const std::string &value)
    {
        int device = -1;
        const auto result = std::from_chars(value.data(), value.data() + value.size(), device);
        if (result.ec != std::errc() || result.ptr != value.data() + value.size() || device < 0)
            throw std::invalid_argument("gpu_device must be a nonnegative integer");
        return device;
    }
 
    // Keep mutually exclusive GPU SVD flags consistent before they are replayed
    // from an unordered map into a new simulator (including network clones/jobs).
    static std::string GpuSvdSettingGroup(const std::string &key)
    {
        for (const char *group : {"matrix_product_state_use_gesvd", "matrix_product_operator_use_gesvd", "tensor_network_use_gesvd"})
        {
            const size_t length = std::char_traits<char>::length(group);
            if (key == group)
                return group;
            if (key.size() == length + 1 && key.compare(0, length, group) == 0 && (key.back() == 'j' || key.back() == 'p' || key.back() == 'r'))
                return group;
        }
        return {};
    }
 
    static bool ParseGpuSvdFlag(const std::string &value)
    {
        if (value == "true" || value == "1")
            return true;
        if (value == "false" || value == "0")
            return false;
        throw std::invalid_argument("GPU SVD flags must be true, false, 1 or 0");
    }
 
    static bool ParsePrecision(const std::string &key, const std::string &value)
    {
        if (key == "precision")
        {
            if (value == "double")
                return true;
            if (value == "single")
                return false;
            throw std::invalid_argument("precision must be single or double");
        }
        if (value == "true" || value == "1")
            return true;
        if (value == "false" || value == "0")
            return false;
        throw std::invalid_argument("use_double_precision must be true, false, 1 or 0");
    }
 
    void SetConfiguration(const std::string &key, const std::string &value)
    {
        if (key == RoutingConfig::kStrategy)
            RoutingConfig::ParseStrategy(value);
        else if (key == RoutingConfig::kVirtualBonds || key == RoutingConfig::kLegacyCap)
            RoutingConfig::ParseFlag(value);
        else if (key == RoutingConfig::kTruncationWeight)
            RoutingConfig::ParseWeight(value);
        if (key == "precision" || key == "use_double_precision")
        {
            const bool useDouble = ParsePrecision(key, value);
            configMap["precision"] = useDouble ? "double" : "single";
            configMap["use_double_precision"] = useDouble ? "1" : "0";
            return;
        }
        if (key == "gpu_device")
            ParseGpuDevice(value);
        const auto svdGroup = GpuSvdSettingGroup(key);
        if (!svdGroup.empty())
        {
            const bool enabled = ParseGpuSvdFlag(value);
            configMap[key] = enabled ? "true" : "false";
            if (enabled)
            {
                for (const char *algorithm : {"", "j", "p", "r"})
                {
                    const auto otherKey = svdGroup + algorithm;
                    const auto other = configMap.find(otherKey);
                    // Do not introduce unused optional settings on older plugins, or
                    // invalidate iterators while an existing map is being replayed.
                    if (otherKey != key && other != configMap.end())
                        other->second = "false";
                }
            }
            return;
        }
        if ((key == "matrix_product_state_truncation_mode" || key == "matrix_product_operator_truncation_mode") && value != "relative_max" &&
            value != "discarded_weight")
            throw std::invalid_argument("Invalid truncation mode: expected relative_max or "
                                        "discarded_weight");
 
        // specially handled, ignore it
        if (IgnoredSetting(key))
            return;
        configMap[key] = value;
    }
 
    void SetConfiguration(const std::string &key, long long int value)
    {
        // specially handled, ignore it
        if (IgnoredSetting(key))
            return;
        SetConfiguration(key, std::to_string(value));
    }
 
    void SetConfiguration(const std::string &key, double value)
    {
        // specially handled, ignore it
        if (IgnoredSetting(key))
            return;
        SetConfiguration(key, std::to_string(value));
    }

    bool IsSet(const std::string &key) const
    {
        return configMap.find(key) != configMap.end();
    }

    std::string GetConfiguration(const std::string &key) const
    {
        auto it = configMap.find(key);
        if (it != configMap.end())
        {
            return it->second;
        }
        return "";
    }
 
    long long int GetConfigurationAsInt(const std::string &key) const
    {
        auto it = configMap.find(key);
        if (it != configMap.end())
        {
            return std::stoll(it->second);
        }
        return 0;
    }
 
    // For size_t-valued settings: the signed and double getters cannot represent
    // the whole range, and a value near SIZE_MAX misconverts through double.
    unsigned long long int GetConfigurationAsUnsigned(const std::string &key) const
    {
        auto it = configMap.find(key);
        if (it != configMap.end())
        {
            return std::stoull(it->second);
        }
        return 0;
    }
 
    double GetConfigurationAsDouble(const std::string &key) const
    {
        auto it = configMap.find(key);
        if (it != configMap.end())
        {
            return std::stod(it->second);
        }
        return 0.0;
    }
 
    static bool CanBeAppliedOnInitializedSimulator(const std::string &key)
    {
        if (key == "gpu_device" || key == "method" || key == "use_double_precision" || key == "precision" || key == "max_parallel_threads" ||
            key == "parallel_state_update" || key == "statevector_parallel_threshold")
            return false;
 
        return true;
    }
 
    static bool IgnoredSetting(const std::string &key)
    {
        if (key == "max_simulators" || key == "method")
            return true;
 
        return false;
    }
 
    void ApplyConfigurationToSimulator(const std::shared_ptr<Simulators::IState> &simulator) const
    {
        for (const auto &[key, value] : configMap)
        {
            if (key == "gate_fusion" && simulator->GetType() != SimulatorType::kQCSim && simulator->GetType() != SimulatorType::kCompositeQCSim &&
                !IsGpuSimulator(simulator->GetType()))
                continue;
 
            // Networks retain GPU placement when an optimizer selects a CPU backend.
            // Replay it only to GPU simulators; Aer rejects this plugin-specific key.
            if (key == "gpu_device" && !IsGpuSimulator(simulator->GetType()))
                continue;
 
            // Route the seed through SetSeed, whose contract is to seed EVERY random
            // stream the simulator owns -- including the auxiliary one used for
            // measurement-time readout error. Its default implementation still
            // records the value with Configure, so this subsumes the plain call.
            if (key == "seed")
            {
                try
                {
                    simulator->SetSeed(std::stoull(value));
                    continue;
                }
                catch (const std::exception &)
                {
                    // Not a number: fall through and let the simulator reject it.
                }
            }
 
            simulator->Configure(key.c_str(), value.c_str());
        }
    }
 
    void ApplyConfigurationFromSimulator(const std::shared_ptr<Simulators::IState> &simulator)
    {
        if (!simulator)
            return;
        ApplyConfigurationFromMap(simulator->GetConfigMap());
    }
 
    void ApplyConfigurationFromMap(const std::unordered_map<std::string, std::string> &config)
    {
        for (const auto &[key, value] : config)
            SetConfiguration(key, value);
    }
 
    const std::unordered_map<std::string, std::string> &GetConfigMap() const
    {
        return configMap;
    }
 
    bool WasApplied(const std::string &key, const std::string &value) const
    {
        auto it = configMap.find(key);
        if (it != configMap.end())
            return it->second == value;
 
        return false;
    }
 
  private:
    std::unordered_map<std::string, std::string> configMap; 
};
 
} // namespace Simulators
 
#endif