LSSTApplications  17.0+11,17.0+34,17.0+56,17.0+57,17.0+59,17.0+7,17.0-1-g377950a+33,17.0.1-1-g114240f+2,17.0.1-1-g4d4fbc4+28,17.0.1-1-g55520dc+49,17.0.1-1-g5f4ed7e+52,17.0.1-1-g6dd7d69+17,17.0.1-1-g8de6c91+11,17.0.1-1-gb9095d2+7,17.0.1-1-ge9fec5e+5,17.0.1-1-gf4e0155+55,17.0.1-1-gfc65f5f+50,17.0.1-1-gfc6fb1f+20,17.0.1-10-g87f9f3f+1,17.0.1-11-ge9de802+16,17.0.1-16-ga14f7d5c+4,17.0.1-17-gc79d625+1,17.0.1-17-gdae4c4a+8,17.0.1-2-g26618f5+29,17.0.1-2-g54f2ebc+9,17.0.1-2-gf403422+1,17.0.1-20-g2ca2f74+6,17.0.1-23-gf3eadeb7+1,17.0.1-3-g7e86b59+39,17.0.1-3-gb5ca14a,17.0.1-3-gd08d533+40,17.0.1-30-g596af8797,17.0.1-4-g59d126d+4,17.0.1-4-gc69c472+5,17.0.1-6-g5afd9b9+4,17.0.1-7-g35889ee+1,17.0.1-7-gc7c8782+18,17.0.1-9-gc4bbfb2+3,w.2019.22
LSSTDataManagementBasePackage
Namespaces | Classes | Functions | Variables
lsst::base Namespace Reference

Namespaces

 packages
 
 version
 

Classes

class  LibraryException
 Unable to load library. More...
 
class  ModuleImporter
 Base class that defines an interface for importing Python modules. More...
 
class  NoThreadsException
 No threading library is available. More...
 
class  PythonModuleImporter
 

Functions

std::string libraryExtension ()
 Return filename extension for libraries. More...
 
std::string getLibraryFilename (std::string const &name)
 Get filename for library. More...
 
bool canLoadLibrary (std::string const &libName)
 Return whether we can load a library. More...
 
template<typename T >
T * loadSymbol (std::string const &libName, std::string const &symName)
 Load a symbol from a dynamic library. More...
 
bool haveThreads ()
 Are threaded packages available? More...
 
void setNumThreads (unsigned int numThreads)
 Set number of threads to use. More...
 
unsigned int getNumThreads ()
 Get maximum number of threads we might use. More...
 
bool disableImplicitThreading ()
 Disable threading that has not been set explicitly. More...
 
std::map< std::string, std::stringgetRuntimeVersions ()
 Return version strings for dependencies. More...
 
std::string getCfitsioVersion ()
 
std::string getFftwVersion ()
 
std::string getWcslibVersion ()
 
std::string getGslVersion ()
 
 PYBIND11_MODULE (threads, mod)
 
 PYBIND11_MODULE (versions, mod)
 
void installPythonModuleImporter ()
 

Variables

bool const haveOpenBlas = loadOpenBlas()
 Is OpenBLAS available? More...
 
bool const haveMkl = loadMkl()
 Is MKL available? More...
 
std::string const allowEnvvar = "LSST_ALLOW_IMPLICIT_THREADS"
 Environment variable to allow implicit threading. More...
 

Function Documentation

◆ canLoadLibrary()

bool lsst::base::canLoadLibrary ( std::string const &  libName)

Return whether we can load a library.

The proper filename extension will be added to the library name unless one is specified.

Parameters
libNameLibrary name

Definition at line 37 of file library.cc.

38 {
39  return dlopen(getLibraryFilename(libName).c_str(), RTLD_LAZY | RTLD_GLOBAL);
40 }
std::string getLibraryFilename(std::string const &name)
Get filename for library.
Definition: library.cc:27

◆ disableImplicitThreading()

bool lsst::base::disableImplicitThreading ( )

Disable threading that has not been set explicitly.

Some threaded packages implicitly use multiple threads if the user doesn't explicitly state the number of desired threads. However, this can interfere with operations that are parallelised at a higher level. This function will disable threading unless the user has explicitly specified the number of desired threads through environment variables.

This behavior may be disabled by setting the environment variable specified by allowEnvvar.

This is principally intended for Linux machines (we explicitly load .so dynamic libraries); MacOS has its own way of doing threading (Grand Central Dispatch) that throttles threads to avoid overwhelming the machine.

@ return whether we disabled threading

Definition at line 132 of file threads.cc.

133 {
134  if (std::getenv(allowEnvvar.c_str())) {
135  return false; // The user knows what he's doing; no intervention performed
136  }
137 
138  bool intervened = false; // Did we intervene on behalf of the user?
139  if (haveOpenBlas) {
140  intervened |= disableImplicitThreadingImpl(
141  "OpenBLAS",
142  {"OPENBLAS_NUM_THREADS", "GOTO_NUM_THREADS", "OMP_NUM_THREADS"},
143  getOpenBlasThreads,
144  setOpenBlasThreads
145  );
146  }
147  if (haveMkl) {
148  intervened |= disableImplicitThreadingImpl(
149  "MKL",
150  {"MKL_NUM_THREADS", "MKL_DOMAIN_NUM_THREADS", "OMP_NUM_THREADS"},
151  getMklThreads,
152  setMklThreads
153  );
154  }
155  return intervened;
156 }
bool const haveMkl
Is MKL available?
Definition: threads.cc:105
T getenv(T... args)
std::string const allowEnvvar
Environment variable to allow implicit threading.
Definition: threads.h:16
T c_str(T... args)
bool const haveOpenBlas
Is OpenBLAS available?
Definition: threads.cc:104

◆ getCfitsioVersion()

std::string lsst::base::getCfitsioVersion ( )

Definition at line 26 of file versions.cc.

27 {
28  typedef float (GetVersion)(float*);
29  float version;
30  loadSymbol<GetVersion>("libcfitsio", "ffvers")(&version);
31 
32  std::stringstream ss(std::stringstream::in | std::stringstream::out);
33  ss << version;
34  return ss.str();
35 }
table::Key< int > version
Definition: PhotoCalib.cc:402

◆ getFftwVersion()

std::string lsst::base::getFftwVersion ( )

Definition at line 37 of file versions.cc.

38 {
39  return std::string(loadSymbol<char const>("libfftw3", "fftw_version"));
40 }
STL class.

◆ getGslVersion()

std::string lsst::base::getGslVersion ( )

Definition at line 48 of file versions.cc.

49 {
50  return std::string(*loadSymbol<char const*>("libgsl", "gsl_version"));
51 }
STL class.

◆ getLibraryFilename()

std::string lsst::base::getLibraryFilename ( std::string const &  name)

Get filename for library.

We'll add the typical filename extension for the platform unless the user specifies a ".so" or ".dylib" extension.

Definition at line 27 of file library.cc.

28 {
29  if (endsWith(name, ".so") || endsWith(name, ".dylib")) {
30  // User asked for a library with a certain extension, so give it to them
31  return name;
32  }
33  return name + libraryExtension();
34 }
std::string libraryExtension()
Return filename extension for libraries.
Definition: library.cc:17

◆ getNumThreads()

unsigned int lsst::base::getNumThreads ( )

Get maximum number of threads we might use.

Returns the maximum value of the number of threads being used by the threading libraries that are available.

Definition at line 120 of file threads.cc.

121 {
122  unsigned int numThreads = 0;
123  if (haveOpenBlas) {
124  numThreads = std::max(numThreads, static_cast<unsigned int>(getOpenBlasThreads()));
125  }
126  if (haveMkl) {
127  numThreads = std::max(numThreads, static_cast<unsigned int>(getMklThreads()));
128  }
129  return numThreads;
130 }
bool const haveMkl
Is MKL available?
Definition: threads.cc:105
T max(T... args)
bool const haveOpenBlas
Is OpenBLAS available?
Definition: threads.cc:104

◆ getRuntimeVersions()

std::map< std::string, std::string > lsst::base::getRuntimeVersions ( )

Return version strings for dependencies.

It is not clever, and only returns versions of packages declared in an internal list.

Returns a map of product:version.

Definition at line 54 of file versions.cc.

55 {
57  for (auto&& pkg : packages) {
58  try {
59  versions[pkg.first] = pkg.second();
60  } catch (LibraryException const&) {
61  // Can't find the module, so ignore it
62  }
63  }
64  return versions;
65 }

◆ getWcslibVersion()

std::string lsst::base::getWcslibVersion ( )

Definition at line 42 of file versions.cc.

43 {
44  typedef char const* (GetVersion)(int[]);
45  return std::string(loadSymbol<GetVersion>("libwcs", "wcslib_version")(NULL));
46 }
STL class.

◆ haveThreads()

bool lsst::base::haveThreads ( )

Are threaded packages available?

Definition at line 26 of file threads.h.

26 { return haveOpenBlas || haveMkl; }
bool const haveMkl
Is MKL available?
Definition: threads.cc:105
bool const haveOpenBlas
Is OpenBLAS available?
Definition: threads.cc:104

◆ installPythonModuleImporter()

void lsst::base::installPythonModuleImporter ( )

Definition at line 58 of file lsstcppimport.cc.

58 { ModuleImporter::install(PythonModuleImporter::get()); }

◆ libraryExtension()

std::string lsst::base::libraryExtension ( )

Return filename extension for libraries.

Typically ".so" for Linux and ".dylib" for Mac.

Definition at line 17 of file library.cc.

18 {
19 #ifdef __APPLE__
20  return ".dylib";
21 #else
22  return ".so";
23 #endif
24 }

◆ loadSymbol()

template<typename T >
T* lsst::base::loadSymbol ( std::string const &  libName,
std::string const &  symName 
)

Load a symbol from a dynamic library.

The proper filename extension will be added to the library name unless one is specified.

No mangling is performed on the symbol name.

Parameters
libNameLibrary name (NOT including ".so" or ".dylib")
symNameSymbol name

Definition at line 51 of file library.h.

55 {
56  void* lib = dlopen(getLibraryFilename(libName).c_str(), RTLD_LAZY | RTLD_DEEPBIND);
57  if (!lib) {
58  throw LibraryException(libName);
59  }
60 
61  T* sym;
62  (void*&)sym = dlsym(lib, symName.c_str());
63  if (!sym) {
64  throw LibraryException(libName, symName);
65  }
66  return sym;
67 }
std::string getLibraryFilename(std::string const &name)
Get filename for library.
Definition: library.cc:27
#define RTLD_DEEPBIND
Definition: library.h:9

◆ PYBIND11_MODULE() [1/2]

lsst::base::PYBIND11_MODULE ( threads  ,
mod   
)

Definition at line 32 of file threads.cc.

32  {
33  mod.def("haveThreads", &lsst::base::haveThreads);
34  mod.def("setNumThreads", &lsst::base::setNumThreads);
35  mod.def("getNumThreads", &lsst::base::getNumThreads);
36  mod.def("disableImplicitThreading", &lsst::base::disableImplicitThreading);
37 }
bool haveThreads()
Are threaded packages available?
Definition: threads.h:26
bool disableImplicitThreading()
Disable threading that has not been set explicitly.
Definition: threads.cc:132
void setNumThreads(unsigned int numThreads)
Set number of threads to use.
Definition: threads.cc:107
unsigned int getNumThreads()
Get maximum number of threads we might use.
Definition: threads.cc:120

◆ PYBIND11_MODULE() [2/2]

lsst::base::PYBIND11_MODULE ( versions  ,
mod   
)

Definition at line 33 of file versions.cc.

33  {
34  mod.def("getRuntimeVersions", &lsst::base::getRuntimeVersions);
35  mod.def("getCfitsioVersion", &lsst::base::getCfitsioVersion);
36  mod.def("getFftwVersion", &lsst::base::getFftwVersion);
37  mod.def("getWcslibVersion", &lsst::base::getWcslibVersion);
38  mod.def("getGslVersion", &lsst::base::getGslVersion);
39 }
std::string getCfitsioVersion()
Definition: versions.cc:26
std::string getFftwVersion()
Definition: versions.cc:37
std::map< std::string, std::string > getRuntimeVersions()
Return version strings for dependencies.
Definition: versions.cc:54
std::string getWcslibVersion()
Definition: versions.cc:42
std::string getGslVersion()
Definition: versions.cc:48

◆ setNumThreads()

void lsst::base::setNumThreads ( unsigned int  numThreads)

Set number of threads to use.

Exceptions
NoThreadsExceptionif no threading library is available

Definition at line 107 of file threads.cc.

108 {
109  if (!haveOpenBlas && !haveMkl && numThreads != 0 && numThreads != 1) {
110  throw NoThreadsException();
111  }
112  if (haveOpenBlas) {
113  setOpenBlasThreads(numThreads);
114  }
115  if (haveMkl) {
116  setMklThreads(numThreads);
117  }
118 }
bool const haveMkl
Is MKL available?
Definition: threads.cc:105
bool const haveOpenBlas
Is OpenBLAS available?
Definition: threads.cc:104

Variable Documentation

◆ allowEnvvar

std::string const lsst::base::allowEnvvar = "LSST_ALLOW_IMPLICIT_THREADS"

Environment variable to allow implicit threading.

Used by disableImplicitThreading.

Definition at line 16 of file threads.h.

◆ haveMkl

bool const lsst::base::haveMkl = loadMkl()

Is MKL available?

Definition at line 105 of file threads.cc.

◆ haveOpenBlas

bool const lsst::base::haveOpenBlas = loadOpenBlas()

Is OpenBLAS available?

Definition at line 104 of file threads.cc.