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/types/memory.hh>
 
namespace wasmtime {
 
enum class Strategy {
  Auto = WASMTIME_STRATEGY_AUTO,
  Cranelift = WASMTIME_STRATEGY_CRANELIFT,
};
 
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,
};
 
#ifdef WASMTIME_FEATURE_POOLING_ALLOCATOR
class PoolAllocationConfig {
  friend class Config;
 
  struct deleter {
    void operator()(wasmtime_pooling_allocation_config_t *p) const {
      wasmtime_pooling_allocation_config_delete(p);
    }
  };
 
  std::unique_ptr<wasmtime_pooling_allocation_config_t, deleter> ptr;
 
public:
  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 {
  friend class Engine;
 
  struct deleter {
    void operator()(wasm_config_t *p) const { wasm_config_delete(p); }
  };
 
  std::unique_ptr<wasm_config_t, deleter> ptr;
 
public:
  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 wasm_tail_call(bool enable) {
    wasmtime_config_wasm_tail_call_set(ptr.get(), enable);
  }
 
  void wasm_reference_types(bool enable) {
    wasmtime_config_wasm_reference_types_set(ptr.get(), enable);
  }
 
  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_gc(bool enable) {
    wasmtime_config_wasm_gc_set(ptr.get(), enable);
  }
 
  void wasm_function_references(bool enable) {
    wasmtime_config_wasm_function_references_set(ptr.get(), enable);
  }
 
  void wasm_wide_arithmetic(bool enable) {
    wasmtime_config_wasm_wide_arithmetic_set(ptr.get(), enable);
  }
 
#ifdef WASMTIME_FEATURE_COMPONENT_MODEL
  void wasm_component_model(bool enable) {
    wasmtime_config_wasm_component_model_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());
  }
#endif // WASMTIME_FEATURE_COMPILER
 
  void profiler(ProfilingStrategy profiler) {
    wasmtime_config_profiler_set(
        ptr.get(), static_cast<wasmtime_profiling_strategy_t>(profiler));
  }
 
  void memory_reservation(size_t size) {
    wasmtime_config_memory_reservation_set(ptr.get(), size);
  }
 
  void memory_reservation_for_growth(size_t size) {
    wasmtime_config_memory_reservation_for_growth_set(ptr.get(), size);
  }
 
  void memory_guard_size(size_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);
  }
 
#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().release();
    return nullptr;
  }
 
  template <typename T>
  static wasmtime_error_t *raw_new_memory(
    void *env, const wasm_memorytype_t *ty, size_t minimum, size_t maximum,
    size_t reserved_size_in_bytes, size_t guard_size_in_bytes,
    wasmtime_linear_memory_t *memory_ret)
  {
    using Memory = typename T::Memory;
    T *creator = reinterpret_cast<T *>(env);
    Result<Memory> result = creator->new_memory(
        MemoryType::Ref(ty),
        minimum,
        maximum,
        reserved_size_in_bytes,
        guard_size_in_bytes);
    if (!result) {
      return result.err().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.ptr.get());
  }
#endif // WASMTIME_FEATURE_POOLING_ALLOCATOR
};
 
} // namespace wasmtime
 
#endif // WASMTIME_CONFIG_HH