def _compiler_info(self): command = os.path.basename(self['path']) role = Knowledgebase.find_role(self['role']) family = role.kbase.families[self['family']] info_list = Knowledgebase.find_compiler(command, family, role) if len(info_list) != 1: raise InternalError("Zero or more than one known compilers match '%s'" % self) return info_list[0]
def check_compiler(self, compiler_cmd, compiler_args): """Checks a compiler command its arguments for compatibility with this target configuration. Checks that the given compiler matches at least one, **but possibly more**, of the compilers used in the target. Also performs any special checkes for invalid compiler arguments, e.g. -mmic is only for native KNC. If the given compiler command and arguments are compatible with this target then information about matching compiler installations is returned as a list of n :any:`InstalledCompiler` instances. Args: compiler_cmd (str): The compiler command as passed by the user. compiler_args (list): Compiler command line arguments. Returns: list: Information about matching installed compilers as :any:`Compiler` instances. Raises: ConfigurationError: The compiler or command line arguments are incompatible with this target. """ if '-mmic' in compiler_args and self['host_arch'] != str(INTEL_KNC): raise ConfigurationError("Host architecture of target '%s' is '%s'" " but the '-mmic' compiler argument requires '%s'" % (self['name'], self['host_arch'], INTEL_KNC), "Select a different target", "Create a new target with host architecture '%s'" % INTEL_KNC) compiler_ctrl = Compiler.controller(self.storage) absolute_path = util.which(compiler_cmd) compiler_cmd = os.path.basename(compiler_cmd) found = [] known_compilers = [comp for comp in self.compilers().itervalues()] for info in Knowledgebase.find_compiler(command=compiler_cmd): try: compiler_record = self.populate(info.role.keyword) except KeyError: # Target was not configured with a compiler in this role continue compiler_path = compiler_record['path'] if (absolute_path and (compiler_path == absolute_path) or (not absolute_path and (os.path.basename(compiler_path) == compiler_cmd))): found.append(compiler_record) else: # Target was configured with a wrapper compiler so check if that wrapper wraps this compiler while 'wrapped' in compiler_record: compiler_record = compiler_ctrl.one(compiler_record['wrapped']) known_compilers.append(compiler_record.installation()) compiler_path = compiler_record['path'] if (absolute_path and (compiler_path == absolute_path) or (not absolute_path and (os.path.basename(compiler_path) == compiler_cmd))): found.append(compiler_record) break if not found: parts = ["No compiler in target '%s' matches '%s'." % (self['name'], absolute_path or compiler_cmd), "The known compiler commands are:"] parts.extend(' %s (%s)' % (comp.absolute_path, comp.info.short_descr) for comp in known_compilers) hints = ("Try one of the valid compiler commands", "Create and select a new target configuration that uses the '%s' compiler" % (absolute_path or compiler_cmd), "Check loaded modules and the PATH environment variable") raise ConfigurationError('\n'.join(parts), *hints) return found
def is_compatible(cmd): """Check if this subcommand can work with the given command. Args: cmd (str): A command from the command line, e.g. sys.argv[1]. Returns: bool: True if this subcommand is compatible with `cmd`. """ return os.path.basename(cmd) in [info.command for info in Knowledgebase.all_compilers()]
def is_compatible(cmd): """Check if this subcommand can work with the given command. Args: cmd (str): A command from the command line, e.g. sys.argv[1]. Returns: bool: True if this subcommand is compatible with `cmd`. """ return os.path.basename(cmd) in [ info.command for info in Knowledgebase.all_compilers() ]
def _construct_parser(self): parts = [' %s %s' % ('{:<15}'.format(comp.command), comp.short_descr) for comp in Knowledgebase.all_compilers()] epilog = "known compiler commands and their roles:\n%s\n" % '\n'.join(sorted(parts)) usage = "%s <command> [arguments]" % self.command parser = arguments.get_parser(prog=self.command, usage=usage, description=self.summary, epilog=epilog) parser.add_argument('cmd', help="Compiler or linker command, e.g. 'gcc'", metavar='<command>') parser.add_argument('cmd_args', help="Compiler arguments", metavar='[arguments]', nargs=arguments.REMAINDER) return parser
def _construct_parser(self): parts = [ ' %s %s' % ('{:<15}'.format(comp.command), comp.short_descr) for comp in Knowledgebase.all_compilers() ] epilog = "known compiler commands and their roles:\n%s\n" % '\n'.join( sorted(parts)) usage = "%s <command> [arguments]" % self.command parser = arguments.get_parser(prog=self.command, usage=usage, description=self.summary, epilog=epilog) parser.add_argument('cmd', help="Compiler or linker command, e.g. 'gcc'", metavar='<command>') parser.add_argument('cmd_args', help="Compiler arguments", metavar='[arguments]', nargs=arguments.REMAINDER) return parser
def compilers(self): """Get information about the compilers used by this target configuration. Returns: InstalledCompilerSet: Collection of installed compilers used by this target. """ if not self._compilers: eids = [] compilers = {} for role in Knowledgebase.all_roles(): try: with fasteners.InterProcessLock(os.path.join(PROJECT_STORAGE.prefix, '.lock')): compiler_record = self.populate(role.keyword) except KeyError: continue compilers[role.keyword] = compiler_record.installation() LOGGER.debug("compilers[%s] = '%s'", role.keyword, compilers[role.keyword].absolute_path) eids.append(compiler_record.eid) self._compilers = InstalledCompilerSet('_'.join([str(x) for x in sorted(eids)]), **compilers) return self._compilers
def compilers(self): """Get information about the compilers used by this target configuration. Returns: InstalledCompilerSet: Collection of installed compilers used by this target. """ if not self._compilers: eids = [] compilers = {} for role in Knowledgebase.all_roles(): try: with fasteners.InterProcessLock( os.path.join(PROJECT_STORAGE.prefix, '.lock')): compiler_record = self.populate(role.keyword) except KeyError: continue compilers[role.keyword] = compiler_record.installation() LOGGER.debug("compilers[%s] = '%s'", role.keyword, compilers[role.keyword].absolute_path) eids.append(compiler_record.eid) self._compilers = InstalledCompilerSet( '_'.join([str(x) for x in sorted(eids)]), **compilers) return self._compilers
# # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # """CUDA compiler knowledgebase.""" from taucmdr.cf.compiler import Knowledgebase CUDA_COMPILERS = Knowledgebase('CUDA', 'Compilers supporting CUDA', CXX=('CUDA', 'CU'), FC=('CUDA Fortran', 'CUF')) NVIDIA = CUDA_COMPILERS.add('NVIDIA', CXX='nvcc') IBM = CUDA_COMPILERS.add('IBM', family_regex=r'^IBM XL', version_flags=['-qversion'], FC='xlcuf') CUDA_CXX = CUDA_COMPILERS.roles['CXX'] CUDA_FC = CUDA_COMPILERS.roles['FC']
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # """SHMEM compiler knowledgebase. Keep a separate knowledge base for SHMEM compilers to simplify compiler identification and because TAU doesn't require SHMEM for all configurations. """ from taucmdr.cf.compiler import Knowledgebase SHMEM_COMPILERS = Knowledgebase( 'SHMEM', 'Compilers supporting Symmetric Hierarchical Memory', CC=('SHMEM C', 'SHMEM_CC'), CXX=('SHMEM C++', 'SHMEM_CXX'), FC=('SHMEM Fortran', ('SHMEM_FC', 'SHMEM_F77', 'SHMEM_F90'))) OPENSHMEM = SHMEM_COMPILERS.add('OpenSHMEM', CC='oshcc', CXX=('oshcxx', 'oshc++', 'oshCC'), FC='oshfort') SOS = SHMEM_COMPILERS.add('SOS', show_wrapper_flags=['-show'], CC='oshcc', CXX=('oshc++', 'oshCC'), FC='oshfort') CRAY_SHMEM = SHMEM_COMPILERS.add(
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # """SHMEM compiler knowledgebase. Keep a separate knowledge base for SHMEM compilers to simplify compiler identification and because TAU doesn't require SHMEM for all configurations. """ from taucmdr.cf.compiler import Knowledgebase SHMEM_COMPILERS = Knowledgebase('SHMEM', 'Compilers supporting Symmetric Hierarchical Memory', CC=('SHMEM C', 'SHMEM_CC'), CXX=('SHMEM C++', 'SHMEM_CXX'), FC=('SHMEM Fortran', ('SHMEM_FC', 'SHMEM_F77', 'SHMEM_F90'))) OPENSHMEM = SHMEM_COMPILERS.add('OpenSHMEM', CC='oshcc', CXX=('oshcxx', 'oshc++', 'oshCC'), FC='oshfort') SOS = SHMEM_COMPILERS.add('SOS', show_wrapper_flags=['-show'], CC='oshcc', CXX=('oshc++', 'oshCC'), FC='oshfort') CRAY_SHMEM = SHMEM_COMPILERS.add('Cray', family_regex=r'-I.*cray', version_flags=['-craype-verbose', '--version', '-E'], show_wrapper_flags=['-craype-verbose', '--version', '-E'], CC='cc', CXX='CC', FC='ftn') SHMEM_CC = SHMEM_COMPILERS.roles['CC']
# be used to endorse or promote products derived from this software without # specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # """CUDA compiler knowledgebase.""" from taucmdr.cf.compiler import Knowledgebase CUDA_COMPILERS = Knowledgebase('CUDA', 'Compilers supporting CUDA', CXX=('CUDA', 'CU'), FC=('CUDA Fortran', 'CUF')) NVIDIA = CUDA_COMPILERS.add('NVIDIA', CXX='nvcc') IBM = CUDA_COMPILERS.add('IBM', family_regex=r'^IBM XL', version_flags=['-qversion'], FC='xlcuf') CUDA_CXX = CUDA_COMPILERS.roles['CXX'] CUDA_FC = CUDA_COMPILERS.roles['FC']
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # """ Python Interpreter Knowledgebase (implemented using the compiler classes) """ from taucmdr.cf.compiler import Knowledgebase PYTHON_INTERPRETERS = Knowledgebase( 'python', 'Compilers targeting different versions of Python', PY=('python', 'python') # language: python, envars: python ) PYTHON2 = PYTHON_INTERPRETERS.add('PY2_INTERPRETER', family_regex=r'^Python 2', version_flags=['--version'], PY=('python2', 'python')) PYTHON3 = PYTHON_INTERPRETERS.add('PY3_INTERPRETER', family_regex=r'^Python 3', version_flags=['--version'], PY=('python3', 'python')) PY = PYTHON_INTERPRETERS.roles['PY']
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # """Host CPU compiler knowledgebase. These are the principal compilers used by the system and **must** be identified to successfully configure and install TAU. """ from taucmdr.cf.compiler import Knowledgebase HOST_COMPILERS = Knowledgebase('Host', 'Compilers targeting the host CPU', CC=('C', 'CC'), CXX=('C++', 'CXX'), FC=('Fortran', ('FC', 'F77', 'F90')), UPC=('Universal Parallel C', 'UPC')) SYSTEM = HOST_COMPILERS.add('System', CC='cc', CXX=('c++', 'cxx', 'CC'), FC=('ftn', 'f90', 'f77'), UPC='upc') GNU = HOST_COMPILERS.add('GNU', family_regex=r'Free Software Foundation, Inc', CC='gcc', CXX='g++', FC=('gfortran', 'g77'), UPC='gupc')
# (3) Neither the name of ParaTools, Inc. nor the names of its contributors may # be used to endorse or promote products derived from this software without # specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # """CAF compiler knowledgebase. We keep a separate knowledge base for CAF compilers to simplify compiler identification and because TAU doesn't require CAF for all configurations. """ from taucmdr.cf.compiler import Knowledgebase CAF_COMPILERS = Knowledgebase('CAF', 'Compilers supporting Coarray Fortran', FC=('Coarray Fortran', ('FC', 'F77', 'F90'))) SYSTEM = CAF_COMPILERS.add('System', show_wrapper_flags=['-show'], FC='caf') CAF_FC = CAF_COMPILERS.roles['FC']
def _parse_tau_makefile(self, args): # Parsing a TAU Makefile is a really hairy operation, so let's lift the limits # pylint: disable=too-many-statements,too-many-locals makefile = args.forced_makefile if not util.path_accessible(makefile): self.parser.error("Invalid TAU makefile: %s" % makefile) tau_arch_name = os.path.basename( os.path.dirname(os.path.dirname(makefile))) matches = [ arch for arch in TauMagic.all() if arch.name == tau_arch_name ] if len(matches) == 1: tau_arch = matches[0] elif not matches: raise ConfigurationError( "TAU Makefile '%s' targets an unrecognized TAU architecture: %s" % (makefile, tau_arch_name)) else: for arch in matches: if arch.architecture == HOST_ARCH and arch.operating_system == HOST_OS: tau_arch = arch break else: parts = [ "TAU Makefile '%s' targets an ambiguous TAU architecture: %s" % (makefile, tau_arch_name), "It could be any of these:" ] parts.extend([ " - %s on %s" % (arch.operating_system.name, arch.architecture.name) for arch in matches ]) raise ConfigurationError("\n".join(parts)) self.logger.info( "Parsing TAU Makefile '%s' to populate command line arguments:", makefile) args.host_arch = tau_arch.architecture.name self.logger.info(" --host-arch='%s'", args.host_arch) args.host_os = tau_arch.operating_system.name self.logger.info(" --host-os='%s'", args.host_os) args.tau_source = os.path.abspath( os.path.join(os.path.dirname(makefile), '..', '..')) self.logger.info(" --taucmdr='%s'", args.tau_source) with open(makefile, 'r') as fin: compiler_parts = ("FULL_CC", "FULL_CXX", "TAU_F90") package_parts = { "BFDINCLUDE": ("binutils_source", lambda x: os.path.dirname(shlex.split(x)[0].lstrip("-I"))), "UNWIND_INC": ("libunwind_source", lambda x: os.path.dirname(x.lstrip("-I"))), "PAPIDIR": ("papi_source", os.path.abspath), "PDTDIR": ("pdt_source", os.path.abspath), "SCOREPDIR": ("scorep_source", os.path.abspath) } tau_r = '' for line in fin: if line.startswith('#'): continue try: key, val = [x.strip() for x in line.split('=', 1)] except ValueError: continue if key == 'TAU_R': tau_r = val.split()[0] elif key in compiler_parts: path = util.which(val.strip().split()[0].replace( '$(TAU_R)', tau_r)) if not path: self.logger.warning( "Failed to parse %s in TAU Makefile '%s'", key, makefile) continue matching_info = Knowledgebase.find_compiler( os.path.basename(path)) if matching_info: if len(matching_info) > 1: self.logger.warning( "Ambiguous compiler '%s' in TAU Makefile '%s'", path, makefile) comp = InstalledCompiler(path, matching_info[0]) attr = comp.info.role.keyword setattr(args, attr, comp.absolute_path) self.logger.info(" --%s='%s'", attr.lower().replace("_", "-"), comp.absolute_path) while comp.wrapped: comp = comp.wrapped attr = comp.info.role.keyword setattr(args, attr, comp.absolute_path) self.logger.info(" --%s='%s'", attr.lower().replace("_", "-"), comp.absolute_path) elif key in package_parts: attr, operator = package_parts[key] path = val.strip() if not path: path = None else: path = operator(path) if not os.path.exists(path): self.logger.warning( "'%s' referenced by TAU Makefile '%s' doesn't exist", path, makefile) continue setattr(args, attr, path) self.logger.info(" --%s='%s'", attr.replace("_source", ""), path)
def check_compiler(self, compiler_cmd, compiler_args): """Checks a compiler command its arguments for compatibility with this target configuration. Checks that the given compiler matches at least one, **but possibly more**, of the compilers used in the target. Also performs any special checkes for invalid compiler arguments, e.g. -mmic is only for native KNC. If the given compiler command and arguments are compatible with this target then information about matching compiler installations is returned as a list of n :any:`InstalledCompiler` instances. Args: compiler_cmd (str): The compiler command as passed by the user. compiler_args (list): Compiler command line arguments. Returns: list: Information about matching installed compilers as :any:`Compiler` instances. Raises: ConfigurationError: The compiler or command line arguments are incompatible with this target. """ if '-mmic' in compiler_args and self['host_arch'] != str(INTEL_KNC): raise ConfigurationError( "Host architecture of target '%s' is '%s'" " but the '-mmic' compiler argument requires '%s'" % (self['name'], self['host_arch'], INTEL_KNC), "Select a different target", "Create a new target with host architecture '%s'" % INTEL_KNC) compiler_ctrl = Compiler.controller(self.storage) absolute_path = util.which(compiler_cmd) compiler_cmd = os.path.basename(compiler_cmd) found = [] known_compilers = [comp for comp in self.compilers().itervalues()] for info in Knowledgebase.find_compiler(command=compiler_cmd): try: compiler_record = self.populate(info.role.keyword) except KeyError: # Target was not configured with a compiler in this role continue compiler_path = compiler_record['path'] if (absolute_path and (compiler_path == absolute_path) or (not absolute_path and (os.path.basename(compiler_path) == compiler_cmd))): found.append(compiler_record) else: # Target was configured with a wrapper compiler so check if that wrapper wraps this compiler while 'wrapped' in compiler_record: compiler_record = compiler_ctrl.one( compiler_record['wrapped']) known_compilers.append(compiler_record.installation()) compiler_path = compiler_record['path'] if (absolute_path and (compiler_path == absolute_path) or (not absolute_path and (os.path.basename(compiler_path) == compiler_cmd))): found.append(compiler_record) break if not found: parts = [ "No compiler in target '%s' matches '%s'." % (self['name'], absolute_path or compiler_cmd), "The known compiler commands are:" ] parts.extend(' %s (%s)' % (comp.absolute_path, comp.info.short_descr) for comp in known_compilers) hints = ( "Try one of the valid compiler commands", "Create and select a new target configuration that uses the '%s' compiler" % (absolute_path or compiler_cmd), "Check loaded modules and the PATH environment variable") raise ConfigurationError('\n'.join(parts), *hints) return found
# """MPI compiler knowledgebase. MPI compilers are a special case for several reasons including: 1) No binary compatibility guarantee among MPI compilers. 2) They're almost always wrappers, not actual compilers. 3) They almost always depend on CPU compilers. We keep a separate knowledge base for MPI compilers to simplify compiler identification and because TAU doesn't require MPI for all configurations. """ from taucmdr.cf.compiler import Knowledgebase MPI_COMPILERS = Knowledgebase('MPI', 'Compilers supporting the Message Passing Interface (MPI)', CC=('MPI C', 'MPI_CC'), CXX=('MPI C++', 'MPI_CXX'), FC=('MPI Fortran', ('MPI_FC', 'MPI_F77', 'MPI_F90'))) SYSTEM = MPI_COMPILERS.add('System', show_wrapper_flags=['-show'], CC='mpicc', CXX=('mpic++', 'mpicxx', 'mpiCC'), FC=('mpiftn', 'mpif90', 'mpif77', 'mpifort')) INTEL = MPI_COMPILERS.add('Intel', show_wrapper_flags=['-show'], CC='mpiicc', CXX='mpiicpc', FC='mpiifort') IBM = MPI_COMPILERS.add('IBM', family_regex=r'^IBM XL', version_flags=['-qversion'], show_wrapper_flags=['-show'],
def _parse_tau_makefile(self, args): # Parsing a TAU Makefile is a really hairy operation, so let's lift the limits # pylint: disable=too-many-statements,too-many-locals makefile = args.forced_makefile if not util.path_accessible(makefile): self.parser.error("Invalid TAU makefile: %s" % makefile) tau_arch_name = os.path.basename(os.path.dirname(os.path.dirname(makefile))) matches = [arch for arch in TauMagic.all() if arch.name == tau_arch_name] if len(matches) == 1: tau_arch = matches[0] elif len(matches) == 0: raise ConfigurationError("TAU Makefile '%s' targets an unrecognized TAU architecture: %s" % (makefile, tau_arch_name)) else: for arch in matches: if arch.architecture == HOST_ARCH and arch.operating_system == HOST_OS: tau_arch = arch break else: parts = ["TAU Makefile '%s' targets an ambiguous TAU architecture: %s" % (makefile, tau_arch_name), "It could be any of these:"] parts.extend([" - %s on %s" % (arch.operating_system.name, arch.architecture.name) for arch in matches]) raise ConfigurationError("\n".join(parts)) self.logger.info("Parsing TAU Makefile '%s' to populate command line arguments:", makefile) args.host_arch = tau_arch.architecture.name self.logger.info(" --host-arch='%s'", args.host_arch) args.host_os = tau_arch.operating_system.name self.logger.info(" --host-os='%s'", args.host_os) args.tau_source = os.path.abspath(os.path.join(os.path.dirname(makefile), '..', '..')) self.logger.info(" --taucmdr='%s'", args.tau_source) with open(makefile, 'r') as fin: compiler_parts = ("FULL_CC", "FULL_CXX", "TAU_F90") package_parts = {"BFDINCLUDE": ("binutils_source", lambda x: os.path.dirname(x.lstrip("-I"))), "UNWIND_INC": ("libunwind_source", lambda x: os.path.dirname(x.lstrip("-I"))), "PAPIDIR": ("papi_source", os.path.abspath), "PDTDIR": ("pdt_source", os.path.abspath), "SCOREPDIR": ("scorep_source", os.path.abspath)} tau_r = '' for line in fin: if line.startswith('#'): continue try: key, val = [x.strip() for x in line.split('=', 1)] except ValueError: continue if key == 'TAU_R': tau_r = val.split()[0] elif key in compiler_parts: path = util.which(val.strip().split()[0].replace('$(TAU_R)', tau_r)) if not path: self.logger.warning("Failed to parse %s in TAU Makefile '%s'", key, makefile) continue matching_info = Knowledgebase.find_compiler(os.path.basename(path)) if matching_info: if len(matching_info) > 1: self.logger.warning("Ambiguous compiler '%s' in TAU Makefile '%s'", path, makefile) comp = InstalledCompiler(path, matching_info[0]) attr = comp.info.role.keyword setattr(args, attr, comp.absolute_path) self.logger.info(" --%s='%s'", attr.lower().replace("_", "-"), comp.absolute_path) while comp.wrapped: comp = comp.wrapped attr = comp.info.role.keyword setattr(args, attr, comp.absolute_path) self.logger.info(" --%s='%s'", attr.lower().replace("_", "-"), comp.absolute_path) elif key in package_parts: attr, operator = package_parts[key] path = val.strip() if not path: path = None else: path = operator(path) if not os.path.exists(path): self.logger.warning("'%s' referenced by TAU Makefile '%s' doesn't exist", path, makefile) continue setattr(args, attr, path) self.logger.info(" --%s='%s'", attr.replace("_source", ""), path)