//******************************************************************************
//
// File: ParallelSection.java
// Package: edu.rit.pj
// Unit: Class edu.rit.pj.ParallelSection
//
// This Java source file is copyright (C) 2007 by Alan Kaminsky. All rights
// reserved. For further information, contact the author, Alan Kaminsky, at
// ark@cs.rit.edu.
//
// This Java source file is part of the Parallel Java Library ("PJ"). PJ is free
// software; you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation; either
// version 3 of the License, or (at your option) any later version.
//
// PJ is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
// A PARTICULAR PURPOSE. See the GNU General Public License for more details.
//
// A copy of the GNU General Public License is provided in the file gpl.txt. You
// may also obtain a copy of the GNU General Public License on the World Wide
// Web at http://www.gnu.org/licenses/gpl.html.
//
//******************************************************************************
package edu.rit.pj;
/**
* Class ParallelSection is the abstract base class for a section of code to be
* executed in parallel.
*
* A group of parallel sections may be executed concurrently by calling a
* {@linkplain ParallelRegion}'s execute() method. Each section in the
* group is executed by a different thread in the parallel thread team. Here is
* one way to code a parallel section group with two parallel sections:
*
* new ParallelTeam(2).execute (new ParallelRegion()
* {
* public void run() throws Exception
* {
* execute
* (new ParallelSection()
* {
* public void run()
* {
* // Code for first concurrent parallel section
* . . .
* }
* },
* new ParallelSection()
* {
* public void run()
* {
* // Code for second concurrent parallel section
* . . .
* }
* });
* }
* });
*
* Here is another way to code a parallel section group with two parallel
* sections:
*
* ParallelSection section_1 = new ParallelSection()
* {
* public void run()
* {
* // Code for first concurrent parallel section
* . . .
* }
* };
* ParallelSection section_2 = new ParallelSection()
* {
* public void run()
* {
* // Code for second concurrent parallel section
* . . .
* }
* };
* new ParallelTeam(2).execute (new ParallelRegion()
* {
* public void run() throws Exception
* {
* execute (section_1, section_2);
* }
* });
*
* A parallel section group may contain any number of parallel sections. There
* are overloaded execute() methods that take one, two, or three
* parallel section arguments. If there are four or more parallel sections, put
* them in an array (type ParallelSection[]) and pass the array to the
* execute() method.
*
* Normally, at the end of the parallel section group, the parallel team threads
* wait for each other at a barrier. To eliminate this barrier wait, include
* {@link BarrierAction#NO_WAIT BarrierAction.NO_WAIT} in the execute()
* method call:
*
* new ParallelTeam(2).execute (new ParallelRegion()
* {
* public void run() throws Exception
* {
* execute (section_1, section_2, BarrierAction.NO_WAIT);
* }
* });
*
* To execute a section of code in a single thread as part of the barrier
* synchronization, include an instance of class {@linkplain BarrierAction} in
* the execute() method call. The barrier action object's
* run() method contains the code to be executed in a single thread
* while the other threads wait:
*
* new ParallelTeam(2).execute (new ParallelRegion()
* {
* public void run() throws Exception
* {
* execute (section_1, section_2, new BarrierAction()
* {
* public void run()
* {
* // Single-threaded code goes here
* . . .
* }
* });
* }
* });
*
* For further information, see class {@linkplain BarrierAction}.
*
* A parallel section may be executed by one thread in the parallel thread team
* by executing a parallel section group consisting of the one parallel section,
* as shown above:
*
* new ParallelTeam().execute (new ParallelRegion()
* {
* public void run() throws Exception
* {
* . . .
* execute (new ParallelSection()
* {
* public void run()
* {
* // Code to be executed by one parallel team thread
* . . .
* }
* });
* . . .
* }
* });
*
*
* A parallel section may be executed in a mutually exclusive fashion by calling
* a {@linkplain ParallelRegion}'s critical() or
* criticalNonexclusive() method. For example:
*
* new ParallelTeam().execute (new ParallelRegion()
* {
* public void run() throws Exception
* {
* . . .
* critical (new ParallelSection()
* {
* public void run()
* {
* // Mutually exclusive code
* . . .
* }
* });
* . . .
* }
* });
*
*
* By calling a {@linkplain ParallelForLoop}'s ordered() method, a
* parallel section may be executed in the order of the loop indexes within a
* parallel for loop body, while the rest of the parallel for loop body executes
* concurrently. See classes {@linkplain IntegerForLoop}, {@linkplain
* IntegerStrideForLoop}, {@linkplain LongForLoop}, and {@linkplain
* LongStrideForLoop} for further information.
*
* By calling a {@linkplain ParallelIteration}'s ordered() method, a
* parallel section may be executed in the order of the items within a parallel
* iteration body, while the rest of the parallel iteration body executes
* concurrently. See class {@linkplain ParallelIteration} for further
* information.
*
* @author Alan Kaminsky
* @version 11-Nov-2007
*/
public abstract class ParallelSection
extends ParallelConstruct
{
// Exported constructors.
/**
* Construct a new parallel section.
*/
public ParallelSection()
{
super();
}
// Exported operations.
/**
* Execute this parallel section.
*
* The run() method must be implemented in a subclass.
*
* @exception Exception
* The run() method may throw any exception.
*/
public abstract void run()
throws Exception;
}
Ads help maintain this website.