Try to fixup the context mess

git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@5335 48e7efb5-ca39-0410-a469-dd3cf9ba447f

diff --git a/src/java/jmsg.c b/src/java/jmsg.c
index e1f2dcf..e74aec4 100644 (file)
--- a/src/java/jmsg.c
+++ b/src/java/jmsg.c
@@ -12,8 +12,7 @@
 #include "msg/msg.h"
 #include "msg/private.h"
 #include "simix/private.h"
 #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"
 
 #include "jmsg_process.h"
 #include "jmsg_host.h"


@@ -49,7 +48,7 @@ get_current_thread_env(void) {
 static jobject
 native_to_java_process(m_process_t process)
 {
 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;     

 }
 
 
 }
 
 

diff --git a/src/java/jmsg_process.c b/src/java/jmsg_process.c
index 4121efd..2fb7ecf 100644 (file)
--- a/src/java/jmsg_process.c
+++ b/src/java/jmsg_process.c
@@ -14,7 +14,7 @@
 #include "jmsg.h"
 #include "jxbt_utilities.h"
 
 #include "jmsg.h"
 #include "jxbt_utilities.h"
 

-#include "xbt/xbt_jcontext.h"
+#include "xbt/xbt_context_java.h"

 
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(jmsg);
 
 
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(jmsg);
 


@@ -188,7 +188,7 @@ jprocess_schedule(xbt_context_t context) {
        if(!id)
                return;
        
        if(!id)
                return;
        

-       (*env)->CallVoidMethod(env,((xbt_jcontext_t)context)->jprocess,id);
+       (*env)->CallVoidMethod(env,((xbt_ctx_java_t)context)->jprocess,id);

 }
 
 
 }
 
 


@@ -206,6 +206,6 @@ jprocess_unschedule(xbt_context_t context) {
        if(!id)
                return;
        
        if(!id)
                return;
        

-       (*env)->CallVoidMethod(env,((xbt_jcontext_t)context)->jprocess,id);
+       (*env)->CallVoidMethod(env,((xbt_ctx_java_t)context)->jprocess,id);

 }
 
 }
 

diff --git a/src/xbt/xbt_context_factory.h b/src/xbt/xbt_context_factory.h
deleted file mode 100644 (file)
index 7ad0ad0..0000000
--- a/src/xbt/xbt_context_factory.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#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

diff --git a/src/xbt/xbt_context_java.c b/src/xbt/xbt_context_java.c
index 8b2516b..bf75e6d 100644 (file)
--- a/src/xbt/xbt_context_java.c
+++ b/src/xbt/xbt_context_java.c
@@ -2,7 +2,7 @@
 \r
 #include "xbt/function_types.h"\r
 #include "xbt/ex_interface.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
 #include "xbt/xbt_context_java.h"\r
 \r
 XBT_LOG_NEW_DEFAULT_CATEGORY(jmsg,"MSG for Java(TM)");\r

diff --git a/src/xbt/xbt_context_java.h b/src/xbt/xbt_context_java.h
index a817ec2..9760e04 100644 (file)
--- a/src/xbt/xbt_context_java.h
+++ b/src/xbt/xbt_context_java.h
@@ -1,5 +1,5 @@
-#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
 #include "portable.h"\r
 #include "xbt/misc.h"\r


@@ -10,13 +10,13 @@
 \r
 SG_BEGIN_DECL()\r
 \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
 {\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
 \r
 SG_END_DECL()\r
 \r

-#endif /* !_XBT_JCONTEXT_H */\r
+#endif /* !_XBT_CONTEXT_JAVA_H */\r

diff --git a/src/xbt/xbt_context_private.h b/src/xbt/xbt_context_private.h
index b073653..bf01c28 100644 (file)
--- a/src/xbt/xbt_context_private.h
+++ b/src/xbt/xbt_context_private.h
@@ -7,16 +7,19 @@
 \r
 SG_BEGIN_DECL()\r
 \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
 /* 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_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_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
 \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
 #define XBT_CTX_BASE_T \\r
        s_xbt_swag_hookup_t hookup; \\r
        char *name; \\r


@@ -36,11 +39,14 @@ typedef void (*xbt_pfn_context_stop_t)(int);                                /* pointer type to the function
        xbt_pfn_context_start_t start; \\r
        xbt_pfn_context_stop_t stop                             \r
 \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
        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
 \r
 /* Important guys */\r
 extern xbt_context_t current_context;\r


@@ -49,13 +55,53 @@ extern xbt_context_t maestro_context;
 extern xbt_swag_t context_living;\r
 extern xbt_swag_t context_to_destroy;\r
 \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
 \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
 \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
 \r
 SG_END_DECL()\r

diff --git a/src/xbt/xbt_ucontext.c b/src/xbt/xbt_context_sysv.c
similarity index 56%
rename from src/xbt/xbt_ucontext.c
rename to src/xbt/xbt_context_sysv.c
index 638edc6..9295621 100644 (file)
--- a/src/xbt/xbt_ucontext.c
+++ b/src/xbt/xbt_context_sysv.c
@@ -1,18 +1,18 @@
 \r
 \r

-#include "ucontext_stack.h"\r

 #include "xbt/ex_interface.h"\r
 #include "xbt/ex_interface.h"\r

-#include "xbt/xbt_context_factory.h"\r
+#include "xbt/xbt_context_private.h"\r

 \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
 #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
    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
 \r
 \r
 /* callback: context fetching */\r


@@ -24,59 +24,59 @@ static void
 xbt_jcontext_ex_terminate(xbt_ex_t *e);\r
 \r
 static xbt_context_t \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
 \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
 \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
 \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
 \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
 \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
 \r
 static void \r

-xbt_ucontext_yield(void);\r
+xbt_ctx_sysv_yield(void);\r

 \r
 static 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
 \r
 static void \r

-xbt_ucontext_stop(int exit_code);\r
+xbt_ctx_sysv_stop(int exit_code);\r

 \r
 static void \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
 \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
 \r
 static void\r

-xbt_ucontext_yield(void);\r
+xbt_ctx_sysv_yield(void);\r

 \r
 static 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
 \r
 static void\r

-xbt_ucontext_resume(xbt_context_t context);\r
+xbt_ctx_sysv_resume(xbt_context_t context);\r

 \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
 \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
 {\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
        xbt_ex_display(e);\r
        abort();\r


@@ -84,28 +84,28 @@ xbt_ucontext_ex_terminate(xbt_ex_t *e)
 \r
 \r
 int\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
 {\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
        \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
     \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
 {\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
        context->exception = xbt_new(ex_ctx_t,1);\r
     XBT_CTX_INITIALIZE(context->exception);\r


@@ -118,7 +118,7 @@ xbt_ucontext_factory_create_maestro_context(xbt_context_t* maestro)
 \r
 \r
 static int\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
        free(maestro_context->exception);\r
        free(*factory);\r


@@ -127,9 +127,9 @@ xbt_ucontext_factory_finalize(xbt_context_factory_t* factory)
 }\r
 \r
 static xbt_context_t \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
 {\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
        \r
        context->code = code;\r
        context->name = xbt_strdup(name);\r


@@ -150,18 +150,18 @@ xbt_ucontext_factory_create_context(const char* name, xbt_main_func_t code, void
        context->cleanup_arg = cleanup_arg;\r
        \r
        \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
        \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
        if(context)\r
        {\r


@@ -187,10 +187,10 @@ xbt_ucontext_free(xbt_context_t context)
 }\r
 \r
 static void \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
 {\r
        context->iwannadie = 1;\r

-       xbt_ucontext_swap(context);\r
+       xbt_ctx_sysv_swap(context);\r

 }\r
 \r
 /** \r
 }\r
 \r
 /** \r


@@ -203,10 +203,10 @@ xbt_ucontext_kill(xbt_context_t context)
  * Only the maestro can call this function to run a given process.\r
  */\r
 static void \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
 {\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
 }\r
 \r
 /** \r


@@ -218,20 +218,20 @@ xbt_ucontext_schedule(xbt_context_t context)
  * to the maestro\r
  */\r
 static void \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
 {\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
 }\r
 \r
 static void \r

-xbt_ucontext_start(xbt_context_t context)\r
+xbt_ctx_sysv_start(xbt_context_t context)\r

 {\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
 }\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
 {\r
        if(current_context->cleanup_func) \r
                ((*current_context->cleanup_func))(current_context->cleanup_arg);\r


@@ -239,59 +239,59 @@ xbt_ucontext_stop(int exit_code)
        xbt_swag_remove(current_context, context_living);\r
        xbt_swag_insert(current_context, context_to_destroy);   \r
        \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
 }\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
 {\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
        else \r

-               xbt_ucontext_suspend(context);\r
+               xbt_ctx_sysv_suspend(context);\r

        \r
        if(current_context->iwannadie)\r
        \r
        if(current_context->iwannadie)\r

-               xbt_ucontext_stop(1);\r
+               xbt_ctx_sysv_stop(1);\r

 }\r
 \r
 static void\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
 {\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
 }\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
 {\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
        \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
        \r

-       ((xbt_ucontext_t)context)->prev = NULL;\r
+       ((xbt_ctx_sysv_t)context)->prev = NULL;\r

        \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
                \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
 {\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
        \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
        xbt_assert0((rv == 0), "Context swapping failure");\r
 }\r

diff --git a/src/xbt/xbt_thread_context.c b/src/xbt/xbt_context_thread.c
similarity index 55%
rename from src/xbt/xbt_thread_context.c
rename to src/xbt/xbt_context_thread.c
index 60e6b26..e39ff91 100644 (file)
--- a/src/xbt/xbt_thread_context.c
+++ b/src/xbt/xbt_context_thread.c
@@ -1,87 +1,87 @@
 \r
 #include "xbt/function_types.h"\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
 \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
        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
 \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
 \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
 \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
 \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
 \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
 \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
 \r
 static void \r

-xbt_thread_context_yield(void);\r
+xbt_ctx_thread_yield(void);\r

 \r
 static 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
 \r
 static void \r

-xbt_thread_context_stop(int exit_code);\r
+xbt_ctx_thread_stop(int exit_code);\r

 \r
 static void \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
 \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
 \r
 static void\r

-xbt_thread_context_yield(void);\r
+xbt_ctx_thread_yield(void);\r

 \r
 static 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
 \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
 \r
 static void* \r

-xbt_thread_context_wrapper(void* param);\r
+xbt_ctx_thread_wrapper(void* param);\r

 \r
 int\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
 {\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
 \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
 {\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
     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
        free(*factory);\r
        *factory = NULL;\r


@@ -89,9 +89,9 @@ xbt_thread_context_factory_finalize(xbt_context_factory_t* factory)
 }\r
 \r
 static xbt_context_t \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
 {\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
        \r
        context->code = code;\r
        context->name = xbt_strdup(name);\r


@@ -105,42 +105,42 @@ xbt_thread_context_factory_create_context(const char* name, xbt_main_func_t code
        context->cleanup_func = cleanup_func;\r
        context->cleanup_arg = cleanup_arg;\r
        \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
        \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
 {\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
                \r

-               free(thread_context->name);\r
+               free(ctx_thread->name);\r

                \r
                \r

-               if(thread_context->argv)\r
+               if(ctx_thread->argv)\r

                {\r
                        int i;\r
                        \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
                                        \r

-                       free(thread_context->argv);\r
+                       free(ctx_thread->argv);\r

                }\r
                \r
                /* wait about the thread terminason */\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
                \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
                /* finally destroy the context */\r
                free(context);\r


@@ -148,10 +148,10 @@ xbt_thread_context_free(xbt_context_t context)
 }\r
 \r
 static void \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
 {\r
        context->iwannadie = 1;\r

-       xbt_thread_context_swap(context);\r
+       xbt_ctx_thread_swap(context);\r

 }\r
 \r
 /** \r
 }\r
 \r
 /** \r


@@ -164,10 +164,10 @@ xbt_thread_context_kill(xbt_context_t context)
  * Only the maestro can call this function to run a given process.\r
  */\r
 static void \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
 {\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
 }\r
 \r
 /** \r


@@ -179,26 +179,26 @@ xbt_thread_context_schedule(xbt_context_t context)
  * to the maestro\r
  */\r
 static void \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
 {\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
 }\r
 \r
 static void \r

-xbt_thread_context_start(xbt_context_t context)\r
+xbt_ctx_thread_start(xbt_context_t context)\r

 {\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
        \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
        \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
 }\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
 {\r
        if(current_context->cleanup_func) \r
                ((*current_context->cleanup_func))(current_context->cleanup_arg);\r


@@ -207,21 +207,21 @@ xbt_thread_context_stop(int exit_code)
        xbt_swag_insert(current_context, context_to_destroy);   \r
 \r
        /* signal to the maestro that it has finished */\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
        \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
 {\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
        }\r
        else\r
        {\r


@@ -249,19 +249,19 @@ xbt_thread_context_swap(xbt_context_t context)
                 *                                      -> goto (3.1)\r
                 */\r
                /* schedule the process associated with this context */\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
        \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
 }\r
 \r
 static void* \r

-xbt_thread_context_wrapper(void* param)\r
+xbt_ctx_thread_wrapper(void* param)\r

 {\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
        \r
        /* Tell the maestro we are starting, and wait for its green light */\r
        xbt_os_sem_release(context->end);               \r


@@ -271,12 +271,12 @@ xbt_thread_context_wrapper(void* param)
                (*(context->startup_func))(context->startup_arg);\r
        \r
        \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
        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
 {\r
        /* save the current context */\r
        xbt_context_t self = current_context;\r


@@ -284,15 +284,15 @@ xbt_thread_context_suspend(xbt_context_t context)
        /* update the current context to this context */\r
        current_context = context;\r
        \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
        \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
 {\r
        /* save the current context */\r
        xbt_context_t self = current_context;\r


@@ -300,8 +300,8 @@ xbt_thread_context_resume(xbt_context_t context)
        /* update the current context */\r
        current_context = context;\r
        \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
        \r
        /* restore the current context to the previously saved context */\r
        current_context = self;\r