CSE 130 Programming Language Principles & Paradigms Lecture # 20. Chapter 13 Concurrency. + AJAX Discussion

Size: px

Start display at page:

Download "CSE 130 Programming Language Principles & Paradigms Lecture # 20. Chapter 13 Concurrency. + AJAX Discussion"

Brendan Thomas
6 years ago
Views:

1 Chapter 13 Concurrency + AJAX Discussion

2 Introduction Concurrency can occur at four levels: Machine instruction level (Processor) High-level language statement level Unit level Program level (OS) Because there are no language issues in instruction- and program-level concurrency, they are not addressed here

3 Multiprocessor Architectures Late 1950s - one general-purpose processor and one or more special-purpose processors for input and output operations Early 1960s - multiple complete processors, used for program-level concurrency Mid-1960s - multiple partial processors, used for instruction-level concurrency Single-Instruction Multiple-Data (SIMD) machines Multiple-Instruction Multiple-Data (MIMD) machines Independent processors that can be synchronized (unit-level concurrency)

4 Categories of Concurrency A thread of control in a program is the sequence of program points reached as control flows through the program Categories of Concurrency: Physical concurrency - Multiple independent processors ( multiple threads of control) Logical concurrency - The appearance of physical concurrency is presented by time-sharing one processor (software can be designed as if there were multiple threads of control) Coroutines (quasi-concurrency) have a single thread of control

5 Motivations for Studying Concurrency Involves a different way of designing software that can be very useful many real-world situations involve concurrency Multiprocessor computers capable of physical concurrency are now widely used With Web services (when asynchronous) we may see distributed concurrency sooner than we think

6 Intro to Subprogram-Level Concurrency A task or process is a program unit that can be in concurrent execution with other program units Tasks differ from ordinary subprograms in that: A task may be implicitly started (maybe by time or action) When a program unit starts the execution of a task, it is not necessarily suspended When a task s execution is completed, control may not return to the caller Tasks usually work together

7 Two General Categories of Tasks Heavyweight tasks execute in their own address space and have their own run-time stacks Lightweight tasks all run in the same address space and use the same run-time stack A task is disjoint if it does not communicate with or affect the execution of any other task in the program in any way

8 Task Synchronization We need a mechanism that controls the order in which tasks execute Two kinds of synchronization Cooperation synchronization Competition synchronization

9 Kinds of synchronization Cooperation: Task A must wait for task B to complete some specific activity before task A can continue its execution, e.g., the producerconsumer problem Competition: Two or more tasks must use some resource that cannot be simultaneously used, e.g., a shared counter Competition is usually provided by mutually exclusive access (approaches are discussed later)

10 Scheduler Providing synchronization requires a mechanism for delaying task execution Task execution control is maintained by a program called the scheduler, which maps task execution onto available processors

11 Task Execution States New - created but not yet started Runnable or ready - ready to run but not currently running (no available processor) Running Blocked - has been running, but cannot now continue (usually waiting for some event to occur) Dead - no longer active in any sense

12 Liveness and Deadlock Liveness is a characteristic that a program unit may or may not have In sequential code, it means the unit will eventually complete its execution In a concurrent environment, a task can easily lose its liveness If all tasks in a concurrent environment lose their liveness, it is called deadlock

13 Methods of Providing Synchronization Semaphores Monitors Message Passing

14 Semaphores Dijkstra A semaphore is a data structure consisting of a counter and a queue for storing task descriptors Semaphores can be used to implement guards on the code that accesses shared data structures Semaphores have only two operations, wait and release (originally called P and V by Dijkstra) Semaphores can be used to provide both competition and cooperation synchronization

15 Monitors Concurrent Pascal, Modula, Mesa, Ada, Java, C# The idea: encapsulate the shared data and its operations to restrict access A monitor is an abstract data type for shared data

16 Competition Synchronization Shared data is resident in the monitor (rather than in the client units) All access resident in the monitor Monitor implementation guarantee synchronized access by allowing only one access at a time Calls to monitor procedures are implicitly queued if the monitor is busy at the time of the call

17 Evaluation of Monitors A better way to provide competition synchronization than are semaphores Semaphores can be used to implement monitors Monitors can be used to implement semaphores Support for cooperation synchronization is very similar as with semaphores, so it has the same problems

18 Message Passing Message passing is a general model for concurrency It can model both semaphores and monitors It is not just for competition synchronization Central idea: task communication is like seeing a doctor--most of the time she waits for you or you wait for her, but when you are both ready, you get together, or rendezvous

19 Message Passing Rendezvous A mechanism to allow a task to indicate when it is willing to accept messages Tasks need a way to remember who is waiting to have its message accepted and some fair way of choosing the next message When a sender task s message is accepted by a receiver task, the actual message transmission is called a rendezvous

20 Threads Thread (thread of execution) split code into two or more simultaneously running tasks Threads were born from the idea that the most efficient way for cooperating processes to exchange data would be to share their entire memory space. Thus, threads are basically processes that run in the same memory context. Threads are described as lightweight because switching between threads does not involve changing the memory context. Threads provide for parallel execution on MP/Multicore systems Standard single CPU threads use standard time slicing Java and C# have support for threads see book for syntax

21 Generic Thread Control To control the execution of a thread you might imagine methods like: Yield() a request from the running thread to voluntarily surrender the processor Sleep() might be used to pause the thread Kill()/Abort() to dump a thread execution Join() could be used to force a delay of execution until the run method of another thread has completed its execution Lock() and other reservation methods Likely you will also have properties to indicate thread priority (high, low, etc.) as well as to change priority level

22 Statement-Level Concurrency Objective: Provide a mechanism that the programmer can use to inform compiler of ways it can map the program onto multiprocessor architecture Minimize communication among processors and the memories of the other processors Example High Performance Fortran A collection of extensions that allow the programmer to provide information to the compiler to help it optimize code for multiprocessor computers Specify the number of processors, the distribution of data over the memories of those processors, and the alignment of data

23 JavaScript and Concurrency Standard JavaScript would appear to have very limited possibility for concurrency Simple time based facilities settimeout(), setinterval() would allow you to schedule the execution of code at a particular time but really no direct support for concurrency at the language level it would seem However, given that JS is used in Web environment launching requests to remote servers (ex. Web services) and waking up to address them certainly has all the characteristics of concurrent programming and in fact is distributed as well. This style of JS usage is quite popular circa under the moniker AJAX

24 What is AJAX? AJAX Asynchronous JavaScript and XML Original term coined by Jesse James Garret in article in Feb es/ php AJAX is a term like DHTML to describe both the use of a collection of technologies (JS, XHTML, DOM, XMLHttp, XML, etc.) and a particular style of coding, in this case remote scripting, partial page updates, and rich Internet applications.

25 What is AJAX Contd. Simple idea is a Web site/application that does partial page updates and provides a desktop application-like experience

26 What is AJAX Contd. Innerbrowsing

27 What is AJAX Contd. Network Activity

28 Original AJAX Model by J.J.G.

29 Yet Another AJAX Model

30 AJAX Data Transmission Methods Typically if JavaScript is used the XMLHttpRequest object is used to exchange data asynchronously with a Web server Many other possibilities are possible <frame> Hidden <iframe> <script> tag <img> tag <link> tag for CSS However, for our purposes they are not as interesting because they are either 1-way or they are not as asynchronous or controlled as XHRs

31 AJAX Data Formats Given the X in AJAX you would assume XML but it is not always used If XML might a custom vocabulary or a known one like SOAP Why not XML? Bulk tag vs. content ratio Value without using some DOM parsing maybe it is just a super CSV format? Easy of eval()ing JavaScript code directly Other transport possibilities: Plain text HTML or XHTML (really XML if done right) JSON (JavaScript Object Notation) YAML Binary formats even!?

32 AJAX Consuming the Data In nearly every case we use JavaScript (particularly DOM features) to consume the received data You could in theory use VBScript Or if you are using the Flash integrated with Ajax you would see Actionscript in play (pretty much JS) In some instances you will see advanced XML ideas discussed such as using client-side XML and XSLT but that is uncommon

33 AJAX Hello World Walk-thru (simple.html) 1. Collect data from a form field 2. Create an XMLHTTP object a) Cross browser issues 3. Call a server-side program which does something a) In this case a PHP file called simple.php 4. Wait for the result 5. Read the result out of the XML using DOM functions 6. Populate a tag in the page using DOM functions

34 Step 1 Collect Data from Form Field Given a form like <form action="#" method="get"> <label>enter your name: <input type="text" id="nametext" /></label> <input type="button" value="ok" onclick="sendname();" /> </form> Use code like function sendname() { var name = document.getelementbyid("nametext"); if (name.value == "") { alert("please enter your name"); return false; } else startajax(name.value); } return false;

35 Step 2 XMLHTTP and Browser Fun var xmlhttp; function ajaxhttp() { try { return new ActiveXObject("Msxml2.XMLHTTP"); } catch (e) {} try { return new ActiveXObject("Microsoft.XMLHTTP"); } catch (e) {} try { return new XMLHttpRequest(); } catch(e) {} alert("xmlhttprequest not supported"); return null; } function startajax() { snip xmlhttp = ajaxhttp(); snip }

36 Step 3 Call the Server Side Program function startajax(param) { var url = "simple.php?name=" + param; xmlhttp = ajaxhttp(); xmlhttp.open("get", url, true); xmlhttp.send(null); xmlhttp.onreadystatechange = ajaxstatechange; } ajaxstatechange is the name of a function I defined that will be invoked as things happen. This is dubbed a callback function

37 Step 3 - Send the Data

38 Step 4 Server Side Processing and Client Waiting <?php header("cache-control: no-cache"); header("pragma: no-cache"); header("content-type: text/xml"); $datemsg = "Hello World to $name at ". date("h:i:s A"); echo <<< END_OF_FILE <hello> <message id="date">$datemsg</message> </hello> END_OF_FILE?>

39 Step 4 Data is returned

40 Steps 5 and 6 Receive the Response and Use function ajaxstatechange() { if (xmlhttp.readystate == 4) { xmlstr = xmlhttp.responsexml; msg = xmlstr.getelementsbytagname("message")[0].firstchild.nodevalue; var ajaxdiv = document.getelementbyid("divforajax"); ajaxdiv.innerhtml = msg; ajaxdiv.style.display = ""; } } In XHTML we have <div id="divforajax" style="display:none;"></div>

41 What You Saw

42 AJAX and Concurrency The simple example shows the idea of how to create a backchannel request but does not point out that you can create many of them at once With AJAX you can easily spawn off numerous requests to various Web services using REST or SOAP interfaces and even route data from one to another, if this isn t concurrency I am not sure what is? Interestingly we see the Web at large playing with these ideas in the form of site/service mashups

43 Ajax Issues - Concurrency Concurrent calls to XMLHttpRequest present a number of problems. Internet Explorer limits the number of concurrent requests to a particular unique FQDN to 2 connections at a time. To have multiple requests you must ensure that your XMLHttpRequest object is not reused name wise particularly if using a global variable. You must use closures in order to guarantee that you pass the callback the appropriate response object. As concurrent requests will be running asynchronously, it is impossible to know which will return first. The callback function must take that into account. Possible race conditions with Session Variables

44 Ajax Issues Concurrency Connections ISSUE: Internet Explorer limits the number of concurrent requests to two connections to a particular FQDN at a time. If you send out multiple asynchronous requests at the same time, only two will be allowed to be processed by the server at once. This can lead to a delay in page processing. Other problem the request queue is unloaded in an order that may not be predictable to the coder (browser implementation dependency) Possible Solutions: Registry tweaks (not reasonable), use different virtual domain names for the same server (ajax1.pint.com, ajax2.pint.com, etc.)

45 Ajax Issues Concurrency Global Vars ISSUE: You must ensure that your XMLHttpRequest object is a unique variable. For example, if you use a global variable and reuse it before it is done with another call, the former call will be lost and only the response object of the second call will be seen. Example:

46 Ajax Issues Concurrency Closures ISSUE: You must use closures in order to guarantee that you pass the callback the appropriate response object. When we set the onreadystatechange property of the XMLHttpRequest, we pass it a function name. xmlhttp.onreadystatechange = ajaxstatechange; The problem is that we can not pass it any parameters. Using a global XHR variable, we may run into the global variable problems. If we don t use a global XHR variable, we have no access to the XHR in the callback function

47 Ajax Issues Concurrency Closures A closure is an inner function that has access to all of the local variables of the scope where it was defined. It captures these variables and is able to access them outside of the scope they were used. We use closures to pass the XmlHttpRequest object to the callback function. xmlhttp.onreadystatechange = function(){ajaxstatechange(xmlhttp)}; The function here passes the local variable xmlhttp to the ajaxstatechange function. When ajaxstatechange is called, xmlhttp is out of scope. However, it gets properly passed because of the closure.

48 Ajax Issues Concurrency Order As concurrent requests will be running asynchronously, it is impossible to know which will return first. The callback function must take that into account. You should not have one concurrent callback function rely on another. If they do rely on another, you must ensure they have both returned before you execute your code. You could detect that with various variables implementing a semaphore concept

49 Ajax Issues Concurrency: Race Conditions A race condition occurs when multiple threads in a process try to modify the same data at the same time. The value will depend on which thread arrived last. In normal Web pages, this is not an issue since each request from a user arrives sequentially. However, using Ajax, each page visit can spawn numerous concurrent requests which will arrive in an unknown order.

50 Ajax Issues Concurrency: Race Conditions With Ajax, it is possible to cause a race condition when writing to session variables. Since you can t check the order in which the threads arrived, the data only holds the value of the latest write.

51 Ajax Issues Concurrency: Race Conditions

52 Ajax Issues Concurrency: Race Conditions setsession.php <?php $_SESSION[ lastedit'] = $_GET[ editfield ];?> setsession.htm xmlhttp.open('get', setsession.php?editfield=clients', true); xmlhttp2.open('get', setsession.php?editfield=staff', true); As we can see in this contrived example, the session variable will be set to whichever of the xmlhttprequest variables hits setsession.php last. Solutions? Re-architect application, locks

CPS 506 Comparative Programming Languages. Programming Language Paradigms

CPS 506 Comparative Programming Languages Concurrent Programming Language Paradigms Topics Introduction Introduction to Subprogram-Level Concurrency Semaphores Monitors Message Passing Java Threads 2 Introduction