void surf_new_model_init_default(void)
{
surf_new_model_init_internal();
new_model_define_callbacks();
xbt_dynar_push(model_list, &surf_new_model);
}
void STag_surfxml_include(void)
{
XBT_DEBUG("STag_surfxml_include '%s'",A_surfxml_include_file);
xbt_dynar_push(surf_parsed_filename_stack,&surf_parsed_filename); // save old file name
surf_parsed_filename = xbt_strdup(A_surfxml_include_file);
xbt_dynar_push(surf_file_to_parse_stack, &surf_file_to_parse); //save old file descriptor
surf_file_to_parse = surf_fopen(A_surfxml_include_file, "r"); // read new file descriptor
xbt_assert((surf_file_to_parse), "Unable to open \"%s\"\n",
A_surfxml_include_file);
xbt_dynar_push(surf_input_buffer_stack,&surf_input_buffer);
surf_input_buffer = surf_parse__create_buffer(surf_file_to_parse, YY_BUF_SIZE);
surf_parse_push_buffer_state(surf_input_buffer);
fflush(NULL);
}
static int coordinator(int argc, char *argv[])
{
int CS_used = 0;
msg_task_t task = NULL, answer = NULL;
xbt_dynar_t requests = xbt_dynar_new(sizeof(char *), NULL);
char *req;
while(1){
MSG_task_receive(&task, "coordinator");
const char *kind = MSG_task_get_name(task);
if (!strcmp(kind, "request")) {
req = MSG_task_get_data(task);
if (CS_used) {
XBT_INFO("CS already used. Queue the request.");
xbt_dynar_push(requests, &req);
} else {
if(strcmp(req, "1") != 0){
XBT_INFO("CS idle. Grant immediatly");
answer = MSG_task_create("grant", 0, 1000, NULL);
MSG_task_send(answer, req);
CS_used = 1;
answer = NULL;
}
}
} else {
if (!xbt_dynar_is_empty(requests)) {
XBT_INFO("CS release. Grant to queued requests (queue size: %lu)", xbt_dynar_length(requests));
xbt_dynar_shift(requests, &req);
if(strcmp(req, "1") != 0){
MSG_task_send(MSG_task_create("grant", 0, 1000, NULL), req);
}else{
xbt_dynar_push(requests, &req);
CS_used = 0;
}
}else{
XBT_INFO("CS release. resource now idle");
CS_used = 0;
}
}
MSG_task_destroy(task);
task = NULL;
kind = NULL;
req = NULL;
}
return 0;
}
/* Build the set of the compute successors of a task that are ready (i.e., with all parents already scheduled). Both
* data and control dependencies are checked. As more than one transfer may exist between two compute tasks, it is
* mandatory to check whether the successor is not already in the set.
*/
xbt_dynar_t SD_task_get_ready_children(SD_task_t t){
unsigned int i;
xbt_dynar_t children=NULL, ready_children;
xbt_dynar_t output_transfers = SD_task_get_children(t);
SD_task_t output, child;
ready_children = xbt_dynar_new(sizeof(SD_task_t), NULL);
xbt_dynar_foreach(output_transfers, i, output){
if (SD_task_get_kind(output) == SD_TASK_COMM_E2E) {
/* Data dependency case: a compute task is followed by a data transfer. Its child (in a scheduling sense) is
* then the grand child
*/
children = SD_task_get_children(output);
xbt_dynar_get_cpy(children, 0, &child);
/* check if this child is already in the set */
if (xbt_dynar_member(ready_children, &child)){
XBT_DEBUG("%s already seen, ignore", SD_task_get_name(child));
xbt_dynar_free_container(&children); /* avoid memory leaks */
continue;
}
if (SD_task_get_kind(child) == SD_TASK_COMP_SEQ && (SD_task_get_state(child) == SD_NOT_SCHEDULED ||
SD_task_get_state(child) == SD_SCHEDULABLE) && SD_task_is_ready(child)){
xbt_dynar_push(ready_children, &child);
}
xbt_dynar_free_container(&children); /* avoid memory leaks */
} else {
/* Control dependency case: a compute task successor is another compute task. */
/* check if this child is already in the set */
if (xbt_dynar_member(ready_children, &output)){
XBT_DEBUG("%s already seen, ignore", SD_task_get_name(output));
continue;
}
if (SD_task_get_kind(output) == SD_TASK_COMP_SEQ && (SD_task_get_state(output) == SD_NOT_SCHEDULED ||
SD_task_get_state(output) == SD_SCHEDULABLE)&& SD_task_is_ready(output)){
xbt_dynar_push(ready_children, &output);
}
}
}
xbt_dynar_free_container(&output_transfers); /* avoid memory leaks */
return ready_children;
}
void surf_host_model_init_compound()
{
xbt_assert(surf_cpu_model_pm, "No CPU model defined yet!");
xbt_assert(surf_network_model, "No network model defined yet!");
surf_host_model = new simgrid::surf::HostCLM03Model();
xbt_dynar_push(all_existing_models, &surf_host_model);
}
/*********
* Model *
*********/
void surf_network_model_init_Constant()
{
xbt_assert(surf_network_model == nullptr);
surf_network_model = new simgrid::surf::NetworkConstantModel();
xbt_dynar_push(all_existing_models, &surf_network_model);
routing_model_create(nullptr);
}
void surfxml_bufferstack_push(int new_one)
{
if (!new_one)
old_buff = surfxml_bufferstack;
else {
xbt_dynar_push(surfxml_bufferstack_stack, &surfxml_bufferstack);
surfxml_bufferstack = xbt_new0(char, surfxml_bufferstack_size);
}
}
void surf_host_model_init_current_default(void)
{
surf_host_model = new simgrid::surf::HostCLM03Model();
xbt_cfg_setdefault_boolean(_sg_cfg_set, "network/crosstraffic", "yes");
surf_cpu_model_init_Cas01();
surf_network_model_init_LegrandVelho();
xbt_dynar_push(all_existing_models, &surf_host_model);
}
int master_fun(int argc, char *argv[])
{
msg_vm_t vm;
unsigned int i;
xbt_dynar_t worker_pms = MSG_process_get_data(MSG_process_self());
int nb_workers = xbt_dynar_length(worker_pms);
xbt_dynar_t vms = xbt_dynar_new(sizeof(msg_vm_t), NULL);
/* Launch VMs and worker processes. One VM per PM, and one worker process per VM. */
XBT_INFO("# Launch %d VMs", nb_workers);
for (i = 0; i< nb_workers; i++) {
char *vm_name = bprintf("VM%02d", i);
char *pr_name = bprintf("WRK%02d", i);
msg_host_t pm = xbt_dynar_get_as(worker_pms, i, msg_host_t);
XBT_INFO("create %s on PM(%s)", vm_name, MSG_host_get_name(pm));
msg_vm_t vm = MSG_vm_create_core(pm, vm_name);
s_vm_params_t params;
memset(¶ms, 0, sizeof(params));
params.ramsize = 1L * 1024 * 1024 * 1024; // 1Gbytes
MSG_host_set_params(vm, ¶ms);
MSG_vm_start(vm);
xbt_dynar_push(vms, &vm);
XBT_INFO("put a process (%s) on %s", pr_name, vm_name);
MSG_process_create(pr_name, worker_fun, NULL, vm);
xbt_free(vm_name);
xbt_free(pr_name);
}
/* Send a bunch of work to every one */
XBT_INFO("# Send a task to %d worker process", nb_workers);
send_tasks(nb_workers);
XBT_INFO("# Suspend all VMs");
xbt_dynar_foreach(vms, i, vm) {
const char *vm_name = MSG_host_get_name(vm);
XBT_INFO("suspend %s", vm_name);
MSG_vm_suspend(vm);
}
XBT_INFO("# Wait a while");
MSG_process_sleep(2);
XBT_INFO("# Resume all VMs");
xbt_dynar_foreach(vms, i, vm) {
MSG_vm_resume(vm);
}
/*********
* Model *
*********/
void surf_network_model_init_Constant()
{
xbt_assert(surf_network_model == NULL);
surf_network_model = new NetworkConstantModel();
sg_platf_host_add_cb(netcste_count_hosts);
ModelPtr model = surf_network_model;
xbt_dynar_push(model_list, &model);
}
tmgr_trace_t tmgr_trace_new_from_string(const char *name, const char *input, double periodicity)
{
int linecount = 0;
tmgr_event_t last_event = nullptr;
unsigned int cpt;
char *val;
xbt_assert(trace_list.find(name) == trace_list.end(), "Refusing to define trace %s twice", name);
xbt_assert(periodicity >= 0, "Invalid periodicity %g (must be positive)", periodicity);
tmgr_trace_t trace = new simgrid::trace_mgr::trace();
xbt_dynar_t list = xbt_str_split(input, "\n\r");
xbt_dynar_foreach(list, cpt, val) {
s_tmgr_event_t event;
linecount++;
xbt_str_trim(val, " \t\n\r\x0B");
if (val[0] == '#' || val[0] == '\0' || val[0] == '%') // pass comments
continue;
if (sscanf(val, "PERIODICITY " "%lg" "\n", &periodicity) == 1)
continue;
xbt_assert(sscanf(val, "%lg" " " "%lg" "\n", &event.delta, &event.value) == 2,
"%s:%d: Syntax error in trace\n%s", name, linecount, input);
if (last_event) {
xbt_assert(last_event->delta <= event.delta,
"%s:%d: Invalid trace: Events must be sorted, but time %g > time %g.\n%s",
name, linecount, last_event->delta, event.delta, input);
last_event->delta = event.delta - last_event->delta;
} else {
if(event.delta > 0.0){
s_tmgr_event_t first_event;
first_event.delta=event.delta;
first_event.value=-1.0;
xbt_dynar_push(trace->event_list, &first_event);
}
}
xbt_dynar_push(trace->event_list, &event);
last_event = (tmgr_event_t)xbt_dynar_get_ptr(trace->event_list, xbt_dynar_length(trace->event_list) - 1);
}
/** @brief handles dup at the exit
Update the table of file descriptors, and also the pipe objects if needed */
void syscall_dup_post(reg_s * reg, process_descriptor_t * proc)
{
proc_outside(proc);
unsigned int oldfd = (int) reg->arg[0];
unsigned int newfd = (int) reg->ret;
fd_descriptor_t *file_desc = process_descriptor_get_fd(proc, oldfd);
file_desc->refcount++;
process_descriptor_set_fd(proc, newfd, file_desc);
if (strace_option)
fprintf(stderr, "[%d] dup(%d, %d) = %d \n", proc->pid, oldfd, newfd, (int) reg->ret);
if (file_desc->type == FD_PIPE) {
pipe_t *pipe = file_desc->pipe;
// look for the fd in the read end of the pipe
xbt_dynar_t read_end = pipe->read_end;
unsigned int cpt_in;
pipe_end_t end_in;
xbt_dynar_foreach(read_end, cpt_in, end_in) {
if (end_in->fd == oldfd && end_in->proc == proc) {
pipe_end_t dup_end = xbt_malloc0(sizeof(pipe_end_s));
dup_end->fd = newfd;
dup_end->proc = end_in->proc;
xbt_dynar_push(read_end, &dup_end);
}
}
// look for the fd in the write end of the pipe
xbt_dynar_t write_end = pipe->write_end;
unsigned int cpt_out;
pipe_end_t end_out;
xbt_dynar_foreach(write_end, cpt_out, end_out) {
if (end_out->fd == oldfd && end_out->proc == proc) {
pipe_end_t dup_end = xbt_malloc0(sizeof(pipe_end_s));
dup_end->fd = newfd;
dup_end->proc = end_out->proc;
xbt_dynar_push(write_end, &dup_end);
}
}
}
/**
* \brief This functions splits a string after using another string as separator
* For example A!!B!!C splitted after !! will return the dynar {A,B,C}
* \return An array of dynars containing the string tokens
*/
xbt_dynar_t xbt_str_split_str(const char *s, const char *sep)
{
xbt_dynar_t res = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
int done;
const char *p, *q;
p = q = s;
done = 0;
if (s[0] == '\0')
return res;
if (sep[0] == '\0') {
s = xbt_strdup(s);
xbt_dynar_push(res, &s);
return res;
}
while (!done) {
char *to_push;
int v = 0;
//get the start of the first occurence of the substring
q = strstr(p, sep);
//if substring was not found add the entire string
if (NULL == q) {
v = strlen(p);
to_push = xbt_malloc(v + 1);
memcpy(to_push, p, v);
to_push[v] = '\0';
xbt_dynar_push(res, &to_push);
done = 1;
} else {
//get the appearance
to_push = xbt_malloc(q - p + 1);
memcpy(to_push, p, q - p);
//add string terminator
to_push[q - p] = '\0';
xbt_dynar_push(res, &to_push);
p = q + strlen(sep);
}
}
return res;
}
void jed_event_add_resources(jed_event_t event, xbt_dynar_t host_selection) {
xbt_dynar_t resource_subset_list;
jed_res_subset_t res_set;
unsigned int i;
resource_subset_list = xbt_dynar_new(sizeof(jed_res_subset_t), NULL);
jed_simgrid_get_resource_selection_by_hosts(resource_subset_list, host_selection);
xbt_dynar_foreach(resource_subset_list, i, res_set) {
xbt_dynar_push(event->resource_subsets, &res_set);
}
/** \ingroup msg_task_usage
* \brief This function checks if a communication is finished.
* \param comms a vector of communications
* \return the position of the finished communication if any
* (but it may have failed, use MSG_comm_get_status() to know its status),
* or -1 if none is finished
*/
int MSG_comm_testany(xbt_dynar_t comms)
{
xbt_ex_t e;
int finished_index = -1;
/* create the equivalent dynar with SIMIX objects */
xbt_dynar_t s_comms = xbt_dynar_new(sizeof(smx_synchro_t), NULL);
msg_comm_t comm;
unsigned int cursor;
xbt_dynar_foreach(comms, cursor, comm) {
xbt_dynar_push(s_comms, &comm->s_comm);
}
tmgr_trace_t tmgr_trace_new_from_string(const char *id, const char *input,
double periodicity)
{
tmgr_trace_t trace = NULL;
int linecount = 0;
s_tmgr_event_t event;
tmgr_event_t last_event = NULL;
xbt_dynar_t list;
unsigned int cpt;
char *val;
if (trace_list) {
trace = xbt_dict_get_or_null(trace_list, id);
if (trace) {
XBT_WARN("Ignoring redefinition of trace %s", id);
return trace;
}
}
xbt_assert(periodicity >= 0,
"Invalid periodicity %lg (must be positive)", periodicity);
trace = xbt_new0(s_tmgr_trace_t, 1);
trace->type = e_trace_list;
trace->s_list.event_list = xbt_dynar_new(sizeof(s_tmgr_event_t), NULL);
list = xbt_str_split(input, "\n\r");
xbt_dynar_foreach(list, cpt, val) {
linecount++;
xbt_str_trim(val, " \t\n\r\x0B");
if (val[0] == '#' || val[0] == '\0' || val[0] == '%')
continue;
if (sscanf(val, "PERIODICITY " "%lg" "\n", &periodicity) == 1)
continue;
if (sscanf(val, "%lg" " " "%lg" "\n", &event.delta, &event.value) != 2)
xbt_die("%s:%d: Syntax error in trace\n%s", id, linecount, input);
if (last_event) {
if (last_event->delta > event.delta) {
xbt_die("%s:%d: Invalid trace: Events must be sorted, "
"but time %lg > time %lg.\n%s",
id, linecount, last_event->delta, event.delta, input);
}
last_event->delta = event.delta - last_event->delta;
}
xbt_dynar_push(trace->s_list.event_list, &event);
last_event =
xbt_dynar_get_ptr(trace->s_list.event_list,
xbt_dynar_length(trace->s_list.event_list) - 1);
}
xbt_dynar_t sg_hosts_as_dynar(void)
{
xbt_dynar_t res = xbt_dynar_new(sizeof(sg_host_t),NULL);
xbt_dict_cursor_t cursor = nullptr;
const char* name = nullptr;
simgrid::s4u::Host* host = nullptr;
xbt_dict_foreach(host_list, cursor, name, host)
if (host && host->pimpl_netcard && host->pimpl_netcard->isHost())
xbt_dynar_push(res, &host);
return res;
}
/** \ingroup m_host_management
* \brief Return a dynar containing all the hosts declared at a given point of time
*/
xbt_dynar_t MSG_hosts_as_dynar(void) {
xbt_lib_cursor_t cursor;
char *key;
void **data;
xbt_dynar_t res = xbt_dynar_new(sizeof(msg_host_t),NULL);
xbt_lib_foreach(host_lib, cursor, key, data) {
if(routing_get_network_element_type(key) == SURF_NETWORK_ELEMENT_HOST)
xbt_dynar_push(res, data + MSG_HOST_LEVEL);
}
return res;
}
/*********
* Model *
*********/
void surf_cpu_model_init_Cas01()
{
char *optim = xbt_cfg_get_string(_sg_cfg_set, "cpu/optim");
xbt_assert(!surf_cpu_model_pm);
xbt_assert(!surf_cpu_model_vm);
if (!strcmp(optim, "TI")) {
surf_cpu_model_init_ti();
return;
}
surf_cpu_model_pm = new CpuCas01Model();
surf_cpu_model_vm = new CpuCas01Model();
cpu_define_callbacks();
ModelPtr model_pm = surf_cpu_model_pm;
ModelPtr model_vm = surf_cpu_model_vm;
xbt_dynar_push(model_list, &model_pm);
xbt_dynar_push(model_list, &model_vm);
}
/** @brief Push something to the message exchange queue.
*
* This is blocking if the declared capacity is non-nul, and if this amount is reached.
*
* @see #xbt_dynar_push
*/
void xbt_queue_push(xbt_queue_t queue, const void *src)
{
xbt_mutex_acquire(queue->mutex);
while (queue->capacity != 0
&& queue->capacity == xbt_dynar_length(queue->data)) {
XBT_DEBUG("Capacity of %p exceeded (=%d). Waiting", queue,
queue->capacity);
xbt_cond_wait(queue->not_full, queue->mutex);
}
xbt_dynar_push(queue->data, src);
xbt_cond_signal(queue->not_empty);
xbt_mutex_release(queue->mutex);
}
/* Build an array that contains all the idle hosts/VMs in the platform */
xbt_dynar_t get_idle_VMs(){
int i;
const sg_host_t *hosts = sg_host_list();
int nhosts = sg_host_count();
xbt_dynar_t idleVMs = xbt_dynar_new(sizeof(sg_host_t), NULL);
for (i = 0; i < nhosts; i++){
if (is_on_and_idle(hosts[i]))
xbt_dynar_push(idleVMs, &(hosts[i]));
}
return idleVMs;
}
/** \ingroup msg_host_management
* \brief Return the content of mounted storages on an host.
* \param host a host
* \return a dynar containing content (as a dict) of all storages mounted on the host
*/
xbt_dynar_t MSG_host_get_storage_content(msg_host_t host)
{
xbt_assert((host != NULL), "Invalid parameters");
xbt_dynar_t contents = xbt_dynar_new(sizeof(void *),NULL);
msg_storage_t storage;
char* storage_name;
unsigned int i;
xbt_dynar_t storage_list = simcall_host_get_storage_list(host);
xbt_dynar_foreach(storage_list, i, storage_name){
storage = xbt_lib_get_elm_or_null(storage_lib,storage_name);
xbt_dict_t content = simcall_storage_get_content(storage);
xbt_dynar_push(contents, &content);
}
static void action_Irecv(const char *const *action)
{
char mailbox[250];
double clock = MSG_get_clock();
process_globals_t globals =
(process_globals_t) MSG_process_get_data(MSG_process_self());
XBT_DEBUG("Irecv on %s", MSG_process_get_name(MSG_process_self()));
sprintf(mailbox, "%s_%s", action[2],
MSG_process_get_name(MSG_process_self()));
msg_task_t t = NULL;
xbt_dynar_push(globals->tasks, &t);
msg_comm_t c =
MSG_task_irecv(xbt_dynar_get_ptr
(globals->tasks, xbt_dynar_length(globals->tasks) - 1),
mailbox);
xbt_dynar_push(globals->irecvs, &c);
log_action(action, MSG_get_clock() - clock);
asynchronous_cleanup();
}
/* } */
void surf_network_model_init_IB(void)
{
if (surf_network_model)
return;
surf_network_model = new NetworkIBModel();
net_define_callbacks();
xbt_dynar_push(model_list, &surf_network_model);
surf_callback_connect(networkActionStateChangedCallbacks, IB_action_state_changed_callback);
surf_callback_connect(networkCommunicateCallbacks, IB_action_init_callback);
sg_platf_host_add_cb(IB_create_host_callback);
xbt_cfg_setdefault_double(_sg_cfg_set, "network/weight_S", 8775);
}
/* Build an array that contains all the busy hosts/VMs in the platform */
xbt_dynar_t get_running_VMs(){
int i;
const sg_host_t *hosts = sg_host_list ();
int nhosts = sg_host_count ();
HostAttribute attr;
xbt_dynar_t runningVMs = xbt_dynar_new(sizeof(sg_host_t), NULL);
for (i = 0; i < nhosts; i++){
attr = sg_host_user(hosts[i]);
if (attr->on_off)
xbt_dynar_push(runningVMs, &(hosts[i]));
}
return runningVMs;
}
void *xbt_multidict_get(xbt_dict_t mdict, xbt_dynar_t keys)
{
xbt_dynar_t lens = xbt_dynar_new(sizeof(unsigned long int), NULL);
unsigned long i;
void *res;
for (i = 0; i < xbt_dynar_length(keys); i++) {
char *thiskey = xbt_dynar_get_as(keys, i, char *);
unsigned long int thislen = (unsigned long int) strlen(thiskey);
xbt_dynar_push(lens, &thislen);
}
res = xbt_multidict_get_ext(mdict, keys, lens), xbt_dynar_free(&lens);
return res;
}
static xbt_dynar_t get_ready_tasks(xbt_dynar_t dax)
{
unsigned int i;
xbt_dynar_t ready_tasks;
SD_task_t task;
ready_tasks = xbt_dynar_new(sizeof(SD_task_t), NULL);
xbt_dynar_foreach(dax, i, task) {
if (SD_task_get_kind(task) == SD_TASK_COMP_SEQ && SD_task_get_state(task) == SD_SCHEDULABLE) {
xbt_dynar_push(ready_tasks, &task);
}
}
XBT_DEBUG("There are %lu ready tasks", xbt_dynar_length(ready_tasks));
return ready_tasks;
}
/** @brief Initialize the xbt mechanisms. */
void xbt_init(int *argc, char **argv)
{
xbt_set_terminate();
if (xbt_initialized++) {
XBT_DEBUG("XBT was initialized %d times.", xbt_initialized);
return;
}
xbt_binary_name = xbt_strdup(argv[0]);
xbt_cmdline = xbt_dynar_new(sizeof(char*),NULL);
for (int i=0;i<*argc;i++)
xbt_dynar_push(xbt_cmdline,&(argv[i]));
xbt_log_init(argc, argv);
}
JNIEXPORT int JNICALL Java_org_simgrid_msg_Comm_waitAny(JNIEnv *env, jclass cls, jobjectArray jcomms)
{
int count;
msg_comm_t* comms = jarray_to_commArray(env, jcomms, &count);
if (not comms)
return -1;
xbt_dynar_t dyn = xbt_dynar_new(sizeof(msg_comm_t),nullptr);
for (int i=0; i<count; i++) {
xbt_dynar_push(dyn, &(comms[i]));
}
int rank = MSG_comm_waitany(dyn);
delete[] comms;
xbt_dynar_free(&dyn);
return rank;
}
/* } */
void surf_network_model_init_CM02(void)
{
if (surf_network_model)
return;
surf_network_model = new NetworkCm02Model();
net_define_callbacks();
ModelPtr model = surf_network_model;
xbt_dynar_push(model_list, &model);
xbt_cfg_setdefault_double(_sg_cfg_set, "network/latency_factor", 1.0);
xbt_cfg_setdefault_double(_sg_cfg_set, "network/bandwidth_factor",
1.0);
xbt_cfg_setdefault_double(_sg_cfg_set, "network/weight_S", 0.0);
}
