CnC-Scala: A Declarative Approach to

Multicore Parallelism

Scala Days April 17, 2012

Shams Imam and Vivek Sarkar Rice University

1

Acknowledgments

•  Habanero Group –  Sagnak Tasirlar – Dragos Sbirlea –  Alina Sbirlea

•  “Concurrent Collections” Zoran Budimlic, Michael Burke, Vincent Cave, Kathleen Knobe, Geoff Lowney, Ryan Newton, Jens Palsberg, David Peixotto, Vivek Sarkar, Frank Schlimbach, Sagnak Tasirlar. Scientific Programming.

•  “Concurrent Collections: Easy and effective distributed computing” Frank Schlimbach, Kath Knobe, James Brodman.

2

Inverted Pyramid of Parallel Programming Skills

Parallelism oblivious developers

Parallelism aware devs

Concurrency Experts

Java threads, locks, etc.

Focus of Rice Habanero Project

Focus of this talk

Habanero-Scala,

presented earlier today

3 http://habanero.rice.edu

The Issue

Parallel programs are notoriously difficult for

mortals to write, debug, maintain and port.

4

The Big Idea

•  Don’t specify what operations run in parallel

•  Difficult and depends on target

•  Specify the semantic ordering constraints only •  Easier and depends only on application

5

•  Producer must execute before consumer

•  Controller must execute before controllee

Exactly Two Sources of Ordering Requirements

6

•  The Concurrent Collections (CnC) Model •  Features •  Constructs

•  CnC Scala – Example •  Implementation •  Results

7

Outline

The CnC model

•  Programmer defines semantic dependences •  Ordering constraints between computational units •  Code in computation unit is standard serial code

•  Runtime takes care of •  Executing the computational units •  Extracting parallelism in the application

8

CnC Constructs - Steps

•  Computational unit of a CnC program •  Stateless •  Side-effect free •  Functional with respect to inputs

(step)

9

CnC Constructs – Data Items

•  Data units are called Item Collection •  Means of communication between steps •  Mapping of data tags to items

•  Items can only be retrieved by their tags

•  Dynamic single assignment

[in_item] [out_item](step)

10

CnC Constructs - Control

•  Tag Collections are control units •  Used to execute (prescribe) steps •  A CnC step will not launch until its tag has been put

<tag>

[in_item] [out_item](step)

11

CnC Constructs - Environment

•  A driver which encapsulates the CnC Graph •  Provides inputs to and consumes outputs

from the CnC Graph

env

env env

<tag>

[in_item] [out_item](step)

12

Controller - Controllee Producer - Consumer

•  Producer must execute before consumer

•  Controller must execute before controllee

Exactly Two Sources of Ordering Requirements

(cons)[C1](prod) (C-ee)(C-er)

<tag1>

13

•  The CnC Model •  CnC-Scala

•  Build Model •  Capitalize-Words Example •  Step Code

•  Implementation •  Results

14

Outline

CnC-Scala

•  Written in pure Scala •  uses continuations compiler plugin

•  Only dependency – jsr-166y.jar •  comes bundled with java 7

•  Distribution with examples available at: •  http://cnc-scala.rice.edu/

15

CnC-Scala Build Model

CnC Graph Spec

Generated Stub code

- Step code - main() method

Compiled bytecode

cnc_scala_compile

cnc_scala_run

Output

cnc_scala_translate

User Code

Generated Code 16

Capitalize-Words example

17

1.  import edu.rice.cnc.translator.GraphDescription._2.  object SplitCapitalizeCncDefinition extends App {3.  // Item Collections4.  ItemCollection[String, String]("input")5.  ItemCollection[String, String]("words")6.  ItemCollection[String, String]("result")7.  // Tag Collections8.  TagCollection[String]("data")9.  TagCollection[String]("token")10.  // Step Prescriptions11.  Presription("data", List("split"))12.  Presription("token", List("capitalize"))13.  // Step Dependences14.  StepDependence("split", List ("input"), List("token", "words"))15.  StepDependence("capitalize", List("words"), List("result"))16.  // Environment Collections17.  EnvironmentDependence(List("input", "data"), List("result"))18.  }

Generated Code Example

18

1.  trait SplitStep extends Step {2.  3.  // Optional to provide an implementation4.  def createDependences(5.  tag: java.lang.String, 6.  inInput: InputCollection[java.lang.String, java.lang.String],7.  dependenceManager: DependenceManager8.  ): Unit = {}9.  10.  // User must provide an implementation for this method11.  def compute(12.  tag: java.lang.String, 13.  inInput: InputCollection[java.lang.String, java.lang.String], 14.  outToken: TagCollection[java.lang.String], 15.  outWords: OutputCollection[java.lang.String, java.lang.String]16.  ): Unit@cpsParam[Any, Any]17.  }

User Step Code

19

1.  class UserSplitStep extends SplitStep {2.  3.  // User must provide an implementation for this method4.  def compute(5.  tag: java.lang.String, 6.  inInput: InputCollection[java.lang.String, java.lang.String], 7.  outToken: TagCollection[java.lang.String], 8.  outWords: OutputCollection[java.lang.String, java.lang.String]9.  ): Unit@cpsParam[Any, Any] = {

10.  val inString = inInput.get(tag)11.  for ((token, index) <- inString.split(" +").view.zipWithIndex) {12.  val newTag = tag + ":" + index13.  outWords.put(newTag, token)14.  outToken.put(newTag)15.  } } }

User Main

20

1.  object SplitCapitalizeMain extends CncScalaApp {

2.  // Instantiate Steps3.  val splitStep = new UserSplitStep()4.  val capitalizeStep = new UserCapitalizeStep()5.  val graph = new SplitCapitalizeGraph(splitStep, capitalizeStep)6.  7.  graph.run(new Runnable() {8.  def run(): Unit = {9.  // populate data from environment to collections10.  val tag = "1"11.  graph.input.put(tag, "hello world")12.  graph.data.put(tag)13.  }14.  })15.  // read results16.  graph.result.dump(System.out)17.  }

•  The CnC Model •  CnC-Scala •  Implementation

•  Data-driven futures •  Continuations

•  Results

21

Outline

Implementation

•  Tag Collections •  Spawn new tasks run step code

•  Item Collections •  Use concurrent maps with user defined tag types as keys

and data-driven futures (DDF) as values •  What to do when get() has unavailable items?

•  Create continuations

•  When value becomes available… •  DDFs resume continuations

22

Data-driven futures

•  Separation of classical “futures” into data and control parts

•  Consumers can eagerly register on the DDF even before we know about the producer •  i.e., lazily attaches a producer to an item

•  When item is produced, all previously registered consumers are notified •  Subsequent consumers always get the value

immediately

23

Continuations

•  Represents rest of the computation from a given point in the program

•  Allows •  suspending current execution state •  resume from that point later

•  We need only delimited one-shot continuations •  Scala has shift-reset!

24

Benefits of using continuations

•  No re-execution of code •  Allow arbitrary (data-dependent) gets •  Threads never block

•  No extra threads created

25

Scala Continuation example

1.  object Main {2.  def main(args: Array[String]) {3.  println("A. Main starts")4.  var continuation: (Unit) => Any = null5.  reset { // delimit boundary start6.  println("B. Entered reset")7.  shift[Unit, Any, Unit] {8.  delimCont =>9.  println("C. Entered shift")10.  continuation = delimCont11.  println("D. Inside shift")12.  } 13.  println("E. After shift")14.  } // delimit boundary end15.  println("F. Outside reset")16.  println("G. Calling cont.")17.  continuation()18.  println("H. Main ends")19.  }20.  }

Output:A. Main startsB. Entered resetC. Entered shiftD. Inside shiftF. Outside resetG. Calling cont.E. After shiftH. Main ends

26

CnC-Scala Runtime - step

•  Tag Collection step prescription •  Wrap each step.compute() in a reset

// some preparation reset { step.compute(tag, inputs, outputs) } // book-keeping logic based on // whether continuation was stored // or execution completed normally

27

CnC-Scala Runtime - get

•  If item is available return it •  Else store continuation get(tag: TagType): ItemType = { if (itemAvailable) return item else shift { continuation => // store continuation } // when cont resumes, item is available return item }

28

CnC-Scala Runtime - put

•  Store item •  Resume waiting continuations put(tag: TagType, item: ItemType) { // store item into DDF // resume ALL waiting continuations }

29

•  The CnC Model •  CnC-Scala •  Implementation •  Results

Outline

30

CnC-Scala Results

•  12-core (two hex-cores) 2.8 GHz Intel Westmere SMP

•  48 GB memory, running Red Hat Linux (RHEL 6.0) •  Hotspot JDK 1.7 •  Scala version 2.9.1-1 •  CnC-Scala 0.1.2 •  Arithmetic mean of last thirty iterations from

hundred iterations on ten separate JVM invocations

31

Successive Over-Relaxation

•  1 Item Collection, 1 Tag Collection, and 1 Step. 32

NQueens

•  3 Item Collections, 1 Tag Collection, and 1 Step. 33

LU Decomposition

•  3 Item Collections, 5 Tag Collections, and 8 Steps. 34

CnC Features

•  Coordination language •  Dynamic light-weight task based •  Single assignment •  Deterministic •  Race free

35

Summary

•  CnC exposes more potential parallelism •  Development is productive

•  User declaratively defines dependences and writes only serial code

•  runtime hides all the difficulties with using low-level techniques

•  result is deterministic and independent of number of threads

36

Thank you!

[image source: http://www.jerryzeinfeld.com/tag/question-of-the-day/] 37