Fortran 90 Compiler Mac
Fortran 90 Compiler Mac

File names ending in.f90 and.f95 are assumed to be free source form - suitable for Fortran 90/95 compilation. File names ending in.f and.for are assumed to be assumed fixed form source - compatible with old Fortran 77 compilation. Compiling a program The role of g95 Fortran compiler is to compile your Fortran source code into an. JDoodle is a free Online Compiler, Editor, IDE for Java, C, C, PHP, Perl, Python, Ruby and many more. You can run your programs on the fly online and you can save and share them with others. Quick and Easy way to compile and run programs online.

First published: 2020/11/02

At WWDC 2020 earlier this year, Apple announced a transition from Intel toARM-based processors in their laptops. This blog is about the prospects ofwhen R will work on that platform, based on experimentation on a developermachine running A12Z, one of the “Apple silicon” processors.

Fortran 90 Compiler Mac

The new platform will includeRosetta 2,a dynamic translation frameworkwhich runs binaries built for 64-bit Intel Macs using just-in-time, dynamictranslation of binary code. The good news is that R seems to be working finewith the dynamic translation, so R users don’t need to worry even if they usecurrent releases. However, the interesting question is whether R will also worknatively. Native execution is expected to be faster, and the transitionprobably has to be done eventually, anyway.

The executive summary is: while there is currently no released Fortrancompiler for the platform, a development version of GNU Fortran alreadyseems to be working fine. There are some surprising results with NaNpayload propagation leading to unexpected results when computing withnumeric NAs, but these can be overcome by changing the mode of thefloating-point unit, which has already been done in R-devel. More detailsfollow in this post.

R needs a Fortran 90 compiler

R needs at least a Fortran 90 compiler to build. Most of the Fortran codein R and base and recommended packages is still in Fortran 77, so it can betranslated by f2c to C and compiled by a C compiler. However, some codealready uses Fortran 90 features and back-porting that would require anon-trivial effort.

In addition, R ships with a slightly modified version of reference LAPACKand BLAS which need a Fortran 90 compiler to build. It is highly preferableto have reference LAPACK/BLAS available also on the new platform, even thoughApple provides an optimized version of BLAS and LAPACK as part of the Accelerateframework in macOS. Download dua qunoot.

GCC’s GFortran supports 64-bit ARMs: an earlier blog postfrom Maywas about building and testing R on Linux running on 64-bit ARM (Aarch64)inside QEMU emulator. However, the Apple silicon platform uses a differentapplication binary interface (ABI) which GFortran does not support, yet.

Currently, there seems to be no other Fortran 90 compiler, neither free norcommercial. Specifically, LLVM’s Fortran compiler (now called Flang again)is not yet finished.

Building development version of GCC/GFortran

While GFortran does not support Apple silicon yet (neither any release northe GCC trunk), there is a private development branch of GCC includingGFortran by Iain Sandoe, which we experimented with.

Building GCC from source as usual requires first building also GMP, MPFR andMPC for the platform. GMP (version 6.2.0) required back-porting a patchfrom the trunk (configure script for Apple silicon, assembler macros).Re-generating the configure script and make files natively also requiredbuilding libtool. The configure script for GMP had to be explicitly runwith --build=aarch64-apple-darwin20.0.0, even when building natively. Theconfigure script for GCC was run with --with-sysroot, specifying adirectory to MacOSX.sdk installed via xcode-select -p.

Testing R

R requires a number of dependencies, which can be built natively followingR Installation and Administration,using the Apple/LLVM toolchain provided by Apple (Fortran compiler is not needed).We have also compiled a native build of Subversion, even though in principleone could build R from a tarball.

R and recommended packages were built using Apple/LLVM clang to compile C(with CFLAGS=-Wno-error=implicit-function-declaration) and Objective C andusing the development version of GFortran to compile Fortran code.

A number of tests for R and recommended packages have failed for aplatform-specific reason, but it turned out that all for the same reason:surprising propagation of NaN payload, where e.g. NA * 1 is NaN.

NA/NaN payload propagation

R’s NA for floating point numbers is represented using NaN with a specialpayload value. NaNs that originate from computations not involving NA havea different (e.g. zero) payload, so can be distinguished from NA. NaNs areoften passed to computations inside R without explicit checks and the samehappens inside package code and external numerical code, which have no ideaabout R’s NA concept nor representation.

The IEEE 754 standard for floating point arithmetics does not mandate howNaN payloads should be propagated through computations. The result ofcomputations involving NAs and/or other NaNs depends on the CPU/floatingpoint unit, on compiler optimizations (compiler may re-order computations),and on the algorithm (e.g. it is tempting to ignore input values not neededto compute the result under the assumption they are finite, but withoutactually checking they are finite).

More information can be found in R’s online help (?NA, ?NaN), includingdisclaimers that the difference between NA and NaN should not be relied on(citing in the wording of recent R-devel):

Computations involving ‘NaN’ will return ‘NaN’ or perhaps ‘NA’: which ofthose two is not guaranteed and may depend on the R platform (sincecompilers may re-order computations).

Numerical computations using ‘NA’ will normally result in ‘NA’: a possibleexception is where ‘NaN’ is also involved, in which case either might result(which may depend on the R platform). However, this is not guaranteed andfuture CPUs and/or compilers may behave differently.

Intel FPUs worked relatively well with respect to R NAs: binary operations withNAs resulted in NAs, even when NaNs were involved (based on experimentation).However, currently R on Intel machines is typically built to use SSEinstructions for computations, which do not work that well for R NAs: binaryoperations with NAs only result in NA when the other argument is not a NaN, orwhen the NA is the first, so NaN + NA is NaN but NA + NaN is NA. As64-bit Intel with SSE has most likely been the prevailing setup for R recently,tests have already been updated to accept this behavior.

However, it turns out that on A12Z, R’s NA becomes a normal NaN after anybinary operation (the payload is lost), so even NA * 1 is NaN. This iswithin what has been warned against in the R documentation cited above, butstill a number of tests for R and recommended packages capture the(documented as unreliable) behavior expecting that operations like thiswill return NA. We have not investigated how many of other CRAN/BIOCpackages do.

The ARM architecture floating point units (VFP, NEON) support RunFast mode,which includes flush-to-zero and default NaN. The latter means that payloadof NaN operands is not propagated, all result NaNs have the default payload,so in R, even NA * 1 is NaN. Luckily, RunFast mode can be disabled, andwhen it is, the NaN payload propagation is friendlier to R NAs than withIntel SSE (NaN + NA is NA). We have therefore updated R to disableRunFast mode on ARM on startup, which resolved all the issues observed.

We have not run into this issue earlier as RunFast has been disabled bydefault on other platforms, including Raspberry Pi (tested on an old model 2with 32-bit ARM, BCM2835) and on QEMU emulating Aarch64 (64-bit ARM,Cortex-A72).

Summary

It turns out there is hope that R will work on Apple silicon. A usable Fortran90 compiler for Apple silicon will hopefully be available relatively soon, sincethe development versi