runner.hpp

Go to the documentation of this file.

#pragma once
 
#include "game.hpp"
#include "inputHistory/inputHistoryFactory.hpp"
#include "inputSet.hpp"
#include <atomic>
#include <cstdint>
#include <gameList.hpp>
#include <jaffarCommon/bitwise.hpp>
#include <jaffarCommon/deserializers/contiguous.hpp>
#include <jaffarCommon/hash.hpp>
#include <jaffarCommon/json.hpp>
#include <jaffarCommon/logger.hpp>
#include <jaffarCommon/serializers/contiguous.hpp>
#include <memory>
#include <unordered_set>
#include <vector>
 
namespace jaffarPlus
{
 
class Runner final
{
public:
  Runner(std::unique_ptr<Game>& game, const nlohmann::json& config) : _game(std::move(game))
  {
    // Mutable copy so unrecognized Runner keys can be flagged after the known ones are consumed
    auto configRemaining = config;
 
    _hashStepTolerance = jaffarCommon::json::popNumber<uint32_t>(configRemaining, "Hash Step Tolerance");
 
    // The input-history strategy (None / Raw / Trie) is selected and validated by the InputHistory
    // factory from this object; stored here and built in initialize() once the input set is known.
    _inputHistoryConfig = jaffarCommon::json::popObject(configRemaining, "Store Input History");
 
    // Storing game inputs for delayed parsing
    _allowedInputSetsJs = jaffarCommon::json::popArray<nlohmann::json>(configRemaining, "Allowed Input Sets");
 
    // Print option: do not print allowed inputs
    _showAllowedInputs = jaffarCommon::json::popBoolean(configRemaining, "Show Allowed Inputs");
 
    // Print option: do not print placeholders for inputs not supported in this frame
    _showEmptyInputSlots = jaffarCommon::json::popBoolean(configRemaining, "Show Empty Input Slots");
 
    // Stores candidate inputs
    _testCandidateInputs = jaffarCommon::json::popBoolean(configRemaining, "Test Candidate Inputs");
 
    // Getting candidate input sets
    _candidateInputSetsJs = jaffarCommon::json::popArray<nlohmann::json>(configRemaining, "Candidate Input Sets");
 
    // Getting frame skip configuration
    auto frameskipJs         = jaffarCommon::json::popObject(configRemaining, "Frameskip");
    _frameskipRate           = jaffarCommon::json::popNumber<size_t>(frameskipJs, "Rate");
    _frameskipUseCustomInput = jaffarCommon::json::popBoolean(frameskipJs, "Use Custom Input");
    _frameskipCustomInput    = jaffarCommon::json::popString(frameskipJs, "Custom Input");
    jaffarCommon::json::checkEmpty(frameskipJs, "Runner Configuration > Frameskip");
 
    // Option to bypass hash calculation via MetroHash and get it straight from the game
    _bypassHashCalculation = jaffarCommon::json::popBoolean(configRemaining, "Bypass Hash Calculation");
 
    // Any remaining Runner key is unrecognized
    jaffarCommon::json::checkEmpty(configRemaining, "Runner Configuration");
  }
 
  void initialize()
  {
    if (_isInitialized == true) JAFFAR_THROW_LOGIC("This runner instance was already initialized");
 
    // Initializing game, if not already initialized
    if (_game->isInitialized() == false) _game->initialize();
 
    // Parsing possible game inputs
    for (const auto& inputSetJs : _allowedInputSetsJs) _allowedInputSets.push_back(parseInputSet(inputSetJs));
 
    // If testing candidate inputs, parse them now
    if (_testCandidateInputs == true)
      for (const auto& inputSetJs : _candidateInputSetsJs) _candidateInputSets.push_back(parseInputSet(inputSetJs));
 
    // Parsing inputs declared directly by the game's code
    for (const auto& input : _game->getAllPossibleInputs()) registerInput(input);
 
    // Resolve the custom frameskip input index once (it is constant), so advanceState() can reuse it
    // instead of re-hashing + re-looking-it-up every skipped frame. Also validates it early -- a bad
    // "Custom Input" now fails here at init rather than crashing deep in the simulation loop.
    if (_frameskipUseCustomInput) _frameskipCustomInputIdx = getInputIndex(_frameskipCustomInput);
 
    // Build the configured input-history strategy now that the input set (hence _maxInputIndex) is known.
    // Worker runners share a backing injected by the engine (setInputHistoryBacking); a standalone runner
    // (player / driver) makes its own private backing here.
    if (_historyBacking == nullptr)
    {
      _historyBacking = inputHistory::createSharedBacking(_inputHistoryConfig, _historyNumShards);
      _historyShardId = 0;
    }
    _inputHistory = inputHistory::create(_inputHistoryConfig, (uint32_t)_maxInputIndex, _historyNumShards, _historyShardId, _historyBacking);
  }
 
  __INLINE__ void setInputHistoryBacking(const std::shared_ptr<void>& backing, const uint32_t shardId, const uint32_t numShards)
  {
    _historyBacking   = backing;
    _historyShardId   = shardId;
    _historyNumShards = numShards;
  }
 
  __INLINE__ const nlohmann::json& getInputHistoryConfig() const { return _inputHistoryConfig; }
 
  __INLINE__ InputHistory* getInputHistory() const { return _inputHistory.get(); }
 
  std::unique_ptr<InputSet> parseInputSet(const nlohmann::json& inputSetJs)
  {
    // Creating new input set to add
    auto inputSet = std::make_unique<InputSet>();
 
    // Getting input set condition array
    const auto& conditions = jaffarCommon::json::getArray<nlohmann::json>(inputSetJs, "Conditions");
 
    // Getting input string array
    const auto& inputsJs = jaffarCommon::json::getArray<std::string>(inputSetJs, "Inputs");
 
    // Parsing input set conditions
    for (const auto& condition : conditions) inputSet->addCondition(_game->parseCondition(condition));
 
    // Parsing input set inputs
    for (const auto& input : inputsJs) inputSet->addInput(registerInput(input));
 
    // Keep track of maximum size (for better output)
    _largestInputSetSize = std::max(_largestInputSetSize, inputSet->getInputIndexes().size());
 
    // Getting stop evaluating flag
    inputSet->setStopInputEvaluationFlag(jaffarCommon::json::getBoolean(inputSetJs, "Stop Input Evaluation"));
 
    // Returning new input set
    return inputSet;
  }
 
  InputSet::inputIndex_t registerInput(const std::string& input)
  {
    // Getting input hash
    const auto inputHash = jaffarCommon::hash::hashString(input);
 
    // Getting index for the new input
    InputSet::inputIndex_t inputIdx = _game->getEmulator()->registerInput(input);
 
    // Adding new input hash->index to the map
    _inputHashMap[inputHash] = inputIdx;
 
    // Adding new input index->string to the map
    _inputStringMap[inputIdx] = input;
 
    // Register maximum input index to determine how many bytes to use for input history storage
    _maxInputIndex = std::max(_maxInputIndex, inputIdx + 1);
 
    // Returning this input's index (either new or the one registered before)
    return inputIdx;
  }
 
  std::vector<InputSet::inputIndex_t> getInputsFromInputSets(const std::vector<std::unique_ptr<InputSet>>& inputSets) const
  {
    // Storage for the possible input set
    std::vector<InputSet::inputIndex_t> possibleInputs;
 
    // For all registered input sets, see which ones satisfy their conditions and add them
    for (const auto& inputSet : inputSets)
      if (inputSet->evaluate() == true)
      {
        possibleInputs.insert(possibleInputs.end(), inputSet->getInputIndexes().begin(), inputSet->getInputIndexes().end());
 
        // Getting stop evaluating flag
        bool stopEvaluating = inputSet->getStopInputEvaluationFlag();
 
        // If stop evaluation is set, then return now
        if (stopEvaluating) break;
      }
 
    // Return possible inputs
    return possibleInputs;
  }
 
  __INLINE__ const auto getAllowedInputs() const
  {
    // Getting possible inputs based on the configuration file
    auto allowedInputs = getInputsFromInputSets(_allowedInputSets);
 
    // Getting additional inputs based on the custom game function
    _game->getAdditionalAllowedInputs(allowedInputs);
 
    return allowedInputs;
  }
 
  __INLINE__ const auto getCandidateInputs() const { return getInputsFromInputSets(_candidateInputSets); }
 
  __INLINE__ jaffarPlus::InputSet::inputIndex_t getInputIndex(const std::string& input) const
  {
    // Getting input hash
    const auto inputHash = jaffarCommon::hash::hashString(input);
 
    // Getting input index from the hash map
    auto it = _inputHashMap.find(inputHash);
    if (it == _inputHashMap.end()) JAFFAR_THROW_LOGIC("[ERROR] Input '%s' provided but has not been registered as allowed input first.\n", input.c_str());
    const auto inputIndex = it->second;
 
    return inputIndex;
  }
 
  bool isInputRegistered(const std::string& inputString)
  {
    // Getting input hash
    const auto inputHash = jaffarCommon::hash::hashString(inputString);
 
    // Returning true if found; false, otherwise
    return _inputHashMap.contains(inputHash);
  }
 
  __INLINE__ void advanceState(const InputSet::inputIndex_t inputIdx)
  {
    // Safety check -- Disabled, for performance
    // if (_inputStringMap.contains(inputIdx) == false) JAFFAR_THROW_RUNTIME("Move Index %u not found in runner\n", inputIdx);
 
    // Performing the requested input
    _game->advanceState(inputIdx);
 
    // Pushing normal input into the history
    pushInput(inputIdx);
 
    // If frameskip was set, execute it now
    for (size_t i = 0; i < _frameskipRate; i++)
    {
      InputSet::inputIndex_t frameskipInputIdx = inputIdx;
      if (_frameskipUseCustomInput) frameskipInputIdx = _frameskipCustomInputIdx;
      _game->advanceState(frameskipInputIdx);
      pushInput(frameskipInputIdx);
    }
  }
 
  __INLINE__ void pushInput(const InputSet::inputIndex_t inputIdx)
  {
    _inputHistory->pushInput(_stepCount, inputIdx);
    _stepCount++;
  }
 
  __INLINE__ void setStepCount(const size_t stepCount) { _stepCount = stepCount; }
 
  __INLINE__ void setSearchStep(const size_t searchStep) { _stepCount = searchStep * (_frameskipRate + 1); }
 
  __INLINE__ size_t getStepCount() const { return _stepCount; }
 
  __INLINE__ void serializeState(jaffarCommon::serializer::Base& serializer) const
  {
    // Game state, then the self-contained ("full") input-history form (used by in-memory, run-scoped
    // snapshots: the player's initial state and the best/worst/win buffers).
    _game->serializeState(serializer);
    _inputHistory->serializeFull(serializer);
  }
 
  __INLINE__ void deserializeState(jaffarCommon::deserializer::Base& deserializer)
  {
    _game->deserializeState(deserializer);
    // The step counter is not part of the stream; the caller sets it (via setStepCount/setSearchStep) before
    // deserializing so strategies that rebuild from the path length (the trie) have it available.
    _inputHistory->deserializeFull(deserializer, _stepCount);
  }
 
  __INLINE__ size_t getStateSize() const
  {
    jaffarCommon::serializer::Contiguous s;
    this->serializeState(s);
    return s.getOutputSize();
  }
 
  // ---- Hot/cold split ------------------------------------------------------------------------------
  // The State DB stores the per-state "path" (the bit-packed input history + step counter) in a
  // parallel "cold" slab instead of the hot state slot it hashes/advances every step. These helpers let
  // it write/measure the two parts separately. serializeState()/getStateSize() above are unchanged and
  // still produce the FULL state for every other caller (player, playback, on-disk checkpoints).
 
  __INLINE__ void serializeHotState(jaffarCommon::serializer::Base& serializer) const { _game->serializeState(serializer); }
  __INLINE__ void deserializeHotState(jaffarCommon::deserializer::Base& deserializer) { _game->deserializeState(deserializer); }
 
  __INLINE__ void serializeHistory(jaffarCommon::serializer::Base& serializer) const { _inputHistory->serializeCold(serializer); }
  __INLINE__ void deserializeHistory(jaffarCommon::deserializer::Base& deserializer) { _inputHistory->deserializeCold(deserializer); }
 
  __INLINE__ size_t getHotStateSize() const
  {
    jaffarCommon::serializer::Contiguous s;
    this->serializeHotState(s);
    return s.getOutputSize();
  }
  __INLINE__ size_t getHistorySize() const { return _inputHistory->getColdSize(); }
 
  __INLINE__ jaffarCommon::hash::hash_t computeHash() const
  {
    // If normal hash calculation is to be bypassed, get it straight from the game
    if (_bypassHashCalculation == true) return _game->getDirectStateHash();
 
    // Storage for hash calculation
    MetroHash128 hashEngine;
 
    // Calculating hash tolerance stage
    auto hashStepToleranceStage = getHashStepToleranceStage();
 
    // Hashing step tolerance stage
    hashEngine.Update(hashStepToleranceStage);
 
    // Processing hashing from the game proper
    _game->computeHash(hashEngine);
 
    jaffarCommon::hash::hash_t result;
    hashEngine.Finalize(reinterpret_cast<uint8_t*>(&result));
    return result;
  }
 
  std::string getInputHistoryString() const { return _inputHistory->toString(_inputStringMap, _stepCount); }
 
  std::string getInputStringFromIndex(const InputSet::inputIndex_t input) { return _inputStringMap[input]; }
 
  void printInfo() const
  {
    // Getting state hash
    const auto hash = jaffarCommon::hash::hashToString(computeHash());
 
    // Calculating hash tolerance stage
    auto hashStepToleranceStage = getHashStepToleranceStage();
 
    // Memory usage
    jaffarCommon::logger::log("[J+]  + Input History Type:                       %s (cold %lu B, full %lu B)\n", inputHistory::getType(_inputHistoryConfig).c_str(),
                              _inputHistory->getColdSize(), _inputHistory->getFullSize());
 
    // Printing runner state
    jaffarCommon::logger::log("[J+]  + Current Input Count:                      %lu\n", _stepCount);
    jaffarCommon::logger::log("[J+]  + Hash:                                     %s\n", hash.c_str());
    jaffarCommon::logger::log("[J+]  + Hash Step Tolerance Stage:                %u / %u\n", hashStepToleranceStage, _hashStepTolerance);
 
    // Printing frameskip information
    if (_frameskipRate > 0) jaffarCommon::logger::log("[J+]  + Frameskip Rate:                           %lu\n", _frameskipRate);
 
    // Check whether we want to print inputs
    if (_showAllowedInputs == true)
    {
      // Getting allowed inputs
      const auto& possibleInputs = getAllowedInputs();
 
      // Printing them
      jaffarCommon::logger::log("[J+]  + Allowed Inputs:\n");
 
      size_t currentInputIdx = 0;
      for (const auto inputIdx : possibleInputs)
      {
        jaffarCommon::logger::log("[J+]    + '%s'\n", _inputStringMap.at(inputIdx).c_str());
        currentInputIdx++;
      }
 
      if (_showEmptyInputSlots)
        for (; currentInputIdx < _largestInputSetSize; currentInputIdx++) jaffarCommon::logger::log("[J+]    + ----- \n");
    }
  }
 
  __INLINE__ uint32_t getHashStepToleranceStage() const { return (uint32_t)_stepCount % (_hashStepTolerance + 1); }
  __INLINE__ Game* getGame() const { return _game.get(); }
 
  static std::unique_ptr<Runner> getRunner(const nlohmann::json& emulatorConfig, const nlohmann::json& gameConfig, const nlohmann::json& runnerConfig)
  {
    // Getting Game
    auto game = Game::getGame(emulatorConfig, gameConfig);
 
    // Creating new runner
    auto r = std::make_unique<Runner>(game, runnerConfig);
 
    // Returning runner
    return r;
  }
 
  __INLINE__ bool isInitialized() const { return _isInitialized; }
 
private:
  bool _isInitialized = false; 
 
  std::unique_ptr<Game> _game; 
 
  uint32_t _hashStepTolerance; 
 
  // --- Input history (strategy-agnostic) -----------------------------------------------------------
  nlohmann::json                _inputHistoryConfig; 
  std::unique_ptr<InputHistory> _inputHistory;       
  size_t _stepCount = 0; 
  std::shared_ptr<void> _historyBacking;       
  uint32_t              _historyShardId   = 0; 
  uint32_t              _historyNumShards = 2; 
 
  bool _bypassHashCalculation; 
 
  // Input processing variables
 
  InputSet::inputIndex_t _maxInputIndex = 0; 
 
  std::map<jaffarCommon::hash::hash_t, InputSet::inputIndex_t> _inputHashMap; 
 
  std::map<InputSet::inputIndex_t, std::string> _inputStringMap; 
 
  //  Frameskip. These are frames that are simply skipped over, but they inputs registered nevertheless
 
  size_t _frameskipRate; 
 
  bool _frameskipUseCustomInput; 
 
  std::string _frameskipCustomInput; 
 
  InputSet::inputIndex_t _frameskipCustomInputIdx{};
 
  // Allowed and candidate input sets
 
  std::vector<nlohmann::json> _allowedInputSetsJs; 
 
  std::vector<nlohmann::json> _candidateInputSetsJs; 
 
  std::vector<std::unique_ptr<InputSet>> _candidateInputSets; 
 
  std::vector<std::unique_ptr<InputSet>> _allowedInputSets; 
 
  size_t _largestInputSetSize = 0; 
 
  bool _testCandidateInputs; 
 
  bool _showEmptyInputSlots; 
 
  bool _showAllowedInputs; 
};
 
} // namespace jaffarPlus