Revert^18 "Thread suspension cleanup and deadlock fix"

This reverts commit 8bc6a58df7046b4d6f4b51eb274c7e60fea396ff.

PS1 is identical to
  https://android-review.git.corp.google.com/c/platform/art/+/2746640

PS2 makes the following changes:
- Remove one DCHECK each from the two WaitForFlipFunction variants.
  The DCHECK could fail if another GC was started in the interim.
- Break up the WaitForSuspendBarrier timeout into shorter ones.
  so we don't time out as easily if our process is frozen.
- Include the thread name for ThreadSuspendByThreadIdWarning, since
  we don't get complete tombstones for some failures.

Test: Treehugger, host tests.
Bug: 240742796
Bug: 203363895
Bug: 238032384
Bug: 253671779
Bug: 276660630
Bug: 295880862
Bug: 294334417
Bug: 301090887
Bug: 313347640
(and more)

Change-Id: I12c5c01b1e006baab4ee4148aadbc721723fb89e

1 files changed, 58 insertions, 6 deletions

diff --git a/test/129-ThreadGetId/src/Main.java b/test/129-ThreadGetId/src/Main.java
index 50e8c098de..3b4b076044 100644
--- a/test/129-ThreadGetId/src/Main.java
+++ b/test/129-ThreadGetId/src/Main.java
@@ -16,23 +16,71 @@
 
 import java.lang.reflect.Field;
 import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
 
 public class Main implements Runnable {
     static final int NUMBER_OF_THREADS = 5;
-    static final int TOTAL_OPERATIONS = 900;
+    static volatile int ops_per_thread = 1000;
+    static AtomicInteger operations_completed = new AtomicInteger(0);
+    static int[] progress = new int[NUMBER_OF_THREADS];
+    static AtomicInteger totalStackFrames = new AtomicInteger(0);
+    static final boolean printStats = false;  // True causes test to fail.
+    int index;
+
+    Main(int i) {
+        index = i;
+    }
 
     public static void main(String[] args) throws Exception {
         final Thread[] threads = new Thread[NUMBER_OF_THREADS];
+        Thread watchdog = new Thread() {
+            public void run() {
+                try {
+                    if (printStats) {
+                        System.out.println("ops_per_thread = " + ops_per_thread);
+                    }
+                    Thread.sleep(10_000);
+                    if (printStats) {
+                        System.out.println("Ops completed after 10 seconds: " +
+                                operations_completed.get());
+                    }
+                    if (operations_completed.get() < NUMBER_OF_THREADS * ops_per_thread / 2) {
+                        // We're in some sort of "go slow" mode, probably gcstress. Finish early.
+                        ops_per_thread /= 10;
+                    }
+                    if (printStats) {
+                        System.out.println("ops_per_thread = " + ops_per_thread);
+                    }
+                    Thread.sleep(200_000);
+                    System.out.print("Watchdog timed out: ");
+                    for (int i = 0; i < NUMBER_OF_THREADS; ++i) {
+                        System.out.print(progress[i] + ", ");
+                    }
+                    System.out.println("");
+                    System.err.println("Watchdog thread timed out");
+                    System.exit(1);
+                } catch (InterruptedException e) {}
+            }
+        };
+        watchdog.start();
+        long start_millis = System.currentTimeMillis();
         for (int t = 0; t < threads.length; t++) {
-            threads[t] = new Thread(new Main());
+            threads[t] = new Thread(new Main(t));
             threads[t].start();
         }
         for (Thread t : threads) {
             t.join();
         }
+        if (printStats) {
+            long elapsed_millis = System.currentTimeMillis() - start_millis;
+            System.out.println("Captured " + totalStackFrames + " stack frames in " +
+                    elapsed_millis + "msecs");
+        }
+        System.out.println("All joined");
         // Do this test after the other part to leave some time for the heap task daemon to start
         // up.
         test_getStackTraces();
+        watchdog.interrupt();
         System.out.println("Finishing");
     }
 
@@ -46,9 +94,9 @@ public class Main implements Runnable {
             Thread[] array = new Thread[activeCount];
             systemThreadGroup.enumerate(array);
             for (Thread thread : array) {
-               if (thread.getName().equals("HeapTaskDaemon") &&
-                   thread.getState() != Thread.State.NEW) {
-                  return thread;
+                if (thread.getName().equals("HeapTaskDaemon") &&
+                    thread.getState() != Thread.State.NEW) {
+                    return thread;
                 }
             }
             // Yield to eventually get the daemon started.
@@ -83,12 +131,16 @@ public class Main implements Runnable {
             if (thread.getId() <= 0) {
                 System.out.println("thread's ID is not positive: " + thread.getName());
             }
+            totalStackFrames.addAndGet(stMap.get(thread).length);
         }
     }
 
     public void run() {
-        for (int i = 0; i < TOTAL_OPERATIONS; ++i) {
+        for (int i = 1; i <= ops_per_thread; ++i) {
             test_getId();
+            operations_completed.addAndGet(1);
+            progress[index] = i;
         }
+        System.out.println("Thread finished");
     }
 }