graph_builder.h

Go to the documentation of this file.

#ifndef FPMAS_GRAPH_BUILDER_H
#define FPMAS_GRAPH_BUILDER_H
 
#include "uniform_graph_builder.h"
#include "clustered_graph_builder.h"
#include "ring_graph_builder.h"
 
namespace fpmas { namespace graph {
 
    template<typename T>
    class DistributedNodeBuilder : public api::graph::DistributedNodeBuilder<T> {
        protected:
            std::size_t local_node_count;
 
        public:
            DistributedNodeBuilder(
                    std::size_t node_count,
                    fpmas::api::communication::MpiCommunicator& comm) {
                local_node_count = node_count / comm.getSize();
                if(comm.getRank() == 0)
                    local_node_count += node_count % comm.getSize();
            }
 
            std::size_t nodeCount() override {
                return local_node_count;
            }
 
            std::size_t localNodeCount() override {
                return local_node_count;
            }
    };
 
 
 
    template<typename T>
        class BipartiteGraphBuilder :
            public api::graph::GraphBuilder<T>,
            private RandomGraphBuilder {
            private:
                std::vector<api::graph::DistributedNode<T>*> base_nodes;
                /*
                 * Function object that return a random integer between 0 and
                 * the specified argument (included).
                 */
                std::function<std::size_t(std::size_t)> index;
 
            public:
                template<typename Generator_t, typename EdgeDist>
                    BipartiteGraphBuilder(
                            Generator_t& generator,
                            EdgeDist& edge_distribution,
                            std::vector<api::graph::DistributedNode<T>*> base_nodes) :
                        RandomGraphBuilder(generator, edge_distribution),
                        base_nodes(base_nodes),
                        index([&generator] (std::size_t max) {
                                fpmas::random::UniformIntDistribution<std::size_t> index(
                                        0, max
                                        );
                                return index(generator);
                                }){
                        }
 
                std::vector<api::graph::DistributedNode<T>*> build(
                        api::graph::NodeBuilder<T>& node_builder,
                        api::graph::LayerId layer,
                        api::graph::DistributedGraph<T>& graph) override;
        };
 
    template<typename T>
        std::vector<api::graph::DistributedNode<T>*> BipartiteGraphBuilder<T>::build(
                api::graph::NodeBuilder<T>& node_builder,
                api::graph::LayerId layer,
                api::graph::DistributedGraph<T>& graph) {
            std::vector<api::graph::DistributedNode<T>*> built_nodes;
 
            while(node_builder.nodeCount() > 0) {
                auto* node = node_builder.buildNode(graph);
                built_nodes.push_back(node);
                std::size_t out_neighbors_count = std::min(
                        base_nodes.size(),
                        this->num_edge()
                        );
                for(std::size_t i = 0; i < out_neighbors_count; i++) {
                    auto& target_node = base_nodes[this->index(base_nodes.size()-1-i)];
                    graph.link(node, target_node, layer);
 
                    std::swap(target_node, base_nodes[base_nodes.size()-1-i]);
                }
            }
            return built_nodes;
        }
}}
#endif