Method construct_old_growing_faster

lib/mapping/construct_mapping.cpp:260–369

}

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

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

        maxNodeHeap unassigned_tasks; // contains unassigned tasks and their priority
        NodeWeight max_vol      = 0;
        NodeWeight max_vol_elem = 0;
        forall_nodes(C, node) {
                NodeWeight cur_vol = 0;
                forall_out_edges(C, e, node) {
                        cur_vol += C.getEdgeWeight(e);
                } endfor

                unassigned_tasks.insert( node, 0);

                if( cur_vol > max_vol ) {
                        max_vol = cur_vol;
                        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++) {
                NodeWeight cur_dist = 0;
                for( unsigned int cpu_bar = 0; cpu_bar < C.number_of_nodes(); cpu_bar++) {
                        cur_dist += D.get_xy( cpu, cpu_bar );
                }

                if( cur_dist < min_dist ) {
                        min_dist = cur_dist;
                        min_dist_elem = cpu;
                }
        }

        std::vector< NodeWeight > core_assigned( C.number_of_nodes(), UNASSIGNED);
        std::vector< NodeWeight > total_vol( C.number_of_nodes(), 0); // store volume to assigned nodes
        std::vector< NodeWeight > total_dist( C.number_of_nodes(), 0);

        std::vector< NodeWeight > unassigned_PEs;
        for( unsigned int cpu = 0; cpu < C.number_of_nodes(); cpu++) {
                unassigned_PEs.push_back(cpu);
        }

        perm_rank[max_vol_elem]      = min_dist_elem;
        core_assigned[min_dist_elem] = ASSIGNED;

        std::swap(unassigned_PEs[min_dist_elem], unassigned_PEs[unassigned_PEs.size()-1 ]);
        unassigned_PEs.pop_back();
        unassigned_tasks.deleteNode(max_vol_elem);

        for( unsigned int i = 0; i < unassigned_PEs.size(); i++) {
                NodeID cpu      = unassigned_PEs[i];