X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/7329497f42d918f8bac62146274854ef8c199681..3203ed1f4fb6f4617e94d5351661ba07e8b8f833:/src/surf/surfxml_parseplatf.c diff --git a/src/surf/surfxml_parseplatf.c b/src/surf/surfxml_parseplatf.c index 894dc9e199..3a0f327421 100644 --- a/src/surf/surfxml_parseplatf.c +++ b/src/surf/surfxml_parseplatf.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011. The SimGrid Team. +/* Copyright (c) 2006-2015. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it @@ -9,8 +9,17 @@ #include "xbt/str.h" #include "xbt/dict.h" #include "simgrid/platf.h" -#include "surf/surfxml_parse_private.h" -#include "surf/surf_private.h" +#include "surf/surfxml_parse.h" +#include "src/surf/surf_private.h" + +#ifdef HAVE_LUA +#include "src/bindings/lua/simgrid_lua.h" +#include "src/bindings/lua/lua_state_cloner.h" + +#include /* Always include this when calling Lua */ +#include /* Always include this when calling Lua */ +#include /* Prototype for luaL_openlibs(), */ +#endif XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_parse); @@ -25,9 +34,8 @@ int surfxml_bufferstack_size = 2048; static char *old_buff = NULL; -unsigned int surfxml_buffer_stack_stack_ptr; -unsigned int surfxml_buffer_stack_stack[1024]; - +XBT_IMPORT_NO_EXPORT(unsigned int) surfxml_buffer_stack_stack_ptr; +XBT_IMPORT_NO_EXPORT(unsigned int) surfxml_buffer_stack_stack[1024]; void surfxml_bufferstack_push(int new) { @@ -49,16 +57,6 @@ void surfxml_bufferstack_pop(int new) } } -/* - * Pass arguments to parsing callback as structures to save some time (and allow callbacks to ignore some) - */ - -sg_platf_router_cbarg_t struct_router = NULL; -surf_parsing_cluster_arg_t struct_cluster = NULL; -surf_parsing_peer_arg_t struct_peer = NULL; -surf_parsing_link_arg_t struct_lnk = NULL; - - /* * Trace related stuff */ @@ -70,142 +68,125 @@ xbt_dict_t trace_connect_list_link_avail = NULL; xbt_dict_t trace_connect_list_bandwidth = NULL; xbt_dict_t trace_connect_list_latency = NULL; -static double trace_periodicity = -1.0; -static char *trace_file = NULL; -static char *trace_id = NULL; - -static void parse_Stag_trace(void) -{ - trace_id = xbt_strdup(A_surfxml_trace_id); - trace_file = xbt_strdup(A_surfxml_trace_file); - trace_periodicity = surf_parse_get_double(A_surfxml_trace_periodicity); +/* ********************************************* */ +/* TUTORIAL: New TAG */ +/* This function should be in gpu.c */ +/* because sg_platf_gpu_add_cb take a staic fct */ +XBT_PUBLIC(void) gpu_register_callbacks(void){ + sg_platf_gpu_add_cb(NULL); } - -static void parse_Etag_trace(void) -{ - tmgr_trace_t trace; - if (!trace_file || strcmp(trace_file, "") != 0) { - trace = tmgr_trace_new(trace_file); - } else { - if (strcmp(surfxml_pcdata, "") == 0) - trace = NULL; - else - trace = - tmgr_trace_new_from_string(trace_id, surfxml_pcdata, - trace_periodicity); - } - xbt_dict_set(traces_set_list, trace_id, (void *) trace, NULL); - xbt_free(trace_file); - trace_file = NULL; - xbt_free(trace_id); - trace_id = NULL; -} - -static void parse_Stag_trace_connect(void) -{ - xbt_assert(xbt_dict_get_or_null - (traces_set_list, A_surfxml_trace_connect_trace), - "Cannot connect trace %s to %s: trace unknown", - A_surfxml_trace_connect_trace, - A_surfxml_trace_connect_element); - - switch (A_surfxml_trace_connect_kind) { - case A_surfxml_trace_connect_kind_HOST_AVAIL: - xbt_dict_set(trace_connect_list_host_avail, - A_surfxml_trace_connect_trace, - xbt_strdup(A_surfxml_trace_connect_element), free); - break; - case A_surfxml_trace_connect_kind_POWER: - xbt_dict_set(trace_connect_list_power, A_surfxml_trace_connect_trace, - xbt_strdup(A_surfxml_trace_connect_element), free); - break; - case A_surfxml_trace_connect_kind_LINK_AVAIL: - xbt_dict_set(trace_connect_list_link_avail, - A_surfxml_trace_connect_trace, - xbt_strdup(A_surfxml_trace_connect_element), free); - break; - case A_surfxml_trace_connect_kind_BANDWIDTH: - xbt_dict_set(trace_connect_list_bandwidth, - A_surfxml_trace_connect_trace, - xbt_strdup(A_surfxml_trace_connect_element), free); - break; - case A_surfxml_trace_connect_kind_LATENCY: - xbt_dict_set(trace_connect_list_latency, A_surfxml_trace_connect_trace, - xbt_strdup(A_surfxml_trace_connect_element), free); - break; - default: - xbt_die("Cannot connect trace %s to %s: kind of trace unknown", - A_surfxml_trace_connect_trace, A_surfxml_trace_connect_element); - break; +/* ***************************************** */ + +static int after_config_done; +void parse_after_config() { + if (!after_config_done) { + TRACE_start(); + + /* Register classical callbacks */ + storage_register_callbacks(); + routing_register_callbacks(); + gpu_register_callbacks(); + + /* ***************************************** */ + /* TUTORIAL: New TAG */ + /* ***************************************** */ + after_config_done = 1; } } -/* Call the right C function when we see the tags */ -static void parse_S_AS(void) { - sg_platf_new_AS_open(A_surfxml_AS_id, A_surfxml_AS_routing); -} -static void parse_E_AS(void) { - sg_platf_new_AS_close(); -} - -/* Init and free parse data */ - -static void init_data(void) -{ - if (!surfxml_bufferstack_stack) - surfxml_bufferstack_stack = xbt_dynar_new(sizeof(char *), NULL); - - traces_set_list = xbt_dict_new(); - trace_connect_list_host_avail = xbt_dict_new(); - trace_connect_list_power = xbt_dict_new(); - trace_connect_list_link_avail = xbt_dict_new(); - trace_connect_list_bandwidth = xbt_dict_new(); - trace_connect_list_latency = xbt_dict_new(); - - surfxml_add_callback(STag_surfxml_trace_cb_list, &parse_Stag_trace); - surfxml_add_callback(ETag_surfxml_trace_cb_list, &parse_Etag_trace); - surfxml_add_callback(STag_surfxml_trace_connect_cb_list, - &parse_Stag_trace_connect); - - /* we care about the ASes while parsing the platf. Incredible, isnt it? */ - surfxml_add_callback(STag_surfxml_AS_cb_list, &parse_S_AS); - surfxml_add_callback(ETag_surfxml_AS_cb_list, &parse_E_AS); -} - -static void free_data(void) -{ - xbt_dict_free(&trace_connect_list_host_avail); - xbt_dict_free(&trace_connect_list_power); - xbt_dict_free(&trace_connect_list_link_avail); - xbt_dict_free(&trace_connect_list_bandwidth); - xbt_dict_free(&trace_connect_list_latency); - xbt_dict_free(&traces_set_list); - xbt_dict_free(&random_data_list); - xbt_dynar_free(&surfxml_bufferstack_stack); -} - /* This function acts as a main in the parsing area. */ void parse_platform_file(const char *file) { - int parse_status; - - surf_parse_reset_callbacks(); +#ifdef HAVE_LUA + int is_lua = (file != NULL && strlen(file) > 3 && file[strlen(file)-3] == 'l' && file[strlen(file)-2] == 'u' + && file[strlen(file)-1] == 'a'); +#endif + + surf_parse_init_callbacks(); + +#ifdef HAVE_LUA + /* Check if file extension is "lua". If so, we will use + * the lua bindings to parse the platform file (since it is + * written in lua). If not, we will use the (old?) XML parser + */ + if (is_lua) { + // Get maestro state. In case we're calling Lua from + // C only, this will be NULL -- no Lua code has been + // executed yet and hence, the SimGrid module has not + // yet been loaded. + // NOTE: After executing the lua_pcall() below, + // sglua_get_maestro() will not be NULL, since the + // SimGrid module was loaded! + lua_State* L = sglua_get_maestro(); + + // We may want to remove the task_copy_callback from + // the SimGrid module if we're using C code only (this + // callback is used for Lua-only code). + int remove_callback = FALSE; + if (L == NULL) { + L = luaL_newstate(); + remove_callback = TRUE; + } + luaL_openlibs(L); + + luaL_loadfile(L, file); // This loads the file without executing it. + + /* Run the script */ + if (lua_pcall(L, 0, 0, 0)) { + XBT_ERROR("FATAL ERROR:\n %s: %s\n\n", "Lua call failed. Errormessage:", lua_tostring(L, -1)); + xbt_die("Lua call failed. See Log"); + } + // Without this, task_copy_callback() will try to copy + // some tasks -- but these don't exist in case we're using + // C. Hence, we need to remove the callback -- we don't + // want to segfault. + if (remove_callback) { + MSG_task_set_copy_callback(NULL); + } - /* Register classical callbacks */ - surfxml_add_callback(STag_surfxml_prop_cb_list, &parse_properties_XML); - surf_parse_add_callback_config(); + } + else +#endif + { // Use XML parser + + int parse_status; + + /* init the flex parser */ + surfxml_buffer_stack_stack_ptr = 1; + surfxml_buffer_stack_stack[0] = 0; + after_config_done = 0; + surf_parse_open(file); + + traces_set_list = xbt_dict_new_homogeneous(NULL); + trace_connect_list_host_avail = xbt_dict_new_homogeneous(free); + trace_connect_list_power = xbt_dict_new_homogeneous(free); + trace_connect_list_link_avail = xbt_dict_new_homogeneous(free); + trace_connect_list_bandwidth = xbt_dict_new_homogeneous(free); + trace_connect_list_latency = xbt_dict_new_homogeneous(free); + + /* Init my data */ + if (!surfxml_bufferstack_stack) + surfxml_bufferstack_stack = xbt_dynar_new(sizeof(char *), NULL); + + /* Do the actual parsing */ + parse_status = surf_parse(); + + /* Free my data */ + xbt_dict_free(&trace_connect_list_host_avail); + xbt_dict_free(&trace_connect_list_power); + xbt_dict_free(&trace_connect_list_link_avail); + xbt_dict_free(&trace_connect_list_bandwidth); + xbt_dict_free(&trace_connect_list_latency); + xbt_dict_free(&traces_set_list); + xbt_dict_free(&random_data_list); + xbt_dynar_free(&surfxml_bufferstack_stack); + + surf_parse_close(); + + if (parse_status) + surf_parse_error("Parse error in %s", file); - surfxml_buffer_stack_stack_ptr = 1; - surfxml_buffer_stack_stack[0] = 0; + } - surf_parse_open(file); - init_data(); - parse_status = surf_parse(); - free_data(); - surf_parse_close(); - if (parse_status) - xbt_die("Parse error in %s", file); - surf_config_models_create_elms(); } -