Reorganized source tree, added CMake based build system and merged ATG project from

HardPkpMin2, which now will serve as a tutorial for Boost.Graph self learning

Author: Arka

.gitignore

@@ -41,6 +41,22 @@ log
 *.swp
 *.svo
 *.svp
+/.vscode/
 
 # Graph/tree visualization files
 *.dot
+
+# Profile CSV datasets
+*.csv
+
+# Build Products
+/build/
+
+# Dump Datasets
+
+# Graphviz visualizations
+*.dot
+*.pdf
+*.svg
+*.png
+*.jpeg

BoostGraph/CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.4.2)
+project(ptss-dse)
+
+set(CMAKE_BUILD_TYPE Debug)
+set(PROJECT_DESCRIPTION "Malleable DAG scheduling with deadline for peak power minimization")
+set(PTSS_DSE_VERSION_MAJOR 1)
+set(PTSS_DSE_VERSION_MINOR 0)
+set(EXEC1 mDagPkpISLPED2019Ext)
+set(EXEC2 mDagPkpJansenBinSearch)
+
+ 
+## Targets (Convex Optimization+DGGD aka ISLPED extension)
+add_executable(${EXEC1} src/ATG.cpp src/testATG.cpp)
+target_include_directories(${EXEC1} PUBLIC ${PROJECT_SOURCE_DIR}/include ${PROJECT_BINARY_DIR})
+target_compile_options(${EXEC1} PRIVATE -std=c++11 -Wall)
+target_link_libraries(${EXEC1} PUBLIC -lm -lecotools -lboost_graph)
+
+## Targets (Tulika's suggestion dated 02/07/2019 aka Malleable-DAG scheduling + Binary search apprach)
+# add_executable(${EXEC2} src/Stats.cpp src/ATG.cpp src/KlausHuangLP.cpp src/KlausHuangListM.cpp src/testKlausHuangLP.cpp src/KHMBinSearch.cpp)
+# target_include_directories(${EXEC2} PUBLIC ${PROJECT_SOURCE_DIR}/include ${PROJECT_BINARY_DIR} $ENV{GUROBI_HOME}/include)
+# target_compile_options(${EXEC2} PRIVATE -std=c++11 -Wall)
+# target_link_libraries(${EXEC2} PUBLIC -lm -lecotools -lgurobi_c++ -lgurobi81)

BoostGraph/DAGGen/tutorialnx.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Jul  2 11:20:05 2019
+
+@author: amaity
+"""
+import numpy as np
+import networkx as nx
+import os
+from networkx.drawing.nx_agraph import write_dot
+
+def main():
+    G = nx.gnp_random_graph(4,0.5,directed=True)
+    H = nx.DiGraph([(u,v,{'weight':np.random.randint(0,5)}) for (u,v) in G.edges() if u<v])
+    if nx.is_directed_acyclic_graph(H):
+        write_dot(H, 'fileD.dot')
+        os.system('neato -Tpdf fileD.dot >fileD.pdf')
+    write_dot(G, 'fileG.dot')
+    os.system('neato -Tpdf fileG.dot >fileG.pdf')
+
+if __name__=="__main__":
+    main()

BoostGraph/README.md

@@ -0,0 +1,2 @@
+# Boost.Graph
+Tutorial on Boost Graphs and their uses.

BoostGraph/include/ATG.hpp

@@ -0,0 +1,51 @@
+#ifndef DEF_ATG_H
+#define DEF_ATG_H
+
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <set>
+#include <queue>
+#include <boost/graph/adjacency_list.hpp>
+
+void testATG(int N, double p);
+void randDAGGen();
+std::ostream& operator<<(std::ostream &os, const NodeType  &et);
+
+class AppTaskGraph {
+    private:
+        DAGType gSS;
+        std::vector<DAGVertexType> vdMap;   /* Node identifier set, vdMap[N-1] is a sink */
+        std::map<DAGVertexType,std::vector<DAGVertexType>> predVdMap;  /* Map of predecessors */
+        std::map<DAGVertexType,std::vector<DAGVertexType>> succVdMap;  /* Map of successors */
+        bool initialized;
+        bool scheduled;
+        double t;         /* Execution time spent */
+        int util;         /* Number of processors used */
+        int finishCounter;
+        double wC;        /* Worst case makespan */
+        double deadline;
+        void computeNbdMap();
+        int execute(int M_X, double delta);
+        int KlausHuangLP(int M_X, double rho, int mu);
+        double KlausHuangListM(int M_X, double delta);
+        void computeHeight(bool schedule);
+        void reset();     /* Reset the schedules and status */
+    public:
+        AppTaskGraph(int N, double p);
+        AppTaskGraph(std::string dotFile);                /* Read a dot file */
+        AppTaskGraph();
+        void writeDot(int iter);
+        std::vector<DAGVertexType> getPreds(int jid) { return this->predVdMap[this->vdMap[jid]]; };
+        std::vector<DAGVertexType> getPreds(DAGVertexType vptr) { return this->predVdMap[vptr]; };
+        std::vector<DAGVertexType> getSuccs(int jid) { return this->succVdMap[this->vdMap[jid]]; };
+        std::vector<DAGVertexType> getSuccs(DAGVertexType vptr) { return this->succVdMap[vptr]; };
+        NodeType getNode(int jid) { return this->gSS[this->vdMap[jid]]; };
+        NodeType getNode(DAGVertexType vptr) { return this->gSS[vptr]; };
+        double tau_j(int jid, int l);
+        int getSize() { return this->vdMap.size(); };
+        double KlausHuangMethodSched(int M_X);
+        void KHMBinSearch(int K); /* Minimum peak power scheduling */
+        void genStats();
+};
+#endif

BoostGraph/include/DataTypes.hpp

@@ -0,0 +1,98 @@
+#ifndef DEF_DATATYPES_H
+#define DEF_DATATYPES_H
+
+#include <iostream>
+#include <iomanip>
+#include <vector>
+#include <boost/graph/adjacency_list.hpp>
+
+#define M    32  // Maximum number of cores
+#define NMax 20000 // Maximum supported taskset size
+#define FIXED_FLOAT(x) std::fixed<<std::setprecision(2)<<(x)
+#define DEBUG
+
+/*
+ * 1. NotReady - Predecessors not yet finished, cannot execute
+ * 2. Ready    - Predecessors finished, but not enough resources
+ * 3. Active   - Execution under progress
+ * 4. Finished - Completed execution already
+ */
+enum StatusType {NotReady,Ready,Finished,Active};
+
+struct NodeType {
+    StatusType status;
+    double estart;  /* Earliest possible start time that satisfies the precedence constraints */
+
+    /* Execution type characteristics (static)
+     * execution time is modelled \tau_j(m) = \tau_j(1) * m^(-d_{j}).
+     * where 0 < d_{j} < 1
+     */
+    double dj;      /* Exponent 0 < dj < 1 */
+    double tau1;
+    int id; 
+
+    /* Execution type characteristics (Dynamic)
+     * mainly start and finish time in the schedule
+     */
+    int alloc;
+    double start_time;
+    double stop_time;
+    double C;        /* computation requirement, uninitialized value = -1 */
+};
+
+/* Only used for dependency modelling */
+struct EdgeType {
+    int edgeNum;
+};
+
+/* Event types for statistics collection and display */
+enum EventType {Stop=1,Start=0};
+
+/* <time stamp, EeventType, alloc, id> */
+typedef std::tuple<double,EventType,int,int> Events;
+
+typedef boost::adjacency_list<boost::vecS,boost::vecS,boost::bidirectionalS,NodeType,EdgeType> DAGType;
+typedef boost::graph_traits<DAGType>::vertex_descriptor DAGVertexType;
+typedef boost::graph_traits<DAGType>::edge_descriptor DAGEdgeType;
+typedef boost::graph_traits<DAGType>::out_edge_iterator DAGOutEdgeIterator;
+typedef boost::graph_traits<DAGType>::in_edge_iterator DAGInEdgeIterator;
+typedef boost::graph_traits<DAGType>::vertex_iterator DAGVertexIterator;
+typedef boost::graph_traits<DAGType>::degree_size_type DAGDegSizeType;
+
+class DAGVertexPW {
+     public:
+       DAGVertexPW(DAGType& g) : myGraph(g) {}
+       template <class VertexOrEdge>
+       void operator()(std::ostream& os, const VertexOrEdge& v) const {
+            os << "[status=\"{";
+            switch(myGraph[v].status) {
+                case NotReady   : os << "NotReady,"; break;
+                case Ready      : os << "Ready,"; break;
+                case Finished   : os << "Finished,"; break;
+                case Active     : os << "Active"; break;
+            }
+            os << "id:" << myGraph[v].id;
+            // os << ",estart:" << FIXED_FLOAT(myGraph[v].estart);
+            // os << ",alloc:" << myGraph[v].alloc;
+            // os << ",start:" << FIXED_FLOAT(myGraph[v].start_time);
+            // os << ",stop:" << FIXED_FLOAT(myGraph[v].stop_time);
+            // os << ",C:" << FIXED_FLOAT(myGraph[v].C);
+            os << ",dj:" << FIXED_FLOAT(myGraph[v].dj);
+            os << ",tau1:" << FIXED_FLOAT(myGraph[v].tau1);
+            os << "}\"]";
+       }
+    private:
+        DAGType& myGraph;
+};
+
+class DAGEdgePW {
+    public:
+       DAGEdgePW(DAGType& g) : myGraph(g) {}
+       template <class VertexOrEdge>
+       void operator()(std::ostream& os, const VertexOrEdge& e) const {
+       }
+    private:
+        DAGType& myGraph;
+};
+
+#endif