StorageAction *StorageN11::open(const char* mount, const char* path)
{
XBT_DEBUG("\tOpen file '%s'",path);
sg_size_t size, *psize;
psize = (sg_size_t*) xbt_dict_get_or_null(content_, path);
// if file does not exist create an empty file
if(psize)
size = *psize;
else {
psize = xbt_new(sg_size_t,1);
size = 0;
*psize = size;
xbt_dict_set(content_, path, psize, nullptr);
XBT_DEBUG("File '%s' was not found, file created.",path);
}
surf_file_t file = xbt_new0(s_surf_file_t,1);
file->name = xbt_strdup(path);
file->size = size;
file->mount = xbt_strdup(mount);
file->current_position = 0;
StorageAction *action = new StorageN11Action(getModel(), 0, isOff(), this, OPEN);
action->p_file = file;
return action;
}
static void parse_ns3_add_link(sg_platf_link_cbarg_t link)
{
XBT_DEBUG("NS3_ADD_LINK '%s'",link->id);
if(!IPV4addr) IPV4addr = xbt_dynar_new(sizeof(char*),free);
tmgr_trace_t bw_trace;
tmgr_trace_t state_trace;
tmgr_trace_t lat_trace;
bw_trace = link->bandwidth_trace;
lat_trace = link->latency_trace;
state_trace = link->state_trace;
if (bw_trace)
XBT_INFO("The NS3 network model doesn't support bandwidth state traces");
if (lat_trace)
XBT_INFO("The NS3 network model doesn't support latency state traces");
if (state_trace)
XBT_INFO("The NS3 network model doesn't support link state traces");
ns3_link_t link_ns3 = xbt_new0(s_ns3_link_t,1);;
link_ns3->id = xbt_strdup((char*)(link->id));
link_ns3->bdw = bprintf("%f",link->bandwidth);
link_ns3->lat = bprintf("%f",link->latency);
surf_ns3_link_t l = xbt_new0(s_surf_ns3_link_t,1);
l->generic_resource.name = xbt_strdup(link->id);
l->generic_resource.properties = current_property_set;
l->data = link_ns3;
l->created = 1;
xbt_lib_set(link_lib,link->id,NS3_LINK_LEVEL,link_ns3);
xbt_lib_set(link_lib,link->id,SURF_LINK_LEVEL,l);
}
//syntax is <maxsize>:<filename>
//If roll is 0, use split files, otherwise, use roll file
//For split, replace % in the file by the current count
xbt_log_appender_t xbt_log_appender2_file_new(char *arg,int roll) {
xbt_log_appender_t res = xbt_new0(s_xbt_log_appender_t, 1);
if (_XBT_LOGV(smpi).initialized) // HACK to detect if we run in SMPI mode. Relies on MAIN__ source disposition
res->do_append = smpi_append2_file;
else
res->do_append = append2_file;
res->free_ = free_append2_;
xbt_log_append2_file_t data = xbt_new0(struct xbt_log_append2_file_s, 1);
xbt_assert(arg);
char* buf=xbt_strdup(arg);
char* sep=strchr(buf,':');
xbt_assert(sep>0);
data->filename=xbt_strdup(sep+1);
*sep='\0';
char *endptr;
data->limit=strtol(buf,&endptr,10);
xbt_assert(endptr[0]=='\0', "Invalid buffer size: %s", buf);
xbt_free(buf);
if(roll)
data->count=-1;
else
data->count=0;
open_append2_file(data);
res->data = data;
return res;
}
void gras_process_init()
{
char **env_iter;
_gras_procdata = xbt_new0(gras_procdata_t, 1);
gras_procdata_init();
/* initialize the host & process properties */
_host_properties = xbt_dict_new();
_process_properties = xbt_dict_new();
env_iter = environ;
while (*env_iter) {
char *equal, *buf = xbt_strdup(*env_iter);
equal = strchr(buf, '=');
if (!equal) {
XBT_WARN
("The environment contains an entry without '=' char: %s (ignore it)",
*env_iter);
continue;
}
*equal = '\0';
xbt_dict_set(_process_properties, buf, xbt_strdup(equal + 1),
xbt_free_f);
free(buf);
env_iter++;
}
}
static void linkContainers (container_t src, container_t dst, xbt_dict_t filter)
{
//ignore loopback
if (strcmp (src->name, "__loopback__") == 0 || strcmp (dst->name, "__loopback__") == 0){
XBT_DEBUG (" linkContainers: ignoring loopback link");
return;
}
//find common father
container_t father = lowestCommonAncestor (src, dst);
if (!father){
xbt_die ("common father unknown, this is a tracing problem");
}
if (filter != NULL){
//check if we already register this pair (we only need one direction)
char aux1[INSTR_DEFAULT_STR_SIZE], aux2[INSTR_DEFAULT_STR_SIZE];
snprintf (aux1, INSTR_DEFAULT_STR_SIZE, "%s%s", src->name, dst->name);
snprintf (aux2, INSTR_DEFAULT_STR_SIZE, "%s%s", dst->name, src->name);
if (xbt_dict_get_or_null (filter, aux1)){
XBT_DEBUG (" linkContainers: already registered %s <-> %s (1)", src->name, dst->name);
return;
}
if (xbt_dict_get_or_null (filter, aux2)){
XBT_DEBUG (" linkContainers: already registered %s <-> %s (2)", dst->name, src->name);
return;
}
//ok, not found, register it
xbt_dict_set (filter, aux1, xbt_strdup ("1"), NULL);
xbt_dict_set (filter, aux2, xbt_strdup ("1"), NULL);
}
//declare type
char link_typename[INSTR_DEFAULT_STR_SIZE];
snprintf (link_typename, INSTR_DEFAULT_STR_SIZE, "%s-%s%s-%s%s",
father->type->name,
src->type->name, src->type->id,
dst->type->name, dst->type->id);
type_t link_type = PJ_type_get_or_null (link_typename, father->type);
if (link_type == NULL){
link_type = PJ_type_link_new (link_typename, father->type, src->type, dst->type);
}
//register EDGE types for triva configuration
xbt_dict_set (trivaEdgeTypes, link_type->name, xbt_strdup("1"), NULL);
//create the link
static long long counter = 0;
char key[INSTR_DEFAULT_STR_SIZE];
snprintf (key, INSTR_DEFAULT_STR_SIZE, "%lld", counter++);
new_pajeStartLink(SIMIX_get_clock(), father, link_type, src, "topology", key);
new_pajeEndLink(SIMIX_get_clock(), father, link_type, dst, "topology", key);
XBT_DEBUG (" linkContainers %s <-> %s", src->name, dst->name);
}
static void vm_migrate_async(msg_vm_t vm, msg_host_t dst_pm)
{
const char *vm_name = MSG_vm_get_name(vm);
const char *dst_pm_name = MSG_host_get_name(dst_pm);
msg_host_t host = MSG_host_self();
const char *pr_name = "mig_wrk";
char **argv = xbt_new(char *, 4);
argv[0] = xbt_strdup(pr_name);
argv[1] = xbt_strdup(vm_name);
argv[2] = xbt_strdup(dst_pm_name);
argv[3] = NULL;
MSG_process_create_with_arguments(pr_name, migration_worker_main, NULL, host, 3, argv);
}
/** \ingroup m_task_management
* \brief Creates a new #msg_task_t.
*
* A constructor for #msg_task_t taking four arguments and returning the
corresponding object.
* \param name a name for the object. It is for user-level information
and can be NULL.
* \param flop_amount a value of the processing amount (in flop)
needed to process this new task. If 0, then it cannot be executed with
MSG_task_execute(). This value has to be >=0.
* \param message_size a value of the amount of data (in bytes) needed to
transfer this new task. If 0, then it cannot be transfered with
MSG_task_send() and MSG_task_recv(). This value has to be >=0.
* \param data a pointer to any data may want to attach to the new
object. It is for user-level information and can be NULL. It can
be retrieved with the function \ref MSG_task_get_data.
* \see msg_task_t
* \return The new corresponding object.
*/
msg_task_t MSG_task_create(const char *name, double flop_amount,
double message_size, void *data)
{
msg_task_t task = xbt_new(s_msg_task_t, 1);
simdata_task_t simdata = xbt_new(s_simdata_task_t, 1);
task->simdata = simdata;
/* Task structure */
task->name = xbt_strdup(name);
task->data = data;
/* Simulator Data */
simdata->compute = NULL;
simdata->comm = NULL;
simdata->bytes_amount = message_size;
simdata->flops_amount = flop_amount;
simdata->sender = NULL;
simdata->receiver = NULL;
simdata->source = NULL;
simdata->priority = 1.0;
simdata->bound = 0;
simdata->affinity_mask_db = xbt_dict_new_homogeneous(NULL);
simdata->rate = -1.0;
simdata->isused = 0;
simdata->host_nb = 0;
simdata->host_list = NULL;
simdata->flops_parallel_amount = NULL;
simdata->bytes_parallel_amount = NULL;
TRACE_msg_task_create(task);
return task;
}
/** Emitter function */
int master(int argc, char *argv[])
{
long number_of_tasks = atol(argv[1]);
double task_comp_size = atof(argv[2]);
double task_comm_size = atof(argv[3]);
long slaves_count = atol(argv[4]);
XBT_INFO("master %ld %f %f %ld", number_of_tasks, task_comp_size,
task_comm_size, slaves_count);
int i;
for (i = 0; i < number_of_tasks; i++) {
char task_name[100];
snprintf (task_name, 100, "task-%d", i);
m_task_t task = NULL;
task = MSG_task_create(task_name, task_comp_size, task_comm_size, NULL);
//setting the category of task to "compute"
//the category of a task must be defined before it is sent or executed
TRACE_msg_set_task_category(task, "compute");
MSG_task_send(task, "master_mailbox");
}
for (i = 0; i < slaves_count; i++) {
char task_name[100];
snprintf (task_name, 100, "task-%d", i);
m_task_t finalize = MSG_task_create(task_name, 0, 0, xbt_strdup("finalize"));
TRACE_msg_set_task_category(finalize, "finalize");
MSG_task_send(finalize, "master_mailbox");
}
return 0;
}
static void replace_lat_ns3(char ** lat)
{
char *temp = xbt_strdup(*lat);
xbt_free(*lat);
*lat = bprintf("%fs",atof(temp));
xbt_free(temp);
}
/** @brief creates a new string buffer containing the provided string
*
* Beware, the ctn is copied, you want to free it afterward, anyhow
*/
XBT_INLINE xbt_strbuff_t xbt_strbuff_new_from(const char *ctn)
{
xbt_strbuff_t res = malloc(sizeof(s_xbt_strbuff_t));
res->data = xbt_strdup(ctn);
res->used = res->size = strlen(ctn);
return res;
}
static int master(int argc, char *argv[])
{
msg_task_t task = NULL;
// I am the master of emigrant process,
// I tell it where it must emigrate to.
xbt_dynar_t destinations = xbt_dynar_new (sizeof(char*), &xbt_free_ref);
xbt_dynar_push_as (destinations, char*, xbt_strdup ("Tremblay"));
xbt_dynar_push_as (destinations, char*, xbt_strdup ("Jupiter"));
xbt_dynar_push_as (destinations, char*, xbt_strdup ("Fafard"));
xbt_dynar_push_as (destinations, char*, xbt_strdup ("Ginette"));
xbt_dynar_push_as (destinations, char*, xbt_strdup ("Bourassa"));
xbt_dynar_push_as (destinations, char*, xbt_strdup ("Fafard"));
xbt_dynar_push_as (destinations, char*, xbt_strdup ("Tremblay"));
xbt_dynar_push_as (destinations, char*, xbt_strdup ("Ginette"));
xbt_dynar_push_as (destinations, char*, NULL);
char *destination;
unsigned int i;
xbt_dynar_foreach(destinations, i, destination){
task = MSG_task_create("task", 0, 0, NULL);
if (destination){
MSG_task_set_data(task, xbt_strdup (destination));
}
MSG_task_set_category(task, "migration_order");
MSG_task_send (task, "master_mailbox");
task = NULL;
}
void operator()() {
XBT_INFO("Hello s4u, I have something to send");
simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::byName("mb42");
simgrid::s4u::this_actor::send(mailbox, xbt_strdup(msg.c_str()), msg.size());
XBT_INFO("I'm done. See you.");
}
/**
* \brief Add a "host" to the network element list
*/
static void parse_S_host(sg_platf_host_cbarg_t host)
{
if (current_routing->p_hierarchy == SURF_ROUTING_NULL)
current_routing->p_hierarchy = SURF_ROUTING_BASE;
xbt_assert(!sg_host_by_name(host->id),
"Reading a host, processing unit \"%s\" already exists", host->id);
RoutingEdge *info = new RoutingEdgeImpl(xbt_strdup(host->id),
-1,
SURF_NETWORK_ELEMENT_HOST,
current_routing);
info->setId(current_routing->parsePU(info));
sg_host_edge_set(sg_host_by_name_or_create(host->id), info);
XBT_DEBUG("Having set name '%s' id '%d'", host->id, info->getId());
if(mount_list){
xbt_lib_set(storage_lib, host->id, ROUTING_STORAGE_HOST_LEVEL, (void *) mount_list);
mount_list = NULL;
}
if (host->coord && strcmp(host->coord, "")) {
unsigned int cursor;
char*str;
if (!COORD_HOST_LEVEL)
xbt_die ("To use host coordinates, please add --cfg=network/coordinates:yes to your command line");
/* Pre-parse the host coordinates -- FIXME factorize with routers by overloading the routing->parse_PU function*/
xbt_dynar_t ctn_str = xbt_str_split_str(host->coord, " ");
xbt_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);
xbt_dynar_foreach(ctn_str,cursor, str) {
double val = atof(str);
xbt_dynar_push(ctn,&val);
}
static int client(int argc, char *argv[])
{
int my_pid = MSG_process_get_PID(MSG_process_self());
char *my_mailbox = xbt_strdup(argv[1]);
while(1){
XBT_INFO("Client (%s) asks the request", my_mailbox);
MSG_task_send(MSG_task_create("request", 0, 1000, my_mailbox), "coordinator");
msg_task_t answer = NULL;
MSG_task_receive(&answer, my_mailbox);
const char* kind = MSG_task_get_name(answer);
if (!strcmp(kind, "grant")) {
XBT_INFO("Client (%s) got the answer (grant). Sleep a bit and release it", my_mailbox);
if(!strcmp(my_mailbox, "1"))
cs = 1;
}else{
XBT_INFO("Client (%s) got the answer (not grant). Try again", my_mailbox);
}
MSG_task_destroy(answer);
kind = NULL;
MSG_process_sleep(my_pid);
}
return 0;
}
int console_host_set_property(lua_State *L) {
const char* name ="";
const char* prop_id = "";
const char* prop_value = "";
lua_ensure(lua_istable(L, -1), "Bad Arguments to create link, Should be a table with named arguments");
// get Host id
lua_pushstring(L, "host");
lua_gettable(L, -2);
name = lua_tostring(L, -1);
lua_pop(L, 1);
// get prop Name
lua_pushstring(L, "prop");
lua_gettable(L, -2);
prop_id = lua_tostring(L, -1);
lua_pop(L, 1);
//get args
lua_pushstring(L,"value");
lua_gettable(L, -2);
prop_value = lua_tostring(L,-1);
lua_pop(L, 1);
sg_host_t host = sg_host_by_name(name);
lua_ensure(host, "no host '%s' found",name);
xbt_dict_t props = sg_host_get_properties(host);
xbt_dict_set(props,prop_id,xbt_strdup(prop_value),nullptr);
return 0;
}
void surf_action_set_category(surf_action_t action,
const char *category)
{
XBT_IN("(%p,%s)", action, category);
action->category = xbt_strdup(category);
XBT_OUT();
}
static void open_append2_file(xbt_log_append2_file_t data){
if(data->count<0)
{
//Roll
if(!data->file)
data->file= fopen(data->filename, "w");
else{
fputs(APPEND2_END_TOKEN_CLEAR,data->file);
fseek(data->file,0,SEEK_SET);
}
}
else{
//printf("Splitting\n");
//Split
if(data->file)
fclose(data->file);
char newname[512];
char* pre=xbt_strdup(data->filename);
char* sep=strchr(pre,'%');
if(!sep)
sep=pre+strlen(pre);
char* post=sep+1;
*sep='\0';
snprintf(newname,511,"%s%i%s",pre,data->count,post);
data->count++;
data->file= fopen(newname, "w");
xbt_assert(data->file);
}
}
/** \ingroup m_task_management
* \brief Creates a new #msg_task_t.
*
* A constructor for #msg_task_t taking four arguments and returning the
corresponding object.
* \param name a name for the object. It is for user-level information
and can be NULL.
* \param compute_duration a value of the processing amount (in flop)
needed to process this new task. If 0, then it cannot be executed with
MSG_task_execute(). This value has to be >=0.
* \param message_size a value of the amount of data (in bytes) needed to
transfer this new task. If 0, then it cannot be transfered with
MSG_task_send() and MSG_task_recv(). This value has to be >=0.
* \param data a pointer to any data may want to attach to the new
object. It is for user-level information and can be NULL. It can
be retrieved with the function \ref MSG_task_get_data.
* \see msg_task_t
* \return The new corresponding object.
*/
msg_task_t MSG_task_create(const char *name, double compute_duration,
double message_size, void *data)
{
msg_task_t task = xbt_new(s_msg_task_t, 1);
simdata_task_t simdata = xbt_new(s_simdata_task_t, 1);
task->simdata = simdata;
/* Task structure */
task->name = xbt_strdup(name);
task->data = data;
/* Simulator Data */
simdata->compute = NULL;
simdata->comm = NULL;
simdata->message_size = message_size;
simdata->computation_amount = compute_duration;
simdata->sender = NULL;
simdata->receiver = NULL;
simdata->source = NULL;
simdata->priority = 1.0;
simdata->bound = 0;
simdata->affinity_mask_db = xbt_dict_new_homogeneous(NULL);
simdata->rate = -1.0;
simdata->isused = 0;
simdata->host_nb = 0;
simdata->host_list = NULL;
simdata->comp_amount = NULL;
simdata->comm_amount = NULL;
#ifdef HAVE_TRACING
TRACE_msg_task_create(task);
#endif
return task;
}
int main(int argc, char **argv)
{
xbt_dynar_t dax;
unsigned int cursor;
SD_task_t task;
/* SD initialization */
SD_init(&argc, argv);
/* Check our arguments */
xbt_assert(argc > 2, "Usage: %s platform_file dax_file [jedule_file]\n"
"\tExample: %s simulacrum_7_hosts.xml Montage_25.xml Montage_25.jed", argv[0], argv[0]);
char *last = strrchr(argv[2], '.');
char * tracefilename = bprintf("%.*s.trace",(int) (last == NULL ? strlen(argv[2]):last - argv[2]), argv[2]);
if (argc == 4)
tracefilename = xbt_strdup(argv[3]);
/* creation of the environment */
SD_create_environment(argv[1]);
/* load the DAX file */
dax = SD_daxload(argv[2]);
if (!dax){
XBT_ERROR("A problem occurred during DAX parsing (cycle or syntax). Do not continue this test");
free(tracefilename);
SD_exit();
exit(255);
}
/* Display all the tasks */
XBT_INFO("------------------- Display all tasks of the loaded DAG ---------------------------");
xbt_dynar_foreach(dax, cursor, task) {
SD_task_dump(task);
}
JNIEXPORT void JNICALL JNICALL Java_org_simgrid_msg_Msg_run(JNIEnv * env, jclass cls)
{
/* Run everything */
XBT_DEBUG("Ready to run MSG_MAIN");
msg_error_t rv = MSG_main();
XBT_DEBUG("Done running MSG_MAIN");
jxbt_check_res("MSG_main()", rv, MSG_OK,
xbt_strdup("unexpected error : MSG_main() failed .. please report this bug "));
XBT_INFO("MSG_main finished; Cleaning up the simulation...");
/* Cleanup java hosts */
xbt_dynar_t hosts = MSG_hosts_as_dynar();
for (unsigned long index = 0; index < xbt_dynar_length(hosts) - 1; index++) {
msg_host_t msg_host = xbt_dynar_get_as(hosts,index,msg_host_t);
jobject jhost = (jobject) msg_host->extension(JAVA_HOST_LEVEL);
if (jhost)
jhost_unref(env, jhost);
}
xbt_dynar_free(&hosts);
/* Cleanup java storages */
xbt_dynar_t storages = MSG_storages_as_dynar();
if(!xbt_dynar_is_empty(storages)){
for (unsigned long index = 0; index < xbt_dynar_length(storages) - 1; index++) {
jobject jstorage = (jobject) xbt_lib_get_level(xbt_dynar_get_as(storages,index,msg_storage_t), JAVA_STORAGE_LEVEL);
if (jstorage)
jstorage_unref(env, jstorage);
}
}
xbt_dynar_free(&storages);
}
static char* buff_size_to_string(size_t buff_size) {
if (XBT_LOG_ISENABLED(mc_request, xbt_log_priority_verbose))
return bprintf("%zu", buff_size);
return xbt_strdup("(verbose only)");
}
/********************************* Host **************************************/
m_host_t __MSG_host_create(smx_host_t workstation, void *data)
{
const char *name;
simdata_host_t simdata = xbt_new0(s_simdata_host_t, 1);
m_host_t host = xbt_new0(s_m_host_t, 1);
int i;
char alias[MAX_ALIAS_NAME + 1] = { 0 }; /* buffer used to build the key of the mailbox */
name = SIMIX_host_get_name(workstation);
/* Host structure */
host->name = xbt_strdup(name);
host->simdata = simdata;
host->data = data;
simdata->smx_host = workstation;
if (msg_global->max_channel > 0)
simdata->mailboxes = xbt_new0(msg_mailbox_t, msg_global->max_channel);
for (i = 0; i < msg_global->max_channel; i++) {
sprintf(alias, "%s:%d", name, i);
/* the key of the mailbox (in this case) is build from the name of the host and the channel number */
simdata->mailboxes[i] = MSG_mailbox_new(alias);
memset(alias, 0, MAX_ALIAS_NAME + 1);
}
SIMIX_req_host_set_data(workstation, host);
xbt_lib_set(host_lib,name,MSG_HOST_LEVEL,host);
return host;
}
static char* pointer_to_string(void* pointer) {
if (XBT_LOG_ISENABLED(mc_request, xbt_log_priority_verbose))
return bprintf("%p", pointer);
return xbt_strdup("(verbose only)");
}
int main(int argc, char **argv)
{
xbt_dynar_t dot;
unsigned int cursor;
SD_task_t task;
/* initialization of SD */
SD_init(&argc, argv);
/* Check our arguments */
xbt_assert(argc > 2, "Usage: %s platform_file dot_file [trace_file]"
"example: %s ../2clusters.xml dag.dot dag.mytrace", argv[0], argv[0]);
/* creation of the environment */
SD_create_environment(argv[1]);
/* load the DOT file */
dot = SD_dotload(argv[2]);
if(dot == NULL){
XBT_CRITICAL("No dot loaded. Do you have a cycle in your graph?");
SD_exit();
exit(2);
}
char *tracefilename;
char *last = strrchr(argv[2], '.');
tracefilename = bprintf("%.*s.trace", (int) (last == NULL ? strlen(argv[2]) : last - argv[2]),argv[2]);
if (argc == 4)
tracefilename = xbt_strdup(argv[3]);
/* Display all the tasks */
XBT_INFO("------------------- Display all tasks of the loaded DAG ---------------------------");
xbt_dynar_foreach(dot, cursor, task) {
SD_task_dump(task);
}
xbt_workload_elm_t xbt_workload_elm_parse(char *line)
{
xbt_workload_elm_t res = xbt_new(s_xbt_workload_elm_t, 1);
res->date = -1;
res->comment = NULL; /* it's not enough to memset for valgrind, apparently */
res->who = NULL;
res->str_arg = NULL;
xbt_dynar_t w = xbt_str_split(line, " ");
if (xbt_dynar_length(w) == 0) {
free(res);
xbt_dynar_free(&w);
return NULL;
}
char **words = xbt_dynar_get_ptr(w, 0);
int i = 0;
if (words[i][0] == '[') {
sscanf(words[i] + 1, "%lg", &(res->date));
i++;
}
res->who = xbt_strdup(words[i++]);
if (!strcmp(words[i], "recv")) {
res->action = XBT_WORKLOAD_RECV;
res->str_arg = xbt_strdup(words[++i]);
sscanf(words[++i], "%lg", &(res->d_arg));
} else if (!strcmp(words[i], "send")) {
res->action = XBT_WORKLOAD_SEND;
res->str_arg = xbt_strdup(words[++i]);
sscanf(words[++i], "%lg", &(res->d_arg));
} else if (!strcmp(words[i], "compute")) {
res->action = XBT_WORKLOAD_COMPUTE;
sscanf(words[++i], "%lg", &(res->d_arg));
} else {
xbt_die("Unparsable command: %s (in %s)", words[i], line);
}
i++;
if (words[i] && words[i][0] == '#') {
res->comment = xbt_strdup(strchr(line, '#') + 1);
}
xbt_dynar_free(&w);
return res;
}
int host(int argc, char *argv[])
{
msg_file_t file = NULL;
char* mount = xbt_strdup("/home");
size_t write;
// First open
XBT_INFO("\tOpen file '%s'",FILENAME1);
file = MSG_file_open(mount,FILENAME1);
// Unlink the file
XBT_INFO("\tUnlink file '%s'",file->fullname);
MSG_file_unlink(file);
// Re Open the file wich is in fact created
XBT_INFO("\tOpen file '%s'",FILENAME1);
file = MSG_file_open(mount,FILENAME1);
// Write into the new file
write = MSG_file_write(100000,file); // Write for 100Ko
XBT_INFO("\tHave written %zu on %s",write,file->fullname);
// Close the file
XBT_INFO("\tClose file '%s'",file->fullname);
MSG_file_close(file);
xbt_dict_t dict_ls;
char* key;
surf_stat_t data = NULL;
xbt_dict_cursor_t cursor = NULL;
dict_ls = MSG_file_ls(mount,"./");
XBT_INFO(" ");XBT_INFO("ls ./");
xbt_dict_foreach(dict_ls,cursor,key,data){
if(data) XBT_INFO("FILE : %s",key);
else XBT_INFO("DIR : %s",key);
}
xbt_dict_free(&dict_ls);
dict_ls = MSG_file_ls(mount,"./doc/simgrid/examples/platforms/");
XBT_INFO(" ");XBT_INFO("ls ./doc/simgrid/examples/platforms/");
xbt_dict_foreach(dict_ls,cursor,key,data){
if(data) XBT_INFO("FILE : %s",key);
else XBT_INFO("DIR : %s",key);
}
xbt_dict_free(&dict_ls);
dict_ls = MSG_file_ls(mount,"./doc/simgrid/examples/msg/");
XBT_INFO(" ");XBT_INFO("ls ./doc/simgrid/examples/msg/");
xbt_dict_foreach(dict_ls,cursor,key,data){
if(data) XBT_INFO("FILE : %s",key);
else XBT_INFO("DIR : %s",key);
}
xbt_dict_free(&dict_ls);
free(mount);
return 0;
}
static char *str_tolower (const char *str)
{
char *ret = xbt_strdup (str);
int i, n = strlen (ret);
for (i = 0; i < n; i++)
ret[i] = tolower (str[i]);
return ret;
}
JNIEXPORT void JNICALL Java_org_simgrid_msg_Msg_init(JNIEnv * env, jclass cls, jobjectArray jargs)
{
char **argv = nullptr;
int index;
int argc = 0;
jstring jval;
const char *tmp;
XBT_LOG_CONNECT(jmsg);
XBT_LOG_CONNECT(jtrace);
env->GetJavaVM(&__java_vm);
simgrid::simix::factory_initializer = simgrid::java::java_factory;
jthrowable exc = env->ExceptionOccurred();
if (exc) {
env->ExceptionClear();
}
setlocale(LC_NUMERIC,"C");
if (jargs)
argc = (int) env->GetArrayLength(jargs);
argc++;
argv = xbt_new(char *, argc + 1);
argv[0] = xbt_strdup("java");
for (index = 0; index < argc - 1; index++) {
jval = (jstring) env->GetObjectArrayElement(jargs, index);
tmp = env->GetStringUTFChars(jval, 0);
argv[index + 1] = xbt_strdup(tmp);
env->ReleaseStringUTFChars(jval, tmp);
}
argv[argc] = nullptr;
MSG_init(&argc, argv);
JAVA_HOST_LEVEL = simgrid::s4u::Host::extension_create(__JAVA_host_priv_free);
JAVA_STORAGE_LEVEL = xbt_lib_add_level(storage_lib, __JAVA_storage_priv_free);
for (index = 0; index < argc; index++)
free(argv[index]);
free(argv);
}
Storage::Storage(Model *model, const char *name, xbt_dict_t props,
lmm_system_t maxminSystem, double bread, double bwrite,
double bconnection, const char* type_id, char *content_name,
char *content_type, sg_size_t size, char *attach)
: Resource(model, name, props, lmm_constraint_new(maxminSystem, this, bconnection))
, p_contentType(content_type)
, m_size(size), m_usedSize(0)
, p_typeId(xbt_strdup(type_id))
, p_writeActions(xbt_dynar_new(sizeof(Action*),NULL)) {
surf_callback_emit(storageCreatedCallbacks, this);
p_content = parseContent(content_name);
p_attach = xbt_strdup(attach);
setState(SURF_RESOURCE_ON);
XBT_DEBUG("Create resource with Bconnection '%f' Bread '%f' Bwrite '%f' and Size '%llu'", bconnection, bread, bwrite, size);
p_constraintRead = lmm_constraint_new(maxminSystem, this, bread);
p_constraintWrite = lmm_constraint_new(maxminSystem, this, bwrite);
}
xbt_dynar_t xbt_str_split_quoted(const char *s)
{
xbt_dynar_t res = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
xbt_dynar_t parsed;
char *str_to_free; /* we have to copy the string before, to handle backslashes */
unsigned int cursor;
char *p;
if (s[0] == '\0')
return res;
str_to_free = xbt_strdup(s);
parsed = xbt_str_split_quoted_in_place(str_to_free);
xbt_dynar_foreach(parsed,cursor,p) {
char *q=xbt_strdup(p);
xbt_dynar_push(res,&q);
}
