Class Parallelization

java.lang.Object
net.imglib2.parallel.Parallelization
public final class Parallelization extends Object
This class allows to configure an algorithm for parallelization.

The algorithm needs to use the TaskExecutor returned by getTaskExecutor() to implement the parallelization. Alternatively it can use getExecutorService(). But TaskExecutor is simpler and better suited for image precessing algorithms.

The algorithm can be executed singleThreaded, multiThreaded or by using a specified ExecutorService or TaskExecutor: 

    

    // Single-threaded call
    Parallelization.runSingleThreaded( () -> myAlgorithm( image ) );

    // Multi-threaded call
    Parallelization.runMultiThreaded( () -> myAlgorithm( image ) );

    // ExecutorService
    Parallelization.withExecutor( executorService, () -> myAlgorithm( image ) );

    // Multi-threaded is the default.
    //     A normal function call, that's not somehow wrapped by
    //     Parallelization.runSingleThreaded( ... ) runs multi-threaded.
    myAlgorithm( image );

    // Example Algorithm, that fills an image with ones.
    public void myAlgorithm( RandomAccessibleInterval< IntType > image )
    {
        TaskExecutor taskExecutor = Parallelization.getTaskExecutor();
        int numTasks = taskExecutor.suggestNumberOfTasks();
        List< Interval > chunks = IntervalChunks.chunkInterval( image, numTasks );

        // The TaskExecutor executes the forEach method in multiple threads, if requested.
        taskExecutor.forEach( chunks, chunk -> {
            for ( IntType pixel : Views.interval( image, chunk ) )
                pixel.setOne();
        } );
    }

  • Field Details

  • Constructor Details

    • Parallelization

      private Parallelization()

  • Method Details

    • getTaskExecutor

      public static TaskExecutor getTaskExecutor()
      Returns the TaskExecutor that was set for this thread.

    • getExecutorService

      public static ExecutorService getExecutorService()

    • runSingleThreaded

      public static void runSingleThreaded(Runnable action)
      To run an algorithm single-threaded use:

      Parallelization.runSingleThreaded( () -> myAlgorithm( input ) );

    • runSingleThreaded

      public static <T> T runSingleThreaded(Callable<T> action)
      To run an algorithm single-threaded use:

      output = Parallelization.runSingleThreaded( () -> myAlgorithm( input ) );

    • runMultiThreaded

      public static void runMultiThreaded(Runnable action)
      To run an algorithm multi-threaded use:

      Parallelization.runMultiThreaded( () -> myAlgorithm( input ) );

    • runMultiThreaded

      public static <T> T runMultiThreaded(Callable<T> action)
      To run an algorithm multi-threaded use:

      output = Parallelization.runMultiThreaded( () -> myAlgorithm( input ) );

    • runWithNumThreads

      public static void runWithNumThreads(int numThreads, Runnable action)
      To run an algorithm a given number of threads use:

      Parallelization.runWithNumThreads( numThreads, () -> myAlgorithm( input ) );

    • runWithNumThreads

      public static <R> R runWithNumThreads(int numThreads, Callable<R> action)
      To run an algorithm a given number of threads use:

      output = Parallelization.runWithNumThreads( numThreads, () -> myAlgorithm( input ) );

    • runWithExecutor

      public static void runWithExecutor(ExecutorService executorService, Runnable action)
      Executes the given Runnable with the given ExecutorService, and waits for the execution to finish.

    • runWithExecutor

      public static <R> R runWithExecutor(ExecutorService executorService, Callable<R> action)
      Executes the given Callable with the given ExecutorService, waits for the execution to finish and returns the result.

    • runWithExecutor

      public static void runWithExecutor(TaskExecutor taskExecutor, Runnable action)
      Executes the given Runnable with the given TaskExecutor, and waits for the execution to finish.

    • runWithExecutor

      public static <T> T runWithExecutor(TaskExecutor taskExecutor, Callable<T> action)
      Executes the given Callable with the given TaskExecutor, waits for the execution to finish and returns the result.

    • setExecutorRequiresReset

      static Parallelization.Frame setExecutorRequiresReset(TaskExecutor taskExecutor)
      This method can be used to execute an algorithm with a given TaskExecutor. But it's easier to use runWithExecutor(ExecutorService, Runnable).

      This method sets the TaskExecutor for the current thread. This can be used to execute a certain part of your code with the given TaskExecutor. It's mandatory to call the close() of the return frame afterwards. This could be done using an try-with-resources statement. 

      

try ( Parallelization.Frame frame = Parallelization.setExecutorRequiresReset( taskExecutor ) )
{
    myAlgorithm(input);
}
      Or by explicitly calling frame.close() in the finally block. 
      

Parallelization.Frame frame = Parallelization.setExecutorRequiresReset( taskExecutor );
try
{
    myAlgorithm(input);
}
finally
{
    frame.close();
}