Some packages contain native code, which is linked to R dynamically in the form of dynamically loaded libraries (DLLs). Recently, R users started loading increasing numbers of packages; “workflow documents” are one source of this pattern. This has eventually lead to hitting the DLL limit in R, which materializes as runtime error “maximal number of DLLs reached”.
Limit on the number of open files
The DLL limit in R is good for one important reason. Each loaded DLL will
consume at least one open file descriptor in the implementation of the
dynamic loader (on Unix inside
dlopen). It can consume more due to
loading of dependent libraries. Operating systems limit the number of open
files per process and on some systems the limit is very low. It has been
reported in the past to be as low as 256 by default on some systems and
todays OS/X platforms still have it at 256 by default. The limit is usually
higher on Linux (e.g. 1024) and is very high (essentially non-existent) on
Windows. It can be increased on both OS/X and Linux, but it is not easy for
regular users. If the limit on the number of open files is reached, R will
start behaving unpredictably as opening files will start failing –
diagnosing that the file limit is the problem may be very difficult (the
failures may show up in any code of R runtime but also in packages; error
messages may not be properly propagated to the user in full detail). At the
same time, diagnosing that the DLL limit has been reached is easy, one gets
a standard R error message saying exactly this when trying to load a DLL,
usually via loading a package.
On POSIX systems (applies to Unix and OS/X of R platforms), the limit on the
number of open files is referred to as
RLIMIT_NOFILE, it can be detected
getrlimit() and changed, following certain restrictions, by
setrlimit(). There is a hard limit and a soft limit. The hard limit
can be irreversibly lowered by a user process. The soft limit can be set
(reversibly) to any value as permitted by the hard limit. One can change
these limits from a shell using utility
ulimit. The utility is not
required by POSIX to support the file limit, but it typically does in shells
on Linux and OS/X. An example from an OS/X 10.13.3 system:
$ ulimit -n 256 $ ulimit -Sn 256 $ ulimit -Hn unlimited
In the example, the soft limit on the system is 256, but there is no (small) hard limit. In fact, there is a limit to the hard limit, it is just not shown by the call. One can thus, with user privileges, simply increase the soft limit to be able to open more files in processes executed further by the shell, so one can just do this before running R:
$ ulimit -Sn 2048
ulimit -n 2048 would do as well, but it would modify both the soft and
the hard limits, and so one would not be able to increase it further, e.g.
for experimentation purposes.
There is also a limit on the number of open files set in the OS kernel. On
OS/X, these are parameters
can be changed via
sysctl (they are
49152 on my system). It
is very unlikely one would have to change these.
DLL registry representation in R
Meta-data about loaded DLLs in R is kept in a fixed-size array allocated at R startup, so setting the size high incurs a memory overhead. In principle, the data structure could be changed to a linked list (and we received a rather extensive patch suggesting to do that). However, one entry of the array takes only 96 bytes (on my 64-bit Linux), so having the limit very high, say a thousand or more, by default would not be a real issue on todays systems with large amounts of memory and perhaps not worth increasing the complexity of this code. One could instead consider re-allocating the array on demand, but it seems there may be pointers inside these entries (I could not persuade myself based on reading the code that moving the entries in memory would be safe). The memory overhead is still small, the real issue that prevents people from loading the DLLs is the number of open files.
Overheads of loading many packages
Apart from that it might not be a good idea conceptually, loading excessive
number of packages may not be advisable also for performance reasons. Even
though packages use so called lazy loading, there are some operations
performed eagerly when packages are loaded, particularly by S4/methods
implementation. Some Bioconductor packages have been seen to take 12
seconds to load on a modern computer (including dependent packages), I’ve
yriMulti which took that long (including dependent
packages) and it seems most time has been spent in updating method tables.
It would be good to reduce these overhead in the future, but for now they
should be taken into consideration.
DLL limit in recent versions of R
In R 3.3.x, the maximum number of DLLs has been fixed to 100. The known minimum default limit on the number of open files was (only) 256, so there was a 156-files buffer to cater for that DLLs may take more than one file and for other files to be open by R runtime and packages.
In R 3.4.x, the maximum number of DLLs can be modified via environment
R_MAX_NUM_DLLS. The variable is checked on R startup and the
fixed array (the registry) is pre-allocated. Setting the variable already
inside running R has no effect on that instance of R. The minimum
permissible value is 100 and the maximum is 1000 (yet permitting the limit
on the number of open files). The limit on the number of open files is
getrlimit() on POSIX systems, and is hardcoded (very high) on
Windows. If such limit is known, the maximum number of DLLs can be up to
60% of the file limit (so the buffer can be a bit smaller than in R 3.3.x).
If no such limit is known, the maximum number of DLLs remains 100. If the
limit on the number of open files is so small that we could not even set the
limit on DLLs to 100, R fails to start with an informative error message.
This allowed users requiring to load many DLLs to increase the DLL limit, but on systems with a small limit on the number of open files (typically OS/X), this also required increasing that limit as well.
To make this behavior more user-friendly, R 3.5.0 automatically aims at a
higher DLL limit (currently 614) when
R_MAX_NUM_DLLS is not set. When the
OS limit on the number of open files is too small for this, R attempts to
increase the limit via
setrlimit() on POSIX systems (on Windows, no
increase is necessary). One thus now gets typically the limit of 614 even on
OS/X systems without setting any variables. When
R_MAX_NUM_DLLS is set,
but the limit on the number of open files is too low, R again attempts to
increase the limit. So now, even on OS/X, this succeeds (provided there is
no strict hard limit):
env R_MAX_NUM_DLLS=1000 R
One can also see that the file limit is increased automatically:
$ ulimit -n 256 $ R > system("ulimit -n") 1024
Listing loaded DLLs
One can list the DLLs registry from R, this could be useful when diagnosing the origins of loaded DLLs:
> getLoadedDLLs() Filename Dynamic.Lookup base base FALSE methods /Users/tomas/trunk/library/methods/libs/methods.so FALSE utils /Users/tomas/trunk/library/utils/libs/utils.so FALSE grDevices /Users/tomas/trunk/library/grDevices/libs/grDevices.so FALSE graphics /Users/tomas/trunk/library/graphics/libs/graphics.so FALSE stats /Users/tomas/trunk/library/stats/libs/stats.so FALSE