TORC: torc/unused/scratch.cpp Source File

00001 // TORC - Copyright 2010 University of Southern California.  All Rights Reserved.
00002 // $HeadURL: https://svn.east.isi.edu/torc/trunk/src/torc/unused/scratch.cpp $
00003 // $Id: scratch.cpp 32 2010-07-17 04:52:11Z nsteiner $
00004 
00005 #if 0
00006 #include "torc/physical/xdl/parser.h"
00007 #include "torc/physical/Named.hpp"
00008 #include "torc/physical/Config.hpp"
00009 #include "torc/physical/ConfigMap.hpp"
00010 #include "torc/physical/Routethrough.hpp"
00011 #include "torc/physical/Net.hpp"
00012 #include "torc/physical/InstancePin.hpp"
00013 #include "torc/physical/Instance.hpp"
00014 #include "torc/physical/Pip.hpp"
00015 #include "torc/physical/Module.hpp"
00016 #include "torc/physical/Design.hpp"
00017 
00018 #include <boost/test/unit_test.hpp>
00019 #include "OutputStreamHelpers.hpp"
00020 #include <vector>
00021 #include <iostream>
00022 #include <sstream>
00023 #include <algorithm>
00024 
00025 
00026 namespace torc {
00027 namespace physical {
00028 
00029 
00030 BOOST_AUTO_TEST_SUITE(physical_database)
00031 
00032 /// \brief Unit test of scratch work.
00033 BOOST_AUTO_TEST_CASE(scratch) {
00034     // create a design and verify it
00035     const char* designName = "design";
00036     Design design(designName);
00037     BOOST_CHECK_EQUAL(designName, design.getName());
00038 
00039     // create a module and verify it
00040     const char* moduleName = "module";
00041     Module module(moduleName);
00042     BOOST_CHECK_EQUAL(moduleName, module.getName());
00043 
00044     // create an instance and verify it
00045     const char* instanceName = "instance";
00046     Instance instance(instanceName);
00047     BOOST_CHECK_EQUAL(instanceName, instance.getName());
00048 
00049     // create a net and verify it
00050     const char* netName = "net";
00051     Net net(netName, eNetTypePower);
00052     BOOST_CHECK_EQUAL(netName, net.getName());
00053     BOOST_CHECK_EQUAL(eNetTypePower, net.getNetType());
00054 
00055     // change the net type and verity it
00056     net.setNetType(eNetTypeNormal);
00057     BOOST_CHECK_EQUAL(eNetTypeNormal, net.getNetType());
00058 
00059     // create some instance pins
00060     InstancePin instancePin1(instance, "pin1");
00061     InstancePin instancePin2(instance, "pin2");
00062 
00063     // add the instance pins to a net
00064     net.addSource(instancePin1);
00065     net.addSink(instancePin2);
00066     BOOST_CHECK(net.hasAnySources());
00067     BOOST_CHECK(net.hasOneSource());
00068     BOOST_CHECK(net.hasMultipleSources() == false);
00069     BOOST_CHECK(net.hasAnySinks());
00070     BOOST_CHECK(net.hasOneSink());
00071     BOOST_CHECK(net.hasMultipleSinks() == false);
00072     // verify that the pins show up in the net
00073     InstancePinVector::const_iterator sourcesBegin = net.sourcesBegin();
00074     InstancePinVector::const_iterator sourcesEnd = net.sourcesEnd();
00075     InstancePinVector::const_iterator sinksBegin = net.sinksBegin();
00076     InstancePinVector::const_iterator sinksEnd = net.sinksEnd();
00077     BOOST_CHECK_EQUAL(*sourcesBegin, instancePin1);
00078     BOOST_CHECK_EQUAL(*sinksBegin, instancePin2);
00079     BOOST_CHECK(net.containsSource(instancePin1));
00080     BOOST_CHECK(net.containsSource(instancePin2) == false);
00081     BOOST_CHECK(net.containsSink(instancePin1) == false);
00082     BOOST_CHECK(net.containsSink(instancePin2));
00083 
00084     // remove the instance pins from the net
00085     BOOST_CHECK(net.removeSource(instancePin1)); // should be found and removed
00086     BOOST_CHECK(net.removeSource(instancePin2) == false); // should not be found
00087     BOOST_CHECK(net.removeSink(instancePin1) == false); // should not be found
00088     BOOST_CHECK(net.removeSink(instancePin2)); // should be found and removed
00089     sourcesBegin = net.sourcesBegin();
00090     sourcesEnd = net.sourcesEnd();
00091     sinksBegin = net.sinksBegin();
00092     sinksEnd = net.sinksEnd();
00093     BOOST_CHECK_EQUAL(sourcesBegin, sourcesEnd);
00094     BOOST_CHECK_EQUAL(sinksBegin, sinksEnd);
00095     BOOST_CHECK(net.hasAnySources() == false);
00096     BOOST_CHECK(net.hasOneSource() == false);
00097     BOOST_CHECK(net.hasMultipleSources() == false);
00098     BOOST_CHECK(net.hasAnySinks() == false);
00099     BOOST_CHECK(net.hasOneSink() == false);
00100     BOOST_CHECK(net.hasMultipleSinks() == false);
00101 
00102     // create some pips
00103     Pip pip1("tile1", "source1", "sink1", ePipUnidirectionalBuffered);
00104     Pip pip2("tile2", "source2", "sink2", ePipUnidirectionalBuffered);
00105     // create a routethrough
00106     Routethrough routethrough("setting", "name", "value", instance, "source", "sink");
00107 
00108     // add the pips to the net
00109     net.addPip(pip1);
00110     net.addPip(pip2, routethrough);
00111     BOOST_CHECK(net.containsPip(pip1));
00112     BOOST_CHECK(net.containsPip(pip2));
00113     
00114     BOOST_CHECK(pip1.isRoutethrough() == false);
00115     BOOST_CHECK(pip2.isRoutethrough() == false);
00116     PipVector::const_iterator pipsBegin = net.pipsBegin();
00117     PipVector::const_iterator pipsEnd = net.pipsEnd();
00118     BOOST_CHECK((pipsBegin++)->isRoutethrough() == false);
00119     BOOST_CHECK((pipsBegin++)->isRoutethrough());
00120 
00121     // remove the pips from the net
00122     BOOST_CHECK(net.removePip(pip1));
00123     BOOST_CHECK(net.removePip(pip2));
00124     BOOST_CHECK(net.containsPip(pip1) == false);
00125     BOOST_CHECK(net.containsPip(pip2) == false);
00126     pipsBegin = net.pipsBegin();
00127     pipsEnd = net.pipsEnd();
00128     BOOST_CHECK_EQUAL(pipsBegin, pipsEnd);
00129 
00130     // create some config entries
00131     Config config1("name1", "value1");
00132     Config config2("name2", "value2");
00133     Config config3("name3", "value3");
00134     Config config4("name4", "value4");
00135     // create a config map and add config entries to it
00136     ConfigMap configMap;
00137     configMap.setConfig("config", config1);
00138     configMap.setConfig("config", config2);
00139     configMap.setConfig("_config", config3);
00140     configMap.setConfig("_config", config4);
00141     BOOST_CHECK(configMap.hasConfig("config"));
00142     BOOST_CHECK(configMap.hasConfig("_config"));
00143     BOOST_CHECK_EQUAL((size_t) 1, configMap.getMultiConfigCount("config"));
00144     BOOST_CHECK_EQUAL((size_t) 2, configMap.getMultiConfigCount("_config"));
00145     Config config5;
00146     configMap.getConfig("config", config5);
00147     BOOST_CHECK_EQUAL(config2, config5);
00148     ConfigMap::const_iterator p = configMap.begin();
00149     ConfigMap::const_iterator e = configMap.end();
00150     BOOST_CHECK_EQUAL(config3, p->second); p++;
00151     BOOST_CHECK_EQUAL(config4, p->second); p++;
00152     BOOST_CHECK_EQUAL(config2, p->second); p++;
00153     std::pair<ConfigMap::const_iterator, ConfigMap::const_iterator> range 
00154         = configMap.getMultiConfigValues("_config");
00155     p = range.first;
00156     e = range.second;
00157     while(p != e) {
00158         std::cout << p->first << ":" << p->second.getName() << ":" << p->second.getValue() << std::endl;
00159         p++;
00160     }
00161 
00162     // add the net and the instance to the module
00163     module.addInstance(instance);
00164     module.addNet(net);
00165     // add the module to the design
00166     design.addModule(module);
00167 
00168     // ensure that the module exists in the design
00169     ModuleVector::const_iterator modulesBegin = design.modulesBegin();
00170     ModuleVector::const_iterator modulesEnd = design.modulesEnd();
00171     BOOST_CHECK_EQUAL(*modulesBegin, module);
00172     // ensure that the instance and net exist in the module
00173     InstanceVector::const_iterator instancesBegin = module.instancesBegin();
00174     InstanceVector::const_iterator instancesEnd = module.instancesEnd();
00175     NetVector::const_iterator netsBegin = module.netsBegin();
00176     NetVector::const_iterator netsEnd = module.netsEnd();
00177     BOOST_CHECK_EQUAL(*instancesBegin, instance);
00178     BOOST_CHECK_EQUAL(*netsBegin, net);
00179 }
00180 
00181 BOOST_AUTO_TEST_SUITE_END()
00182 
00183 
00184 } // namespace physical
00185 } // namespace torc
00186 
00187 /*
00188 #include <boost/multi_index_container.hpp>
00189 #include <boost/multi_index/sequenced_index.hpp>
00190 #include <boost/multi_index/ordered_index.hpp>
00191 #include <boost/multi_index/indexed_by.hpp>
00192 
00193 using namespace boost::multi_index;
00194 
00195 struct name{};
00196 struct order{};
00197 typedef boost::multi_index::multi_index_container<
00198     std::string, 
00199     boost::multi_index::indexed_by<
00200         ordered_unique< tag<name>, identity<name> >,
00201         sequenced< tag<order> >
00202     >
00203 > ConfigMap;
00204 
00205 BOOST_AUTO_TEST_SUITE(physical_database)
00206 
00207 BOOST_AUTO_TEST_CASE(multi_index) {
00208     ConfigMap configMap;
00209     BOOST_CHECK(configMap.size() == 0);
00210 std::cout << "sizeof(boost::multi_index::multi_index_container): " << sizeof(torc::ConfigMap) << std::endl;
00211 std::cout << "sizeof(std::map<std::string,std::string>): " << sizeof(std::map<std::string,std::string>) << std::endl;
00212 std::cout << "sizeof(std::multimap<std::string,std::string>): " << sizeof(std::multimap<std::string,std::string>) << std::endl;
00213 std::cout << "sizeof(std::vector<torc::InstancePin>): " << sizeof(std::vector<torc::InstancePin>) << std::endl;
00214 std::cout << "sizeof(std::vector<torc::Pip>): " << sizeof(std::vector<torc::Pip>) << std::endl;
00215 std::cout << "sizeof(std::vector<std::string>): " << sizeof(std::vector<std::string>) << std::endl;
00216 
00217 }
00218 
00219 BOOST_AUTO_TEST_SUITE_END()
00220 */
00221 #endif