CpuCas01Model::CpuCas01Model() : simgrid::surf::CpuModel()
{
char *optim = xbt_cfg_get_string("cpu/optim");
bool select = xbt_cfg_get_boolean("cpu/maxmin-selective-update");
if (!strcmp(optim, "Full")) {
updateMechanism_ = UM_FULL;
selectiveUpdate_ = select;
} else if (!strcmp(optim, "Lazy")) {
updateMechanism_ = UM_LAZY;
selectiveUpdate_ = true;
xbt_assert(select || (xbt_cfg_is_default_value("cpu/maxmin-selective-update")),
"Disabling selective update while using the lazy update mechanism is dumb!");
} else {
xbt_die("Unsupported optimization (%s) for this model", optim);
}
p_cpuRunningActionSetThatDoesNotNeedBeingChecked = new ActionList();
maxminSystem_ = lmm_system_new(selectiveUpdate_);
if (getUpdateMechanism() == UM_LAZY) {
actionHeap_ = xbt_heap_new(8, nullptr);
xbt_heap_set_update_callback(actionHeap_, surf_action_lmm_update_index_heap);
modifiedSet_ = new ActionLmmList();
maxminSystem_->keep_track = modifiedSet_;
}
}
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");
}
static void test_reset_heap(xbt_heap_t * heap, int size)
{
xbt_heap_free(*heap);
*heap = xbt_heap_new(size, NULL);
for (int i = 0; i < size; i++) {
xbt_heap_push(*heap, NULL, (10.0 * rand() / (RAND_MAX + 1.0)));
}
}
XBT_INLINE tmgr_history_t tmgr_history_new(void)
{
tmgr_history_t h;
h = xbt_new0(s_tmgr_history_t, 1);
h->heap = xbt_heap_new(8, xbt_free_f); /* Why 8 ? Well, why not... */
return h;
}
CpuCas01Model::CpuCas01Model() : CpuModel("cpu")
{
char *optim = xbt_cfg_get_string(_sg_cfg_set, "cpu/optim");
int select = xbt_cfg_get_boolean(_sg_cfg_set, "cpu/maxmin_selective_update");
if (!strcmp(optim, "Full")) {
p_updateMechanism = UM_FULL;
m_selectiveUpdate = select;
} else if (!strcmp(optim, "Lazy")) {
p_updateMechanism = UM_LAZY;
m_selectiveUpdate = 1;
xbt_assert((select == 1)
||
(xbt_cfg_is_default_value
(_sg_cfg_set, "cpu/maxmin_selective_update")),
"Disabling selective update while using the lazy update mechanism is dumb!");
} else {
xbt_die("Unsupported optimization (%s) for this model", optim);
}
p_cpuRunningActionSetThatDoesNotNeedBeingChecked = new ActionList();
if (getUpdateMechanism() == UM_LAZY) {
shareResources = &CpuCas01Model::shareResourcesLazy;
updateActionsState = &CpuCas01Model::updateActionsStateLazy;
} else if (getUpdateMechanism() == UM_FULL) {
shareResources = &CpuCas01Model::shareResourcesFull;
updateActionsState = &CpuCas01Model::updateActionsStateFull;
} else
xbt_die("Invalid cpu update mechanism!");
if (!p_maxminSystem) {
p_maxminSystem = lmm_system_new(m_selectiveUpdate);
}
if (getUpdateMechanism() == UM_LAZY) {
p_actionHeap = xbt_heap_new(8, NULL);
xbt_heap_set_update_callback(p_actionHeap, surf_action_lmm_update_index_heap);
p_modifiedSet = new ActionLmmList();
p_maxminSystem->keep_track = p_modifiedSet;
}
}
void NetworkCm02Model::initialize()
{
char *optim = xbt_cfg_get_string(_sg_cfg_set, "network/optim");
int select =
xbt_cfg_get_boolean(_sg_cfg_set, "network/maxmin_selective_update");
if (!strcmp(optim, "Full")) {
p_updateMechanism = UM_FULL;
m_selectiveUpdate = select;
} else if (!strcmp(optim, "Lazy")) {
p_updateMechanism = UM_LAZY;
m_selectiveUpdate = 1;
xbt_assert((select == 1)
||
(xbt_cfg_is_default_value
(_sg_cfg_set, "network/maxmin_selective_update")),
"Disabling selective update while using the lazy update mechanism is dumb!");
} else {
xbt_die("Unsupported optimization (%s) for this model", optim);
}
if (!p_maxminSystem)
p_maxminSystem = lmm_system_new(m_selectiveUpdate);
const char* lb_name = "__loopback__";
routing_model_create(createNetworkLink(lb_name,
498000000, NULL, 0.000015, NULL,
SURF_RESOURCE_ON, NULL,
SURF_LINK_FATPIPE, NULL));
if (p_updateMechanism == UM_LAZY) {
p_actionHeap = xbt_heap_new(8, NULL);
xbt_heap_set_update_callback(p_actionHeap, surf_action_lmm_update_index_heap);
p_modifiedSet = new ActionLmmList();
p_maxminSystem->keep_track = p_modifiedSet;
}
m_haveGap = false;
}
void AsDijkstra::getRouteAndLatency(NetCard *src, NetCard *dst, sg_platf_route_cbarg_t route, double *lat)
{
getRouteCheckParams(src, dst);
int src_id = src->id();
int dst_id = dst->id();
int *pred_arr = nullptr;
sg_platf_route_cbarg_t e_route;
int size = 0;
xbt_dynar_t nodes = xbt_graph_get_nodes(routeGraph_);
/* Use the graph_node id mapping set to quickly find the nodes */
graph_node_map_element_t src_elm = nodeMapSearch(src_id);
graph_node_map_element_t dst_elm = nodeMapSearch(dst_id);
int src_node_id = ((graph_node_data_t) xbt_graph_node_get_data(src_elm->node))->graph_id;
int dst_node_id = ((graph_node_data_t) xbt_graph_node_get_data(dst_elm->node))->graph_id;
/* if the src and dst are the same */
if (src_node_id == dst_node_id) {
xbt_node_t node_s_v = xbt_dynar_get_as(nodes, src_node_id, xbt_node_t);
xbt_node_t node_e_v = xbt_dynar_get_as(nodes, dst_node_id, xbt_node_t);
xbt_edge_t edge = xbt_graph_get_edge(routeGraph_, node_s_v, node_e_v);
if (edge == nullptr)
THROWF(arg_error, 0, "No route from '%s' to '%s'", src->name(), dst->name());
e_route = (sg_platf_route_cbarg_t) xbt_graph_edge_get_data(edge);
for (auto link: *e_route->link_list) {
route->link_list->insert(route->link_list->begin(), link);
if (lat)
*lat += static_cast<Link*>(link)->getLatency();
}
}
route_cache_element_t elm = nullptr;
if (routeCache_) { /* cache mode */
elm = (route_cache_element_t) xbt_dict_get_or_null_ext(routeCache_, (char *) (&src_id), sizeof(int));
}
if (elm) { /* cached mode and cache hit */
pred_arr = elm->pred_arr;
} else { /* not cached mode, or cache miss */
int nr_nodes = xbt_dynar_length(nodes);
double * cost_arr = xbt_new0(double, nr_nodes); /* link cost from src to other hosts */
pred_arr = xbt_new0(int, nr_nodes); /* predecessors in path from src */
xbt_heap_t pqueue = xbt_heap_new(nr_nodes, xbt_free_f);
/* initialize */
cost_arr[src_node_id] = 0.0;
for (int i = 0; i < nr_nodes; i++) {
if (i != src_node_id) {
cost_arr[i] = DBL_MAX;
}
pred_arr[i] = 0;
/* initialize priority queue */
int *nodeid = xbt_new0(int, 1);
*nodeid = i;
xbt_heap_push(pqueue, nodeid, cost_arr[i]);
}
/* apply dijkstra using the indexes from the graph's node array */
while (xbt_heap_size(pqueue) > 0) {
int *v_id = (int *) xbt_heap_pop(pqueue);
xbt_node_t v_node = xbt_dynar_get_as(nodes, *v_id, xbt_node_t);
xbt_edge_t edge = nullptr;
unsigned int cursor;
xbt_dynar_foreach(xbt_graph_node_get_outedges(v_node), cursor, edge) {
xbt_node_t u_node = xbt_graph_edge_get_target(edge);
graph_node_data_t data = (graph_node_data_t) xbt_graph_node_get_data(u_node);
int u_id = data->graph_id;
sg_platf_route_cbarg_t tmp_e_route = (sg_platf_route_cbarg_t) xbt_graph_edge_get_data(edge);
int cost_v_u = tmp_e_route->link_list->size(); /* count of links, old model assume 1 */
if (cost_v_u + cost_arr[*v_id] < cost_arr[u_id]) {
pred_arr[u_id] = *v_id;
cost_arr[u_id] = cost_v_u + cost_arr[*v_id];
int *nodeid = xbt_new0(int, 1);
*nodeid = u_id;
xbt_heap_push(pqueue, nodeid, cost_arr[u_id]);
}
}
/* free item popped from pqueue */
xbt_free(v_id);
}
