#ifdef __cplusplus
namespace simgrid {
+namespace kernel {
+namespace context {
+ class Context;
+ class ContextFactory;
+}}
+
namespace simix {
/** @brief Process datatype
\see m_process_management
@{ */
class ActorImpl;
- class Context;
- class ContextFactory;
class Mutex;
class Mailbox;
}
}
-typedef simgrid::simix::Context *smx_context_t;
+typedef simgrid::kernel::context::Context *smx_context_t;
typedef simgrid::simix::ActorImpl *smx_process_t;
typedef simgrid::simix::Mutex *smx_mutex_t;
typedef simgrid::simix::Mailbox *smx_mailbox_t;
return result.get();
}
-class Context;
-class ContextFactory;
-
-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_process_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_process_t process);
- virtual Context* create_maestro(std::function<void()> code, smx_process_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;
- }
-};
-
-XBT_PUBLIC_CLASS Context {
-private:
- std::function<void()> code_;
- void_pfn_smxprocess_t cleanup_func_ = nullptr;
- smx_process_t process_ = nullptr;
-public:
- bool iwannadie;
-public:
- Context(std::function<void()> code,
- void_pfn_smxprocess_t cleanup_func,
- smx_process_t process);
- void operator()()
- {
- code_();
- }
- bool has_code() const
- {
- return (bool) code_;
- }
- smx_process_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;
-};
-
-XBT_PUBLIC_CLASS AttachContext : public Context {
-public:
-
- AttachContext(std::function<void()> code,
- void_pfn_smxprocess_t cleanup_func,
- smx_process_t process)
- : Context(std::move(code), cleanup_func, process)
- {}
-
- ~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;
-};
XBT_PUBLIC(void) set_maestro(std::function<void()> code);
XBT_PUBLIC(void) create_maestro(std::function<void()> code);
#include <simgrid/s4u/host.hpp>
+#include "src/kernel/context/Context.hpp"
#include "src/kernel/activity/SynchroSleep.hpp"
#include "src/surf/surf_interface.hpp"
#include "mc/mc.h"
+#include "src/kernel/context/Context.hpp"
#include "src/simix/smx_private.h"
void SIMIX_process_set_cleanup_function(
}
namespace simgrid {
-namespace simix {
+namespace kernel {
+namespace context {
ContextFactoryInitializer factory_initializer = nullptr;
{
}
+}}}
+
+/** @brief Executes all the processes to run (in parallel if possible). */
+void SIMIX_context_runall(void)
+{
+ if (!xbt_dynar_is_empty(simix_global->process_to_run))
+ simix_global->context_factory->run_all();
}
+
+/** @brief returns the current running context */
+smx_context_t SIMIX_context_self(void)
+{
+ if (simix_global && simix_global->context_factory)
+ return simix_global->context_factory->self();
+ else
+ return nullptr;
}
+
--- /dev/null
+/* Copyright (c) 2007-2016. 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. */
+
+#ifndef _SIMGRID_KERNEL_CONTEXT_CONTEXT_HPP
+#define _SIMGRID_KERNEL_CONTEXT_CONTEXT_HPP
+
+#include <functional>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+#include <xbt/functional.hpp>
+
+#include "src/internal_config.h"
+#include "simgrid/simix.h"
+#include "surf/surf.h"
+#include "xbt/base.h"
+#include "xbt/fifo.h"
+#include "xbt/swag.h"
+#include "xbt/dict.h"
+#include "xbt/mallocator.h"
+#include "xbt/config.h"
+#include "xbt/xbt_os_time.h"
+#include "xbt/function_types.h"
+#include "src/xbt/ex_interface.h"
+#include "src/instr/instr_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/popping_private.h"
+#include "src/simix/smx_synchro_private.h"
+
+#include <signal.h>
+#include "src/simix/ActorImpl.hpp"
+
+#ifdef __cplusplus
+
+#include <simgrid/simix.hpp>
+
+namespace simgrid {
+namespace kernel {
+namespace context {
+
+ class Context;
+ class ContextFactory;
+
+ 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_process_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_process_t process);
+ virtual Context* create_maestro(std::function<void()> code, smx_process_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;
+ }
+ };
+
+ XBT_PUBLIC_CLASS Context {
+ private:
+ std::function<void()> code_;
+ void_pfn_smxprocess_t cleanup_func_ = nullptr;
+ smx_process_t process_ = nullptr;
+ public:
+ bool iwannadie;
+ public:
+ Context(std::function<void()> code,
+ void_pfn_smxprocess_t cleanup_func,
+ smx_process_t process);
+ void operator()()
+ {
+ code_();
+ }
+ bool has_code() const
+ {
+ return (bool) code_;
+ }
+ smx_process_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;
+ };
+
+ XBT_PUBLIC_CLASS AttachContext : public Context {
+ public:
+
+ AttachContext(std::function<void()> code,
+ void_pfn_smxprocess_t cleanup_func,
+ smx_process_t process)
+ : Context(std::move(code), cleanup_func, process)
+ {}
+
+ ~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)(void);
+XBT_PUBLIC_DATA(ContextFactoryInitializer) factory_initializer;
+
+XBT_PRIVATE ContextFactory* thread_factory();
+XBT_PRIVATE ContextFactory* sysv_factory();
+XBT_PRIVATE ContextFactory* raw_factory();
+XBT_PRIVATE ContextFactory* boost_factory();
+
+}}}
+
+typedef simgrid::kernel::context::ContextFactory *smx_context_factory_t;
+
+#else
+
+typedef struct s_smx_context_factory *smx_context_factory_t;
+
+#endif
+
+SG_BEGIN_DECL()
+
+
+XBT_PRIVATE void SIMIX_context_mod_init(void);
+XBT_PRIVATE void SIMIX_context_mod_exit(void);
+
+XBT_PRIVATE smx_context_t SIMIX_context_new(
+ std::function<void()> code,
+ void_pfn_smxprocess_t cleanup_func,
+ smx_process_t simix_process);
+
+#ifndef WIN32
+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. */
+#if HAVE_VALGRIND_H
+# define smx_context_usable_stack_size \
+ (smx_context_stack_size - sizeof(unsigned int)) /* for valgrind_stack_id */
+#else
+# define smx_context_usable_stack_size smx_context_stack_size
+#endif
+
+/** @brief Executes all the processes to run (in parallel if possible). */
+XBT_PRIVATE void SIMIX_context_runall(void);
+/** @brief returns the current running context */
+XBT_PRIVATE smx_context_t SIMIX_context_self(void);
+
+XBT_PRIVATE void *SIMIX_context_stack_new(void);
+XBT_PRIVATE void SIMIX_context_stack_delete(void *stack);
+
+XBT_PRIVATE void SIMIX_context_set_current(smx_context_t context);
+XBT_PRIVATE smx_context_t SIMIX_context_get_current(void);
+
+XBT_PUBLIC(int) SIMIX_process_get_maxpid(void);
+
+XBT_PRIVATE void SIMIX_post_create_environment(void);
+
+// FIXME, Dirty hack for SMPI+MSG
+XBT_PRIVATE void SIMIX_process_set_cleanup_function(smx_process_t process, void_pfn_smxprocess_t cleanup);
+
+SG_END_DECL()
+
+XBT_PRIVATE simgrid::simix::ActorCodeFactory& SIMIX_get_actor_code_factory(const char *name);
+
+#endif
XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_context);
namespace simgrid {
-namespace simix {
+namespace kernel {
+namespace context {
class BoostSerialContext : public BoostContext {
public:
return new BoostContextFactory();
}
-}
-}
+}}} // namespace
namespace simgrid {
-namespace simix {
+namespace kernel {
+namespace context {
class BoostContext;
class BoostSerialContext;
void run_all() override;
};
-}
-}
+}}} // namespace
#endif
// ***** Class definitions
namespace simgrid {
-namespace simix {
+namespace kernel {
+namespace context {
class RawContext;
class RawContextFactory;
return new RawContextFactory();
}
-}
-}
+}}} // namespace
// ***** Loads of static stuff
#if HAVE_THREAD_CONTEXTS
static xbt_parmap_t raw_parmap;
-static simgrid::simix::RawContext** raw_workers_context; /* space to save the worker context in each thread */
+static simgrid::kernel::context::RawContext** raw_workers_context; /* space to save the worker context in each thread */
static uintptr_t raw_threads_working; /* number of threads that have started their work */
static xbt_os_thread_key_t raw_worker_id_key; /* thread-specific storage for the thread id */
#endif
static unsigned long raw_process_index = 0; /* index of the next process to run in the
* list of runnable processes */
-static simgrid::simix::RawContext* raw_maestro_context;
+static simgrid::kernel::context::RawContext* raw_maestro_context;
static bool raw_context_parallel = false;
// ***** Method definitions
namespace simgrid {
-namespace simix {
+namespace kernel {
+namespace context {
RawContextFactory::RawContextFactory()
: ContextFactory("RawContextFactory")
}
}
-}
-}
+}}}
static xbt_os_sem_t smx_ctx_thread_sem = nullptr;
namespace simgrid {
-namespace simix {
+namespace kernel {
+namespace context {
XBT_PRIVATE ContextFactory* thread_factory()
{
xbt_os_thread_set_extra_data(nullptr);
}
-}
-}
+}}} // namespace
namespace simgrid {
-namespace simix {
+namespace kernel {
+namespace context {
class ThreadContext;
class ThreadContextFactory;
ThreadContext* create_maestro(std::function<void()> code, smx_process_t process) override;
};
-}
-}
+}}} // namespace
-#endif
\ No newline at end of file
+#endif
XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_context);
namespace simgrid {
-namespace simix {
+namespace kernel {
+namespace context {
class UContext;
class SerialUContext;
class ParallelUContext;
class UContextFactory;
-}
-}
+}}}
#if HAVE_THREAD_CONTEXTS
static xbt_parmap_t sysv_parmap;
-static simgrid::simix::ParallelUContext** sysv_workers_context; /* space to save the worker's context in each thread */
+static simgrid::kernel::context::ParallelUContext** sysv_workers_context; /* space to save the worker's context in each thread */
static uintptr_t sysv_threads_working; /* number of threads that have started their work */
static xbt_os_thread_key_t sysv_worker_id_key; /* thread-specific storage for the thread id */
#endif
static unsigned long sysv_process_index = 0; /* index of the next process to run in the
* list of runnable processes */
-static simgrid::simix::UContext* sysv_maestro_context;
+static simgrid::kernel::context::UContext* sysv_maestro_context;
static bool sysv_parallel;
// The name of this function is currently hardcoded in the code (as string).
static void smx_ctx_sysv_wrapper(int first, ...);
namespace simgrid {
-namespace simix {
+namespace kernel {
+namespace context {
class UContext : public Context {
protected:
SIMIX_context_stack_delete(this->stack_);
}
-}
-}
+}}} // namespace simgrid::kernel::context
static void smx_ctx_sysv_wrapper(int first, ...)
{
// Rebuild the Context* pointer from the integers:
int ctx_addr[CTX_ADDR_LEN];
- simgrid::simix::UContext* context;
+ simgrid::kernel::context::UContext* context;
ctx_addr[0] = first;
if (CTX_ADDR_LEN > 1) {
va_list ap;
ctx_addr[i] = va_arg(ap, int);
va_end(ap);
}
- memcpy(&context, ctx_addr, sizeof(simgrid::simix::UContext*));
+ memcpy(&context, ctx_addr, sizeof(simgrid::kernel::context::UContext*));
(*context)();
context->stop();
}
namespace simgrid {
-namespace simix {
+namespace kernel {
+namespace context {
void SerialUContext::stop()
{
#endif
}
-}
-}
+}}} // namespace simgrid::kernel::context
#include "simgrid/simix.h"
+#include "src/kernel/context/Context.hpp"
#include "src/simix/ActorImpl.hpp"
#include "src/simix/smx_private.h"
#include "src/mc/mc_replay.h"
void replay(const char* path_string)
{
- simgrid::mc::processes_time.resize(simix_process_maxpid);
+ simgrid::mc::processes_time.resize(SIMIX_process_get_maxpid());
simgrid::mc::RecordTrace trace = simgrid::mc::parseRecordTrace(path_string);
simgrid::mc::replay(trace);
simgrid::mc::processes_time.clear();
#include "simgrid/s4u/host.hpp"
#include "simgrid/s4u/mailbox.hpp"
+#include "src/kernel/context/Context.hpp"
#include "src/simix/smx_private.h"
XBT_LOG_NEW_DEFAULT_CATEGORY(s4u_actor,"S4U actors");
/* Tracing the process creation */
TRACE_msg_process_create(process->name.c_str(), process->pid, process->host);
- auto context = dynamic_cast<simgrid::simix::AttachContext*>(process->context);
+ auto context = dynamic_cast<simgrid::kernel::context::AttachContext*>(process->context);
if (!context)
xbt_die("Not a suitable context");
void SIMIX_process_detach()
{
- auto context = dynamic_cast<simgrid::simix::AttachContext*>(SIMIX_context_self());
+ auto context = dynamic_cast<simgrid::kernel::context::AttachContext*>(SIMIX_context_self());
if (!context)
xbt_die("Not a suitable context");
// Let maestro ignore we are still alive:
// xbt_swag_remove(context->process(), simix_global->process_list);
- // TODDO, Remove from proces list:
+ // TODO, Remove from proces list:
// xbt_swag_remove(process, sg_host_simix(host)->process_list);
context->attach_stop();
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_context, simix, "Context switching mechanism");
-static std::pair<const char*, simgrid::simix::ContextFactoryInitializer> context_factories[] = {
+static std::pair<const char*, simgrid::kernel::context::ContextFactoryInitializer> context_factories[] = {
#if HAVE_RAW_CONTEXTS
- { "raw", &simgrid::simix::raw_factory },
+ { "raw", &simgrid::kernel::context::raw_factory },
#endif
#if HAVE_UCONTEXT_CONTEXTS
- { "ucontext", &simgrid::simix::sysv_factory },
+ { "ucontext", &simgrid::kernel::context::sysv_factory },
#endif
#if HAVE_BOOST_CONTEXTS
- { "boost", &simgrid::simix::boost_factory },
+ { "boost", &simgrid::kernel::context::boost_factory },
#endif
#if HAVE_THREAD_CONTEXTS
- { "thread", &simgrid::simix::thread_factory },
+ { "thread", &simgrid::kernel::context::thread_factory },
#endif
};
if (simix_global->context_factory)
return;
/* select the context factory to use to create the contexts */
- if (simgrid::simix::factory_initializer) { // Give Java a chance to hijack the factory mechanism
- simix_global->context_factory = simgrid::simix::factory_initializer();
+ if (simgrid::kernel::context::factory_initializer) { // Give Java a chance to hijack the factory mechanism
+ simix_global->context_factory = simgrid::kernel::context::factory_initializer();
return;
}
/* use the factory specified by --cfg=contexts/factory:value */
#include <signal.h>
#include "src/simix/ActorImpl.hpp"
-
-#ifdef __cplusplus
-
-#include <simgrid/simix.hpp>
-
-namespace simgrid {
-namespace simix {
-
-/* This allows Java to hijack the context factory (Java induces factories of factory :) */
-typedef ContextFactory* (*ContextFactoryInitializer)(void);
-XBT_PUBLIC_DATA(ContextFactoryInitializer) factory_initializer;
-
-XBT_PRIVATE ContextFactory* thread_factory();
-XBT_PRIVATE ContextFactory* sysv_factory();
-XBT_PRIVATE ContextFactory* raw_factory();
-XBT_PRIVATE ContextFactory* boost_factory();
-
-}
-}
-
-typedef simgrid::simix::ContextFactory *smx_context_factory_t;
-
-#else
-
-typedef struct s_smx_context_factory *smx_context_factory_t;
-
-#endif
+#include "src/kernel/context/Context.hpp"
/********************************** Simix Global ******************************/
XBT_PUBLIC_DATA(std::unique_ptr<simgrid::simix::Global>) simix_global;
-extern XBT_PRIVATE unsigned long simix_process_maxpid;
-
XBT_PUBLIC(void) SIMIX_clean(void);
/******************************** Exceptions *********************************/
void* data; /**< @brief user data */
} s_smx_file_t;
-XBT_PRIVATE void SIMIX_context_mod_init(void);
-XBT_PRIVATE void SIMIX_context_mod_exit(void);
-
-XBT_PRIVATE smx_context_t SIMIX_context_new(
- std::function<void()> code,
- void_pfn_smxprocess_t cleanup_func,
- smx_process_t simix_process);
-
-#ifndef WIN32
-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. */
-#if HAVE_VALGRIND_H
-# define smx_context_usable_stack_size \
- (smx_context_stack_size - sizeof(unsigned int)) /* for valgrind_stack_id */
-#else
-# define smx_context_usable_stack_size smx_context_stack_size
-#endif
-
-/** @brief Executes all the processes to run (in parallel if possible). */
-static inline void SIMIX_context_runall(void)
-{
- if (!xbt_dynar_is_empty(simix_global->process_to_run))
- simix_global->context_factory->run_all();
-}
-
-/** @brief returns the current running context */
-static inline smx_context_t SIMIX_context_self(void)
-{
- if (simix_global && simix_global->context_factory)
- return simix_global->context_factory->self();
- else
- return nullptr;
-}
-
-XBT_PRIVATE void *SIMIX_context_stack_new(void);
-XBT_PRIVATE void SIMIX_context_stack_delete(void *stack);
-
-XBT_PRIVATE void SIMIX_context_set_current(smx_context_t context);
-XBT_PRIVATE smx_context_t SIMIX_context_get_current(void);
-
-XBT_PUBLIC(int) SIMIX_process_get_maxpid(void);
-
-XBT_PRIVATE void SIMIX_post_create_environment(void);
-
-// FIXME, Dirty hack for SMPI+MSG
-XBT_PRIVATE void SIMIX_process_set_cleanup_function(smx_process_t process, void_pfn_smxprocess_t cleanup);
SG_END_DECL()
-XBT_PRIVATE simgrid::simix::ActorCodeFactory& SIMIX_get_actor_code_factory(const char *name);
-
#endif
src/simix/libsmx.cpp
src/simix/smx_context.cpp
src/kernel/context/Context.cpp
+ src/kernel/context/Context.hpp
src/kernel/context/ContextRaw.cpp
src/simix/smx_deployment.cpp
src/simix/smx_environment.cpp