TORC: torc/router/UnrouterUnitTest.cpp Source File

00001 // Torc - Copyright 2011 University of Southern California.  All Rights Reserved.
00002 // $HeadURL: https://torc-isi.svn.sourceforge.net/svnroot/torc-isi/branches/staging/0.9/src/torc/router/UnrouterUnitTest.cpp $
00003 // $Id: UnrouterUnitTest.cpp 1 2011-02-25 22:11:16Z nsteiner $
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 Regression test for the Unrouter class.
00018 
00019 #include <boost/test/unit_test.hpp>
00020 #include "torc/architecture/XdlImporter.hpp"
00021 #include "torc/architecture/DDB.hpp"
00022 #include "torc/router/Trace.hpp"
00023 #include <map>
00024 
00025 //#include <boost/filesystem/convenience.hpp>
00026 #include "torc/common/DirectoryTree.hpp"
00027 //#include "torc/physical/Factory.hpp"
00028 //#include "torc/physical/XdlExporter.hpp"
00029 #include "torc/physical/OutputStreamHelpers.hpp"
00030 #include "torc/common/TestHelpers.hpp"
00031 #include <fstream>
00032 
00033 namespace torc {
00034 namespace router {
00035 
00036 struct TracerTestFixture {
00037     int& argc;
00038     char**&argv;
00039     torc::common::DirectoryTree directoryTree;
00040     boost::filesystem::path testPath;
00041     boost::filesystem::path referencePath;
00042     std::fstream fileStream;
00043     architecture::XdlImporter importer;
00044     torc::physical::DesignSharedPtr designPtr;
00045     architecture::DDB* ddbPtr;
00046     std::map<architecture::Tilewire, int> sinkCounts;
00047     architecture::Tilewire sourceTw;
00048     architecture::Tilewire sourceTw2;
00049     
00050     TracerTestFixture() : argc(boost::unit_test::framework::master_test_suite().argc),
00051             argv(boost::unit_test::framework::master_test_suite().argv),
00052             directoryTree(argv[0]),
00053             testPath(directoryTree.getExecutablePath() / "torc" / "router"),
00054             referencePath(testPath / "TracerUnitTest.xdl"),
00055             fileStream(referencePath.string().c_str())
00056             //importer(fileStream, referencePath.string()),
00057             //ddbPtr(importer.releaseDDBPtr()),
00058             //tracer(*ddbPtr)
00059     {
00060         BOOST_REQUIRE(argc >= 1);
00061         BOOST_REQUIRE(fileStream.good());
00062         importer(fileStream, referencePath.string());
00063         designPtr = importer.getDesignPtr();
00064         BOOST_REQUIRE(designPtr.get() != 0);
00065         ddbPtr = importer.releaseDDBPtr();
00066         BOOST_REQUIRE(ddbPtr != 0);
00067         //tracer(*ddbPtr);
00068         
00069         BOOST_CHECK_EQUAL(designPtr->getNetCount(), 1u);
00070         BOOST_CHECK_EQUAL(ddbPtr->getArcUsage().getArcUsageCount(), 53u);
00071         //BOOST_TEST_MESSAGE("Should the pip count really include the routethrough?");
00072         //BOOST_CHECK_EQUAL(ddbPtr->getArcUsage().getArcUsageCount(), 54u);
00073         
00074         sourceTw = ddbPtr->lookupTilewire("CLBLL_X16Y39", "L_C");
00075         sourceTw2 = ddbPtr->lookupTilewire("CLBLL_X16Y39", "L_CMUX");
00076         
00077         architecture::Tilewire tempTw;
00078         tempTw = ddbPtr->lookupTilewire("CLBLM_X13Y42", "L_D1");
00079         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00080         tempTw = ddbPtr->lookupTilewire("CLBLM_X18Y36", "L_A1");
00081         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00082         tempTw = ddbPtr->lookupTilewire("CLBLM_X18Y36", "L_D3");
00083         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00084         tempTw = ddbPtr->lookupTilewire("CLBLM_X13Y36", "M_B6");
00085         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00086         tempTw = ddbPtr->lookupTilewire("CLBLM_X13Y36", "M_C5");
00087         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00088         tempTw = ddbPtr->lookupTilewire("CLBLM_X13Y36", "M_D3");
00089         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00090         tempTw = ddbPtr->lookupTilewire("CLBLM_X13Y42", "L_D2");
00091         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00092         tempTw = ddbPtr->lookupTilewire("CLBLL_X16Y42", "L_A1");
00093         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00094         tempTw = ddbPtr->lookupTilewire("CLBLL_X16Y42", "L_CE");
00095         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00096         tempTw = ddbPtr->lookupTilewire("CLBLM_X18Y40", "L_BX");
00097         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00098         tempTw = ddbPtr->lookupTilewire("CLBLM_X18Y40", "L_B4");
00099         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00100     }
00101     ~TracerTestFixture() {
00102         delete ddbPtr;
00103     }
00104 };
00105 
00106 BOOST_FIXTURE_TEST_SUITE(router, TracerTestFixture)
00107 /*
00108 /// \brief Unit test for the traceSource function in the Tracer.
00109 BOOST_AUTO_TEST_CASE(router_unrouter_tracetosinks) {
00110     Tracer tracer(*ddbPtr);
00111     RouteTreeNode* rtn;
00112     RouteTreeNode* rtn2;
00113     rtn = tracer.traceToSinks(sourceTw);
00114     rtn2 = tracer.traceToSinks(sourceTw2);
00115     rtn->normalizeDepth();
00116     rtn2->normalizeDepth();
00117     std::vector<RouteTreeNode*> vec;
00118     std::vector<RouteTreeNode*> wavefront;
00119     //vec.push_back(rtn);
00120     //vec.push_back(rtn2);
00121     wavefront.push_back(rtn);
00122     wavefront.push_back(rtn2);
00123     while (wavefront.size() != 0) {
00124         RouteTreeNode* node = wavefront.back();
00125         wavefront.pop_back();
00126         vec.push_back(node);
00127         for (unsigned int i = 0; i < node->getNumChildren(); i++) {
00128             wavefront.push_back(node->getChild(i));
00129         }
00130     }
00131     std::map<architecture::Tilewire, int>::iterator it;
00132     for (unsigned int i = 0 ; i < vec.size(); i++) {
00133         it = sinkCounts.find(vec[i]->getSinkTilewire());
00134         if (it != sinkCounts.end()) {
00135             it->second++;
00136         }
00137     }
00138     BOOST_TEST_MESSAGE(*ddbPtr);
00139     for (it = sinkCounts.begin(); it != sinkCounts.end(); it++) {
00140         BOOST_TEST_MESSAGE("Checking sink " << it->first);
00141         BOOST_CHECK(it->second == 1);
00142     }
00143 }
00144 
00145 /// \brief Unit test for the traceBranch function in the Tracer.
00146 BOOST_AUTO_TEST_CASE(router_unrouter_tracebranch) {
00147     Tracer tracer(*ddbPtr);
00148     architecture::Tilewire branchSource = ddbPtr->lookupTilewire("INT_X14Y37", "SL2END0");
00149     RouteTreeNode* rtn;
00150     rtn = tracer.traceBranch(branchSource);
00151     rtn->normalizeDepth();
00152     std::vector<RouteTreeNode*> vec;
00153     std::vector<RouteTreeNode*> wavefront;
00154     vec.push_back(rtn);
00155     wavefront.push_back(rtn);
00156     while (wavefront.size() != 0) {
00157         RouteTreeNode* node = wavefront.back();
00158         wavefront.pop_back();
00159         vec.push_back(node);
00160         for (unsigned int i = 0; i < node->getNumChildren(); i++) {
00161             wavefront.push_back(node->getChild(i));
00162         }
00163     }
00164     std::map<architecture::Tilewire, int>::iterator it;
00165     for (unsigned int i = 0 ; i < vec.size(); i++) {
00166 std::cout << "NODE: " << vec[i]->getArc() << std::endl;
00167         it = sinkCounts.find(vec[i]->getSinkTilewire());
00168         if (it != sinkCounts.end()) {
00169             it->second++;
00170         }
00171     }
00172     BOOST_TEST_MESSAGE(*ddbPtr);
00173     for (it = sinkCounts.begin(); it != sinkCounts.end(); it++) {
00174         BOOST_TEST_MESSAGE("Checking sink " << it->first);
00175         BOOST_CHECK_EQUAL(it->second, 1);
00176         //std::cout << it->first << " " << it->second << std::endl;
00177     }
00178 }
00179 
00180 /// \brief Unit test for the traceSink function in the Tracer.
00181 BOOST_AUTO_TEST_CASE(router_unrouter_tracesink) {
00182 }
00183 
00184 /// \brief Unit test for the traceFull function in the Tracer.
00185 BOOST_AUTO_TEST_CASE(router_unrouter_tracefull) {
00186     Tracer tracer(*ddbPtr);
00187     architecture::Tilewire branchSource = ddbPtr->lookupTilewire("INT_X14Y37", "SL2END0");
00188 std::cout << *ddbPtr << "START: " << branchSource << std::endl;
00189     RouteTreeNode* rtn;
00190     rtn = tracer.traceFull(branchSource);
00191     rtn->normalizeDepth();
00192     rtn = (RouteTreeNode*)rtn->getTop();
00193     std::vector<RouteTreeNode*> vec;
00194     std::vector<RouteTreeNode*> wavefront;
00195     wavefront.push_back(rtn);
00196     while (wavefront.size() != 0) {
00197         RouteTreeNode* node = wavefront.back();
00198         wavefront.pop_back();
00199         vec.push_back(node);
00200         for (unsigned int i = 0; i < node->getNumChildren(); i++) {
00201             wavefront.push_back(node->getChild(i));
00202         }
00203     }
00204     std::map<architecture::Tilewire, int>::iterator it;
00205     for (unsigned int i = 0 ; i < vec.size(); i++) {
00206 std::cout << "NODE: " << vec[i]->getArc() << std::endl;
00207         it = sinkCounts.find(vec[i]->getSinkTilewire());
00208         if (it != sinkCounts.end()) {
00209             it->second++;
00210         }
00211     }
00212     BOOST_TEST_MESSAGE(*ddbPtr);
00213     for (it = sinkCounts.begin(); it != sinkCounts.end(); it++) {
00214         BOOST_TEST_MESSAGE("Checking sink " << it->first);
00215         BOOST_CHECK_EQUAL(it->second, 1);
00216         //std::cout << it->first << " " << it->second << std::endl;
00217     }
00218 }
00219 */
00220 BOOST_AUTO_TEST_SUITE_END()
00221 
00222 } // namespace router
00223 } // namespace torc