void compile(SgProject * project, const std::string & KLT_RTL, const std::string & USER_RTL, const std::string & kernel_file, const std::string & static_file) {
typedef ::DLX::Directives::directive_t<Dlang> directive_t;
typedef ::DLX::KLT::Annotation<Dlang> Annotation;
typedef ::KLT::LoopTrees<Annotation> LoopTrees;
typedef ::KLT::Kernel<Annotation, Runtime> Kernel;
// Declarations
::DLX::Frontend::Frontend<Dlang> frontend;
::MFB::Driver< ::MFB::KLT> driver(project);
::MDCG::ModelBuilder model_builder(driver);
size_t model = Runtime::loadAPI(model_builder, KLT_RTL, USER_RTL);
// Initialize language description
Dlang::init();
// Run DLX frontend
if (!frontend.parseDirectives(project)) {
std::cerr << "Error in FrontEnd !!!" << std::endl;
exit(1);
}
// Extract LoopTrees
std::map<directive_t *, LoopTrees *> loop_trees;
std::map<SgForStatement *, typename LoopTrees::loop_t *> loop_map;
::DLX::KLT::extractLoopTrees(frontend.directives, loop_trees, loop_map);
// Generate Kernels
::KLT::Generator<Annotation, Runtime, ::MFB::Driver< ::MFB::KLT> > generator(driver, kernel_file);
::KLT::LoopMapper<Annotation, Runtime> loop_mapper;
::KLT::LoopTiler<Annotation, Runtime> loop_tiler;
::KLT::DataFlow<Annotation, Runtime> data_flow;
std::vector<Kernel *> all_kernels;
std::map<directive_t *, Kernel *> kernel_map;
typename std::map<directive_t *, LoopTrees *>::const_iterator it_loop_tree;
for (it_loop_tree = loop_trees.begin(); it_loop_tree != loop_trees.end(); it_loop_tree++) {
// Generate Kernels
std::set<std::list<Kernel *> > kernel_lists;
generator.generate(*(it_loop_tree->second), kernel_lists, loop_mapper, loop_tiler, data_flow);
// Assume only one implementation of the kernel made of one kernel
assert(kernel_lists.size() == 1);
assert(kernel_lists.begin()->size() == 1);
Kernel * kernels = *kernel_lists.begin()->begin();
assert(kernels->getKernels().size() == 1);
kernel_map.insert(std::pair<directive_t *, Kernel *>(it_loop_tree->first, kernels));
all_kernels.push_back(kernels);
}
// Replace annotated code by host runtime code
typename std::map<directive_t *, Kernel *>::const_iterator it_kernel;
for (it_kernel = kernel_map.begin(); it_kernel != kernel_map.end(); it_kernel++) {
typename Dlang::kernel_construct_t * kernel_construct = Dlang::isKernelConstruct(it_kernel->first->construct);
assert(kernel_construct != NULL);
Runtime::useSymbolsHost(driver, driver.getFileID(kernel_construct->assoc_nodes.kernel_region->get_scope()));
SageInterface::replaceStatement(kernel_construct->assoc_nodes.kernel_region, ::KLT::intantiateOnHost<Annotation, Runtime>(it_kernel->second));
}
// Stores static description of the generated kernels
size_t host_data_file_id = driver.create(boost::filesystem::path(static_file));
driver.setUnparsedFile(host_data_file_id);
driver.setCompiledFile(host_data_file_id);
Runtime::useSymbolsHost(driver, host_data_file_id);
::MDCG::StaticInitializer static_initializer(driver);
std::ostringstream decl_name;
decl_name << "kernel_desc";
std::set< ::MDCG::Model::class_t> classes;
model_builder.get(model).lookup< ::MDCG::Model::class_t>("kernel_desc_t", classes);
assert(classes.size() == 1);
static_initializer.createArrayPointer<KernelDesc>(*(classes.begin()), all_kernels.size(), all_kernels.begin(), all_kernels.end(), host_data_file_id, decl_name.str());
Runtime::addRuntimeStaticData(driver, KLT_RTL, USER_RTL, kernel_file, static_file, host_data_file_id);
// Removes all pragma
std::vector<SgPragmaDeclaration * > pragma_decls = SageInterface::querySubTree<SgPragmaDeclaration>(project);
std::vector<SgPragmaDeclaration * >::iterator it_pragma_decl;
for (it_pragma_decl = pragma_decls.begin(); it_pragma_decl != pragma_decls.end(); it_pragma_decl++) {
std::string directive_string = (*it_pragma_decl)->get_pragma()->get_pragma();
if (::DLX::Frontend::consume_label(directive_string, Dlang::language_label))
SageInterface::removeStatement(*it_pragma_decl);
}
}
