#include "msg/msg.h"
#include "msg/private.h"
#include "simix/private.h"
-#include "xbt/xbt_jcontext.h"
-#include "xbt/xbt_context_factory.h"
+#include "xbt/xbt_context_java.h"
#include "jmsg_process.h"
#include "jmsg_host.h"
static jobject
native_to_java_process(m_process_t process)
{
- return ((xbt_jcontext_t)(process->simdata->s_process->simdata->context))->jprocess;
+ return ((xbt_ctx_java_t)(process->simdata->s_process->simdata->context))->jprocess;
}
#include "jmsg.h"
#include "jxbt_utilities.h"
-#include "xbt/xbt_jcontext.h"
+#include "xbt/xbt_context_java.h"
XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(jmsg);
if(!id)
return;
- (*env)->CallVoidMethod(env,((xbt_jcontext_t)context)->jprocess,id);
+ (*env)->CallVoidMethod(env,((xbt_ctx_java_t)context)->jprocess,id);
}
if(!id)
return;
- (*env)->CallVoidMethod(env,((xbt_jcontext_t)context)->jprocess,id);
+ (*env)->CallVoidMethod(env,((xbt_ctx_java_t)context)->jprocess,id);
}
+++ /dev/null
-#ifndef _XBT_CONTEXT_FACTORY_H \r
-#define _XBT_CONTEXT_FACTORY_H\r
-\r
-#include "portable.h"\r
-#include "xbt/function_types.h"\r
-#include "xbt_context_private.h"\r
-\r
-SG_BEGIN_DECL()\r
-\r
-/* forward declaration */\r
-struct s_xbt_context_factory;\r
-\r
-/* this function describes the interface that all context factory must implement */\r
-typedef xbt_context_t (*xbt_pfn_context_factory_create_context_t)(const char*, xbt_main_func_t, void_f_pvoid_t, void*, void_f_pvoid_t, void*, int, char**);\r
-typedef int (*xbt_pfn_context_factory_create_maestro_context_t)(xbt_context_t*);\r
-\r
-/* this function finalize the specified context factory */\r
-typedef int (*xbt_pfn_context_factory_finalize_t)(struct s_xbt_context_factory**);\r
-\r
-/* this interface is used by the xbt context module to create the appropriate concept */\r
-typedef struct s_xbt_context_factory\r
-{\r
- xbt_pfn_context_factory_create_maestro_context_t create_maestro_context; /* create the context of the maestro */\r
- xbt_pfn_context_factory_create_context_t create_context; /* create a new context */\r
- xbt_pfn_context_factory_finalize_t finalize; /* finalize the context factory */\r
- const char* name; /* the name of the context factory */\r
- \r
-}s_xbt_context_factory_t;\r
-\r
-/**\r
- * This function select a context factory associated with the name specified by\r
- * the parameter name.\r
- * If successful the function returns 0. Otherwise the function returns the error\r
- * code.\r
- */\r
-int\r
-xbt_context_select_factory(const char* name);\r
-\r
-/**\r
- * This function initialize a context factory from the name specified by the parameter\r
- * name.\r
- * If successful the factory specified by the parameter factory is initialized and the\r
- * function returns 0. Otherwise the function returns the error code.\r
- */\r
-int\r
-xbt_context_init_factory_by_name(xbt_context_factory_t* factory, const char* name);\r
-\r
-\r
-SG_END_DECL()\r
-\r
-#endif /* !_XBT_CONTEXT_FACTORY_H */\r
\r
#include "xbt/function_types.h"\r
#include "xbt/ex_interface.h"\r
-#include "xbt/xbt_context_factory.h"\r
+#include "xbt/xbt_context_private.h"\r
#include "xbt/xbt_context_java.h"\r
\r
XBT_LOG_NEW_DEFAULT_CATEGORY(jmsg,"MSG for Java(TM)");\r
-#ifndef _XBT_JCONTEXT_H\r
-#define _XBT_JCONTEXT_H\r
+#ifndef _XBT_CONTEXT_JAVA_H\r
+#define _XBT_CONTEXT_JAVA_H\r
\r
#include "portable.h"\r
#include "xbt/misc.h"\r
\r
SG_BEGIN_DECL()\r
\r
-typedef struct s_xbt_jcontext\r
+typedef struct s_xbt_ctx_java\r
{\r
XBT_CTX_BASE_T;\r
jobject jprocess; /* the java process instance binded with the msg process structure */\r
JNIEnv* jenv; /* jni interface pointer associated to this thread */\r
-}s_xbt_jcontext_t,* xbt_jcontext_t;\r
+}s_xbt_ctx_java_t,* xbt_ctx_java_t;\r
\r
SG_END_DECL()\r
\r
-#endif /* !_XBT_JCONTEXT_H */\r
+#endif /* !_XBT_CONTEXT_JAVA_H */\r
\r
SG_BEGIN_DECL()\r
\r
+/* *********************** */\r
+/* Context type definition */\r
+/* *********************** */\r
+ \r
/* the following function pointers describe the interface that all context concepts must implement */\r
-\r
typedef void (*xbt_pfn_context_free_t)(xbt_context_t); /* pointer type to the function used to destroy the specified context */\r
typedef void (*xbt_pfn_context_kill_t)(xbt_context_t); /* pointer type to the function used to kill the specified context */\r
typedef void (*xbt_pfn_context_schedule_t)(xbt_context_t); /* pointer type to the function used to resume the specified context */\r
-typedef void (*xbt_pfn_context_yield_t)(void); /* pointer type to the function used to yield the specified context */\r
+typedef void (*xbt_pfn_context_yield_t)(void); /* pointer type to the function used to yield the specified context */\r
typedef void (*xbt_pfn_context_start_t)(xbt_context_t); /* pointer type to the function used to start the specified context */\r
-typedef void (*xbt_pfn_context_stop_t)(int); /* pointer type to the function used to stop the current context */\r
+typedef void (*xbt_pfn_context_stop_t)(int); /* pointer type to the function used to stop the current context */\r
\r
-/* each context concept must use this macro in its declaration */\r
+/* each context type must contain this macro at its begining -- OOP in C :/ */\r
#define XBT_CTX_BASE_T \\r
s_xbt_swag_hookup_t hookup; \\r
char *name; \\r
xbt_pfn_context_start_t start; \\r
xbt_pfn_context_stop_t stop \r
\r
-/* all other contexts derive from this structure */\r
-typedef struct s_xbt_context\r
-{\r
+/* all other context types derive from this structure */\r
+typedef struct s_xbt_context {\r
XBT_CTX_BASE_T;\r
-}s_xbt_context_t;\r
+} s_xbt_context_t;\r
+\r
+/* ****************** */\r
+/* Globals definition */\r
+/* ****************** */\r
\r
/* Important guys */\r
extern xbt_context_t current_context;\r
extern xbt_swag_t context_living;\r
extern xbt_swag_t context_to_destroy;\r
\r
+/* *********************** */\r
+/* factory type definition */\r
+/* *********************** */\r
+typedef struct s_xbt_context_factory * xbt_context_factory_t;\r
+\r
+/* this function describes the interface that all context factory must implement */\r
+typedef xbt_context_t (*xbt_pfn_context_factory_create_context_t)(const char*, xbt_main_func_t, void_f_pvoid_t, void*, void_f_pvoid_t, void*, int, char**);\r
+typedef int (*xbt_pfn_context_factory_create_maestro_context_t)(xbt_context_t*);\r
+\r
+/* this function finalize the specified context factory */\r
+typedef int (*xbt_pfn_context_factory_finalize_t)(xbt_context_factory_t*);\r
+\r
+/* this interface is used by the xbt context module to create the appropriate concept */\r
+typedef struct s_xbt_context_factory {\r
+ xbt_pfn_context_factory_create_maestro_context_t create_maestro_context; /* create the context of the maestro */\r
+ xbt_pfn_context_factory_create_context_t create_context; /* create a new context */\r
+ xbt_pfn_context_factory_finalize_t finalize; /* finalize the context factory */\r
+ const char* name; /* the name of the context factory */\r
+ \r
+} s_xbt_context_factory_t;\r
+\r
+/**\r
+ * This function select a context factory associated with the name specified by\r
+ * the parameter name.\r
+ * If successful the function returns 0. Otherwise the function returns the error\r
+ * code.\r
+ */\r
+int\r
+xbt_context_select_factory(const char* name);\r
+\r
+/**\r
+ * This function initialize a context factory from the name specified by the parameter\r
+ * name.\r
+ * If successful the factory specified by the parameter factory is initialized and the\r
+ * function returns 0. Otherwise the function returns the error code.\r
+ */\r
+int\r
+xbt_context_init_factory_by_name(xbt_context_factory_t* factory, const char* name);\r
+\r
\r
/* All factories init */\r
-typedef struct s_xbt_context_factory* xbt_context_factory_t;\r
+int xbt_ctx_thread_factory_init(xbt_context_factory_t* factory);\r
+int xbt_ctx_sysv_factory_init(xbt_context_factory_t* factory);\r
+int xbt_ctx_java_factory_init(xbt_context_factory_t* factory);\r
+\r
+\r
\r
-int xbt_thread_context_factory_init(xbt_context_factory_t* factory);\r
-int xbt_ucontext_factory_init(xbt_context_factory_t* factory);\r
-int xbt_jcontext_factory_init(xbt_context_factory_t* factory);\r
\r
\r
SG_END_DECL()\r
\r
-#include "ucontext_stack.h"\r
#include "xbt/ex_interface.h"\r
-#include "xbt/xbt_context_factory.h"\r
+#include "xbt/xbt_context_private.h"\r
\r
-#include "ucontext_stack.h" /* loads context system definitions */\r
+#include "context_sysv_config.h" /* loads context system definitions */\r
+#include "portable.h" \r
#include <ucontext.h> /* context relative declarations */ \r
#define STACK_SIZE 128*1024 /* lower this if you want to reduce the memory consumption */\r
\r
-typedef struct s_xbt_ucontext {\r
+typedef struct s_xbt_ctx_sysv {\r
XBT_CTX_BASE_T;\r
ucontext_t uc; /* the thread that execute the code */\r
char stack[STACK_SIZE]; /* the thread stack size */\r
- struct s_xbt_ucontext* prev; /* the previous thread */\r
-} s_xbt_ucontext_t,* xbt_ucontext_t;\r
+ struct s_xbt_ctx_sysv* prev;/* the previous thread */\r
+} s_xbt_ctx_sysv_t,* xbt_ctx_sysv_t;\r
\r
\r
/* callback: context fetching */\r
xbt_jcontext_ex_terminate(xbt_ex_t *e);\r
\r
static xbt_context_t \r
-xbt_ucontext_factory_create_context(const char* name, xbt_main_func_t code, void_f_pvoid_t startup_func, void* startup_arg, void_f_pvoid_t cleanup_func, void* cleanup_arg, int argc, char** argv);\r
+xbt_ctx_sysv_factory_create_context(const char* name, xbt_main_func_t code, void_f_pvoid_t startup_func, void* startup_arg, void_f_pvoid_t cleanup_func, void* cleanup_arg, int argc, char** argv);\r
\r
static int\r
-xbt_ucontext_factory_finalize(xbt_context_factory_t* factory);\r
+xbt_ctx_sysv_factory_finalize(xbt_context_factory_t* factory);\r
\r
static int \r
-xbt_ucontext_factory_create_maestro_context(xbt_context_t* maestro);\r
+xbt_ctx_sysv_factory_create_maestro_context(xbt_context_t* maestro);\r
\r
static void \r
-xbt_ucontext_free(xbt_context_t context);\r
+xbt_ctx_sysv_free(xbt_context_t context);\r
\r
static void \r
-xbt_ucontext_kill(xbt_context_t context);\r
+xbt_ctx_sysv_kill(xbt_context_t context);\r
\r
static void \r
-xbt_ucontext_schedule(xbt_context_t context);\r
+xbt_ctx_sysv_schedule(xbt_context_t context);\r
\r
static void \r
-xbt_ucontext_yield(void);\r
+xbt_ctx_sysv_yield(void);\r
\r
static void \r
-xbt_ucontext_start(xbt_context_t context);\r
+xbt_ctx_sysv_start(xbt_context_t context);\r
\r
static void \r
-xbt_ucontext_stop(int exit_code);\r
+xbt_ctx_sysv_stop(int exit_code);\r
\r
static void \r
-xbt_ucontext_swap(xbt_context_t context);\r
+xbt_ctx_sysv_swap(xbt_context_t context);\r
\r
static void\r
-xbt_ucontext_schedule(xbt_context_t context);\r
+xbt_ctx_sysv_schedule(xbt_context_t context);\r
\r
static void\r
-xbt_ucontext_yield(void);\r
+xbt_ctx_sysv_yield(void);\r
\r
static void\r
-xbt_ucontext_suspend(xbt_context_t context);\r
+xbt_ctx_sysv_suspend(xbt_context_t context);\r
\r
static void\r
-xbt_ucontext_resume(xbt_context_t context);\r
+xbt_ctx_sysv_resume(xbt_context_t context);\r
\r
-static void xbt_ucontext_wrapper(void);\r
+static void xbt_ctx_sysv_wrapper(void);\r
\r
/* callback: context fetching */\r
static ex_ctx_t*\r
-xbt_ucontext_ex_ctx(void) \r
+xbt_ctx_sysv_ex_ctx(void) \r
{\r
return current_context->exception;\r
}\r
\r
/* callback: termination */\r
static void \r
-xbt_ucontext_ex_terminate(xbt_ex_t *e) \r
+xbt_ctx_sysv_ex_terminate(xbt_ex_t *e) \r
{\r
xbt_ex_display(e);\r
abort();\r
\r
\r
int\r
-xbt_ucontext_factory_init(xbt_context_factory_t* factory)\r
+xbt_ctx_sysv_factory_init(xbt_context_factory_t* factory)\r
{\r
/* context exception */\r
*factory = xbt_new0(s_xbt_context_factory_t,1);\r
\r
- (*factory)->create_context = xbt_ucontext_factory_create_context;\r
- (*factory)->finalize = xbt_ucontext_factory_finalize;\r
- (*factory)->create_maestro_context = xbt_ucontext_factory_create_maestro_context;\r
- (*factory)->name = "ucontext_context_factory";\r
+ (*factory)->create_context = xbt_ctx_sysv_factory_create_context;\r
+ (*factory)->finalize = xbt_ctx_sysv_factory_finalize;\r
+ (*factory)->create_maestro_context = xbt_ctx_sysv_factory_create_maestro_context;\r
+ (*factory)->name = "ctx_sysv_context_factory";\r
\r
/* context exception handlers */\r
- __xbt_ex_ctx = xbt_ucontext_ex_ctx;\r
- __xbt_ex_terminate = xbt_ucontext_ex_terminate; \r
+ __xbt_ex_ctx = xbt_ctx_sysv_ex_ctx;\r
+ __xbt_ex_terminate = xbt_ctx_sysv_ex_terminate; \r
\r
return 0;\r
}\r
\r
static int \r
-xbt_ucontext_factory_create_maestro_context(xbt_context_t* maestro)\r
+xbt_ctx_sysv_factory_create_maestro_context(xbt_context_t* maestro)\r
{\r
\r
- xbt_ucontext_t context = xbt_new0(s_xbt_ucontext_t, 1);\r
+ xbt_ctx_sysv_t context = xbt_new0(s_xbt_ctx_sysv_t, 1);\r
\r
context->exception = xbt_new(ex_ctx_t,1);\r
XBT_CTX_INITIALIZE(context->exception);\r
\r
\r
static int\r
-xbt_ucontext_factory_finalize(xbt_context_factory_t* factory)\r
+xbt_ctx_sysv_factory_finalize(xbt_context_factory_t* factory)\r
{\r
free(maestro_context->exception);\r
free(*factory);\r
}\r
\r
static xbt_context_t \r
-xbt_ucontext_factory_create_context(const char* name, xbt_main_func_t code, void_f_pvoid_t startup_func, void* startup_arg, void_f_pvoid_t cleanup_func, void* cleanup_arg, int argc, char** argv)\r
+xbt_ctx_sysv_factory_create_context(const char* name, xbt_main_func_t code, void_f_pvoid_t startup_func, void* startup_arg, void_f_pvoid_t cleanup_func, void* cleanup_arg, int argc, char** argv)\r
{\r
- xbt_ucontext_t context = xbt_new0(s_xbt_ucontext_t, 1);\r
+ xbt_ctx_sysv_t context = xbt_new0(s_xbt_ctx_sysv_t, 1);\r
\r
context->code = code;\r
context->name = xbt_strdup(name);\r
context->cleanup_arg = cleanup_arg;\r
\r
\r
- context->free = xbt_ucontext_free; \r
- context->kill = xbt_ucontext_kill; \r
- context->schedule = xbt_ucontext_schedule;\r
- context->yield = xbt_ucontext_yield; \r
- context->start = xbt_ucontext_start; \r
- context->stop = xbt_ucontext_stop; \r
+ context->free = xbt_ctx_sysv_free; \r
+ context->kill = xbt_ctx_sysv_kill; \r
+ context->schedule = xbt_ctx_sysv_schedule;\r
+ context->yield = xbt_ctx_sysv_yield; \r
+ context->start = xbt_ctx_sysv_start; \r
+ context->stop = xbt_ctx_sysv_stop; \r
\r
return (xbt_context_t)context;\r
}\r
\r
static void \r
-xbt_ucontext_free(xbt_context_t context)\r
+xbt_ctx_sysv_free(xbt_context_t context)\r
{\r
if(context)\r
{\r
}\r
\r
static void \r
-xbt_ucontext_kill(xbt_context_t context)\r
+xbt_ctx_sysv_kill(xbt_context_t context)\r
{\r
context->iwannadie = 1;\r
- xbt_ucontext_swap(context);\r
+ xbt_ctx_sysv_swap(context);\r
}\r
\r
/** \r
* Only the maestro can call this function to run a given process.\r
*/\r
static void \r
-xbt_ucontext_schedule(xbt_context_t context)\r
+xbt_ctx_sysv_schedule(xbt_context_t context)\r
{\r
xbt_assert0((current_context == maestro_context),"You are not supposed to run this function here!");\r
- xbt_ucontext_swap(context);\r
+ xbt_ctx_sysv_swap(context);\r
}\r
\r
/** \r
* to the maestro\r
*/\r
static void \r
-xbt_ucontext_yield(void)\r
+xbt_ctx_sysv_yield(void)\r
{\r
xbt_assert0((current_context != maestro_context),"You are not supposed to run this function here!");\r
- xbt_ucontext_swap(current_context);\r
+ xbt_ctx_sysv_swap(current_context);\r
}\r
\r
static void \r
-xbt_ucontext_start(xbt_context_t context)\r
+xbt_ctx_sysv_start(xbt_context_t context)\r
{\r
- makecontext(&(((xbt_ucontext_t)context)->uc), xbt_ucontext_wrapper, 0);\r
+ makecontext(&(((xbt_ctx_sysv_t)context)->uc), xbt_ctx_sysv_wrapper, 0);\r
}\r
\r
static void \r
-xbt_ucontext_stop(int exit_code)\r
+xbt_ctx_sysv_stop(int exit_code)\r
{\r
if(current_context->cleanup_func) \r
((*current_context->cleanup_func))(current_context->cleanup_arg);\r
xbt_swag_remove(current_context, context_living);\r
xbt_swag_insert(current_context, context_to_destroy); \r
\r
- xbt_ucontext_swap(current_context);\r
+ xbt_ctx_sysv_swap(current_context);\r
}\r
\r
static void \r
-xbt_ucontext_swap(xbt_context_t context)\r
+xbt_ctx_sysv_swap(xbt_context_t context)\r
{\r
xbt_assert0(current_context, "You have to call context_init() first.");\r
xbt_assert0(context, "Invalid argument");\r
\r
- if(((xbt_ucontext_t)context)->prev == NULL) \r
- xbt_ucontext_resume(context);\r
+ if(((xbt_ctx_sysv_t)context)->prev == NULL) \r
+ xbt_ctx_sysv_resume(context);\r
else \r
- xbt_ucontext_suspend(context);\r
+ xbt_ctx_sysv_suspend(context);\r
\r
if(current_context->iwannadie)\r
- xbt_ucontext_stop(1);\r
+ xbt_ctx_sysv_stop(1);\r
}\r
\r
static void\r
-xbt_ucontext_wrapper(void)\r
+xbt_ctx_sysv_wrapper(void)\r
{\r
if (current_context->startup_func)\r
(*current_context->startup_func)(current_context->startup_arg);\r
\r
- xbt_ucontext_stop((*(current_context->code))(current_context->argc, current_context->argv));\r
+ xbt_ctx_sysv_stop((*(current_context->code))(current_context->argc, current_context->argv));\r
}\r
\r
static void\r
-xbt_ucontext_suspend(xbt_context_t context)\r
+xbt_ctx_sysv_suspend(xbt_context_t context)\r
{\r
int rv;\r
\r
- xbt_ucontext_t prev_context = ((xbt_ucontext_t)context)->prev;\r
+ xbt_ctx_sysv_t prev_context = ((xbt_ctx_sysv_t)context)->prev;\r
\r
- current_context = (xbt_context_t)(((xbt_ucontext_t)context)->prev);\r
+ current_context = (xbt_context_t)(((xbt_ctx_sysv_t)context)->prev);\r
\r
- ((xbt_ucontext_t)context)->prev = NULL;\r
+ ((xbt_ctx_sysv_t)context)->prev = NULL;\r
\r
- rv = swapcontext(&(((xbt_ucontext_t)context)->uc), &(prev_context->uc));\r
+ rv = swapcontext(&(((xbt_ctx_sysv_t)context)->uc), &(prev_context->uc));\r
\r
xbt_assert0((rv == 0), "Context swapping failure");\r
}\r
\r
static void\r
-xbt_ucontext_resume(xbt_context_t context)\r
+xbt_ctx_sysv_resume(xbt_context_t context)\r
{\r
int rv;\r
\r
- ((xbt_ucontext_t)context)->prev = (xbt_ucontext_t)current_context;\r
+ ((xbt_ctx_sysv_t)context)->prev = (xbt_ctx_sysv_t)current_context;\r
\r
current_context = context;\r
\r
- rv = swapcontext(&(((xbt_ucontext_t)context)->prev->uc), &(((xbt_ucontext_t)context)->uc));\r
+ rv = swapcontext(&(((xbt_ctx_sysv_t)context)->prev->uc), &(((xbt_ctx_sysv_t)context)->uc));\r
\r
xbt_assert0((rv == 0), "Context swapping failure");\r
}\r
\r
#include "xbt/function_types.h"\r
-#include "xbt/xbt_context_factory.h"\r
+#include "xbt/xbt_context_private.h"\r
\r
#include "portable.h" /* loads context system definitions */\r
#include "xbt/swag.h"\r
#include "xbt/xbt_os_thread.h"\r
\r
\r
-typedef struct s_xbt_thread_context {\r
+typedef struct s_xbt_ctx_thread {\r
XBT_CTX_BASE_T;\r
xbt_os_thread_t thread; /* a plain dumb thread (portable to posix or windows) */\r
xbt_os_sem_t begin; /* this semaphore is used to schedule/yield the process */\r
xbt_os_sem_t end; /* this semaphore is used to schedule/unschedule the process */\r
-} s_xbt_thread_context_t,* xbt_thread_context_t;\r
+} s_xbt_ctx_thread_t,* xbt_ctx_thread_t;\r
\r
static xbt_context_t \r
-xbt_thread_context_factory_create_context(const char* name, xbt_main_func_t code, void_f_pvoid_t startup_func, void* startup_arg, void_f_pvoid_t cleanup_func, void* cleanup_arg, int argc, char** argv);\r
+xbt_ctx_thread_factory_create_context(const char* name, xbt_main_func_t code, void_f_pvoid_t startup_func, void* startup_arg, void_f_pvoid_t cleanup_func, void* cleanup_arg, int argc, char** argv);\r
\r
\r
static int\r
-xbt_thread_context_factory_create_master_context(xbt_context_t* maestro);\r
+xbt_ctx_thread_factory_create_master_context(xbt_context_t* maestro);\r
\r
static int\r
-xbt_thread_context_factory_finalize(xbt_context_factory_t* factory);\r
+xbt_ctx_thread_factory_finalize(xbt_context_factory_t* factory);\r
\r
static void \r
-xbt_thread_context_free(xbt_context_t context);\r
+xbt_ctx_thread_free(xbt_context_t context);\r
\r
static void \r
-xbt_thread_context_kill(xbt_context_t context);\r
+xbt_ctx_thread_kill(xbt_context_t context);\r
\r
static void \r
-xbt_thread_context_schedule(xbt_context_t context);\r
+xbt_ctx_thread_schedule(xbt_context_t context);\r
\r
static void \r
-xbt_thread_context_yield(void);\r
+xbt_ctx_thread_yield(void);\r
\r
static void \r
-xbt_thread_context_start(xbt_context_t context);\r
+xbt_ctx_thread_start(xbt_context_t context);\r
\r
static void \r
-xbt_thread_context_stop(int exit_code);\r
+xbt_ctx_thread_stop(int exit_code);\r
\r
static void \r
-xbt_thread_context_swap(xbt_context_t context);\r
+xbt_ctx_thread_swap(xbt_context_t context);\r
\r
static void\r
-xbt_thread_context_schedule(xbt_context_t context);\r
+xbt_ctx_thread_schedule(xbt_context_t context);\r
\r
static void\r
-xbt_thread_context_yield(void);\r
+xbt_ctx_thread_yield(void);\r
\r
static void\r
-xbt_thread_context_suspend(xbt_context_t context);\r
+xbt_ctx_thread_suspend(xbt_context_t context);\r
\r
static void\r
-xbt_thread_context_resume(xbt_context_t context);\r
+xbt_ctx_thread_resume(xbt_context_t context);\r
\r
static void* \r
-xbt_thread_context_wrapper(void* param);\r
+xbt_ctx_thread_wrapper(void* param);\r
\r
int\r
-xbt_thread_context_factory_init(xbt_context_factory_t* factory)\r
+xbt_ctx_thread_factory_init(xbt_context_factory_t* factory)\r
{\r
*factory = xbt_new0(s_xbt_context_factory_t,1);\r
\r
- (*factory)->create_context = xbt_thread_context_factory_create_context;\r
- (*factory)->finalize = xbt_thread_context_factory_finalize;\r
- (*factory)->create_maestro_context = xbt_thread_context_factory_create_master_context;\r
- (*factory)->name = "thread_context_factory";\r
+ (*factory)->create_context = xbt_ctx_thread_factory_create_context;\r
+ (*factory)->finalize = xbt_ctx_thread_factory_finalize;\r
+ (*factory)->create_maestro_context = xbt_ctx_thread_factory_create_master_context;\r
+ (*factory)->name = "ctx_thread_factory";\r
\r
return 0;\r
}\r
\r
static int\r
-xbt_thread_context_factory_create_master_context(xbt_context_t* maestro)\r
+xbt_ctx_thread_factory_create_master_context(xbt_context_t* maestro)\r
{\r
- *maestro = (xbt_context_t)xbt_new0(s_xbt_thread_context_t, 1);\r
+ *maestro = (xbt_context_t)xbt_new0(s_xbt_ctx_thread_t, 1);\r
return 0;\r
}\r
\r
static int\r
-xbt_thread_context_factory_finalize(xbt_context_factory_t* factory)\r
+xbt_ctx_thread_factory_finalize(xbt_context_factory_t* factory)\r
{\r
free(*factory);\r
*factory = NULL;\r
}\r
\r
static xbt_context_t \r
-xbt_thread_context_factory_create_context(const char* name, xbt_main_func_t code, void_f_pvoid_t startup_func, void* startup_arg, void_f_pvoid_t cleanup_func, void* cleanup_arg, int argc, char** argv)\r
+xbt_ctx_thread_factory_create_context(const char* name, xbt_main_func_t code, void_f_pvoid_t startup_func, void* startup_arg, void_f_pvoid_t cleanup_func, void* cleanup_arg, int argc, char** argv)\r
{\r
- xbt_thread_context_t context = xbt_new0(s_xbt_thread_context_t, 1);\r
+ xbt_ctx_thread_t context = xbt_new0(s_xbt_ctx_thread_t, 1);\r
\r
context->code = code;\r
context->name = xbt_strdup(name);\r
context->cleanup_func = cleanup_func;\r
context->cleanup_arg = cleanup_arg;\r
\r
- context->free = xbt_thread_context_free; \r
- context->kill = xbt_thread_context_kill; \r
- context->schedule = xbt_thread_context_schedule;\r
- context->yield = xbt_thread_context_yield; \r
- context->start = xbt_thread_context_start; \r
- context->stop = xbt_thread_context_stop; \r
+ context->free = xbt_ctx_thread_free; \r
+ context->kill = xbt_ctx_thread_kill; \r
+ context->schedule = xbt_ctx_thread_schedule;\r
+ context->yield = xbt_ctx_thread_yield; \r
+ context->start = xbt_ctx_thread_start; \r
+ context->stop = xbt_ctx_thread_stop; \r
\r
return (xbt_context_t)context;\r
}\r
\r
static void \r
-xbt_thread_context_free(xbt_context_t context)\r
+xbt_ctx_thread_free(xbt_context_t context)\r
{\r
if(context)\r
{\r
- xbt_thread_context_t thread_context = (xbt_thread_context_t)context;\r
+ xbt_ctx_thread_t ctx_thread = (xbt_ctx_thread_t)context;\r
\r
- free(thread_context->name);\r
+ free(ctx_thread->name);\r
\r
- if(thread_context->argv)\r
+ if(ctx_thread->argv)\r
{\r
int i;\r
\r
- for(i = 0; i < thread_context->argc; i++)\r
- if(thread_context->argv[i])\r
- free(thread_context->argv[i]);\r
+ for(i = 0; i < ctx_thread->argc; i++)\r
+ if(ctx_thread->argv[i])\r
+ free(ctx_thread->argv[i]);\r
\r
- free(thread_context->argv);\r
+ free(ctx_thread->argv);\r
}\r
\r
/* wait about the thread terminason */\r
- xbt_os_thread_join(thread_context->thread, NULL);\r
+ xbt_os_thread_join(ctx_thread->thread, NULL);\r
\r
/* destroy the synchronisation objects */\r
- xbt_os_sem_destroy(thread_context->begin);\r
- xbt_os_sem_destroy(thread_context->end);\r
+ xbt_os_sem_destroy(ctx_thread->begin);\r
+ xbt_os_sem_destroy(ctx_thread->end);\r
\r
/* finally destroy the context */\r
free(context);\r
}\r
\r
static void \r
-xbt_thread_context_kill(xbt_context_t context)\r
+xbt_ctx_thread_kill(xbt_context_t context)\r
{\r
context->iwannadie = 1;\r
- xbt_thread_context_swap(context);\r
+ xbt_ctx_thread_swap(context);\r
}\r
\r
/** \r
* Only the maestro can call this function to run a given process.\r
*/\r
static void \r
-xbt_thread_context_schedule(xbt_context_t context)\r
+xbt_ctx_thread_schedule(xbt_context_t context)\r
{\r
xbt_assert0((current_context == maestro_context),"You are not supposed to run this function here!");\r
- xbt_thread_context_swap(context);\r
+ xbt_ctx_thread_swap(context);\r
}\r
\r
/** \r
* to the maestro\r
*/\r
static void \r
-xbt_thread_context_yield(void)\r
+xbt_ctx_thread_yield(void)\r
{\r
xbt_assert0((current_context != maestro_context),"You are not supposed to run this function here!");\r
- xbt_thread_context_swap(current_context);\r
+ xbt_ctx_thread_swap(current_context);\r
}\r
\r
static void \r
-xbt_thread_context_start(xbt_context_t context)\r
+xbt_ctx_thread_start(xbt_context_t context)\r
{\r
- xbt_thread_context_t thread_context = (xbt_thread_context_t)context;\r
+ xbt_ctx_thread_t ctx_thread = (xbt_ctx_thread_t)context;\r
\r
/* create and start the process */\r
- thread_context->thread = xbt_os_thread_create(thread_context->name,xbt_thread_context_wrapper,thread_context);\r
+ ctx_thread->thread = xbt_os_thread_create(ctx_thread->name,xbt_ctx_thread_wrapper,ctx_thread);\r
\r
/* wait the starting of the newly created process */\r
- xbt_os_sem_acquire(thread_context->end);\r
+ xbt_os_sem_acquire(ctx_thread->end);\r
}\r
\r
static void \r
-xbt_thread_context_stop(int exit_code)\r
+xbt_ctx_thread_stop(int exit_code)\r
{\r
if(current_context->cleanup_func) \r
((*current_context->cleanup_func))(current_context->cleanup_arg);\r
xbt_swag_insert(current_context, context_to_destroy); \r
\r
/* signal to the maestro that it has finished */\r
- xbt_os_sem_release(((xbt_thread_context_t)current_context)->end);\r
+ xbt_os_sem_release(((xbt_ctx_thread_t)current_context)->end);\r
\r
/* exit*/\r
xbt_os_thread_exit(NULL); /* We should provide return value in case other wants it */\r
}\r
\r
static void \r
-xbt_thread_context_swap(xbt_context_t context)\r
+xbt_ctx_thread_swap(xbt_context_t context)\r
{\r
if((current_context != maestro_context) && !context->iwannadie)\r
{\r
/* (0) it's not the scheduler and the process doesn't want to die, it just wants to yield */\r
\r
/* yield itself, resume the maestro */\r
- xbt_thread_context_suspend(context);\r
+ xbt_ctx_thread_suspend(context);\r
}\r
else\r
{\r
* -> goto (3.1)\r
*/\r
/* schedule the process associated with this context */\r
- xbt_thread_context_resume(context);\r
+ xbt_ctx_thread_resume(context);\r
\r
}\r
\r
/* (4) the current process wants to die */\r
if(current_context->iwannadie)\r
- xbt_thread_context_stop(1);\r
+ xbt_ctx_thread_stop(1);\r
}\r
\r
static void* \r
-xbt_thread_context_wrapper(void* param)\r
+xbt_ctx_thread_wrapper(void* param)\r
{\r
- xbt_thread_context_t context = (xbt_thread_context_t)param;\r
+ xbt_ctx_thread_t context = (xbt_ctx_thread_t)param;\r
\r
/* Tell the maestro we are starting, and wait for its green light */\r
xbt_os_sem_release(context->end); \r
(*(context->startup_func))(context->startup_arg);\r
\r
\r
- xbt_thread_context_stop((context->code) (context->argc, context->argv));\r
+ xbt_ctx_thread_stop((context->code) (context->argc, context->argv));\r
return NULL;\r
}\r
\r
static void\r
-xbt_thread_context_suspend(xbt_context_t context)\r
+xbt_ctx_thread_suspend(xbt_context_t context)\r
{\r
/* save the current context */\r
xbt_context_t self = current_context;\r
/* update the current context to this context */\r
current_context = context;\r
\r
- xbt_os_sem_release(((xbt_thread_context_t)context)->end); \r
- xbt_os_sem_acquire(((xbt_thread_context_t)context)->begin);\r
+ xbt_os_sem_release(((xbt_ctx_thread_t)context)->end); \r
+ xbt_os_sem_acquire(((xbt_ctx_thread_t)context)->begin);\r
\r
/* restore the current context to the previously saved context */\r
current_context = self; \r
}\r
\r
static void\r
-xbt_thread_context_resume(xbt_context_t context)\r
+xbt_ctx_thread_resume(xbt_context_t context)\r
{\r
/* save the current context */\r
xbt_context_t self = current_context;\r
/* update the current context */\r
current_context = context;\r
\r
- xbt_os_sem_release(((xbt_thread_context_t)context)->begin); \r
- xbt_os_sem_acquire(((xbt_thread_context_t)context)->end);\r
+ xbt_os_sem_release(((xbt_ctx_thread_t)context)->begin); \r
+ xbt_os_sem_acquire(((xbt_ctx_thread_t)context)->end);\r
\r
/* restore the current context to the previously saved context */\r
current_context = self;\r