Initial Code

Author: RyanWei0224

.gitignore

@@ -0,0 +1,86 @@
+# This file is used to ignore files which are generated
+# ----------------------------------------------------------------------------
+
+*~
+*.autosave
+*.a
+*.core
+*.moc
+*.o
+*.obj
+*.orig
+*.rej
+*.so
+*.so.*
+*_pch.h.cpp
+*_resource.rc
+*.qm
+.#*
+*.*#
+core
+!core/
+tags
+.DS_Store
+.directory
+*.debug
+*.prl
+*.app
+moc_*.cpp
+ui_*.h
+qrc_*.cpp
+Thumbs.db
+*.res
+*.rc
+/.qmake.cache
+/.qmake.stash
+
+# qtcreator generated files
+*.pro.user*
+
+# xemacs temporary files
+*.flc
+
+# Vim temporary files
+.*.swp
+
+# Visual Studio generated files
+*.ib_pdb_index
+*.idb
+*.ilk
+*.pdb
+*.sln
+*.suo
+*.vcproj
+*vcproj.*.*.user
+*.ncb
+*.sdf
+*.opensdf
+*.vcxproj
+*vcxproj.*
+
+# MinGW generated files
+*.Debug
+*.Release
+
+# Python byte code
+*.pyc
+
+# Binaries
+# --------
+*.dll
+*.exe
+
+*.txt
+*.bat
+*.json
+gmon.out
+callgrind.out.*
+
+.idea/
+*.csv
+results/
+build/
+*.sh
+results*/
+*.py
+running/

STSchedule.pro

@@ -0,0 +1,74 @@
+TEMPLATE = app
+CONFIG += console c++11
+CONFIG -= app_bundle
+CONFIG -= qt
+
+
+QMAKE_CXXFLAGS_RELEASE -= -O2
+QMAKE_CXXFLAGS_RELEASE += -O3 -Wall
+
+QMAKE_LFLAGS += -Wl,--stack,64000000 -Wall
+
+HEADERS += \
+    include/bitset.h \
+    include/bufferusage.h \
+    include/cluster.h \
+    include/core.h \
+    include/coremapping.h \
+    include/datalayout.h \
+    include/json/json.h \
+    include/json/json_autolink.h \
+    include/json/json_batchallocator.h \
+    include/json/json_config.h \
+    include/json/json_features.h \
+    include/json/json_forwards.h \
+    include/json/json_internalarray.inl \
+    include/json/json_internalmap.inl \
+    include/json/json_reader.h \
+    include/json/json_value.h \
+    include/json/json_valueiterator.inl \
+    include/json/json_writer.h \
+    include/layer.h \
+    include/layerengine.h \
+    include/ltreenode.h \
+    include/network.h \
+    include/nns/nns.h \
+    include/noc.h \
+    include/partition.h \
+    include/placement.h \
+    include/schnode.h \
+    include/util.h
+
+SOURCES += \
+    src/bitset.cpp \
+    src/bufferusage.cpp \
+    src/cluster.cpp \
+    src/core.cpp \
+    src/coremapping.cpp \
+    src/datalayout.cpp \
+    src/json/json_reader.cpp \
+    src/json/json_value.cpp \
+    src/json/json_writer.cpp \
+    src/layer.cpp \
+    src/layerengine.cpp \
+    src/ltreenode.cpp \
+    src/main.cpp \
+    src/network.cpp \
+    src/nns/alexnet.cpp \
+    src/nns/darknet19.cpp \
+    src/nns/densenet.cpp \
+    src/nns/gnmt.cpp \
+    src/nns/googlenet.cpp \
+    src/nns/incep_resnet.cpp \
+    src/nns/pnasnet.cpp \
+    src/nns/resnet.cpp \
+    src/nns/transformer.cpp \
+    src/nns/vgg.cpp \
+    src/nns/zfnet.cpp \
+    src/noc.cpp \
+    src/partition.cpp \
+    src/placement.cpp \
+    src/schnode.cpp \
+    src/util.cpp
+
+INCLUDEPATH += include/

include/bitset.h

@@ -0,0 +1,45 @@
+#ifndef BITSET_H
+#define BITSET_H
+
+#include <bitset>
+#include <cstdint>
+#include <initializer_list>
+#include <iostream>
+#include <vector>
+
+#define FOR_BITSET(var, set) for(Bitset::bitlen_t var = set.first(); var != set.max_size(); var = set.next(var))
+
+#define MAX_BITS_IN_BS 640
+
+class Bitset: private std::bitset<MAX_BITS_IN_BS>{
+public:
+	typedef std::uint16_t bitlen_t;
+private:
+	typedef std::bitset<MAX_BITS_IN_BS> std_bs;
+	// std::int64_t bits[4];
+	Bitset(std_bs&& base);
+public:
+	Bitset()=default;
+	explicit Bitset(bitlen_t bit);
+	Bitset(std::initializer_list<bitlen_t> bits);
+	Bitset(std::vector<bitlen_t> list);
+	bitlen_t count() const;
+	// Undefined behaviour if bitset is empty.
+	bitlen_t first() const;
+	// Returns 0 if there is no next.
+	bitlen_t next(bitlen_t bit) const;
+	bool contains(bitlen_t bit) const;
+	void set(bitlen_t bit);
+	void reset(bitlen_t bit);
+	void clear();
+	bitlen_t max_size() const;
+	Bitset& operator|=(const Bitset& other);
+	bool operator==(const Bitset& other) const;
+	//Bitset& operator|=(bitlen_t other);
+	friend std::ostream& operator<<(std::ostream& os, const Bitset& set);
+	friend Bitset operator|(const Bitset& lhs, const Bitset& rhs);
+};
+
+#undef MAX_BITS_IN_BS
+
+#endif // BITSET_H

include/bufferusage.h

@@ -0,0 +1,33 @@
+#ifndef BUFFERUSAGE_H
+#define BUFFERUSAGE_H
+
+#include <unordered_map>
+#include "util.h"
+
+class BufferUsage{
+	struct pos_hash {
+		std::size_t operator()(const pos_t& pos) const {
+			return std::hash<pos_t::pos_hash_t>{}(*reinterpret_cast<const pos_t::pos_hash_t*>(&pos));
+		}
+	};
+	std::unordered_map<pos_t, vol_t, pos_hash> usage;
+	vol_t factor, max_vol;
+	bool valid;
+public:
+	BufferUsage();
+	BufferUsage(vol_t _max_vol);
+	bool add(pos_t chip, vol_t size);
+	bool all_add(vol_t size);
+	operator bool() const;
+	BufferUsage& operator+=(const BufferUsage& other);
+	BufferUsage operator+(const BufferUsage& other) const;
+	void max(const BufferUsage& other);
+	vol_t max() const;
+	double avg() const;
+	bool multiple(vol_t n);
+	vol_t get_max_vol() const;
+
+	friend std::ostream& operator<<(std::ostream& os, const BufferUsage& usage);
+};
+
+#endif // BUFFERUSAGE_H

include/cluster.h

@@ -0,0 +1,58 @@
+#ifndef CLUSTER_H
+#define CLUSTER_H
+
+#include <memory>
+//#include <vector>
+#include "util.h"
+
+class Cluster{
+public:
+	/*
+	struct core{
+		pos_t pos;
+		vol_t UBUF_vol;
+	};
+	*/
+	typedef vol_t hop_t;
+	typedef cidx_t xyid_t;
+	typedef std::unique_ptr<cidx_t[]> allocRes_t;
+	static mlen_t xlen,ylen,stride;
+	static double min_util;
+private:
+	//const core* cores;
+	struct{
+		cidx_t first, last;
+	}range;
+
+	// TODO: use core_list in the future,
+	//       when cores are not allocated in rectangular fashion.
+	//bool use_range;
+	//std::vector<pos_t> core_list;
+
+public:
+	Cluster(cidx_t _first, cidx_t _last);
+	bool operator==(const Cluster& other) const;
+	bool operator!=(const Cluster& other) const;
+	cidx_t num_cores() const;
+	allocRes_t try_alloc(utime_t* ops, cidx_t childNum, utime_t totOps=0) const;
+	Cluster sub_cluster(cidx_t childIdx, const allocRes_t& allocRes) const;
+	Cluster sub_cluster(cidx_t from, cidx_t num) const;
+	/*
+	static hop_t unicast(pos_t src, pos_t dst);
+	// TODO: dst needs to be in inc. order.
+	static hop_t multicast(pos_t src, pos_t* dst, cidx_t len);
+	// DRAM is at (-1,x) and (n,x)
+	static hop_t unicast_dram(pos_t dst, vol_t size);
+	static hop_t unicast_to_dram(pos_t dst, vol_t size);
+	static hop_t multicast_dram(pos_t* dst, cidx_t len, vol_t size);
+	*/
+	static pos_t get_pos(cidx_t core_idx);
+	static xyid_t get_xyid(pos_t& chip);
+	// bool first_chip(pos_t& chip) const;
+	// bool next_chip(pos_t& chip) const;
+	pos_t operator[](cidx_t num_chip) const;
+	memidx_t nearest_dram() const;
+};
+
+
+#endif // CLUSTER_H

include/core.h

@@ -0,0 +1,78 @@
+#ifndef CORE_H
+#define CORE_H
+
+#include <cstdint>
+#include "util.h"
+
+class Core{
+public:
+	typedef std::uint16_t numMac_t;
+	const numMac_t mac_num, LR_mac_num;
+	const energy_t LR_mac_cost;
+
+	struct Buffer{
+		vol_t Size;
+		energy_t RCost, WCost;
+		bw_t RBW, WBW;
+		Buffer(vol_t _size = 0, energy_t _rCost = 0, bw_t _rBW = 256, energy_t _wCost = 0, bw_t _wBW = 0);
+	};
+	Core(numMac_t _mac_num, numMac_t _LR_mac_num, energy_t _LR_mac_cost);
+	virtual const Buffer& ubuf() const = 0;
+};
+
+class PolarCore : public Core{
+public:
+	typedef std::uint8_t vmac_t;
+	struct PESetting{
+		vmac_t vecSize, laneNum;
+		energy_t MACCost;
+		PESetting(vmac_t _vecSize, vmac_t _laneNum, energy_t _macCost);
+	};
+	typedef std::uint8_t numpe_t;
+	struct Bus{
+		numpe_t aLen,oLen,totNum; // x for act. y for wgt.
+		energy_t hopCost;
+		bw_t busBW;
+		Bus(numpe_t _aLen, numpe_t _oLen, energy_t _hopCost,bw_t _busBW);
+	};
+	struct Buffers{
+		// Notice: there are 8 wl1 in each Polar Core.
+		const Buffer al1, wl1, ol1, al2, wl2, ol2, ul3;
+	};
+	const PESetting pes;
+	const Bus bus;
+	const Buffer al1, wl1, ol1, al2, wl2, ol2, ul3;
+public:
+	PolarCore(const PESetting& _pes, const Bus& _noc,
+			  const Buffer& _al1,
+			  const Buffer& _wl1, const Buffer& _ol1,
+			  const Buffer& _al2, const Buffer& _wl2,
+			  const Buffer& _ol2, const Buffer& _ul3,
+			  numMac_t _LR_mac_num, energy_t _LR_mac_cost);
+	virtual const Core::Buffer& ubuf() const;
+};
+class EyerissCore : public Core {
+public:
+	typedef std::uint8_t vmac_t;
+	struct PESetting {
+		vmac_t Xarray, Yarray;
+		energy_t MacCost;
+		PESetting(vmac_t _Xarray, vmac_t _Yarray, energy_t _MacCost);
+	};
+	struct Bus {
+		energy_t BusCost;//global bus
+		bw_t BusBW;
+		Bus(energy_t _BusCost, bw_t _BusBW);
+	};
+	const PESetting pes;
+	const Bus ibus, wbus, pbus;
+	const Buffer al1, wl1, pl1, ul2;
+public:
+	EyerissCore(const PESetting& _pes, const Bus& _ibus, const Bus& _wbus, const Bus& _pbus,
+		const Buffer& _al1, const Buffer& _wl1,
+		const Buffer& _ol1, const Buffer& _ul2,
+		numMac_t _LR_mac_num, energy_t _LR_mac_cost
+	);
+	virtual const Core::Buffer& ubuf() const;
+};
+#endif // CORE_H