Miracle-dz/UniFAR-FTUs huggingface dataset:
Cache abstraction for data race detection in heterogeneous systems with non-coherent accelerators

Embedded systems are becoming increasingly complex and heterogeneous, featuring multiple processor cores (which might themselves be heterogeneous) as well as specialized hardware accelerators, all accessing shared memory. Many accelerators are non-coherent (i.e., do not support hardware cache coherence) because it reduces hardware complexity, cost, and power consumption, while potentially offering superior performance. However, the disadvantage of non-coherence is that the software must explicitly synchronize between accelerators and processors, and this synchronization is notoriously error-prone. We propose an analysis technique to find data races in software for heterogeneous systems that include non-coherent accelerators. Our approach builds on classical results for data race detection, but the challenge turns out to be analyzing cache behavior rather than the behavior of the non-coherent accelerators. Accordingly, our central contribution is a novel, sound (data-race-preserving) abstraction of cache behavior. We prove our abstraction sound, and then to demonstrate the precision of our abstraction, we implement it in a simple dynamic race detector for a system with a processor and a massively parallel accelerator provided by a commercial FPGA-based accelerator vendor. On eleven software examples provided by the vendor, the tool had zero false positives and was able to detect previously unknown data races in 2 of the 11 examples.
Efficient Deterministic Concurrency Control Under Practical Isolation Levels

Deterministic databases are able to run transactions efficiently in a distributed setting with minimal coordination. Research has shown many benefits from having determinism, from more lightweight database replication, to no/cheaper distributed commit, to high throughput during live migration. Besides those known applications, permissioned blockchain can also be viewed as an application of the deterministic database with security added. A permissioned blockchain maintains a fully-replicated database, where each replica is synchronized by getting blocks of updates. Early permissioned blockchains run a consensus protocol (e.g., PBFT) to agree on the input and rely on the replicas to execute the transactions serially to uphold determinism. Fabric allows concurrent transaction executions but rely on running consensus to agree on the read-write-sets and broadcasting them, which incurs an excessive volume of network traffic. Deterministic concurrency control combines the best of both worlds. It enables solving consensus on the small input, and each replica is able to execute transactions independently with high concurrency. Although powerful, contemporary deterministic databases are still primitive because they support only one isolation level -- Serializable. Furthermore, many deterministic concurrency control schemes are overly pessimistic and cause many unnecessary transaction aborts. These factors motivate us to design DCC, a suite of better deterministic concurrency control schemes, not only for Serializable but also for practical isolation levels beyond Serializable.
An In-Depth Benchmarking of Text-to-SQL Systems

Text-to-SQL systems allow users to explore relational databases by posing free-form queries, alleviating the need for using structured languages, such as SQL. Although numerous systems have been developed so far, existing system evaluations lack in rigour. In this work, we build a text-to-SQL benchmark that covers different classes of queries, and we evaluate the effectiveness of several systems in the field. To evaluate system efficiency, we measure execution time and resource consumption for the different query classes. Our comprehensive evaluation aims at filling in a big gap in understanding the capabilities and boundaries of existing systems and it reveals several open challenges.
EPEX: Processor Verification by Equivalent Program Execution

Verifying processors has been and still is a major challenge. Therefore, intensive research has led to advanced verification solutions ranging from ISS-based reference models, (cross-level) simulation down to formal verification at the RTL. During the verification of the processor implementation at the Instruction Set Architecture (ISA) level, test stimuli, i.e. test programs are needed. They are either created manually or with the aid of sophisticated test program generators. However, significant effort is required to produce thorough test programs. In this paper, we devise a novel approach for processor verification by Equivalent Program EXecution (EPEX). Our approach is based on a new form of equivalence checking Instead of comparing the architectural states of two models which execute the same program P, we derive a second, but equivalent program P^ from P (wrt. to a formal ISA model), and check that executing P and P^ will produce equal architectural states on the same design. We show that EPEX can easily be used in a simulation-based verification environment and broadens existing tests automatically. In a RISC-V case study using different core configurations of the well-known VexRiscv core, we demonstrate the bug-finding capabilities of EPEX.
LIMA: Fine-grained Lineage Tracing and Reuse in Machine Learning Systems

Machine learning (ML) and data science workflows are inherently exploratory. Data scientists pose hypotheses, integrate the necessary data, and run ML pipelines of data cleaning, feature engineering, model selection and hyper-parameter tuning. The repetitive nature of these workflows, and their hierarchical composition from building blocks exhibits high computational redundancy. Existing work addresses this redundancy with coarse-grained lineage tracing and reuse for ML pipelines. This approach allows using existing ML systems, but views entire algorithms as black boxes, and thus, fails to eliminate fine-grained redundancy and to handle internal non-determinism. In this paper, we introduce LIMA, a practical framework for efficient, fine-grained lineage tracing and reuse inside ML systems. Lineage tracing of individual operations creates new challenges and opportunities. We address the large size of lineage traces with multi-level lineage tracing and reuse, as well as lineage deduplication for loops and functions; exploit full and partial reuse opportunities across the program hierarchy; and integrate this framework with task parallelism and operator fusion. The resulting framework performs fine-grained lineage tracing with low overhead, provides versioning and reproducibility, and is able to eliminate fine-grained redundancy. Our experiments on a variety of ML pipelines show performance improvements up to 12.4x.
The Case for SIMDified Analytical Query Processing on GPUs

Data-level parallelism (DLP) is a heavily used hardware-driven parallelization technique to optimize the analytical query processing, especially in in-memory column stores. This kind of parallelism is characterized by executing essentially the same operation on different data elements simultaneously. Besides Single Instruction Multiple Data (SIMD) extensions on common x86-processors, GPUs also provide DLP but with a different execution model called Single Instruction Multiple Threads (SIMT), where multiple scalar threads are executed in a SIMD manner. Unfortunately, a complete GPU-specific implementation of all query operators has to be set up, since the state of the vectorized implementations cannot be ported from x86-processors to GPUs right now. To avoid this implementation effort, we present our vision to virtualize GPUs as virtual vector engines with software-defined SIMD instructions and to specialize hardware-oblivious vectorized operators to GPUs using our Template Vector Library (TVL) in this paper.
Millenia as Moment: A Triptych in 75 Colorgrams by Comp-syn

In Millenia as Moment: A Triptych in 75 Colorgrams, Comp-syn showcases state-of-the-art computational methods for depicting how a city like Venice, as a collective entity, perceives itself overtime. Millenia as Moment consists of colorgrams, a unit of visualization invented by Comp-syn1 . Colorgrams are produced by aggregating hundreds of images using a mathematical representation of colorspace that is optimized to emulate human perception. In Millenia as Moment, each colorgram aggregates the top 100 images associated with a word in Google search results, such that the Triptych consists of 75 colorgrams (words) in total. Via the PageRank algorithm, Google's search results are adapted to large-scale patterns of search activity bound to a geographical IP address, which allows our method to identify cultural associations that emerge as a result of the decentralized information seeking activities of entire populations, akin to the dynamics of a city. First, we present a Triptych of 75 colorgrams imaging the past, present, and future of Venice using English search terms implemented from New York City. We then replicate this Triptych while composing each colorgram using the Italian translation of each word, searched from an IP in Venice. A goal of Millenia as Moment is to imagine how cities perceive, think, and experience as collective cognitive agents. For this reason, Millenia as Moment resists linear reading. Color and shape present cognitive trails on which the viewer's mind is led, but not always to a logical destination. The words provide a map, though not always a reliable one, just as the maps of a city evolve through the Odysseus ship of its political inhabitants. An experience of meaning lies in the ineffable space between the words, images, and their arrangement, much like the identity of the city hangs ineffably between its people and its innumerable structures, spatial, temporal, and conceptual.
Collaborative Visual Environments for Evidence Taking in Digital Justice: A Design Concept

In recent years, Spatial Computing (SC) has emerged as a novel paradigm thanks to the advancements in Extended Reality (XR), remote sensing, and artificial intelligence. Computers are nowadays more and more aware of physical environments (i.e. objects shape, size, location and movement) and can use this knowledge to blend technology into reality seamlessly, merge digital and real worlds, and connect users by providing innovative interaction methods. Criminal and civil trials offer an ideal scenario to exploit Spatial Computing. The taking of evidence, indeed, is a complex activity that not only involves several actors (judges, lawyers, clerks, advisors) but it often requires accurate topographic surveys of places and objects. Moreover, another essential means of proof, the "judicial experiments" - reproductions of real-world events (e.g. a road accident) the judge uses to evaluate if and how a given fact has taken place - could be usefully carried out in virtual environments. In this paper we propose a novel approach for digital justice based on a multi-user, multimodal virtual collaboration platform that enables technology-enhanced acquisition and analysis of trial evidence.
ArkDB: A Key-Value Engine for Scalable Cloud Storage Services

Persistent key-value stores play a crucial role in enabling internet-scale services. At Alibaba Cloud, scale-out cloud storage services including Object Storage Service, File Storage Service and Tablestore are built on distributed key-value stores. Key challenges in the design of the underlying key-value engine for these services lie in utilization of disaggregated storage, supporting write and range query-heavy workloads, and balancing of scalability, availability and resource usage. This paper presents ArkDB, a key-value engine designed to address these challenges by combining advantages of both LSM tree and Bw-tree, and leveraging advances in hardware technologies. Built on top of Pangu, an append-only distributed file system, ArkDB's innovations include shrinkable page mapping table, clear separation of system and user states for fast recovery, write amplification reduction, efficient garbage collection and lightweight partition split and merge. Experimental results demonstrate ArkDB's improvements over existing designs. Compared with Bw-tree, ArkDB efficiently stabilizes the mapping table size despite continuous write working set growth. Compared with RocksDB, an LSM tree-based key-value engine, ArkDB increases ingestion throughput by 2.16x, while reducing write amplification by 3.1x. It outperforms RocksDB by 52% and 37% respectively on a write-heavy workload and a range query-intensive workload of the Yahoo! Cloud Serving Benchmark. Experiments running in Tablestore in a cluster environment further demonstrate ArkDB's performance on Pangu and its efficient partition split/merge support.
Deploying a Strategy to Unlock Big Data Research and Teaching Activities in the West Balkan Region

Big Data Analytics is a crucial component of the Big Data paradigm and deals with the extraction of knowledge from the enormous amount of data. As the number of Big Data related methods, tools, frameworks, and solutions is growing, there is a need to systematize the knowledge about the domain. Moreover, as this domain is rapidly involving, it is difficult to keep up to date with its latest and most efficient technologies; and this is thereby especially challenging for countries which have so far suffered from a lack of infrastructure in Big Data. In this article, we report on the deployment of a strategy we design, fostering the knowledge and awareness around the challenges of Big Data analytics in the West Balkan region. In particular, we describe how we joined forces across multiple European institutions in order to design bespoke actions (from, e.g. classes, to student exchanges) to be applied in Serbia and the West Balkan region over several years.
Making Meals Both Appealing and Healthy: A Food Presentation Simulation System

“You eat with your eyes first. ” Marcus Gavius Apicius, the insightful first-century Roman gourmand, stated. Although arranging foods in attractive ways can increase one’s appetite, creating an aesthetic food presentation is challenging. For instance, users have to cut ingredients into pieces of specific shapes and sizes, while imagining the overall appearance of their desired composition. To overcome such challenges, we introduce a system that assists users to arrange ingredients to present appealing patterns in meals. The system enables them to perform a process of trial-and-error in the simulation prior to creating a real food presentation. Due to machines’ high computing power, our automatic simulation provides users with a variety of food presentation results and inspires their creativity accordingly. It also computes the nutritional composition of each simulated food presentation so that both visual quality and health are considered simultaneously. Results demonstrate that the simulated food presentations are visually appealing and could be physically created. Participants who joined the user study also favored our food presentation simulation system.
One WITH RECURSIVE is Worth Many GOTOs

PL/SQL integrates an imperative statement-by-statement style of programming with the plan-based evaluation of SQL queries. The disparity of both leads to friction at runtime, slowing PL/SQL execution down significantly. This work describes a compiler from PL/SQL UDFs to plain SQL queries. Post-compilation, evaluation entirely happens on the SQL side of the fence. With the friction gone, we observe execution times to improve by about a factor of 2, even for complex UDFs. The compiler builds on techniques long established by the programming language community. In particular, it uses trampolined style to compile arbitrarily nested iterative control flow in PL/SQL into SQL's recursive common table expressions.
BullFrog: Online Schema Evolution via Lazy Evaluation

BullFrog is a relational DBMS that supports single-step schema migrations --- even those that are backwards incompatible --- without downtime, and without need for advanced warning. When a schema migration is submitted, BullFrog initiates a logical switch to the new schema, but physically migrates affected data lazily, as it is accessed by incoming transactions. BullFrog's internal concurrency control algorithms and data structures enable concurrent processing of schema migration operations with post-migration transactions, while ensuring exactly-once migration of all old data into the physical layout required by the new schema. BullFrog is implemented as an open source extension to PostgreSQL. Experiments using this prototype over a TPC-C based workload (supplemented to include schema migrations) show that BullFrog can achieve zero-downtime migration to non-trivial new schemas with near-invisible impact on transaction throughput and latency.
Becoming a Designer at the Design Lab: Empowerment and participation in children's design activities

This paper draws on data from an interview study with children engaged in a leisure time design lab situated in a socioeconomically vulnerable neighborhood. The study accounts for how the children involved in the design activities make sense of their experiences of participating in the design lab. Some perspectives on the relationship between design and empowerment are discussed and three empowering functions of the activities are identified that serve to empower the children in different ways: 1) The creative laboratory – How the activities allow for exploration and experimentation of both new identities and of new possible futures. 2) Community participation – How the design lab enables participation in the local community and reflections on what it means to be a citizen. 3) Playful apprenticeship – How the lab builds a peer-culture where children are continuously addressed and presented as equal colleagues in the lab, both in internal and external settings.
Chianina: an evolving graph system for flow- and context-sensitive analyses of million lines of C code

Sophisticated static analysis techniques often have complicated implementations, much of which provides logic for tuning and scaling rather than basic analysis functionalities. This tight coupling of basic algorithms with special treatments for scalability makes an analysis implementation hard to (1) make correct, (2) understand/work with, and (3) reuse for other clients. This paper presents Chianina, a graph system we developed for fully context- and flow-sensitive analysis of large C programs. Chianina overcomes these challenges by allowing the developer to provide only the basic algorithm of an analysis and pushing the tuning/scaling work to the underlying system. Key to the success of Chianina is (1) an evolving graph formulation of flow sensitivity and (2) the leverage of out-of-core, disk support to deal with memory blowup resulting from context sensitivity. We implemented three context- and flow-sensitive analyses on top of Chianina and scaled them to large C programs like Linux (17M LoC) on a single commodity PC.
A-Tree: A Dynamic Data Structure for Efficiently Indexing Arbitrary Boolean Expressions

Efficiently evaluating a large number of arbitrary Boolean expressions is needed in many applications such as advertising exchanges, complex event processing, and publish/subscribe systems. However, most solutions can support only conjunctive Boolean expression matching. The limited number of solutions that can directly work on arbitrary Boolean expressions present performance and flexibility limitations. Moreover, normalizing arbitrary Boolean expressions into conjunctive forms and then using existing methods for evaluating such expressions is not effective because of the potential exponential increase in the size of the expressions. Therefore, we propose the A-Tree data structure to efficiently index arbitrary Boolean expressions. A-Tree is a multirooted tree, in which predicates and subexpressions from different arbitrary Boolean expressions are aggregated and shared. A-Tree employs dynamic self-adjustment policies to adapt itself as the workload changes. Moreover, A-Tree adopts different event matching optimizations. Our comprehensive experiments show that A-Tree-based matching outperforms existing arbitrary Boolean expression matching algorithms in terms of memory use, matching time, and index construction time by up to 71%, 99% and 75%, respectively. Even on conjunctive expression workloads, A-Tree achieves a lower matching time than state-of-the-art conjunctive expression matching algorithms.
Klink: Progress-Aware Scheduling for Streaming Data Systems

Modern stream processing engines (SPEs) process large volumes of events propagated at high velocity through multiple queries. To improve performance, existing SPEs generally aim to minimize query output latency by minimizing, in turn, the propagation delay of events in query pipelines. However, for queries containing commonly used blocking operators such as windows, this scheduling approach can be inefficient. Watermarks are events popularly utilized by SPEs to correctly process window operators. Watermarks are injected into the stream to signify that no events preceding their timestamp should be further expected. Through the design and development of Klink, we leverage these watermarks to robustly infer stream progress based on window deadlines and network delay, and to schedule query pipeline execution that reflects stream progress. Klink aims to unblock window operators and to rapidly propagate events to output operators while performing judicious memory management. We integrate Klink into the popular open source SPE Apache Flink and demonstrate that Klink delivers significant performance gains over existing scheduling policies on benchmark workloads for both scale-up and scale-out deployments.
HedgeCut: Maintaining Randomised Trees for Low-Latency Machine Unlearning

Software systems that learn from user data with machine learning (ML) have become ubiquitous over the last years. Recent law such as the "General Data Protection Regulation" (GDPR) requires organisations that process personal data to delete user data upon request (enacting the "right to be forgotten"). However, this regulation does not only require the deletion of user data from databases, but also applies to ML models that have been learned from the stored data. We therefore argue that ML applications should offer users to unlearn their data from trained models in a timely manner. We explore how fast this unlearning can be done under the constraints imposed by real world deployments, and introduce the problem of low-latency machine unlearning: maintaining a deployed ML model in-place under the removal of a small fraction of training samples without retraining. We propose HedgeCut, a classification model based on an ensemble of randomised decision trees, which is designed to answer unlearning requests with low latency. We detail how to efficiently implement HedgeCut with vectorised operators for decision tree learning. We conduct an experimental evaluation on five privacy-sensitive datasets, where we find that HedgeCut can unlearn training samples with a latency of around 100 microseconds and answers up to 36,000 prediction requests per second, while providing a training time and predictive accuracy similar to widely used implementations of tree-based ML models such as Random Forests.
Classification of Levels of Induction Motor Overload using Sound Analysis

Induction motors are widely used not only in home appliances but also in industries because of their important role in electromechanical energy conversion. Overloading is among those which can shorten the operating life of those electric machines. Our research tries to use a single microphone to distinguish between full load, 10 percent overload, and 100 percent overload operations of induction motors. Three acoustic features and five classification models are evaluated to establish an overload classification system based on sound analysis. Obtained results show that this is a promising way to classify and monitor induction motor overload.