The Art of Multiprocessor Programming

During the last few years, software evolution research has explored new domains such as the study of socio-technical aspects and collaboration between different individuals contributing to a software system, the use of search-based techniques and meta-heuristics, the mining of unstructured software repositories, the evolution of software requirements, and the dynamic adaptation of software systems at runtime. Also more and more attention is being paid to the evolution of collections of inter-related and inter-dependent software projects, be it in the form of web systems, software product families, software ecosystems or systems of systems. With this book, the editors present insightful contributions on these and other domains currently being intensively explored, written by renowned researchers in the respective fields of software evolution. Each chapter presents the state of the art in a particular topic, as well as the current research, available tool support and remaining challenges. The book is complemented by a glossary of important terms used in the community, a reference list of nearly 1,000 papers and books and tips on additional resources that may be useful to the reader (reference books, journals, standards and major scientific events in the domain of software evolution and datasets). This book is intended for all those interested in software engineering, and more particularly, software maintenance and evolution. Researchers and software practitioners alike will find in the contributed chapters an overview of the most recent findings, covering a broad spectrum of software evolution topics. In addition, it can also serve as the basis of graduate or postgraduate courses on e.g., software evolution, requirements engineering, model-driven software development or social informatics.

Evolving Software Systems

Today, Representational State Transfer (REST) is becoming more and more important. RESTful web services are an alternative to Remote Procedure Call technologies like SOAP and WS-* services. There are many frameworks for implementing RESTful applications, but there is still a lack of support for the early phases of the development process, particularly analysis and design. For building formal models of RESTful applications an appropriate metamodel is needed. After analyzing existing approaches and techniques a first version of such a REST metamodel is presented and used to model an example application. Beside enabling modeling, such a metamodel offers a vocabulary for REST in practice and the basis for model driven development.

/pdf/modeling-restful-applications-2iyx5wscxe.pdf

Modeling RESTful applications

Enterprises depend on business-critical systems that have been developed over the last three decades or more, also known as legacy systems. They have several well-known disadvantages (e.g., inflexible, domain unspecific, and hard to maintain), and this is recognized by both the vendors and customers of these software systems. Both vendors and customers of these systems are well aware that better and cheaper customer specific solutions can be created following the service-oriented paradigm. Hence, momentum is growing within enterprises to evolve legacy systems towards Service-Oriented Architecture (SOA). The evolution to SOA is favored because of various advantages including well established sets of open standards, platform and language independent interfaces, clear separation of service interface and implementation, and loose-coupling among services. Over a decade there have been significant developments in legacy to SOA evolution and that has resulted in a large research body of which there exists no comprehensive overview. This chapter provides an historic overview, focusing on the methods and techniques used in a legacy to SOA evolution. We conducted a systematic literature review to collect legacy to SOA evolution approaches reported from 2000 to August 2011. To this end, 121 primary studies were collected and evaluated using an evaluation framework, which was developed from three evolution and modernization methods widely used in software re-engineering domain. The resulting evaluation constitutes the inventory of current research approaches, methods and techniques used in legacy to SOA evolution and identification of several research directions for future research.

Legacy to SOA Evolution: A Systematic Literature Review

Legacy systems are vitally important for the continuation of business in an enterprise as they support complex core business processes. However, legacy systems have several well-known disadvantages such as being inflexible and hard to maintain, so momentum is growing to evolve those systems into new technology environments. Recently, service-oriented architecture has emerged as a promising architectural style that enables existing legacy systems to expose their functionality as services, without making significant changes to the legacy systems themselves. A significant number of the legacy to service migration approaches address the technical perspective (i.e., supporting technology) to expose the legacy code as services. The other approaches focus on determining the feasibility of the migration that includes economical and technical feasibility, based on the characteristics of existing legacy system and the requirements of the target SOA system. In this paper, a legacy to SOA migration method that does not single out the migration feasibility and technical perspectives, but combines these two perspectives of migration, is proposed. Method engineering is used to develop the migration method by reusing method fragments from existing service-oriented development methods. Then, concept slicing is used to develop the service by extracting the relevant parts of the legacy code. The method is evaluated and enhanced by interviewing experts and further validated with two case studies. The method is found to be appropriate and effective in extracting services from legacy code with the aim of reusing these services in new configurations.

/pdf/a-method-engineering-based-legacy-to-soa-migration-method-31dur3hn0v.pdf

A method engineering based legacy to SOA migration method

Most of the SOA (Service Oriented Architecture) applications are not brand new and usually evolved from legacy systems. Legacy systems carry out the enterprisepsilas most crucial business information together with business processes and many organizations have leveraged the value of their legacy systems by exposing parts of it as services. Most of current Web services are SOAP-RPC style services. The evolution of the Web 2.0 phenomenon has led to the increased adoption of the RESTful services paradigm and reengineering legacy system to SOA with RESTful Web services is not only for reusing but will bring other benefits due to its special features. In this paper, the key issues for reengineering legacy systems with RESTful Web services are discussed. A common process for reengineering legacy systems to REST-style is proposed. The candidate Web services are identified by legacy systems comprehension at first. Then blend services are generated based on relationships between entities and constraint rules specified. The generated URIs are refined and split carefully to represent the RESTful Web services.

/pdf/reengineering-legacy-systems-with-restful-web-service-hp6siaolks.pdf

Reengineering Legacy Systems with RESTful Web Service

We consider the verification of safety (strict serializability and abort consistency) and liveness (obstruction and livelock freedom) for the hybrid transactional memory framework FlexTM. This framework allows for flexible implementations of transactional memories based on an adaptation of the MESI coherence protocol. FlexTM allows for both eager and lazy conflict resolution strategies. Like in the case of Software Transactional Memories, the verification problem is not trivial as the number of concurrent transactions, their size, and the number of accessed shared variables cannot be a priori bounded. This complexity is exacerbated by aspects that are specific to hardware and hybrid transactional memories. Our work takes into account intricate behaviours such as cache line based conflict detection, false sharing, invisible reads or non-transactional instructions. We carry out the first automatic verification of a hybrid transactional memory and establish, by adopting a small model approach, challenging properties such as strict serializability, abort consistency, and obstruction freedom for both an eager and a lazy conflict resolution strategies. We also detect an example that refutes livelock freedom. To achieve this, our prototype tool makes use of the latest antichain based techniques to handle systems with tens of thousands of states.

/pdf/verifying-safety-and-liveness-for-the-flextm-hybrid-2hamv46ptx.pdf

Verifying safety and liveness for the FlexTM hybrid transactional memory

Cache coherence protocols based on self-invalidation and self-downgrade have
recently seen increased popularity due to their simplicity, potential
performance efficiency, and low energy consumption. However, such protocols
result in memory instruction reordering, thus causing extra program behaviors
that are often not intended by the programmers. We propose a novel formal model
that captures the semantics of programs running under such protocols, and
features a set of fences that interact with the coherence layer. Using the
model, we design an algorithm to analyze the reachability and check whether a
program satisfies a given safety property with the current set of fences. We
describe a method for insertion of optimal sets of fences that ensure
correctness of the program under such protocols. The method relies on a
counter-example guided fence insertion procedure. One feature of our method is
that it can handle a variety of fences (with different costs). This diversity
makes optimization more difficult since one has to optimize the total cost of
the inserted fences, rather than just their number. To demonstrate the strength
of our approach, we have implemented a prototype and run it on a wide range of
examples and benchmarks. We have also, using simulation, evaluated the
performance of the resulting fenced programs.

Mending Fences with Self-Invalidation and Self-Downgrade

Cache coherence protocols using self-invalidation and self-downgrade have recently seen increased popularity due to their simplicity, potential performance efficiency, and low energy consumption. However, such protocols result in memory instruction reordering, thus causing extra program behaviors that are often not intended by the programmer. We propose a novel formal model that captures the semantics of programs running under such protocols, and employs a set of fences that interact with the coherence layer. Using the model, we perfform a reachability analysis that can check whether a program satisfies a given safety property with the current set of fences. Based on an algorithm in [19], we describe a method for insertion of optimal sets of fences that ensure correctness of the program under such protocols. The method relies on a counter-example guided fence insertion procedure. One feature of our method is that it can handle a variety of fences with different costs. This diversity makes optimization more difficult since one has to optimize the total cost of the inserted fences, rather than just their number. To demonstrate the strength of our approach, we have implemented a prototype and run it on a wide range of examples and benchmarks. We have also, using simulation, evaluated the performance of the resulting fenced programs.

/pdf/fencing-programs-with-self-invalidation-and-self-downgrade-1gndspzn0f.pdf

Fencing Programs with Self-Invalidation and Self-Downgrade

We address the problem of parameterized verification of cache coherence protocols for hardware accelerated transactional memories. In this setting, transactional memories leverage on the versioning capabilities of the underlying cache coherence protocol. The length of the transactions, their number, and the number of manipulated variables (i.e., cache lines) are parameters of the verification problem. Caches in such systems are finite-state automata communicating via broadcasts and shared variables. We augment our system with filters that restrict the set of possible executable traces according to existing conflict resolution policies. We show that the verification of coherence for parameterized cache protocols with filters can be reduced to systems with only a finite number of cache lines. For verification, we show how to account for the effect of the adopted filters in a symbolic backward reachability algorithm based on the framework of constrained monotonic abstraction. We have implemented our method and used it to verify transactional memory coherence protocols with respect to different conflict resolution policies.

/pdf/verification-of-cache-coherence-protocols-wrt-trace-filters-55x5wirj9i.pdf

Yunyun Zhu

Papers

Reengineering Legacy Systems with RESTful Web Service

Verifying safety and liveness for the FlexTM hybrid transactional memory

Mending Fences with Self-Invalidation and Self-Downgrade

Fencing Programs with Self-Invalidation and Self-Downgrade

Verification of cache coherence protocols wrt. trace filters