/usr/lib/python2.7/dist-packages/dolfin/compilemodules/jit.py is in python-dolfin 1.3.0+dfsg-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 | """This module defines a jit function that wraps the jit function for
the chosen form compiler."""
# Copyright (C) 2008-2009 Johan Hake
#
# This file is part of DOLFIN.
#
# DOLFIN is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# DOLFIN is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with DOLFIN. If not, see <http://www.gnu.org/licenses/>.
#
# Modified by Anders Logg, 2008-2009.
# Modified by Garth N. Wells, 2011.
#
# First added: 2008-12-04
# Last changed: 2011-09-10
__all__ = ["jit"]
from functools import wraps
# Import SWIG-generated extension module (DOLFIN C++)
import dolfin.cpp as cpp
from dolfin.cpp import MPI, info, parameters, warning, info
# Set UFL log level
import ufl
ufl.set_level(ufl.INFO)
def mpi_jit_decorator(local_jit, *args, **kwargs):
"""A decorator for jit compilation
Use this function as a decorator to any jit compiler function. In
a paralell run, this function will first call the jit compilation
function on the first process. When this is done, and the module
is in the cache, it will call the jit compiler on the remaining
processes, which will then use the cached module.
*Example*
.. code-block:: python
def jit_something(something):
....
"""
@wraps(local_jit)
def mpi_jit(*args, **kwargs):
# Just call JIT compiler when running in serial
if MPI.num_processes() == 1:
return local_jit(*args, **kwargs)
# Compile first on process 0
if MPI.process_number() == 0:
output = local_jit(*args, **kwargs)
# Wait for the first process to finish
MPI.barrier()
# Then compile on all other processes (which may then just read the cache)
if not MPI.process_number() == 0:
output = local_jit(*args,**kwargs)
return output
# Return the decorated jit function
return mpi_jit
@mpi_jit_decorator
def jit(form, form_compiler_parameters=None, common_cell=None):
"""Just-in-time compile any provided form.
It uses the jit function from the form compiler registered by
parameters["form_compiler"]["name"].
"""
# Check that form is not empty
if isinstance(form, ufl.Form):
if form.integrals() == ():
raise RuntimeError, "Form is empty. Cannot pass to JIT compiler."
# Import form compiler
form_compiler_name = cpp.parameters["form_compiler"]["name"]
try:
form_compiler = __import__(form_compiler_name)
except ImportError, message:
print message
warning("Could not import %s form compiler, falling back to FFC." % form_compiler_name)
try:
form_compiler = __import__("ffc")
except:
cpp.dolfin_error("jit.py",
"perform just-in-time compilation of form",
"Could not import FFC form compiler")
# Prepare form compiler parameters
p = form_compiler.default_parameters()
# Set parameters from global DOLFIN parameter set
for key, value in parameters["form_compiler"].iteritems():
p[key] = value
# Override with local parameters if any
if form_compiler_parameters:
p.update(form_compiler_parameters)
# Get jit function
try:
jit_compile = form_compiler.jit
except AttributeError:
raise RuntimeError, "Form compiler must implement the jit function."
return jit_compile(form, parameters=p, common_cell=common_cell)
|