X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/03847b386b2035bec76237eab400aeaf07466496..ae4b6cc2c552e112d81d613060466b16f474dc67:/include/simgrid/simix.h

diff --git a/include/simgrid/simix.h b/include/simgrid/simix.h
index d28bcd87a9..982bedf5e2 100644
--- a/include/simgrid/simix.h
+++ b/include/simgrid/simix.h
@@ -19,6 +19,12 @@
 #ifdef __cplusplus
 
 namespace simgrid {
+namespace kernel {
+namespace context {
+  class Context;
+  class ContextFactory;
+}}
+
 namespace simix {
 
   /** @brief Process datatype
@@ -28,16 +34,14 @@ namespace simix {
       data</em>, executing in a <em>location</em>.
       \see m_process_management
     @{ */
-  class Process;
-  class Context;
-  class ContextFactory;
+  class ActorImpl;
   class Mutex;
   class Mailbox;
 }
 }
 
-typedef simgrid::simix::Context *smx_context_t;
-typedef simgrid::simix::Process *smx_process_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;
 
@@ -124,17 +128,17 @@ SG_BEGIN_DECL()
 
 XBT_PUBLIC(xbt_dynar_t) SIMIX_process_get_runnable();
 XBT_PUBLIC(smx_process_t) SIMIX_process_from_PID(int PID);
-XBT_PUBLIC(xbt_dynar_t) SIMIX_processes_as_dynar(void);
+XBT_PUBLIC(xbt_dynar_t) SIMIX_processes_as_dynar();
 
 /* parallelism */
-XBT_PUBLIC(int) SIMIX_context_is_parallel(void);
-XBT_PUBLIC(int) SIMIX_context_get_nthreads(void);
+XBT_PUBLIC(int) SIMIX_context_is_parallel();
+XBT_PUBLIC(int) SIMIX_context_get_nthreads();
 XBT_PUBLIC(void) SIMIX_context_set_nthreads(int nb_threads);
 XBT_PUBLIC(int) SIMIX_context_get_parallel_threshold();
 XBT_PUBLIC(void) SIMIX_context_set_parallel_threshold(int threshold);
-XBT_PUBLIC(e_xbt_parmap_mode_t) SIMIX_context_get_parallel_mode(void);
+XBT_PUBLIC(e_xbt_parmap_mode_t) SIMIX_context_get_parallel_mode();
 XBT_PUBLIC(void) SIMIX_context_set_parallel_mode(e_xbt_parmap_mode_t mode);
-XBT_PUBLIC(int) SIMIX_is_maestro(void);
+XBT_PUBLIC(int) SIMIX_is_maestro();
 
 
 /********************************** Global ************************************/
@@ -159,7 +163,7 @@ typedef struct s_smx_timer* smx_timer_t;
 
 XBT_PUBLIC(smx_timer_t) SIMIX_timer_set(double date, void (*function)(void*), void *arg);
 XBT_PUBLIC(void) SIMIX_timer_remove(smx_timer_t timer);
-XBT_PUBLIC(double) SIMIX_timer_next(void);
+XBT_PUBLIC(double) SIMIX_timer_next();
 XBT_PUBLIC(double) SIMIX_timer_get_date(smx_timer_t timer);
 
 XBT_PUBLIC(void) SIMIX_display_process_status();
@@ -171,7 +175,7 @@ XBT_PUBLIC(void) SIMIX_create_environment(const char *file);
 
 XBT_PUBLIC(void) SIMIX_function_register(const char *name, xbt_main_func_t code);
 XBT_PUBLIC(void) SIMIX_function_register_default(xbt_main_func_t code);
-XBT_PUBLIC(void) SIMIX_init_application(void);
+XBT_PUBLIC(void) SIMIX_init_application();
 XBT_PUBLIC(void) SIMIX_launch_application(const char *file);
 
 XBT_PUBLIC(void) SIMIX_process_set_function(const char* process_host,
@@ -199,21 +203,21 @@ XBT_PUBLIC(smx_process_t) SIMIX_process_attach(
 XBT_PUBLIC(void) SIMIX_process_detach();
 
 /*********************************** Host *************************************/
-XBT_PUBLIC(sg_host_t) SIMIX_host_self(void);
-XBT_PUBLIC(const char*) SIMIX_host_self_get_name(void);
+XBT_PUBLIC(sg_host_t) SIMIX_host_self();
+XBT_PUBLIC(const char*) SIMIX_host_self_get_name();
 XBT_PUBLIC(void) SIMIX_host_on(sg_host_t host);
 XBT_PUBLIC(void) SIMIX_host_off(sg_host_t host, smx_process_t issuer);
 XBT_PUBLIC(void) SIMIX_host_self_set_data(void *data);
-XBT_PUBLIC(void*) SIMIX_host_self_get_data(void);
+XBT_PUBLIC(void*) SIMIX_host_self_get_data();
 
 /********************************* Process ************************************/
 XBT_PUBLIC(smx_process_t) SIMIX_process_ref(smx_process_t process);
 XBT_PUBLIC(void) SIMIX_process_unref(smx_process_t process);
-XBT_PUBLIC(int) SIMIX_process_count(void);
-XBT_PUBLIC(smx_process_t) SIMIX_process_self(void);
-XBT_PUBLIC(const char*) SIMIX_process_self_get_name(void);
+XBT_PUBLIC(int) SIMIX_process_count();
+XBT_PUBLIC(smx_process_t) SIMIX_process_self();
+XBT_PUBLIC(const char*) SIMIX_process_self_get_name();
 XBT_PUBLIC(void) SIMIX_process_self_set_data(void *data);
-XBT_PUBLIC(void*) SIMIX_process_self_get_data(void);
+XBT_PUBLIC(void*) SIMIX_process_self_get_data();
 XBT_PUBLIC(smx_context_t) SIMIX_process_get_context(smx_process_t process);
 XBT_PUBLIC(void) SIMIX_process_set_context(smx_process_t p,smx_context_t c);
 XBT_PUBLIC(int) SIMIX_process_has_pending_comms(smx_process_t process);
@@ -221,14 +225,14 @@ XBT_PUBLIC(void) SIMIX_process_on_exit_runall(smx_process_t process);
 XBT_PUBLIC(void) SIMIX_process_on_exit(smx_process_t process, int_f_pvoid_pvoid_t fun, void *data);
 
 /****************************** Communication *********************************/
-XBT_PUBLIC(void) SIMIX_comm_set_copy_data_callback(void (*callback) (smx_synchro_t, void*, size_t));
-XBT_PUBLIC(void) SIMIX_comm_copy_pointer_callback(smx_synchro_t comm, void* buff, size_t buff_size);
-XBT_PUBLIC(void) SIMIX_comm_copy_buffer_callback(smx_synchro_t comm, void* buff, size_t buff_size);
+XBT_PUBLIC(void) SIMIX_comm_set_copy_data_callback(void (*callback) (smx_activity_t, void*, size_t));
+XBT_PUBLIC(void) SIMIX_comm_copy_pointer_callback(smx_activity_t comm, void* buff, size_t buff_size);
+XBT_PUBLIC(void) SIMIX_comm_copy_buffer_callback(smx_activity_t comm, void* buff, size_t buff_size);
 
-XBT_PUBLIC(smx_synchro_t) SIMIX_comm_get_send_match(smx_mailbox_t mbox, int (*match_fun)(void*, void*), void* data);
+XBT_PUBLIC(smx_activity_t) SIMIX_comm_get_send_match(smx_mailbox_t mbox, int (*match_fun)(void*, void*), void* data);
 XBT_PUBLIC(int) SIMIX_comm_has_send_match(smx_mailbox_t mbox, int (*match_fun)(void*, void*), void* data);
 XBT_PUBLIC(int) SIMIX_comm_has_recv_match(smx_mailbox_t mbox, int (*match_fun)(void*, void*), void* data);
-XBT_PUBLIC(void) SIMIX_comm_finish(smx_synchro_t synchro);
+XBT_PUBLIC(void) SIMIX_comm_finish(smx_activity_t synchro);
 
 /******************************************************************************/
 /*                            SIMIX simcalls                                  */
@@ -242,21 +246,21 @@ XBT_PUBLIC(void) simcall_call(smx_process_t process);
 /******************************* Host simcalls ********************************/
 XBT_PUBLIC(void) simcall_host_set_data(sg_host_t host, void *data);
 
-XBT_PUBLIC(smx_synchro_t) simcall_execution_start(const char *name,
+XBT_PUBLIC(smx_activity_t) simcall_execution_start(const char *name,
                                                 double flops_amount,
                                                 double priority, double bound, unsigned long affinity_mask);
-XBT_PUBLIC(smx_synchro_t) simcall_execution_parallel_start(const char *name,
+XBT_PUBLIC(smx_activity_t) simcall_execution_parallel_start(const char *name,
                                                      int host_nb,
                                                      sg_host_t *host_list,
                                                      double *flops_amount,
                                                      double *bytes_amount,
                                                      double amount,
                                                      double rate);
-XBT_PUBLIC(void) simcall_execution_cancel(smx_synchro_t execution);
-XBT_PUBLIC(void) simcall_execution_set_priority(smx_synchro_t execution, double priority);
-XBT_PUBLIC(void) simcall_execution_set_bound(smx_synchro_t execution, double bound);
-XBT_PUBLIC(void) simcall_execution_set_affinity(smx_synchro_t execution, sg_host_t host, unsigned long mask);
-XBT_PUBLIC(e_smx_state_t) simcall_execution_wait(smx_synchro_t execution);
+XBT_PUBLIC(void) simcall_execution_cancel(smx_activity_t execution);
+XBT_PUBLIC(void) simcall_execution_set_priority(smx_activity_t execution, double priority);
+XBT_PUBLIC(void) simcall_execution_set_bound(smx_activity_t execution, double bound);
+XBT_PUBLIC(void) simcall_execution_set_affinity(smx_activity_t execution, sg_host_t host, unsigned long mask);
+XBT_PUBLIC(e_smx_state_t) simcall_execution_wait(smx_activity_t execution);
 
 /******************************* VM simcalls ********************************/
 // Create the vm_workstation at the SURF level
@@ -297,12 +301,10 @@ XBT_PUBLIC(void) simcall_process_suspend(smx_process_t process);
 XBT_PUBLIC(void) simcall_process_resume(smx_process_t process);
 
 /* Getters and Setters */
-XBT_PUBLIC(int) simcall_process_count(void);
+XBT_PUBLIC(int) simcall_process_count();
 XBT_PUBLIC(void *) simcall_process_get_data(smx_process_t process);
 XBT_PUBLIC(void) simcall_process_set_data(smx_process_t process, void *data);
 XBT_PUBLIC(void) simcall_process_set_host(smx_process_t process, sg_host_t dest);
-XBT_PUBLIC(int) simcall_process_get_PID(smx_process_t process);
-XBT_PUBLIC(int) simcall_process_get_PPID(smx_process_t process);
 XBT_PUBLIC(int) simcall_process_is_suspended(smx_process_t process);
 XBT_PUBLIC(xbt_dict_t) simcall_process_get_properties(smx_process_t host);
 XBT_PUBLIC(void) simcall_process_set_kill_time(smx_process_t process, double kill_time);
@@ -325,60 +327,58 @@ XBT_PUBLIC(void) simcall_mbox_set_receiver(smx_mailbox_t mbox , smx_process_t pr
 XBT_PUBLIC(void) simcall_comm_send(smx_process_t sender, smx_mailbox_t mbox, double task_size,
                                      double rate, void *src_buff,
                                      size_t src_buff_size,
-                                     int (*match_fun)(void *, void *, smx_synchro_t),
-                                     void (*copy_data_fun)(smx_synchro_t, void*, size_t),
+                                     int (*match_fun)(void *, void *, smx_activity_t),
+                                     void (*copy_data_fun)(smx_activity_t, void*, size_t),
                                      void *data, double timeout);
 
-XBT_PUBLIC(smx_synchro_t) simcall_comm_isend(smx_process_t sender, smx_mailbox_t mbox,
+XBT_PUBLIC(smx_activity_t) simcall_comm_isend(smx_process_t sender, smx_mailbox_t mbox,
                                               double task_size,
                                               double rate, void *src_buff,
                                               size_t src_buff_size,
-                                              int (*match_fun)(void *, void *, smx_synchro_t),
+                                              int (*match_fun)(void *, void *, smx_activity_t),
                                               void (*clean_fun)(void *),
-                                              void (*copy_data_fun)(smx_synchro_t, void*, size_t),
+                                              void (*copy_data_fun)(smx_activity_t, void*, size_t),
                                               void *data, int detached);
 
 XBT_PUBLIC(void) simcall_comm_recv(smx_process_t receiver, smx_mailbox_t mbox, void *dst_buff,
                                    size_t * dst_buff_size,
-                                   int (*match_fun)(void *, void *, smx_synchro_t),
-                                   void (*copy_data_fun)(smx_synchro_t, void*, size_t),
+                                   int (*match_fun)(void *, void *, smx_activity_t),
+                                   void (*copy_data_fun)(smx_activity_t, void*, size_t),
                                    void *data, double timeout, double rate);
 
-XBT_PUBLIC(smx_synchro_t) simcall_comm_irecv(smx_process_t receiver, smx_mailbox_t mbox, void *dst_buff,
+XBT_PUBLIC(smx_activity_t) simcall_comm_irecv(smx_process_t receiver, smx_mailbox_t mbox, void *dst_buff,
                                             size_t * dst_buff_size,
-                                            int (*match_fun)(void *, void *, smx_synchro_t),
-                                            void (*copy_data_fun)(smx_synchro_t, void*, size_t),
+                                            int (*match_fun)(void *, void *, smx_activity_t),
+                                            void (*copy_data_fun)(smx_activity_t, void*, size_t),
                                             void *data, double rate);
 
-XBT_PUBLIC(smx_synchro_t) simcall_comm_iprobe(smx_mailbox_t mbox, int type, int src, int tag,
-                                int (*match_fun)(void *, void *, smx_synchro_t), void *data);
-XBT_PUBLIC(void) simcall_comm_cancel(smx_synchro_t comm);
+XBT_PUBLIC(smx_activity_t) simcall_comm_iprobe(smx_mailbox_t mbox, int type, int src, int tag,
+                                int (*match_fun)(void *, void *, smx_activity_t), void *data);
+XBT_PUBLIC(void) simcall_comm_cancel(smx_activity_t comm);
 
 /* FIXME: waitany is going to be a vararg function, and should take a timeout */
 XBT_PUBLIC(unsigned int) simcall_comm_waitany(xbt_dynar_t comms, double timeout);
-XBT_PUBLIC(void) simcall_comm_wait(smx_synchro_t comm, double timeout);
-XBT_PUBLIC(int) simcall_comm_test(smx_synchro_t comm);
-XBT_PUBLIC(int) simcall_comm_testany(smx_synchro_t* comms, size_t count);
+XBT_PUBLIC(void) simcall_comm_wait(smx_activity_t comm, double timeout);
+XBT_PUBLIC(int) simcall_comm_test(smx_activity_t comm);
+XBT_PUBLIC(int) simcall_comm_testany(smx_activity_t* comms, size_t count);
 
 /************************** Tracing handling **********************************/
-XBT_PUBLIC(void) simcall_set_category(smx_synchro_t synchro, const char *category);
+XBT_PUBLIC(void) simcall_set_category(smx_activity_t synchro, const char *category);
 
 /************************** Synchro simcalls **********************************/
-XBT_PUBLIC(smx_mutex_t) simcall_mutex_init(void);
+XBT_PUBLIC(smx_mutex_t) simcall_mutex_init();
 XBT_PUBLIC(smx_mutex_t) SIMIX_mutex_ref(smx_mutex_t mutex);
 XBT_PUBLIC(void) SIMIX_mutex_unref(smx_mutex_t mutex);
 XBT_PUBLIC(void) simcall_mutex_lock(smx_mutex_t mutex);
 XBT_PUBLIC(int) simcall_mutex_trylock(smx_mutex_t mutex);
 XBT_PUBLIC(void) simcall_mutex_unlock(smx_mutex_t mutex);
 
-XBT_PUBLIC(smx_cond_t) simcall_cond_init(void);
+XBT_PUBLIC(smx_cond_t) simcall_cond_init();
 XBT_PUBLIC(void) SIMIX_cond_unref(smx_cond_t cond);
 XBT_PUBLIC(smx_cond_t) SIMIX_cond_ref(smx_cond_t cond);
 XBT_PUBLIC(void) simcall_cond_signal(smx_cond_t cond);
 XBT_PUBLIC(void) simcall_cond_wait(smx_cond_t cond, smx_mutex_t mutex);
-XBT_PUBLIC(void) simcall_cond_wait_timeout(smx_cond_t cond,
-                                         smx_mutex_t mutex,
-                                         double max_duration);
+XBT_PUBLIC(void) simcall_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double max_duration);
 XBT_PUBLIC(void) simcall_cond_broadcast(smx_cond_t cond);
 
 XBT_PUBLIC(smx_sem_t) simcall_sem_init(int capacity);
@@ -386,8 +386,7 @@ XBT_PUBLIC(void) SIMIX_sem_destroy(smx_sem_t sem);
 XBT_PUBLIC(void) simcall_sem_release(smx_sem_t sem);
 XBT_PUBLIC(int) simcall_sem_would_block(smx_sem_t sem);
 XBT_PUBLIC(void) simcall_sem_acquire(smx_sem_t sem);
-XBT_PUBLIC(void) simcall_sem_acquire_timeout(smx_sem_t sem,
-                                             double max_duration);
+XBT_PUBLIC(void) simcall_sem_acquire_timeout(smx_sem_t sem, double max_duration);
 XBT_PUBLIC(int) simcall_sem_get_capacity(smx_sem_t sem);
 
 /*****************************   File   **********************************/