TIOBE index top 20: re-emergence of Fortran

'Another notable change is the re-emergence of Fortran in the index at 20th position, up from 34th spot a year ago. Fortran, which emerged from IBM in the 1950s, remains popular in scientific computing. Its highest ranking on Tiobe's index was 10th in 2002.

Fortran was the first commercial programming language ever, and is gaining popularity thanks to the massive need for (scientific) number crunching. Welcome back Fortran.

The top 20 programming languages this month were: C, Java, Python, C++, C#, Visual Basic, JavaScript, Assembly language, PHP, and SQL, Classic Visual Basic, Delphi/Object Pascal, Ruby, Go, Swift, R, Groovy, Perl, MATLAB, and Fortran.'

https://www.tiobe.com/tiobe-index/

Noticed Fortran almost beating MATLAB which is on 19th place ?

To surpass it we need

• perfect %pl (must be publishable quality by default)
• add surfaceplot
• add 3D plot (OpenGL)

I have surfaceplot and OpenGL implemented, they are not difficult to do

Also

• perfect run speed on Polyhedron tests
• add Wininet (sockets)
• add support of OpenMP and create examples
• add support of HDF5 + examples

Dan you intrigued me with 'surface plot'. Is this a routine that uses 'Z' data in addition to an X and Y to interpolate thicknesses at various positions?

Bill Yes. In simple form it is like here. Done with current %GR quarter century ago. Same can be done with %PL

in more complex like here. Bottom is 3D, top - surface plot. Essentially it is 2D plot in 3D. Both done in OpenGL. Difference in programming almost zero

I published sources demo many times here. With OpenGL the only what's left is to add numbering like in the 3D picture. I modified existing OpenGL example supplied with Silverfrost Examples without even learning OpenGL

Other examples. Surface plot at the bottom

Good to add a pie chart

You sent me these OpenGL examples to use for learning some of the ins/outs of OpenGL. Much appreciated.

I am not sure what to make of it when Assembler is in the top 20.

Assembler became popular lately because of extensive use of testing by everyone on the net. Beating competitors just by the factor of 1% immediately makes you the winner of universe and all others bite the dust.

Can the Polyhedron tests be disassembled to understand why gfortran and IVF sometimes beat by the factor of 2-5-10 and even 30?

Look at that. Fortran jumped on 12th place. Because it is Simplest. Fastest. Best. And on supercomputers C and Fortran are like a king and queen. Only utter @#$% think Fortran is dead.

https://www.tiobe.com/tiobe-index/

By switching from the code written in C to Fortran i got so large boost in performance that i used just the PC and did not use supercomputers for almost a year.

That was amazing year. With this and other tricks we got the code run speed up by 5 orders of magnitude. Imagine, the code which on supercomputer 1000-2000 cores ran for two weeks ending on PC in 20 minutes! When for first time i ran this code i though it quickly crashed. But then i saw full directory of data :roll: :roll: :roll: 😒hock: 😒hock: 😒hock:

All that got me to realize one pity thing. Unfortunately it is impossible to satisfy humans. I got one task which grabbed all that extra power and even 100x more so that I recently returned to supercomputers again 😦

Got one more order of magnitude compared to previous 16-core AMD 5950x...Look at this thread count. Interesting that i got 1.35 times boost in speed going from 6 memory channels to 12. So appears this indeed is important.

And i made it incredibly cheap for that kind of performances, guarantee you will not believe me...

TIOBE Index for August 2024 : Fortran steadily going to the top. From 20th to 10th place already. And ahead of MATLAB

/** And if Silverfrost

• made its compiler for Linux

• with MPI and OpenMP parallelization,

• with standard Makefiles and preprocessing language similar to other Fortran compilers

• with SDBG64 debugger capable to debug MPI parallel files (unbelievable, but there are no friendly graphics debuggers among all Linux compilers, they debug like Neanderthals planting PRINT into the code )

• added Clearwin for Linux and made more flashy scientific graphics examples including OpenGL

• made more freindly Plato for Linux

• optimized run speed beating at least Gfortran

• and advertised it at least ones in last 25 years

    ***it would be in the first 5***
  

On Youtube: Fortran in 100 seconds https://www.youtube.com/watch?v=NMWzgy8FsKs&t=17s

On Youtube: Amazing Return of Fortran https://www.youtube.com/watch?v=b2GZ540Fj4U

Run on GPU. Colleague rewrote the program to run on NVIDIA GPUs instead of regular CPU and reported that he got the speedup 173x from just single GPU !!! When Silverfrost adopts NVIDIA CUDA?

reported that he got the speedup 173x from just single GPU

Dan,

Is this dan-talk !!

This speedup needs some explaination ! For my calculations, I can get 10 to 15x with OpenMP (100 Gflop/s), but the bottleneck has shifted to memory bandwidth.

Your example must be a unique calculation, with minimal memory footprint to achieve 173x performance gain. Your other descriptions have referred to very large memory footprint, so a bit confusing ?

Can you give some description of the hardware and calculations. How many local cpu's are on the GPU you are using ? Potentially if the GPU supports intrinsic functions ? Do GPU support AVX instructions ?

More details would be interesting.

John, I do not know what is dan-talk - ?

I am waiting for confirmations from other people but the more i know about GPU the more i feel that such speedups are typical without any special trickery. But again, we always need double check

This year there will be three good news to build powerful workstations or PC for parallel simulations:

• NVIDIA RTX 5090, it is gaming GPU, it has some restrictions, but still works with CUDA too. Rumors are that it will have 32GB RAM. No NVlink on modern cards anymore but it's on 2-4x faster than previous gen GPUs PCIe 5.0. PCIe6 is already ready and PCIe7 will be perfect even without NVLink
• 128 core Intel Xeon 6980P and
• 128 and 192 core AMD 'Turin' processors.

Intel's monster processor already came last week, its spec is really impressive (do not know about price tag but i am sure it will be an arm and leg. And kidney). And 500 Watt consumption. AMD should be much cheaper. But also 500 W. Buy two (or dig out in California city dump 😃 ) and you'll get 1 kW. This is the trend. The RTX 5090 will consume even more, 600W.

Plan to buy good 2-2.5 kW power supply working on 240W power grid, the 120V one like in our Antarctica will already not fit their power envelop

Here is good picture which explains why this compiler must support GPUs. This diagram shows how works typical modern supercomputer, this was from the most powerful one called Frontier but in essence all is almost the same for other servers or even HPC workstations. On their baseboards they have one or two server CPU chips connected to 8 GPUs via fast links. The CPU essentially is just the input/output controller for the GPUs. There are 10,000 such baseboards in supercomputers like Frontier and typically few or even just one in high performance workstations. Even our PC with usual graphics card basically works same way. To save on cost of fast networking inside the baseboard, on workstations often is enough to use standard PCIe bus same way like with regular graphics cards. Little more complex motherboards can use NVIDIA's NVLink which has 300MB/s speed, or a bit more modern ones have special faster switches allowing more GPUs work in parallel.

You can see why supercomputers with GPUs are faster than CPU based ones: first, each GPU is faster than CPU and second, their amount is 8x larger than the number of CPUs.

So essentially all modern supercomputers are GPU supercomputers and this will be the trend for some time due to the fact that GPUs are also specifically good for AI. The reason for that is that GPUs besides 64bit arithmetic also have 32bit, 16bit and 8bit arithmetic and hence each time you use less bits you obviously get the speed doubled and AI often needs just the 8bit one and sometimes even 4bit is enough.

With CPUs though a decade or two ago what happened was unthinkable: Intel killed native support for single precision 32bit arithmetic and started to use just the double precision 64bit one and then truncating the final result to 32bit. I used so called mixed precision before when most of operations were in 32bit and only minor amount with 64bit and even larger precisions. Decently, 64bit is easier to use, no problems with the overflows or denormal numbers. But the price for that is factor of 2 speed decline.

What is good with the new processors is that by adding more cores they become as fast as all these incarnations of previous generations of GPUs which are still hell expensive. So hopefully all of them will drop in prices. Why we will need GPU if multi-core CPUs becoming as powerful as GPUs? Because besides monopoly in GPU NVIDIA also overjumped everyone with the fast interconnect. It is easy to add 2,3,...,8...16 GPUs to the existing system and improve with that the performance accordingly while you will not find a single manufacturer which makes more than dual-CPU motherboards and you will not find how to connect even two motherboards to make a parallel system. Hence with the CPUs you are screwed if you will try to get more performance

One thing is specifically good for this compiler. With it supporting CUDA and GPUs the speed of CPU will have no difference. All will depend on GPU and not on that CPU is old, slow or does not support multuthreading. Win-win for FTN95 !

There are various ways in which we (Silverfrost) can deploy our resources:

1. Bug fixing.
2. Implementing new features in the Fortran Standards.
3. Implementing on operating systems other than Windows.
4. Making use of new technology such as parallel processors.

We depend largely on user feedback in order to prioritise these tasks.

Almost all development work is hugely expensive in time and resources.

At some point I plan to investigate the potential for further work on parallel processing.

In the mean time users should note that parallel processing is not simply a task for the compiler. The programmer must create and use parallel algorithms. Such algorithms provide for parallel action whilst selectively locking memory that is used on more than one stream.

The compiler already allows for multiple threads and selective locking and this represents one kind of parallel processing.

Another approach is available with 64 bit FTN95 and is described in the document notes_on_parallel_processing.txt that is typically located in C:\Program Files (x86)\Silverfrost\FTN95\doc.

In any case, you can assume that a parallel processing approach will require a significant investment of time and resources from the programmer.

I think asking users of this compiler at this point to prioritize the trends of future development is like to fall into closed loop. With time the users who are left or attracted here became those who do not need parallel simulations or speed, including mostly programmers of older generation. Asking them about their priorities is like slowly going into decline and dead end. We discussed this many times already, that just the name of this compiler invites only retirees, it has to be changed as it supports already many never Standard's features

I can not propose any magical solution where to find funds and resources for that. I'd try for example to investigate how gFortran which was like a dumb toy for kindergarten in 1990 while Salford/Silverfrost was a super-pro-ultra with even FTN77 doing multithreading became so prolific. What is their business model? Here is the list of gFortran compilers in my Linux Mint third party Software Manager

All of these are different flavors and versions of gFortrans for different processors. Than means 100s of independent people worked on them. In 30 years FTN77/FTN95 departed too far from the mainstream in parallel simulations and run speed. All other Fortran compilers support MPI, CUDA and some OpenMP. Modern, older and even already dead Fortran compilers made them a defacto standard. Besides that they all merged in many other features so that for example this popular supercomputer PIC code

https://epochpic.github.io/documentation/basic_usage/compiling.html

can be compiled and run without any changes on these compilers

COMPILER=gfortran - GNU Fortran
COMPILER=intel - Intel ifort
COMPILER=pgi - Portland group compiler
COMPILER=g95 - G95 compiler
COMPILER=ibm - IBM AIX Fortran compiler for BlueGene
COMPILER=hector - Cray compiler as used on hector and archer

and with some minor changes on additional 6. No FTN95 listed here

May be FTN95 with time will merge with all other Fortran compilers using one common new parallelization method offered by Fortran 2018 Standard, I do not know. But that may take too long time.

Dan

If you are aready doing parallel processing but not with FTN95 perhaps you would send me the project so that I can get an idea of what you are asking for.

In the mean time FTN95 with ClearWin+ still provides viable and competitive solutions for all users (valetudinarian or not). Please see this video for further details...

https://www.youtube.com/watch?v=50BY9gyNY2o&t=16s