Date post: | 06-Apr-2016 |
Category: |
Documents |
Upload: | juergen-grosser |
View: | 218 times |
Download: | 2 times |
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
Was ist nun Polyphnic C# ?
Alle features von C# bleiben erhalten Hinzufügen von zwei neuen
SprachKonstrukten Asynchronous methods und Chords
12
Was ist nun Polyphnic C# ?
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
Was ist nun Polyphnic C# ?
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
Was ist nun Polyphnic C# ?
15
Ein einfaches Beispiel
class Buffer {String get() & async put(String s) {
return s;}
}
16
Ein einfaches Beispiel
class Buffer {String get() & async put(String s) {
return s;}
} Eine einfache paramterlose synchrone
Methode mit String Rückgabewert
17
Ein einfaches Beispiel
class Buffer {String get() & async put(String s) {
return s;}
} Eine einfache paramterlose synchrone Methode mit
String Rückgabewert Eine asynchrone Methode mit String-Parameter
(liefert keinen Wert Zurück)
18
Ein einfaches Beispiel
class Buffer {String get() & async put(String s) {
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