Efficiency of software application is one of the important metrics that are used to measure the quality of software applications. Nowadays, more and more professionals are focusing on programming technology because suitable programming may make the products more efficient. The emergence of multiprocessor systems and multi-core CPUs makes concurrent programs much more popular than sequential programs. However, a great number of large complex software applications that have already been released and are currently being used by many clients are programmed in sequential fashion. Compared to developing the program from scratch again, code refactoring with the concept of concurrent programming would be a better choice. It saves effort, time, manpower and money. This thesis studies the problems of introducing concurrency into large and complex software applications and proposes a methodology for transforming sequential programs into concurrent programs. We successfully speeded up a prototype of IBM Security AppScan Source for Analysis by introducing concurrency into the program. The performance of the application was improved, thus demonstrating the usefulness of the proposed methodology.

No description available.

Concurrent programming can improve performance. However, it comes with two drawbacks. First, concurrent programs can be more difficult to design and reason about than their sequential counterparts. Second, error conditions that do not exist in sequential programs, such as data race conditions and deadlock, can make concurrent programs more unreliable. To make concurrent programming simpler and more reliable, while still providing sufficient performance gains, we present a concurrency framework based on an existing concurrency initiation mechanism called “Early-Reply”. Early-Reply is based on the idea that some functions can produce final return values long before they terminate. Concurrent execution begins when return value of a function is returned to the caller, allowing the rest of the work of the function to be done on an auxiliary thread. The simpler sequential programming model can be used by the caller, because the concurrency is initiated and hidden within the function body. Pike and Sridhar recognized Early-Reply as a way for sequential programs to get the benefits of concurrent execution. They also discussed using object-oriented programming to serialize access to data that needs synchronization. Our work expands on their approach and provides an actual C++ implementation of an Early-Reply based framework. Our framework simplifies concurrent programming for both users and implementers by allowing developers to use sequential reasoning, and by providing a minimal framework interface. Concurrent programming is made more reliable by combining the concurrency synchronization and initiation into one mechanism within the framework, which isolates where race conditions and deadlock can occur. Furthermore, this isolation facilitates the development of a simple set of coding guidelines that can be used by developers (through inspection) or static analysis tools (through verification) to eliminate race conditions and deadlocks. As a motivating example, we parallelize an instructional compiler that processes multiple input source files. For each input file; the parsing and semantic analysis execute on the calling thread, while the code optimization and object code generation execute on an auxiliary thread. Speedups of 1.5 to 1.7 were observed on a dual processor confirming that sufficient performance gains are possible.

Concurrent programming has become ubiquitous in the arena of application development, requiring most production quality systems to deal with at least some degree of multi-threaded execution. An increasing level of maturity is developing around the impact of concurrency on the design and testing processes. Much of this knowledge focuses on the functional aspect of the design and execution with success measures typically related to the correctness of a program. However, there exists a gap in the research to date around the process for concurrent performance testing. While many companies acknowledge that performance is a major source of complaints in production environments, performance testing historically receives low priority and is often little more than an extension of the functional testing. Possibly the most widely discussed and understood implementation language today, in terms of multi-threaded programming, is Java. The report outlines a standard framework for concurrent performance testing targeted towards Java based applications. In an effort to vet the framework, we execute a series of practical concurrent testing that address some of the most common aspects of concurrent programming in Java, with a particular focus on the Java Concurrency package. As a result, this report presents a portable, extensible framework that designers can use in evaluating the range of concurrency options available in Java within their particular environment. Additionally, it provides specific insight into the performance of these options in a typical run-time environment. This includes particular attention to the comparison of traditional lock based approach to non-blocking algorithms. / text

No description available.

No description available.

Programming is a core subject within Computer Science curricula and many also consider it a particularly difficult subject to learn. There have been many studies and suggestions on what causes these difficulties and what can be done to improve the situation. This thesis builds on previous work, trying to understand what difficulties students have when learning to program. The included papers cover several areas encountered when trying to learn programming. In Paper I we study how students use annotations during problem solving. The results show that students who annotate more also tend to be more successful. However, the results also indicate that there might be a cultural bias towards the use of annotations. Not only do students have problems with programming, they also have problems with designing software. Even graduating students fail to a large extent on simple design tasks. Our results in Paper II show that the majority of the students do not go beyond restating the problem when asked to design a system. Getting stuck is something that most learners experience at one time or another. In Paper III we investigate how successful students handle these situations. The results show that the students use a large number of different strategies to get unstuck and continue their learning. Many of the strategies involve social interaction with peers and others. In Papers IV, V, and VI we study what students experience as being key and threshold concepts in Computer Science. The results show that understanding particular concepts indeed affect the students greatly, changing the way they look at Computer Science, their peers, and themselves. The two last papers, Papers VII and VIII, investigate how researchers, teachers and students view concurrency. Most researchers/teachers claim that students have difficulties because of non-determinism, not understanding synchronization, etc. According to our results the students themselves do not seem to think that concurrency is significantly more difficult than any other subject. Actually most of them find concurrency to be both easy to understand and fun. / Programmering har en central roll i datavetenskapliga utbildningar. Många anser att programmering är svårt att lära sig. Ett stort antal studier har undersökt vad som orsakar dessa svårigheter och hur det är möjligt att övervinna dem. Denna avhandling är en del av denna forskning. Artiklarna i avhandlingen undersöker vilka problem som studenterna stöter på under sina programmeringsstudier. Artikel 1 beskriver hur studenter använder sig av annoteringar vid problemlösning. Resultaten visar att studenter som gör många annoteringar tenderar att prestera bättre. Resultaten antyder också att det kan finnas kulturella skillnader i hur ofta annoteringar används. Studenter har inte bara problem vid programmering, de har också problem med att utforma programvarusystem. Även sistaårsstudenter misslyckas till stor del att utforma lösningar för relativt enkla system. Resultaten i Artikel II visar att majoriteten av studenterna inte kommer längre än en omformulering av problemet. Att inte förstå ett koncept eller en specifik detalj är något som alla studenter stöter på då och då. I Artikel III undersöker vi hur framgångsrika studenter hanterar en sådan situation. Resultaten visar att studenterna använder sig av ett stort antal olika strategier för att få en förståelse för konceptet/detaljen. Många av de redovisade strategierna bygger på en social interaktion med andra. Artiklarna IV, V och VI utforskar vad studenterna uppfattar som nyckelkoncept inom datavetenskap och hur förståelsen av dessa koncept påverkar dem. Resultaten visar att förståelsen av vissa specifika koncept kan göra att studenterna ändrar hur de ser på datavetenskap, kollegor och sig själva. I artiklarna VII och VIII undersöker vi hur forskare, lärare och studenter ser på de problem studenter har vid jämlöpande programmering. De flesta forskare och lärare hävdar att studenterna har problem med att förstå icke-determinism, synkronisering, etc. Våra resultat visar dock att studenterna inte själva tycks anse att jämlöpande programmering är signifikant svårare än andra ämnen. Tvärtom, de flesta anser att jämlöpande programmering är både lätt att förstå och roligt.

This dissertation is concerned with the development of fully-automatic methods of verification, for message-passing based concurrent systems. In the first part of the thesis we focus on Erlang, a dynamically typed, higher-order functional language with pattern-matching algebraic data types extended with asynchronous message-passing. We define a sound parametric control-flow analysis for Erlang, which we use to bootstrap the construction of an abstract model that we call Actor Communicating System (ACS). ACS are given semantics by means of Vector Addition Systems (VAS), which have rich decidable properties. We exploit VAS model checking algorithms to prove properties of Erlang programs such as unreachability of error states, mutual exclusion, or bounds on mailboxes. To assess the approach empirically, we constructed Soter, a prototype implementation of the verification method, thereby obtaining the first fully-automatic, infinite-state model checker for a core concurrent fragment of Erlang. The second part of the thesis addresses one of the major sources of imprecision in the ACS abstraction: process identities. To study the problem of algorithmically verifying models where process identities are accurately represented we turn to the π-calculus, a process algebra based around the notion of name and mobility. The full π-calculus is Turing-powerful so we focus on the depth-bounded fragment introduced by Roland Meyer, which enjoys decidability of some verification problems. The main obstacle in using depth-bounded terms as a target abstract model, is that depth-boundedness of arbitrary π-terms is undecidable. We therefore consider the problem of identifying a fragment of depth-bounded π-calculus for which membership is decidable. We define the first such fragment by means of a novel type system for the π-calculus. Typable terms are ensured to be depth-bounded. Both type-checking and type inference are shown to be decidable. The constructions are based on the novel notion of Τ-compatibility, which imposes a hierarchy between names. The type system's main goal is proving that this hierarchy is preserved under reduction, even in the presence of unbounded name creation and mobility.

Doctor of Philosophy(PhD) / Snapshot Isolation (SI) is a multiversion concurrency control that has been implemented by open source and commercial database systems such as PostgreSQL and Oracle. The main feature of SI is that a read operation does not block a write operation and vice versa, which allows higher degree of concurrency than traditional two-phase locking. SI prevents many anomalies that appear in other isolation levels, but it still can result in non-serializable execution, in which database integrity constraints can be violated. Several techniques have been proposed to ensure serializable execution with engines running SI; these techniques are based on modifying the applications by introducing conflicting SQL statements. However, with each of these techniques the DBA has to make a difficult choice among possible transactions to modify. This thesis helps the DBA’s to choose between these different techniques and choices by understanding how the choices affect system performance. It also proposes a novel technique called ’External Lock Manager’ (ELM) which introduces conflicts in a separate lock-manager object so that every execution will be serializable. We build a prototype system for ELM and we run experiments to demonstrate the robustness of the new technique compare to the previous techniques. Experiments show that modifying the application code for some transactions has a high impact on performance for some choices, which makes it very hard for DBA’s to choose wisely. However, ELM has peak performance which is similar to SI, no matter which transactions are chosen for modification. Thus we say that ELM is a robust technique for ensure serializable execution.

Doctor of Philosophy(PhD) / Snapshot Isolation (SI) is a multiversion concurrency control that has been implemented by open source and commercial database systems such as PostgreSQL and Oracle. The main feature of SI is that a read operation does not block a write operation and vice versa, which allows higher degree of concurrency than traditional two-phase locking. SI prevents many anomalies that appear in other isolation levels, but it still can result in non-serializable execution, in which database integrity constraints can be violated. Several techniques have been proposed to ensure serializable execution with engines running SI; these techniques are based on modifying the applications by introducing conflicting SQL statements. However, with each of these techniques the DBA has to make a difficult choice among possible transactions to modify. This thesis helps the DBA’s to choose between these different techniques and choices by understanding how the choices affect system performance. It also proposes a novel technique called ’External Lock Manager’ (ELM) which introduces conflicts in a separate lock-manager object so that every execution will be serializable. We build a prototype system for ELM and we run experiments to demonstrate the robustness of the new technique compare to the previous techniques. Experiments show that modifying the application code for some transactions has a high impact on performance for some choices, which makes it very hard for DBA’s to choose wisely. However, ELM has peak performance which is similar to SI, no matter which transactions are chosen for modification. Thus we say that ELM is a robust technique for ensure serializable execution.