Function main

app/node_ordering.cpp:25–107

#include "tools/random_functions.h"

int main(int argn, char **argv) {
        PartitionConfig partition_config;
        std::string graph_filename;
        
        bool is_graph_weighted = false;
        bool suppress_output = false;
        bool recursive = false;

        int ret_code = parse_parameters(argn, argv,
                                        partition_config,
                                        graph_filename,
                                        is_graph_weighted,
                                        suppress_output, recursive);

        if (ret_code) {
                return 0;
        }

        // Backup stdout
        std::streambuf* backup = std::cout.rdbuf();
        if(suppress_output) {
                std::cout.rdbuf(nullptr);
        }

        graph_access G;

        timer t;
        graph_io::readGraphWeighted(G, graph_filename);
        std::cout << "io time: " << t.elapsed() << std::endl;

        // Make G unweighted
        bool has_node_weights = false;
        forall_nodes(G, node) {
                if (G.getNodeWeight(node) != 1) {
                        has_node_weights = true;
                }
                G.setNodeWeight(node, 1);
        } endfor
        if (has_node_weights) {
                std::cout << "There were nodes with weight != 1" << std::endl;
        }

        std::cout << "imbalance is set to " << partition_config.imbalance << "%" << std::endl;
        balance_configuration bc;
        bc.configurate_balance(partition_config, G);

        srand(partition_config.seed);
        random_functions::setSeed(partition_config.seed);

        std::cout << "graph has " << G.number_of_nodes() << " nodes and " << G.number_of_edges() << " edges" << std::endl;

        t.restart();
        nested_dissection dissection(&G);
        dissection.perform_nested_dissection(partition_config);

        // Restore cout output stream
        std::cout.rdbuf(backup);