AGILe::Loader Namespace Reference

Classes
struct	GenLibInfo
Typedefs
typedef map< string, vector < GenLibInfo > >	GenLibs
Functions
void	initialize ()
std::vector< std::string >	getAvailableGens ()
void	loadGenLibs (const std::string &genname)
Generator *	createGen ()
void	destroyGen (Generator *gen)
void	finalize ()
Log &	getLog ()
string	sysLibName (string libname)
vector< string >	getPlatforms (const GenLibInfo &info)
vector< string >	getLibSearchDirs (const GenLibInfo &info)
string	findGenLib (const GenLibInfo &info, const vector< string > searchdirs, const vector< string > platforms)
string	findGenLib (const GenLibInfo &info)
void *	loadGenLib (const string &libpath, int dlmode=(RTLD_LAZY|RTLD_GLOBAL))
void *	loadGenLib (const GenLibInfo &info, int dlmode=(RTLD_LAZY|RTLD_GLOBAL))
vector< string >	_findGenVersions (const string &name)
GenLibs	_getAllGenLibInfo ()
void	loadGenLibs (const string &genname)
template<typename Fn >
Fn	evil_cast (void *ptr)
Variables
vector< void * >	handles
void *	agilehandle = 0
string	version

---

Detailed Description

Todo:

Make this a singleton class with automatic init and finalize

---

Typedef Documentation

typedef map<string, vector<GenLibInfo> > GenLibs

Definition at line 35 of file Loader.cc.

---

Function Documentation

vector<string> AGILe::Loader::_findGenVersions

(

const string &

name

)

Definition at line 202 of file Loader.cc.

References AGILe::getGenPaths().

Referenced by _getAllGenLibInfo().

                                                        {
      vector<string> rtn;
      vector<string> dirs = getGenPaths();
      foreach (const string& d, dirs) {
        oslink::directory dir(d + "/" + name);
        while (dir) {
          string filename = dir.next();
          if (filename == "." || filename == "..") continue;
          if (filename.find(".2") == filename.length()-2 || filename.find(".3") == filename.length()-2) {
            filename = filename.substr(0, filename.length()-2);
          }
          //if (rtn.find(filename) == rtn.end()) rtn += filename;
          if (find(rtn.begin(), rtn.end(), filename) == rtn.end()) rtn += filename;
        }
      }
      // Get the versions sorted most-recent first, so that it will be the first to be tested
      sort(rtn.begin(), rtn.end());
      rtn += "HEAD";
      reverse(rtn.begin(), rtn.end());
      return rtn;
    }

GenLibs AGILe::Loader::_getAllGenLibInfo

(

)

Definition at line 225 of file Loader.cc.

References _findGenVersions(), Log::DEBUG, findGenLib(), getLog(), v, and Log::WARN.

Referenced by getAvailableGens(), and loadGenLibs().

                                {

      // Is LHAPDF available?
      const vector<string> lhapdf_versions = _findGenVersions("lhapdf");
      bool haveLHAPDF = false;
      GenLibInfo lhapdfLibInfo("DUMMY");
      foreach (const string& v, lhapdf_versions) {
        lhapdfLibInfo = GenLibInfo("libLHAPDF", "lhapdf", v);
        haveLHAPDF = ! findGenLib(lhapdfLibInfo).empty();
        if (haveLHAPDF) break;
      }
      // Try to fall back to non-Genser packaging
      if (!haveLHAPDF) {
        lhapdfLibInfo = GenLibInfo("libLHAPDF");
        haveLHAPDF = ! findGenLib(lhapdfLibInfo).empty();
      }
      // Announce the result
      if (haveLHAPDF) {
        Log::getLog("AGILe.Loader") << Log::DEBUG << "LHAPDF is available" << endl;
      } else {
        Log::getLog("AGILe.Loader") << Log::WARN << "LHAPDF is not available" << endl;
      }


      // Find available Fortran generator versions
      vector<string> py6_versions = _findGenVersions("pythia6");
      vector<string> hw6_versions = _findGenVersions("herwig");
      vector<string> alpgen_versions = _findGenVersions("alpgen");
      vector<string> rapgap_versions = _findGenVersions("rapgap");
      vector<string> cascade_versions = _findGenVersions("cascade");
      vector<string> ariadne_versions = _findGenVersions("ariadne");
      vector<string> phojet_versions = _findGenVersions("phojet");


      // Return value, to be populated
      GenLibs gens;


      // Fortran Herwig + variants
      foreach (const string& v, hw6_versions) {
        vector<GenLibInfo> baselibs, reqlibs;
        baselibs += GenLibInfo("libherwig", "herwig", v);
        if (haveLHAPDF) {
          baselibs += lhapdfLibInfo;
        } else {
          baselibs += GenLibInfo("libherwig_pdfdummy", "herwig", v);
        }
        baselibs += GenLibInfo("libHepMCfio");
        baselibs += GenLibInfo("libAGILeFHerwig");
        const GenLibInfo libinfo_herwigdummy("libherwig_dummy", "herwig", v);
        const GenLibInfo libinfo_jimmy("libjimmy", "jimmy", "4.31");
        const GenLibInfo libinfo_charybher("libcharybdis-h", "charybdis", "1.003hp");
        // Standard Herwig
        reqlibs = baselibs;
        reqlibs += libinfo_herwigdummy;
        gens["Herwig:" + v] = reqlibs;
        //
        // Herwig+Jimmy
        reqlibs = baselibs;
        reqlibs += libinfo_herwigdummy;
        reqlibs += libinfo_jimmy;
        reqlibs += GenLibInfo("libAGILeFHerwigJimmy");
        gens["HerwigJimmy:" + v] = reqlibs;
        //
        // Herwig(+Jimmy)+AlpGen
        foreach (const string& alpgen_version, alpgen_versions) {
          // Herwig+AlpGen
          reqlibs = baselibs;
          reqlibs += GenLibInfo("libalpgen", "alpgen", alpgen_version);
          reqlibs += GenLibInfo("libalpsho", "alpgen", alpgen_version);
          reqlibs += GenLibInfo("libatoher", "alpgen", alpgen_version);
          reqlibs += GenLibInfo("libAGILeAlpGen");
          reqlibs += GenLibInfo("libAGILeAlpGenFHerwig");
          gens["AlpGenHerwig:" + v + ":" + alpgen_version] = reqlibs;
          // Herwig+Jimmy+AlpGen
          reqlibs = baselibs;
          reqlibs += GenLibInfo("libalpgen", "alpgen", alpgen_version);
          reqlibs += GenLibInfo("libalpsho", "alpgen", alpgen_version);
          reqlibs += GenLibInfo("libatoher", "alpgen", alpgen_version);
          reqlibs += libinfo_jimmy;
          reqlibs += GenLibInfo("libAGILeAlpGen");
          reqlibs += GenLibInfo("libAGILeFHerwigJimmy");
          reqlibs += GenLibInfo("libAGILeAlpGenFHerwigJimmy");
          gens["AlpGenHerwigJimmy:" + v + ":" + alpgen_version] = reqlibs;
        }
        //
        // Herwig+Charybdis
        reqlibs = baselibs;
        reqlibs += libinfo_charybher;
        reqlibs += GenLibInfo("libAGILeCharybdis");
        reqlibs += GenLibInfo("libAGILeCharybdisFHerwig");
        gens["CharybdisHerwig:" + v] = reqlibs;
        //
        // Herwig+Jimmy+Charybdis
        reqlibs = baselibs;
        reqlibs += libinfo_charybher;
        reqlibs += libinfo_jimmy;
        reqlibs += GenLibInfo("libAGILeCharybdis");
        reqlibs += GenLibInfo("libAGILeFHerwigJimmy");
        reqlibs += GenLibInfo("libAGILeCharybdisFHerwigJimmy");
        gens["CharybdisHerwigJimmy:" + v] = reqlibs;
      }


      // Fortran Pythia + variants
      foreach (const string& v, py6_versions) {
        vector<GenLibInfo> baselibs, reqlibs;
        baselibs += GenLibInfo("libpythia6", "pythia6", v);
        if (haveLHAPDF) {
          baselibs += lhapdfLibInfo;
        } else {
          baselibs += GenLibInfo("libpythia6_pdfdummy", "pythia6", v);
        }
        baselibs += GenLibInfo("libHepMCfio");
        //
        // Standard Pythia
        reqlibs = baselibs;
        reqlibs += GenLibInfo("libAGILeFPythia_pyevwt");
        reqlibs += GenLibInfo("libpythia6_dummy", "pythia6", v);
        reqlibs += GenLibInfo("libAGILeFPythia");
        gens["Pythia6:" + v] = reqlibs;
        //
        // Pythia+AlpGen
        foreach (const string& alpgen_version, alpgen_versions) {
          reqlibs = baselibs;
          reqlibs += GenLibInfo("libalpgen", "alpgen", alpgen_version);
          reqlibs += GenLibInfo("libalpsho", "alpgen", alpgen_version);
          reqlibs += GenLibInfo("libatopyt", "alpgen", alpgen_version);
          reqlibs += GenLibInfo("libpythia6_dummy", "pythia6", v);
          reqlibs += GenLibInfo("libAGILeAlpGen");
          reqlibs += GenLibInfo("libAGILeAlpGenFPythia");
          gens["AlpGenPythia6:" + v + ":" + alpgen_version] = reqlibs;
        }
        //
        // Pythia+Charybdis
        reqlibs = baselibs;
        reqlibs += GenLibInfo("libcharybdis", "charybdis", "1.003hp");
        reqlibs += GenLibInfo("libpythia6_dummy", "pythia6", v);
        reqlibs += GenLibInfo("libAGILeCharybdis");
        reqlibs += GenLibInfo("libAGILeCharybdisFPythia");
        gens["CharybdisPythia6:" + v] = reqlibs;
        //
        // Pythia+Rapgap
        foreach (const string& vr, rapgap_versions) {
          reqlibs.clear();
          reqlibs += GenLibInfo("libpythia6", "pythia6", v);
          reqlibs.push_back(GenLibInfo("libpythia6_dummy", "pythia6", v)); // This is for pytime
          //reqlibs += GenLibInfo("libpythia6_dummies", "pythia6", v);
          reqlibs += GenLibInfo("librapgap32", "Rapgap", vr);
          reqlibs += GenLibInfo("libHepMCfio"); // This order is important
          if (haveLHAPDF) {
            reqlibs += lhapdfLibInfo;
          } else {
            reqlibs += GenLibInfo("libpythia6_pdfdummy", "pythia6", v);
          }
          reqlibs += GenLibInfo("libAGILeRapgap");
          gens["RapgapPythia6:" + v + ":" + vr] = reqlibs;
        }
        //
        // Pythia+Cascade
        foreach (const string& vc, cascade_versions) {
          vector<GenLibInfo> baselibs, reqlibs;
          baselibs.push_back(GenLibInfo("libpythia6", "pythia6", v));
          baselibs.push_back(GenLibInfo("libpythia6_dummy", "pythia6", v)); // This is for pytime
          baselibs.push_back(GenLibInfo("libcascade2", "cascade", vc));
          baselibs.push_back(GenLibInfo("libHepMCfio")); // This order is important
          if (haveLHAPDF) {
            reqlibs += lhapdfLibInfo;
          } else {
            reqlibs += GenLibInfo("libpythia6_pdfdummy", "pythia6", v);
          }

          reqlibs = baselibs;
          reqlibs.push_back(GenLibInfo("libAGILeCascade"));
          gens["CascadePythia6:" + v + ":" + vc] = reqlibs;
        }
        //
        // Pythia+Ariadne
        foreach (const string& va, ariadne_versions) {
          vector<GenLibInfo> baselibs, reqlibs;
          baselibs.push_back(GenLibInfo("libpythia6", "pythia6", v));
          baselibs.push_back(GenLibInfo("libar4", "ariadne", va));
          baselibs.push_back(GenLibInfo("libHepMCfio")); // This order is important
          if (haveLHAPDF) {
            reqlibs += lhapdfLibInfo;
          } else {
            reqlibs += GenLibInfo("libpythia6_pdfdummy", "pythia6", v);
          }

          reqlibs = baselibs;
          reqlibs.push_back(GenLibInfo("libAGILeAriadne"));
          gens["Ariadne" + va + ":" + "Pythia6." + v] = reqlibs;
        }
        //
        // Pythia+Phojet
        foreach (const string& vp, phojet_versions) {
          vector<GenLibInfo> baselibs, reqlibs;
          baselibs.push_back(GenLibInfo("libpythia6", "pythia6", v));
          baselibs.push_back(GenLibInfo("libphojet", "phojet", vp));
          baselibs.push_back(GenLibInfo("libHepMCfio")); // This order is important
          if (haveLHAPDF) {
            reqlibs += lhapdfLibInfo;
          } else {
            reqlibs += GenLibInfo("libpythia6_pdfdummy", "pythia6", v);
          }

          reqlibs = baselibs;
          reqlibs.push_back(GenLibInfo("libAGILePhojet"));
          gens["Phojet" + vp + ":" + "Pythia6." + v] = reqlibs;
        }
      }

      return gens;
    }

Generator * createGen

(

)

Definition at line 514 of file Loader.cc.

References agilehandle, evil_cast(), Generator::setVersion(), and version.

                           {
      // Load the factory and create an instance of the class
      void* makeGen = dlsym(agilehandle, "create");
      if (char* err = dlerror()) {
        throw runtime_error((string("Can't load creation factory: ") + err).c_str());
      }

      // Make the generator object.
      Generator* gen = evil_cast<Creator>(makeGen)();

      // Set the generator version for e.g. HepML dumps of generator state.
      gen->setVersion(version);

      return gen;
    }

void destroyGen

(

Generator *

gen

)

Definition at line 531 of file Loader.cc.

                                    {
      //Destroyer* destroy_gen = (Destroyer*) dlsym(agilemod, "destroy");
      //if (dlerror()) {
      //  throw runtime_error("Can't load destruction factory");
      //}
      //destroy_gen(gen);
      delete gen;
    }

Fn AGILe::Loader::evil_cast

(

void *

ptr

)

[inline]

Definition at line 509 of file Loader.cc.

Referenced by createGen().

                                   {
      return reinterpret_cast<Fn>(reinterpret_cast<size_t>(ptr));
    }

void finalize

(

)

Definition at line 542 of file Loader.cc.

References handles.

                    {
      for (vector<void*>::reverse_iterator h = handles.rbegin(); h != handles.rend(); ++h) {
        if (*h != 0) dlclose(*h);
      }
    }

string AGILe::Loader::findGenLib

(

const GenLibInfo &

info

)

Definition at line 165 of file Loader.cc.

References findGenLib(), getLibSearchDirs(), and getPlatforms().

                                              {
      // Build up lists of search directories and platforms
      vector<string> platforms = getPlatforms(info);
      vector<string> dirs = getLibSearchDirs(info);

      return findGenLib(info, dirs, platforms);
    }

string AGILe::Loader::findGenLib	(	const GenLibInfo &	info,
		const vector< string >	searchdirs,
		const vector< string >	platforms
	)

Definition at line 104 of file Loader.cc.

References getLog(), GenLibInfo::libname, p, GenLibInfo::pkgname, GenLibInfo::pkgversion, SYSDSO, sysLibName(), and Log::TRACE.

Referenced by _getAllGenLibInfo(), findGenLib(), getAvailableGens(), and loadGenLib().

    {
      // Get platform-specific filename
      string libname = sysLibName(info.libname);

      // Try to find lib file here
      foreach (const string& d, searchdirs) {
        foreach (const string& p, platforms) {
          vector<string> versionsuffixes;
          versionsuffixes += ".3", ".2", "";
          foreach (string& vsuffix, versionsuffixes) {
            string libpath = d + "/" + info.pkgname;
            if (!info.pkgversion.empty()) {
              libpath += "/" + info.pkgversion + vsuffix;
            }
            if (!p.empty()) {
              libpath += "/" + p;
            }
            if (!info.pkgname.empty()) {
              libpath += "/lib";
            }
            libpath += "/" + libname;
            // Remove duplicate slashes from path
            while (libpath.find("//") != string::npos) {
              libpath.replace(libpath.find("//"), 2, "/");
            }
            // Return path if present
            getLog() << Log::TRACE << "Testing for " << libpath << endl;
            if (access(libpath.c_str(), R_OK) == 0) {
              getLog() << Log::TRACE << "Found " << libpath << endl;
              return libpath;
            }
          }
        }
      }
      // Fall back to non-Genser structure
      foreach (const string& d, searchdirs) {
        const string libdir = d + "/lib";
        vector<string> libnames;
        libnames += libname,(info.libname+info.pkgversion+SYSDSO);
        foreach (string& ln, libnames) {
          string libpath = libdir + "/" + ln;
          // Remove duplicate slashes from path
          while (libpath.find("//") != string::npos) {
            libpath.replace(libpath.find("//"), 2, "/");
          }
          // Return path if present
          getLog() << Log::TRACE << "Testing for " << libpath << endl;
          if (access(libpath.c_str(), R_OK) == 0) {
            getLog() << Log::TRACE << "Found " << libpath << endl;
            return libpath;
          }
        }
      }
      return "";
    }

vector< string > getAvailableGens

(

)

Definition at line 443 of file Loader.cc.

References _getAllGenLibInfo(), Log::DEBUG, findGenLib(), getLog(), GenLibInfo::libname, GenLibInfo::pkgname, GenLibInfo::pkgversion, and Log::TRACE.

                                      {
      GenLibs genlibs = _getAllGenLibInfo();
      vector<string> availableGens;
      typedef pair<string, vector<GenLibInfo> > GenLibInfoKV;
      foreach (const GenLibInfoKV& g, genlibs) {
        getLog() << Log::TRACE << "Trying to find libs for " << g.first << endl;
        // All listed libraries must be available for each generator to be considered useable.
        bool ok = true;
        foreach (const GenLibInfo& l, g.second) {
          const string libpath = findGenLib(l);
          if (libpath != "") {
            getLog() << Log::TRACE << "Found " << l.libname << " at " << libpath << endl;
          } else {
            getLog() << Log::TRACE << "Didn't find "
                     << l.pkgname << ":" << l.pkgversion << ":" << l.libname << endl;
            ok = false;
            break;
          }
        }
        // If all libs were present, add this gen to the "available" list.
        if (ok) {
          getLog() << Log::DEBUG << "Found all libs for " << g.first << endl;
          availableGens.push_back(g.first);
        }
      }
      return availableGens;
    }

vector<string> AGILe::Loader::getLibSearchDirs

(

const GenLibInfo &

info

)

Todo:

Is this needed? Can't dlopen do this automatically for non-gen libs?

Todo:

Need to use DYLD_LIBRARY_PATH on Macs?

Definition at line 72 of file Loader.cc.

References AGILe::getGenPaths(), AGILe::getLibPath(), GenLibInfo::pkgname, and AGILe::split().

Referenced by findGenLib().

                                                            {
      vector<string> dirs;
      if (info.pkgname.empty()) {
        // If we're trying to load an AGILe interface...


        // Use the AGILe library install path
        dirs.push_back(getLibPath());

        // Use the current dir, too.
        dirs.push_back(".");

        // and some default system locations
        dirs += "/usr/lib", "/usr/lib64", "/usr/lib32";
        dirs += "/usr/local/lib", "/usr/local/lib64", "/usr/local/lib32";

        // And then the user's (non-system) library path
        const char* envld = getenv("LD_LIBRARY_PATH");
        if (envld) dirs += split(envld);

      } else {
        // If we're loading a real generator library...
        dirs += getGenPaths();
      }

      return dirs;
    }

Log& AGILe::Loader::getLog

(

)

Definition at line 14 of file Loader.cc.

Referenced by _getAllGenLibInfo(), findGenLib(), getAvailableGens(), and loadGenLib().

                  {
      return AGILe::Log::getLog("AGILe.Loader");
    }

vector<string> AGILe::Loader::getPlatforms

(

const GenLibInfo &

info

)

Definition at line 58 of file Loader.cc.

References AGILe::getLCGPlatformTag(), and GenLibInfo::pkgname.

Referenced by findGenLib().

                                                        {
      vector<string> platforms;
      if (!info.pkgname.empty()) {
        // If we're not trying to load an AGILe interface...
        platforms += getLCGPlatformTag();
      }
      // Also try with no platform tag
      platforms += "";

      return platforms;
    }

void initialize

(

)

Definition at line 43 of file Loader.cc.

                      {
      // Nothing to do with raw dlopen
    }

void* AGILe::Loader::loadGenLib	(	const GenLibInfo &	info,
		int	dlmode = (RTLD_LAZY|RTLD_GLOBAL)
	)

Definition at line 193 of file Loader.cc.

References findGenLib(), and loadGenLib().

                                                                                 {
      const string libpath = findGenLib(info);
      if (libpath != "") {
        return loadGenLib(libpath, dlmode);
      }
      return 0;
    }

void* AGILe::Loader::loadGenLib	(	const string &	libpath,
		int	dlmode = (RTLD_LAZY|RTLD_GLOBAL)
	)

Definition at line 175 of file Loader.cc.

References agilehandle, getLog(), and Log::TRACE.

Referenced by loadGenLib(), and loadGenLibs().

                                                                                {
      getLog() << Log::TRACE << "Trying to load " << libpath << endl;
      void* lib = dlopen(libpath.c_str(), dlmode);
      if (lib) {
        getLog() << Log::TRACE << "Successfully loaded " << libpath << " (" << lib << ")" << endl;
        // If this is an AGILe interface, set the global handle
        if (libpath.find("libAGILe") != string::npos) {
          getLog() << Log::TRACE << "Setting AGILe module handle for " << libpath
                   << " (" << lib << ")" << endl;
          agilehandle = lib;
        }
      } else {
        getLog() << Log::TRACE << "Failed to load " << libpath << endl;
      }
      return lib;
    }

void AGILe::Loader::loadGenLibs

(

const string &

genname

)

Definition at line 472 of file Loader.cc.

References _getAllGenLibInfo(), handles, loadGenLib(), and version.

                                            {
      const string fioName = "libHepMCfio";
      string agileName = "";
      string pdflibName = "";

      // Get version string from colon separated version string if given.
      string name = genname;
      version = "";
      const size_t colonpos = genname.rfind(":");
      if (colonpos != string::npos) {
        const size_t versionlength = genname.length() - colonpos - 1;
        name = genname.substr(0, colonpos);
        version = genname.substr(colonpos+1, versionlength);
      }

      GenLibs genlibs = _getAllGenLibInfo();
      if (genlibs.find(genname) == genlibs.end()) {
        throw runtime_error("Trying to load an unknown generator combination: " + genname);
      } else {
        const vector<GenLibInfo> libs = genlibs[genname];
        for (vector<GenLibInfo>::const_iterator l = libs.begin(); l != libs.end(); ++l) {
          handles.push_back(loadGenLib(*l));
        }
      }


      // Check and reset dlopen errors
      for (vector<void*>::const_iterator h = handles.begin(); h != handles.end(); ++h) {
        if (*h == 0) {
          throw runtime_error((string("Failed to load libraries: ") + dlerror()).c_str());
        }
      }
      dlerror();
    }

void AGILe::Loader::loadGenLibs

(

const std::string &

genname

)

string AGILe::Loader::sysLibName

(

string

libname

)

Definition at line 50 of file Loader.cc.

References SYSDSO.

Referenced by findGenLib().

                                      {
      // Put lib suffix on the end if needed
      if (libname.find(SYSDSO) == string::npos) libname += SYSDSO;
      return libname;
    }

---

Variable Documentation

void* agilehandle = 0

Definition at line 32 of file Loader.cc.

Referenced by createGen(), and loadGenLib().

vector<void*> handles

Definition at line 31 of file Loader.cc.

Referenced by finalize(), and loadGenLibs().

string version

Definition at line 39 of file Loader.cc.

Referenced by createGen(), and loadGenLibs().