org.apfloat.internal
Class FloatParallelFNTStrategy

java.lang.Object
  extended by org.apfloat.internal.FloatElementaryModMath
      extended by org.apfloat.internal.FloatModMath
          extended by org.apfloat.internal.FloatTableFNTStrategy
              extended by org.apfloat.internal.FloatParallelFNTStrategy
All Implemented Interfaces:
NTTStrategy
Direct Known Subclasses:
FloatSixStepFNTStrategy, FloatTwoPassFNTStrategy

public abstract class FloatParallelFNTStrategy
extends FloatTableFNTStrategy

Common methods to calculate Fast Number Theoretic Transforms in parallel using multiple threads.

Note that to get any performance gain from running many threads in parallel, the JVM must be executing native threads. If the JVM is running in green threads mode, there is no advantage of having multiple threads, as the JVM will in fact execute just one thread and divide its time to multiple simulated threads.

Version:
1.5
Author:
Mikko Tommila

Constructor Summary
protected FloatParallelFNTStrategy()
          Default constructor.
 
Method Summary
protected static Object getSharedMemoryLockKey(long length)
          Get an object on which to synchronize data storage access.
protected static void lock(Object key)
          Start the synchronization for the given lock key.
protected  void multiplyElements(Object key, ArrayAccess arrayAccess, int startRow, int rows, int columns, float w, float scaleFactor)
          Multiply each matrix element (i, j) by wi * j * scaleFactor.
protected  void transformRows(Object key, int length, int count, boolean isInverse, ArrayAccess arrayAccess, float[] wTable, int[] permutationTable)
          Transform the rows of the data matrix.
protected static void unlock(Object key)
          Finish the synchronization for the given lock key.
 
Methods inherited from class org.apfloat.internal.FloatTableFNTStrategy
getTransformLength, inverseTableFNT, inverseTransform, tableFNT, transform
 
Methods inherited from class org.apfloat.internal.FloatModMath
createWTable, getForwardNthRoot, getInverseNthRoot, modDivide, modInverse, modPow, negate
 
Methods inherited from class org.apfloat.internal.FloatElementaryModMath
getModulus, modAdd, modMultiply, modSubtract, setModulus
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

FloatParallelFNTStrategy

protected FloatParallelFNTStrategy()
Default constructor.

Method Detail

getSharedMemoryLockKey

protected static Object getSharedMemoryLockKey(long length)
Get an object on which to synchronize data storage access. If length is more than the shared memory treshold, then use shared memory, otherwise create a dummy key that will not cause any real synchronization. The shared memory threshold is determined using ApfloatContext.getSharedMemoryTreshold().

Parameters:
length - The length of data that will be accessed.
Returns:
The object on which the memory access should be synchronized.

lock

protected static void lock(Object key)
Start the synchronization for the given lock key. The key must be released using the unlock(Object) method, in the finally block of the immediately following try block, just like for concurrency locks. The number of processors is taken from ApfloatContext.getNumberOfProcessors().

Parameters:
key - The lock key for synchronization.

unlock

protected static void unlock(Object key)
Finish the synchronization for the given lock key. The key must be first locked using the lock(Object) method.

Parameters:
key - The lock key for synchronization.

multiplyElements

protected void multiplyElements(Object key,
                                ArrayAccess arrayAccess,
                                int startRow,
                                int rows,
                                int columns,
                                float w,
                                float scaleFactor)
                         throws ApfloatRuntimeException
Multiply each matrix element (i, j) by wi * j * scaleFactor. The matrix size is n1 x n2.

Parameters:
key - The lock key for synchronization.
arrayAccess - The memory array to multiply.
startRow - Which row in the whole matrix the starting row in the arrayAccess is.
rows - The number of rows in the arrayAccess to multiply.
columns - The number of columns in the matrix (= n2).
w - The n:th root of unity (where n = n1 * n2).
scaleFactor - An extra factor by which all elements are multiplied.
Throws:
ApfloatRuntimeException

transformRows

protected void transformRows(Object key,
                             int length,
                             int count,
                             boolean isInverse,
                             ArrayAccess arrayAccess,
                             float[] wTable,
                             int[] permutationTable)
                      throws ApfloatRuntimeException
Transform the rows of the data matrix. If only one processor is available, it runs all transforms in the current thread. If more than one processor are available, it dispatches the calculations to multiple threads to parallelize the calculation. The number of processors is determined using ApfloatContext.getNumberOfProcessors().

Parameters:
key - The lock key for synchronization.
length - Length of one transform (one row).
count - Number of rows.
isInverse - true if an inverse transform is performed, false if a forward transform is performed.
arrayAccess - The memory array to split to rows and to transform.
wTable - Table of powers of n:th root of unity (where n is the transform length).
permutationTable - Table of permutation indexes, or null if no permutation should be done.
Throws:
ApfloatRuntimeException