214 research outputs found
Scalable Termination Detection for Distributed Actor Systems
Automatic garbage collection (GC) prevents certain kinds of bugs and reduces
programming overhead. GC techniques for sequential programs are based on
reachability analysis. However, testing reachability from a root set is
inadequate for determining whether an actor is garbage because an unreachable
actor may send a message to a reachable actor. Instead, it is sufficient to
check termination (sometimes also called quiescence): an actor is terminated if
it is not currently processing a message and cannot receive a message in the
future. Moreover, many actor frameworks provide all actors with access to file
I/O or external storage; without inspecting an actor's internal code, it is
necessary to check that the actor has terminated to ensure that it may be
garbage collected in these frameworks. Previous algorithms to detect actor
garbage require coordination mechanisms such as causal message delivery or
nonlocal monitoring of actors for mutation. Such coordination mechanisms
adversely affect concurrency and are therefore expensive in distributed
systems. We present a low-overhead reference listing technique (called DRL) for
termination detection in actor systems. DRL is based on asynchronous local
snapshots and message-passing between actors. This enables a decentralized
implementation and transient network partition tolerance. The paper provides a
formal description of DRL, shows that all actors identified as garbage have
indeed terminated (safety), and that all terminated actors--under certain
reasonable assumptions--will eventually be identified (liveness).Comment: 23 pages, 7 figures. To appear in the proceedings of CONCUR 2020.
Version 2: Fixed TeX error that omitted predicates in the third line of the
Send rule: Actor must have active refobs and $y_1 \dots y_n
Isosurface Extraction in the Visualization Toolkit Using the Extrema Skeleton Algorithm
Generating isosurfaces is a very useful technique in data visualization for understanding the distribution of scalar data. Often, when the size of the data set is really large, as in the case with data produced by medical imaging applications, engineering simulations or geographic information systems applications, the use of traditional methods like marching cubes makes repeated generation of isosurfaces a very time consuming task. This thesis investigated the use of the Extrema Skeleton algorithm to speed up repeated isosurface generation in the visualization package, Visualization Toolkit (VTK). The objective was to reduce the number of non-isosurface cells visited to generate isosurfaces, and to compare the Extrema Skeleton method with the Marching Cubes method by monitoring parameters like time taken for the isosurfacing process and number of cells visited. The results of this investigation showed that the Extrema Skeleton method was faster for most of the datasets tested. For simple datasets with less than 10% isosurface cells and complex datasets with less than 5% isosurface cells, the Extrema Skeleton method was found to be significantly faster than the Marching Cubes method. The time gained by the Extrema Skeleton method for datasets with greater than 15% isosurface cells was found to be insignificant. Based on the results of this study, implementing the Extrema Skeleton method for the VTK software is a change worth making because typical VTK users deal with datasets for which the Extrema Skeleton method is significantly faster and also with datasets for which it is marginally faster than the Marching Cubes method
Extending the Finite Domain Solver of GNU Prolog
International audienceThis paper describes three significant extensions for the Finite Domain solver of GNU Prolog. First, the solver now supports negative integers. Second, the solver detects and prevents integer overflows from occurring. Third, the internal representation of sparse domains has been redesigned to overcome its current limitations. The preliminary performance evaluation shows a limited slowdown factor with respect to the initial solver. This factor is widely counterbalanced by the new possibilities and the robustness of the solver. Furthermore these results are preliminary and we propose some directions to limit this overhead
TULIP 4
Tulip is an information visualization framework dedicated to the analysis and visualization of relational data. Based on more than 15 years of research and development, Tulip is built on a suite of tools and techniques , that can be used to address a large variety of domain-specific problems. With Tulip, we aim to provide Python and/or C++ developers a complete library, supporting the design of interactive information visualization applications for relational data, that can be customized to address a wide range of visualization problems. In its current iteration, Tulip enables the development of algorithms, visual encodings, interaction techniques, data models, and domain-specific visualizations. This development pipeline makes the framework efficient for creating research prototypes as well as developing end-user applications. The recent addition of a complete Python programming layer wraps up Tulip as an ideal tool for fast prototyping and treatment automation, allowing to focus on problem solving, and as a great system for teaching purposes at all education levels
Challenges in using the actor model in software development, systematic literature review
Toimijamalli on hajautetun ja samanaikaisen laskennan malli, jossa pienet osat ohjelmistoa viestivät keskenään asynkronisesti ja käyttäjälle näkyvä toiminnallisuus on usean osan yhteistyöstä esiin nouseva ominaisuus. Nykypäivän ohjelmistojen täytyy kestää valtavia käyttäjämääriä ja sitä varten niiden täytyy pystyä nostamaan kapasiteettiaan nopeasti skaalautuakseen. Pienempiä ohjelmiston osia on helpompi lisätä kysynnän mukaan, joten toimijamalli vaikuttaa vastaavan tähän tarpeeseen. Toimijamallin käytössä voi kuitenkin esiintyä haasteita, joita tämä tutkimus pyrkii löytämään ja esittelemään. Tutkimus toteutetaan systemaattisena kirjallisuuskatsauksena toimijamalliin liittyvistä tutkimuksista.
Valituista tutkimuksista kerättiin tietoja, joiden pohjalta tutkimuskysymyksiin vastattiin. Tutkimustulokset listaavat ja kategorisoivat ohjelmistokehityksen ongelmia, joihin käytettiin toimijamallia, sekä erilaisia toimijamallin käytössä esiintyviä haasteita ja niiden ratkaisuita. Tutkimuksessa löydettiin toimijamallin käytössä esiintyviä haasteita ja näille haasteille luotiin uusi kategorisointi. Haasteiden juurisyitä analysoidessa havaittiin, että suuri osa toimijamallin haasteista johtuvat asynkronisen viestinnän käyttämisestä, ja että ohjelmoijan on oltava jatkuvasti tarkkana omista oletuksistaan viestijärjestyksestä. Haasteisiin esitetyt ratkaisut kategorisoitiin niihin liittyvän lisättävän koodin sijainnin mukaan
Improving Model-Based Software Synthesis: A Focus on Mathematical Structures
Computer hardware keeps increasing in complexity. Software design needs to keep up with this. The right models and abstractions empower developers to leverage the novelties of modern hardware. This thesis deals primarily with Models of Computation, as a basis for software design, in a family of methods called software synthesis.
We focus on Kahn Process Networks and dataflow applications as abstractions, both for programming and for deriving an efficient execution on heterogeneous multicores. The latter we accomplish by exploring the design space of possible mappings of computation and data to hardware resources. Mapping algorithms are not at the center of this thesis, however. Instead, we examine the mathematical structure of the mapping
space, leveraging its inherent symmetries or geometric properties to improve mapping methods in general.
This thesis thoroughly explores the process of model-based design, aiming to go beyond the more established software synthesis on dataflow applications. We starting with the problem of assessing these methods through benchmarking, and go on to formally examine the general goals of benchmarks. In this context, we also consider the role modern machine learning methods play in benchmarking.
We explore different established semantics, stretching the limits of Kahn Process Networks. We also discuss novel models, like Reactors, which are designed to be a deterministic, adaptive model with time as a first-class citizen. By investigating abstractions and transformations in the Ohua language for implicit dataflow programming, we also focus on programmability.
The focus of the thesis is in the models and methods, but we evaluate them in diverse use-cases, generally centered around Cyber-Physical Systems. These include the 5G telecommunication standard, automotive and signal processing domains. We even go beyond embedded systems and discuss use-cases in GPU programming and microservice-based architectures
Doctor of Philosophy
dissertationMany algorithms have been developed for synthesizing shaded images of three dimensional objects modeled by computer. In spite of widely differing approaches the current state of the art algorithms are surprisingly similar with respect to the richness of the scenes they can process. One attribute these algorithms have in common is the use of a conventional passive data base to represent the objects being modeled. This paper postulates and explores the use of an alternative modeling technique which uses procedures to represent the objects being modeled. The properties and structure of such "procedure models" are investigated and an algorithm based on them is presented
- …