TORC: torc/bitstream/Virtex7UnitTest.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/bitstream/Virtex7UnitTest.cpp $
00003 // $Id: Virtex7UnitTest.cpp 10 2011-10-12 18:40: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 Unit test for the Virtex7 class.
00018 
00019 #include <boost/test/unit_test.hpp>
00020 #include "torc/bitstream/Virtex7.hpp"
00021 #include "torc/common/DirectoryTree.hpp"
00022 #include "torc/common/Devices.hpp"
00023 #include "torc/architecture/DDB.hpp"
00024 #include "torc/common/DeviceDesignator.hpp"
00025 #include "torc/bitstream/OutputStreamHelpers.hpp"
00026 #include "torc/bitstream/build/DeviceInfoHelper.hpp"
00027 #include "torc/common/TestHelpers.hpp"
00028 #include <fstream>
00029 #include <iostream>
00030 #include <boost/filesystem.hpp>
00031 
00032 namespace torc{
00033 namespace bitstream{
00034 
00035 BOOST_AUTO_TEST_SUITE(bitstream)
00036 
00037 /// \brief Unit test for the Virtex7 CRC
00038 BOOST_AUTO_TEST_CASE(Virtex7CrcUnitTest){
00039     std::fstream fileStream("Virtex7UnitTest.reference.bit", std::ios::binary | std::ios::in);
00040     Virtex7 bitstream;
00041     bitstream.read(fileStream, false);
00042     std::cout << bitstream << std::endl;
00043     bitstream.preflightPackets();
00044     BOOST_REQUIRE(true);
00045 }
00046   
00047 /// \brief Unit test for the Virtex7 class
00048 BOOST_AUTO_TEST_CASE(Virtex7UnitTest){
00049     //enums tested:
00050     //             Epacket
00051     //             Efar
00052     boost::uint32_t mask;
00053     // type 1 packet subfield masks
00054     mask = Virtex7::ePacketMaskType + Virtex7::ePacketMaskOpcode 
00055         + Virtex7::ePacketMaskType1Address + Virtex7::ePacketMaskType1Reserved 
00056         + Virtex7::ePacketMaskType1Count;
00057     BOOST_CHECK_EQUAL(mask, 0xFFFFFFFFu);
00058     // type 2 packet subfield masks
00059     mask = Virtex7::ePacketMaskType + Virtex7::ePacketMaskOpcode 
00060         + Virtex7::ePacketMaskType2Count;
00061     BOOST_CHECK_EQUAL(mask, 0xFFFFFFFFu);
00062     // frame address register subfield masks
00063     mask = Virtex7::eFarMaskBlockType + Virtex7::eFarMaskTopBottom + Virtex7::eFarMaskRow 
00064         + Virtex7::eFarMaskMajor + Virtex7::eFarMaskMinor;
00065     BOOST_CHECK_EQUAL(mask, 0x03FFFFFFu);
00066 
00067     // members tested:
00068     //              Virtex7::sPacketTypeName and EPacketTypeName
00069     BOOST_CHECK_EQUAL(Virtex7::sPacketTypeName[0],                  "[UNKNOWN TYPE 0]");
00070     BOOST_CHECK_EQUAL(Virtex7::sPacketTypeName[Virtex7::ePacketType1],              "TYPE1");
00071     BOOST_CHECK_EQUAL(Virtex7::sPacketTypeName[Virtex7::ePacketType2],              "TYPE2");
00072     BOOST_CHECK_EQUAL(Virtex7::sPacketTypeName[3],                                  "[UNKNOWN TYPE 3]");
00073     BOOST_CHECK_EQUAL(Virtex7::sPacketTypeName[4],                                  "[UNKNOWN TYPE 4]");
00074     BOOST_CHECK_EQUAL(Virtex7::sPacketTypeName[5],                                  "[UNKNOWN TYPE 5]");
00075     BOOST_CHECK_EQUAL(Virtex7::sPacketTypeName[6],                                  "[UNKNOWN TYPE 6]");
00076     BOOST_CHECK_EQUAL(Virtex7::sPacketTypeName[7],                                  "[UNKNOWN TYPE 7]");
00077 
00078     // members tested:
00079     //              Virtex7::sOpcodeName and EOpcode
00080     BOOST_CHECK_EQUAL(Virtex7::sOpcodeName[Virtex7::eOpcodeNOP],                    "NOP");
00081     BOOST_CHECK_EQUAL(Virtex7::sOpcodeName[Virtex7::eOpcodeRead],                   "READ");
00082     BOOST_CHECK_EQUAL(Virtex7::sOpcodeName[Virtex7::eOpcodeWrite],                  "WRITE");
00083     BOOST_CHECK_EQUAL(Virtex7::sOpcodeName[Virtex7::eOpcodeReserved],               "RESERVED");
00084 
00085     // members tested:
00086     //              Virtex7::sRegisterName and ERegister
00087     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterCRC],                "CRC");
00088     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterFAR],                "FAR");
00089     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterFDRI],               "FDRI");
00090     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterFDRO],               "FDRO");
00091     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterCMD],                "CMD");
00092     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterCTL0],               "CTL0");
00093     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterMASK],               "MASK");
00094     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterSTAT],               "STAT");
00095     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterLOUT],               "LOUT");
00096     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterCOR0],               "COR0");
00097     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterMFWR],               "MFWR");
00098     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterCBC],                "CBC");
00099     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterIDCODE],             "IDCODE");
00100     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterAXSS],               "AXSS");
00101     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterCOR1],               "COR1");
00102     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterWBSTAR],             "WBSTAR");
00103     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterTIMER],              "TIMER");
00104     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterBOOTSTS],            "BOOTSTS");
00105     BOOST_CHECK_EQUAL(Virtex7::sRegisterName[Virtex7::eRegisterCTL1],               "CTL1");
00106 
00107     // members tested:
00108     //              Virtex7::sCommandName and ECommand
00109     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandNULL],                 "NULL");
00110     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandWCFG],                 "WCFG");
00111     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandMFW],                  "MFW");
00112     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandLFRM],                 "DGHIGH/LFRM");
00113     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandRCFG],                 "RCFG");
00114     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandSTART],                "START");
00115     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandRCAP],                 "RCAP");
00116     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandRCRC],                 "RCRC");
00117     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandAGHIGH],               "AGHIGH");
00118     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandSWITCH],               "SWITCH");
00119     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandGRESTORE],             "GRESTORE");
00120     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandSHUTDOWN],             "SHUTDOWN");
00121     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandGCAPTURE],             "GCAPTURE");
00122     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandDESYNCH],              "DESYNCH");
00123     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandReserved],             "Reserved");
00124     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandIPROG],                "IPROG");
00125     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandCRCC],         "CRCC");
00126     BOOST_CHECK_EQUAL(Virtex7::sCommandName[Virtex7::eCommandLTIMER],               "LTIMER");
00127 
00128 
00129     // build the file paths
00130     boost::filesystem::path regressionPath 
00131         = torc::common::DirectoryTree::getExecutablePath() / "regression";
00132     boost::filesystem::path generatedPath = regressionPath / "Virtex7UnitTest.generated.bit";
00133     boost::filesystem::path referencePath = regressionPath / "Virtex7UnitTest.reference.bit";
00134 
00135     // read the bitstream
00136     std::fstream fileStream(referencePath.string().c_str(), std::ios::binary | std::ios::in);
00137     BOOST_REQUIRE(fileStream.good());
00138     Virtex7 bitstream;
00139     bitstream.read(fileStream, false);
00140     // write the bitstream digest to the console
00141     std::cout << bitstream << std::endl;
00142 
00143 
00144     std::string designName = bitstream.getDesignName();
00145     std::string deviceName = bitstream.getDeviceName();
00146     std::string designDate = bitstream.getDesignDate();
00147     std::string designTime = bitstream.getDesignTime();
00148     torc::common::DeviceDesignator deviceDesignator(deviceName);
00149     std::cout << "family of " << deviceName << " is " << deviceDesignator.getFamily() << std::endl;
00150 
00151     // write the bitstream back out
00152     std::fstream outputStream(generatedPath.string().c_str(), std::ios::binary | std::ios::out);
00153     BOOST_REQUIRE(outputStream.good());
00154     bitstream.write(outputStream);
00155     outputStream.flush();
00156 
00157     // compare the reference and generated XDL
00158     BOOST_CHECK(torc::common::fileContentsAreEqual(generatedPath, referencePath));  
00159 }  
00160 
00161 
00162 
00163 
00164 
00165 
00166 
00167 
00168 
00169 
00170 
00171 
00172 
00173 
00174 
00175 
00176 void testVirtex7Device(const std::string& inDeviceName, const boost::filesystem::path& inWorkingPath);
00177 
00178 /// \brief Unit test for the Virtex7 class Frame Address Register mapping.
00179 BOOST_AUTO_TEST_CASE(Virtex7FarUnitTest) {
00180 
00181     // look up the command line arguments
00182     int& argc = boost::unit_test::framework::master_test_suite().argc;
00183     char**& argv = boost::unit_test::framework::master_test_suite().argv;
00184     // make sure that we at least have the name under which we were invoked
00185     BOOST_REQUIRE(argc >= 1);
00186     // resolve symbolic links if applicable
00187     torc::common::DirectoryTree directoryTree(argv[0]);
00188     
00189     // iterate over the Virtex7 devices
00190     {
00191         const torc::common::DeviceVector& devices = torc::common::Devices::getVirtex7Devices();
00192         torc::common::DeviceVector::const_iterator dp = devices.begin();
00193         torc::common::DeviceVector::const_iterator de = devices.end();
00194         while(dp < de) {
00195             const std::string& device = *dp++;
00196             if(device.empty()) break;
00197     //std::cout << "device " << ": " << device << std::endl;
00198             testVirtex7Device(device, torc::common::DirectoryTree::getWorkingPath());
00199         }
00200     }
00201 
00202     // iterate over the Virtex7L devices
00203     {
00204         const torc::common::DeviceVector& devices = torc::common::Devices::getVirtex7LDevices();
00205         torc::common::DeviceVector::const_iterator dp = devices.begin();
00206         torc::common::DeviceVector::const_iterator de = devices.end();
00207         while(dp < de) {
00208             const std::string& device = *dp++;
00209             if(device.empty()) break;
00210     //std::cout << "device " << ": " << device << std::endl;
00211             testVirtex7Device(device, torc::common::DirectoryTree::getWorkingPath());
00212         }
00213     }
00214 }
00215   /*
00216         class TileTypeWidths {
00217         public:
00218                 uint32_t mWidth[8];
00219                 TileTypeWidths(uint32_t in0 = 0, uint32_t in1 = 0, uint32_t in2 = 0, uint32_t in3 = 0, 
00220                         uint32_t in4 = 0, uint32_t in5 = 0, uint32_t in6 = 0, uint32_t in7 = 0) {
00221                         int i = 0;
00222                         mWidth[i++] = in0; mWidth[i++] = in1; mWidth[i++] = in2; mWidth[i++] = in3;
00223                         mWidth[i++] = in4; mWidth[i++] = in5; mWidth[i++] = in6; mWidth[i++] = in7;
00224                 }
00225                 void clear(void) { for(int i = 0; i < 8; i++) mWidth[i] = 0; }
00226                 uint32_t operator[] (int inIndex) const { return mWidth[inIndex]; }
00227         };
00228   */
00229 
00230     std::ostream& operator<< (std::ostream& os, const Virtex7::FrameAddress& rhs);
00231     std::ostream& operator<< (std::ostream& os, const Virtex7::FrameAddress& rhs) {
00232         return os << (rhs.mTopBottom == Virtex7::eFarTop ? 'T' : 'B') << "" << rhs.mBlockType 
00233                   << "(" << rhs.mRow << "," << rhs.mMajor << "." << rhs.mMinor << ")";
00234 
00235     }
00236 
00237 
00238 
00239 
00240 
00241 
00242 
00243 
00244 void testVirtex7Device(const std::string& inDeviceName, const boost::filesystem::path& inWorkingPath) {
00245 
00246     // build the file paths
00247     boost::filesystem::path debugBitstreamPath = inWorkingPath / "torc" / "bitstream" / "regression";
00248     //boost::filesystem::path generatedPath = debugBitstreamPath / (inDeviceName + ".debug.bit");
00249     boost::filesystem::path referencePath = debugBitstreamPath / (inDeviceName + ".debug.bit");
00250 
00251     // read the bitstream
00252     std::fstream fileStream(referencePath.string().c_str(), std::ios::binary | std::ios::in);
00253     std::cerr << "Trying to read: " << referencePath << std::endl;
00254     BOOST_REQUIRE(fileStream.good());
00255     Virtex7 bitstream;
00256     bitstream.read(fileStream, false);
00257     // write the bitstream digest to the console
00258     //      std::cout << bitstream << std::endl;
00259     //      // initialize the bitstream frame maps
00260     //      boost::filesystem::path deviceColumnsPath = inWorkingPath / "torc" / "bitstream" / "regression" 
00261     //              / (inDeviceName + ".cpp");
00262     //      std::fstream deviceColumnsStream(deviceColumnsPath.string().c_str(), std::ios::out);
00263     // bitstream.initializeDeviceInfo(inDeviceName);
00264     // bitstream.initializeFrameMaps();
00265 
00266 
00267     // iterate through the packets, and extract all of the FARs
00268     Virtex7::FrameAddressToIndex farRemaining = bitstream.mFrameAddressToIndex;
00269     Virtex7::FrameAddressToIndex farVisited;
00270     {
00271         bool first = true;
00272         Virtex7::const_iterator p = bitstream.begin();
00273         Virtex7::const_iterator e = bitstream.end();
00274         uint32_t header = VirtexPacket::makeHeader(VirtexPacket::ePacketType1, 
00275                        VirtexPacket::eOpcodeWrite, Virtex7::eRegisterLOUT, 1);
00276         while(p < e) {
00277             const VirtexPacket& packet = *p++;
00278             if(packet.getHeader() != header) continue;
00279             if(first) { first = false; continue; }
00280             Virtex7::FrameAddress far = packet[1];
00281             farVisited[far] = 0;
00282             Virtex7::FrameAddressToIndex::iterator found = farRemaining.find(far);
00283             if(found != farRemaining.end()) {
00284                 farRemaining.erase(found);
00285             } else {
00286                 std::cerr << "missing " << far << " ";
00287             }
00288         }
00289     }
00290     {
00291     Virtex7::FrameAddressToIndex::const_iterator p = farRemaining.begin();
00292     Virtex7::FrameAddressToIndex::const_iterator e = farRemaining.end();
00293     while(p != e) {
00294         std::cerr << "remaining " << (*p++).first << " ";
00295     }
00296         std::cerr << std::endl;
00297     }
00298     // verify that we have visited all of the expected FARs and no others
00299     std::cout << "Device: " << inDeviceName << std::endl;
00300     std::cout << "Size of farRemaining: " << farRemaining.size() << std::endl;
00301     std::cout << "Size of farVisited: " << farVisited.size() << std::endl;
00302     BOOST_REQUIRE_EQUAL(bitstream.mFrameAddressToIndex.size(), farVisited.size());
00303     BOOST_REQUIRE_EQUAL(farRemaining.size(), 0u);
00304 
00305 return;
00306 
00307 
00308     // iterate through the debug bitstream packets, and extract all of the FARs
00309     // this isn't currently being used, but it may come in handy for debugging
00310     for(int half = 0; half < 2; half++) {
00311         for(uint32_t row = 0; row < 2; row++) {
00312             typedef std::map<uint32_t, uint32_t> ColumnMaxFrame;
00313             ColumnMaxFrame maxFrames[Virtex7::eFarBlockTypeCount];
00314             Virtex7::const_iterator p = bitstream.begin();
00315             Virtex7::const_iterator e = bitstream.end();
00316             uint32_t header = VirtexPacket::makeHeader(VirtexPacket::ePacketType1, 
00317                  VirtexPacket::eOpcodeWrite, Virtex7::eRegisterLOUT, 1);
00318             while(p < e) {
00319                 const VirtexPacket& packet = *p++;
00320                 if(packet.getHeader() != header) continue;
00321                 Virtex7::FrameAddress far = packet[1];
00322 //                              uint32_t far = packet[1];
00323 //                              std::cerr << Hex32(far) << " ";
00324                 if(far.mTopBottom == half && far.mRow == row) { 
00325  //                                      std::cerr << far << " ";
00326                     ColumnMaxFrame::iterator i = maxFrames[far.mBlockType].find(far.mMajor);
00327                     if(i == maxFrames[far.mBlockType].end()) {
00328                         maxFrames[far.mBlockType][far.mMajor] = 0;
00329                     } else {
00330                             if(maxFrames[far.mBlockType][far.mMajor] < far.mMinor) 
00331                                 maxFrames[far.mBlockType][far.mMajor] = far.mMinor;
00332                     }               
00333                 }
00334                 }
00335                 std::cerr << std::endl;
00336                 uint32_t frameCount = 0;
00337                 for(uint32_t i = 0; i < Virtex7::eFarBlockTypeCount; i++) {
00338                 Virtex7::EFarBlockType blockType = Virtex7::EFarBlockType(i);
00339                 uint32_t majorCount = maxFrames[blockType].size();
00340                 for(uint32_t major = 0; major < majorCount; major++) {
00341                     frameCount += maxFrames[blockType][major] + 1;
00342                     std::cerr << blockType << "(" << major << "): " 
00343                         << (maxFrames[blockType][major] + 1) << " (" << frameCount << ")" 
00344                             << std::endl;
00345                 }
00346                 }
00347             }
00348     }   
00349 }
00350 
00351 /*
00352 /// \brief Unit test for the Virtex7 static device info generation.
00353 BOOST_AUTO_TEST_CASE(Virtex7GenerateUnitTest) {
00354 
00355     Virtex7 bitstream;
00356     const torc::common::DeviceVector& virtex7Devices = torc::common::Devices::getVirtex7Devices();
00357     const torc::common::DeviceVector& virtex7LDevices = torc::common::Devices::getVirtex7LDevices();
00358     torc::common::DeviceVector devices;
00359     devices.insert(devices.end(), virtex7Devices.begin(), virtex7Devices.end());
00360     devices.insert(devices.end(), virtex7LDevices.begin(), virtex7LDevices.end());
00361     devices = torc::common::Devices::getKintex7Devices();
00362     DeviceInfoHelper::buildFamilyDeviceInfo("Virtex7", "Virtex7DeviceInfo.template", 
00363         "Virtex7DeviceInfo.cpp", devices, bitstream);
00364 }
00365 */
00366 
00367 BOOST_AUTO_TEST_SUITE_END()
00368 
00369 
00370 } //namespace bitstream
00371 }//namespace torc