#1899: util: use new memory pool

src/vt/pool/static_sized/memory_pool_equal.cc

@@ -44,6 +44,7 @@
 #include "vt/config.h"
 #include "vt/pool/static_sized/memory_pool_equal.h"
 #include "vt/pool/header/pool_header.h"
+#include "vt/runnable/runnable.h"
 
 #include <vector>
 #include <cstdint>
@@ -146,3 +147,9 @@ template struct MemoryPoolEqual<memory_size_small>;
 template struct MemoryPoolEqual<memory_size_medium>;
 
 }} //end namespace vt::pool
+
+namespace vt { namespace pool {
+
+template struct MemoryPoolEqual<vt::runnable::detail::runnable_context_max_size>;
+
+}} /* end namespace vt::pool */

src/vt/runnable/make_runnable.h

@@ -145,7 +145,7 @@ struct RunnableMaker {
    */
   template <typename ElmT, typename IdxT = typename ElmT::IndexType>
   RunnableMaker&& withCollection(ElmT* elm) {
-    impl_->template addContext<ctx::Collection<IdxT>>(elm);
+    impl_->template addContext<ctx::Collection>(elm);
     set_handler_ = true;
 
     if (handler_ != uninitialized_handler) {

src/vt/runnable/runnable.cc

@@ -50,6 +50,7 @@
 #include "vt/configs/debug/debug_var_unused.h"
 #include "vt/configs/arguments/app_config.h"
 #include "vt/scheduler/thread_manager.h"
+#include "vt/pool/static_sized/memory_pool_equal.h"
 
 namespace vt { namespace runnable {
 
@@ -199,33 +200,38 @@ void RunnableNew::run() {
 }
 
 void RunnableNew::begin() {
-  for (auto&& ctx : contexts_) {
-    ctx->begin();
+  for (int i = 0; i < ci_; i++) {
+    contexts_[i]->begin();
   }
 }
 
 void RunnableNew::end() {
-  for (auto&& ctx : contexts_) {
-    ctx->end();
+  for (int i = 0; i < ci_; i++) {
+    contexts_[i]->end();
   }
 }
 
 void RunnableNew::suspend() {
-  for (auto&& ctx : contexts_) {
-    ctx->suspend();
+  for (int i = 0; i < ci_; i++) {
+    contexts_[i]->suspend();
   }
 }
 
 void RunnableNew::resume() {
-  for (auto&& ctx : contexts_) {
-    ctx->resume();
+  for (int i = 0; i < ci_; i++) {
+    contexts_[i]->resume();
   }
 }
 
 void RunnableNew::send(elm::ElementIDStruct elm, MsgSizeType bytes) {
-  for (auto&& ctx : contexts_) {
-    ctx->send(elm, bytes);
+  for (int i = 0; i < ci_; i++) {
+    contexts_[i]->send(elm, bytes);
   }
 }
 
+/*static*/ std::unique_ptr<
+  pool::MemoryPoolEqual<detail::runnable_context_max_size>
+> RunnableNew::up_pool =
+  std::make_unique<pool::MemoryPoolEqual<detail::runnable_context_max_size>>();
+
 }} /* end namespace vt::runnable */

src/vt/runnable/runnable.h

@@ -46,7 +46,15 @@
 
 #include "vt/messaging/message/smart_ptr.h"
 #include "vt/context/runnable_context/base.h"
+#include "vt/context/runnable_context/td.h"
+#include "vt/context/runnable_context/trace.h"
+#include "vt/context/runnable_context/from_node.h"
+#include "vt/context/runnable_context/set_context.h"
+#include "vt/context/runnable_context/collection.h"
+#include "vt/context/runnable_context/lb_data.h"
+#include "vt/context/runnable_context/continuation.h"
 #include "vt/elm/elm_id.h"
+#include "vt/utils/ptr/unique_fixed.h"
 
 // fwd-declarations for the element types
 namespace vt { namespace vrt {
@@ -61,14 +69,49 @@ struct UntypedCollection;
 
 namespace vt { namespace runnable {
 
+namespace detail {
+
+template <typename T>
+constexpr T& constexprMax(T& a, T& b) {
+  return a > b ? a : b;
+}
+
+template <typename T>
+constexpr T& arrayMaxImpl(T* begin, T* end) {
+  return begin + 1 == end
+    ? *begin
+    : constexprMax(*begin, arrayMaxImpl(begin + 1, end));
+}
+
+template <typename T, std::size_t N>
+constexpr T& arrayMax(T(&arr)[N]) {
+  return arrayMaxImpl(arr, arr + N);
+}
+
+constexpr std::size_t runnable_context_array[] = {
+#if vt_check_enabled(trace_enabled)
+  sizeof(ctx::Trace),
+#endif
+  sizeof(ctx::Continuation),
+  sizeof(ctx::FromNode),
+  sizeof(ctx::LBData),
+  sizeof(ctx::SetContext),
+  sizeof(ctx::TD),
+  sizeof(ctx::Collection)
+};
+
+constexpr std::size_t runnable_context_max_size = arrayMax(runnable_context_array);
+
+} /* end namespace detail */
+
 /**
  * \struct RunnableNew
  *
  * \brief Holds a runnable active handler along with all the context associated
  * with it to run it independently of the where in the stack it was created.
  */
 struct RunnableNew {
-  using CtxBasePtr = std::unique_ptr<ctx::Base>;
+  using CtxBasePtr = vt::util::ptr::unique_ptr_fixed<ctx::Base>;
 
   template <typename... Args>
   using FnParamType = void(*)(Args...);
@@ -107,9 +150,7 @@ struct RunnableNew {
    * \c T
    */
   template <typename T, typename... Args>
-  void addContext(Args&&... args) {
-    contexts_.emplace_back(std::make_unique<T>(std::forward<Args>(args)...));
-  }
+  void addContext(Args&&... args);
 
   /**
    * \brief Set up a handler to run on an collection object
@@ -241,10 +282,16 @@ struct RunnableNew {
     task_ = task_in;
   }
 
+  /// Memory pool for fixed sized unique pointer allocation
+  static std::unique_ptr<
+    pool::MemoryPoolEqual<detail::runnable_context_max_size>
+  > up_pool;
+
 private:
   MsgSharedPtr<BaseMsgType> msg_ = nullptr; /**< The associated message */
   bool is_threaded_ = false;                /**< Whether ULTs are supported */
-  std::vector<CtxBasePtr> contexts_;        /**< Vector of contexts */
+  std::array<CtxBasePtr, 8> contexts_;      /**< Array of contexts */
+  int ci_ = 0;                              /**< Current index of contexts */
   ActionType task_ = nullptr;               /**< The runnable's task  */
   bool done_ = false;                       /**< Whether task is complete */
   bool suspended_ = false;                  /**< Whether task is suspended */

src/vt/runnable/runnable.impl.h

@@ -52,15 +52,25 @@ namespace vt { namespace runnable {
 
 template <typename T>
 T* RunnableNew::get() {
-  for (auto&& ctx : contexts_) {
-    auto t = dynamic_cast<T*>(ctx.get());
+  for (int i = 0; i < ci_; i++) {
+    auto t = dynamic_cast<T*>(contexts_[i].get());
     if (t) {
       return t;
     }
   }
   return nullptr;
 }
 
+template <typename T, typename... Args>
+void RunnableNew::addContext(Args&&... args) {
+  auto c = vt::util::ptr::make_unique_fixed<
+    T, detail::runnable_context_max_size
+  >(*up_pool.get(), std::forward<Args>(args)...);
+  contexts_[ci_++] = vt::util::ptr::unique_fixed_to_base<ctx::Base, detail::runnable_context_max_size>(
+    *up_pool.get(), std::move(c)
+  );
+}
+
 }} /* end namespace vt::runnable */
 
 #endif /*INCLUDED_VT_RUNNABLE_RUNNABLE_IMPL_H*/