X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/7198a3162eaae82fa2ec5c612d5ae22e243055d7..b2fe69328dc3b66ce74894b58f5446514e48d53c:/src/kernel/context/Context.hpp

diff --git a/src/kernel/context/Context.hpp b/src/kernel/context/Context.hpp
index a60ea33971..50f140cfbc 100644
--- a/src/kernel/context/Context.hpp
+++ b/src/kernel/context/Context.hpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2007-2018. The SimGrid Team. All rights reserved.          */
 
 /* 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. */
@@ -6,134 +6,106 @@
 #ifndef SIMGRID_KERNEL_CONTEXT_CONTEXT_HPP
 #define SIMGRID_KERNEL_CONTEXT_CONTEXT_HPP
 
-#include <exception>
-#include <functional>
-#include <memory>
-#include <unordered_map>
-#include <vector>
-
-#include <xbt/functional.hpp>
-
-#include "simgrid/simix.h"
-#include "src/instr/instr_private.h"
 #include "src/internal_config.h"
-#include "src/simix/popping_private.h"
-#include "src/simix/smx_host_private.h"
-#include "src/simix/smx_io_private.h"
-#include "src/simix/smx_network_private.h"
-#include "src/simix/smx_synchro_private.hpp"
-#include "surf/surf.h"
-#include "xbt/base.h"
-#include "xbt/config.h"
-#include "xbt/function_types.h"
-#include "xbt/mallocator.h"
-#include "xbt/xbt_os_time.h"
-
-#include "src/simix/ActorImpl.hpp"
-#include <csignal>
+#include "src/simix/smx_network_private.hpp"
 
-#include <simgrid/simix.hpp>
+#include <csignal>
 
 namespace simgrid {
 namespace kernel {
 namespace context {
 
-  XBT_PUBLIC_CLASS ContextFactory {
-  private:
-    std::string name_;
-  public:
-
-    explicit ContextFactory(std::string name) : name_(std::move(name)) {}
-    virtual ~ContextFactory();
-    virtual Context* create_context(std::function<void()> code,
-      void_pfn_smxprocess_t cleanup, smx_actor_t process) = 0;
-
-    // Optional methods for attaching main() as a context:
-
-    /** Creates a context from the current context of execution
+class XBT_PUBLIC ContextFactory {
+private:
+  std::string name_;
+
+public:
+  explicit ContextFactory(std::string name) : name_(std::move(name)) {}
+  virtual ~ContextFactory();
+  virtual Context* create_context(std::function<void()> code, void_pfn_smxprocess_t cleanup, smx_actor_t process) = 0;
+
+  // Optional methods for attaching main() as a context:
+
+  /** Creates a context from the current context of execution
+   *
+   *  This will not work on all implementation of `ContextFactory`.
+   */
+  virtual Context* attach(void_pfn_smxprocess_t cleanup_func, smx_actor_t process);
+  virtual Context* create_maestro(std::function<void()> code, smx_actor_t process);
+
+  virtual void run_all() = 0;
+  virtual Context* self();
+  std::string const& name() const { return name_; }
+private:
+  void declare_context(void* T, std::size_t size);
+
+protected:
+  template <class T, class... Args> T* new_context(Args&&... args)
+  {
+    T* context = new T(std::forward<Args>(args)...);
+    this->declare_context(context, sizeof(T));
+    return context;
+  }
+};
+
+class XBT_PUBLIC Context {
+private:
+  std::function<void()> code_;
+  void_pfn_smxprocess_t cleanup_func_ = nullptr;
+  smx_actor_t actor_                  = nullptr;
+
+public:
+  class StopRequest {
+    /** @brief Exception launched to kill a process, in order to properly unwind its stack and release RAII stuff
      *
-     *  This will not work on all implementation of `ContextFactory`.
+     * Nope, Sonar, this should not inherit of std::exception nor of simgrid::Exception.
+     * Otherwise, users may accidentally catch it with a try {} catch (std::exception)
      */
-    virtual Context* attach(void_pfn_smxprocess_t cleanup_func, smx_actor_t process);
-    virtual Context* create_maestro(std::function<void()> code, smx_actor_t process);
-
-    virtual void run_all() = 0;
-    virtual Context* self();
-    std::string const& name() const
-    {
-      return name_;
-    }
-  private:
-    void declare_context(void* T, std::size_t size);
-  protected:
-    template<class T, class... Args>
-    T* new_context(Args&&... args)
-    {
-      T* context = new T(std::forward<Args>(args)...);
-      this->declare_context(context, sizeof(T));
-      return context;
-    }
-  };
+  public:
+    StopRequest() = default;
+    explicit StopRequest(std::string msg) : msg_(msg) {}
 
-  XBT_PUBLIC_CLASS Context {
   private:
-    std::function<void()> code_;
-    void_pfn_smxprocess_t cleanup_func_ = nullptr;
-    smx_actor_t process_ = nullptr;
-  public:
-    class StopRequest : public std::exception {
-    };
-    bool iwannadie;
-
-    Context(std::function<void()> code,
-            void_pfn_smxprocess_t cleanup_func,
-            smx_actor_t process);
-    void operator()()
-    {
-      code_();
-    }
-    bool has_code() const
-    {
-      return static_cast<bool>(code_);
-    }
-    smx_actor_t process()
-    {
-      return this->process_;
-    }
-    void set_cleanup(void_pfn_smxprocess_t cleanup)
-    {
-      cleanup_func_ = cleanup;
-    }
-
-    // Virtual methods
-    virtual ~Context();
-    virtual void stop();
-    virtual void suspend() = 0;
+    std::string msg_;
   };
+  bool iwannadie = false;
 
-  XBT_PUBLIC_CLASS AttachContext : public Context {
-  public:
+  Context(std::function<void()> code, void_pfn_smxprocess_t cleanup_func, smx_actor_t process);
+  Context(const Context&) = delete;
+  Context& operator=(const Context&) = delete;
 
-    AttachContext(std::function<void()> code,
-            void_pfn_smxprocess_t cleanup_func,
-            smx_actor_t process)
-      : Context(std::move(code), cleanup_func, process)
-    {}
+  void operator()() { code_(); }
+  bool has_code() const { return static_cast<bool>(code_); }
+  smx_actor_t process() { return this->actor_; }
+  void set_cleanup(void_pfn_smxprocess_t cleanup) { cleanup_func_ = cleanup; }
 
-    ~AttachContext() override;
+  // Virtual methods
+  virtual ~Context();
+  virtual void stop();
+  virtual void suspend() = 0;
+};
 
-    /** Called by the context when it is ready to give control
-     *  to the maestro.
-     */
-    virtual void attach_start() = 0;
+class XBT_PUBLIC AttachContext : public Context {
+public:
+  AttachContext(std::function<void()> code, void_pfn_smxprocess_t cleanup_func, smx_actor_t actor)
+      : Context(std::move(code), cleanup_func, actor)
+  {
+  }
 
-    /** Called by the context when it has finished its job */
-    virtual void attach_stop() = 0;
-  };
+  ~AttachContext() override;
+
+  /** Called by the context when it is ready to give control
+   *  to the maestro.
+   */
+  virtual void attach_start() = 0;
+
+  /** Called by the context when it has finished its job */
+  virtual void attach_stop() = 0;
+};
 
 /* This allows Java to hijack the context factory (Java induces factories of factory :) */
 typedef ContextFactory* (*ContextFactoryInitializer)();
-XBT_PUBLIC_DATA(ContextFactoryInitializer) factory_initializer;
+XBT_PUBLIC_DATA ContextFactoryInitializer factory_initializer;
 
 XBT_PRIVATE ContextFactory* thread_factory();
 XBT_PRIVATE ContextFactory* sysv_factory();
@@ -144,46 +116,41 @@ XBT_PRIVATE ContextFactory* boost_factory();
 
 typedef simgrid::kernel::context::ContextFactory *smx_context_factory_t;
 
-SG_BEGIN_DECL()
-
-
 XBT_PRIVATE void SIMIX_context_mod_init();
 XBT_PRIVATE void SIMIX_context_mod_exit();
 
-XBT_PUBLIC(smx_context_t)
-SIMIX_context_new(std::function<void()> code, void_pfn_smxprocess_t cleanup_func, smx_actor_t simix_process);
+XBT_PUBLIC smx_context_t SIMIX_context_new(std::function<void()> code, void_pfn_smxprocess_t cleanup_func,
+                                           smx_actor_t simix_process);
 
 #ifndef WIN32
-XBT_PUBLIC_DATA(char sigsegv_stack[SIGSTKSZ]);
+XBT_PUBLIC_DATA char sigsegv_stack[SIGSTKSZ];
 #endif
 
 /* We are using the bottom of the stack to save some information, like the
  * valgrind_stack_id. Define smx_context_usable_stack_size to give the remaining
- * size for the stack. */
+ * size for the stack. Round its value to a multiple of 16 (asan wants the stacks to be aligned this way). */
 #if HAVE_VALGRIND_H
-# define smx_context_usable_stack_size                                  \
-  (smx_context_stack_size - sizeof(unsigned int)) /* for valgrind_stack_id */
+#define smx_context_usable_stack_size                                                                                  \
+  ((smx_context_stack_size - sizeof(unsigned int)) & ~0xf) /* for valgrind_stack_id */
 #else
-# define smx_context_usable_stack_size smx_context_stack_size
+#define smx_context_usable_stack_size (smx_context_stack_size & ~0xf)
 #endif
 
 /** @brief Executes all the processes to run (in parallel if possible). */
 XBT_PRIVATE void SIMIX_context_runall();
 /** @brief returns the current running context */
-XBT_PUBLIC(smx_context_t) SIMIX_context_self(); // public because it's used in simgrid-java
+XBT_PUBLIC smx_context_t SIMIX_context_self(); // public because it's used in simgrid-java
 
 XBT_PRIVATE void *SIMIX_context_stack_new();
 XBT_PRIVATE void SIMIX_context_stack_delete(void *stack);
 
-XBT_PUBLIC(void) SIMIX_context_set_current(smx_context_t context);
+XBT_PUBLIC void SIMIX_context_set_current(smx_context_t context);
 XBT_PRIVATE smx_context_t SIMIX_context_get_current();
 
-XBT_PUBLIC(int) SIMIX_process_get_maxpid();
+XBT_PUBLIC int SIMIX_process_get_maxpid();
 
 XBT_PRIVATE void SIMIX_post_create_environment();
 
-SG_END_DECL()
-
-XBT_PRIVATE simgrid::simix::ActorCodeFactory& SIMIX_get_actor_code_factory(const char *name);
+XBT_PRIVATE simgrid::simix::ActorCodeFactory& SIMIX_get_actor_code_factory(std::string name);
 
 #endif