blob: a5cdb9d02134150acf28aa389a05e6ad97e02931 [file] [log] [blame] [edit]
/* Copyright (c) 2012 Massachusetts Institute of Technology
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "model/ModelGen.h"
#include <iostream>
#include "model/Model.h"
// Standard cells
#include "model/std_cells/StdCell.h"
#include "model/std_cells/INV.h"
#include "model/std_cells/NAND2.h"
#include "model/std_cells/NOR2.h"
#include "model/std_cells/MUX2.h"
#include "model/std_cells/XOR2.h"
#include "model/std_cells/DFFQ.h"
#include "model/std_cells/LATQ.h"
#include "model/std_cells/ADDF.h"
#include "model/std_cells/OR2.h"
#include "model/std_cells/AND2.h"
#include "model/std_cells/BUF.h"
// Electrical functional units
#include "model/electrical/TestModel.h"
#include "model/electrical/RippleAdder.h"
#include "model/electrical/Multiplexer.h"
#include "model/electrical/MultiplexerCrossbar.h"
#include "model/electrical/OR.h"
#include "model/electrical/Decoder.h"
#include "model/electrical/DFFRAM.h"
#include "model/electrical/MatrixArbiter.h"
#include "model/electrical/SeparableAllocator.h"
#include "model/electrical/router/Router.h"
#include "model/electrical/RepeatedLink.h"
#include "model/electrical/BroadcastHTree.h"
// Optical functional units
#include "model/optical/OpticalLinkBackendTx.h"
#include "model/optical/OpticalLinkBackendRx.h"
#include "model/optical/SWMRLink.h"
#include "model/optical/SWSRLink.h"
#include "model/optical/LaserSource.h"
#include "model/optical/ThrottledLaserSource.h"
#include "model/optical/RingModulator.h"
#include "model/optical/RingDetector.h"
// Networks
#include "model/network/ElectricalMesh.h"
#include "model/network/ElectricalClos.h"
#include "model/network/PhotonicClos.h"
namespace DSENT
{
using std::cout;
using std::endl;
//TODO: Eventually automate the creation of this file
Model* ModelGen::createModel(const String& model_name_, const String& instance_name_, const TechModel* tech_model_)
{
Log::printLine("ModelGen::createModel -> " + model_name_);
if("INV" == model_name_)
{
return new INV(instance_name_, tech_model_);
}
else if("NAND2" == model_name_)
{
return new NAND2(instance_name_, tech_model_);
}
else if("NOR2" == model_name_)
{
return new NOR2(instance_name_, tech_model_);
}
else if("MUX2" == model_name_)
{
return new MUX2(instance_name_, tech_model_);
}
else if("XOR2" == model_name_)
{
return new XOR2(instance_name_, tech_model_);
}
else if("DFFQ" == model_name_)
{
return new DFFQ(instance_name_, tech_model_);
}
else if("LATQ" == model_name_)
{
return new LATQ(instance_name_, tech_model_);
}
else if("ADDF" == model_name_)
{
return new ADDF(instance_name_, tech_model_);
}
else if("OR2" == model_name_)
{
return new OR2(instance_name_, tech_model_);
}
else if("AND2" == model_name_)
{
return new AND2(instance_name_, tech_model_);
}
else if("BUF" == model_name_)
{
return new BUF(instance_name_, tech_model_);
}
else if("TestModel" == model_name_)
{
return new TestModel(instance_name_, tech_model_);
}
else if("RippleAdder" == model_name_)
{
return new RippleAdder(instance_name_, tech_model_);
}
else if("Multiplexer" == model_name_)
{
return new Multiplexer(instance_name_, tech_model_);
}
else if("OR" == model_name_)
{
return new OR(instance_name_, tech_model_);
}
else if("MultiplexerCrossbar" == model_name_)
{
return new MultiplexerCrossbar(instance_name_, tech_model_);
}
else if("Decoder" == model_name_)
{
return new Decoder(instance_name_, tech_model_);
}
else if("DFFRAM" == model_name_)
{
return new DFFRAM(instance_name_, tech_model_);
}
else if("MatrixArbiter" == model_name_)
{
return new MatrixArbiter(instance_name_, tech_model_);
}
else if("SeparableAllocator" == model_name_)
{
return new SeparableAllocator(instance_name_, tech_model_);
}
else if("Router" == model_name_)
{
return new Router(instance_name_, tech_model_);
}
else if("OpticalLinkBackendTx" == model_name_)
{
return new OpticalLinkBackendTx(instance_name_, tech_model_);
}
else if("OpticalLinkBackendRx" == model_name_)
{
return new OpticalLinkBackendRx(instance_name_, tech_model_);
}
else if("SWMRLink" == model_name_)
{
return new SWMRLink(instance_name_, tech_model_);
}
else if("SWSRLink" == model_name_)
{
return new SWSRLink(instance_name_, tech_model_);
}
else if("LaserSource" == model_name_)
{
return new LaserSource(instance_name_, tech_model_);
}
else if("ThrottledLaserSource" == model_name_)
{
return new ThrottledLaserSource(instance_name_, tech_model_);
}
else if("RingModulator" == model_name_)
{
return new RingModulator(instance_name_, tech_model_);
}
else if("RingDetector" == model_name_)
{
return new RingDetector(instance_name_, tech_model_);
}
else if("RepeatedLink" == model_name_)
{
return new RepeatedLink(instance_name_, tech_model_);
}
else if("BroadcastHTree" == model_name_)
{
return new BroadcastHTree(instance_name_, tech_model_);
}
else if("ElectricalMesh" == model_name_)
{
return new ElectricalMesh(instance_name_, tech_model_);
}
else if("ElectricalClos" == model_name_)
{
return new ElectricalClos(instance_name_, tech_model_);
}
else if("PhotonicClos" == model_name_)
{
return new PhotonicClos(instance_name_, tech_model_);
}
else
{
const String& error_msg = "[Error] Invalid model name (" + model_name_ + ")";
throw Exception(error_msg);
return NULL;
}
return NULL;
}
StdCell* ModelGen::createStdCell(const String& std_cell_name_, const String& instance_name_, const TechModel* tech_model_)
{
Log::printLine("ModelGen::createStdCell -> " + std_cell_name_);
if("INV" == std_cell_name_)
{
return new INV(instance_name_, tech_model_);
}
else if("NAND2" == std_cell_name_)
{
return new NAND2(instance_name_, tech_model_);
}
else if("NOR2" == std_cell_name_)
{
return new NOR2(instance_name_, tech_model_);
}
else if("MUX2" == std_cell_name_)
{
return new MUX2(instance_name_, tech_model_);
}
else if("XOR2" == std_cell_name_)
{
return new XOR2(instance_name_, tech_model_);
}
else if("DFFQ" == std_cell_name_)
{
return new DFFQ(instance_name_, tech_model_);
}
else if("LATQ" == std_cell_name_)
{
return new LATQ(instance_name_, tech_model_);
}
else if("ADDF" == std_cell_name_)
{
return new ADDF(instance_name_, tech_model_);
}
else if("OR2" == std_cell_name_)
{
return new OR2(instance_name_, tech_model_);
}
else if("AND2" == std_cell_name_)
{
return new AND2(instance_name_, tech_model_);
}
else if("BUF" == std_cell_name_)
{
return new BUF(instance_name_, tech_model_);
}
else
{
const String& error_msg = "[Error] Invalid Standard Cell name (" + std_cell_name_ + ")";
throw Exception(error_msg);
return NULL;
}
return NULL;
}
ElectricalModel* ModelGen::createRAM(const String& ram_name_, const String& instance_name_, const TechModel* tech_model_)
{
Log::printLine("ModelGen::createRAM -> " + ram_name_);
if("DFFRAM" == ram_name_)
{
return new DFFRAM(instance_name_, tech_model_);
}
else
{
const String& error_msg = "[Error] Invalid RAM name (" + ram_name_ + ")";
throw Exception(error_msg);
return NULL;
}
return NULL;
}
ElectricalModel* ModelGen::createCrossbar(const String& crossbar_name_, const String& instance_name_, const TechModel* tech_model_)
{
Log::printLine("ModelGen::createCrossbar -> " + crossbar_name_);
if("MultiplexerCrossbar" == crossbar_name_)
{
return new MultiplexerCrossbar(instance_name_, tech_model_);
}
else
{
const String& error_msg = "[Error] Invalid Crossbar name (" + crossbar_name_ + ")";
throw Exception(error_msg);
return NULL;
}
return NULL;
}
//-----------------------------------------------------------------
void ModelGen::printAvailableModels()
{
// TODO: Need more descriptions
cout << "INV NAND2 NOR2 MUX2 XOR2 DFFQ LATQ ADDF OR2 AND2 BUF" << endl;
cout << "RippleAdder Multiplexer OR RepeatedLink BroadcastHTree" << endl;
cout << "MultiplexerCrossbar Decoder DFFRAM MatrixArbiter SeparableAllocator Router" << endl;
cout << "OpticalLinkBackendTx OpticalLinkBackendRx SWMRLink SWSRLink" << endl;
cout << "LaserSource ThrottledLaserSource RingModulator RingDetector" << endl;
cout << "ElectricalMesh ElectricalClos PhotonicClos" << endl;
return;
}
} // namespace DSENT