[simix] Add comments about the generic simcalls and rename them

diff --git a/ChangeLog b/ChangeLog
index 5d6e12c..bec4c08 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -111,7 +111,7 @@ SimGrid (3.13) stable; urgency=low
    include/simgrid/simdag.h
 
  Simix
    include/simgrid/simdag.h
 
  Simix

- * simgrid::simix::kernel() is the closure callback. It ensures that
+ * simgrid::simix::kernelImmediate() is the closure callback. It ensures that

     the lambda or closure passed as a parameter will run in kernel mode.
    All the callback functions should be rewritten to that interface at some point.
 
     the lambda or closure passed as a parameter will run in kernel mode.
    All the callback functions should be rewritten to that interface at some point.
 

diff --git a/include/simgrid/kernel/future.hpp b/include/simgrid/kernel/future.hpp
index a99a155..c58f46b 100644 (file)
--- a/include/simgrid/kernel/future.hpp
+++ b/include/simgrid/kernel/future.hpp
@@ -235,9 +235,20 @@ public:
   }
 };
 
   }
 };
 

-/** Result of some (possibly ongoing, asynchronous) operation in the SimGrid kernel
+/** Result of some (probably) asynchronous operation in the SimGrid kernel

  *
  *

- *  As the operation may not be completed yet, the result might be an exception.
+ * @ref simgrid::simix::Future and @ref simgrid::simix::Future provide an
+ * abstration for asynchronous stuff happening in the SimGrid kernel. They
+ * are based on C++1z futures.
+ *
+ * The future represents a value which will be available at some point when this
+ * asynchronous operaiont is finished. Alternatively, if this operations fails,
+ * the result of the operation might be an exception.
+ *
+ *  As the operation is possibly no terminated yet, we cannot get the result
+ *  yet. Moreover, as we cannot block in the SimGrid kernel we cannot wait for
+ *  it. However, we can attach some code/callback/continuation which will be
+ *  executed when the operation terminates.

  *
  *  Example of the API (`simgrid::kernel::createProcess` does not exist):
  *  <pre>
  *
  *  Example of the API (`simgrid::kernel::createProcess` does not exist):
  *  <pre>

diff --git a/include/simgrid/simix.hpp b/include/simgrid/simix.hpp
index ad48794..99d2410 100644 (file)
--- a/include/simgrid/simix.hpp
+++ b/include/simgrid/simix.hpp
@@ -21,6 +21,16 @@
 #include <simgrid/simix.h>
 
 XBT_PUBLIC(void) simcall_run_kernel(std::function<void()> const& code);
 #include <simgrid/simix.h>
 
 XBT_PUBLIC(void) simcall_run_kernel(std::function<void()> const& code);

+
+/** Execute some code in the kernel and block
+ *
+ * run_blocking() is a generic blocking simcall. It is given a callback
+ * which is executed immediately in the SimGrid kernel. The callback is
+ * responsible for setting the suitable logic for waking up the process
+ * when needed.
+ *
+ * @ref simix::kernelSync() is a higher level wrapper for this.
+ */

 XBT_PUBLIC(void) simcall_run_blocking(std::function<void()> const& code);
 
 template<class F> inline
 XBT_PUBLIC(void) simcall_run_blocking(std::function<void()> const& code);
 
 template<class F> inline


@@ -45,7 +55,7 @@ namespace simix {
  *  of the operation with respect to other simcalls.
  */
 template<class F>
  *  of the operation with respect to other simcalls.
  */
 template<class F>

-typename std::result_of<F()>::type kernel(F&& code)
+typename std::result_of<F()>::type kernelImmediate(F&& code)

 {
   // If we are in the maestro, we take the fast path and execute the
   // code directly without simcall mashalling/unmarshalling/dispatch:
 {
   // If we are in the maestro, we take the fast path and execute the
   // code directly without simcall mashalling/unmarshalling/dispatch:

diff --git a/include/simgrid/simix/blocking_simcall.hpp b/include/simgrid/simix/blocking_simcall.hpp
index 59f688c..ee12510 100644 (file)
--- a/include/simgrid/simix/blocking_simcall.hpp
+++ b/include/simgrid/simix/blocking_simcall.hpp
@@ -30,21 +30,22 @@ XBT_PUBLIC(void) unblock(smx_process_t process);
 /** Execute some code in kernel mode and wakes up the process when
  *  the result is available.
  *
 /** Execute some code in kernel mode and wakes up the process when
  *  the result is available.
  *

- *  The code given is executed in SimGrid kernel and expected to return
- *  a `simgrid::kernel::Future`. The current process is resumed whenever
- *  the Future becomes ready and gets the value or exception of the future:
+ * It is given a callback which is executed in the kernel SimGrid and
+ * returns a simgrid::kernel::Future<T>. The kernel blocks the process
+ * until the Future is ready and either the value wrapped in the future
+ * to the process or raises the exception stored in the Future in the process.

  *
  *

- *  This can be used to implement blocking calls in without adding new simcalls.
- *  One downside of this approach is that we don't have any semantic on what
- *  the process is waiting. This might be a problem for the model-checker and
- *  we'll have to device a way to make it work.
+ * This can be used to implement blocking calls without adding new simcalls.
+ * One downside of this approach is that we don't have any semantic on what
+ * the process is waiting. This might be a problem for the model-checker and
+ * we'll have to devise a way to make it work.

  *
  *

- *  @param     code Kernel code returning a `simgrid::kernel::Future<T>`
- *  @return         Value of the kernel future
- *  @exception      Exception from the kernel future
+ * @param     code Kernel code returning a `simgrid::kernel::Future<T>`
+ * @return         Value of the kernel future
+ * @exception      Exception from the kernel future

  */
 template<class F>
  */
 template<class F>

-auto blocking_simcall(F code) -> decltype(code().get())
+auto kernelSync(F code) -> decltype(code().get())

 {
   typedef decltype(code().get()) T;
   if (SIMIX_is_maestro())
 {
   typedef decltype(code().get()) T;
   if (SIMIX_is_maestro())


@@ -113,14 +114,14 @@ private:
  *  @return     User future
  */
 template<class F>
  *  @return     User future
  */
 template<class F>

-auto asynchronous_simcall(F code)
+auto kernelAsync(F code)

   -> Future<decltype(code().get())>
 {
   typedef decltype(code().get()) T;
 
   // Execute the code in the kernel and get the kernel simcall:
   simgrid::kernel::Future<T> future =
   -> Future<decltype(code().get())>
 {
   typedef decltype(code().get()) T;
 
   // Execute the code in the kernel and get the kernel simcall:
   simgrid::kernel::Future<T> future =

-    simgrid::simix::kernel(std::move(code));
+    simgrid::simix::kernelImmediate(std::move(code));

 
   // Wrap tyhe kernel simcall in a user simcall:
   return simgrid::simix::Future<T>(std::move(future));
 
   // Wrap tyhe kernel simcall in a user simcall:
   return simgrid::simix::Future<T>(std::move(future));

diff --git a/include/xbt/future.hpp b/include/xbt/future.hpp
index b7e52e0..aa559db 100644 (file)
--- a/include/xbt/future.hpp
+++ b/include/xbt/future.hpp
@@ -15,6 +15,8 @@
 
 #include <type_traits>
 
 
 #include <type_traits>
 

+
+

 namespace simgrid {
 namespace xbt {
 
 namespace simgrid {
 namespace xbt {
 

diff --git a/src/s4u/s4u_host.cpp b/src/s4u/s4u_host.cpp
index 7bd578d..9c3b420 100644 (file)
--- a/src/s4u/s4u_host.cpp
+++ b/src/s4u/s4u_host.cpp
@@ -76,11 +76,11 @@ Host *Host::current(){
 }
 
 void Host::turnOn() {
 }
 
 void Host::turnOn() {

-  simgrid::simix::kernel(std::bind(SIMIX_host_on, this));
+  simgrid::simix::kernelImmediate(std::bind(SIMIX_host_on, this));

 }
 
 void Host::turnOff() {
 }
 
 void Host::turnOff() {

-  simgrid::simix::kernel(std::bind(SIMIX_host_off, this, SIMIX_process_self()));
+  simgrid::simix::kernelImmediate(std::bind(SIMIX_host_off, this, SIMIX_process_self()));

 }
 
 bool Host::isOn() {
 }
 
 bool Host::isOn() {


@@ -111,7 +111,7 @@ boost::unordered_map<std::string, Storage*> const& Host::mountedStorages() {
 
 /** Get the properties assigned to a host */
 xbt_dict_t Host::properties() {
 
 /** Get the properties assigned to a host */
 xbt_dict_t Host::properties() {

-  return simgrid::simix::kernel([&] {
+  return simgrid::simix::kernelImmediate([&] {

     simgrid::surf::HostImpl* surf_host = this->extension<simgrid::surf::HostImpl>();
     return surf_host->getProperties();
   });
     simgrid::surf::HostImpl* surf_host = this->extension<simgrid::surf::HostImpl>();
     return surf_host->getProperties();
   });


@@ -123,7 +123,7 @@ const char*Host::property(const char*key) {
   return surf_host->getProperty(key);
 }
 void Host::setProperty(const char*key, const char *value){
   return surf_host->getProperty(key);
 }
 void Host::setProperty(const char*key, const char *value){

-  simgrid::simix::kernel([&] {
+  simgrid::simix::kernelImmediate([&] {

     simgrid::surf::HostImpl* surf_host = this->extension<simgrid::surf::HostImpl>();
     surf_host->setProperty(key,value);
   });
     simgrid::surf::HostImpl* surf_host = this->extension<simgrid::surf::HostImpl>();
     surf_host->setProperty(key,value);
   });


@@ -132,7 +132,7 @@ void Host::setProperty(const char*key, const char *value){
 /** Get the processes attached to the host */
 xbt_swag_t Host::processes()
 {
 /** Get the processes attached to the host */
 xbt_swag_t Host::processes()
 {

-  return simgrid::simix::kernel([&]() {
+  return simgrid::simix::kernelImmediate([&]() {

     return ((smx_host_priv_t)this->extension(SIMIX_HOST_LEVEL))->process_list;
   });
 }
     return ((smx_host_priv_t)this->extension(SIMIX_HOST_LEVEL))->process_list;
   });
 }


@@ -140,7 +140,7 @@ xbt_swag_t Host::processes()
 /** Get the peak power of a host */
 double Host::getPstateSpeedCurrent()
 {
 /** Get the peak power of a host */
 double Host::getPstateSpeedCurrent()
 {

-  return simgrid::simix::kernel([&] {
+  return simgrid::simix::kernelImmediate([&] {

     return this->pimpl_cpu->getPstateSpeedCurrent();
   });
 }
     return this->pimpl_cpu->getPstateSpeedCurrent();
   });
 }


@@ -148,7 +148,7 @@ double Host::getPstateSpeedCurrent()
 /** Get one power peak (in flops/s) of a host at a given pstate */
 double Host::getPstateSpeed(int pstate_index)
 {
 /** Get one power peak (in flops/s) of a host at a given pstate */
 double Host::getPstateSpeed(int pstate_index)
 {

-  return simgrid::simix::kernel([&] {
+  return simgrid::simix::kernelImmediate([&] {

     return this->pimpl_cpu->getPstateSpeed(pstate_index);
   });
 }
     return this->pimpl_cpu->getPstateSpeed(pstate_index);
   });
 }


@@ -165,7 +165,7 @@ int Host::coresCount() {
 /** @brief Set the pstate at which the host should run */
 void Host::setPstate(int pstate_index)
 {
 /** @brief Set the pstate at which the host should run */
 void Host::setPstate(int pstate_index)
 {

-  simgrid::simix::kernel(std::bind(
+  simgrid::simix::kernelImmediate(std::bind(

       &simgrid::surf::Cpu::setPState, pimpl_cpu, pstate_index
   ));
 }
       &simgrid::surf::Cpu::setPState, pimpl_cpu, pstate_index
   ));
 }


@@ -177,14 +177,14 @@ int Host::pstate()
 
 void Host::parameters(vm_params_t params)
 {
 
 void Host::parameters(vm_params_t params)
 {

-  simgrid::simix::kernel([&]() {
+  simgrid::simix::kernelImmediate([&]() {

     this->extension<simgrid::surf::HostImpl>()->getParams(params);
   });
 }
 
 void Host::setParameters(vm_params_t params)
 {
     this->extension<simgrid::surf::HostImpl>()->getParams(params);
   });
 }
 
 void Host::setParameters(vm_params_t params)
 {

-  simgrid::simix::kernel([&]() {
+  simgrid::simix::kernelImmediate([&]() {

     this->extension<simgrid::surf::HostImpl>()->setParams(params);
   });
 }
     this->extension<simgrid::surf::HostImpl>()->setParams(params);
   });
 }


@@ -196,7 +196,7 @@ void Host::setParameters(vm_params_t params)
  */
 xbt_dict_t Host::mountedStoragesAsDict()
 {
  */
 xbt_dict_t Host::mountedStoragesAsDict()
 {

-  return simgrid::simix::kernel([&] {
+  return simgrid::simix::kernelImmediate([&] {

     return this->extension<simgrid::surf::HostImpl>()->getMountedStorageList();
   });
 }
     return this->extension<simgrid::surf::HostImpl>()->getMountedStorageList();
   });
 }


@@ -208,7 +208,7 @@ xbt_dict_t Host::mountedStoragesAsDict()
  */
 xbt_dynar_t Host::attachedStorages()
 {
  */
 xbt_dynar_t Host::attachedStorages()
 {

-  return simgrid::simix::kernel([&] {
+  return simgrid::simix::kernelImmediate([&] {

     return this->extension<simgrid::surf::HostImpl>()->getAttachedStorageList();
   });
 }
     return this->extension<simgrid::surf::HostImpl>()->getAttachedStorageList();
   });
 }

diff --git a/src/simix/libsmx.cpp b/src/simix/libsmx.cpp
index e91ebb8..be3b661 100644 (file)
--- a/src/simix/libsmx.cpp
+++ b/src/simix/libsmx.cpp
@@ -206,7 +206,7 @@ e_smx_state_t simcall_execution_wait(smx_synchro_t execution)
  */
 void* simcall_vm_create(const char *name, sg_host_t phys_host)
 {
  */
 void* simcall_vm_create(const char *name, sg_host_t phys_host)
 {

-  return simgrid::simix::kernel(std::bind(SIMIX_vm_create, name, phys_host));
+  return simgrid::simix::kernelImmediate(std::bind(SIMIX_vm_create, name, phys_host));

 }
 
 /**
 }
 
 /**


@@ -217,7 +217,7 @@ void* simcall_vm_create(const char *name, sg_host_t phys_host)
  */
 void simcall_vm_start(sg_host_t vm)
 {
  */
 void simcall_vm_start(sg_host_t vm)
 {

-  return simgrid::simix::kernel(std::bind(SIMIX_vm_start, vm));
+  return simgrid::simix::kernelImmediate(std::bind(SIMIX_vm_start, vm));

 }
 
 /**
 }
 
 /**


@@ -229,7 +229,7 @@ void simcall_vm_start(sg_host_t vm)
  */
 int simcall_vm_get_state(sg_host_t vm)
 {
  */
 int simcall_vm_get_state(sg_host_t vm)
 {

-  return simgrid::simix::kernel(std::bind(SIMIX_vm_get_state, vm));
+  return simgrid::simix::kernelImmediate(std::bind(SIMIX_vm_get_state, vm));

 }
 
 /**
 }
 
 /**


@@ -241,17 +241,17 @@ int simcall_vm_get_state(sg_host_t vm)
  */
 void *simcall_vm_get_pm(sg_host_t vm)
 {
  */
 void *simcall_vm_get_pm(sg_host_t vm)
 {

-  return simgrid::simix::kernel(std::bind(SIMIX_vm_get_pm, vm));
+  return simgrid::simix::kernelImmediate(std::bind(SIMIX_vm_get_pm, vm));

 }
 
 void simcall_vm_set_bound(sg_host_t vm, double bound)
 {
 }
 
 void simcall_vm_set_bound(sg_host_t vm, double bound)
 {

-  simgrid::simix::kernel(std::bind(SIMIX_vm_set_bound, vm, bound));
+  simgrid::simix::kernelImmediate(std::bind(SIMIX_vm_set_bound, vm, bound));

 }
 
 void simcall_vm_set_affinity(sg_host_t vm, sg_host_t pm, unsigned long mask)
 {
 }
 
 void simcall_vm_set_affinity(sg_host_t vm, sg_host_t pm, unsigned long mask)
 {

-  simgrid::simix::kernel(std::bind(SIMIX_vm_set_affinity, vm, pm, mask));
+  simgrid::simix::kernelImmediate(std::bind(SIMIX_vm_set_affinity, vm, pm, mask));

 }
 
 /**
 }
 
 /**


@@ -263,7 +263,7 @@ void simcall_vm_set_affinity(sg_host_t vm, sg_host_t pm, unsigned long mask)
  */
 void simcall_vm_migrate(sg_host_t vm, sg_host_t host)
 {
  */
 void simcall_vm_migrate(sg_host_t vm, sg_host_t host)
 {

-  return simgrid::simix::kernel(std::bind(SIMIX_vm_migrate, vm, host));
+  return simgrid::simix::kernelImmediate(std::bind(SIMIX_vm_migrate, vm, host));

 }
 
 /**
 }
 
 /**


@@ -329,7 +329,7 @@ void simcall_vm_shutdown(sg_host_t vm)
  */
 void simcall_vm_destroy(sg_host_t vm)
 {
  */
 void simcall_vm_destroy(sg_host_t vm)
 {

-  simgrid::simix::kernel(std::bind(SIMIX_vm_destroy, vm));
+  simgrid::simix::kernelImmediate(std::bind(SIMIX_vm_destroy, vm));

 }
 
 /**
 }
 
 /**


@@ -348,7 +348,7 @@ void simcall_vm_destroy(sg_host_t vm)
  */
 void simcall_vm_migratefrom_resumeto(sg_host_t vm, sg_host_t src_pm, sg_host_t dst_pm)
 {
  */
 void simcall_vm_migratefrom_resumeto(sg_host_t vm, sg_host_t src_pm, sg_host_t dst_pm)
 {

-  simgrid::simix::kernel(std::bind(
+  simgrid::simix::kernelImmediate(std::bind(

     SIMIX_vm_migratefrom_resumeto, vm, src_pm, dst_pm));
 }
 
     SIMIX_vm_migratefrom_resumeto, vm, src_pm, dst_pm));
 }
 


@@ -441,7 +441,7 @@ void simcall_process_resume(smx_process_t process)
  */
 int simcall_process_count(void)
 {
  */
 int simcall_process_count(void)
 {

-  return simgrid::simix::kernel(SIMIX_process_count);
+  return simgrid::simix::kernelImmediate(SIMIX_process_count);

 }
 
 /**
 }
 
 /**


@@ -487,7 +487,7 @@ void* simcall_process_get_data(smx_process_t process)
  */
 void simcall_process_set_data(smx_process_t process, void *data)
 {
  */
 void simcall_process_set_data(smx_process_t process, void *data)
 {

-  simgrid::simix::kernel(std::bind(SIMIX_process_set_data, process, data));
+  simgrid::simix::kernelImmediate(std::bind(SIMIX_process_set_data, process, data));

 }
 
 /**
 }
 
 /**


@@ -757,7 +757,7 @@ smx_synchro_t simcall_comm_iprobe(smx_mailbox_t mbox, int type, int src, int tag
  */
 void simcall_comm_cancel(smx_synchro_t synchro)
 {
  */
 void simcall_comm_cancel(smx_synchro_t synchro)
 {

-  simgrid::simix::kernel([synchro]{
+  simgrid::simix::kernelImmediate([synchro]{

     simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
     comm->cancel();
   });
     simgrid::simix::Comm *comm = static_cast<simgrid::simix::Comm*>(synchro);
     comm->cancel();
   });

diff --git a/src/simix/popping.cpp b/src/simix/popping.cpp
index d5cabef..70a30d2 100644 (file)
--- a/src/simix/popping.cpp
+++ b/src/simix/popping.cpp
@@ -47,7 +47,7 @@ void SIMIX_run_kernel(std::function<void()> const* code)
 
 /** Kernel code for run_blocking
  *
 
 /** Kernel code for run_blocking
  *

- * This looks a lot like SIMIX_run_kernel ^^
+ * The implementtion looks a lot like SIMIX_run_kernel ^^

  *
  * However, this `run_blocking` is blocking so the process will not be woken
  * up until `SIMIX_simcall_answer(simcall)`` is called by the kernel.
  *
  * However, this `run_blocking` is blocking so the process will not be woken
  * up until `SIMIX_simcall_answer(simcall)`` is called by the kernel.

diff --git a/src/simix/smx_process.cpp b/src/simix/smx_process.cpp
index d7654ef..de6db49 100644 (file)
--- a/src/simix/smx_process.cpp
+++ b/src/simix/smx_process.cpp
@@ -1041,7 +1041,7 @@ smx_process_t simcall_process_create(
   if (name == nullptr)
     name = "";
   smx_process_t self = SIMIX_process_self();
   if (name == nullptr)
     name = "";
   smx_process_t self = SIMIX_process_self();

-  return simgrid::simix::kernel([&] {
+  return simgrid::simix::kernelImmediate([&] {

     return SIMIX_process_create(name,
           std::move(code), data, hostname,
           kill_time, properties, auto_restart,
     return SIMIX_process_create(name,
           std::move(code), data, hostname,
           kill_time, properties, auto_restart,

diff --git a/src/surf/plugins/energy.cpp b/src/surf/plugins/energy.cpp
index 76e254d..57ad84b 100644 (file)
--- a/src/surf/plugins/energy.cpp
+++ b/src/surf/plugins/energy.cpp
@@ -156,7 +156,7 @@ double HostEnergy::getCurrentWattsValue(double cpu_load)
 double HostEnergy::getConsumedEnergy()
 {
   if (last_updated < surf_get_clock()) // We need to simcall this as it modifies the environment
 double HostEnergy::getConsumedEnergy()
 {
   if (last_updated < surf_get_clock()) // We need to simcall this as it modifies the environment

-    simgrid::simix::kernel(std::bind(&HostEnergy::update, this));
+    simgrid::simix::kernelImmediate(std::bind(&HostEnergy::update, this));

 
   return total_energy;
 }
 
   return total_energy;
 }

diff --git a/teshsuite/simix/generic_simcalls/generic_simcalls.cpp b/teshsuite/simix/generic_simcalls/generic_simcalls.cpp
index 3160657..b2525f5 100644 (file)
--- a/teshsuite/simix/generic_simcalls/generic_simcalls.cpp
+++ b/teshsuite/simix/generic_simcalls/generic_simcalls.cpp
@@ -40,22 +40,22 @@ static int master(int argc, char *argv[])
 {
   // Test the simple immediate execution:
   XBT_INFO("Start");
 {
   // Test the simple immediate execution:
   XBT_INFO("Start");

-  simgrid::simix::kernel([] {
+  simgrid::simix::kernelImmediate([] {

     XBT_INFO("kernel");
   });
   XBT_INFO("kernel, returned");
 
   // Synchronize on a successful Future<void>:
     XBT_INFO("kernel");
   });
   XBT_INFO("kernel, returned");
 
   // Synchronize on a successful Future<void>:

-  simgrid::simix::blocking_simcall([&] {
+  simgrid::simix::kernelSync([&] {

     return kernel_defer(10, [] {
     return kernel_defer(10, [] {

-      XBT_INFO("blocking_simcall with void");
+      XBT_INFO("kernelSync with void");

     });
   });
     });
   });

-  XBT_INFO("blocking_simcall with void, returned");
+  XBT_INFO("kernelSync with void, returned");

 
   // Synchronize on a failing Future<void>:
   try {
 
   // Synchronize on a failing Future<void>:
   try {

-    simgrid::simix::blocking_simcall([&] {
+    simgrid::simix::kernelSync([&] {

       return kernel_defer(20, [] {
         throw std::runtime_error("Exception throwed from kernel_defer");
       });
       return kernel_defer(20, [] {
         throw std::runtime_error("Exception throwed from kernel_defer");
       });


@@ -67,23 +67,23 @@ static int master(int argc, char *argv[])
   }
 
   // Synchronize on a successul Future<int> and get the value:
   }
 
   // Synchronize on a successul Future<int> and get the value:

-  int res = simgrid::simix::blocking_simcall([&] {
+  int res = simgrid::simix::kernelSync([&] {

     return kernel_defer(30, [] {
     return kernel_defer(30, [] {

-      XBT_INFO("blocking_simcall with value");
+      XBT_INFO("kernelSync with value");

       return 42;
     });
   });
       return 42;
     });
   });

-  XBT_INFO("blocking_simcall with value returned with %i", res);
+  XBT_INFO("kernelSync with value returned with %i", res);

 
   // Synchronize on a successul Future<int> and get the value:
 
   // Synchronize on a successul Future<int> and get the value:

-  simgrid::simix::Future<int> future = simgrid::simix::asynchronous_simcall([&] {
+  simgrid::simix::Future<int> future = simgrid::simix::kernelAsync([&] {

     return kernel_defer(50, [] {
     return kernel_defer(50, [] {

-      XBT_INFO("asynchronous_simcall with value");
+      XBT_INFO("kernelAsync with value");

       return 43;
     });
   });
   res = future.get();
       return 43;
     });
   });
   res = future.get();

-  XBT_INFO("asynchronous_simcall with value returned with %i", res);
+  XBT_INFO("kernelAsync with value returned with %i", res);

 
   return 0;
 }
 
   return 0;
 }

diff --git a/teshsuite/simix/generic_simcalls/generic_simcalls.tesh b/teshsuite/simix/generic_simcalls/generic_simcalls.tesh
index bd2dfd5..25c22ef 100644 (file)
--- a/teshsuite/simix/generic_simcalls/generic_simcalls.tesh
+++ b/teshsuite/simix/generic_simcalls/generic_simcalls.tesh
@@ -2,10 +2,10 @@ $ ${bindir:=.}/generic_simcalls --cfg=contexts/stack-size:96 ${srcdir:=.}/exampl
 > [Tremblay:master:(0) 0.000000] [test/INFO] Start
 > [0.000000] [test/INFO] kernel
 > [Tremblay:master:(0) 0.000000] [test/INFO] kernel, returned
 > [Tremblay:master:(0) 0.000000] [test/INFO] Start
 > [0.000000] [test/INFO] kernel
 > [Tremblay:master:(0) 0.000000] [test/INFO] kernel, returned

-> [10.000000] [test/INFO] blocking_simcall with void
-> [Tremblay:master:(0) 10.000000] [test/INFO] blocking_simcall with void, returned
+> [10.000000] [test/INFO] kernelSync with void
+> [Tremblay:master:(0) 10.000000] [test/INFO] kernelSync with void, returned

 > [Tremblay:master:(0) 20.000000] [test/INFO] Exception caught: Exception throwed from kernel_defer
 > [Tremblay:master:(0) 20.000000] [test/INFO] Exception caught: Exception throwed from kernel_defer

-> [30.000000] [test/INFO] blocking_simcall with value
-> [Tremblay:master:(0) 30.000000] [test/INFO] blocking_simcall with value returned with 42
-> [50.000000] [test/INFO] asynchronous_simcall with value
-> [Tremblay:master:(0) 50.000000] [test/INFO] asynchronous_simcall with value returned with 43
+> [30.000000] [test/INFO] kernelSync with value
+> [Tremblay:master:(0) 30.000000] [test/INFO] kernelSync with value returned with 42
+> [50.000000] [test/INFO] kernelAsync with value
+> [Tremblay:master:(0) 50.000000] [test/INFO] kernelAsync with value returned with 43