static void test_heap_mean_operation(int size)
{
xbt_heap_t heap = xbt_heap_new(size, NULL);
double date = xbt_os_time() * 1000000;
for (int i = 0; i < size; i++)
xbt_heap_push(heap, NULL, (10.0 * rand() / (RAND_MAX + 1.0)));
date = xbt_os_time() * 1000000 - date;
printf("Creation time %d size heap : %g\n", size, date);
date = xbt_os_time() * 1000000;
for (int j = 0; j < MAX_TEST; j++) {
if (!(j % size) && j)
test_reset_heap(&heap, size);
double val = xbt_heap_maxkey(heap);
xbt_heap_pop(heap);
xbt_heap_push(heap, NULL, 3.0 * val);
}
date = xbt_os_time() * 1000000 - date;
printf("Mean access time for a %d size heap : %g\n", size, date * 1.0 / (MAX_TEST + 0.0));
xbt_heap_free(heap);
}
void test_heap_validity(int size)
{
xbt_heap_t heap = xbt_heap_new(size, NULL);
double *tab = xbt_new0(double, size);
int i;
for (i = 0; i < size; i++) {
tab[i] = (double) (10.0 * rand() / (RAND_MAX + 1.0));
xbt_heap_push(heap, NULL, (double) tab[i]);
}
qsort(tab, size, sizeof(double), compare_double);
for (i = 0; i < size; i++) {
/* printf("%g" " ", xbt_heap_maxkey(heap)); */
if (xbt_heap_maxkey(heap) != tab[i]) {
fprintf(stderr, "Problem !\n");
exit(1);
}
xbt_heap_pop(heap);
}
xbt_heap_free(heap);
free(tab);
printf("Validity test complete!\n");
}
void NetworkCm02Model::updateActionsStateLazy(double now, double /*delta*/)
{
NetworkCm02ActionPtr action;
while ((xbt_heap_size(p_actionHeap) > 0)
&& (double_equals(xbt_heap_maxkey(p_actionHeap), now, sg_surf_precision))) {
action = (NetworkCm02ActionPtr) xbt_heap_pop(p_actionHeap);
XBT_DEBUG("Something happened to action %p", action);
#ifdef HAVE_TRACING
if (TRACE_is_enabled()) {
int n = lmm_get_number_of_cnst_from_var(p_maxminSystem, action->getVariable());
int i;
for (i = 0; i < n; i++){
lmm_constraint_t constraint = lmm_get_cnst_from_var(p_maxminSystem,
action->getVariable(),
i);
NetworkCm02LinkPtr link = static_cast<NetworkCm02LinkPtr>(lmm_constraint_id(constraint));
TRACE_surf_link_set_utilization(link->getName(),
action->getCategory(),
(lmm_variable_getvalue(action->getVariable())*
lmm_get_cnst_weight_from_var(p_maxminSystem,
action->getVariable(),
i)),
action->getLastUpdate(),
now - action->getLastUpdate());
}
}
#endif
// if I am wearing a latency hat
if (action->getHat() == LATENCY) {
XBT_DEBUG("Latency paid for action %p. Activating", action);
lmm_update_variable_weight(p_maxminSystem, action->getVariable(), action->m_weight);
action->heapRemove(p_actionHeap);
action->refreshLastUpdate();
// if I am wearing a max_duration or normal hat
} else if (action->getHat() == MAX_DURATION ||
action->getHat() == NORMAL) {
// no need to communicate anymore
// assume that flows that reached max_duration have remaining of 0
XBT_DEBUG("Action %p finished", action);
action->setRemains(0);
action->finish();
action->setState(SURF_ACTION_DONE);
action->heapRemove(p_actionHeap);
action->gapRemove();
}
}
return;
}
/*********
* Model *
*********/
void CpuModel::updateActionsStateLazy(double now, double /*delta*/)
{
CpuAction *action;
while ((xbt_heap_size(getActionHeap()) > 0)
&& (double_equals(xbt_heap_maxkey(getActionHeap()), now, sg_surf_precision))) {
action = static_cast<CpuAction*>(xbt_heap_pop(getActionHeap()));
XBT_CDEBUG(surf_kernel, "Something happened to action %p", action);
if (TRACE_is_enabled()) {
Cpu *cpu = static_cast<Cpu*>(lmm_constraint_id(lmm_get_cnst_from_var(getMaxminSystem(), action->getVariable(), 0)));
TRACE_surf_host_set_utilization(cpu->getName(), action->getCategory(),
lmm_variable_getvalue(action->getVariable()),
action->getLastUpdate(),
now - action->getLastUpdate());
}
action->finish();
XBT_CDEBUG(surf_kernel, "Action %p finished", action);
/* set the remains to 0 due to precision problems when updating the remaining amount */
action->setRemains(0);
action->setState(SURF_ACTION_DONE);
action->heapRemove(getActionHeap()); //FIXME: strange call since action was already popped
}
if (TRACE_is_enabled()) {
//defining the last timestamp that we can safely dump to trace file
//without losing the event ascending order (considering all CPU's)
double smaller = -1;
ActionList *actionSet = getRunningActionSet();
for(ActionList::iterator it(actionSet->begin()), itend(actionSet->end())
; it != itend ; ++it) {
action = static_cast<CpuAction*>(&*it);
if (smaller < 0) {
smaller = action->getLastUpdate();
continue;
}
if (action->getLastUpdate() < smaller) {
smaller = action->getLastUpdate();
}
}
if (smaller > 0) {
TRACE_last_timestamp_to_dump = smaller;
}
}
return;
}
void generic_update_actions_state_lazy(double now, double delta, surf_model_t model)
{
surf_action_lmm_t action;
while ((xbt_heap_size(model->model_private->action_heap) > 0)
&& (double_equals(xbt_heap_maxkey(model->model_private->action_heap), now))) {
action = xbt_heap_pop(model->model_private->action_heap);
XBT_DEBUG("Something happened to action %p", action);
#ifdef HAVE_TRACING
if (TRACE_is_enabled()) {
if(model == surf_cpu_model){
surf_resource_t cpu =
lmm_constraint_id(lmm_get_cnst_from_var
(model->model_private->maxmin_system,
action->variable, 0));
TRACE_surf_host_set_utilization(cpu->name,
((surf_action_t)action)->category,
lmm_variable_getvalue(action->variable),
action->last_update,
now - action->last_update);
}
else{
int n = lmm_get_number_of_cnst_from_var(model->model_private->maxmin_system, action->variable);
unsigned int i;
for (i = 0; i < n; i++){
lmm_constraint_t constraint = lmm_get_cnst_from_var(model->model_private->maxmin_system,
action->variable,
i);
link_CM02_t link = lmm_constraint_id(constraint);
TRACE_surf_link_set_utilization(link->lmm_resource.generic_resource.name,
((surf_action_t)action)->category,
(lmm_variable_getvalue(action->variable)*
lmm_get_cnst_weight_from_var(model->model_private->maxmin_system,
action->variable,
i)),
action->last_update,
now - action->last_update);
}
}
}
#endif
if(model == surf_cpu_model){
action->generic_action.finish = surf_get_clock();
update_resource_energy(model, action);
/* set the remains to 0 due to precision problems when updating the remaining amount */
action->generic_action.remains = 0;
surf_action_state_set((surf_action_t) action, SURF_ACTION_DONE);
surf_action_lmm_heap_remove(model->model_private->action_heap,action); //FIXME: strange call since action was already popped
}
else{
// if I am wearing a latency hat
if (action->hat == LATENCY) {
XBT_DEBUG("Latency paid for action %p. Activating", action);
lmm_update_variable_weight(model->model_private->maxmin_system, action->variable,
((surf_action_network_CM02_t)(action))->weight);
surf_action_lmm_heap_remove(model->model_private->action_heap,action);
action->last_update = surf_get_clock();
// if I am wearing a max_duration or normal hat
} else if (action->hat == MAX_DURATION ||
action->hat == NORMAL) {
// no need to communicate anymore
// assume that flows that reached max_duration have remaining of 0
action->generic_action.finish = surf_get_clock();
XBT_DEBUG("Action %p finished", action);
action->generic_action.remains = 0;
((surf_action_t)action)->finish = surf_get_clock();
model->action_state_set((surf_action_t) action,
SURF_ACTION_DONE);
surf_action_lmm_heap_remove(model->model_private->action_heap,action);
if (model->gap_remove && model == surf_network_model)
model->gap_remove(action);
}
}
}
#ifdef HAVE_TRACING
if (TRACE_is_enabled() && model == surf_cpu_model) {
//defining the last timestamp that we can safely dump to trace file
//without losing the event ascending order (considering all CPU's)
double smaller = -1;
xbt_swag_t running_actions = model->states.running_action_set;
xbt_swag_foreach(action, running_actions) {
if (smaller < 0) {
smaller = action->last_update;
continue;
}
if (action->last_update < smaller) {
smaller = action->last_update;
}
}
if (smaller > 0) {
TRACE_last_timestamp_to_dump = smaller;
}
}
