Lines Matching refs:self
9 def __init__(self, framework): argument
10 config.base.Configure.__init__(self, framework)
11 self.headerPrefix = 'PETSC'
12 self.substPrefix = 'PETSC'
13 … self.installed = 0 # 1 indicates that Configure itself has already compiled and installed PETSc
14 self.found = 1
17 def __str2__(self): argument
20 desc = [' Using GNU make: ' + self.make.make]
21 if self.defines.get('USE_COVERAGE'):
24 ' Using code coverage executable: {}'.format(self.getMakeMacro('PETSC_COVERAGE_EXEC'))
30 if not self.installed:
32 …desc.append(' %s PETSC_DIR=%s PETSC_ARCH=%s all' % (self.make.make_user, self.petscdir.dir, self…
38 def setupHelp(self, help): argument
56 def registerPythonFile(self,filename,directory): argument
62 utilityObj = self.framework.require(directory+utilityName, self)
63 utilityObj.headerPrefix = self.headerPrefix
64 utilityObj.archProvider = self.arch
65 utilityObj.languageProvider = self.languages
66 utilityObj.installDirProvider = self.installdir
67 utilityObj.externalPackagesDirProvider = self.externalpackagesdir
68 utilityObj.precisionProvider = self.scalartypes
69 utilityObj.indexProvider = self.indexTypes
70 setattr(self, utilityName.lower(), utilityObj)
74 def setupDependencies(self, framework): argument
75 config.base.Configure.setupDependencies(self, framework)
76 self.programs = framework.require('config.programs', self)
77 self.setCompilers = framework.require('config.setCompilers', self)
78 self.compilerFlags = framework.require('config.compilerFlags', self)
79 self.compilers = framework.require('config.compilers', self)
80 self.arch = framework.require('PETSc.options.arch', self.setCompilers)
81 self.petscdir = framework.require('PETSc.options.petscdir', self.arch)
82 self.installdir = framework.require('PETSc.options.installDir', self)
83 self.dataFilesPath = framework.require('PETSc.options.dataFilesPath',self)
84 self.scalartypes = framework.require('PETSc.options.scalarTypes', self)
85 self.indexTypes = framework.require('PETSc.options.indexTypes', self)
86 self.languages = framework.require('PETSc.options.languages', self.setCompilers)
87 self.indexTypes = framework.require('PETSc.options.indexTypes', self.compilers)
88 self.types = framework.require('config.types', self)
89 self.headers = framework.require('config.headers', self)
90 self.functions = framework.require('config.functions', self)
91 self.libraries = framework.require('config.libraries', self)
92 self.atomics = framework.require('config.atomics', self)
93 self.make = framework.require('config.packages.make', self)
94 self.blasLapack = framework.require('config.packages.BlasLapack',self)
95 self.mpi = framework.require('config.packages.MPI', self)
96 self.fortran = framework.require('config.compilersFortran', self)
97 self.ftncmdline = framework.require('config.utilities.fortranCommandLine',self)
98 self.externalpackagesdir = framework.require('PETSc.options.externalpackagesdir',self)
101 self.registerPythonFile(utility,'PETSc.options')
104 self.registerPythonFile(utility,'config.utilities')
107 obj = self.registerPythonFile(package,'config.packages')
109 obj.archProvider = self.framework.requireModule(obj.archProvider, obj)
110 obj.languageProvider = self.framework.requireModule(obj.languageProvider, obj)
111 obj.installDirProvider = self.framework.requireModule(obj.installDirProvider, obj)
112 …obj.externalPackagesDirProvider = self.framework.requireModule(obj.externalPackagesDirProvider, ob…
113 obj.precisionProvider = self.framework.requireModule(obj.precisionProvider, obj)
114 obj.indexProvider = self.framework.requireModule(obj.indexProvider, obj)
117 framework.require('PETSc.options.scalarTypes', self.f2cblaslapack)
118 framework.require('PETSc.options.scalarTypes', self.fblaslapack)
119 framework.require('PETSc.options.scalarTypes', self.blaslapack)
120 framework.require('PETSc.options.scalarTypes', self.opencl)
122 self.programs.headerPrefix = self.headerPrefix
123 self.setCompilers.headerPrefix = self.headerPrefix
124 self.compilers.headerPrefix = self.headerPrefix
125 self.fortran.headerPrefix = self.headerPrefix
126 self.types.headerPrefix = self.headerPrefix
127 self.headers.headerPrefix = self.headerPrefix
128 self.functions.headerPrefix = self.headerPrefix
129 self.libraries.headerPrefix = self.headerPrefix
132 if 'with-package-scripts' in self.framework.argDB:
133 for script in self.framework.argDB['with-package-scripts']:
136 self.framework.logPrint('User is registering a new package script: '+script)
139 self.registerPythonFile(fname,'')
156 self.headers.headers.extend(headersC)
157 self.functions.functions.extend(functions)
158 self.libraries.libraries.extend(libraries)
159 if not hasattr(self,'socket'):
160 self.libraries.libraries.extend(librariessock)
163 def DumpPkgconfig(self, petsc_pc): argument
165 if not os.path.exists(os.path.join(self.petscdir.dir,self.arch.arch,'lib','pkgconfig')):
166 os.makedirs(os.path.join(self.petscdir.dir,self.arch.arch,'lib','pkgconfig'))
167 with open(os.path.join(self.petscdir.dir,self.arch.arch,'lib','pkgconfig',petsc_pc),'w') as fd:
169 if self.framework.argDB['prefix']:
170 fd.write('prefix='+self.installdir.dir+'\n')
172 fd.write('prefix='+os.path.join(self.petscdir.dir, self.arch.arch)+'\n')
173 cflags_inc.append('-I' + os.path.join(self.petscdir.dir, 'include'))
178 with self.setCompilers.Language('C'):
179 fd.write('ccompiler='+self.setCompilers.getCompiler()+'\n')
180 fd.write('cflags_extra='+self.setCompilers.getCompilerFlags().strip()+'\n')
181 fd.write('cflags_dep='+self.compilers.dependenciesGenerationFlag.get('C','')+'\n')
182 fd.write('ldflag_rpath='+self.setCompilers.CSharedLinkerFlag+'\n')
183 fd.write('ldflags='+self.setCompilers.getLinkerFlags().strip()+'\n')
184 if hasattr(self.compilers, 'CXX'):
185 with self.setCompilers.Language('C++'):
186 fd.write('cxxcompiler='+self.setCompilers.getCompiler()+'\n')
187 fd.write('cxxflags_extra='+self.setCompilers.getCompilerFlags().strip()+'\n')
188 if hasattr(self.compilers, 'FC'):
189 with self.setCompilers.Language('FC'):
190 fd.write('fcompiler='+self.setCompilers.getCompiler()+'\n')
191 fd.write('fflags_extra='+self.setCompilers.getCompilerFlags().strip()+'\n')
192 if hasattr(self.compilers, 'CUDAC'):
193 with self.setCompilers.Language('CUDA'):
194 fd.write('cudacompiler='+self.setCompilers.getCompiler()+'\n')
195 fd.write('cudaflags_extra='+self.setCompilers.getCompilerFlags().strip()+'\n')
196 p = self.framework.require('config.packages.CUDA')
197 fd.write('cudalib='+self.libraries.toStringNoDupes(p.lib)+'\n')
198 fd.write('cudainclude='+self.headers.toStringNoDupes(p.include)+'\n')
199 if hasattr(self.setCompilers,'CUDA_CXX'):
200 fd.write('cuda_cxx='+self.setCompilers.CUDA_CXX+'\n')
201 fd.write('cuda_cxxflags='+self.setCompilers.CUDA_CXXFLAGS+'\n')
202 fd.write('mpiexec='+self.mpi.mpiexec+'\n')
203 if self.python.path:
205 fd.write('PETSCPYTHONPATH='+':'.join(self.python.path)+':'+os.environ['PYTHONPATH']+'\n')
207 fd.write('PETSCPYTHONPATH='+':'.join(self.python.path)+'\n')
212 fd.write('Version: %s\n' % self.petscdir.version)
213 fd.write('Cflags: ' + ' '.join([self.setCompilers.CPPFLAGS] + cflags_inc) + '\n')
214 …fd.write('Libs: '+self.libraries.toStringNoDupes(['-L${libdir}', self.petsclib], with_rpath=False)…
217 …fd.write('Libs.private: '+self.libraries.toStringNoDupes([f for f in self.packagelibs+self.complib…
220 def DumpModule(self): argument
222 …if not os.path.exists(os.path.join(self.petscdir.dir,self.arch.arch,'lib','petsc','conf','modules'…
223 os.makedirs(os.path.join(self.petscdir.dir,self.arch.arch,'lib','petsc','conf','modules'))
224 …if not os.path.exists(os.path.join(self.petscdir.dir,self.arch.arch,'lib','petsc','conf','modules'…
225 … os.makedirs(os.path.join(self.petscdir.dir,self.arch.arch,'lib','petsc','conf','modules','petsc'))
226 if self.framework.argDB['prefix']:
227 installdir = self.installdir.dir
231 installdir = self.petscdir.dir
232 installarch = self.arch.arch
234 …fd = open(os.path.join(self.petscdir.dir,self.arch.arch,'lib','petsc','conf','modules','petsc',sel…
251 ''' % (self.petscdir.version, installdir, installarch, installpath))
255 def Dump(self): argument
258 if self.mpi.usingMPIUni:
261 …self.executeShellCommand('rm -rf '+os.path.join(self.petscdir.dir,self.arch.arch,'include','mpi*'…
263 self.logPrintDivider()
265 if self.setCompilers.isCrayVector('CC', self.log):
266 self.addDefine('HAVE_CRAY_VECTOR','1')
268 …if self.functions.haveFunction('gethostbyname') and self.functions.haveFunction('socket') and self…
269 self.addDefine('USE_SOCKET_VIEWER','1')
270 if self.checkCompile('#include <sys/socket.h>','setsockopt(0,SOL_SOCKET,SO_REUSEADDR,0,0)'):
271 self.addDefine('HAVE_SO_REUSEADDR','1')
273 self.logPrintDivider()
274 self.setCompilers.pushLanguage('C')
275 compiler = self.setCompilers.getCompiler()
278 output = self.executeShellCommand(compiler + ' -show', log = self.log)[0]
280 self.addDefine('MPICC_SHOW','"'+output.strip().replace('\n','\\\\n').replace('"','')+'"')
282 self.addDefine('MPICC_SHOW','"Unavailable"')
284 self.addDefine('MPICC_SHOW','"Unavailable"')
285 self.setCompilers.popLanguage()
289 self.setCompilers.pushLanguage('C')
291 self.addMakeMacro('CC_FLAGS',self.setCompilers.CFLAGS)
292 self.setCompilers.popLanguage()
295 if hasattr(self.compilers, 'CXX'):
296 self.setCompilers.pushLanguage('Cxx')
297 self.addDefine('HAVE_CXX','1')
298 self.addMakeMacro('CXXPP_FLAGS',self.setCompilers.CXXPPFLAGS)
300 self.addMakeMacro('CXX_FLAGS',self.setCompilers.CXXFLAGS+' '+self.setCompilers.CXX_CXXFLAGS)
301 cxx_linker = self.setCompilers.getLinker()
302 self.addMakeMacro('CXX_LINKER',cxx_linker)
303 self.addMakeMacro('CXX_LINKER_FLAGS',self.setCompilers.getLinkerFlags())
304 self.setCompilers.popLanguage()
306 self.addMakeMacro('CXX','')
309 self.addMakeMacro('CPP_FLAGS',self.setCompilers.CPPFLAGS)
312 self.setCompilers.pushLanguage(self.languages.clanguage)
313 self.addMakeMacro('PCC',self.setCompilers.getCompiler())
315 if self.languages.clanguage == 'C':
316 self.addMakeMacro('PCC_FLAGS','$(CC_FLAGS)')
318 self.addMakeMacro('PCC_FLAGS','$(CXX_FLAGS)')
319 self.setCompilers.popLanguage()
321 self.addMakeMacro('CC_SUFFIX','o')
324 self.setCompilers.pushLanguage(self.languages.clanguage)
325 pcc_linker = self.setCompilers.getLinker()
326 self.addMakeMacro('PCC_LINKER',pcc_linker)
328 if hasattr(self.compilers, 'SYCLC'):
329 …self.addMakeMacro('PCC_LINKER_FLAGS',self.setCompilers.getLinkerFlags()+' '+self.setCompilers.SYCL…
331 self.addMakeMacro('PCC_LINKER_FLAGS',self.setCompilers.getLinkerFlags())
332 self.setCompilers.popLanguage()
334 self.addMakeMacro('CC_LINKER_SUFFIX','')
336 if hasattr(self.compilers, 'FC'):
337 if self.framework.argDB['with-fortran-bindings']:
338 if not self.fortran.fortranIsF90:
339 …raise RuntimeError('Error! Fortran compiler "'+self.compilers.FC+'" does not support F90! PETSc Fo…
340 if not self.fortran.fortranBoolIsInteroperable:
341 …raise RuntimeError('Error! Fortran compiler "'+self.compilers.FC+'" does not have a C-interoperabl…
342 self.addDefine('USE_FORTRAN_BINDINGS','1')
343 if not self.ftncmdline.have_command_argument:
344 …raise RuntimeError('Error! Fortran compiler "'+self.compilers.FC+'" does not support F2003 GET_COM…
345 if not self.fortran.fortranInitializePtrInDecl:
346 …raise RuntimeError('Error! Fortran compiler "'+self.compilers.FC+'" does not support the F2018 sta…
347 self.setCompilers.pushLanguage('FC')
349 self.addMakeMacro('FPP_FLAGS',self.setCompilers.FPPFLAGS)
352 self.addMakeMacro('FC_FLAGS',self.setCompilers.getCompilerFlags())
353 self.setCompilers.popLanguage()
355 self.addMakeMacro('FC_SUFFIX','o')
358 self.setCompilers.pushLanguage('FC')
359 self.addMakeMacro('FC_LINKER',self.setCompilers.getLinker())
360 self.addMakeMacro('FC_LINKER_FLAGS',self.setCompilers.getLinkerFlags())
361 self.setCompilers.popLanguage()
364 if self.setCompilers.fortranModuleIncludeFlag:
365 self.addMakeMacro('FC_MODULE_FLAG', self.setCompilers.fortranModuleIncludeFlag)
367 self.addMakeMacro('FC_MODULE_FLAG', '-I')
368 if self.setCompilers.fortranModuleIncludeFlag:
369 self.addMakeMacro('FC_MODULE_OUTPUT_FLAG', self.setCompilers.fortranModuleOutputFlag)
371 self.addMakeMacro('FC','')
373 if hasattr(self.compilers, 'CUDAC'):
374 self.setCompilers.pushLanguage('CUDA')
375 self.addMakeMacro('CUDAC_FLAGS',self.setCompilers.getCompilerFlags())
376 self.addMakeMacro('CUDAPP_FLAGS',self.setCompilers.CUDAPPFLAGS)
377 self.setCompilers.popLanguage()
379 if hasattr(self.compilers, 'HIPC'):
380 self.setCompilers.pushLanguage('HIP')
381 self.addMakeMacro('HIPC_FLAGS',self.setCompilers.getCompilerFlags())
382 self.addMakeMacro('HIPPP_FLAGS',self.setCompilers.HIPPPFLAGS)
383 self.setCompilers.popLanguage()
385 if hasattr(self.compilers, 'SYCLC'):
386 self.setCompilers.pushLanguage('SYCL')
387 self.addMakeMacro('SYCLC_FLAGS',self.setCompilers.getCompilerFlags())
388 self.addMakeMacro('SYCLC_LINKER_FLAGS',self.setCompilers.getLinkerFlags())
389 self.addMakeMacro('SYCLPP_FLAGS',self.setCompilers.SYCLPPFLAGS)
390 self.setCompilers.popLanguage()
393 self.setCompilers.pushLanguage(self.languages.clanguage)
395 self.addMakeMacro('SL_LINKER',self.setCompilers.getLinker())
396 self.addMakeMacro('SL_LINKER_FLAGS','${PCC_LINKER_FLAGS}')
397 self.setCompilers.popLanguage()
400 if self.setCompilers.sharedLibraryExt == self.setCompilers.AR_LIB_SUFFIX:
401 self.addMakeMacro('SL_LINKER_SUFFIX', '')
402 self.addDefine('SLSUFFIX','""')
404 self.addMakeMacro('SL_LINKER_SUFFIX', self.setCompilers.sharedLibraryExt)
405 self.addDefine('SLSUFFIX','"'+self.setCompilers.sharedLibraryExt+'"')
407 self.addMakeMacro('SL_LINKER_LIBS','${PETSC_EXTERNAL_LIB_BASIC}')
412 if self.languages.clanguage == 'C': lang = 'CONLY'
414 self.addMakeMacro('PETSC_LANGUAGE',lang)
417 self.addMakeMacro('PETSC_SCALAR',self.scalartypes.scalartype)
419 self.addMakeMacro('PETSC_PRECISION',self.scalartypes.precision)
421 if self.framework.argDB['with-batch']:
422 self.addMakeMacro('PETSC_WITH_BATCH','1')
426 self.logPrintDivider()
427 self.framework.packages.reverse()
428 …petscincludes = [os.path.join(self.petscdir.dir,'include'),os.path.join(self.petscdir.dir,self.arc…
429 …petscincludes_install = [os.path.join(self.installdir.dir, 'include')] if self.framework.argDB['pr…
431 self.packagelibs = []
432 for i in self.framework.packages:
435 self.addDefine('HAVE_DEVICE',1)
436 if self.languages.devicelanguage == 'C':
438 self.languages.devicelanguage = 'Cxx'
439 …self.addDefine('HAVE_'+i.PACKAGE.replace('-','_'), 1) # ONLY list package if it is used directly …
442 if i.linkedbypetsc: self.packagelibs.extend(i.lib)
443 self.addMakeMacro(i.PACKAGE.replace('-','_')+'_LIB', self.libraries.toStringNoDupes(i.lib))
448 … self.addMakeMacro(i.PACKAGE.replace('-','_')+'_INCLUDE',self.headers.toStringNoDupes(i.include))
449 if self.languages.devicelanguage == '': self.languages.devicelanguage = self.languages.clanguage
450 elif self.languages.devicelanguage == 'Cxx' and not hasattr(self.compilers, 'CXX'):
452 if self.getMakeMacro('DEVICELANGUAGE') is None:
453 self.addDefine('DEVICELANGUAGE_'+self.languages.devicelanguage.upper(),'1')
454 self.addMakeMacro('DEVICELANGUAGE',self.languages.devicelanguage.upper())
456 self.complibs = self.compilers.flibs+self.compilers.cxxlibs+self.compilers.LIBS.split()
457 self.PETSC_EXTERNAL_LIB_BASIC = self.libraries.toStringNoDupes(self.packagelibs+self.complibs)
459 self.addMakeMacro('PETSC_EXTERNAL_LIB_BASIC',self.PETSC_EXTERNAL_LIB_BASIC)
462 self.PETSC_CC_INCLUDES = self.headers.toStringNoDupes(allincludes)
463 self.PETSC_CC_INCLUDES_INSTALL = self.headers.toStringNoDupes(allincludes_install)
464 self.addMakeMacro('PETSC_CC_INCLUDES',self.PETSC_CC_INCLUDES)
465 self.addMakeMacro('PETSC_CC_INCLUDES_INSTALL', self.PETSC_CC_INCLUDES_INSTALL)
466 if hasattr(self.compilers, 'FC'):
468 return includes if self.fortran.fortranIsF90 else []
469 …self.addMakeMacro('PETSC_FC_INCLUDES',self.headers.toStringNoDupes(allincludes,modinc(allincludes)…
470 …self.addMakeMacro('PETSC_FC_INCLUDES_INSTALL',self.headers.toStringNoDupes(allincludes_install,mod…
472 LIB_DIR = os.path.join(self.installdir.dir,'lib')
473 self.addDefine('LIB_DIR','"'+LIB_DIR+'"')
475 PREINSTALL_LIB_DIR = os.path.join(self.petscdir.dir,self.arch.arch,'lib')
477 self.LIB_NAME_SUFFIX = self.framework.argDB['with-library-name-suffix']
478 self.addMakeMacro('LIB_NAME_SUFFIX', self.LIB_NAME_SUFFIX)
479 self.addDefine('LIB_NAME_SUFFIX', '"'+self.LIB_NAME_SUFFIX+'"')
481 if self.framework.argDB['with-single-library']:
482 self.petsclib = '-lpetsc'+self.LIB_NAME_SUFFIX
483 self.addDefine('USE_SINGLE_LIBRARY', '1')
484 self.addMakeMacro('LIBNAME','${INSTALL_LIB_DIR}/libpetsc${LIB_NAME_SUFFIX}.${AR_LIB_SUFFIX}')
485 self.addMakeMacro('SHLIBS','libpetsc')
486 …self.addMakeMacro('PETSC_WITH_EXTERNAL_LIB',self.libraries.toStringNoDupes(['-L'+PREINSTALL_LIB_DI…
487 self.addMakeMacro('PETSC_SYS_LIB','${PETSC_WITH_EXTERNAL_LIB}')
488 self.addMakeMacro('PETSC_VEC_LIB','${PETSC_WITH_EXTERNAL_LIB}')
489 self.addMakeMacro('PETSC_MAT_LIB','${PETSC_WITH_EXTERNAL_LIB}')
490 self.addMakeMacro('PETSC_DM_LIB','${PETSC_WITH_EXTERNAL_LIB}')
491 self.addMakeMacro('PETSC_KSP_LIB','${PETSC_WITH_EXTERNAL_LIB}')
492 self.addMakeMacro('PETSC_SNES_LIB','${PETSC_WITH_EXTERNAL_LIB}')
493 self.addMakeMacro('PETSC_TS_LIB','${PETSC_WITH_EXTERNAL_LIB}')
494 self.addMakeMacro('PETSC_TAO_LIB','${PETSC_WITH_EXTERNAL_LIB}')
495 self.addMakeMacro('PETSC_ML_LIB','${PETSC_WITH_EXTERNAL_LIB}')
499 return [ '-lpetsc'+lib+self.LIB_NAME_SUFFIX for lib in libs]
501 …return self.libraries.toStringNoDupes(['-L'+PREINSTALL_LIB_DIR]+liblist_basic(libs)+self.packageli…
502 self.petsclib = ' '.join(liblist_basic(pkgs))
503 self.addMakeMacro('PETSC_SYS_LIB', liblist(pkgs[-1:]))
504 self.addMakeMacro('PETSC_VEC_LIB', liblist(pkgs[-2:]))
505 self.addMakeMacro('PETSC_MAT_LIB', liblist(pkgs[-3:]))
506 self.addMakeMacro('PETSC_DM_LIB', liblist(pkgs[-4:]))
507 self.addMakeMacro('PETSC_KSP_LIB', liblist(pkgs[-5:]))
508 self.addMakeMacro('PETSC_SNES_LIB',liblist(pkgs[-6:]))
509 self.addMakeMacro('PETSC_TS_LIB', liblist(pkgs[-7:]))
510 self.addMakeMacro('PETSC_TAO_LIB', liblist(pkgs[-8:]))
511 self.addMakeMacro('PETSC_ML_LIB', liblist(pkgs[-9:]))
512 self.addMakeMacro('PETSC_LIB','${PETSC_ML_LIB}')
513 self.addMakeMacro('PETSC_LIB_BASIC',self.petsclib)
515 if not os.path.exists(os.path.join(self.petscdir.dir,self.arch.arch,'lib')):
516 os.makedirs(os.path.join(self.petscdir.dir,self.arch.arch,'lib'))
519 if self.framework.argDB['with-display']:
520 self.addMakeMacro('DISPLAY',self.framework.argDB['with-display'])
523 …self.addMakeMacro('CONFIGURE_OPTIONS', self.framework.getOptionsString(['configModules', 'optionsM…
525 if self.framework.argDB['with-tau-perfstubs']:
526 self.addDefine('HAVE_TAU_PERFSTUBS',1)
528 if self.python.path:
530 self.addMakeMacro('PETSCPYTHONPATH',':'.join(self.python.path)+':'+os.environ['PYTHONPATH'])
532 self.addMakeMacro('PETSCPYTHONPATH',':'.join(self.python.path))
534 def dumpConfigInfo(self): argument
536 fd = open(os.path.join(self.arch.arch,'include','petscconfiginfo.h'),'w')
537 …fd.write('static const char *petscconfigureoptions = "'+self.framework.getOptionsString(['configMo…
541 def dumpMachineInfo(self): argument
548 fd = open(os.path.join(self.arch.arch,'include','petscmachineinfo.h'),'w')
557 fd.write('\"Using PETSc directory: %s\\n\"\n' % (escape(self.installdir.petscDir)))
558 fd.write('\"Using PETSc arch: %s\\n\"\n' % (escape(self.installdir.petscArch)))
561 self.setCompilers.pushLanguage(self.languages.clanguage)
562 …fd.write('\"Using C compiler: %s %s\\n\"\n' % (escape(self.setCompilers.getCompiler()), escape(sel…
563 self.setCompilers.popLanguage()
564 if hasattr(self.compilers, 'FC'):
565 self.setCompilers.pushLanguage('FC')
566 …er: %s %s %s\\n\"\n' % (escape(self.setCompilers.getCompiler()), escape(self.setCompilers.getCompi…
567 self.setCompilers.popLanguage()
570 …e('\"Using include paths: %s\\n\"\n' % (escape(self.PETSC_CC_INCLUDES_INSTALL.replace('${PETSC_DIR…
573 self.setCompilers.pushLanguage(self.languages.clanguage)
574 fd.write('\"Using C linker: %s\\n\"\n' % (escape(self.setCompilers.getLinker())))
575 self.setCompilers.popLanguage()
576 if hasattr(self.compilers, 'FC'):
577 self.setCompilers.pushLanguage('FC')
578 fd.write('\"Using Fortran linker: %s\\n\"\n' % (escape(self.setCompilers.getLinker())))
579 self.setCompilers.popLanguage()
580 …self.setCompilers.CSharedLinkerFlag), escape(os.path.join(self.installdir.petscDir, self.installdi…
585 def configurePrefetch(self): argument
587 …if config.setCompilers.Configure.isSolaris(self.log) or self.framework.argDB['with-ios'] or not se…
588 self.addDefine('Prefetch(a,b,c)', ' ')
590 self.pushLanguage(self.languages.clanguage)
591 …if self.checkLink('#include <xmmintrin.h>', 'void *v = 0;_mm_prefetch((const char*)v,_MM_HINT_NTA)…
602 self.addDefine('HAVE_XMMINTRIN_H', 1)
603 self.addDefine('Prefetch(a,b,c)', '_mm_prefetch((const char*)(a),(c))')
604 self.addDefine('PREFETCH_HINT_NTA', '_MM_HINT_NTA')
605 self.addDefine('PREFETCH_HINT_T0', '_MM_HINT_T0')
606 self.addDefine('PREFETCH_HINT_T1', '_MM_HINT_T1')
607 self.addDefine('PREFETCH_HINT_T2', '_MM_HINT_T2')
608 elif self.checkLink('#include <xmmintrin.h>', 'void *v = 0;_mm_prefetch(v,_MM_HINT_NTA);\n'):
609 self.addDefine('HAVE_XMMINTRIN_H', 1)
610 self.addDefine('Prefetch(a,b,c)', '_mm_prefetch((const void*)(a),(c))')
611 self.addDefine('PREFETCH_HINT_NTA', '_MM_HINT_NTA')
612 self.addDefine('PREFETCH_HINT_T0', '_MM_HINT_T0')
613 self.addDefine('PREFETCH_HINT_T1', '_MM_HINT_T1')
614 self.addDefine('PREFETCH_HINT_T2', '_MM_HINT_T2')
615 elif self.checkLink('', 'void *v = 0;__builtin_prefetch(v,0,0);\n'):
632 self.addDefine('Prefetch(a,b,c)', '__builtin_prefetch((a),(b),(c))')
633 self.addDefine('PREFETCH_HINT_NTA', '0')
634 self.addDefine('PREFETCH_HINT_T0', '3')
635 self.addDefine('PREFETCH_HINT_T1', '2')
636 self.addDefine('PREFETCH_HINT_T2', '1')
638 self.addDefine('Prefetch(a,b,c)', ' ')
639 self.popLanguage()
641 def delGenFiles(self): argument
643 delfile = os.path.join(self.arch.arch,'lib','petsc','conf','files')
648 def configureAtoll(self): argument
650 …if self.checkLink('#define _POSIX_C_SOURCE 200112L\n#include <stdlib.h>','long v = atoll("25");\n(…
651 self.addDefine('HAVE_ATOLL', '1')
653 def configureSanitize(self): argument
655 …if self.checkLink('#if defined(__has_feature)\n#if !__has_feature(address_sanitizer)\nGarbage\n#en…
656 self.addDefine('HAVE_SANITIZER', '1')
657 elif self.checkLink('#if !defined(__SANITIZE_ADDRESS__)\nGarbage\n#endif\n'):
658 self.addDefine('HAVE_SANITIZER', '1')
660 def configureUnused(self): argument
662 if self.framework.argDB['with-ios']:
663 self.addDefine('UNUSED', ' ')
665 self.pushLanguage(self.languages.clanguage)
666 …if self.checkLink('__attribute((unused)) static int myfunc(__attribute((unused)) void *name){ retu…
667 self.addDefine('UNUSED', '__attribute((unused))')
669 self.addDefine('UNUSED', ' ')
670 self.popLanguage()
672 def configureIsatty(self): argument
675 if not self.framework.argDB['with-batch']:
676 self.addDefine('USE_ISATTY',1)
678 def configureDeprecated(self): argument
701 if self.checkCompile(test_src, ''):
702 self.logPrint('configureDeprecated: \'{}\' appears to work'.format(attr_def))
704 …self.logPrint('configureDeprecated: Intel has conspired to make a supremely environment-sensitive …
705 … self.logPrint('*** WE WILL THEREFORE REJECT \'{}\' AND CONTINUE TESTING ***'.format(attr_def))
707 self.addDefine(full_macro_name, attr_def)
710 self.addDefine(full_macro_name, ' ')
713 lang = self.languages.clanguage
714 with self.Language(lang):
715 is_intel = self.setCompilers.isIntel(self.getCompiler(lang=lang), self.log)
723 if self.checkCompile('#define TEST _Pragma("GCC warning \"Testing _Pragma\"") value'):
724 self.addDefine('DEPRECATED_MACRO_BASE_(why)', '_Pragma(#why)')
725 …self.addDefine('DEPRECATED_MACRO_BASE(string_literal_why)', self.substPrefix + '_DEPRECATED_MACRO_…
727 self.addDefine('DEPRECATED_MACRO_BASE(why)', ' ')
729 def configureAlign(self): argument
735 self.pushLanguage(self.languages.clanguage)
736 if self.checkCompile(code):
737 self.addDefine('ATTRIBUTEALIGNED(size)', '__attribute((aligned(size)))')
738 self.addDefine('HAVE_ATTRIBUTEALIGNED', 1)
740 self.framework.logPrint('Incorrect attribute(aligned)')
741 self.addDefine('ATTRIBUTEALIGNED(size)', ' ')
742 self.popLanguage()
745 def configureExpect(self): argument
747 self.pushLanguage(self.languages.clanguage)
748 if self.checkLink('', 'if (__builtin_expect(0,1)) return 1;'):
749 self.addDefine('HAVE_BUILTIN_EXPECT', 1)
750 self.popLanguage()
752 def configureFunctionName(self): argument
756 self.pushLanguage(lang)
759 if self.checkCompile('',code) and self.checkLink('',code):
762 self.popLanguage()
766 self.addDefine('FUNCTION_NAME_C', getFunctionName('C'))
767 if hasattr(self.compilers, 'CXX'):
768 self.addDefine('FUNCTION_NAME_CXX', getFunctionName('Cxx'))
770 def configureIntptrt(self): argument
775 …return self.checkCompile(inc, ('#define STATIC_ASSERT(cond) char negative_length_if_false[2*(!!(co…
795 with self.Language(self.languages.clanguage):
796 if self.checkCompile(
808 self.addDefine(macro_name , typename)
809 self.addDefine(macro_name + '_FMT', '\"#\" ' + print_format)
816 def configureRTLDDefault(self): argument
818 if self.checkCompile('#include <dlfcn.h>\n void *ptr = RTLD_DEFAULT;'):
819 self.addDefine('HAVE_RTLD_DEFAULT','1')
822 def configureSolaris(self): argument
826 flag = getattr(self.setCompilers, self.language[-1]+'SharedLinkerFlag')
830 self.compilers.LIBS += ' -L/usr/ucblib'
832 self.compilers.LIBS += ' '+flag+'/usr/ucblib'
835 def configureDarwin(self): argument
838 self.executeShellCommand(['brew', 'config'], log = self.log)
839 self.executeShellCommand(['brew', 'info', 'gcc'], log = self.log)
844 def configureLinux(self): argument
847 self.addDefine('HAVE_DOUBLE_ALIGN_MALLOC', 1)
850 def configureWin32(self): argument
853 …if self.libraries.add('Kernel32.lib','GetComputerName',prototype='#include <windows.h>', call='Get…
854 self.addDefine('HAVE_WINDOWS_H',1)
855 self.addDefine('HAVE_GETCOMPUTERNAME',1)
857 …elif self.libraries.add('kernel32','GetComputerName',prototype='#include <windows.h>', call='GetCo…
858 self.addDefine('HAVE_WINDOWS_H',1)
859 self.addDefine('HAVE_GETCOMPUTERNAME',1)
862 if self.framework.argDB['with-windows-graphics']:
863 self.addDefine('USE_WINDOWS_GRAPHICS',1)
864 if self.checkLink('#include <windows.h>','LoadLibrary(0)'):
865 self.addDefine('HAVE_LOADLIBRARY',1)
866 if self.checkLink('#include <windows.h>','GetProcAddress(0,0)'):
867 self.addDefine('HAVE_GETPROCADDRESS',1)
868 if self.checkLink('#include <windows.h>','FreeLibrary(0)'):
869 self.addDefine('HAVE_FREELIBRARY',1)
870 if self.checkLink('#include <windows.h>','GetLastError()'):
871 self.addDefine('HAVE_GETLASTERROR',1)
872 if self.checkLink('#include <windows.h>','SetLastError(0)'):
873 self.addDefine('HAVE_SETLASTERROR',1)
874 if self.checkLink('#include <windows.h>\n','QueryPerformanceCounter(0);\n'):
875 self.addDefine('USE_MICROSOFT_TIME',1)
876 …if self.libraries.add('Advapi32.lib','GetUserName',prototype='#include <windows.h>', call='GetUser…
877 self.addDefine('HAVE_GET_USER_NAME',1)
878 …elif self.libraries.add('advapi32','GetUserName',prototype='#include <windows.h>', call='GetUserNa…
879 self.addDefine('HAVE_GET_USER_NAME',1)
881 … if not self.libraries.add('User32.lib','GetDC',prototype='#include <windows.h>',call='GetDC(0);'):
882 self.libraries.add('user32','GetDC',prototype='#include <windows.h>',call='GetDC(0);')
883 …if not self.libraries.add('Gdi32.lib','CreateCompatibleDC',prototype='#include <windows.h>',call='…
884 …self.libraries.add('gdi32','CreateCompatibleDC',prototype='#include <windows.h>',call='CreateCompa…
886 if not self.checkCompile('#include <sys/types.h>\n','uid_t u;\n(void)u'):
887 self.addTypedef('int', 'uid_t')
888 self.addTypedef('int', 'gid_t')
889 …if not self.checkLink('#if defined(PETSC_HAVE_UNISTD_H)\n#include <unistd.h>\n#endif\n','int a=R_O…
890 self.framework.addDefine('R_OK', '04')
891 self.framework.addDefine('W_OK', '02')
892 self.framework.addDefine('X_OK', '01')
893 if not self.checkLink('#include <sys/stat.h>\n','int a=0;\nif (S_ISDIR(a)){}\n'):
894 self.framework.addDefine('S_ISREG(a)', '(((a)&_S_IFMT) == _S_IFREG)')
895 self.framework.addDefine('S_ISDIR(a)', '(((a)&_S_IFMT) == _S_IFDIR)')
896 if self.checkCompile('#include <windows.h>\n','LARGE_INTEGER a;\nDWORD b=a.u.HighPart;\n'):
897 self.addDefine('HAVE_LARGE_INTEGER_U',1)
900 if self.checkCompile('#include <windows.h>\n#include <fcntl.h>\n', 'int flags = O_BINARY;'):
901 self.addDefine('HAVE_O_BINARY',1)
903 if self.compilers.CC.find('win32fe') >= 0:
904 self.addDefine('HAVE_WINDOWS_COMPILERS',1)
905 self.addDefine('DIR_SEPARATOR','\'\\\\\'')
906 self.addDefine('REPLACE_DIR_SEPARATOR','\'/\'')
907 self.addDefine('CANNOT_START_DEBUGGER',1)
908 …(petscdir,error,status) = self.executeShellCommand('cygpath -w '+self.installdir.petscDir, log = s…
909 self.addDefine('DIR','"'+petscdir.replace('\\','\\\\')+'"')
910 …(petscdir,error,status) = self.executeShellCommand('cygpath -m '+self.installdir.petscDir, log = s…
911 self.addMakeMacro('wPETSC_DIR',petscdir)
912 if self.dataFilesPath.datafilespath:
913 …(datafilespath,error,status) = self.executeShellCommand('cygpath -m '+self.dataFilesPath.datafiles…
914 self.addMakeMacro('DATAFILESPATH',datafilespath)
917 self.addDefine('REPLACE_DIR_SEPARATOR','\'\\\\\'')
918 self.addDefine('DIR_SEPARATOR','\'/\'')
919 self.addDefine('DIR','"'+self.installdir.petscDir+'"')
920 self.addMakeMacro('wPETSC_DIR',self.installdir.petscDir)
921 if self.dataFilesPath.datafilespath:
922 self.addMakeMacro('DATAFILESPATH',self.dataFilesPath.datafilespath)
923 self.addDefine('ARCH','"'+self.installdir.petscArch+'"')
926 …def configureCoverageForLang(self, log_printer_cls, lang, extra_coverage_flags=None, extra_debug_f… argument
939 log_print = log_printer_cls(self)
953 compiler = self.getCompiler(lang=lang)
954 if self.setCompilers.isGNU(compiler, self.log):
956 elif self.setCompilers.isClang(compiler, self.log):
970 with self.Language(lang):
971 with self.setCompilers.Language(lang):
974 with self.setCompilers.extraCompilerFlags([flag], compilerOnly=False) as skip_flags:
975 if not skip_flags and self.checkRun():
998 self.setCompilers.insertCompilerFlag(flag, False)
1000 if not self.functions.haveFunction('__gcov_dump'):
1001 self.functions.checkClassify(['__gcov_dump'])
1007 with self.Language(lang):
1008 compiler_flags = self.getCompilerFlags()
1012 … for flagsname in [self.getCompilerFlagsName(lang), self.compilerFlags.getOptionalFlagsName(lang)]:
1013 if flagsname in self.argDB:
1015 … f for f in self.compilerFlags.findOptFlags(compiler_flags) if not allowed_opt_flags.match(f)
1018 …self.logPrintWarning('Coverage requested, but optimization flag(s) {} found in {}. Coverage collec…
1026 with self.setCompilers.Language(lang):
1029 self.setCompilers.addCompilerFlag(flag)
1034 self.addDefine('USE_COVERAGE', 1)
1037 def configureCoverage(self): argument
1052 def __init__(self, cfg): argument
1053 self.cfg = cfg
1064 self.fmt_str = func_name + '(): {}'
1066 def __call__(self, msg, *args, **kwargs): argument
1067 return self.cfg.logPrint(self.fmt_str.format(msg), *args, **kwargs)
1070 log_print = LogPrinter(self)
1071 if not self.argDB[argdb_flag]:
1078 if hasattr(self.setCompilers, compilerName):
1086 nvcc_tmp_dir = os.path.join(self.petscdir.dir, self.arch.arch, 'nvcc_tmp')
1094 if self.kokkos.found:
1102 self.executeTest(self.configureCoverageForLang, args=[LogPrinter, LANG], kargs=kwargs)
1104 if not self.defines.get('USE_COVERAGE'):
1108 argdb_flag, self.argDB[argdb_flag],
1109 … '\n'.join([' - {} ({})'.format(self.getCompiler(lang=lang), lang) for lang in tested_langs])
1133 if not hasattr(self.setCompilers, 'FC'):
1137 c_lang = self.languages.clanguage
1138 if not self.setCompilers.isClang(self.getCompiler(lang=c_lang), self.log):
1140 …it is GCC, so cross-linking with FC ({}) assumed to be OK'.format(c_lang, self.getCompiler(lang='F…
1153 return self.compilers.checkCrossLink(
1154 f_body, c_body, language1='FC', language2=c_lang, extralibs=self.compilers.flibs, **kwargs
1169 self.setCompilers.LIBS += ' ' + ' '.join(extra_libs)
1172 …self.logPrintWarning("Could not successfully cross-link covered code between {} and FC. Sometimes …
1175 def configureCoverageExecutable(self): argument
1188 self.logPrint('checkCoverage: '+str(msg), *args, **kwargs)
1194 required = bool(self.argDB['with-coverage'])
1195 arg_opt = self.argDB['with-coverage-exec']
1202 lang = self.setCompilers.languages.clanguage
1203 compiler = self.getCompiler(lang=lang)
1205 if self.setCompilers.isGNU(compiler, self.log):
1208 elif self.setCompilers.isClang(compiler, self.log):
1211 if self.setCompilers.isDarwin(self.log):
1225 compiler_version_str = self.compilerFlags.version[lang]
1253 found_exec = self.getExecutables(
1267 self.addMakeMacro(make_macro_name, found_exec + ' gcov')
1270 def configureStrictPetscErrorCode(self): argument
1281 if self.argDB['with-strict-petscerrorcode']:
1282 self.addDefine(define_name, 1)
1285 self.delDefine(define_name)
1289 def configureCygwinBrokenPipe(self): argument
1292 if config.setCompilers.Configure.isCygwin(self.log):
1301 self.addMakeMacro('PETSC_CYGWIN_BROKEN_PIPE','1')
1305 def configureDefaultArch(self): argument
1307 if self.framework.argDB['with-default-arch']:
1309 fd.write('PETSC_ARCH='+self.arch.arch+'\n')
1310 fd.write('PETSC_DIR='+self.petscdir.dir+'\n')
1313 …self.framework.actions.addArgument('PETSc', 'Build', 'Set default architecture to '+self.arch.arch…
1322 def configureScript(self): argument
1326 …scriptName = os.path.join(self.arch.arch,'lib','petsc','conf', 'reconfigure-'+self.arch.arch+'.py')
1327 args = dict([(nargs.Arg.parseArgument(arg)[0], arg) for arg in self.framework.clArgs])
1339 args['PETSC_ARCH'] = 'PETSC_ARCH='+str(self.arch.arch)
1357 self.framework.logPrint('Unable to make reconfigure script executable:\n'+str(e))
1358 …self.framework.actions.addArgument('PETSc', 'File creation', 'Created '+scriptName+' for automatic…
1361 def configureInstall(self): argument
1363 if self.framework.argDB['prefix']:
1364 self.addMakeRule('print_mesg_after_build','',
1367 …'-@echo "%s${MAKE_USER} PETSC_DIR=${PETSC_DIR} PETSC_ARCH=${PETSC_ARCH} install"' % self.installdi…
1370 self.addMakeRule('print_mesg_after_build','',
1377 def postProcessPackages(self): argument
1379 for i in self.framework.packages:
1383 self.framework.dumpConfFiles()
1392 self.installed = 1
1396 def generateFortranBindings(self): argument
1399 dir = os.path.join(self.arch.arch,'ftn')
1401 if hasattr(self.compilers, 'FC') and self.framework.argDB['with-fortran-bindings']:
1402 self.logPrintBox('Generating Fortran binding')
1404 sys.path.append(os.path.join(self.petscdir.dir,'lib','petsc','bin'))
1406 generatefortranbindings.main(self.petscdir.dir, '', self.arch.arch, self.mpi.mpi_f08)
1410 def configure(self): argument
1411 if 'package-prefix-hash' in self.argDB:
1413 self.framework.argDB['prefix'] = ''
1414 self.dir = os.path.abspath(os.path.join(self.petscdir.dir, self.arch.arch))
1415 self.installdir.dir = self.dir
1416 self.installdir.petscDir = self.petscdir.dir
1417 self.petscDir = self.petscdir.dir
1418 self.petscArch = self.arch.arch
1419 self.addMakeMacro('PREFIXDIR',self.dir)
1420 self.confDir = os.path.abspath(os.path.join(self.petscdir.dir, self.arch.arch))
1422 if not os.path.samefile(self.petscdir.dir, os.getcwd()):
1423 …raise RuntimeError('Wrong PETSC_DIR option specified: '+str(self.petscdir.dir) + '\n Configure in…
1424 …if self.framework.argDB['prefix'] and os.path.isdir(self.framework.argDB['prefix']) and os.path.sa…
1425 …raise RuntimeError('Incorrect option --prefix='+self.framework.argDB['prefix']+' specified. It can…
1426 if self.framework.argDB['prefix'] and self.framework.argDB['prefix'].find(' ') > -1:
1427 …raise RuntimeError('Your --prefix '+self.framework.argDB['prefix']+' has spaces in it; this is not…
1428 …self.framework.argDB['prefix'] and os.path.isdir(self.framework.argDB['prefix']) and os.path.samef…
1429 …raise RuntimeError('Incorrect option --prefix='+self.framework.argDB['prefix']+' specified. It can…
1430 self.framework.header = os.path.join(self.arch.arch,'include','petscconf.h')
1431 self.framework.cHeader = os.path.join(self.arch.arch,'include','petscfix.h')
1432 self.framework.poisonheader = os.path.join(self.arch.arch,'include','petscconf_poison.h')
1433 self.framework.pkgheader = os.path.join(self.arch.arch,'include','petscpkg_version.h')
1434 …self.framework.makeMacroHeader = os.path.join(self.arch.arch,'lib','petsc','conf','petscvariables')
1435 self.framework.makeRuleHeader = os.path.join(self.arch.arch,'lib','petsc','conf','petscrules')
1436 if self.libraries.math is None:
1438 if self.languages.clanguage == 'Cxx' and not hasattr(self.compilers, 'CXX'):
1440 self.executeTest(self.configureRTLDDefault)
1441 self.executeTest(self.configurePrefetch)
1442 self.executeTest(self.configureUnused)
1443 self.executeTest(self.configureDeprecated)
1444 self.executeTest(self.configureIsatty)
1445 self.executeTest(self.configureExpect)
1446 self.executeTest(self.configureAlign)
1447 self.executeTest(self.configureFunctionName)
1448 self.executeTest(self.configureIntptrt)
1449 self.executeTest(self.configureSolaris)
1450 self.executeTest(self.configureLinux)
1451 self.executeTest(self.configureDarwin)
1452 self.executeTest(self.configureWin32)
1453 self.executeTest(self.configureCygwinBrokenPipe)
1454 self.executeTest(self.configureDefaultArch)
1455 self.executeTest(self.configureScript)
1456 self.executeTest(self.configureInstall)
1457 self.executeTest(self.configureAtoll)
1458 self.executeTest(self.configureCoverage)
1459 self.executeTest(self.configureCoverageExecutable)
1460 self.executeTest(self.configureStrictPetscErrorCode)
1461 self.executeTest(self.configureSanitize)
1462 self.executeTest(self.generateFortranBindings)
1464 self.Dump()
1465 self.dumpConfigInfo()
1466 self.dumpMachineInfo()
1467 self.delGenFiles()
1469 self.framework.storeSubstitutions(self.framework.argDB)
1470 self.framework.argDB['configureCache'] = pickle.dumps(self.framework)
1471 self.framework.argDB.save(force = True)
1472 self.DumpPkgconfig('PETSc.pc')
1473 self.DumpPkgconfig('petsc.pc')
1474 self.DumpModule()
1475 self.postProcessPackages()
1476 …self.framework.log.write('========================================================================…
1477 self.logClear()