TORC: torc/bitstream/Virtex4UnitTest.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/Virtex4UnitTest.cpp $
00003 // $Id: Virtex4UnitTest.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 Virtex4 class.
00018 
00019 #include <boost/test/unit_test.hpp>
00020 #include "torc/bitstream/Virtex4.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 Virtex4 CRC
00038 BOOST_AUTO_TEST_CASE(Virtex4CrcUnitTest) {
00039     std::fstream fileStream("Virtex4UnitTest.reference.bit", std::ios::binary | std::ios::in);
00040     Virtex4 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 Virtex4 class.
00048 BOOST_AUTO_TEST_CASE(Virtex4UnitTest) {
00049 
00050     // enums tested:
00051     //      EPacket
00052     //      EFar
00053     boost::uint32_t mask;
00054     // type 1 packet subfield masks
00055     mask = Virtex4::ePacketMaskType + Virtex4::ePacketMaskOpcode 
00056         + Virtex4::ePacketMaskType1Address + Virtex4::ePacketMaskType1Reserved 
00057         + Virtex4::ePacketMaskType1Count;
00058     BOOST_CHECK_EQUAL(mask, 0xFFFFFFFFu);
00059     // type 2 packet subfield masks
00060     mask = Virtex4::ePacketMaskType + Virtex4::ePacketMaskOpcode 
00061         + Virtex4::ePacketMaskType2Count;
00062     BOOST_CHECK_EQUAL(mask, 0xFFFFFFFFu);
00063     // frame address register subfield masks
00064     mask = Virtex4::eFarMaskTopBottom + Virtex4::eFarMaskBlockType + Virtex4::eFarMaskRow 
00065         + Virtex4::eFarMaskMajor + Virtex4::eFarMaskMinor;
00066     BOOST_CHECK_EQUAL(mask, 0x007FFFFFu);
00067 
00068     // members tested:
00069     //      Virtex4::sPacketTypeName and EPacketTypeName
00070     BOOST_CHECK_EQUAL(Virtex4::sPacketTypeName[0],                          "[UNKNOWN TYPE 0]");
00071     BOOST_CHECK_EQUAL(Virtex4::sPacketTypeName[Virtex4::ePacketType1],      "TYPE1");
00072     BOOST_CHECK_EQUAL(Virtex4::sPacketTypeName[Virtex4::ePacketType2],      "TYPE2");
00073     BOOST_CHECK_EQUAL(Virtex4::sPacketTypeName[3],                          "[UNKNOWN TYPE 3]");
00074     BOOST_CHECK_EQUAL(Virtex4::sPacketTypeName[4],                          "[UNKNOWN TYPE 4]");
00075     BOOST_CHECK_EQUAL(Virtex4::sPacketTypeName[5],                          "[UNKNOWN TYPE 5]");
00076     BOOST_CHECK_EQUAL(Virtex4::sPacketTypeName[6],                          "[UNKNOWN TYPE 6]");
00077     BOOST_CHECK_EQUAL(Virtex4::sPacketTypeName[7],                          "[UNKNOWN TYPE 7]");
00078 
00079     // members tested:
00080     //      Virtex4::sOpcodeName and EOpcode
00081     BOOST_CHECK_EQUAL(Virtex4::sOpcodeName[Virtex4::eOpcodeNOP],            "NOP");
00082     BOOST_CHECK_EQUAL(Virtex4::sOpcodeName[Virtex4::eOpcodeRead],           "READ");
00083     BOOST_CHECK_EQUAL(Virtex4::sOpcodeName[Virtex4::eOpcodeWrite],          "WRITE");
00084     BOOST_CHECK_EQUAL(Virtex4::sOpcodeName[Virtex4::eOpcodeReserved],       "RESERVED");
00085 
00086     // members tested:
00087     //      Virtex4::sRegisterName and ERegister
00088     BOOST_CHECK_EQUAL(Virtex4::sRegisterName[Virtex4::eRegisterCRC],        "CRC");
00089     BOOST_CHECK_EQUAL(Virtex4::sRegisterName[Virtex4::eRegisterFAR],        "FAR");
00090     BOOST_CHECK_EQUAL(Virtex4::sRegisterName[Virtex4::eRegisterFDRI],       "FDRI");
00091     BOOST_CHECK_EQUAL(Virtex4::sRegisterName[Virtex4::eRegisterFDRO],       "FDRO");
00092     BOOST_CHECK_EQUAL(Virtex4::sRegisterName[Virtex4::eRegisterCMD],        "CMD");
00093     BOOST_CHECK_EQUAL(Virtex4::sRegisterName[Virtex4::eRegisterCTL],        "CTL");
00094     BOOST_CHECK_EQUAL(Virtex4::sRegisterName[Virtex4::eRegisterMASK],       "MASK");
00095     BOOST_CHECK_EQUAL(Virtex4::sRegisterName[Virtex4::eRegisterSTAT],       "STAT");
00096     BOOST_CHECK_EQUAL(Virtex4::sRegisterName[Virtex4::eRegisterLOUT],       "LOUT");
00097     BOOST_CHECK_EQUAL(Virtex4::sRegisterName[Virtex4::eRegisterCOR],        "COR");
00098     BOOST_CHECK_EQUAL(Virtex4::sRegisterName[Virtex4::eRegisterMFWR],       "MFWR");
00099     BOOST_CHECK_EQUAL(Virtex4::sRegisterName[Virtex4::eRegisterCBC],        "CBC");
00100     BOOST_CHECK_EQUAL(Virtex4::sRegisterName[Virtex4::eRegisterIDCODE],     "IDCODE");
00101     BOOST_CHECK_EQUAL(Virtex4::sRegisterName[Virtex4::eRegisterAXSS],       "AXSS");
00102 
00103     // members tested:
00104     //      Virtex4::sCommandName and ECommand
00105     BOOST_CHECK_EQUAL(Virtex4::sCommandName[Virtex4::eCommandNULL],         "NULL");
00106     BOOST_CHECK_EQUAL(Virtex4::sCommandName[Virtex4::eCommandWCFG],         "WCFG");
00107     BOOST_CHECK_EQUAL(Virtex4::sCommandName[Virtex4::eCommandMFWR],         "MFWR");
00108     BOOST_CHECK_EQUAL(Virtex4::sCommandName[Virtex4::eCommandLFRM],         "LFRM");
00109     BOOST_CHECK_EQUAL(Virtex4::sCommandName[Virtex4::eCommandRCFG],         "RCFG");
00110     BOOST_CHECK_EQUAL(Virtex4::sCommandName[Virtex4::eCommandSTART],        "START");
00111     BOOST_CHECK_EQUAL(Virtex4::sCommandName[Virtex4::eCommandRCAP],         "RCAP");
00112     BOOST_CHECK_EQUAL(Virtex4::sCommandName[Virtex4::eCommandRCRC],         "RCRC");
00113     BOOST_CHECK_EQUAL(Virtex4::sCommandName[Virtex4::eCommandAGHIGH],       "AGHIGH");
00114     BOOST_CHECK_EQUAL(Virtex4::sCommandName[Virtex4::eCommandSWITCH],       "SWITCH");
00115     BOOST_CHECK_EQUAL(Virtex4::sCommandName[Virtex4::eCommandGRESTORE],     "GRESTORE");
00116     BOOST_CHECK_EQUAL(Virtex4::sCommandName[Virtex4::eCommandSHUTDOWN],     "SHUTDOWN");
00117     BOOST_CHECK_EQUAL(Virtex4::sCommandName[Virtex4::eCommandGCAPTURE],     "GCAPTURE");
00118     BOOST_CHECK_EQUAL(Virtex4::sCommandName[Virtex4::eCommandDESYNC],       "DESYNC");
00119 
00120     // verify conversion to and from FrameAddress objects
00121     uint32_t u1 = 0xffffffff & mask;
00122     BOOST_CHECK_EQUAL(uint32_t(Virtex4::FrameAddress(u1)), u1);
00123     uint32_t u2 = 0xffff0000 & mask;
00124     BOOST_CHECK_EQUAL(uint32_t(Virtex4::FrameAddress(u2)), u2);
00125     uint32_t u3 = 0xff00ff00 & mask;
00126     BOOST_CHECK_EQUAL(uint32_t(Virtex4::FrameAddress(u3)), u3);
00127     uint32_t u4 = 0xf0f0f0f0 & mask;
00128     BOOST_CHECK_EQUAL(uint32_t(Virtex4::FrameAddress(u4)), u4);
00129     uint32_t u5 = 0xcccccccc & mask;
00130     BOOST_CHECK_EQUAL(uint32_t(Virtex4::FrameAddress(u5)), u5);
00131     uint32_t u6 = 0xaaaaaaaa & mask;
00132     BOOST_CHECK_EQUAL(uint32_t(Virtex4::FrameAddress(u6)), u6);
00133 
00134     // build the file paths
00135     boost::filesystem::path regressionPath 
00136         = torc::common::DirectoryTree::getExecutablePath() / "regression";
00137     boost::filesystem::path generatedPath = regressionPath / "Virtex4UnitTest.generated.bit";
00138     boost::filesystem::path referencePath = regressionPath / "Virtex4UnitTest.reference.bit";
00139 
00140     // read the bitstream
00141     std::fstream fileStream(referencePath.string().c_str(), std::ios::binary | std::ios::in);
00142     BOOST_REQUIRE(fileStream.good());
00143     Virtex4 bitstream;
00144     bitstream.read(fileStream, false);
00145     // write the bitstream digest to the console
00146     std::cout << bitstream << std::endl;
00147 
00148     std::string designName = bitstream.getDesignName();
00149     std::string deviceName = bitstream.getDeviceName();
00150     std::string designDate = bitstream.getDesignDate();
00151     std::string designTime = bitstream.getDesignTime();
00152     torc::common::DeviceDesignator deviceDesignator(deviceName);
00153     std::cout << "family of " << deviceName << " is " << deviceDesignator.getFamily() << std::endl;
00154 
00155     // write the bitstream back out
00156     std::fstream outputStream(generatedPath.string().c_str(), std::ios::binary | std::ios::out);
00157     BOOST_REQUIRE(outputStream.good());
00158     bitstream.write(outputStream);
00159     outputStream.flush();
00160 
00161     // compare the reference and generated XDL
00162     BOOST_CHECK(torc::common::fileContentsAreEqual(generatedPath, referencePath));
00163 }
00164 
00165 
00166 
00167 
00168 
00169 
00170 
00171 
00172 
00173 
00174 
00175 
00176 
00177 
00178 
00179 
00180 
00181 
00182 
00183 
00184 
00185 
00186 
00187 
00188 
00189 
00190 
00191 
00192 
00193 
00194 
00195 
00196 
00197 
00198 
00199 
00200 
00201 
00202 
00203 
00204 void testVirtex4Device(const std::string& inDeviceName, const boost::filesystem::path& inWorkingPath);
00205 
00206 /// \brief Unit test for the Virtex4 class Frame Address Register mapping.
00207 BOOST_AUTO_TEST_CASE(Virtex4FarUnitTest) {
00208 
00209     // look up the command line arguments
00210     int& argc = boost::unit_test::framework::master_test_suite().argc;
00211     char**& argv = boost::unit_test::framework::master_test_suite().argv;
00212     // make sure that we at least have the name under which we were invoked
00213     BOOST_REQUIRE(argc >= 1);
00214     // resolve symbolic links if applicable
00215     torc::common::DirectoryTree directoryTree(argv[0]);
00216 
00217     // iterate over the devices
00218     const torc::common::DeviceVector& devices = torc::common::Devices::getVirtex4Devices();
00219     torc::common::DeviceVector::const_iterator dp = devices.begin();
00220     torc::common::DeviceVector::const_iterator de = devices.end();
00221     while(dp < de) {
00222         const std::string& device = *dp++;
00223         if(device.empty()) break;
00224 //std::cout << "device " << ": " << device << std::endl;
00225         testVirtex4Device(device, torc::common::DirectoryTree::getWorkingPath());
00226     }
00227 }
00228 
00229 /*
00230     class TileTypeWidths {
00231     public:
00232         uint32_t mWidth[8];
00233         TileTypeWidths(uint32_t in0 = 0, uint32_t in1 = 0, uint32_t in2 = 0, uint32_t in3 = 0, 
00234             uint32_t in4 = 0, uint32_t in5 = 0, uint32_t in6 = 0, uint32_t in7 = 0) {
00235             int i = 0;
00236             mWidth[i++] = in0; mWidth[i++] = in1; mWidth[i++] = in2; mWidth[i++] = in3;
00237             mWidth[i++] = in4; mWidth[i++] = in5; mWidth[i++] = in6; mWidth[i++] = in7;
00238         }
00239         void clear(void) { for(int i = 0; i < 8; i++) mWidth[i] = 0; }
00240         uint32_t operator[] (int inIndex) const { return mWidth[inIndex]; }
00241     };
00242 */
00243 
00244     //std::ostream& operator<< (std::ostream& os, const Virtex4::FrameAddress& rhs);
00245     //std::ostream& operator<< (std::ostream& os, const Virtex4::FrameAddress& rhs) {
00246     //  return os << (rhs.mTopBottom == Virtex4::eFarTop ? 'T' : 'B') << "" << rhs.mBlockType 
00247     //          << "(" << rhs.mRow << "," << rhs.mMajor << "." << rhs.mMinor << ")";
00248     //}
00249 
00250 void testVirtex4Device(const std::string& inDeviceName, const boost::filesystem::path& inWorkingPath) {
00251 
00252     // build the file paths
00253     boost::filesystem::path debugBitstreamPath = inWorkingPath / "torc" / "bitstream" / "regression";
00254     //boost::filesystem::path generatedPath = debugBitstreamPath / (inDeviceName + ".debug.bit");
00255     boost::filesystem::path referencePath = debugBitstreamPath / (inDeviceName + ".debug.bit");
00256 std::cerr << "TRYING TO FIND " << referencePath << std::endl;
00257 
00258     // read the bitstream
00259     std::fstream fileStream(referencePath.string().c_str(), std::ios::binary | std::ios::in);
00260     std::cerr << "Trying to read: " << referencePath << std::endl;
00261     BOOST_REQUIRE(fileStream.good());
00262     Virtex4 bitstream;
00263     bitstream.read(fileStream, false);
00264     // write the bitstream digest to the console
00265 //  std::cout << bitstream << std::endl;
00266 
00267 //  // initialize the bitstream frame maps
00268 //  boost::filesystem::path deviceColumnsPath = inWorkingPath / "regression" 
00269 //      / (inDeviceName + ".cpp");
00270 //  std::fstream deviceColumnsStream(deviceColumnsPath.string().c_str(), std::ios::out);
00271     bitstream.initializeDeviceInfo(inDeviceName);
00272     bitstream.initializeFrameMaps();
00273 
00274     // iterate through the packets, and extract all of the FARs
00275     Virtex4::FrameAddressToIndex farRemaining = bitstream.mFrameAddressToIndex;
00276     Virtex4::FrameAddressToIndex farVisited;
00277     {
00278         bool first = true;
00279         Virtex4::const_iterator p = bitstream.begin();
00280         Virtex4::const_iterator e = bitstream.end();
00281         uint32_t header = VirtexPacket::makeHeader(VirtexPacket::ePacketType1, 
00282             VirtexPacket::eOpcodeWrite, Virtex4::eRegisterLOUT, 1);
00283         while(p < e) {
00284             const VirtexPacket& packet = *p++;
00285             if(packet.getHeader() != header) continue;
00286             if(first) { first = false; continue; }
00287             Virtex4::FrameAddress far = packet[1];
00288             farVisited[far] = 0;
00289             Virtex4::FrameAddressToIndex::iterator found = farRemaining.find(far);
00290             if(found != farRemaining.end()) {
00291                 farRemaining.erase(found);
00292             } else {
00293                 std::cerr << "missing " << far << " ";
00294             }
00295         }
00296     }
00297     // verify that we have visited all of the expected FARs and no others
00298     std::cout << "Device: " << inDeviceName << std::endl;
00299     std::cout << "Size of farRemaining: " << farRemaining.size() << std::endl;
00300     std::cout << "Size of farVisited: " << farVisited.size() << std::endl;
00301     BOOST_REQUIRE_EQUAL(bitstream.mFrameAddressToIndex.size(), farVisited.size());
00302     BOOST_REQUIRE_EQUAL(farRemaining.size(), 0u);
00303 
00304 return;
00305 
00306     // iterate through the debug bitstream packets, and extract all of the FARs
00307     // this isn't currently being used, but it may come in handy for debugging
00308     for(int half = 0; half < 2; half++) {
00309         for(uint32_t row = 0; row < 2; row++) {
00310             typedef std::map<uint32_t, uint32_t> ColumnMaxFrame;
00311             ColumnMaxFrame maxFrames[Virtex4::eFarBlockTypeCount];
00312             Virtex4::const_iterator p = bitstream.begin();
00313             Virtex4::const_iterator e = bitstream.end();
00314             uint32_t header = VirtexPacket::makeHeader(VirtexPacket::ePacketType1, 
00315                 VirtexPacket::eOpcodeWrite, Virtex4::eRegisterLOUT, 1);
00316             while(p < e) {
00317                 const VirtexPacket& packet = *p++;
00318                 if(packet.getHeader() != header) continue;
00319                 Virtex4::FrameAddress far = packet[1];
00320 //              uint32_t far = packet[1];
00321 //              std::cerr << Hex32(far) << " ";
00322                 if(far.mTopBottom == half && far.mRow == row) {
00323 //                  std::cerr << far << " ";
00324                     ColumnMaxFrame::iterator i = maxFrames[far.mBlockType].find(far.mMajor);
00325                     if(i == maxFrames[far.mBlockType].end()) {
00326                         maxFrames[far.mBlockType][far.mMajor] = 0;
00327                     } else {
00328                         if(maxFrames[far.mBlockType][far.mMajor] < far.mMinor) 
00329                             maxFrames[far.mBlockType][far.mMajor] = far.mMinor;
00330                     }
00331                 }
00332             }
00333             std::cerr << std::endl;
00334             uint32_t frameCount = 0;
00335             for(uint32_t i = 0; i < Virtex4::eFarBlockTypeCount; i++) {
00336                 Virtex4::EFarBlockType blockType = Virtex4::EFarBlockType(i);
00337                 uint32_t majorCount = maxFrames[blockType].size();
00338                 for(uint32_t major = 0; major < majorCount; major++) {
00339                     frameCount += maxFrames[blockType][major] + 1;
00340                     std::cerr << blockType << "(" << major << "): " 
00341                         << (maxFrames[blockType][major] + 1) << " (" << frameCount << ")" 
00342                         << std::endl;
00343                 }
00344             }
00345         }
00346     }
00347 
00348 }
00349 
00350 void testVirtex4FullMapping(const boost::filesystem::path& inWorkingPath);
00351 void testVirtex4PartialMapping(const boost::filesystem::path& inWorkingPath);
00352 
00353 /// \brief Unit test for the Virtex4 bitstream to bitmap conversion.
00354 BOOST_AUTO_TEST_CASE(Virtex4MapUnitTest) {
00355     // look up the command line arguments
00356     int& argc = boost::unit_test::framework::master_test_suite().argc;
00357     char**& argv = boost::unit_test::framework::master_test_suite().argv;
00358     // make sure that we at least have the name under which we were invoked
00359     BOOST_REQUIRE(argc >= 1);
00360     // resolve symbolic links if applicable
00361     torc::common::DirectoryTree directoryTree(argv[0]);
00362     testVirtex4FullMapping(torc::common::DirectoryTree::getWorkingPath());
00363     //testVirtex4PartialMapping(torc::common::DirectoryTree::getWorkingPath());
00364 }
00365 
00366 
00367 void testVirtex4FullMapping(const boost::filesystem::path& inWorkingPath) {
00368     // build the file paths
00369     boost::filesystem::path regressionPath 
00370         = torc::common::DirectoryTree::getExecutablePath() / "regression";
00371     boost::filesystem::path generatedPath = regressionPath / "Virtex4UnitTest.generatedFull.bit";
00372     boost::filesystem::path referencePath = regressionPath / "Virtex4UnitTest.reference.bit";
00373 
00374     // read the bitstream
00375     std::fstream fileStream(referencePath.string().c_str(), std::ios::binary | std::ios::in);
00376     BOOST_REQUIRE(fileStream.good());
00377     // read and gather bitstream frames
00378     Virtex4 bitstream;
00379     bitstream.read(fileStream, false);
00380 
00381     // initialize frame map
00382     bitstream.initializeDeviceInfo("xc4vlx15");
00383     bitstream.initializeFrameMaps();
00384 
00385     // load bitstream frames in data structure
00386     bitstream.initializeFullFrameBlocks();
00387 
00388     // write full bitstream from frame blocks data structure
00389     uint32_t frameLength = bitstream.getFrameLength();
00390     typedef boost::shared_array<uint32_t> WordSharedArray;
00391     Virtex4::iterator p = bitstream.begin();
00392     Virtex4::iterator e = bitstream.end();
00393     while (p < e) {
00394         const VirtexPacket& packet = *p++;
00395         if (packet.isType2()) {
00396             WordSharedArray words = packet.getWords();
00397             uint32_t* ptr = words.get();
00398             for (uint32_t block = 0; block < 8; block++) {
00399                 for (uint32_t frame = 0; frame < bitstream.mBlockFrameIndexBounds[block]; frame++) {
00400                     VirtexFrameBlocks::word_t* words = const_cast<VirtexFrameBlocks::word_t*>(bitstream.mFrameBlocks.mBlock[block][frame]->getWords());
00401                     for (uint32_t index = 0; index < frameLength; index++) {
00402                         *ptr++ = words[index];
00403                     }
00404                 }
00405             }
00406         }
00407     }
00408     // write the test bitstream back out
00409     std::fstream outputStream(generatedPath.string().c_str(), std::ios::binary | std::ios::out);
00410     BOOST_REQUIRE(outputStream.good());
00411     bitstream.write(outputStream);
00412     outputStream.flush();
00413     BOOST_REQUIRE(torc::common::fileContentsAreEqual(referencePath, generatedPath));
00414 
00415     return;
00416 }
00417 
00418 
00419 
00420 
00421 
00422 /*
00423 /// \brief Unit test for the Virtex4 static device info generation.
00424 BOOST_AUTO_TEST_CASE(Virtex4GenerateUnitTest) {
00425 
00426     Virtex4 bitstream;
00427     DeviceInfoHelper::buildFamilyDeviceInfo("Virtex4", "Virtex4DeviceInfo.template", 
00428         "Virtex4DeviceInfo.cpp", torc::common::Devices::getVirtex4Devices(), bitstream);
00429 
00430 }
00431 */
00432 
00433 BOOST_AUTO_TEST_SUITE_END()
00434 
00435 } // namespace bitstream
00436 } // namespace torc