TORC: torc/bitstream/Spartan3EUnitTest.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/Spartan3EUnitTest.cpp $
00003 // $Id: Spartan3EUnitTest.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 Spartan3E class.
00018 
00019 #include <boost/test/unit_test.hpp>
00020 #include "torc/bitstream/Spartan3E.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 
00038 /// \brief Unit test for the Spartan3E class.
00039 BOOST_AUTO_TEST_CASE(Spartan3EUnitTest) {
00040 
00041     // enums tested:
00042     //      EPacket
00043     //      EFar
00044     boost::uint32_t mask;
00045     // type 1 packet subfield masks
00046     mask = Spartan3E::ePacketMaskType + Spartan3E::ePacketMaskOpcode 
00047         + Spartan3E::ePacketMaskType1Address + Spartan3E::ePacketMaskType1Reserved 
00048         + Spartan3E::ePacketMaskType1Count;
00049     BOOST_CHECK_EQUAL(mask, 0xFFFFFFFFu);
00050     // type 2 packet subfield masks
00051     mask = Spartan3E::ePacketMaskType + Spartan3E::ePacketMaskOpcode 
00052         + Spartan3E::ePacketMaskType2Count;
00053     BOOST_CHECK_EQUAL(mask, 0xFFFFFFFFu);
00054     // frame address register subfield masks
00055     mask = Spartan3E::eFarMaskColumn + Spartan3E::eFarMaskMajor + Spartan3E::eFarMaskMinor;
00056     BOOST_CHECK_EQUAL(mask, 0x07FFFE00u);
00057 
00058     // members tested:
00059     //      Spartan3E::sPacketTypeName and EPacketTypeName
00060     BOOST_CHECK_EQUAL(Spartan3E::sPacketTypeName[0],                            "[UNKNOWN TYPE 0]");
00061     BOOST_CHECK_EQUAL(Spartan3E::sPacketTypeName[Spartan3E::ePacketType1],      "TYPE1");
00062     BOOST_CHECK_EQUAL(Spartan3E::sPacketTypeName[Spartan3E::ePacketType2],      "TYPE2");
00063     BOOST_CHECK_EQUAL(Spartan3E::sPacketTypeName[3],                            "[UNKNOWN TYPE 3]");
00064     BOOST_CHECK_EQUAL(Spartan3E::sPacketTypeName[4],                            "[UNKNOWN TYPE 4]");
00065     BOOST_CHECK_EQUAL(Spartan3E::sPacketTypeName[5],                            "[UNKNOWN TYPE 5]");
00066     BOOST_CHECK_EQUAL(Spartan3E::sPacketTypeName[6],                            "[UNKNOWN TYPE 6]");
00067     BOOST_CHECK_EQUAL(Spartan3E::sPacketTypeName[7],                            "[UNKNOWN TYPE 7]");
00068 
00069     // members tested:
00070     //      Spartan3E::sOpcodeName and EOpcode
00071     BOOST_CHECK_EQUAL(Spartan3E::sOpcodeName[Spartan3E::eOpcodeNOP],            "NOP");
00072     BOOST_CHECK_EQUAL(Spartan3E::sOpcodeName[Spartan3E::eOpcodeRead],           "READ");
00073     BOOST_CHECK_EQUAL(Spartan3E::sOpcodeName[Spartan3E::eOpcodeWrite],          "WRITE");
00074     BOOST_CHECK_EQUAL(Spartan3E::sOpcodeName[Spartan3E::eOpcodeReserved],       "RESERVED");
00075 
00076     // members tested:
00077     //      Spartan3E::sRegisterName and ERegister
00078     BOOST_CHECK_EQUAL(Spartan3E::sRegisterName[Spartan3E::eRegisterCRC],        "CRC");
00079     BOOST_CHECK_EQUAL(Spartan3E::sRegisterName[Spartan3E::eRegisterFAR],        "FAR");
00080     BOOST_CHECK_EQUAL(Spartan3E::sRegisterName[Spartan3E::eRegisterFDRI],       "FDRI");
00081     BOOST_CHECK_EQUAL(Spartan3E::sRegisterName[Spartan3E::eRegisterFDRO],       "FDRO");
00082     BOOST_CHECK_EQUAL(Spartan3E::sRegisterName[Spartan3E::eRegisterCMD],        "CMD");
00083     BOOST_CHECK_EQUAL(Spartan3E::sRegisterName[Spartan3E::eRegisterCTL],        "CTL");
00084     BOOST_CHECK_EQUAL(Spartan3E::sRegisterName[Spartan3E::eRegisterMASK],       "MASK");
00085     BOOST_CHECK_EQUAL(Spartan3E::sRegisterName[Spartan3E::eRegisterSTAT],       "STAT");
00086     BOOST_CHECK_EQUAL(Spartan3E::sRegisterName[Spartan3E::eRegisterLOUT],       "LOUT");
00087     BOOST_CHECK_EQUAL(Spartan3E::sRegisterName[Spartan3E::eRegisterCOR],        "COR");
00088     BOOST_CHECK_EQUAL(Spartan3E::sRegisterName[Spartan3E::eRegisterMFWR],       "MFWR");
00089     BOOST_CHECK_EQUAL(Spartan3E::sRegisterName[Spartan3E::eRegisterFLR],        "FLR");
00090     BOOST_CHECK_EQUAL(Spartan3E::sRegisterName[Spartan3E::eRegisterIDCODE],     "IDCODE");
00091 
00092     // members tested:
00093     //      Spartan3E::sCommandName and ECommand
00094     BOOST_CHECK_EQUAL(Spartan3E::sCommandName[Spartan3E::eCommandWCFG],         "WCFG");
00095     BOOST_CHECK_EQUAL(Spartan3E::sCommandName[Spartan3E::eCommandMFWR],         "MFWR");
00096     BOOST_CHECK_EQUAL(Spartan3E::sCommandName[Spartan3E::eCommandLFRM],         "LFRM");
00097     BOOST_CHECK_EQUAL(Spartan3E::sCommandName[Spartan3E::eCommandRCFG],         "RCFG");
00098     BOOST_CHECK_EQUAL(Spartan3E::sCommandName[Spartan3E::eCommandSTART],        "START");
00099     BOOST_CHECK_EQUAL(Spartan3E::sCommandName[Spartan3E::eCommandRCAP],         "RCAP");
00100     BOOST_CHECK_EQUAL(Spartan3E::sCommandName[Spartan3E::eCommandRCRC],         "RCRC");
00101     BOOST_CHECK_EQUAL(Spartan3E::sCommandName[Spartan3E::eCommandAGHIGH],       "AGHIGH");
00102     BOOST_CHECK_EQUAL(Spartan3E::sCommandName[Spartan3E::eCommandSWITCH],       "SWITCH");
00103     BOOST_CHECK_EQUAL(Spartan3E::sCommandName[Spartan3E::eCommandGRESTORE],     "GRESTORE");
00104     BOOST_CHECK_EQUAL(Spartan3E::sCommandName[Spartan3E::eCommandSHUTDOWN],     "SHUTDOWN");
00105     BOOST_CHECK_EQUAL(Spartan3E::sCommandName[Spartan3E::eCommandGCAPTURE],     "GCAPTURE");
00106     BOOST_CHECK_EQUAL(Spartan3E::sCommandName[Spartan3E::eCommandDESYNCH],      "DESYNCH");
00107 
00108     // build the file paths
00109     boost::filesystem::path regressionPath 
00110         = torc::common::DirectoryTree::getExecutablePath() / "regression";
00111     boost::filesystem::path generatedPath = regressionPath / "Spartan3EUnitTest.generated.bit";
00112     boost::filesystem::path referencePath = regressionPath / "Spartan3EUnitTest.reference.bit";
00113 
00114     // read the bitstream
00115     std::fstream fileStream(referencePath.string().c_str(), std::ios::binary | std::ios::in);
00116     BOOST_REQUIRE(fileStream.good());
00117     Spartan3E bitstream;
00118     bitstream.read(fileStream, false);
00119     // write the bitstream digest to the console
00120     std::cout << bitstream << std::endl;
00121 
00122     std::string designName = bitstream.getDesignName();
00123     std::string deviceName = bitstream.getDeviceName();
00124     std::string designDate = bitstream.getDesignDate();
00125     std::string designTime = bitstream.getDesignTime();
00126     torc::common::DeviceDesignator deviceDesignator(deviceName);
00127     std::cout << "family of " << deviceName << " is " << deviceDesignator.getFamily() << std::endl;
00128 
00129     // write the bitstream back out
00130     std::fstream outputStream(generatedPath.string().c_str(), std::ios::binary | std::ios::out);
00131     BOOST_REQUIRE(outputStream.good());
00132     bitstream.write(outputStream);
00133     outputStream.flush();
00134 
00135     // compare the reference and generated XDL
00136     BOOST_CHECK(torc::common::fileContentsAreEqual(generatedPath, referencePath));
00137 }
00138 
00139 
00140 
00141 
00142 
00143 
00144 
00145 
00146 
00147 
00148 
00149 
00150 
00151 
00152 
00153 
00154 
00155 
00156 
00157 
00158 
00159 
00160 
00161 
00162 
00163 
00164 
00165 
00166 
00167 
00168 
00169 
00170 
00171 
00172 
00173 
00174 
00175 
00176 
00177 void testSpartan3EDevice(const std::string& inDeviceName, const boost::filesystem::path& inWorkingPath);
00178 
00179 /// \brief Unit test for the Spartan3E class Frame Address Register mapping.
00180 BOOST_AUTO_TEST_CASE(Spartan3EFarUnitTest) {
00181 
00182     // look up the command line arguments
00183     int& argc = boost::unit_test::framework::master_test_suite().argc;
00184     char**& argv = boost::unit_test::framework::master_test_suite().argv;
00185     // make sure that we at least have the name under which we were invoked
00186     BOOST_REQUIRE(argc >= 1);
00187     // resolve symbolic links if applicable
00188     torc::common::DirectoryTree directoryTree(argv[0]);
00189 
00190     // iterate over the devices
00191     const torc::common::DeviceVector& devices = torc::common::Devices::getSpartan3EDevices();
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         testSpartan3EDevice(device, torc::common::DirectoryTree::getWorkingPath());
00199     }
00200 }
00201 
00202 /*
00203     class TileTypeWidths {
00204     public:
00205         uint32_t mWidth[8];
00206         TileTypeWidths(uint32_t in0 = 0, uint32_t in1 = 0, uint32_t in2 = 0, uint32_t in3 = 0, 
00207             uint32_t in4 = 0, uint32_t in5 = 0, uint32_t in6 = 0, uint32_t in7 = 0) {
00208             int i = 0;
00209             mWidth[i++] = in0; mWidth[i++] = in1; mWidth[i++] = in2; mWidth[i++] = in3;
00210             mWidth[i++] = in4; mWidth[i++] = in5; mWidth[i++] = in6; mWidth[i++] = in7;
00211         }
00212         void clear(void) { for(int i = 0; i < 8; i++) mWidth[i] = 0; }
00213         uint32_t operator[] (int inIndex) const { return mWidth[inIndex]; }
00214     };
00215 */
00216 
00217     std::ostream& operator<< (std::ostream& os, const Spartan3E::FrameAddress& rhs);
00218     std::ostream& operator<< (std::ostream& os, const Spartan3E::FrameAddress& rhs) {
00219         return os << rhs.mColumn << "(" << rhs.mMajor << "." << rhs.mMinor << ")";
00220     }
00221 
00222 void testSpartan3EDevice(const std::string& inDeviceName, const boost::filesystem::path& inWorkingPath) {
00223 
00224     // build the file paths
00225     boost::filesystem::path debugBitstreamPath = inWorkingPath / "torc" / "bitstream" / "regression";
00226     //boost::filesystem::path generatedPath = debugBitstreamPath / (inDeviceName + ".debug.bit");
00227     boost::filesystem::path referencePath = debugBitstreamPath / (inDeviceName + ".debug.bit");
00228 std::cerr << "TRYING TO FIND " << referencePath << std::endl;
00229 
00230     // read the bitstream
00231     std::fstream fileStream(referencePath.string().c_str(), std::ios::binary | std::ios::in);
00232     std::cerr << "Trying to read: " << referencePath << std::endl;
00233     BOOST_REQUIRE(fileStream.good());
00234     Spartan3E bitstream;
00235     bitstream.read(fileStream, false);
00236     // write the bitstream digest to the console
00237     //std::cout << bitstream << std::endl;
00238 
00239 //  // initialize the bitstream frame maps
00240 //  boost::filesystem::path deviceColumnsPath = inWorkingPath / "regression" 
00241 //      / (inDeviceName + ".cpp");
00242 //  std::fstream deviceColumnsStream(deviceColumnsPath.string().c_str(), std::ios::out);
00243     bitstream.initializeDeviceInfo(inDeviceName);
00244     bitstream.initializeFrameMaps();
00245 
00246     // iterate through the packets, and extract all of the FARs
00247     Spartan3E::FrameAddressToIndex farRemaining = bitstream.mFrameAddressToIndex;
00248     Spartan3E::FrameAddressToIndex farVisited;
00249     {
00250         bool first = true;
00251         Spartan3E::const_iterator p = bitstream.begin();
00252         Spartan3E::const_iterator e = bitstream.end();
00253         uint32_t header = SpartanPacket::makeHeader(SpartanPacket::ePacketType1, 
00254             SpartanPacket::eOpcodeWrite, Spartan3E::eRegisterLOUT, 1);
00255         while(p < e) {
00256             const SpartanPacket& packet = *p++;
00257             if(packet.getHeader() != header) continue;
00258             if(first) { first = false; continue; }
00259             Spartan3E::FrameAddress far = packet[1];
00260             //std::cout << std::endl << "Debug Far Address: " << Hex32(packet[1]) << std::endl;
00261             farVisited[far] = 0;
00262             Spartan3E::FrameAddressToIndex::iterator found = farRemaining.find(far);
00263             if(found != farRemaining.end()) {
00264                 farRemaining.erase(found);
00265             } else {
00266                 std::cerr << "missing " << far << " ";
00267             }
00268         }
00269     }
00270     {
00271         std::cerr << std::endl;
00272         Spartan3E::FrameAddressToIndex::const_iterator p = farRemaining.begin();
00273         Spartan3E::FrameAddressToIndex::const_iterator e = farRemaining.end();
00274         while(p != e) {
00275             std::cerr << "remaining " << p->first << " ";
00276             p++;
00277         }
00278         std::cerr << std::endl;
00279     }
00280     // verify that we have visited all of the expected FARs and no others
00281     std::cout << "Device: " << inDeviceName << std::endl;
00282     std::cout << "Size of farRemaining: " << farRemaining.size() << std::endl;
00283     std::cout << "Size of farVisited: " << farVisited.size() << std::endl;
00284     BOOST_REQUIRE_EQUAL(bitstream.mFrameAddressToIndex.size(), farVisited.size());
00285     BOOST_REQUIRE_EQUAL(farRemaining.size(), 0u);
00286 
00287 return;
00288 }
00289 
00290 
00291 
00292 
00293 
00294 
00295 /*
00296 /// \brief Unit test for the Spartan3E static device info generation.
00297 BOOST_AUTO_TEST_CASE(Spartan3EGenerateUnitTest) {
00298 
00299     Spartan3E bitstream;
00300     DeviceInfoHelper::buildFamilyDeviceInfo("Spartan3E", "Spartan3EDeviceInfo.template", 
00301         "Spartan3EDeviceInfo.cpp", torc::common::Devices::getSpartan3EDevices(), bitstream);
00302 
00303 }
00304 */
00305 
00306 BOOST_AUTO_TEST_SUITE_END()
00307 
00308 } // namespace bitstream
00309 } // namespace torc