namespace kernel {
namespace context {
-ContextFactory* java_factory()
-{
- XBT_INFO("Using regular java threads.");
- return new JavaContextFactory();
-}
-
JavaContextFactory::JavaContextFactory() : ContextFactory()
{
xbt_assert(xbt::binary_name == "java");
{
env->GetJavaVM(&__java_vm);
- simgrid::kernel::context::factory_initializer = &simgrid::kernel::context::java_factory;
+ simgrid::kernel::context::ContextFactory::initializer = []() {
+ XBT_INFO("Using regular java threads.");
+ return new simgrid::kernel::context::JavaContextFactory();
+ };
const _jthrowable* exc = env->ExceptionOccurred();
if (exc) {
env->ExceptionClear();
"When non-negative, raise a SIGTRAP after given (simulated) time", -1.0};
config::Flag<bool> cfg_verbose_exit{"debug/verbose-exit", "Display the actor status at exit", true};
-constexpr std::initializer_list<std::pair<const char*, context::ContextFactoryInitializer>> context_factories = {
+constexpr std::initializer_list<std::pair<const char*, context::ContextFactory* (*)()>> context_factories = {
#if HAVE_RAW_CONTEXTS
{"raw", &context::raw_factory},
#endif
#endif
/* select the context factory to use to create the contexts */
- if (context::factory_initializer != nullptr) { // Give Java a chance to hijack the factory mechanism
- instance_->set_context_factory(context::factory_initializer());
+ if (context::ContextFactory::initializer) { // Give Java a chance to hijack the factory mechanism
+ instance_->set_context_factory(context::ContextFactory::initializer());
return;
}
/* use the factory specified by --cfg=contexts/factory:value */
namespace kernel {
namespace context {
-ContextFactoryInitializer factory_initializer = nullptr;
+std::function<ContextFactory*(void)> ContextFactory::initializer;
+
static e_xbt_parmap_mode_t parallel_synchronization_mode = XBT_PARMAP_DEFAULT;
static int parallel_contexts = 1;
unsigned stack_size;
virtual void run_all(std::vector<actor::ActorImpl*> const& actors_list) = 0;
+ /* This allows Java to hijack the context factory (Java induces factories of factory :) */
+ static std::function<ContextFactory*(void)> initializer;
+
protected:
template <class T, class... Args> T* new_context(Args&&... args)
{
virtual void attach_stop() = 0;
};
-
-/* This allows Java to hijack the context factory (Java induces factories of factory :) */
-using ContextFactoryInitializer = ContextFactory* (*)();
-XBT_PUBLIC_DATA ContextFactoryInitializer factory_initializer;
-
XBT_PRIVATE ContextFactory* thread_factory();
XBT_PRIVATE ContextFactory* sysv_factory();
XBT_PRIVATE ContextFactory* raw_factory();