nvptx | How to : Run Rust code on your NVIDIA GPU | GPU library

The issue was mentioned by @AnttiHaapala: By the instructions ask you to set the prefix to /usr/local/i386elfgcc - maybe you've accidentally dropped this out from the binutils config and installed binutils in /usr/bin instead

The solution was uninstalling the binutils and install it again

• sudo apt-get remove binutils

  sudo apt-get remove --auto-remove binutils

  sudo apt install build-essential

Now the binutils version is 2.34, earlier it was 2.24

Returning the address of a local variable and trying to access it after its lifetime is over is undefined behavior, rationalizing what happens under the hood is a fool's errand because there are no standard rules to be followed (appart, of course, from the aforementioned and linked UB rules), it's quite common different compiler versions changing the way a situation like this is dealt with.

The order of libraries on the command line is important - this means that a library containing the definition of a function should appear after any source files or object files which use it. Please see here for more information. Also the comment of @SeanFrancisNBallais is exactly about that.

In your case you need to place the sfml-system-s library after all other SFML libraries, something like below:

I followed advice VladimirF gave me in the comments, and everthing worked out. This site provided all the necessary guidelines. Only a few minor problems had to be dealth with. Before I could create ./configure file, I was prompted to install some missing autotools, which was simply done using apt. Once ./configure file was ready, I passed in the mostly same configuration that apt originally installed MPICH with (see the long list original question), with 'FC = gfortran-10' 'CC = gcc-10' 'CXX = g++-10' replacing 'FC = gfortran' 'CC = gcc' 'CXX = g++'. Several more prompts had to be dealt with (mostly adding something to configuration or installing missing packages, easily done with Synaptic package manager). After doing all the steps, F08 bindings were succesfully built and work properly. Here is my current MPICH configuration :

MPICH requires the Fortran compiler to support the array descriptor of Technical Specification 29113, and this is only supported in recent versions of gfortran (GNU 10 is ok). Intel compilers have been fine for a while fwiw.

Note that Open MPI is not that picky w.r.t. TS 29113 and does not need support for the array descriptor. GNU 7.5 can be used to generate the mpi_f08 module.

Bottom line, you have two options w.r.t. the mpi_f08 Fortran module:

• use a Fortran support that meets MPICH expectation w.r.t. TS 29113 (e.g. GNU 10, or Intel compilers for example)
• move to Open MPI

Very brief overview for GCC:

GCC's .md machine definition files tell it what instructions are available and what they do, using similar constraint syntax to GNU C inline asm. (GCC doesn't know about machine code, only asm text, that's why it can only output a .s for as to assemble separately.) There are also some C functions that know about generic rules for that architecture, and I guess stuff like register names.

The GCC-internals manual has a section 6.3.9 Anatomy of a Target Back End that documents where the relevant files are in the GCC source tree.

I spoke to the GCC developers and it seems to be a bug. They seem to have it resolved for GCC 11, but the fix was not backported. See https://gcc.gnu.org/g:a8b522311beef5e02de15427e924752ea02def2a for more information.

The problem is this:

"Can ...?" : No, it can't; otherwise it would be in the manual :-)

"Could ... ?": probably not; compilation is mostly walking over data-structures, not performing parallel arithmetic operations, and is not obviously parallel other than at a very high level. One pass requires the state which was created by a previous pass, so there is a strict ordering and you can't easily execute more than one pass in parallel. (Each pass is updating a single representation of the code).

The current approach is to use make -j8 or similar to compile multiple files simultaneously, but even there you are unlikely to have anywhere near enough parallelism to keep a GPU busy.