Most high-performance software transactional memories (STM) use optimistic invisible reads. Consequently, a transaction might have an inconsistent view of the objects it accesses unless the consistency of the view is validated whenever the view changes. Although all STMs usually detect inconsistencies at commit time, a transaction might never reach this point because an inconsistent view can provoke arbitrary behavior in the application (e.g., enter an infinite loop). In this paper, we formally introduce a lazy snapshot algorithm that verifies at each object access that the view observed by a transaction is consistent. Validating previously accessed objects is not necessary for that, however, it can be used on-demand to prolong the view's validity. We demonstrate both formally and by measurements that the performance of our approach is quite competitive by comparing other STMs with an STM that uses our algorithm.

https://doc.rero.ch/record/18139/files/Riegel_Torvald_-_A_Lazy_Snapshot_Algorithm_with_Eager_Validation_20100430.pdf

A Lazy Snapshot Algorithm with Eager Validation

As the number of available Web services is steadily increasing, there is a growing interest for reusing basic Web services in new, composite Web services. Several organizations have proposed composition languages (BPML, BPMN, BPEL4WS, BPSS, WSCI), but no winner has been declared so far. This work proposes a method that uses UML Activity models to design Web service compositions, and OMG's Model Driven Architecture (MDA) to generate executable specifications in different composition languages. The method utilizes standard UML constructs with a minimal set of extensions for Web services. An important step in the method is the transformation of WSDL descriptions into UML This information is used to complete the composition models. Another key aspect of the method is its independence of the Web service composition language. The user can thus select his preferred composition language - and execution engine - for realizing the composite Web service. Currently, the method has been implemented to support two executable composition languages BPEL4WS and WorkSCo, with corresponding execution engines. WorkSco is a Web service enabled workflow composition language. The method is illustrated with an example from a crisis management scenario.

Web service composition in UML

Cloud computing can be defined as the use of new or existing computing hardware and virtualization technologies to form a shared infrastructure that enables web-based value added services. The three predominant service models are infrastructure, platform, and software-asa-service. Infrastructure-as-a-Service (IaaS) can be defined as the use of servers, storage, and virtualization to enable utility like services for users. Security is a big concern within IaaS, especially considering that the rest of the cloud service models run on top of the infrastructure and related layers. Platform-as-a-Service (PaaS) providers offer access to APIs, programming languages and development middleware which allows subscribers to develop custom applications without installing or configuring the development environment. Software-as-a-Service (SaaS) gives subscribed or pay-peruse users access to software or services which reside in the cloud and not on the user's device. Understanding the cloud service models is critical in determining if cloud services or hosting are an appropriate business solution, and if so, which model best balances the level of control required versus reduced hardware, configuration, and maintenance costs. Cloud computing offers many benefits to organizations; it has enabled collaboration amongst disparate communities and workgroups, and has overcome challenges that have plagued existing business solutions. However, the security, privacy, and integrity of the cloud are of prime importance and there are many challenges that exist. At the present time there seems to be a lot of momentum behind the adoption of cloud computing despite these. This may simply be a trend, an indication that society truly wants their data to be available whenever from anywhere, or a sign that few understand the associated risks.

Benefits and challenges of three cloud computing service models

We present Selective Multi-Versioning (SMV), a new STM that reduces the number of aborts, especially those of long read-only transactions. SMV keeps old object versions as long as they might be useful for some transaction to read. It is able to do so while still allowing reading transactions to be invisible by relying on automatic garbage collection to dispose of obsolete versions.

SMV is most suitable for read-dominated workloads, for which it performs better than previous solutions. It has an up to ×7 throughput improvement over a single-version STMand more than a two-fold improvement over an STMkeeping a constant number of versions per object. We show that the memory consumption of algorithms keeping a constant number of versions per object might grow exponentially with the number of objects, while SMV operates successfully even in systems with stringent memory constraints.

/pdf/smv-selective-multi-versioning-stm-2s6gb5368e.pdf

SMV: selective multi-versioning STM

Software Transactional Memory Systems STM are a promising alternative for concurrency control in shared memory systems. Multiversion STM systems maintain multiple versions for each t-object. The advantage of storing multiple versions is that it facilitates successful execution of higher number of read operations than otherwise. Multi-Version permissiveness mv-permissiveness is a progress condition for multi-version STMs that states that a read-only transaction never aborts. Recently a STM system was proposed that maintains only a single version but is mv-permissive. This raises a natural question: how much concurrency can be achieved by multi-version STM. We show that fewer transactions are aborted in multi-version STMs than single-version systems. We also show that any STM system that is permissive w.r.t opacity must maintain at least as many versions as the number of live transactions. A direct implication of this result is that no single-version STM can be permissive w.r.t opacity.

In this paper we present a time-stamp based multiversion STM system that satisfies opacity and is easy to implement. We formally prove the correctness of the proposed STM system. Although many multi-version STM systems have been proposed in literature that satisfy opacity, to the best of our knowledge none of them has been formally proved to be opaque. We also present garbage collection procedure which deletes unwanted versions of the transaction objects. We show that with garbage collection the number of versions maintained is bounded by number of live transactions.

/pdf/a-timestamp-based-multi-version-stm-algorithm-uucyoejs0o.pdf

A TimeStamp Based Multi-version STM Algorithm

Software Transactional Memory (STM) was initially proposed as a lock-free mechanism for concurrency control. Early implementations had efficiency limitations, and soon obstruction-free proposals appeared, to tackle this problem, often simplifying STM implementation. Today, most of the modern and top-performing STMs use blocking designs, relying on locks to ensure an atomic commit operation. This approach has revealed better in practice, in part due to its simplicity. Yet, it may have scalability problems when we move into many-core computers, requiring fine-tuning and careful programming to avoid contention. In this paper we present and discuss the modifications we made to a lock-based multi-version STM in Java, to turn it into a lock-free implementation that we have tested to scale at least up to 192 cores, and which provides results that compete with, and sometimes exceed, some of today's top-performing lock-based implementations. The new lock-free commit algorithm allows write transactions to proceed in parallel, by allowing them to run their validation phase independently of each other, and by resorting to helping from threads that would otherwise be waiting to commit, during the write-back phase. We also present a new garbage collection algorithm to dispose of old unused object versions that allows for asynchronous identification of unnecessary versions, which minimizes its interference with the rest of the transactional system.

Lock-free and scalable multi-version software transactional memory

Workflow definition languages are evolving rapidly. However, there is not any agreed-upon standard for such languages. In this paper we address the problem of how to develop a workflow system that is able to cope with the constant changes in these languages. We address the definition aspect of workflow systems by distinguishing between frontend and backend languages. This way, a workflow system can be developed based on the backend language whereas the frontend language can change.

Supporting Evolution in Workflow Definition Languages

Cloud Computing offers application developers an abstract view of computational resources that can be provisioned on demand over a computer network. This model allows organizations to concentrate on the applications needed to support their core business, instead of having to manage the infrastructure required to run those applications. Yet, even though this approach promises very compelling benefits, there is still a lack of programming models capable of bringing the power of parallel programming into the hands of ordinary programmers. In this paper we tackle this problem by proposing the use of the Fenix Framework as the means of exposing a simple and intuitive programming model for the cloud, while still attaining scalability on par with other Cloud Computing platforms. We claim that may be achieved by integrating the Fenix Framework into the Cloud-TM platform, which is being developed as a self-optimized middleware platform aimed at simplifying the development and administration of applications deployed on Cloud Computing infrastructures. We validate our claims by describing an initial prototype that provides a simple integration of the Fenix Framework with the persistence tier of Cloud-TM in such a way that it allowed us to run a previously developed benchmark application without changing any of its code to adapt it to the cloud platform.

Towards a Simple Programming Model in Cloud Computing Platforms

Despite many evolutions in the software architecture of enterprise applications, one thing has remained the same over the years: They still use a relational database both for data persistence and transactional support. We argue that such design, once justified by hardware limitations, endured mostly for legacy reasons and is no longer adequate for a significant portion of modern applications running in a new generation of multicore machines with very large memories.We propose a new architecture for enterprise applications that uses a Software Transactional Memory for transactional support at the application server tier, thereby shifting the responsibility of transaction control from the database to the application server. The database tier remains in our architecture with the sole purpose of ensuring the durability of data.With this change we are able to provide strictly serializable transaction semantics, and we do so with increased performance. Thus, we claim that strict serializability is harmless, in the sense that programmers no longer have to trade correctness for performance for a significant class of applications. We have been using this new architecture since 2005 in the development of real-world complex object-oriented applications, and we present statistical data collected over several years about the workload patterns of these applications, revealing a surprisingly low rate of write transactions.

Strict serializability is harmless: a new architecture for enterprise applications

Organizations expect Web Services to make their information systems more agile so they can better adapt to changes in business requirements. Hence, this technology's design principles focus on interoperability and flexibility to give developers the ability to customize, reuse and enhance functionalities as well as non-functionalities such as security, transactions and reliable messaging. In particular, an effective Web Services customization must give application developers simple and expressive ways to program the changes they need without losing any capabilities available in the platform. We propose customization with Web Services Extensions and present the concept, its core mechanisms and its implementation on the STEP Framework, an open-source multi-layer Java enterprise application framework.

Sérgio Miguel Fernandes

Papers

Lock-free and scalable multi-version software transactional memory

Supporting Evolution in Workflow Definition Languages

Towards a Simple Programming Model in Cloud Computing Platforms

Strict serializability is harmless: a new architecture for enterprise applications

Customizing Web Services with Extensions in the STEP framework