Scioto

From HPCRL Wiki
(Difference between revisions)
Jump to: navigation, search
(Undo revision 832 by 94.102.60.182 (Talk))
(Updated download link)
 
(30 intermediate revisions by 2 users not shown)
Line 1: Line 1:
== Scioto: Shared Collections of Task Objects ==
+
Scioto, or Shared Collections of Task Objects, is a lightweight framework for providing task management on
 +
distributed memory machines under one-sided and global-view parallel programming models. Scioto provides locality aware dynamic load balancing and interoperates with MPI, ARMCI, and Global Arrays.  Through task parallelism, the Scioto framework provides a solution for overcoming irregularity, load imbalance, and heterogeneity as well as dynamic mapping of computation onto emerging architectures.
  
Scioto (pronounced /sigh-OH-toe/ [http://en.wikipedia.org/wiki/Scioto_River]) is a framework for supporting task parallelism on distributed memory machines under one-sided and global view parallel programming models.  This framework allows the user to express their program as a set of tasks that are automatically scheduled and load balanced with respect to locality by the runtime system.    Through task parallelism, the Scioto framework provides an approach to overcoming irregularity, load imbalance, and heterogeneity as well as dynamic mapping of computation onto emerging architectures.
+
== Scioto Programming Model ==
  
Scioto uses ARMCI and MPI internallyWe have tested interoperability with MPI, ARMCI, and Global Arrays applications and are investigating interoperability with additional parallel programming tools.
+
Scioto provides the user with a task pool programming modelUnder this model the user expresses their computation as a set of ''tasks'' that can be executed in parallel.  Tasks read inputs from their task descriptor as well as from data stored in the global address space.  Tasks store their output in the global address space and are also permitted to add new tasks to the task collection.
  
== Documentation ==
+
Below is pseudocode that shows the structure of a simple Scioto program.
  
Sorry, documentation is a work in progress! We hope to have something here soon! Please refer to the example programs included with the Scioto source code and Doxygen comments in the source.
+
<pre>
 +
  // The user decides how to store task arguments within the task
 +
  // body.  Generally, users define a struct to organize this data.
 +
typedef struct {
 +
  double args;
 +
} mytask_t;
  
=== Publications ===
+
// The user provides a function that implements the task.  This
 +
// function is run by Scioto when executing the task.
 +
void task_fcn(gtc_t gtc, task_t *my_task) {
 +
  // ...
 +
}
  
'''Scioto: A Framework for Global-View Task Parallelism''' [http://www.cse.ohio-state.edu/~dinan/research/tasks/scioto_icpp08.pdf pdf] [http://www.cse.ohio-state.edu/~dinan/scioto/Scioto_ICPP_2008.ppt slides]<br>
+
int main() {
James Dinan, Sriram Krishnamoorthy, D. Brian Larkins, Jarek Nieplocha, P. Sadayappan <br>
+
  gtc_t    tc  = gtc_create(...);      // Create a task collection
Proc. of 37th Intl. Conference on Parallel Processing. Portland, OR, Sept. 8-12, 2008.
+
  task_t  task = gtc_task_create(...); // Create a task descriptor
 +
  mytask_t my_t = gtc_task_body(task);  // Get the task body
 +
 
 +
  my_t.args = ...;    // Fill in the task's arguments
  
== Installing Scioto ==
+
  gtc_task_add(task); // Add the task to the task collection
  
Scioto depends on both [http://www.emsl.pnl.gov/docs/parsoft/armci/ ARMCI] and MPI.  Detailed installation instructions are included in the README file.
+
  gtc_process(tc);    // Enter task-parallel region
 +
}
 +
</pre>
  
=== Installing on a Linux Desktop ===
+
== Documentation ==
  
Scioto is designed for use on distributed memory clusters but it is also possible to try it out on your desktop.  This can also be convenient for development and tends to work best on SMP and multicore systems.  Here's how I do it on my Ubuntu Linux laptop:
+
=== Programming Interface ===
  
# Install MPI.  Under Ubuntu, MPICH for shared memory can be easily installed via:
+
Documentation on Scioto's user API can be found here: [[Scioto API]]
## $ apt-get install mpich-shmem-bin
+
# Download [http://www.emsl.pnl.gov/docs/parsoft/armci/ ARMCI v1.3.]
+
# Compile ARMCI using your MPI distribution.  Here's how I do it (''note: if you are running a 64 bit OS, you should change the target to LINUX64 and the ARMCI_LIBS path to LINUX64''):
+
## $ tar xvzf armci-1-3.tgz
+
## $ cd armci-1-3
+
## $ make CC=mpicc TARGET=LINUX MSG_COMMS=MPI ARMCI_NETWORK=SOCKETS
+
# Compile Scioto:
+
## $ make CC=mpicc ARMCI_LIBS=~/src/armci-1-3/lib/LINUX/ ARMCI_INCLUDE=~/src/armci-1-3/src/
+
# Compile the Scioto examples:
+
## $ cd tc-examples
+
## $ make CC=mpicc ARMCI_LIBS=~/src/armci-1-3/lib/LINUX/ ARMCI_INCLUDE=~/src/armci-1-3/src/
+
# Try it out!  Using Ubuntu's MPICH:
+
## $ mpirun.mpich-shmem -n 2 ./test-task
+
  
== Acknowledgements ==
+
=== Publications ===
  
Current project members:
+
'''Scalable Work Stealing'''
* [http://www.cse.ohio-state.edu/~dinan James Dinan] (Scioto maintainer)
+
[http://www.cse.ohio-state.edu/~dinan/research/tpool/dinan_sc09.pdf PDF]
* [http://www.cse.ohio-state.edu/~larkins D. Brian Larkins]
+
[http://www.cse.ohio-state.edu/~dinan/research/tpool/dinan_sc09_slides.ppt PPT]
 +
<br />
 +
James Dinan, Sriram Krishnamoorthy, D. Brian Larkins, Jarek Nieplocha, P. Sadayappan <br />
 +
Proc. 21st Intl. Conference on Supercomputing (SC). Portland, OR, Nov. 14-20, 2009.
 +
 
 +
'''Scioto: A Framework for Global-View Task Parallelism'''
 +
[http://www.cse.ohio-state.edu/~dinan/research/tpool/dinan_icpp08.pdf PDF]
 +
[http://www.cse.ohio-state.edu/~dinan/research/tpool/dinan_icpp08_slides.ppt PPT]
 +
<br />
 +
James Dinan, Sriram Krishnamoorthy, D. Brian Larkins, Jarek Nieplocha, P. Sadayappan <br />
 +
Proc. of 37th Intl. Conference on Parallel Processing. Portland, OR, Sept. 8-12, 2008.
 +
 
 +
== People ==
 +
 
 +
=== Project Leaders ===
 +
 
 +
* [http://www.mcs.anl.gov/~dinan James Dinan] (Primary contact)
 
* [http://www.cse.ohio-state.edu/~saday Prof. P. Sadayappan]
 
* [http://www.cse.ohio-state.edu/~saday Prof. P. Sadayappan]
 
* [http://hpc.pnl.gov/people/sriram/ Sriram Krishnamoorthy]
 
* [http://hpc.pnl.gov/people/sriram/ Sriram Krishnamoorthy]
 +
 +
=== Contributors ===
 +
 +
* [http://www.cse.ohio-state.edu/~larkins D. Brian Larkins]
 
* [http://hpc.pnl.gov/people/jarek/ Jarek Nieplocha]
 
* [http://hpc.pnl.gov/people/jarek/ Jarek Nieplocha]
  
This research was supported in part by DOE grant ''#DE-FC02-06ER25755'' and NSF
+
== Acknowledgements ==
grant ''#0403342''.
+
 
 +
This research was supported in part by DOE grant ''#DE-FC02-06ER25755'' and NSF grant ''#0403342''.
  
 
== Download ==
 
== Download ==
  
We are currently providing early development snapshots for downloadPlease contact Jim Dinan (dinan at cse.ohio-state.edu) if you have questions or comments regarding Scioto.
+
Please see the included README file for installation instructionsIf you have questions or comments, contact Jim Dinan (dinan at mcs.anl.gov).
  
* Dev Snapshot, 09-13-2008 [http://www.cse.ohio-state.edu/~dinan/scioto/scioto-dev-09-13-2008.tar.gz]
+
* [http://hpcrl.cse.ohio-state.edu/scioto/scioto-r7688.tar.gz Scioto v0.2] -- ''11/15/2011''
* Dev Snapshot, 09-10-2008 [http://www.cse.ohio-state.edu/~dinan/scioto/scioto-dev-09-10-2008.tar.gz]
+
* [http://www.mcs.anl.gov/~dinan/download/scioto/scioto-0.1.tar.gz Scioto v0.1] -- ''11/15/2010''

Latest revision as of 16:25, 7 January 2015

Scioto, or Shared Collections of Task Objects, is a lightweight framework for providing task management on distributed memory machines under one-sided and global-view parallel programming models. Scioto provides locality aware dynamic load balancing and interoperates with MPI, ARMCI, and Global Arrays. Through task parallelism, the Scioto framework provides a solution for overcoming irregularity, load imbalance, and heterogeneity as well as dynamic mapping of computation onto emerging architectures.

Contents

Scioto Programming Model

Scioto provides the user with a task pool programming model. Under this model the user expresses their computation as a set of tasks that can be executed in parallel. Tasks read inputs from their task descriptor as well as from data stored in the global address space. Tasks store their output in the global address space and are also permitted to add new tasks to the task collection.

Below is pseudocode that shows the structure of a simple Scioto program.

 // The user decides how to store task arguments within the task
 // body.  Generally, users define a struct to organize this data.
 typedef struct {
   double args;
 } mytask_t;

 // The user provides a function that implements the task.  This
 // function is run by Scioto when executing the task.
 void task_fcn(gtc_t gtc, task_t *my_task) {
   // ...
 }

 int main() {
   gtc_t    tc   = gtc_create(...);      // Create a task collection
   task_t   task = gtc_task_create(...); // Create a task descriptor
   mytask_t my_t = gtc_task_body(task);  // Get the task body
   
   my_t.args = ...;    // Fill in the task's arguments

   gtc_task_add(task); // Add the task to the task collection

   gtc_process(tc);    // Enter task-parallel region
}

Documentation

Programming Interface

Documentation on Scioto's user API can be found here: Scioto API

Publications

Scalable Work Stealing PDF PPT
James Dinan, Sriram Krishnamoorthy, D. Brian Larkins, Jarek Nieplocha, P. Sadayappan
Proc. 21st Intl. Conference on Supercomputing (SC). Portland, OR, Nov. 14-20, 2009.

Scioto: A Framework for Global-View Task Parallelism PDF PPT
James Dinan, Sriram Krishnamoorthy, D. Brian Larkins, Jarek Nieplocha, P. Sadayappan
Proc. of 37th Intl. Conference on Parallel Processing. Portland, OR, Sept. 8-12, 2008.

People

Project Leaders

Contributors

Acknowledgements

This research was supported in part by DOE grant #DE-FC02-06ER25755 and NSF grant #0403342.

Download

Please see the included README file for installation instructions. If you have questions or comments, contact Jim Dinan (dinan at mcs.anl.gov).

Personal tools