Method construct_old_growing

lib/mapping/construct_mapping.cpp:178–258

}

void construct_mapping::construct_old_growing( PartitionConfig & config, graph_access & C, matrix & D, std::vector< NodeID > & perm_rank) {
        std::cout <<  "constructing initial mapping"  << std::endl;

        std::vector< NodeWeight > total_dist( C.number_of_nodes(), 0);
        std::vector< NodeWeight > total_vol( C.number_of_nodes(), 0);
        std::vector< NodeWeight > core_assigned( C.number_of_nodes(), UNASSIGNED);

        NodeWeight max_vol      = 0;
        NodeWeight max_vol_elem = 0;
        forall_nodes(C, node) {
                forall_out_edges(C, e, node) {
                        total_vol[node] += C.getEdgeWeight(e);
                } endfor
                if( total_vol[node] > max_vol ) {
                        max_vol = total_vol[node];
                        max_vol_elem = node;
                }
        } endfor

        NodeWeight min_dist      = std::numeric_limits< NodeWeight >::max();
        NodeWeight min_dist_elem = 0;
        for( unsigned int cpu = 0; cpu < C.number_of_nodes(); cpu++) {
                total_dist[cpu] = 0;
                for( unsigned int cpu_bar = 0; cpu_bar < C.number_of_nodes(); cpu_bar++) {
                        total_dist[cpu] += D.get_xy( cpu, cpu_bar );
                }

                if( total_dist[cpu] < min_dist ) {
                        min_dist = total_dist[cpu];
                        min_dist_elem = cpu;
                }
        }

        //initialze perm rank
        //interpretation task 'node' is assinged to perm_rank[node] 
        for( unsigned int i = 0; i < perm_rank.size(); i++) {
                perm_rank[i] = UNASSIGNED;
        }
        perm_rank[max_vol_elem]      = min_dist_elem;
        core_assigned[min_dist_elem] = ASSIGNED;
        //initialization, now assign the rest of the ranks to the tasks
        for( unsigned i = 0; i < C.number_of_nodes()-1; i++) {
                max_vol      = 0;
                max_vol_elem = std::numeric_limits< NodeWeight >::max();
                forall_nodes(C, node) {
                        if(perm_rank[node] != UNASSIGNED) continue;

                        total_vol[node] = 0;
                        forall_out_edges(C, e, node) {
                                NodeID target = C.getEdgeTarget(e);
                                if( perm_rank[target] != UNASSIGNED ) {
                                        total_vol[node] += C.getEdgeWeight(e);
                                }
                        } endfor
                        if( total_vol[node] >= max_vol ) {
                                max_vol      = total_vol[node];
                                max_vol_elem = node;
                        }