def run4():
import DemoExtension
JyNI.JyRefMonitor_setMemDebugFlags(1)
l = ([0, "test"], )
l[0][0] = l
DemoExtension.argCountToString(l)
del l
#l[0][1] = None
print "Leaks before GC:"
monitor.listLeaks()
System.gc()
time.sleep(2)
print "Leaks after GC:"
monitor.listLeaks()
def tearDownClass(cls): JyNI.JyRefMonitor_setMemDebugFlags(0)
def setUpClass(cls): JyNI.JyRefMonitor_setMemDebugFlags(1)
def run1():
JyNI.JyRefMonitor_setMemDebugFlags(1)
JyWeakReferenceGC.monitorNativeCollection = True
# PyType <- Make native ref-cycle test with heap type to test partly-stub-mode.
# PySet, but no native link to other PyObject
# PyFrozenSet, "
# PyCode, not GC-relevant in CPython
import DemoExtension
#Note:
# For now we attempt to verify JyNI's GC-functionality independently from
# Jython concepts like Jython weak references or Jython GC-module.
# So we use java.lang.ref.WeakReference and java.lang.System.gc to monitor
# and control Java-gc.
#JyNI.JyRefMonitor_setMemDebugFlags(1)
#JyWeakReferenceGC.monitorNativeCollection = True
#l = (123,)
l = ([0, "test"], )
l[0][0] = l
#l = (123, {'a': 0, 'b': "test"})
#l[1]['a'] = l
#We create weak reference to l to monitor collection by Java-GC:
wkl = WeakReference(l)
print "weak(l): " + str(wkl.get())
# We pass down l to some native method. We don't care for the method itself,
# but conversion to native side causes creation of native PyObjects that
# correspond to l and its elements. We will then track the life-cycle of these.
print "make l native..."
DemoExtension.argCountToString(l)
#print "argCountToString.__doc__-address: "+str(JyNI.lookupNativeHandle(DemoExtension.argCountToString.__doc__))
#print "We access a method-doc as this used to cause problems with GC:"
#print " "+DemoExtension.argCountToString.__doc__
#print "Native static objects so far:"
#print JyNI.nativeStaticPyObjectHeads.keySet()
print "Delete l... (but GC not yet ran)"
del l
#l = None
print "weak(l) after del: " + str(wkl.get())
print ""
# monitor.list-methods display the following format:
# [native pointer]{'' | '_GC_J' | '_J'} ([type]) #[native ref-count]: [repr] *[creation time]
# _GC_J means that JyNI tracks the object
# _J means that a JyNI-GC-head exists, but the object is not actually treated by GC
# This can serve monitoring purposes or soft-keep-alive (c.f. java.lang.ref.SoftReference)
# for caching.
print "Leaks before GC:"
monitor.listLeaks()
print ""
# By inserting this line you can confirm that native
# leaks would persist if JyNI-GC is not working:
#JyWeakReferenceGC.nativecollectionEnabled = False
print "calling Java-GC..."
System.gc()
time.sleep(2)
print "weak(l) after GC: " + str(wkl.get())
print ""
monitor.listWouldDeleteNative()
print ""
print "leaks after GC:"
monitor.listLeaks()
print ""
print " " + DemoExtension.argCountToString.__doc__
monitor.listLeaks()
#print "----"
#print monitor.listAll()
print ""
print "===="
print "exit"
print "===="
def run3():
JyNI.JyRefMonitor_setMemDebugFlags(1)
JyWeakReferenceGC.monitorNativeCollection = True
import DemoExtension
#JyNI.JyRefMonitor_setMemDebugFlags(1)
#JyWeakReferenceGC.monitorNativeCollection = True
l = [0, "test1"]
# print l
# DemoExtension.listSetIndex(l, 0, 100.7)
# print l
d = {'a': 7, 'b': "test6"}
#We create weak reference to l to monitor collection by Java-GC:
wkl = WeakReference(l)
wkd = WeakReference(d)
wkl2 = weakref.ref(l)
wkd2 = weakref.ref(d)
#Note:
#=====
#To make this work we'll have to ensure that d gets a GCHead even though
#l doesn't recognize the insertion of d and thus would not explore it.
#In fact every C-stub object must get a GCHead when going native, regardless
#of whether it is inserted somewhere or not, because it might be silently
#inserted and a GCHead is the only way to detect this and fix it.
#Add a call (e.g. to size) to the dict in l on native side to test that
#d still works (which it currently shouldn't).
#Later use d's GCHead to detect the invalid graph and resurrect d's java-part.
#Take care of the GIL here. CStubs must release the GIL when they detect a
#failing backend, so the GC-thread can acquire it and resurrect the backend.
#How to fix the weak reference etc?
#l[0] = d
print "weak(l): " + str(wkl.get())
print "weak(d): " + str(wkd.get())
print "weak2(l): " + str(wkl2())
print "weak2(d): " + str(wkd2())
print "make l native..."
#l[0] = d
#DemoExtension.argCountToString(l)
#l[0] = d
DemoExtension.listSetIndex(l, 0, d)
print "Delete l... (but GC not yet ran)"
#del l
del d
#l = None
#print "weak(l) after del: "+str(wkl.get())
print "weak(d) after del: " + str(wkd.get())
print "weak2(d) after del: " + str(wkd2())
print ""
print "Leaks before GC:"
monitor.listLeaks()
print ""
print "calling Java-GC..."
System.gc()
time.sleep(2)
# if monitor.lastClearGraphValid:
# print "valid graph"
# else:
# print "invalid graph"
# monitor.lastClearGraphValid = False
print "weak(l) after GC: " + str(wkl.get())
#print "l after GC: "+str(l)
print "weak(d) after GC: " + str(wkd.get())
print "weak2(l) after GC: " + str(wkl2())
print "weak2(d) after GC: " + str(wkd2())
wkd = WeakReference(l[0])
print ""
#monitor.listWouldDeleteNative()
print ""
#print "leaks after GC:"
#monitor.listLeaks()
print "l[0], i.e. d after gc:"
#print l[0]
#print len(l[0])
print "------"
print "del l..."
del l
System.gc()
time.sleep(2)
# if monitor.lastClearGraphValid:
# print "valid graph"
# else:
# print "invalid graph"
# monitor.lastClearGraphValid = False
print ""
monitor.listWouldDeleteNative()
print ""
#print "leaks after GC (l deleted):"
#monitor.listLeaks()
#print DemoExtension.argCountToString.__doc__
#monitor.listFreeStatus("dict")
#monitor.listAll()
#GlobalRef.processDelayedCallbacks()
print "weak(d) after GC2: " + str(wkd.get())
print "weak2(l) after GC2: " + str(wkl2())
print "weak2(d) after GC2: " + str(wkd2())
System.gc()
time.sleep(2)
print "weak(d) after GC3: " + str(wkd.get())
monitor.listWouldDeleteNative()
print ""
print "leaks after GC3:"
monitor.listLeaks()
print ""
print "===="
print "exit"
print "===="