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.4 by jsr166, Wed Dec 31 07:54:13 2014 UTC vs.
Revision 1.7 by jsr166, Sun Sep 20 15:33:12 2015 UTC

#	Line 7 | Line 7
7		package java.util;
8
9		import java.util.concurrent.CountedCompleter;
10	–	import java.util.concurrent.ForkJoinPool;
10		import java.util.function.BinaryOperator;
11		import java.util.function.DoubleBinaryOperator;
12		import java.util.function.IntBinaryOperator;
#	Line 73 | 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
83	–	/** Root task constructor */
84	–	public CumulateTask(CumulateTask<T> parent,
85	–	BinaryOperator<T> function,
86	–	T[] array, int lo, int hi) {
87	–	super(parent);
88	–	this.function = function; this.array = array;
89	–	this.lo = this.origin = lo; this.hi = this.fence = hi;
90	–	int p;
91	–	this.threshold =
92	–	(p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3))
93	–	<= MIN_PARTITION ? MIN_PARTITION : p;
94	–	}
95	–
96	–	/** 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 225 | 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
235	–	/** Root task constructor */
236	–	public LongCumulateTask(LongCumulateTask parent,
237	–	LongBinaryOperator function,
238	–	long[] array, int lo, int hi) {
239	–	super(parent);
240	–	this.function = function; this.array = array;
241	–	this.lo = this.origin = lo; this.hi = this.fence = hi;
242	–	int p;
243	–	this.threshold =
244	–	(p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3))
245	–	<= MIN_PARTITION ? MIN_PARTITION : p;
246	–	}
247	–
248	–	/** Subtask constructor */
222		LongCumulateTask(LongCumulateTask parent, LongBinaryOperator function,
223		long[] array, int origin, int fence, int threshold,
224		int lo, int hi) {
#	Line 375 | 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
385	–	/** Root task constructor */
386	–	public DoubleCumulateTask(DoubleCumulateTask parent,
387	–	DoubleBinaryOperator function,
388	–	double[] array, int lo, int hi) {
389	–	super(parent);
390	–	this.function = function; this.array = array;
391	–	this.lo = this.origin = lo; this.hi = this.fence = hi;
392	–	int p;
393	–	this.threshold =
394	–	(p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3))
395	–	<= MIN_PARTITION ? MIN_PARTITION : p;
396	–	}
397	–
398	–	/** 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 525 | 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
535	–	/** Root task constructor */
536	–	public IntCumulateTask(IntCumulateTask parent,
537	–	IntBinaryOperator function,
538	–	int[] array, int lo, int hi) {
539	–	super(parent);
540	–	this.function = function; this.array = array;
541	–	this.lo = this.origin = lo; this.hi = this.fence = hi;
542	–	int p;
543	–	this.threshold =
544	–	(p = (hi - lo) / (ForkJoinPool.getCommonPoolParallelism() << 3))
545	–	<= MIN_PARTITION ? MIN_PARTITION : p;
546	–	}
547	–
548	–	/** 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