7. Concurrency. Motivation Infrastructure Faking concurrency Mobile Java implementation Symbian OS implementation. Maemo implementation Summary

Transcription

1 7. Concurrency Motivation Infrastructure Faking concurrency Mobile Java implementation Symbian OS implementation Threads Active objects Maemo implementation Summary 1

2 Motivation Mobile devices are fundamentally reactive systems Incoming events from the environment that require a response Event handler based design commonly applied In addition to user-initiated GUI events, also other environment (constituted by associated auxiliary subsystems) can generate events Nondeterministic event generation No order can be assumed or imposed on executions To be handled with standard facilities of concurrent programming at some level However, why to reveal unnecessary complications to an application developer? 2

3 Content and goals Motivation Infrastructure Faking concurrency Mobile Java implementation Symbian OS implementation Threads Active objects Maemo implementation Summary 3

4 Infrastructure for Concurrent Programming Threads as units of execution, processes as units of resource reservation Pre-emptive vs. non-pre-emptive scheduling Cost of a context switch Thread communication Shared memory Message passing Blocking other threads Crititical regions Protected with semaphores, locks, monitors, etc. 4

5 Design challenges Classic Race conditions (timing changes behavior) Mutual exclusion (not accessing at the same time) Synchronization (acting in synchrony) Parallel slowdown (communication slows down actual work) Practical Complex debugging; errors may be unrepeatable Low-level differences are extensive in different setups Portability in general is hardened when system specifics are relied on Implementation differences can produce different results due to numerous side-effects 5

6 Content and goals Motivation Infrastructure Faking concurrency Mobile Java implementation Symbian OS implementation Threads Active objects Maemo implementation Summary 6

7 From threading to eventing Principle: Make all synchronous requests asyncronous (threads will not wait for immediate return) Messages/shared variables used as the means of communication When all requests have been made, enter a mainloop where incoming messages (or semaphores or lock variables or... ) indicate an event Serve the incoming event with a single thread and wait for the next to come in No need for application level concurrency Internals may still require concurrent processing, but this is not revealed at application level 7

8 Overview Events Events Event-handling thread reads ready to execute (synchronous) service Event handler code 8

9 Event-driven Execution Keyboard Screen Device IF UI mgr App key_press key_press draw draw_fig draw_char 9

10 Serialization of execution instead of real threads Positive In line with non-pre-emptive event processing; events invoke other events which invoke other events No need to consider critical regions as long as events are self- contained Less potential for design and programming errors Simplified implementation in terms of memory consumption Eased porting; operating systems native threads can behave differently but event handler scheme is probably similar in all implementations Negative Event handling interruptions for higher-priority tasks more complicated or impossible Execution priority based on thread priority Possibility to select the highest-priority event Design Visible to the designer or included in the infrastructure 10

11 Content and goals Motivation Infrastructure Faking concurrency Mobile Java implementation Symbian OS implementation Threads Active objects Maemo implementation Summary 11

12 Threading in Virtual Machine Operating system specific threading Operating system handles scheduling Performance can be better (several threads can get more execution time than one thread running the virtual machine) Porting complexitites (different operating systems can have different threading systems, requires intimate connection with Java runtime) Virtual machine implemented threading (green threads) Virtual machine handles scheduling Performance loss Eased porting; especially exceptions and cleanup etc. Essentially an event processing machine, where threads are executed for X instructions per activation peridic event handling Multi-application VM introduces also issues related to securing applications from one another 12

13 Example: Java Threading <<Runnable>> IncrementerThread public int i; // shared incrementsharedvalue start read <<MIDlet>> <<CommandListener>> MyThread 13

14 Example Code public class IncrementerThread extends Thread { public int i; public IncrementerThread() { i = 0; Thread t = new Thread(this); t.start(); } } public void run() { for(;;) i++; } 14

15 Example Code import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class MyThread extends MIDlet implements CommandListener { private Command exitcommand, togglecommand; private TextBox tb; private IncrementerThread t; public MyThread() { exitcommand = new Command("EXIT", Command.EXIT, 1); togglecommand = new Command("Toggle", Command.OK, 2); t = null; t = null; } 15

16 Example Code protected void startapp() { tb = new TextBox("Thread Example", "Thread was started", 80, 0); tb.addcommand(togglecommand); tb.addcommand(exitcommand); tb.setcommandlistener(this); Display.getDisplay(this).setCurrent(tb); t = new IncrementerThread(); } public void commandaction(command c, Displayable d) { if (c == exitcommand) { destroyapp(false); notifydestroyed(); } else { togglethread(); t.interrupt(); } } 16

17 Example Code protected void destroyapp(boolean u) {} protected void pauseapp() {} private void togglethread() { tb = new TextBox("Thread Example", "Thread run " + t.i + " times", 80, 0); tb.addcommand(togglecommand); tb.addcommand(exitcommand); tb.setcommandlistener(this); Display.getDisplay(this).setCurrent(tb); } // togglethread } // MyThread 17

18 Content and goals Motivation Infrastructure Faking concurrency Mobile Java implementation Symbian OS implementation Threads Active objects Maemo implementation Summary 18

19 Components RThread Used similarly to most other systems Create, kill, etc.... Implementation details seem to be dependant on the used version of the Symbian OS, at least to some extent Shared memory, semaphores, mutexes etc that one would expect to be included Again interfaces can be different from e.g. Unix/Linux Functionally things are somewhat similar 19

20 Example Code TInt i; // Communication variable. void myop() { for(;;) i++; } // Thread function. void MyConsoleL() { LOCAL_D CConsoleBase* console; RThread mythread; // Created thread. console = Console::NewL(_L("Thread"), TSize(KConsFullScreen, KConsFullScreen)); CleanupStack::PushL(console); i = 0; // Shared thread is reset in the beginning. TInt status = mythread.create( _L("TEST THREAD"), // Thread name. (TThreadFunction)myOp, // Called procedure. 0x1000, // Size of stack. 0x1000, // Minimum size of thread's heap. 0x1000, // Maximum size of thread's heap. NULL, // Data to be passed to the thread. EOwnerProcess); // Owned by the current process. 20

21 Example Code console->printf(_l("thread created.\n")); mythread.resume(); // Activates the thread. console->getch(); // Wait for keyboard hit. mythread.kill(-1); // Terminate the thread. console->printf(_l("thread run %d rounds.\n"), i); console->getch(); CleanupStack::Pop(); // Console delete console; console = 0; } 21

22 Content and goals Motivation Infrastructure Faking concurrency Mobile Java implementation Symbian OS implementation Threads Active objects Maemo implementation Summary 22

23 Active Objects and Eventing Events Events Active scheduler (1 per thread) Event handlers ach a separate thread) Event handlers (each an active object) 23

24 Benefits Eased mutual exclusion Memory savings (some bytes vs. some kilobytes) Performance improvement for the overall system Operations in the same active scheduler do not require context switch No overhead of changing the process while an operation is being performed Can be offered as a generic event handler included in e.g. application framework 24

25 Components Active object (CActive or its derivative) Implements operations that will be executed when an event occurs Active scheduler (CActiveScheduler or its derivative) Implements scheduling Selects the active object to call Service providers Introduce operations that take some time and potentially require actions by other parties E.g. timers 25

26 Overview Application Create and Install Active Scheduler 1 2 Create AO, issue request, add to Scheduler 4 Start Scheduler Active scheduler Wait for any req Call AO RunL Active object Activate request function3 set iactive true 6 Service provider Set istatus to Pending Service complete 5 Req completed, reset istatus Cleanup, terminate 7 RunL (redo/quit) 26

27 Example Code LOCAL_D CConsoleBase* console; // Write all messages to this. class CDelayer : public CActive { public: static CDelayer *NewL(); ~CDelayer(); void SetHello(TInt adelay); private: CDelayer(); void ConstructL(); protected: void RunL(); void DoCancel(); private: RTimer itimer; }; // class 27

28 Example Code CDelayer::CDelayer(): CActive(EPriorityStandard) {} void CDelayer::ConstructL() { User::LeaveIfError(iTimer.CreateLocal()); CActiveScheduler::Add(this); // Add this object to the set of active objects. } CDelayer * CDelayer::NewL() { CDelayer * self = new (ELeave) CDelayer(); CleanupStack::PushL(self); self->constructl(); CleanupStack::Pop(); // self return self; } CDelayer::~CDelayer() { Cancel(); // DoCancel implementation requires that destructor calls Cancel itimer.close(); } 28

29 Example Code void CDelayer::SetHello(TInt adelay) { // Nested set operations are forbidden. This is ensured // by IsActive and ASSERT_ALWAYS. ASSERT_ALWAYS(!IsActive(), User::Panic(_L("CDelayedHello"), 1)); // Request for an event after adelay. itimer.after(istatus, adelay); // istatus is a member variable of CActive. SetActive(); // Set this active object active. } void CDelayer::RunL() { _LIT(KTimer, "\ntimer expired"); console->printf(ktimer); // Stop the active scheduler, so the execution can continue. CActiveScheduler::Stop(); } void CDelayer::DoCancel() { itimer.cancel(); } 29

30 Example Code int MyConsoleL() { console = Console::NewL(_L("Active Object Sample"), TSize(KConsFullScreen,KConsFullScreen)); CActiveScheduler * as = new (ELeave) CActiveScheduler(); CleanupStack::PushL(as); CActiveScheduler::Install(as); CDelayer * d = CDelayer::NewL(); CleanupStack::PushL(d); d->sethello( ); // Time in in microseconds. CActiveScheduler::Start(); // Delay occurs here. console->printf(_l("ready.\n")); console->getch(); // User intervention CleanupStack::PopAndDestroy(2); // d, as delete console; return 0; } 30

31 Using Active Objects Support included in Symbian Application Framework No need to introduce active scheduler Active objects must still be defined and added to the active scheduler Commonly used in cooperation with Observer design pattern MObserverIF implemented by e.g. AppView component which used in callbacks from AO to GUI Problems Errors: RunError RunL cannot be interrupted; implement longish operations in smaller steps to allow other AOs to execute meanwhile Simple basic scheme, complex implementation framework 31

32 Content and goals Motivation Infrastructure Faking concurrency Mobile Java implementation Symbian OS implementation Threads Active objects Maemo implementation Summary 32

33 Maemo threading and eventing Threading No surprises there Linux threading and processes GTK eventing Mainloop listening for events and reacting accordingly Design mismatch: GTK is not thread-safe Seemingly inexplainable failures when things go wrong Seemingly inexplainable successes at times when context switching occurs in a suitable fashion Design mismatch: Some GTK operations involve threading The programmer must figure out the necessary means to address the problems 33

34 Example: gnome_vfs_async_read void gnome_vfs_async_read ( GnomeVFSAsyncHandle *handle, gpointer buffer, guint bytes, GnomeVFSAsyncReadCallback callback, gpointer callback_data); Read bytes bytes from the file pointed to be handle into buffer. When the operation is complete, callback will be called with the result of the operation and callback_data. ( vfs-20-gnome-vfs-async-ops.html#gnome-vfs-async-read) Looks nice but 34

35 there are complications gnome-vfs async callbacks are called in the main thread, so making GTK+ calls from them is fine. If you are using GTK+ from multiple threads with gdk_threads_init() gdk_threads_enter() gdk_threads_leave() then you have to be aware that the callbacks are called outside the GTK+ lock. But if all your GUI is done in the main thread, then you don't have to worry about it. ( fs%20api+page:1+mid:mlmukdzlpmneuccj+state:results) 35

36 Content and goals Motivation Infrastructure Faking concurrency Mobile Java implementation Symbian OS implementation Threads Active objects Maemo implementation Summary 36

37 Summary Concurrent programming can lead to complex designs regarding critical regions Using program-level pseudo-parallel executions instead of more elaborated implementations can offer benefits Improved portability Smaller memory footprint Simplified programming model and eased debugging Supporting built-in facilities to simplify event handling and threading Java: Green threads; eventing inside GUI framework Symbian: Native threading; eventing with active objects Maemo: Native threading; eventing with GTK events 37