DsoDb.cxx

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// DsoDb.cxx 
// Implementation file for class DsoDb
// Author: S.Binet<binet@cern.ch>
 
// AthenaKernel includes
#include "AthenaKernel/DsoDb.h"
 
//#define ATH_DSODB_VERBOSE
 
// STL includes
#include <cstdlib>    /* getenv */
#include <algorithm>
#include <iostream>
#include <print>
#include <fstream>
#include <set>
 
// boost includes
#include <filesystem>
#include "boost/tokenizer.hpp"
 
#include "boost/algorithm/string.hpp"
 
// ROOT includes
#include "TClassEdit.h"
 
// fwk includes
#include "GaudiKernel/System.h"
 
namespace fs = std::filesystem;
 
namespace {
  typedef std::vector<std::string> Strings_t;
  const std::string RootMap = ".rootmap";
  const std::string Components = ".components";
  const std::string PluginNs= "__pf__";
 
#ifdef _WIN32
  const std::string SHLIB_PREFIX = "lib";
  const std::string SHLIB_SUFFIX = ".dll";
#else
  const std::string SHLIB_PREFIX = "lib";
  const std::string SHLIB_SUFFIX = ".so";
#endif
 
 
  bool is_rootcint_dict(const std::string& libname)
  {
    if (libname == "liblistDict.so") return true;
    if (libname == "libmapDict.so") return true;
    if (libname == "libmap2Dict.so") return true;
    if (libname == "libmultimapDict.so") return true;
    if (libname == "libsetDict.so") return true;
    if (libname == "libvectorDict.so") return true;
    if (libname == "libCore.so") return true;
    if (libname == "libMathCore.so") return true;
 
    static const std::string dll = ".dll";
    if (libname == dll) {
      return false;
    }
    return !libname.starts_with(SHLIB_PREFIX) && libname.ends_with(dll);
  }
 
  inline
  std::string to_string(const fs::path& p) 
  {
    return p.string();
  }
 
  std::string getlibname(const std::string& libname)
  {
    std::string lib = libname;
    if (!lib.starts_with( "lib")) {
      lib = std::string("lib") + lib;
    }
    if (!lib.ends_with(SHLIB_SUFFIX)) {
      lib += SHLIB_SUFFIX;
    }
    return lib;
  }
 
  const std::set<std::string>& 
  s_cxx_builtins()
  {
    static const std::set<std::string> s = {
      "char",
      "unsigned char",
      "signed char",
      
      "signed",
      
      "short int",
      "short signed",
      "short signed int",
      
      "short",
      "unsigned short",
      "signed short",
 
      "int",
      "unsigned int",
 
      "long int",
      "long signed int",
      "signed long int",
      
      "long",
      "long signed",
      "signed long",
      "unsigned long",
      "unsigned long int",
 
      "long long",
      "long long int",
      "unsigned long long",
      "longlong",
      
      "ulonglong",
 
      "float",
      "double",
      "long double",
      "bool",
    };
    return s;
  }
 
  const std::map<std::string, std::string>&
  s_cxx_aliases()
  {
    static const std::map<std::string, std::string> s =
      {{"ElementLinkInt_p1",             "ElementLink_p1<unsigned int>"},
       {"basic_string<char>",            "string"},
       {"vector<basic_string<char> >",   "vector<string>"},
       {"INavigable4MomentumCollection", "DataVector<INavigable4Momentum>"},
       {"IParticleContainer",            "DataVector<IParticle>"},
      };
    return s;
  }
 
  const std::map<std::string, std::string>&
  s_cxx_typedefs()
  {
    static const std::map<std::string, std::string> s =
      {{"INavigable4MomentumCollection", "DataVector<INavigable4Momentum>"},
       {"IParticleContainer",            "DataVector<IParticle>"},
      };
    return s;
  }

  std::string 
  to_rootmap_name(const std::string& type_name_)
  {
    std::string type_name = type_name_;
    boost::algorithm::replace_all(type_name, ", ", ",");
    // first, the easy case: builtins
    if (s_cxx_builtins().find(type_name) != s_cxx_builtins().end()) {
      return type_name;
    }
 
    // known missing aliases ?
    if (s_cxx_aliases().find(type_name) != s_cxx_aliases().end()) {
      return ::to_rootmap_name(s_cxx_aliases().find(type_name)->second);
    }
 
    // Protect against data race inside TClassEdit.
    // https://github.com/root-project/root/issues/10353
    // Should be fixed in root 6.26.02.
    {
      R__WRITE_LOCKGUARD(ROOT::gCoreMutex);
      type_name = TClassEdit::ShortType(type_name.c_str(), 
                                        TClassEdit::kDropDefaultAlloc|
                                        TClassEdit::kDropStd);
    }
    boost::algorithm::replace_all(type_name, "basic_string<char> >", "string>");
    boost::algorithm::replace_all(type_name, "basic_string<char>", "string");
    return type_name;
  }

  std::string
  to_rflx_name(const std::string& type_name_)
  {
    std::string type_name = type_name_;
    boost::algorithm::replace_all(type_name, ", ", ",");
    // first the easy case: builtins
    if (s_cxx_builtins().find(type_name) != s_cxx_builtins().end()) {
      return type_name;
    }
 
    // known missing typedefs ?
    if (s_cxx_typedefs().find(type_name) != s_cxx_typedefs().end()) {
      return ::to_rflx_name(s_cxx_typedefs().find(type_name)->second);
    }
    {
      // Protect against data race inside TClassEdit.
      // https://github.com/root-project/root/issues/10353
      // Should be fixed in root 6.26.02.
      R__WRITE_LOCKGUARD(ROOT::gCoreMutex);
      type_name = TClassEdit::ShortType(type_name.c_str(),
                                        TClassEdit::kDropDefaultAlloc);
    }
    // !! order matters !! (at least in C++03. C++11 should be good)
    boost::algorithm::replace_all(type_name, 
                                  "std::string>", 
                                  "std::basic_string<char> >");
    boost::algorithm::replace_all(type_name, 
                                  "std::string", 
                                  "std::basic_string<char>");
    return type_name;
  }
}
 
namespace Ath {

// Public methods: 

const DsoDb* DsoDb::instance()
{
   static const DsoDb db;
   return &db;
}
 
// Constructors
DsoDb::DsoDb() :
  m_pf(),
  m_db(),
  m_dsofiles()
{
  build_repository();
}
 
// Destructor
DsoDb::~DsoDb()
{}

// Non-const methods: 
 
bool
DsoDb::has_type(const std::string& type_name) const
{
  if (s_cxx_builtins().find(type_name) != s_cxx_builtins().end()) {
    return true;
  }
  const std::string n = ::to_rootmap_name(type_name);
  if ( m_db.find(n) != m_db.end() ||
       m_pf.find(n) != m_pf.end() ) {
    return true;
  }
  return false;
}
 
std::string
DsoDb::load_type ATLAS_NOT_THREAD_SAFE (const std::string& type_name) const
{
  RootType t = this->rflx_type(type_name);
  if (t.Id()) {
    return t.Name(Reflex::SCOPED|Reflex::QUALIFIED);
  }
  return std::string();
}

// Protected methods: 

void 
DsoDb::build_repository()
{
  typedef boost::tokenizer<boost::char_separator<char> > Tokenizer_t;
  typedef std::vector<fs::path> Paths_t;
 
  std::set<std::string> dsofiles;
 
  std::string dsopath = System::getEnv("LD_LIBRARY_PATH");
  std::string rootsys = System::getEnv("ROOTSYS");
 
  Tokenizer_t tok(dsopath, boost::char_separator<char>(":"));
 
  for (Tokenizer_t::iterator itr = tok.begin(), iend = tok.end();
       itr != iend;
       ++itr) {
    if (itr->starts_with(rootsys)) {
      continue;
    }
    fs::path p(*itr);
    if (!std::filesystem::exists(*itr)) {
      continue;
    }
    Paths_t dir_content {fs::directory_iterator(p),
                         fs::directory_iterator()};
    std::sort(dir_content.begin(),
              dir_content.end());
    for (Paths_t::iterator ipath = dir_content.begin(),
           ipath_end = dir_content.end();
         ipath != ipath_end;
         ++ipath) {
      const fs::path& dsomap = *ipath;
 
      bool is_components = false;
      if (dsomap.extension() == Components)
        is_components = true;
      else if (dsomap.extension() != RootMap)
        continue;
 
      if (!fs::exists(dsomap)) continue;
 
      dsofiles.insert(dsomap.c_str());
      std::ifstream f(dsomap.c_str());
      int line_nbr = -1;
      std::string lastlib;
      while (f) {
        line_nbr += 1;
        std::string line;
        std::getline(f, line);
        boost::algorithm::trim(line);
 
        std::string libname;
        std::string dso_key;
        if ( line.empty() )
          continue;
 
        else if (line.compare (0, 8, "Library.")==0) {
          Strings_t ll;
          boost::algorithm::split(ll, line, 
                                  boost::is_any_of(" "),
                                  boost::token_compress_on);
          if (ll.size() < 2) {
            std::print (std::cerr,
                        "DsoDb:: **error** could not parse {}:{}\n"
                        "DsoDb:: (some) reflex-dicts may fail to be autoloaded",
                        dsomap.string(), line_nbr);
            continue;
          }
          libname = ll[1];
          if (::is_rootcint_dict(libname)) {
            continue;
          }
          dso_key = ll[0];
          libname = ::getlibname(libname);
          boost::algorithm::replace_all(dso_key, "Library.", "");
          boost::algorithm::replace_all(dso_key, ":", "");
          std::replace(dso_key.begin(), dso_key.end(), '@', ':');
          std::replace(dso_key.begin(), dso_key.end(), '-', ' ');
        }
 
        else if (line[0] == '[') {
          libname = line.substr (1, line.size()-2);
          boost::algorithm::trim (libname);
          if (::is_rootcint_dict(libname)) {
            lastlib.clear();
            continue;
          }
          if (!libname.empty())
            lastlib = ::getlibname (libname);
          continue;
        }
 
        else if (line.compare(0, 8, "# --End ")==0) {
           lastlib.clear();
           continue;
        }
 
        else if (line.compare(0, 6, "class ")==0) {
          libname = lastlib;
          line.erase (0, 6);
          dso_key = std::move(line);
        }
 
        else if (is_components && line.compare(0, 3, "lib") ==0) {
          std::string::size_type pos = line.find (':');
          if (pos == std::string::npos) continue;
          libname = line.substr(0, pos);
          line.erase (0, pos+1);
          dso_key = std::move(line);
 
          if (dso_key.compare(0, 6, "_PERS_")==0 ||
              dso_key.compare(0, 7, "_TRANS_")==0)
            continue;
 
          if (libname.find ("AthenaPoolPoolCnv") != std::string::npos)
            continue;
        }
 
        if (libname.empty() || dso_key.empty()) continue;
 
        const std::string fullpath_libname = to_string(dsomap.parent_path() / fs::path(libname));
 
        DsoMap_t *db = NULL;
        if (dso_key.starts_with(PluginNs) || is_components) {
          db = &m_pf;
        } else {
          db = &m_db;
        }
        if (db->find(dso_key) == db->end()) {
          db->insert(std::make_pair(dso_key, Strings_t()));
        }
        (*db)[dso_key].push_back(std::move(fullpath_libname));
      }
    }
  }
  
  m_dsofiles.reserve(dsofiles.size());
  std::copy(dsofiles.begin(), dsofiles.end(), std::back_inserter(m_dsofiles));
 
  return;
}
 
std::vector<std::string>
DsoDb::capabilities(const std::string& libname_) const
{
  fs::path p(libname_);
 
  const std::string libname = ::getlibname(to_string(p.filename()));
  std::set<std::string> caps;
  const DsoMap_t* dbs[] = { &m_pf, &m_db };
 
  for (std::size_t i = 0, imax = 2; i < imax; ++i) {
    const DsoMap_t* db = dbs[i];
    for (DsoMap_t::const_iterator idb = db->begin(), iend=db->end();
         idb != iend;
         ++idb) {
      for (Libs_t::const_iterator ilib = idb->second.begin(),
             ilibend = idb->second.end();
           ilib != ilibend;
           ++ilib) {
        fs::path lib(*ilib);
        if (to_string(lib.filename()) == libname) {
          caps.insert(idb->first);
        }
      }
    }
  }
 
  return std::vector<std::string>(caps.begin(), caps.end());
}

DsoDb::DsoMap_t 
DsoDb::duplicates(const std::string& libname, bool pedantic) const
{
  DsoMap_t dups;
  const std::string basename_lib = to_string(fs::path(libname).filename());
  std::vector<std::string> caps = this->capabilities(libname);
  const DsoMap_t* dbs[] = { &m_pf, &m_db };
 
  for (std::size_t i = 0, imax = 2; i < imax; ++i) {
    DsoMap_t dup_db;
    this->get_dups(dup_db, *dbs[i], pedantic);
    for (DsoMap_t::const_iterator 
           idb = dup_db.begin(), 
           idbend = dup_db.end();
         idb != idbend;
         ++idb) {
      if (std::find(caps.begin(), caps.end(), idb->first) != caps.end()) {
        for (Libs_t::const_iterator 
               ilib = idb->second.begin(),
               ilibend=idb->second.end();
             ilib != ilibend;
             ++ilib) {
          fs::path p(*ilib);
          const std::string basename = to_string(p.filename());
          if (basename != libname) {
            dups[idb->first].push_back(*ilib);
          }
        }
      }
    }
  }  
  return dups;
}

DsoDb::DsoMap_t 
DsoDb::dict_duplicates(bool pedantic) const
{
  DsoMap_t dups;
  get_dups(dups, m_db, pedantic);
  return dups;
}

DsoDb::DsoMap_t 
DsoDb::pf_duplicates(bool pedantic) const
{
  DsoMap_t dups;
  get_dups(dups, m_pf, pedantic);
  return dups;
}

DsoDb::Libs_t 
DsoDb::libs(bool detailed) const
{
  std::set<std::string> libs;
  const DsoMap_t* dbs[] = { &m_pf, &m_db };
 
  for (std::size_t i = 0, imax = 2; i < imax; ++i) {
    const DsoMap_t& db = *dbs[i];
    for (DsoMap_t::const_iterator idb = db.begin(), iend=db.end();
         idb != iend;
         ++idb) {
      for (Libs_t::const_iterator 
             ilib = idb->second.begin(),
             ilibend=idb->second.end();
           ilib != ilibend;
           ++ilib) {
        if (detailed) {
          libs.insert(*ilib);
        } else {
          libs.insert(to_string(fs::path(*ilib).filename()));
        }
      }
    }
  }
  return Libs_t(libs.begin(), libs.end());
}

DsoDb::DsoMap_t 
DsoDb::content(bool pedantic) const
{
  DsoMap_t db;
 
  const DsoMap_t* dbs[] = { &m_pf, &m_db };
  for (std::size_t i = 0, imax = 2; i < imax; ++i) {
    const DsoMap_t& d = *dbs[i];
    for (DsoMap_t::const_iterator idb = d.begin(), idbend=d.end();
         idb != idbend;
         ++idb) {
      if (pedantic) {
        db[idb->first] = idb->second;
      } else {
        Libs_t libs;
        std::set<std::string> baselibs;
        for (Libs_t::const_iterator 
               ilib = idb->second.begin(),
               ilibend= idb->second.end();
             ilib != ilibend;
             ++ilib) {
          const std::string baselib = to_string(fs::path(*ilib).filename());
          if (baselibs.find(baselib) == baselibs.end()) {
            libs.push_back(*ilib);
            baselibs.insert(std::move(baselib));
          }
        }
        db[idb->first] = std::move(libs);
      }
    }
  }
 
  return db;
}

void 
DsoDb::get_dups(DsoMap_t& dups, const DsoMap_t& db, bool pedantic) const
{
  for (DsoMap_t::const_iterator idb = db.begin(), iend = db.end();
       idb != iend;
       ++idb) {
    if (idb->second.size() == 1) {
      continue;
    }
    Libs_t libs;
    if (pedantic) {
      libs = idb->second;
    } else {
      std::unordered_set<std::string> baselibs;
      for (Libs_t::const_iterator 
             ilib = idb->second.begin(), 
             ilend= idb->second.end();
           ilib != ilend;
           ++ilib)
      {
        fs::path p(*ilib);
        if (! baselibs.emplace (to_string(p.filename())) . second) {
          // String wasn't in the set.
          libs.push_back(*ilib);
        }
      }
    }
    if (libs.size() > 1) {
      dups[idb->first] = std::move(libs);
    }
  }
}

RootType 
DsoDb::rflx_type ATLAS_NOT_THREAD_SAFE (const std::string& type_name) const
{
  const std::string rootmap_name = ::to_rootmap_name(type_name);
  const std::string rflx_name = ::to_rflx_name(type_name);
 
  if (s_cxx_builtins().find(type_name) != s_cxx_builtins().end()) {
    return RootType(rflx_name);
  }
 
  if (!this->has_type(rootmap_name)) {
#ifdef ATH_DSODB_VERBOSE
    std::println (std::cerr,
                  "DsoDb **error**: no such type [{}] in rootmap files",
                  rootmap_name);
#endif
    return RootType();
  }
  DsoMap_t::const_iterator idb = m_db.find(rootmap_name);
  if (idb == m_db.end()) {
    // try plugin factories...
    idb = m_pf.find(rootmap_name);
    if (idb == m_pf.end()) {
      return RootType();
    }
  }
  const Libs_t& libs = idb->second;
  if (libs.empty()) {
#ifdef ATH_DSODB_VERBOSE
    std::println (std::cerr, "DsoDb **error**: no library hosting [{}]",
                  type_name);
#endif
    return RootType();
  }
 
  System::ImageHandle handle;
  std::string libname = ::to_string(fs::path(libs[0]).filename());
  boost::algorithm::trim(libname);
  if (libname.starts_with(SHLIB_PREFIX)) {
    libname = libname.substr(SHLIB_PREFIX.size(), std::string::npos);
  }
  if (libname.ends_with(SHLIB_SUFFIX)) {
    libname.resize(libname.size() - SHLIB_SUFFIX.size());
  }
 
  unsigned long err = System::loadDynamicLib( libname, &handle );
  if ( err != 1 ) {
    std::println (std::cerr,
                  "DsoDb **error**: could not load library [{}] ({})",
                  libs[0], System::getLastErrorString());
    return RootType();
  }
 
  return RootType(rflx_name);
}
 
} //> end namespace Ath