Seminar Ojektorientierte Programmiersprachen WS 2003/04 FU-Berlin Dozent: Prof.Dr.-Ing.Peter Löhr

Seminar Ojektorientierte Programmiersprachen

WS 2003/04 FU-BerlinDozent: Prof.Dr.-Ing.Peter Löhr

2

Vortrag

C# und Nichtsequentialität( Polyphonic C# )

3

Polyphonic C#

C# vs Java Definition Beispiele Spezifikation Restriktion Programming in Polyphonic C# Implementation and Translation Schlussfolgerung Quelle

4

Blocksynchronization (C# vs Java)C# Code public void WithdrawAmount(int num){ lock(this){

if(num < this.amount) this.amount -= num; } }Java Code public void withdrawAmount(int num)

{ synchronized(this){ if(num < this.amount) this.amount -= num;

} }

5

MethodSynchronization (C# vs Java)C# Code [MethodImpl(MethodImplOptions.Synchronized)]

public void WithdrawAmount(int n){ if(n < this.amount) this.amount - n; } Java Codepublic synchronized void withdrawAmount(int

n){ if(n < this.amount) this.amount - n; }

6

Threads (C# vs Java )

Java Extending Java.lang.Thread Overriding run method Or implementing java.lang.Runnable

interface and its run method every class inherits the wait(), notify() and

notifyAll() from java.lang.Object Multithreaded „run methods“ designed up

front for multithreaded scenarios

7

Threads (C# vs Java )

C# creating a new System.Threading.Thread object passing it a System.Threading.ThreadStart

delegate Delegate initialized with the method that is to be run

as a thread any method can be passed to a ThreadStart object

and run in a multithreaded scenario Every class inherits Wait(), Pulse() and PulseAll()

methods in the System.Threading.Monitor

8

Einleitung

Asynchrone Nachrichten und Erreignisse Benutzerschnittstellen- Treibererreignisse ,

verteilte Systeme , Web Services etc Alle diese asynchrone Nachrichten werden

von Threads behandlet Threads sind immernoch kostbare Resourcen

an vielen SystemenVerstecken von Threads hinter Sprachmechanismus

9

Einleitung

Nick Benton, Luca Cardelli und Cedric Fournet bei Microsoft Research Concurrency should be a language feature

High-level abstraction for asynchronous programming

Hence better optimization possibilities for the compiler (queues, lightweight threads, thread pools)

10

Was ist nun Polyphnic C# ?

eine Erweiterung von C# mit neuen asynchronen nichtsequentiallen Konstrukten

Basierend auf dem Join Calculus Eine geignete Sprache für asynchron verteilten

Systemen

11


Alle features von C# bleiben erhalten Hinzufügen von zwei neuen

SprachKonstrukten Asynchronous methods und Chords

12


Standard Methoden sind alle synchron Der Aufruf kehrt nach der Ausführung des

Rumpfs zurück Asynchrone Methode haben async vor

Methodennamen Kehren sofort ohne Rückgabewert zurück

13


Chords Auch synchronization pattern oder join

pattern genannt Besteht aus Methodenkopf und

Methodenrumpf Der Kopf kann aus mehreren Methoden

bestehen Sie werden durch einen & getrennt

14

In einem Chord kann es nur eine synchrone Methode geben aber viele async

Ausführung des Rumpfs nur wenn alle Methoden aufgerufen sind

Sonst wird der Thread in einer Schlange gestellt Steht eine async Methode alleine, wird sie in einem

neuen Thread sofort ausgeführt Eine Methode kann in vielen

Chords(synchronization patterns) auftauchen


15

Ein einfaches Beispiel

class Buffer {String get() & async put(String s) {

return s;}

}

16



return s;}

} Eine einfache paramterlose synchrone

Methode mit String Rückgabewert

17



return s;}

} Eine einfache paramterlose synchrone Methode mit

String Rückgabewert Eine asynchrone Methode mit String-Parameter

(liefert keinen Wert Zurück)

18



return s;}

} Eine einfache paramterlose synchrone Methode mit String

Rückgabewert Eine asynchrone Methode mit String-Parameter (liefert keinen

Wert Zurück) Beide in einem Chord (synchronization pattern)

19

Chords

Ein Object kann mehrere Chords enthalten Welche Methode der passende Partner einer

anderen wird, ist unbestimmt

20

Beispiel mit zwei Chords

class Buffer {int get() & async put(int n) {

return n;}string get() & async put(int n){

return n.ToString();}

} Welches put mit welchem get synchronisiert wird, ist

unbestimmt

21

Buffer buff = new Buffer();buff.put(‘‘blue“);buff.put(‘‘sky“);Console.Write(buff.get()+“ ‘‘+buff.get());

Ausgabe unbestimmt ‘‘blue sky“ oder auch ‘‘sky blue“

22

Informelle Spezifikation

Return-type = type | void | async

chord-declaration ::= method-header | [& method-header]* body

method-header ::= attributes modifiers return-type member-name(formals)

23

Restriktion für Vererbung

Bei Überschreibung einer Methode eines Chords einer Superklasse müssen alle Methoden dieses Chords überschrieben werden impliziert Transivität

24

Restriktion für Vererbung

class C {virtual void f() & virtual async g(){ /* body1 */ }virtual void f() & virtual async h(){ /* body2 */ }

class D:C {override async g(){ /* body3 */ }

Gefahr eines Deadlocks

25

Programming in Polyphonic C# Reader-Writer Locks Asynchrone Nachrichten Active Objects

26

Reader-Writer Locks

public class ReaderWriter { public ReaderWriter() { Idle(); } public void Shared() & async Idle() { S(1); } public void Shared() & async S(int n)

{ S(n+1); } public void ReleaseShared() & async S(int n) { if (n == 1) Idle(); else S(n-1); } public void Exclusive() & async Idle() {} public void ReleaseExclusive() { Idle(); } }

27

Asynchrone Nachricht

public delegate async IntCB(int v); public class Service {

public async request(String arg, IntCB callback) {int result;// do something interesting…callback(result);

}}

28

Asynchrone Nachrichtclass Join2 {

void wait(out int i, out int j)& async first(int r1)& async second(int r2) {

i = r1; j = r2; return;}

}// client code:int i,j;Join2 x = new Join2();service1.request(arg1, new IntCB(x.first));service2.request(arg2, new IntCB(x.second));// do something useful// now wait until both results have come backx.wait(out i,out j);// do something with i and j

29

Active objects(1/2)

public abstract class ActiveObject { protected bool done; abstract protected void ProcessMessage();

public ActiveObject () {done = false; mainLoop(); }

async mainLoop() {while (!done) { ProcessMessage(); }

}}

30

Active objects(2/2)class StockServer : ActiveObject {

private ArrayList clients;public async AddClient(Client c) & void ProcessMessage(){clients.Add(c);}public async WireQuote(Quote q) & void ProcessMessage(){foreach(Client c in clients)

c.UpdateQuote(q);}

public async CloseDown() & void ProcessMessage(){done = true;

}}

31

Implementation and Translationstruct BitMask{

private int v; // = 0;public void set(int m) {v |= m; }public void clear(int m) { v &= ~m; }public bool match(int m ) { return ( ~v & m)==0; }

}class intQ {

private Queue q;public intQ() {q = new Queue(); }public void add(int i) { q.Enqueue(i); }public int get() {return (int) q.Daqueue(); }public bool empty {get{return q.Count == 0;}}}

32

Implementation and Translationclass voidQ{

private int n;public voidQ() { n = 0; }public void add() { n++; }public void get() { n--; }public bool empty {get{ return n==0; }}}

33

Implementation and Translationclass threadQ {

private Queue q;public threadQ() { q = new Queue(); }public bool empty {get{ return (q.Count == 0); }}public void yield(object myCurrentLok){

q.Enqueue(Thread.CurrentThread); Monitor.Exit(myCurrentLock); try { Thread.Sleep(Temeout.Infinite); } catch (ThreadInterruptedException) {} Monitor.Enter(myCurrentLock; q.Dequeue();}

public void wakeup() {((Thread) q.Peek()).Interrupt();}}

34

Eine Polyphonic-klasse

Class Token{public Token(int initialToken){

for(int i=0;i<initialTokens;i++)Release();}public int Grab(int id) & public async Release(){

return id;}}

35

Die kompilierte Klasse(1/3)

class Token{private const int mGrab = 1 << 0;private const int mRelease = 1 << 1;private threadQ GrabQ = new threadQ();private voidQ ReleaseQ = new voidQ();private const int mGrabRelease = mGrab |

mRelease;private BitMask s = new BitMask();private object mlock = GrabQ();

36

Die kompilierte Klasse(2/3)..................private void scan(){

if(s.match(mGrabRelease)) GrabQ.wakeup();}public Token(int initialTokens){

for(int i=0;i< initialTokens;i++)Release();}

[OneWay] public void Release(){

lock(mlock){ReleaseQ.add(),if(!s.match(mRelease)){

s.set(mRelease);scan();}

}}

37

Die kompilierte Klasse(3/3)...........................public int Grab(int id){

Monitor.Enter(mlock);if( !s.match(mGrab) )goto now;later:

GrabQ.yield(mlock);if(GrabQ.empty) s.clear(mGrab);now:

if(s.match(mRelease)){ReleaseQ.get();if(ReleaseQ.empty)s.clear(mRelease);scan();Monitor.Exit(mlock);{

return id; //source code for the chord}}else{s.set(mGrab);goto later;}

}}

38

Fully Asynchronous Chords

..............public async live(string s,int id){

Grab(id);Release();Console.WriteLine(s);

}

39

Translated Fully Asynchronous Chordprivate class liveArgs{public string s;public int id;public liveArgs(string s,int id){this.s= s;this.id=id;}}private void liveBody(object o){liveArgs a = (liveArgs)o;string s = a.s;int id= a.id;Grab(id);Release();Console.WriteLine(s);}

40

Translated Fully Asynchronous Chord...........[OneWay]Public void live(string s,int id){liveArgs a = new lineArgs(s,id);WaitCallback c = new WaitCallback(liveBody);ThreadPool.QueueUserWorkItem(c,a);}}

41

Future Work

Concurrency Types Timeouts and Priorities

Declarative support for timeouts or priorities Finer control over dynamic scheduling

Optimizations Lock optimization Queue optimization Thread optimization

Pattern-Matching Additional constraints in arguments

42

Schlussfolgerung

Ein sauber und einfaches Modell für asynchrone Nichtsequentiallität in C#

Modell geignet für Lokale Nichtsequentiallität (viele Threads auf

einer Maschine ) Verteilte Nichtsequentiallität ( asynchrone

Erreignisse über LAN oder WAN ) Kompatible mit existierenden Konstrukten

43

Polyphonic C# Dining Philosophers Demo

Copyright (C) 2001 Microsoft Corporation

44

Quellen:

Introduction to Polyphonic C#http://research.microsoft.com/~nick/polyphony/intro.htm

Modern Concurrency Abstractions for C#(Nick Benton, Luca Cardelli, and C´edric Fournet)

http://research.microsoft.com/~nick/polyphony/PolyphonyECOOP.A4.pdf

http://research.microsoft.com/~nick/polyphony/intro.htm

http://research.microsoft.com/~nick/polyphony/PolyphonyECOOP.A4.pdf

Documents

Seminar Ojektorientierte Programmiersprachen WS 2003/04 FU-Berlin Dozent: Prof.Dr.-Ing.Peter Löhr