ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/main/java/util/ArrayPrefixHelpers.java

Comparing jsr166/src/main/java/util/ArrayPrefixHelpers.java (file contents):
Revision 1.3 by jsr166, Wed Dec 31 04:53:37 2014 UTC vs.
Revision 1.7 by jsr166, Sun Sep 20 15:33:12 2015 UTC

#	Line 5 | Line 5
5		*/
6
7		package java.util;
8	<	import java.util.concurrent.ForkJoinPool;
8	>
9		import java.util.concurrent.CountedCompleter;
10		import java.util.function.BinaryOperator;
11	+	import java.util.function.DoubleBinaryOperator;
12		import java.util.function.IntBinaryOperator;
13		import java.util.function.LongBinaryOperator;
13	–	import java.util.function.DoubleBinaryOperator;
14
15		/**
16		* ForkJoin tasks to perform Arrays.parallelPrefix operations.
#	Line 72 | Line 72 | class ArrayPrefixHelpers {
72		/** The smallest subtask array partition size to use as threshold */
73		static final int MIN_PARTITION = 16;
74
75	<	static final class CumulateTask<T> extends CountedCompleter<Void> {
75	>	private static final class CumulateTask<T>
76	>	extends CountedCompleter<Void> {
77		final T[] array;
78		final BinaryOperator<T> function;
79		CumulateTask<T> left, right;
80		T in, out;
81		final int lo, hi, origin, fence, threshold;
82
82	–	/** Root task constructor */
83	–	public CumulateTask(CumulateTask<T> parent,
84	–	BinaryOperator<T> function,
85	–	T[] array, int lo, int hi) {
86	–	super(parent);
87	–	this.function = function; this.array = array;
88	–	this.lo = this.origin = lo; this.hi = this.fence = hi;
89	–	int p;
90	–	this.threshold =
91	–	(p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3))
92	–	<= MIN_PARTITION ? MIN_PARTITION : p;
93	–	}
94	–
95	–	/** Subtask constructor */
83		CumulateTask(CumulateTask<T> parent, BinaryOperator<T> function,
84		T[] array, int origin, int fence, int threshold,
85		int lo, int hi) {
#	Line 224 | Line 211 | class ArrayPrefixHelpers {
211		private static final long serialVersionUID = 5293554502939613543L;
212		}
213
214	<	static final class LongCumulateTask extends CountedCompleter<Void> {
214	>	private static final class LongCumulateTask
215	>	extends CountedCompleter<Void> {
216		final long[] array;
217		final LongBinaryOperator function;
218		LongCumulateTask left, right;
219		long in, out;
220		final int lo, hi, origin, fence, threshold;
221
234	–	/** Root task constructor */
235	–	public LongCumulateTask(LongCumulateTask parent,
236	–	LongBinaryOperator function,
237	–	long[] array, int lo, int hi) {
238	–	super(parent);
239	–	this.function = function; this.array = array;
240	–	this.lo = this.origin = lo; this.hi = this.fence = hi;
241	–	int p;
242	–	this.threshold =
243	–	(p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3))
244	–	<= MIN_PARTITION ? MIN_PARTITION : p;
245	–	}
246	–
247	–	/** Subtask constructor */
222		LongCumulateTask(LongCumulateTask parent, LongBinaryOperator function,
223		long[] array, int origin, int fence, int threshold,
224		int lo, int hi) {
#	Line 374 | Line 348 | class ArrayPrefixHelpers {
348		private static final long serialVersionUID = -5074099945909284273L;
349		}
350
351	<	static final class DoubleCumulateTask extends CountedCompleter<Void> {
351	>	private static final class DoubleCumulateTask
352	>	extends CountedCompleter<Void> {
353		final double[] array;
354		final DoubleBinaryOperator function;
355		DoubleCumulateTask left, right;
356		double in, out;
357		final int lo, hi, origin, fence, threshold;
358
384	–	/** Root task constructor */
385	–	public DoubleCumulateTask(DoubleCumulateTask parent,
386	–	DoubleBinaryOperator function,
387	–	double[] array, int lo, int hi) {
388	–	super(parent);
389	–	this.function = function; this.array = array;
390	–	this.lo = this.origin = lo; this.hi = this.fence = hi;
391	–	int p;
392	–	this.threshold =
393	–	(p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3))
394	–	<= MIN_PARTITION ? MIN_PARTITION : p;
395	–	}
396	–
397	–	/** Subtask constructor */
359		DoubleCumulateTask(DoubleCumulateTask parent, DoubleBinaryOperator function,
360	<	double[] array, int origin, int fence, int threshold,
361	<	int lo, int hi) {
360	>	double[] array, int origin, int fence, int threshold,
361	>	int lo, int hi) {
362		super(parent);
363		this.function = function; this.array = array;
364		this.origin = origin; this.fence = fence;
#	Line 524 | Line 485 | class ArrayPrefixHelpers {
485		private static final long serialVersionUID = -586947823794232033L;
486		}
487
488	<	static final class IntCumulateTask extends CountedCompleter<Void> {
488	>	private static final class IntCumulateTask
489	>	extends CountedCompleter<Void> {
490		final int[] array;
491		final IntBinaryOperator function;
492		IntCumulateTask left, right;
493		int in, out;
494		final int lo, hi, origin, fence, threshold;
495
534	–	/** Root task constructor */
535	–	public IntCumulateTask(IntCumulateTask parent,
536	–	IntBinaryOperator function,
537	–	int[] array, int lo, int hi) {
538	–	super(parent);
539	–	this.function = function; this.array = array;
540	–	this.lo = this.origin = lo; this.hi = this.fence = hi;
541	–	int p;
542	–	this.threshold =
543	–	(p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3))
544	–	<= MIN_PARTITION ? MIN_PARTITION : p;
545	–	}
546	–
547	–	/** Subtask constructor */
496		IntCumulateTask(IntCumulateTask parent, IntBinaryOperator function,
497	<	int[] array, int origin, int fence, int threshold,
498	<	int lo, int hi) {
497	>	int[] array, int origin, int fence, int threshold,
498	>	int lo, int hi) {
499		super(parent);
500		this.function = function; this.array = array;
501		this.origin = origin; this.fence = fence;

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines