LammpsLoader.cpp

Go to the documentation of this file.

/*
** This file is part of eOn.
**
** SPDX-License-Identifier: BSD-3-Clause
**
** Copyright (c) 2010--present, eOn Development Team
** All rights reserved.
**
** Repo:
** https://github.com/TheochemUI/eOn
*/
#include "eon/potentials/LAMMPS/LammpsLoader.h"
 
#include <cstdlib>
#include <filesystem>
#include <iostream>
#include <string>
#include <system_error>
 
namespace eonc {
 
namespace {
 
const char *const *lammps_lib_names() noexcept {
#ifdef _WIN32
  static const char *names[] = {"lammps.dll", "liblammps.dll", nullptr};
#elif defined(__APPLE__)
  static const char *names[] = {"liblammps.dylib", "liblammps.0.dylib",
                                nullptr};
#else
  static const char *names[] = {"liblammps.so", "liblammps.so.0", nullptr};
#endif
  return names;
}
 
bool path_exists(const std::filesystem::path &p) {
  std::error_code ec;
  return std::filesystem::exists(p, ec);
}
 
bool lib_file_visible(const char *const *names) {
  for (const char *const *n = names; *n; ++n) {
    if (path_exists(*n))
      return true;
  }
#ifdef _WIN32
  const char *path = std::getenv("PATH");
  const char sep = ';';
#else
  const char *path = std::getenv("LD_LIBRARY_PATH");
#ifdef __APPLE__
  if (!path || !*path)
    path = std::getenv("DYLD_LIBRARY_PATH");
#endif
  const char sep = ':';
#endif
  if (!path || !*path)
    return false;
  const std::string paths(path);
  std::string::size_type start = 0;
  while (start < paths.size()) {
    auto pos = paths.find(sep, start);
    if (pos == std::string::npos)
      pos = paths.size();
    if (pos > start) {
      const std::filesystem::path dir(paths.substr(start, pos - start));
      for (const char *const *n = names; *n; ++n) {
        if (path_exists(dir / *n))
          return true;
      }
    }
    start = pos + 1;
  }
  return false;
}
 
} // namespace
 
LammpsLoader &LammpsLoader::instance() {
  static LammpsLoader loader;
  return loader;
}
 
void LammpsLoader::ensure_loaded() {
  if (m_tried)
    return;
  m_tried = true;
  m_last_error.clear();
 
  // Always dlopen the soname. lib_file_visible only walks cwd and
  // LD_LIBRARY_PATH; the dynamic linker also searches ld.so.cache and
  // the default lib dirs. Gating on visibility skipped a distro so.
  m_handle = dynlib::openFirst(lammps_lib_names());
  if (!m_handle) {
    const std::string dle = dynlib::error();
    if (!lib_file_visible(lammps_lib_names())) {
      m_last_error = "liblammps.so not visible on LD_LIBRARY_PATH / cwd "
                     "and dlopen of the soname failed "
                     "(liblammps_pot.so is the eOn plugin, not LAMMPS)";
    } else {
      m_last_error = "liblammps.so is visible but dlopen failed";
    }
    if (!dle.empty()) {
      m_last_error += ": " + dle;
    }
    return;
  }
 
  open_no_mpi = dynlib::loadSym<open_no_mpi_fn>(m_handle, "lammps_open_no_mpi");
  close = dynlib::loadSym<close_fn>(m_handle, "lammps_close");
  command = dynlib::loadSym<command_fn>(m_handle, "lammps_command");
  file = dynlib::loadSym<file_fn>(m_handle, "lammps_file");
  scatter_atoms =
      dynlib::loadSym<scatter_atoms_fn>(m_handle, "lammps_scatter_atoms");
  extract_variable =
      dynlib::loadSym<extract_var_fn>(m_handle, "lammps_extract_variable");
 
#ifdef EONMPI
  open_mpi = dynlib::loadSym<open_mpi_fn>(m_handle, "lammps_open");
#endif
 
  if (!open_no_mpi || !close || !command || !file || !scatter_atoms ||
      !extract_variable) {
    std::cerr << "[LAMMPS] Library loaded but missing required symbols\n";
    m_last_error = "opened a liblammps* but lammps_open_no_mpi is missing "
                   "(plugin or ABI mismatch, not the LAMMPS C library)";
    dynlib::close(m_handle);
    m_handle = {};
    return;
  }
 
  m_loaded = true;
}
 
LammpsLoader::~LammpsLoader() { dynlib::close(m_handle); }
 
bool LammpsLoader::available() const {
  return lib_file_visible(lammps_lib_names());
}
 
void LammpsLoader::require_loaded() {
  ensure_loaded();
  if (!m_loaded) {
    std::string msg =
        "LAMMPS potential requested but liblammps is not usable.\n";
    if (!m_last_error.empty()) {
      msg += m_last_error;
      msg += "\n";
    }
    msg += "Need a real liblammps.so with lammps_open_no_mpi, built for "
           "this glibc. conda-forge latest may need a newer libc than "
           "the host. liblammps_pot.so is the eOn plugin, not LAMMPS.";
    throw std::runtime_error(msg);
  }
}
 
} // namespace eonc