test/719-varhandle-concurrency/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.invoke.VarHandle;
 import java.lang.invoke.MethodHandles;
 import java.time.Duration;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Consumer;

 /**
  * Runs tests to validate the concurrency guarantees of VarHandle.
  *
  * The tests involve having a lot of tasks and significantly fewer threads. The tasks are stored on
  * a queue and each thread tries to grab a task from the queue using operations like
  * VarHandle.compareAndSet(). If the operation works as specified, then each task would only be
  * handled in a single thread, exactly once.
  *
  * The tasks just add atomically a specified integer to a total. If the total is different from the
  * expected one, then either some tasks were run multiple times (on multiple threads), or some task
  * were not run at all (skipped by all threads).
  */
 public class Main {
     private static final VarHandle QA;
     static {
         QA = MethodHandles.arrayElementVarHandle(TestTask[].class);
     }

     private static final int TASK_COUNT = 10000;
     private static final int THREAD_COUNT = 20;
     /* Each test may need several retries before a concurrent failure is seen. In the past, for a
      * known bug, between 5 and 10 retries were sufficient. Use RETRIES to configure how many
      * iterations to retry for each test scenario. However, to avoid the test running for too long,
      * for example with gcstress, set a cap duration in MAX_RETRIES_DURATION. With this at least one
      * iteration would run, but there could be fewer retries if each of them takes too long. */
     private static final int RETRIES = 50;
     // b/235431387: timeout reduced from 1 minute
     private static final Duration MAX_RETRIES_DURATION = Duration.ofSeconds(15);

     public static void main(String[] args) throws Throwable {
         testConcurrentProcessing(new CompareAndExchangeRunnerFactory(), "compareAndExchange");
         testConcurrentProcessing(new CompareAndSetRunnerFactory(), "compareAndSet");
         testConcurrentProcessing(new WeakCompareAndSetRunnerFactory(), "weakCompareAndSet");
     }

     private static void testConcurrentProcessing(RunnerFactory factory, String testName)
             throws Throwable {
         final Duration startTs = Duration.ofNanos(System.nanoTime());
         final Duration endTs = startTs.plus(MAX_RETRIES_DURATION);
         for (int i = 0; i < RETRIES; ++i) {
             concurrentProcessingTestIteration(factory, i, testName);
             Duration now = Duration.ofNanos(System.nanoTime());
             if (0 < now.compareTo(endTs)) {
                 break;
             }
         }
     }

     private static void concurrentProcessingTestIteration(
             RunnerFactory factory, int iteration, String testName) throws Throwable {
         final TestTask[] tasks = new TestTask[TASK_COUNT];
         final AtomicInteger result = new AtomicInteger();

         for (int i = 0; i < TASK_COUNT; ++i) {
             tasks[i] = new TestTask(Integer.valueOf(i + 1), result::addAndGet);
         }

         Thread[] threads = new Thread[THREAD_COUNT];
         for (int i = 0; i < THREAD_COUNT; ++i) {
             threads[i] = factory.createRunner(tasks);
         }

         for (int i = 0; i < THREAD_COUNT; ++i) {
             threads[i].start();
         }

         for (int i = 0; i < THREAD_COUNT; ++i) {
             threads[i].join();
         }

         check(result.get(),
               TASK_COUNT * (TASK_COUNT + 1) / 2,
               testName + " test result not as expected",
               iteration);
     }

     /**
      * Processes the task queue until there are no tasks left.
      *
      * The actual task-grabbing mechanism is implemented in subclasses through grabTask().
      * This allows testing various mechanisms, like compareAndSet() and compareAndExchange().
      */
     private static abstract class TaskRunner extends Thread {

         protected final TestTask[] tasks;

         TaskRunner(TestTask[] tasks) {
             this.tasks = tasks;
         }

         @Override
         public void run() {
             int i = 0;
             while (i < TASK_COUNT) {
                 TestTask t = (TestTask) QA.get(tasks, i);
                 if (t == null) {
                     ++i;
                     continue;
                 }
                 if (!grabTask(t, i)) {
                     continue;
                 }
                 ++i;
                 VarHandle.releaseFence();
                 t.exec();
             }
         }

         /**
          * Grabs the next task from the queue in an atomic way.
          *
          * Once a task is retrieved successfully, the queue should no longer hold a reference to it.
          * This would be done, for example, by swapping the task with a null value.
          *
          * @param t The task to get from the queue
          * @param i The index where the task is found
          *
          * @return {@code true} if the task has been retrieved and is not available to any other
          * threads. Otherwise {@code false}. If {@code false} is returned, then either the task was
          * no longer present on the queue due to another thread grabbing it, or, in case of spurious
          * failure, the task is still available and no other thread managed to grab it.
          */
         protected abstract boolean grabTask(TestTask t, int i);
     }

     private static class TaskRunnerWithCompareAndExchange extends TaskRunner {
         TaskRunnerWithCompareAndExchange(TestTask[] tasks) {
             super(tasks);
         }

         @Override
         protected boolean grabTask(TestTask t, int i) {
             return (t == QA.compareAndExchange(tasks, i, t, null));
         }
     }

     private static class TaskRunnerWithCompareAndSet extends TaskRunner {
         TaskRunnerWithCompareAndSet(TestTask[] tasks) {
             super(tasks);
         }

         @Override
         protected boolean grabTask(TestTask t, int i) {
             return QA.compareAndSet(tasks, i, t, null);
         }
     }

     private static class TaskRunnerWithWeakCompareAndSet extends TaskRunner {
         TaskRunnerWithWeakCompareAndSet(TestTask[] tasks) {
             super(tasks);
         }

         @Override
         protected boolean grabTask(TestTask t, int i) {
             return QA.weakCompareAndSet(tasks, i, t, null);
         }
     }


     private interface RunnerFactory {
         Thread createRunner(TestTask[] tasks);
     }

     private static class CompareAndExchangeRunnerFactory implements RunnerFactory {
         @Override
         public Thread createRunner(TestTask[] tasks) {
             return new TaskRunnerWithCompareAndExchange(tasks);
         }
     }

     private static class CompareAndSetRunnerFactory implements RunnerFactory {
         @Override
         public Thread createRunner(TestTask[] tasks) {
             return new TaskRunnerWithCompareAndSet(tasks);
         }
     }

     private static class WeakCompareAndSetRunnerFactory implements RunnerFactory {
         @Override
         public Thread createRunner(TestTask[] tasks) {
             return new TaskRunnerWithWeakCompareAndSet(tasks);
         }
     }

     private static class TestTask {
         private final Integer ord;
         private final Consumer<Integer> action;

         TestTask(Integer ord, Consumer<Integer> action) {
             this.ord = ord;
             this.action = action;
         }

         public void exec() {
             action.accept(ord);
         }
     }

     private static void check(int actual, int expected, String msg, int iteration) {
         if (actual != expected) {
             System.err.println(String.format(
                     "[iteration %d] %s : %d != %d", iteration, msg, actual, expected));
             System.exit(1);
         }
     }
 }
	/*
	* 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.invoke.VarHandle;
	import java.lang.invoke.MethodHandles;
	import java.time.Duration;
	import java.util.concurrent.atomic.AtomicInteger;
	import java.util.function.Consumer;

	/**
	* Runs tests to validate the concurrency guarantees of VarHandle.
	*
	* The tests involve having a lot of tasks and significantly fewer threads. The tasks are stored on
	* a queue and each thread tries to grab a task from the queue using operations like
	* VarHandle.compareAndSet(). If the operation works as specified, then each task would only be
	* handled in a single thread, exactly once.
	*
	* The tasks just add atomically a specified integer to a total. If the total is different from the
	* expected one, then either some tasks were run multiple times (on multiple threads), or some task
	* were not run at all (skipped by all threads).
	*/
	public class Main {
	private static final VarHandle QA;
	static {
	QA = MethodHandles.arrayElementVarHandle(TestTask[].class);
	}

	private static final int TASK_COUNT = 10000;
	private static final int THREAD_COUNT = 20;
	/* Each test may need several retries before a concurrent failure is seen. In the past, for a
	* known bug, between 5 and 10 retries were sufficient. Use RETRIES to configure how many
	* iterations to retry for each test scenario. However, to avoid the test running for too long,
	* for example with gcstress, set a cap duration in MAX_RETRIES_DURATION. With this at least one
	* iteration would run, but there could be fewer retries if each of them takes too long. */
	private static final int RETRIES = 50;
	// b/235431387: timeout reduced from 1 minute
	private static final Duration MAX_RETRIES_DURATION = Duration.ofSeconds(15);

	public static void main(String[] args) throws Throwable {
	testConcurrentProcessing(new CompareAndExchangeRunnerFactory(), "compareAndExchange");
	testConcurrentProcessing(new CompareAndSetRunnerFactory(), "compareAndSet");
	testConcurrentProcessing(new WeakCompareAndSetRunnerFactory(), "weakCompareAndSet");
	}

	private static void testConcurrentProcessing(RunnerFactory factory, String testName)
	throws Throwable {
	final Duration startTs = Duration.ofNanos(System.nanoTime());
	final Duration endTs = startTs.plus(MAX_RETRIES_DURATION);
	for (int i = 0; i < RETRIES; ++i) {
	concurrentProcessingTestIteration(factory, i, testName);
	Duration now = Duration.ofNanos(System.nanoTime());
	if (0 < now.compareTo(endTs)) {
	break;
	}
	}
	}

	private static void concurrentProcessingTestIteration(
	RunnerFactory factory, int iteration, String testName) throws Throwable {
	final TestTask[] tasks = new TestTask[TASK_COUNT];
	final AtomicInteger result = new AtomicInteger();

	for (int i = 0; i < TASK_COUNT; ++i) {
	tasks[i] = new TestTask(Integer.valueOf(i + 1), result::addAndGet);
	}

	Thread[] threads = new Thread[THREAD_COUNT];
	for (int i = 0; i < THREAD_COUNT; ++i) {
	threads[i] = factory.createRunner(tasks);
	}

	for (int i = 0; i < THREAD_COUNT; ++i) {
	threads[i].start();
	}

	for (int i = 0; i < THREAD_COUNT; ++i) {
	threads[i].join();
	}

	check(result.get(),
	TASK_COUNT * (TASK_COUNT + 1) / 2,
	testName + " test result not as expected",
	iteration);
	}

	/**
	* Processes the task queue until there are no tasks left.
	*
	* The actual task-grabbing mechanism is implemented in subclasses through grabTask().
	* This allows testing various mechanisms, like compareAndSet() and compareAndExchange().
	*/
	private static abstract class TaskRunner extends Thread {

	protected final TestTask[] tasks;

	TaskRunner(TestTask[] tasks) {
	this.tasks = tasks;
	}

	@Override
	public void run() {
	int i = 0;
	while (i < TASK_COUNT) {
	TestTask t = (TestTask) QA.get(tasks, i);
	if (t == null) {
	++i;
	continue;
	}
	if (!grabTask(t, i)) {
	continue;
	}
	++i;
	VarHandle.releaseFence();
	t.exec();
	}
	}

	/**
	* Grabs the next task from the queue in an atomic way.
	*
	* Once a task is retrieved successfully, the queue should no longer hold a reference to it.
	* This would be done, for example, by swapping the task with a null value.
	*
	* @param t The task to get from the queue
	* @param i The index where the task is found
	*
	* @return {@code true} if the task has been retrieved and is not available to any other
	* threads. Otherwise {@code false}. If {@code false} is returned, then either the task was
	* no longer present on the queue due to another thread grabbing it, or, in case of spurious
	* failure, the task is still available and no other thread managed to grab it.
	*/
	protected abstract boolean grabTask(TestTask t, int i);
	}

	private static class TaskRunnerWithCompareAndExchange extends TaskRunner {
	TaskRunnerWithCompareAndExchange(TestTask[] tasks) {
	super(tasks);
	}

	@Override
	protected boolean grabTask(TestTask t, int i) {
	return (t == QA.compareAndExchange(tasks, i, t, null));
	}
	}

	private static class TaskRunnerWithCompareAndSet extends TaskRunner {
	TaskRunnerWithCompareAndSet(TestTask[] tasks) {
	super(tasks);
	}

	@Override
	protected boolean grabTask(TestTask t, int i) {
	return QA.compareAndSet(tasks, i, t, null);
	}
	}

	private static class TaskRunnerWithWeakCompareAndSet extends TaskRunner {
	TaskRunnerWithWeakCompareAndSet(TestTask[] tasks) {
	super(tasks);
	}

	@Override
	protected boolean grabTask(TestTask t, int i) {
	return QA.weakCompareAndSet(tasks, i, t, null);
	}
	}


	private interface RunnerFactory {
	Thread createRunner(TestTask[] tasks);
	}

	private static class CompareAndExchangeRunnerFactory implements RunnerFactory {
	@Override
	public Thread createRunner(TestTask[] tasks) {
	return new TaskRunnerWithCompareAndExchange(tasks);
	}
	}

	private static class CompareAndSetRunnerFactory implements RunnerFactory {
	@Override
	public Thread createRunner(TestTask[] tasks) {
	return new TaskRunnerWithCompareAndSet(tasks);
	}
	}

	private static class WeakCompareAndSetRunnerFactory implements RunnerFactory {
	@Override
	public Thread createRunner(TestTask[] tasks) {
	return new TaskRunnerWithWeakCompareAndSet(tasks);
	}
	}

	private static class TestTask {
	private final Integer ord;
	private final Consumer<Integer> action;

	TestTask(Integer ord, Consumer<Integer> action) {
	this.ord = ord;
	this.action = action;
	}

	public void exec() {
	action.accept(ord);
	}
	}

	private static void check(int actual, int expected, String msg, int iteration) {
	if (actual != expected) {
	System.err.println(String.format(
	"[iteration %d] %s : %d != %d", iteration, msg, actual, expected));
	System.exit(1);
	}
	}
	}