config.hh

Go to the documentation of this file.

 
#ifndef WASMTIME_CONFIG_HH
#define WASMTIME_CONFIG_HH
 
#include <wasmtime/conf.h>
#include <wasmtime/config.h>
#include <wasmtime/error.hh>
#include <wasmtime/helpers.hh>
#include <wasmtime/types/memory.hh>
 
namespace wasmtime {
 
enum class Strategy {
  Auto = WASMTIME_STRATEGY_AUTO,
  Cranelift = WASMTIME_STRATEGY_CRANELIFT,
  Winch = WASMTIME_STRATEGY_WINCH,
};
 
enum class OptLevel {
  None = WASMTIME_OPT_LEVEL_NONE,
  Speed = WASMTIME_OPT_LEVEL_SPEED,
  SpeedAndSize = WASMTIME_OPT_LEVEL_SPEED_AND_SIZE,
};
 
enum class ProfilingStrategy {
  None = WASMTIME_PROFILING_STRATEGY_NONE,
  Jitdump = WASMTIME_PROFILING_STRATEGY_JITDUMP,
  Vtune = WASMTIME_PROFILING_STRATEGY_VTUNE,
  Perfmap = WASMTIME_PROFILING_STRATEGY_PERFMAP,
};
 
enum RegallocAlgorithm {
  Backtracking = WASMTIME_REGALLOC_BACKTRACKING,
  SinglePass = WASMTIME_REGALLOC_SINGLE_PASS,
};
 
enum class MemoryKind {
  LinearMemory = WASMTIME_MEMORY_KIND_LINEAR_MEMORY,
  GcHeap = WASMTIME_MEMORY_KIND_GC_HEAP,
};
 
class MemoryRequest {
  const wasmtime_memory_request_t *req;
 
public:
  explicit MemoryRequest(const wasmtime_memory_request_t *req) : req(req) {}
  MemoryType::Ref ty() const { return MemoryType::Ref(req->ty); }
  size_t minimum() const { return req->minimum; }
  size_t maximum() const { return req->maximum; }
  size_t reserved_size_in_bytes() const { return req->reserved_size_in_bytes; }
  size_t guard_size_in_bytes() const { return req->guard_size_in_bytes; }
  MemoryKind kind() const { return static_cast<MemoryKind>(req->kind); }
};
 
#ifdef WASMTIME_FEATURE_POOLING_ALLOCATOR
class PoolAllocationConfig {
  WASMTIME_OWN_WRAPPER(PoolAllocationConfig,
                       wasmtime_pooling_allocation_config);
 
  PoolAllocationConfig() : ptr(wasmtime_pooling_allocation_config_new()) {}
 
  void max_unused_warm_slots(uint32_t max) {
    wasmtime_pooling_allocation_config_max_unused_warm_slots_set(ptr.get(),
                                                                 max);
  }
 
  void decommit_batch_size(size_t batch_size) {
    wasmtime_pooling_allocation_config_decommit_batch_size_set(ptr.get(),
                                                               batch_size);
  }
 
#ifdef WASMTIME_FEATURE_ASYNC
  void async_stack_keep_resident(size_t size) {
    wasmtime_pooling_allocation_config_async_stack_keep_resident_set(ptr.get(),
                                                                     size);
  }
#endif // WASMTIME_FEATURE_ASYNC
 
  void linear_memory_keep_resident(size_t size) {
    wasmtime_pooling_allocation_config_linear_memory_keep_resident_set(
        ptr.get(), size);
  }
 
  void table_keep_resident(size_t size) {
    wasmtime_pooling_allocation_config_table_keep_resident_set(ptr.get(), size);
  }
 
  void total_component_instances(uint32_t count) {
    wasmtime_pooling_allocation_config_total_component_instances_set(ptr.get(),
                                                                     count);
  }
 
  void max_component_instance_size(size_t size) {
    wasmtime_pooling_allocation_config_max_component_instance_size_set(
        ptr.get(), size);
  }
 
  void max_core_instances_per_component(uint32_t count) {
    wasmtime_pooling_allocation_config_max_core_instances_per_component_set(
        ptr.get(), count);
  }
 
  void max_memories_per_component(uint32_t count) {
    wasmtime_pooling_allocation_config_max_memories_per_component_set(ptr.get(),
                                                                      count);
  }
 
  void max_tables_per_component(uint32_t count) {
    wasmtime_pooling_allocation_config_max_tables_per_component_set(ptr.get(),
                                                                    count);
  }
 
  void total_memories(uint32_t count) {
    wasmtime_pooling_allocation_config_total_memories_set(ptr.get(), count);
  }
 
  void total_tables(uint32_t count) {
    wasmtime_pooling_allocation_config_total_tables_set(ptr.get(), count);
  }
 
#ifdef WASMTIME_FEATURE_ASYNC
  void total_stacks(uint32_t count) {
    wasmtime_pooling_allocation_config_total_stacks_set(ptr.get(), count);
  }
#endif // WASMTIME_FEATURE_ASYNC
 
  void total_core_instances(uint32_t count) {
    wasmtime_pooling_allocation_config_total_core_instances_set(ptr.get(),
                                                                count);
  }
 
  void max_core_instance_size(size_t size) {
    wasmtime_pooling_allocation_config_max_core_instance_size_set(ptr.get(),
                                                                  size);
  }
 
  void max_tables_per_module(uint32_t tables) {
    wasmtime_pooling_allocation_config_max_tables_per_module_set(ptr.get(),
                                                                 tables);
  }
 
  void table_elements(size_t elements) {
    wasmtime_pooling_allocation_config_table_elements_set(ptr.get(), elements);
  }
 
  void max_memories_per_module(uint32_t memories) {
    wasmtime_pooling_allocation_config_max_memories_per_module_set(ptr.get(),
                                                                   memories);
  }
 
  void max_memory_size(size_t bytes) {
    wasmtime_pooling_allocation_config_max_memory_size_set(ptr.get(), bytes);
  }
 
  void total_gc_heaps(uint32_t count) {
    wasmtime_pooling_allocation_config_total_gc_heaps_set(ptr.get(), count);
  }
};
#endif // WASMTIME_FEATURE_POOLING_ALLOCATOR
 
class Config {
  WASMTIME_OWN_WRAPPER(Config, wasm_config);
 
  Config() : ptr(wasm_config_new()) {}
 
  void debug_info(bool enable) {
    wasmtime_config_debug_info_set(ptr.get(), enable);
  }
 
  void epoch_interruption(bool enable) {
    wasmtime_config_epoch_interruption_set(ptr.get(), enable);
  }
 
  void consume_fuel(bool enable) {
    wasmtime_config_consume_fuel_set(ptr.get(), enable);
  }
 
  void max_wasm_stack(size_t stack) {
    wasmtime_config_max_wasm_stack_set(ptr.get(), stack);
  }
 
#ifdef WASMTIME_FEATURE_THREADS
  void wasm_threads(bool enable) {
    wasmtime_config_wasm_threads_set(ptr.get(), enable);
  }
#endif // WASMTIME_FEATURE_THREADS
 
  void shared_memory(bool enable) {
    wasmtime_config_shared_memory_set(ptr.get(), enable);
  }
 
  void wasm_tail_call(bool enable) {
    wasmtime_config_wasm_tail_call_set(ptr.get(), enable);
  }
 
#ifdef WASMTIME_FEATURE_GC
  void wasm_reference_types(bool enable) {
    wasmtime_config_wasm_reference_types_set(ptr.get(), enable);
  }
#endif // WASMTIME_FEATURE_GC
 
  void wasm_simd(bool enable) {
    wasmtime_config_wasm_simd_set(ptr.get(), enable);
  }
 
  void wasm_relaxed_simd(bool enable) {
    wasmtime_config_wasm_relaxed_simd_set(ptr.get(), enable);
  }
 
  void wasm_relaxed_simd_deterministic(bool enable) {
    wasmtime_config_wasm_relaxed_simd_deterministic_set(ptr.get(), enable);
  }
 
  void wasm_bulk_memory(bool enable) {
    wasmtime_config_wasm_bulk_memory_set(ptr.get(), enable);
  }
 
  void wasm_multi_value(bool enable) {
    wasmtime_config_wasm_multi_value_set(ptr.get(), enable);
  }
 
  void wasm_multi_memory(bool enable) {
    wasmtime_config_wasm_multi_memory_set(ptr.get(), enable);
  }
 
  void wasm_memory64(bool enable) {
    wasmtime_config_wasm_memory64_set(ptr.get(), enable);
  }
 
  void wasm_stack_switching(bool enable) {
    wasmtime_config_wasm_stack_switching_set(ptr.get(), enable);
  }
 
#ifdef WASMTIME_FEATURE_GC
  void wasm_gc(bool enable) { wasmtime_config_wasm_gc_set(ptr.get(), enable); }
#endif // WASMTIME_FEATURE_GC
 
#ifdef WASMTIME_FEATURE_GC
  void wasm_function_references(bool enable) {
    wasmtime_config_wasm_function_references_set(ptr.get(), enable);
  }
#endif // WASMTIME_FEATURE_GC
 
  void wasm_wide_arithmetic(bool enable) {
    wasmtime_config_wasm_wide_arithmetic_set(ptr.get(), enable);
  }
 
#ifdef WASMTIME_FEATURE_GC
  void wasm_exceptions(bool enable) {
    wasmtime_config_wasm_exceptions_set(ptr.get(), enable);
  }
#endif // WASMTIME_FEATURE_GC
 
  void wasm_custom_page_sizes(bool enable) {
    wasmtime_config_wasm_custom_page_sizes_set(ptr.get(), enable);
  }
 
  void wasm_compact_imports(bool enable) {
    wasmtime_config_wasm_compact_imports_set(ptr.get(), enable);
  }
 
#ifdef WASMTIME_FEATURE_COMPONENT_MODEL
  void wasm_component_model(bool enable) {
    wasmtime_config_wasm_component_model_set(ptr.get(), enable);
  }
 
  void wasm_component_model_map(bool enable) {
    wasmtime_config_wasm_component_model_map_set(ptr.get(), enable);
  }
 
  void wasm_component_model_implements(bool enable) {
    wasmtime_config_wasm_component_model_implements_set(ptr.get(), enable);
  }
#endif // WASMTIME_FEATURE_COMPONENT_MODEL
 
#ifdef WASMTIME_FEATURE_PARALLEL_COMPILATION
  void parallel_compilation(bool enable) {
    wasmtime_config_parallel_compilation_set(ptr.get(), enable);
  }
#endif // WASMTIME_FEATURE_PARALLEL_COMPILATION
 
#ifdef WASMTIME_FEATURE_COMPILER
  void strategy(Strategy strategy) {
    wasmtime_config_strategy_set(ptr.get(),
                                 static_cast<wasmtime_strategy_t>(strategy));
  }
 
  void cranelift_debug_verifier(bool enable) {
    wasmtime_config_cranelift_debug_verifier_set(ptr.get(), enable);
  }
 
  void cranelift_nan_canonicalization(bool enable) {
    wasmtime_config_cranelift_nan_canonicalization_set(ptr.get(), enable);
  }
 
  void cranelift_opt_level(OptLevel level) {
    wasmtime_config_cranelift_opt_level_set(
        ptr.get(), static_cast<wasmtime_opt_level_t>(level));
  }
 
  void cranelift_flag_enable(const std::string &flag) {
    wasmtime_config_cranelift_flag_enable(ptr.get(), flag.c_str());
  }
 
  void cranelift_flag_set(const std::string &flag, const std::string &value) {
    wasmtime_config_cranelift_flag_set(ptr.get(), flag.c_str(), value.c_str());
  }
 
  void cranelift_regalloc_algorithm(RegallocAlgorithm algo) {
    wasmtime_config_cranelift_regalloc_algorithm_set(
        ptr.get(), static_cast<wasmtime_regalloc_algorithm_t>(algo));
  }
#endif // WASMTIME_FEATURE_COMPILER
 
  void profiler(ProfilingStrategy profiler) {
    wasmtime_config_profiler_set(
        ptr.get(), static_cast<wasmtime_profiling_strategy_t>(profiler));
  }
 
  void memory_reservation(uint64_t size) {
    wasmtime_config_memory_reservation_set(ptr.get(), size);
  }
 
  void memory_reservation_for_growth(uint64_t size) {
    wasmtime_config_memory_reservation_for_growth_set(ptr.get(), size);
  }
 
  void memory_guard_size(uint64_t size) {
    wasmtime_config_memory_guard_size_set(ptr.get(), size);
  }
 
  void memory_may_move(bool enable) {
    wasmtime_config_memory_may_move_set(ptr.get(), enable);
  }
 
  void memory_init_cow(bool enable) {
    wasmtime_config_memory_init_cow_set(ptr.get(), enable);
  }
 
  void native_unwind_info(bool enable) {
    wasmtime_config_native_unwind_info_set(ptr.get(), enable);
  }
 
  void macos_use_mach_ports(bool enable) {
    wasmtime_config_macos_use_mach_ports_set(ptr.get(), enable);
  }
 
  void signals_based_traps(bool enable) {
    wasmtime_config_signals_based_traps_set(ptr.get(), enable);
  }
 
#ifdef WASMTIME_FEATURE_CACHE
  Result<std::monostate> cache_load_default() {
    auto *error = wasmtime_config_cache_config_load(ptr.get(), nullptr);
    if (error != nullptr) {
      return Error(error);
    }
    return std::monostate();
  }
 
  Result<std::monostate> cache_load(const std::string &path) {
    auto *error = wasmtime_config_cache_config_load(ptr.get(), path.c_str());
    if (error != nullptr) {
      return Error(error);
    }
    return std::monostate();
  }
#endif // WASMTIME_FEATURE_CACHE
 
private:
  template <typename T> static void raw_finalize(void *env) {
    std::unique_ptr<T> ptr(reinterpret_cast<T *>(env));
  }
 
  template <typename M>
  static uint8_t *raw_get_memory(void *env, size_t *byte_size,
                                 size_t *byte_capacity) {
    M *memory = reinterpret_cast<M *>(env);
    return memory->get_memory(byte_size, byte_capacity);
  }
 
  template <typename M>
  static wasmtime_error_t *raw_grow_memory(void *env, size_t new_size) {
    M *memory = reinterpret_cast<M *>(env);
    Result<std::monostate> result = memory->grow_memory(new_size);
    if (!result)
      return result.err().capi_release();
    return nullptr;
  }
 
  template <typename T>
  static wasmtime_error_t *
  raw_new_memory(void *env, const wasmtime_memory_request_t *request,
                 wasmtime_linear_memory_t *memory_ret) {
    using Memory = typename T::Memory;
    T *creator = reinterpret_cast<T *>(env);
    Result<Memory> result = creator->new_memory(MemoryRequest(request));
    if (!result) {
      return result.err().capi_release();
    }
    Memory memory = result.unwrap();
    memory_ret->env = std::make_unique<Memory>(memory).release();
    memory_ret->finalizer = raw_finalize<Memory>;
    memory_ret->get_memory = raw_get_memory<Memory>;
    memory_ret->grow_memory = raw_grow_memory<Memory>;
    return nullptr;
  }
 
public:
  template <typename T> void host_memory_creator(T creator) {
    wasmtime_memory_creator_t config = {0};
    config.env = std::make_unique<T>(creator).release();
    config.finalizer = raw_finalize<T>;
    config.new_memory = raw_new_memory<T>;
    wasmtime_config_host_memory_creator_set(ptr.get(), &config);
  }
 
#ifdef WASMTIME_FEATURE_POOLING_ALLOCATOR
  void pooling_allocation_strategy(const PoolAllocationConfig &config) {
    wasmtime_pooling_allocation_strategy_set(ptr.get(), config.capi());
  }
#endif // WASMTIME_FEATURE_POOLING_ALLOCATOR
 
#ifdef WASMTIME_FEATURE_COMPONENT_MODEL
  void concurrency_support(bool enable) {
    wasmtime_config_concurrency_support_set(ptr.get(), enable);
  }
#endif // WASMTIME_FEATURE_COMPONENT_MODEL
 
#ifdef WASMTIME_FEATURE_COMPONENT_MODEL_ASYNC
  void wasm_component_model_async(bool enable) {
    wasmtime_config_wasm_component_model_async_set(ptr.get(), enable);
  }
 
  void wasm_component_model_more_async_builtins(bool enable) {
    wasmtime_config_wasm_component_model_more_async_builtins_set(ptr.get(),
                                                                 enable);
  }
 
  void wasm_component_model_async_stackful(bool enable) {
    wasmtime_config_wasm_component_model_async_stackful_set(ptr.get(), enable);
  }
#endif // WASMTIME_FEATURE_COMPONENT_MODEL_ASYNC
};
 
} // namespace wasmtime
 
#endif // WASMTIME_CONFIG_HH