test/2042-reference-processing/src/Main.java - LeafOS-Project/android_art - Gitiles

 /*
  * Copyright (C) 2022 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 import java.lang.ref.PhantomReference;
 import java.lang.ref.Reference;
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.WeakReference;
 import java.math.BigInteger;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.TreeMap;

 /**
  * Test that objects get finalized and their references cleared in the right order.
  *
  * We maintain a list of nominally MAX_LIVE_OBJS numbered finalizable objects.
  * We then alternately drop the last 50, and add 50 more. When we see an object finalized
  * or its reference cleared, we make sure that the preceding objects in its group of 50
  * have also had their references cleared. We also perform a number of other more
  * straightforward checks, such as ensuring that all references are eventually cleared,
  * and all objects are finalized.
  */
 public class Main {
     // TODO(b/216481630) Enable CHECK_PHANTOM_REFS. This currently occasionally reports a few
     // PhantomReferences as not enqueued. If this report is correct, this needs to be tracked
     // down and fixed.
     static final boolean CHECK_PHANTOM_REFS = false;

     static final int MAX_LIVE_OBJS = 150;
     static final int DROP_OBJS = 50;  // Number of linked objects dropped in each batch.
     static final int MIN_LIVE_OBJS = MAX_LIVE_OBJS - DROP_OBJS;
     static final int TOTAL_OBJS = 200_000;  // Allocate this many finalizable objects in total.
     static final boolean REPORT_DROPS = false;
     static volatile boolean pleaseStop;

     AtomicInteger totalFinalized = new AtomicInteger(0);
     int maxDropped = 0;
     int liveObjects = 0;

     // Number of next finalizable object to be allocated.
     int nextAllocated = 0;

     // List of finalizable objects in descending order. We add to the front and drop
     // from the rear.
     FinalizableObject listHead;

     // A possibly incomplete list of FinalizableObject indices that were finalized, but
     // have yet to be checked for consistency with reference processing.
     ArrayBlockingQueue<Integer> finalized = new ArrayBlockingQueue<>(20_000);

     // Maps from object number to Reference; Cleared references are deleted when queues are
     // processed.
     TreeMap<Integer, MyWeakReference> weakRefs = new TreeMap<>();
     ConcurrentHashMap<Integer, MyPhantomReference> phantomRefs = new ConcurrentHashMap<>();

     class FinalizableObject {
         int n;
         FinalizableObject next;
         FinalizableObject(int num, FinalizableObject nextObj) {
             n = num;
             next = nextObj;
         }
         protected void finalize() {
             if (!inPhantomRefs(n)) {
                 System.out.println("PhantomRef enqueued before finalizer ran");
             }
             totalFinalized.incrementAndGet();
             if (!finalized.offer(n) && REPORT_DROPS) {
                 System.out.println("Dropped finalization of " + n);
             }
         }
     }
     ReferenceQueue<FinalizableObject> refQueue = new ReferenceQueue<>();
     class MyWeakReference extends WeakReference<FinalizableObject> {
         int n;
         MyWeakReference(FinalizableObject obj) {
             super(obj, refQueue);
             n = obj.n;
         }
     };
     class MyPhantomReference extends PhantomReference<FinalizableObject> {
         int n;
         MyPhantomReference(FinalizableObject obj) {
             super(obj, refQueue);
             n = obj.n;
         }
     }
     boolean inPhantomRefs(int n) {
         MyPhantomReference ref = phantomRefs.get(n);
         if (ref == null) {
             return false;
         }
         if (ref.n != n) {
             System.out.println("phantomRef retrieval failed");
         }
         return true;
     }

     void CheckOKToClearWeak(int num) {
         if (num > maxDropped) {
             System.out.println("WeakRef to live object " + num + " was cleared/enqueued.");
         }
         int batchEnd = (num / DROP_OBJS + 1) * DROP_OBJS;
         for (MyWeakReference wr : weakRefs.subMap(num + 1, batchEnd).values()) {
             if (wr.n <= num || wr.n / DROP_OBJS != num / DROP_OBJS) {
                 throw new AssertionError("MyWeakReference logic error!");
             }
             // wr referent was dropped in same batch and precedes it in list.
             if (wr.get() != null) {
                 // This violates the WeakReference spec, and can result in strong references
                 // to objects that have been cleaned.
                 System.out.println("WeakReference to " + wr.n
                     + " was erroneously cleared after " + num);
             }
         }
     }

     void CheckOKToClearPhantom(int num) {
         if (num > maxDropped) {
             System.out.println("PhantomRef to live object " + num + " was enqueued.");
         }
         MyWeakReference wr = weakRefs.get(num);
         if (wr != null && wr.get() != null) {
             System.out.println("PhantomRef cleared before WeakRef for " + num);
         }
     }

     void emptyAndCheckQueues() {
         // Check recently finalized objects for consistency with cleared references.
         while (true) {
             Integer num = finalized.poll();
             if (num == null) {
                 break;
             }
             MyWeakReference wr = weakRefs.get(num);
             if (wr != null) {
                 if (wr.n != num) {
                     System.out.println("Finalization logic error!");
                 }
                 if (wr.get() != null) {
                     System.out.println("Finalizing object with uncleared reference");
                 }
             }
             CheckOKToClearWeak(num);
         }
         // Check recently enqueued references for consistency.
         while (true) {
             Reference<FinalizableObject> ref = (Reference<FinalizableObject>) refQueue.poll();
             if (ref == null) {
                 break;
             }
             if (ref instanceof MyWeakReference) {
                 MyWeakReference wr = (MyWeakReference) ref;
                 if (wr.get() != null) {
                     System.out.println("WeakRef " + wr.n + " enqueued but not cleared");
                 }
                 CheckOKToClearWeak(wr.n);
                 if (weakRefs.remove(Integer.valueOf(wr.n)) != ref) {
                     System.out.println("Missing WeakReference: " + wr.n);
                 }
             } else if (ref instanceof MyPhantomReference) {
                 MyPhantomReference pr = (MyPhantomReference) ref;
                 CheckOKToClearPhantom(pr.n);
                 if (phantomRefs.remove(Integer.valueOf(pr.n)) != ref) {
                     System.out.println("Missing PhantomReference: " + pr.n);
                 }
             } else {
                 System.out.println("Found unrecognized reference in queue");
             }
         }
     }


     /**
      * Add n objects to the head of the list. These will be assigned the next n consecutive
      * numbers after the current head of the list.
      */
     void addObjects(int n) {
         for (int i = 0; i < n; ++i) {
             int me = nextAllocated++;
             listHead = new FinalizableObject(me, listHead);
             weakRefs.put(me, new MyWeakReference(listHead));
             phantomRefs.put(me, new MyPhantomReference(listHead));
         }
         liveObjects += n;
     }

     /**
      * Drop n finalizable objects from the tail of the list. These are the lowest-numbered objects
      * in the list.
      */
     void dropObjects(int n) {
         FinalizableObject list = listHead;
         FinalizableObject last = null;
         if (n > liveObjects) {
             System.out.println("Removing too many elements");
         }
         if (liveObjects == n) {
             maxDropped = list.n;
             listHead = null;
         } else {
             final int skip = liveObjects - n;
             for (int i = 0; i < skip; ++i) {
                 last = list;
                 list = list.next;
             }
             int expected = nextAllocated - skip - 1;
             if (list.n != expected) {
                 System.out.println("dropObjects found " + list.n + " but expected " + expected);
             }
             maxDropped = expected;
             last.next = null;
         }
         liveObjects -= n;
     }

     void testLoop() {
         System.out.println("Starting");
         addObjects(MIN_LIVE_OBJS);
         final int ITERS = (TOTAL_OBJS - MIN_LIVE_OBJS) / DROP_OBJS;
         for (int i = 0; i < ITERS; ++i) {
             addObjects(DROP_OBJS);
             if (liveObjects != MAX_LIVE_OBJS) {
                 System.out.println("Unexpected live object count");
             }
             dropObjects(DROP_OBJS);
             if (i % 100 == 0) {
               // Make sure we don't fall too far behind, otherwise we may run out of memory.
               System.runFinalization();
             }
             emptyAndCheckQueues();
         }
         dropObjects(MIN_LIVE_OBJS);
         if (liveObjects != 0 || listHead != null) {
             System.out.println("Unexpected live objecs at end");
         }
         if (maxDropped != TOTAL_OBJS - 1) {
             System.out.println("Unexpected dropped object count: " + maxDropped);
         }
         for (int i = 0; i < 2; ++i) {
             Runtime.getRuntime().gc();
             System.runFinalization();
             emptyAndCheckQueues();
         }
         if (!weakRefs.isEmpty()) {
             System.out.println("Weak Reference map nonempty size = " + weakRefs.size());
         }
         if (CHECK_PHANTOM_REFS && !phantomRefs.isEmpty()) {
             try {
                 Thread.sleep(500);
             } catch (InterruptedException e) {
                 System.out.println("Unexpected interrupt");
             }
             if (!phantomRefs.isEmpty()) {
                 System.out.println("Phantom Reference map nonempty size = " + phantomRefs.size());
                 System.out.print("First elements:");
                 int i = 0;
                 for (MyPhantomReference pr : phantomRefs.values()) {
                     System.out.print(" " + pr.n);
                     if (++i > 10) {
                         break;
                     }
                 }
                 System.out.println("");
             }
         }
         if (totalFinalized.get() != TOTAL_OBJS) {
             System.out.println("Finalized only " + totalFinalized + " objects");
         }
     }

     static Runnable causeGCs = new Runnable() {
         public void run() {
             // Allocate a lot.
             BigInteger counter = BigInteger.ZERO;
             while (!pleaseStop) {
                 counter = counter.add(BigInteger.TEN);
             }
             // Look at counter to reduce chance of optimizing out the allocation.
             if (counter.longValue() % 10 != 0) {
                  System.out.println("Bad causeGCs counter value: " + counter);
             }
         }
     };

     public static void main(String[] args) throws Exception {
         Main theTest = new Main();
         Thread gcThread = new Thread(causeGCs);
         gcThread.setDaemon(true);  // Terminate if main thread dies.
         gcThread.start();
         theTest.testLoop();
         pleaseStop = true;
         gcThread.join();
         System.out.println("Finished");
     }
 }
	/*
	* Copyright (C) 2022 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	import java.lang.ref.PhantomReference;
	import java.lang.ref.Reference;
	import java.lang.ref.ReferenceQueue;
	import java.lang.ref.WeakReference;
	import java.math.BigInteger;
	import java.util.concurrent.ArrayBlockingQueue;
	import java.util.concurrent.atomic.AtomicInteger;
	import java.util.concurrent.ConcurrentHashMap;
	import java.util.TreeMap;

	/**
	* Test that objects get finalized and their references cleared in the right order.
	*
	* We maintain a list of nominally MAX_LIVE_OBJS numbered finalizable objects.
	* We then alternately drop the last 50, and add 50 more. When we see an object finalized
	* or its reference cleared, we make sure that the preceding objects in its group of 50
	* have also had their references cleared. We also perform a number of other more
	* straightforward checks, such as ensuring that all references are eventually cleared,
	* and all objects are finalized.
	*/
	public class Main {
	// TODO(b/216481630) Enable CHECK_PHANTOM_REFS. This currently occasionally reports a few
	// PhantomReferences as not enqueued. If this report is correct, this needs to be tracked
	// down and fixed.
	static final boolean CHECK_PHANTOM_REFS = false;

	static final int MAX_LIVE_OBJS = 150;
	static final int DROP_OBJS = 50; // Number of linked objects dropped in each batch.
	static final int MIN_LIVE_OBJS = MAX_LIVE_OBJS - DROP_OBJS;
	static final int TOTAL_OBJS = 200_000; // Allocate this many finalizable objects in total.
	static final boolean REPORT_DROPS = false;
	static volatile boolean pleaseStop;

	AtomicInteger totalFinalized = new AtomicInteger(0);
	int maxDropped = 0;
	int liveObjects = 0;

	// Number of next finalizable object to be allocated.
	int nextAllocated = 0;

	// List of finalizable objects in descending order. We add to the front and drop
	// from the rear.
	FinalizableObject listHead;

	// A possibly incomplete list of FinalizableObject indices that were finalized, but
	// have yet to be checked for consistency with reference processing.
	ArrayBlockingQueue<Integer> finalized = new ArrayBlockingQueue<>(20_000);

	// Maps from object number to Reference; Cleared references are deleted when queues are
	// processed.
	TreeMap<Integer, MyWeakReference> weakRefs = new TreeMap<>();
	ConcurrentHashMap<Integer, MyPhantomReference> phantomRefs = new ConcurrentHashMap<>();

	class FinalizableObject {
	int n;
	FinalizableObject next;
	FinalizableObject(int num, FinalizableObject nextObj) {
	n = num;
	next = nextObj;
	}
	protected void finalize() {
	if (!inPhantomRefs(n)) {
	System.out.println("PhantomRef enqueued before finalizer ran");
	}
	totalFinalized.incrementAndGet();
	if (!finalized.offer(n) && REPORT_DROPS) {
	System.out.println("Dropped finalization of " + n);
	}
	}
	}
	ReferenceQueue<FinalizableObject> refQueue = new ReferenceQueue<>();
	class MyWeakReference extends WeakReference<FinalizableObject> {
	int n;
	MyWeakReference(FinalizableObject obj) {
	super(obj, refQueue);
	n = obj.n;
	}
	};
	class MyPhantomReference extends PhantomReference<FinalizableObject> {
	int n;
	MyPhantomReference(FinalizableObject obj) {
	super(obj, refQueue);
	n = obj.n;
	}
	}
	boolean inPhantomRefs(int n) {
	MyPhantomReference ref = phantomRefs.get(n);
	if (ref == null) {
	return false;
	}
	if (ref.n != n) {
	System.out.println("phantomRef retrieval failed");
	}
	return true;
	}

	void CheckOKToClearWeak(int num) {
	if (num > maxDropped) {
	System.out.println("WeakRef to live object " + num + " was cleared/enqueued.");
	}
	int batchEnd = (num / DROP_OBJS + 1) * DROP_OBJS;
	for (MyWeakReference wr : weakRefs.subMap(num + 1, batchEnd).values()) {
	if (wr.n <= num \|\| wr.n / DROP_OBJS != num / DROP_OBJS) {
	throw new AssertionError("MyWeakReference logic error!");
	}
	// wr referent was dropped in same batch and precedes it in list.
	if (wr.get() != null) {
	// This violates the WeakReference spec, and can result in strong references
	// to objects that have been cleaned.
	System.out.println("WeakReference to " + wr.n
	+ " was erroneously cleared after " + num);
	}
	}
	}

	void CheckOKToClearPhantom(int num) {
	if (num > maxDropped) {
	System.out.println("PhantomRef to live object " + num + " was enqueued.");
	}
	MyWeakReference wr = weakRefs.get(num);
	if (wr != null && wr.get() != null) {
	System.out.println("PhantomRef cleared before WeakRef for " + num);
	}
	}

	void emptyAndCheckQueues() {
	// Check recently finalized objects for consistency with cleared references.
	while (true) {
	Integer num = finalized.poll();
	if (num == null) {
	break;
	}
	MyWeakReference wr = weakRefs.get(num);
	if (wr != null) {
	if (wr.n != num) {
	System.out.println("Finalization logic error!");
	}
	if (wr.get() != null) {
	System.out.println("Finalizing object with uncleared reference");
	}
	}
	CheckOKToClearWeak(num);
	}
	// Check recently enqueued references for consistency.
	while (true) {
	Reference<FinalizableObject> ref = (Reference<FinalizableObject>) refQueue.poll();
	if (ref == null) {
	break;
	}
	if (ref instanceof MyWeakReference) {
	MyWeakReference wr = (MyWeakReference) ref;
	if (wr.get() != null) {
	System.out.println("WeakRef " + wr.n + " enqueued but not cleared");
	}
	CheckOKToClearWeak(wr.n);
	if (weakRefs.remove(Integer.valueOf(wr.n)) != ref) {
	System.out.println("Missing WeakReference: " + wr.n);
	}
	} else if (ref instanceof MyPhantomReference) {
	MyPhantomReference pr = (MyPhantomReference) ref;
	CheckOKToClearPhantom(pr.n);
	if (phantomRefs.remove(Integer.valueOf(pr.n)) != ref) {
	System.out.println("Missing PhantomReference: " + pr.n);
	}
	} else {
	System.out.println("Found unrecognized reference in queue");
	}
	}
	}


	/**
	* Add n objects to the head of the list. These will be assigned the next n consecutive
	* numbers after the current head of the list.
	*/
	void addObjects(int n) {
	for (int i = 0; i < n; ++i) {
	int me = nextAllocated++;
	listHead = new FinalizableObject(me, listHead);
	weakRefs.put(me, new MyWeakReference(listHead));
	phantomRefs.put(me, new MyPhantomReference(listHead));
	}
	liveObjects += n;
	}

	/**
	* Drop n finalizable objects from the tail of the list. These are the lowest-numbered objects
	* in the list.
	*/
	void dropObjects(int n) {
	FinalizableObject list = listHead;
	FinalizableObject last = null;
	if (n > liveObjects) {
	System.out.println("Removing too many elements");
	}
	if (liveObjects == n) {
	maxDropped = list.n;
	listHead = null;
	} else {
	final int skip = liveObjects - n;
	for (int i = 0; i < skip; ++i) {
	last = list;
	list = list.next;
	}
	int expected = nextAllocated - skip - 1;
	if (list.n != expected) {
	System.out.println("dropObjects found " + list.n + " but expected " + expected);
	}
	maxDropped = expected;
	last.next = null;
	}
	liveObjects -= n;
	}

	void testLoop() {
	System.out.println("Starting");
	addObjects(MIN_LIVE_OBJS);
	final int ITERS = (TOTAL_OBJS - MIN_LIVE_OBJS) / DROP_OBJS;
	for (int i = 0; i < ITERS; ++i) {
	addObjects(DROP_OBJS);
	if (liveObjects != MAX_LIVE_OBJS) {
	System.out.println("Unexpected live object count");
	}
	dropObjects(DROP_OBJS);
	if (i % 100 == 0) {
	// Make sure we don't fall too far behind, otherwise we may run out of memory.
	System.runFinalization();
	}
	emptyAndCheckQueues();
	}
	dropObjects(MIN_LIVE_OBJS);
	if (liveObjects != 0 \|\| listHead != null) {
	System.out.println("Unexpected live objecs at end");
	}
	if (maxDropped != TOTAL_OBJS - 1) {
	System.out.println("Unexpected dropped object count: " + maxDropped);
	}
	for (int i = 0; i < 2; ++i) {
	Runtime.getRuntime().gc();
	System.runFinalization();
	emptyAndCheckQueues();
	}
	if (!weakRefs.isEmpty()) {
	System.out.println("Weak Reference map nonempty size = " + weakRefs.size());
	}
	if (CHECK_PHANTOM_REFS && !phantomRefs.isEmpty()) {
	try {
	Thread.sleep(500);
	} catch (InterruptedException e) {
	System.out.println("Unexpected interrupt");
	}
	if (!phantomRefs.isEmpty()) {
	System.out.println("Phantom Reference map nonempty size = " + phantomRefs.size());
	System.out.print("First elements:");
	int i = 0;
	for (MyPhantomReference pr : phantomRefs.values()) {
	System.out.print(" " + pr.n);
	if (++i > 10) {
	break;
	}
	}
	System.out.println("");
	}
	}
	if (totalFinalized.get() != TOTAL_OBJS) {
	System.out.println("Finalized only " + totalFinalized + " objects");
	}
	}

	static Runnable causeGCs = new Runnable() {
	public void run() {
	// Allocate a lot.
	BigInteger counter = BigInteger.ZERO;
	while (!pleaseStop) {
	counter = counter.add(BigInteger.TEN);
	}
	// Look at counter to reduce chance of optimizing out the allocation.
	if (counter.longValue() % 10 != 0) {
	System.out.println("Bad causeGCs counter value: " + counter);
	}
	}
	};

	public static void main(String[] args) throws Exception {
	Main theTest = new Main();
	Thread gcThread = new Thread(causeGCs);
	gcThread.setDaemon(true); // Terminate if main thread dies.
	gcThread.start();
	theTest.testLoop();
	pleaseStop = true;
	gcThread.join();
	System.out.println("Finished");
	}
	}