Program Listing for File IntermittentIntrospectiveStateExchangeService.hpp

↰ Return to documentation for file (include/dish2/services/IntermittentIntrospectiveStateExchangeService.hpp)

#pragma once
#ifndef DISH2_SERVICES_INTERMITTENTINTROSPECTIVESTATEEXCHANGESERVICE_HPP_INCLUDE
#define DISH2_SERVICES_INTERMITTENTINTROSPECTIVESTATEEXCHANGESERVICE_HPP_INCLUDE

#include <algorithm>
#include <numeric>
#include <utility>

#include "../../../third-party/conduit/include/uitsl/datastructs/RingBuffer.hpp"
#include "../../../third-party/conduit/include/uitsl/debug/WarnOnce.hpp"
#include "../../../third-party/conduit/include/uitsl/math/shift_mod.hpp"
#include "../../../third-party/Empirical/include/emp/base/vector.hpp"
#include "../../../third-party/Empirical/include/emp/math/random_utils.hpp"
#include "../../../third-party/signalgp-lite/include/sgpl/algorithm/execute_cpu.hpp"
#include "../../../third-party/signalgp-lite/include/sgpl/utility/ThreadLocalRandom.hpp"

#include "../cell/cardinal_iterators/IntrospectiveStateWrapper.hpp"
#include "../config/cfg.hpp"
#include "../debug/LogScope.hpp"

namespace dish2 {

template<typename Spec>
struct IntermittentIntrospectiveStateExchangeService {

  inline static thread_local emp::vector<
    dish2::IntrospectiveState<Spec>
  > stash{};

  static bool ShouldRun( const size_t update, const bool alive ) {
    const size_t freq
      = dish2::cfg.INTERMITTENT_STATE_PERTURB_SERVICES_FREQUENCY();
    return
      alive
      && freq > 0
      && uitsl::shift_mod( update, freq ) == 0;
  }

  template<typename Cell>
  static void DoService( Cell& cell ) {

    const dish2::LogScope guard{
      "intermittent introspective state exchange service", "TODO", 3
    };

    using spec_t = typename Cell::spec_t;

    using introspective_state_t = dish2::IntrospectiveState<spec_t>;

    constexpr size_t exchange_chain_length
      = spec_t::STATE_EXCHANGE_CHAIN_LENGTH;
    using exchange_buffer_t
      = uitsl::RingBuffer<introspective_state_t, exchange_chain_length>;

    emp_assert( stash.empty() );

    const auto& perturbation_config = cell.genome->GetRootPerturbationConfig();
    const auto& target_idx = perturbation_config.introspective_state_target_idx;

    if ( perturbation_config.ShouldExchangeIntrospectiveState() ) std::for_each(
      cell.template begin<dish2::IntrospectiveStateWrapper<spec_t>>(),
      cell.template end<dish2::IntrospectiveStateWrapper<spec_t>>(),
      [&]( auto& introspective_state ){
        thread_local exchange_buffer_t fifo;

        // stash state to be reverted in restore service
        stash.push_back( introspective_state );

        // fill fifo up and then start exchanging
        if ( !fifo.IsFull() ) fifo.PushHead( introspective_state );
        else {

          const auto incoming = fifo.GetTail();
          fifo.PopTail();
          fifo.PushHead( introspective_state );

          if ( target_idx.has_value() ) {
            introspective_state.Assign( *target_idx, incoming );
          } else introspective_state = incoming;

        }

      }
    );

  }

};

} // namespace dish2

#endif // #ifndef DISH2_SERVICES_INTERMITTENTINTROSPECTIVESTATEEXCHANGESERVICE_HPP_INCLUDE