in_place_exec_ctxt.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// Copyright (C) 2021 CERN & University of Surrey for the benefit of the
// BioDynaMo collaboration. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
//
// See the LICENSE file distributed with this work for details.
// See the NOTICE file distributed with this work for additional information
// regarding copyright ownership.
//
// -----------------------------------------------------------------------------
 
#ifndef CORE_EXECUTION_CONTEXT_IN_PLACE_EXEC_CTXT_H_
#define CORE_EXECUTION_CONTEXT_IN_PLACE_EXEC_CTXT_H_
 
#include <atomic>
#include <functional>
#include <memory>
#include <utility>
#include <vector>
 
#include "core/agent/agent_handle.h"
#include "core/agent/agent_pointer.h"
#include "core/agent/agent_uid.h"
#include "core/container/agent_uid_map.h"
#include "core/container/math_array.h"
#include "core/execution_context/execution_context.h"
#include "core/functor.h"
#include "core/operation/operation.h"
#include "core/util/spinlock.h"
#include "core/util/thread_info.h"
 
namespace bdm {
 
namespace in_place_exec_ctxt_detail {
class InPlaceExecutionContext_NeighborCacheValidity_Test;
}
 
class InPlaceExecutionContext : public ExecutionContext {
 public:
  struct ThreadSafeAgentUidMap {
    using value_type = Agent*;
    using Batch = std::vector<value_type>;
    ThreadSafeAgentUidMap();
    ~ThreadSafeAgentUidMap();
 
    void Insert(const AgentUid& uid, const value_type& value);
    const value_type& operator[](const AgentUid& key) const;
    uint64_t Size() const;
    void Resize(uint64_t new_size);
    void DeleteOldCopies();
 
    Spinlock lock_;
    constexpr static uint64_t kBatchSize = 10240;
    uint64_t num_batches_ = 0;
    std::atomic<Batch**> batches_;
    std::vector<Batch**> old_copies_;
  };
 
  explicit InPlaceExecutionContext(
      const std::shared_ptr<ThreadSafeAgentUidMap>& map);
 
  ~InPlaceExecutionContext() override;
 
  void SetupIterationAll(
      const std::vector<ExecutionContext*>& all_exec_ctxts) override;
 
  void TearDownIterationAll(
      const std::vector<ExecutionContext*>& all_exec_ctxts) override;
 
  void SetupAgentOpsAll(
      const std::vector<ExecutionContext*>& all_exec_ctxts) override;
 
  void TearDownAgentOpsAll(
      const std::vector<ExecutionContext*>& all_exec_ctxts) override;
 
  void Execute(Agent* agent, AgentHandle ah,
               const std::vector<Operation*>& operations) override;
 
  void ForEachNeighbor(Functor<void, Agent*>& lambda, const Agent& query,
                       void* criteria) override;
 
  void ForEachNeighbor(Functor<void, Agent*, real_t>& lambda,
                       const Agent& query, real_t squared_radius) override;
 
  void ForEachNeighbor(Functor<void, Agent*, real_t>& lambda,
                       const Real3& query_position,
                       real_t squared_radius) override;
 
  void AddAgent(Agent* new_agent) override;
 
  void RemoveAgent(const AgentUid& uid) override;
 
  Agent* GetAgent(const AgentUid& uid) override;
 
  const Agent* GetConstAgent(const AgentUid& uid) override;
 
 protected:
  friend class Environment;
  friend class in_place_exec_ctxt_detail::
      InPlaceExecutionContext_NeighborCacheValidity_Test;
  std::shared_ptr<ThreadSafeAgentUidMap> new_agent_map_;
 
  ThreadInfo* tinfo_;
 
  std::vector<Agent*> new_agents_;
 
  std::vector<AgentUid> remove_;
 
  std::atomic_flag mutex_ = ATOMIC_FLAG_INIT;
 
  std::vector<std::pair<Agent*, real_t>> neighbor_cache_;
  real_t cached_squared_search_radius_ = 0.0;
  bool cache_neighbors_ = false;
 
  bool IsNeighborCacheValid(real_t query_squared_radius) const;
 
  virtual void AddAgentsToRm(
      const std::vector<ExecutionContext*>& all_exec_ctxts);
 
  virtual void RemoveAgentsFromRm(
      const std::vector<ExecutionContext*>& all_exec_ctxts);
 
 private:
  std::vector<AgentPointer<>> critical_region_;
  std::vector<AgentPointer<>> critical_region_2_;
 
  std::vector<Spinlock*> locks_;
};
 
}  // namespace bdm
 
#endif  // CORE_EXECUTION_CONTEXT_IN_PLACE_EXEC_CTXT_H_