IFX in the Intel® oneAPI 2022.3 Release

The Intel® Fortran Compiler IFX What is New With the Intel® oneAPI 2022.3 Release

by Ron Green

In this blog I am excited to share with you the phenomenal progress and features in our latest IFX release. With the recent release of our Fortran compilers in the latest Intel® oneAPI Update (2022.3), our LLVM-based Intel® Fortran Compiler ( IFX ) has matured and is now very close to providing the features we have in the Intel^® Fortran Compiler Classic ( IFORT ). Therefore, it is a good opportunity to see where we are in our development of IFX in the latter half of calendar year 2022.  And to look forward to next year’s 2023 releases.

This latest update of the oneAPI toolkits and components was posted live on 27 September 2022.  The version of the oneAPI Toolkits was 2022.3.  Inside the Intel® oneAPI HPC Toolkit, and provided as a separate download from our Single Component Downloads and Runtime Versions page, and our repos for package managers we released:

• Intel® Fortran Compiler version 2022.2.0
• Intel® Fortran Compiler Classic version 2021.7.0

(Confused about versions of compiler versus versions of oneAPI? Read all about it in my forum post on version confusion.)

You can also download the oneAPI HPC Toolkit which contains our Fortran compilers.  If you are trying IFX for the first time and are an IFORT user, make sure to read our IFX Porting Guide  https://www.intel.com/content/www/us/en/developer/articles/guide/porting-guide-for-ifort-to-ifx.html

.

What is In IFX version 2022.2.0?

As always, we publish our latest changes in our online Release Notes.  This is an overview of new features with each release.  For IFX, we add to that a detailed table of both Fortran Standard features and OpenMP features, our Fortran Language and OpenMP* Features page.  It is a lot of information.  And without a doubt, this is the most ambitious and feature-packed release in Intel Fortran history!  Let me call out some of my favorite new things in IFX.

Fortran Language Support:

We have made HUGE progress implementing language features and IFX now has FULL support for Fortran 2003, Fortran 2008, and Fortran 2018, with one small exception: the REDUCE intrinsic.  The REDUCE intrinsic is under development now and will be supported in our next release. If you look at our IFX Fortran Language Features page you can see how close we are.  In this table, the BOLD “YES” items are those new in 2022.2 over the prior releases.  You can see why I said this is the most ambitious release in our history! Once the REDUCE intrinsic work is done, IFX will have language feature parity with IFORT. Getting IFX language feature parity with IFORT is our goal to complete by the end of 2023.  We are well on track to meet this goal.  And IFX is a HUGE improvement over IFX v2022.0 and v2022.1, which were missing a lot of F2008 and had little or no F2018 feature support.  But, of course, there is more:  IFX has a tremendous amount of OpenMP 4.5, 5.0, and 5.1 features for offload as well!  And we are continuing to add more OpenMP 5.x in the coming releases.  And we are anxious to start our work on OpenMP 6.0 as soon as that Standard is ratified.

But before we get too excited about IFX achieving IFORT language parity, let me discuss what to expect for Fortran Language Features in IFX.  Fortran language feature parity does not mean that “anything that compiles in IFORT will compile in IFX”.  While we have done our best to combine our ifort language parser ( Intel Fortran Frontend ) to the LLVM infrastructure, the translation is complex.  We do have 10s of thousands of tests from numerous suites we run nightly.  But as with any complex piece of software, you cannot anticipate all the possible usages in a language as rich as Fortran.  We expect you will find some codes or usages that compile and run fine with IFORT but may crash IFX or have an application crash at runtime.  Remember, we are finishing our initial development of IFX in 2022.  There is still work to be done finding and fixing things with IFX.

OpenMP offload to Intel GPUs

You have probably read that one of the major features of IFX is the ability to use the OpenMP 4.5/5.0/5.1 features allowing offload of computation to Intel GPUs.  With IFX 2022.2 we added more OpenMP features for offload.  But we’re not done yet.  We have a lot of new clauses and features coming in the 2023 release.  Stay tuned, I am writing a series of blogs about OpenMP offload with IFX.

Automatic Offload of DO CONCURRENT

When it comes to offload to Intel GPUs, IFX has a robust set of OpenMP 4.5/5.0/5.1 features for most application needs.  But looking at a higher level, OpenMP is an extension to the Fortran language.  It is an external set of directives and functions to Fortran along with a runtime library to support OpenMP.  These are not part of the Fortran Language Standard.

Within the Fortran community there has been discussion for years on how to support parallel programming paradigms directly in the language without resorting to external extensions and runtime libraries like OpenMP.  You can trace such efforts back to High Performance Fortran (HPF).  And you have probably heard and read about Coarray Fortran, which is implemented in both IFORT and IFX.  And then there was/is the F95 FORALL statement and construct, which was obsolescent in Fortran 2018 for a variety of reason.  And most recently DO CONCURRENT was introduced in Fortran 2008, enhanced in Fortran 2018, and is due for further enhancement in the upcoming Fortran 202x Standard. 

DO CONCURRENT is a way to assert that the following DO block MAY BE run in parallel – there are no interdependencies between loop iterations. Notice that I said, “may be” and not “must be”. DO CONCURRENT does not demand that the compiler perform the loop in parallel, rather you declare or assert to the compiler that the DO block can safely run in parallel and thus the compiler could, if it chooses to, run the loop in parallel. 

Both IFX and IFORT parallelize DO CONCURRENT for multicore CPUs if you use the
-qopenmp or /Qopenmp option.  In this latest release, we extended IFX for DO CONCURRENT to allow offload to supported Intel GPUs.  This capability, like OpenMP GPU offload support, is only provided in IFX and not in IFORT.  Our implementation for the “automatic offload” of DO CONCURRENT to supported Intel GPUs requires two more options in addition to -qopenmp or /Qopenmp for Linux and Windows.  Here is the description of the new option, from the Release Notes and the Intel Fortran Developer Guide and Reference:

Linux:

-fopenmp-target-do-concurrent

-fno-openmp-target-do-concurrent

macOS:

None

Windows:

/Qopenmp-target-do-concurrent

/Qopenmp-target-do-concurrent-

This is in addition to the two options you need to specify OpenMP and to specify a target architecture or SPIR-V for the offload.  The set of options needed is (linux):

-fopenmp-target-do-concurrent -qopenmp -fopenmp-targets=spir64

Yes, it is a lot of options.  I have to warn you to not get too attached the options shown above.  We have already had customer requests for a single and more simple compiler option rather than reusing several existing OpenMP options.

If you have already set up your PC or workstation for OpenMP offload with IFX, you can use the options above to begin testing out the DO CONCURRENT offload feature.  If not, in a future blog I will describe setting up your Windows or Linux system for offload.

DLLIMPORT/DLLEXPORT

We have a large active community of users of our compilers on Windows*.  And one of the key features of IFORT has been the ability to create and use Windows Dynamic-Link Libraries, or DLLs.  This shared library object can be used in mixed language programming, for modularizing and making updates to applications easier, and for adding extended functions in Fortran for CAD/CAM, spreadsheet programs, and other third-party tools and applications.  It is an essential and necessary capability to have for any Fortran compiler claiming to support Windows.  Until this latest IFX v2022.2 release, the ability to create and use DLLs only existed in IFORT.  Our Windows users were quite vocal about the need for this feature in IFX; We listened. We delivered!

 Fortran C Interoperability Features: Call me, or I’ll Call You!

Certainly, there is a wealth of C/C++ libraries and sources out there with very cool functionality.  And since OSes and their system functions are in C/C++ we need a way for our Fortran code to call and be called with C.  Fortran provides a standardized method for interoperating with C.  IFORT for years has provided an intrinsic module iso_c_binding for this purpose.  Again, this is an essential feature for any compiler claiming Fortran language support.  IFX has supported iso_c_binding in prior releases, but this release also adds all C interoperability features, including assumed rank arrays and C array descriptors (Fortran 2018).  

IFX Today and What is Ahead for 2023 and Beyond

With the release of version 2022.2 of the Intel^® Fortran Compiler (IFX) we are nearing our goal of reaching Fortran Language parity with IFORT and completing our implementation of the Fortran 2018 Standard.  We are on track to achieve this goal in the next release of IFX. 

After IFX version 2023.0 comes out, what’s next?  In calendar year 2023 we still have several loose ends to correct.  And we need more user testing which will undoubtably find use cases and combinations of language features that trigger errors in the compiler.  I think you will agree, there is no such thing as a ‘perfect and complete’ Fortran compiler. Compilers evolve and improve over time.  And the Fortran Language evolves over time, requiring changes to Fortran compilers.  For 2023, we welcome our users to compare IFX head-to-head with IFORT.  We believe you see the potential for this new and modern Fortran compiler. So, while we are very proud of our progress to date, we know that we’re just getting started on this shared journey with IFX.

Author! Author!

Keep up with all the latest from the Intel Fortran team by following me on Twitter @iCompilersRon

Ron Green #IAmIntel

Ron Green is a member of the Intel Fortran development team and moderator of the Intel Fortran Community Forum.  He has extensive experience as a Fortran developer and consultant in HPC for the past 30+ years and has been with Intel’s compiler team for 15+ years.  His technical interest area is in parallel application development with a focus on Fortran programming.