dolfin team mailing list archive

[Anders Logg <logg@xxxxxxxxx>]

On Wed, Aug 20, 2008 at 12:02:57PM -0500, Matthew Knepley wrote:
> On Wed, Aug 20, 2008 at 11:54 AM, Marie Rognes <meg@xxxxxxxxxxx> wrote:
> > Jed Brown wrote:
> >> On Wed 2008-08-20 17:35, Marie Rognes wrote:
> >>
> >>> Matthew Knepley wrote:
> >>>
> >>>> On Wed, Aug 20, 2008 at 5:08 AM, Garth N. Wells <gnw20@xxxxxxxxx> wrote:
> >>>>
> >>>>
> >>>>> Marie Rognes wrote:
> >>>>>
> >>>>>
> >>>>>> Garth N. Wells wrote:
> >>>>>>
> >>>>>>
> >>>>>>> Marie Rognes wrote:
> >>>>>>>
> >>>>>>>
> >>>>>>>> I'm trying to compile dolfin with PETSc and SLEPc, but without MPI:
> >>>>>>>>
> >>>>>>>>      ./scons.local enableMpi=no withPetscDir=$PETSC_DIR
> >>>>>>>>     withSlepcDir=$SLEPC_DIR
> >>>>>>>>
> >>>>>>>> This gives the following error:
> >>>>>>>>
> >>>>>>>>
> >>>>>>>>
> >>>>>>> Hopefully this is fixed now, although my PETSc is built with MPI, so I
> >>>>>>> can't be sure. Let me know if it's ok or otherwise.
> >>>>>>>
> >>>>>>>
> >>>>>> I get through the compilation stage now, so that's good :)
> >>>>>>
> >>>>>> However, if I try to "import dolfin", I get:
> >>>>>>
> >>>>>>        Python 2.5.2 (r252:60911, Jun 19 2008, 15:12:17)
> >>>>>>    [GCC 4.1.2 (Gentoo 4.1.2 p1.0.2)] on linux2
> >>>>>>    Type "help", "copyright", "credits" or "license" for more information.
> >>>>>>     >>> import dolfin
> >>>>>>    Traceback (most recent call last):
> >>>>>>      File "<stdin>", line 1, in <module>
> >>>>>>      File
> >>>>>>
> >>>>>> "/home/meg/src/dolfin/dolfin/local/lib/python2.5/site-packages/dolfin/__init__.py",
> >>>>>>
> >>>>>>    line 13, in <module>
> >>>>>>        from assemble import *
> >>>>>>      File
> >>>>>>
> >>>>>> "/home/meg/src/dolfin/dolfin/local/lib/python2.5/site-packages/dolfin/assemble.py",
> >>>>>>
> >>>>>>    line 22, in <module>
> >>>>>>        from dolfin import *
> >>>>>>      File
> >>>>>>
> >>>>>> "/home/meg/src/dolfin/dolfin/local/lib/python2.5/site-packages/dolfin/dolfin.py",
> >>>>>>
> >>>>>>    line 7, in <module>
> >>>>>>        import _dolfin
> >>>>>>    ImportError: /home/meg/src/dolfin/dolfin/local/lib/libdolfin.so:
> >>>>>>    undefined symbol: MPIUNI_TMP
> >>>>>>
> >>>>>>
> >>>>>>
> >>>>> Looks like a linking problem to PETSc. Can you compile C++ DOLFIN programs?
> >>>>>
> >>>>>
> >>>>
> >>>>
> >>> Nope. The cpp poisson demo gives:
> >>>
> >>> meg in cpp >> scons
> >>> scons: Reading SConscript files ...
> >>> scons: done reading SConscript files.
> >>> scons: Building targets ...
> >>> c++ -o main.o -c -Wall -pipe -ansi -g -Werror -O2 -fno-strict-aliasing
> >>> -pthread -DDEBUG -DNDEBUG -DPACKAGE_VERSION="0.8.0" -DHAS_PETSC=1
> >>> -DHAS_SLEPC=1 -DHAS_UMFPACK=1 -DHAS_GTS=1
> >>> -I/home/meg/src/dolfin/dolfin/local/include
> >>> -I/usr/lib/python2.5/site-packages/numpy/core/include
> >>> -I/home/meg/src/slepc -I/home/meg/src/slepc/include
> >>> -I/usr/include/python2.5 -I/home/meg/src/petsc/bmake/linux-gnu-c-debug
> >>> -I/home/meg/src/petsc/include
> >>> -I/home/meg/src/petsc-2.3.3-p13/include/mpiuni -I/usr/include/libxml2
> >>> -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include main.cpp
> >>> c++ -o demo -Wl,-rpath,/home/meg/src/slepc/lib/linux-gnu-c-debug
> >>> -Wl,-rpath,/home/meg/src/petsc/lib/linux-gnu-c-debug -pthread
> >>> -Wl,--export-dynamic main.o -L/home/meg/src/dolfin/dolfin/local/lib
> >>> -L/home/meg/src/slepc/lib/linux-gnu-c-debug -L/usr/lib/atlas
> >>> -L/home/meg/src/petsc/lib/linux-gnu-c-debug -ldolfin -lslepc -lblas
> >>> -lumfpack -lamd -lgts -lxml2 -lpetscts -lpetscsnes -lpetscksp -lpetscdm
> >>> -lpetscmat -lpetscvec -lpetsc -lgthread-2.0 -lrt -lgmodule-2.0 -ldl
> >>> -lglib-2.0
> >>> /home/meg/src/dolfin/dolfin/local/lib/libdolfin.so: undefined reference
> >>> to `Petsc_MPI_Abort'
> >>>
> >>>
> >>>> Almost  certainly it is an incomplete link line when libdolfin.so is
> >>>> constructed. When PETSc
> >>>> is built without MPI, it creates an extra library (libmpiuni) which
> >>>> must be linked against to
> >>>> get these symbols.
> >>>>
> >>>>
> >>> I'm not quite sure what that implies... But, I should somehow add
> >>> -lmpiuni when linking dolfin? For instance in the pkgconfig file scons
> >>> creates for petsc?
> >>>
> >>
> >> What does the it look like when you build a PETSc demo?  What should be
> >> on the `Libs:' line of petsc.pc is the result of the following:
> >>
> >> echo -e 'include ${PETSC_DIR}/bmake/common/base\nlink:\n\t-@echo ${PETSC_LIB}' | make PETSC_DIR=~/usr/petsc-2* PETSC_ARCH=ompic-opt -f - link
> >>
> >> It will probably be ugly and often has lots of repetition for no
> >> apparent reason.  However, it should be reliable.
> >>
> >
> >
> > Hurray! My DOLFIN is back among the living. (Now, I just need to get it
> > to understand that SLEPc is hanging around as well.)
> >
> > Just adding -lmpiuni to petsc.pc did not help. Adding the output of
> >
> >    echo -e 'include ${PETSC_DIR}/bmake/common/base\nlink:\n\t-@echo
> > ${PETSC_LIB}' |     make -f - link
> >
> > did. Thanks a lot!
> >
> > However, there should probably be a prettier way of doing this?
> 
> Yes, of course. The prettier way is to actually use the information we give
> 
>   1) at the end of configure
> 
>   2) in the configure.log
> 
>   3) in RDict.db (Python pickle)
> 
>   4) in the makefile (make getincludedirs, make getlinklibs)
> 
>   5) in the conf files (petscvariables, petsconf.h)
> 
> instead of ignoring it and hardcoding something into scons.
> 
>   Matt

We don't. We get the include and link flags from the PETSc Makefiles.
I've attached the pkgconfig generator for PETSc. Take a look at it.

-- 
Anders

#!/usr/bin/env python
import os,sys
import string
import os.path
import commands

from commonPkgConfigUtils import *

def getPetscVariables(variables=('includes','libs','compiler','linker'), sconsEnv=None):
  if isinstance(variables, str):
    variables = (variables,)
  filename = "petsc_makefile"
  arch = get_architecture()
  # Create a makefile to read basic things from PETSc
  petsc_makefile_str="""
# Retrive various flags from PETSc settings.

PETSC_DIR=%s

include ${PETSC_DIR}/bmake/common/variables

get_petsc_include:
	-@echo  -I${PETSC_DIR}/bmake/${PETSC_ARCH} -I${PETSC_DIR}/include ${MPI_INCLUDE}

get_petsc_libs:
	-@echo   ${C_SH_LIB_PATH} -L${PETSC_LIB_DIR} ${PETSC_LIB_BASIC}

get_petsc_cc:
	-@echo ${PCC}

get_petsc_ld:
	-@echo ${PCC_LINKER}
""" % getPetscDir(sconsEnv=sconsEnv)
  petsc_make_file = open(filename, "w")
  petsc_make_file.write(petsc_makefile_str)
  petsc_make_file.close()

  petsc_includes = None
  if 'includes' in variables: 
    cmdstr = "make -s -f %s get_petsc_include" % filename
    runFailed, cmdoutput = commands.getstatusoutput(cmdstr)
    if runFailed:
      os.unlink(filename)
      msg = "Unable to read PETSc includes through make."
      raise UnableToXXXException(msg, errormsg=cmdoutput)
    petsc_includes = cmdoutput

  petsc_libs = None
  if 'libs' in variables:
    cmdstr = "make -s -f %s get_petsc_libs" % filename
    runFailed, cmdoutput = commands.getstatusoutput(cmdstr)
    if runFailed:
      os.unlink(filename)
      msg = "Unable to read PETSc libs through make."
      raise UnableToXXXException(msg, errormsg=cmdoutput)
    petsc_libs = cmdoutput

  petsc_cc = None
  if 'compiler' in variables:
    cmdstr = "make -s -f %s get_petsc_cc" % filename
    runFailed, cmdoutput = commands.getstatusoutput(cmdstr)
    if runFailed:
      os.unlink(filename)
      msg = "Unable to figure out correct PETSc compiler."
      raise UnableToXXXException(msg, errormsg=cmdoutput)
    # We probably get a c-compiler from the petsc config, switch to a 
    # compatible c++
    petsc_cc = cmdoutput
    if not is_cxx_compiler(petsc_cc):
      petsc_cc = get_alternate_cxx_compiler(petsc_cc, arch=arch)

  petsc_ld = None
  if 'linker' in variables:
    cmdstr = "make -s -f %s get_petsc_ld" % filename
    runFailed, cmdoutput = commands.getstatusoutput(cmdstr)
    if runFailed:
      os.unlink(filename)
      msg = "Unable to figure out correct PETSc linker"
      raise UnableToXXXException(msg, errormsg=cmdoutput)
    # We probably get a c-compiler from the petsc config, switch to a 
    # compatible c++
    petsc_ld = cmdoutput
    if not is_cxx_compiler(petsc_ld):
      petsc_ld = get_alternate_cxx_compiler(petsc_ld, arch=arch)

  os.unlink(filename)

  ret = []
  for variable in petsc_includes, petsc_libs, petsc_cc, petsc_ld:
    if variable is not None:
      ret.append(variable)
  return ret

def getPetscDir(sconsEnv=None):
    petsc_dir = getPackageDir("petsc", sconsEnv=sconsEnv, default=None)
    if not petsc_dir:
        petsc_locations = ["/usr/lib/petscdir/2.3.3"]
        for petsc_location in petsc_locations:
            if os.access(petsc_location, os.F_OK) == True:
                return petsc_location
        raise UnableToFindPackageException("PETSc")
    return petsc_dir

def pkgVersion(compiler=None, linker=None, cflags=None, libs=None, sconsEnv=None):
  cpp_test_version_str = r"""
#include <stdio.h>
#include <petsc.h>

int main() {
  #ifdef PETSC_VERSION_MAJOR
    #ifdef PETSC_VERSION_MINOR
      #ifdef PETSC_VERSION_SUBMINOR
        printf("%d.%d.%d", PETSC_VERSION_MAJOR, PETSC_VERSION_MINOR, PETSC_VERSION_SUBMINOR);
      #else
        printf("%d.%d", PETSC_VERSION_MAJOR, PETSC_VERSION_MINOR);
      #endif
    #else
      printf("%d", PETSC_VERSION_MAJOR);
    #endif
  #endif
  return 0;
}
"""
  write_cppfile(cpp_test_version_str, "petsc_config_test_version.cpp");

  if not compiler:
    compiler = pkgCompiler(sconsEnv=sconsEnv)
  if not linker:
    linker = pkgLinker(sconsEnv=sconsEnv)
  if not cflags:
    cflags = pkgCflags(sconsEnv=sconsEnv)
  if not libs:
    libs = pkgLibs(sconsEnv=sconsEnv)

  cmdstr = "%s %s -c petsc_config_test_version.cpp" % (compiler, cflags)
  compileFailed, cmdoutput = commands.getstatusoutput(cmdstr)
  if compileFailed:
    remove_cppfile("petsc_config_test_version.cpp")
    raise UnableToCompileException("PETSc", cmd=cmdstr,
                                   program=cpp_test_version_str, errormsg=cmdoutput)
  cmdstr = "%s %s petsc_config_test_version.o" % (linker, libs)
  linkFailed, cmdoutput = commands.getstatusoutput(cmdstr)
  if linkFailed:
    remove_cppfile("petsc_config_test_version.cpp", ofile=True)
    raise UnableToLinkException("PETSc", cmd=cmdstr,
                                program=cpp_test_version_str, errormsg=cmdoutput)
  runFailed, cmdoutput = commands.getstatusoutput("./a.out")
  if runFailed:
    remove_cppfile("petsc_config_test_version.cpp", ofile=True, execfile=True)
    raise UnableToRunException("PETSc", errormsg=cmdoutput)
  petsc_version = cmdoutput

  remove_cppfile("petsc_config_test_version.cpp", ofile=True, execfile=True)
  return petsc_version

def pkgLibs(sconsEnv=None):
  libs, = getPetscVariables(variables='libs', sconsEnv=sconsEnv)
  return libs

def pkgCflags(sconsEnv=None):
  includes, = getPetscVariables(variables='includes', sconsEnv=sconsEnv)
  return includes

def pkgCompiler(sconsEnv=None):
  compiler, = getPetscVariables(variables='compiler', sconsEnv=sconsEnv)
  if not compiler:
    compiler = get_compiler(sconsEnv)
  return compiler

def pkgLinker(sconsEnv=None):
  linker, = getPetscVariables(variables='linker', sconsEnv=sconsEnv)
  if not linker:
    linker = get_linker(sconsEnv)
  return linker

def pkgTests(forceCompiler=None, sconsEnv=None,
             cflags=None, libs=None, version=None, **kwargs):
  """Run the tests for this package.
     
     If Ok, return various variables, if not we will end with an exception.
     forceCompiler, if set, should be a tuple containing (compiler, linker)
     or just a string, which in that case will be used as both.
  """
  if not cflags:
    cflags = pkgCflags(sconsEnv=sconsEnv)
  if not libs:
    libs = pkgLibs(sconsEnv=sconsEnv)

  if not forceCompiler:
    compiler = pkgCompiler(sconsEnv=sconsEnv)
    linker = pkgLinker(sconsEnv=sconsEnv)
  else:
    compiler, linker = set_forced_compiler(forceCompiler)

  if not version:
    version = pkgVersion(cflags=cflags, libs=libs,
                         compiler=compiler, linker=linker, sconsEnv=sconsEnv)
  else:
    # Run pkgVersion since this is the current PETSc test
    pkgVersion(cflags=cflags, libs=libs,
               compiler=compiler, linker=linker, sconsEnv=sconsEnv)

  return version, compiler, linker, libs, cflags

def generatePkgConf(directory=suitablePkgConfDir(), sconsEnv=None, **kwargs):

  version, compiler, linker, libs, cflags = pkgTests(sconsEnv=sconsEnv)

  pkg_file_str = r"""Name: PETSc
Version: %s
Description: The PETSc project from Argonne Nat.Lab, Math. and CS Division (http://www-unix.mcs.anl.gov/petsc/petsc-as/)
compiler=%s
linker=%s
Libs: %s
Cflags: %s
""" % (version, compiler, linker, libs, cflags)
  pkg_file = open(os.path.join(directory,"petsc.pc"), "w")
  pkg_file.write(pkg_file_str)
  pkg_file.close()
  
  print "done\n Found PETSc and generated pkg-config file in\n '%s'" % directory

if __name__ == "__main__": 
  generatePkgConf(directory=".")

Attachment: signature.asc
Description: Digital signature