Opened 13 years ago

Last modified 7 years ago

#715 closed defect

Parents probably not reclaimed due to too much caching — at Version 61

Reported by: robertwb Owned by: somebody
Priority: major Milestone: sage-5.5
Component: coercion Keywords: weak cache coercion Cernay2012
Cc: jpflori, zimmerma, vbraun, robertwb, nbruin, malb, mjo Merged in:
Authors: Simon King Reviewers:
Report Upstream: N/A Work issues:
Branch: Commit:
Dependencies: #9138, #11900 Stopgaps:

Description (last modified by SimonKing)

Here is a small example illustrating the issue.

The memory footprint of the following piece of code grows indefinitely.

sage: K = GF(1<<55,'t') 
sage: a = K.random_element() 
sage: while 1: 
....:     E = EllipticCurve(j=a); P = E.random_point(); 2*P; del E, P;

E and P get deleted, but when 2*P is computed, the action of integers on A, the abelian group of rational points of the ellitpic curve, gets cached in the corecion model.

A key-value pair is left in coercion_model._action_maps dict:

(ZZ,A,*) : IntegerMulAction?

Moreover there is at least also references to A in the IntegerMulAction? and one in ZZ._action_hash.

So weak refs should be used in all these places if it does not slow things too much.

Apply:

trac715_two_tripledicts.patch

Change History (63)

comment:1 Changed 13 years ago by mabshoff

  • Milestone set to sage-feature

comment:2 Changed 12 years ago by mabshoff

  • Milestone changed from sage-feature to sage-2.10.2

comment:3 Changed 11 years ago by mhansen

I think this is a bit too vague for a ticket. Robert, could you be more specific or close this?

comment:4 Changed 11 years ago by robertwb

The coercion model needs to use weakrefs so that parents aren't needlessly referenced when they're discarded. It is nontrivial to see where the weakrefs need to go, and how to do so without slowing the code down.

The ticket is still valid.

comment:5 Changed 9 years ago by davidloeffler

  • Component changed from basic arithmetic to coercion
  • Description modified (diff)
  • Report Upstream set to N/A

comment:6 Changed 9 years ago by jpflori

  • Cc jpflori added

comment:7 Changed 9 years ago by jpflori

  • Description modified (diff)

With the piece of code in the desrciption, there is only one reference to these objects in that ZZ._hash_actions dictionary because to build it we test if A1 == A2 and not A1 is A2 as in coercion_model._action_maps, and because of the current implementation of ellitpic curves, see http://groups.google.com/group/sage-nt/browse_thread/thread/ec8d0ad14a819082 and #11474, and decause the above code use only one j-invariant, only ones gets finally stored.

However with random curves, I guess there would be all of them.

About the weakref, the idea should more be to build something like WeakKeyDictionnary? if it does not slow down coercion too much...

comment:8 Changed 9 years ago by nbruin

The following example also exhibits a suspicious, steady growth in memory use. The only reason I can think of why that would happen is that references to the created finite field remain lying around somewhere, preventing deallocation:

sage: L=prime_range(10^8)
sage: for p in L: k=GF(p)

If you change it to the creation of a polynomial ring the memory use rises much faster:

sage: L=prime_range(10^8)
sage: for p in L: k=GF(p)['t']

Are "unique" parents simply *never* deallocated?

comment:9 Changed 9 years ago by jpflori

Be aware that polynomial rings are also cached because of uniqueness of parents, explaining somehow your second memory consumption; see #5970 for example.

For finite fields I did not check.

comment:10 Changed 8 years ago by zimmerma

  • Cc zimmerma added

comment:11 Changed 8 years ago by jpflori

See #11521 for some concrete instances of this problem and some advice to investigate it.

comment:12 Changed 8 years ago by SimonKing

In my code for the computation Ext algebras of basic algebras, I use letterplace algebras (see #7797), and they involve the creation of many polynomial rings. Only one of them is used at a time, so, the others could be garbage collected. But they aren't, and I suspect this is because of using strong references in the coercion cache.

See the following example (using #7797)

sage: F.<a,b,c> = FreeAlgebra(GF(4,'z'), implementation='letterplace')
sage: import gc
sage: len(gc.get_objects())
170947
sage: a*b*c*b*c*a*b*c
a*b*c*b*c*a*b*c
sage: len(gc.get_objects())
171556
sage: del F,a,b,c
sage: gc.collect()
81
sage: len(gc.get_objects())
171448
sage: cm = sage.structure.element.get_coercion_model()
sage: cm.reset_cache()
sage: gc.collect()
273
sage: len(gc.get_objects())
171108

That is certainly not a proof of my claim, but it indicates that it might be worth while to investigate.

In order to facilitate work, I am providing some other tickets that may be related to this:

I guess that one should use a similar cache model to what I did in #11521: The key for the cache should not just be (domain,codomain), because we want that garbage collection of the cache item is already allowed if just one of domain or codomain is collectable.

comment:13 Changed 8 years ago by SimonKing

I try to wrap my mind around weak references. I found that when creating a weak reference, one can also provide a method that is called when the weak reference becomes invalid. I propose to use such method to erase the deleted object from the cache, regardless whether it appears as domain or codomain.

Here is a proof of concept:

sage: ref = weakref.ref
sage: D = {}
sage: def remove(x):
....:     for a,b,c in D.keys():
....:         if a is x or b is x or c is x:
....:             D.__delitem__((a,b,c))
....:             
sage: class A:
....:     def __init__(self,x):
....:         self.x = x
....:     def __repr__(self):
....:         return str(self.x)
....:     def __del__(self):
....:         print "deleting",self.x
....:         
sage: a = A(5)
sage: b = A(6)
sage: r = ref(a,remove)
sage: s = ref(b,remove)
sage: D[r,r,s] = 1
sage: D[s,r,s] = 2
sage: D[s,s,s] = 3
sage: D[s,s,1] = 4
sage: D[r,s,1] = 5
sage: D.values()
[5, 3, 1, 4, 2]
sage: del a
deleting 5
sage: D.values()
[4, 3]
sage: del b
deleting 6
sage: D.values()
[]

comment:14 Changed 8 years ago by SimonKing

It turns out that using weak references in the coercion cache will not be enough. Apparently there are other direct references that have to be dealt with.

comment:15 Changed 8 years ago by SimonKing

I wonder whether the problem has already been solved. I just tested the example from the ticket description, and get (at least with #11900, #11521 and #11115):

sage: K = GF(1<<55,'t')
sage: a = K.random_element()
sage: m0 = get_memory_usage()
sage: for i in range(1000):
....:     E = EllipticCurve(j=a); P = E.random_point(); PP = 2*P
....:     
sage: get_memory_usage() - m0
15.22265625

I think that this is not particularly scary. I'll repeat the test with vanilla sage-4.8.alpha3, but this will take a while to rebuild.

comment:16 Changed 8 years ago by SimonKing

No, even in vanilla sage-4.8.alpha3 I don't find a scary memory leak in this example.

Do we have a better example? One could, of course, argue that one should use weak references for caching even if we do not find an apparent memory leak. I am preparing a patch for it now.

comment:17 Changed 8 years ago by SimonKing

  • Cc vbraun added

Here is an experimental patch.

A new test shows that the weak caching actually works.

Note that the patch also introduces a weak cache for polynomial rings, which might be better to put into #5970. Well, we can sort things out later...

comment:18 Changed 8 years ago by SimonKing

It needs work, though. Some tests in sage/structure fail, partially because of pickling, partially because some tests do not follow the new specification of TripleDict (namely that the first two parts of each key triple and the associated value must be weak referenceable.

comment:19 Changed 8 years ago by SimonKing

Now I wonder: Should I try to use weak references and make it accept stuff that does not allow for weak references?

In the intended applications, weak references are possible. But in some tests and in the pickle jar, the "wrong" type of keys (namely strings and ints) are used.

comment:20 Changed 8 years ago by SimonKing

The only place where the weak references are created is in the set(...) method of TripleDict. I suggest to simply catch the error that may occur when creating a weak reference, and then use a different way of storing the key. I am now running tests, and I hope that this ticket will be "needs review" in a few hours.

comment:21 Changed 8 years ago by SimonKing

  • Authors set to Simon King
  • Keywords weak cache coercion added
  • Status changed from new to needs_review

With the attached patch, all tests pass for me, and the new features are doctested. Needs review!

comment:22 Changed 8 years ago by SimonKing

  • Dependencies set to #11900

It turns out that this patch only cleanly applies after #11900. So, I introduce #11900 as a dependency. My statement on "doctests passing" was with #11900 anyway.

comment:23 Changed 8 years ago by zimmerma

I was able to apply this patch to vanilla 4.7.2. Should I continue reviewing it like this?

Paul

comment:24 Changed 8 years ago by zimmerma

on top of vanilla 4.7.2 several doctests fail:

        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/calculus/interpolators.pyx # 0 doctests failed
        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/databases/database.py # 15 doctests failed
        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/finance/time_series.pyx # 0 doctests failed
        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/graphs/graph_list.py # 4 doctests failed
        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/graphs/graph_database.py # 28 doctests failed
        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/graphs/graph.py # 6 doctests failed
        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/graphs/generic_graph.py # 4 doctests failed

        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/matrix/matrix2.pyx # 3 doctests failed
        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/modular/hecke/hecke_operator.py # 1 doctests failed
        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/modular/hecke/ambient_module.py # 2 doctests failed
        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/modular/modsym/subspace.py # 6 doctests failed
        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/modular/modsym/boundary.py # 3 doctests failed
        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/modular/modsym/space.py # 3 doctests failed
        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/modular/modsym/modsym.py # 1 doctests failed
        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/modular/modsym/ambient.py # 11 doctests failed
        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/modular/abvar/abvar.py # 0 doctests failed
        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/schemes/elliptic_curves/heegner.py # 9 doctests failed
        sage -t  4.7-linux-64bit-ubuntu_10.04.1_lts-x86_64-Linux/devel/sage-715/sage/sandpiles/sandpile.py # Time out

Paul

comment:25 Changed 8 years ago by SimonKing

I'll try again on top of vanilla sage-4.8.alpha3. You are right, the patch does apply (almost) cleanly even without #11900. That surprises me, because at some point there was an inconsistency.

Hopefully I can see later today whether I get the same errors as you.

comment:26 Changed 8 years ago by SimonKing

  • Dependencies #11900 deleted

It turns out that #11900 is indeed not needed.

I can not reproduce any of the errors you mention.

Moreover, the file "sage/devel/sage/databases/database.py", for which you reported an error, does not exist in vanilla sage (not in 4.7.2 and not in 4.8.alpha3).

Did you test other patches before returning to vanilla 4.7.2? Namely, when a patch changes a module from python to cython, and one wants to remove the patch, then it is often needed to also remove any reference to the cython module in build/sage/... and in build/*/sage/.... For example, when I had #11115 applied and want to remove it again, then I would do rm build/sage/misc/cachefunc.* and rm build/*/sage/misc/cachefunc.*.

comment:27 follow-up: Changed 8 years ago by zimmerma

yes I tried other patches (#10983, #8720, #10596) before #715, but each one with a different clone.

Paul

comment:28 in reply to: ↑ 27 Changed 8 years ago by SimonKing

Replying to zimmerma:

yes I tried other patches (#10983, #8720, #10596) before #715, but each one with a different clone.

But where does the databases/database.py file come from?

And could you post one or two examples for the errors you are getting (i.e. not just which files are problematic, but what commands exactly fail)?

comment:29 Changed 8 years ago by SimonKing

FWIW: I started with sage-4.8.alpha3, have #9138, #11900 and #715 applied, and all doctests pass. I don't know why the patchbot isn't even trying (although it says "retry: True"), but from my point of view, everything is alright.

comment:30 Changed 8 years ago by SimonKing

I have simplified the routine that removes cache items when a weak reference became invalid. The tests all pass for me.

Apply trac715_weak_coercion_cache.patch

comment:31 Changed 8 years ago by vbraun

  • Dependencies set to #9138, #11900

comment:32 Changed 8 years ago by SimonKing

One question: Currently, my patch uses weak references only for the first two parts of the key. Should it also use weak references to the value, when possible?

By "when possible", I mean that not all values allow weak references - if it is possible then a weak reference is used, otherwise a strong reference is used. This might contribute to fixing the memory leak in #11521, but it might have a speed penalty.

Concerning #11521: The point is that an action (which currently does not allow weak references, but that might change) has a strong reference to the objects that are used for storing it in the cache. Hence, an action is not collectable with the current patch.

Thoughts?

Changed 8 years ago by SimonKing

Use weak references in the coercion cache

comment:33 Changed 8 years ago by SimonKing

I have slightly updated some of the new examples: In the old patch version, I had created TripleDict(10), but meanwhile I learnt that the given parameter should better be odd (actually a prime). So, in the new patch version, it is TripleDict(11).

comment:34 Changed 8 years ago by SimonKing

  • Status changed from needs_review to needs_work
  • Work issues set to Comparison of the third key items

I think I need to modify one detail:

For efficiency and since domain/codomain of a map must be identic with (and not just equal to) the given keys, my patch compares them by "is" rather than "==". But I think one should still compare the third item of a key via "==" and not "is". I need to do some tests first...

comment:35 Changed 8 years ago by SimonKing

It really is not an easy question whether or not we should have "is" or "==".

On the one hand, we have the lines

!python
            if y_mor is not None:
                all.append("Coercion on right operand via")
                all.append(y_mor)
                if res is not None and res is not y_mor.codomain():
                    raise RuntimeError, ("BUG in coercion model: codomains not equal!", x_mor, y_mor)

in sage/structure/coerce.pyx seem to imply that comparison via "is" is the right thing to do.

But in the same file, the coercion model copes with the fact that some parents are not unique:

!python
        # Make sure the domains are correct
        if R_map.domain() is not R:
            if fix:
                connecting = R_map.domain().coerce_map_from(R)
                if connecting is not None:
                    R_map = R_map * connecting
            if R_map.domain() is not R:
                raise RuntimeError, ("BUG in coercion model, left domain must be original parent", R, R_map)
        if S_map is not None and S_map.domain() is not S:
            if fix:
                connecting = S_map.domain().coerce_map_from(S)
                if connecting is not None:
                    S_map = S_map * connecting
            if S_map.domain() is not S:
                raise RuntimeError, ("BUG in coercion model, right domain must be original parent", S, S_map)

That would suggest that comparison by "==" (the old behaviour or TripleDict) is fine.

Perhaps we should actually have to variants of TripleDict, one using "is" and one using "==".

Note another detail of sage/structure/coerce.pyx: We have

    cpdef verify_action(self, action, R, S, op, bint fix=True):

but

    cpdef verify_coercion_maps(self, R, S, homs, bint fix=False):

Note the different default value for "fix". If "fix" is True then the coercion model tries to cope with non-unique parents by prepending a conversion between the two equal copies of a parent.

Since the default is to fix non-unique parents for actions, but not for coercion maps, I suggest that a "=="-TripleDict should be used for actions and an "is"-TripleDict for coercions.

comment:36 Changed 8 years ago by jpflori

I guess a choice has to be made and that it should at lest be as consistent as possible. What you propose makes sense to me, is not too far from the current model and gives a little more conssitency. Moreover, when both TripleDicts? will have been implemented, changing our mind later will be trivial.

comment:37 Changed 8 years ago by SimonKing

There is another detail. Even in the old version of TripleDict, we have

    It is implemented as a list of lists (hereafter called buckets). The bucket 
    is chosen according to a very simple hash based on the object pointer.
    and each bucket is of the form [k1, k2, k3, value, k1, k2, k3, value, ...]
    on which a linear search is performed. 

So, the choice of a bucket is based on the object pointer - but then it is not consequent to compare by "==".

comment:38 Changed 8 years ago by SimonKing

To be precise: The old behaviour was not consequent. The bucket depended on id(k1),id(k2),id(k3), but the comparison was by "==" rather than by "is".

Experimentally, I will provide two versions of TripleDict, one using "hash"for determining the bucket and doing comparison by "==", the other using "id" for determining the bucket and doing comparison by "is".

comment:39 Changed 8 years ago by SimonKing

  • Work issues changed from Comparison of the third key items to fix doctests

As announced, I have attached an experimental patch. It provides two variants of TripleDict, namely using "==" or "is" for comparison, respectively. Both are used, namely for caching coerce maps or actions, respectively.

It could be that a last-minute change was interfering, but I am confident that all but the following three tests pass:

        sage -t  devel/sage-main/doc/en/bordeaux_2008/nf_introduction.rst # 1 doctests failed
        sage -t  devel/sage-main/sage/modular/modsym/space.py # Killed/crashed
        sage -t  devel/sage-main/sage/structure/coerce_dict.pyx # 3 doctests failed

The memory leak exposed in the ticket description is fixed (more or less):

sage: K = GF(1<<55,'t')
sage: a = K.random_element()
sage: for i in range(500):
....:     E = EllipticCurve(j=a)
....:     P = E.random_point()
....:     Q = 2*P
....:     
sage: import gc
sage: gc.collect()
862
sage: from sage.schemes.generic.homset import SchemeHomsetModule_abelian_variety_coordinates_field
sage: LE = [x for x in gc.get_objects() if  isinstance(x,SchemeHomsetModule_abelian_variety_coordinates_field)]
sage: len(LE)
2

I am not sure whether this makes #11521 redundant.

For now, it is "needs work, because of the doctests. But you can already play with the patch.

comment:40 Changed 8 years ago by SimonKing

Sorry, only TWO doctests should fail: The tests of sage/structure/coerce_dict.pyx are, of course, fixed.

comment:41 Changed 8 years ago by SimonKing

The segfault in sage -t devel/sage-main/sage/modular/modsym/space.py seems difficult to debug.

Inspecting a core dump with gdb did not help at all:

(gdb) bt
#0  0x00007f61d12ca097 in kill () from /lib64/libc.so.6
#1  0x00007f61d0044a40 in sigdie () from /home/simon/SAGE/sage-4.8.alpha3/local/lib/libcsage.so
#2  0x00007f61d0044646 in sage_signal_handler () from /home/simon/SAGE/sage-4.8.alpha3/local/lib/libcsage.so
#3  <signal handler called>
#4  0x00007f61cf080520 in mpn_submul_1 () from /home/simon/SAGE/sage-4.8.alpha3/local/lib/libgmp.so.8
#5  0x00007f61cf0b4f0f in __gmpn_sb_bdiv_q () from /home/simon/SAGE/sage-4.8.alpha3/local/lib/libgmp.so.8
#6  0x00007f61cf0b6428 in __gmpn_divexact () from /home/simon/SAGE/sage-4.8.alpha3/local/lib/libgmp.so.8
#7  0x00007f61ccbf4d64 in ?? ()
...
#191 0x55c0ade81d9aeecf in ?? ()
#192 0xffffe4b8b6920b7b in ?? ()
#193 0x000000000ac854cf in ?? ()
#194 0x0000000000000000 in ?? ()

How could one proceed? What other debugging techniques can you recommend?

comment:42 follow-up: Changed 8 years ago by vbraun

Looks like you did not tell gdb about the executable you were running. You should run

gdb --core=<corefile> $SAGE_LOCAL/bin/python

comment:43 in reply to: ↑ 42 Changed 8 years ago by SimonKing

Replying to vbraun:

Looks like you did not tell gdb about the executable you were running.

No, I did tell it. I did

gdb --core=715doublecore ~/SAGE/sage-4.8.alpha3/local/bin/python

Should I do it inside a Sage shell?

comment:44 Changed 8 years ago by SimonKing

No, doing the same inside a sage shell did not help either.

comment:45 Changed 8 years ago by SimonKing

I am now printing some debugging information into a file, which hopefully means that I am coming closer to the source of the problem. The segfault arises in line 2165 of sage/modular/modsym/space.py

comment:46 Changed 8 years ago by SimonKing

Sorry, it was the wrong line number.

comment:47 Changed 8 years ago by SimonKing

Meanwhile I am rather desperate: I have not the faintest idea how the segfault occurs.

Therefore I used some debugging function that I registered using sys.settrace(...), so that all Python commands in the critical example are written into a file.

I posted logs for the unpatched and the patched version.

There is one obvious difference of the two logs: The hash is called more often in the patched version. Calling the hash is rather inefficient for matrix spaces: Each time when the hash of a matrix space is called, the matrix space's string representation is created, which is slow. I suggest to cache the hash value (like what I did for polynomial rings in #9944), but this should be on a different ticket.

Apart from that, I can't spot an obvious difference. Do you have any clue?

comment:48 Changed 8 years ago by SimonKing

It turns out that using TripleDictById for the _action_maps cache makes the segfault disappear.

If one uses TripleDict for _coercion_maps then

sage -t  devel/sage-main/sage/modular/modsym/space.py

takes 30 seconds, but if one also uses TripleDictById then it only takes 23 seconds.

My conclusion:

  • The old version of TripleDict was buggy: It uses id(...) for the hash table, but == for comparison. I think that had to be fixed.
  • The new version of TripleDict uses hash(...) for the hash table and == for comparison. That should be fine, but (1) it leads to a segfault and (2) it leads to a slowdown. After all, calling hash(...) is a lot slower than determining the address.
  • The new TripleDictById uses id(...) for the hash table and ... is ... for comparison. Problem: It would probably not fix the memory leak.

However, the fact that using TripleDictById fixes the segfault makes me wonder: Perhaps the segfault occurs when calling hash(...) on a parent? Namely, in some cases, and action will already be constructed during initialisation of a parent. But if the hash is determined based on cdef data that aren't initialised, a segfault can easily occur.

I'll investigate that further. In any case, we need to keep an eye on the potential slow-down.

comment:49 Changed 8 years ago by SimonKing

The segfault does not occur while computing a hash. It occurs in line 468 of sage/matrix/matrix_rational_dense.pyx, namely

                mpq_mul(y, w._entries[j], self._matrix[j][i])

I also tested, just before that line, that w[j] and self.get_unsafe(j,i) (which accesses w._entries[j] and self._matrix[j],[i]) works.

At this point, I am at my wits' end. To me, it looks like a change in the way of comparing dictionary keys modifies internals of mpir (IIRC, this is where mpq_mul is defined). gdb can not decipher the core file, and I don't know how valgrind can be used.

What else?

comment:50 follow-up: Changed 8 years ago by vbraun

Which patches did you apply? With only trac715_two_tripledicts.patch applied sage doesn't start.

comment:51 in reply to: ↑ 50 Changed 8 years ago by SimonKing

Replying to vbraun:

Which patches did you apply? With only trac715_two_tripledicts.patch applied sage doesn't start.

What???

According to hg qapplied, I have

trac_12057_fix_doctests.patch
9138_flat.patch
trac_11319_prime_field_coercion.patch
trac_11319_number_field_example.patch
trac11900_category_speedup_combined.patch
11115_flat.patch
trac_11115_docfix.patch
trac715_two_tripledicts.patch

Remark: I work on openSUSE, hence, I had to apply #12131 and thus also its dependency #12057. I doubt that the absence of #11115 is responsible for Sage not starting. And all other patches are dependencies.

What error occurs when you start Sage with my patch? If we are lucky, it gives some clue why the segfault in the one doctest occurs.

Best regards,

Simon

comment:52 Changed 8 years ago by SimonKing

PS: I started on top of sage-4.8.alpha3.

comment:53 Changed 8 years ago by SimonKing

Meanwhile I built sage-5.0.prealpha0 and applied #11780 and trac715_two_tripledicts.patch. Sage starts fine.

So, Volker, what had you have applied when Sage didn't start?

comment:54 Changed 8 years ago by SimonKing

I think I made a progress: I found that the vector space that is part of the crash is not unique! So, the VectorMatrixAction is defined for a vector space that is equal to but not identical with the vector space it is acting on!

The natural solution is to try and find out why the vector space is not unique. Vector spaces should be created using the VectorSpace constructor, that relies on a UniqueFactory. But apparently some very old code is constructing a vector space directly - it wouldn't be the first time that this is causing trouble.

comment:55 Changed 8 years ago by SimonKing

PS: Note that vector spaces with different inner product are considered equal.

sage: V = QQ^5
sage: M = random_matrix(QQ,5,5)
sage: M.set_immutable()
sage: W = VectorSpace(QQ,5,inner_product_matrix=M)
sage: V
Vector space of dimension 5 over Rational Field
sage: W
Ambient quadratic space of dimension 5 over Rational Field
Inner product matrix:
[   0  1/2    1   -1   -1]
[   0    0    0    1 -1/2]
[  -2    0    0    0    0]
[   1    0    2    0    0]
[   0   -2    0    1    0]
sage: V==W
True
sage: type(V)==type(W)
False

But this is not the problem here: The two equal vector spaces involved in the crash have default inner product.

The non-uniqueness makes me think of another potential solution: The coercion model has a method "verify_action". This is only called when a new action is found, but not when an action is taken from the cache.

So, in addition to fixing the non-unique vector space in the modular symbols code, one could always verify the action. Probably this would be too slow, though.

comment:56 Changed 8 years ago by SimonKing

Aha! We have a sparse versus a dense vector space! Here is our problem!

comment:57 Changed 8 years ago by vbraun

I did manage to install it and reproduce the crash. The core dump shows that the stack is completely corrupted before we called into gmp code.

comment:58 Changed 8 years ago by SimonKing

Hi Volker,

good that you managed to install it. Meanwhile I think I can debug it without the core dump - I think mistaking a sparse with a dense vector space is a pretty convincing reason for a segfault.

However, I hate that old code!!

I tried verify_action, but then hundreds of tests fail in sage/modular/modsym/space.py. So, apparently it is very common to have non-unique parents in such a way that the action can not be fixed!

For example, I see errors like

    TypeError: Coercion of [Infinity] - [0] (of type <class 'sage.modular.modsym.boundary.BoundarySpaceElement'>) into Space of Boundary Modular Symbols for Congruence Subgroup Gamma0(43) of weight 2 and over Rational Field not (yet) defined.

Anyway, verify_action is no solution.

comment:59 Changed 8 years ago by jpflori

Hi all,

Just wanted to say I had no problem installing the new patch on top of sage.4.8.alpha5 with tickets #9138 #11900 #1115 #715 and #11521 in that order and Sage launches. I'll start a make ptestlong now.

comment:60 Changed 8 years ago by SimonKing

Hi Jean-Pierre,

don't start ptestlong - I am about to update the new patch such that the segfault does not occur and the time for executing the test is fine and the memleak is gone!

Changed 8 years ago by SimonKing

Use weak references to the keys of TripleDict. Compare by "==" or by "is", depending on the application. Use weak references for storing actions.

comment:61 Changed 8 years ago by SimonKing

  • Description modified (diff)
  • Status changed from needs_work to needs_review
  • Work issues fix doctests deleted

See the updated patch:

Apply trac715_two_tripledicts.patch

Note: See TracTickets for help on using tickets.