host_parameters.id = NULL;
//Power from 3,000,000 to 10,000,000
- host_parameters.power_peak = xbt_dynar_new(sizeof(double), NULL);
- xbt_dynar_push_as(host_parameters.power_peak, double,
+ host_parameters.speed_peak = xbt_dynar_new(sizeof(double), NULL);
+ xbt_dynar_push_as(host_parameters.speed_peak, double,
7000000 * RngStream_RandU01(rng_stream) + 3000000.0);
host_parameters.core_amount = 1;
- host_parameters.power_scale = 1;
- host_parameters.power_trace = NULL;
+ host_parameters.speed_scale = 1;
+ host_parameters.speed_trace = NULL;
host_parameters.initial_state = SURF_RESOURCE_ON;
host_parameters.state_trace = NULL;
host_parameters.coord = NULL;
static int master_choosen = FALSE;
host_parameters.id = NULL;
- host_parameters.power_peak = xbt_dynar_new(sizeof(double), NULL);
- xbt_dynar_push_as(host_parameters.power_peak, double, 25000000.0);
+ host_parameters.speed_peak = xbt_dynar_new(sizeof(double), NULL);
+ xbt_dynar_push_as(host_parameters.speed_peak, double, 25000000.0);
host_parameters.core_amount = 1;
- host_parameters.power_scale = 1;
- host_parameters.power_trace = NULL;
+ host_parameters.speed_scale = 1;
+ host_parameters.speed_trace = NULL;
host_parameters.initial_state = SURF_RESOURCE_ON;
host_parameters.state_trace = NULL;
host_parameters.coord = NULL;
tmgr_event_generator_new_uniform(pw_date_generator_id, 5, 10);
probabilist_event_generator_t pw_value_generator =
tmgr_event_generator_new_uniform(pw_value_generator_id, 0.6, 1.0);
- host_parameters.power_trace =
+ host_parameters.speed_trace =
tmgr_trace_generator_value(bprintf("pw_host_%ld", node->id),
pw_date_generator,
pw_value_generator);
s_sg_platf_host_cbarg_t host_parameters;
host_parameters.id = NULL;
- host_parameters.power_peak = xbt_dynar_new(sizeof(double), NULL);
- xbt_dynar_push_as(host_parameters.power_peak, double, 1000000.0);
+ host_parameters.speed_peak = xbt_dynar_new(sizeof(double), NULL);
+ xbt_dynar_push_as(host_parameters.speed_peak, double, 1000000.0);
host_parameters.core_amount = 1;
- host_parameters.power_scale = 1;
- host_parameters.power_trace = NULL;
+ host_parameters.speed_scale = 1;
+ host_parameters.speed_trace = NULL;
host_parameters.initial_state = SURF_RESOURCE_ON;
host_parameters.state_trace = NULL;
host_parameters.coord = NULL;
s_sg_platf_host_cbarg_t bob = SG_PLATF_HOST_INITIALIZER;
bob.id = "bob";
- bob.power_peak = xbt_dynar_new(sizeof(double), NULL);
- xbt_dynar_push_as(bob.power_peak, double, 98095000.0);
+ bob.speed_peak = xbt_dynar_new(sizeof(double), NULL);
+ xbt_dynar_push_as(bob.speed_peak, double, 98095000.0);
sg_platf_new_host(&bob);
- xbt_dynar_free(&bob.power_peak);
+ xbt_dynar_free(&bob.speed_peak);
s_sg_platf_host_cbarg_t alice = SG_PLATF_HOST_INITIALIZER;
alice.id = "alice";
- alice.power_peak = xbt_dynar_new(sizeof(double), NULL);
- xbt_dynar_push_as(alice.power_peak, double, 98095000.0);
+ alice.speed_peak = xbt_dynar_new(sizeof(double), NULL);
+ xbt_dynar_push_as(alice.speed_peak, double, 98095000.0);
sg_platf_new_host(&alice);
- xbt_dynar_free(&alice.power_peak);
+ xbt_dynar_free(&alice.speed_peak);
s_sg_platf_link_cbarg_t link = SG_PLATF_LINK_INITIALIZER;
link.id = "link1";
typedef struct {
const char* id;
- xbt_dynar_t power_peak;
+ xbt_dynar_t speed_peak;
int pstate;
int core_amount;
- double power_scale;
- tmgr_trace_t power_trace;
+ double speed_scale;
+ tmgr_trace_t speed_trace;
e_surf_resource_state_t initial_state;
tmgr_trace_t state_trace;
const char* coord;
typedef struct s_sg_platf_peer_cbarg *sg_platf_peer_cbarg_t;
typedef struct s_sg_platf_peer_cbarg {
const char* id;
- double power;
+ double speed;
double bw_in;
double bw_out;
double lat;
const char* prefix;
const char* suffix;
const char* radical;
- double power;
+ double speed;
int core_amount;
double bw;
double lat;
const char* prefix;
const char* suffix;
const char* radical;
- double power;
+ double speed;
double bw;
double lat;
} s_sg_platf_cabinet_cbarg_t;
XBT_PUBLIC(double) surf_parse_get_time(const char *string);
XBT_PUBLIC(double) surf_parse_get_size(const char *string);
XBT_PUBLIC(double) surf_parse_get_bandwidth(const char *string);
-XBT_PUBLIC(double) surf_parse_get_power(const char *string);
+XBT_PUBLIC(double) surf_parse_get_speed(const char *string);
/* Prototypes of the functions offered by flex */
XBT_PUBLIC(int) surf_parse_lex(void);
if (type != LUA_TSTRING && type != LUA_TNUMBER) {
XBT_ERROR("Attribute 'power' must be specified for host and must either be a string (in the correct format; check documentation) or a number.");
}
- host.power_peak = xbt_dynar_new(sizeof(double), NULL);
- xbt_dynar_push_as(host.power_peak, double, get_cpu_power(lua_tostring(L, -1)));
+ host.speed_peak = xbt_dynar_new(sizeof(double), NULL);
+ xbt_dynar_push_as(host.speed_peak, double, get_cpu_speed(lua_tostring(L, -1)));
lua_pop(L, 1);
// get core
//get power_scale
lua_pushstring(L, "availability");
lua_gettable(L, -2);
- if(!lua_isnumber(L,-1)) host.power_scale = 1;// Default value
- else host.power_scale = lua_tonumber(L, -1);
+ if(!lua_isnumber(L,-1)) host.speed_scale = 1;// Default value
+ else host.speed_scale = lua_tonumber(L, -1);
lua_pop(L, 1);
//get power_trace
lua_pushstring(L, "availability_file");
lua_gettable(L, -2);
- host.power_trace = tmgr_trace_new_from_file(lua_tostring(L, -1));
+ host.speed_trace = tmgr_trace_new_from_file(lua_tostring(L, -1));
lua_pop(L, 1);
//get state initial
lua_pop(L, 1);
sg_platf_new_host(&host);
- xbt_dynar_free(&host.power_peak);
+ xbt_dynar_free(&host.speed_peak);
return 0;
}
XBT_PUBLIC_DATA(xbt_dict_t) trace_connect_list_latency;
-XBT_PUBLIC(double) get_cpu_power(const char *power);
+XBT_PUBLIC(double) get_cpu_speed(const char *power);
XBT_PUBLIC(xbt_dict_t) get_as_router_properties(const char* name);
return trace_disable_link && TRACE_is_enabled();
}
-int TRACE_disable_power(void)
+int TRACE_disable_speed(void)
{
return trace_disable_power && TRACE_is_enabled();
}
XBT_PRIVATE int TRACE_msg_vm_is_enabled(void);
XBT_PRIVATE int TRACE_buffer (void);
XBT_PRIVATE int TRACE_disable_link(void);
-XBT_PRIVATE int TRACE_disable_power(void);
+XBT_PRIVATE int TRACE_disable_speed(void);
XBT_PRIVATE int TRACE_onelink_only (void);
XBT_PRIVATE int TRACE_disable_destroy (void);
XBT_PRIVATE int TRACE_basic (void);
delete p_cpuRunningActionSetThatDoesNotNeedBeingChecked;
}
-Cpu *CpuCas01Model::createCpu(const char *name, xbt_dynar_t power_peak,
- int pstate, double power_scale,
- tmgr_trace_t power_trace, int core,
+Cpu *CpuCas01Model::createCpu(const char *name, xbt_dynar_t speedPeak,
+ int pstate, double speedScale,
+ tmgr_trace_t speedTrace, int core,
e_surf_resource_state_t state_initial,
tmgr_trace_t state_trace,
xbt_dict_t cpu_properties)
{
Cpu *cpu = NULL;
sg_host_t host = sg_host_by_name(name);
- xbt_assert(xbt_dynar_getfirst_as(power_peak, double) > 0.0,
- "Power has to be >0.0. Did you forget to specify the mandatory power attribute?");
+ xbt_assert(xbt_dynar_getfirst_as(speedPeak, double) > 0.0,
+ "Speed has to be >0.0. Did you forget to specify the mandatory power attribute?");
xbt_assert(core > 0, "Invalid number of cores %d. Must be larger than 0", core);
- cpu = new CpuCas01(this, name, power_peak, pstate, power_scale, power_trace, core, state_initial, state_trace, cpu_properties);
+ cpu = new CpuCas01(this, name, speedPeak, pstate, speedScale, speedTrace, core, state_initial, state_trace, cpu_properties);
sg_host_surfcpu_register(host, cpu);
return cpu;
}
/************
* Resource *
************/
-CpuCas01::CpuCas01(CpuCas01Model *model, const char *name, xbt_dynar_t powerPeak,
- int pstate, double powerScale, tmgr_trace_t powerTrace, int core,
+CpuCas01::CpuCas01(CpuCas01Model *model, const char *name, xbt_dynar_t speedPeak,
+ int pstate, double speedScale, tmgr_trace_t speedTrace, int core,
e_surf_resource_state_t stateInitial, tmgr_trace_t stateTrace,
xbt_dict_t properties)
: Cpu(model, name, properties,
- lmm_constraint_new(model->getMaxminSystem(), this, core * powerScale * xbt_dynar_get_as(powerPeak, pstate, double)),
- core, xbt_dynar_get_as(powerPeak, pstate, double), powerScale,
+ lmm_constraint_new(model->getMaxminSystem(), this, core * speedScale * xbt_dynar_get_as(speedPeak, pstate, double)),
+ core, xbt_dynar_get_as(speedPeak, pstate, double), speedScale,
stateInitial) {
p_speedEvent = NULL;
// Copy the power peak array:
p_speedPeakList = xbt_dynar_new(sizeof(double), nullptr);
- unsigned long n = xbt_dynar_length(powerPeak);
+ unsigned long n = xbt_dynar_length(speedPeak);
for (unsigned long i = 0; i != n; ++i) {
- double value = xbt_dynar_get_as(powerPeak, i, double);
+ double value = xbt_dynar_get_as(speedPeak, i, double);
xbt_dynar_push(p_speedPeakList, &value);
}
XBT_DEBUG("CPU create: peak=%f, pstate=%d", m_speedPeak, m_pstate);
m_core = core;
- if (powerTrace)
- p_speedEvent = tmgr_history_add_trace(history, powerTrace, 0.0, 0, this);
+ if (speedTrace)
+ p_speedEvent = tmgr_history_add_trace(history, speedTrace, 0.0, 0, this);
if (stateTrace)
p_stateEvent = tmgr_history_add_trace(history, stateTrace, 0.0, 0, this);
p_speedEvent = powerEvent;
}
-xbt_dynar_t CpuCas01::getPowerPeakList(){
+xbt_dynar_t CpuCas01::getSpeedPeakList(){
return p_speedPeakList;
}
if (event_type == p_speedEvent) {
/* TODO (Hypervisor): do the same thing for constraint_core[i] */
- xbt_assert(m_core == 1, "FIXME: add power scaling code also for constraint_core[i]");
+ xbt_assert(m_core == 1, "FIXME: add speed scaling code also for constraint_core[i]");
m_speedScale = value;
lmm_update_constraint_bound(getModel()->getMaxminSystem(), getConstraint(),
m_core * m_speedScale *
m_speedPeak);
- TRACE_surf_host_set_power(date, getName(),
+ TRACE_surf_host_set_speed(date, getName(),
m_core * m_speedScale *
m_speedPeak);
while ((var = lmm_get_var_from_cnst
* Action *
**********/
-CpuCas01Action::CpuCas01Action(Model *model, double cost, bool failed, double power, lmm_constraint_t constraint)
+CpuCas01Action::CpuCas01Action(Model *model, double cost, bool failed, double speed, lmm_constraint_t constraint)
: CpuAction(model, cost, failed,
lmm_variable_new(model->getMaxminSystem(), this,
- 1.0, power, 1))
+ 1.0, speed, 1))
{
m_suspended = 0;
if (model->getUpdateMechanism() == UM_LAZY) {
class CpuCas01 : public Cpu {
public:
- CpuCas01(CpuCas01Model *model, const char *name, xbt_dynar_t power_peak,
- int pstate, double powerScale, tmgr_trace_t powerTrace, int core,
+ CpuCas01(CpuCas01Model *model, const char *name, xbt_dynar_t speedPeak,
+ int pstate, double speedScale, tmgr_trace_t speedTrace, int core,
e_surf_resource_state_t stateInitial, tmgr_trace_t stateTrace,
xbt_dict_t properties) ;
~CpuCas01();
bool isUsed();
void setStateEvent(tmgr_trace_event_t stateEvent);
void setPowerEvent(tmgr_trace_event_t stateEvent);
- xbt_dynar_t getPowerPeakList();
+ xbt_dynar_t getSpeedPeakList();
int getPState();
friend CpuAction *CpuCas01::execute(double size);
friend CpuAction *CpuCas01::sleep(double duration);
public:
- CpuCas01Action(Model *model, double cost, bool failed, double power,
+ CpuCas01Action(Model *model, double cost, bool failed, double speed,
lmm_constraint_t constraint);
~CpuCas01Action() {};
Cpu::Cpu(Model *model, const char *name, xbt_dict_t props,
- int core, double powerPeak, double powerScale,
+ int core, double speedPeak, double speedScale,
e_surf_resource_state_t stateInitial)
: Resource(model, name, props, stateInitial)
, m_core(core)
- , m_speedPeak(powerPeak)
- , m_speedScale(powerScale)
+ , m_speedPeak(speedPeak)
+ , m_speedScale(speedScale)
, p_constraintCore(NULL)
, p_constraintCoreId(NULL)
{
*********/
class CpuTiTrace {
public:
- CpuTiTrace(tmgr_trace_t powerTrace);
+ CpuTiTrace(tmgr_trace_t speedTrace);
~CpuTiTrace();
double integrateSimple(double a, double b);
enum trace_type {
TRACE_FIXED, /*< Trace fixed, no availability file */
- TRACE_DYNAMIC /*< Dynamic, availability file disponible */
+ TRACE_DYNAMIC /*< Dynamic, have an availability file */
};
class CpuTiTgmr {
public:
CpuTiTgmr(trace_type type, double value): m_type(type), m_value(value){};
- CpuTiTgmr(tmgr_trace_t power_trace, double value);
+ CpuTiTgmr(tmgr_trace_t speedTrace, double value);
~CpuTiTgmr();
double integrate(double a, double b);
double getPowerScale(double a);
trace_type m_type;
- double m_value; /*< Percentage of cpu power disponible. Value fixed between 0 and 1 */
+ double m_value; /*< Percentage of cpu speed available. Value fixed between 0 and 1 */
/* Dynamic */
double m_lastTime; /*< Integral interval last point (discret time) */
container_t father = *(container_t*)xbt_dynar_get_ptr(currentContainer, xbt_dynar_length(currentContainer)-1);
container_t container = PJ_container_new (host->id, INSTR_HOST, father);
- if ((TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) && (! TRACE_disable_power())) {
- type_t power = PJ_type_get_or_null ("power", container->type);
- if (power == NULL){
- power = PJ_type_variable_new ("power", NULL, container->type);
+ if ((TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) && (! TRACE_disable_speed())) {
+ type_t speed = PJ_type_get_or_null ("power", container->type);
+ if (speed == NULL){
+ speed = PJ_type_variable_new ("power", NULL, container->type);
}
- double current_power_state;
- xbt_dynar_get_cpy(host->power_peak, host->pstate, ¤t_power_state);
- new_pajeSetVariable (0, container, power, current_power_state);
+ double current_speed_state;
+ xbt_dynar_get_cpy(host->speed_peak, host->pstate, ¤t_speed_state);
+ new_pajeSetVariable (0, container, speed, current_speed_state);
}
if (TRACE_uncategorized()){
- type_t power_used = PJ_type_get_or_null ("power_used", container->type);
- if (power_used == NULL){
+ type_t speed_used = PJ_type_get_or_null ("power_used", container->type);
+ if (speed_used == NULL){
PJ_type_variable_new ("power_used", "0.5 0.5 0.5", container->type);
}
}
TRACE_surf_resource_utilization_release();
}
-void TRACE_surf_host_set_power(double date, const char *resource, double power)
+void TRACE_surf_host_set_speed(double date, const char *resource, double speed)
{
if (TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) {
container_t container = PJ_container_get(resource);
type_t type = PJ_type_get ("power", container->type);
- new_pajeSetVariable(date, container, type, power);
+ new_pajeSetVariable(date, container, type, speed);
}
}
Cpu *cpu = surf_cpu_model_pm->createCpu(
host->id,
- host->power_peak,
+ host->speed_peak,
host->pstate,
- host->power_scale,
- host->power_trace,
+ host->speed_scale,
+ host->speed_trace,
host->core_amount,
host->initial_state,
host->state_trace,
/********** Tracing **********/
/* from surf_instr.c */
-void TRACE_surf_host_set_power(double date, const char *resource, double power);
+void TRACE_surf_host_set_speed(double date, const char *resource, double power);
void TRACE_surf_link_set_bandwidth(double date, const char *resource, double bandwidth);
/********** Instr. **********/
memset(&host, 0, sizeof(host));
host.initial_state = SURF_RESOURCE_ON;
host.pstate = 0;
- host.power_scale = 1.0;
+ host.speed_scale = 1.0;
host.core_amount = 1;
s_sg_platf_link_cbarg_t link = SG_PLATF_LINK_INITIALIZER;
link_id = bprintf("link_%s%d%s",cabinet->prefix,i,cabinet->suffix);
host.id = host_id;
link.id = link_id;
- host.power_peak = xbt_dynar_new(sizeof(double), NULL);
- xbt_dynar_push(host.power_peak,&cabinet->power);
+ host.speed_peak = xbt_dynar_new(sizeof(double), NULL);
+ xbt_dynar_push(host.speed_peak,&cabinet->speed);
sg_platf_new_host(&host);
- xbt_dynar_free(&host.power_peak);
+ xbt_dynar_free(&host.speed_peak);
sg_platf_new_link(&link);
char* link_up = bprintf("%s_UP",link_id);
bprintf("%s%d%s", cluster->prefix, i, cluster->suffix);
link_id = bprintf("%s_link_%d", cluster->id, i);
- XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\">", host_id, cluster->power);
+ XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\">", host_id, cluster->speed);
memset(&host, 0, sizeof(host));
host.id = host_id;
xbt_dict_set(patterns, "radical", bprintf("%d", i), NULL);
char *avail_file = xbt_str_varsubst(cluster->availability_trace, patterns);
XBT_DEBUG("\tavailability_file=\"%s\"", avail_file);
- host.power_trace = tmgr_trace_new_from_file(avail_file);
+ host.speed_trace = tmgr_trace_new_from_file(avail_file);
xbt_free(avail_file);
} else {
XBT_DEBUG("\tavailability_file=\"\"");
XBT_DEBUG("\tstate_file=\"\"");
}
- host.power_peak = xbt_dynar_new(sizeof(double), NULL);
- xbt_dynar_push(host.power_peak,&cluster->power);
+ host.speed_peak = xbt_dynar_new(sizeof(double), NULL);
+ xbt_dynar_push(host.speed_peak,&cluster->speed);
host.pstate = 0;
//host.power_peak = cluster->power;
- host.power_scale = 1.0;
+ host.speed_scale = 1.0;
host.core_amount = cluster->core_amount;
host.initial_state = SURF_RESOURCE_ON;
host.coord = "";
sg_platf_new_host(&host);
- xbt_dynar_free(&host.power_peak);
+ xbt_dynar_free(&host.speed_peak);
XBT_DEBUG("</host>");
XBT_DEBUG("<link\tid=\"%s\"\tbw=\"%f\"\tlat=\"%f\"/>", link_id,
current_routing->p_linkUpDownList = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL);
- XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\"/>", host_id, peer->power);
+ XBT_DEBUG("<host\tid=\"%s\"\tpower=\"%f\"/>", host_id, peer->speed);
s_sg_platf_host_cbarg_t host = SG_PLATF_HOST_INITIALIZER;
memset(&host, 0, sizeof(host));
host.initial_state = SURF_RESOURCE_ON;
host.id = host_id;
- host.power_peak = xbt_dynar_new(sizeof(double), NULL);
- xbt_dynar_push(host.power_peak,&peer->power);
+ host.speed_peak = xbt_dynar_new(sizeof(double), NULL);
+ xbt_dynar_push(host.speed_peak,&peer->speed);
host.pstate = 0;
//host.power_peak = peer->power;
- host.power_scale = 1.0;
- host.power_trace = peer->availability_trace;
+ host.speed_scale = 1.0;
+ host.speed_trace = peer->availability_trace;
host.state_trace = peer->state_trace;
host.core_amount = 1;
sg_platf_new_host(&host);
- xbt_dynar_free(&host.power_peak);
+ xbt_dynar_free(&host.speed_peak);
s_sg_platf_link_cbarg_t link = SG_PLATF_LINK_INITIALIZER;
memset(&link, 0, sizeof(link));
return surf_parse_get_value_with_unit(string, units);
}
-double surf_parse_get_power(const char *string)
+double surf_parse_get_speed(const char *string)
{
const struct unit_scale units[] = {
{ "yottaflops", 1e24 },
buf = A_surfxml_host_power;
XBT_DEBUG("Buffer: %s", buf);
- host.power_peak = xbt_dynar_new(sizeof(double), NULL);
+ host.speed_peak = xbt_dynar_new(sizeof(double), NULL);
if (strchr(buf, ',') == NULL){
- double power_value = get_cpu_power(A_surfxml_host_power);
- xbt_dynar_push_as(host.power_peak,double, power_value);
+ double speed = get_cpu_speed(A_surfxml_host_power);
+ xbt_dynar_push_as(host.speed_peak,double, speed);
}
else {
xbt_dynar_t pstate_list = xbt_str_split(buf, ",");
int i;
for (i = 0; i < xbt_dynar_length(pstate_list); i++) {
- double power_value;
- char* power_value_str;
-
- xbt_dynar_get_cpy(pstate_list, i, &power_value_str);
- xbt_str_trim(power_value_str, NULL);
- power_value = get_cpu_power(power_value_str);
- xbt_dynar_push_as(host.power_peak, double, power_value);
- XBT_DEBUG("Power value: %f", power_value);
+ double speed;
+ char* speed_str;
+
+ xbt_dynar_get_cpy(pstate_list, i, &speed_str);
+ xbt_str_trim(speed_str, NULL);
+ speed = get_cpu_speed(speed_str);
+ xbt_dynar_push_as(host.speed_peak, double, speed);
+ XBT_DEBUG("Speed value: %f", speed);
}
xbt_dynar_free(&pstate_list);
}
XBT_DEBUG("pstate: %s", A_surfxml_host_pstate);
- //host.power_peak = get_cpu_power(A_surfxml_host_power);
- host.power_scale = surf_parse_get_double( A_surfxml_host_availability);
+ host.speed_scale = surf_parse_get_double( A_surfxml_host_availability);
host.core_amount = surf_parse_get_int(A_surfxml_host_core);
- host.power_trace = tmgr_trace_new_from_file(A_surfxml_host_availability___file);
+ host.speed_trace = tmgr_trace_new_from_file(A_surfxml_host_availability___file);
host.state_trace = tmgr_trace_new_from_file(A_surfxml_host_state___file);
host.pstate = surf_parse_get_int(A_surfxml_host_pstate);
host.coord = A_surfxml_host_coordinates;
sg_platf_new_host(&host);
- xbt_dynar_free(&host.power_peak);
+ xbt_dynar_free(&host.speed_peak);
current_property_set = NULL;
}
cluster.prefix = A_surfxml_cluster_prefix;
cluster.suffix = A_surfxml_cluster_suffix;
cluster.radical = A_surfxml_cluster_radical;
- cluster.power = surf_parse_get_power(A_surfxml_cluster_power);
+ cluster.speed = surf_parse_get_speed(A_surfxml_cluster_power);
cluster.core_amount = surf_parse_get_int(A_surfxml_cluster_core);
cluster.bw = surf_parse_get_bandwidth(A_surfxml_cluster_bw);
cluster.lat = surf_parse_get_time(A_surfxml_cluster_lat);
cabinet.id = A_surfxml_cabinet_id;
cabinet.prefix = A_surfxml_cabinet_prefix;
cabinet.suffix = A_surfxml_cabinet_suffix;
- cabinet.power = surf_parse_get_power(A_surfxml_cabinet_power);
+ cabinet.speed = surf_parse_get_speed(A_surfxml_cabinet_power);
cabinet.bw = surf_parse_get_bandwidth(A_surfxml_cabinet_bw);
cabinet.lat = surf_parse_get_time(A_surfxml_cabinet_lat);
cabinet.radical = A_surfxml_cabinet_radical;
s_sg_platf_peer_cbarg_t peer = SG_PLATF_PEER_INITIALIZER;
memset(&peer,0,sizeof(peer));
peer.id = A_surfxml_peer_id;
- peer.power = surf_parse_get_power(A_surfxml_peer_power);
+ peer.speed = surf_parse_get_speed(A_surfxml_peer_power);
peer.bw_in = surf_parse_get_bandwidth(A_surfxml_peer_bw___in);
peer.bw_out = surf_parse_get_bandwidth(A_surfxml_peer_bw___out);
peer.lat = surf_parse_get_time(A_surfxml_peer_lat);
* With XML parser
*/
-double get_cpu_power(const char *power)
+double get_cpu_speed(const char *str_speed)
{
- double power_scale = 0.0;
+ double speed = 0.0;
const char *p, *q;
char *generator;
random_data_t random = NULL;
/* randomness is inserted like this: power="$rand(my_random)" */
- if (((p = strstr(power, "$rand(")) != NULL)
- && ((q = strstr(power, ")")) != NULL)) {
+ if (((p = strstr(str_speed, "$rand(")) != NULL)
+ && ((q = strstr(str_speed, ")")) != NULL)) {
if (p < q) {
generator = xbt_malloc(q - (p + 6) + 1);
memcpy(generator, p + 6, q - (p + 6));
generator[q - (p + 6)] = '\0';
random = xbt_dict_get_or_null(random_data_list, generator);
xbt_assert(random, "Random generator %s undefined", generator);
- power_scale = random_generate(random);
+ speed = random_generate(random);
}
} else {
- power_scale = surf_parse_get_power(power);
+ speed = surf_parse_get_speed(str_speed);
}
- return power_scale;
+ return speed;
}
double random_min, random_max, random_mean, random_std_deviation;
CpuCas01 *sub_cpu = static_cast<CpuCas01*>(sg_host_surfcpu(host_PM));
p_cpu = surf_cpu_model_vm->createCpu(name, // name
- sub_cpu->getPowerPeakList(), // host->power_peak,
+ sub_cpu->getSpeedPeakList(), // host->power_peak,
sub_cpu->getPState(),
1, // host->power_scale,
NULL, // host->power_trace,
