TORC: torc/examples/CollatzMapper.cpp Source File

00001 // Torc - Copyright 2011 University of Southern California.  All Rights Reserved.
00002 // $HeadURL:$
00003 // $Id:$
00004 
00005 // This program is free software: you can redistribute it and/or modify it under the terms of the 
00006 // GNU General Public License as published by the Free Software Foundation, either version 3 of the 
00007 // License, or (at your option) any later version.
00008 // 
00009 // This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
00010 // without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See 
00011 // the GNU General Public License for more details.
00012 // 
00013 // You should have received a copy of the GNU General Public License along with this program.  If 
00014 // not, see <http://www.gnu.org/licenses/>.
00015 
00016 /// \file
00017 /// \brief Source for the generic object model unit test.
00018 
00019 #include <boost/test/unit_test.hpp>
00020 #include "torc/physical/Factory.hpp"
00021 #include "torc/physical/XdlExporter.hpp"
00022 #include <iostream>
00023 #include <sstream>
00024 #include <fstream>
00025 #include "torc/generic/om/ObjectFactory.hpp"
00026 #include "torc/generic/om/ScalarNet.hpp"
00027 #include "torc/generic/parser/Linker.hpp"
00028 #include "torc/generic/parser/ParserOptions.hpp"
00029 #include "torc/generic/parser/EdifParser.hpp"
00030 #include "torc/generic/util/MessageTable.hpp"
00031 #include <boost/regex.hpp>
00032 #include <boost/filesystem.hpp>
00033 
00034 //#include "torc/examples/PrintInfo.hpp"
00035 
00036 
00037 //using namespace torc::generic;
00038 
00039 template <typename T> class VisitorRecursor {
00040 public:
00041     VisitorRecursor(T& inVisitor) : mVisitor(inVisitor) {}
00042     template <typename U> void operator() (const boost::shared_ptr<U>& inVisited) 
00043         const throw(torc::generic::Error) {
00044         try {
00045             inVisited->accept(mVisitor);
00046         }
00047         catch(torc::generic::Error& e) {
00048             e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
00049             throw;
00050         }
00051     }
00052 protected:
00053     mutable T& mVisitor;
00054 };
00055 
00056 std::string getPropertyString(const std::string& inPropertyName, 
00057     torc::generic::PropertyContainer& inPropertyContainer);
00058 std::string getPropertyString(const std::string& inPropertyName, 
00059     torc::generic::PropertyContainer& inPropertyContainer) {
00060     const boost::shared_ptr<torc::generic::Property> propertyPtr 
00061         = inPropertyContainer.getProperty(inPropertyName);
00062     return propertyPtr->getValue().get<std::string>();
00063 }
00064 
00065 
00066 class A {};
00067 class Mapper :
00068     public torc::generic::Library::Visitor,
00069     public torc::generic::Cell::Visitor,
00070     public torc::generic::View::Visitor,
00071 //  public torc::generic::ScalarPort::Visitor,
00072 //  public torc::generic::ScalarPortReference::Visitor,
00073 //  public torc::generic::VectorPort::Visitor,
00074 //  public torc::generic::VectorPortReference::Visitor,
00075 //  public torc::generic::PortBundle::Visitor,
00076 //  public torc::generic::PortBundleReference::Visitor,
00077     public torc::generic::SingleInstance::Visitor,
00078     public torc::generic::ScalarNet::Visitor, 
00079 //  public torc::generic::NetBundle::Visitor,
00080 //  public torc::generic::VectorNet::Visitor,
00081 //  public torc::generic::VectorNetBit::Visitor,
00082 //  public torc::generic::VectorPortBit::Visitor,
00083 //  public torc::generic::VectorPortBitReference::Visitor,
00084 //  public torc::generic::InstanceArray::Visitor,
00085 //  public torc::generic::InstanceArrayMember::Visitor,
00086 //  public torc::generic::ParameterArrayElement::Visitor,
00087 //  public torc::generic::ParameterArray::Visitor,
00088 //  public torc::generic::Property::Visitor,
00089 //  public torc::generic::SingleParameter::Visitor,
00090     public A
00091     {
00092 public:
00093     void visit(torc::generic::Root& inRoot) throw(torc::generic::Error) {
00094         std::cout << "visited the root" << std::endl;
00095         VisitorRecursor<Mapper> recursor(*this);
00096         inRoot.applyOnAllLibraries(recursor);
00097     }
00098     void visit(torc::generic::Library& inLibrary) throw(torc::generic::Error) {
00099         std::cout << "visited library " << inLibrary.getName() << std::endl;
00100         VisitorRecursor<Mapper> recursor(*this);
00101         inLibrary.applyOnAllCells(recursor);
00102     }
00103     void visit(torc::generic::Cell& inCell) throw(torc::generic::Error) {
00104         std::cout << "    visited cell " << inCell.getName() << std::endl;
00105         mDesignPtr = torc::physical::Factory::newDesignPtr(inCell.getName(), "experimental", 
00106             "package", "speed", "v3.2");
00107         VisitorRecursor<Mapper> recursor(*this);
00108         inCell.applyOnAllViews(recursor);
00109     }
00110     void visit(torc::generic::View& inView) throw(torc::generic::Error) {
00111         std::cout << "        visited view " << inView.getName() << std::endl;
00112         VisitorRecursor<Mapper> recursor(*this);
00113         inView.applyOnAllInstances(recursor);
00114         inView.applyOnAllNets(recursor);
00115     }
00116     void visit(torc::generic::SingleInstance& inInstance) throw(torc::generic::Error) {
00117         std::cout << "            visited instance " << inInstance.getName() << std::endl;
00118         const boost::shared_ptr<torc::generic::View> masterViewPtr = inInstance.getMaster();
00119         const boost::shared_ptr<torc::generic::Cell> masterCellPtr = masterViewPtr->getParent();
00120         std::string masterName = masterCellPtr->getName();
00121         ELogicType masterType = mLogicTypeMap[masterName];
00122         std::string type;
00123         std::string setting;
00124         std::string mask;
00125         switch(masterType) {
00126         case eLogicTypeGnd:
00127             type = "LUT";
00128             setting = "MASK";
00129             mask = "0000";
00130             break;
00131         case eLogicTypeVcc:
00132             type = "LUT";
00133             setting = "MASK";
00134             mask = "FFFF";
00135             break;
00136         case eLogicTypeLut1:
00137         case eLogicTypeLut2:
00138         case eLogicTypeLut3:
00139         case eLogicTypeLut4:
00140             type = "LUT";
00141             setting = "MASK";
00142             mask = getPropertyString("INIT", inInstance);
00143             if(mask.length() >= 2 && mask[0] == '"' && mask[mask.length() - 1] == '"') {
00144                 mask.erase(mask.end() - 1, mask.end());
00145                 mask.erase(mask.begin(), mask.begin() + 1);
00146             }
00147             switch(masterType) {
00148             case eLogicTypeLut1: mask = (mask[0] & 1) ? "F" : "0";
00149             case eLogicTypeLut2: mask += mask;
00150             case eLogicTypeLut3: mask += mask;
00151             default: break;
00152             }
00153             break;
00154         case eLogicTypeFF:
00155             type = "FF";
00156             setting = "INIT";
00157             mask = getPropertyString("INIT", inInstance);
00158             if(mask.length() >= 2 && mask[0] == '"' && mask[mask.length() - 1] == '"') {
00159                 mask.erase(mask.end() - 1, mask.end());
00160                 mask.erase(mask.begin(), mask.begin() + 1);
00161             }
00162             break;
00163         case eLogicTypeUnknown:
00164             type = "";
00165             setting = "";
00166             mask = "";
00167             std::cerr << "Unknown logic type " << masterName << std::endl;
00168             break;
00169         }
00170         mCurrentInstancePtr = torc::physical::Factory::newInstancePtr(inInstance.getName(), 
00171             type, "", "");
00172         if(mask.length() != 0) mCurrentInstancePtr->setConfig(setting, "", mask);
00173         mDesignPtr->addInstance(mCurrentInstancePtr);
00174     //  VisitorRecursor<Mapper> recursor(*this);
00175     //  inInstance.applyOnAllViews(recursor);
00176     }
00177     void visit(torc::generic::ScalarNet& inNet) throw(torc::generic::Error) {
00178         std::cout << "            visited net " << inNet.getName() << std::endl;
00179         mCurrentNetPtr = torc::physical::Factory::newNetPtr(inNet.getName(), 
00180             torc::physical::eNetTypeNormal);
00181         mDesignPtr->addNet(mCurrentNetPtr);
00182     //  VisitorRecursor<Mapper> recursor(*this);
00183     //  inNet.applyOnAllViews(recursor);
00184     }
00185 
00186     Mapper(void) {
00187         mLogicTypeMap["GND"] = eLogicTypeGnd;
00188         mLogicTypeMap["VCC"] = eLogicTypeVcc;
00189         mLogicTypeMap["FDRE"] = eLogicTypeFF;
00190         mLogicTypeMap["LUT1"] = eLogicTypeLut1;
00191         mLogicTypeMap["LUT2"] = eLogicTypeLut2;
00192         mLogicTypeMap["LUT3"] = eLogicTypeLut3;
00193         mLogicTypeMap["LUT4"] = eLogicTypeLut4;
00194     }
00195     ~Mapper() throw() {}
00196     torc::physical::DesignSharedPtr& getDesignPtr(void) { return mDesignPtr; }
00197 protected:
00198     enum ELogicType { eLogicTypeUnknown, eLogicTypeGnd, eLogicTypeVcc, eLogicTypeFF, 
00199         eLogicTypeLut1, eLogicTypeLut2, eLogicTypeLut3, eLogicTypeLut4 };
00200     torc::physical::DesignSharedPtr mDesignPtr;
00201     torc::physical::InstanceSharedPtr mCurrentInstancePtr;
00202     torc::physical::NetSharedPtr mCurrentNetPtr;
00203     std::map<std::string, ELogicType> mLogicTypeMap;
00204 };
00205 
00206 
00207 
00208 /*
00209     // For Root
00210     void
00211     visit( Root &root ) throw(Error)
00212     try
00213     {
00214         VisitorApplier<PrintInfo> applier( *this );
00215         mOut << "Root name      : " << root.getName() << std::endl;
00216         mOut << "  Edif version : " << (int32_t)root.getVersion().mFirst << " " 
00217                                          << (int32_t)root.getVersion().mSecond << " "
00218                                          << (int32_t)root.getVersion().mThird << " " << std::endl;
00219         mOut << "  Edif level   : " << root.getLevel() << std::endl;
00220         root.applyOnAllLibraries( applier );
00221     }
00222     catch( Error &e )
00223     {
00224         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00225         throw;
00226     }
00227 
00228     // For Library
00229     void
00230     visit( Library &library ) throw(Error)
00231     try
00232     {
00233         VisitorApplier<PrintInfo> applier( *this );
00234         mOut << "    Library name : " << library.getName() << std::endl;
00235         mOut << "      IsExtern   : " << library.getIsExtern() << std::endl;
00236         mOut << "      Edif level : " << library.getLevel() << std::endl;
00237         library.applyOnAllCells( applier );
00238     }
00239     catch( Error &e )
00240     {
00241         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00242         throw;
00243     }
00244 
00245     // For Cell
00246     void
00247     visit( Cell &cell ) throw(Error)
00248     try
00249     {
00250         mOut << "        Cell name   : " << cell.getName() << std::endl;
00251         mOut << "          Cell type : " << cell.getType() << std::endl;
00252         mOut << "          IsExtern  : " << cell.getIsExtern() << std::endl;
00253         VisitorApplier<PrintInfo> applier( *this );
00254         cell.applyOnAllViews( applier );
00255     }
00256     catch( Error &e )
00257     {
00258         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00259         throw;
00260     }
00261 
00262     // For View
00263     void
00264     visit( View &view ) throw(Error)
00265     try
00266     {
00267         VisitorApplier<PrintInfo> applier( *this );
00268         mOut << "            View name   : " << view.getName().c_str() << std::endl;
00269         mOut << "              View type : " << view.getType() << std::endl;
00270         mOut << "              IsExtern  : " << view.getIsExtern() << std::endl;
00271         view.applyOnAllInstances( applier );
00272         view.applyOnAllNets( applier );
00273         view.applyOnAllPorts( applier );
00274     }
00275     catch( Error &e )
00276     {
00277         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00278         throw;
00279     }
00280 
00281     // For ScalarPort
00282     void
00283     visit( ScalarPort &port ) throw(Error)
00284     try
00285     {
00286         VisitorApplier<PrintInfo> applier( *this );
00287         mOut << "                Port name           : " << port.getName() << std::endl;
00288         mOut << "                  Direction         : " << port.getDirection() << std::endl;
00289         mOut << "                  Size              : " << port.getSize() << std::endl;
00290     }
00291     catch( Error &e )
00292     {
00293         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00294         throw;
00295     }
00296 
00297     // For ScalarPortReference
00298     void
00299     visit( ScalarPortReference &portRef ) throw(Error)
00300     try
00301     {
00302         VisitorApplier<PrintInfo> applier( *this );
00303         mOut << "                  Port ref name     : " << portRef.getName() << std::endl;
00304         mOut << "                  Instance ref name : " << portRef.getParent()->getName() 
00305                                                               << std::endl;
00306     }
00307     catch( Error &e )
00308     {
00309         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00310         throw;
00311     }
00312 
00313     // For VectorPort
00314     void
00315     visit( VectorPort &port ) throw(Error)
00316     try
00317     {
00318         VisitorApplier<PrintInfo> applier( *this );
00319         mOut << "                VectorPort name : " << port.getName() << std::endl;
00320         mOut << "                  Direction     : " << port.getDirection() << std::endl;
00321         mOut << "                  Size          : " << port.getSize() << std::endl;
00322     }
00323     catch( Error &e )
00324     {
00325         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00326         throw;
00327     }   
00328 
00329     // For VectorPortReference
00330     void
00331     visit( VectorPortReference &portRef ) throw(Error)
00332     try
00333     {
00334         VisitorApplier<PrintInfo> applier( *this );
00335         mOut << "                VectorPort ref name : " << portRef.getName() << std::endl;
00336     }
00337     catch( Error &e )
00338     {
00339         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00340         throw;
00341     }
00342 
00343     // For VectorPortBit
00344     void
00345     visit( VectorPortBit &bit ) throw(Error)
00346     try
00347     {
00348         VisitorApplier<PrintInfo> applier( *this );
00349         mOut << "           VectorPortBit name : " << bit.getName() << std::endl;
00350         mOut << "             Size             : " << bit.getSize() << std::endl;
00351     }
00352     catch( Error &e )
00353     {
00354         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00355         throw;
00356     }
00357 
00358     // For VectorPortBitReference
00359     void
00360     visit( VectorPortBitReference &bitRef ) throw(Error)
00361     try
00362     {
00363         VisitorApplier<PrintInfo> applier( *this );
00364         mOut << "           VectorPortBit ref name : " << bitRef.getName() << std::endl;
00365         mOut << "             Size                 : " << bitRef.getSize() << std::endl;
00366     }
00367     catch( Error &e )
00368     {
00369         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00370         throw;
00371     }
00372     
00373     // For PortBundle
00374     void
00375     visit( PortBundle &port ) throw(Error)
00376     try
00377     {
00378         VisitorApplier<PrintInfo> applier( *this );
00379         mOut << "                PortBundle name : " << port.getName() << std::endl;
00380         mOut << "                  Size          : " << port.getSize() << std::endl;
00381         port.applyOnAllChildren( applier );
00382     }
00383     catch( Error &e )
00384     {
00385         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00386         throw;
00387     }
00388 
00389     // For PortBundleReference
00390     void
00391     visit( PortBundleReference &portRef ) throw(Error)
00392     try
00393     {
00394         VisitorApplier<PrintInfo> applier( *this );
00395         mOut << "                PortBundle Ref name : " << portRef.getName() << std::endl;
00396         mOut << "                Master port name    : " << portRef.getMaster()->getName() 
00397                                                               << std::endl;
00398         portRef.applyOnAllChildren( applier );
00399     }
00400     catch( Error &e )
00401     {
00402         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00403         throw;
00404     }
00405 
00406     // For SingleInstance
00407     void
00408     visit( SingleInstance &instance ) throw(Error)
00409     try
00410     {
00411         VisitorApplier<PrintInfo> applier( *this );
00412         mOut << "                Instance name      : " << instance.getName() << std::endl;
00413         mOut << "                  View ref name    : " << instance.getMaster()->getName() 
00414                                                              << std::endl;
00415         mOut << "                  Cell ref name    : " << instance.getMaster()->getParent()->
00416                                                                 getName() << std::endl;
00417         mOut << "                  Library ref name : " << instance.getMaster()->getParent()->
00418                                                                  getParent()->getName()<< std::endl;
00419     }
00420     catch( Error &e )
00421     {
00422         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00423         throw;
00424     }
00425 
00426     // For ScalarNet
00427     void
00428     visit( ScalarNet &net ) throw(Error)
00429     try
00430     {
00431         VisitorApplier<PrintInfo> applier( *this );
00432         mOut << "                Net name            : " << net.getName() << std::endl;
00433         net.applyOnAllSubnets( applier );
00434         net.applyOnAllConnectedPorts( applier );
00435         net.applyOnAllConnectedPortRefs( applier );
00436     }
00437     catch( Error &e )
00438     {
00439         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00440         throw;
00441     }
00442 
00443     // For NetBundle
00444     void
00445     visit( NetBundle &net ) throw(Error)
00446     try
00447     {
00448         VisitorApplier<PrintInfo> applier( *this );
00449         mOut << "                Net Bundle name    : " << net.getName() << std::endl;
00450         mOut << "                  Size             : " << net.getSize() << std::endl;
00451         net.applyOnAllSubnets( applier );
00452         net.applyOnAllChildren( applier );
00453         net.applyOnAllConnectedPorts( applier );
00454         net.applyOnAllConnectedPortRefs( applier );
00455     }
00456     catch( Error &e )
00457     {
00458         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00459         throw;
00460     }
00461 
00462     // For VectorNet
00463     void
00464     visit( VectorNet &net ) throw(Error)
00465     try
00466     {
00467         VisitorApplier<PrintInfo> applier( *this );
00468         mOut << "                VectorNet name : " << net.getName() << std::endl;
00469         mOut << "                  Size          : " << net.getSize() << std::endl;
00470         net.applyOnAllSubnets( applier );
00471         net.applyOnAllConnectedPorts( applier );
00472         net.applyOnAllConnectedPortRefs( applier );
00473     }
00474     catch( Error &e )
00475     {
00476         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00477         throw;
00478     }
00479 
00480     // For VectorNetBit
00481     void
00482     visit( VectorNetBit &net ) throw(Error)
00483     try
00484     {
00485         VisitorApplier<PrintInfo> applier( *this );
00486         mOut << "                VectorNetBit name : " << net.getName() << std::endl;
00487         mOut << "                  Size            : " << net.getSize() << std::endl;
00488         net.applyOnAllSubnets( applier );
00489         net.applyOnAllConnectedPorts( applier );
00490         net.applyOnAllConnectedPortRefs( applier );
00491     }
00492     catch( Error &e )
00493     {
00494         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00495         throw;
00496     }
00497 
00498     // For InstanceArray
00499     void
00500     visit( InstanceArray &instanceArray ) throw(Error)
00501     try
00502     {
00503         VisitorApplier<PrintInfo> applier( *this );
00504         mOut << "                 Instance array name : " << instanceArray.getName() << std::endl;
00505         mOut << "                   Size              : " << instanceArray.getSize() << std::endl;
00506         instanceArray.applyOnAllBits( applier );
00507     }
00508     catch( Error &e )
00509     {
00510         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00511         throw;
00512     }
00513 
00514     // For InstanceArrayMember
00515     void
00516     visit( InstanceArrayMember &instance ) throw(Error)
00517     try
00518     {
00519         VisitorApplier<PrintInfo> applier( *this );
00520         mOut << "                  Instance name      : " << instance.getName() << std::endl;
00521         mOut << "                    View ref name    : " << instance.getMaster()->getName() 
00522                                                              << std::endl;
00523         mOut << "                    Cell ref name    : " << instance.getMaster()->getParent()->
00524                                                                 getName() << std::endl;
00525         mOut << "                    Library ref name : " << instance.getMaster()->getParent()->
00526                                                                  getParent()->getName()<< std::endl;
00527     }
00528     catch( Error &e )
00529     {
00530         e.setCurrentLocation( __FUNCTION__, __FILE__, __LINE__ );
00531         throw;
00532     }
00533 
00534 };
00535 */
00536 
00537 
00538 
00539 
00540 
00541 
00542 
00543 
00544 
00545 
00546 
00547 
00548 
00549 
00550 
00551 
00552 
00553 
00554 
00555 
00556 namespace torc {
00557 namespace generic {
00558 
00559 BOOST_AUTO_TEST_SUITE(generic)
00560 
00561 /// \brief Unit test for the generic Collatz mapper.
00562 BOOST_AUTO_TEST_CASE(generic_collatz_mapper) {
00563 
00564     // create string streams for both the generated and parsed EDIF
00565     std::stringstream generated;
00566     std::stringstream parsed;
00567 
00568     boost::filesystem::path collatzEdif = "collatz1.edf";
00569     try {
00570         // parse the EDIF
00571         std::cout << "Parsing " << collatzEdif << " ...  ";
00572         boost::shared_ptr<ObjectFactory> factoryPtr(new ObjectFactory());
00573         boost::shared_ptr<Root> rootPtr;
00574         factoryPtr->create(rootPtr);
00575         boost::shared_ptr<Linker> linkerPtr(new Linker(rootPtr));
00576         ParserOptions options;
00577         EdifParser parser;
00578         parser.parse(collatzEdif.string(), rootPtr, linkerPtr, factoryPtr, options);
00579         std::cout << "done." << std::endl;
00580 
00581         // map to XDL
00582         std::cout << "Mapping ...  " << std::endl;
00583         boost::shared_ptr<Library> workLibraryPtr = rootPtr->findLibrary("work");
00584         Mapper mapper;
00585         workLibraryPtr->accept(mapper);
00586         torc::physical::DesignSharedPtr designPtr = mapper.getDesignPtr();
00587 
00588         // export the XDL design
00589         std::string outFileName = "collatz1.xdl";
00590         std::fstream xdlExport(outFileName.c_str(), std::ios_base::out);
00591         torc::physical::XdlExporter fileExporter(xdlExport);
00592         fileExporter(designPtr);
00593     } catch(Error& e) {
00594         std::cerr << MessageTable::instance()->getMessage(e.getErrorMessageId()) << std::endl;
00595         const std::vector<Error::StackFrameInfo> &stack = e.getStackTrace();
00596         for(std::vector<Error::StackFrameInfo>::const_iterator it = stack.begin(); 
00597             it != stack.end(); it++) {
00598             std::cerr << "    " << (*it).getFunction() << "() [" << (*it).getFile() << ":" 
00599                 << (*it).getLine() << "]" << std::endl;
00600         }
00601     }
00602 
00603     // verify that the generated and parsed outputs are identical
00604     BOOST_CHECK_EQUAL(generated.str(), parsed.str());
00605 
00606 }
00607 
00608 BOOST_AUTO_TEST_SUITE_END()
00609 
00610 } // namespace generic
00611 } // namespace torc