Cnc scala-presentation
Upcoming SlideShare
Loading in...5
×
 

Cnc scala-presentation

on

  • 949 views

 

Statistics

Views

Total Views
949
Views on SlideShare
707
Embed Views
242

Actions

Likes
0
Downloads
7
Comments
0

2 Embeds 242

http://skillsmatter.com 234
http://smash 8

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Cnc scala-presentation Cnc scala-presentation Presentation Transcript

  • 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 SkillsParallelism oblivious Focus of this talk developers Focus of Rice Habanero Project Parallelism aware Habanero-Scala, devs presented earlier today Java threads, locks, etc. Concurrency Experts 3 http://habanero.rice.edu
  • The IssueParallel 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
  • Exactly Two Sources of Ordering Requirements•  Producer must execute before consumer•  Controller must execute before controllee 6
  • Outline•  The Concurrent Collections (CnC) Model •  Features •  Constructs•  CnC Scala – Example•  Implementation•  Results 7
  • 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 (step) •  Computational unit of a CnC program •  Stateless •  Side-effect free •  Functional with respect to inputs 9
  • CnC Constructs – Data Items [in_item] (step) [out_item] •  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 10
  • CnC Constructs - Control <tag> [in_item] (step) [out_item] •  Tag Collections are control units •  Used to execute (prescribe) steps •  A CnC step will not launch until its tag has been put 11
  • CnC Constructs - Environment env <tag> envenv [in_item] (step) [out_item] •  A driver which encapsulates the CnC Graph •  Provides inputs to and consumes outputs from the CnC Graph 12
  • Exactly Two Sources of Ordering Requirements•  Producer must execute before consumer•  Controller must execute before controllee Producer - Consumer Controller - Controllee <tag1> (prod) [C1] (cons) (C-er) (C-ee) 13
  • Outline•  The CnC Model•  CnC-Scala •  Build Model •  Capitalize-Words Example •  Step Code•  Implementation•  Results 14
  • 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 cnc_scala_translate - Step code - main() method Generated Stub code cnc_scala_compile Compiled bytecode cnc_scala_run User Code OutputGenerated Code 16
  • Capitalize-Words example1.  import edu.rice.cnc.translator.GraphDescription._ 2.  object SplitCapitalizeCncDefinition extends App { 3.  // Item Collections 4.  ItemCollection[String, String]("input") 5.  ItemCollection[String, String]("words") 6.  ItemCollection[String, String]("result") 7.  // Tag Collections 8.  TagCollection[String]("data") 9.  TagCollection[String]("token") 10.  // Step Prescriptions 11.  Presription("data", List("split")) 12.  Presription("token", List("capitalize")) 13.  // Step Dependences 14.  StepDependence("split", List ("input"), List("token", "words")) 15.  StepDependence("capitalize", List("words"), List("result")) 16.  // Environment Collections 17.  EnvironmentDependence(List("input", "data"), List("result")) 18.  } 17
  • Generated Code Example1.  trait SplitStep extends Step { 2.  3.  // Optional to provide an implementation 4.  def createDependences( 5.  tag: java.lang.String, 6.  inInput: InputCollection[java.lang.String, java.lang.String], 7.  dependenceManager: DependenceManager 8.  ): Unit = {} 9.  10.  // User must provide an implementation for this method 11.  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.  } 18
  • User Step Code1.  class UserSplitStep extends SplitStep { 2.  3.  // User must provide an implementation for this method 4.  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 + ":" + index 13.  outWords.put(newTag, token) 14.  outToken.put(newTag) 15.  } } } 19
  • User Main1.  object SplitCapitalizeMain extends CncScalaApp { 2.  // Instantiate Steps 3.  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 collections 10.  val tag = "1" 11.  graph.input.put(tag, "hello world") 12.  graph.data.put(tag) 13.  } 14.  }) 15.  // read results 16.  graph.result.dump(System.out) 17.  } 20
  • Outline•  The CnC Model•  CnC-Scala•  Implementation •  Data-driven futures •  Continuations•  Results 21
  • 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 = null Output: 5.  reset { // delimit boundary start 6.  println("B. Entered reset") 7.  shift[Unit, Any, Unit] { A. Main starts 8.  delimCont => B. Entered reset 9.  println("C. Entered shift") C. Entered shift 10.  continuation = delimCont D. Inside shift F. Outside reset 11.  println("D. Inside shift") G. Calling cont. 12.  } E. After shift 13.  println("E. After shift") H. Main ends 14.  } // delimit boundary end 15.  println("F. Outside reset") 16.  println("G. Calling cont.") 17.  continuation() 18.  println("H. Main ends") 19.  } 20.  } 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
  • Outline•  The CnC Model•  CnC-Scala•  Implementation•  Results 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