RC

git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@2710 331e1502-861f-0410-8da2-ba01fb791d7f

branches/rc2.0/eo/contrib/mathsym/eval/sym_compile.cpp

@@ -0,0 +1,219 @@
+/*	    
+ *             Copyright (C) 2005 Maarten Keijzer
+ *
+ *          This program is free software; you can redistribute it and/or modify
+ *          it under the terms of version 2 of the GNU General Public License as 
+ *          published by the Free Software Foundation. 
+ *
+ *          This program is distributed in the hope that it will be useful,
+ *          but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *          MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *          GNU General Public License for more details.
+ *
+ *          You should have received a copy of the GNU General Public License
+ *          along with this program; if not, write to the Free Software
+ *          Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+
+#include "Sym.h"
+#include "FunDef.h"
+#include "sym_compile.h"
+
+#include <sstream>
+
+using namespace std;
+
+extern "C" {
+    void  symc_init();
+    int  symc_compile(const char* func_str);
+    int  symc_link();
+    void* symc_get_fun(const char* func_name);
+    void* symc_make(const char* func_str, const char* func_name);
+}
+
+string make_prototypes() {
+    string prot = get_prototypes();
+    prot += "double sqr(double x) { return x*x; }";
+    return prot;
+}
+
+// contains variable names, like 'a0', 'a1', etc. or regular code
+
+#if USE_TR1 
+typedef std::tr1::unordered_map<Sym, string, HashSym> HashMap;
+#else
+typedef hash_map<Sym, string, HashSym> HashMap;
+#endif
+
+// prints 'num' in reverse notation. Does not matter as it's a unique id
+string make_var(unsigned num) {
+    string str = "a";
+    do {
+	str += char('0' + (num % 10));
+	num /= 10;
+    } while (num);
+    return str;
+}
+
+template <class T>
+string to_string(T t) {
+    ostringstream os;
+    os << t;
+    return os.str();
+}
+
+
+HashMap::iterator find_entry(const Sym& sym, string& str, HashMap& map) {
+    HashMap::iterator result = map.find(sym);
+
+    if (result == map.end()) { // new entry
+	const SymVec& args = sym.args();
+	
+	vector<string> argstr(args.size());
+	for (unsigned i = 0; i < args.size(); ++i) {
+	    argstr[i] = find_entry(args[i], str, map)->second;
+	}
+
+	string var = make_var(map.size()); // map.size(): unique id
+	string code;	
+	// write out the code
+	const FunDef& fun = get_element(sym.token());
+	code = fun.c_print(argstr, vector<string>() );
+	    
+	str += "double " + var + "=" + code + ";\n";
+	result = map.insert( make_pair(sym, var ) ).first; // only want iterator
+    }
+    
+    return result;
+}
+
+void write_entry(const Sym& sym, string& str, HashMap& map, unsigned out) {
+    HashMap::iterator it = find_entry(sym, str, map);
+    
+    str += "y[" + to_string(out) + "]=" + it->second + ";\n";
+    //cout << "wrote " << out << '\n';
+}
+
+#include <fstream>
+multi_function compile(const std::vector<Sym>& syms) {
+    
+    //cout << "Multifunction " << syms.size() << endl;
+    // static stream to avoid fragmentation of these LARGE strings
+    static string str;
+    str.clear();
+    str += make_prototypes();
+
+    str += "extern double func(const double* x, double* y) { \n ";
+   
+    multi_function result;
+    HashMap map(Sym::get_dag().size());
+    
+    for (unsigned i = 0; i < syms.size(); ++i) {
+	write_entry(syms[i], str, map, i);
+    }
+    
+    str += ";}";
+
+    
+    /*static int counter = 0;
+    ostringstream nm;
+    nm << "cmp/compiled" << (counter++) << ".c";
+    cout << "Saving as " << nm.str() << endl;
+    ofstream cmp(nm.str().c_str());
+    cmp << str;
+    cmp.close();
+
+    //cout << "Multifunction " << syms.size() << endl;
+    cout << "Size of map " << map.size() << endl;
+*/
+
+    result = (multi_function) symc_make(str.c_str(), "func"); 
+
+    if (result==0) { // error
+	cout << "Error in compile " << endl;
+    }
+
+    return result;
+}
+
+single_function compile(Sym sym) {
+
+    ostringstream os;
+
+    os << make_prototypes();
+    os << "double func(const double* x) { return ";
+    
+    string code = c_print(sym);
+    os << code;
+    os << ";}";
+    string func_str = os.str();
+  
+    //cout << "compiling " << func_str << endl;
+    
+    return  (single_function) symc_make(func_str.c_str(), "func"); 
+}
+
+/* finds and inserts the full code in a hashmap */
+HashMap::iterator find_code(Sym sym, HashMap& map) {
+    HashMap::iterator result = map.find(sym);
+
+    if (result == map.end()) { // new entry
+	const SymVec& args = sym.args();
+	vector<string> argstr(args.size());
+	for (unsigned i = 0; i < args.size(); ++i) {
+	    argstr[i] = find_code(args[i], map)->second;
+	}
+
+	// write out the code
+	const FunDef& fun = get_element(sym.token());
+	string code = fun.c_print(argstr, vector<string>());
+	result = map.insert( make_pair(sym, code) ).first; // only want iterator
+    }
+    
+    return result;
+}
+
+string print_code(Sym sym, HashMap& map) {
+    HashMap::iterator it = find_code(sym, map);
+    return it->second;
+}
+
+void compile(const std::vector<Sym>& syms, std::vector<single_function>& functions) {
+    symc_init();
+    
+    static ostringstream os;
+    os.str("");
+    
+    os << make_prototypes();
+    HashMap map(Sym::get_dag().size());
+    for (unsigned i = 0; i < syms.size(); ++i) {
+	
+	os << "double func" << i << "(const double* x) { return ";
+	os << print_code(syms[i], map); //c_print(syms[i]);
+	os << ";}\n";
+
+	//symc_compile(os.str().c_str());
+	//cout << "compiling " << os.str() << endl;	
+    }
+
+    os << ends;
+#ifdef INTERVAL_DEBUG
+    //cout << "Compiling " << os.str() << endl;
+#endif
+    
+    symc_compile(os.str().c_str()); 
+    symc_link();
+
+    functions.resize(syms.size());
+    for (unsigned i = 0; i < syms.size(); ++i) {
+	ostringstream os2;
+	os2 << "func" << i;
+	
+	functions[i] = (single_function) symc_get_fun(os2.str().c_str());
+    }
+
+}
+
+
+