TORC: torc/router/TraceRegressionTest.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/TraceRegressionTest.cpp $
00003 // $Id: TraceRegressionTest.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 Tracer 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 TraceVirtex5TestFixture {
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     TraceVirtex5TestFixture() : 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() / "regression"),
00054             referencePath(testPath / "TraceRegressionTest.Virtex5.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         
00068         BOOST_CHECK_EQUAL(designPtr->getNetCount(), 1u);
00069         BOOST_CHECK_EQUAL(ddbPtr->getArcUsage().getArcUsageCount(), 53u);
00070         BOOST_TEST_MESSAGE("The pip count should include the routethrough.");
00071         BOOST_CHECK_EQUAL(ddbPtr->getArcUsage().getArcUsageCount(), 54u);
00072         
00073         sourceTw = ddbPtr->lookupTilewire("CLBLL_X16Y39", "L_C");
00074         sourceTw2 = ddbPtr->lookupTilewire("CLBLL_X16Y39", "L_CMUX");
00075         
00076         architecture::Tilewire tempTw;
00077         tempTw = ddbPtr->lookupTilewire("CLBLM_X13Y42", "L_D1");
00078         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00079         tempTw = ddbPtr->lookupTilewire("CLBLM_X18Y36", "L_A1");
00080         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00081         tempTw = ddbPtr->lookupTilewire("CLBLM_X18Y36", "L_D3");
00082         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00083         tempTw = ddbPtr->lookupTilewire("CLBLM_X13Y36", "M_B6");
00084         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00085         tempTw = ddbPtr->lookupTilewire("CLBLM_X13Y36", "M_C5");
00086         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00087         tempTw = ddbPtr->lookupTilewire("CLBLM_X13Y36", "M_D3");
00088         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00089         tempTw = ddbPtr->lookupTilewire("CLBLM_X13Y42", "L_D2");
00090         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00091         tempTw = ddbPtr->lookupTilewire("CLBLL_X16Y42", "L_A1");
00092         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00093         tempTw = ddbPtr->lookupTilewire("CLBLL_X16Y42", "L_CE");
00094         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00095         tempTw = ddbPtr->lookupTilewire("CLBLM_X18Y40", "L_BX");
00096         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00097         tempTw = ddbPtr->lookupTilewire("CLBLM_X18Y40", "L_B4");
00098         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00099     }
00100     ~TraceVirtex5TestFixture() {
00101         BOOST_CHECK_EQUAL(TraceNode::sLiveNodes, 0);
00102         delete ddbPtr;
00103     }
00104 };
00105 
00106 struct TraceVirtexTristateTestFixture {
00107     int& argc;
00108     char**&argv;
00109     torc::common::DirectoryTree directoryTree;
00110     boost::filesystem::path testPath;
00111     boost::filesystem::path referencePath;
00112     std::fstream fileStream;
00113     architecture::XdlImporter importer;
00114     torc::physical::DesignSharedPtr designPtr;
00115     architecture::DDB* ddbPtr;
00116     std::map<architecture::Tilewire, int> sinkCounts;
00117     architecture::Tilewire sourceTw1;
00118     architecture::Tilewire sourceTw2;
00119     
00120     TraceVirtexTristateTestFixture() : argc(boost::unit_test::framework::master_test_suite().argc),
00121             argv(boost::unit_test::framework::master_test_suite().argv),
00122             directoryTree(argv[0]),
00123             testPath(directoryTree.getExecutablePath() / "regression"),
00124             referencePath(testPath / "TraceRegressionTest.VirtexTbuf.xdl"),
00125             fileStream(referencePath.string().c_str())
00126             //importer(fileStream, referencePath.string()),
00127             //ddbPtr(importer.releaseDDBPtr()),
00128             //tracer(*ddbPtr)
00129     {
00130         BOOST_REQUIRE(argc >= 1);
00131         BOOST_REQUIRE(fileStream.good());
00132         importer(fileStream, referencePath.string());
00133         designPtr = importer.getDesignPtr();
00134         BOOST_REQUIRE(designPtr.get() != 0);
00135         ddbPtr = importer.releaseDDBPtr();
00136         BOOST_REQUIRE(ddbPtr != 0);
00137         
00138         BOOST_CHECK_EQUAL(designPtr->getNetCount(), 1u);
00139         BOOST_CHECK_EQUAL(ddbPtr->getArcUsage().getArcUsageCount(), 34u); //33 without bidir
00140         
00141         sourceTw1 = ddbPtr->lookupTilewire("R7C14", "TBUF_OUT0");
00142         sourceTw2 = ddbPtr->lookupTilewire("R7C18", "TBUF_OUT0");
00143         
00144         architecture::Tilewire tempTw;
00145         tempTw = ddbPtr->lookupTilewire("R7C14", "S0_F_B1");
00146         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00147         tempTw = ddbPtr->lookupTilewire("R7C14", "S1_F_B1");
00148         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00149         tempTw = ddbPtr->lookupTilewire("R7C14", "S1_G_B1");
00150         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00151         tempTw = ddbPtr->lookupTilewire("R7C14", "S0_G_B1");
00152         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00153         tempTw = ddbPtr->lookupTilewire("R7C18", "S1_G_B1");
00154         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00155         tempTw = ddbPtr->lookupTilewire("R7C18", "S0_F_B1");
00156         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00157         tempTw = ddbPtr->lookupTilewire("R7C18", "S1_F_B1");
00158         sinkCounts.insert(std::pair<architecture::Tilewire, int>(tempTw, 0));
00159     }
00160     ~TraceVirtexTristateTestFixture() {
00161         BOOST_CHECK_EQUAL(TraceNode::sLiveNodes, 0);
00162         delete ddbPtr;
00163     }
00164 };
00165 
00166 BOOST_AUTO_TEST_SUITE(router)
00167 
00168 BOOST_FIXTURE_TEST_SUITE(TraceRegressionVirtex, TraceVirtexTristateTestFixture)
00169 
00170 BOOST_AUTO_TEST_CASE(FullNet) {
00171     std::cout << *ddbPtr;
00172     Trace trace(*ddbPtr, sourceTw1, Trace::eTraceFullNet);
00173     TraceNodePtrVector& sources = trace.getSources();
00174     BOOST_CHECK_EQUAL(sources.size(), 2u);
00175     TraceNodePtrVector& sinks = trace.getSinks();
00176     BOOST_CHECK_EQUAL(sinks.size(), 7u);
00177     TraceNodePtrVector& branchpoints = trace.getBranchPoints();
00178     BOOST_CHECK_EQUAL(branchpoints.size(), 4u);
00179     architecture::ArcVector& arcs = trace.getArcs();
00180     BOOST_CHECK_EQUAL(arcs.size(), 34u);
00181 }
00182 
00183 BOOST_AUTO_TEST_SUITE_END()
00184 
00185 BOOST_FIXTURE_TEST_SUITE(TraceRegressionVirtex5, TraceVirtex5TestFixture)
00186 
00187 /// \brief Unit test for the findTop and normalizeDepth functions in the Tracer.
00188 BOOST_AUTO_TEST_CASE(FullNet) {
00189     std::cout << *ddbPtr;
00190     Trace trace(*ddbPtr, sourceTw, Trace::eTraceFullNet);
00191     TraceNodePtrVector& sources = trace.getSources();
00192     BOOST_CHECK_EQUAL(sources.size(), 1u);
00193     TraceNodePtrVector& sinks = trace.getSinks();
00194     BOOST_CHECK_EQUAL(sinks.size(), 8u);
00195     TraceNodePtrVector& branchpoints = trace.getBranchPoints();
00196     BOOST_CHECK_EQUAL(branchpoints.size(), 5u);
00197     architecture::ArcVector& arcs = trace.getArcs();
00198     BOOST_CHECK_EQUAL(arcs.size(), 34u);
00199 }
00200 
00201 /*
00202 /// \brief Unit test for the traceSource function in the Tracer.
00203 BOOST_AUTO_TEST_CASE(router_tracer_tracetosinks) {
00204     Tracer tracer(*ddbPtr);
00205     RouteTreeNode* rtn;
00206     RouteTreeNode* rtn2;
00207     rtn = tracer.traceToSinks(sourceTw);
00208     rtn2 = tracer.traceToSinks(sourceTw2);
00209     rtn->normalizeDepth();
00210     rtn2->normalizeDepth();
00211     std::vector<RouteTreeNode*> vec;
00212     std::vector<RouteTreeNode*> wavefront;
00213     //vec.push_back(rtn);
00214     //vec.push_back(rtn2);
00215     wavefront.push_back(rtn);
00216     wavefront.push_back(rtn2);
00217     while (wavefront.size() != 0) {
00218         RouteTreeNode* node = wavefront.back();
00219         wavefront.pop_back();
00220         vec.push_back(node);
00221         for (unsigned int i = 0; i < node->getNumChildren(); i++) {
00222             wavefront.push_back(node->getChild(i));
00223         }
00224     }
00225     std::map<architecture::Tilewire, int>::iterator it;
00226     for (unsigned int i = 0 ; i < vec.size(); i++) {
00227         it = sinkCounts.find(vec[i]->getSinkTilewire());
00228         if (it != sinkCounts.end()) {
00229             it->second++;
00230         }
00231     }
00232     BOOST_TEST_MESSAGE(*ddbPtr);
00233     for (it = sinkCounts.begin(); it != sinkCounts.end(); it++) {
00234         BOOST_TEST_MESSAGE("Checking sink " << it->first);
00235         BOOST_CHECK(it->second == 1);
00236     }
00237 }
00238 
00239 /// \brief Unit test for the traceBranch function in the Tracer.
00240 BOOST_AUTO_TEST_CASE(router_tracer_tracebranch) {
00241     Tracer tracer(*ddbPtr);
00242     architecture::Tilewire branchSource = ddbPtr->lookupTilewire("INT_X14Y37", "SL2END0");
00243     RouteTreeNode* rtn;
00244     rtn = tracer.traceBranch(branchSource);
00245     rtn->normalizeDepth();
00246     std::vector<RouteTreeNode*> vec;
00247     std::vector<RouteTreeNode*> wavefront;
00248     vec.push_back(rtn);
00249     wavefront.push_back(rtn);
00250     while (wavefront.size() != 0) {
00251         RouteTreeNode* node = wavefront.back();
00252         wavefront.pop_back();
00253         vec.push_back(node);
00254         for (unsigned int i = 0; i < node->getNumChildren(); i++) {
00255             wavefront.push_back(node->getChild(i));
00256         }
00257     }
00258     std::map<architecture::Tilewire, int>::iterator it;
00259     for (unsigned int i = 0 ; i < vec.size(); i++) {
00260 std::cout << "NODE: " << vec[i]->getArc() << std::endl;
00261         it = sinkCounts.find(vec[i]->getSinkTilewire());
00262         if (it != sinkCounts.end()) {
00263             it->second++;
00264         }
00265     }
00266     BOOST_TEST_MESSAGE(*ddbPtr);
00267     for (it = sinkCounts.begin(); it != sinkCounts.end(); it++) {
00268         BOOST_TEST_MESSAGE("Checking sink " << it->first);
00269         BOOST_CHECK_EQUAL(it->second, 1);
00270         //std::cout << it->first << " " << it->second << std::endl;
00271     }
00272 }
00273 
00274 /// \brief Unit test for the traceSink function in the Tracer.
00275 BOOST_AUTO_TEST_CASE(router_tracer_tracesink) {
00276 }
00277 
00278 /// \brief Unit test for the traceFull function in the Tracer.
00279 BOOST_AUTO_TEST_CASE(router_tracer_tracefull) {
00280     Tracer tracer(*ddbPtr);
00281     architecture::Tilewire branchSource = ddbPtr->lookupTilewire("INT_X14Y37", "SL2END0");
00282 std::cout << *ddbPtr << "START: " << branchSource << std::endl;
00283     RouteTreeNode* rtn;
00284     rtn = tracer.traceFull(branchSource);
00285     rtn->normalizeDepth();
00286     rtn = (RouteTreeNode*)rtn->getTop();
00287     std::vector<RouteTreeNode*> vec;
00288     std::vector<RouteTreeNode*> wavefront;
00289     wavefront.push_back(rtn);
00290     while (wavefront.size() != 0) {
00291         RouteTreeNode* node = wavefront.back();
00292         wavefront.pop_back();
00293         vec.push_back(node);
00294         for (unsigned int i = 0; i < node->getNumChildren(); i++) {
00295             wavefront.push_back(node->getChild(i));
00296         }
00297     }
00298     std::map<architecture::Tilewire, int>::iterator it;
00299     for (unsigned int i = 0 ; i < vec.size(); i++) {
00300 std::cout << "NODE: " << vec[i]->getArc() << std::endl;
00301         it = sinkCounts.find(vec[i]->getSinkTilewire());
00302         if (it != sinkCounts.end()) {
00303             it->second++;
00304         }
00305     }
00306     BOOST_TEST_MESSAGE(*ddbPtr);
00307     for (it = sinkCounts.begin(); it != sinkCounts.end(); it++) {
00308         BOOST_TEST_MESSAGE("Checking sink " << it->first);
00309         BOOST_CHECK_EQUAL(it->second, 1);
00310         //std::cout << it->first << " " << it->second << std::endl;
00311     }
00312 }
00313 */
00314 BOOST_AUTO_TEST_SUITE_END()
00315 
00316 BOOST_AUTO_TEST_SUITE_END()
00317 
00318 } // namespace router
00319 } // namespace torc