-
Notifications
You must be signed in to change notification settings - Fork 2.5k
/
FindMPI.cmake
1911 lines (1686 loc) · 91.8 KB
/
FindMPI.cmake
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
#[=======================================================================[.rst:
FindMPI
-------
Find a Message Passing Interface (MPI) implementation.
The Message Passing Interface (MPI) is a library used to write
high-performance distributed-memory parallel applications, and is
typically deployed on a cluster. MPI is a standard interface (defined
by the MPI forum) for which many implementations are available.
.. versionadded:: 3.10
Major overhaul of the module: many new variables, per-language components,
support for a wider variety of runtimes.
Variables for using MPI
^^^^^^^^^^^^^^^^^^^^^^^
The module exposes the components ``C``, ``CXX``, ``MPICXX`` and ``Fortran``.
Each of these controls the various MPI languages to search for.
The difference between ``CXX`` and ``MPICXX`` is that ``CXX`` refers to the
MPI C API being usable from C++, whereas ``MPICXX`` refers to the MPI-2 C++ API
that was removed again in MPI-3.
Depending on the enabled components the following variables will be set:
``MPI_FOUND``
Variable indicating that MPI settings for all requested languages have been found.
If no components are specified, this is true if MPI settings for all enabled languages
were detected. Note that the ``MPICXX`` component does not affect this variable.
``MPI_VERSION``
Minimal version of MPI detected among the requested languages, or all enabled languages
if no components were specified.
This module will set the following variables per language in your
project, where ``<lang>`` is one of C, CXX, or Fortran:
``MPI_<lang>_FOUND``
Variable indicating the MPI settings for ``<lang>`` were found and that
simple MPI test programs compile with the provided settings.
``MPI_<lang>_COMPILER``
MPI compiler for ``<lang>`` if such a program exists.
``MPI_<lang>_COMPILE_OPTIONS``
Compilation options for MPI programs in ``<lang>``, given as a :ref:`;-list <CMake Language Lists>`.
``MPI_<lang>_COMPILE_DEFINITIONS``
Compilation definitions for MPI programs in ``<lang>``, given as a :ref:`;-list <CMake Language Lists>`.
``MPI_<lang>_INCLUDE_DIRS``
Include path(s) for MPI header.
``MPI_<lang>_LINK_FLAGS``
Linker flags for MPI programs.
``MPI_<lang>_LIBRARIES``
All libraries to link MPI programs against.
.. versionadded:: 3.9
Additionally, the following :prop_tgt:`IMPORTED` targets are defined:
``MPI::MPI_<lang>``
Target for using MPI from ``<lang>``.
The following variables indicating which bindings are present will be defined:
``MPI_MPICXX_FOUND``
Variable indicating whether the MPI-2 C++ bindings are present (introduced in MPI-2, removed with MPI-3).
``MPI_Fortran_HAVE_F77_HEADER``
True if the Fortran 77 header ``mpif.h`` is available.
``MPI_Fortran_HAVE_F90_MODULE``
True if the Fortran 90 module ``mpi`` can be used for accessing MPI (MPI-2 and higher only).
``MPI_Fortran_HAVE_F08_MODULE``
True if the Fortran 2008 ``mpi_f08`` is available to MPI programs (MPI-3 and higher only).
If possible, the MPI version will be determined by this module. The facilities to detect the MPI version
were introduced with MPI-1.2, and therefore cannot be found for older MPI versions.
``MPI_<lang>_VERSION_MAJOR``
Major version of MPI implemented for ``<lang>`` by the MPI distribution.
``MPI_<lang>_VERSION_MINOR``
Minor version of MPI implemented for ``<lang>`` by the MPI distribution.
``MPI_<lang>_VERSION``
MPI version implemented for ``<lang>`` by the MPI distribution.
Note that there's no variable for the C bindings being accessible through ``mpi.h``, since the MPI standards
always have required this binding to work in both C and C++ code.
For running MPI programs, the module sets the following variables
``MPIEXEC_EXECUTABLE``
Executable for running MPI programs, if such exists.
``MPIEXEC_NUMPROC_FLAG``
Flag to pass to ``mpiexec`` before giving it the number of processors to run on.
``MPIEXEC_MAX_NUMPROCS``
Number of MPI processors to utilize. Defaults to the number
of processors detected on the host system.
``MPIEXEC_PREFLAGS``
Flags to pass to ``mpiexec`` directly before the executable to run.
``MPIEXEC_POSTFLAGS``
Flags to pass to ``mpiexec`` after other flags.
Variables for locating MPI
^^^^^^^^^^^^^^^^^^^^^^^^^^
This module performs a four step search for an MPI implementation:
1. Search for ``MPIEXEC_EXECUTABLE`` and, if found, use its base directory.
2. Check if the compiler has MPI support built-in. This is the case if the user passed a
compiler wrapper as ``CMAKE_<LANG>_COMPILER`` or if they use Cray system compiler wrappers.
3. Attempt to find an MPI compiler wrapper and determine the compiler information from it.
4. Try to find an MPI implementation that does not ship such a wrapper by guessing settings.
Currently, only Microsoft MPI and MPICH2 on Windows are supported.
For controlling the ``MPIEXEC_EXECUTABLE`` step, the following variables may be set:
``MPIEXEC_EXECUTABLE``
Manually specify the location of ``mpiexec``.
``MPI_HOME``
Specify the base directory of the MPI installation.
``ENV{MPI_HOME}``
Environment variable to specify the base directory of the MPI installation.
``ENV{I_MPI_ROOT}``
Environment variable to specify the base directory of the MPI installation.
For controlling the compiler wrapper step, the following variables may be set:
``MPI_<lang>_COMPILER``
Search for the specified compiler wrapper and use it.
``MPI_<lang>_COMPILER_FLAGS``
Flags to pass to the MPI compiler wrapper during interrogation. Some compiler wrappers
support linking debug or tracing libraries if a specific flag is passed and this variable
may be used to obtain them.
``MPI_COMPILER_FLAGS``
Used to initialize ``MPI_<lang>_COMPILER_FLAGS`` if no language specific flag has been given.
Empty by default.
``MPI_EXECUTABLE_SUFFIX``
A suffix which is appended to all names that are being looked for. For instance you may set this
to ``.mpich`` or ``.openmpi`` to prefer the one or the other on Debian and its derivatives.
In order to control the guessing step, the following variable may be set:
``MPI_GUESS_LIBRARY_NAME``
Valid values are ``MSMPI`` and ``MPICH2``. If set, only the given library will be searched for.
By default, ``MSMPI`` will be preferred over ``MPICH2`` if both are available.
This also sets ``MPI_SKIP_COMPILER_WRAPPER`` to ``true``, which may be overridden.
Each of the search steps may be skipped with the following control variables:
``MPI_ASSUME_NO_BUILTIN_MPI``
If true, the module assumes that the compiler itself does not provide an MPI implementation and
skips to step 2.
``MPI_SKIP_COMPILER_WRAPPER``
If true, no compiler wrapper will be searched for.
``MPI_SKIP_GUESSING``
If true, the guessing step will be skipped.
Additionally, the following control variable is available to change search behavior:
``MPI_CXX_SKIP_MPICXX``
Add some definitions that will disable the MPI-2 C++ bindings.
Currently supported are MPICH, Open MPI, Platform MPI and derivatives thereof,
for example MVAPICH or Intel MPI.
If the find procedure fails for a variable ``MPI_<lang>_WORKS``, then the settings detected by or passed to
the module did not work and even a simple MPI test program failed to compile.
If all of these parameters were not sufficient to find the right MPI implementation, a user may
disable the entire autodetection process by specifying both a list of libraries in ``MPI_<lang>_LIBRARIES``
and a list of include directories in ``MPI_<lang>_ADDITIONAL_INCLUDE_DIRS``.
Any other variable may be set in addition to these two. The module will then validate the MPI settings and store the
settings in the cache.
Cache variables for MPI
^^^^^^^^^^^^^^^^^^^^^^^
The variable ``MPI_<lang>_INCLUDE_DIRS`` will be assembled from the following variables.
For C and CXX:
``MPI_<lang>_HEADER_DIR``
Location of the ``mpi.h`` header on disk.
For Fortran:
``MPI_Fortran_F77_HEADER_DIR``
Location of the Fortran 77 header ``mpif.h``, if it exists.
``MPI_Fortran_MODULE_DIR``
Location of the ``mpi`` or ``mpi_f08`` modules, if available.
For all languages the following variables are additionally considered:
``MPI_<lang>_ADDITIONAL_INCLUDE_DIRS``
A :ref:`;-list <CMake Language Lists>` of paths needed in addition to the normal include directories.
``MPI_<include_name>_INCLUDE_DIR``
Path variables for include folders referred to by ``<include_name>``.
``MPI_<lang>_ADDITIONAL_INCLUDE_VARS``
A :ref:`;-list <CMake Language Lists>` of ``<include_name>`` that will be added to the include locations of ``<lang>``.
The variable ``MPI_<lang>_LIBRARIES`` will be assembled from the following variables:
``MPI_<lib_name>_LIBRARY``
The location of a library called ``<lib_name>`` for use with MPI.
``MPI_<lang>_LIB_NAMES``
A :ref:`;-list <CMake Language Lists>` of ``<lib_name>`` that will be added to the include locations of ``<lang>``.
Usage of mpiexec
^^^^^^^^^^^^^^^^
When using ``MPIEXEC_EXECUTABLE`` to execute MPI applications, you should typically
use all of the ``MPIEXEC_EXECUTABLE`` flags as follows:
::
${MPIEXEC_EXECUTABLE} ${MPIEXEC_NUMPROC_FLAG} ${MPIEXEC_MAX_NUMPROCS}
${MPIEXEC_PREFLAGS} EXECUTABLE ${MPIEXEC_POSTFLAGS} ARGS
where ``EXECUTABLE`` is the MPI program, and ``ARGS`` are the arguments to
pass to the MPI program.
Advanced variables for using MPI
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The module can perform some advanced feature detections upon explicit request.
**Important notice:** The following checks cannot be performed without *executing* an MPI test program.
Consider the special considerations for the behavior of :command:`try_run` during cross compilation.
Moreover, running an MPI program can cause additional issues, like a firewall notification on some systems.
You should only enable these detections if you absolutely need the information.
If the following variables are set to true, the respective search will be performed:
``MPI_DETERMINE_Fortran_CAPABILITIES``
Determine for all available Fortran bindings what the values of ``MPI_SUBARRAYS_SUPPORTED`` and
``MPI_ASYNC_PROTECTS_NONBLOCKING`` are and make their values available as ``MPI_Fortran_<binding>_SUBARRAYS``
and ``MPI_Fortran_<binding>_ASYNCPROT``, where ``<binding>`` is one of ``F77_HEADER``, ``F90_MODULE`` and
``F08_MODULE``.
``MPI_DETERMINE_LIBRARY_VERSION``
For each language, find the output of ``MPI_Get_library_version`` and make it available as ``MPI_<lang>_LIBRARY_VERSION_STRING``.
This information is usually tied to the runtime component of an MPI implementation and might differ depending on ``<lang>``.
Note that the return value is entirely implementation defined. This information might be used to identify
the MPI vendor and for example pick the correct one of multiple third party binaries that matches the MPI vendor.
Backward Compatibility
^^^^^^^^^^^^^^^^^^^^^^
.. deprecated:: 3.10
For backward compatibility with older versions of FindMPI, these
variables are set:
::
MPI_COMPILER MPI_LIBRARY MPI_EXTRA_LIBRARY
MPI_COMPILE_FLAGS MPI_INCLUDE_PATH MPI_LINK_FLAGS
MPI_LIBRARIES
In new projects, please use the ``MPI_<lang>_XXX`` equivalents.
Additionally, the following variables are deprecated:
``MPI_<lang>_COMPILE_FLAGS``
Use ``MPI_<lang>_COMPILE_OPTIONS`` and ``MPI_<lang>_COMPILE_DEFINITIONS`` instead.
``MPI_<lang>_INCLUDE_PATH``
For consumption use ``MPI_<lang>_INCLUDE_DIRS`` and for specifying folders use ``MPI_<lang>_ADDITIONAL_INCLUDE_DIRS`` instead.
``MPIEXEC``
Use ``MPIEXEC_EXECUTABLE`` instead.
#]=======================================================================]
cmake_policy(PUSH)
cmake_policy(SET CMP0057 NEW) # if IN_LIST
cmake_policy(SET CMP0159 NEW) # file(STRINGS) with REGEX updates CMAKE_MATCH_<n>
include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
find_package(PkgConfig QUIET)
# Generic compiler names
set(_MPI_C_GENERIC_COMPILER_NAMES mpicc mpcc mpicc_r mpcc_r)
set(_MPI_CXX_GENERIC_COMPILER_NAMES mpicxx mpiCC mpcxx mpCC mpic++ mpc++
mpicxx_r mpiCC_r mpcxx_r mpCC_r mpic++_r mpc++_r)
set(_MPI_Fortran_GENERIC_COMPILER_NAMES mpif95 mpif95_r mpf95 mpf95_r
mpif90 mpif90_r mpf90 mpf90_r
mpif77 mpif77_r mpf77 mpf77_r
mpifc)
#Fujitsu cross/own compiler names
set(_MPI_Fujitsu_C_COMPILER_NAMES mpifccpx mpifcc)
set(_MPI_Fujitsu_CXX_COMPILER_NAMES mpiFCCpx mpiFCC)
set(_MPI_Fujitsu_Fortran_COMPILER_NAMES mpifrtpx mpifrt)
set(_MPI_FujitsuClang_C_COMPILER_NAMES mpifccpx mpifcc)
set(_MPI_FujitsuClang_CXX_COMPILER_NAMES mpiFCCpx mpiFCC)
set(_MPI_FujitsuClang_Fortran_COMPILER_NAMES mpifrtpx mpifrt)
# GNU compiler names
set(_MPI_GNU_C_COMPILER_NAMES mpigcc mpgcc mpigcc_r mpgcc_r)
set(_MPI_GNU_CXX_COMPILER_NAMES mpig++ mpg++ mpig++_r mpg++_r mpigxx)
set(_MPI_GNU_Fortran_COMPILER_NAMES mpigfortran mpgfortran mpigfortran_r mpgfortran_r
mpig77 mpig77_r mpg77 mpg77_r)
# Intel MPI compiler names on Windows
if(WIN32)
list(APPEND _MPI_C_GENERIC_COMPILER_NAMES mpicc.bat)
list(APPEND _MPI_CXX_GENERIC_COMPILER_NAMES mpicxx.bat)
list(APPEND _MPI_Fortran_GENERIC_COMPILER_NAMES mpifc.bat)
# Intel MPI compiler names
set(_MPI_Intel_C_COMPILER_NAMES mpiicc.bat)
set(_MPI_Intel_CXX_COMPILER_NAMES mpiicpc.bat)
set(_MPI_Intel_Fortran_COMPILER_NAMES mpiifort.bat mpif77.bat mpif90.bat)
# Intel MPI compiler names
set(_MPI_IntelLLVM_C_COMPILER_NAMES mpiicx.bat mpiicc.bat)
set(_MPI_IntelLLVM_CXX_COMPILER_NAMES mpiicx.bat mpiicpc.bat) # Not GNU-like mpiicpx.bat
set(_MPI_IntelLLVM_Fortran_COMPILER_NAMES mpiifx.bat mpiifort.bat mpif77.bat mpif90.bat)
# Intel MPI compiler names for MSMPI
set(_MPI_MSVC_C_COMPILER_NAMES mpicl.bat)
set(_MPI_MSVC_CXX_COMPILER_NAMES mpicl.bat)
else()
# Intel compiler names
set(_MPI_Intel_C_COMPILER_NAMES mpiicc)
set(_MPI_Intel_CXX_COMPILER_NAMES mpiicpc mpiicxx mpiic++)
set(_MPI_Intel_Fortran_COMPILER_NAMES mpiifort mpiif95 mpiif90 mpiif77)
# Intel compiler names
set(_MPI_IntelLLVM_C_COMPILER_NAMES mpiicx mpiicc)
set(_MPI_IntelLLVM_CXX_COMPILER_NAMES mpiicpx mpiicpc mpiicxx mpiic++)
set(_MPI_IntelLLVM_Fortran_COMPILER_NAMES mpiifx mpiifort mpiif95 mpiif90 mpiif77)
endif()
# PGI compiler names
set(_MPI_PGI_C_COMPILER_NAMES mpipgicc mpipgcc mppgcc)
set(_MPI_PGI_CXX_COMPILER_NAMES mpipgic++ mpipgCC mppgCC)
set(_MPI_PGI_Fortran_COMPILER_NAMES mpipgifort mpipgf95 mpipgf90 mppgf95 mppgf90 mpipgf77 mppgf77)
# XLC MPI Compiler names
set(_MPI_XL_C_COMPILER_NAMES mpxlc mpxlc_r mpixlc mpixlc_r)
set(_MPI_XL_CXX_COMPILER_NAMES mpixlcxx mpixlC mpixlc++ mpxlcxx mpxlc++ mpixlc++ mpxlCC
mpixlcxx_r mpixlC_r mpixlc++_r mpxlcxx_r mpxlc++_r mpixlc++_r mpxlCC_r)
set(_MPI_XL_Fortran_COMPILER_NAMES mpixlf95 mpixlf95_r mpxlf95 mpxlf95_r
mpixlf90 mpixlf90_r mpxlf90 mpxlf90_r
mpixlf77 mpixlf77_r mpxlf77 mpxlf77_r
mpixlf mpixlf_r mpxlf mpxlf_r)
# Cray Compiler names
set(_MPI_Cray_C_COMPILER_NAMES cc)
set(_MPI_Cray_CXX_COMPILER_NAMES CC)
set(_MPI_Cray_Fortran_COMPILER_NAMES ftn)
# Prepend vendor-specific compiler wrappers to the list. If we don't know the compiler,
# attempt all of them.
# By attempting vendor-specific compiler names first, we should avoid situations where the compiler wrapper
# stems from a proprietary MPI and won't know which compiler it's being used for. For instance, Intel MPI
# controls its settings via the I_MPI_CC environment variables if the generic name is being used.
# If we know which compiler we're working with, we can use the most specialized wrapper there is in order to
# pick up the right settings for it.
foreach (LANG IN ITEMS C CXX Fortran)
set(_MPI_${LANG}_COMPILER_NAMES "")
foreach (id IN ITEMS Fujitsu FujitsuClang GNU Intel IntelLLVM MSVC PGI XL)
if (NOT CMAKE_${LANG}_COMPILER_ID OR CMAKE_${LANG}_COMPILER_ID STREQUAL id)
foreach(_COMPILER_NAME IN LISTS _MPI_${id}_${LANG}_COMPILER_NAMES)
list(APPEND _MPI_${LANG}_COMPILER_NAMES ${_COMPILER_NAME}${MPI_EXECUTABLE_SUFFIX})
endforeach()
endif()
unset(_MPI_${id}_${LANG}_COMPILER_NAMES)
endforeach()
foreach(_COMPILER_NAME IN LISTS _MPI_${LANG}_GENERIC_COMPILER_NAMES)
list(APPEND _MPI_${LANG}_COMPILER_NAMES ${_COMPILER_NAME}${MPI_EXECUTABLE_SUFFIX})
endforeach()
unset(_MPI_${LANG}_GENERIC_COMPILER_NAMES)
endforeach()
# Names to try for mpiexec
# Only mpiexec commands are guaranteed to behave as described in the standard,
# mpirun commands are not covered by the standard in any way whatsoever.
# lamexec is the executable for LAM/MPI, srun is for SLURM or Open MPI with SLURM support.
# srun -n X <executable> is however a valid command, so it behaves 'like' mpiexec.
set(_MPIEXEC_NAMES_BASE mpiexec mpiexec.hydra mpiexec.mpd mpirun lamexec srun)
unset(_MPIEXEC_NAMES)
foreach(_MPIEXEC_NAME IN LISTS _MPIEXEC_NAMES_BASE)
list(APPEND _MPIEXEC_NAMES "${_MPIEXEC_NAME}${MPI_EXECUTABLE_SUFFIX}")
endforeach()
unset(_MPIEXEC_NAMES_BASE)
function (_MPI_check_compiler LANG QUERY_FLAG OUTPUT_VARIABLE RESULT_VARIABLE)
if(DEFINED MPI_${LANG}_COMPILER_FLAGS)
separate_arguments(_MPI_COMPILER_WRAPPER_OPTIONS NATIVE_COMMAND "${MPI_${LANG}_COMPILER_FLAGS}")
else()
separate_arguments(_MPI_COMPILER_WRAPPER_OPTIONS NATIVE_COMMAND "${MPI_COMPILER_FLAGS}")
endif()
execute_process(
COMMAND ${MPI_${LANG}_COMPILER} ${_MPI_COMPILER_WRAPPER_OPTIONS} ${QUERY_FLAG}
OUTPUT_VARIABLE WRAPPER_OUTPUT OUTPUT_STRIP_TRAILING_WHITESPACE
ERROR_VARIABLE WRAPPER_OUTPUT ERROR_STRIP_TRAILING_WHITESPACE
RESULT_VARIABLE WRAPPER_RETURN)
# Some compiler wrappers will yield spurious zero return values, for example
# Intel MPI tolerates unknown arguments and if the MPI wrappers loads a shared
# library that has invalid or missing version information there would be warning
# messages emitted by ld.so in the compiler output. In either case, we'll treat
# the output as invalid.
if(WRAPPER_OUTPUT MATCHES "undefined reference|unrecognized|need to set|no version information available|command not found")
set(WRAPPER_RETURN 255)
endif()
# Ensure that no error output might be passed upwards.
if(NOT WRAPPER_RETURN EQUAL "0")
unset(WRAPPER_OUTPUT)
else()
# Strip leading whitespace
string(REGEX REPLACE "^ +" "" WRAPPER_OUTPUT "${WRAPPER_OUTPUT}")
endif()
set(${OUTPUT_VARIABLE} "${WRAPPER_OUTPUT}" PARENT_SCOPE)
set(${RESULT_VARIABLE} "${WRAPPER_RETURN}" PARENT_SCOPE)
endfunction()
macro(_MPI_env_set_ifnot VAR VALUE)
if(NOT DEFINED ENV{${VAR}})
set(_MPI_${VAR}_WAS_SET FALSE)
set(ENV{${VAR}} ${${VALUE}})
else()
set(_MPI_${VAR}_WAS_SET TRUE)
endif()
endmacro()
macro(_MPI_env_unset_ifnot VAR)
if(NOT _MPI_${VAR}_WAS_SET)
unset(ENV{${VAR}})
endif()
endmacro()
function (_MPI_interrogate_compiler LANG)
unset(MPI_COMPILE_CMDLINE)
unset(MPI_LINK_CMDLINE)
unset(MPI_COMPILE_OPTIONS_WORK)
unset(MPI_COMPILE_DEFINITIONS_WORK)
unset(MPI_INCLUDE_DIRS_WORK)
unset(MPI_LINK_FLAGS_WORK)
unset(MPI_LIB_NAMES_WORK)
unset(MPI_LIB_FULLPATHS_WORK)
# Define the MPICH and Intel MPI compiler variables to the compilers set in CMake.
# It's possible to have a per-compiler configuration in these MPI implementations and
# a particular MPICH derivate might check compiler interoperability.
# Intel MPI in particular does this with I_MPI_CHECK_COMPILER.
file(TO_NATIVE_PATH "${CMAKE_${LANG}_COMPILER}" _MPI_UNDERLAYING_COMPILER)
# On Windows, the Intel MPI batch scripts can only work with filenames - Full paths will break them.
# Due to the lack of other MPICH-based wrappers for Visual C++, we may treat this as default.
if(MSVC)
get_filename_component(_MPI_UNDERLAYING_COMPILER "${_MPI_UNDERLAYING_COMPILER}" NAME)
endif()
if(LANG STREQUAL "C")
_MPI_env_set_ifnot(I_MPI_CC _MPI_UNDERLAYING_COMPILER)
_MPI_env_set_ifnot(MPICH_CC _MPI_UNDERLAYING_COMPILER)
elseif(LANG STREQUAL "CXX")
_MPI_env_set_ifnot(I_MPI_CXX _MPI_UNDERLAYING_COMPILER)
_MPI_env_set_ifnot(MPICH_CXX _MPI_UNDERLAYING_COMPILER)
elseif(LANG STREQUAL "Fortran")
_MPI_env_set_ifnot(I_MPI_FC _MPI_UNDERLAYING_COMPILER)
_MPI_env_set_ifnot(MPICH_FC _MPI_UNDERLAYING_COMPILER)
_MPI_env_set_ifnot(I_MPI_F77 _MPI_UNDERLAYING_COMPILER)
_MPI_env_set_ifnot(MPICH_F77 _MPI_UNDERLAYING_COMPILER)
_MPI_env_set_ifnot(I_MPI_F90 _MPI_UNDERLAYING_COMPILER)
_MPI_env_set_ifnot(MPICH_F90 _MPI_UNDERLAYING_COMPILER)
endif()
# Set these two variables for Intel MPI:
# - I_MPI_DEBUG_INFO_STRIP: It adds 'objcopy' lines to the compiler output. We support stripping them
# (see below), but if we can avoid them in the first place, we should.
# - I_MPI_FORT_BIND: By default Intel MPI makes the C/C++ compiler wrappers link Fortran bindings.
# This is so that mixed-language code doesn't require additional libraries when linking with mpicc.
# For our purposes, this makes little sense, since correct MPI usage from CMake already circumvenes this.
set(_MPI_ENV_VALUE "disable")
_MPI_env_set_ifnot(I_MPI_DEBUG_INFO_STRIP _MPI_ENV_VALUE)
_MPI_env_set_ifnot(I_MPI_FORT_BIND _MPI_ENV_VALUE)
# Check whether the -showme:compile option works. This indicates that we have either Open MPI
# or a newer version of LAM/MPI, and implies that -showme:link will also work.
# Open MPI also supports -show, but separates linker and compiler information
_MPI_check_compiler(${LANG} "-showme:compile" MPI_COMPILE_CMDLINE MPI_COMPILER_RETURN)
if (MPI_COMPILER_RETURN EQUAL "0")
_MPI_check_compiler(${LANG} "-showme:link" MPI_LINK_CMDLINE MPI_COMPILER_RETURN)
if (NOT MPI_COMPILER_RETURN EQUAL "0")
unset(MPI_COMPILE_CMDLINE)
endif()
endif()
# MPICH and MVAPICH offer -compile-info and -link-info.
# For modern versions, both do the same as -show. However, for old versions, they do differ
# when called for mpicxx and mpif90 and it's necessary to use them over -show in order to find the
# removed MPI C++ bindings.
if (NOT MPI_COMPILER_RETURN EQUAL "0")
_MPI_check_compiler(${LANG} "-compile-info" MPI_COMPILE_CMDLINE MPI_COMPILER_RETURN)
if (MPI_COMPILER_RETURN EQUAL "0")
_MPI_check_compiler(${LANG} "-link-info" MPI_LINK_CMDLINE MPI_COMPILER_RETURN)
if (NOT MPI_COMPILER_RETURN EQUAL "0")
unset(MPI_COMPILE_CMDLINE)
endif()
endif()
endif()
# Cray compiler wrappers come usually without a separate mpicc/c++/ftn, but offer
# --cray-print-opts=...
if (NOT MPI_COMPILER_RETURN EQUAL "0")
_MPI_check_compiler(${LANG} "--cray-print-opts=cflags"
MPI_COMPILE_CMDLINE MPI_COMPILER_RETURN)
if (MPI_COMPILER_RETURN EQUAL "0")
# Pass --no-as-needed so the mpi library is always linked. Otherwise, the
# Cray compiler wrapper puts an --as-needed flag around the mpi library,
# and it is not linked unless code directly refers to it.
_MPI_check_compiler(${LANG} "--no-as-needed;--cray-print-opts=libs"
MPI_LINK_CMDLINE MPI_COMPILER_RETURN)
if (NOT MPI_COMPILER_RETURN EQUAL "0")
unset(MPI_COMPILE_CMDLINE)
unset(MPI_LINK_CMDLINE)
endif()
endif()
endif()
# MPICH, MVAPICH2 and Intel MPI just use "-show". Open MPI also offers this, but the
# -showme commands are more specialized.
if (NOT MPI_COMPILER_RETURN EQUAL "0")
_MPI_check_compiler(${LANG} "-show" MPI_COMPILE_CMDLINE MPI_COMPILER_RETURN)
endif()
# Older versions of LAM/MPI have "-showme". Open MPI also supports this.
# Unknown to MPICH, MVAPICH and Intel MPI.
if (NOT MPI_COMPILER_RETURN EQUAL "0")
_MPI_check_compiler(${LANG} "-showme" MPI_COMPILE_CMDLINE MPI_COMPILER_RETURN)
endif()
if (MPI_COMPILER_RETURN EQUAL "0" AND DEFINED MPI_COMPILE_CMDLINE)
# Intel MPI can be run with -compchk or I_MPI_CHECK_COMPILER set to 1.
# In this case, -show will be prepended with a line to the compiler checker. This is a script that performs
# compatibility checks and returns a non-zero exit code together with an error if something fails.
# It has to be called as "compchk.sh <arch> <compiler>". Here, <arch> is one out of 32 (i686), 64 (ia64) or 32e (x86_64).
# The compiler is identified by filename, and can be either the MPI compiler or the underlying compiler.
# NOTE: It is vital to run this script while the environment variables are set up, otherwise it can check the wrong compiler.
if(MPI_COMPILE_CMDLINE MATCHES "^([^\" ]+/compchk.sh|\"[^\"]+/compchk.sh\") +([^ ]+)")
# Now CMAKE_MATCH_1 contains the path to the compchk.sh file and CMAKE_MATCH_2 the architecture flag.
unset(COMPILER_CHECKER_OUTPUT)
execute_process(
COMMAND ${CMAKE_MATCH_1} ${CMAKE_MATCH_2} ${MPI_${LANG}_COMPILER}
OUTPUT_VARIABLE COMPILER_CHECKER_OUTPUT OUTPUT_STRIP_TRAILING_WHITESPACE
ERROR_VARIABLE COMPILER_CHECKER_OUTPUT ERROR_STRIP_TRAILING_WHITESPACE
RESULT_VARIABLE MPI_COMPILER_RETURN)
# If it returned a non-zero value, the check below will fail and cause the interrogation to be aborted.
if(NOT MPI_COMPILER_RETURN EQUAL "0")
if(NOT MPI_FIND_QUIETLY)
message(STATUS "Intel MPI compiler check failed: ${COMPILER_CHECKER_OUTPUT}")
endif()
else()
# Since the check passed, we can remove the compchk.sh script.
string(REGEX REPLACE "^([^\" ]+|\"[^\"]+\")/compchk.sh.*\n" "" MPI_COMPILE_CMDLINE "${MPI_COMPILE_CMDLINE}")
endif()
endif()
endif()
# Revert changes to the environment made previously
if(LANG STREQUAL "C")
_MPI_env_unset_ifnot(I_MPI_CC)
_MPI_env_unset_ifnot(MPICH_CC)
elseif(LANG STREQUAL "CXX")
_MPI_env_unset_ifnot(I_MPI_CXX)
_MPI_env_unset_ifnot(MPICH_CXX)
elseif(LANG STREQUAL "Fortran")
_MPI_env_unset_ifnot(I_MPI_FC)
_MPI_env_unset_ifnot(MPICH_FC)
_MPI_env_unset_ifnot(I_MPI_F77)
_MPI_env_unset_ifnot(MPICH_F77)
_MPI_env_unset_ifnot(I_MPI_F90)
_MPI_env_unset_ifnot(MPICH_F90)
endif()
_MPI_env_unset_ifnot(I_MPI_DEBUG_INFO_STRIP)
_MPI_env_unset_ifnot(I_MPI_FORT_BIND)
if (NOT (MPI_COMPILER_RETURN EQUAL "0") OR NOT (DEFINED MPI_COMPILE_CMDLINE))
# Cannot interrogate this compiler, so exit.
set(MPI_${LANG}_WRAPPER_FOUND FALSE PARENT_SCOPE)
return()
endif()
unset(MPI_COMPILER_RETURN)
# We have our command lines, but we might need to copy MPI_COMPILE_CMDLINE
# into MPI_LINK_CMDLINE, if we didn't find the link line.
if (NOT DEFINED MPI_LINK_CMDLINE)
set(MPI_LINK_CMDLINE "${MPI_COMPILE_CMDLINE}")
endif()
# Visual Studio parsers permit each flag prefixed by either / or -.
# We'll normalize this to the - syntax we use for CMake purposes anyways.
if(MSVC)
foreach(_MPI_VARIABLE IN ITEMS COMPILE LINK)
# The Intel MPI wrappers on Windows prefix their output with some copyright boilerplate.
# To prevent possible problems, we discard this text before proceeding with any further matching.
string(REGEX REPLACE "^[^ ]+ for the Intel\\(R\\) MPI Library [^\n]+ for Windows\\*\nCopyright\\(C\\) [^\n]+, Intel Corporation\\. All rights reserved\\.\n\n" ""
MPI_${_MPI_VARIABLE}_CMDLINE "${MPI_${_MPI_VARIABLE}_CMDLINE}")
string(REGEX REPLACE "(^| )/" "\\1-" MPI_${_MPI_VARIABLE}_CMDLINE "${MPI_${_MPI_VARIABLE}_CMDLINE}")
string(REPLACE "-libpath:" "-LIBPATH:" MPI_${_MPI_VARIABLE}_CMDLINE "${MPI_${_MPI_VARIABLE}_CMDLINE}")
endforeach()
endif()
# For MSVC and cl-compatible compilers, the keyword /link indicates a point after which
# everything following is passed to the linker. In this case, we drop all prior information
# from the link line and treat any unknown extra flags as linker flags.
set(_MPI_FILTERED_LINK_INFORMATION FALSE)
if(MSVC)
if(MPI_LINK_CMDLINE MATCHES " -(link|LINK) ")
string(REGEX REPLACE ".+-(link|LINK) +" "" MPI_LINK_CMDLINE "${MPI_LINK_CMDLINE}")
set(_MPI_FILTERED_LINK_INFORMATION TRUE)
endif()
string(REGEX REPLACE " +-(link|LINK) .+" "" MPI_COMPILE_CMDLINE "${MPI_COMPILE_CMDLINE}")
endif()
if(UNIX)
# At this point, we obtained some output from a compiler wrapper that works.
# We'll now try to parse it into variables with meaning to us.
if(LANG STREQUAL "Fortran")
# If MPICH (and derivates) didn't recognize the Fortran compiler include flag during configuration,
# they'll return a set of three commands, consisting out of a symlink command for mpif.h,
# the actual compiler command and deletion of the created symlink.
# Especially with M(VA)PICH-1, this appears to happen erroneously, and therefore we should translate
# this output into an additional include directory and then drop it from the output.
if(MPI_COMPILE_CMDLINE MATCHES "^ln -s ([^\" ]+|\"[^\"]+\") mpif.h")
get_filename_component(MPI_INCLUDE_DIRS_WORK "${CMAKE_MATCH_1}" DIRECTORY)
string(REGEX REPLACE "^ln -s ([^\" ]+|\"[^\"]+\") mpif.h\n" "" MPI_COMPILE_CMDLINE "${MPI_COMPILE_CMDLINE}")
string(REGEX REPLACE "^ln -s ([^\" ]+|\"[^\"]+\") mpif.h\n" "" MPI_LINK_CMDLINE "${MPI_LINK_CMDLINE}")
string(REGEX REPLACE "\nrm -f mpif.h$" "" MPI_COMPILE_CMDLINE "${MPI_COMPILE_CMDLINE}")
string(REGEX REPLACE "\nrm -f mpif.h$" "" MPI_LINK_CMDLINE "${MPI_LINK_CMDLINE}")
endif()
endif()
# If Intel MPI was configured for static linkage with -static_mpi, the wrapper will by default strip
# debug information from resulting binaries (see I_MPI_DEBUG_INFO_STRIP).
# Since we cannot process this information into CMake logic, we need to discard the resulting objcopy
# commands from the output.
string(REGEX REPLACE "(^|\n)objcopy[^\n]+(\n|$)" "" MPI_COMPILE_CMDLINE "${MPI_COMPILE_CMDLINE}")
string(REGEX REPLACE "(^|\n)objcopy[^\n]+(\n|$)" "" MPI_LINK_CMDLINE "${MPI_LINK_CMDLINE}")
endif()
# For Visual C++, extracting compiler options in a generic fashion isn't easy. However, no MPI implementation
# on Windows seems to require any specific ones, either.
if(NOT MSVC)
# Extract compile options from the compile command line.
string(REGEX MATCHALL "(^| )-f([^\" ]+|\"[^\"]+\")" MPI_ALL_COMPILE_OPTIONS "${MPI_COMPILE_CMDLINE}")
foreach(_MPI_COMPILE_OPTION IN LISTS MPI_ALL_COMPILE_OPTIONS)
string(REGEX REPLACE "^ " "" _MPI_COMPILE_OPTION "${_MPI_COMPILE_OPTION}")
# Ignore -fstack-protector directives: These occur on MPICH and MVAPICH when the libraries
# themselves were built with this flag. However, this flag is unrelated to using MPI, and
# we won't match the accompanying --param-ssp-size and -Wp,-D_FORTIFY_SOURCE flags and therefore
# produce inconsistent results with the regularly flags.
# Similarly, aliasing flags do not belong into our flag array.
# Also strip out `-framework` flags.
if(NOT _MPI_COMPILE_OPTION MATCHES "^-f((no-|)(stack-protector|strict-aliasing)|PI[CE]|pi[ce]|ramework)")
list(APPEND MPI_COMPILE_OPTIONS_WORK "${_MPI_COMPILE_OPTION}")
endif()
endforeach()
endif()
# For GNU-style compilers, it's possible to prefix includes and definitions with certain flags to pass them
# only to the preprocessor. For CMake purposes, we need to treat, but ignore such scopings.
# Note that we do not support spaces between the arguments, i.e. -Wp,-I -Wp,/opt/mympi will not be parsed
# correctly. This form does not seem to occur in any common MPI implementation, however.
if(NOT MSVC)
set(_MPI_PREPROCESSOR_FLAG_REGEX "(-Wp,|-Xpreprocessor )?")
else()
set(_MPI_PREPROCESSOR_FLAG_REGEX "")
endif()
# Same deal as above, for the definitions.
string(REGEX MATCHALL "(^| )${_MPI_PREPROCESSOR_FLAG_REGEX}-D *([^\" ]+|\"[^\"]+\")" MPI_ALL_COMPILE_DEFINITIONS "${MPI_COMPILE_CMDLINE}")
foreach(_MPI_COMPILE_DEFINITION IN LISTS MPI_ALL_COMPILE_DEFINITIONS)
string(REGEX REPLACE "^ ?${_MPI_PREPROCESSOR_FLAG_REGEX}-D *" "" _MPI_COMPILE_DEFINITION "${_MPI_COMPILE_DEFINITION}")
string(REPLACE "\"" "" _MPI_COMPILE_DEFINITION "${_MPI_COMPILE_DEFINITION}")
if(NOT _MPI_COMPILE_DEFINITION MATCHES "^_FORTIFY_SOURCE.*")
list(APPEND MPI_COMPILE_DEFINITIONS_WORK "${_MPI_COMPILE_DEFINITION}")
endif()
endforeach()
# Extract include paths from compile command line
string(REGEX MATCHALL "(^| )${_MPI_PREPROCESSOR_FLAG_REGEX}${CMAKE_INCLUDE_FLAG_${LANG}} *([^\" ]+|\"[^\"]+\")"
MPI_ALL_INCLUDE_PATHS "${MPI_COMPILE_CMDLINE}")
# If extracting failed to work, we'll try using -showme:incdirs.
# Unlike before, we do this without the environment variables set up, but since only MPICH derivates are affected by any of them, and
# -showme:... is only supported by Open MPI and LAM/MPI, this isn't a concern.
if (NOT MPI_ALL_INCLUDE_PATHS)
_MPI_check_compiler(${LANG} "-showme:incdirs" MPI_INCDIRS_CMDLINE MPI_INCDIRS_COMPILER_RETURN)
if(MPI_INCDIRS_COMPILER_RETURN)
separate_arguments(MPI_ALL_INCLUDE_PATHS NATIVE_COMMAND "${MPI_INCDIRS_CMDLINE}")
endif()
endif()
foreach(_MPI_INCLUDE_PATH IN LISTS MPI_ALL_INCLUDE_PATHS)
string(REGEX REPLACE "^ ?${_MPI_PREPROCESSOR_FLAG_REGEX}${CMAKE_INCLUDE_FLAG_${LANG}} *" "" _MPI_INCLUDE_PATH "${_MPI_INCLUDE_PATH}")
string(REPLACE "\"" "" _MPI_INCLUDE_PATH "${_MPI_INCLUDE_PATH}")
string(REPLACE "'" "" _MPI_INCLUDE_PATH "${_MPI_INCLUDE_PATH}")
get_filename_component(_MPI_INCLUDE_PATH "${_MPI_INCLUDE_PATH}" REALPATH)
list(APPEND MPI_INCLUDE_DIRS_WORK "${_MPI_INCLUDE_PATH}")
endforeach()
# The next step are linker flags and library directories. Here, we first take the flags given in raw -L or -LIBPATH: syntax.
string(REGEX MATCHALL "(^| )${CMAKE_LIBRARY_PATH_FLAG} *([^\" ]+|\"[^\"]+\")" MPI_DIRECT_LINK_PATHS "${MPI_LINK_CMDLINE}")
foreach(_MPI_LPATH IN LISTS MPI_DIRECT_LINK_PATHS)
string(REGEX REPLACE "(^| )${CMAKE_LIBRARY_PATH_FLAG} *" "" _MPI_LPATH "${_MPI_LPATH}")
list(APPEND MPI_ALL_LINK_PATHS "${_MPI_LPATH}")
endforeach()
# If the link commandline hasn't been filtered (e.g. when using MSVC and /link), we need to extract the relevant parts first.
if(NOT _MPI_FILTERED_LINK_INFORMATION)
string(REGEX MATCHALL "(^| )(-Wl,|-Xlinker +)([^\" ]+|\"[^\"]+\")" MPI_LINK_FLAGS "${MPI_LINK_CMDLINE}")
# In this case, we could also find some indirectly given linker paths, e.g. prefixed by -Xlinker or -Wl,
# Since syntaxes like -Wl,-L -Wl,/my/path/to/lib are also valid, we parse these paths by first removing -Wl, and -Xlinker
# from the list of filtered flags and then parse the remainder of the output.
string(REGEX REPLACE "(-Wl,|-Xlinker +)" "" MPI_LINK_FLAGS_RAW "${MPI_LINK_FLAGS}")
# Now we can parse the leftover output. Note that spaces can now be handled since the above example would reduce to
# -L /my/path/to/lib and can be extracted correctly.
string(REGEX MATCHALL "^(${CMAKE_LIBRARY_PATH_FLAG},? *|--library-path=)([^\" ]+|\"[^\"]+\")"
MPI_INDIRECT_LINK_PATHS "${MPI_LINK_FLAGS_RAW}")
foreach(_MPI_LPATH IN LISTS MPI_INDIRECT_LINK_PATHS)
string(REGEX REPLACE "^(${CMAKE_LIBRARY_PATH_FLAG},? *|--library-path=)" "" _MPI_LPATH "${_MPI_LPATH}")
list(APPEND MPI_ALL_LINK_PATHS "${_MPI_LPATH}")
endforeach()
# We need to remove the flags we extracted from the linker flag list now.
string(REGEX REPLACE "(^| )(-Wl,|-Xlinker +)(${CMAKE_LIBRARY_PATH_FLAG},? *(-Wl,|-Xlinker +)?|--library-path=)([^\" ]+|\"[^\"]+\")" ""
MPI_LINK_CMDLINE_FILTERED "${MPI_LINK_CMDLINE}")
# Some MPI implementations pass on options they themselves were built with. Since -z,noexecstack is a common
# hardening, we should strip it. In general, the -z options should be undesirable.
string(REGEX REPLACE "(^| )-Wl,-z(,[^ ]+| +-Wl,[^ ]+)" "" MPI_LINK_CMDLINE_FILTERED "${MPI_LINK_CMDLINE_FILTERED}")
string(REGEX REPLACE "(^| )-Xlinker +-z +-Xlinker +[^ ]+" "" MPI_LINK_CMDLINE_FILTERED "${MPI_LINK_CMDLINE_FILTERED}")
# We only consider options of the form -Wl or -Xlinker:
string(REGEX MATCHALL "(^| )(-Wl,|-Xlinker +)([^\" ]+|\"[^\"]+\")" MPI_ALL_LINK_FLAGS "${MPI_LINK_CMDLINE_FILTERED}")
# As a next step, we assemble the linker flags extracted in a preliminary flags string
foreach(_MPI_LINK_FLAG IN LISTS MPI_ALL_LINK_FLAGS)
string(STRIP "${_MPI_LINK_FLAG}" _MPI_LINK_FLAG)
if (MPI_LINK_FLAGS_WORK)
string(APPEND MPI_LINK_FLAGS_WORK " ${_MPI_LINK_FLAG}")
else()
set(MPI_LINK_FLAGS_WORK "${_MPI_LINK_FLAG}")
endif()
endforeach()
else()
# In the filtered case, we obtain the link time flags by just stripping the library paths.
string(REGEX REPLACE "(^| )${CMAKE_LIBRARY_PATH_FLAG} *([^\" ]+|\"[^\"]+\")" "" MPI_LINK_CMDLINE_FILTERED "${MPI_LINK_CMDLINE}")
endif()
# If we failed to extract any linker paths, we'll try using the -showme:libdirs option with the MPI compiler.
# This will return a list of folders, not a set of flags!
if (NOT MPI_ALL_LINK_PATHS)
_MPI_check_compiler(${LANG} "-showme:libdirs" MPI_LIBDIRS_CMDLINE MPI_LIBDIRS_COMPILER_RETURN)
if(MPI_LIBDIRS_COMPILER_RETURN)
separate_arguments(MPI_ALL_LINK_PATHS NATIVE_COMMAND "${MPI_LIBDIRS_CMDLINE}")
endif()
endif()
# We need to remove potential quotes and convert the paths to CMake syntax while resolving them, too.
foreach(_MPI_LPATH IN LISTS MPI_ALL_LINK_PATHS)
string(REPLACE "\"" "" _MPI_LPATH "${_MPI_LPATH}")
get_filename_component(_MPI_LPATH "${_MPI_LPATH}" REALPATH)
list(APPEND MPI_LINK_DIRECTORIES_WORK "${_MPI_LPATH}")
endforeach()
# Extract the set of libraries to link against from the link command line
# This only makes sense if CMAKE_LINK_LIBRARY_FLAG is defined, i.e. a -lxxxx syntax is supported by the compiler.
if(CMAKE_LINK_LIBRARY_FLAG)
string(REGEX MATCHALL "(^| )${CMAKE_LINK_LIBRARY_FLAG}([^\" ]+|\"[^\"]+\")"
MPI_LIBNAMES "${MPI_LINK_CMDLINE}")
foreach(_MPI_LIB_NAME IN LISTS MPI_LIBNAMES)
# also match flags starting with "-l:" here
string(REGEX REPLACE "^ ?${CMAKE_LINK_LIBRARY_FLAG}(:lib|:)?" "" _MPI_LIB_NAME "${_MPI_LIB_NAME}")
string(REPLACE "\"" "" _MPI_LIB_NAME "${_MPI_LIB_NAME}")
list(APPEND MPI_LIB_NAMES_WORK "${_MPI_LIB_NAME}")
endforeach()
endif()
# Treat linker objects given by full path, for example static libraries, import libraries
# or shared libraries if there aren't any import libraries in use on the system.
# Note that we do not consider CMAKE_<TYPE>_LIBRARY_PREFIX intentionally here: The linker will for a given file
# decide how to link it based on file type, not based on a prefix like 'lib'.
set(_MPI_LIB_SUFFIX_REGEX "${CMAKE_STATIC_LIBRARY_SUFFIX}")
if(DEFINED CMAKE_IMPORT_LIBRARY_SUFFIX)
if(NOT (CMAKE_IMPORT_LIBRARY_SUFFIX STREQUAL CMAKE_STATIC_LIBRARY_SUFFIX))
string(APPEND _MPI_LIB_SUFFIX_REGEX "|${CMAKE_IMPORT_LIBRARY_SUFFIX}")
endif()
else()
string(APPEND _MPI_LIB_SUFFIX_REGEX "|${CMAKE_SHARED_LIBRARY_SUFFIX}")
endif()
set(_MPI_LIB_NAME_REGEX "(([^\" ]+(${_MPI_LIB_SUFFIX_REGEX}))|(\"[^\"]+(${_MPI_LIB_SUFFIX_REGEX})\"))( +|$)")
string(REPLACE "." "\\." _MPI_LIB_NAME_REGEX "${_MPI_LIB_NAME_REGEX}")
string(REGEX MATCHALL "${_MPI_LIB_NAME_REGEX}" MPI_LIBNAMES "${MPI_LINK_CMDLINE}")
foreach(_MPI_LIB_NAME IN LISTS MPI_LIBNAMES)
# Do not match "-l:" flags
string(REGEX MATCH "^ ?${CMAKE_LINK_LIBRARY_FLAG}:" _MPI_LIB_NAME_TEST "${_MPI_LIB_NAME}")
if(_MPI_LIB_NAME_TEST STREQUAL "")
string(REGEX REPLACE "^ +\"?|\"? +$" "" _MPI_LIB_NAME "${_MPI_LIB_NAME}")
get_filename_component(_MPI_LIB_PATH "${_MPI_LIB_NAME}" DIRECTORY)
if(NOT _MPI_LIB_PATH STREQUAL "")
list(APPEND MPI_LIB_FULLPATHS_WORK "${_MPI_LIB_NAME}")
else()
list(APPEND MPI_LIB_NAMES_WORK "${_MPI_LIB_NAME}")
endif()
endif()
endforeach()
# Save the explicitly given link directories
set(MPI_LINK_DIRECTORIES_LEFTOVER "${MPI_LINK_DIRECTORIES_WORK}")
# An MPI compiler wrapper could have its MPI libraries in the implicitly
# linked directories of the compiler itself.
if(DEFINED CMAKE_${LANG}_IMPLICIT_LINK_DIRECTORIES)
list(APPEND MPI_LINK_DIRECTORIES_WORK "${CMAKE_${LANG}_IMPLICIT_LINK_DIRECTORIES}")
endif()
# Determine full path names for all of the libraries that one needs
# to link against in an MPI program
unset(MPI_PLAIN_LIB_NAMES_WORK)
foreach(_MPI_LIB_NAME IN LISTS MPI_LIB_NAMES_WORK)
get_filename_component(_MPI_PLAIN_LIB_NAME "${_MPI_LIB_NAME}" NAME_WE)
list(APPEND MPI_PLAIN_LIB_NAMES_WORK "${_MPI_PLAIN_LIB_NAME}")
find_library(MPI_${_MPI_PLAIN_LIB_NAME}_LIBRARY
NAMES "${_MPI_LIB_NAME}" "lib${_MPI_LIB_NAME}"
HINTS ${MPI_LINK_DIRECTORIES_WORK}
DOC "Location of the ${_MPI_PLAIN_LIB_NAME} library for MPI"
)
mark_as_advanced(MPI_${_MPI_PLAIN_LIB_NAME}_LIBRARY)
# Remove the directory from the remainder list.
if(MPI_${_MPI_PLAIN_LIB_NAME}_LIBRARY)
get_filename_component(_MPI_TAKEN_DIRECTORY "${MPI_${_MPI_PLAIN_LIB_NAME}_LIBRARY}" DIRECTORY)
list(REMOVE_ITEM MPI_LINK_DIRECTORIES_LEFTOVER "${_MPI_TAKEN_DIRECTORY}")
endif()
endforeach()
# Add the link directories given explicitly that we haven't used back as linker directories.
if(NOT WIN32)
foreach(_MPI_LINK_DIRECTORY IN LISTS MPI_LINK_DIRECTORIES_LEFTOVER)
file(TO_NATIVE_PATH "${_MPI_LINK_DIRECTORY}" _MPI_LINK_DIRECTORY_ACTUAL)
string(FIND "${_MPI_LINK_DIRECTORY_ACTUAL}" " " _MPI_LINK_DIRECTORY_CONTAINS_SPACE)
if(NOT _MPI_LINK_DIRECTORY_CONTAINS_SPACE EQUAL "-1")
set(_MPI_LINK_DIRECTORY_ACTUAL "\"${_MPI_LINK_DIRECTORY_ACTUAL}\"")
endif()
if(MPI_LINK_FLAGS_WORK)
string(APPEND MPI_LINK_FLAGS_WORK " ${CMAKE_LIBRARY_PATH_FLAG}${_MPI_LINK_DIRECTORY_ACTUAL}")
else()
set(MPI_LINK_FLAGS_WORK "${CMAKE_LIBRARY_PATH_FLAG}${_MPI_LINK_DIRECTORY_ACTUAL}")
endif()
endforeach()
endif()
# Deal with the libraries given with full path next
unset(MPI_DIRECT_LIB_NAMES_WORK)
foreach(_MPI_LIB_FULLPATH IN LISTS MPI_LIB_FULLPATHS_WORK)
get_filename_component(_MPI_PLAIN_LIB_NAME "${_MPI_LIB_FULLPATH}" NAME_WE)
list(APPEND MPI_DIRECT_LIB_NAMES_WORK "${_MPI_PLAIN_LIB_NAME}")
set(MPI_${_MPI_PLAIN_LIB_NAME}_LIBRARY "${_MPI_LIB_FULLPATH}" CACHE FILEPATH "Location of the ${_MPI_PLAIN_LIB_NAME} library for MPI")
mark_as_advanced(MPI_${_MPI_PLAIN_LIB_NAME}_LIBRARY)
endforeach()
# Directly linked objects should be linked first in case some generic linker flags are needed for them.
if(MPI_DIRECT_LIB_NAMES_WORK)
set(MPI_PLAIN_LIB_NAMES_WORK "${MPI_DIRECT_LIB_NAMES_WORK};${MPI_PLAIN_LIB_NAMES_WORK}")
endif()
# MPI might require pthread to work. The above mechanism wouldn't detect it, but we need to
# link it in that case. -lpthread is covered by the normal library treatment on the other hand.
if(MPI_COMPILE_CMDLINE MATCHES "-pthread")
list(APPEND MPI_COMPILE_OPTIONS_WORK "-pthread")
if(MPI_LINK_FLAGS_WORK)
string(APPEND MPI_LINK_FLAGS_WORK " -pthread")
else()
set(MPI_LINK_FLAGS_WORK "-pthread")
endif()
endif()
if(MPI_${LANG}_EXTRA_COMPILE_DEFINITIONS)
list(APPEND MPI_COMPILE_DEFINITIONS_WORK "${MPI_${LANG}_EXTRA_COMPILE_DEFINITIONS}")
endif()
if(MPI_${LANG}_EXTRA_COMPILE_OPTIONS)
list(APPEND MPI_COMPILE_OPTIONS_WORK "${MPI_${LANG}_EXTRA_COMPILE_OPTIONS}")
endif()
if(MPI_${LANG}_EXTRA_LIB_NAMES)
list(APPEND MPI_PLAIN_LIB_NAMES_WORK "${MPI_${LANG}_EXTRA_LIB_NAMES}")
endif()
# If we found MPI, set up all of the appropriate cache entries
if(NOT MPI_${LANG}_COMPILE_OPTIONS)
set(MPI_${LANG}_COMPILE_OPTIONS ${MPI_COMPILE_OPTIONS_WORK} CACHE STRING "MPI ${LANG} compilation options" FORCE)
endif()
if(NOT MPI_${LANG}_COMPILE_DEFINITIONS)
set(MPI_${LANG}_COMPILE_DEFINITIONS ${MPI_COMPILE_DEFINITIONS_WORK} CACHE STRING "MPI ${LANG} compilation definitions" FORCE)
endif()
if(NOT MPI_${LANG}_COMPILER_INCLUDE_DIRS)
set(MPI_${LANG}_COMPILER_INCLUDE_DIRS ${MPI_INCLUDE_DIRS_WORK} CACHE STRING "MPI ${LANG} compiler wrapper include directories" FORCE)
endif()
if(NOT MPI_${LANG}_LINK_FLAGS)
set(MPI_${LANG}_LINK_FLAGS ${MPI_LINK_FLAGS_WORK} CACHE STRING "MPI ${LANG} linker flags" FORCE)
endif()
if(NOT MPI_${LANG}_LIB_NAMES)
set(MPI_${LANG}_LIB_NAMES ${MPI_PLAIN_LIB_NAMES_WORK} CACHE STRING "MPI ${LANG} libraries to link against" FORCE)
endif()
set(MPI_${LANG}_WRAPPER_FOUND TRUE PARENT_SCOPE)
endfunction()
function(_MPI_guess_settings LANG)
set(MPI_GUESS_FOUND FALSE)
# Currently only MSMPI and MPICH2 on Windows are supported, so we can skip this search if we're not targeting that.
if(WIN32)
# MSMPI
# The environment variables MSMPI_INC and MSMPILIB32/64 are the only ways of locating the MSMPI_SDK,
# which is installed separately from the runtime. Thus it's possible to have mpiexec but not MPI headers
# or import libraries and vice versa.
if(NOT MPI_GUESS_LIBRARY_NAME OR MPI_GUESS_LIBRARY_NAME STREQUAL "MSMPI")
# We first attempt to locate the msmpi.lib. Should be find it, we'll assume that the MPI present is indeed
# Microsoft MPI.
if(CMAKE_SIZEOF_VOID_P EQUAL "8")
file(TO_CMAKE_PATH "$ENV{MSMPI_LIB64}" MPI_MSMPI_LIB_PATH)
file(TO_CMAKE_PATH "$ENV{MSMPI_INC}/x64" MPI_MSMPI_INC_PATH_EXTRA)
else()
file(TO_CMAKE_PATH "$ENV{MSMPI_LIB32}" MPI_MSMPI_LIB_PATH)
file(TO_CMAKE_PATH "$ENV{MSMPI_INC}/x86" MPI_MSMPI_INC_PATH_EXTRA)
endif()
find_library(MPI_msmpi_LIBRARY
NAMES msmpi
HINTS ${MPI_MSMPI_LIB_PATH}
DOC "Location of the msmpi library for Microsoft MPI")
mark_as_advanced(MPI_msmpi_LIBRARY)
if(MPI_msmpi_LIBRARY)
# Next, we attempt to locate the MPI header. Note that for Fortran we know that mpif.h is a way
# MSMPI can be used and therefore that header has to be present.
if(NOT MPI_${LANG}_ADDITIONAL_INCLUDE_DIRS)
get_filename_component(MPI_MSMPI_INC_DIR "$ENV{MSMPI_INC}" REALPATH)
set(MPI_${LANG}_ADDITIONAL_INCLUDE_DIRS "${MPI_MSMPI_INC_DIR}" CACHE STRING "MPI ${LANG} additional include directories" FORCE)
unset(MPI_MSMPI_INC_DIR)
endif()
# For MSMPI, one can compile the MPI module by building the mpi.f90 shipped with the MSMPI SDK,
# thus it might be present or provided by the user. Figuring out which is supported is done later on.
# The PGI Fortran compiler for instance ships a prebuilt set of modules in its own include folder.
# Should a user be employing PGI or have built its own set and provided it via cache variables, the
# splitting routine would have located the module files.
# For C and C++, we're done here (MSMPI does not ship the MPI-2 C++ bindings) - however, for Fortran
# we need some extra library to glue Fortran support together:
# MSMPI ships 2-4 Fortran libraries, each for different Fortran compiler behaviors. The library names
# ending with a c are using the cdecl calling convention, whereas those ending with an s are for Fortran
# implementations using stdcall. Therefore, the 64-bit MSMPI only ships those ending in 'c', whereas the 32-bit
# has both variants available.
# The second difference is the last but one letter, if it's an e(nd), the length of a string argument is
# passed by the Fortran compiler after all other arguments on the parameter list, if it's an m(ixed),
# it's passed immediately after the string address.
# To summarize:
# - msmpifec: CHARACTER length passed after the parameter list and using cdecl calling convention
# - msmpifmc: CHARACTER length passed directly after string address and using cdecl calling convention
# - msmpifes: CHARACTER length passed after the parameter list and using stdcall calling convention
# - msmpifms: CHARACTER length passed directly after string address and using stdcall calling convention
# 32-bit MSMPI ships all four libraries, 64-bit MSMPI ships only the first two.
# As is, Intel Fortran and PGI Fortran both use the 'ec' variant of the calling convention, whereas
# the old Compaq Visual Fortran compiler defaulted to the 'ms' version. It's possible to make Intel Fortran
# use the CVF calling convention using /iface:cvf, but we assume - and this is also assumed in FortranCInterface -
# this isn't the case. It's also possible to make CVF use the 'ec' variant, using /iface=(cref,nomixed_str_len_arg).
# Our strategy is now to locate all libraries, but enter msmpifec into the LIB_NAMES array.
# Should this not be adequate it's a straightforward way for a user to change the LIB_NAMES array and
# have his library found. Still, this should not be necessary outside of exceptional cases, as reasoned.
if (LANG STREQUAL "Fortran")
set(MPI_MSMPI_CALLINGCONVS c)
if(CMAKE_SIZEOF_VOID_P EQUAL "4")
list(APPEND MPI_MSMPI_CALLINGCONVS s)
endif()
foreach(mpistrlenpos IN ITEMS e m)
foreach(mpicallingconv IN LISTS MPI_MSMPI_CALLINGCONVS)
find_library(MPI_msmpif${mpistrlenpos}${mpicallingconv}_LIBRARY
NAMES msmpif${mpistrlenpos}${mpicallingconv}
HINTS "${MPI_MSMPI_LIB_PATH}"
DOC "Location of the msmpi${mpistrlenpos}${mpicallingconv} library for Microsoft MPI")
mark_as_advanced(MPI_msmpif${mpistrlenpos}${mpicallingconv}_LIBRARY)
endforeach()
endforeach()
if(NOT MPI_${LANG}_LIB_NAMES)
set(MPI_${LANG}_LIB_NAMES "msmpi;msmpifec" CACHE STRING "MPI ${LANG} libraries to link against" FORCE)
endif()
# At this point we're *not* done. MSMPI requires an additional include file for Fortran giving the value