Java ConcurrencyUtils.setNumberOfThreads方法代码示例

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入方法依赖的package包/类
public void runAll() throws Exception {
	List<AbstractMatrix2DBenchmark> benchmarks = getDenseBenchmarks();

	UJMPSettings.getInstance().setNumberOfThreads(getConfig().getNumberOfThreads());
	ConcurrencyUtils.setNumberOfThreads(getConfig().getNumberOfThreads());
	System.setProperty("ATLAS_NUM_THREADS", "" + getConfig().getNumberOfThreads());

	if (getConfig().isShuffle()) {
		Collections.shuffle(benchmarks);
	}
	if (getConfig().isReverse()) {
		Collections.reverse(benchmarks);
	}

	long t0 = System.currentTimeMillis();

	for (int j = 0; j < benchmarks.size(); j++) {
		AbstractMatrix2DBenchmark benchmark = benchmarks.get(j);
		benchmark.run();
	}

	long t1 = System.currentTimeMillis();

	System.out.println();
	System.out.println("Finished.");
	System.out.println("Total Time: " + StringUtil.duration(t1 - t0));
	System.out.println();
	System.out.println();
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入方法依赖的package包/类
public static void initCheck(Frame input, int width, int height, int depth) {
  ConcurrencyUtils.setNumberOfThreads(1);
  if (width < 1 || height < 1 || depth < 1)
    throw new H2OIllegalArgumentException("dimensions must be >= 1");
  if (width*height*depth != input.numCols())
    throw new H2OIllegalArgumentException("dimensions HxWxD must match the # columns of the frame");
  for (Vec v : input.vecs()) {
    if (v.naCnt() > 0)
      throw new H2OIllegalArgumentException("DCT can not be computed on rows with missing values");
    if (!v.isNumeric())
      throw new H2OIllegalArgumentException("DCT can only be computed on numeric columns");
  }
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入方法依赖的package包/类
public static void parseArguments(String[] args) {
	if (args.length > 0) {
		nthread = Integer.parseInt(args[0]);
		threadsBegin2D = Integer.parseInt(args[1]);
		threadsBegin3D = Integer.parseInt(args[3]);
		niter = Integer.parseInt(args[3]);
		doWarmup = Boolean.parseBoolean(args[4]);
		doScaling = Boolean.parseBoolean(args[5]);
		nsize = Integer.parseInt(args[6]);
		sizes1D = new int[nsize];
		sizes2D = new int[nsize];
		sizes3D = new int[nsize];
		for (int i = 0; i < nsize; i++) {
			sizes1D[i] = Integer.parseInt(args[7 + i]);
		}
		for (int i = 0; i < nsize; i++) {
			sizes2D[i] = Integer.parseInt(args[7 + nsize + i]);
		}
		for (int i = 0; i < nsize; i++) {
			sizes3D[i] = Integer.parseInt(args[7 + nsize + nsize + i]);
		}
	} else {
		System.out.println("Default settings are used.");
	}
	ConcurrencyUtils.setNumberOfThreads(nthread);
	ConcurrencyUtils.setThreadsBeginN_2D(threadsBegin2D);
	ConcurrencyUtils.setThreadsBeginN_3D(threadsBegin3D);
	System.out.println("nthred = " + nthread);
	System.out.println("threadsBegin2D = " + threadsBegin2D);
	System.out.println("threadsBegin3D = " + threadsBegin3D);
	System.out.println("niter = " + niter);
	System.out.println("doWarmup = " + doWarmup);
	System.out.println("doScaling = " + doScaling);
	System.out.println("nsize = " + nsize);
	System.out.println("sizes1D[] = " + Arrays.toString(sizes1D));
	System.out.println("sizes2D[] = " + Arrays.toString(sizes2D));
	System.out.println("sizes3D[] = " + Arrays.toString(sizes3D));
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入方法依赖的package包/类
public static void parseArguments(String[] args) {
	if (args.length > 0) {
		nthread = Integer.parseInt(args[0]);
		threadsBegin2D = Integer.parseInt(args[1]);
		threadsBegin3D = Integer.parseInt(args[2]);
		niter = Integer.parseInt(args[3]);
		doWarmup = Boolean.parseBoolean(args[4]);
		doScaling = Boolean.parseBoolean(args[5]);
		nsize = Integer.parseInt(args[6]);
		sizes1D = new int[nsize];
		sizes2D = new int[nsize];
		sizes3D = new int[nsize];
		for (int i = 0; i < nsize; i++) {
			sizes1D[i] = Integer.parseInt(args[7 + i]);
		}
		for (int i = 0; i < nsize; i++) {
			sizes2D[i] = Integer.parseInt(args[7 + nsize + i]);
		}
		for (int i = 0; i < nsize; i++) {
			sizes3D[i] = Integer.parseInt(args[7 + nsize + nsize + i]);
		}
	} else {
		System.out.println("Default settings are used.");
	}
	ConcurrencyUtils.setNumberOfThreads(nthread);
	ConcurrencyUtils.setThreadsBeginN_2D(threadsBegin2D);
	ConcurrencyUtils.setThreadsBeginN_3D(threadsBegin3D);
	System.out.println("nthred = " + nthread);
	System.out.println("threadsBegin2D = " + threadsBegin2D);
	System.out.println("threadsBegin3D = " + threadsBegin3D);
	System.out.println("niter = " + niter);
	System.out.println("doWarmup = " + doWarmup);
	System.out.println("doScaling = " + doScaling);
	System.out.println("nsize = " + nsize);
	System.out.println("sizes1D[] = " + Arrays.toString(sizes1D));
	System.out.println("sizes2D[] = " + Arrays.toString(sizes2D));
	System.out.println("sizes3D[] = " + Arrays.toString(sizes3D));
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入方法依赖的package包/类
/**
 * Creates a new instance of this test.
 *
 * @param numRows
 *            number of rows
 * @param numColumns
 *            number of columns
 * @param numThreads
 *            the number of threads to be used
 * @param seed
 *            the seed of the random generator
 */
public DoubleFFT_2DTest(final int numRows, final int numColumns,
		final int numThreads, final long seed)
{
	this.numRows = numRows;
	this.numCols = numColumns;
	this.rfft = new DoubleFFT_1D(numColumns);
	this.cfft = new DoubleFFT_1D(numRows);
	this.fft = new DoubleFFT_2D(numRows, numColumns);
	this.random = new Random(seed);
	ConcurrencyUtils.setNumberOfThreads(numThreads);
	ConcurrencyUtils.setThreadsBeginN_2D(4);
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入方法依赖的package包/类
/**
 * Creates a new instance of this test.
 *
 * @param numRows
 *            number of rows
 * @param numColumns
 *            number of columns
 * @param numThreads
 *            the number of threads to be used
 * @param seed
 *            the seed of the random generator
 */
public FloatFFT_2DTest(final int numRows, final int numColumns,
		final int numThreads, final long seed)
{
	this.numRows = numRows;
	this.numCols = numColumns;
	this.rfft = new FloatFFT_1D(numColumns);
	this.cfft = new FloatFFT_1D(numRows);
	this.fft = new FloatFFT_2D(numRows, numColumns);
	this.random = new Random(seed);
	ConcurrencyUtils.setNumberOfThreads(numThreads);
	ConcurrencyUtils.setThreadsBeginN_2D(4);
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入方法依赖的package包/类
@Override
public void setThreadNumber(int number) {
	ConcurrencyUtils.setNumberOfThreads(number);
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入方法依赖的package包/类
/**
 * Creates a new instance of this test.
 *
 * @param numSlices
 *            number of slices
 * @param numRows
 *            number of rows
 * @param numColumns
 *            number of columns
 * @param numThreads
 *            the number of threads to be used
 * @param seed
 *            the seed of the random generator
 */
public DoubleFFT_3DTest(final int numSlices, final int numRows,
		final int numColumns, final int numThreads, final long seed)
{
	this.numSlices = numSlices;
	this.numRows = numRows;
	this.numCols = numColumns;
	this.fft = new DoubleFFT_3D(numSlices, numRows, numColumns);
	this.xfft = new DoubleFFT_1D(numSlices);
	this.sfft = new DoubleFFT_2D(numRows, numColumns);
	this.random = new Random(seed);
	ConcurrencyUtils.setNumberOfThreads(numThreads);
	ConcurrencyUtils.setThreadsBeginN_3D(4);
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入方法依赖的package包/类
/**
 * Creates a new instance of this class.
 *
 * @param n
 *            the size of the FFT to be tested
 * @param numThreads
 *            the number of threads
 * @param seed
 *            the seed of the random generator
 */
public FloatFFT_1DTest(final int n, final int numThreads, final long seed) {
	this.n = n;
	this.fft = new FloatFFT_1D(n);
	this.random = new Random(seed);
	ConcurrencyUtils.setThreadsBeginN_1D_FFT_2Threads(512);
	ConcurrencyUtils.setThreadsBeginN_1D_FFT_4Threads(512);
	ConcurrencyUtils.setNumberOfThreads(numThreads);
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入方法依赖的package包/类
/**
 * Creates a new instance of this class.
 *
 * @param n
 *            the size of the FFT to be tested
 * @param numThreads
 *            the number of threads
 * @param seed
 *            the seed of the random generator
 */
public DoubleFFT_1DTest(final int n, final int numThreads, final long seed) {
	this.n = n;
	this.fft = new DoubleFFT_1D(n);
	this.random = new Random(seed);
	ConcurrencyUtils.setThreadsBeginN_1D_FFT_2Threads(512);
	ConcurrencyUtils.setThreadsBeginN_1D_FFT_4Threads(512);
	ConcurrencyUtils.setNumberOfThreads(numThreads);
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入方法依赖的package包/类
/**
 * Creates a new instance of this test.
 *
 * @param numSlices
 *            number of slices
 * @param numRows
 *            number of rows
 * @param numColumns
 *            number of columns
 * @param numThreads
 *            the number of threads to be used
 * @param seed
 *            the seed of the random generator
 */
public FloatFFT_3DTest(final int numSlices, final int numRows,
		final int numColumns, final int numThreads, final long seed)
{
	this.numSlices = numSlices;
	this.numRows = numRows;
	this.numCols = numColumns;
	this.fft = new FloatFFT_3D(numSlices, numRows, numColumns);
	this.xfft = new FloatFFT_1D(numSlices);
	this.sfft = new FloatFFT_2D(numRows, numColumns);
	this.random = new Random(seed);
	ConcurrencyUtils.setNumberOfThreads(numThreads);
	ConcurrencyUtils.setThreadsBeginN_3D(4);
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入方法依赖的package包/类
/**
 * Creates a new instance of this test.
 *
 * @param rows
 *            number of rows
 * @param columns
 *            number of columns
 * @param numThreads
 *            the number of threads to be used
 * @param seed
 *            the seed of the random generator
 */
public RealFFTUtils_2DTest(final int rows, final int columns,
		final int numThreads, final long seed)
{
	this.rows = rows;
	this.columns = columns;
	this.fft2d = new DoubleFFT_2D(rows, columns);
	this.fft2f = new FloatFFT_2D(rows, columns);
	this.random = new Random(seed);
	this.unpacker = new RealFFTUtils_2D(rows, columns);
	ConcurrencyUtils.setNumberOfThreads(numThreads);
}
 

import edu.emory.mathcs.utils.ConcurrencyUtils; //导入方法依赖的package包/类
/**
 * Creates a new instance of this test.
 *
 * @param slices
 *            number of slices
 * @param rows
 *            number of rows
 * @param columns
 *            number of columns
 * @param numThreads
 *            the number of threads to be used
 * @param seed
 *            the seed of the random generator
 */
public RealFFTUtils_3DTest(final int slices, final int rows,
		final int columns, final int numThreads, final long seed)
{
	this.slices = slices;
	this.rows = rows;
	this.columns = columns;
	this.fft3d = new DoubleFFT_3D(slices, rows, columns);
	this.fft3f = new FloatFFT_3D(slices, rows, columns);
	this.random = new Random(seed);
	this.unpacker = new RealFFTUtils_3D(slices, rows, columns);
	ConcurrencyUtils.setNumberOfThreads(numThreads);
}