runtime.h

// -*- mode: c++; tab-width: 4; indent-tabs-mode: t; c-file-style: "stroustrup"; -*-
// vi:set ts=4 sts=4 sw=4 noet cino+=(0 :
// Copyright 2013, 2014, The TPIE development team
// 
// This file is part of TPIE.
// 
// TPIE is free software: you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the
// Free Software Foundation, either version 3 of the License, or (at your
// option) any later version.
// 
// TPIE is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
// License for more details.
// 
// You should have received a copy of the GNU Lesser General Public License
// along with TPIE.  If not, see <http://www.gnu.org/licenses/>

#ifndef TPIE_PIPELINING_RUNTIME_H
#define TPIE_PIPELINING_RUNTIME_H

#include <tpie/fractional_progress.h>
#include <tpie/pipelining/tokens.h>
#include <tpie/pipelining/node.h>
#include <set>
#include <unordered_set>

namespace tpie {

namespace pipelining {

namespace bits {

template <typename T>
class graph;
class file_runtime;
class memory_runtime;
class datastructure_runtime;

struct gocontext;
struct gocontextdel {
    void operator()(void *);
};
typedef std::unique_ptr<gocontext, gocontextdel> gocontext_ptr;

    
class runtime {
    node_map & m_nodeMap;

public:
    runtime(node_map::ptr nodeMap);

    size_t get_node_count();

    gocontext_ptr go_init(stream_size_type items,
                         progress_indicator_base & progress,
                         memory_size_type files,
                         memory_size_type memory,
                         const char * file, const char * function);
    
    void go_until(gocontext * gc, node * node=nullptr);

    void go(stream_size_type items,
            progress_indicator_base & progress,
            memory_size_type files,
            memory_size_type memory,
            const char * file, const char * function);

    void get_item_sources(std::vector<node *> & itemSources);

    void get_item_sinks(std::vector<node *> & itemSinks);

    void get_phase_map(std::map<node *, size_t> & phaseMap);

    void get_phase_graph(const std::map<node *, size_t> & phaseMap,
                         graph<size_t> & phaseGraph);

    static std::vector<size_t> inverse_permutation(const std::vector<size_t> & f);

    void get_phases(const std::map<node *, size_t> & phaseMap,
                    const graph<size_t> & phaseGraph,
                    std::unordered_set<node_map::id_t> & evacuateWhenDone,
                    std::vector<std::vector<node *> > & phases);

    void get_item_flow_graphs(std::vector<std::vector<node *> > & phases,
                              std::vector<graph<node *> > & itemFlow);

    void get_actor_graphs(std::vector<std::vector<node *> > & phases,
                          std::vector<graph<node *> > & actors);

    void get_graph(std::vector<node *> & phase, graph<node *> & result,
                   bool itemFlow);

    bool is_initiator(node * n);

    bool has_initiator(const std::vector<node *> & phase);

    void ensure_initiators(const std::vector<std::vector<node *> > & phases);

    void prepare_all(const std::vector<graph<node *> > & itemFlow);

    void evacuate_all(const std::vector<node *> & phase,
                      const std::unordered_set<node_map::id_t> & evacuateWhenDone);

    void propagate_all(const graph<node *> & itemFlow);

    void set_progress_indicators(const std::vector<node *> & phase,
                                 progress_indicator_base & pi);

    void go_initiators(const std::vector<node *> & phase);

    static void set_resource_being_assigned(const std::vector<node *> & nodes,
                                            resource_type type);

    static void assign_files(const std::vector<std::vector<node *> > & phases,
                              memory_size_type files);

    static void reassign_files(const std::vector<std::vector<node *> > & phases,
                                memory_size_type phase,
                                memory_size_type files);

    static double get_files_factor(memory_size_type files,
                                   const file_runtime & frt);

    static void assign_memory(const std::vector<std::vector<node *> > & phases,
                              memory_size_type memory, datastructure_runtime & drt);

    static void reassign_memory(const std::vector<std::vector<node *> > & phases,
                                memory_size_type phase,
                                memory_size_type memory, const datastructure_runtime & drt);

    static double get_memory_factor(memory_size_type memory,
                                    memory_size_type phase,
                                    const memory_runtime & mrt,
                                    const datastructure_runtime & drt,
                                    bool datastructures_locked);
};

}

}

}

#endif // TPIE_PIPELINING_RUNTIME_H