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)));
}
}
/* insert action on heap using a given key and a hat (heap_action_type)
* a hat can be of three types for communications:
*
* NORMAL = this is a normal heap entry stating the date to finish transmitting
* LATENCY = this is a heap entry to warn us when the latency is payed
* MAX_DURATION =this is a heap entry to warn us when the max_duration limit is reached
*/
void surf_action_lmm_heap_insert(xbt_heap_t heap, surf_action_lmm_t action, double key,
enum heap_action_type hat)
{
action->hat = hat;
xbt_heap_push(heap, action, key);
}
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);
}
