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; } }