Systems where pqR has been tried

Radford Neal edited this page Dec 7, 2016 · 243 revisions

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". For example, tests of 32-bit builds will show differences in object sizes (in lines starting with "RPROFMEM").

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.

These 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.

Linux / Intel or AMD

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, and support OpenMP.

RStudio can be used with pqR provided it is configured with the --enable-R-shlib option. 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=/bin/R rstudio). The environment variable R_HELPERS may be set to the number of helper threads to use.

Recent Intel and AMD processors have fused multiply-add instructions that can produce results that are rounded differently than the results of separate multiply and add instructions. Although the results with fused multiply-add instructions will usually be more accurate, rather than less accurate, this introduces an element of non-reproducibility, since two ways of doing what appears to be the same computation may produce different results, and the results with builds on diffferent platforms or with different compilers or compiler options may differ. Use of these fused instructions is controlled by the -ffp-contract=off (not used) or -ffp-contract=fast (used) options for gcc/gfortran and clang. Therefore, one some processors, some tests may produce differing output, or even explicit errors, unless the -ffp-contract=off option is included in CFLAGS, FFLAGS, and FCFLAGS.

Ubuntu 16.04.1 LTS, Dell Precision T1600 system with Intel 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

Other Ubuntu flavours may require a different set of installs, as what is already in the base system may differ. To use clang, the following were also installed:

sudo apt install clang
sudo apt install libiomp-dev

NOTE: In all these configurations, the time needed for computation of some mathematical functions, such as exp, can vary by a factor of about six in apparently arbitrary (but not random) fashion, as a result of a performance bug in the glibc math libraries that manifests on processors that have AVX instructions. This may be fixed in the development version of glibc. This is in addition to the well known glibc behaviour in which mathematical functions such as exp and sin may take thousands of times longer to computer for certain apparently normal arguments (which is due to glibc's insistence on absolutely correct rounding).

Compiled with gcc 5.4.0 and gfortran 5.4.0 (which support OpenMP 4.0). Configured with helper threads, without fused multiply-add, without byte compiling of base and recommended packages, as a shared library (so RStudio can be used). Works when tested by running "make check-all" with 3 helper threads. Works with RStudio 1.0.44.

Configuration options [pqR-2016-10-24]:

--disable-byte-compiled-packages \
--enable-R-shlib \
CFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
CXXFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FCFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off"

Compiled with clang 3.8.0 (which supports OpenMP 3.1) and gfortran 5.4.0 (which supports OpenMP 4.0). Configured with helper threads, without fused multiply-add, without byte compiling of base and recommended packages, as a shared library (so RStudio can be used). Works when tested by running "make check-all" with 3 helper threads. Works with RStudio 1.0.44. Unfortunately, with the clang OpenMP implementation, helper threads consume CPU time even when they have nothing to do.

Configuration options [pqR-2016-10-24]:

--disable-byte-compiled-packages \
--enable-R-shlib \
CC=clang \
CXX=clang++ \
OBJC=clang \
CFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off -Wno-unused-value -Wno-logical-op-parentheses" \
CXXFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FCFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off"

Ubuntu 14.04.5 LTS, Dell Precision T3620 system with Intel E3-1270 v5 processor (3.6 GHz, 64-bit, 4 cores, 2 threads per core, 8 threads total), 32 GBytes RAM.

Ubuntu 14.04 was pre-installed by Dell, and further software was installed as follows:

sudo apt install build-essential
sudo apt install gfortran
sudo apt install default-jre
sudo apt install automake
sudo apt install texlive-latex-recommended
sudo apt install texlive-fonts-recommended
sudo apt install texlive-fonts-extra 
sudo apt install texinfo
sudo apt install libreadline6-dev
sudo apt install xorg-dev
sudo apt install libbz2-dev
sudo apt install liblzma-dev
sudo apt install libcairo2-dev
sudo apt install libcurl4-openssl-dev
sudo apt install tk-dev
sudo apt install tk-doc

Compiled with gcc 4.8.4 and gfortran 4.8.4 (which support OpenMP 3.1).

Configured with helper threads, without fused multiply-add, without byte compiling of base and recommended packages, as a shared library (so RStudio can be used). Works when tested by running "make check-all" with no helper threads and with 3 helper threads, except that a test for the the 'Matrix' package sometimes hangs up on a call of dev.off() when creating a PNG plot, perhaps only when using a remote X11 connection when system load is high (probably due to some X11 issue unrelated to pqR).

Configuration options [pqR-2016-10-24]:

--disable-byte-compiled-packages \
--enable-R-shlib \
CFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
CXXFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FCFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off"

Fedora 24, Zotac ZBOX C1520 nano, Intel i3-4020Y processor (1.5 GHz, 64-bit, 2 cores, each with 2 threads, 4 threads total), 8 GBytes RAM.

This is a "Haswell" processor, that has fused multiply-add instructions, so the setting of the -ffp-contract option makes a difference.

NOTE: In all these configurations, the time needed for computation of some mathematical functions, such as exp, can vary by a factor of about six in apparently arbitrary (but not random) fashion, as a result of a performance bug in the glibc math libraries that manifests on processors that have AVX instructions. This may be fixed in the development version of glibc. This is in addition to the well known glibc behaviour in which mathematical functions such as exp and sin may take thousands of times longer to computer for certain apparently normal arguments (which is due to glibc's insistence on absolutely correct rounding).

Compiled with gcc 6.2.1 (supports OpenMP 4.0) and gfortran 6.2.1.

Works with helper threads enabled and no byte compiling of packages, with use of fused multiply-add disabled, building as a shared library (so it can be used with rstudio). Confirmed as working with RStudio 0.99.902. Tested with "make check-all" using 3 helper threads.

Configuration options [pqR-2016-10-24]:

--disable-byte-compiled-packages \
--enable-R-shlib \
CFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
CXXFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FCFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" 

Ubuntu 14.04.2, Gateway SX2185 system with AMD E1-2500 processor (1.4 GHz, 64-bit, 2 cores), 4 GBytes RAM.

Compiled with gcc 4.8.4 (supports OpenMP 3.1) and gfortran 4.8.4.

Works with helper threads and without byte compiling of base and recommended packages, building as a shared library (as needed for RStudio). Tested by running "make check-all" with 0 helper threads and with 1 helper thread. Confirmed as working with RStudio 0.99.464.

Configuration options [pqR-2015-09-14]:

--disable-byte-compiled-packages \
--enable-R-shlib \
CFLAGS="-g -O2 -march=native -mtune=native" \
CXXFLAGS="-g -O2 -march=native -mtune=native" \
FFLAGS="-g -O3 -march=native -mtune=native" \
FCFLAGS="-g -O3 -march=native -mtune=native"

Works with helper threads disabled and with byte compiling of base and recommended packages. Tested by running "make check-all".

Configuration options [pqR-2015-09-14]:

--disable-helper-threads \
CFLAGS="-g -O2 -march=native -mtune=native" \
CXXFLAGS="-g -O2 -march=native -mtune=native" \
FFLAGS="-g -O3 -march=native -mtune=native" \
FCFLAGS="-g -O3 -march=native -mtune=native"

CentOS release 6.8, Dell PowerEdge R920 system with 4 E7-8891 v2 processors (3.2 GHz, 64-bit, 10 cores per processor, 2 threads per core, 80 threads total), 256 GBytes RAM.

Compiled with gcc 4.4.7 and fortran 4.4.7 (which support OpenMP 3.0).

Works with helper threads enabled, without byte compiling of base and recommended packages, built as a shared library. Tested using 'make check-all' with no helper threads and with 9 helper threads.

Configuration options [pqR-2016-10-24]:

--disable-byte-compiled-packages \
--enable-R-shlib \
CFLAGS='-g -O3 -march=native -mtune=native' \
CXXFLAGS='-g -O3 -march=native -mtune=native' \
FFLAGS='-g -O3 -march=native -mtune=native' \
FCFLAGS='-g -O3 -march=native -mtune=native'

Ubuntu 12.04.5 LTS, Dell Precision 350 system with Pentium 4 processor (3.06 GHz, 32-bit, single core), 2 GBytes RAM.

Compiled with gcc 4.6.3 and gfortran 4.6.3.

Helper threads were disabled, since this system has only a single core, so no benefit would be expected. Since this processor supports the SSE2 instructions, the compiler option to use them for floating point operations was specified, since this probably gives better performance, and more reproducible results. (Note that using SSE2 instructions is the default for 64-bit processors, since all 64-bit processors have them.)

Works with helper threads disabled (but task merging enabled) and without byte compiling of base and recommended packages.

Configuration options [pqR-2016-10-24]:

--disable-helper-threads \
--disable-byte-compiled-packages \
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'

Ubuntu 12.04.5 LTS, Dell Precision 530 system with two Xeon processors (1.7 GHz, 32-bit, 1 core each, 2 cores total), 2 GBytes RAM.

Compiled with gcc 4.6.4 and gfortran 4.6.4, which support OpenMP 3.0.

Since this processor supports the SSE2 instructions, the compiler option to use them for floating point operations was specified, since this probably gives better performance, as well as more reproducible results.

Works with helper threads and without byte compiling of base and recommended packages. Tested by running "make check-all" with 1 helper thread.

Configuration options [pqR-2016-10-24]:

--disable-byte-compiled-packages \
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"

Works compiled as a shared library (for use with RStudio) with helper threads and with byte compiling of base and recommended packages. Tested by running "make check-all" with no helper threads and with 1 helper thread. Verified to work with RStudio 0.98.1056.

Configuration options [pqR-2016-10-24]:

--enable-R-shlib \
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"

Linux / ARM

On ARM Linux systems, gcc and fortran can be used. Clang may also be available, but problems compiling Rcpp were observed when it was tried on the CuBox system below. 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 helper threads enabled and without byte compiling of base and recommended packages. Tested with "make check-all" with no helper threads and with 3 helper threads.

Configuration options [pqR-2016-10-24]:

--disable-byte-compiled-packages \
CFLAGS="-g -O2 -march=native -mtune=native" \
CXXFLAGS="-g -O2 -march=native -mtune=native" \
FFLAGS="-g -O3 -march=native -mtune=native" \
FCFLAGS="-g -O3 -march=native -mtune=native"

Compiling with gcc 4.8.4 and gfortran 4.8.4, works with helper threads disabled and with byte compiling of base and recommended packages (tested with "make check-all").

Configuration options [pqR-2016-10-24]:

--disable-helper-threads \
CFLAGS="-g -O2 -march=native -mtune=native" \
CXXFLAGS="-g -O2 -march=native -mtune=native" \
FFLAGS="-g -O3 -march=native -mtune=native" \
FCFLAGS="-g -O3 -march=native -mtune=native"

Rasbian GNU/Linux 7 (wheezy), Raspberry Pi Model B with ARMv6-compatible processor (700 MHz, 32-bit, single core), 512 MBytes RAM.

Additional software was installed in addition to what comes with Rasbian (the version released 2015-01-30), by running "apt-get install" for gfortran, libreadline-dev, and xorg-dev.

Helper threads were disabled, since this system has only a single core, so no benefit would be expected.

When running "make check-all", there may be errors (non-fatal, in the pqR version of the test scripts) when "xz" compression is attempted, due to lack of memory (error code 5), and in a test for the Matrix recommended package. These tests may succeed if the size of the system swap file is increased from 100 to 300 MBytes by editing /etc/dphys-swapfile (and then rebooting).

Compiling with gcc 4.6.3 and gfortran 4.6.3, works (passes "make check-all", when swap file size increased) with helper threads disabled (but task merging enabled) and without byte compiling of base and recommended packages.

Configuration options [pqR-2016-10-24]:

--disable-helper-threads \
--disable-byte-compiled-packages \
CFLAGS="-g -O2" \
CXXFLAGS="-g -O2" \
FFLAGS="-g -O2" \
FCFLAGS="-g -O2"

Linux / PowerPC

PowerPC Linux systems will generally have gcc and gfortran available (clang is also available, but has not yet been tried). RStudio is not available (unless perhaps it can be installed from source).

Lubuntu 16.04.1, Apple iBook G4 with PowerPC G4 processor (1.07 GHz, 32-bit, 1 core), 1.125 GByte RAM.

[ Note: To install Lubuntu 16.04 on this machine, one must use "video=ofonly radeon.agpmode=-1", not just the "video=ofonly" option suggested by the installer. ]

The easiest way to install most of the development tools is "sudo apt-get install r-base-core", which installs gcc, gfortran, and other development tools along with R-3.2.3. One also needs "sudo apt-get install xorg-dev".

This system has only one processor core, so one would expect no benefit from using helper threads.

Compiling with gcc 5.4.0 and fortran 5.4.0, works with helper threads disabled and without byte compiling of base and recommended packages. Testing with "make check-all" produces a few instances of slightly different floating-point output.

Configuration options [pqR-2016-10-24]:

--disable-helper-threads \
--disable-byte-compiled-packages \
CFLAGS="-g -O2" \
CXXFLAGS="-g -O2" \
FFLAGS="-g -O2" \
FCFLAGS="-g -O2"

Lubuntu 14.04, Apple iBook G4 with PowerPC G4 processor (800 MHz, 32-bit, 1 core), 1.125 GByte RAM.

[ Note: To install Lubuntu 14.04 on this machine, one must use "video=ofonly radeon.agpmode=-1", not just the "video=ofonly" option suggested by the installer. ]

The easiest way to install most of the development tools is "sudo apt-get install r-base-core", which installs gcc, gfortran, and other development tools along with R-3.0.2. One also needs "sudo apt-get install xorg-dev".

This system has only one processor core, so one would expect no benefit from using helper threads.

Compiling with gcc 4.8.4 and gfortran 4.8.4, works (except as noted below) with helper threads disabled and without byte compiling of base and recommended packages. Testing with "make check-all" fails the p-d-q-r-tests, because the value output on line 1018 is 0.39894228 rather than 0.39894227, presumably do to slightly different floating-point precision. Editing tests/Examples/d-p-q-r-tests.Rout.save in the source directory to match the value produced allows "make check-all" to complete. A few other instances of slightly different floating-point output are also seen, including one instance where symbolic representations differ ("*" vs. "+"), due to slightly different floating-point errors when the value is near the cutoff point.

Configuration options [pqR-2015-09-14]:

--disable-helper-threads \
--disable-byte-compiled-packages \
CFLAGS="-g -O2" \
CXXFLAGS="-g -O2" \
FFLAGS="-g -O2" \
FCFLAGS="-g -O2"

Mac OS X / Intel

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, 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

Recent versions of the Apple C compiler, clang, produce a large number of warnings for "expression result unused" when compiling pqR, stemming from use of the expression "(0,(x))" in a macro. This is legal C code, used deliberately to ensure that any inappropriate use of some macros on the left side of an assignment statement will produce an error. These and other spurious warnings can be suppressed with suitable compiler options (see below).

Helper threads cannot be used when building with the Apple-supplied C compiler, since these compilers do 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. An old version of gfortran-4.2.3 is mentioned for some tests below, but it is probably better to use a newer version installed using Homebrew or macports.

The recent tests below were done using Homebrew, so this is recommended.
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 --without-multilib

This unfortunately takes a while. The --without-multilib option is essential in order to get OpenMP to work correctly, which is needed for helper threads, as well as some R packages.

After installing these things, you will be able to build pqR without support for helper threads using Apple's version of clang and gfortran, or to build pqR with helper threads using gcc and gfortran. To build pqR with helper threads using clang, you will need to install a non-Apple version of clang that supports OpenMP, which can be done by downloading clang for Mac OS from http://llvm.org/releases/download.html and then installing it as follows:

cd /opt
sudo mkdir clang+llvm-3.9.0-x86_64-apple-darwin
sudo chown <your-acct> clang+llvm-3.9.0-x86_64-apple-darwin
tar xf ~/Downloads/clang+llvm-3.9.0-x86_64-apple-darwin.tar.xz

You should then put /opt/clang+llvm-3.9.0-x86_64-apple-darwin/bin in your PATH shell variable, for instance, by putting the following in your .bashrc file (and then closing your terminal and re-opening a new one):

PATH=$PATH:/opt/clang+llvm-3.9.0-x86_64-apple-darwin/bin

This all assumes that you downloaded version 3.9.0 and want to put it in /opt -- obvious modifications are needed if you get a different version or want to put it elsewhere (but the configuration options below assume you put it in /opt).

macOS 10.12.1 (Sierra), Macbook 7,1 (Mid 2010) with one Intel Core 2 Duo processor (2.4 GHz, 64-bit, 2 cores, 2 threads total), 2 GBytes RAM.

Note: In the configurations below, the -ffp-contract=off option is used to disable use of fused multiply-add instructions, but this probably makes no difference with this processor.

Works with Apple's clang (aka gcc) version 8.0.0/800.0.42.1 and gfortran 6.2.0 from homebrew, with helper threads disabled, and with byte compiling of base and recommended packages. Tested by running "make check-all". Works with RStudio 0.99.903.

Configuration options [pqR-2016-10-24]:

--disable-helper-threads \
CC="clang" \
CXX="clang++" \
OBJC="clang" \
FC="gfortran-6" \
F77="gfortran-6" \
CFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off -Wno-unused-value -Wno-logical-op-parentheses" \
CXXFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FCFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off"

Works with clang 3.9.0 (supporting OpenMP) installed from the llvm website (see above) and gfortran 6.2.0 from homebrew, with helper threads enabled, and without byte compiling of base and recommended packages. Tested with "R_HELPERS=1 make check-all". Works with RStudio 0.99.903. Unfortunately, with the clang OpenMP implementation, the helper threads run even when they have nothing to do (eg, when the interpreter is waiting for user input).

Configuration options [pqR-2016-10-24]:

--disable-byte-compiled-packages \
CC="clang-3.9" \
CXX="clang-3.9" \
FC="gfortran-6" \
F77="gfortran-6" \
MAIN_LDFLAGS="-rpath /opt/clang+llvm-3.9.0-x86_64-apple-darwin/lib -rpath /usr/local/lib/gcc/6 /opt/clang+llvm-3.9.0-x86_64-apple-darwin/lib/libomp.dylib" \
SHLIB_LDFLAGS="-rpath /opt/clang+llvm-3.9.0-x86_64-apple-darwin/lib -rpath /usr/local/lib/gcc/6 /opt/clang+llvm-3.9.0-x86_64-apple-darwin/lib/libomp.dylib" \
DYLIB_LDFLAGS="-rpath /opt/clang+llvm-3.9.0-x86_64-apple-darwin/lib -rpath /usr/local/lib/gcc/6 /opt/clang+llvm-3.9.0-x86_64-apple-darwin/lib/libomp.dylib" \
LDFLAGS="-L/opt/clang+llvm-3.9.0-x86_64-apple-darwin/lib -L/usr/local/lib/gcc/6" \
CFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off -Wno-unused-value -Wno-logical-op-parentheses" \
CXXFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
OBJCFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FCFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off"

Works with gcc 6.2.0 and gfortran 6.2.0, with helper threads enabled, without byte compiling of base and recommended packages. Unfortunately, it is necessary to disable support for non-English languages, because an Apple-supplied include file used for this module contains code that gcc can't compile. Tested with "R_HELPERS=1 make check-all". Works with RStudio 0.99.903.

Configuration options [pqR-2016-10-24]:

--disable-byte-compiled-packages \
--disable-nls \
CC="gcc-6" \
CXX="g++-6" \
FC="gfortran-6" \
F77="gfortran-6" \
CFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
CXXFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FCFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off"

OS X 10.11.6 (El Capitan), Mac Pro 3,1 (early 2008) with two Intel E5462 processors (2.8 GHz, 64-bit, 4 cores each, 8 cores total, 8 threads total), 16 GBytes RAM.

Note: In the configurations below, the -ffp-contract=off option is used to disable use of fused multiply-add instructions, but this probably makes no difference with this processor.

Works with Apple's clang (aka gcc) version 7.3.0/703.0.31 and gfortran 6.2.0 from homebrew, with helper threads disabled, and without byte compiling of base and recommended packages. Tested by running "make check-all". Works with RStudio 1.0.44.

Configuration options [pqR-2016-10-24]:

--disable-byte-compiled-packages \
--disable-helper-threads \
CC="clang" \
CXX="clang++" \
OBJC="clang" \
FC="gfortran-6" \
F77="gfortran-6" \
CFLAGS="-g -O2 -march=native -mtune=native -ffp-contract=off -Wno-unused-value -Wno-logical-op-parentheses" \
CXXFLAGS="-g -O2 -march=native -mtune=native -ffp-contract=off" \
OBJCFLAGS="-g -O2 -march=native -mtune=native -ffp-contract=off" \
FCFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off"

Works with clang 3.9.0 (supporting OpenMP) installed from the llvm website (see above) and gfortran 6.2.0 from homebrew, with helper threads enabled, and without byte compiling of base and recommended packages. Tested with "R_HELPERS=7 make check-all". Works with RStudio 1.0.44. Unfortunately, with the clang OpenMP implementation, the helper threads run even when they have nothing to do (eg, when the interpreter is waiting for user input).

Configuration options [pqR-2016-10-24]:

--disable-byte-compiled-packages \
CC="clang-3.9" \
CXX="clang-3.9" \
FC="gfortran-6" \
F77="gfortran-6" \
MAIN_LDFLAGS="-rpath /opt/clang+llvm-3.9.0-x86_64-apple-darwin/lib -rpath /usr/local/lib/gcc/6 /opt/clang+llvm-3.9.0-x86_64-apple-darwin/lib/libomp.dylib" \
SHLIB_LDFLAGS="-rpath /opt/clang+llvm-3.9.0-x86_64-apple-darwin/lib -rpath /usr/local/lib/gcc/6 /opt/clang+llvm-3.9.0-x86_64-apple-darwin/lib/libomp.dylib" \
DYLIB_LDFLAGS="-rpath /opt/clang+llvm-3.9.0-x86_64-apple-darwin/lib -rpath /usr/local/lib/gcc/6 /opt/clang+llvm-3.9.0-x86_64-apple-darwin/lib/libomp.dylib" \
LDFLAGS="-L/opt/clang+llvm-3.9.0-x86_64-apple-darwin/lib -L/usr/local/lib/gcc/6" \
CFLAGS="-g -O2 -march=native -mtune=native -ffp-contract=off -Wno-unused-value -Wno-logical-op-parentheses" \
CXXFLAGS="-g -O2 -march=native -mtune=native -ffp-contract=off" \
OBJCFLAGS="-g -O2 -march=native -mtune=native -ffp-contract=off" \
FCFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off"

Works with gcc 6.2.0 and gfortran 6.2.0, with helper threads enabled, without byte compiling of base and recommended packages. Tested with "R_HELPERS=7 make check-all". Works with RStudio 1.0.44.

Configuration options [pqR-2016-10-24]:

--disable-byte-compiled-packages \
CC="gcc-6" \
CXX="g++-6" \
FC="gfortran-6" \
F77="gfortran-6" \
CFLAGS="-g -O2 -march=native -mtune=native -ffp-contract=off" \
CXXFLAGS="-g -O2 -march=native -mtune=native -ffp-contract=off" \
FCFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off" \
FFLAGS="-g -O3 -march=native -mtune=native -ffp-contract=off"

OS X 10.10.4 (Yosemite), Mac mini 3,1 (early 2009) with Intel Core 2 Duo processor (2.0 GHz, 64-bit, 2 cores), 4 GBytes RAM.

Apple's Xcode 6.4 was installed. XQuartz 2.7.7 was installed. The gfortran-4.2.3 Fortran compiler was installed from http://cran.r-project.org/bin/macosx/tools/ (also available here).

Compiling with Apple LLVM version 6.1.0 (based on LLVM 3.6.0, called "gcc"), works (passes "make check-all") with helper threads disabled (but task merging enabled) and with byte compiling of base and recommended packages disabled.

Configuration options [pqR-2015-07-08]:

--disable-byte-compiled-packages \
--disable-helper-threads \
CFLAGS="-g -O3 -march=native -mtune=native -Wno-unused-value -Wno-logical-op-parentheses" \
CXXFLAGS="-g -O3 -march=native -mtune=native" \
OBJCFLAGS="-g -O3 -march=native -mtune=native" \
FFLAGS="-O3 -m64 -mtune=native" \
FCFLAGS="-O3 -m64 -mtune=native"

OS X 10.10.3 (Yosemite), MacBook Pro 3,1 (mid/late 2007) with Intel Core 2 Duo processor (2.4 GHz, 64-bit, 2 cores), 4 GBytes RAM.

Apple's Xcode 6.3.2 was installed. XQuartz 2.7.7 was installed. The gfortran-4.2.3 Fortran compiler was installed from http://cran.r-project.org/bin/macosx/tools/ (also available here).

Compiling with Apple LLVM version 6.1.0 (clang 3.6.0, called "gcc"), works (passes "make check-all") with helper threads disabled (but task merging enabled) and with byte compiling of base and recommended packages.

Configuration options [pqR-2015-07-08]:

--disable-helper-threads \
CFLAGS="-g -O3 -march=native -mtune=native -Wno-unused-value -Wno-logical-op-parentheses" \
CXXFLAGS="-g -O3 -march=native -mtune=native" \
OBJCFLAGS="-g -O3 -march=native -mtune=native" \
FFLAGS="-O3 -m64 -mtune=native" \
FCFLAGS="-O3 -m64 -mtune=native"

OS X 10.9.5 (Mavericks), Mac Pro 3,1 (early 2008) with two Intel E5462 processors (2.8 GHz, 64-bit, 4 cores each, 8 cores total), 32 GBytes RAM.

Apple's Xcode 6.2 was installed. XQuartz 2.7.7 was installed.

Two C compilers were tried - the Apple LLVM compiler supplied with Xcode, which does not allow for helper threads (lack of OpenMP support), and gcc 4.7 obtained from macports.org, which does allow for helper threads.

After installing the gfortran-4.2.3 Fortran compiler from http://cran.r-project.org/bin/macosx/tools/ (also available here), compiling with Apple LLVM version 6.0 (clang-600.0.57, called "gcc") and gfortran 4.2.3 works (passes "make check-all") with helper threads disabled (but task merging enabled) and with byte compiling of base and recommended packages.

Configuration options [pqR-2015-09-14]:

--disable-helper-threads \
CFLAGS="-g -O3 -march=native -mtune=native -Wno-unused-value -Wno-logical-op-parentheses" \
CXXFLAGS="-g -O3 -march=native -mtune=native" \
OBJCFLAGS="-g -O3 -march=native -mtune=native" \
FFLAGS="-O3 -m64 -mtune=native" \
FCFLAGS="-O3 -m64 -mtune=native"

After installing gcc 4.7 and gfortran 4.7 from macports.org, compiling with gcc 4.7.3 (supports OpenMP 3.1) and gfortran 4.7.3 works with helper threads and without byte compiling of base and recommended packages. (Tested by running "make check-all" with no helper threads and with 7 helper threads.)

Configuration options [pqR-2015-09-14]:

--disable-byte-compiled-packages \
CC="gcc-mp-4.7" \
CXX="g++-mp-4.7 -L/opt/local/lib" \
FC="gfortran-mp-4.7" \
F77="gfortran-mp-4.7" \
OBJC="gcc-mp-4.7" \
CFLAGS="-g -O2 -m64 -march=native -mtune=native" \
CXXFLAGS="-g -O2 -m64 -march=native -mtune=native -I/opt/local/include/gcc47/c++" \
FCFLAGS="-g -O3 -m64 -march=native -mtune=native" \
FFLAGS="-g -O3 -m64 -march=native -mtune=native" \
OBJCFLAGS="-g -O2 -m64 -march=native -mtune=native" \
CPPFLAGS="-I/usr/include" \
LDFLAGS="-L/opt/local/lib" \
R_XTRA_LIBS="/opt/local/lib/gcc47/gcc/x86_64-apple-darwin13/4.7.3/libgcc.a"

OS X 10.6.8 (Snow Leopard), MacBookAir 3,1 (late 2010) with Intel Core 2 Duo processor (1.4 GHz, 64-bit, 2 cores), 2 GBytes RAM.

All the builds below pass "make check-all" except for one error in reg-tests-1b, in which the following expression fails to produce an error (instead returning a match of length zero):

regexpr("a{2-}", "")

The cause of this hasn't been investigated, but a guess would be that it relates to some 64-bit Snow Leopard system library.

One can build pqR without helper threads using the C compiler (gcc 4.2.1) from Apple's Xcode 3.2.6, and with the version of X11 distributed with Snow Leopard. The gfortran-4.2.3 Fortran compiler can be installed from http://cran.r-project.org/bin/macosx/tools/ (also available here).

Compiling with gcc 4.2.1, works (passes "make check-all" except as noted above) with helper threads disabled (but task merging enabled) and with byte compiling of base and recommended packages.

Configuration options [pqR-2014-11-16]:

--disable-helper-threads \
CFLAGS="-g -O2 -m64 -mtune=native -DENABLE_ISNAN_TRICK" \
CXXFLAGS="-g -O2 -m64 -mtune=native" \
OBJCFLAGS="-g -O2 -m64 -mtune=native" \
FFLAGS="-O3 -m64 -mtune=native" \
FCFLAGS="-O3 -m64 -mtune=native"

Compiling with gcc 4.2.1, works (passes "make check-all" except as noted above) with helper threads disabled (but task merging enabled) and without byte compiling of base and recommended packages.

Configuration options [pqR-2014-11-16]:

--disable-byte-compiled-packages \
--disable-helper-threads \
CFLAGS="-g -O2 -m64 -mtune=native -DENABLE_ISNAN_TRICK" \
CXXFLAGS="-g -O2 -m64 -mtune=native" \
OBJCFLAGS="-g -O2 -m64 -mtune=native" \
FFLAGS="-O3 -m64 -mtune=native" \
FCFLAGS="-O3 -m64 -mtune=native"

One can build pqR with helper threads enabled using gcc 4.7 obtained from macports.org, from where one can also get gfortran 4.7.

Compiling with gcc 4.7.3 (supports OpenMP 3.1) and gfortran 4.7.3, works with helper threads and without byte compiling of base and recommended packages. (Tested by running "make check-all" with 0 helper threads and with 1 helper thread.)

Configuration options [pqR-2014-11-16]:

--disable-byte-compiled-packages \
CC="gcc-mp-4.7 -std=gnu99" \
CXX="g++-mp-4.7 -L/opt/local/lib" \
OBJC="gcc-mp-4.7" \
F77="gfortran-mp-4.7" \
FC="gfortran-mp-4.7" \
CFLAGS="-g -O2 -m64 -march=native -mtune=native -DENABLE_ISNAN_TRICK" \
CXXFLAGS="-g -O2 -m64 -march=native -mtune=native -I/opt/local/include/gcc47/c++" \
OBJCFLAGS="-g -O2 -m64 -march=native -mtune=native" \
CPPFLAGS="-I/usr/include" \
FFLAGS="-g -O2 -m64 -march=native -mtune=native" \
FCFLAGS="-g -O2 -m64 -march=native -mtune=native" \
LDFLAGS="-L/opt/local/lib" \
R_XTRA_LIBS="/opt/local/lib/gcc47/gcc/x86_64-apple-darwin10/4.7.3/libgcc.a"

OS X 10.6.8 (Snow Leopard), Mac mini 1,1 (early 2006) with Intel Core Solo processor (1.5 GHz, 32-bit, 1 core), 2 GBytes RAM.

Apple's Xcode 3.2.6 and XQuartz 2.3.6 were used (the old X11 that comes with Snow Leopard also works). The gcc 4.2.1 compiler supplied with Xcode was used, along with the gfortran-4.2.1 Fortran compiler from http://r.research.att.com/tools (also available here).

Works (passes "make check-all") with helper threads disabled (but task merging enabled), with SSE2 instructions used for floating point operations, and without byte compiling of base and recommended packages.

Configuration options [pqR-2015-09-14]:

--disable-byte-compiled-packages \
--disable-helper-threads \
CFLAGS="-g -O2 -mtune=native -mfpmath=sse" \
CXXFLAGS="-g -O2 -mtune=native -mfpmath=sse" \
FFLAGS="-g -O3 -mtune=native -mfpmath=sse" \
FCFLAGS="-g -O3 -mtune=native -mfpmath=sse"

Solaris / SPARC

The Oracle Solaris Studio compilers can be used to build pqR, in conjunction with some software (eg, the readline library) from www.opencsw.org. One can also install gcc and gfortran from www.opencsw.org, and use them to compile pqR.

The Oracle Solaris Studio compilers support OpenMP. However, helper threads run continually even when they have nothing to do, a problem which I have so far not been able to solve by fiddling with the Solaris OpenMP options. Also, one test with 10 helper threads on a T5140 system resulted in the tests hanging up, with no progress made (though this was not repeatable). Examination of the core file produced when terminating this test indicated that the problem was likely a resource starvation issue with the Oracle implementation of the OpenMP atomic read and write operations. This problem is unlikely to arise except when many helper threads are running on an otherwise idle system.

Build time with the Oracle compilers can be quite long, especially when helper threads are enabled, since compiling the merged-ops.c file can then take several hours (on a T5140 system).

Recent versions of gcc also support OpenMP, and can be used to build pqR with helper threads. With the gcc implementation of OpenMP, helper threads without a task to perform do not consume CPU time (with default settings for OpenMP options).

Oracle Solaris 11.2, SPARC Enterprise T5140 with two UltraSPARC T2 Plus processors (1.2 GHz, 8 cores each, 8 threads per core, 128 threads total), 16 GBytes RAM.

Works with Oracle Solaris Studio 12.4 in a 64-bit build with helper threads enabled and without byte compiling of base and recommended packages. Tested using "make check-all" with 10 helper threads.

Configuration options [pqR-2016-10-24]:

--disable-byte-compiled-packages \
CC='cc -xc99 -m64' \
CFLAGS='-g -O3 -xlibmil -xlibmieee -xtarget=native -I/opt/csw/include' \
CXX='CC -library=stlport4 -m64' \
CXXFLAGS='-g -O3 -xtarget=native' \
FC='f95 -m64' \
FCFLAGS='-g -O3 -xlibmil -xtarget=native' \
F77='f95 -m64' \
FFLAGS='-g -O3 -xtarget=native' \
FCLIBS="-lfai -lfai2 -lfsu" \
LDFLAGS="-L/opt/csw/lib/sparcv9 -L/opt/solarisstudio12.4/lib/sparcv9"

Works except as noted below with Oracle Solaris Studio 12.4 in a 32-bit build with helper threads disabled and with byte compiling of base and recommended packages. Tested with "make check-all", with the only failure being in the check of the "mgcv" package, which produced a relocation error involving perl when attempting to do a test using the "parallel" package. This error does not occur with 64-bit builds, or when gcc is used (see below). It is perhaps due to some system configuration problem not related to pqR.

Configuration options [pqR-2016-10-24]:

--disable-helper-threads \
CC='cc -xc99' \
CFLAGS='-g -O3 -xlibmil -xlibmieee -xtarget=native -I/opt/csw/include' \
CXX='CC -library=stlport4' \
CXXFLAGS='-g -O3 -xtarget=native' \
FC=f95 \
FCFLAGS='-g -O3 -xlibmil -xtarget=native' \
F77=f95 \
FFLAGS='-g -O3 -xtarget=native' \
FCLIBS="-lfai -lfai2 -lfsu" \
LDFLAGS="-L/opt/csw/lib -L/opt/solarisstudio12.4/lib"

Works with gcc 4.9.2 and gfortran 4.9.2 in a 32-bit build with helper threads enabled and without byte compiling of base and recommended packages. Fused multiply-add instructions are disabled, though it's not clear this actually changes anything. Tested using "make check-all" with no helper threads and with 10 helper threads.

Configuration options [pqR-2016-10-24]:

--disable-byte-compiled-packages \
CC='gcc -std=gnu99' \
CXX=g++ \
F77=gfortran \
FC=gfortran \
OBJC=gcc \
CFLAGS='-g -O2 -mcpu=v9 -ffp-contract=off' \
CXXFLAGS='-g -O2 -mcpu=v9 -ffp-contract=off' \
FFLAGS='-g -O3 -mcpu=v9 -ffp-contract=off' \
FCFLAGS='-g -O3 -mcpu=v9 -ffp-contract=off'

Works with gcc 4.9.2 and gfortran 4.9.2 in a 64-bit build with helper threads enabled and without byte compiling of base and recommended packages. Fused multiply-add instructions are disabled, though it's not clear this actually changes anything. Tested using "make check-all" with 14 helper threads.

Configuration options [pqR-2016-10-24]:

--disable-byte-compiled-packages \
CC='gcc -std=gnu99 -m64' \
CXX='g++ -m64' \
F77='gfortran -m64' \
FC='gfortran -m64' \
OBJC='gcc -m64' \
CFLAGS='-g -O2 -mcpu=v9' -ffp-contract=off \
CXXFLAGS='-g -O2 -mcpu=v9' -ffp-contract=off \
FFLAGS='-g -O3 -mcpu=v9' -ffp-contract=off \
FCFLAGS='-g -O3 -mcpu=v9' -ffp-contract=off

Oracle Solaris 10, Sun Fire V880 with 8 UltraSPARC-III+ processors (1.2 GHz, 1 core each, 8 cores total), 24 GBytes RAM.

Works with Oracle Solaris Studio 12.3 compilers in a 32-bit build with helper threads enabled and without byte compiling of base and recommended packages. Tested using "make check-all" with no helper threads and with 3 helper threads.

Configuration options [pqR-2015-09-14]:

--disable-byte-compiled-packages \
CC='cc -xc99' \
CFLAGS='-g -O3 -xlibmil -xlibmieee -xtarget=native -I/opt/csw/include' \
CXX='CC -library=stlport4' \
CXXFLAGS='-g -O3 -xtarget=native' \
FC=f95 \
FCFLAGS='-g -O3 -xlibmil -xtarget=native' \
F77=f95 \
FFLAGS='-g -O3 -xtarget=native' \
FCLIBS="-lfai -lfai2 -lfsu" \
LDFLAGS="-L/opt/csw/lib -L/opt/solarisstudio12.3/lib"

Microsoft Windows / Intel

pqR has been tested and works on Microsoft Windows XP, 7, 8, 8.1, and 10 (it probably works with Windows Vista too). 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. If you've downloaded the latest version of miktex, the r-devel post here may be helpful (but it hasn't been tested with pqR).

At present, the only way to specify the number of helper threads to use is by setting the R_HELPERS environment variable in a console prompt window before starting R.

All builds were tested and work when running R in the console window, with the Windows R Gui, and with RStudio. 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"

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 processor (1.4 GHz, 64-bit, 2 cores), 8 GBytes RAM.

Works with a 64-bit build with helper threads enabled, and without byte compiling of included packages. Tested with "make check-all" with 1 helper thread. Works with RStudio 0.99.902.

Configuration [pqR-2016-10-24, Rtools33 from pqR-project.org/Rtools33.exe]:

  • Use pqR-win-extras-64
  • Copy MkRules.dist64 to MkRules.local
  • Set R_NO_BASE_COMPILE to TRUE

Windows 10 (64-bit), Aspire V5-132-2852 laptop with Intel Celeron 1019Y processor (1.0 GHz, 64-bit, 2 cores), 2 GBytes RAM.

Works with a 64-bit build with helper threads enabled, with no byte compiling of base and recommended packages, except that make check-all fails in the no-segfault test, for reasons that appear to have nothing to do with pqR or Windows 10, as described inf pqR issue #29. After applying the patch found there, it passes make check-all with 0 helper threads and with 1 helper thread. Verified to work with RStudio 0.99.484.

Configuration [pqR-2015-09-14, Rtools33 from pqR-project.org/Rtools33.exe]:

  • Use pqR-win-extras-64
  • Copy MkRules.dist64 to MkRules.local
  • Set R_NO_BASE_COMPILE to TRUE

Windows 8.1 (64-bit), Aspire V5-132-2852 laptop with Intel Celeron 1019Y processor (1.0 GHz, 64-bit, 2 cores), 2 GBytes RAM.

For reliable operation, it is necessary to uninstall the McAfee anti-virus software that comes pre-installed on this machine.

Works with a 64-bit build with helper threads enabled, with no byte compiling of base and recommended packages. Passes make check-all with 0 helper threads and with 1 helper thread. Verified to work with RStudio 0.99.484.

Configuration [pqR-2015-09-14, Rtools33 from pqR-project.org/Rtools33.exe]:

  • Use pqR-win-extras-64
  • Copy MkRules.dist64 to MkRules.local
  • Set R_NO_BASE_COMPILE to TRUE

Windows 8 (64-bit), Gateway SX2185 system with AMD E1-2500 processor (1.4 GHz, 64-bit, 2 cores), 4 GBytes RAM.

Works with a 64-bit build with helper threads enabled, and with no byte compiling of base and recommended packages. Tested with "make check-all" with 0 helper threads and with 1 helper thread. Works with RStudio 0.99.467.

Configuration [pqR-2015-09-14, Rtools215]:

  • Use pqR-win-extras-64
  • Copy MkRules.dist64 to MkRules.local
  • Set R_NO_BASE_COMPILE to TRUE

Works with a 32-bit build (using SSE2 instructions) with helper threads enabled, and with byte compiling of base and recommended packages. Tested with "make check-all" with 0 helper threads and with 1 helper thread. Works with RStudio 0.99.467.

Configuration [pqR-2015-09-14, Rtools215]:

  • Use pqR-win-extras-32
  • Copy MkRules.dist32-sse2 to MkRules.local
  • Do not set R_NO_BASE_COMPILE

Windows 7 Professional (32-bit), Dell Precision T1600 with an Intel Xeon E31225 processor (3.1 GHz, 64-bit (but used in 32-bit mode), 4 cores), 12 GBytes RAM (3.16 GBytes usable in 32-bit mode).

Works with a 32-bit build (using SSE2 instructions) with helper threads enabled, and without byte compiling of base and recommended packages. Tested with "make check-all" with 0 helper threads and with 3 helper threads. Works with RStudio 0.99.473.

Configuration [pqR-2015-09-14, Rtools215]:

  • Use pqR-win-extras-32
  • Copy MkRules.dist32-sse2 to MkRules.local
  • Set R_NO_BASE_COMPILE to TRUE

Windows XP Home Edition SP3 (32-bit), Dell Optiplex GX200 system with Pentium III processor (1 GHz, 32-bit, single core), 1 GByte RAM.

Works with a 32-bit build (not using SSE2 instructions, which this processor lacks), with helper threads disabled (as this processor has only one core) but with deferred evaluation for task merging still enabled, and without byte compiling of base and recommended packages. Passes "make check-all". Verified to work with RStudio 0.98.1103 (the last version compatible with Windows XP).

Configuration [pqR-2015-09-14, Rtools33 from pqR-project.org/Rtools33.exe]:

  • Use pqR-win-extras32
  • Copy MkRules.dist32 to MkRules.local
  • Comment out the line "#define R_HELPER_THREADS" in src/gnuwin32/fixed/h/config.h.
  • Set R_NO_BASE_COMPILE to TRUE