ports/openmpi
ports
/
openmpi
1
1
Форкнуть 0
Код Релизы Активность
openmpi/autogen.pl

1470 строки
48 KiB
Prolog
Исполняемый файл
Исходник Постоянная ссылка Ответственный История

#!/usr/bin/env perl
#
# Copyright (c) 2009-2020 Cisco Systems, Inc. All rights reserved
# Copyright (c) 2010 Oracle and/or its affiliates. All rights reserved.
# Copyright (c) 2013 Mellanox Technologies, Inc.
# All rights reserved.
# Copyright (c) 2013-2014 Intel, Inc. All rights reserved.
# Copyright (c) 2015-2020 Research Organization for Information Science
# and Technology (RIST). All rights reserved.
# Copyright (c) 2015 IBM Corporation. All rights reserved.
#
# $COPYRIGHT$
#
# Additional copyrights may follow
#
# $HEADER$
#
use strict;
use Cwd;
use File::Basename;
use File::Find;
use Data::Dumper;
use Getopt::Long;
#
# Global variables
#
# Sentinel file to remove if we fail
my $sentinel;
# The m4 file we'll write at the end
my $m4_output_file = "config/autogen_found_items.m4";
my $m4;
# Sanity check file
my $topdir_file = "opal/include/opal_config_bottom.h";
my $dnl_line = "dnl ---------------------------------------------------------------------------";
# Data structures to fill up with all the stuff we find
my $mca_found;
my $mpiext_found;
my $mpicontrib_found;
my @subdirs;
# Command line parameters
my $no_ompi_arg = 0;
my $no_orte_arg = 0;
my $no_oshmem_arg = 0;
my $quiet_arg = 0;
my $debug_arg = 0;
my $help_arg = 0;
my $platform_arg = 0;
my $include_arg = 0;
my $exclude_arg = 0;
my $force_arg = 0;
# Include/exclude lists
my $include_list;
my $exclude_list;
# Minimum versions
my $ompi_automake_version = "1.12.2";
my $ompi_autoconf_version = "2.69";
my $ompi_libtool_version = "2.4.2";
# Search paths
my $ompi_autoconf_search = "autoconf";
my $ompi_automake_search = "automake";
my $ompi_libtoolize_search = "libtoolize;glibtoolize";
# One-time setup
my $username;
my $hostname;
my $full_hostname;
# Patch program
my $patch_prog = "patch";
# Solaris "patch" doesn't understand unified diffs, and will cause
# autogen.pl to hang with a "File to patch:" prompt. Default to Linux
# "patch", but use "gpatch" on Solaris.
if ($^O eq "solaris") {
$patch_prog = "gpatch";
}
$username = getpwuid($>);
$full_hostname = `hostname`;
chomp($full_hostname);
$hostname = $full_hostname;
$hostname =~ s/^([\w\-]+)\..+/\1/;
##############################################################################
sub my_die {
unlink($sentinel)
if ($sentinel);
die @_;
}
sub my_exit {
my ($ret) = @_;
unlink($sentinel)
if ($sentinel && $ret != 0);
exit($ret);
}
##############################################################################
sub verbose {
print @_
if (!$quiet_arg);
}
sub debug {
print @_
if ($debug_arg);
}
sub debug_dump {
my $d = new Data::Dumper([@_]);
$d->Purity(1)->Indent(1);
debug $d->Dump;
}
##############################################################################
sub read_config_params {
my ($filename, $dir_prefix) = @_;
my $dir = dirname($filename);
open(FILE, $filename) ||
my_die "Can't open $filename";
my $file;
$file .= $_
while(<FILE>);
close(FILE);
# Save all lines of the form "foo = bar" in a hash
my $ret;
while ($file =~ s/^\s*(\w+)\s*=\s*(.+)\s*$//m) {
my $key = $1;
my $val = $2;
# Strip off any leading and trailing "'s
$val = $1
if ($val =~ m/^\"(.+)\"$/);
$ret->{$key} = $val;
}
# Split PARAM_CONFIG_FILES into an array
if (exists($ret->{PARAM_CONFIG_FILES})) {
my @out;
foreach my $f (split(/\s+/, $ret->{PARAM_CONFIG_FILES})) {
push(@out, "$dir_prefix/$f");
}
$ret->{PARAM_CONFIG_FILES} = \@out;
}
debug_dump($ret);
return $ret;
}
##############################################################################
# Process a "subdir", meaning that the directory isn't a component or
# an extension; it probably just needs an autoreconf, autogen, etc.
sub process_subdir {
my ($dir) = @_;
# Chdir to the subdir
print "\n=== Processing subdir: $dir\n";
my $start = Cwd::cwd();
chdir($dir);
# Run an action depending on what we find in that subdir
if (-x "autogen.pl") {
print "--- Found autogen.pl; running...\n";
safe_system("./autogen.pl");
} elsif (-x "autogen.sh") {
print "--- Found autogen.sh; running...\n";
safe_system("./autogen.sh");
} elsif (-f "configure.in" || -f "configure.ac") {
print "--- Found configure.in|ac; running autoreconf...\n";
safe_system("autoreconf -ivf");
print "--- Patching autotools output... :-(\n";
} else {
my_die "Found subdir, but no autogen.sh or configure.in|ac to do anything";
}
# Ensure that we got a good configure executable.
my_die "Did not generate a \"configure\" executable in $dir.\n"
if (! -x "configure");
# Fix known issues in Autotools output
patch_autotools_output($start);
# Chdir back to where we came from
chdir($start);
}
##############################################################################
sub process_autogen_subdirs {
my ($dir) = @_;
my $file = "$dir/autogen.subdirs";
if (-f $file) {
open(FILE, $file) || my_die "Can't open $file";
while (<FILE>) {
chomp;
$_ =~ s/#.*$//;
$_ =~ s/^\s*//;
$_ =~ s/\s*$//;
if ($_ ne "") {
print " Found subdir: $_ (will process later)\n";
# Note: there's no real technical reason to defer
# processing the subdirs. It's more of an aesthetic
# reason -- don't interrupt the current flow of
# finding mca / ext / contribs (which is a nice, fast
# process). Then process the subdirs (which is a slow
# process) all at once.
push(@subdirs, "$dir/$_");
}
}
close(FILE);
}
}
##############################################################################
sub mca_process_component {
my ($topdir, $project, $framework, $component) = @_;
my $pname = $project->{name};
my $pdir = $project->{dir};
my $cdir = "$topdir/$pdir/mca/$framework/$component";
return
if (! -d $cdir);
# Process this directory (pretty much the same treatment as for
# mpiext, so it's in a sub).
my $found_component;
# Does this directory have a configure.m4 file?
if (-f "$cdir/configure.m4") {
$found_component->{"configure.m4"} = 1;
verbose " Found configure.m4 file\n";
}
$found_component->{"name"} = $component;
# Push the results onto the $mca_found hash array
push(@{$mca_found->{$pname}->{$framework}->{"components"}},
$found_component);
# Is there an autogen.subdirs in here?
process_autogen_subdirs($cdir);
}
##############################################################################
sub ignored {
my ($dir) = @_;
# If this directory does not have .opal_ignore, or if it has a
# .opal_unignore that has my username in it, then add it to the
# list of components.
my $ignored = 0;
if (-f "$dir/.opal_ignore") {
$ignored = 1;
}
if (-f "$dir/.opal_unignore") {
open(UNIGNORE, "$dir/.opal_unignore") ||
my_die "Can't open $dir/.opal_unignore file";
my $unignore;
$unignore .= $_
while (<UNIGNORE>);
close(UNIGNORE);
$ignored = 0
if ($unignore =~ /^$username$/m ||
$unignore =~ /^$username\@$hostname$/m ||
$unignore =~ /^$username\@$full_hostname$/m);
}
return $ignored;
}
##############################################################################
sub mca_process_framework {
my ($topdir, $project, $framework) = @_;
my $pname = $project->{name};
my $pdir = $project->{dir};
# Does this framework have a configure.m4 file?
my $dir = "$topdir/$pdir/mca/$framework";
if (-f "$dir/configure.m4") {
$mca_found->{$pname}->{$framework}->{"configure.m4"} = 1;
verbose " Found framework configure.m4 file\n";
}
# Did we exclude all components for this framework?
if (exists($exclude_list->{$framework}) &&
$exclude_list->{$framework}[0] eq "AGEN_EXCLUDE_ALL") {
verbose " => Excluded\n";
} else {
# Look for component directories in this framework
if (-d $dir) {
$mca_found->{$pname}->{$framework}->{found} = 1;
opendir(DIR, $dir) ||
my_die "Can't open $dir directory";
foreach my $d (sort(readdir(DIR))) {
# Skip any non-directory, "base", or any dir that
# begins with "."
next
if (! -d "$dir/$d" || $d eq "base" ||
substr($d, 0, 1) eq ".");
# Skip any component that doesn't have a configure.m4
# or Makefile.am as we couldn't build it anyway
if (! -f "$dir/$d/configure.m4" &&
! -f "$dir/$d/Makefile.am" &&
! -f "$dir/$d/configure.ac" &&
! -f "$dir/$d/configure.in") {
verbose " => No sentinel file found in $dir/$d -> Excluded\n";
next;
}
verbose "--- Found $pname / $framework / $d component\n";
# Skip if specifically excluded
if (exists($exclude_list->{$framework}) &&
$exclude_list->{$framework}[0] eq $d) {
verbose " => Excluded\n";
next;
}
# Skip if the framework is on the include list, but
# doesn't contain this component
if (exists($include_list->{$framework})) {
my $tst = 0;
foreach my $ck (@{$include_list->{$framework}}) {
if ($ck ne $d) {
verbose " => Not included\n";
$tst = 1;
last;
}
}
if ($tst) {
next;
}
}
# Check ignore status
if (ignored("$dir/$d")) {
verbose " => Ignored (found .opal_ignore file)\n";
} else {
mca_process_component($topdir, $project, $framework, $d);
}
}
}
closedir(DIR);
}
}
##############################################################################
sub mca_generate_framework_header(\$\@) {
my ($project, @frameworks) = @_;
my $framework_array_output="";
my $framework_decl_output="";
foreach my $framework (@frameworks) {
# There is no common framework object
if ($framework ne "common") {
my $framework_name = "${project}_${framework}_base_framework";
$framework_array_output .= " &$framework_name,\n";
$framework_decl_output .= "extern mca_base_framework_t $framework_name;\n";
}
}
my $ifdef_string = uc "${project}_FRAMEWORKS_H";
open(FRAMEWORKS_OUT, ">$project/include/$project/frameworks.h");
printf FRAMEWORKS_OUT "%s", "/*
* This file is autogenerated by autogen.pl. Do not edit this file by hand.
*/
#ifndef $ifdef_string
#define $ifdef_string
#include <opal/mca/base/mca_base_framework.h>
$framework_decl_output
static mca_base_framework_t *${project}_frameworks[] = {
$framework_array_output NULL
};
#endif /* $ifdef_string */\n\n";
close(FRAMEWORKS_OUT);
}
##############################################################################
sub mca_process_project {
my ($topdir, $project) = @_;
my $pname = $project->{name};
my $pdir = $project->{dir};
# Does this project have a configure.m4 file?
if (-f "$topdir/$pdir/configure.m4") {
$mca_found->{$pname}->{"configure.m4"} = 1;
verbose " Found $topdir/$pdir/configure.m4 file\n";
}
# Look for framework directories in this project
my $dir = "$topdir/$pdir/mca";
if (-d $dir) {
opendir(DIR, $dir) ||
my_die "Can't open $dir directory";
my @my_dirs = readdir(DIR);
@my_dirs = sort(@my_dirs);
foreach my $d (@my_dirs) {
# Skip any non-directory, "base", or any dir that begins with "."
next
if (! -d "$dir/$d" || $d eq "base" || substr($d, 0, 1) eq ".");
my $framework_header = "$dir/$d/$d.h";
# If there's a $dir/$d/autogen.options file, read it
my $ao_file = "$dir/$d/autogen.options";
if (-r $ao_file) {
verbose "\n>>> Found $dir/$d/autogen.options file\n";
open(IN, $ao_file) ||
die "$ao_file present, but cannot open it";
while (<IN>) {
if (m/\s*framework_header\s*=\s*(.+?)\s*$/) {
verbose " Framework header entry: $1\n";
$framework_header = "$dir/$d/$1";
}
}
close(IN);
}
# If this directory has a framework header and a base/
# subdirectory, or its name is "common", then it's a
# framework.
if ("common" eq $d || !$project->{need_base} ||
(-f $framework_header && -d "$dir/$d/base")) {
verbose "\n=== Found $pname / $d framework\n";
mca_process_framework($topdir, $project, $d);
}
}
closedir(DIR);
}
}
##############################################################################
sub mca_run_global {
my ($projects) = @_;
# For each project, go find a list of frameworks, and for each of
# those, go find a list of components.
my $topdir = Cwd::cwd();
foreach my $p (@$projects) {
if (-d "$topdir/$p->{dir}") {
verbose "\n*** Found $p->{name} project\n";
mca_process_project($topdir, $p);
}
}
# Debugging output
debug_dump($mca_found);
# Save (just) the list of MCA projects in the m4 file
my $str;
foreach my $p (@$projects) {
my $pname = $p->{name};
# Check if this project is an MCA project (contains MCA framework)
if (exists($mca_found->{$pname})) {
$str .= "$p->{name}, ";
}
}
$str =~ s/, $//;
$m4 .= "\ndnl List of MCA projects found by autogen.pl
m4_define([mca_project_list], [$str])\n";
#-----------------------------------------------------------------------
$m4 .= "\n$dnl_line
$dnl_line
$dnl_line
dnl MCA information\n";
# Array for all the m4_includes that we'll need to pick up the
# configure.m4's.
my @includes;
# Next, for each project, write the list of frameworks
foreach my $p (@$projects) {
my $pname = $p->{name};
my $pdir = $p->{dir};
if (exists($mca_found->{$pname})) {
my $frameworks_comma;
# Does this project have a configure.m4 file?
push(@includes, "$pdir/configure.m4")
if (exists($mca_found->{$p}->{"configure.m4"}));
# Print out project-level info
my @mykeys = keys(%{$mca_found->{$pname}});
@mykeys = sort(@mykeys);
# Ensure that the "common" framework is listed first
# (if it exists)
my @tmp;
push(@tmp, "common")
if (grep(/common/, @mykeys));
foreach my $f (@mykeys) {
push(@tmp, $f)
if ($f ne "common");
}
@mykeys = @tmp;
foreach my $f (@mykeys) {
$frameworks_comma .= ", $f";
# Does this framework have a configure.m4 file?
push(@includes, "$pdir/mca/$f/configure.m4")
if (exists($mca_found->{$pname}->{$f}->{"configure.m4"}));
# This framework does have a Makefile.am (or at least,
# it should!)
my_die "Missing $pdir/mca/$f/Makefile.am"
if (! -f "$pdir/mca/$f/Makefile.am");
}
$frameworks_comma =~ s/^, //;
&mca_generate_framework_header($pname, @mykeys);
$m4 .= "$dnl_line
dnl Frameworks in the $pname project and their corresponding directories
m4_define([mca_${pname}_framework_list], [$frameworks_comma])
";
# Print out framework-level info
foreach my $f (@mykeys) {
my $components;
my $m4_config_component_list;
my $no_config_component_list;
# Troll through each of the found components
foreach my $comp (@{$mca_found->{$pname}->{$f}->{components}}) {
my $c = $comp->{name};
$components .= "$c ";
# Does this component have a configure.m4 file?
if (exists($comp->{"configure.m4"})) {
push(@includes, "$pdir/mca/$f/$c/configure.m4");
$m4_config_component_list .= ", $c";
} else {
$no_config_component_list .= ", $c";
}
}
$m4_config_component_list =~ s/^, //;
$no_config_component_list =~ s/^, //;
$m4 .= "dnl Components in the $pname / $f framework
m4_define([mca_${pname}_${f}_m4_config_component_list], [$m4_config_component_list])
m4_define([mca_${pname}_${f}_no_config_component_list], [$no_config_component_list])
";
}
}
}
# List out all the m4_include
$m4 .= "$dnl_line
dnl List of configure.m4 files to include\n";
foreach my $i (@includes) {
$m4 .= "m4_include([$i])\n";
}
}
##############################################################################
sub mpiext_process_extension {
my ($topdir, $ext_prefix, $extdir) = @_;
my $edir = "$topdir/$ext_prefix/$extdir";
return
if (! -d $edir);
# Process this directory (pretty much the same treatment as for
# MCA components, so it's in a sub).
my $found_ext;
$found_ext->{"name"} = $extdir;
# Push the results onto the hash array
push(@{$mpiext_found}, $found_ext);
# Is there an autogen.subdirs in here?
process_autogen_subdirs($edir);
}
##############################################################################
sub mpiext_run_global {
my ($ext_prefix) = @_;
my $topdir = Cwd::cwd();
my $dir = "$topdir/$ext_prefix";
opendir(DIR, $dir) ||
my_die "Can't open $dir directory";
foreach my $d (sort(readdir(DIR))) {
# Skip any non-directory, "base", or any dir that begins with "."
next
if (! -d "$dir/$d" || $d eq "base" || substr($d, 0, 1) eq ".");
# If this directory has a configure.m4, then it's an
# extension.
if (-f "$dir/$d/configure.m4") {
verbose "=== Found $d MPI extension";
# Check ignore status
if (ignored("$dir/$d")) {
verbose " (ignored)\n";
} else {
verbose "\n";
mpiext_process_extension($topdir, $ext_prefix, $d);
}
}
}
closedir(DIR);
debug_dump($mpiext_found);
#-----------------------------------------------------------------------
$m4 .= "\n$dnl_line
$dnl_line
$dnl_line
dnl Open MPI extensions information
$dnl_line\n\n";
# Array for all the m4_includes that we'll need to pick up the
# configure.m4's.
my @includes;
my $m4_config_ext_list;
# Troll through each of the found exts
foreach my $ext (@{$mpiext_found}) {
my $e = $ext->{name};
push(@includes, "$ext_prefix/$e/configure.m4");
$m4_config_ext_list .= ", $e";
}
$m4_config_ext_list =~ s/^, //;
# List the M4 and no configure exts
$m4 .= "dnl List of all MPI extensions
m4_define([ompi_mpiext_list], [$m4_config_ext_list])\n";
# List out all the m4_include
$m4 .= "\ndnl List of configure.m4 files to include\n";
foreach my $i (@includes) {
$m4 .= "m4_include([$i])\n";
}
}
##############################################################################
sub mpicontrib_process {
my ($topdir, $contrib_prefix, $contribdir) = @_;
my $cdir = "$topdir/$contrib_prefix/$contribdir";
return
if (! -d $cdir);
# Process this directory (pretty much the same treatment as for
# MCA components, so it's in a sub).
my $found_contrib;
$found_contrib->{"name"} = $contribdir;
# Push the results onto the hash array
push(@{$mpicontrib_found}, $found_contrib);
# Is there an autogen.subdirs in here?
process_autogen_subdirs($cdir);
}
##############################################################################
sub mpicontrib_run_global {
my ($contrib_prefix) = @_;
my $topdir = Cwd::cwd();
my $dir = "$topdir/$contrib_prefix";
opendir(DIR, $dir) ||
my_die "Can't open $dir directory";
foreach my $d (sort(readdir(DIR))) {
# Skip any non-directory, "base", or any dir that begins with "."
next
if (! -d "$dir/$d" || $d eq "base" || substr($d, 0, 1) eq ".");
# If this directory has a configure.m4, then it's an
# contrib.
if (-f "$dir/$d/configure.m4") {
verbose "=== Found $d MPI contrib";
# Check ignore status
if (ignored("$dir/$d")) {
verbose " (ignored)\n";
} else {
verbose "\n";
mpicontrib_process($topdir, $contrib_prefix, $d);
}
}
}
closedir(DIR);
debug_dump($mpicontrib_found);
#-----------------------------------------------------------------------
$m4 .= "\n$dnl_line
$dnl_line
$dnl_line
dnl Open MPI contrib information
$dnl_line\n\n";
# Array for all the m4_includes that we'll need to pick up the
# configure.m4's.
my @includes;
my $m4_config_contrib_list;
# Troll through each of the found contribs
foreach my $contrib (@{$mpicontrib_found}) {
my $c = $contrib->{name};
push(@includes, "$contrib_prefix/$c/configure.m4");
$m4_config_contrib_list .= ", $c";
}
$m4_config_contrib_list =~ s/^, //;
# List the M4 and no configure contribs
$m4 .= "dnl List of all MPI contribs
m4_define([ompi_mpicontrib_list], [$m4_config_contrib_list])\n";
# List out all the m4_include
$m4 .= "\ndnl List of configure.m4 files to include\n";
foreach my $i (@includes) {
$m4 .= "m4_include([$i])\n";
}
}
##############################################################################
# Find and remove stale files
sub find_and_delete {
foreach my $file (@_) {
my $removed = 0;
if (-f $file) {
unlink($file);
$removed = 1;
}
if (-f "config/$file") {
unlink("config/$file");
$removed = 1;
}
debug " Removed stale copy of $file\n"
if ($removed);
}
}
##############################################################################
# Find a specific executable and ensure that it is a recent enough
# version.
sub find_and_check {
my ($app, $app_name, $req_version) = @_;
my @search_path = split(/;/, $app_name);
my @min_version = split(/\./, $req_version);
my @versions_found = ();
foreach (@search_path) {
verbose " Searching for $_\n";
my $version = `$_ --version`;
if (!defined($version)) {
verbose " $_ not found\n";
next;
}
# Matches a version string with 1 or more parts possibly prefixed with a letter (ex:
# v2.2) or followed by a letter (ex: 2.2.6b). This regex assumes there is a space
# before the version string and that the version is ok if there is no version.
if (!($version =~ m/\s[vV]?(\d[\d\.]*\w?)/m)) {
verbose " WARNING: $_ does not appear to support --version. Assuming it is ok\n";
return;
}
$version = $1;
verbose " Found $_ version $version; checking version...\n";
push(@versions_found, $version);
my @parts = split(/\./, $version);
my $i = 0;
# Check every component of the version number
while ($i <= $#min_version) {
verbose " Found version component $parts[$i] -- need $min_version[$i]\n";
# Check to see if there are any characters (!) in the
# version number (e.g., Libtool's "2.2.6b" -- #%@#$%!!!).
# Do separate comparisons between the number and any
# trailing digits. You can't just "lt" compare the whole
# string because "10 lt 2b" will return true. #@$@#$#@$
# Libtool!!
$parts[$i] =~ m/(\d+)([a-z]*)/i;
my $pn = $1;
my $pa = $2;
$min_version[$i] =~ m/(\d+)([a-z]*)/i;
my $mn = $1;
my $ma = $2;
# If the version is higher, we're done.
if ($pn > $mn) {
verbose " ==> ACCEPTED\n";
return;
}
# If the version is lower, we're done.
elsif ($pn < $mn ||
($pn == $mn && $pa lt $ma)) {
verbose " ==> Too low! Skipping this version\n";
last;
}
# If the version was equal, keep checking.
++$i;
}
# If we found a good version, return.
if ($i > $#min_version) {
verbose " ==> ACCEPTED\n";
return;
}
}
# if no acceptable version found, reject it
print "
=================================================================
I could not find a recent enough copy of $app.
I need at least $req_version, but only found the following versions:\n\n";
my $i = 0;
foreach (@search_path) {
print " $_: $versions_found[$i]\n";
$i++;
}
print "\nI am gonna abort. :-(
Please make sure you are using at least the following versions of the
tools:
GNU Autoconf: $ompi_autoconf_version
GNU Automake: $ompi_automake_version
GNU Libtool: $ompi_libtool_version
=================================================================\n";
my_exit(1);
}
##############################################################################
sub safe_system {
print "Running: " . join(/ /, @_) . "\n";
my $ret = system(@_);
$ret >>= 8;
if (0 != $ret) {
print "Command failed: @_\n";
my_exit($ret);
}
$ret;
}
##############################################################################
sub patch_autotools_output {
my ($topdir) = @_;
# Set indentation string for verbose output depending on current directory.
my $indent_str = " ";
if ($topdir eq ".") {
$indent_str = "=== ";
}
# Patch ltmain.sh error for PGI version numbers. Redirect stderr to
# /dev/null because this patch is only necessary for some versions of
# Libtool (e.g., 2.2.6b); it'll [rightfully] fail if you have a new
# enough Libtool that doesn't need this patch. But don't alarm the
# user and make them think that autogen failed if this patch fails --
# make the errors be silent.
# Also patch ltmain.sh for NAG compiler
if (-f "config/ltmain.sh") {
verbose "$indent_str"."Patching PGI compiler version numbers in ltmain.sh\n";
system("$patch_prog -N -p0 < $topdir/config/ltmain_pgi_tp.diff >/dev/null 2>&1");
unlink("config/ltmain.sh.rej");
verbose "$indent_str"."Patching \"-pthread\" option for NAG compiler in ltmain.sh\n";
system("$patch_prog -N -p0 < $topdir/config/ltmain_nag_pthread.diff >/dev/null 2>&1");
unlink("config/ltmain.sh.rej");
}
# If there's no configure script, there's nothing else to do.
return
if (! -f "configure");
my @verbose_out;
# Total ugh. We have to patch the configure script itself. See below
# for explanations why.
open(IN, "configure") || my_die "Can't open configure";
my $c;
$c .= $_
while(<IN>);
close(IN);
my $c_orig = $c;
# LT <=2.2.6b need to be patched for the PGI 10.0 fortran compiler
# name (pgfortran). The following comes from the upstream LT patches:
# http://lists.gnu.org/archive/html/libtool-patches/2009-11/msg00012.html
# http://lists.gnu.org/archive/html/bug-libtool/2009-11/msg00045.html
# Note that that patch is part of Libtool (which is not in this OMPI
# source tree); we can't fix it. So all we can do is patch the
# resulting configure script. :-(
push(@verbose_out, $indent_str . "Patching configure for Libtool PGI 10 fortran compiler name\n");
$c =~ s/gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn/gfortran g95 xlf95 f95 fort ifort ifc efc pgfortran pgf95 lf95 ftn/g;
$c =~ s/pgcc\* \| pgf77\* \| pgf90\* \| pgf95\*\)/pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)/g;
$c =~ s/pgf77\* \| pgf90\* \| pgf95\*\)/pgf77* | pgf90* | pgf95* | pgfortran*)/g;
# Similar issue as above -- the PGI 10 version number broke <=LT
# 2.2.6b's version number checking regexps. Again, we can't fix the
# Libtool install; all we can do is patch the resulting configure
# script. :-( The following comes from the upstream patch:
# http://lists.gnu.org/archive/html/libtool-patches/2009-11/msg00016.html
push(@verbose_out, $indent_str . "Patching configure for Libtool PGI version number regexps\n");
$c =~ s/\*pgCC\\ \[1-5\]\* \| \*pgcpp\\ \[1-5\]\*/*pgCC\\ [1-5]\.* | *pgcpp\\ [1-5]\.*/g;
# Similar issue as above -- fix the case statements that handle the Sun
# Fortran version strings.
#
# Note: we have to use octal escapes to match '*Sun\ F*) and the
# four succeeding lines in the bourne shell switch statement.
# \ = 134
# ) = 051
# * = 052
#
# Below is essentially an upstream patch for Libtool which we want
# made available to Open MPI users running older versions of Libtool
foreach my $tag (("", "_FC")) {
# We have to change the search pattern and substitution on each
# iteration to take into account the tag changing
my $search_string = '# icc used to be incompatible with GCC.\n\s+' .
'# ICC 10 doesn\047t accept -KPIC any more.\n.*\n\s+' .
"lt_prog_compiler_wl${tag}=";
my $replace_string = "# Flang compiler
*flang)
lt_prog_compiler_wl${tag}='-Wl,'
lt_prog_compiler_pic${tag}='-fPIC -DPIC'
lt_prog_compiler_static${tag}='-static'
;;
# icc used to be incompatible with GCC.
# ICC 10 doesn't accept -KPIC any more.
icc* | ifort*)
lt_prog_compiler_wl${tag}=";
push(@verbose_out, $indent_str . "Patching configure for flang Fortran ($tag)\n");
$c =~ s/$search_string/$replace_string/;
}
foreach my $tag (("", "_FC")) {
# We have to change the search pattern and substitution on each
# iteration to take into account the tag changing
my $search_string = '\052Sun\134 F\052.*\n.*\n\s+' .
"lt_prog_compiler_pic${tag}" . '.*\n.*\n.*\n.*\n';
my $replace_string = "
*Sun\\ Ceres\\ Fortran* | *Sun*Fortran*\\ [[1-7]].* | *Sun*Fortran*\\ 8.[[0-3]]*)
# Sun Fortran 8.3 passes all unrecognized flags to the linker
lt_prog_compiler_pic${tag}='-KPIC'
lt_prog_compiler_static${tag}='-Bstatic'
lt_prog_compiler_wl${tag}=''
;;
*Sun\\ F* | *Sun*Fortran*)
lt_prog_compiler_pic${tag}='-KPIC'
lt_prog_compiler_static${tag}='-Bstatic'
lt_prog_compiler_wl${tag}='-Qoption ld '
;;
";
push(@verbose_out, $indent_str . "Patching configure for Sun Studio Fortran version strings ($tag)\n");
$c =~ s/$search_string/$replace_string/;
}
foreach my $tag (("", "_FC")) {
# We have to change the search pattern and substitution on each
# iteration to take into account the tag changing
my $search_string = 'lf95\052.*# Lahey Fortran 8.1\n\s+' .
"whole_archive_flag_spec${tag}=" . '\n\s+' .
"tmp_sharedflag='--shared' ;;" . '\n\s+' .
'xl';
my $replace_string = "lf95*) # Lahey Fortran 8.1
whole_archive_flag_spec${tag}=
tmp_sharedflag='--shared' ;;
nagfor*) # NAGFOR 5.3
tmp_sharedflag='-Wl,-shared';;
xl";
push(@verbose_out, $indent_str . "Patching configure for NAG compiler ($tag)\n");
$c =~ s/$search_string/$replace_string/;
}
# Oracle has apparently begun (as of 12.5-beta) removing the "Sun" branding.
# So this patch (cumulative over the previous one) is required.
push(@verbose_out, $indent_str . "Patching configure for Oracle Studio Fortran version strings\n");
$c =~ s/\*Sun\*Fortran\*\)/*Sun*Fortran* | *Studio*Fortran*)/g;
$c =~ s/\*Sun\\ F\*\)(.*\n\s+tmp_sharedflag=)/*Sun\\ F* | *Studio*Fortran*)$1/g;
# See http://git.savannah.gnu.org/cgit/libtool.git/commit/?id=v2.2.6-201-g519bf91 for details
# Note that this issue was fixed in LT 2.2.8, however most distros are still using 2.2.6b
push(@verbose_out, $indent_str . "Patching configure for IBM xlf libtool bug\n");
$c =~ s/(\$LD -shared \$libobjs \$deplibs \$)compiler_flags( -soname \$soname)/$1linker_flags$2/g;
#Check if we are using a recent enough libtool that supports PowerPC little endian
if(index($c, 'powerpc64le-*linux*)') == -1) {
push(@verbose_out, $indent_str . "Patching configure for PowerPC little endian support\n");
my $replace_string = "x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*|";
$c =~ s/x86_64-\*kfreebsd\*-gnu\|x86_64-\*linux\*\|ppc\*-\*linux\*\|powerpc\*-\*linux\*\|/$replace_string/g;
$replace_string =
"powerpc64le-*linux*)\n\t LD=\"\${LD-ld} -m elf32lppclinux\"\n\t ;;\n\t powerpc64-*linux*)";
$c =~ s/ppc64-\*linux\*\|powerpc64-\*linux\*\)/$replace_string/g;
$replace_string =
"powerpcle-*linux*)\n\t LD=\"\${LD-ld} -m elf64lppc\"\n\t ;;\n\t powerpc-*linux*)";
$c =~ s/ppc\*-\*linux\*\|powerpc\*-\*linux\*\)/$replace_string/g;
}
# Fix consequence of broken libtool.m4
# see http://lists.gnu.org/archive/html/bug-libtool/2015-07/msg00002.html and
# https://github.com/open-mpi/ompi/issues/751
push(@verbose_out, $indent_str . "Patching configure for -L/-R libtool.m4 bug\n");
# patch for libtool < 2.4.3
$c =~ s/# Some compilers place space between "-\{L,R\}" and the path.\n # Remove the space.\n if test \$p = \"-L\" \|\|/# Some compilers place space between "-\{L,-l,R\}" and the path.\n # Remove the spaces.\n if test \$p = \"-L\" \|\|\n test \$p = \"-l\" \|\|/g;
# patch for libtool >= 2.4.3
$c =~ s/# Some compilers place space between "-\{L,R\}" and the path.\n # Remove the space.\n if test x-L = \"\$p\" \|\|\n test x-R = \"\$p\"\; then/# Some compilers place space between "-\{L,-l,R\}" and the path.\n # Remove the spaces.\n if test x-L = \"x\$p\" \|\|\n test x-l = \"x\$p\" \|\|\n test x-R = \"x\$p\"\; then/g;
# Fix OS X Big Sur (11.0.x) support
# From https://lists.gnu.org/archive/html/libtool-patches/2020-06/msg00001.html
push(@verbose_out, $indent_str . "Patching configure for MacOS Big Sur libtool.m4 bug\n");
# Some versions of Libtool use ${wl} consistently, but others did
# not (e.g., they used $wl). Make the regexp be able to handle
# both. Additionally, the case string searching for 10.[012]*
# changed over time. So make sure it can handle both of the case
# strings that we're aware of.
my $WL = '(\$\{wl\}|\$wl)';
my $SOMETIMES = '(\[,.\])*';
my $search_string = 'darwin\*\) # darwin 5.x on
# if running on 10.5 or later, the deployment target defaults
# to the OS version, if on x86, and 10.4, the deployment
# target defaults to 10.4. Don\'t you love it\?
case \$\{MACOSX_DEPLOYMENT_TARGET-10.0\},\$host in
10.0,\*86\*-darwin8\*\|10.0,\*-darwin\[91\]\*\)
_lt_dar_allow_undefined=\'' . $WL . '-undefined ' . $WL . 'dynamic_lookup\' ;;
10.\[012\]' . $SOMETIMES . '\*\)
_lt_dar_allow_undefined=\'' . $WL . '-flat_namespace ' . $WL . '-undefined ' . $WL . 'suppress\' ;;
10.\*\)';
my $replace_string = 'darwin*)
# Open MPI patched for Darwin / MacOS Big Sur. See
# http://lists.gnu.org/archive/html/bug-libtool/2015-07/msg00001.html
case ${MACOSX_DEPLOYMENT_TARGET},$host in
10.[012],*|,*powerpc*)
_lt_dar_allow_undefined=\'${wl}-flat_namespace ${wl}-undefined ${wl}suppress\' ;;
*)';
$c =~ s/$search_string/$replace_string/g;
# Only write out verbose statements and a new configure if the
# configure content actually changed
return
if ($c eq $c_orig);
foreach my $str (@verbose_out) {
verbose($str);
}
open(OUT, ">configure.patched") || my_die "Can't open configure.patched";
print OUT $c;
close(OUT);
# Use cp so that we preserve permissions on configure
safe_system("cp configure.patched configure");
unlink("configure.patched");
}
sub in_tarball {
my $tarball = 0;
open(IN, "VERSION") || my_die "Can't open VERSION";
# If repo_rev is not an empty string, we are in a tarball
while (<IN>) {
my $line = $_;
my @fields = split(/=/,$line);
if ($fields[0] eq "repo_rev") {
if ($fields[1] ne "\n") {
$tarball = 1;
last;
}
}
}
close(IN);
return $tarball;
}
##############################################################################
##############################################################################
## main - do the real work...
##############################################################################
##############################################################################
# Command line parameters
my $ok = Getopt::Long::GetOptions("no-ompi" => \$no_ompi_arg,
"no-orte" => \$no_orte_arg,
"no-oshmem" => \$no_oshmem_arg,
"quiet|q" => \$quiet_arg,
"debug|d" => \$debug_arg,
"help|h" => \$help_arg,
"platform=s" => \$platform_arg,
"include=s" => \$include_arg,
"exclude=s" => \$exclude_arg,
"force|f" => \$force_arg,
);
if (!$ok || $help_arg) {
print "Invalid command line argument.\n\n"
if (!$ok);
print "Options:
--no-ompi | -no-ompi Do not build the Open MPI layer
--no-orte | -no-orte Do not build the ORTE layer
--no-oshmem | -no-oshmem Do not build the OSHMEM layer
--quiet | -q Do not display normal verbose output
--debug | -d Output lots of debug information
--help | -h This help list
--platform | -p Specify a platform file to be parsed for no_build
and only_build directives
--include | -i Comma-separated list of framework-component pairs
to be exclusively built - i.e., all other components
will be ignored and only those specified will be marked
to build
--exclude | -e Comma-separated list of framework or framework-component
to be excluded from the build
--force | -f Run even if invoked from the source tree of an expanded
distribution tarball\n";
my_exit($ok ? 0 : 1);
}
#---------------------------------------------------------------------------
# Check for project existence
my $project_name_long = "Open MPI";
my $project_name_short = "openmpi";
if (! -e "ompi") {
$no_ompi_arg = 1;
debug "No ompi subdirectory found - will not build MPI layer\n";
}
if (! -e "orte") {
$no_orte_arg = 1;
debug "No orte subdirectory found - will not build ORTE\n";
}
if (! -e "oshmem") {
$no_oshmem_arg = 1;
debug "No oshmem subdirectory found - will not build OSHMEM\n";
}
if (-e "orcm") {
# bozo check - ORCM requires ORTE
if ($no_orte_arg == 1) {
print "Cannot build ORCM without ORTE\n";
my_exit(1);
}
$project_name_long = "Open Resilient Cluster Manager";
$project_name_short = "open-rcm";
} elsif ($no_ompi_arg == 1) {
if ($no_orte_arg == 0) {
$project_name_long = "Open MPI Run Time Environment";
$project_name_short = "open-rte";
} else {
$project_name_long = "Open Portability Access Layer";
$project_name_short = "open-pal";
}
}
#---------------------------------------------------------------------------
$full_hostname = `hostname`;
chomp($full_hostname);
$m4 = "dnl
dnl \$HEADER\$
dnl
$dnl_line
dnl This file is automatically created by autogen.pl; it should not
dnl be edited by hand!!
dnl
dnl Generated by $username at " . localtime($ENV{SOURCE_DATE_EPOCH} || time) . "
dnl on $full_hostname.
$dnl_line\n\n";
#---------------------------------------------------------------------------
# Verify that we're in the OMPI root directorty by checking for a token file.
my_die "Not at the root directory of an OMPI source tree"
if (! -f "config/opal_try_assemble.m4");
my_die "autogen.pl has been invoked in the source tree of an Open MPI distribution tarball; aborting...
You likely do not need to invoke \"autogen.pl\" -- you can probably run \"configure\" directly.
If you really know what you are doing, and really need to run autogen.pl, use the \"--force\" flag."
if (!$force_arg && in_tarball());
# Now that we've verified that we're in the top-level OMPI directory,
# set the sentinel file to remove if we abort.
$sentinel = Cwd::cwd() . "/configure";
#---------------------------------------------------------------------------
my $step = 1;
verbose "Open MPI autogen (buckle up!)
$step. Checking tool versions\n\n";
# Check the autotools revision levels
&find_and_check("autoconf", $ompi_autoconf_search, $ompi_autoconf_version);
&find_and_check("libtool", $ompi_libtoolize_search, $ompi_libtool_version);
&find_and_check("automake", $ompi_automake_search, $ompi_automake_version);
#---------------------------------------------------------------------------
# Save the platform file in the m4
$m4 .= "dnl Platform file\n";
# Process platform arg, if provided
if ($platform_arg) {
$m4 .= "m4_define([autogen_platform_file], [$platform_arg])\n\n";
open(IN, $platform_arg) || my_die "Can't open $platform_arg";
# Read all lines from the file
while (<IN>) {
my $line = $_;
my @fields = split(/=/,$line);
if ($fields[0] eq "enable_mca_no_build") {
if ($exclude_arg) {
print "The specified platform file includes an
enable_mca_no_build line. However, your command line
also contains an exclude specification. Only one of
these directives can be given.\n";
my_exit(1);
}
$exclude_arg = $fields[1];
} elsif ($fields[0] eq "enable_mca_only_build") {
if ($include_arg) {
print "The specified platform file includes an
enable_mca_only_build line. However, your command line
also contains an include specification. Only one of
these directives can be given.\n";
my_exit(1);
}
$include_arg = $fields[1];
}
}
close(IN);
} else {
# No platform file -- write an empty list
$m4 .= "m4_define([autogen_platform_file], [])\n\n";
}
if ($exclude_arg) {
debug "Using exclude list: $exclude_arg";
my @list = split(/,/, $exclude_arg);
foreach (@list) {
my @pairs = split(/-/, $_);
if (exists($pairs[1])) {
# Remove any trailing newlines
chomp($pairs[1]);
debug " Adding ".$pairs[0]."->".$pairs[1]." to exclude list\n";
push(@{$exclude_list->{$pairs[0]}}, $pairs[1]);
} else {
debug " Adding $pairs[0] to exclude list\n";
push(@{$exclude_list->{$pairs[0]}}, "AGEN_EXCLUDE_ALL");
}
}
}
if ($include_arg) {
debug "Using include list: $include_arg";
my @list = split(/,/, $include_arg);
foreach (@list) {
my @pairs = split(/-/, $_);
if (exists($pairs[1])) {
# Remove any trailing newlines
chomp($pairs[1]);
debug " Adding ".$pairs[0]."->".$pairs[1]." to include list\n";
push(@{$include_list->{$pairs[0]}}, $pairs[1]);
}
# NOTE: it makes no sense to include all as that is the default
# so ignore that scenario here, if given
}
}
#---------------------------------------------------------------------------
++$step;
verbose "\n$step. Running template-generating scripts\n\n";
# These scripts generate fortran header files of different types, but
# guaranteed to have the same value (i.e., so humans don't have to
# maintain two sets of files, and potentially have values get out of
# sync).
my @scripts;
push(@scripts, "ompi/include/mpif-values.pl");
foreach my $s (@scripts) {
verbose "=== $s\n";
if (! -x $s) {
print "Cannot find executable $s!\nAborting.\n";
my_exit(1);
}
if (system($s) != 0) {
print "Script failed: $s\n";
my_exit(1);
}
}
#---------------------------------------------------------------------------
# Find projects, frameworks, components
++$step;
verbose "\n$step. Searching for projects, MCA frameworks, and MCA components\n";
my $ret;
# Figure out if we're at the top level of the OMPI tree or not.
if (! (-f "VERSION" && -f "configure.ac" && -f $topdir_file)) {
print("\n\nYou must run this script from the top-level directory of the Open MPI tree.\n\n");
my_exit(1);
}
# Top-level projects to examine
my $projects;
push(@{$projects}, { name => "opal", dir => "opal", need_base => 1 });
push(@{$projects}, { name => "orte", dir => "orte", need_base => 1 })
if (!$no_orte_arg);
push(@{$projects}, { name => "ompi", dir => "ompi", need_base => 1 })
if (!$no_ompi_arg);
push(@{$projects}, { name => "oshmem", dir => "oshmem", need_base => 1 })
if (!$no_ompi_arg && !$no_orte_arg && !$no_oshmem_arg);
push(@{$projects}, { name => "orcm", dir => "orcm", need_base => 1 })
if (-e "orcm");
$m4 .= "dnl Separate m4 define for each project\n";
foreach my $p (@$projects) {
$m4 .= "m4_define([project_$p->{name}], [1])\n";
}
$m4 .= "\ndnl Project names
m4_define([project_name_long], [$project_name_long])
m4_define([project_name_short], [$project_name_short])\n";
# Setup MCA
mca_run_global($projects);
#---------------------------------------------------------------------------
# Find MPI extensions and contribs
if (!$no_ompi_arg) {
++$step;
verbose "\n$step. Searching for Open MPI extensions\n\n";
mpiext_run_global("ompi/mpiext");
++$step;
verbose "\n$step. Searching for Open MPI contribs\n\n";
mpicontrib_run_global("ompi/contrib");
}
#---------------------------------------------------------------------------
# Process all subdirs that we found in previous steps
++$step;
verbose "\n$step. Processing autogen.subdirs directories\n";
if ($#subdirs >= 0) {
foreach my $d (@subdirs) {
process_subdir($d);
}
} else {
print "<none found>\n";
}
#---------------------------------------------------------------------------
# If we got here, all was good. Run the auto tools.
++$step;
verbose "\n$step. Running autotools on top-level tree\n\n";
# Remove old versions of the files (this is probably overkill, but...)
verbose "==> Remove stale files\n";
find_and_delete(qw/config.guess config.sub depcomp compile install-sh ltconfig
ltmain.sh missing mkinstalldirs libtool/);
# Remove the old m4 file and write the new one
verbose "==> Writing m4 file with autogen.pl results\n";
unlink($m4_output_file);
open(M4, ">$m4_output_file") ||
my_die "Can't open $m4_output_file";
print M4 $m4;
close(M4);
# Generate the version checking script with autom4te
verbose "==> Generating opal_get_version.sh\n";
chdir("config");
safe_system("autom4te --language=m4sh opal_get_version.m4sh -o opal_get_version.sh");
# Run autoreconf
verbose "==> Running autoreconf\n";
chdir("..");
my $cmd = "autoreconf -ivf --warnings=all,no-obsolete,no-override -I config";
foreach my $project (@{$projects}) {
$cmd .= " -I $project->{dir}/config"
if (-d "$project->{dir}/config");
}
safe_system($cmd);
patch_autotools_output(".");
#---------------------------------------------------------------------------
verbose "
================================================
Open MPI autogen: completed successfully. w00t!
================================================\n\n";
# Done!
exit(0);
Показать git blame Копировать постоянную ссылку