lua_state.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <atomic>
#include <cstdint>
#include <functional>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <string_view>
#include <toast/export.hpp>
#include <toast/log.hpp>
#include <toast/thread_pool.hpp>
#include <unordered_map>
#include <vector>
 
struct lua_State;
 
namespace scripting {
 
class TOAST_API LuaState {
  struct Entry;
 
public:
  class TOAST_API Lock {
  public:
    Lock() = default;
    Lock(Lock&& other) noexcept;
    auto operator=(Lock&& other) noexcept -> Lock&;
    Lock(const Lock&) = delete;
    auto operator=(const Lock&) -> Lock& = delete;
    ~Lock();
 
    explicit operator bool() const noexcept { return m_entry != nullptr; }
 
    [[nodiscard]]
    auto state() const noexcept -> lua_State* {
      return m_state;
    }
 
    [[nodiscard]]
    auto index() const noexcept -> size_t {
      return m_index;
    }

    void unlock() noexcept;
 
  private:
    friend class LuaState;
    Lock(Entry* entry, lua_State* state, size_t index) noexcept;
 
    Entry* m_entry = nullptr;
    lua_State* m_state = nullptr;
    size_t m_index = 0;
  };
 
  static auto create() noexcept -> std::unique_ptr<LuaState>;
  static auto get() noexcept -> LuaState&;
 
  [[nodiscard]]
  static auto exists() noexcept -> bool {
    return instance != nullptr;
  }
 
  ~LuaState() noexcept;

  [[nodiscard]]
  auto lock(size_t index) noexcept -> Lock;

  [[nodiscard]]
  auto tryLock(size_t index) noexcept -> Lock;
 
  [[nodiscard]]
  static auto indexOf(lua_State* state) noexcept -> std::optional<size_t>;

  [[nodiscard]]
  static auto ownedByCurrentThread(size_t index) noexcept -> bool;
  [[nodiscard]]
  static auto ownedByCurrentThread(lua_State* state) noexcept -> bool;

  [[nodiscard]]
  static auto ownsAnyState() noexcept -> bool;

  [[nodiscard]]
  static auto lastOwnedIndex() noexcept -> std::optional<size_t>;

  static constexpr uint32_t k_group_chunk = 8;

  [[nodiscard]]
  auto assign(uint64_t group, std::optional<size_t> forced = std::nullopt) -> size_t;

  void unassign(uint64_t group, size_t index) noexcept;

  [[nodiscard]]
  auto loads() const -> std::vector<uint32_t>;

  [[nodiscard]]
  static auto newGroup() noexcept -> uint64_t;
 
  [[nodiscard]]
  auto poolSize() const noexcept -> size_t {
    return m_pool_size;
  }

  [[nodiscard]]
  auto mainState(size_t index) const noexcept -> lua_State*;

  void retire(size_t index, std::move_only_function<void()> destroyer) noexcept;

  static void retireOrLeak(size_t index, std::move_only_function<void()> destroyer) noexcept;

  [[nodiscard]]
  auto contentionCount() const noexcept -> uint64_t {
    return m_contention.load(std::memory_order_relaxed);
  }

  [[nodiscard]]
  auto waitCount() const noexcept -> uint64_t {
    return m_waits.load(std::memory_order_relaxed);
  }

  class TOAST_API NonBlockingScope {
  public:
    NonBlockingScope() noexcept;
    ~NonBlockingScope();
 
    NonBlockingScope(const NonBlockingScope&) = delete;
    auto operator=(const NonBlockingScope&) -> NonBlockingScope& = delete;
    NonBlockingScope(NonBlockingScope&&) = delete;
    auto operator=(NonBlockingScope&&) -> NonBlockingScope& = delete;
  };

  auto runString(std::string_view lua_code) noexcept -> bool;

  auto runStringOn(size_t index, std::string_view lua_code, std::string* error = nullptr) noexcept -> bool;

  void refreshTypeMarkers() noexcept;
 
private:
  static inline LuaState* instance = nullptr;
 
  struct Entry {
    lua_State* state = nullptr;
    std::recursive_mutex mutex;
    std::atomic<uint64_t> owner {0};                         
    int depth = 0;                                           
    std::mutex pending_mutex;
    std::vector<std::move_only_function<void()>> pending;    
    std::atomic<size_t> pending_count {0};
  };
 
  size_t m_pool_size = 0;
  std::vector<Entry> m_entries;
  std::atomic<uint64_t> m_contention {0};
  std::atomic<uint64_t> m_waits {0};

  struct GroupPlacement {
    std::vector<uint32_t> per_index;
    size_t index = 0;
    uint32_t members = 0;
  };
 
  // Guards the placement bookkeeping, which only changes while runtimes are created and destroyed
  mutable std::mutex m_placement_mutex;
  std::vector<uint32_t> m_loads;    
  std::unordered_map<uint64_t, GroupPlacement> m_groups;
  size_t m_next_tie = 0;
 
  LuaState();
 
  auto acquire(size_t index, bool wait) noexcept -> Lock;
  static void release(Entry& entry, size_t index) noexcept;
  static void drainPending(Entry& entry) noexcept;
 
  static void registerApi(lua_State* state) noexcept;
  static void registerTypeMarkers(lua_State* state) noexcept;
};
 
}

#ifdef _DEBUG
#define TOAST_LUA_ASSERT_OWNED(state)                                                                                          \
  TOAST_ASSERT(                                                                                                                \
      ::scripting::LuaState::ownedByCurrentThread(state), "Lua", "A Lua interpreter was used by a thread that does not own it" \
  )
#elif defined(TOAST_LUA_OWNERSHIP_CHECKS)
#define TOAST_LUA_ASSERT_OWNED(state)                                                       \
  do {                                                                                      \
    if (!::scripting::LuaState::ownedByCurrentThread(state)) {                              \
      TOAST_CRITICAL("Lua", "A Lua interpreter was used by a thread that does not own it"); \
    }                                                                                       \
  } while (0)
#else
#define TOAST_LUA_ASSERT_OWNED(state) ((void)(state))
#endif