Concurrency: Rubies, Plural

Concurrency:Rubies, Plural

Elise Huard & Eleanor McHugh

RubyConf 2010Friday 12 November 2010

manifestoconcurrency matters

Friday 12 November 2010

multicoreit’s a revolution in mainstream computing

and you want to exploit it in Ruby

MULTIPROCESSOR/MULTICORE

NETWORK ON CHIP(50..96..100 CORES)

diminishing returns

• communication takes finite time

• so doubling processors never doubles a system’s realworld performance

• realtime capacity ~70% theoretical capacity

• or less!!!

• independence = performance

“... for the first time in history, no one is building a much faster sequential processor. If you want your programs to run significantly faster (...) you’re going to have to parallelize your program.”

Hennessy and Patterson “Computer Architectures” (4th edition, 2007)

concurrencywhy it really matters

an aide to good design

• decouples independent tasks

• encourages data to flow efficiently

• supports parallel execution

• enhances scalability

• improves program comprehensibility

finding green pasturesadopting concurrency idioms from other languages

victims of choice

Erlang Actors

Go Concurrent Sequential Processes

Clojure Software Transactional Memory

Icon Coexpressions

coroutinessynchronising via transfer of control

• a procedural language

• with a single thread of execution

• generators are decoupled coexpressions

• and goal-directed evaluation

• creates flexible flow-of-control

icon coexpressionsprocedure main()

n := create(seq(1)\10)s := create(squares())c := create(cubes())while write(@n, “\t”, @s, “\t”, @c)

procedure seq(start)repeat {

suspend startstart += 1

procedure squares()odds := 3sum := 1repeat {

suspend sumsum +:= oddsodds +:= 2

procedure cubes()odds := 1sum := 1i := create(seq(2))repeat {

suspend sumsum +:= 1 + (odds * 6)odds +:= @i

3 9 27

4 16 64

5 25 125

6 36 216

7 49 343

8 64 512

9 81 729

10 100 1000

ruby fibers

• coexpressions

• bound to a single thread

• scheduled cooperatively

• the basis for enumerators

• library support for full coroutines

ruby coexpressionsdef seq start = 1

Fiber.new doloop do

Fiber.yield startstart += 1

endend

n = seq()

s = Fiber.new dosum, odds = 1, 3loop do

Fiber.yield sumsum += oddsodds += 2

endend

c = Fiber.new dosum, odds, i = 1, 1, seq(2)loop do

Fiber.yield sumsum += 1 + (odds * 6)odds += i.resume

endend

10.times doputs “#{n.resume}\t#{s.resume}\t#{c.resume}”

3 9 27

4 16 64

5 25 125

6 36 216

7 49 343

8 64 512

9 81 729

10 100 1000

ruby coroutinesrequire 'fiber'

def login Fiber.new do |server, name, password| puts "#{server.transfer(Fiber.current)} #{name}" puts "#{server.transfer name} #{password}" puts “login #{server.transfer password}” endend

def authenticate Fiber.new do |client| name = client.transfer "name:" password = client.transfer "password:" if password == "ultrasecret" then client.transfer "succeeded" else client.transfer "failed" end endend

login.transfer authenticate, "jane doe", "ultrasecret"login.transfer authenticate, "john doe", "notsosecret"

name: jane doepassword: ultrasecretlogin succeededname: john doepassword: notsosecretlogin failed

icon revisitedprocedure powers()

repeat {while e := get(queue) do

write(e, “\t”, e^ 2, “\t”, e^ 3)e @&source

procedure process(L)consumer := get(L)every producer := !L do

while put(queue, @producer) doif *queue > 3 then @consumer

@consumerend

global queue

procedure main()queue := []process{ powers(), 1 to 5, seq(6, 1)\5 }

3 9 27

4 16 64

5 25 125

6 36 216

7 49 343

8 64 512

9 81 729

10 100 1000

a ruby equivalentrequire 'fiber'

def process consumer, *fibersq = consumer.transfer(Fiber.current)fibers.each do |fiber|

while fiber.alive?q.push(fiber.resume)q = consumer.transfer(q) if q.length > 3

endendconsumer.transfer q

powers = Fiber.new do |caller|loop do

caller.transfer([]).each do |e|puts "#{e}\t#{e ** 2}\t#{e ** 3}" rescue nil

endend

low_seq = Fiber.new do5.times { |i| Fiber.yield i + 1 }nil

high_seq = Fiber.new do(6..10).each { |i| Fiber.yield i }

process powers, low_seq, high_seq

3 9 27

4 16 64

5 25 125

6 36 216

7 49 343

8 64 512

9 81 729

10 100 1000

processesthe traditional approach to concurrency

language VM

OS(kernel processes, other processes)

Your program

multicore - multiCPU

processes + threads

Process 2

RAMmemory space

Process 1

thread1

scheduler (OS)

CPU CPU

memory space

thread2 t1 t2 t3

cooperative preemptive

active task has full control scheduler controls task activity

runs until it yields control switches tasks automatically

tasks transfer control directly a task can still yield control

within one thread several threads

schedulers

3 threads, 2 cores

core1 core2 core1 core2

process thread

address space

kernel resources

scheduling

communication

control

private shared

private + shared shared

kernel varies

IPC via kernel in process

children in process

feature comparison

process creation

• unix spawns

• windows cuts from whole cloth

• ruby wraps this many ways

• but we’re mostly interested in fork

• creates a new process

• in the same state as its parent

• but executing a different code path

• forking is complicated by pthreads

• and ruby’s default garbage collector

• creates an I/O channel between processes

• unnamed pipes join two related processes

• posix named pipes

• live in the file system

• have user permissions

• persist independently of processes

def execute &blockchild_input, parent_input = IO.pipepid = fork dochild_input.closeresult = block.callparent_input.write result.to_jsonparent_input.close

endparent_input.closesorted = JSON.parse child_input.readchild_input.closeProcess.waitpid pidreturn sorted

forking

context switchingOperating System Benchmark Operation Time (ms)

LinuxLinuxLinuxLinuxLinux

Windows NTWindows NTWindows NTWindows NTWindows NT

spawn new process fork() / exec() 6,000

clone current process fork() 1,000

spawn new thread pthread_create 0,300

switch current process sched_yield() 0,019

switch current thread sched_yield() 0,019

spawn new process spawnl() 12,000

clone current process N/A ---

spawn new thread pthread_create() 0,900

switch current process Sleep(0) 0,010

switch current thread Sleep(0) 0,006

C Benchmarks by Gregory Travis on a P200 MMXhttp://cs.nmu.edu/~randy/Research/Papers/Scheduler/

shared state hurts

• non-determinism

• atomicity

• fairness/starvation

• race conditions

• locking

• transactional memory

semaphores

• exist independently of processes

• provide blocking access

• allowing processes to be synchronised

• nodes in the file system

• usable from Ruby with syscall

synchronising processesrequire ‘dl’require ‘fcntl’libc = DL::dlopen ‘libc.dylib’open = libc[‘sem_open’, ‘ISII’]try_wait = libc[‘sem_trywait’, ‘II’]wait = libc[‘sem_wait’, ‘II’]post = libc[‘sem_post’, ‘II’]close = libc[‘sem_close’, ‘II’]

process 1s = open.call(“/tmp/s”, Fcntl::O_CREAT, 1911)[0]wait.call sputs “locked at #{Time.now}”sleep 50puts “posted at #{Time.now}”post.call sclose.call s

process 2s = open.call(“/tmp/s”)t = Time.nowif try_wait.call(s)[0] == 0 then

puts “locked at #{t}”else

puts “busy at #{t}”wait.call sputs “waited #{Time.now - t} seconds”

locked at Thu May 28 01:03:23 +0100 2009 busy at Thu May 28 01:03:36 +0100 2009

posted at Thu May 28 01:04:13 +0100 2009 waited 47.056508 seconds

complexity

• file locking

• shared memory

• message queues

• transactional data stores

threadsthe popular approach to concurrency

threads under the hood

from http://www.igvita.com/2008/11/13/concurrency-is-a-myth-in-ruby/ @igrigorik

the global lock

• compatibility for 1.8 C extensions

• only one thread executes at a time

• scheduled fairly with a timer thread

• 10 μs for Linux

• 10 ms for Windows

synchronisation

• thread groups

• locks address race conditions

• mutex + monitor

• condition variable

• deadlocks

• livelocks

threads + socketsrequire 'socket'require 'thread'

class ThreadGroupdef all_but_me &block

list. delete_if { |t|t.name == Thread.current.name

}.each { |t| yield t }end

def select *names, &block

list.delete_if { |t|!names.include? t.name

}.each { |t| yield t }end

class Threaddef name= n

raise ArgumentError if key? :nameself[:name] = n self[:Q] = Queue.new

def send messageself[:Q].enq message

def bind_transmitter socketraise ArgumentError if key? :XMITself[:socket] = socketself[:XMIT] = Thread.new(socket, self[:Q]) do |s, q|

loop docase message = q.deqwhen :EXIT: Thread.current.exitelse s.puts messageendThread.pass

endend

def disconnectsend "Goodbye #{name}"send :EXITself[:XMIT].joinself[:socket].closeexit

endend

threads + socketsclass ChatServer < TCPServer

def initialize port@receivers = ThreadGroup.new@transmitters = ThreadGroup.new@deceased = ThreadGroup.newsuper

def register name, socket@receivers.add(t = Thread.current)t.name = name@transmitters.add t.bind_transmitter(socket)broadcast "#{name} has joined the conversation"t.send "Welcome #{name}"

def connect socketloop do

beginsocket.print "Please enter your name: "register socket.readline.chomp).downcase, socketbreak

rescue ArgumentErrorsocket.puts "That name is already in use"

endend

def send message, name = Thread.current.name@receivers.select(name) { |t| t.send message }

def broadcast message@receivers.all_but_me { |t| t.send message }

def listen sockett = Thread.currentloop do

message = socket.readline.chompcase message.downcasewhen "bye" raise EOFErrorwhen "known" list_known_userswhen "quit" raise SystemExitelse broadcast "#{t.name}: #{message}"end

endend

def runwhile socket = accept

Thread.new(socket) do |socket|begin

connect socketlisten socket

rescue SystemExitbroadcast "#{Thread.current.name} terminated this conversation"broadcast :EXITsend :EXIT@receivers.all_but_me { |t| t.transmitter.join }Kernel.exit 0

rescue EOFErrordisconnect

endend

ChatServer.new(3939).run

the macruby twist

• grand central dispatch

• uses an optimal number of threads

• state is shared but not mutable

• object-level queues for atomic mutability

clojure

lisp dialect for the JVMlisp dialect for the JVM

refs software transactional memory

agents independent, asynchronous change

vars in-thread mutability

check out Tim Bray’s Concur.next seriescheck out Tim Bray’s Concur.next series

parallel banking(ns account)

; ref (def transactional-balance (ref 0))

; transfer: within a transaction (defn parallel-transfer [amount] (dosync (alter transactional-balance transfer amount)))

; many threads adding 10 onto account (defn parallel-stm [amount nthreads] (let [threads (for [x (range 0 nthreads)] (Thread. #(parallel-transfer amount)))] (do (doall (map #(.start %) threads)) (doall (map #(.join %) threads)))) @transactional-balance)

ruby can do that toorequire 'clojure'

include Clojure

def parallel_transfer(amount) Ref.dosync do @balance.alter {|b| b + amount } endend

def parallel_stm(amount, nthreads) threads = [] 10.times do threads << Thread.new do parallel_transfer(amount) end end threads.each {|t| t.join } @balance.derefend

@balance = Ref.new(0)puts parallel_stm(10,10)

enumerableseveryday ruby code which is naturally concurrent

vector processing

• collections are first-class values

• single instruction multiple data

• each datum is processed independently

• successive instructions can be pipelined

• so long as there are no side-effects

map/reduce

• decompose into independent elements

• process each element separately

• use functional code without side-effects

• recombine the elements

• intrinsically suited to parallel execution

a two-phase operationconcurrent sequential

(0..5).to_a.each { |i| puts i }

x = 0(0..5).to_a.each { |i| x = x + i }

(0..5).to_a.map { |i| i ** 2 }

(0..5).to_a.inject { |sum, i| sum + i }

parallelrequire 'brute_force'require 'parallel'

# can be run with :in_processes as wellmapped = Parallel.map((0..3).to_a, :in_threads => 4) do |num| map("english.#{num}") # hash the whole dictionaryend

hashed = "71aa27d3bf313edf99f4302a65e4c042"

puts reduce(hashed, mapped) # returns “zoned”

algebra, actors + eventssynchronising concurrency via communication

process calculi

• mathematical model of interaction

• processes and events

• (a)synchronous message passing

• named channels with atomic semantics

• statically-typed compiled systems language

• class-free object-orientation

• garbage collection

• independent lightweight coroutines

• implicit cross-thread scheduling

• channels are a first-class datatype

package mainimport "syscall"

func (c *Clock) Start() {if !c.active {

go func() {c.active = truefor i := int64(0); ; i++ {

select {case status := <- c.Control:

c.active = statusdefault:

if c.active {c.Count <- i

}syscall.Sleep(c.Period)

type Clock struct {Period int64Count chan int64Control chan boolactive bool

func main() {c := Clock{1000, make(chan int64), make(chan bool), false}c.Start()

for i := 0; i < 3; i++ {println("pulse value", <-c.Count, "from clock")

println("disabling clock")c.Control <- falsesyscall.Sleep(1000000)println("restarting clock")c.Control <- trueprintln("pulse value", <-c.Count, "from clock")

produces:pulse value 0 from clockpulse value 1 from clockpulse value 2 from clockdisabling clockrestarting clockpulse value 106 from clock

a signal generator

homework

• write a signal generator in ruby

• hints:

• it’s very easy

• look at the thread + socket example

• use atomic queues

• and yes, ruby grok’s csp

actor model

• named actors

• fully independent of each other

• asynchronous message passing

• and no shared state

erlang

• implements actors with green processes

• efficient SMP-enabled VM

• functional language

• hot code loading

• fault-tolerant

erlang-module(brute_force).-import(plists).-export(run/2).

map(FileName) -> {ok, Binary} = file:read_file(FileName), Lines = string:tokens(erlang:binary_to_list(Binary), "\n"), lists:map(fun(I) -> {erlang:md5(I), I} end, Lines).

reduce(Hashed, Dictionary) -> dict:fetch(Hashed, Dictionary).

run(Hashed, Files) -> Mapped = plists:map(fun(I) -> map(I) end, Files), Values = lists:flatten(Mapped), Dict = dict:from_list(Values), reduce(Hashed, Dict).

erlangpmap(F, L) -> S = self(), Pids = lists:map(fun(I) -> spawn(fun() -> pmap_f(S, F, I) end) end, L), pmap_gather(Pids).

pmap_gather([H|T]) -> receive {H, Ret} -> [Ret|pmap_gather(T)] end;pmap_gather([]) -> [].

pmap_f(Parent, F, I) -> Parent ! {self(), (catch F(I))}.

rubinius actors

• implemented as ruby threads

• each thread has an inbox

• cross-VM communication

rubinius actorsrequire 'quick_sort'require 'actor'

class RbxActorSort

" def execute(&block)" " current = Actor.current" " Actor.spawn(current) {|current| current.send(block.call) }" " Actor.receive # could have filter" end

puts q = QuickSort.new([1,7,3,2,77,23,4,2,90,100,33,2,4], RbxActorSort).sort

ruby revactor

• erlang-like semantics

• actor spawn/receive

• filter

• uses fibers for cooperative scheduling

• so only works on ruby 1.9

• non-blocking network access in ruby 1.9.2

promises + futures

• abstraction for delayed execution

• a promise is calculated in parallel

• a future is calculated on demand

• caller will block when requesting result

• until that result is ready

ruby futuresLazy.rb gem (@mentalguy)require 'lazy'require 'lazy/futures'

def fib(n) return n if (0..1).include? n fib(n-1) + fib(n-2) if n > 1end

puts "before first future"future1 = Lazy::Future.new { fib(40) }puts "before second future"future2 = Lazy::Future.new { fib(40) }puts "and now we're waiting for results ... getting futures fulfilled is blocking"

puts future1puts future2

we didn’t cover

• tuple spaces (Rinda)

• event-driven IO

• petri nets

• ...

reinventing?

some of these problems have been solved before ...

to surmise

• beware of shared mutable state

• but: sane ways to handle concurrency

• they are all possible in Ruby

http://www.delicious.com/elisehuard/concurrency

http://www.ecst.csuchico.edu/~beej/guide/ipc/

http://wiki.netbsd.se/kqueue_tutorial

http://www.kegel.com/c10k.html

Elise Huard @elise_huard http://jabberwocky.eu

Eleanor McHugh @feyeleanor http://slides.games-with-brains.net

Concurrency: Rubies, Plural

Technology

Transcript of Concurrency: Rubies, Plural

PLURAL RULE ONE PLURAL RULE TWO

Natural Rubies with Glass-Filled Cavities - GIA · NATURAL RUBIES WITH GLASS-FILLED CAVITIES By Robert E. Kane During recent months, natural rubies with surface cavities filled with

Concurrency: Rubies, plural

Far - Far Above Rubies - Spring Issue

Color improvement of rubies by ion beam techniqueqd.swu.ac.th/Portals/2077/10_4-2-19 Color improvement of rubies by … · Color improvement of rubies by ion beam technique ... However,

Kirkwood Community College - Beyond Rubies

RUBIES - Wag & Pawshcmsfeffer.weebly.com › uploads › 2 › 2 › 7 › 9 › 22796270 › rubies_an… · Sample Problem – Step 6 RUBIES List A List B [Glass] beaker [Copper]

2010 Trend Article - Above Rubies Studio

“Lead Glass Filled/Repaired Rubies” - fieldgemology.orgold-fg.fieldgemology.org/Ruby_lead_glass_treatment.pdf · 2017-08-15 · “Lead Glass Filled/Repaired Rubies” By Vincent

Multithreading and Concurrency Questionsenos.itcollege.ee/.../reading/Multithreading-and-Concurrency-Questions.pdf · Multithreading and Concurrency Questions vi Preface Concurrency

AGA Rubies: The Heat Is On - Solitaire International...Rubies: The Heat Is On Lack of proper disclosure for lead-glass filled rubies challenges consumer confidence in the gem and jewellery

A Basket of Rubies - Pre-Release

Concurrency: Rubies, Plural · 2015. 10. 20. · diminishing returns • communication takes ﬁnite time • so doubling processors never doubles a system’s realworld performance

s Beyond Rubies Conference for Women

IES Maria Rubies

FAR Far Above Rubies - Winter 2012-13

Newsletter July Rubies - draft 3.pdf

Above rubies media kit

Goal of Concurrency Control Concurrency Control Also ...

Sandman 01-08 - More than Rubies