ModelGen.cc revision 10447:a465576671d4 
1#include "model/ModelGen.h"
2
3#include <iostream>
4
5#include "model/Model.h"
6// Standard cells
7#include "model/std_cells/StdCell.h"
8#include "model/std_cells/INV.h"
9#include "model/std_cells/NAND2.h"
10#include "model/std_cells/NOR2.h"
11#include "model/std_cells/MUX2.h"
12#include "model/std_cells/XOR2.h"
13#include "model/std_cells/DFFQ.h"
14#include "model/std_cells/LATQ.h"
15#include "model/std_cells/ADDF.h"
16#include "model/std_cells/OR2.h"
17#include "model/std_cells/AND2.h"
18#include "model/std_cells/BUF.h"
19// Electrical functional units
20#include "model/electrical/TestModel.h"
21#include "model/electrical/RippleAdder.h"
22#include "model/electrical/Multiplexer.h"
23#include "model/electrical/MultiplexerCrossbar.h"
24#include "model/electrical/OR.h"
25#include "model/electrical/Decoder.h"
26#include "model/electrical/DFFRAM.h"
27#include "model/electrical/MatrixArbiter.h"
28#include "model/electrical/SeparableAllocator.h"
29#include "model/electrical/router/Router.h"
30#include "model/electrical/RepeatedLink.h"
31#include "model/electrical/BroadcastHTree.h"
32// Optical functional units
33#include "model/optical/OpticalLinkBackendTx.h"
34#include "model/optical/OpticalLinkBackendRx.h"
35#include "model/optical/SWMRLink.h"
36#include "model/optical/SWSRLink.h"
37#include "model/optical/LaserSource.h"
38#include "model/optical/ThrottledLaserSource.h"
39#include "model/optical/RingModulator.h"
40#include "model/optical/RingDetector.h"
41// Networks
42#include "model/network/ElectricalMesh.h"
43#include "model/network/ElectricalClos.h"
44#include "model/network/PhotonicClos.h"
45
46namespace DSENT
47{
48    using std::cout;
49    using std::endl;
50
51    //TODO: Eventually automate the creation of this file
52
53    Model* ModelGen::createModel(const String& model_name_, const String& instance_name_, const TechModel* tech_model_)
54    {
55        Log::printLine("ModelGen::createModel -> " + model_name_);
56
57        if("INV" == model_name_)
58        {
59            return new INV(instance_name_, tech_model_);
60        }
61        else if("NAND2" == model_name_)
62        {
63            return new NAND2(instance_name_, tech_model_);
64        }
65        else if("NOR2" == model_name_)
66        {
67            return new NOR2(instance_name_, tech_model_);
68        }
69        else if("MUX2" == model_name_)
70        {
71            return new MUX2(instance_name_, tech_model_);
72        }
73        else if("XOR2" == model_name_)
74        {
75            return new XOR2(instance_name_, tech_model_);
76        }
77        else if("DFFQ" == model_name_)
78        {
79            return new DFFQ(instance_name_, tech_model_);
80        }
81        else if("LATQ" == model_name_)
82        {
83            return new LATQ(instance_name_, tech_model_);
84        }
85        else if("ADDF" == model_name_)
86        {
87            return new ADDF(instance_name_, tech_model_);
88        }
89        else if("OR2" == model_name_)
90        {
91            return new OR2(instance_name_, tech_model_);
92        }
93        else if("AND2" == model_name_)
94        {
95            return new AND2(instance_name_, tech_model_);
96        }
97        else if("BUF" == model_name_)
98        {
99            return new BUF(instance_name_, tech_model_);
100        }
101        else if("TestModel" == model_name_)
102        {
103            return new TestModel(instance_name_, tech_model_);
104        }
105        else if("RippleAdder" == model_name_)
106        {
107            return new RippleAdder(instance_name_, tech_model_);
108        }
109        else if("Multiplexer" == model_name_)
110        {
111            return new Multiplexer(instance_name_, tech_model_);
112        }
113        else if("OR" == model_name_)
114        {
115            return new OR(instance_name_, tech_model_);
116        }
117        else if("MultiplexerCrossbar" == model_name_)
118        {
119            return new MultiplexerCrossbar(instance_name_, tech_model_);
120        }
121        else if("Decoder" == model_name_)
122        {
123            return new Decoder(instance_name_, tech_model_);
124        }
125        else if("DFFRAM" == model_name_)
126        {
127            return new DFFRAM(instance_name_, tech_model_);
128        }
129        else if("MatrixArbiter" == model_name_)
130        {
131            return new MatrixArbiter(instance_name_, tech_model_);
132        }
133        else if("SeparableAllocator" == model_name_)
134        {
135            return new SeparableAllocator(instance_name_, tech_model_);
136        }
137        else if("Router" == model_name_)
138        {
139            return new Router(instance_name_, tech_model_);
140        }
141        else if("OpticalLinkBackendTx" == model_name_)
142        {
143            return new OpticalLinkBackendTx(instance_name_, tech_model_);
144        }
145        else if("OpticalLinkBackendRx" == model_name_)
146        {
147            return new OpticalLinkBackendRx(instance_name_, tech_model_);
148        }
149        else if("SWMRLink" == model_name_)
150        {
151            return new SWMRLink(instance_name_, tech_model_);
152        }
153        else if("SWSRLink" == model_name_)
154        {
155            return new SWSRLink(instance_name_, tech_model_);
156        }
157        else if("LaserSource" == model_name_)
158        {
159            return new LaserSource(instance_name_, tech_model_);
160        }
161        else if("ThrottledLaserSource" == model_name_)
162        {
163            return new ThrottledLaserSource(instance_name_, tech_model_);
164        }
165        else if("RingModulator" == model_name_)
166        {
167            return new RingModulator(instance_name_, tech_model_);
168        }
169        else if("RingDetector" == model_name_)
170        {
171            return new RingDetector(instance_name_, tech_model_);
172        }
173        else if("RepeatedLink" == model_name_)
174        {
175            return new RepeatedLink(instance_name_, tech_model_);
176        }
177        else if("BroadcastHTree" == model_name_)
178        {
179            return new BroadcastHTree(instance_name_, tech_model_);
180        }
181        else if("ElectricalMesh" == model_name_)
182        {
183            return new ElectricalMesh(instance_name_, tech_model_);
184        }
185        else if("ElectricalClos" == model_name_)
186        {
187            return new ElectricalClos(instance_name_, tech_model_);
188        }
189        else if("PhotonicClos" == model_name_)
190        {
191            return new PhotonicClos(instance_name_, tech_model_);
192        }
193        else
194        {
195            const String& error_msg = "[Error] Invalid model name (" + model_name_ + ")";
196            throw Exception(error_msg);
197            return NULL;
198        }
199        return NULL;
200    }
201
202    StdCell* ModelGen::createStdCell(const String& std_cell_name_, const String& instance_name_, const TechModel* tech_model_)
203    {
204        Log::printLine("ModelGen::createStdCell -> " + std_cell_name_);
205
206        if("INV" == std_cell_name_)
207        {
208            return new INV(instance_name_, tech_model_);
209        }
210        else if("NAND2" == std_cell_name_)
211        {
212            return new NAND2(instance_name_, tech_model_);
213        }
214        else if("NOR2" == std_cell_name_)
215        {
216            return new NOR2(instance_name_, tech_model_);
217        }
218        else if("MUX2" == std_cell_name_)
219        {
220            return new MUX2(instance_name_, tech_model_);
221        }
222        else if("XOR2" == std_cell_name_)
223        {
224            return new XOR2(instance_name_, tech_model_);
225        }
226        else if("DFFQ" == std_cell_name_)
227        {
228            return new DFFQ(instance_name_, tech_model_);
229        }
230        else if("LATQ" == std_cell_name_)
231        {
232            return new LATQ(instance_name_, tech_model_);
233        }
234        else if("ADDF" == std_cell_name_)
235        {
236            return new ADDF(instance_name_, tech_model_);
237        }
238        else if("OR2" == std_cell_name_)
239        {
240            return new OR2(instance_name_, tech_model_);
241        }
242        else if("AND2" == std_cell_name_)
243        {
244            return new AND2(instance_name_, tech_model_);
245        }
246        else if("BUF" == std_cell_name_)
247        {
248            return new BUF(instance_name_, tech_model_);
249        }
250        else
251        {
252            const String& error_msg = "[Error] Invalid Standard Cell name (" + std_cell_name_ + ")";
253            throw Exception(error_msg);
254            return NULL;
255        }
256        return NULL;
257    }
258
259    ElectricalModel* ModelGen::createRAM(const String& ram_name_, const String& instance_name_, const TechModel* tech_model_)
260    {
261        Log::printLine("ModelGen::createRAM -> " + ram_name_);
262
263        if("DFFRAM" == ram_name_)
264        {
265            return new DFFRAM(instance_name_, tech_model_);
266        }
267        else
268        {
269            const String& error_msg = "[Error] Invalid RAM name (" + ram_name_ + ")";
270            throw Exception(error_msg);
271            return NULL;
272        }
273        return NULL;
274    }
275
276    ElectricalModel* ModelGen::createCrossbar(const String& crossbar_name_, const String& instance_name_, const TechModel* tech_model_)
277    {
278        Log::printLine("ModelGen::createCrossbar -> " + crossbar_name_);
279
280        if("MultiplexerCrossbar" == crossbar_name_)
281        {
282            return new MultiplexerCrossbar(instance_name_, tech_model_);
283        }
284        else
285        {
286            const String& error_msg = "[Error] Invalid Crossbar name (" + crossbar_name_ + ")";
287            throw Exception(error_msg);
288            return NULL;
289        }
290        return NULL;
291    }
292    //-----------------------------------------------------------------
293
294    void ModelGen::printAvailableModels()
295    {
296        // TODO: Need more descriptions
297        cout << "INV NAND2 NOR2 MUX2 XOR2 DFFQ LATQ ADDF OR2 AND2 BUF" << endl;
298        cout << "RippleAdder Multiplexer OR RepeatedLink BroadcastHTree" << endl;
299        cout << "MultiplexerCrossbar Decoder DFFRAM MatrixArbiter SeparableAllocator Router" << endl;
300        cout << "OpticalLinkBackendTx OpticalLinkBackendRx SWMRLink SWSRLink" << endl;
301        cout << "LaserSource ThrottledLaserSource RingModulator RingDetector" << endl;
302        cout << "ElectricalMesh ElectricalClos PhotonicClos" << endl;
303        return;
304    }
305} // namespace DSENT
306
307