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 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 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 "===="
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 "===="
# correspond to l and its elements. We will then track the life-cycle of these. print "make l native..." DemoExtension.argCountToString(l) print "Delete l... (but GC not yet ran)" del l 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()