"""Unit tests for the JIT compiler"""
# Copyright (C) 2011 Anders Logg
#
# 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 .
import pytest
import platform
import dolfin
from dolfin import *
from dolfin_utils.test import (skip_if_not_PETSc, skip_if_not_SLEPc,
skip_if_not_MPI, skip_in_serial,
skip_if_not_petsc4py)
def test_nasty_jit_caching_bug():
# This may result in something like "matrices are not aligned"
# from FIAT if the JIT caching does not recognize that the two
# forms are different
default_parameters = parameters["form_compiler"]["representation"]
for representation in ["quadrature"]:
parameters["form_compiler"]["representation"] = representation
M1 = assemble(Constant(1.0)*dx(UnitSquareMesh(4, 4)))
M2 = assemble(Constant(1.0)*dx(UnitCubeMesh(4, 4, 4)))
assert round(M1 - 1.0, 7) == 0
assert round(M2 - 1.0, 7) == 0
parameters["form_compiler"]["representation"] = default_parameters
def test_mpi_pybind11():
"""
Test MPICommWrapper <-> mpi4py.MPI.Comm conversion for JIT-ed code
"""
cpp_code = """
#include
#include
namespace dolfin
{
dolfin_wrappers::MPICommWrapper
test_comm_passing(const dolfin_wrappers::MPICommWrapper comm)
{
MPI_Comm c = comm.get();
return dolfin_wrappers::MPICommWrapper(c);
}
}
PYBIND11_MODULE(SIGNATURE, m)
{
m.def("test_comm_passing", &dolfin::test_comm_passing);
}
"""
# Import MPI_COMM_WORLD
if dolfin.has_mpi4py():
from mpi4py import MPI
w1 = MPI.COMM_WORLD
else:
w1 = dolfin.MPI.comm_world
# Compile the JIT module
return pytest.xfail('Include path for dolfin_wrappers/* not set up to '
'work in the JIT at the moment')
mod = dolfin.compile_cpp_code(cpp_code)
# Pass a comm into C++ and get a new wrapper of the same comm back
w2 = mod.test_comm_passing(w1)
if dolfin.has_mpi4py():
assert isinstance(w2, MPI.Comm)
else:
assert isinstance(w2, dolfin.cpp.MPICommWrapper)
assert w1.underlying_comm() == w2.underlying_comm()
@skip_if_not_PETSc
def test_petsc():
create_matrix_code = r'''
#include
#include
namespace dolfin
{
std::shared_ptr create_matrix(void) {
Mat I;
std::shared_ptr ptr = std::make_shared(I);
return ptr;
}
}
PYBIND11_MODULE(SIGNATURE, m)
{
m.def("create_matrix", &dolfin::create_matrix);
}
'''
module = compile_cpp_code(create_matrix_code)
@pytest.mark.skip
@skip_if_not_SLEPc
def test_slepc():
create_eps_code = r'''
#include
#include
#include
namespace dolfin
{
std::shared_ptr create_matrix(MPI_Comm comm) {
EPS eps;
EPSCreate(comm, &eps);
std::shared_ptr ptr = std::make_shared(eps);
return ptr;
}
}
PYBIND11_MODULE(SIGNATURE, m)
{
m.def("create_matrix", &dolfin::create_matrix);
}
'''
compile_cpp_code(create_eps_code)
def test_pass_array_int():
import numpy
code = """
#include
#include
#include
using IntVecIn = Eigen::Ref;
int test_int_array(const IntVecIn arr)
{
return arr.sum();
}
PYBIND11_MODULE(SIGNATURE, m)
{
m.def("test_int_array", &test_int_array);
}
"""
module = compile_cpp_code(code)
arr = numpy.array([1, 2, 4, 8], dtype=numpy.intc)
ans = module.test_int_array(arr)
assert ans == arr.sum() == 15
def test_pass_array_double():
import numpy
code = """
#include
#include
#include
using DoubleVecIn = Eigen::Ref;
int test_double_array(const DoubleVecIn arr)
{
return arr.sum();
}
PYBIND11_MODULE(SIGNATURE, m)
{
m.def("test_double_array", &test_double_array);
}
"""
module = compile_cpp_code(code)
arr = numpy.array([1, 2, 4, 8], dtype=float)
ans = module.test_double_array(arr)
assert abs(arr.sum() - 15) < 1e-15
assert abs(ans - 15) < 1e-15
@pytest.mark.skip
@skip_if_not_PETSc
def test_compile_extension_module():
# This test should do basically the same as the docstring of the
# compile_extension_module function in compilemodule.py. Remember
# to update the docstring if the test is modified!
from numpy import arange, exp
code = """
#include
#include
#include
void PETSc_exp(std::shared_ptr vec)
{
Vec x = vec->vec();
assert(x);
VecExp(x);
}
PYBIND11_MODULE(SIGNATURE, m)
{
m.def("PETSc_exp", &PETSc_exp);
}
"""
ext_module = compile_cpp_code(code)
vec = PETScVector(MPI.comm_world, 10)
np_vec = vec.get_local()
np_vec[:] = arange(len(np_vec))
vec.set_local(np_vec)
ext_module.PETSc_exp(vec)
np_vec[:] = exp(np_vec)
assert (np_vec == vec.get_local()).all()
@pytest.mark.xfail
def test_compile_extension_module_kwargs():
# This test check that instant_kwargs of compile_extension_module
# are taken into account when computing signature
m2 = compile_cpp_code('', cppargs='-O2')
m0 = compile_cpp_code('', cppargs='')
assert not m2.__file__ == m0.__file__
@pytest.mark.skip
@skip_if_not_petsc4py
@skip_in_serial
def test_mpi_dependent_jiting():
# FIXME: Not a proper unit test...
from dolfin import (Expression, UnitSquareMesh, Function,
TestFunction, Form, FunctionSpace, dx, CompiledSubDomain,
SubSystemsManager)
# Init petsc (needed to initalize petsc and slepc collectively on
# all processes)
SubSystemsManager.init_petsc()
try:
import mpi4py.MPI as mpi
except:
return
try:
import petsc4py.PETSc as petsc
except:
return
# Set communicator and get process information
comm = mpi.COMM_WORLD
group = comm.Get_group()
size = comm.Get_size()
# Only consider parallel runs
if size == 1:
return
rank = comm.Get_rank()
group_comm_0 = petsc.Comm(comm.Create(group.Incl(range(1))))
group_comm_1 = petsc.Comm(comm.Create(group.Incl(range(1, 2))))
if size > 2:
group_comm_2 = petsc.Comm(comm.Create(group.Incl(range(2,size))))
if rank == 0:
e = Expression("4", mpi_comm=group_comm_0, degree=0)
elif rank == 1:
e = Expression("5", mpi_comm=group_comm_1, degree=0)
domain = CompiledSubDomain("on_boundary", mpi_comm=group_comm_1,
degree=0)
else:
mesh = UnitSquareMesh(group_comm_2, 2, 2)
V = FunctionSpace(mesh, "P", 1)
u = Function(V)
v = TestFunction(V)
Form(u*v*dx)