61 research outputs found
Adaptive software transactional memory : dynamic contention management
This thesis addresses the problem of contention management in Software Transactional Memory (STM), which is a scheme for managing shared memory in a concurrent programming environment. STM views shared memory in a way similar to that of a database; read and write operations are handled through transactions, with changes to the shared memory becoming permanent through commit operations. Research on this subject reveals that there are currently varying methods for collision detection, data validation, and contention management, each of which has different situations in which they become the preferred method. This thesis introduces a dynamic contention manager that monitors current performance and chooses the proper contention manager accordingly. Performance calculations, and subsequent polling of the underlying library, are minimized. As a result, this adaptive contention manager yields a higher average performance level over time when compared with existing static implementations
Performance Optimization Strategies for Transactional Memory Applications
This thesis presents tools for Transactional Memory (TM) applications that cover multiple TM systems (Software, Hardware, and hybrid TM) and use information of all different layers of the TM software stack. Therefore, this thesis addresses a number of challenges to extract static information, information about the run time behavior, and expert-level knowledge to develop these new methods and strategies for the optimization of TM applications
The design and application of an extensible operating system
Tanenbaum, A.S. [Promotor
Formal Semantics for Java-like Languages and Research Opportunities
The objective of this paper is twofold: first, we discuss the state of art on Java-like semantics, focusing on those that provide formal specification using operational semantics (big-step or small-step), studying in detail the most cited projects and presenting some derivative works that extend the originals aggregating useful features. Also, we filter our research for those that provide some insights in type-safety proofs. Furthermore, we provide a comparison between the most used projects in order to show which functionalities are covered in such projects. Second, our effort is focused towards the research opportunities in this area, showing some important works that can be applied to the previously presented projects to study features of object-oriented languages, and pointing for some possibilities to explore in future researches
Contributions to the safe execution of dynamic component-based real-time systems
Traditionally, real-time systems have based their design and execution on barely dynamic models to ensure, since design time, the temporal guarantees in the execution of their functionality. Great effort is being applied nowadays to progressively develop more dynamic systems, with the target of changing during their execution and to adapt themselves to their environment. The capability to change and to reconfigure themselves represents remarkable advantages as the capability to fix errors and to add new functionality with on-line updates. This means to be able to be updated without needing to stop the service, that may imply monetary losses in many cases. Design and development techniques based on components have become popular due to the use of components, which allows simplifying the system design, code reusability and updates through the substitution of components. The target of this thesis work is to provide certain degree of dynamism to real-time systems allowing them to replace components, incorporating new functionality of fixing existing bugs. On that purpose, a component-based framework is proposed, as well as the corresponding task in charge of providing dynamism to the system. The main contribution is to provide a framework to allow safe component replacements. Safe meaning that incorrect executions of tasks are avoided even y multiple tasks are executing concurrently and making use of the same data. Also that temporal guarantees are provided for every task. This framework incorporates a generic component model with real-time threads, a components replacement model with execution times that are known and bounded, and different strategies to apply such component replacement model. Some mechanisms to maintain a seamless and safe execution, regarding concurrency, before, during, and after applying the processes in charge of replacing running components are also described. Seamless execution means that components themselves do not perform the replacements, and safe means that temporal guarantees are provided and components are not affected in their execution. Part of these mechanisms are the system schedulability analysis and the framework tasks as well as reserving the needed resources for such scheduling to be correct. ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Los sistemas de tiempo real han basado tradicionalmente su desarrollo en modelos altamente
predecibles ya que estos requieren garantías temporales en su ejecución.
A lo largo de los años, la technología de tiempo real ha ido penetrando en diferentes campos de
aplicación y ajustándose a paradigmas de desarrollo software más novedosos. Esto ha presentado y
presenta en la actualidad un tremendo reto ya que estas aplicaciones suelen tener un alto grado de
dinamismo, lo que entra en conflicto con la predictibilidad temporal y, en general la ejecución
segura de los mismos.
Hoy en dia se esta realizando un gran esfuerzo en el desarrollo de sistemas cada vez más
dinamicos que permitan adaptar su estructura en tiempo de ejecución para adaptarse a entornos que
presentan condiciones cambiantes. La capacidad de soportar este tipo de dinamismo presenta
ventajas descatables como permitir corregir fallos y anadir funcionalidad mediante actualizaciones
en caliente, es decir, poder actualizarse sin necesidad de realizar paradas en su servicio, lo que
podria implicar costes monetarios en muchos casos o perdidas temporales de servicio.
Por otro lado, las técnicas de diseño y desarrollo basadas en componentes se han hecho muy
populares y su aplicación a los sistemas de tiempo real gana terreno día a día. Uno de los
principales motivos de ellos es que el uso de componentes permite simplificar el diseño del sistema,
la reutilizacion de codigo e incluso la actualizacion del mismo mediante la substitucion de
componentes.
En esta tesis se aborda el objetivo de proveer a los sistemas de tiempo real de cierto grado de
dinamismo para poder reemplazar componentes de forma segura, que permita incorporar nuevas
funcionalidades o corregir errores existentes. Para ello, en esta tesis se ha elaborado de un marco de
trabajo para dar soporte a reemplazos de componentes de forma segura, entendiendo como tal que el
hecho de que no se produzcan ejecuciones incorrectas debido a la ejecución concurrente de
multiples tareas, asi como el garantizar los tiempos de ejecucion de cada tarea y acotar la duración
temporal de los reemplazos. El marco de trabajo propuesto está basado, pues, en componentes de
tiempo real, que tiene en cuenta los requisitos temporales en la ejecución de los componentes del
sistema y de las tareas propias del marco que dan soporte a estos mecanismos de reemplazo. Este
marco de trabajo incorpora un modelo generico de componente con tareas de tiempo real, un
modelo de reemplazo de componentes cuyos tiempos de ejecucion son conocidos y limitados en
tiempo y diferentes estrategias de aplicacion de dicho modelo de reemplazo de componente. Las
contribuciones propuestas integran el analisis de la planificabilidad de los componentes del sistema
y de las tareas del marco de componentes para permitir establecer los parámetros de reserva de los
recursos necesarios para las tareas del marco. Por último, se realiza una validación empírica en la
que se comprueba experimentalmente la validez del modelo tanto de forma genérica como en un
escenario específico y determinando también los recursos necesarios para su implementación
Component replication in application servers
Three-tier middleware architecture is commonly used for hosting large-scale distributed applications. Typically the application is decomposed into three layers: front-end, middle tier and back-end. Front-end ("Web server") is responsible for handling user interactions and acts as a client of the middle tier, while back-end provides storage facilities for applications. Middle tier (' Application server') is usually the place where all computations are performed, so this layer provides middleware services for transactions, security and so forth. The benefit of this architecture is that it allows flexible configuration such as partitioning and clustering for improved performance and scalability. On this architecture, availability measures, such as replication, can be introduced in each tier in an application specific manner. Among the three tier described above, the availability of the middle tier and the back-end tier are the most important, as these tiers provide the computation and the data for the applications. This thesis investigates how replication for availability can be incorporated within the middle and back-end tiers. The replication mechanisms must guarantee exactly once execution of user request despite failures of application and database servers. The thesis develops an approach that requires enhancements to the middle tier only for supporting replication of both the tiers. The design, implementation and performance evaluation of such a middle tier based replication scheme for multi-database transactions on a widely deployed open source application server (1Boss) are presented.EThOS - Electronic Theses Online ServiceQUE Project, Department of Informatics, ITB, Bandung, IndonesiaGBUnited Kingdo
3rd Many-core Applications Research Community (MARC) Symposium. (KIT Scientific Reports ; 7598)
This manuscript includes recent scientific work regarding the Intel Single Chip Cloud computer and describes approaches for novel approaches for programming and run-time organization
XML-aware data synchronization for mobile devices
In everyday life, and when using computer systems in particular, it is sometimes the case that a logical datum is replicated into multiple copies, such as when we send a document by electronic mail, or inform interested parties of a new address of residence. If the datum for some reason changes, we would then also like the changes to be reflected in the copies. The problem of keeping the copies up-to-date with respect to each other is studied under the heading of data synchronization.
In this thesis, we address data synchronization for mobile devices with limited energy resources and limited connectivity to the Internet, such as mobile phones. The importance of data synchronization is emphasized here, as it becomes infeasible to communicate continuously and in high volumes about the current state of each copy. The established conventions of the Internet and mobile computing environments on such matters as storage interfaces and data formats define an overall system architecture, into which we as seamlessly as possible want to incorporate our proposal. By focusing on interoperability we lower the threshold for utilizing our research in practice.
We present a comprehensive approach to data synchronization for mobile devices that is optimistic and state-based, and which targets opaque and XML files on a standard file system. We consider how to use the available connectivity in an economical manner, and so that existing sources of data on the Internet can be utilized. We focus on XML synchronization, where we identify an opportunity to utilize the structure of the data the format exposes. Specifically, we present an algorithm for merging concurrent changes to XML documents which supports subtree moves, an efficient heuristic algorithm for computing tree-level changes between two XML documents, and an overall architecture and algorithms to support the use of lazily instantiated XML documents. Our data synchronization approach is evaluated quantitatively in several experiments, as well as qualitatively by constructing applications that build on top of the approach. One of our applications is an editor that processes 1 GB XML files on a mobile phone
- …