dolfin team mailing list archive

[Garth Wells <gnw20@xxxxxxxxx>]

Here's another solver that leaks. It doesn't use Expressions.


from dolfin import *

class MyProblem(NonlinearProblem):
    def __init__(self, a, L):
        NonlinearProblem.__init__(self)
        self.L = L
        self.a = a
    def F(self, b, x):
        assemble(self.L, tensor=b)
    def J(self, A, x):
        assemble(self.a, tensor=A)

mesh = UnitSquare(8, 8, "crossed")
BDM = FunctionSpace(mesh, "Brezzi-Douglas-Marini", 1)
DG = FunctionSpace(mesh, "Discontinuous Lagrange", 0)
mixed_space = MixedFunctionSpace([BDM, DG, DG])

V   = TestFunction(mixed_space)
dU  = TrialFunction(mixed_space)
U   = Function(mixed_space)
U0  = Function(mixed_space)
v, q, r    = split(V)
u, p, s    = split(U)
u0, p0, s0 = split(U0)

L = inner(v, u)*dx - div(v)*p*dx + v[0]*dx + q*div(u)*dx + r*(s - s0)*dx
a = derivative(L, U, dU)

for level0 in xrange(1000):
    for level in xrange(10):

        A = Matrix();
        b = Vector();

        # This does not appear to leak
        problem = MyProblem(a, L)
        problem.F(b, U.vector())
        problem.J(A, U.vector())

        # This does leak
        #solver  = NewtonSolver()
        #solver.solve(problem, U.vector())
    
        # This does leak (goes through call-back to Python)
        lu = LUSolver()
        lu.solve(A, U.vector(), b)

        U.vector().zero()
    print "End inner loop"

-- 
Memory leak in Python Expression interface
https://bugs.launchpad.net/bugs/521507
You received this bug notification because you are a member of DOLFIN
Team, which is subscribed to DOLFIN.

Status in DOLFIN: New

Bug description:
The below code leads to a memory leak (I see a leak over about 2MB over 90s). The leak is related to the Expression. If I comment out the call to

    eval(Array<double>&, const Array<double>&);

from 

  dolfin::GenericFunction::evaluate(double*, const double*, const ufc::cell) const

I don't detect a leak.

------

from dolfin import *
parameters["form_compiler"]["cpp_optimize"] = True
parameters["form_compiler"]["optimize"] = True

class MyExpression(Expression):
    def eval(self, values, x):
        if x[0] < DOLFIN_EPS:
            values[0] =  1.0

mesh = UnitSquare(32, 32)
for t in xrange(20000):
    for level in xrange(100):
        V  = FunctionSpace(mesh, "CG", 1)
        v  = TestFunction(V)
        u  = Function(V)
        u0 = Function(V)
        f  = MyExpression(degree=1)
        L = v*(u-u0)*dx + v*f*ds
        b = assemble(L)
    print "----"