Remove a level of constness for argv parameter of sg_actor_start/create.

Aligns with the signature of main(), and allows to write without cast:

    int main(int argc, char *argv[]) {
        sg_actor_start(NULL, NULL, argc, argv);
        ...

The main drawback is that we have to add an explicit cast in our constrained
examples.

diff --git a/docs/source/app_s4u.rst b/docs/source/app_s4u.rst
index 0c85251..8b50a25 100644 (file)
--- a/docs/source/app_s4u.rst
+++ b/docs/source/app_s4u.rst
@@ -467,9 +467,9 @@ Creating actors
 
    .. group-tab:: C
 
-      .. doxygenfunction:: sg_actor_create(const char *name, sg_host_t host, xbt_main_func_t code, int argc, const char *const *argv)
+      .. doxygenfunction:: sg_actor_create(const char *name, sg_host_t host, xbt_main_func_t code, int argc, char *const *argv)
       .. doxygenfunction:: sg_actor_init(const char *name, sg_host_t host)
-      .. doxygenfunction:: sg_actor_start(sg_actor_t actor, xbt_main_func_t code, int argc, const char *const *argv)
+      .. doxygenfunction:: sg_actor_start(sg_actor_t actor, xbt_main_func_t code, int argc, char *const *argv)
 
       .. doxygenfunction:: sg_actor_attach(const char *name, void *data, sg_host_t host, xbt_dict_t properties)
       .. doxygenfunction:: sg_actor_detach()

diff --git a/examples/c/actor-create/actor-create.c b/examples/c/actor-create/actor-create.c
index 3ade6c3..5cdf513 100644 (file)
--- a/examples/c/actor-create/actor-create.c
+++ b/examples/c/actor-create/actor-create.c
@@ -88,16 +88,16 @@ int main(int argc, char** argv)
    */
   int recv_argc           = 2;
   const char* recv_argv[] = {"receiver", "mb42", NULL};
-  sg_actor_create("receiver", sg_host_by_name("Fafard"), receiver, recv_argc, recv_argv);
+  sg_actor_create("receiver", sg_host_by_name("Fafard"), receiver, recv_argc, (char**)recv_argv);
 
   int sender1_argc           = 3;
   const char* sender1_argv[] = {"sender", "GaBuZoMeu", "mb42", NULL};
-  sg_actor_create("sender1", sg_host_by_name("Tremblay"), sender, sender1_argc, sender1_argv);
+  sg_actor_create("sender1", sg_host_by_name("Tremblay"), sender, sender1_argc, (char**)sender1_argv);
 
   int sender2_argc           = 3;
   const char* sender2_argv[] = {"sender", "GloubiBoulga", "mb42", NULL};
   sg_actor_t sender2         = sg_actor_init("sender2", sg_host_by_name("Jupiter"));
-  sg_actor_start(sender2, sender, sender2_argc, sender2_argv);
+  sg_actor_start(sender2, sender, sender2_argc, (char**)sender2_argv);
 
   /* But starting actors directly is considered as a bad experimental habit, since it ties the code
    * you want to test with the experimental scenario. Starting your actors from an external deployment

diff --git a/examples/c/actor-migrate/actor-migrate.c b/examples/c/actor-migrate/actor-migrate.c
index 300ae18..a5358cf 100644 (file)
--- a/examples/c/actor-migrate/actor-migrate.c
+++ b/examples/c/actor-migrate/actor-migrate.c
@@ -42,7 +42,7 @@ static void monitor(int argc, char* argv[])
 
   int actor_argc           = 3;
   const char* actor_argv[] = {"worker", "Boivin", "Jacquelin", NULL};
-  sg_actor_t actor         = sg_actor_create("worker", sg_host_by_name("Fafard"), worker, actor_argc, actor_argv);
+  sg_actor_t actor = sg_actor_create("worker", sg_host_by_name("Fafard"), worker, actor_argc, (char**)actor_argv);
 
   sg_actor_sleep_for(5);
 

diff --git a/examples/c/cloud-capping/cloud-capping.c b/examples/c/cloud-capping/cloud-capping.c
index c8ea02e..81dc1fd 100644 (file)
--- a/examples/c/cloud-capping/cloud-capping.c
+++ b/examples/c/cloud-capping/cloud-capping.c
@@ -50,7 +50,7 @@ static void launch_worker(sg_host_t host, const char* pr_name, double computatio
   char* argv3        = bprintf("%f", bound);
   const char* argv[] = {pr_name, argv1, argv2, argv3, NULL};
 
-  sg_actor_create(pr_name, host, worker_main, 4, argv);
+  sg_actor_create(pr_name, host, worker_main, 4, (char**)argv);
 
   free(argv1);
   free(argv2);
@@ -92,11 +92,11 @@ static void test_dynamic_change()
   sg_vm_start(vm1);
 
   const char* w0_argv[] = {"worker0", "Task0", "-1.0", NULL};
-  sg_actor_create("worker0", (sg_host_t)vm0, worker_busy_loop, 3, w0_argv);
+  sg_actor_create("worker0", (sg_host_t)vm0, worker_busy_loop, 3, (char**)w0_argv);
 
   char* speed           = bprintf("%f", sg_host_get_speed(pm0));
   const char* w1_argv[] = {"worker1", "Task1", speed, NULL};
-  sg_actor_create("worker1", (sg_host_t)vm1, worker_busy_loop, 3, w1_argv);
+  sg_actor_create("worker1", (sg_host_t)vm1, worker_busy_loop, 3, (char**)w1_argv);
 
   sg_actor_sleep_for(3000); // let the tasks end
 

diff --git a/examples/c/cloud-migration/cloud-migration.c b/examples/c/cloud-migration/cloud-migration.c
index 72467e9..f3e5b82 100644 (file)
--- a/examples/c/cloud-migration/cloud-migration.c
+++ b/examples/c/cloud-migration/cloud-migration.c
@@ -45,7 +45,7 @@ static void vm_migrate_async(const_sg_vm_t vm, const_sg_host_t dst_pm)
   const char* dst_pm_name = sg_host_get_name(dst_pm);
 
   const char* argv[] = {"mig_work", vm_name, dst_pm_name, NULL};
-  sg_actor_create("mig_wrk", sg_host_self(), migration_worker_main, 3, argv);
+  sg_actor_create("mig_wrk", sg_host_self(), migration_worker_main, 3, (char**)argv);
 }
 
 static void master_main(int argc, char* argv[])

diff --git a/examples/c/cloud-simple/cloud-simple.c b/examples/c/cloud-simple/cloud-simple.c
index 335f189..6ed1719 100644 (file)
--- a/examples/c/cloud-simple/cloud-simple.c
+++ b/examples/c/cloud-simple/cloud-simple.c
@@ -72,10 +72,10 @@ static void launch_communication_worker(sg_host_t tx_host, sg_host_t rx_host)
   char* mbox = bprintf("MBOX:%s-%s", sg_host_get_name(tx_host), sg_host_get_name(rx_host));
 
   const char* tx_argv[] = {"comm_tx", mbox, NULL};
-  sg_actor_create("comm_tx", tx_host, communication_tx_fun, 2, tx_argv);
+  sg_actor_create("comm_tx", tx_host, communication_tx_fun, 2, (char**)tx_argv);
 
   const char* rx_argv[] = {"comm_rx", mbox, NULL};
-  sg_actor_create("comm_rx", rx_host, communication_rx_fun, 2, rx_argv);
+  sg_actor_create("comm_rx", rx_host, communication_rx_fun, 2, (char**)rx_argv);
 
   xbt_free(mbox);
 }

diff --git a/examples/c/exec-waitany/exec-waitany.c b/examples/c/exec-waitany/exec-waitany.c
index 72f4545..8b29393 100644 (file)
--- a/examples/c/exec-waitany/exec-waitany.c
+++ b/examples/c/exec-waitany/exec-waitany.c
@@ -67,10 +67,10 @@ int main(int argc, char* argv[])
   simgrid_load_platform(argv[1]);
 
   const char* worker_argv[] = {"worker", "false"};
-  sg_actor_create("worker", sg_host_by_name("Tremblay"), worker, 2, worker_argv);
+  sg_actor_create("worker", sg_host_by_name("Tremblay"), worker, 2, (char**)worker_argv);
 
   worker_argv[1] = "true";
-  sg_actor_create("worker_timeout", sg_host_by_name("Tremblay"), worker, 2, worker_argv);
+  sg_actor_create("worker_timeout", sg_host_by_name("Tremblay"), worker, 2, (char**)worker_argv);
 
   simgrid_run();
   return 0;

diff --git a/examples/c/synchro-semaphore/synchro-semaphore.c b/examples/c/synchro-semaphore/synchro-semaphore.c
index 409a160..f52532c 100644 (file)
--- a/examples/c/synchro-semaphore/synchro-semaphore.c
+++ b/examples/c/synchro-semaphore/synchro-semaphore.c
@@ -56,8 +56,8 @@ int main(int argc, char* argv[])
   const char* aliceTimes[] = {"0", "1", "3", "5", "1", "2", "5", "0"};
   const char* bobTimes[]   = {"0.9", "1", "1", "2", "2", "0", "0", "5"};
 
-  sg_actor_create("Alice", h, peer, 8, aliceTimes);
-  sg_actor_create("Bob", h, peer, 8, bobTimes);
+  sg_actor_create("Alice", h, peer, 8, (char**)aliceTimes);
+  sg_actor_create("Bob", h, peer, 8, (char**)bobTimes);
 
   simgrid_run();
   sg_sem_destroy(sem);

diff --git a/include/simgrid/actor.h b/include/simgrid/actor.h
index 62b5fc6..58f2ec2 100644 (file)
--- a/include/simgrid/actor.h
+++ b/include/simgrid/actor.h
@@ -24,12 +24,12 @@ XBT_PUBLIC size_t sg_actor_count();
 XBT_PUBLIC sg_actor_t* sg_actor_list();
 
 XBT_PUBLIC sg_actor_t sg_actor_create(const char* name, sg_host_t host, xbt_main_func_t code, int argc,
-                                      const char* const* argv);
+                                      char* const* argv);
 XBT_PUBLIC sg_actor_t sg_actor_init(const char* name, sg_host_t host);
 /** Start the previously initialized actor.
  *
  * Note that argv is copied over, so you should free your own copy once the actor is started. */
-XBT_PUBLIC void sg_actor_start(sg_actor_t actor, xbt_main_func_t code, int argc, const char* const* argv);
+XBT_PUBLIC void sg_actor_start(sg_actor_t actor, xbt_main_func_t code, int argc, char* const* argv);
 XBT_PUBLIC void sg_actor_set_stacksize(sg_actor_t actor, unsigned size);
 
 XBT_PUBLIC void sg_actor_exit();

diff --git a/src/s4u/s4u_Actor.cpp b/src/s4u/s4u_Actor.cpp
index 3770e80..ba18f77 100644 (file)
--- a/src/s4u/s4u_Actor.cpp
+++ b/src/s4u/s4u_Actor.cpp
@@ -492,7 +492,7 @@ sg_actor_t sg_actor_init(const char* name, sg_host_t host)
   return simgrid::s4u::Actor::init(name, host).get();
 }
 
-void sg_actor_start(sg_actor_t actor, xbt_main_func_t code, int argc, const char* const* argv)
+void sg_actor_start(sg_actor_t actor, xbt_main_func_t code, int argc, char* const* argv)
 {
   simgrid::kernel::actor::ActorCode function;
   if (code)
@@ -500,7 +500,7 @@ void sg_actor_start(sg_actor_t actor, xbt_main_func_t code, int argc, const char
   actor->start(function);
 }
 
-sg_actor_t sg_actor_create(const char* name, sg_host_t host, xbt_main_func_t code, int argc, const char* const* argv)
+sg_actor_t sg_actor_create(const char* name, sg_host_t host, xbt_main_func_t code, int argc, char* const* argv)
 {
   simgrid::kernel::actor::ActorCode function = simgrid::xbt::wrap_main(code, argc, argv);
   return simgrid::s4u::Actor::init(name, host)->start(function).get();