diff --git a/chamsin/CMakeLists.txt b/chamsin/CMakeLists.txt new file mode 100644 index 00000000..4d7b6e3f --- /dev/null +++ b/chamsin/CMakeLists.txt @@ -0,0 +1,15 @@ +PROJECT(CHAMSIN) + +CMAKE_MINIMUM_REQUIRED(VERSION 2.4.0) + +SET(CMAKE_MODULE_PATH "$ENV{HURRICANE_TOP}/share/cmake_modules/") + +FIND_PACKAGE(BISON REQUIRED) +FIND_PACKAGE(FLEX REQUIRED) +find_package(HURRICANE REQUIRED) +#FIND_PACKAGE(Doxygen) + +ADD_SUBDIRECTORY(src) +#IF(DOXYGEN_FOUND) +# ADD_SUBDIRECTORY(doc) +#ENDIF(DOXYGEN_FOUND) diff --git a/chamsin/src/CMakeLists.txt b/chamsin/src/CMakeLists.txt new file mode 100644 index 00000000..789d6e6e --- /dev/null +++ b/chamsin/src/CMakeLists.txt @@ -0,0 +1,4 @@ +ADD_SUBDIRECTORY(analogic) +ADD_SUBDIRECTORY(dtr) +ADD_SUBDIRECTORY(device) +ADD_SUBDIRECTORY(tests) diff --git a/chamsin/src/analogic/AnalogicalCommons.h b/chamsin/src/analogic/AnalogicalCommons.h new file mode 100644 index 00000000..172521ba --- /dev/null +++ b/chamsin/src/analogic/AnalogicalCommons.h @@ -0,0 +1,45 @@ +// **************************************************************************************************** +// File: AnalogicalCommons.h +// Authors: Wu YiFei +// Date : 21/12/2006 +// **************************************************************************************************** + +#ifndef HURRICANE_ANALOGICALCOMMONS +#define HURRICANE_ANALOGICALCOMMONS + + + +// ********************************************************************* +// Macros Declaration. +// ********************************************************************* + +# define TRANSN 'N' +# define TRANSP 'P' + + +# define MAXNBCONTACT 8 + +# define IF_DEBUG_HUR_ANALOG \ + if(getenv("DEBUG_HUR_ANALOG")) { + +# ifndef END_IF +# define END_IF \ + } +# endif + + +// ********************************************************************* +// Analogical Unit declaration. +// ********************************************************************* +# if !defined(__DOXYGEN_PROCESSOR__) + +typedef double Micro; +typedef double MicroPower2; +typedef long Nano; + +# endif + +#include "TwoSpaces.h" + + +#endif // HURRICANE_ANALOGICALCOMMONS diff --git a/chamsin/src/analogic/CMakeLists.txt b/chamsin/src/analogic/CMakeLists.txt new file mode 100644 index 00000000..ce73afcb --- /dev/null +++ b/chamsin/src/analogic/CMakeLists.txt @@ -0,0 +1,12 @@ +INCLUDE_DIRECTORIES(${CHAMSIN_SOURCE_DIR}/src/dtr ${HURRICANE_INCLUDE_DIR} ${source_dir}) + +ADD_LIBRARY(analogic SHARED +GenV1Trans.cpp +MetaTransistor.cpp +RdsUnit.cpp +Transistor.cpp +TwoSpaces.cpp) + +TARGET_LINK_LIBRARIES(analogic ${HURRICANE_LIBRARIES}) + +INSTALL(TARGETS analogic DESTINATION /lib) diff --git a/chamsin/src/analogic/GenTrans.h b/chamsin/src/analogic/GenTrans.h new file mode 100644 index 00000000..6104c5a8 --- /dev/null +++ b/chamsin/src/analogic/GenTrans.h @@ -0,0 +1,220 @@ +// **************************************************************************************************** +// File: GenTrans.h +// Authors: Wu YiFei +// Date : 04/04/2007 +// **************************************************************************************************** + + +#ifndef HURRICANE_GENTRANS +#define HURRICANE_GENTRANS + + +#include "Transistor.h" +#include "Box.h" + + +// -------------------------------------------------------------------- +// Macro Method : "MAXLONG(a,b), MINLONG(a,b)" +// Comparaison Method Macro For Calculate Rectangles. + +#define MAXLONG(a,b) (a>b?a:b) +#define MINLONG(a,b) (a>b?b:a) + + +// -------------------------------------------------------------------- +// Macro Method : "GET_RULE(s)" +// This Method Macro is For Geting The Value in RdsUnit of a DRM Rule. +// To Use This Macro, you must predefine Pointeur dtraccess. + +#define GET_RULE(s) \ + dtraccess->GetSingleRdsRuleByLabel(string(s)) + + + +// -------------------------------------------------------------------- +// Macro Method "GET_RULE_BYNP(prefix, type, suffix)" +// This Method Macro is For Geting The Value in RdsUnit of a DRM Rule +// selected by string type which is mostype . + + /* \prefix must be a chain character. + * \type mos type('N'/'P'), must be a string. + * \suffix must be a chain character. + */ + +// To Use This Macro, you must Predefine Pointeur dtraccess. + +#define GET_RULE_BYNP(prefix, type, suffix) \ + dtraccess->GetSingleRdsRuleByLabel(prefix, type, suffix) + + + +// -------------------------------------------------------------------- +// Macro Method : "Get_LAYER_BYNP(prefix, type, suffix)" +// This Method Macro is For Geting the Layer of a Layer Rule Selected +// by string type which is mostype. To Use This Macro, you must predefine +// Pointeur dtraccess. + + /* \prefix must be a chain of character. + * \type mos type('N'/'P'), must be a string. + * \suffix must be a string. + */ + +// To Use This Macro, you must Predefine Pointeur dtraccess. + +#define GET_LAYER_BYNP(prefix, type, suffix) \ + dtraccess->GetSingleLayerByLabel(prefix, type, suffix) + + + +// -------------------------------------------------------------------- +// Macro Method : "SAVE_RECTANGLE(S, x, y, dx, dy)" +// This Method Macro is For Saving A Rectangle in a map . + + /* \s name of rectangle, must be a chain of character. + * \x xmin, must be a long. + * \y ymin, must be a long. + * \dx width, must be a long. + * \dy height, must be a long. + */ + +// This Method Macro must be used in Membre Function Calculate. + +#define SAVE_RECTANGLE(s, x, y, dx, dy) \ + _mapString2Box[string(s)] = Box(GetUnit(x), GetUnit(y), GetUnit(x+dx), GetUnit(y+dy)); \ + xmin = MINLONG(xmin, GetUnit(x)); \ + ymin = MINLONG(ymin, GetUnit(y)); + + +// -------------------------------------------------------------------- +// Macro Method : "GET_BOX(s)" +// This Method Macro is For Get the box According to the its name. + + /* + * \s name of rectangle, must be a string. + */ + +// This Method Macro must be used in member function of Class GenTrans. +// + +#define GET_BOX(s) \ + _mapString2Box[s] + + +// --------------------------------------------------------------------- +// Macro Method : "CREATE_CONTACT_MATRIX_UNDER(boxname, nbcolumn, layer, net)" +// This Method Macro is For Create a matrix of Contact under a zone for +// a net specified. + + /* \underbox A rectangle under which contacts will be placed, must be a objet Box. + * \nbcolumn the number of column, must be a integer. + * \layer the layer of contact, must be a pointer of type Layer*. + * \net the net to be hooked, must be a pointer of type Net*. + */ + +// To use this Macro Function. You Must also définir variable nbcontact, +// tmp_xcenter, tmp_ycenter, rw_cont, rd_cont. +// + +#define CREATE_CONTACT_MATRIX_UNDER(underbox, nbcolumn, layer, net) \ + \ + if(underbox.getHeight() _mapString2Box; + + +// Constructors +// ************* + public : GenTrans() {}; + +// Destructors +// *********** + public : virtual ~GenTrans() {}; + +// Operators +// ********** + public : virtual void Calculate(Transistor*) = 0; + public : virtual void Generate(Transistor*) = 0; + +}; + + +class GenV1Trans : public GenTrans { +// ********************************* + +// Types +// ***** + public : typedef GenTrans Inherit; + +// Attributs +// ********* + public : const Transistor::MaskV1Info* _masqueV1Info; + +// Constructors +// ************ + public : GenV1Trans(Transistor::MaskV1Info*); + +// Destructors +// ************ + public : virtual ~GenV1Trans() {}; + +// Operators +// ********* + public : virtual void Calculate(Transistor*) ; + public : virtual void Generate(Transistor*) ; + +}; + + +END_NAMESPACE_HURRICANE + +#endif diff --git a/chamsin/src/analogic/GenV1Trans.cpp b/chamsin/src/analogic/GenV1Trans.cpp new file mode 100644 index 00000000..528ba67c --- /dev/null +++ b/chamsin/src/analogic/GenV1Trans.cpp @@ -0,0 +1,539 @@ +// **************************************************************************************************** +// File: GenV1Trans.cpp +// Authors: Wu YiFei +// Date : 04/04/2007 +// **************************************************************************************************** + +#include "Collection.h" +#include "RdsUnit.h" +#include "GenTrans.h" +#include "DtrAccess.h" +#include "GenericDtrAccess.h" + +#include "Technology.h" +#include "UpdateSession.h" + +#include "DataBase.h" + + + +BEGIN_NAMESPACE_HURRICANE + + + +// **************************************************************************************************** +// Globals Datas +// **************************************************************************************************** +string segsforsource[] = {string("20"), string("23")}; +string segsfordrain[] = {string("40"), string("43")}; +string segsforgrid[] = {string("00"), string("01"), string("30"), string("31")}; +//string segsforgrid[] = {string("00"), string("30") }; +string segsforanonym[] = {string("10"), string("11"), string("12"), string("50")}; + + +// **************************************************************************************************** +// Class GetV1Trans implementation +// **************************************************************************************************** +GenV1Trans::GenV1Trans(Transistor::MaskV1Info* masqueinfo) +// ********************************************************* +: _masqueV1Info(masqueinfo) +{ +} + + +void GenV1Trans::Calculate(Transistor* transistor) +// ********************************************** +{ + DtrAccess * dtraccess = DtrAccess::Instance(); + + // Check out mask param. + // ********************* + if(_masqueV1Info->GetL() < dtraccess->GetSingleRealRuleByLabel("L_TRANS") || + _masqueV1Info->GetL() > dtraccess->GetSingleRealRuleByLabel("L_TRANS_MAX") || + _masqueV1Info->GetW() < dtraccess->GetSingleRealRuleByLabel("W_TRANS") || + _masqueV1Info->GetW() > dtraccess->GetSingleRealRuleByLabel("W_TRANS_MAX") ) + + throw Error("Can't launch function GenV1Trans::Calculate for " + GetString(transistor) + + " the L " + GetString(_masqueV1Info->GetL()) + + " or the W " + GetString(_masqueV1Info->GetW()) + + " of this transistor is invalid." + ); + + if(_masqueV1Info->GetNbSourceColumn() < 1 || _masqueV1Info->GetNbSourceColumn() > MAXNBCONTACT || + _masqueV1Info->GetNbDrainColumn() < 1 || _masqueV1Info->GetNbDrainColumn() > MAXNBCONTACT ) + + throw Error("Can't launch function GenV1Trans::Calculate for " + GetString(transistor) + + " the nbsourcecolumn " + GetString(_masqueV1Info->GetNbSourceColumn()) + + " or the nbdraincolumn " + GetString(_masqueV1Info->GetNbDrainColumn()) + + " of this transistor is invalid." + ); + + IF_DEBUG_HUR_ANALOG + cout << ts << GetString(transistor) + " 's masqueinfo is " + GetString(_masqueV1Info) + << endl; + END_IF + + + // Tempory Variable. + // ************************** + long x00, y00, dx00, dy00; + long x10, y10, dx10, dy10; + long x11, y11, dx11, dy11; + long x12, y12, dx12, dy12; + long x20, y20, dx20, dy20; + long x23, y23, dx23, dy23; + long x30, y30, dx30, dy30; + long x31, y31, dx31, dy31; + long x01, y01, dx01, dy01; + long x40, y40, dx40, dy40; + long x43, y43, dx43, dy43; + long x50, y50, dx50, dy50; + + long xmin = 999999L, ymin = 999999L; + long realw = 0; + + // Tempory Variable. + // ************************** + long extension1 = 0; + long extension2 = 0; + long extension3 = 0; + long extension4 = 0; + long ymax = 0; + string mostype; // Get Mos Type (N/P). + + if(transistor->IsNmos()) + mostype='N'; + else + mostype='P'; + + //string mostype; // Get Mos Type (N/P). + //mostype=transistor->GetType(); + + // ------------------------------------------------------------- + // Begin Calculate. + + //long re_imp_acti = GET_RULE_BYNP("RE_", mostype, "IMP_ACTI"); + long re_imp_acti = GET_RULE_BYNP("RE_", mostype, "IMP_ACTI"); + long re_imp_poly = GET_RULE_BYNP("RE_", mostype, "IMP_POLY"); + long re_imp_cont = GET_RULE_BYNP("RE_", mostype, "IMP_CONT"); + long re_imp_gate = GET_RULE_BYNP("RE_", mostype, "IMP_GATE"); + //long re_well_acti = GET_RULE_BYNP("RE_", mostype, "WELL_ACTI"); + + // Calculate Rectangle 00 + // ********************** + x00 = 0; + y00 = -( GET_RULE("RE_GATE_ACTI") ); + + dx00 = ConvertRealToRdsUnit(_masqueV1Info->GetL()); + realw = ConvertRealToRdsUnit(_masqueV1Info->GetW()); + + dy00 = realw + 2*(-y00); + + SAVE_RECTANGLE("00", x00, y00, dx00, dy00) + + + // Calculate Rectangle 30 + // ********************** + +// cout << "RD_ACTI_CONT is " << GET_RULE("RD_ACTI_CONT")<= dx00) { + dx30 = GET_RULE("RW_CONT"); + dy30 = dx30; + y30 = 0 + realw + MAXLONG(GET_RULE("RD_ACTI_CONT"), GET_RULE("RD_ACTI_POLY") + GET_RULE("RE_POLY_CONT")); + } + else { + dx30 = dx00 - 2*GET_RULE("RE_POLY_CONT"); + dy30 = GET_RULE("RW_CONT"); + y30 = 0 + realw + GET_RULE("RD_ACTI_CONT"); + } + + x30 = x00 + dx00/2 - dx30/2; + + SAVE_RECTANGLE("30", x30, y30, dx30, dy30) + + + // Calculate Rectangle 31 + // ********************** + dx31 = dx30 + 2*GET_RULE("RE_POLY_CONT"); + dy31 = dy30 + 2*GET_RULE("RE_POLY_CONT"); + x31 = x30 - GET_RULE("RE_POLY_CONT"); + y31 = y30 - GET_RULE("RE_POLY_CONT"); + + SAVE_RECTANGLE("31", x31, y31, dx31, dy31) + + + // Calculate Rectangle 01 + // ********************** + if ( y31 <= (y00+dy00) ) { + x01 = 0; y01 = 0; dx01 = 0; dy01 = 0; + } + else { + x01 = x00; + y01 = y00 + dy00; + dx01 = dx00; + dy01 = y31 - (y00 + dy00); + } + + SAVE_RECTANGLE("01", x01, y01, dx01, dy01) + + + // Calculate Rectangle 12 + // ********************** + x12 = MINLONG(x31, x00) - re_imp_poly; + y12 = MINLONG(0 - re_imp_acti, y00 - re_imp_poly); + dx12 = MAXLONG(dx31, dx00) + 2 * re_imp_poly; + + ymax = MAXLONG( MAXLONG( y30 + dy30 + re_imp_cont + , MAXLONG(y31 + dy31, y00 + dy00) + re_imp_poly ) + , realw + re_imp_acti ); + + dy12 = ymax - y12 ; + + SAVE_RECTANGLE("12", x12, y12, dx12, dy12) + + + // Calculate Rectangle 20 + // ********************** + y20 = 0 + GET_RULE("RE_ACTI_CONT"); + dy20 = realw - 2 * GET_RULE("RE_ACTI_CONT"); + dx20 = (_masqueV1Info->GetNbSourceColumn()) * GET_RULE("RW_CONT") + + ((_masqueV1Info->GetNbSourceColumn()) - 1) * GET_RULE("RD_CONT"); + x20 = 0 - ( dx20 + GET_RULE("RD_CONT_GATE") ); + + SAVE_RECTANGLE("20", x20, y20, dx20, dy20) + + + // Calculate Rectangle 40 + // ********************** + y40 = y20; + x40 = x00 + dx00 + GET_RULE("RD_CONT_GATE"); + dx40 = (_masqueV1Info->GetNbDrainColumn()) * GET_RULE("RW_CONT") + + ((_masqueV1Info->GetNbDrainColumn()) - 1) * GET_RULE("RD_CONT"); + dy40 = dy20; + + SAVE_RECTANGLE("40", x40, y40, dx40, dy40) + + // Calculate Rectangle 10 + // ********************** + y10 = 0; + x10 = MINLONG(x20 - GET_RULE("RE_ACTI_CONT"), 0 - GET_RULE("RE_ACTI_GATE")); + dy10 = realw; + + extension1 = MAXLONG(0 + x40 + dx40 + GET_RULE("RE_ACTI_CONT"), dx00 + GET_RULE("RE_ACTI_GATE")); + + dx10 = 0 - x10 + extension1; + + SAVE_RECTANGLE("10", x10, y10, dx10, dy10) + + + // Calculate Rectangle 23 + // *********************** + x23 = x10; + y23 = y10; + dx23 = 0 - x10; + dy23 = realw; + + SAVE_RECTANGLE("23", x23, y23, dx23, dy23) + + + // Calculate Rectangle 43 + // ********************** + x43 = x00 + dx00 ; + y43 = y10; + dx43 = x10 + dx10 - (x00 + dx00); + dy43 = realw; + + SAVE_RECTANGLE("43", x43, y43, dx43, dy43) + + + // Calculate Rectangle 11 + // ********************** + extension1 = re_imp_gate; + extension2 = re_imp_cont + 0 - x20; + extension3 = re_imp_acti + 0 - x10; + + extension4 = MAXLONG(MAXLONG(extension1, extension2), extension3); + + x11 = 0 - extension4; + + extension1 = re_imp_gate + x00 + dx00; + extension2 = re_imp_cont + x40 + dx40; + extension3 = re_imp_acti + x10 + dx10; + + extension4 = MAXLONG(MAXLONG(extension1, extension2), extension3); + + dx11 = 0 - x11 + extension4; + + y11 = MINLONG(y20 - re_imp_cont, y23 - re_imp_acti); + + ymax = MAXLONG(y20 + dy20 + re_imp_cont, y23 + dy23 + re_imp_acti); + + dy11 = ymax - y11; + + SAVE_RECTANGLE("11", x11, y11, dx11, dy11); + + + // Calculate Rectangle 50 just for PMOS. + // ------------------------------------------------------------- + if (transistor->IsPmos()) { // Calculate Rectangle 50 for PMos. + x50 = x10 - GET_RULE("RE_NWELL_ACTI"); + y50 = y10 - GET_RULE("RE_NWELL_ACTI"); + dx50 = dx10 + 2 * GET_RULE("RE_NWELL_ACTI"); + dy50 = dy10 + 2 * GET_RULE("RE_NWELL_ACTI"); + + SAVE_RECTANGLE("50", x50, y50, dx50, dy50); + } + + // End Calculate. + // ------------------------------------------------------------- + + // Translate rectangles. + // ********************* + map::iterator i = _mapString2Box.begin(), + j = _mapString2Box.end(); + + while(i!=j) { + _mapString2Box[(*i).first] = (*i).second.translate(-xmin, -ymin); + + IF_DEBUG_HUR_ANALOG + cout << ts << (*i).first <<" " << GetString((*i).second) << endl; + END_IF + + assert(BOX_IS_VALID((*i).second)); + i++; + } + +} + + +void GenV1Trans::Generate(Transistor* transistor) +// ********************************************* +{ + OpenUpdateSession(); + + Net* source = transistor->GetNet(Name(transistor->GetSourceName())); + Net* drain = transistor->GetNet(Name(transistor->GetDrainName()) ); + Net* grid = transistor->GetNet(Name(transistor->GetGridName()) ); + + DtrAccess * dtraccess = DtrAccess::Instance(); + //string mostype(1, transistor->GetType()); // Get Mos Type (N/P). + + string mostype; // Get Mos Type (N/P). + + if(transistor->IsNmos()) + mostype='N'; + else + mostype='P'; + + long rw_cont = GetUnit(GET_RULE("RW_CONT")); + long rd_cont = GetUnit(GET_RULE("RD_CONT")); + unsigned nbcontact = 0; + long tmp_xcenter = 0; + long tmp_ycenter = 0; + + DataBase * db = GetDataBase(); + + if(!db) throw Error("In GetV1Trans::Generate : can't find DataBase"); + + //Technology * tech = db->GetTechnology(); + + Layer * layer_20 = GET_LAYER_BYNP("TRANS_",mostype,"_LAYER_20"); + Layer * layer_30 = GET_LAYER_BYNP("TRANS_",mostype,"_LAYER_30"); + Layer * layer_40 = GET_LAYER_BYNP("TRANS_",mostype,"_LAYER_40"); + + + // ------------------------------------------------------------- + // Begin Generation. + + // Cenerate Components For Net Source. + // *********************************** +IF_DEBUG_HUR_ANALOG + cout << ts << "Begin for create components for net Source of " << GetString(transistor) << endl; +END_IF + + for(size_t i=0; iGetNbSourceColumn(), layer_20, source) + //cout << ts << " Finish create contact for source " <GetNbDrainColumn(), layer_40, drain) + //cout << ts << " Finish create contact for drain" <IsNmos() && segsforanonym[i]=="50") + continue; + + Contact::Create(anonym, GET_LAYER_BYNP("TRANS_",mostype,"_LAYER_"+segsforanonym[i]) + , GET_BOX(segsforanonym[i]).getXCenter() + , GET_BOX(segsforanonym[i]).getYCenter() + , GET_BOX(segsforanonym[i]).getWidth() + , GET_BOX(segsforanonym[i]).getHeight() + ); + } + +IF_DEBUG_HUR_ANALOG + cout << ts << "End for create components for net Anonyme of " << GetString(transistor) << endl; +END_IF + + // End Generation. + // ------------------------------------------------------------- + + CloseUpdateSession(); + + // Set Transistor::_mapNet2Box. + // **************************** + (*(transistor->_GetMapNet2Box()))[grid] = _mapString2Box[string("30")]; + (*(transistor->_GetMapNet2Box()))[source] = _mapString2Box[string("20")]; + (*(transistor->_GetMapNet2Box()))[drain] = _mapString2Box[string("40")]; + + cout<< GetString(_mapString2Box[string("30")]) <GetAbutmentType().GetCode()) { + + case Transistor::Type::INTERNAL : + transistor->SetAbutmentBox( Box(GET_BOX(string("20")).getXCenter() + , transistor->GetBoundingBox().getYMin() + , GET_BOX(string("40")).getXCenter() + , transistor->GetBoundingBox().getYMax() + ) + ); + break; + + case Transistor::Type::LEFT: + transistor->SetAbutmentBox( Box(GET_BOX(string("11")).getXMin() + , transistor->GetBoundingBox().getYMin() + , GET_BOX(string("40")).getXCenter() + , transistor->GetBoundingBox().getYMax() + ) + ); + break ; + + case Transistor::Type::RIGHT: + transistor->SetAbutmentBox( Box(GET_BOX(string("20")).getXCenter() + , transistor->GetBoundingBox().getYMin() + , GET_BOX(string("11")).getXMax() + , transistor->GetBoundingBox().getYMax() + ) + ); + break ; + + case Transistor::Type::SINGLE: + transistor->SetAbutmentBox( Box(GET_BOX(string("11")).getXMin() + , transistor->GetBoundingBox().getYMin() + , GET_BOX(string("11")).getXMax() + , transistor->GetBoundingBox().getYMax() + ) + ); + break ; + + default : + break; + } + + +} + + +END_NAMESPACE_HURRICANE diff --git a/chamsin/src/analogic/MetaTransistor.cpp b/chamsin/src/analogic/MetaTransistor.cpp new file mode 100644 index 00000000..ee764e40 --- /dev/null +++ b/chamsin/src/analogic/MetaTransistor.cpp @@ -0,0 +1,184 @@ +// **************************************************************************************************** +// File: MetaTransistor.cpp +// Authors: Wu YiFei +// Date : 21/12/2006 +// **************************************************************************************************** + + +#include "MetaTransistor.h" +#include "Transistor.h" +#include "Instances.h" +#include "UpdateSession.h" +#include "Vertical.h" + + +BEGIN_NAMESPACE_HURRICANE + +// **************************************************************************************************** +// MetaTransistor implementation +// **************************************************************************************************** + +MetaTransistor::MetaTransistor(Library* library, const Name& name, char type) +// ************************************************************************** +: Inherit(library, name), + _type(type), + _m(1), + _le(0.0), + _we(0.0) +{ +} + + +MetaTransistor* MetaTransistor::Create(Library* library, const Name& name, char type) +// ********************************************************************************** +{ + MetaTransistor* metatransistor = new MetaTransistor(library, name, type); + + metatransistor->_PostCreate(); + + return metatransistor; +} + + +void MetaTransistor::_PreDelete() +// ****************************** +{ + // do something + // ************ + + Inherit::_PreDelete(); +} + + +void MetaTransistor::_PostCreate() +// ******************************* +{ + Inherit::_PostCreate(); + + (Net::Create(this, Name("DRAIN")))->SetExternal(true); + (Net::Create(this, Name("SOURCE")))->SetExternal(true); + (Net::Create(this, Name("GRID")))->SetExternal(true); + (Net::Create(this, Name("BULK")))->SetExternal(true); +} + + +void MetaTransistor::CreateConnection() +// *********************************** +{ + for_each_instance(instance, this->GetInstances()) + Cell * mastercell = instance->GetMasterCell(); + + // Assurance of unique instanciation + // ********************************* + if(mastercell->_GetSlaveInstanceSet()._GetSize()!=1) { + string err_msg = "Can't create connection : " + GetString(mastercell) + " hasn't only one slave instance"; + assert(err_msg.c_str()); + } + + instance->GetPlug(mastercell->GetNet(Name("DRAIN")))->SetNet(GetNet(Name("DRAIN"))); + instance->GetPlug(mastercell->GetNet(Name("SOURCE")))->SetNet(GetNet(Name("SOURCE"))); + instance->GetPlug(mastercell->GetNet(Name("GRID")))->SetNet(GetNet(Name("GRID"))); + instance->GetPlug(mastercell->GetNet(Name("BULK")))->SetNet(GetNet(Name("BULK"))); + end_for +} + + +void MetaTransistor::CreateLayout() +// ******************************** +{ +// OpenUpdateSession(); + + if((_le == 0.0) || (_we == 0.0)) { + throw Error("Can't generate layout : " + GetString(this) + " hasn't been dimensionned"); + } + + SetTerminal(false); + + Transistor * internal_ref = NULL; + Transistor * left_ref = NULL; + Transistor * right_ref = NULL; + + for_each_instance(instance, this->GetInstances()) + Cell * mastercell = instance->GetMasterCell(); + + // Assurance of unique instanciation + // ********************************* + if(mastercell->_GetSlaveInstanceSet()._GetSize()!=1) { + string err_msg = "Can't generate layout : " + GetString(mastercell) + " hasn't only one slave instance"; + assert(err_msg.c_str()); + } + + Transistor * trans = dynamic_cast(mastercell); + if(!trans){ + string err_msg = "Can't genrate layout : " + GetString(mastercell) + " isn't a Transistor"; + } + + if(trans->IsInternal()) { + if(!internal_ref) { + trans->CreateLayout(); + internal_ref = trans; + } + else { + trans->DuplicateLayout(internal_ref); + } + } + else if(trans->IsLeft()) { + if(!left_ref) { + trans->CreateLayout(); + left_ref=trans; + } + else + trans->DuplicateLayout(left_ref); + } + else if(trans->IsRight()) { + if(!right_ref) { + trans->CreateLayout(); + right_ref=trans; + } + else + trans->DuplicateLayout(right_ref); + } + else + trans->CreateLayout(); + end_for + + + Materialize(); + // CloseUpdateSession(); + +} + + +void MetaTransistor::Flush() +// ************************* +{ + OpenUpdateSession(); + for_each_instance(instance, this->GetInstances()) + Cell * mastercell = instance->GetMasterCell(); + instance->Delete(); + mastercell->Delete(); + end_for + CloseUpdateSession(); +} + + + +string MetaTransistor::_GetString() const +// *************************************** +{ + string s= Inherit::_GetString(); + s.insert(s.length()-1, " " + GetString(GetType()) ); + s.insert(s.length()-1, " " + GetString(GetM()) ); + return s; +} + +Record* MetaTransistor::_GetRecord() const +// *************************************** +{ + Record* record = Inherit::_GetRecord(); + return record; +} + +END_NAMESPACE_HURRICANE + + diff --git a/chamsin/src/analogic/MetaTransistor.h b/chamsin/src/analogic/MetaTransistor.h new file mode 100644 index 00000000..1e617b6f --- /dev/null +++ b/chamsin/src/analogic/MetaTransistor.h @@ -0,0 +1,133 @@ +// **************************************************************************************************** +// File: MetaTransistor.h +// Authors: Wu YiFei +// Date : 21/12/2006 +// **************************************************************************************************** + +#ifndef HURRICANE_METATRANSISTOR +#define HURRICANE_METATRANSISTOR + +#include "Cell.h" +#include "AnalogicalCommons.h" + + +//BEGIN_NAMESPACE_HURRICANE + +namespace Hurricane { + +class Library; +class Name; +class Symbol; +class Record; + +class MetaTransistor: public Cell { +// ******************************** + + +// Types +// ***** + public : typedef Cell Inherit; + +# if !defined(__DOXYGEN_PROCESSOR__) + +// Logicals Attributes +// ******************* + private : char _type; + private : unsigned _m; + private : Micro _le, _we; // length and width expected + private : Micro _lr, _wr; // real length and real width + private : unsigned _nSex, _nDex, nSin, _nDin, _nSsh, _nDsh; + private : Micro _dgg, _de; + private : MicroPower2 _as, _ad; + private : Micro _ps, _pd; + private : double _capaDrain, _capaGate, _capaSource; + private : double _cgb, _cgs, _cdb, _cds, _csb, _cgd; + + +// Behaviorals attributes +// ********************** + private : double _temp, _vds, _vgs; // DC + private : double _vg, _vd, _vs, _vb; + private : char _region; + private : double _ids; + private : double _vth, _vdsat; // AC + +# endif + +// Constructors +// ************ +# if !defined(__DOXYGEN_PROCESSOR__) + protected : MetaTransistor(Library* library, const Name& name, char type); +# endif + + public : static MetaTransistor* Create(Library* library, const Name& name, char type); + +# if !defined(__DOXYGEN_PROCESSOR__) + protected : virtual void _PostCreate(); + + +// Destructors +// *********** + protected : ~MetaTransistor() {}; + protected : virtual void _PreDelete(); +# endif + +// Operations +// ********** + + // Create the connection between all instances. + // ******************************************** + public : void CreateConnection(); + + // Create the layout of all motifs in this metatransistor. + // ******************************************************* + public : void CreateLayout(); + + +# if !defined(__DOXYGEN_PROCESSOR__) + // Get all paramters after generation of Layout (capa..). + // ***************************************************** + public : void GetParameterOfGeneration() { /* to do */}; + + // Delete all instances and all motifs in this metatransistor. + // *********************************************************** + public : void Flush(); +# endif + + +// Accessors +// ********* + public : const Micro& GetLe() const { return _le; }; + public : const Micro& GetWe() const { return _we; }; + public : const char GetType() const { return _type; }; + public : const unsigned GetM() const { return _m; }; + + +// Updators +// ******** + public : void SetLe (const Micro le) { _le=le; }; + public : void SetWe (const Micro we) { _we=we; }; + public : void SetType(const char type) { _type=type; }; + public : void SetM (const unsigned m) { _m=m; }; + + +//#endif + +# if !defined(__DOXYGEN_PROCESSOR__) +// Others +// ****** + public: virtual string _GetTypeName() const {return _TName("MetaTransistor");}; + public: virtual string _GetString() const; + public: virtual Record* _GetRecord() const; +# endif + +}; + + +} + +//END_NAMESPACE_HURRICANE + +#endif // HURRICANE_METATRANSISTOR + + diff --git a/chamsin/src/analogic/MetaTransistors.h b/chamsin/src/analogic/MetaTransistors.h new file mode 100644 index 00000000..786abf96 --- /dev/null +++ b/chamsin/src/analogic/MetaTransistors.h @@ -0,0 +1,59 @@ + +// **************************************************************************************************** +// File: MetaTransistors.h +// Authors: YIFEI WU +// Date : 21/12/2006 +// **************************************************************************************************** + +#ifndef HURRICANE_METATRANSISTORS +#define HURRICANE_METATRANSISTORS + +#include "Collection.h" + +BEGIN_NAMESPACE_HURRICANE + +class MetaTransistor; + + +// **************************************************************************************************** +// MetaTransistors declaration +// **************************************************************************************************** + +typedef GenericCollection MetaTransistors; + + + +// **************************************************************************************************** +// MetaTransistorLocator declaration +// **************************************************************************************************** + +typedef GenericLocator MetaTransistorLocator; + + + +// **************************************************************************************************** +// MetaTransistorFilter declaration +// **************************************************************************************************** + +typedef GenericFilter MetaTransistorFilter; + + + +// **************************************************************************************************** +// for_each_metatransistor declaration +// **************************************************************************************************** + +#define for_each_metatransistor(metatransistor, metatransistors)\ +/******************************/\ +{\ + MetaTransistorLocator _locator = metatransistors.GetLocator();\ + while (_locator.IsValid()) {\ + MetaTransistor* metatransistor = _locator.GetElement();\ + _locator.Progress(); + + + +END_NAMESPACE_HURRICANE + +#endif // HURRICANE_METATRANSISTORS + diff --git a/chamsin/src/analogic/RdsUnit.cpp b/chamsin/src/analogic/RdsUnit.cpp new file mode 100644 index 00000000..c2098d06 --- /dev/null +++ b/chamsin/src/analogic/RdsUnit.cpp @@ -0,0 +1,260 @@ +// **************************************************************************************************** +// File: RdsUnit.cpp +// Authors: Wu YiFei +// Date : 21/12/2006 +// **************************************************************************************************** + + +#include "Error.h" +#include "stdio.h" +#include "regex.h" +#include "math.h" +#include "Commons.h" +#include "RdsUnit.h" + + + + +// **************************************************************************************************** +// Static data&function +// **************************************************************************************************** + +static long RDS_UNIT = -1; + +static long RDS_PHYSICAL_GRID = 2; + +static long RDS_LAMBDA = -1; + + + +// ----------------------------------------------------------------------- +// Function : "GetPattern()". + + /* \static char * GetPattern (const string& str, const char* pattern) + * \param str the string to check for regex. + * \param pattern the pattern to find. + * + * Get and return the march substring from str according to the pattern. + * + * \return NULL if Failure. + * \return the according substring if Success. + */ + +static char* GetPattern(const string& str, const char* pattern) +// ************************************************************ +{ + int err; + regex_t preg; + const char *str_request = str.c_str(); + const char *str_regex = pattern; + +/* (1) */ + err = regcomp (&preg, str_regex, REG_EXTENDED); + + if (err == 0) + { + int match; + size_t nmatch = 0; + regmatch_t *pmatch = NULL; + + nmatch= 1; + pmatch = (regmatch_t*)malloc (sizeof (*pmatch) * nmatch); + + if (pmatch) + { +/* (2) */ + match = regexec (&preg, str_request, nmatch, pmatch, 0); + +/* (3) */ + regfree (&preg); + +/* (4) */ + if (match == 0) + { + char *site = NULL; + int start = pmatch[0].rm_so; + int end = pmatch[0].rm_eo; + size_t size = end - start; + + site = (char*)malloc (sizeof (*site) * (size + 1)); + if (site) + { + strncpy (site, &str_request[start], size); + site[size] = '\0'; + + return site; + } + else { + fprintf (stderr, "Memoire insuffisante\n"); + exit (EXIT_FAILURE); + } + } + /* (5) */ + else if (match == REG_NOMATCH) + { + printf ("%s doesn't accord to %s\n", str_request, str_regex); + return NULL; + } + /* (6) */ + else + { + char *text; + size_t size; + + /* (7) */ + size = regerror (err, &preg, NULL, 0); + text = (char*)malloc (sizeof (*text) * size); + if (text) + { + /* (8) */ + regerror (err, &preg, text, size); + fprintf (stderr, "%s\n", text); + free (text); + } + else + { + fprintf (stderr, "Memoire insuffisante\n"); + } + exit (EXIT_FAILURE); + } + } + else + { + fprintf (stderr, "Memoire insuffisante\n"); + exit (EXIT_FAILURE); + } + } + else { + fprintf (stderr, "Regcomp fail\n"); + exit (EXIT_FAILURE); + } + +} + + + +// ------------------------------------------------------------------- +// Function : "CalculateRdsUnit()". + + /* static void CalculateRdsUnit() + * + * Open rds techno file who's name is MACRO RDS_TECHNO_FILE, + * and get values technology : rds_physical_grid, rds_lambda. + * Calculate the RDS_UNIT according to these values. + * + * If RDS_TECHNO_FILE is invalid or operaton of reading values technologys + * fail, a Hurricane Error will be throwed to explain the reason of failure. + */ + + +static void CalculateRdsUnit() +// *************************** +{ + using Hurricane::Error; + + const char * rdsfilename = getenv("RDS_TECHNO_NAME"); + FILE * rdstechnofile; + + if(!rdsfilename) { + throw Error("Can't not find macro RDS_TECHNO_FILE"); + } + + if( !(rdstechnofile = fopen(rdsfilename, "r")) ) { + throw Error("Can't not open rds techno file : " + GetString(rdsfilename)); + } + + char buffer[80]; // For stock a line of the rds techno file + double rds_physical_grid = -0.1; // For stock value of physical_grid + double rds_lambda = -0.1; // For stock value of lamba + + while(fgets(buffer, 80, rdstechnofile )!=NULL){ + string tmp = buffer; + + if( tmp.find("define physical_grid")!=string::npos) { // Find the ligne begin with "define physical_grid" + + string pattern; + + if( (pattern = GetPattern(tmp, "[[:digit:]\\.]+")).size()==0 ) { // Get the value behind + throw Error("Can't get rds_physical_grid : GetPattern(string&, char*) return NULL"); + } + + if(!Scan(pattern, rds_physical_grid)){ // Convert from string to double + throw Error("Can't get rds_physical_grid " + pattern + " : Hurricane::Scan(string&, double&) return false"); + } + + } + + if( tmp.find("define lambda")!=string::npos ) { + + string pattern; + + if( (pattern = GetPattern(tmp, "[[:digit:]\\.]+")).size()==0 ) { + throw Error("Can't get rds_lambda : GetPattern(string&, char*) return NULL"); + } + + if(!Scan(pattern, rds_lambda)){ + throw Error("Can't get rds_lambda " + pattern + " : Hurricane::Scan(string&, double&) return false"); + } + + } + + // if rds_physical_grid and rds_lambda are finded, break the loop + // ************************************************************** + if( (rds_physical_grid!=-0.1) && (rds_lambda!=-0.1) ) + break; + + } // end of while + + if( (rds_physical_grid==-0.1) && (rds_lambda==-0.1) ) { + throw Error("Can't get rds_physical_grid and rds_lambda from rds techno file : \n" + string(rdsfilename)); + } + + long rds_physical_grid_nano = (long)rint(rds_physical_grid*(double)1000); + + rds_physical_grid_nano = (long)rint( (double)1000/(double)rds_physical_grid_nano ); + + RDS_UNIT = rds_physical_grid_nano << 1; + + long rds_lambda_nano = (long)rint( rds_lambda*(double)1000 ); + + RDS_LAMBDA = rds_lambda_nano * RDS_UNIT / 1000 ; + + fclose(rdstechnofile); + +} + +BEGIN_NAMESPACE_HURRICANE + + + + +// **************************************************************************************************** +// Utilitarians +// **************************************************************************************************** + +const long& GetRdsUnit() +// ********************* +{ + if ( RDS_UNIT == -1) + CalculateRdsUnit(); + + return RDS_UNIT; +} + +const long& GetRdsPhysicalGrid() +// ***************************** +{ + return RDS_PHYSICAL_GRID; +} + +const long& GetRdsLambda() +// *********************** +{ + if ( RDS_LAMBDA == -1) + CalculateRdsUnit(); + + return RDS_LAMBDA; +} + + +END_NAMESPACE_HURRICANE diff --git a/chamsin/src/analogic/RdsUnit.h b/chamsin/src/analogic/RdsUnit.h new file mode 100644 index 00000000..b1186110 --- /dev/null +++ b/chamsin/src/analogic/RdsUnit.h @@ -0,0 +1,54 @@ +// **************************************************************************************************** +// File: RdsUnit.h +// Authors: Wu YiFei +// Date : 21/12/2006 +// **************************************************************************************************** + +#ifndef HURRICANE_RDSUNIT +#define HURRICANE_RDSUNIT + +#include + +//BEGIN_NAMESPACE_HURRICANE + + +namespace Hurricane { + + + +// **************************************************************************************************** +// Utilitarians +// **************************************************************************************************** + +extern const long& GetRdsUnit(); + +extern const long& GetRdsPhysicalGrid(); + +extern const long& GetRdsLambda(); + +// ------------------------------------------------------------------------ +// Function : "ConvertRealToRdsUnit(const double&)". +// + + /* \inline long ConvertRealToRdsUnit(const double& value) + * \param value the value en Micro to convert to RdsUnit. + * + * Get and return the value en RdsUnit. + * + */ + +inline long ConvertRealToRdsUnit(const double& value) +// ******************************************************* +{ + long tmp_value = (long)rint(value*GetRdsUnit()); + return (tmp_value%2)==0?tmp_value:(tmp_value+1); +} + + +//END_NAMESPACE_HURRICANE + +} + +#endif // HURRICANE_RDSUNIT + + diff --git a/chamsin/src/analogic/Transistor.cpp b/chamsin/src/analogic/Transistor.cpp new file mode 100644 index 00000000..b0cd0743 --- /dev/null +++ b/chamsin/src/analogic/Transistor.cpp @@ -0,0 +1,505 @@ +// **************************************************************************************************** +// File: Transistor.h +// Authors: Wu YiFei +// Date : 21/12/2006 +// **************************************************************************************************** + +#include "AnalogicalCommons.h" +#include "Transistor.h" +#include "GenTrans.h" + +#include "Vertical.h" +#include "Horizontal.h" + +#include "UpdateSession.h" + +BEGIN_NAMESPACE_HURRICANE + + +// **************************************************************************************************** +// Transistor::MaskVersion implementation +// **************************************************************************************************** +Transistor::MaskVersion::MaskVersion(const Code& code) +// ******************************************************* +:_code(code) +{ +} + +Transistor::MaskVersion::MaskVersion(const MaskVersion& version) +// ******************************************************************* +:_code(version._code) +{ +} + + +Transistor::MaskVersion& Transistor::MaskVersion::operator=(const MaskVersion& version) +// ****************************************************************************************** +{ + _code = version._code; + return *this; +} + + +bool Transistor::MaskVersion::operator==(const MaskVersion& version) const +// *************************************************************************** +{ + return _code==version._code; +} + + +string Transistor::MaskVersion::_GetString() const +// ************************************************* +{ + switch(_code) { + case VERSION1 : return "VERSION1"; + } + return "ABNORMAL"; +} + + +Record* Transistor::MaskVersion::_GetRecord() const +// ************************************************** +{ + Record* record = new Record(GetString(this)); + record->Add(GetSlot("Code", _code)); + return record; +} + + +// **************************************************************************************************** +// Transistor::Type implementation +// **************************************************************************************************** +Transistor::Type::Type(const Code& code) +// ************************************* +:_code(code) +{ +} + + +Transistor::Type::Type(const Type& type) +// ************************************* +:_code(type._code) +{ +} + + +Transistor::Type& Transistor::Type::operator=(const Type& type) +// ************************************************************ +{ + _code = type._code; + return *this; +} + + +string Transistor::Type::_GetString() const +// ***************************************** +{ + switch(_code) { + case INTERNAL : return "INTERNAL"; + case LEFT : return "LEFT"; + case RIGHT : return "RIGHT"; + case SINGLE : return "SINGLE"; + } + + return "ABNORMAL"; +} + + +Record* Transistor::Type::_GetRecord() const +// ***************************************** +{ + Record* record = new Record(GetString(this)); + record->Add(GetSlot("Code", _code)); + return record; +} + + +// **************************************************************************************************** +// Transistor::MaskInfo implementation +// **************************************************************************************************** +Transistor::MaskInfo::MaskInfo(const double& l, const double& w, const Type::Code& type + , const unsigned& nbDrainColumn + , const unsigned& nbSourceColumn) +// **************************************************************************************************** +: _l(l) + , _w(w) + , _type(type) + , _nbDrainColumn(nbDrainColumn) + , _nbSourceColumn(nbSourceColumn) +{}; + + +Transistor::MaskInfo& Transistor::MaskInfo::operator=(const MaskInfo& masqueinfo) +// ************************************************************************************ +{ + _l = masqueinfo.GetL(); + _w = masqueinfo.GetW(); + _type= masqueinfo.GetType(); + _nbDrainColumn = masqueinfo.GetNbDrainColumn(); + _nbSourceColumn = masqueinfo.GetNbSourceColumn(); + + return *this; +} + + +void Transistor::MaskInfo::_PostCreate() +// *************************************** +{ +} + + +void Transistor::MaskInfo::_PreDelete() +// ************************************** +{ +} + + +void Transistor::MaskInfo::Delete() +// ********************************** +{ + _PreDelete(); + delete this; +} + + +bool Transistor::MaskInfo::operator==(const MaskInfo& masqueinfo) +// ****************************************************************** +{ + if(_l == masqueinfo.GetL() && + _w == masqueinfo.GetW() && + _type== masqueinfo.GetType() && + _nbDrainColumn == masqueinfo.GetNbDrainColumn() && + _nbSourceColumn == masqueinfo.GetNbSourceColumn() + ) + return true; + + return false; +} + + +string Transistor::MaskInfo::_GetString() const +// ********************************************** +{ + string s = "<" + _GetTypeName() + " " + + GetString(_l) + " " + + GetString(_w) + " " + + _type._GetString() + " " + + GetString(_nbSourceColumn) + " " + + GetString(_nbDrainColumn) + + ">"; + return s; +} + + +Record* Transistor::MaskInfo::_GetRecord() const +// *********************************************** +{ + Record * record = new Record(_GetString()); + return record; +} + + +// **************************************************************************************************** +// Transistor::MaskV1Info implementation +// **************************************************************************************************** +Transistor::MaskV1Info::MaskV1Info(const double& l, const double& w, const Type::Code& type + , const unsigned& nbDrainColumn + , const unsigned& nbSourceColumn) +// **************************************************************************************************** +: Inherit(l + , w + , type + , nbDrainColumn + , nbSourceColumn + ) +{} + + +Transistor::MaskV1Info* Transistor::MaskV1Info::Create(const double& l, const double& w + , const Type::Code& type + , const unsigned& nbDrainColumn + , const unsigned& nbSourceColumn) +// ********************************************************************************************** +{ + MaskV1Info* masquev1info = new MaskV1Info(l, w, type, nbDrainColumn, nbSourceColumn); + + masquev1info->_PostCreate(); + + return masquev1info; +} + + +Transistor::MaskInfo& Transistor::MaskV1Info::operator=(const MaskInfo& masqueinfo) +// ************************************************************************************** +{ +// (*(static_cast(this)))=masqueinfo; + Inherit::operator=(masqueinfo); + + return *this; +} + + +void Transistor::MaskV1Info::_PostCreate() +// ***************************************** +{ + Inherit::_PostCreate(); +} + + +void Transistor::MaskV1Info::_PreDelete() +// **************************************** +{ + Inherit::_PreDelete(); +} + + +bool Transistor::MaskV1Info::operator == (const MaskInfo& masqueinfo) +// ********************************************************************** +{ + //return (*(static_cast(this)))==masqueinfo; + return Inherit::operator==(masqueinfo); +} + + +string Transistor::MaskV1Info::_GetString() const +// ************************************************ +{ + string s = Inherit::_GetString(); + return s; +} + +Record* Transistor::MaskV1Info::_GetRecord() const +// ************************************************* +{ + Record* record = Inherit::_GetRecord(); + return record; +} + +// **************************************************************************************************** +// Transistor implementation +// **************************************************************************************************** + +Transistor::Transistor(Library* library, const Name& name, char type) +// ******************************************************************* +: Inherit(library, name), + _type(type), + _masqueInfo(NULL), + _genTrans(NULL) +{ +} + + +Transistor* Transistor::Create(Library* library, const Name& name, char type) +// ************************************************************************** +{ + Transistor* transistor = new Transistor(library, name, type); + + transistor->_PostCreate(); + + return transistor; +} + + + +void Transistor::_PreDelete() +// ****************************** +{ + // Delete aggregated objets. + // ************************* + if(_masqueInfo) + _masqueInfo->Delete(); + + if(_genTrans) + delete _genTrans; + + Inherit::_PreDelete(); +} + + +void Transistor::_PostCreate() +// ******************************* +{ + Inherit::_PostCreate(); + + (Net::Create(this, Name("DRAIN")))->SetExternal(true); + (Net::Create(this, Name("SOURCE")))->SetExternal(true); + (Net::Create(this, Name("GRID")))->SetExternal(true); + (Net::Create(this, Name("BULK")))->SetExternal(true); + + // By default, transistor's length and heigth is NULL, and is internal. + // ******************************************************************** + _masqueInfo = new MaskV1Info(0.0, 0.0); +} + + +string Transistor::_GetString() const +// *********************************** +{ + string s = Inherit::_GetString(); + s.insert(s.length()-1, " " + GetString(_type)); + s.insert(s.length()-1, " " + GetAbutmentType()._GetString()); + return s; +} + + +Record* Transistor::_GetRecord() const +// ************************************ +{ + Record* record = Inherit::_GetRecord(); + return record; +} + + +Transistor::MaskVersion Transistor::_GetMaskInfoVersion(MaskInfo* masqueinfo) +// *************************************************************************************** +{ + if(!masqueinfo) + throw Error("Error : In Transistor::_GetMaskInfoVersion, param masqueinfo is NULL"); + + if(dynamic_cast(masqueinfo)) + return MaskVersion(MaskVersion::VERSION1); + + throw Error("Error : In Transistor::_GetMaskInfoVersion, can't dynamic cast param masqueinfo"); + return MaskVersion(MaskVersion::VERSION1); +} + + +Transistor::MaskInfo* Transistor::_CreateMaskInfo(const MaskVersion& version) +// ******************************************************************************* +{ + switch((const MaskVersion::Code&)version) { + case MaskVersion::VERSION1 : + return MaskV1Info::Create(0.0, 0.0); + + default : + throw Error ("Error : In Transistor::_CreateMaskInfoBy, unknown param version"); + return NULL; + } +} + + +void Transistor::SetMaskInfo(MaskInfo* masqueinfo) +// *************************************************** +{ + if(!masqueinfo) + throw Error("Error : In Transistor::CreateLayout : masqueinfo is NULL"); + + // Set new Param. + // *************** + MaskVersion newversion = _GetMaskInfoVersion(masqueinfo); + MaskVersion oldversion = _GetMaskInfoVersion(_masqueInfo); + + if(newversion == oldversion) { // If they are the same version. + if((*_masqueInfo)==(*masqueinfo)) // If they are identical. + return; + else + (*_masqueInfo)=(*masqueinfo); + } + else { // If change the version. + _masqueInfo->Delete(); + _masqueInfo = _CreateMaskInfo(newversion); + (*_masqueInfo) == (*masqueinfo); + } +} + + +void Transistor::CreateLayout() +// **************************** +{ + MaskVersion version = _GetMaskInfoVersion(_masqueInfo); + MaskV1Info* masquev1info = NULL; + + // Select algorithme with technology and masque version. + // ***************************************************** + switch((const MaskVersion::Code&)version) { + + case MaskVersion::VERSION1 : + masquev1info = dynamic_cast(_masqueInfo); + _genTrans = new GenV1Trans(masquev1info); + break; + + default : + break; + } + + SetTerminal(false); + + // Launch the selected algorithme. + // ****************************** + _genTrans->Calculate(this); + _genTrans->Generate(this); + + Materialize(); + + delete _genTrans; + _genTrans = NULL; + +} + + +void Transistor::DuplicateLayout(Transistor* transistor) +// ***************************************************** +{ + OpenUpdateSession(); + + SetTerminal(false); + + Net * tmp = NULL; + Contact * con = NULL; + Segment * seg = NULL; + + for_each_net(net, transistor->GetNets()) + if( !( tmp=GetNet(net->GetName()) ) ) { // + tmp = Net::Create(this, net->GetName()); + tmp->SetExternal(net->IsExternal()); + } + + for_each_component(component, net->GetComponents()) + if( (con=dynamic_cast(component)) ){ + Contact::Create(tmp, component->GetLayer(), con->GetX(), con->GetY(), con->GetWidth(), con->GetHeight()); + } + else if( (seg=dynamic_cast(component)) ) { + Vertical::Create(tmp, component->GetLayer(), seg->GetSourceX(), seg->GetWidth(), seg->GetSourceY(), + seg->GetTargetY()); + } + else if( (seg=dynamic_cast(component)) ){ + Horizontal::Create(tmp, component->GetLayer(), seg->GetSourceY(), seg->GetWidth(), seg->GetSourceX(), + seg->GetTargetX()); + } + else + throw Error ("Error : In Transistor::DuplicateLayout, find illegal elem : " + GetString(component) + + "In Transistor, all component must be contact or segment" ) ; + end_for + end_for + + SetAbutmentBox(transistor->GetAbutmentBox()); + + _mapNet2Box.clear(); + + map::iterator i = transistor->_GetMapNet2Box()->begin(), + j = transistor->_GetMapNet2Box()->end(); + + while(i!=j) { + _mapNet2Box[GetNet((*i).first->GetName())]=(*i).second; + i++; + } + + Materialize(); + + CloseUpdateSession(); + +} + +END_NAMESPACE_HURRICANE + + +// **************************************************************************************************** +// Generic functions +// **************************************************************************************************** + +string GetString(const H::Transistor::MaskInfo& masqueinfo) +// ********************************************************** +{ + return masqueinfo._GetString(); +} + diff --git a/chamsin/src/analogic/Transistor.h b/chamsin/src/analogic/Transistor.h new file mode 100644 index 00000000..9d9a5da1 --- /dev/null +++ b/chamsin/src/analogic/Transistor.h @@ -0,0 +1,344 @@ +// **************************************************************************************************** +// File: Transistor.h +// Authors: Wu YiFei +// Date : 21/12/2006 +// **************************************************************************************************** + +#ifndef HURRICANE_TRANSISTOR +#define HURRICANE_TRANSISTOR + +#include "Cell.h" +#include "AnalogicalCommons.h" + + +//BEGIN_NAMESPACE_HURRICANE + +namespace Hurricane { + +class Library; +class Name; +class Symbol; +class Record; +class GenTrans; + +class Transistor : public Cell { +// ******************************** + +//# if !defined(__DOXYGEN_PROCESSOR__) + +// Types +// ***** + + public : typedef Cell Inherit; + + + public : class MaskVersion { + // ****************** + public : enum Code { VERSION1=0 }; + + private: Code _code; + + public : explicit MaskVersion(const Code& code=VERSION1); + public : MaskVersion(const MaskVersion&); + public : MaskVersion& operator=(const MaskVersion&); + + public : bool operator==(const MaskVersion&) const; + + public : operator const Code& () const { return _code; }; + public : const Code& GetCode() const { return _code; }; + + public : string _GetTypeName() const { return _TName("Transistor::MaskVersion"); }; + public : string _GetString() const; + public : Record* _GetRecord() const; + + }; + + + public : class Type { + // ********* + + public : enum Code { INTERNAL=0, LEFT=1, RIGHT=2, SINGLE=3}; + + private: Code _code; + + public : explicit Type(const Code& code=INTERNAL); + public : Type(const Type& type); + public : Type& operator=(const Type& type); + public : operator const Code&() const { return _code; }; + + public : void SetCode(const Code& code) { _code = code; }; + + public : const Code& GetCode() const { return _code; }; + + public : string _GetTypeName() const { return _TName("Transistor::Type"); }; + public : string _GetString() const; + public : Record* _GetRecord() const; + + }; + + + public : class MaskInfo { + // *************** + + // Attributs + // ********* + private : double _l; + private : double _w ; + private : Type _type; + private : unsigned _nbDrainColumn; + private : unsigned _nbSourceColumn; + + // Constructors + // ************ + public : MaskInfo(const double& l, const double& w, const Type::Code& type=Type::INTERNAL + , const unsigned& nbDrainColumn=1 + , const unsigned& nbSourceColumn=1); + + public : virtual MaskInfo& operator=(const MaskInfo&); + + private : MaskInfo(const MaskInfo& ); + + protected : virtual void _PostCreate(); + + // Destructors + // *********** + protected: virtual ~MaskInfo() {}; + protected: virtual void _PreDelete(); + public : virtual void Delete(); + + // Accessors + // ********* + public : const double& GetL() const { return _l; }; + public : const double& GetW() const { return _w; }; + public : const unsigned & GetNbDrainColumn() const { return _nbDrainColumn; }; + public : const unsigned & GetNbSourceColumn() const { return _nbSourceColumn; }; + public : const Type& GetType() const { return _type; }; + + // Update + // ****** + public : void SetL(const double& l) { _l=l;}; + public : void SetW(const double& w) { _w=w;}; + public : void SetNbDrainColumn(const unsigned& column) { _nbDrainColumn=column; }; + public : void SetNbSourceColumn(const unsigned& column) { _nbSourceColumn=column; }; + public : void SetType(const Type::Code& code) { _type.SetCode(code); }; + public : void SetType(const Type& type) { _type = type; }; + + // Predicats + // ********* + + // Operators + // ********* + public : virtual bool operator==(const MaskInfo&); + + // Others + // ****** + public : virtual string _GetTypeName() const =0; + public : virtual string _GetString() const; + public : virtual Record* _GetRecord() const; + + }; + + + public : class MaskV1Info : public MaskInfo { + // ************************************* + + // type + // ***** + public : typedef MaskInfo Inherit ; + + // Attributs + // ********* + + // Constructors + // ************ + public: MaskV1Info(const double& l, const double& w, const Type::Code& type=Type::INTERNAL + , const unsigned& nbDrainColumn = 1 + , const unsigned& nbSourceColumn = 1); + + public: static MaskV1Info* Create(const double& l, const double& w, const Type::Code& type=Type::INTERNAL + , const unsigned& nbDrainColumn = 1 + , const unsigned& nbSourceColumn = 1); + + public : MaskInfo& operator=(const MaskInfo&); + + protected : void _PostCreate(); + + // Destructor + // *********** + public : virtual ~MaskV1Info() {}; + protected: void _PreDelete(); + + // Operators + // ********* + public : bool operator==(const MaskInfo&); + + // Others + // ********* + public : virtual string _GetTypeName() const { return _TName("Transistor::MaskV1Info"); }; + public : virtual string _GetString() const; + public : virtual Record* _GetRecord() const; + }; + + +# if !defined(__DOXYGEN_PROCESSOR__) + +// Attributes +// ******************* + private : char _type; + private : MaskInfo* _masqueInfo; + private : GenTrans * _genTrans; + //public : RealInfo * _realInfo; + + private : map _mapNet2Box; // This Map Is For localize The Position Of Routing. + +# endif + +// Constructors +// ************ +# if !defined(__DOXYGEN_PROCESSOR__) + protected : Transistor(Library* library, const Name& name, char type); +# endif + + public : static Transistor* Create(Library* library, const Name& name, char type); + +# if !defined(__DOXYGEN_PROCESSOR__) + protected : virtual void _PostCreate(); + + +// Destructors +// *********** + protected : ~Transistor() {}; + protected : virtual void _PreDelete(); +# endif + +// Accessors +// ********* + public : char GetType() const { return _type; }; + public : MaskVersion GetMaskVersion() const { return _GetMaskInfoVersion(_masqueInfo); }; + public : const MaskInfo* GetMaskInfo() const { return _masqueInfo; }; + public : const double& GetL() const { return _masqueInfo->GetL(); }; + public : const double& GetW() const { return _masqueInfo->GetW(); }; + public : const unsigned& GetNbDrainColumn() const { return _masqueInfo->GetNbDrainColumn(); }; + public : const unsigned& GetNbSourceColumn() const { return _masqueInfo->GetNbSourceColumn(); }; + public : const char* GetDrainName() const { return "DRAIN"; }; + public : const char* GetSourceName() const { return "SOURCE"; }; + public : const char* GetGridName() const { return "GRID"; }; + public : Net* GetDrain() const { return GetNet(GetDrainName()); }; + public : Net* GetSource() const { return GetNet(GetSourceName()); }; + public : Net* GetGrid() const { return GetNet(GetGridName()); }; + public : const Type& GetAbutmentType() const { return _masqueInfo->GetType(); }; + +// Predicats +// ********* + public : bool IsNmos() const { return _type==TRANSN; }; + public : bool IsPmos() const { return _type==TRANSP; }; + public : bool IsInternal() const { return GetAbutmentType().GetCode()==Type::INTERNAL; }; + public : bool IsLeft() const { return GetAbutmentType().GetCode()==Type::LEFT; }; + public : bool IsRight() const { return GetAbutmentType().GetCode()==Type::RIGHT; }; + public : bool IsSingle() const { return GetAbutmentType().GetCode()==Type::SINGLE; }; + +// Updators +// ******** + public : void SetL(const double& l) { _masqueInfo->SetL(l); }; + public : void SetW(const double& w) { _masqueInfo->SetW(w); }; + +//# endif + +# if !defined(__DOXYGEN_PROCESSOR__) +// Others +// ****** + public : virtual string _GetTypeName() const {return _TName("Transistor");}; + public : virtual string _GetString() const; + public : virtual Record* _GetRecord() const; + public : const GenTrans* _GetGenTrans() const {return _genTrans; }; + public : static MaskVersion _GetMaskInfoVersion(MaskInfo*) ; + public : static MaskInfo* _CreateMaskInfo(const MaskVersion&) ; + public : map* _GetMapNet2Box() { return &_mapNet2Box; }; + +# endif + +// Operators +// ********* + public : void SetMaskInfo(MaskInfo*); + public : void CreateLayout(); + public : void DuplicateLayout(Transistor* transistor) ; + + +}; + + +# if !defined(__DOXYGEN_PROCESSOR__) +// ------------------------------------------------------------------- +// Class : "Proxy...". + +template<> + inline string ProxyTypeName + ( const Transistor::MaskVersion::Code* object ) + { return ">"; } + +template<> + inline string ProxyString + ( const Transistor::MaskVersion::Code* object ) + { + switch ( *object ) { + case Transistor::MaskVersion::VERSION1: return "VERSION1"; + } + return "ABNORMAL"; + } + +template<> + inline Record* ProxyRecord + ( const Transistor::MaskVersion::Code* object ) + { + Record* record = new Record(GetString(object)); + record->Add(GetSlot("Code", (unsigned int*)object)); + return record; + } + + +// ------------------------------------------------------------------- +// Class : "Proxy...". + +template<> + inline string ProxyTypeName + ( const Transistor::Type::Code* object ) + { return ">"; } + +template<> + inline string ProxyString + ( const Transistor::Type::Code* object ) + { + switch ( *object ) { + case Transistor::Type::LEFT : return "LEFT"; + case Transistor::Type::SINGLE: return "SINGLE"; + case Transistor::Type::RIGHT: return "RIGHT"; + case Transistor::Type::INTERNAL: return "INTERNAL"; + } + return "ABNORMAL"; + } + +template<> + inline Record* ProxyRecord + ( const Transistor::Type::Code* object ) + { + Record* record = new Record(GetString(object)); + record->Add(GetSlot("Code", (unsigned int*)object)); + return record; + } + + +# endif + +} + +//END_NAMESPACE_HURRICANE + + +// **************************************************************************************************** +// Generic functions +// **************************************************************************************************** + +string GetString(const H::Transistor::MaskInfo&); + + +#endif // HURRICANE_TRANSISTOR diff --git a/chamsin/src/analogic/Transistors.h b/chamsin/src/analogic/Transistors.h new file mode 100644 index 00000000..72a4d882 --- /dev/null +++ b/chamsin/src/analogic/Transistors.h @@ -0,0 +1,59 @@ + +// **************************************************************************************************** +// File: Transistors.h +// Authors: YIFEI WU +// Date : 21/12/2006 +// **************************************************************************************************** + +#ifndef HURRICANE_TRANSISTORS +#define HURRICANE_TRANSISTORS + +#include "Collection.h" + +BEGIN_NAMESPACE_HURRICANE + +class Transistor; + + +// **************************************************************************************************** +// Transistors declaration +// **************************************************************************************************** + +typedef GenericCollection Transistors; + + + +// **************************************************************************************************** +// TransistorLocator declaration +// **************************************************************************************************** + +typedef GenericLocator TransistorLocator; + + + +// **************************************************************************************************** +// TransistorFilter declaration +// **************************************************************************************************** + +typedef GenericFilter TransistorFilter; + + + +// **************************************************************************************************** +// for_each_transistor declaration +// **************************************************************************************************** + +#define for_each_transistor(transistor, transistors)\ +/******************************/\ +{\ + TransistorLocator _locator = transistors.GetLocator();\ + while (_locator.IsValid()) {\ + Transistor* transistor = _locator.GetElement();\ + _locator.Progress(); + + + +END_NAMESPACE_HURRICANE + +#endif // HURRICANE_TRANSISTORS + diff --git a/chamsin/src/analogic/TwoSpaces.cpp b/chamsin/src/analogic/TwoSpaces.cpp new file mode 100644 index 00000000..74a81254 --- /dev/null +++ b/chamsin/src/analogic/TwoSpaces.cpp @@ -0,0 +1,123 @@ +// ************************************************************** +// TwoSpaces.cpp +// Author : Wu YiFei +// Date : 12/04/2007 +// *************************************************************** + +#include "TwoSpaces.h" + + +BEGIN_NAMESPACE_HURRICANE + +// **************************************************************************************************** +// Two Spaces definition. +// **************************************************************************************************** +TwoSpaces::TwoSpaces(const string& s) +// ********************************* +: _s(s) + ,_n(1) +{ +} + + +TwoSpaces::TwoSpaces(const TwoSpaces& ts) +// ************************************** +: _s(ts._s) + ,_n(ts._n) +{ +} + + +TwoSpaces& TwoSpaces::operator=(const TwoSpaces& ts) +// ************************************************ +{ + _s = ts._s; + _n = ts._n; + return *this; +} + + +TwoSpaces& TwoSpaces::operator++() +// ******************************* +{ + if(_n<100) _n++; + return *this; +} + +TwoSpaces TwoSpaces::operator++(int) +// ********************************* +{ + TwoSpaces ts = *this; + if(_n<100) _n++; + return ts; +} + + +TwoSpaces& TwoSpaces::operator--() +// ******************************* +{ + if(_n>1) _n--; + return *this; +} + + +TwoSpaces TwoSpaces::operator--(int) +// ********************************* +{ + TwoSpaces ts = *this; + if(_n>1) _n--; + return ts; +} + + +TwoSpaces TwoSpaces::operator+(int count) +// ************************************** +{ + TwoSpaces ts = *this; + if( (_n+count) <= 100 ) ts._n = _n + count; + return ts; +} + + +TwoSpaces TwoSpaces::operator-(int count) +// ************************************** +{ + TwoSpaces ts = *this; + if ( (_n - count) >= 1 ) ts._n = _n - count; + return ts; +} + + +string TwoSpaces::_GetString() const +// ********************************* +{ + string s; + unsigned n = _n; + + while(n--) { + s += _s; + } + + return s; +} + + + +// **************************************************************************************************** +// Variables definition. +// **************************************************************************************************** +TwoSpaces ts(" "); + + +END_NAMESPACE_HURRICANE + + +// **************************************************************************************************** +// Generic functions +// **************************************************************************************************** +string GetString(const H::TwoSpaces& ts) +// *********************************** +{ + return ts._GetString(); +} + diff --git a/chamsin/src/analogic/TwoSpaces.h b/chamsin/src/analogic/TwoSpaces.h new file mode 100644 index 00000000..bf62dfba --- /dev/null +++ b/chamsin/src/analogic/TwoSpaces.h @@ -0,0 +1,72 @@ +// ************************************************************** +// TwoSpaces.h +// Author : Wu YiFei +// Date : 12/04/2007 +// *************************************************************** + + +# ifndef HURRICANE_TWOSPACES +# define HURRICANE_TWOSPACES + +# include "Commons.h" + + +BEGIN_NAMESPACE_HURRICANE + +// **************************************************************************************************** +// TwoSpaces declaration. +// **************************************************************************************************** +class TwoSpaces { +// *************** + +// Attributes +// ********** + private : string _s; + private : unsigned _n; + +// Constructors +// ************* + public : TwoSpaces(const string& s = " "); + public : TwoSpaces(const TwoSpaces&); + +// Destructors +// *********** + public : ~TwoSpaces(){}; + +// Operators +// ********* + public : TwoSpaces& operator=(const TwoSpaces&); + public : TwoSpaces& operator++(); + public : TwoSpaces operator++(int); + public : TwoSpaces& operator--(); + public : TwoSpaces operator--(int); + public : TwoSpaces operator+(int); + public : TwoSpaces operator-(int); + +// Others +// ****** + public : string _GetString() const ; + +}; + + +// **************************************************************************************************** +// Variables declaration. +// **************************************************************************************************** +extern TwoSpaces ts; + +END_NAMESPACE_HURRICANE + + +// **************************************************************************************************** +// Generic functions +// **************************************************************************************************** +string GetString(const H::TwoSpaces&); + +inline ostream& operator<<(ostream& stream, const H::TwoSpaces& ts) +// **************************************************************** +{ + return stream<< GetString(ts); +} + +# endif // END HURRICANE_TWOSPACES diff --git a/chamsin/src/device/CMakeLists.txt b/chamsin/src/device/CMakeLists.txt new file mode 100644 index 00000000..5a654099 --- /dev/null +++ b/chamsin/src/device/CMakeLists.txt @@ -0,0 +1,6 @@ +INCLUDE_DIRECTORIES(${HURRICANE_INCLUDE_DIR} ${CHAMSIN_SOURCE_DIR}/src/dtr +${CHAMSIN_SOURCE_DIR}/src/analogic) + +ADD_LIBRARY(device SHARED Device.cpp TrMos.cpp TrMos_PlaceRoute.cpp) + +TARGET_LINK_LIBRARIES(device analogic dtr hurricane) diff --git a/chamsin/src/device/Device.cpp b/chamsin/src/device/Device.cpp new file mode 100644 index 00000000..4604ddd9 --- /dev/null +++ b/chamsin/src/device/Device.cpp @@ -0,0 +1,203 @@ +// **************************************************************************************************** +// File: Device.cpp +// Authors: Wu YiFei +// Date : 21/12/2006 +// **************************************************************************************************** + + +#include "Device.h" + +#include "Transformation.h" +#include "Point.h" +#include "Instance.h" +#include "Box.h" +#include "Error.h" + +#include "Cells.h" +#include "DtrAccess.h" +#include "GenericDtrAccess.h" +using namespace Hurricane; + +// **************************************************************************************************** +// Static data function +// **************************************************************************************************** + +static Instance * refins = NULL; + + +static set cellSet; + + +static void GetAllCells(Cell* cell) +// ******************************** +{ + cellSet.insert(cell); + + if(!(cell->IsLeaf())){ + for_each_instance(instance, cell->GetInstances()) + Cell * mastercell = instance->GetMasterCell(); + GetAllCells(mastercell); + end_for + } +} + + + +namespace DEVICE { + + +// **************************************************************************************************** +// Device implementation +// **************************************************************************************************** + +Device::Device(Library* library, const Name& name) +// ************************************************************************** +: Inherit(library, name) +{ +} + + +void Device::Delete() +// ************************** +{ + _PreDelete(); + delete this; +} + + +void Device::_PreDelete() +// ****************************** +{ + // do something + // ************ + + Inherit::_PreDelete(); +} + + +void Device::_PostCreate() +// ******************************* +{ + Inherit::_PostCreate(); + + //CDataBase* database = GetCDataBase(); + //CCatal* ccatal = database->GetCCatal(); + + //CCatal::State* state = ccatal->GetState(GetName(), true); + //state->SetFlags(CCatal::State::LOGICAL|CCatal::State::PHYSICAL|CCatal::State::IN_MEMORY|CCatal::State::GDS, true); + //state->SetCell(this); + //state->SetLibrary(GetLibrary()); + + // Create GenericDtrAccess and DtrAccess + // ************************************* + GenericDtrAccess::Instance(DtrAccess::Instance()); + +} + + +void Device::SaveLogicalView() +// *************************** +{ + cellSet.clear(); + GetAllCells(this); + + //CDataBase * db = GetCDataBase(); + + // set::iterator i = cellSet.begin(), j = cellSet.end(); + // + // while(i!=j) { + // db->SaveCell(*i, CCatal::State::LOGICAL ); + // i++; + // } +} + + + +string Device::_GetString() const +// *************************************** +{ + string s= Inherit::_GetString(); + return s; +} + +Record* Device::_GetRecord() const +// ********************************* +{ + Record* record = Inherit::_GetRecord(); + return record; +} + + +void Device::_Place(Instance* ins, const Transformation::Orientation& orientation, const Point& point) +// ************************************************************************************************** +{ + if(!ins) { + throw Error("Can't Place Instance : ins is NULL"); + } + + if(ins->IsPlaced()) { + throw Error("Can't Place " + GetString(ins) + " : it has already been placed"); + } + + Transformation transformation(Point(0,0), orientation); + Box orientedmastercellbox = transformation.getBox(ins->GetMasterCell()->GetAbutmentBox()); + + Point translation( point.getX() - orientedmastercellbox.getXMin() + , point.getY() - orientedmastercellbox.getYMin() ); + + Transformation transformation_ins = Transformation(translation, orientation); + + ins->SetTransformation(transformation_ins); + ins->SetPlacementStatus(Instance::PlacementStatus::PLACED); +} + + +void Device::_SetRefIns(Instance* ins) const +// ***************************************** +{ + if(!ins) { + throw Error("Can't SetRefIns : ref instance is NULL"); + } + + if(ins->IsUnplaced()) { + throw Error("Can't SetRefIns : ref instance has't been placed"); + } + + refins = ins; +} + + +void Device::_PlaceRight(Instance* ins, const Transformation::Orientation& orientation, const Point& offset) +// ******************************************************************************************************** +{ + if(!ins) { + throw Error("Can't PlaceRight Instance : ins is NULL"); + } + + if(ins->IsPlaced()) { + throw Error("Can't PlaceRight " + GetString(ins) + " : it has already been placed"); + } + + + if(!refins) { + throw Error("Can't Place Right " + GetString(ins) + " : can't find refins"); + } + + Box refinsbox = refins->GetAbutmentBox(); + + Transformation transformation(Point(0,0), orientation); + Box orientedmastercellbox = transformation.getBox(ins->GetMasterCell()->GetAbutmentBox()); + + Point translation( refinsbox.getXMax() - orientedmastercellbox.getXMin() + offset.getX() + , refinsbox.getYMin() - orientedmastercellbox.getYMin() + offset.getY() ); + + Transformation transformation_ins = Transformation(translation, orientation); + + ins->SetTransformation(transformation_ins); + ins->SetPlacementStatus(Instance::PlacementStatus::PLACED); + + refins = ins; +} + + +} // end namespace Device diff --git a/chamsin/src/device/Device.h b/chamsin/src/device/Device.h new file mode 100644 index 00000000..36fc398f --- /dev/null +++ b/chamsin/src/device/Device.h @@ -0,0 +1,105 @@ + +// **************************************************************************************************** +// File: Device.h +// Authors: Wu YiFei +// Date : 21/12/2006 +// **************************************************************************************************** + +#ifndef DEVICE_DEVICE +#define DEVICE_DEVICE + + +#include "Cell.h" +using Hurricane::Cell; +using Hurricane::_TName; + + +namespace Hurricane { + + class Library; + class Name; + class Record; + class Point; + class Transformation; +// class Transformation::Orientation; + class Instance; + +} + + +namespace DEVICE { + +using Hurricane::Library; +using Hurricane::Name; +using Hurricane::Record; +using Hurricane::Point; +using Hurricane::Transformation; +//using Hurricane::Transformation::Orientation; +using Hurricane::Instance; + +class Device : public Cell { +// ************************* + +# if !defined(__DOXYGEN_PROCESSOR__) +// Types +// ***** + public : typedef Cell Inherit; + +// Attributes +// ******************* + + +// Constructors +// ************ + protected : Device(Library* library, const Name& name); + protected : virtual void _PostCreate(); + + +// Destructors +// *********** + protected : ~Device() {}; + public : virtual void Delete(); + protected : virtual void _PreDelete(); +# endif + +// Operations +// ********** +// public : virtual void Create(const char, const bool) = 0; + public : virtual void Dses() = 0; + public : virtual void Shape() = 0; +// public : virtual void Generate() = 0; + + +# if !defined(__DOXYGEN_PROCESSOR__) + public : virtual void SaveLogicalView(); + public : virtual void SavePhysicalView() {}; + +// Accessors +// ********* + +// Updators +// ******** + +// Others +// ****** + public: virtual string _GetTypeName() const {return _TName("Device"); }; + public: virtual string _GetString() const; + public: virtual Record* _GetRecord() const; + public : virtual void _Flush() = 0; + + // Description of Layout + // ********************** + public: void _Place(Instance* ins, const Transformation::Orientation& orientation, const Point& point); + public: void _SetRefIns(Instance*) const; + public: void _PlaceRight(Instance* ins, const Transformation::Orientation& orientation, const Point& offset=Point()); + + +#endif + +} ; + + +} // end namespace Device + + +#endif diff --git a/chamsin/src/device/DeviceUtil.h b/chamsin/src/device/DeviceUtil.h new file mode 100644 index 00000000..18eb1f58 --- /dev/null +++ b/chamsin/src/device/DeviceUtil.h @@ -0,0 +1,77 @@ +// **************************************************************************************************** +// File: DeviceUtil.h +// Authors: Wu YiFei +// Date : 28/05/2006 +// **************************************************************************************************** + + +# ifndef DEVICEUTIL_H +# define DEVICEUTIL_H + + +// **************************************************************************************************** +// Identifier Declaration. +// **************************************************************************************************** + + + + +namespace DEVICE { + +// **************************************************************************************************** +// Constants. +// **************************************************************************************************** + + +// **************************************************************************************************** +// Macros. +// **************************************************************************************************** + +// -------------------------------------------------------------------- +// Macro Method "RETURN_EVEN(num)" +// This Method Macro is return a number even. + + /* \num must be a integer. + */ + +# define RETURN_EVEN(num) \ + (num%2)==0?num:num+1 + + +// -------------------------------------------------------------------- +// Macro Method "MAX_INTEGER(a, b)" +// This Method Macro is return the Max between a and b. + + /* \a must be a integer. + * \b must be a integer. + */ + +# define MAX_INTEGER(a, b) \ + a>b?a:b + + + +// **************************************************************************************************** +// Class. +// **************************************************************************************************** + + +// **************************************************************************************************** +// Variables. +// **************************************************************************************************** + + +// **************************************************************************************************** +// Utilitarians (functions). +// **************************************************************************************************** + + +} // END OF NAMESPACE DEVICE + + +// **************************************************************************************************** +// Generic Functions. +// **************************************************************************************************** + + +# endif diff --git a/chamsin/src/device/TrMos.cpp b/chamsin/src/device/TrMos.cpp new file mode 100644 index 00000000..de2b553d --- /dev/null +++ b/chamsin/src/device/TrMos.cpp @@ -0,0 +1,462 @@ +// **************************************************************************************************** +// File: TrMos.cpp +// Authors: Wu YiFei +// Date : 21/12/2006 +// **************************************************************************************************** + + +#include "TrMos.h" + +#include "Instance.h" +#include "MetaTransistor.h" +#include "Net.h" +#include "Transistor.h" +#include "Transistors.h" + +#include "UpdateSession.h" + +#include "DtrAccess.h" +using namespace Hurricane; + + +namespace DEVICE{ + +// **************************************************************************************************** +// TrMos implementation +// **************************************************************************************************** + +TrMos::TrMos(Library* library, const Name& name) +// ************************************************************************** +: Inherit(library, name), + _type('N'), + _isBsConnected(false), + _m(1), + _sourceIsFirst(true), + _hasDummy(false), + _hasRing(true), + _tr1(NULL), + _capaRouting(0) +{ +} + + +TrMos* TrMos::Create(Library* library, const Name & name) +// ************************************************************************** +{ + TrMos* trmos= new TrMos(library, name); + trmos->_PostCreate(); + return trmos; +} + + +void TrMos::Delete() +// ***************** +{ + _PreDelete(); + delete this; +} + + +void TrMos::_PreDelete() +// ****************************** +{ + // do something + // ************ + + Inherit::_PreDelete(); +} + + +void TrMos::_PostCreate() +// ******************************* +{ + Inherit::_PostCreate(); + + // do something. + // Initialize pin order list and other attributes. + // ********************************************** + // _lowPinOrder[0]=D; + // _lowPinOrder[1]=G; + + // _highPinOrder[0]=S; + // _highPinOrder[1]=B; + + _highPinOrder.push_back(D); + _highPinOrder.push_back(G); + + _lowPinOrder.push_back(S); + _lowPinOrder.push_back(B); + + double minWidth = (DtrAccess::Instance())->GetSingleRealRuleByLabel(string("RW_ALU1")); + + _widthOfSourceWire = minWidth; + _widthOfDrainWire = minWidth; + +} + + +Transistors TrMos::GetTransistors() const +// ************************************** +{ + return GetCollection(_transistorList); +} + + +void TrMos::Create(const char type, const bool isbsconnected) +// ********************************************************** +{ + if( _tr1 ) { + throw Error("Can't Create Logical View of TrMos " + GetString(GetName()) + " : " + + "it has already been created"); + } + + if( (type!=TRANSN) && (type!=TRANSP)) { + throw Error("Can't Create TrMos " + GetString(GetName()) + " : type " + GetString(type) + " is invalid"); + } + + _type = type; + _isBsConnected = isbsconnected; + + // MetaTransistor is in the same library than Trmos + // ************************************************ + Library * library = GetLibrary(); + + // Create signals + // ************** + Net * drain = NULL; + Net * source = NULL; + Net * grid = NULL; + Net * bulk = NULL; + + (drain = Net::Create(this, Name("drain")))->SetExternal(true); + (source = Net::Create(this, Name("source")))->SetExternal(true); + (grid = Net::Create(this, Name("grid")))->SetExternal(true); + + if(!isbsconnected) { + (bulk = Net::Create(this, Name("bulk")))->SetExternal(true); + } + + + // Instancier a MetaTransistor and create the connection + // The name of MetaTransistor is nameoftrmos_tr1 + // **************************************************** + + _tr1 = MetaTransistor::Create(library, Name( GetString(GetName())+"_Mos1" ), _type); + Instance * instance = Instance::Create(this + , Name("Ins_" + GetString(_tr1->GetName())) + , _tr1 + ); + + instance->GetPlug(_tr1->GetNet(Name("DRAIN")))->SetNet(drain); + instance->GetPlug(_tr1->GetNet(Name("SOURCE")))->SetNet(source); + instance->GetPlug(_tr1->GetNet(Name("GRID")))->SetNet(grid); + + if(!isbsconnected) + instance->GetPlug(_tr1->GetNet(Name("BULK")))->SetNet(bulk); + else + instance->GetPlug(_tr1->GetNet(Name("BULK")))->SetNet(source); + + +} + + +void TrMos::Generate(const unsigned m, const bool sourceisfirst, const bool hasring + , const unsigned nbsourcecolumn, const unsigned nbdraincolumn) +// ********************************************************************************* +{ + if( !_tr1 ) { + throw Error("Can't Create Physical View for " + GetString(this) + + " : " + "Logical view has't been created yet."); + } + +// if( !(_transistorList.empty()) ) { +// throw Error("Can't Create Physical View of TrMos " + GetString(GetName()) + " : " +// + "it has already been created"); +// } + + // Check out param of realization. + // ******************************* + if( m <= 0 ) + throw Error("Can't generate for " + GetString(this) + " : m " + GetString(m) + + " is invalid."); + + if(nbsourcecolumn<1) + throw Error("Can't generate for " + GetString(this) + " : nbsourcecolumn " + + GetString(nbsourcecolumn) + " is invalid."); + + if(nbdraincolumn<1) + throw Error("Can't generate for" + GetString(this) + " : nbdraincolumn " + + GetString(nbdraincolumn) + " is invalid."); + + + if(!(_transistorList.empty())) { + _Flush(); + } + + _m = m; + _sourceIsFirst = sourceisfirst; + _hasRing = hasring; + + // Motifs are in the same library than Trmos + // ***************************************** + Library * library = GetLibrary(); + + cout << ts << "################################################################" <SetM(_m); + + for(unsigned i=0; iGetName()) + "_Finger_" + GetString(i) + , _type + ); + + _transistorList.push_back(finger); + Instance::Create(_tr1, Name("Ins_" + GetString(finger->GetName())), finger); + } + + IF_DEBUG_HUR_ANALOG + + cout << "*** Stage 1 : CreateLayout of " + GetString(this) + " finish ***" <GetM()) + ".\n" + << ts << GetString(_m) + " Transistors are created.\n" + <CreateConnection(); + + IF_DEBUG_HUR_ANALOG + cout << "*** Stage 2 : CreateLayout of " + GetString(this) + " finish ***" <SetLe(10); +// _tr1->SetWe(11); + +/* (3) */ + IF_DEBUG_HUR_ANALOG + cout << "*** Stage 3 : CreateLayout of " + GetString(this) + " Begin ***" <GetLe() ; + double w_finger = (_tr1->GetWe()) / (double)(_tr1->GetM()) ; + unsigned count = 0; + + Transistor::MaskV1Info * masqueinfo = Transistor::MaskV1Info::Create( l_finger, w_finger); + masqueinfo->SetNbSourceColumn(nbsourcecolumn); + masqueinfo->SetNbDrainColumn(nbdraincolumn); + + list::iterator i = _transistorList.begin() + , j = _transistorList.end(); + + if(_m == 1){ + masqueinfo->SetType(Transistor::Type::SINGLE); + (*(_transistorList.begin()))->SetMaskInfo(masqueinfo); + } + else if(_m%2==0) { // if m is pair, create two left fingers if is source first. + // and create two right fingers if is drain first. + while(i!=j) { + if(++count>2) + masqueinfo->SetType(Transistor::Type::INTERNAL); + else { + if ( _sourceIsFirst ) + masqueinfo->SetType(Transistor::Type::LEFT); + else + masqueinfo->SetType(Transistor::Type::RIGHT); + } + + (*i)->SetMaskInfo(masqueinfo); + i++; + } + } + else if(_m%2==1) { // if m is impair, create one left finger, one right finger. + while(i!=j){ + ++ count ; + if (count == 1) + masqueinfo-> SetType(Transistor::Type::LEFT); + else if (count == 2) + masqueinfo-> SetType(Transistor::Type::RIGHT); + else + masqueinfo-> SetType(Transistor::Type::INTERNAL); + + (*i)->SetMaskInfo(masqueinfo); + i++; + } + } + + masqueinfo->Delete(); + + IF_DEBUG_HUR_ANALOG + cout << "*** Stage 3 : CreateLayout of " + GetString(this) + " finish ***" <_le) + "." << endl +// << ts << "Real w of " << (long)_tr1 << GetString(_tr1) + " is " + GetString(_tr1->_we) + "." << endl +// <CreateLayout(); + + IF_DEBUG_HUR_ANALOG + cout << "*** Stage 4 : CreateLayout of " + GetString(this) + " finish ***"<SetTransformation(instance->GetTransformation()); + instance->Unmaterialize(); + instance->Materialize(); + +IF_DEBUG_HUR_ANALOG + cout << ts << GetString(instance) <<" 's boundingBox is " << GetString(instance->GetBoundingBox())<::iterator i = _lowPinOrder.begin(), j = _lowPinOrder.end(); + + cout << " Low Pin Order " << endl; + + while(i!=j) { + cout << *i << endl; + i++; + } + +} + + +void TrMos::SetHighPinOrder(const PinName pin1, const PinName pin2) +// ***************************************************************** +{ + _highPinOrder[0]=pin1; + _highPinOrder[1]=pin2; + + vector::iterator i = _highPinOrder.begin(), j = _highPinOrder.end(); + + cout << " High Pin Order " << endl; + + while(i!=j) { + cout << *i << endl; + i++; + } +} + + +void TrMos::_Flush() +// **************** +{ + if(_transistorList.empty()) { + throw Error("Can't delete Physical View of TrMos " + GetString(GetName()) + " : " + "il doesn't exist"); + } + + _tr1->Flush(); + + _transistorList.clear(); + + // Delete all segments of TrMos + // **************************** + /* to do */ + + +} + + +string TrMos::_GetString() const +// *************************************** +{ + string s= Inherit::_GetString(); + return s; +} + +Record* TrMos::_GetRecord() const +// ********************************* +{ + Record* record = Inherit::_GetRecord(); + return record; +} + +} // end of namespace Device diff --git a/chamsin/src/device/TrMos.h b/chamsin/src/device/TrMos.h new file mode 100644 index 00000000..edf193ff --- /dev/null +++ b/chamsin/src/device/TrMos.h @@ -0,0 +1,161 @@ +// **************************************************************************************************** +// File: TrMos.h +// Authors: Wu YiFei +// Date : 21/12/2006 +// **************************************************************************************************** + +#ifndef DEVICE_TRMOS +#define DEVICE_TRMOS + + +#include "Device.h" +#include "Transistors.h" +#include "MetaTransistor.h" + + +namespace Hurricane { + + class Library; + class Name; + class Record; + class Transistor; + + class Net; + class Pin; +} + +namespace DEVICE { + +using Hurricane::Library; +using Hurricane::Name; +using Hurricane::Record; +using Hurricane::MetaTransistor; +using Hurricane::Transistor; +using Hurricane::Transistors; +using Hurricane::Net; +using Hurricane::Pin; + + +class TrMos : public Device { +// ************************** + +# if !defined(__DOXYGEN_PROCESSOR__) +// Types +// ***** + public : typedef Device Inherit; + + public : enum PinName { D, G, S, B }; + +// Attributes +// ******************* + + // Structural parameter. + // ******************** + private : char _type; + private : bool _isBsConnected; + private : unsigned _m; + + // Parameter of the electric synthesis. + // *********************************** + /* to do */ + + // Physical parameter of realization. + // ********************************** + /* Placement. */ + private : bool _sourceIsFirst; + private : bool _hasDummy; + private : bool _hasRing; + + /* Routing. */ + private : vector _lowPinOrder; // relative position of the connectors on the basis of the top. + private : vector _highPinOrder; + + private : map _mapNetToPinBoxInLeftSide; + private : map _mapNetToPinBoxInRightSide; + + private : double _widthOfSourceWire; // by defect, minWidth, unit of valeur is Micro + private : double _widthOfDrainWire; // by defect, minWidth, unit of valeur is Micro + + /* Others */ + private : MetaTransistor * _tr1; + private : double _capaRouting; + private : list _transistorList; + + +// Constructors +// ************ + protected : TrMos(Library* library, const Name& name); + protected : virtual void _PostCreate(); +#endif + + public : static TrMos* Create(Library* library, const Name & name); + + +# if !defined(__DOXYGEN_PROCESSOR__) +// Destructors +// *********** + protected : ~TrMos() {}; + public : virtual void Delete(); + protected : virtual void _PreDelete(); + + +// Operations +// ********** + public : virtual void Dses() { /* to do */}; + public : virtual void Shape() { /* to do */}; +#endif + + + public : void Create(const char type, const bool isbsconnected); + public : void Generate(const unsigned m, const bool sourceisfirst, const bool hasring, + const unsigned nbsourcecolumn, const unsigned nbdraincolumn); + +// Accessors +// ********* + public : char GetType() const { return _type; }; + public : unsigned GetM() const { return _m; }; + public : const double GetWidthOfSourceWire() const { return _widthOfSourceWire; }; + public : const double GetWidthOfDrainWire() const { return _widthOfDrainWire; }; + public : MetaTransistor* GetTr1() const { return _tr1; }; + public : Transistors GetTransistors() const ; + +// Updators +// ******** + public : void SetMosLength(const double length) { if(_tr1) _tr1->SetLe(length); } + public : void SetMosWidth(const double width) { if(_tr1) _tr1->SetWe(width); } + public : void SetWidthOfSourceWire(const double width) { _widthOfSourceWire = width; }; + public : void SetWidthOfDrainWire(const double width) { _widthOfDrainWire=width; }; + public : void SetLowPinOrder(const PinName, const PinName) ; + public : void SetHighPinOrder(const PinName, const PinName) ; + +// Predicats +// ********* + public : bool IsBsConnected() const { return _isBsConnected; }; + public : bool SourceIsFirst() const { return _sourceIsFirst; }; + public : bool HasRing() const { return _hasRing; }; + + +# if !defined(__DOXYGEN_PROCESSOR__) + +// Others +// ****** + public: virtual string _GetTypeName() const {return _TName("TrMos"); }; + public: virtual string _GetString() const; + public: virtual Record* _GetRecord() const; + + public: vector& GetLowPinOrder() { return _lowPinOrder; }; + public: vector& GetHighPinOrder() { return _highPinOrder; }; + + public: map& GetMapNetToPinBoxInLeftSide() { return _mapNetToPinBoxInLeftSide; }; + public: map& GetMapNetToPinBoxInRightSide() { return _mapNetToPinBoxInRightSide; }; + + public : virtual void _Flush(); + protected : void _PlaceAndRoute(); +# endif + +} ; + +} // end of namespace Device + + +#endif diff --git a/chamsin/src/device/TrMos_PlaceRoute.cpp b/chamsin/src/device/TrMos_PlaceRoute.cpp new file mode 100644 index 00000000..72d33c9d --- /dev/null +++ b/chamsin/src/device/TrMos_PlaceRoute.cpp @@ -0,0 +1,689 @@ +// **************************************************************************************************** +// File: TrMos.cpp +// Authors: Wu YiFei +// Date : 21/12/2006 +// **************************************************************************************************** + + +#include "TrMos.h" + +#include "Instances.h" +#include "MetaTransistor.h" +#include "Net.h" +#include "Transistors.h" +#include "Box.h" +#include "UpdateSession.h" +#include "HyperNet.h" +#include "DataBase.h" +#include "Technology.h" +#include "Vertical.h" +#include "Horizontal.h" +#include "Pin.h" + +#include "RdsUnit.h" +#include "Transistor.h" +#include "DtrAccess.h" +using namespace Hurricane; + + + +#include "DeviceUtil.h" + + +namespace DEVICE{ + + +// **************************************************************************************************** +// TrMos implementation +// **************************************************************************************************** +void TrMos::_PlaceAndRoute() +// ************************* +{ + + // Get Dtr Rules And Calculate the Size of AbutmentBox of Device. + // ************************************************************** + DtrAccess * dtraccess = DtrAccess::Instance(); + + char type; + if(_type == 'P') type = 'N'; + else type = 'P'; + + long minImpWidth = dtraccess->GetSingleRdsRuleByLabel("RW_", GetString(type), "IMP"); + long minContWidth = dtraccess->GetSingleRdsRuleByLabel(string("RW_CONT")); + long minAlu1Width = dtraccess->GetSingleRdsRuleByLabel(string("RW_ALU1")); + long minVia1Width = dtraccess->GetSingleRdsRuleByLabel(string("RW_VIA1")); + + long rdImp = dtraccess->GetSingleRdsRuleByLabel(string("RD_NIMP")); + long rdActive = dtraccess->GetSingleRdsRuleByLabel(string("RD_ACTI")); + long rdAlu2 = dtraccess->GetSingleRdsRuleByLabel(string("RD_ALU1")); + + long reImpActi = dtraccess->GetSingleRdsRuleByLabel("RE_", GetString(type), "IMP_CONT"); + long reActiContact = dtraccess->GetSingleRdsRuleByLabel("RE_ACTI_CONT"); + long reAlu1Contact = dtraccess->GetSingleRdsRuleByLabel("RE_ALU1_CONT"); + long reAlu1Via1 = dtraccess->GetSingleRdsRuleByLabel("RE_ALU1_VIA1"); + + long minActiWidth = 2*reActiContact + minContWidth; + + long widthOfSourceWire = ConvertRealToRdsUnit(_widthOfSourceWire); + long widthOfDrainWire = ConvertRealToRdsUnit(_widthOfDrainWire); + + long widthOfActive = MAX_INTEGER(minActiWidth, minContWidth + 2*reActiContact); + long widthOfImp = MAX_INTEGER(widthOfActive + 2*reImpActi, minImpWidth); + + + // ************************************************************** + // Placing . + // ************************************************************** + + Transformation::Orientation::Code internalTransCode = Transformation::Orientation::ID; + + Unit horizontalMargin = 0; // the horizontal margin of trmos. + Unit verticalLowMargin = 0; // the vertical low margin of trmos. + Unit verticalHighMargin = 0; // the vertical high margin of trmos. + + Unit fingerHeight = 0; // the height of trmos. + Instance * leftins = NULL; + Instance * rightins = NULL; + + OccurrenceLocator locator = GetLeafInstanceOccurrences().GetLocator(); + Instance * instance = dynamic_cast(locator.GetElement().GetEntity());; + fingerHeight = instance->GetCell()->GetBoundingBox().getHeight(); + horizontalMargin = GetUnit(RETURN_EVEN((long)(GetValue(fingerHeight))/4)); + verticalLowMargin = GetUnit(RETURN_EVEN((long)(GetValue(fingerHeight))/2)); + verticalHighMargin = GetUnit(RETURN_EVEN((long)(GetValue(fingerHeight))/2)); + + + verticalLowMargin = MAX_INTEGER(verticalLowMargin, GetUnit(RETURN_EVEN(rdImp + widthOfImp/2 + widthOfSourceWire + + rdAlu2 + widthOfActive + rdActive)) ); + + verticalHighMargin = MAX_INTEGER(verticalHighMargin, horizontalMargin + GetUnit(2*rdAlu2 + 2*widthOfDrainWire) ); + horizontalMargin = MAX_INTEGER(horizontalMargin, GetUnit(RETURN_EVEN(rdImp + widthOfImp/2)) ); + + OpenUpdateSession(); + + if(_m == 1 ) { // If there is only one finger. + _Place( instance, Transformation::Orientation::ID, Point( horizontalMargin, verticalLowMargin ) ); + //CloseUpdateSession(); + //return; + + } + else { + // Get instance who's model's abutment type is Left or Right. + // ************************************************************ + for_each_occurrence(occurrence, GetLeafInstanceOccurrences()) + instance = dynamic_cast(occurrence.GetEntity()); + Transistor * trans = dynamic_cast(instance->GetMasterCell()); + + if ( _sourceIsFirst ) { + if(trans->IsLeft() && !leftins) + leftins = instance; + else if ( trans->IsLeft() && leftins) + rightins = instance; + else if ( trans->IsRight()) + rightins = instance; + } + else { + if(trans->IsRight() && !leftins) + leftins = instance; + else if (trans->IsRight() && leftins ) + rightins = instance; + else if (trans->IsLeft()) + rightins = instance; + } + end_for + + // You must place this first instance who's model is left finger in a point who's + // x, y are all pair. + // Because if you do this, you can be sure that all rectangle of this instance are + // correctly in the grille of fondor. + // *********************************************************************************** + + if(_sourceIsFirst) + _Place( leftins, Transformation::Orientation::ID, Point(horizontalMargin, verticalLowMargin) ); + else + _Place( leftins, Transformation::Orientation::MX, Point(horizontalMargin, verticalLowMargin) ); + + _SetRefIns(leftins); + + if(_sourceIsFirst) // internal Finger's transformation. + internalTransCode = Transformation::Orientation::MX; + else + internalTransCode = Transformation::Orientation::ID; + + // Place internal finger. + // ********************* + for_each_occurrence(occurrence, GetLeafInstanceOccurrences()) + + Instance * instance = dynamic_cast(occurrence.GetEntity()); + + if(instance==leftins || instance==rightins ) + continue; + + _PlaceRight( instance, internalTransCode); + + if(internalTransCode == Transformation::Orientation::MX) + internalTransCode = Transformation::Orientation::ID; + else + internalTransCode = Transformation::Orientation::MX; + + end_for + + // Place the last finger. + // ********************** + Transistor * trans = dynamic_cast(rightins->GetMasterCell()); + + if( trans->IsRight()) + _PlaceRight( rightins, Transformation::Orientation::ID); + else + _PlaceRight( rightins, Transformation::Orientation::MX); + + } + + CloseUpdateSession(); + + + + // Set AbutmentBox. + // **************** + for_each_instance(instance, GetInstances()) + instance->Unmaterialize(); + instance->Materialize(); + end_for + + OpenUpdateSession(); + + + cout <<"Bounding box of TrMos is "< netName2PositionOfConnectorMap; + list routingZoneList; + list sourcePositionList; + list drainPositionList; + Unit sourceRoutingZoneWidth; + Unit drainRoutingZoneWidth; + + DataBase * db = GetDataBase(); + if(!db) throw Error("Can't launch Trmos::PlaceAndRoute for " + GetString(this) + " : can't find DataBase"); + + Layer * layerAlu1 = db->GetTechnology()->GetLayer(Name("ALU1")); + Layer * layerAlu2 = db->GetTechnology()->GetLayer(Name("ALU2")); + + Layer * layerVia1 = db->GetTechnology()->GetLayer(Name("VIA1")); + Layer * layerActive = db->GetTechnology()->GetLayer(Name("ACTIVE")); + + Layer * layerVia01 = db->GetTechnology()->GetLayer(Name("via01")); + Layer * layerVia12 = db->GetTechnology()->GetLayer(Name("via12")); + + Layer * layerPoly = db->GetTechnology()->GetLayer(Name("POLY")); + Layer * layerNwell = db->GetTechnology()->GetLayer(Name("NWELL")); + Layer * layerCont = db->GetTechnology()->GetLayer(Name("CONT")); + + Layer * layerImp = NULL; + + if(_type == 'P') + layerImp = db->GetTechnology()->GetLayer(Name("NIMP")); + else + layerImp = db->GetTechnology()->GetLayer(Name("PIMP")); + + Pin * pin = NULL; // For get the adresse of Created Pins. + + long connectorPosition = 0; + + + cout << " Begin routage " << endl; + + + // Set position of four connectors. + // ******************************** + vector::iterator i = _highPinOrder.begin(), + j = _highPinOrder.end(); + + while(i!=j) { + if(*i == D) + netName2PositionOfConnectorMap[string("drain")] = initialPosition; + if(*i == G) + netName2PositionOfConnectorMap[string("grid")] = initialPosition; + + interval = MAX_INTEGER(expectedInterval, GetUnit(widthOfDrainWire + rdAlu2)); + + // initialPosition += horizontalMargin/2; + initialPosition += interval; + i++; + } + + vector::iterator m = _lowPinOrder.begin(), + n = _lowPinOrder.end(); + + //initialPosition = verticalMargin - horizontalMargin/2; + //initialPosition = verticalLowMargin - MAX_INTEGER(expectedInterval, GetUnit(rdImp + widthOfImp/2)); + initialPosition = verticalLowMargin - GetUnit(rdImp + widthOfImp/2); + + while(m!=n) { + if(*m == S) + netName2PositionOfConnectorMap[string("source")] = initialPosition; + if(*m == B) + netName2PositionOfConnectorMap[string("bulk")] = initialPosition; + + interval = MAX_INTEGER(expectedInterval, GetUnit(rdAlu2 + widthOfSourceWire)); + + initialPosition -= interval; + m++; + } + + cout << " Main loop "<< endl; + + // Main Routing Algorithm. + // *********************** + + // Main Loop. + // ********** + for_each_net(net, GetNets()) // For all hypernets. + + if(GetString(net->GetName())=="bulk" || GetString(net->GetName())=="BULK" ) + continue; + + // Get Routing Zone. + // ***************** + HyperNet hyperNet(Occurrence(net, Path())); + for_each_occurrence(occurrence, hyperNet.GetNetOccurrences()) // For all net occurrences. + Net * net = dynamic_cast(occurrence.GetEntity()); + Box routingZone; + + if(net->GetCell()->IsLeaf()) { + Transistor * trans = dynamic_cast(net->GetCell()); + if ( !trans ) + throw Error("Can't launch Trmos::PlaceAndRoute for " + GetString(this) + + ", it is not a Transistor"); + + cout << GetString(occurrence) << endl; + cout << GetString(occurrence.GetPath().GetTransformation()) <_GetMapNet2Box()))[net]) << endl; + + // Get Routing Zone. + // ***************** + routingZone = occurrence.GetPath().GetTransformation().getBox((*(trans->_GetMapNet2Box()))[net]); + routingZoneList.push_back(routingZone); + + if(GetString(net->GetName())=="SOURCE") { + sourcePositionList.push_back(routingZone.getXCenter()); + sourceRoutingZoneWidth = routingZone.getWidth(); + } + else if (GetString(net->GetName())=="DRAIN") { + drainPositionList.push_back(routingZone.getXCenter()); + drainRoutingZoneWidth = routingZone.getWidth(); + } + } + + end_for + + + cout <<"Print routing zone for " <::iterator it_begin_listbox = routingZoneList.begin(), + it_end_listbox = routingZoneList.end(); + + while(it_begin_listbox != it_end_listbox) + { + cout<< GetString(*it_begin_listbox) <::iterator routingzonelist_begin_it = routingZoneList.begin(), + routingzonelist_end_it = routingZoneList.end(); + + connectorPosition = netName2PositionOfConnectorMap[GetString(net->GetName())]; + cout << "Connector Position is " << netName2PositionOfConnectorMap[GetString(net)] << endl; + + while(routingzonelist_begin_it!=routingzonelist_end_it) { + + Box routingZoneBox = *routingzonelist_begin_it; + + // Create vertical line and Contact. + // ******************************** + if(connectorPosition > routingZoneBox.getYMin()) { + Vertical::Create(net, layerAlu1, routingZoneBox.getXCenter() + , routingZoneBox.getWidth() + GetUnit(2*reAlu1Contact) + , routingZoneBox.getYMin() - GetUnit(reAlu1Contact) + , connectorPosition); + } + else { + Vertical::Create(net, layerAlu1, routingZoneBox.getXCenter() + , routingZoneBox.getWidth() + GetUnit(2*reAlu1Contact) + , connectorPosition + , routingZoneBox.getYMax() + GetUnit(reAlu1Contact) ) ; + } + + Contact::Create(net, layerVia12, routingZoneBox.getXCenter() + , connectorPosition + , GetUnit(minVia1Width) + , GetUnit(minVia1Width) + ); + + routingzonelist_begin_it ++ ; + } + + // Create horizontal line. + // *********************** + long widthOfWire = 0; + + if(GetString(net->GetName())=="source") + widthOfWire = widthOfSourceWire; + else if(GetString(net->GetName())=="drain") + widthOfWire = widthOfDrainWire; + else + widthOfWire = widthOfDrainWire; + + + Horizontal::Create(net, layerAlu2, connectorPosition + , GetUnit(widthOfWire) + , 0 + , GetAbutmentBox().getXMax() + ); + + // Create Two Pins. + // **************** + pin = Pin::Create(net + , Name(GetString(net->GetName())+"_west") + , Pin::AccessDirection(Pin::AccessDirection::WEST) + , Pin::PlacementStatus(Pin::PlacementStatus::PLACED) + , layerAlu2 + , GetAbutmentBox().getXMin() + , connectorPosition + , GetUnit(widthOfWire) + , GetUnit(widthOfWire) + ); + + _mapNetToPinBoxInLeftSide[net] = pin; + + pin = Pin::Create(net + , Name(GetString(net->GetName())+"_east") + , Pin::AccessDirection(Pin::AccessDirection::EAST) + , Pin::PlacementStatus(Pin::PlacementStatus::PLACED) + , layerAlu2 + , GetAbutmentBox().getXMax() + , connectorPosition + , GetUnit(widthOfWire) + , GetUnit(widthOfWire) + ); + + _mapNetToPinBoxInRightSide[net] = pin; + + routingZoneList.clear(); + + // End Of Main Loop. + // ***************** + end_for + + // Route Net Bulk. + // *************** + connectorPosition = netName2PositionOfConnectorMap[string("bulk")]; + + Net * netBulk = GetNet(Name("bulk")); + + if(!netBulk) // bulk and source are connected. + netBulk = GetNet(Name("source")); + + // Calculate the width of Contact Alu1. + // ************************************ + long widthOfAlu1 = MAX_INTEGER( MAX_INTEGER(minAlu1Width, 2*reAlu1Contact + minContWidth), 2*reAlu1Via1 + minVia1Width); + + Unit bulkPosition = netName2PositionOfConnectorMap[string("bulk")]; + Unit sourcePosition = netName2PositionOfConnectorMap[string("source")]; + + Horizontal::Create( netBulk + , layerImp + , bulkPosition + , GetUnit(widthOfImp) + , 0 - GetUnit(reImpActi) + , GetAbutmentBox().getXMax() + GetUnit(reImpActi) + ); + + Horizontal::Create( netBulk + , layerActive + , bulkPosition + , GetUnit(widthOfActive) + , 0 + , GetAbutmentBox().getXMax() + ); + + Horizontal::Create( netBulk + , layerAlu2 + , bulkPosition + , GetUnit(widthOfSourceWire) + , 0 + , GetAbutmentBox().getXMax() + ); + + // Create Two Pins For Net bulk. + // ***************************** + if(!_isBsConnected) { + + pin = Pin::Create(netBulk + , Name(GetString(netBulk->GetName())+"_west") + , Pin::AccessDirection(Pin::AccessDirection::WEST) + , Pin::PlacementStatus(Pin::PlacementStatus::PLACED) + , layerAlu2 + , GetAbutmentBox().getXMin() + , bulkPosition + , GetUnit(widthOfSourceWire) + , GetUnit(widthOfSourceWire) + ); + + _mapNetToPinBoxInLeftSide[netBulk] = pin; + + pin = Pin::Create(netBulk + , Name(GetString(netBulk->GetName())+"_east") + , Pin::AccessDirection(Pin::AccessDirection::EAST) + , Pin::PlacementStatus(Pin::PlacementStatus::PLACED) + , layerAlu2 + , GetAbutmentBox().getXMax() + , bulkPosition + , GetUnit(widthOfSourceWire) + , GetUnit(widthOfSourceWire) + ); + + _mapNetToPinBoxInRightSide[netBulk] = pin; + } + + + if( netName2PositionOfConnectorMap[string("source")] > netName2PositionOfConnectorMap[string("bulk")] ) { + // Source Is Upper Than Bulk. + + cout << " Source is Upper Than Bulk" << endl; + + list::iterator i = sourcePositionList.begin(), j = sourcePositionList.end(); + + while(i!=j) { + + cout << " ######### Create Contact ###########" <::iterator i , j; + + + if( _isBsConnected ) { // If bulk and Source are connected. + i = sourcePositionList.begin(); + j = sourcePositionList.end(); + } + else { + i = drainPositionList.begin(); + j = drainPositionList.end(); + } + + while(i!=j) { + + cout << " ######### Create Contact ###########" < DtrAccess::_registry; + +DtrAccess::DtrAccess() +// ******************* +{ +} + + +DtrAccess * DtrAccess::Create() +// ***************************** +{ + DtrAccess * dtraccess = new DtrAccess(); + + dtraccess->_PostCreate(); + + return dtraccess; +} + + +void DtrAccess::_PostCreate() +// ************************** +{ + const char * dtrfilename = getenv("DTR_FILE"); + if(!dtrfilename) { + throw Error("Can't not get Macro DTR_FILE."); + } + + // Use API of DtrParser for get technology informations + // **************************************************** + ParseDtr(dtrfilename, this); + + // Traduit Micro to RdsUnit + // ************************ + map >::iterator it_rulemap = _label2ruleMap.begin(), + it_end_rulemap = _label2ruleMap.end(); + + while(it_rulemap!=it_end_rulemap) { + + list::iterator m = ((*it_rulemap).second).begin() + , n = ((*it_rulemap).second).end(); + + while(m!=n) { + _label2RdsRuleMap[(*it_rulemap).first].push_back(ConvertRealToRdsUnit(*m)); + m++; + } + it_rulemap++; + } + + // Get Objet Layer from Technology with its name. + // ********************************************** + + DataBase * db = GetDataBase(); + + if(!db) throw Error("In GetV1Trans::Generate : can't find DataBase."); + + Technology * tech = db->GetTechnology(); + + map >::iterator it_layermap = _label2layerNameMap.begin(), + it_end_layermap = _label2layerNameMap.end(); + + while(it_layermap != it_end_layermap) { + + list::iterator m = (*it_layermap).second.begin(), + n = (*it_layermap).second.end(); + + while(m!=n) { + Layer * layer = tech->GetLayer(Name(*m)); + if(!layer) { + throw Error("Error : in function DtrAccess::_PostCreate , Can't find Layer " + + GetString(*m) + " in technology file when parser DtrFile."); +// cerr << Warning("In function DtrAccess::_PostCreate , Can't find Layer " +// + GetString(*m) + " in technology file when parser DtrFile"); + } + + _label2layerMap[(*it_layermap).first].push_back(layer); + m++; + } + it_layermap++; + } + +} + + +DtrAccess * DtrAccess::Instance() +// ***************************** +{ + // User or environnement supplies this at startup + // ********************************************** + const char * singleton_name = getenv("DTRACCESS_SINGLETON"); + + if(!singleton_name) { // if MACRO IS INVALID + if(!_instance) { + _instance = DtrAccess::Create(); + } + } + else { + if(!_instance){ + if( !(_instance=LookUp(string(singleton_name))) ) // if singleton hasn't been registered + _instance = DtrAccess::Create(); + } + } + + return _instance; +} + + +void DtrAccess::_PreDelete() +// *********************** +{ + // Do something + // ************ +} + + +void DtrAccess::Delete() +// ******************** +{ + _PreDelete(); + delete this; +} + + +GenericCollection DtrAccess::GetRuleByLabel(const string& label) const +// *************************************************************************** +{ + map >::const_iterator i = _label2ruleMap.find(label); + + if(i==_label2ruleMap.end()) + throw Error("Can't find in DtrFile rule the label : " + GetString(label)); + + return GetCollection((*i).second); +} + + +GenericCollection DtrAccess::GetRdsRuleByLabel(const string& label) const +// ****************************************************************************** +{ + map >::const_iterator i = _label2RdsRuleMap.find(label); + + if(i==_label2RdsRuleMap.end()) + throw Error("Can't find in DtrFile The Rds Value of Rule by label : " + GetString(label)); + + return GetCollection((*i).second); +} + + +GenericCollection DtrAccess::GetLayerNamesByLabel(const string& label) const +// ********************************************************************************* +{ + map >::const_iterator i = _label2layerNameMap.find(label); + + if(i==_label2layerNameMap.end()) + throw Error("Can't find in DtrFile layers the label : " + label); + + return GetCollection((*i).second); +} + + +GenericCollection DtrAccess::GetLayersByLabel(const string& label) const +// ****************************************************************************** +{ + map >::const_iterator i = _label2layerMap.find(label); + + if(i==_label2layerMap.end()) + throw Error("Can't find in DtrFile objet Layer by label : " + label ); + + return GetCollection((*i).second); +} + + +GenericCollection DtrAccess::GetElectricalsByLabel(const string& label) const +// ********************************************************************************** +{ + map >::const_iterator i = _label2electricalMap.find(label); + + if(i==_label2electricalMap.end()) + throw Error("Can't find in DtrFile electricals by label : " + label); + + return GetCollection((*i).second); +} + + +int DtrAccess::GetModellingByLabel(const string& label) const +// ********************************************************** +{ + map::const_iterator i = _label2modellingMap.find(label); + + if(i==_label2modellingMap.end()) + throw Error("Can't find in DtrFile modelling by label : " + GetString(label)); + + return (*i).second; +} + + +double DtrAccess::GetSimpleCapaMimByLabel(const string& label) const +// **************************************************************** +{ + map::const_iterator i = _label2simplecapamimMap.find(label); + + if(i==_label2simplecapamimMap.end()) + throw Error("Can't find in DtrFile simple capa mim by label : " + GetString(label)); + + return (*i).second; +} + + +// ------------------------------------------------------ +// Function "DtrAccess::LookUp(const string&)". +// + + /* \static DtrAccess* DtrAccess::LookUp(const string& singletonname) + * \param singletonname normally the name of derive class of DtrAccess. + * \return addresse of objet singleton of derive class if success. + * NULL if failure. + * + * Find the singleton objet if it exist according to the singletonname. + * + */ + +DtrAccess* DtrAccess::LookUp(const string& singletonname) +// ****************************************************** +{ + map::iterator i = _registry.find(singletonname); + + if(i==_registry.end()) + return NULL; + + return (*i).second; +} + + +// ------------------------------------------------------------------------ +// Function Register(const string&, DtrAccess*) + + /* \void DtrAccess::Register(const string& singletonname, DtrAccess* dtraccess) + * \param singletonname the name of derive class. + * \param dtraccess addresse of objet singleton of derive class. + * + * + * This function is to be called when the singleton objet of derive class is + * created. + * + */ + +void DtrAccess::Register(const string& singletonname, DtrAccess* dtraccess) +// ************************************************************************* +{ + _registry[singletonname]=dtraccess; +} + + +string DtrAccess::_GetString() const +// ********************************** +{ + string s("Singleton DtrAccess"); + return s; +} + + +Record* DtrAccess::_GetRecord() const +// ********************************** +{ + Record* record = new Record(_GetString()); + return record; +} + +END_NAMESPACE_HURRICANE + +// **************************************************************************************************** +// Generic functions +// **************************************************************************************************** + +string GetString(const H::DtrAccess& access) +// ********************************************** +{ + return access._GetString(); +} + + diff --git a/chamsin/src/dtr/DtrAccess.h b/chamsin/src/dtr/DtrAccess.h new file mode 100644 index 00000000..fe660bbe --- /dev/null +++ b/chamsin/src/dtr/DtrAccess.h @@ -0,0 +1,187 @@ +// **************************************************************************************************** +// File: DtrAccess.h +// Authors: Wu YiFei +// Date : 21/12/2006 +// **************************************************************************************************** + +#ifndef HURRICANE_DTRACCESS +#define HURRICANE_DTRACCESS + +#include "Layer.h" +#include "Layers.h" + +//BEGIN_NAMESPACE_HURRICANE + + +namespace Hurricane { + +class DtrAccess { +// ************** + +// Types +// ***** + +# if !defined(__DOXYGEN_PROCESSOR__) +// Attributes +// ********** + private : static DtrAccess * _instance; + + private : map > _label2ruleMap; + private : map > _label2layerNameMap; + private : map > _label2electricalMap; + private : map _label2modellingMap; + private : map _label2simplecapamimMap; + + private : map > _label2RdsRuleMap; + private : map > _label2layerMap; + + + // For reusability of software + // *************************** + private : static map _registry; + + +// Constructors +// ************ + protected : DtrAccess(); + private : DtrAccess(const DtrAccess&); + private : DtrAccess& operator=(const DtrAccess&); + + protected : static DtrAccess * Create(); + protected : virtual void _PostCreate(); +# endif + + public : static DtrAccess* Instance(); + +// Destructors +// *********** +# if !defined(__DOXYGEN_PROCESSOR__) + protected : virtual ~DtrAccess() {}; + protected : virtual void _PreDelete(); +# endif + + + public : virtual void Delete(); + + +// Accessors +// ********* + + // If can't find data , throw Hurricane::Error + // ******************************************* + public : GenericCollection GetRuleByLabel(const string&) const; + public : GenericCollection GetRdsRuleByLabel(const string&) const; + public : GenericCollection GetLayerNamesByLabel(const string&) const; + public : Layers GetLayersByLabel(const string&) const; + public : GenericCollection GetElectricalsByLabel(const string& ) const; + public : int GetModellingByLabel(const string&) const; + public : double GetSimpleCapaMimByLabel(const string&) const; + + +# if !defined(__DOXYGEN_PROCESSOR__) + public : double GetSingleRealRuleByLabel(const string& s) const + // ************************************************* + { + GenericLocator locator = GetRuleByLabel(s).GetLocator(); + return locator.GetElement(); + } + + public : long GetSingleRdsRuleByLabel(const string& s) const + // ************************************************ + { + GenericLocator locator = GetRdsRuleByLabel(s).GetLocator(); + return locator.GetElement(); + } + + public : string GetSingleLayerNameByLabel(const string& s) const + // **************************************************** + { + GenericLocator locator = GetLayerNamesByLabel(s).GetLocator(); + return locator.GetElement(); + } + + public : Layer* GetSingleLayerByLabel(const string& s) const + // ************************************************ + { + LayerLocator locator = GetLayersByLabel(s).GetLocator(); + return locator.GetElement(); + } + + public : double GetSingleRealRuleByLabel(char* prefix, const string& type, char* suffix) const + // ********************************************************************************** + { + return GetSingleRealRuleByLabel(prefix + type + suffix); + } + + public : long GetSingleRdsRuleByLabel(char* prefix, const string& type, char* suffix) const + // ******************************************************************************* + { + return GetSingleRdsRuleByLabel(prefix + type + suffix); + } + + public : string GetSingleLayerNameByLabel(char* prefix, const string& type, const string& suffix) const + // ************************************************************************************ + { + return GetSingleLayerNameByLabel(prefix + type + suffix); + } + + + public : Layer* GetSingleLayerByLabel(char* prefix, const string& type, const string& suffix) const + // *************************************************************************************** + { + return GetSingleLayerByLabel(prefix + type + suffix); + } + +# endif + +// Updators +// ******** + public : void AddRuleByLabel(const string& label, const list& rule){ _label2ruleMap[label]=rule; }; + public : void AddLayersByLabel(const string& label, const list& layers) { _label2layerNameMap[label]=layers; }; + public : void AddElectricalsByLabel(const string& label, const list& electricals) + { _label2electricalMap[label]=electricals; }; + + public : void AddModellingByLabel(const string& label, const int modelling) { _label2modellingMap[label]=modelling; }; + public : void AddSimpleCapaMimByLabel(const string& label, const double capamim) { _label2simplecapamimMap[label]=capamim; }; + +// Operations +// ********** + + // For reusability of software + // *************************** + protected : static DtrAccess* LookUp(const string&); + protected : static void Register(const string& , DtrAccess* ); + + +# if !defined(__DOXYGEN_PROCESSOR__) +// Others +// ****** + public: virtual string _GetTypeName() const {return _TName("DtrAccess");}; + public: virtual string _GetString() const; + public: virtual Record* _GetRecord() const; + + public: map >& _GetLabel2RuleMap() { return _label2ruleMap; }; + public: map >& _GetLabel2LayerNameMap() { return _label2layerNameMap; }; + public: map >& _GetLabel2ElectricalMap() + { return _label2electricalMap; }; + public: map& _GetLabel2ModellingMap() { return _label2modellingMap; }; + public: map& _GetLabel2SimpleCapaMimMap() + { return _label2simplecapamimMap; }; +# endif + +}; + +} + + +//END_NAMESPACE_HURRICANE + + +// **************************************************************************************************** +// Generic functions +// **************************************************************************************************** + +string GetString(const H::DtrAccess&); + + +#endif // HURRICANE_DTRACCESS diff --git a/chamsin/src/dtr/GenericDtrAccess.cpp b/chamsin/src/dtr/GenericDtrAccess.cpp new file mode 100644 index 00000000..875592e4 --- /dev/null +++ b/chamsin/src/dtr/GenericDtrAccess.cpp @@ -0,0 +1,61 @@ +// **************************************************************************************************** +// File: GenericDtrAccess.cpp +// Authors: Wu YiFei +// Date : 21/12/2006 +// **************************************************************************************************** + +#include "DtrAccess.h" +#include "GenericDtrAccess.h" +//#include "DtrAccess.h" + +BEGIN_NAMESPACE_HURRICANE + + +// **************************************************************************************************** +// GenericDtrAccess implementation +// **************************************************************************************************** + +GenericDtrAccess GenericDtrAccess::instance(NULL); + +GenericDtrAccess::GenericDtrAccess(DtrAccess* dtraccess):_dtrAccess(dtraccess) +// ************************************************************************** +{ +} + +void GenericDtrAccess::Instance(DtrAccess* dtraccess) +// ************************************************** +{ + if(!(instance._dtrAccess)) + instance._dtrAccess = dtraccess; +} + +GenericDtrAccess::~GenericDtrAccess() +// ********************************* +{ + if(_dtrAccess) { cout<Delete();} +} + + +string GenericDtrAccess::_GetString() const +// **************************************** +{ + string s("Singleton GenericDtrAccess"); + return s; + +} + +END_NAMESPACE_HURRICANE + + + +// **************************************************************************************************** +// Generic functions +// **************************************************************************************************** + +string GetString(const H::GenericDtrAccess& access) +// ************************************************ +{ + return access._GetString(); +} + + diff --git a/chamsin/src/dtr/GenericDtrAccess.h b/chamsin/src/dtr/GenericDtrAccess.h new file mode 100644 index 00000000..c9922055 --- /dev/null +++ b/chamsin/src/dtr/GenericDtrAccess.h @@ -0,0 +1,77 @@ +// **************************************************************************************************** +// File: GenericDtrAccess.h +// Authors: Wu YiFei +// Date : 21/12/2006 +// **************************************************************************************************** + + +#ifndef HURRICANE_GENERICDTRACCESS +#define HURRICANE_GENERICDTRACCESS + + +//BEGIN_NAMESPACE_HURRICANE + +namespace Hurricane { + +class DtrAccess; + +class GenericDtrAccess { +// ********************* + +// Types +// ***** + +# if !defined(__DOXYGEN_PROCESSOR__) +// Attributes +// ********** + private : static GenericDtrAccess instance; + + private : DtrAccess * _dtrAccess; + + +// Constructors +// ************ + protected : GenericDtrAccess(DtrAccess*); + private : GenericDtrAccess(const GenericDtrAccess&); + private : GenericDtrAccess& operator=(const GenericDtrAccess&); + +# endif + + public : static void Instance(DtrAccess*); + +// Destructors +// *********** + protected : virtual ~GenericDtrAccess(); + +// Accessors +// ********* + + +// Updators +// ******** + +// Operations +// ********** + +# if !defined(__DOXYGEN_PROCESSOR__) +// Others +// ****** + public: virtual string _GetTypeName() const {return _TName("GenericDtrAccess");}; + public: virtual string _GetString() const; +# endif + +}; + + +//END_NAMESPACE_HURRICANE + +} + +// **************************************************************************************************** +// Generic functions +// **************************************************************************************************** + +string GetString(const H::GenericDtrAccess&); + + +#endif // HURRICANE_GENERICDTRACCESS diff --git a/chamsin/src/dtr/ParserDtrGram.hpp b/chamsin/src/dtr/ParserDtrGram.hpp new file mode 100644 index 00000000..2b14211d --- /dev/null +++ b/chamsin/src/dtr/ParserDtrGram.hpp @@ -0,0 +1,72 @@ +/* A Bison parser, made by GNU Bison 2.3. */ + +/* Skeleton interface for Bison's Yacc-like parsers in C + + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 + Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + T_TABLE = 258, + T_TABLE_END = 259, + T_DOUBLE = 260, + T_ID = 261 + }; +#endif +/* Tokens. */ +#define T_TABLE 258 +#define T_TABLE_END 259 +#define T_DOUBLE 260 +#define T_ID 261 + + + + +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +typedef union YYSTYPE +#line 47 "/home/xtof/workspace/hurricane/src/analogic/ParserDtrGram.yy" +{ double _value; + char * _text; + } +/* Line 1489 of yacc.c. */ +#line 65 "/home/xtof/workspace/hurricane/src/analogic/ParserDtrGram.hpp" + YYSTYPE; +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif + +extern YYSTYPE dtrlval; + diff --git a/chamsin/src/dtr/ParserDtrGram.yy b/chamsin/src/dtr/ParserDtrGram.yy new file mode 100644 index 00000000..e10a1b8e --- /dev/null +++ b/chamsin/src/dtr/ParserDtrGram.yy @@ -0,0 +1,202 @@ +%{ +#include +#include +#include +#include + +#include "Error.h" +#include "DtrAccess.h" +using namespace Hurricane; + +#include "ParserDtrGram.hpp" + +extern FILE * dtrin; +extern int dtrlex(void); +extern char * dtrtext; +extern int DTRlineno; + + +// ************************************************************************* +// Static Function&Data +// ************************************************************************* + +static int dtrerror( char * message) +// ********************************* +{ + char * str = (char*)malloc(200*sizeof(char)); + sprintf(str, "ParserDtr():\n %s before %s at line %d.\n", message, dtrtext, DTRlineno); + + string errmsg = str; + + throw Error (errmsg); + + return 0; +} + +static DtrAccess * dtraccess = NULL; + + +static char* table_name = NULL; + +static list doubleList; +static list stringList; + + +%} + +%union { double _value; + char * _text; + }; + +%token T_TABLE T_TABLE_END T_DOUBLE T_ID +%type < _value > T_DOUBLE +%type < _text > T_ID + +%start file + +%% + +file: lines tables + ; + +lines : '\n' + | lines '\n' + ; + +tables: table + |tables table + ; + +table: T_TABLE T_ID '\n' + { table_name = $2; } + items T_TABLE_END lines + ; + +items: item + |items item + ; + +item: T_ID elems '\n' + { + + string label = $1; + delete $1; + + if( strcmp(table_name, "RULES")==0 ) { + if ( doubleList.empty() ) { + + dtrerror("ParserDtr detect no data in a line of table RULES : Please check it"); + } + + list::iterator i = doubleList.begin() + , j = doubleList.end(); + + while(i!=j) { + (dtraccess->_GetLabel2RuleMap())[label].push_back(*i); + i++; + } + } + else if( strcmp(table_name, "LAYERS")==0 ) { + if ( stringList.empty() ) { + dtrerror("ParserDtr detect no data in a line of table LAYERS : Please check it"); + } + + list::iterator i = stringList.begin() + , j = stringList.end(); + + while(i!=j) { + (dtraccess->_GetLabel2LayerNameMap())[label].push_back(*i);; + i++; + } + } + else if( strcmp(table_name, "ELECTRICAL") == 0 ) { + if ( doubleList.empty() ) { + dtrerror("ParserDtr detect no data in a line of table ELECTRICAL : Please check it"); + } + + list::iterator i = doubleList.begin() + , j = doubleList.end(); + + while(i!=j) { + (dtraccess->_GetLabel2ElectricalMap())[label].push_back(*i); + i++; + } + } + else if( strcmp(table_name, "MODELLING") == 0 ) { + if ( (doubleList.empty()) || (doubleList.size()!=1) ) { + dtrerror("ParserDtr detect no data or mutli datas in a line of table MODELLING: Please check it"); + } + + list::iterator i = doubleList.begin(); + + (dtraccess->_GetLabel2ModellingMap())[label] = (int)(*i); + } + + else if( strcmp(table_name, "SIMPLE_CAPA_MIM")==0 ) { + if( (doubleList.empty()) || (doubleList.size()!=1) ) { + dtrerror("ParserDtr detect no data or mutli datas in a line of table SIMPLE_CAPA_MIM : Please check it"); + } + + list::iterator i = doubleList.begin(); + (dtraccess->_GetLabel2SimpleCapaMimMap())[label] = (*i); + + } + + else { + throw Error("ParserDtr detect unknown table name " + string(table_name)); + } + + // Vide temporary list + // ******************** + doubleList.clear(); + stringList.clear(); + + } + | lines + ; + +elems: elem + |elems elem + ; + +elem: T_ID + { + if(!(doubleList.empty())) { + + dtrerror("ParserDtr detect incompatibles datas : Please check it"); + } + + stringList.push_back(string($1)); + delete $1; + } + | T_DOUBLE + { + if(!(stringList.empty())) { + + dtrerror("ParserDtr detect incompatibles datas : Please check it"); + } + + doubleList.push_back($1); + } + ; + +%% + +// ************************************************************************* +// Generic Function +// ************************************************************************* + +void ParseDtr(const char* dtrfilename, DtrAccess* dtr) +// *************************************************** +{ + dtraccess = dtr; + + if((dtrin=fopen(dtrfilename, "r"))==NULL) + { + throw Error("Can't open dtr file : " + string(dtrfilename)); + } + + dtrparse(); + +} + diff --git a/chamsin/src/dtr/ParserDtrScan.ll b/chamsin/src/dtr/ParserDtrScan.ll new file mode 100644 index 00000000..8e68e0fa --- /dev/null +++ b/chamsin/src/dtr/ParserDtrScan.ll @@ -0,0 +1,27 @@ +%{ + +#include +#include +#include +using namespace std; + +#include "ParserDtrGram.hpp" + +#define YY_NO_UNPUT + +int DTRlineno = 1; + +%} +%% +([ \t]+|#.*) {/* nothing to do */} +\n { DTRlineno++; return '\n'; } +TABLE_1DM { return T_TABLE;} +END_TABLE_1DM { return T_TABLE_END;} +[1-9]?[0-9]*(\.)?[0-9]+ { dtrlval._value=atof(dtrtext); return T_DOUBLE;} +[a-zA-Z0-9]+(_?[a-zA-Z0-9]+)* {dtrlval._text=strdup(dtrtext); return T_ID;} +. { return *dtrtext; } + +%% + +int dtrwrap() {return 1;} + diff --git a/chamsin/src/tests/AnalogicTest.cpp b/chamsin/src/tests/AnalogicTest.cpp new file mode 100644 index 00000000..517f69e5 --- /dev/null +++ b/chamsin/src/tests/AnalogicTest.cpp @@ -0,0 +1,17 @@ +#include + +#include "DataBase.h" +#include "Library.h" +USING_NAMESPACE_HURRICANE + +#include "TrMos.h" +using namespace DEVICE; + +int main() { + cout << "simple analogic test" << endl; + DataBase* db = DataBase::Create(); + Library* rootLibrary = Library::Create(db, Name("RootLibrary")); + Library* workLibrary = Library::Create(rootLibrary, Name("WorkLibrary")); + TrMos* trmos = TrMos::Create(workLibrary, Name("MosTr")); + return 1; +} diff --git a/chamsin/src/tests/CMakeLists.txt b/chamsin/src/tests/CMakeLists.txt new file mode 100644 index 00000000..973567fb --- /dev/null +++ b/chamsin/src/tests/CMakeLists.txt @@ -0,0 +1,6 @@ +INCLUDE_DIRECTORIES(${HURRICANE_INCLUDE_DIR} +${CHAMSIN_SOURCE_DIR}/src/analogic ${CHAMSIN_SOURCE_DIR}/src/device) + +ADD_EXECUTABLE(atest AnalogicTest.cpp) + +TARGET_LINK_LIBRARIES(atest analogic device ${HURRICANE_LIBRARIES})