config.h

Go to the documentation of this file.

#ifndef FREE_TENSOR_CONFIG_H
#define FREE_TENSOR_CONFIG_H
 
#include <filesystem>
#include <vector>
 
#include <container_utils.h>
#include <ref.h>
 
namespace freetensor {
 
class Target;
class Device;
 
class Config {
    static bool prettyPrint_;         
    static bool printAllId_;          
    static bool printSourceLocation_; 
    static bool fastMath_;            
    static bool werror_; 
    static bool
        debugBinary_; 
    static bool debugRuntimeCheck_; 
    static bool
        debugCUDAWithUM_; 
    static std::vector<std::filesystem::path>
        backendCompilerCXX_; 
    static std::vector<std::filesystem::path>
        backendCompilerNVCC_; 
    static std::vector<std::filesystem::path>
        backendOpenMP_; // Env and macro FT_BACKEND_OPENMP. Colon-separated
                        // paths, linked from left to right
 
    static Ref<Target>
        defaultTarget_; 
    static Ref<Device> defaultDevice_; 
    static std::vector<std::filesystem::path>
        runtimeDir_; 
 
  private:
    static std::vector<std::filesystem::path>
    checkValidPaths(const std::vector<std::filesystem::path> &paths,
                    bool required = true);
 
  public:
    static void init(); 
 
    static bool withMKL();
    static bool withCUDA();
    static bool withPyTorch();
 
    static void setPrettyPrint(bool pretty = true) { prettyPrint_ = pretty; }
    static bool prettyPrint() { return prettyPrint_; }
 
    static void setPrintAllId(bool flag = true) { printAllId_ = flag; }
    static bool printAllId() { return printAllId_; }
 
    static void setPrintSourceLocation(bool flag = true) {
        printSourceLocation_ = flag;
    }
    static bool printSourceLocation() { return printSourceLocation_; }
 
    static void setFastMath(bool flag = true) { fastMath_ = flag; }
    static bool fastMath() { return fastMath_; }
 
    static void setWerror(bool flag = true) { werror_ = flag; }
    static bool werror() { return werror_; }
 
    static void setDebugBinary(bool flag = true) { debugBinary_ = flag; }
    static bool debugBinary() { return debugBinary_; }
 
    static void setDebugRuntimeCheck(bool flag = true) {
        debugRuntimeCheck_ = flag;
    }
    static bool debugRuntimeCheck() { return debugRuntimeCheck_; }
 
    static void setDebugCUDAWithUM(bool flag = true) {
        debugCUDAWithUM_ = flag;
    }
    static bool debugCUDAWithUM() { return debugCUDAWithUM_; }
 
    static void
    setBackendCompilerCXX(const std::vector<std::filesystem::path> &paths) {
        backendCompilerCXX_ = checkValidPaths(paths);
    }
    static const std::vector<std::filesystem::path> &backendCompilerCXX() {
        return backendCompilerCXX_;
    }
 
    static void
    setBackendCompilerNVCC(const std::vector<std::filesystem::path> &paths) {
        backendCompilerNVCC_ = checkValidPaths(paths);
    }
    static const std::vector<std::filesystem::path> &backendCompilerNVCC() {
        return backendCompilerNVCC_;
    }
 
    static void
    setBackendOpenMP(const std::vector<std::filesystem::path> &path) {
        backendOpenMP_ = path;
    }
    static const std::vector<std::filesystem::path> &backendOpenMP() {
        return backendOpenMP_;
    }
 
    static void setDefaultTarget(const Ref<Target> &target) {
        defaultTarget_ = target;
    }
    static Ref<Target> defaultTarget() { return defaultTarget_; }
 
    static void setDefaultDevice(const Ref<Device> &dev) {
        defaultDevice_ = dev;
    }
    static Ref<Device> defaultDevice() { return defaultDevice_; }
 
    static void setRuntimeDir(const std::vector<std::filesystem::path> &paths) {
        runtimeDir_ = checkValidPaths(paths);
    }
    static const std::vector<std::filesystem::path> &runtimeDir() {
        return runtimeDir_;
    }
};
 
} // namespace freetensor
 
#endif // FREE_TENSOR_CONFIG_H