DAG.hpp

Go to the documentation of this file.

// <DAG.hpp> -*- C++ -*-
 
 
#pragma once
 
#include <cstdint>
#include <string>
#include <iostream>
#include <sstream>
#include <memory>
#include <list>
#include <map>
#include <vector>
#include <set>
#include <cinttypes>
#include <cassert>
#include <utility>
 
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/events/Scheduleable.hpp"
#include "sparta/events/SchedulingPhases.hpp"
#include "sparta/kernel/Vertex.hpp"
#include "sparta/kernel/VertexFactory.hpp"
#include "sparta/kernel/EdgeFactory.hpp"
 
namespace sparta
{
    class Unit;
    class Scheduler;
 
    class DAG
    {
 
        friend std::ostream& operator<<(std::ostream& os, const Edge &e);
        friend std::ostream& operator<<(std::ostream& os, const Vertex &v);
 
        friend Unit;
 
    public:
 
        // For backward compatibility
        typedef Vertex GOPoint;
        typedef std::map<std::string, Vertex*>   VertexMap;
 
        class CycleException : public SpartaException
        {
        public:
            CycleException(const typename Vertex::VertexList & cycle_set) :
                SpartaException(),
                cycle_set_(cycle_set)
            {}
 
            CycleException(const std::string& reason) :
                SpartaException(reason)
            {}
 
            void writeCycleAsDOT (std::ostream & os) const;
            void writeCycleAsText (std::ostream & os) const;
 
        private:
            //void outPutIssue_(std::ostream & os, bool dot) const;
            typename Vertex::VertexList     cycle_set_;
        };
 
 
 
        // DAG Nabbit
        DAG(sparta::Scheduler * scheduler, const bool& check_cycles = false);
 
        DAG() =delete;
 
        void enableEarlyCycleDetect() {
            early_cycle_detect_ = true;
        }
 
        void initializeDAG_();
 
        uint32_t finalize();
 
        bool isFinalized() const {
            return finalized_;
        }
 
        Vertex* newFactoryVertex(const std::string& label,
                                 sparta::Scheduler* const scheduler,
                                 const bool isgop=false);
 
        void link(Vertex *v, Vertex *w, const std::string & reason = "");
 
        bool unlink(Vertex *v, Vertex *w)
        {
            sparta_assert(v != nullptr);
            sparta_assert(w != nullptr);
 
            return v->unlink(e_factory_, w);
        }
 
        uint32_t numGroups() {
            return num_groups_;
        }
 
        bool sort();
 
        Vertex* findGOPVertex(const std::string& label) const
        {
            auto loc = gops_.find(label);
            return (loc != gops_.end()) ? loc->second : nullptr;
        }
 
        Vertex* newGOPVertex(const std::string& label, sparta::Scheduler* const scheduler)
        {
            sparta_assert(findGOPVertex(label) == nullptr);
            Vertex* gop = this->newFactoryVertex(label, scheduler, true);
            gops_[label] = gop;
            return gop;
        }
 
        Vertex* getGOPoint(const std::string& label)
        {
            Vertex *gop = findGOPVertex(label);
            if (gop == nullptr) {
                return newGOPVertex(label, getScheduler());
            }
            return gop;
        }
 
        sparta::Scheduler * getScheduler() const{
            return my_scheduler_;
        }
 
        bool detectCycle() const;
 
        // Just print one cycle for now...
        void printCycles(std::ostream& os) const;
 
        void dumpToCSV(std::ostream& os_vertices, std::ostream& os_edges) const;
 
        void print(std::ostream& os) const;
 
    private:
        // Just mark one cycle for now...
        typename Vertex::VertexList getCycles_();
 
        // Transfer Global Ordering Point GID's to associates
        void finalizeGOPs_()
        {
            for (auto& i : gops_) {
                i.second->transferGID();
            }
        }
 
        VertexFactory                           v_factory_;
        EdgeFactory                             e_factory_;
 
        std::vector<Vertex*>                    alloc_vertices_;
        uint32_t                                num_groups_ = 1;
        bool                                    early_cycle_detect_;
        VertexMap                               gops_;
        bool                                    finalized_ = false;
        sparta::Scheduler*                      my_scheduler_ = nullptr;
        const log::MessageSource                debug_logger_;
    };//End class DAG
 
 
    inline std::ostream& operator<<(std::ostream& os, const DAG &d)
    {
        d.print(os);
        return os;
    }
 
    inline std::ostream& operator<<(std::ostream& os, const DAG *d)
    {
        os << *d;
        return os;
    }
 
} // namespace sparta