int main(int argc, char *argv[]){
int res = 0;
shrdPtr= (struct wonk*)malloc(sizeof(struct wonk));
shrdPtr->a = 1;
pthread_mutex_init(&lock,NULL);
START_TIME();
pthread_t acc[7],upd;
pthread_create(&acc[0],NULL,accessorThread,(void*)shrdPtr);
pthread_create(&acc[1],NULL,accessorThread,(void*)shrdPtr);
pthread_create(&acc[2],NULL,accessorThread,(void*)shrdPtr);
pthread_create(&acc[3],NULL,accessorThread,(void*)shrdPtr);
pthread_create(&acc[4],NULL,accessorThread,(void*)shrdPtr);
pthread_create(&acc[5],NULL,accessorThread,(void*)shrdPtr);
pthread_create(&acc[6],NULL,accessorThread,(void*)shrdPtr);
pthread_create(&upd,NULL,updaterThread,(void*)shrdPtr);
pthread_join(upd,NULL);
pthread_join(acc[0],(void*)&res);
pthread_join(acc[1],(void*)&res);
pthread_join(acc[2],(void*)&res);
pthread_join(acc[3],(void*)&res);
pthread_join(acc[4],(void*)&res);
pthread_join(acc[5],(void*)&res);
pthread_join(acc[6],(void*)&res);
STOP_TIME();
fprintf(stderr,"Final value of res was %d\n",res);
PRINT_TIME();
}
void framerate_clean()
{
if(!graf_init_lfb()) return;
START_TIME(timer);
for(int i = 0; i < 1000; i++) clear(i);
STOP_TIME(timer);
fps_clean = FPS(1000,timer);
graf_close();
}
DesignFlowStep_Status values_scheme::InternalExec()
{
long step_time;
START_TIME(step_time);
THROW_ASSERT(HLS->Rliv, "Liveness analysis not yet computed");
unsigned int i = 0;
const std::list<vertex> & support = HLS->Rliv->get_support();
const std::list<vertex>::const_iterator vEnd = support.end();
for(std::list<vertex>::const_iterator vIt = support.begin(); vIt != vEnd; vIt++)
{
//std::cerr << "current state for sv " << HLS->Rliv->get_name(*vIt) << std::endl;
const std::set<unsigned int>& live = HLS->Rliv->get_live_in(*vIt);
const std::set<unsigned int>::const_iterator k_end = live.end();
for(std::set<unsigned int>::const_iterator k = live.begin(); k != k_end; k++)
{
if(HLS->storage_value_information->storage_index_map.find(*k) == HLS->storage_value_information->storage_index_map.end())
{
HLS->storage_value_information->storage_index_map[*k] = i;
HLS->storage_value_information->variable_index_vect.push_back(*k);
i++;
}
}
}
HLS->storage_value_information->number_of_storage_values = i;
if(output_level <= OUTPUT_LEVEL_PEDANTIC)
INDENT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "");
INDENT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "-->Storage Value Information of function " + HLSMgr->CGetFunctionBehavior(funId)->CGetBehavioralHelper()->get_function_name() + ":");
INDENT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "---Number of storage values inserted: "+boost::lexical_cast<std::string>(i));
STOP_TIME(step_time);
if(output_level >= OUTPUT_LEVEL_MINIMUM and output_level <= OUTPUT_LEVEL_PEDANTIC)
INDENT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "Time to compute storage value information: " + print_cpu_time(step_time) + " seconds");
INDENT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "<--");
if(output_level <= OUTPUT_LEVEL_PEDANTIC)
INDENT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "");
return DesignFlowStep_Status::SUCCESS;
}
int main(int argc, char* argv[]) {
// if (argc != 7) {
// fprintf(stderr, "Usage: %s <N> <N> <block size> <block size> <index> <B|PW|SEQ>\n", argv[0]);
// return 1;
// }
parseInitializationType("SEQ");
long N = 100;
long BS = 20;
// long L = atol(argv[4]);
long L = 16;
if (BS > N) {
printf("0");
return 1;
}
typedef double (*m_t)[N/BS + 2][BS][BS];
m_t A = (m_t) alloc_and_gen_matrix(N + BS*2, BS);
for (int i=0; i<N/BS; ++i) {
for (int j=0; j<N/BS; ++j) {
for (int k=0; k<BS; ++k) {
for (int l=0; l<BS; ++l) {
//printf (" %f", A[i][j][k][l]);
}
}
// printf ("\n");
}
}
// printf ("\n");
#pragma omp taskwait
Extrae_init();
printf("extrae init\n");
START_TIME();
for (int iters=0; iters<L; iters++) {
for (long i=1; i <= N/BS; i++) {
for (long j=1; j <= N/BS; j++) {
wrapperxxxxxxx(i, j, (N+BS+BS), BS, A[i][j], A[i-1][j], A[i][j-1], A[i+1][j], A[i][j+1]);
}
}
}
printf("extrae fini\n");
Extrae_fini();
#pragma omp taskwait
STOP_TIME();
//#pragma omp critical
{
for (int iters=0; iters<N; iters++) {
for (int i=0; i <= N; i++) {
//printf (" %f", *A[iters][i]);
}
// printf ("\n");
}
// printf ("\n");
}
if (getenv("MEASURE_TIME") == NULL) {
// Megaelements per second
printf("%f", ((double)(L*N*N))/GET_TIME());
} else {
printf("%f", GET_TIME() / 1000000.0);
}
return 0;
}
DesignFlowStep_Status weighted_clique_register::InternalExec()
{
const FunctionBehaviorConstRef FB = HLSMgr->CGetFunctionBehavior(funId);
long step_time;
START_TIME(step_time);
const CliqueCovering_Algorithm clique_covering_algorithm = GetPointer<const WeightedCliqueRegisterBindingSpecialization>(hls_flow_step_specialization)->clique_covering_algorithm;
refcount< clique_covering<CG_vertex_descriptor> > register_clique = clique_covering<CG_vertex_descriptor>::create_solver(clique_covering_algorithm);
create_compatibility_graph();
std::vector<CG_vertex_descriptor>::const_iterator v_it_end = verts.end();
unsigned int vertex_index = 0;
unsigned int num_registers = 0;
for(std::vector<CG_vertex_descriptor>::const_iterator v_it = verts.begin(); v_it != v_it_end; ++v_it, ++vertex_index)
register_clique->add_vertex(*v_it, STR(vertex_index));
if(vertex_index>0)
{
boost::graph_traits<compatibility_graph>::edge_iterator cg_ei,cg_ei_end;
for(boost::tie(cg_ei,cg_ei_end) = boost::edges(CG); cg_ei != cg_ei_end; ++cg_ei)
{
CG_vertex_descriptor src = boost::source(*cg_ei, CG);
CG_vertex_descriptor tgt = boost::target(*cg_ei, CG);
register_clique->add_edge(src, tgt, CG[*cg_ei].weight);
}
if(parameters->getOption<bool>(OPT_print_dot))
{
const auto functionName = FB->CGetBehavioralHelper()->get_function_name();
const auto output_directory = parameters->getOption<std::string>(OPT_dot_directory) + "/" + functionName + "/";
if (!boost::filesystem::exists(output_directory))
boost::filesystem::create_directories(output_directory);
const auto file_name = output_directory + "HLS_RegisterBinding.dot";
register_clique->writeDot(file_name);
}
/// performing clique covering
no_check_clique<CG_vertex_descriptor> cq;
register_clique->exec(no_filter_clique<CG_vertex_descriptor>(), cq);
/// vertex to clique map
std::map<CG_vertex_descriptor, unsigned int> v2c;
/// retrieve the solution
num_registers = static_cast<unsigned int>(register_clique->num_vertices());
for (unsigned int i = 0; i < num_registers; ++i)
{
std::set<CG_vertex_descriptor> clique = register_clique->get_clique(i);
std::set<CG_vertex_descriptor>::const_iterator v_end = clique.end();
for (std::set<CG_vertex_descriptor>::const_iterator v = clique.begin(); v != v_end; ++v)
{
v2c[*v] = i;
}
}
/// finalize
HLS->Rreg = reg_bindingRef(new reg_binding(HLS, HLSMgr));
const std::list<vertex> & support = HLS->Rliv->get_support();
const std::list<vertex>::const_iterator vEnd = support.end();
for(std::list<vertex>::const_iterator vIt = support.begin(); vIt != vEnd; vIt++)
{
const std::set<unsigned int>& live = HLS->Rliv->get_live_in(*vIt);
std::set<unsigned int>::iterator k_end = live.end();
for(std::set<unsigned int>::iterator k = live.begin(); k != k_end; k++)
{
unsigned int storage_value_index = HLS->storage_value_information->get_storage_value_index(*vIt, *k);
HLS->Rreg->bind(storage_value_index, v2c[verts[storage_value_index]]);
}
}
}
else
{
HLS->Rreg = reg_bindingRef(new reg_binding(HLS, HLSMgr));
num_registers = 0;
}
HLS->Rreg->set_used_regs(num_registers);
STOP_TIME(step_time);
if(output_level <= OUTPUT_LEVEL_PEDANTIC)
INDENT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "");
INDENT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "-->Register binding information for function " + FB->CGetBehavioralHelper()->get_function_name() + ":");
INDENT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, std::string("---Register allocation algorithm obtains ") + (num_registers == register_lower_bound ? "an optimal" : "a sub-optimal") + " result: " + STR(num_registers) + " registers"+(num_registers == register_lower_bound?"":("(LB:"+STR(register_lower_bound)+")")));
if (output_level >= OUTPUT_LEVEL_VERY_PEDANTIC)
HLS->Rreg->print();
if(output_level >= OUTPUT_LEVEL_MINIMUM and output_level <= OUTPUT_LEVEL_PEDANTIC)
INDENT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "Time to perform register binding: " + print_cpu_time(step_time) + " seconds");
INDENT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "<--");
if(output_level <= OUTPUT_LEVEL_PEDANTIC)
INDENT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "");
return DesignFlowStep_Status::SUCCESS;
}
int main(int argc, char *argv[])
{
// Program name
ParameterRef parameters;
try
{
// ---------- General options ------------ //
// Synthesis cpu time
long total_time;
START_TIME(total_time);
// General options register
// ---------- Initialization ------------ //
// ---------- Parameter parsing ------------ //
long cpu_time;
START_TIME(cpu_time);
parameters = ParameterRef(new EucalyptusParameter(argv[0], argc, argv));
switch(parameters->Exec())
{
case PARAMETER_NOTPARSED:
{
exit_code = PARAMETER_NOTPARSED;
throw "Bad Parameters format";
}
case EXIT_SUCCESS:
{
if(not (parameters->getOption<bool>(OPT_no_clean)))
{
boost::filesystem::remove_all(parameters->getOption<std::string>(OPT_output_temporary_directory));
}
return EXIT_SUCCESS;
}
case PARAMETER_PARSED:
{
exit_code = EXIT_FAILURE;
break;
}
default:
{
THROW_ERROR("Bad Parameters parsing");
}
}
int output_level = parameters->getOption<int>(OPT_output_level);
STOP_TIME(cpu_time);
if(output_level >= OUTPUT_LEVEL_MINIMUM)
parameters->PrintFullHeader(std::cerr);
/// eucalyptus does not perform a clock constrained synthesis
if(!parameters->isOption(OPT_clock_period))
parameters->setOption(OPT_clock_period, 0.0);
// Technology library manager
technology_managerRef TM = technology_managerRef(new technology_manager(parameters));
///creating the datastructure representing the target device
const auto target_device = static_cast<TargetDevice_Type>(parameters->getOption<unsigned int>(OPT_target_device_type));
target_deviceRef device = target_device::create_device(target_device, parameters, TM);
device->set_parameter("clock_period", parameters->getOption<double>(OPT_clock_period));
target_managerRef target = target_managerRef(new target_manager(parameters, TM, device));
const DesignFlowManagerRef design_flow_manager(new DesignFlowManager(parameters));
const DesignFlowGraphConstRef design_flow_graph = design_flow_manager->CGetDesignFlowGraph();
const DesignFlowStepFactoryConstRef technology_flow_step_factory(new TechnologyFlowStepFactory(TM, device, design_flow_manager, parameters));
design_flow_manager->RegisterFactory(technology_flow_step_factory);
const std::string technology_flow_signature = TechnologyFlowStep::ComputeSignature(TechnologyFlowStep_Type::LOAD_TECHNOLOGY);
const vertex technology_flow_step = design_flow_manager->GetDesignFlowStep(technology_flow_signature);
const DesignFlowStepRef technology_design_flow_step = technology_flow_step ? design_flow_graph->CGetDesignFlowStepInfo(technology_flow_step)->design_flow_step : GetPointer<const TechnologyFlowStepFactory>(technology_flow_step_factory)->CreateTechnologyFlowStep(TechnologyFlowStep_Type::LOAD_TECHNOLOGY);
design_flow_manager->AddStep(technology_design_flow_step);
#if HAVE_XILINX || HAVE_ALTERA || HAVE_LATTICE || HAVE_DESIGN_COMPILER
if(parameters->isOption(OPT_component_name))
{
const DesignFlowStepRef design_flow_step(new RTLCharacterization(target, parameters->getOption<std::string>(OPT_component_name), design_flow_manager, parameters));
design_flow_manager->AddStep(design_flow_step);
}
#endif
design_flow_manager->Exec();
#if HAVE_EXPERIMENTAL
if (parameters->isOption(OPT_import_ip_core))
{
START_TIME(cpu_time);
std::string core_hdl = parameters->getOption<std::string>(OPT_import_ip_core);
core_generationRef core_gen = core_generationRef(new core_generation(parameters));
core_gen->convert_to_XML(core_hdl, device->get_type());
STOP_TIME(cpu_time);
PRINT_OUT_MEX(DEBUG_LEVEL_MINIMUM, output_level, " ==== Core generation performed in " + print_cpu_time(cpu_time) + " seconds; ====\n");
}
if (parameters->isOption(OPT_export_ip_core))
{
START_TIME(cpu_time);
std::string core_name = parameters->getOption<std::string>(OPT_export_ip_core);
core_generationRef core_gen = core_generationRef(new core_generation(parameters));
core_gen->export_core(TM, core_name);
STOP_TIME(cpu_time);
PRINT_OUT_MEX(DEBUG_LEVEL_MINIMUM, output_level, " ==== Core exported in " + print_cpu_time(cpu_time) + " seconds; ====\n");
}
#endif
STOP_TIME(total_time);
PRINT_MSG(" ==== Total Execution Time: " + print_cpu_time(total_time) + " seconds; ====\n");
if(not (parameters->getOption<bool>(OPT_no_clean)))
{
boost::filesystem::remove_all(parameters->getOption<std::string>(OPT_output_temporary_directory));
}
return EXIT_SUCCESS; // Eucalyptus tool has completed execution without errors
}
// exception catching
catch (const char * str)
{
std::cerr << str << std::endl;
}
catch (const std::string& str)
{
std::cerr << str << std::endl;
}
catch (std::exception &e)
{
std::cerr << e.what() << std::endl;
}
catch (...)
{
std::cerr << "Unknown error type" << std::endl;
}
switch(exit_code)
{
case PARAMETER_NOTPARSED:
{
parameters->PrintUsage(std::cout);
break;
}
case EXIT_FAILURE:
{
parameters->PrintBugReport(std::cout);
break;
}
default:
{
}
}
if(parameters and not (parameters->getOption<bool>(OPT_no_clean)))
{
boost::filesystem::remove_all(parameters->getOption<std::string>(OPT_output_temporary_directory));
}
return exit_code;
}
syntax_error *lang_CPP::definitionsModified(const char* wscode, const char* targetYaml)
{
cout << "Parsing settings..." << endl;
parse_ide_settings(targetYaml);
cout << targetYaml << endl;
cout << "Creating swap." << endl;
delete main_context;
main_context = new jdi::context();
cout << "Dumping whiteSpace definitions..." << endl;
FILE *of = wscode ? fopen((makedir +"Preprocessor_Environment_Editable/IDE_EDIT_whitespace.h").c_str(),"wb") : NULL;
if (of) fputs(wscode,of), fclose(of);
cout << "Opening ENIGMA for parse..." << endl;
llreader f("ENIGMAsystem/SHELL/SHELLmain.cpp");
int res = 1;
DECLARE_TIME();
if (f.is_open()) {
START_TIME();
res = main_context->parse_C_stream(f, "SHELLmain.cpp");
STOP_TIME();
}
jdi::definition *d;
if ((d = main_context->get_global()->look_up("variant"))) {
enigma_type__variant = d;
if (!(d->flags & jdi::DEF_TYPENAME))
cerr << "ERROR! ENIGMA's variant is not a type!" << endl;
else
cout << "Successfully loaded builtin variant type" << endl;
} else cerr << "ERROR! No variant type found!" << endl;
if ((d = main_context->get_global()->look_up("var"))) {
enigma_type__var = d;
if (!(d->flags & jdi::DEF_TYPENAME))
cerr << "ERROR! ENIGMA's var is not a type!" << endl;
else
cout << "Successfully loaded builtin var type" << endl;
} else cerr << "ERROR! No var type found!" << endl;
if ((d = main_context->get_global()->look_up("enigma"))) {
if (d->flags & jdi::DEF_NAMESPACE) {
if ((d = ((jdi::definition_scope*)d)->look_up("varargs"))) {
enigma_type__varargs = d;
if (!(d->flags & jdi::DEF_TYPENAME))
cerr << "ERROR! ENIGMA's varargs is not a type!" << endl;
else
cout << "Successfully loaded builtin varargs type" << endl;
} else cerr << "ERROR! No varargs type found!" << endl;
} else cerr << "ERROR! Namespace enigma is... not a namespace!" << endl;
} else cerr << "ERROR! Namespace enigma not found!" << endl;
if (res) {
cout << "ERROR in parsing engine file: The parser isn't happy. Don't worry, it's never happy.\n";
cout << heaping_pile_of_dog_shit;
ide_passback_error.set(0,0,0,"Parse failed; details in stdout. Bite me.");
cout << "Continuing anyway." << endl;
// return &ide_passback_error;
} else {
cout << "Successfully parsed ENIGMA's engine (" << PRINT_TIME() << "ms)\n"
<< "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
//cout << "Namespace std contains " << global_scope.members["std"]->members.size() << " items.\n";
}
cout << "Creating dummy primitives for old ENIGMA" << endl;
for (jdip::tf_iter it = jdip::builtin_declarators.begin(); it != jdip::builtin_declarators.end(); ++it) {
main_context->get_global()->members[it->first] = new jdi::definition(it->first, main_context->get_global(), jdi::DEF_TYPENAME);
}
cout << "Initializing EDL Parser...\n";
parser_init();
cout << "Grabbing locals...\n";
shared_locals_load(requested_extensions);
cout << "Determining build target...\n";
extensions::determine_target();
cout << " Done.\n";
return &ide_passback_error;
}
void read_technology_library(technology_managerRef TM, const ParameterConstRef Param, const target_deviceRef device)
{
#if HAVE_EXPERIMENTAL || HAVE_FROM_LIBERTY || HAVE_LIBRARY_COMPILER
int output_level = Param->getOption<int>(OPT_output_level);
#endif
#ifndef NDEBUG
int debug_level = Param->get_class_debug_level("parse_technology");
#endif
#if HAVE_FROM_LIBERTY
//parsing of liberty format
if (Param->isOption(OPT_input_liberty_library_file))
{
long lib2xmlTime;
std::string LibFile = Param->getOption<std::string>(OPT_input_liberty_library_file);
std::string XmlList;
std::vector<std::string> SplittedLibs;
boost::algorithm::split(SplittedLibs, LibFile, boost::algorithm::is_any_of(";"));
for (unsigned int i = 0; i < SplittedLibs.size(); i++)
{
if (SplittedLibs.size() == 0) continue;
boost::trim(SplittedLibs[i]);
std::vector<std::string> SplittedLib;
boost::algorithm::split(SplittedLib, SplittedLibs[i], boost::algorithm::is_any_of(":"));
std::string LibraryFile, LibraryName;
if (SplittedLib.size() < 1 or SplittedLib.size() > 2)
THROW_ERROR("Malformed input liberty description: \"" + SplittedLibs[i] + "\"");
if (SplittedLib.size() == 1)
{
LibraryFile = SplittedLib[0];
}
else
{
LibraryName = SplittedLib[0];
LibraryFile = SplittedLib[1];
}
if (!boost::filesystem::exists(LibraryFile))
THROW_ERROR("Liberty file \"" + LibraryFile + "\" does not exists!");
START_TIME(lib2xmlTime);
std::string TargetXML = Param->getOption<std::string>(OPT_output_temporary_directory) + "/library_" + boost::lexical_cast<std::string>(i) + ".xml";
lib2xml(LibraryFile, TargetXML, Param);
if (XmlList.size()) XmlList += ";";
XmlList += TargetXML;
STOP_TIME(lib2xmlTime);
PRINT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "(koala) Read and converted the liberty file \"" + LibraryFile + "\" in "
+ boost::lexical_cast<std::string>(print_cpu_time(lib2xmlTime)) + " seconds;\n");
}
///FIXME: setting parameters
const_cast<Parameter *>(Param.get())->setOption("input_xml_library_file", XmlList);
}
#endif
#if HAVE_BOOLEAN_PARSER_BUILT
if (Param->isOption("input_genlib_library_file"))
{
long genlibTime;
START_TIME(genlibTime);
PRINT_DBG_MEX(DEBUG_LEVEL_VERBOSE, debug_level, "(koala) Reading the genlib technology library");
std::string LibraryName = Param->getOption<std::string>("genlib_library_file");
technology_managerRef local_TM = technology_managerRef(new technology_manager(Param));
read_genlib_technology_File(LibraryName, local_TM, Param);
STOP_TIME(genlibTime);
PRINT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "(koala) Read the technology library file \"" + LibraryName + "\" in "
+ boost::lexical_cast<std::string>(print_cpu_time(genlibTime)) + " seconds;\n");
write_technology_File(technology_manager::XML, "genlib", local_TM, device->get_type());
///FIXME: setting parameters
const_cast<Parameter *>(Param.get())->setOption("input_xml_library_file", "genlib.xml");
const_cast<Parameter *>(Param.get())->removeOption("input_genlib_library_file");
}
#endif
if (Param->isOption("input_xml_library_file"))
{
PRINT_DBG_MEX(DEBUG_LEVEL_VERBOSE, debug_level, "(koala) Reading the XML technology library");
std::string LibraryName;
std::string XmlLibraryList = Param->getOption<std::string>("input_xml_library_file");
std::vector<std::string> SplittedLibs;
boost::algorithm::split(SplittedLibs, XmlLibraryList, boost::algorithm::is_any_of(";"));
for (unsigned int i = 0; i < SplittedLibs.size(); i++)
{
if (SplittedLibs.size() == 0) continue;
LibraryName = SplittedLibs[i];
long xmlTime;
START_TIME(xmlTime);
read_technology_File(SplittedLibs[i], TM, Param, device);
STOP_TIME(xmlTime);
PRINT_DBG_MEX(DEBUG_LEVEL_VERBOSE, debug_level, "(koala) Read the XML technology library file \"" + LibraryName + "\" in "
+ boost::lexical_cast<std::string>(print_cpu_time(xmlTime)) + " seconds;\n");
}
#if HAVE_BOOLEAN_PARSER_BUILT
if (Param->getOption<bool>(OPT_dump_genlib))
{
std::string genlib_name(LibraryName.substr(0, LibraryName.find_last_of('.')) + ".genlib");
PRINT_DBG_MEX(DEBUG_LEVEL_VERBOSE, debug_level, "(koala) Dumping the technology library in genlib format");
#if HAVE_CIRCUIT_BUILT
dump_genlib(genlib_name, TM);
#endif
}
#endif
}
#if HAVE_EXPERIMENTAL
if (Param->isOption("input_lef_library_file"))
{
std::string FileList = Param->getOption<std::string>("input_lef_library_file");
std::vector<std::string> SplittedLibs;
boost::algorithm::split(SplittedLibs, FileList, boost::algorithm::is_any_of(";"));
for (unsigned int i = 0; i < SplittedLibs.size(); i++)
{
if (SplittedLibs.size() == 0) continue;
boost::trim(SplittedLibs[i]);
std::vector<std::string> SplittedName;
boost::algorithm::split(SplittedName, SplittedLibs[i], boost::algorithm::is_any_of(":"));
if (SplittedName.size() != 2) THROW_ERROR("Malformed LEF description: \"" + SplittedLibs[i] + "\"");
std::string LibraryName = SplittedName[0];
std::string LefFileName = SplittedName[1];
if (!boost::filesystem::exists(LefFileName))
THROW_ERROR("Lef file \"" + LefFileName + "\" does not exists!");
if (!TM->is_library_manager(LibraryName))
THROW_ERROR("Library \"" + LibraryName + "\" is not contained into the datastructure");
const library_managerRef& LM = TM->get_library_manager(LibraryName);
LM->set_info(library_manager::LEF, LefFileName);
PRINT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "(koala) Stored LEF file \"" + LefFileName + "\" for library \""
+ LibraryName + "\";\n");
}
}
#endif
#if HAVE_LIBRARY_COMPILER
if (Param->isOption("input_db_library_file"))
{
std::string FileList = Param->getOption<std::string>("input_db_library_file");
std::vector<std::string> SplittedLibs;
boost::algorithm::split(SplittedLibs, FileList, boost::algorithm::is_any_of(";"));
for (unsigned int i = 0; i < SplittedLibs.size(); i++)
{
if (SplittedLibs.size() == 0) continue;
boost::trim(SplittedLibs[i]);
std::vector<std::string> SplittedName;
boost::algorithm::split(SplittedName, SplittedLibs[i], boost::algorithm::is_any_of(":"));
if (SplittedName.size() != 2) THROW_ERROR("Malformed db description: \"" + SplittedLibs[i] + "\"");
std::string LibraryName = SplittedName[0];
std::string dbFileName = SplittedName[1];
if (!TM->is_library_manager(LibraryName))
THROW_ERROR("Library \"" + LibraryName + "\" is not contained into the datastructure");
const library_managerRef LM = TM->get_library_manager(LibraryName);
LM->set_info(library_manager::DB, dbFileName);
PRINT_OUT_MEX(OUTPUT_LEVEL_MINIMUM, output_level, "(koala) Stored DB file \"" + dbFileName + "\" for library \""
+ LibraryName + "\";\n");
}
}
#endif
}