Systems where pqR has been tried
This page contains reports on which systems pqR has been tested on, including configuration options used, and whether all checks from "make check-all" were passed.
All the configurations below use the BLAS and LAPACK routines supplied with pqR. See here for information on configurations using external BLAS or LAPACK libraries.
Failures of checks due to Latex or related software not being installed are ignored. (But pqR does pass these checks on systems with the appropriate software.) Similarly, some systems did not have Tcl/Tk installed, but failure due to this is not noted below. (Tcl/Tk does work with pqR on system where it is installed.) Note that it is normal to get some test output that indicates differences from the saved output being compared against, as long as it is not marked with "ERROR" or "FAILURE". This may be due, for example, to differing accuracy of mathematical functions such as exp or cos, or to slight changes in wording of error messages.
See the pqR installation instructions (Linux/Unix/Mac or Windows) and pqR's R-admin manual for information on configuration of pqR. Note that many combinations of configuration options are possible, not all of which have been tested on every system, but any combinations that are known not to work are noted.
Tests with "make check-all" can be run with helper threads (if they are enabled) by setting the R_HELPERS environment variable to the number of threads to use.
Note that pqR is not compatible with packages installed with other versions of R (unless perhaps they have only R code, and code called with .C or .Fortran, not with .Call or .External). Packages used should be re-installed from source for pqR. It may be best (at least initially) to run pqR from its build directory (just run <build-dir>/bin/R), with packages installed within that build directory, in order to avoid conflicts with previous installations.
RStudio versions up to 1.1.463 work with pqR (on system where RStudio runs), if built with --enable-R-shlib (which is always the case on Windows and macOS). Later versions of RStudio claim to require R 3.0.1 or later, whereas pqR declares compatibility up to R 2.15.1, but it seems that they don't check in all circumstances, and seem to work OK when they run.
These installation reports are categorized below by operating system and processor type:
The version of pqR used is noted for each report. The reports are updated to refer to the current stable release as soon as possible, but some reports for previous releases may remain if they cannot be updated. Currently, a lot of older reports for versions earlier than pqR-2020-07-23 have been pruned, but more reports, for more processors and operating systems, may be added soon.
On Intel/AMD Linux systems, pqR would usually be compiled with gcc and gfortran, though on some systems clang can be used instead of gcc (though gfortran is still needed). Recent versions of gcc and clang support OpenMP, and hence can be used with helper threads enabled. However, the OpenMP implementation for clang keeps helper threads running even when they are not in use (eg, when the interpreter is waiting for user input), so gcc is recommended for use with helper threads. The proprietary Intel C and Fortran compilers (Intel Parallel Studio XE) can also be used (though this has not been tested recently), and support OpenMP.
RStudio can be used with pqR provided that pqR is configured with the --enable-R-shlib option, and it is not configured with --enable-compressed-pointers on a 64-bit platform. If pqR is not installed as the system R, the environment variable RSTUDIO_WHICH_R must be set to the path to the "R" program for pqR when running "rstudio" (eg, a command such as RSTUDIO_WHICH_R=<build-dir>/bin/R rstudio). The environment variable R_HELPERS may be set to the number of helper threads to use.
Ubuntu 20.04 LTS, Dell Precision T1600 system with Intel "Sandy Bridge" E3-1225 processor (3.1 GHz, 64-bit, 4 cores, 4 threads total), 12 GBytes RAM.
Tests were done on a Lubuntu installation, after installing required software as follows:
sudo apt install build-essential
sudo apt install gfortran
sudo apt install libreadline-dev
sudo apt install xorg-dev
sudo apt install texlive-full
sudo apt install tcl-dev
sudo apt install tk-dev
Other Ubuntu flavours may require a different set of installs, as what is already in the base system may differ.
Compiled with gcc 9.3.0 and gfortran 9.3.0 (which support OpenMP). Configured with uncompressed pointers, with helper threads, as a shared library (so RStudio can be used). Works when tested by running "R_HELPERS=3 make check-all". Works with Studio 1.3.1056.
Configuration options [pqR-2020-07-23]:
--enable-R-shlib \
CC=gcc-9 \
CXX=g++-9 \
FC=gfortran-9 \
F77=gfortran-9 \
CFLAGS='-g -O3 -march=native -mtune=native -fno-stack-protector -falign-functions=32' \
CXXFLAGS='-std=gnu++98 -g -O3 -march=native -mtune=native -fno-stack-protector -fpermissive' \
FFLAGS='-g -O3 -march=native -mtune=native -fno-stack-protector' \
FCFLAGS='-g -O3 -march=native -mtune=native -fno-stack-protector
Setting CC, CXX, FC, and F77 isn't really necessary, since gcc-9, etc. are the defaults for this system. The CFLAGS, etc. settings are aimed at getting the maximum performance for this system. Setting -std=gnu++98 and -fpermissive in CXXFLAGS isn't necessary for building pqR (which doesn't use C++), but may affect installation of packages that use C++, since these options are used for package compilation as well.
One can use gcc-10, g++-10, and gfortran-10 by installing them with "apt install gcc-10", etc. Here is one build using them:
Compiled with gcc 10.0.1 and gfortran 10.0.1 (which support OpenMP). Configured with compressed pointers and helper threads. Works when tested with "R_HELPERS=2 make check-all".
Configuration options [pqR-2020-07-23]:
--enable-compressed-pointers \
CC=gcc-10 \
CXX=g++-10 \
FC=gfortran-10 \
F77=gfortran-10 \
CFLAGS='-g -O3 -march=native -mtune=native -fno-stack-protector -falign-functions=32' \
CXXFLAGS='-g -O3 -march=native -mtune=native -fno-stack-protector -fpermissive -std=gnu++98' \
FFLAGS='-g -O3 -march=native -mtune=native -fno-stack-protector' \
FCFLAGS='-g -O3 -march=native -mtune=native -fno-stack-protector'
Ubuntu 14.04.5 LTS, Dell Precision 530 system with two Xeon "Foster" processors (1.7 GHz, 32-bit, 1 core each, 2 cores total), 1 GByte RAM.
Compiled with gcc 4.8.4 and gfortran 4.8.4, which support OpenMP 3.1.
This processor supports use of the SSE2 instructions, which is now required for pqR for Intel/AMD processors (the 387 FPU does not produce correct IEEE rounding), but which is not the default - hence the -mfpmath=sse compiler option is needed. Setting the architecture to one that supports SSE2 is also necessary (here, -march=native sets it to the architecture on which the compiler is running).
Works with helper threads. Tested by running "R_HELPERS=1 make check-all".
Configuration options [pqR-2020-07-23]:
CFLAGS='-g -O2 -march=native -mtune=native -mfpmath=sse' \
CXXFLAGS='-g -O2 -march=native -mtune=native -mfpmath=sse' \
FFLAGS='-g -O2 -march=native -mtune=native -mfpmath=sse' \
FCFLAGS='-g -O2 -march=native -mtune=native -mfpmath=sse'
On ARM Linux systems, gcc and gfortran can be used. Clang may also be available. RStudio is not available (unless perhaps it can be installed from source, as at https://github.com/dashaub/ARM-RStudio).
Debian/Trusty Linux, CuBox-i4Pro with ARMv7 Cortex-A9 i.MX6 processor (1 GHz, 32-bit, 4 cores), 2 GByte RAM.
Compiling with gcc 4.8.4 (supports OpenMP 3.1) and gfortran 4.8.4, works with uncompressed pointers, with helper threads enabled. Tested with "R_HELPERS=3 make check-all".
Configuration options [pqR-2020-07-23]:
CFLAGS="-g -O3 -march=native -mtune=native" \
CXXFLAGS="-std=gnu++98 -g -O3 -march=native -mtune=native"\
FFLAGS="-g -O3 -march=native -mtune=native" \
FCFLAGS="-g -O3 -march=native -mtune=native"
Tests on Macs are for pqR installed from source and run in a terminal window. The Mac GUI has been reported to work if helper threads are disabled, but will require modifications to work with helper threads. RStudio works, as long as pqR is not configured with --enable-compressed-pointers, but note that if you haven't installed pqR as your current version of R, you must start RStudio from a terminal window, with a command of the form
RSTUDIO_WHICH_R=path-to-pqR-build-directory/bin/R /Applications/RStudio.app/Contents/MacOS/RStudio
Helper threads cannot be used when building with the Apple-supplied C compiler, since it does not support OpenMP, but other versions of clang and gcc do support OpenMP, and can be used to build pqR with helper threads enabled. However, the clang implementation of OpenMP keeps helper threads running even when they have nothing to do, so gcc is recommended if helper threads are to be used.
If you want Java support, you should download the "legacy" Java provided by Apple at https://support.apple.com/kb/dl1572.
On recent Apple systems, support for X Windows (which is needed) is supplied via XQuartz, so this must be installed.
After installing XQuartz, open a terminal in XQuartz and issue the following command to install the Apple development tools, which are also needed:
xcode-select --install
A Fortran compiler is necessary to build pqR; one can be installed using Homebrew (installing using macports may also work). Follow the instructions for installing Homebrew at http://brew.sh, and then do the following to install the gfortran and gcc compilers:
brew update
brew install gcc
Note that the gcc that is installed must be referred to by gcc-10 (or whatever version was installed), since plain gcc is an alias for Apple's clang compiler (for compatibility, and in fact pqR uses it with this name to compile a few Apple-specific modules).
After installing these things, you will be able to build pqR without support for helper threads using Apple's version of clang (called gcc) and gfortran, or to build pqR with helper threads using a real gcc and gfortran.
macOS 10.13.6 (High Sierra), MacBook Pro 9,2 (13-inch, Mid 2012) with one Intel "Ivy Bridge" Core i5-3210M processor (2.5 GHz, 64-bit, 2 cores, 4 threads total), 8 GBytes RAM
Works with gcc 10.1.0 and gfortran 10.1.0 from Homebrew, with uncompressed pointers and with helper threads enabled. Tested with "R_HELPERS=1 make check-all". Works with RStudio 1.1.463 and with RStudio 1.3.1056.
Configuration options [pqR-2020-07-23]:
CC="gcc-10" \
CXX="g++-10" \
FC="gfortran-10" \
F77="gfortran-10"
pqR has been tested and works on Microsoft Windows 7 and 10. All reports below are for builds using the compilers in the Rtools package as described in the installation instructions.
Note that installing Tex (step 1 in the instructions) is not essential to build pqR, though omitting this step will lead to the obvious failures to make some manuals.
At present, the only way to specify the number of helper threads to use is by setting the R_HELPERS environment variable, for example in a console prompt window before starting R from that window.
All builds were tested and work when running R in the console window, with the Windows R Gui, and with RStudio (except RStudio will not work if pqR is configured with --enable-compressed-pointers on a 64-bit platform, it crashes when you try to debug a function). To set RStudio to use a pqR installation, you will need to hold down the control key when starting RStudio (it seems that you may have to press control between the two clicks of a double click...), or select Global Options... under the Tools menu once RStudio is running. To use helper threads with RStudio, you will need to set R_HELPERS in a command prompt window, and then start RStudio the hard way, with something like
set R_HELPERS=1
"c:\Program Files\RStudio\bin\rstudio"
Or you might use the Windows facility for globally specifying environment variables (found under "Settings").
NOTES: It may be necessary to disable or uninstall any anti-virus programs or similar malware that may be installed in order for building pqR to work reliably (such programs may, for example, open files created during the build, causing errors when the build process later attempts to modify these files, but is not allowed to do so because another process has them open). Performance on Windows systems may be subject to large randomly-timed degradations when Windows security and updating processes decide to run automatically, appropriating a substantial fraction of CPU and other resources. Errors from failure of internet accesses in "make check" may result if you have the Windows firewall enabled.
Windows 10 (64-bit), Gateway SX2185 system with AMD E1-2500 "Jaguar" processor (1.4 GHz, 64-bit, 2 cores), 8 GBytes RAM.
Works with a 64-bit build using uncompressed pointers, with helper threads enabled. Tested with "make check-all" with 1 helper thread. Works with RStudio 1.1.463, but not with RStudio 1.3.1056 (which refuses to start using pqR).
Configuration [pqR-2020-07-23, Rtools33 from pqR-project.org/Rtools33.exe]:
- Use pqR-win-extras-64
- Copy MkRules.dist64 to MkRules.local