Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
ContextBoost: cleanup in includes and cosmetic moves and renames.
authorArnaud Giersch <arnaud.giersch@univ-fcomte.fr>
Fri, 20 Oct 2017 11:48:38 +0000 (13:48 +0200)
committerArnaud Giersch <arnaud.giersch@univ-fcomte.fr>
Sat, 21 Oct 2017 20:31:41 +0000 (22:31 +0200)
src/kernel/context/ContextBoost.cpp
src/kernel/context/ContextBoost.hpp

index 3e18362..6a8beb7 100644 (file)
@@ -3,20 +3,10 @@
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
-#include <cstdint>
+#include "ContextBoost.hpp"
 
 
-#include <functional>
 #include <utility>
 #include <utility>
-#include <vector>
-
-#include <boost/context/all.hpp>
-
 #include <xbt/log.h>
 #include <xbt/log.h>
-#include <xbt/xbt_os_thread.h>
-
-#include "src/internal_config.h"
-#include "src/kernel/context/ContextBoost.hpp"
-#include "src/simix/smx_private.hpp"
 
 #if HAVE_SANITIZE_ADDRESS_FIBER_SUPPORT
 #include <sanitizer/asan_interface.h>
 
 #if HAVE_SANITIZE_ADDRESS_FIBER_SUPPORT
 #include <sanitizer/asan_interface.h>
@@ -36,37 +26,8 @@ namespace simgrid {
 namespace kernel {
 namespace context {
 
 namespace kernel {
 namespace context {
 
-class BoostSerialContext : public BoostContext {
-public:
-  BoostSerialContext(std::function<void()> code,
-      void_pfn_smxprocess_t cleanup_func,
-      smx_actor_t process)
-    : BoostContext(std::move(code), cleanup_func, process) {}
-  void suspend() override;
-};
-
-#if HAVE_THREAD_CONTEXTS
-class BoostParallelContext : public BoostContext {
-public:
-  BoostParallelContext(std::function<void()> code,
-      void_pfn_smxprocess_t cleanup_func,
-      smx_actor_t process)
-    : BoostContext(std::move(code), cleanup_func, process) {}
-  void suspend() override;
-  void resume() override;
-};
-#endif
-
 // BoostContextFactory
 
 // BoostContextFactory
 
-bool BoostContext::parallel_                             = false;
-simgrid::xbt::Parmap<smx_actor_t>* BoostContext::parmap_ = nullptr;
-uintptr_t BoostContext::threads_working_                 = 0;
-xbt_os_thread_key_t BoostContext::worker_id_key_;
-unsigned long BoostContext::process_index_   = 0;
-BoostContext* BoostContext::maestro_context_ = nullptr;
-std::vector<BoostContext*> BoostContext::workers_context_;
-
 BoostContextFactory::BoostContextFactory()
   : ContextFactory("BoostContextFactory")
 {
 BoostContextFactory::BoostContextFactory()
   : ContextFactory("BoostContextFactory")
 {
@@ -96,16 +57,12 @@ BoostContextFactory::~BoostContextFactory()
 smx_context_t BoostContextFactory::create_context(std::function<void()> code, void_pfn_smxprocess_t cleanup_func,
                                                   smx_actor_t process)
 {
 smx_context_t BoostContextFactory::create_context(std::function<void()> code, void_pfn_smxprocess_t cleanup_func,
                                                   smx_actor_t process)
 {
-  BoostContext* context = nullptr;
-  if (BoostContext::parallel_)
 #if HAVE_THREAD_CONTEXTS
 #if HAVE_THREAD_CONTEXTS
-    context = this->new_context<BoostParallelContext>(std::move(code), cleanup_func, process);
-#else
-    xbt_die("No support for parallel execution");
+  if (BoostContext::parallel_)
+    return this->new_context<ParallelBoostContext>(std::move(code), cleanup_func, process);
 #endif
 #endif
-  else
-    context = this->new_context<BoostSerialContext>(std::move(code), cleanup_func, process);
-  return context;
+
+  return this->new_context<SerialBoostContext>(std::move(code), cleanup_func, process);
 }
 
 void BoostContextFactory::run_all()
 }
 
 void BoostContextFactory::run_all()
@@ -122,68 +79,38 @@ void BoostContextFactory::run_all()
           return context->resume();
         },
         simix_global->process_to_run);
           return context->resume();
         },
         simix_global->process_to_run);
-  } else
-#endif
-  {
-    if (simix_global->process_to_run.empty())
-      return;
-    smx_actor_t first_process    = simix_global->process_to_run.front();
-    BoostContext::process_index_ = 1;
-    /* execute the first process */
-    static_cast<BoostContext*>(first_process->context)->resume();
+    return;
   }
   }
+#endif
+
+  if (simix_global->process_to_run.empty())
+    return;
+  smx_actor_t first_process    = simix_global->process_to_run.front();
+  BoostContext::process_index_ = 1;
+  /* execute the first process */
+  static_cast<BoostContext*>(first_process->context)->resume();
 }
 
 
 // BoostContext
 
 }
 
 
 // BoostContext
 
-void BoostContext::smx_ctx_boost_wrapper(BoostContext::ctx_arg_type arg)
-{
-#if BOOST_VERSION < 106100
-  BoostContext* context = reinterpret_cast<BoostContext*>(arg);
-#else
-  ASAN_FINISH_SWITCH(nullptr, &static_cast<BoostContext**>(arg.data)[0]->asan_stack_,
-                     &static_cast<BoostContext**>(arg.data)[0]->asan_stack_size_);
-  static_cast<BoostContext**>(arg.data)[0]->fc_ = arg.fctx;
-  BoostContext* context                         = static_cast<BoostContext**>(arg.data)[1];
-#endif
-  try {
-    (*context)();
-    context->Context::stop();
-  } catch (StopRequest const&) {
-    XBT_DEBUG("Caught a StopRequest");
-  }
-  ASAN_EVAL(context->asan_stop_ = true);
-  context->suspend();
-}
-
-inline void BoostContext::smx_ctx_boost_jump_fcontext(BoostContext* from, BoostContext* to)
-{
-#if BOOST_VERSION < 105600
-  boost::context::jump_fcontext(from->fc_, to->fc_, reinterpret_cast<intptr_t>(to));
-#elif BOOST_VERSION < 106100
-  boost::context::jump_fcontext(&from->fc_, to->fc_, reinterpret_cast<intptr_t>(to));
-#else
-  BoostContext* ctx[2] = {from, to};
-  void* fake_stack;
-  ASAN_START_SWITCH(from->asan_stop_ ? nullptr : &fake_stack, to->asan_stack_, to->asan_stack_size_);
-  boost::context::detail::transfer_t arg = boost::context::detail::jump_fcontext(to->fc_, ctx);
-  ASAN_FINISH_SWITCH(fake_stack, &static_cast<BoostContext**>(arg.data)[0]->asan_stack_,
-                     &static_cast<BoostContext**>(arg.data)[0]->asan_stack_size_);
-  static_cast<BoostContext**>(arg.data)[0]->fc_ = arg.fctx;
-#endif
-}
+bool BoostContext::parallel_                             = false;
+simgrid::xbt::Parmap<smx_actor_t>* BoostContext::parmap_ = nullptr;
+uintptr_t BoostContext::threads_working_                 = 0;
+xbt_os_thread_key_t BoostContext::worker_id_key_;
+unsigned long BoostContext::process_index_   = 0;
+BoostContext* BoostContext::maestro_context_ = nullptr;
+std::vector<BoostContext*> BoostContext::workers_context_;
 
 
-BoostContext::BoostContext(std::function<void()> code,
-    void_pfn_smxprocess_t cleanup_func, smx_actor_t process)
-  : Context(std::move(code), cleanup_func, process)
+BoostContext::BoostContext(std::function<void()> code, void_pfn_smxprocess_t cleanup_func, smx_actor_t process)
+    : Context(std::move(code), cleanup_func, process)
 {
 
   /* if the user provided a function for the process then use it, otherwise it is the context for maestro */
   if (has_code()) {
     this->stack_ = SIMIX_context_stack_new();
 {
 
   /* if the user provided a function for the process then use it, otherwise it is the context for maestro */
   if (has_code()) {
     this->stack_ = SIMIX_context_stack_new();
-// We need to pass the bottom of the stack to make_fcontext, depending on the stack direction it may be the lower
-// or higher address:
+    /* We need to pass the bottom of the stack to make_fcontext,
+       depending on the stack direction it may be the lower or higher address: */
 #if PTH_STACKGROWTH == -1
     void* stack = static_cast<char*>(this->stack_) + smx_context_usable_stack_size;
 #else
 #if PTH_STACKGROWTH == -1
     void* stack = static_cast<char*>(this->stack_) + smx_context_usable_stack_size;
 #else
@@ -191,9 +118,9 @@ BoostContext::BoostContext(std::function<void()> code,
 #endif
     ASAN_EVAL(this->asan_stack_ = stack);
 #if BOOST_VERSION < 106100
 #endif
     ASAN_EVAL(this->asan_stack_ = stack);
 #if BOOST_VERSION < 106100
-    this->fc_ = boost::context::make_fcontext(stack, smx_context_usable_stack_size, smx_ctx_boost_wrapper);
+    this->fc_ = boost::context::make_fcontext(stack, smx_context_usable_stack_size, BoostContext::wrapper);
 #else
 #else
-    this->fc_ = boost::context::detail::make_fcontext(stack, smx_context_usable_stack_size, smx_ctx_boost_wrapper);
+    this->fc_ = boost::context::detail::make_fcontext(stack, smx_context_usable_stack_size, BoostContext::wrapper);
 #endif
   } else {
 #if BOOST_VERSION < 105600
 #endif
   } else {
 #if BOOST_VERSION < 105600
@@ -215,7 +142,42 @@ BoostContext::~BoostContext()
   SIMIX_context_stack_delete(this->stack_);
 }
 
   SIMIX_context_stack_delete(this->stack_);
 }
 
-// BoostSerialContext
+void BoostContext::wrapper(BoostContext::arg_type arg)
+{
+#if BOOST_VERSION < 106100
+  BoostContext* context = reinterpret_cast<BoostContext*>(arg);
+#else
+  ASAN_FINISH_SWITCH(nullptr, &static_cast<BoostContext**>(arg.data)[0]->asan_stack_,
+                     &static_cast<BoostContext**>(arg.data)[0]->asan_stack_size_);
+  static_cast<BoostContext**>(arg.data)[0]->fc_ = arg.fctx;
+  BoostContext* context                         = static_cast<BoostContext**>(arg.data)[1];
+#endif
+  try {
+    (*context)();
+    context->Context::stop();
+  } catch (StopRequest const&) {
+    XBT_DEBUG("Caught a StopRequest");
+  }
+  ASAN_EVAL(context->asan_stop_ = true);
+  context->suspend();
+}
+
+inline void BoostContext::swap(BoostContext* from, BoostContext* to)
+{
+#if BOOST_VERSION < 105600
+  boost::context::jump_fcontext(from->fc_, to->fc_, reinterpret_cast<intptr_t>(to));
+#elif BOOST_VERSION < 106100
+  boost::context::jump_fcontext(&from->fc_, to->fc_, reinterpret_cast<intptr_t>(to));
+#else
+  BoostContext* ctx[2] = {from, to};
+  void* fake_stack;
+  ASAN_START_SWITCH(from->asan_stop_ ? nullptr : &fake_stack, to->asan_stack_, to->asan_stack_size_);
+  boost::context::detail::transfer_t arg = boost::context::detail::jump_fcontext(to->fc_, ctx);
+  ASAN_FINISH_SWITCH(fake_stack, &static_cast<BoostContext**>(arg.data)[0]->asan_stack_,
+                     &static_cast<BoostContext**>(arg.data)[0]->asan_stack_size_);
+  static_cast<BoostContext**>(arg.data)[0]->fc_ = arg.fctx;
+#endif
+}
 
 void BoostContext::stop()
 {
 
 void BoostContext::stop()
 {
@@ -223,63 +185,65 @@ void BoostContext::stop()
   throw StopRequest();
 }
 
   throw StopRequest();
 }
 
-void BoostContext::resume()
-{
-  SIMIX_context_set_current(this);
-  smx_ctx_boost_jump_fcontext(maestro_context_, this);
-}
+// SerialBoostContext
 
 
-void BoostSerialContext::suspend()
+void SerialBoostContext::suspend()
 {
   /* determine the next context */
 {
   /* determine the next context */
-  BoostSerialContext* next_context;
+  SerialBoostContext* next_context;
   unsigned long int i = process_index_;
   process_index_++;
 
   if (i < simix_global->process_to_run.size()) {
     /* execute the next process */
     XBT_DEBUG("Run next process");
   unsigned long int i = process_index_;
   process_index_++;
 
   if (i < simix_global->process_to_run.size()) {
     /* execute the next process */
     XBT_DEBUG("Run next process");
-    next_context = static_cast<BoostSerialContext*>(simix_global->process_to_run[i]->context);
+    next_context = static_cast<SerialBoostContext*>(simix_global->process_to_run[i]->context);
   } else {
     /* all processes were run, return to maestro */
     XBT_DEBUG("No more process to run");
   } else {
     /* all processes were run, return to maestro */
     XBT_DEBUG("No more process to run");
-    next_context = static_cast<BoostSerialContext*>(maestro_context_);
+    next_context = static_cast<SerialBoostContext*>(maestro_context_);
   }
   SIMIX_context_set_current(static_cast<smx_context_t>(next_context));
   }
   SIMIX_context_set_current(static_cast<smx_context_t>(next_context));
-  smx_ctx_boost_jump_fcontext(this, next_context);
+  BoostContext::swap(this, next_context);
+}
+
+void SerialBoostContext::resume()
+{
+  SIMIX_context_set_current(this);
+  BoostContext::swap(maestro_context_, this);
 }
 
 }
 
-// BoostParallelContext
+// ParallelBoostContext
 
 #if HAVE_THREAD_CONTEXTS
 
 
 #if HAVE_THREAD_CONTEXTS
 
-void BoostParallelContext::suspend()
+void ParallelBoostContext::suspend()
 {
   boost::optional<smx_actor_t> next_work = parmap_->next();
 {
   boost::optional<smx_actor_t> next_work = parmap_->next();
-  BoostParallelContext* next_context;
+  ParallelBoostContext* next_context;
   if (next_work) {
     XBT_DEBUG("Run next process");
   if (next_work) {
     XBT_DEBUG("Run next process");
-    next_context = static_cast<BoostParallelContext*>(next_work.get()->context);
+    next_context = static_cast<ParallelBoostContext*>(next_work.get()->context);
   } else {
     XBT_DEBUG("No more processes to run");
     uintptr_t worker_id = reinterpret_cast<uintptr_t>(xbt_os_thread_get_specific(worker_id_key_));
   } else {
     XBT_DEBUG("No more processes to run");
     uintptr_t worker_id = reinterpret_cast<uintptr_t>(xbt_os_thread_get_specific(worker_id_key_));
-    next_context = static_cast<BoostParallelContext*>(workers_context_[worker_id]);
+    next_context        = static_cast<ParallelBoostContext*>(workers_context_[worker_id]);
   }
 
   SIMIX_context_set_current(static_cast<smx_context_t>(next_context));
   }
 
   SIMIX_context_set_current(static_cast<smx_context_t>(next_context));
-  smx_ctx_boost_jump_fcontext(this, next_context);
+  BoostContext::swap(this, next_context);
 }
 
 }
 
-void BoostParallelContext::resume()
+void ParallelBoostContext::resume()
 {
   uintptr_t worker_id = __sync_fetch_and_add(&threads_working_, 1);
   xbt_os_thread_set_specific(worker_id_key_, reinterpret_cast<void*>(worker_id));
 
 {
   uintptr_t worker_id = __sync_fetch_and_add(&threads_working_, 1);
   xbt_os_thread_set_specific(worker_id_key_, reinterpret_cast<void*>(worker_id));
 
-  BoostParallelContext* worker_context = static_cast<BoostParallelContext*>(SIMIX_context_self());
+  ParallelBoostContext* worker_context = static_cast<ParallelBoostContext*>(SIMIX_context_self());
   workers_context_[worker_id] = worker_context;
 
   SIMIX_context_set_current(this);
   workers_context_[worker_id] = worker_context;
 
   SIMIX_context_set_current(this);
-  smx_ctx_boost_jump_fcontext(worker_context, this);
+  BoostContext::swap(worker_context, this);
 }
 
 #endif
 }
 
 #endif
@@ -289,5 +253,4 @@ XBT_PRIVATE ContextFactory* boost_factory()
   XBT_VERB("Using Boost contexts. Welcome to the 21th century.");
   return new BoostContextFactory();
 }
   XBT_VERB("Using Boost contexts. Welcome to the 21th century.");
   return new BoostContextFactory();
 }
-
 }}} // namespace
 }}} // namespace
index f1261db..a816fe6 100644 (file)
@@ -6,27 +6,27 @@
 #ifndef SIMGRID_SIMIX_BOOST_CONTEXT_HPP
 #define SIMGRID_SIMIX_BOOST_CONTEXT_HPP
 
 #ifndef SIMGRID_SIMIX_BOOST_CONTEXT_HPP
 #define SIMGRID_SIMIX_BOOST_CONTEXT_HPP
 
-#include <boost/version.hpp>
-#if BOOST_VERSION < 106100
-#include <boost/context/fcontext.hpp>
-#else
-#include <boost/context/detail/fcontext.hpp>
-#endif
+#include <boost/context/all.hpp>
+
+#include <cstdint>
 #include <functional>
 #include <vector>
 
 #include <functional>
 #include <vector>
 
-#include <xbt/parmap.hpp>
-
 #include <simgrid/simix.hpp>
 #include <simgrid/simix.hpp>
+#include <xbt/parmap.hpp>
+#include <xbt/xbt_os_thread.h>
 
 
+#include "Context.hpp"
+#include "src/internal_config.h"
+#include "src/simix/smx_private.hpp"
 
 namespace simgrid {
 namespace kernel {
 namespace context {
 
 class BoostContext;
 
 namespace simgrid {
 namespace kernel {
 namespace context {
 
 class BoostContext;
-class BoostSerialContext;
-class BoostParallelContext;
+class SerialBoostContext;
+class ParallelBoostContext;
 class BoostContextFactory;
 
 /** @brief Userspace context switching implementation based on Boost.Context */
 class BoostContextFactory;
 
 /** @brief Userspace context switching implementation based on Boost.Context */
@@ -42,16 +42,16 @@ protected: // static
 
 #if BOOST_VERSION < 105600
   boost::context::fcontext_t* fc_ = nullptr;
 
 #if BOOST_VERSION < 105600
   boost::context::fcontext_t* fc_ = nullptr;
-  typedef intptr_t ctx_arg_type;
+  typedef intptr_t arg_type;
 #elif BOOST_VERSION < 106100
   boost::context::fcontext_t fc_;
 #elif BOOST_VERSION < 106100
   boost::context::fcontext_t fc_;
-  typedef intptr_t ctx_arg_type;
+  typedef intptr_t arg_type;
 #else
   boost::context::detail::fcontext_t fc_;
 #else
   boost::context::detail::fcontext_t fc_;
-  typedef boost::context::detail::transfer_t ctx_arg_type;
+  typedef boost::context::detail::transfer_t arg_type;
 #endif
 #endif
-  static void smx_ctx_boost_wrapper(ctx_arg_type);
-  static void smx_ctx_boost_jump_fcontext(BoostContext*, BoostContext*);
+  static void wrapper(arg_type arg);
+  static void swap(BoostContext* from, BoostContext* to);
 
 #if HAVE_SANITIZE_ADDRESS_FIBER_SUPPORT
   const void* asan_stack_ = nullptr;
 
 #if HAVE_SANITIZE_ADDRESS_FIBER_SUPPORT
   const void* asan_stack_ = nullptr;
@@ -61,25 +61,41 @@ protected: // static
 
   void* stack_ = nullptr;
 public:
 
   void* stack_ = nullptr;
 public:
-  friend BoostContextFactory;
-  BoostContext(std::function<void()> code,
-          void_pfn_smxprocess_t cleanup_func,
-          smx_actor_t process);
+  BoostContext(std::function<void()> code, void_pfn_smxprocess_t cleanup_func, smx_actor_t process);
   ~BoostContext() override;
   void stop() override;
   ~BoostContext() override;
   void stop() override;
-  virtual void resume();
+  virtual void resume() = 0;
+
+  friend BoostContextFactory;
 };
 
 };
 
-class BoostContextFactory : public ContextFactory {
+class SerialBoostContext : public BoostContext {
+public:
+  SerialBoostContext(std::function<void()> code, void_pfn_smxprocess_t cleanup_func, smx_actor_t process)
+      : BoostContext(std::move(code), cleanup_func, process)
+  {
+  }
+  void suspend() override;
+  void resume() override;
+};
+
+#if HAVE_THREAD_CONTEXTS
+class ParallelBoostContext : public BoostContext {
 public:
 public:
-  friend BoostContext;
-  friend BoostSerialContext;
-  friend BoostParallelContext;
+  ParallelBoostContext(std::function<void()> code, void_pfn_smxprocess_t cleanup_func, smx_actor_t process)
+      : BoostContext(std::move(code), cleanup_func, process)
+  {
+  }
+  void suspend() override;
+  void resume() override;
+};
+#endif
 
 
+class BoostContextFactory : public ContextFactory {
+public:
   BoostContextFactory();
   ~BoostContextFactory() override;
   BoostContextFactory();
   ~BoostContextFactory() override;
-  Context* create_context(std::function<void()> code,
-    void_pfn_smxprocess_t, smx_actor_t process) override;
+  Context* create_context(std::function<void()> code, void_pfn_smxprocess_t, smx_actor_t process) override;
   void run_all() override;
 };
 
   void run_all() override;
 };