Practical concurrent systems made simple using Kamaelia

Michael Sparks (BBC Research)

http://edit.kamaelia.org/GetKamaelia

Practical concurrent systems made simple using Kamaelia

Michael Sparks (BBC Research)http://edit.kamaelia.org/GetKamaelia


http://edit.kamaelia.org/GetKamaeliaMichael Sparks (BBC Research)


What is the problem?




Concurrencyis considered

HARD




WHY ?(is that really the problem?)




What is Kamaelia's

Goal?




to make

Concurrency

EASYto use




WHY ?(is that really the goal?)




What would Knuth do?




I can’t think of even five of those programs that would

have been enhanced noticeably by parallelism

or multithreading.

http://flickr.com/photos/scottlaird/




Hmm...




They think a magic bullet will come along to make multicores speed up my

kind of work; I think it’s a pipe dream.





Not helping...




(No—that’s the wrong metaphor! "Pipelines"

actually work for me, but threads don’t.)





Any formal support?




Why don't (more) people know

about it?

http://www.inf.u-szeged.hu/stf/eloado.php

It was written by Tony Hoare in 198523 years ago

Communicating Sequential Processes

essentially supports this in a formal way



http://edit.kamaelia.org/GetKamaeliahttp://www.inf.u-szeged.hu/stf/eloado.php

Scary?



Why is

concurrency(considered)

hard?



Why is

concurrency(considered)

hard?



BankCashiers£5

£10Alice

BobAccount starts at £2.50



Valid case 1Alice enters Bank cashier sharedCashier A, gets balance £ 2.50 £ 2.50A Takes £10 from Alice, add to balance £12.50 £ 2.50A Stores balance £12.50 £12.50

Bob enters Bank cashier sharedCashier B, gets balance £12.50 £12.50B Gives Bob £5, removes from balance £ 7.50 £12.50B Stores balance £ 7.50 £ 7.50

Final Balance: £7.50



Valid case 2Bob enters Bank cashier sharedCashier B, gets balance £ 2.50 £ 2.50B Gives Bob £5, removes from balance £ -2.50 £ 2.50B Stores balance £ -2.50 £ -2.50

Alice enters Bank cashier sharedCashier A, gets balance £ -2.50 £ -2.50A Takes £10 from Alice, add to balance £ 7.50 £ -2.50A Stores balance £ 7.50 £ 7.50

Final Balance: £7.50



But concurrency allows any order...

Final Balance: £.......



But concurrency allows any order...Bob enters Bank cashier sharedAlice enters Bank cashier sharedCashier B, gets balance £ 2.50 £ 2.50Cashier A, gets balance £ 2.50 £ 2.50B Gives Bob £5, removes from balance £ -2.50 £ 2.50A Takes £10 from Alice, add to balance £12.50 £ 2.50B Stores balance £ -2.50 £ -2.50A Stores balance £12.50 £12.50

Final (wrong) Balance: £12.50



But concurrency allows any order...Bob enters Bank cashier sharedAlice enters Bank cashier sharedCashier B, gets balance £ 2.50 £ 2.50Cashier A, gets balance £ 2.50 £ 2.50B Gives Bob £5, removes from balance £ -2.50 £ 2.50A Takes £10 from Alice, add to balance £12.50 £ 2.50B Stores balance £ -2.50 £ -2.50A Stores balance £12.50 £12.50

£12.50Lost update




What is the problem?




Concurrencyis considered

HARD?



Concurrency is hard due tounconstrained shared data

Threads provide precisely thatenvironment

Concurrency is hard because weuse hard to use tools to useconcurrency



But what about...

● Mutexes, Semaphores,Locks?



But what about...


“I accidentally discovered I had a second thread updatinga dictionary value without locking the dictionary first”

Pycon attendee yesterday



But what about...


They work, but many people find them hard to get right



However, threads, mutexes etcare not the problem

Remember:

Concurrency is hard due tounconstrained shared data

Can we do better?



Kamaelia's Underlying Goals



To assist with building and maintaining practical systems using communicating components to simplify them in a usable way such that it allows even novice developers to build safe and efficient highly concurrent systems. (rather than a niche of developers)



“Even Novice Developers?”

Trainee engineers

Google Summer of Code students

+ other small number ofrandom novices :)



14+ developers with limited levelsof experience

All produced interesting (safe) systems with high levels of

concurrency



Applications?(aka What sort of systems?)



Brisk walk through of a few...



Email Greylisting(spam resistant mail server)

Recognises that in event of an error...

● Most spammers don't resend● Most real mail does resend



Content Transcoderheadless toolchain for transcoding & resizing images/videos (eg for web)

The sort of thing youtube, flickr, slideshare, etc need as a background job



Content Transcoder● Watches directories● Sorts content by type● Transcodes user video to flash● Converts images to variety of sizes● Moves to moderation queue



Content Transcoder● Watches directories● Sorts content by type● Transcodes user video to flash● Converts images to variety of sizes● Moves to moderation queue

(Part of a wider project)



Speak 'n WriteGraphical desktop tool to allow a child to learn to read and write...

Speaks and displays:“write the word <some word>”

The child copies the wordReads back what the child wroteTells them if they succeeded or failed



Speak 'n WriteGraphical desktop tool to allow a child to learn to read and write...

● Uses espeak for speech● Pygame used for display● Uses gesture recognition for

determining what was written.



ER ModellerGraphical desktop tool that renders a conceptual data model

● Textual description -> visual layout.● Specifically designed to work at conceptual rather than visual level.

● Aids data model design



IRC LoggerYep, rather hackneyed...

● But really about IRC components allowing remote control of systems

● Also have AIM components, and there's a community library for XMPP components (etc)



Others... (far from exhaustive)

Digital TV tools (eg timeshifting everything through to agent based recording), whiteboarding, simple games, personal webserving, music generation, bit torrent distribution, AIM/IRC/XMPP based systems, Pop3 proxying, Pop3 spam filtering, PyQT/tkinter/pygame tools, video shot change detection, etc



OK, that's the problems, background, and some

usecases. I want to see what this looks like.



from Kamaelia.Chassis.Pipeline import Pipeline

from Kamaelia.Apps.Games4Kids.BasicSprite import BasicSpritefrom Kamaelia.Apps.Games4Kids.SpriteScheduler import SpriteSchedulerfrom Kamaelia.Apps.Games4Kids.MyGamesEventsComponent import MyGamesEventsComponent

Pipeline( MyGamesEventsComponent(up="p", down="l", left="a", right="s"), BasicSprite("cat.png", name = "cat", border=40),).activate()

Pipeline( MyGamesEventsComponent(up="up", down="down", left="left", right="right"), BasicSprite("mouse.png", name = "player", border=40),).activate()

SpriteScheduler(BasicSprite.allSprites()).run()



Bunch of imports

Pipeline( MyGamesEventsComponent(...), BasicSprite(...),).activate()

Pipeline( MyGamesEventsComponent(...), BasicSprite(...),).activate()

SpriteScheduler(BasicSprite.allSprites()).run()

Pipeline

MyGamesEvents

Component

BasicSprite



Note: this focusses on what we want to do, at a high level.Pipeline( MyGamesEventsComponent(up="p", down="l", left="a", right="s"), BasicSprite("cat.png", name = "cat", border=40),).activate()



What if we want to update and act on a global state?(eg based on distance between players?)



GlobalState

{('Mouse', 'Cat '): 244, ('Cat ', 'Mouse'): 244}{('Mouse', 'Cat '): 244, ('Cat ', 'Mouse'): 244}{('Mouse', 'Cat '): 244, ('Cat ', 'Mouse'): 244}{('Mouse', 'Cat '): 244, ('Cat ', 'Mouse'): 244}{('Mouse', 'Cat '): 244, ('Cat ', 'Mouse'): 244}{('Mouse', 'Cat '): 244, ('Cat ', 'Mouse'): 244}{('Mouse', 'Cat '): 244, ('Cat ', 'Mouse'): 244}{('Mouse', 'Cat '): 244, ('Cat ', 'Mouse'): 244}{('Mouse', 'Cat '): 244, ('Cat ', 'Mouse'): 244}{('Mouse', 'Cat '): 244, ('Cat ', 'Mouse'): 244}{('Mouse', 'Cat '): 244, ('Cat ', 'Mouse'): 244}{('Mouse', 'Cat '): 244, ('Cat ', 'Mouse'): 244}{('Mouse', 'Cat '): 244, ('Cat ', 'Mouse'): 244}



Create a place to publish locations to.from Kamaelia.Util.Backplane import *Backplane("PLAYERS").activate()

Backplane(“Players”)



Make our Cat publish to it.Pipeline( MyGamesEventsComponent(up="p", down="l", ...), BasicSprite("cat.png", name = "cat", border=40), PureTransformer(lambda x: ("Cat ", x)), PublishTo("PLAYERS"),).activate()


MyGamesEventsComp...

BasicSprite

PureTransformer

PublishTo



Make our Mouse publish to it.Pipeline( MyGamesEventsComponent(up="p", down="l", ...), BasicSprite("cat.png", name = "cat", border=40), PureTransformer(lambda x: ("Mouse ", x)), PublishTo("PLAYERS"),).activate()


MyGamesEventsComp...

BasicSprite

PureTransformer

PublishTo



Make our analyser & subscribe itPipeline( SubscribeTo("PLAYERS"), PlayerAnalyser(), Distancer(), ConsoleEchoer(),).activate()


SubscribeTo

PlayerAnalyser Distancer

ConsoleEchoer



Full System View


PublishTo

PureTransformer

BasicSprite

MyGamesEvents...

PublishTo

PureTransformer

BasicSprite

MyGamesEvents...

SubscribeTo

PlayerAnalyser

Distancer

ConsoleEchoer



Full System View


PublishTo

PureTransformer

BasicSprite

MyGamesEvents...

PublishTo

PureTransformer

BasicSprite

MyGamesEvents...

SubscribeTo

PlayerAnalyser

Distancer

ConsoleEchoer

The ERModeller code

also uses this

sort of code

structure



Full System View


PublishTo

PureTransformer

BasicSprite

MyGamesEvents...

PublishTo

PureTransformer

BasicSprite

MyGamesEvents...

SubscribeTo

PlayerAnalyser

Distancer

ConsoleEchoer

(No—that’s the wrong metaphor!

"Pipelines" actually work for me, but threads don’t.)



Full System View


Cat SpritePipeline

Mouse SpritePipeline

Player AnalyserPipeline



GlobalState




GlobalState


Cat SpritePipeline






GlobalState


Cat SpritePipeline


Player AnalyserPipelineBackplane

(“Players”)



GlobalState


Cat SpritePipeline






Observations● Code structure follows problem structure

● 1 to 1 correspondence between diagram and code

● We're focussing on the problem, not code, not concurrency

● BUT we're looking for how things talk and transform.

Just like web mashups, or hardwareor unix pipelines, or ...



Observations● Significantly easier to think about if you

anthropomorphise the problem

● Or “if there was a small army of little robots inside your computer, what would they do, who would they need to talk to”.

Each component is one of these “robots”

● Yes, I know its sad, and I do rather think that way far too often, but it works - so shoot me :-)



Internal Component Metaphor

inbox

control

...

outbox

signal

...



System Metaphor



Building a Network Server

MainServer Core

Remote User

Protocol Handler Factory




MainServer Core

Remote User


Socket handler

Protocol handler




MainServer Core

Remote User


Socket handler

Protocol handler

datato

user

datafromuser




Protocol Handler FactoryProtocol handler

This is the part you focus on:



Simplest Possible protocol handlerimport Axon

class Echo(Axon.Component.component): def main(self): while 1: for data in self.Inbox(“inbox”): self.send(data, “outbox”) yield 1

datato

userdatafromuser



Anatomy of a more complex http-ish protocol handler

One approach is a bit like how an animal is “constructed”:

● Skeleton● Muscle● Tendons● Skin



Building a More Complex Protocolclass ProtocolSkeleton(Axon.Component.component): def main(self): while not self.dataReady(“control”): for data in self.Inbox(“inbox”): response = self.handleMessage(data) self.send(response, “outbox”) if not self.anyReady(): self.pause() yield 1



Building a More Complex Protocol

class HTTP_ish_Muscle(ProtocolSkeleton): def handleMessage(self, data): args = self.parse(data) handler_app = self.findHandler(*args) for line in handler_app(*args): self.send(line, “outbox”)

def parse(self, data): args = data.split() return args[:1], args[1:-1] args[-1:]

def findHandler(meth, args, version): def null(*args): yield 1 return null



Building a More Complex Protocol

class SimpleFileProtocol(HTTP_ish_Muscle):

def findHandler(meth, args, version):

def fileReader(*args): filename = “ “.join(args).replace(“..“,““) for i in open(filename): yield i

return fileReader



Using our Protocol Handlerfrom Kamaelia.Chassis.ConnectedServer import ServerCore

ServerCore(protocol = SimpleFileProtocol, port=1180).run()



or... you can also do this

from Kamaelia.Chassis.ConnectedServer import \ServerCore

class SimpleFileServer(ServerCore): protocol = SimpleFileProtocol port=1180

SimpleFileServer().run()

The greylistin

g code

essentially us

es this

sort of code

structure



Graphlines

Not every system makes sense as a pipeline, nor make sense as backplanes.

Example structures:

... ... ... ...

...

...

... ...

...



Graphline eg: Simple Slideshow Graphline( NEXT = Button(caption="Next", msg="NEXT", position=(72,8)), PREVIOUS = Button(caption="Previous", msg="PREV",position=(8,8)), FIRST = Button(caption="First", msg="FIRST",position=(256,8)), LAST = Button(caption="Last", msg="LAST",position=(320,8)), CHOOSER = Chooser(items = files), IMAGE = Image(size=(800,600), position=(8,48)), linkages = { ("NEXT","outbox") : ("CHOOSER","inbox"), ("PREVIOUS","outbox") : ("CHOOSER","inbox"), ("FIRST","outbox") : ("CHOOSER","inbox"), ("LAST","outbox") : ("CHOOSER","inbox"), ("CHOOSER","outbox") : ("IMAGE","inbox"), }).run()

...

...

...

... ...

...



Simple Slideshow (args/links trimmed) Graphline( NEXT = Button(...), PREVIOUS = Button(...), FIRST = Button(...), LAST = Button(...), CHOOSER = Chooser(...), IMAGE = Image(...), ...).run()



Simple Slideshow (args/links trimmed) Graphline( NEXT = Button(...), PREVIOUS = Button(...), FIRST = Button(...), LAST = Button(...), CHOOSER = Chooser(...), IMAGE = Image(...), ...).run()

FIRST(button)

Chooser

LAST(button)

PREVIOUS(button)

NEXT(button)

Image



Recap...● What's the problem with concurrency?● Approaches that work:● “shared nothing” - aka message passing● Friendlier metaphor (inboxes/outboxes)● Overview of systems built this way



Recap...

Nitty gritties:● Composing basic systems● Evolving basic systems

● Similar basic structure to the ERModeller● Building basic network servers● Evolving more complex network servers

● Similar basic structure to the greylister



More information?

http://edit.kamaelia.org/GetKamaelia● Links to code● Links to tutorials● Links to examples● Links to reference documentation

IRC: freenode.net , channel #kamaeliaLogs: http://edit.kamaelia.org/logs/



Thank you for listening

Questions?

more info:● http://edit.kamaelia.org/GetKamaelia● freenode.net , channel #kamaelia

Practical concurrent systems made simple using Kamaelia

Technology

Transcript of Practical concurrent systems made simple using Kamaelia