XBT_LOG_NEW_DEFAULT_CATEGORY(energy_vm, "Messages of this example");
static int worker_func(int argc, char *argv[]) {
- (void)argc;
- (void)argv;
msg_task_t task1 = MSG_task_create("t1", 300E6, 0, NULL);
MSG_task_execute (task1);
MSG_task_destroy(task1);
my_jedule->root_container = root_container;
}
-void jedule_sd_exit(void)
+void jedule_sd_exit()
{
delete my_jedule;
}
mc_model_checker->process().dumpStack();
}
-static void MC_report_assertion_error(void)
+static void MC_report_assertion_error()
{
XBT_INFO("**************************");
XBT_INFO("*** PROPERTY NOT VALID ***");
static const void* zero_buffer;
static const size_t zero_buffer_size = 10 * 4096;
-static void zero_buffer_init(void)
+static void zero_buffer_init()
{
int fd = open("/dev/zero", O_RDONLY);
if (fd<0)
}
// static
-Session* Session::fork(std::function<void(void)> code)
+Session* Session::fork(std::function<void()> code)
{
// Create a AF_LOCAL socketpair used for exchanging messages
// bewteen the model-checker process (ourselves) and the model-checked
*
* The code is expected to `exec` the model-checker program.
*/
- static Session* fork(std::function<void(void)> code);
+ static Session* fork(std::function<void()> code);
/** Spawn a model-checked process
*
}
}
-void CommunicationDeterminismChecker::main(void)
+void CommunicationDeterminismChecker::main()
{
std::unique_ptr<simgrid::mc::VisitedState> visited_state = nullptr;
smx_simcall_t req = nullptr;
namespace simgrid {
namespace mc {
-void wait_for_requests(void)
+void wait_for_requests()
{
#if SIMGRID_HAVE_MC
xbt_assert(mc_model_checker == nullptr);
simgrid::mc::Client::get()->reportAssertionFailure();
}
-void MC_cut(void)
+void MC_cut()
{
xbt_assert(mc_model_checker == nullptr);
if (not MC_is_active())
simgrid::mc::Client::get()->ignoreMemory(addr, size);
}
-void MC_automaton_new_propositional_symbol(const char *id, int(*fct)(void))
+void MC_automaton_new_propositional_symbol(const char* id, int (*fct)())
{
xbt_assert(mc_model_checker == nullptr);
if (not MC_is_active())
simgrid::mc::processes_time.clear();
}
-void MC_show_deadlock(void)
+void MC_show_deadlock()
{
XBT_INFO("**************************");
XBT_INFO("*** DEAD-LOCK DETECTED ***");
}
/* Finalize the memory subsystem */
-void MC_memory_exit(void)
+void MC_memory_exit()
{
}
}
#if HAVE_SMPI
-int MC_smpi_process_count(void)
+int MC_smpi_process_count()
{
if (mc_model_checker == nullptr)
return smpi_process_count();
}
#endif
-unsigned long MC_smx_get_maxpid(void)
+unsigned long MC_smx_get_maxpid()
{
unsigned long maxpid;
mc_model_checker->process().read_variable("simix_process_maxpid",
}
}
-void Client::mainLoop(void)
+void Client::mainLoop()
{
while (1) {
simgrid::mc::wait_for_requests();
{
auto previous = (cond->refcount_)++;
xbt_assert(previous != 0);
- (void) previous;
}
void intrusive_ptr_release(s_smx_cond_t *cond)
}
}
-
-void smpi_coll_cleanup_mvapich2(void){
-int i=0;
-if(mv2_alltoall_thresholds_table)
- xbt_free(mv2_alltoall_thresholds_table[i]);
-xbt_free(mv2_alltoall_thresholds_table);
-xbt_free(mv2_size_alltoall_tuning_table);
-xbt_free(mv2_alltoall_table_ppn_conf);
-
-xbt_free(mv2_gather_thresholds_table);
-if(mv2_allgather_thresholds_table)
- xbt_free(mv2_allgather_thresholds_table[0]);
-xbt_free(mv2_size_allgather_tuning_table);
-xbt_free(mv2_allgather_table_ppn_conf);
-xbt_free(mv2_allgather_thresholds_table);
-
-xbt_free(mv2_allgatherv_thresholds_table);
-xbt_free(mv2_reduce_thresholds_table);
-xbt_free(mv2_red_scat_thresholds_table);
-xbt_free(mv2_allreduce_thresholds_table);
-xbt_free(mv2_bcast_thresholds_table);
-if(mv2_scatter_thresholds_table)
- xbt_free(mv2_scatter_thresholds_table[0]);
-xbt_free(mv2_scatter_thresholds_table);
-xbt_free(mv2_size_scatter_tuning_table);
-xbt_free(mv2_scatter_table_ppn_conf);
+void smpi_coll_cleanup_mvapich2()
+{
+ int i = 0;
+ if (mv2_alltoall_thresholds_table)
+ xbt_free(mv2_alltoall_thresholds_table[i]);
+ xbt_free(mv2_alltoall_thresholds_table);
+ xbt_free(mv2_size_alltoall_tuning_table);
+ xbt_free(mv2_alltoall_table_ppn_conf);
+
+ xbt_free(mv2_gather_thresholds_table);
+ if (mv2_allgather_thresholds_table)
+ xbt_free(mv2_allgather_thresholds_table[0]);
+ xbt_free(mv2_size_allgather_tuning_table);
+ xbt_free(mv2_allgather_table_ppn_conf);
+ xbt_free(mv2_allgather_thresholds_table);
+
+ xbt_free(mv2_allgatherv_thresholds_table);
+ xbt_free(mv2_reduce_thresholds_table);
+ xbt_free(mv2_red_scat_thresholds_table);
+ xbt_free(mv2_allreduce_thresholds_table);
+ xbt_free(mv2_bcast_thresholds_table);
+ if (mv2_scatter_thresholds_table)
+ xbt_free(mv2_scatter_thresholds_table[0]);
+ xbt_free(mv2_scatter_thresholds_table);
+ xbt_free(mv2_size_scatter_tuning_table);
+ xbt_free(mv2_scatter_table_ppn_conf);
}
}
#if HAVE_PAPI
-int Process::papi_event_set(void)
+int Process::papi_event_set()
{
return papi_event_set_;
}
-papi_counter_t& smpi_process_papi_counters(void)
+papi_counter_t& smpi_process_papi_counters()
{
return papi_counter_data_;
}
smx_mailbox_t mailbox_small();
xbt_mutex_t mailboxes_mutex();
#if HAVE_PAPI
- int papi_event_set(void);
- papi_counter_t& papi_counters(void);
+ int papi_event_set();
+ papi_counter_t& papi_counters();
#endif
xbt_os_timer_t timer();
void simulated_start();
}
/* Create the ns3 topology based on routing strategy */
-static void postparse_cb(void)
+static void postparse_cb()
{
IPV4addr.shrink_to_fit();
namespace simgrid {
namespace surf {
-simgrid::xbt::signal<void(void)> surfExitCallbacks;
-
+simgrid::xbt::signal<void()> surfExitCallbacks;
}
}
extern XBT_PRIVATE std::vector<std::string> surf_path;
extern "C" {
-XBT_PUBLIC(double) surf_get_clock(void);
+XBT_PUBLIC(double) surf_get_clock();
}
/** \ingroup SURF_simulation
* \brief List of hosts that have just restarted and whose autorestart process should be restarted.
namespace simgrid {
namespace surf {
-extern XBT_PRIVATE simgrid::xbt::signal<void(void)> surfExitCallbacks;
-
+extern XBT_PRIVATE simgrid::xbt::signal<void()> surfExitCallbacks;
}
}
*/
XBT_PUBLIC(void) tmgr_trace_event_unref(tmgr_trace_event_t* trace_event);
-XBT_PUBLIC(void) tmgr_finalize(void);
+XBT_PUBLIC(void) tmgr_finalize();
XBT_PUBLIC(tmgr_trace_t) tmgr_trace_new_from_file(const char* filename);
XBT_PUBLIC(tmgr_trace_t) tmgr_trace_new_from_string(const char* id, std::string input, double periodicity);
debugged_add_ext(head, key, key);
}
-static xbt_dict_t new_fixture(void)
+static xbt_dict_t new_fixture()
{
xbt_test_add("Fill in the dictionnary");
/* Declare xbt_preinit and xbt_postexit as constructor/destructor of the library.
* This is crude and rather compiler-specific, unfortunately.
*/
-static void xbt_preinit(void) _XBT_GNUC_CONSTRUCTOR(200);
-static void xbt_postexit(void);
+static void xbt_preinit() _XBT_GNUC_CONSTRUCTOR(200);
+static void xbt_postexit();
#ifdef _WIN32
#include <windows.h>
#endif
-static void xbt_preinit(void) {
+static void xbt_preinit()
+{
unsigned int seed = 2147483647;
#ifdef _WIN32
SYSTEM_INFO si;
atexit(xbt_postexit);
}
-static void xbt_postexit(void)
+static void xbt_postexit()
{
if (!_sg_do_clean_atexit)
return;
}
/** @brief Kill the program in silence */
-void xbt_abort(void)
+void xbt_abort()
{
#ifdef COVERAGE
/* Call __gcov_flush on abort when compiling with coverage options. */
- extern void __gcov_flush(void);
+ extern void __gcov_flush();
__gcov_flush();
#endif
#ifdef _WIN32