1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
#include <stdint.h>
#include <vector>
#include <string>
#include <unordered_set>
#include <unordered_map>
// replace with proper IdString later
typedef std::string IdString;
// replace with haslib later
template<typename T> using pool = std::unordered_set<T>;
template<typename T, typename U> using dict = std::unordered_map<T, U>;
using std::vector;
// -------------------------------------------------------
// Arch-specific declarations
struct ObjId
{
uint8_t tile_x = 0, tile_y = 0;
uint16_t index = 0;
bool nil() const {
return !tile_x && !tile_y && !index;
}
} __attribute__((packed));
namespace std
{
template<> struct hash<ObjId>
{
std::size_t operator()(const ObjId &obj) const noexcept
{
std::size_t result = std::hash<int>{}(obj.index);
result ^= std::hash<int>{}(obj.tile_x) + 0x9e3779b9 + (result << 6) + (result >> 2);
result ^= std::hash<int>{}(obj.tile_y) + 0x9e3779b9 + (result << 6) + (result >> 2);
return result;
}
};
}
struct ObjIterator
{
ObjId *ptr = nullptr;
void operator++() { ptr++; }
bool operator!=(const ObjIterator &other) const { return ptr != other.ptr; }
ObjId operator*() const { return *ptr; }
};
struct ObjRange
{
ObjIterator b, e;
ObjIterator begin() const { return b; }
ObjIterator end() const { return e; }
};
struct BelPin
{
ObjId bel;
IdString pin;
};
struct BelPinIterator
{
BelPin *ptr = nullptr;
void operator++() { ptr++; }
bool operator!=(const BelPinIterator &other) const { return ptr != other.ptr; }
BelPin operator*() const { return *ptr; }
};
struct BelPinRange
{
BelPinIterator b, e;
BelPinIterator begin() const { return b; }
BelPinIterator end() const { return e; }
};
struct GuiLine
{
float x1, y1, x2, y2;
};
struct Chip
{
// ...
Chip(std::string cfg);
void setBelActive(ObjId bel, bool active);
bool getBelActive(ObjId bel);
ObjId getObjByName(IdString name) const;
IdString getObjName(ObjId obj) const;
ObjRange getBels() const;
ObjRange getBelsByType(IdString type) const;
IdString getBelType(ObjId bel) const;
void getObjPosition(ObjId obj, float &x, float &y) const;
vector<GuiLine> getGuiLines(ObjId obj) const;
ObjRange getWires() const;
ObjRange getWiresUphill(ObjId wire) const;
ObjRange getWiresDownhill(ObjId wire) const;
ObjRange getWiresBidir(ObjId wire) const;
ObjRange getWireAliases(ObjId wire) const;
// the following will only operate on / return "active" BELs
// multiple active uphill BELs for a wire will cause a runtime error
ObjId getWireBelPin(ObjId bel, IdString pin) const;
BelPin getBelPinUphill(ObjId wire) const;
BelPinRange getBelPinsDownhill(ObjId wire) const;
};
// -------------------------------------------------------
// Generic declarations
struct PortRef
{
IdString cell_name;
IdString port_name;
};
struct NetInfo
{
IdString name;
PortRef driver;
vector<PortRef> users;
dict<IdString, std::string> attrs;
// wire -> delay
dict<ObjId, float> wires;
};
enum PortType
{
PORT_IN = 0,
PORT_OUT = 1,
PORT_INOUT = 2
};
struct PortInfo
{
IdString name, net;
PortType type;
};
struct CellInfo
{
IdString name, type;
dict<IdString, PortInfo> ports;
dict<IdString, std::string> attrs, params;
ObjId bel;
// cell_port -> bel_pin
dict<IdString, IdString> pins;
};
struct Design
{
struct Chip chip;
Design(std::string chipCfg) : chip(chipCfg) {
// ...
}
dict<IdString, NetInfo*> nets;
dict<IdString, CellInfo*> cells;
};
|
