• ¿Documento equivocado? Cámbialo gratis
  • Escrito por estudiantes que aprobaron
  • Inmediatamente disponible después del pago
  • Leer en línea o como PDF
Vender
¿Dónde estudias?
Tu idioma
Document preview thumbnail
Vista previa 3 fuera de 18 páginas
Examen

Atomic Object Factory: Efficient, Consistent and Dependable Support for Distributed Objects

Document preview thumbnail
Vista previa 3 fuera de 18 páginas

Atomic Object Factory: Efficient, Consistent and Dependable Support for Distributed Objects Research report Pierre Sutra Télécom SudParis, CNRS Université Paris-Saclay, France Etienne Rivière University of Neuchâtel, Switzerland Cristian Cotes, Marc Sánchez Artigas, Pedro Garcia Lopez Universitat Rovira i Virgili Tarragona, Spain Emmanuel Bernard, William Burns, Galder Zamarreño Red Hat ABSTRACT This paper introduces Atomic Object Factory (AOF), a novel implementation of the distributed object paradigm. AOF allows client applications to transparently manipulate and share remotely-stored objects, while providing strong guarantees on dependability, consistency and persistence. It leverages the support of a listenable key-value store (LKVS), a novel NoSQL storage abstraction that we introduce in this paper. AOF offers integrated language support at the application-facing interface tier. Its middle tier implements the distributed object functionalities atop the LKVS, including coordinated replication. AOF does not rely on a mapping phase and deals with objects end-to-end. It allows the composition of these objects and provide efficient access to their methods. In particular, AOF guarantees disjoint access parallelism: operations on distinct distribued objects make use of distinct LKVS components and execute in parallel. We assess the benefits of our approach in practice by comparing the implementation of a personal cloud storage service using AOF, to an implementation of the same application with a state-of-the-art object-relational mapping over a sharded PostgreSQL database. Our results show that AOF offers a simpler programming framework both in terms of learning time and lines of code, while performing better on average and being more scalable. Keywords Distributed Objects, Language support, Dependability, Listenable Key-Value Store, Composability. 1. INTRODUCTION Context. Programming a highly-available large-scale application in a distributed Cloud environment is a complex task. In particular, proper management of the application state is critical. To this end, developers require strong guarantees on dependability and performance from the data management solutions they employ. They require to be able to manage and persist the application state using a well-defined and simple interface, ideally allowing for complex operations over structured data. These expectations extend to consistency guarantees in presence of concurrent accesses. As importantly, developers also expect the data management solution to be scalable, and to enable the pay-per-use model of Cloud computing through elastic scaling capabilities. On the one hand, relational databases remain in the majority of cases the solution of choice for structured data management. They support a well-principled and standardized interface for data specification, through the notion of relations and the SQL language. They also offer strong consistency guarantees with the use of transactions supporting the ACID semantics. On the other hand, the most popular programming model for building complex distributed applications is arguably the object-oriented paradigm (OOP). Developers are generally well-trained in languages using this paradigm, and master the associated concepts such as encapsulation, composition, inheritance, delegation, or object-centric synchronization. A mapping phase is necessary in order to use a database for persisting and sharing data between the components of an object-oriented application. For relational databases, this is the role of an object-relational mapping (ORM). An ORM transforms the application data from the object-oriented in-memory model to the relational model stored remotely, and vice-versa. Objects mapped to the relational model are persisted in the database and updated using transactions. The mapping can be done manually, or automated thanks to various technologies available in different languages, e.g., Hibernate ORM [8] for Java. Motivation. The use of ORM solutions and relational databases is unfortunately unable to meet all the needs of modern, large-scale object-oriented applications running in the Cloud. Some of these limitations come from the relational database itself, and some come from the the use of a mapping solution between the application and the storage layer. In what follows, we overview this situation. With relational databases, scalability is achieved through the sharding of relations across multiple semi-independent servers. However, this operation is complex, requires nontrivial changes at the application level, and breaks consistency for transactions that operate across shards. Moreover, resharding is a stop-the-world operation that can induce long application downtimes [19]. This generally prevents relational databases from attaining elastic scalability. A response to the scalability and elasticity defects of relational databases came in the form of NoSQL databases. By offering a simpler data interface, e.g., in the form of a key/value store, and employing placement techniques such as consistent hashing [38], the design of these novel-generation databases focuses on elastic scalability, that is the ability to add/remove servers with limited amount of data migration and without service interruption. NoSQL databases provide a large variety of consistency guarantees, ranging from eventual consistency [20, 60] to stronger guarantees such as linearizability [16, 23, 49]. Some NoSQL databases also provide transactions with various levels of isolation, e.g., serializability (MarkLogic), snapshot isolation (RavenDB) or repeatable read (Infinispan [49]). Similarly to relational databases, it is possible to define a mapping between in-memory objects and their representations stored in the NoSQL database, either manually or using tools such as Hibernate OGM. Object-to-database mappings have some intrinsic drawbacks that are commonly named the impedance mismatch. These limitations are shared by mapping solutions for both relational and NoSQL databases. First, the programmer should go back-and-forth between the in-memory representation of the data and its storage representation. This often requires to retrieve and instantiate objects from the persistent storage, access and modify them locally, then eventually push them back. This operation is done at the level of the full object state, which is shared anew upon a mutation. As a consequence, when the objects get large, performance degrades rapidly. The second problem that arises with ORM is that the relational model is data agnostic and understands solely tuples. This implies, for instance, that constructing even a shared counter in SQL requires some ad-hoc code. The same applies to the NoSQL stores that solely understand opaque values stored under a certain key. A third problem occurs with the management of complex hierarchical data structures and data locality. Circumventing issues that arise in such situations usually rely on complicated stored procedures. These procedures increases the overall code complexity, while reducing the maintainability and portability of the application. Contributions. In this paper, we propose that distributed application developers benefit from the scalability, elasticity and dependability of NoSQL systems, while at the same time manipulating the familiar object-oriented programming (OOP) paradigm. We remove the impedance mismatch associated with mapping approaches by avoiding an explicit conversion layer, and by dealing with objects end-to-end from the application code to the storage layer. Our novel framework, Atomic Object Factory (AOF), offers language-level support for data persistence, distribution and concurrency. It follows the distributed object paradigm. In comparison to previous attempts implementing this paradigm, e.g., dedicated object-oriented databases or object broker middleware solutions, AOF shows key differences that allow reaching its goals of performance, dependability and usability. First, we do not build a new and specific data management layer but leverage the robustness, elasticity and scalability of a NoSQL data store. Second, AOF offers high availability in the presence of crash failures through the use of state-machine replication. Third, objects can be composed in arbitrary acyclic graphs, and cached close to the client for performance. Finally, the use of AOF is transparent and simple: one just needs to annotate the classes of objects to access them remotely and distribute the computation. Our framework takes complete care of moving the objects and their constituents to the underlying NoSQL data store, replicating them, and providing strong consistency in presence of concurrent accesses. This paper makes the following contributions: - The design and implementation of AOF, which is formed of three complementary tiers: ⊲ A first application-facing interface tier implementing simple and transparent support for the Java language based on annotations, allowing developers to easily manipulate remotely-stored objects; ⊲ A second intermediate object management tier implementing support for dependable and strongly consistent shared objects; ⊲ A third and lower storage tier in the form of a listenable key-value store (LKVS), a novel NoSQL abstraction that allows AOF to meet its consistency, dependability and performance guarantees. We provide both an algorithmic realization of the LKVS, and a concrete implementation in a state-of-the-art NoSQL database; - The description of a representative cloud application in the form of StackSync, a personal cloud storage application. This application initially uses a state-of-the-art ORM solution with sharding and stored procedures. We describe its porting to AOF, and report on the relative complexity of the two approaches; - An evaluation of the performance and scalability of AOF both using micro-benchmarks and the StackSync application under a large-scale trace from the Ubuntu One personal cloud service. This evaluation shows that AOF consistently outperforms the ORM-based approach, being able to sustain a higher throughput and to offer shorter response times. Outline. We organize the remaining of this paper as follows. Section 2 presents the interface tier of AOF and its guarantees. Section 3 details the two server-side object management and storage tiers of AOF, and Section 4 covers implementation details. In Section 5, we describe the use case application. Results of our evaluation appear in Section 6. We survey related work in Section 7, then conclude in Section 8. For readability purposes, we defer some algorithmic details as well as our correctness proofs to the appendix. 2. PROGRAMMER’S PERSPECTIVE


Información del documento

Subido en
25 de julio de 2024
Número de páginas
18
Escrito en
2023/2024
Tipo
Examen
Contiene
Preguntas y respuestas
$11.49

¿Documento equivocado? Cámbialo gratis Dentro de los 14 días posteriores a la compra y antes de descargarlo, puedes elegir otro documento. Puedes gastar el importe de nuevo.
Escrito por estudiantes que aprobaron
Inmediatamente disponible después del pago
Leer en línea o como PDF

Seller avatar
Los indicadores de reputación están sujetos a la cantidad de artículos vendidos por una tarifa y las reseñas que ha recibido por esos documentos. Hay tres niveles: Bronce, Plata y Oro. Cuanto mayor reputación, más podrás confiar en la calidad del trabajo del vendedor.
Vendido
123
Seguidores
33
Artículos
1517
Última venta
1 mes hace



Por qué los estudiantes eligen Stuvia

Creado por compañeros estudiantes, verificado por reseñas

Calidad en la que puedes confiar: escrito por estudiantes que aprobaron y evaluado por otros que han usado estos resúmenes.

¿No estás satisfecho? Elige otro documento

¡No te preocupes! Puedes elegir directamente otro documento que se ajuste mejor a lo que buscas.

Paga como quieras, empieza a estudiar al instante

Sin suscripción, sin compromisos. Paga como estés acostumbrado con tarjeta de crédito y descarga tu documento PDF inmediatamente.

Student with book image

“Comprado, descargado y aprobado. Así de fácil puede ser.”

Alisha Student

Preguntas frecuentes

Ups! No podemos cargar tu documento ahora. Inténtalo de nuevo o contacta con soporte.