models/cpm_predict_trees.hpp

#ifndef CPM_TREE_PREDICTION_HPP_
#define CPM_TREE_PREDICTION_HPP_

#include "MPIBlib/collectives/libmpib_coll.h"
#include "collectives/cpm_coll_ops_list.h"
#include "cpm_models.h"
#include "MPIBlib/collectives/comm_tree.hpp"
#include "MPIBlib/collectives/mpib_coll.h"
#include <boost/graph/graphviz.hpp>

using namespace MPIB::comm_tree;
class TreePredictor {
private:
    CPM_predictor *predictor;
    MPIB_child_traverse_order order;
    /*
     counts_helper has a different role depending on the routine:
        -in Bcast/Reduce, it is not used
        -in Scatter/Gather, it stands for children count
        -in Scatterv/Gatherv, it stands for sum of messages of children  
     */
    int* counts_helper;//relevant for scatter/gather and 
    int* size_bytes;
    double* t;
    int size;
    CPM_coll_op_types op;
    
public:
    //constructor
    TreePredictor(CPM_predictor* _predictor, MPIB_child_traverse_order _order, int _size, int* _size_bytes, CPM_coll_op_types _op, int* _counts_helper, double* _t) {
        predictor = _predictor;
        t = _t;
        counts_helper = _counts_helper;
        order = _order;
        size = _size;
        size_bytes = _size_bytes;
        op = _op;
    }

    void preorder(Vertex vertex, Tree& tree) {
    }
    void inorder(Vertex vertex, Tree& tree) {}
    void postorder(Vertex vertex, Tree& tree) {
        int my_rank = get(vertex_index, tree._g, vertex);
        Adjacency_iterator ai, ai_end;
        tie(ai, ai_end) = adjacent_vertices(vertex,tree._g);
        double temp=0.;
        //if the node is not a leaf, then calculate the new value
        while (ai != ai_end) {
            int child_rank = get(vertex_index, tree._g, order == R2L ? *(--ai_end) : *(ai++));
            if (op == SG) counts_helper[my_rank] += counts_helper[child_rank];
            if (op == SGV) counts_helper[my_rank] +=counts_helper[child_rank];
            int size_bytes_tmp;
            if (op == SG)  size_bytes_tmp = size_bytes[0] * counts_helper[child_rank];
            if (op == BR) size_bytes_tmp = size_bytes[0];
            if (op == SGV) size_bytes_tmp = counts_helper[child_rank];
            if (mpib_coll_verbose == 1) {
                printf("DEBUG: temp <= predict_p2p (%d, %d, %d) = %lf + max (%lf, %lf)\n",\
                     my_rank, child_rank, size_bytes_tmp, \
                     predictor->predict_p2p(predictor, my_rank, child_rank,  size_bytes_tmp), temp, t[child_rank]);
            }
            temp = predictor->predict_p2p(predictor, my_rank, child_rank, size_bytes_tmp) +  max (temp, t[child_rank]);
        }
        t[my_rank] = temp;
    }
};


template<typename Builder>
double CPM_predict_tree_sgv(Builder builder, MPIB_child_traverse_order order, int size, int root, int* size_bytes, CPM_predictor* predictor, CPM_coll_op_types op) {
    Graph graph;
    Vertex r, u, v;
    double prediction;
    builder.build(size, root, root, size_bytes, graph, r, u, v);
    if (mpib_coll_verbose == 1) {
        write_graphviz(cout, graph);
    }
    Tree tree(graph, r);
    double* t = new double[size];
    int* counts_helper = NULL;
    counts_helper = new int[size];
    for (int i = 0; i < size; i++)
        counts_helper[i] = size_bytes[i];
    traverse_tree(r, tree, TreePredictor(predictor, order, size, size_bytes, op, counts_helper, t));
    //the final prediction is stored in the root node
    prediction = t[root];
    free(t);
    free(counts_helper);
    return prediction;
}

template<typename Builder>
double CPM_predict_tree_brsg(Builder builder, MPIB_child_traverse_order order, int size, int root, int size_bytes, CPM_predictor* predictor, CPM_coll_op_types op) {
    Graph graph;
    Vertex r, u, v;
    builder.build(size, root, root, size_bytes, graph, r, u, v);
    if (mpib_coll_verbose == 1) {
        write_graphviz(cout, graph);
    }
    Tree tree(graph, r);
    double* t = new double[size];
    int* counts_helper = NULL;
    if (op == SG) {
        counts_helper = new int[size];
        for (int i = 0; i < size; i++)
            counts_helper[i] = 1;
    }
    traverse_tree(r, tree, TreePredictor(predictor, order, size, &size_bytes, op, counts_helper, t));
    //the final prediction is stored in the root node
    double prediction = t[root];
    free(t);
    if (op == SG) {
        free(counts_helper);
    }

    return prediction;
}

#endif /* CPM_TREE_PREDICTION_HPP_ */