From 3be4a2bfb2538f16ee5a156b69575ac732290e87 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Thu, 7 Sep 2023 15:35:03 -0400 Subject: [PATCH 01/64] TOC --- OpenTOC/erlang23.html | 122 ++++++++++++++++++++++++++++ OpenTOC/farm23.html | 130 ++++++++++++++++++++++++++++++ OpenTOC/fhpnc23.html | 111 ++++++++++++++++++++++++++ OpenTOC/funarch23.html | 143 +++++++++++++++++++++++++++++++++ OpenTOC/haskell23.html | 177 +++++++++++++++++++++++++++++++++++++++++ OpenTOC/tyde23.html | 122 ++++++++++++++++++++++++++++ _data/OpenTOC.yaml | 24 ++++++ 7 files changed, 829 insertions(+) create mode 100644 OpenTOC/erlang23.html create mode 100644 OpenTOC/farm23.html create mode 100644 OpenTOC/fhpnc23.html create mode 100644 OpenTOC/funarch23.html create mode 100644 OpenTOC/haskell23.html create mode 100644 OpenTOC/tyde23.html diff --git a/OpenTOC/erlang23.html b/OpenTOC/erlang23.html new file mode 100644 index 0000000..0cfa227 --- /dev/null +++ b/OpenTOC/erlang23.html @@ -0,0 +1,122 @@ +Erlang 2023: Proceedings of the 22nd ACM SIGPLAN International Workshop on Erlang

Erlang 2023: Proceedings of the 22nd ACM SIGPLAN International Workshop on Erlang

+ Full Citation in the ACM Digital Library +

SESSION: Keynote

+

Code Analysis at WhatsApp (Keynote)

  • Ke Mao
+

In the ever-evolving world of software development, code analysis stands as a critical component for quality and efficiency. This keynote will present an overview of code analysis tools at WhatsApp, and then delve into the techniques of dynamic and static analysis, with examples of their industrial deployments. The keynote will discuss the integration of code analysis into early stages of the software development life cycle, from continuous integration pipelines to DevOps practices.

+
+ +

SESSION: Papers

+

TLS the Erlang/OTP Way (Experience Report)

  • Ingela Anderton Andin
  • Raimo Niskanen
  • Péter Dimitrov
  • Kiko Fernandez-Reyes
+

The Transport Layer Security (TLS) protocol is one of the most used protocols to +ensure data privacy, integrity and authenticity on the Internet. Erlang/OTP's +TLS implementation is widely used in industry, and especially in the telecommunication +sector. +

+

+This paper describes an overview of the TLS protocol in the context of Erlang. +We explain Erlang/OTP's TLS protocol design and implementation, optimizations, a benchmark +evaluation of the Erlang TLS protocol implementation against previous +Erlang/OTP's TLS implementations, and a benchmark comparison against the Go's +TLS implementation.

+
+ + +

Generation and Refinement of Testing Models

  • Luis Eduardo Bueso de Barrio
  • Lars-Åke Fredlund
  • Clara Benac Earle
  • Ángel Herranz
  • Julio Mariño
+

Writing property-based testing models is a challenging task. This article introduces a new tool, Faktory, which is capable of automatically generating an executable property-based testing model from less complicated sources: normal function type specifications, and traditional function calling contracts using pre- and post-conditions. Concretely, Faktory is an Elixir library which from an API annotated with executable calling contracts written using the Corsa contract checking library, automatically generates a property-based testing model in the form of a state machine implemented using the Makina state machine DSL. In the article we illustrate the functionalities of the Faktory tool using a number of examples. The first one shows how to test a functional data structure; the second shows how to improve test-case generation by reusing test results; and in the third example a stateful key-value storage is tested by first deriving an initial test model using Faktory, and then refining the generated model using the Makina model/state machine extension mechanism.

+
+ + +

Mria: An Eventually Consistent Mnesia

  • Dmitrii Fedoseev
  • Serhii Tupchii
  • Thales Macedo Garitezi
  • Zaiming Shi
+

Mnesia, an Erlang distributed database, serves as an embedded storage and replication layer for OTP applications requiring low read latency and high availability. +EMQX is a publish-subscribe message broker supporting the MQTT protocol that uses Mnesia to replicate its internal state across the cluster. +We analyze the limitations of Mnesia's replication protocol scalability in large clusters under high load. +To address these limitations, we developed Mria, an extension to the Mnesia database that provides eventual consistency within a cluster and achieves better horizontal scalability. +We validated Mria using a variety of testing techniques, including model checking, chaos engineering, and formal verification. +Replacing Mnesia with Mria allowed us to scale the EMQX cluster to 23 nodes, handle 100 million simultaneous client sessions and achieve a higher sustained load.

+
+ + +

A Semantics of Core Erlang with Handling of Signals

  • Aurélie Kong Win Chang
  • Jérôme Feret
  • Gregor Gössler
+

We introduce a small step semantics for a subset of Core Erlang modeling its monitoring and signal systems. The goal of our semantics is to enable the construction of causal explanations for property violations, which will be the object of future work. As a first axis of reflection, we chose to study the impact of the order of messages on a faulty behavior. We present our semantics and discuss some of our design choices. This work is a part of a broader project on causal debugging of concurrent programs in Erlang.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/farm23.html b/OpenTOC/farm23.html new file mode 100644 index 0000000..94ee291 --- /dev/null +++ b/OpenTOC/farm23.html @@ -0,0 +1,130 @@ +FARM 2023: Proceedings of the 11th ACM SIGPLAN International Workshop on Functional Art, Music, Modelling, and Design

FARM 2023: Proceedings of the 11th ACM SIGPLAN International Workshop on Functional Art, Music, Modelling, and Design

+ Full Citation in the ACM Digital Library +

SESSION: Keynote

+

Perfectly Imperfect: Music, Math, and the Keyboard (Keynote)

  • Gloria Cheng
+

As a concert pianist and harpsichordist, I am devoted to extracting expression and meaning out of the silent abstractions of a musical score. Behind the preparation for any performance is my stark wonder at how such innovative, suggestive sonic domains are realized by composers, literally out of thin air. We’ll explore some basic mathematic principles that underlie all musical discourse, with a focus, given time constraints, on Western classical music. With recorded and live examples from the keyboard, we’ll look at Harmony: from the acoustical demonstrations of Pythagoras, through the contentious battles over tunings and temperaments during the Baroque, to the microtonal experiments of modern times in the work of Harry Partch and Iannis Xenakis. And Rhythm: another vast realm of experimentation and invention, how did we get from 2/4 to the polymeters and irrational meters of Conlon Nancarrow and Thomas Adès? +

+

+Looking at music through a mathematical lens is one effort out of many to understand—though never explain—how this remarkable acoustic phenomenon can move us to tears.

+
+ +

SESSION: Session 1

+

Weighted Refinement Types for Counterpoint Composition

  • Youyou Cong
+

Refinement types are useful for describing specifications of programs. +When applied to music theory, however, refinement types are too +restrictive in that they do not allow breaking of rules. +To relax this restriction, we propose weighted refinement types, +a variation of refinement types where each refinement predicate carries +a weight representing the importance of that predicate. +In this paper, we present a weighted refinement type system that has +core features required for composing species counterpoint. +We also discuss potential applications of weighted refinement types +in non-musical domains.

+
+ + +

The Beauty and Elegance of Functional Reactive Animation

  • Ivan Perez
+

It has been over 20 years since Elliott and Hudak published Functional Reactive Animation, which outlined the principles of interactive programming in functional languages. As a result, Functional Reactive Programming (FRP) has seen numerous implementations and has been applied to multiple areas, like robotics, physics simulations, game programming and user interfaces. The use of the term FRP has itself broadened, and nowadays covers both continuous-time purely functional abstractions and discrete-time reactive implementations. This paper presents a series of increasingly complex FRP animations in a current implementation. With a main focus on clarity and meaning, we explore three independent dimensions: space, time, and color. We demonstrate that, when embraced fully, Functional Programming can result in declarative constructs that are aesthetically beautiful and notationally elegant.

+
+ + +

Demo: A Functional EDSL for Mathematics Visualization That Compiles to JavaScript

  • Allister Beharry
+

Visualizations are a critical part of mathematics practice and education, and computers and open-source web technologies provide accessible ways to create high-quality mathematics visualizations at virtually no cost. However libraries and languages to create visualizations for mathematics are typically fine-grained, low-level, and targeted to vector graphics domain experts or web developers, not mathematics students or teachers or end-users. We present demos of Sylvester: a functional domain-specific language interface to the JSXGraph visualization library embedded in F# that emphasizes readability, composability, and the ability of end-users to easily create and manipulate elements of high-quality interactive mathematics visualizations without needing vector graphics or web development domain knowledge.

+
+ +

SESSION: Session 2

+

Exploring Self-Embedded Knitting Programs with Twine

  • Amy Zhu
  • Adriana Schulz
  • Zachary Tatlock
+

We examine how we might explicitly embed the intricate details of the fabrication process in the design of an object; the goal is for the programs that manufacture the object to also produce themselves within the object. We highlight how concretizing the design process of an object in the real object can help reconstruct items and remind us of the reality that all objects must be manufactured, incurring labour and environmental costs. By drawing inspiration from self-reproducing programs, we outline a new self-decoding language design centred around quines for knitting, a versatile technique in fabric construction, with both historical significance and recent advances in programmable whole-garment machines for their manufacture. We show some preliminary results of using this language design to create knitted quines, and discuss how this interesting question might be further advanced.

+
+ + +

Homotopy Type Theory for Sewn Quilts

  • Charlotte Clark
  • Rose Bohrer
+

This paper introduces PieceWork, an imperative programming language for the construction of designs for sewn quilts, whose semantics are inspired by Homotopy Type Theory. The goals of PieceWork include improving the diversity of sewn designs that can be represented in computational methods, demonstrating a creative application of Homotopy Type Theory, and demonstrating that the craft of quilting is a worthy object of study in programming language theory. +We develop an operational semantics, provide a prototype implementation and examples, and provide initial theoretical results. Type system design is in-progress.

+
+ + +

Demo: Sonic Catalog of Rare Diseases

  • Stephen Taylor
  • Aditi Kantipuly
+

This 15-20 minute demo presents our work in progress, a sonic catalog of rare diseases, along with prior work of data- driven music based on genetic sequences from SARS CoV-2. These data-driven compositions are created from spread- sheets, imported into Max and Kyma, and mapped to musical sound.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/fhpnc23.html b/OpenTOC/fhpnc23.html new file mode 100644 index 0000000..1177df6 --- /dev/null +++ b/OpenTOC/fhpnc23.html @@ -0,0 +1,111 @@ +FHPNC 2023: Proceedings of the 11th ACM SIGPLAN International Workshop on Functional High-Performance and Numerical Computing

FHPNC 2023: Proceedings of the 11th ACM SIGPLAN International Workshop on Functional High-Performance and Numerical Computing

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

Rank-Polymorphism for Shape-Guided Blocking

  • Artjoms Šinkarovs
  • Thomas Koopman
  • Sven-Bodo Scholz
+

Many numerical algorithms on matrices or tensors can be formulated in a blocking style which improves performance due to better cache locality. In imperative languages, blocking is achieved by introducing additional layers of loops in a nested fashion alongside with suitable adjustments in index computations. While this process is tedious and error-prone, it is also difficult to implement a generically blocked version that would support arbitrary levels of blocking.

At the example of matrix multiply, this paper demonstrates how rank-polymorphic array languages enable the specification of such generically blocked algorithms in a simple, recursive form. The depth of the blocking as well as blocking factors can be encoded in the structure of array shapes. In turn, reshaping arrays makes it possible to switch between blocked and non-blocked arrays. Through rank-polymorphic array combinators, any specification of loop boundaries or explicit index computations can be avoided.

Firstly, we propose a dependently-typed framework for rank-polymorphic arrays. We use it to demonstrate that all blocked algorithms can be naturally derived by induction on the argument shapes. Our framework guarantees lack of out-of-bound indexing, and we also prove that all the blocked versions compute the same results as the canonical algorithm. Secondly, we translate our specification to the array language SaC. Not only do we show that we achieve similar conciseness in the implementation, but we also observe good performance of the generated code. We achieve a 7% improvement compared to the highly-optimised OpenBLAS library, and 3% compared to Intel’s MKL library when running on a 32-core shared-memory system.

+
+ + +

Efficient GPU Implementation of Affine Index Permutations on Arrays

  • Mathis Bouverot-Dupuis
  • Mary Sheeran
+

Optimal usage of the memory system is a key element of fast GPU algorithms. Unfortunately many common algorithms fail in this regard despite exhibiting great regularity in memory access patterns. In this paper we propose efficient kernels to permute the elements of an array. We handle a class of permutations known as Bit Matrix Multiply Complement (BMMC) permutations, for which we design kernels of speed comparable to that of a simple array copy. This is a first step towards implementing a set of array combinators based on these permutations.

+
+ + +

Shape-Constrained Array Programming with Size-Dependent Types

  • Lubin Bailly
  • Troels Henriksen
  • Martin Elsman
+

We present a dependent type system for enforcing array-size + consistency in an ML-style functional array language. Our goal is + to enforce shape-consistency at compile time and allow nontrivial + transformations on array shapes, without the complexity such + features tend to introduce in dependently typed languages. Sizes + can be arbitrary expressions and size equality is purely + syntactical, which fits naturally within a scheme that interprets + size-polymorphic functions as having implicit arguments. When + non-syntactical equalities are needed, we provide dynamic checking. + In contrast to other dependently typed languages, we automate the + book-keeping involved in tracking existential sizes, such as when + filtering arrays. We formalise a large subset of the presented type + system and prove it sound. We also discuss how to adapt the type + system for a real implementation, including type inference, within + the Futhark programming language.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/funarch23.html b/OpenTOC/funarch23.html new file mode 100644 index 0000000..c157643 --- /dev/null +++ b/OpenTOC/funarch23.html @@ -0,0 +1,143 @@ +FUNARCH 2023: Proceedings of the 1st ACM SIGPLAN International Workshop on Functional Software Architecture

FUNARCH 2023: Proceedings of the 1st ACM SIGPLAN International Workshop on Functional Software Architecture

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

A Software Architecture Based on Coarse-Grained Self-Adjusting Computations

  • Stefan Wehr
+

Ensuring that software applications +present their users the most recent version of data is not trivial. +Self-adjusting computations are a technique for automatically and efficiently recomputing +output data whenever some input changes. +

+

+This article describes the software architecture of a large, commercial +software system built around a framework for coarse-grained self-adjusting +computations in Haskell. It discusses advantages and disadvantages +based on longtime experience. +The article also presents a demo of the system +and explains the API of the framework.

+
+ + +

Crème de la Crem: Composable Representable Executable Machines

  • Marco Perone
  • Georgios Karachalias
+

In this paper we describe how to build software architectures as a composition of state machines, using ideas and principles from the field of Domain-Driven Design. By definition, our approach is modular, allowing one to compose independent subcomponents to create bigger systems, and representable, allowing the implementation of a system to be kept in sync with its graphical representation. +

+

+In addition to the design itself we introduce the Crem library, which provides a concrete state machine implementation that is both compositional and representable. Crem uses Haskell's advanced type-level features to allow users to specify allowed and forbidden state transitions, and to encode complex state machine---and therefore domain-specific---properties. Moreover, since Crem's state machines are representable, Crem can automatically generate graphical representations of systems from their domain implementations.

+
+ + +

Functional Shell and Reusable Components for Easy GUIs

  • D. Ben Knoble
  • Bogdan Popa
+

Some object-oriented GUI toolkits tangle state management with rendering. Functional shells and observable toolkits like GUI Easy simplify and promote the creation of reusable views by analogy to functional programming. We have successfully used GUI Easy on small and large GUI projects. We report on our experience constructing and using GUI Easy and derive from that experience several architectural patterns and principles for building functional programs out of imperative systems.

+
+ + +

Phases in Software Architecture

  • Jeremy Gibbons
  • Donnacha Oisín Kidney
  • Tom Schrijvers
  • Nicolas Wu
+

The large-scale structure of executing a computation can often be thought of as being separated into distinct phases. But the most natural form in which to specify that computation may well have a different and conflicting structure. For example, the computation might consist of gathering data from some locations, processing it, then distributing the results back to the same locations; it may be executed in three phases—gather, process, distribute—but mostly conveniently specified orthogonally—by location. We have recently shown that this multi-phase structure can be expressed as a novel applicative functor (also known as an idiom, or lax monoidal functor). Here we summarize the idea from the perspective of software architecture. At the end, we speculate about applications to choreography and multi-tier architecture.

+
+ + +

Stretching the Glasgow Haskell Compiler: Nourishing GHC with Domain-Driven Design

  • Jeffrey M. Young
  • Sylvain Henry
  • John Ericson
+

Over the last decade Haskell has been productized; transitioning from a + research language to an industrial strength language ready for large-scale + systems. However, the literature on architecting such systems with a pure + functional language is scarce. In this paper we contribute to that discourse, + by using a large-scale system: the Glasgow Haskell Compiler (GHC), as a guide + to more maintainable, flexible and effective, pure functional architectures. + We describe, from experience, how GHC as a system, violates the desirable + properties that make pure functional programming attractive: immutability, + modularity, and composability. With these violations identified, we provide + guidance for other functional system architectures; drawing heavily on + Domain-Driven Design. We write from an engineering perspective, with the hope + that our experience may provide insight into best practices for other pure + functional software architects.

+
+ + +

Typed Design Patterns for the Functional Era

  • Will Crichton
+

This paper explores how design patterns could be revisited in the era of mainstream functional programming languages. I discuss the kinds of knowledge that ought to be represented as functional design patterns: architectural concepts that are relatively self-contained, but whose entirety cannot be represented as a language-level abstraction. I present four concrete examples embodying this idea: the Witness, the State Machine, the Parallel Lists, and the Registry. Each pattern is implemented in Rust to demonstrate how careful use of a sophisticated type system can better model each domain construct and thereby catch user mistakes at compile-time.

+
+ + +

Types that Change: The Extensible Type Design Pattern

  • Ivan Perez
+

Compilers are often structured as chains of transformations, from source code to object code, through multiple intermediate representations. The existence of different representations of the same program presents challenges both for code maintenance and in terms of architecture. The types used to capture programs at multiple stages may be similar but not interchangeable, leading to code duplication. Methods to alleviate such duplication often lead to violations of software engineering principles of abstraction and encapsulation. This pearl discusses a design pattern where an algebraic data type (ADT) is extended with an argument type function that is applied to every component of the ADT. The resulting parametric type can be instantiated with multiple type functions, each providing a different feature. We demonstrate the versatility of this pattern by capturing notions of traceability and error recovery, and demonstrate that it can also be used to selectively modify existing types, as well as to extend them. Our proposal has been validated by applying it to a real-world use case with very good results.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/haskell23.html b/OpenTOC/haskell23.html new file mode 100644 index 0000000..04c6303 --- /dev/null +++ b/OpenTOC/haskell23.html @@ -0,0 +1,177 @@ +Haskell 2023: Proceedings of the 16th ACM SIGPLAN International Haskell Symposium

Haskell 2023: Proceedings of the 16th ACM SIGPLAN International Haskell Symposium

+ Full Citation in the ACM Digital Library +

SESSION: Keynotes

+

Haskell for Choice-Based Learning (Keynote)

  • Ningning Xie
+

Machine learning has achieved many successes during the past decades, spanning domains of game-playing, protein folding, competitive programming, and many others. However, while there have been major efforts in building programming techniques and frameworks for machine learning programming, there has been very little study of general language design for machine learning programming. +

+

+We pursue such a study in this talk, focusing on choice-based learning, particularly where choices are driven by optimizations. This includes widely-used decision-making models and techniques (e.g., Markov decision processes or gradient descent) which provide frameworks for describing systems in terms of choices (e.g., actions or parameters) and their resulting feedback as losses (dually, rewards). +

+

+We propose and give evidence for the following thesis: languages for choice-based learning can be obtained by combining two paradigms, algebraic effects and handlers, and the selection monad. We provide a prototype implementation as a Haskell library and present a variety of programming examples for choice-based learning: stochastic gradient descent, hyperparameter tuning, generative adversarial networks, and reinforcement learning.

+
+ + +

The Evolution of Effects (Keynote)

  • Nicolas Wu
+

Functional programming has been celebrated for its promise of pure functions, delivering referential transparency and elegant reasoning about programs. However, real-world applications are not pure, and necessitate interaction with the outside world, introducing computational effects such as IO, state, and exceptions. The journey to harmonize these seemingly contradictory paradigms has led to a fascinating evolution of effectful programming in Haskell. +

+

+The introduction of monads as a practical programming tool was a pivotal discovery, enabling controlled sequencing of effectful computations and addressing the challenge of handling side effects in a pure language. However, it soon became evident that the lack of modularity in composing effects using monads posed a limitation to effectful programming. To overcome this obstacle, monad transformers emerged as a solution, providing a composable manner of building effects on top of one another. +

+

+More recent advancements have led to algebraic effects as an alternative framework that is easy to extend, particularly as domain-specific languages crafted to work in specific contexts. Nevertheless, these effects are not without quirks and limitations, leading to the development of higher-order effects. These higher-order effects extend the capabilities of algebraic effects, providing greater flexibility for expressing effectful computations, while also shedding light on the connection between the monad approach and the algebraic approach to effects. +

+

+This talk will survey the historical milestones that have shaped the landscape of effectful programming in Haskell, exploring the transition from monads to monad transformers and the emergence of algebraic and higher-order effects.

+
+ +

SESSION: Papers

+

This Is Driving Me Loopy: Efficient Loops in Arrowized Functional Reactive Programs

  • Finnbar Keating
  • Michael B. Gale
+

Arrowized Functional Reactive Programming (AFRP) is one approach to writing reactive programs declaratively, based on the arrows abstraction in Haskell. While AFRP elegantly expresses the relationships between inputs and outputs of a reactive system, na'ive implementations suffer from poor performance. In particular, the loop combinator depends on lazy semantics: this inflicts the overheads of lazy evaluation and simultaneously prevents existing optimisation techniques from being applied to it.

We present a novel program transformation which utilises the Arrow and ArrowLoop laws to transform typical uses of loop into restricted forms that have an execution order that is known at compile-time and therefore can be executed strictly. We evaluate the performance gained from our transformations and prove that the transformations are correct.

+
+ + +

The Essence of Reactivity

  • Ivan Perez
  • Frank Dedden
+

Reactive programming, functional reactive programming, event-based programming, stream programming, and temporal logic all share an underlying commonality: values can vary over time. These languages differ in multiple ways, including the nature of time itself (e.g., continuous or discrete, dense or sparse, implicit or explicit), on how much of the past and future can be referenced, on the kinds of values that can be represented, as well as the mechanisms used to evaluate expressions or formulas. This paper presents a series of abstractions that capture the essence of different forms of time variance. By separating the aspects that differentiate each family of formalisms, we can better express the commonalities and differences between them. We demonstrate our work with a prototype in Haskell that allows us to write programs in terms of a generic interface that can be later instantiated to different abstractions depending on the desired target.

+
+ + +

An Exceptional Actor System (Functional Pearl)

  • Patrick Redmond
  • Lindsey Kuper
+

The Glasgow Haskell Compiler is known for its feature-laden runtime system +(RTS), which includes lightweight threads, asynchronous exceptions, and a +slew of other features. +Their combination is powerful enough that a programmer may +complete the same task in many different ways --- some more advisable than +others. +

+

+We present a user-accessible actor framework hidden in plain sight within +the RTS and demonstrate it on a classic example from the distributed +systems literature. +We then extend both the framework and example to the realm of dynamic +types. +Finally, we raise questions about how RTS features intersect and possibly +subsume one another, and suggest that GHC can guide good practice by +constraining the use of some features.

+
+ + +

Effect Handlers for Programmable Inference

  • Minh Nguyen
  • Roly Perera
  • Meng Wang
  • Steven Ramsay
+

Inference algorithms for probabilistic programming are complex imperative programs with many moving parts. Efficient inference often requires customising an algorithm to a particular probabilistic model or problem, sometimes called inference programming. Most inference frameworks are implemented in languages that lack a disciplined approach to side effects, which can result in monolithic implementations where the structure of the algorithms is obscured and inference programming is hard. Functional programming with typed effects offers a more structured and modular foundation for programmable inference, with monad transformers being the primary structuring mechanism explored to date.

This paper presents an alternative approach to inference programming based on algebraic effects. Using effect signatures to specify the key operations of the algorithms, and effect handlers to modularly interpret those operations for specific variants, we develop two abstract algorithms, or inference patterns, representing two important classes of inference: Metropolis-Hastings and particle filtering. We show how our approach reveals the algorithms’ high-level structure, and makes it easy to tailor and recombine their parts into new variants. We implement the two inference patterns as a Haskell library, and discuss the pros and cons of algebraic effects vis-à-vis monad transformers as a structuring mechanism for modular imperative algorithm design.

+
+ + +

Don’t Go Down the Rabbit Hole: Reprioritizing Enumeration for Property-Based Testing

  • Segev Elazar Mittelman
  • Aviel Resnick
  • Ivan Perez
  • Alwyn E. Goodloe
  • Leonidas Lampropoulos
+

In our implementation, we integrate a state-of-the-art enumeration-based property-based testing framework, LazySearch, with a state-of-the-art combinatorial testing tool, NIST’s ACTS, and demonstrate how it can significantly speed up the effectiveness of testing—up to more than 20× in the case of a prior System F case study from the literature.

+
+ + +

HasTEE: Programming Trusted Execution Environments with Haskell

  • Abhiroop Sarkar
  • Robert Krook
  • Alejandro Russo
  • Koen Claessen
+

Trusted Execution Environments (TEEs) are hardware enforced memory isolation units, emerging as a pivotal security solution for security-critical applications. TEEs, like Intel SGX and ARM TrustZone, allow the isolation of confidential code and data within an untrusted host environment, such as the cloud and IoT. Despite strong security guarantees, TEE adoption has been hindered by an awkward programming model. This model requires manual application partitioning and the use of error-prone, memory-unsafe, and potentially information-leaking low-level C/C++ libraries.

We address the above with HasTEE, a domain-specific language (DSL) embedded in Haskell for programming TEE applications. HasTEE includes a port of the GHC runtime for the Intel-SGX TEE.HasTEE uses Haskell’s type system to automatically partition an application and to enforce Information Flow Control on confidential data. The DSL, being embedded in Haskell, allows for the usage of higher-order functions, monads, and a restricted set of I/O operations to write any standard Haskell application. Contrary to previous work, HasTEE is lightweight, simple, and is provided as a simple security library; thus avoiding any GHC modifications. We show the applicability of HasTEE by implementing case studies on federated learning, an encrypted password wallet, and a differentially-private data clean room.

+
+ + +

Haskell Library for Safer Virtual Machine Introspection (Experience Report)

  • Takato Otsuka
  • Hideya Iwasaki
+

Virtual machine introspection (VMI) is a technique for inspecting a virtual machine +from the outside, typically to analyze the +operating system (guest OS) running on it. +LibVMI is a C library for VMI and provides APIs for accessing +guest OS's memory. +However, in using LibVMI APIs directly in C, the programmer must +compute target addresses in the kernel memory +and then access them with their exact bit widths and types. +This is an enormous burden for the programmer and is prone to introducing +statically undetected but fatal errors. +We create HaVMI, a Haskell library that facilitates VMI programming. +HaVMI provides meta-functions for compile-time +code generation by Template Haskell. +These meta-functions make it easy to write safer VMI programs. +HaVMI uses Haskell language features to detect the programmer's errors +statically.

+
+ + +

falsify: Internal Shrinking Reimagined for Haskell

  • Edsko de Vries
+

In unit testing we apply the function under test to known inputs and check for known outputs. By contrast, in property based testing we state properties relating inputs and outputs, apply the function to random inputs, and verify that the property holds; if not, we found a bug. Randomly generated inputs tend to be large and should therefore be minimised. Traditionally this is done with an explicitly provided shrinker, but in this paper we propose a way to write generators that obsoletes the need to write a separate shrinker. Inspired by the Python library Hypothesis, the approach can work even across monadic bind. Compared to Hypothesis, our approach is more suitable to the Haskell setting: it depends on a minimal set of core principles, and handles generation and shrinking of infinite data structures, including functions.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/tyde23.html b/OpenTOC/tyde23.html new file mode 100644 index 0000000..c2803ac --- /dev/null +++ b/OpenTOC/tyde23.html @@ -0,0 +1,122 @@ +TyDe 2023: Proceedings of the 8th ACM SIGPLAN International Workshop on Type-Driven Development

TyDe 2023: Proceedings of the 8th ACM SIGPLAN International Workshop on Type-Driven Development

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

A Calculus of Inductive Linear Constructions

  • Qiancheng Fu
  • Hongwei Xi
+

In this paper, we present a novel calculus of inductive linear constructions (CILC), combining linear types and dependent types. Our type theory addresses a looming issue in the research on linear dependent types: the lack of a general mechanism for defining sound linear inductive types. CILC allows one to encode in a straightforward manner the linear connectives that must be baked into the core of other systems. This greatly lowers the difficulty of encoding various data structures and makes writing non-trivial programs humanly feasible. We study the standard meta theory of our calculus, showing that it is sound in the usual sense. Through a heap-based operational semantics, we show that CILC safely manipulates resources and runs memory clean. We have formalized and proven correct most of the reported results in the Coq Proof Assistant.

+
+ + +

Semantic Encapsulation using Linking Types

  • Daniel Patterson
  • Andrew Wagner
  • Amal Ahmed
+

Interoperability pervades nearly all mainstream language implementations, as most systems leverage subcomponents written in different languages. And yet, such linking can expose a language to foreign behaviors that are internally inexpressible, which poses a serious threat to safety invariants and programmer reasoning. To preserve such invariants, a language may try to add features to limit the reliance on external libraries, but endless extensions can obscure the core abstractions the language was designed to provide.

In this paper, we outline an approach that encapsulates foreign code in a sound way—i.e., without disturbing the invariants promised by types of the core language. First, one introduces novel linking types that characterize the behaviors of foreign libraries that are inexpressible in the core language. To reason about the soundness of linking, one constructs a realizability model that captures the meaning of both core types and linking types as sets of target-language terms. Using this model, one can formally prove when foreign behavior is encapsulated; that is, unobservable to core code. We show one way to discharge such proofs automatically by augmenting the compiler to insert verified encapsulation wrappers around components that use foreign libraries.

Inspired by existing approaches to FFIs, we develop a pair of case studies that extend a pure, functional language: one extension for state, and another for exceptions. The first allows us to implement mutable references via a library, whereas the second allows us to implement try and catch as library functions. Both extensions and the overall system are proven sound using logical relations that use realizability techniques.

+
+ + +

Infix-Extensible Record Types for Tabular Data

  • Adam Paszke
  • Ningning Xie
+

We present a novel row-polymorphic record calculus, supporting a unique combination of features: scoped labels, first-class labels and rows, and record concatenation. Our work is motivated by the similarity of record types and data table (or data frame) schemas, commonly used in data processing tasks. After presenting our record calculus, we demonstrate its applicability to data frame manipulation by showing that it can be used to successfully assign types to the functions listed in the Brown Benchmark for Tabular Types. Our typing discipline is remarkably lightweight, compared to calculi that require reasoning about type-level constraints when manipulating record types, making it a viable candidate for practical use.

+
+ + +

A Dependently Typed Language with Dynamic Equality

  • Mark Lemay
  • Qiancheng Fu
  • William Blair
  • Cheng Zhang
  • Hongwei Xi
+

Dependent type systems are powerful tools for preventing bugs in programs. +Unlike other formal methods, dependent type systems can reuse the methodology and syntax familiar to functional programmers to construct formal proofs. +However, usability issues, like confusing error messages, often arise from the conservative equalities required by such type theories. +We address this issue by designing a dependently typed language where equality checking is delayed until runtime. +What were once static errors can now be presented to programmers as warnings. +When runtime failures occur, the blame system provides clear error messages indicating the exact static assumption violated during execution. +We present several examples in this system, introduce novel correctness properties, and prove them for a fragment of the language. +Our full system handles dependent indexed data and pattern matching, which are difficult for dependent gradual typing systems to manage. +Finally, we have implemented a prototype of the language.

+
+ + +

Combining Dependency, Grades, and Adjoint Logic

  • Peter Hanukaev
  • Harley Eades III
+

We propose two new dependent type systems. The first, is a dependent +graded/linear type system where a graded dependent type system is +connected via modal operators to a linear type system in the style of +Linear/Non-linear logic. We then generalize this system to support +many graded systems connected by many modal operators through the +introduction of modes from Adjoint Logic. Finally, we prove several +meta-theoretic properties of these two systems including graded +substitution.

+
+ +
\ No newline at end of file diff --git a/_data/OpenTOC.yaml b/_data/OpenTOC.yaml index 28848a9..bc3b4b8 100644 --- a/_data/OpenTOC.yaml +++ b/_data/OpenTOC.yaml @@ -1281,3 +1281,27 @@ event: ExHET year: 2023 title: "Proceedings of the 2nd International Workshop on Extreme Heterogeneity Solutions" +- + event: FUNARCH + year: 2023 + title: "Proceedings of the 1st ACM SIGPLAN International Workshop on Functional Software Architecture" +- + event: FHPNC + year: 2023 + title: "Proceedings of the 11th ACM SIGPLAN International Workshop on Functional High-Performance and Numerical Computing" +- + event: Erlang + year: 2023 + title: "Proceedings of the 22nd ACM SIGPLAN International Workshop on Erlang" +- + event: FARM + year: 2023 + title: "Proceedings of the 11th ACM SIGPLAN International Workshop on Functional Art, Music, Modelling, and Design" +- + event: Haskell + year: 2023 + title: "Proceedings of the 16th ACM SIGPLAN International Haskell Symposium" +- + event: TyDe + year: 2023 + title: "Proceedings of the 8th ACM SIGPLAN International Workshop on Type-Driven Development" From b5fc46a011e839a7a39cf9f16896f2d91a70ff11 Mon Sep 17 00:00:00 2001 From: David Grove Date: Fri, 15 Sep 2023 12:14:16 -0400 Subject: [PATCH 02/64] add SPLASH to main conference list; related small fixes/updates --- Conferences/OOPSLA.md | 6 +++++- Conferences/SPLASH.md | 4 ++-- _data/Conferences.yaml | 20 ++++++++++++++++++-- 3 files changed, 25 insertions(+), 5 deletions(-) diff --git a/Conferences/OOPSLA.md b/Conferences/OOPSLA.md index fdeb1db..7c8ac37 100644 --- a/Conferences/OOPSLA.md +++ b/Conferences/OOPSLA.md @@ -6,13 +6,15 @@ OOPSLA (Object-oriented Programming, Systems, Languages, and Applications) is now part of SPLASH (Systems, Programming, Languages, and Applications: Software for Humanity). +The [SPLASH Steering Committee](/Conferences/SPLASH) serves as the OOPSLA Steering Committee. + The scope of OOPSLA includes all aspects of programming languages and software engineering, broadly construed. Papers that address any aspect of software development are welcome, including requirements, modeling, prototyping, design, implementation, generation, analysis, verification, testing, evaluation, maintenance, reuse, replacement, and retirement of software systems. Papers may address these topics in a variety of ways, including new tools (such as languages, program analyses, and runtime systems), new techniques (such as methodologies, design processes, code organization approaches, and management techniques), and new evaluations (such as formalisms and proofs, corpora analyses, user studies, and surveys). **Most Influential OOPSLA Paper Award** Each year a "Most Influential" OOPSLA paper is chosen and an presentation is made at OOPSLA. More details about this award and -past winning papers can be found [here](/Awards/Conferences/OOPSLA/). SIGPLAN +past winning papers can be found [here](/Awards/OOPSLA/). SIGPLAN also makes several other awards including an "Outstanding Dissertation Award." Please consider making a nomination for one of these awards.  More details about the SIGPLAN awards can be found @@ -21,6 +23,8 @@ these awards.  More details about the SIGPLAN awards can be found Web Pages of Previous Conferences --------------------------------- +* [OOPSLA 2023](https://2023.splashcon.org/track/splash-2023-oopsla) (Lisbon, Portugal) +* [OOPSLA 2022](https://2022.splashcon.org/track/splash-2022-oopsla) (Auckland, New Zealand) * [OOPSLA 2021](https://2021.splashcon.org/track/splash-2021-oopsla) (Chicago, IL) * [OOPSLA 2020](https://2020.splashcon.org/track/splash-2020-oopsla) (virtual) * [OOPSLA 2019](http://2019.splashcon.org/) (Athens, Greece) diff --git a/Conferences/SPLASH.md b/Conferences/SPLASH.md index b53eec0..9de4bde 100644 --- a/Conferences/SPLASH.md +++ b/Conferences/SPLASH.md @@ -2,7 +2,7 @@ layout: default title: "Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH)" --- -SPLASH (Systems, Programming, Languages, and Applications: Software for Humanity) contains several conferences concerned with programming, languages, and software engineering, including [OOPSLA](/Conferences/OOPSLA) (Object-oriented Programming, Systems, Languages, and Applications), [Onward!](/Conferences/Onward), [DLS](/Conferences/DLS) (the Dynamic Languages Symposium), and PLoP (Pattern Languages of Programming). +SPLASH (Systems, Programming, Languages, and Applications: Software for Humanity) contains several conferences concerned with programming, languages, and software engineering, including [OOPSLA](/Conferences/OOPSLA) (Object-oriented Programming, Systems, Languages, and Applications), [Onward!](/Conferences/Onward), [DLS](/Conferences/DLS) (the Dynamic Languages Symposium), and GPCE(Conferences/GPCE). **SPLASH Steering Committee** @@ -28,7 +28,7 @@ in 2020, with the intention of adding one member-at-large each subsequent year. Members-at-large serve 4 year terms and are selected by the Steering Committee. -The constitution of the steering committee changes each year upon conclusion +The membership of the steering committee changes each year upon conclusion of that year's conference. The current SPLASH steering committee is: diff --git a/_data/Conferences.yaml b/_data/Conferences.yaml index 8e75edf..84d6863 100644 --- a/_data/Conferences.yaml +++ b/_data/Conferences.yaml @@ -58,6 +58,22 @@ [SIGARCH](http://www.acm.org/sigs/sigarch/) and [SIGOPS](http://www.sigops.org/). +- + name: Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH) + link: /Conferences/SPLASH + description: | + The ACM SIGPLAN conference on Systems, Programming, Languages, and + Applications: Software for Humanity embraces all aspects of + software construction and delivery, to make it the premier + conference on the applications of programming languages - at the + intersection of programming languages and software engineering. SPLASH is the home of + several SIGPLAN conferences and symposium, including: + - [OOPSLA](/Conferences/OOPSLA) + - [Onward](/Conferences/Onward) + - [DLS](/Conferences/DLS) + - [GPCE](/Conferences/GPCE) + - [SLE](/Conferences/SLE) + - name: Compiler Construction (CC) link: 'https://conf.researchr.org/series/CC' @@ -81,8 +97,8 @@ support. - - name: Dynamic Languages Symposium ([DLS](Conferences/DLS) @ [SPLASH) - link: /Conferences/SPLASH + name: Dynamic Languages Symposium (DLS) + link: /Conferences/DLS description: | The Dynamic Languages Symposium (DLS) is a forum for discussion of dynamic languages, their implementation, and application. From 208ee94153721b2218c75f35577740010f7b809f Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Fri, 15 Sep 2023 17:52:43 -0400 Subject: [PATCH 03/64] Update Conferences/SPLASH.md --- Conferences/SPLASH.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Conferences/SPLASH.md b/Conferences/SPLASH.md index 9de4bde..57ceb87 100644 --- a/Conferences/SPLASH.md +++ b/Conferences/SPLASH.md @@ -2,7 +2,7 @@ layout: default title: "Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH)" --- -SPLASH (Systems, Programming, Languages, and Applications: Software for Humanity) contains several conferences concerned with programming, languages, and software engineering, including [OOPSLA](/Conferences/OOPSLA) (Object-oriented Programming, Systems, Languages, and Applications), [Onward!](/Conferences/Onward), [DLS](/Conferences/DLS) (the Dynamic Languages Symposium), and GPCE(Conferences/GPCE). +SPLASH (Systems, Programming, Languages, and Applications: Software for Humanity) contains several conferences concerned with programming, languages, and software engineering, including [OOPSLA](/Conferences/OOPSLA) (Object-oriented Programming, Systems, Languages, and Applications), [Onward!](/Conferences/Onward), [DLS](/Conferences/DLS) (the Dynamic Languages Symposium), and [GPCE](Conferences/GPCE). **SPLASH Steering Committee** From adb5272c4c5aebd3f55c6ba77c42b03c7e5b2ef6 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Sat, 16 Sep 2023 20:42:18 -0400 Subject: [PATCH 04/64] Announce --- _announce/2023-08-24-real_world_pim.txt | 19 ++ _announce/2023-09-08-sas_2023.txt | 135 ++++++++++ _announce/2023-09-11-oopsla_2024.txt | 332 ++++++++++++++++++++++++ 3 files changed, 486 insertions(+) create mode 100644 _announce/2023-08-24-real_world_pim.txt create mode 100644 _announce/2023-09-08-sas_2023.txt create mode 100644 _announce/2023-09-11-oopsla_2024.txt diff --git a/_announce/2023-08-24-real_world_pim.txt b/_announce/2023-08-24-real_world_pim.txt new file mode 100644 index 0000000..9f83356 --- /dev/null +++ b/_announce/2023-08-24-real_world_pim.txt @@ -0,0 +1,19 @@ +--- +title: "Call for Participation: Real-World PIM Tutorial @ MICRO 2023" +timestamp: "8/24/2023 8:49:11" +start: "10/29/2023" +end: "10/29/2023" +--- +We would like to announce our upcoming tutorial at MICRO 2023 on “Real-world Processing-in-Memory Systems for Modern Workloads”. + +Sunday, October 29 (held during MICRO 2023, Oct 28 – Nov 1, 2023 in Toronto, Canada). + +The Real World PIM tutorial will cover the latest advances in PIM technology, introducing PIM concepts “processing near memory” and “processing using memory”, and give real world examples of both types of systems. We’ll also discuss workload characterization for PIM, and programming and optimizing PIM kernels, with a hands-on lab in the afternoon. We’ll have several invited talks from industry speakers, with additional talks and hands-on PIM session led by Juan Gómez Luna, Onur Mutlu and Ataberk Olgun (ETH Zürich). + +MICRO 2023 Real-World PIM tutorial website & preliminary program (speakers will be confirmed soon!): https://events.safari.ethz.ch/micro-pim-tutorial/ + +Livestream Sunday, October 29 (full day, virtual): https://youtu.be/ohU00NSIxOI + +MICRO 2023 Workshops and Tutorials: https://microarch.org/micro56/program/workshops.php + +Organizers: Juan Gómez Luna, Onur Mutlu, Ataberk Olgun diff --git a/_announce/2023-09-08-sas_2023.txt b/_announce/2023-09-08-sas_2023.txt new file mode 100644 index 0000000..03780b4 --- /dev/null +++ b/_announce/2023-09-08-sas_2023.txt @@ -0,0 +1,135 @@ +--- +title: "SAS 2023 - Call for Participation - Early deadline: Sept 22" +timestamp: "9/8/2023 7:27:04" +start: "10/22/2023" +end: "10/24/2023" +--- + +---------------------------------------------------------------------- + Call for Participation + Early registration deadline: September 22 + + SAS 2023 + The 30th Static Analysis Symposium + Cascais (Lisbon), Portugal, Sun 22 - Tue 24, October 2023 + Colocated with SPLASH 23 + + https://2023.splashcon.org/home/sas-2023 + +---------------------------------------------------------------------- + +Registration is now open for SAS 2023! + +The 30th Static Analysis Symposium (SAS 2023) will be co-located with +SPLASH 2023 in Cascais (Lisbon), Portugal and held on October 22-24. + + +REGISTRATION + +*Early bird registration deadline: September 22* + +Registration to be completed through the SPLASH registration pages; see instructions at: +https://conf.researchr.org/attending/sas-2023/%5Esattending%5EsRegistration +https://2023.splashcon.org/attending/Registration + +INVITED SPEAKERS + +- Loris D'Antoni + Verifying Infinitely Many Programs at Once + +- Bor-Yuh Evan Chang + Goal-Directed Abstract Interpretation and Event-Driven Frameworks + +- Daniel Kästner + Abstract Interpretation in Industry - Experience and Lessons Learned + +- Gagandeep Singh + Building Trust and Safety in Artificial Intelligence + with Abstract Interpretation + + +ACCEPTED PAPERS + +- Mutual Refinements of Context-Free Language Reachability + Shuo Ding and Qirun Zhang +- Modular Optimization-Based Roundoff Error Analysis of Floating-Point Programs + Rosa Abbasi Boroujeni and Eva Darulova +- How fitting is your abstract domain? + Roberto Giacobazzi, Isabella Mastroeni and Elia Perantoni +- BREWasm: A General Static Binary Rewriting Framework for WebAssembly + Shangtong Cao, Ningyu He, Yao Guo and Haoyu Wang +- Scaling up Roundoff Analysis of Functional Data Structure Programs + Anastasia Isychev and Eva Darulova +- Octagons Revisited - Elegant Proofs and Simplified Algorithms + Michael Schwarz and Helmut Seidl +- Error Invariants for Fault Localization via Abstract Interpretation + Aleksandar S. Dimovski +- Symbolic transformation of expressions in modular arithmetic + Jérôme Boillot and Jérôme Feret +- ADCL: Acceleration Driven Clause Learning for Constrained Horn Clauses + Florian Frohn and Jürgen Giesl +- Unconstrained Variable Oracles for Faster Static Analyses + Vincenzo Arceri, Greta Dolcetti and Enea Zaffanella +- Generalized Program Sketching by Abstract Interpretation and Logical Abduction + Aleksandar S. Dimovski +- Domain Precision in Galois Connection-less Abstract Interpretation + Isabella Mastroeni and Michele Pasqua +- A Formal Framework to Measure the Incompleteness of Abstract Interpretations + Marco Campion, Caterina Urban, Mila Dalla Preda and Roberto Giacobazzi +- Error Localization for Sequential Effect Systems + Colin S. Gordon and Chaewon Yun +- Lifting On-Demand Analysis to Higher-Order Languages + Daniel Schoepe, David Seekatz, Ilina Stoilkovska, Sandro Stucki, Daniel + Tattersall, Pauline Bolignano, Franco Raimondi and Bor-Yuh Evan Chang +- A Product of Shape and Sequence Abstractions + Josselin Giet, Félix Ridoux and Xavier Rival +- Quantum Constant Propagation + Yanbin Chen and Yannick Stade +- Polynomial Analysis of Modular Arithmetic + Thomas Seed, Andy King, Neil Evans and Chris Coppins +- Boosting Multi-Neuron Convex Relaxation for Neural Network Verification + Xuezhou Tang, Ye Zheng and Jiaxiang Liu +- Reverse Template Processing using Abstract Interpretation + Matthieu Lemerre +- Mutual Refinements of Context-Free Language Reachability + Shuo Ding and Qirun Zhang +- Modular Optimization-Based Roundoff Error Analysis of Floating-Point Programs + Rosa Abbasi Boroujeni and Eva Darulova +- How fitting is your abstract domain? + Roberto Giacobazzi, Isabella Mastroeni and Elia Perantoni +- BREWasm: A General Static Binary Rewriting Framework for WebAssembly + Shangtong Cao, Ningyu He, Yao Guo and Haoyu Wang +- Scaling up Roundoff Analysis of Functional Data Structure Programs + Anastasia Isychev and Eva Darulova +- Octagons Revisited - Elegant Proofs and Simplified Algorithms + Michael Schwarz and Helmut Seidl +- Error Invariants for Fault Localization via Abstract Interpretation + Aleksandar S. Dimovski +- Symbolic transformation of expressions in modular arithmetic + Jérôme Boillot and Jérôme Feret +- ADCL: Acceleration Driven Clause Learning for Constrained Horn Clauses + Florian Frohn and Jürgen Giesl +- Unconstrained Variable Oracles for Faster Static Analyses + Vincenzo Arceri, Greta Dolcetti and Enea Zaffanella +- Generalized Program Sketching by Abstract Interpretation and Logical Abduction + Aleksandar S. Dimovski +- Domain Precision in Galois Connection-less Abstract Interpretation + Isabella Mastroeni and Michele Pasqua +- A Formal Framework to Measure the Incompleteness of Abstract Interpretations + Marco Campion, Caterina Urban, Mila Dalla Preda and Roberto Giacobazzi +- Error Localization for Sequential Effect Systems + Colin S. Gordon and Chaewon Yun +- Lifting On-Demand Analysis to Higher-Order Languages + Daniel Schoepe, David Seekatz, Ilina Stoilkovska, Sandro Stucki, Daniel + Tattersall, Pauline Bolignano, Franco Raimondi and Bor-Yuh Evan Chang +- A Product of Shape and Sequence Abstractions + Josselin Giet, Félix Ridoux and Xavier Rival +- Quantum Constant Propagation + Yanbin Chen and Yannick Stade +- Polynomial Analysis of Modular Arithmetic + Thomas Seed, Andy King, Neil Evans and Chris Coppins +- Boosting Multi-Neuron Convex Relaxation for Neural Network Verification + Xuezhou Tang, Ye Zheng and Jiaxiang Liu +- Reverse Template Processing using Abstract Interpretation + Matthieu Lemerre + diff --git a/_announce/2023-09-11-oopsla_2024.txt b/_announce/2023-09-11-oopsla_2024.txt new file mode 100644 index 0000000..ae8cfb7 --- /dev/null +++ b/_announce/2023-09-11-oopsla_2024.txt @@ -0,0 +1,332 @@ +--- +title: "Call for Papers, The Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA 2024)" +timestamp: "9/11/2023 18:47:59" +deadline: "10/20/2023" +--- +======================================================================== + PACMPL Issue OOPSLA 2024 + + Call for Papers + + OOPSLA 2024 will be held as part of +The ACM Conference on Systems, Programming, Languages, and Applications: + Software for Humanity (SPLASH'24) + + October 20-25, 2024, Pasadena, California, United States + + https://2024.splashcon.org/track/splash-2024-oopsla +======================================================================== + +### Important dates + +#### ROUND 1: +Submission Deadline: Fri Oct 20, 2023 +Author Response: Mon Dec 11 - Wed Dec 13, 2023 +Author Notification: Fri Dec 22, 2023 +Artifact Submission: Fri Jan 5, 2024 +Artifact kick-tires: Sat Jan 6 - Fri Jan 19, 2024 +Submission of Revisions: Sun Feb 11, 2024 +Author Notification of Revisions: Sat Feb 24, 2024 +Artifact Notification: Fri Mar 1, 2024 +Camera Ready: Fri Mar 8, 2024 + +#### ROUND 2: +Submission Deadline: Fri Apr 5, 2024 +Author Response: Mon Jun 3 - Wed Jun 5, 2024 +Author Notification: Fri Jun 21, 2024 +Artifact Submission: Fri Jul 5, 2024 +Artifact kick-tires: Sat Jul 6 - Fri Jul 19, 2024 +Submission of Revisions: Sun Aug 4, 2024 +Author Notification of Revisions: Sun Aug 18, 2024 +Artifact Notification: Fri Aug 23, 2024 +Camera Ready: Sun Sep 1, 2024 + + +Papers accepted at either of the rounds will be published in the 2024 +volume of PACMPL(OOPSLA) and invited to be presented at the SPLASH +conference in October 2024. + +### Scope + +The OOPSLA issue of the Proceedings of the ACM on Programming Languages +(PACMPL) welcomes papers focusing on all practical and theoretical +investigations of programming languages, systems and environments. +Papers may target any stage of software development, including +requirements, modelling, prototyping, design, implementation, +generation, analysis, verification, testing, evaluation, maintenance, +and reuse of software systems. Contributions may include the +development of new tools, techniques, principles, and evaluations. + +#### Review Process + +PACMPL(OOPSLA) has two rounds of reviewing with submission deadlines +around October and April each year. As you submit your paper you will +receive around three reviews and an opportunity to provide an author +response that will be read and addressed by the reviewers in the final +decision outcome summary. There are 5 possible outcomes at the end of +the round: + +*Accept*: Your paper will appear in the upcoming volume of PACMPL +(OOPSLA). + +*Conditional Accept*: You will receive a list of required revisions +that you will need to address. You must submit a revised paper, a clear +explanation of how your revision addresses these comments, and +"if possible" a diff of the PDF as supplementary material. Assuming +you meet the listed requirements, after further review by the same +reviewers, your paper will very likely be accepted. This process +*has to be completed within two months of the initial decision* for the +paper to be accepted, so we encourage timely turnaround in case +revisions take more than one cycle to be accepted. + +*Minor Revision*: The reviewers have concerns that go beyond what can +be enumerated in a list. Therefore, while you may receive a list of +revisions suggested by the reviewers, this will not necessarily be +comprehensive. You will have the opportunity to resubmit your revised +paper and have it re-reviewed by the same reviewers, which may or may +not result in your paper's acceptance. When you resubmit, you should +clearly explain how the revisions address the comments of the +reviewers, by including a document describing the changes and "if +possible" a diff of the PDF as supplementary material. This process +*has to be completed within two months of the initial decision* for the +paper to be accepted in the current round, so we encourage timely +turnaround in case revisions take more than one cycle to be accepted. + +*Major Revision*: You will receive a list of revisions suggested by the +reviewers. Papers in this category are *invited to submit a revision +to the next round of submissions* with a specific set of expectations +to be met. When you resubmit, you should clearly explain how the +revisions address the comments of the reviewers, by including a +document describing the changes and "if possible" a diff of the PDF as +supplementary material. The revised paper will be re-evaluated in the +next round. Resubmitted papers will retain the same reviewers +throughout the process to the extent possible. + +*Reject*: Rejected papers will not be included in the upcoming volume +of PACMPL(OOPSLA). Papers in this category are not guaranteed a review +if resubmitted less than one year from the date of the original +submission. A paper will be judged to be a resubmission if it is +substantially similar to the original submission. The Chairs will +decide whether or not a paper is a resubmission of the same work. + +### Submissions + +Submitted papers must be at most **23 pages** in 10 point font. There +is no page limit on references. No appendices are allowed on the main +paper, instead authors can upload supplementary material with no page +or content restrictions, but reviewers may choose to ignore it. +Submissions must adhere to the "ACM Small" template available from +[the ACM](http://www.acm.org/publications/authors/submissions). Papers +are expected to use author-year citations. Author-year citations may be +used as either a noun phrase, such as "The lambda calculus was +originally conceived by Church (1932)", or a parenthetic phase, such +as "The lambda calculus (Church 1932) was intended as a foundation for +mathematics". + +PACMPL uses double-blind reviewing. Authors' identities are only +revealed if a paper is accepted. Papers must + +1. omit author names and institutions, +2. use the third person when referencing your work, +3. anonymise supplementary material. + +Nothing should be done in the name of anonymity that weakens the +submission; see the DBR FAQ. When in doubt, contact the Review +Committee Chairs. + +Papers must describe unpublished work that is not currently submitted +for publication elsewhere as described by [SIGPLAN's Republication +Policy](http://www.sigplan.org/Resources/Policies/Republication). +Submitters should also be aware of [ACM's Policy and Procedures on +Plagiarism](http://www.acm.org/publications/policies/plagiarism_policy). +Submissions are expected to comply with the [ACM Policies for +Authorship](https://www.acm.org/publications/authors/information-for-authors). + +#### Artifacts + +Authors should indicate with their initial submission if an artifact +exists, describe its nature and limitations, and indicate if it will +be submitted for evaluation. Accepted papers that fail to provide an +artifact will be requested to explain the reason they cannot support +replication. It is understood that some papers have no artifacts. +Please note that the artifact submission deadline will be following +closely the paper submission deadline so make sure you check the +Artifact Call as soon as you submit your paper to PACMPL(OOPSLA). + +##### Data-Availability Statement + +To help readers find data and software, OOPSLA recommends adding a +section just before the references titled Data-Availability Statement. +If the paper has an artifact, cite it here. If there is no artifact, +this section can explain how to obtain relevant code. The statement +does not count toward the OOPSLA 2024 page limit. It may be included +in the submitted paper; in fact we encourage this, even if the DOI is +not ready yet. + +Example: + +\section{Conclusion} +.... + +\section*{Data-Availability Statement} +The software that supports~\cref{s:design,s:evaluation} +is available on Software Heritage~\cite{artifact-swh} +and Zenodo~\cite{artifact-doi}. + +\begin{acks} +.... + +#### Expert PC Members + +During the submission, we will ask you to list up to 3 non-conflicted +PC members who you think are experts on the topic of this submission, +starting with the most expert. This list will not be used as an input +during the paper assignment and it will not be visible to the PC. It +may be used by the PC Chair and Associate Chairs for advice on +external experts if the paper lacks expert reviews. + +### Publication + +PACMPL is a Gold Open Access journal, all papers will be freely +available to the public. Authors can voluntarily cover the article +processing charge ($400 USD), but payment is not required. The +official publication date is the date the journal is made available in +the ACM Digital Library. The journal issue and associated papers may +be published up to two weeks prior to the first day of the conference. +The official publication date affects the deadline for any patent +filings related to published work. + +By submitting your article to an ACM Publication, you are +acknowledging that you and your co-authors are subject to all [ACM +Publications Policies](https://www.acm.org/publications/policies), +including ACM’s [new Publications Policy on Research Involving Human +Participants and Subjects](https://www.acm.org/publications/policies/research-involving-human-participants-and-subjects). +Alleged violations of this policy or an ACM Publications Policy will +be investigated by ACM and may result in a full retraction of your +paper, in addition to other potential penalties, as per ACM +Publications Policy. + +Please ensure that you and your co-authors obtain [an ORCID ID](https://orcid.org/register), +so you can complete the publishing process for your accepted paper. +ACM has been involved in ORCID from the start and we have recently +made a [commitment to collect ORCID IDs from all of our published +authors](https://authors.acm.org/author-resources/orcid-faqs). +We are committed to improving author discoverability, ensuring proper +attribution and contributing to ongoing community efforts around name +normalization; your ORCID ID will help in these efforts. + +The ACM Publications Board has recently updated the ACM Authorship +Policy in several ways: + +- Addressing the use of generative AI systems in the publications +process +- Clarifying criteria for authorship and the responsibilities of +authors +- Defining prohibited behaviour, such as gift, ghost, or purchased +authorship +- Providing a linked FAQ explaining the rationale for the policy and +providing additional details + +You can find the updated policy here: + +[https://www.acm.org/publications/policies/new-acm-policy-on-authorship](https://www.acm.org/publications/policies/new-acm-policy-on-authorship) + +##### Review Committee + +Review Committee Chairs: + +Alex Potanin, Australian National University, Australia +Bor-Yuh Evan Chang, University of Colorado Boulder, USA + +Review Committee Associate Chairs: + +Anders Møller, Aahrus University, Denmark +Lingming Zhang, UIUC, USA + +Review Committee: + +Aleksandar Nanevski, IMDEA Software Institute, Spain +Alex Summers, University of British Columbia, Canada +Alexandra Bugariu, ETH Zurich, Switzerland +Ana Milanova, Rensselaer Polytechnic Institute, USA +Andreas Zeller, CISPA Helmholtz Center for Information Security, Germany +Anitha Gollamudi, UMass, USA +Ankush Desai, AWS, USA +Ashish Tiwari, Microsoft Research, USA +Ben Hermann, TU Dortmund, Germany +Ben Titzer, CMU, USA +Benjamin Delaware, Purdue University, USA +Bernardo Toninho, Universidade Nova de Lisboa, Portugal +Bruno C. d. S. Oliveira, U. Hong Kong, Hong Kong +Burcu Kulahcioglu Ozkan, Delft University of Technology, The Netherlands +Casper Bach Poulsen, Delft University of Technology, Netherlands +Colin Gordon, Drexel University, USA +Corina Pasarenau, NASA, USA +Cyrus Omar, University of Michigan, USA +Damien Zufferey, Sonar Source, Switzerland +Dana Drachsler Cohen, Technion, Israel +David Darais, Galois, USA +David Pearce, ConsenSys, New Zealand +Di Wang, Peking University, China +Emma Söderberg, Lund University, Sweden +Emma Tosch, Northeastern University, USA +Fabian Muehlboeck, Australian National University, Australia +Fei He, Tsinghua University, China +Filip Niksic, Google, USA +Fredrik Kjolstad, Stanford University, USA +Guido Salvaneschi, University of St. Gallen, Switzerland +Hila Peleg, Technion, Israel +Jiasi Shen, The Hong Kong University of Science and Technology, China (Hong Kong) +Jonathan Bell, Northeastern University, USA +Jonathan Brachthäuser, University of Tübingen, Germany +Joseph Tassarotti, New York University, USA +Justin Hsu, Cornell University, USA +Karine Even-Mendoza, King's College London, UK +Kenji Maillard, Inria Rennes, France +Matthew Flatt, U. Utah, USA +Matthew Parkinson, Microsoft, UK +Max Schaefer, GitHub, UK +Michael Coblenz, UCSD, USA +Milos Gligoric, UT Austin, USA +Minseok Jeon, Korea University, Korea +Mohamed Faouzi Atig, Uppsala University, Sweden +Owolabi Legunsen, Cornell University, USA +Pamela Zave, AT&T Laboratories, USA +Pavel Panchekha, University of Utah, USA +Rahul Gopinath, University of Sydney, Australia +Rajiv Gupta, UC Riverside, USA +Saman Amarasinghe, MIT, USA +Santosh Pande, Georgia Institute of Technology, USA +Sean Treichler, NVIDIA, USA +Shachar Itzhaky, Technion, Israel +Shaz Qadeer, Facebook, USA +Sheng Chen, University of Louisiana at Lafayette, USA +Shigeru Chiba, University of Tokyo, Japan +Shriram Krishnamurthi, Brown University, USA +Sreepathi Pai, University of Rochester, USA +Stefan Brunthaler, University of the Federal Armed Forces in Munchen, Germany +Steve Blackburn, Google, Australia +Subhajit Roy, IIT Kanpur, India +Sukyoung Ryu, KAIST, Korea +Swarnendu Biswas, IIT Kanpur, India +Thanh Vu Nguyen, George Mason University, USA +Tiark Rompf, Purdue, USA +Tien Nguyen, University of Texas at Dallas, USA +Tomas Petricek, Charles University, Czech Republic +Umut Acar, CMU, USA +Wei Le, Iowa State, USA +Wei Zhang , Meta, USA +Xiaokang Qiu, Purdue University, USA +Yingfei Xiong, Peking University, China +Yizhou Zhang, University of Waterloo, Canada +Youyou Cong, Tokyo Institute of Technology, Japan +Yu David Liu, Binghamton, USA +Yu Feng, UCSB, USA +Yuepeng Wang, Simon Fraser University, Canada + +##### Artifact Evaluation Committee + +Artifact Evaluation Committee Chairs: + +Guillaume Baudart, Inria - École normale supérieure, France +Sankha Narayan Guria, University of Kansas, USA From 732b2e9763101a1e0ea5297ccde7b041ff73f803 Mon Sep 17 00:00:00 2001 From: Nadia Polikarpova Date: Sun, 1 Oct 2023 17:38:32 -0700 Subject: [PATCH 05/64] Add Satnam Singh to mentor list --- LongTermMentoring.md | 1 + 1 file changed, 1 insertion(+) diff --git a/LongTermMentoring.md b/LongTermMentoring.md index b047c4e..b187f4e 100644 --- a/LongTermMentoring.md +++ b/LongTermMentoring.md @@ -110,6 +110,7 @@ We'd like to thank these amazing mentors: - Sukyoung Ryu - Roopsha Samanta - Mike Samuel +- Satnam Singh - Gus Smith - Caleb Stanford - Kathrin Stark From 6406f11a1d7976893d6038269ee82e014b0710e6 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Thu, 12 Oct 2023 11:55:19 -0400 Subject: [PATCH 06/64] Announcements --- _announce/2023-10-03-icsr_2024.txt | 110 +++++++++++++++++++++++++++++ _announce/2023-10-03-pldi_2024.txt | 68 ++++++++++++++++++ 2 files changed, 178 insertions(+) create mode 100644 _announce/2023-10-03-icsr_2024.txt create mode 100644 _announce/2023-10-03-pldi_2024.txt diff --git a/_announce/2023-10-03-icsr_2024.txt b/_announce/2023-10-03-icsr_2024.txt new file mode 100644 index 0000000..abcde96 --- /dev/null +++ b/_announce/2023-10-03-icsr_2024.txt @@ -0,0 +1,110 @@ +--- +title: "21st International Conference on Software and Systems Reuse" +timestamp: "10/3/2023 9:15:36" +deadline: "2/12/2024" +--- +*** Call for Papers *** + +21st International Conference on Software and Systems Reuse (ICSR 2024) + +June 10-12, 2024, 5* St. Raphael Resort and Marina, Limassol, Cyprus + +https://cyprusconferences.org/icsr2024/ + +(*** Submission Deadline: February 12, 2024 AoE ***) + + +The International Conference on Software and Systems Reuse (ICSR) is a biannual conference +in the field of software reuse research and technology. ICSR is a premier event aiming to +present the most recent advances and breakthroughs in the area of software reuse and to +promote an intensive and continuous exchange among researchers and practitioners. + +The guiding theme of this edition is Sustainable Software Reuse. + +We invite submissions on new and innovative research results and industrial experience +reports dealing with all aspects of software reuse within the context of the modern software +development landscape. Topics include but are not limited to the following. + +1 Technical aspects of reuse, including +• Reuse in/for Quality Assurance (QA) techniques, testing, verification, etc. +• Domain ontologies and Model-Driven Development +• Variability management and software product lines +• Context-aware and Dynamic Reuse +• Reuse in and for Machine Learning +• Domain-specific languages (DSLs) +• New language abstractions for software reuse +• Generative Development +• COTS-based development and reuse of open source assets +• Retrieval and recommendation of reusable assets +• Reuse of non-code artefacts +• Architecture-centric reuse approaches +• Service-oriented architectures and microservices +• Software composition and modularization +• Sustainability and software reuse +• Economic models of reuse +• Benefit and risk analysis, scoping +• Legal and managerial aspects of reuse +• Reuse adoption and transition to software reuse +• Lightweight reuse approaches +• Reuse in agile projects +• Technical debt and software reuse + +2 Software reuse in industry and in emerging domains +• Reuse success stories +• Reuse failures, and lessons learned +• Reuse obstacles and success factors +• Return on Investment (ROI) studies +• Reuse in hot topic domains (Artificial Intelligence, Internet of Things, Virtualization, +Network functions, Quantum Computing, etc.) + +We welcome research (16 pages) and industry papers (12 pages) following the Springer +Lecture Notes in Computer Science format. Submissions will be handled via +EasyChair (https://easychair.org/my/conference?conf=icsr2024). Submissions will be +**double-blindly** reviewed, meaning that authors should: +• Omit all authors’ names and affiliations from the title page +• Do not include the acknowledgement section, if you have any, in the submitted paper +• Refer to your own work in the third person +• Use anonymous GitHub, Zenondo, FigShare or equivalent to provide access to artefacts +without disclosing your identity + +Both research and industry papers will be reviewed by members of the same program +committee (check the website for details). Proceedings will be published by Springer in +their Lecture Notes for Computer Science (LNCS) series. An award will be given to the best +research and the best industry papers. + +The authors of selected papers from the conference will be invited to submit an extended +version (containing at least 30% new material) to a special issue in the Journal of Systems and +Software (Elsevier). More details will follow. + +  +IMPORTANT DATES + +• Abstract submission: February 12, 2024, AoE +• Full paper submission: February 19, 2024, AoE +• Notification: April 8, 2024, AoE +• Camera Ready: April 22, 2024, AoE +• Author Registration: April 22, 2024 AoE + + +ORGANISATION + +Steering Committee +• Eduardo Almeida, Federal University of Bahia, Brazil +• Goetz Botterweck,  Lero, University of Limerick, Ireland +• Rafael Capilla Sevilla, Universidad Rey Juan Carlos, Spain +• John Favaro, Trust-IT, Italy +• William B. Frakes, IEEE TCSE committee on software reuse, USA +• Martin L. Griss, Carnegie Mellon University, USA +• Oliver Hummel, University of Applied Sciences, Germany +• Hafedh Mili, Université du Québec à Montréal, Canada +• Nan Niu, University of Cincinnati, USA +• George Angelos Papadopoulos, University of Cyprus, Cyprus +• Claudia M.L. Werner, Federal University of Rio de Janeiro, Brazil + +General Chair +• George A. Papadopoulos, University of Cyprus, Cyprus + +Program Co-Chairs +• Achilleas Achilleos, Frederick University, Cyprus +• Lidia Fuentes, University of Malaga, Spain + diff --git a/_announce/2023-10-03-pldi_2024.txt b/_announce/2023-10-03-pldi_2024.txt new file mode 100644 index 0000000..9055791 --- /dev/null +++ b/_announce/2023-10-03-pldi_2024.txt @@ -0,0 +1,68 @@ +--- +title: "Call for Papers, ACM Conference on Programming Language Design and Implementation (PLDI 2024)" +timestamp: "10/3/2023 17:03:07" +deadline: "11/16/2023" +--- + +*Call for Papers* +==================== +2024 ACM Conference on Programming Language Design and Implementation (PLDI) +Wed 26 - Fri 28 June 2024 +Copenhagen, Denmark +https://pldi24.sigplan.org/track/pldi-2024-papers#Call-for-Papers + +PACMPL Issue PLDI 2024 seeks contributions on all aspects of programming +languages research, broadly construed, including design, implementation, theory, +applications, and performance. Authors of papers published in PACMPL Issue PLDI +2024 will be invited – but not required – to present their work in the PLDI +conference in June 2024, which is sponsored by ACM SIGPLAN. + +*Important Dates* +=============== +Thu 16 Nov 2023, Submission Deadline +Tue 6 Feb - Thu 8 Feb 2024, Author Response +Mon 26 Feb 2024, Author Notification + +*Author Instructions* +================== +https://pldi24.sigplan.org/track/pldi-2024-papers#Call-for-Papers + +Submission site: https://pldi2024.hotcrp.com/ + +*Organizing Committee* +==================== +- General Chair: Milind Kulkarni, Purdue U. +- Program Chair: John Regehr, U. of Utah +- Web Co-Chairs: + - Jedidiah McClurg, Colorado State U. + - Xinyu Wang, U. of Michigan +- Publicity Co-Chairs: + - Anders Miltner, Simon Fraser U. + - Yao Li, Portland State U. +- Sponsorship Co-Chairs: + - Deian Stefan, U. of California at San Diego + - Fredrik Kjolstad, Stanford U. +- Workshops Co-Chairs: + - Zachary Tatlock, U. of Washington + - Clément Pit-Claudel, EPFL +- Student Research Competition Co-Chairs: + - Chandrakana Nandi, Certora + - Rachit Nigam, Cornell U. +- Artifact Evaluation Co-Chairs: + - Manuel Rigger, National U. of Singapore + - Ningning Xie, U. of Toronto +- Diversity and Inclusion Co-Chairs: + - Fernando Magno Quintão Pereira, Federal U. of Minas Gerais + - Mae Milano, Princeton U. +- Social Events Chair: + - Alex Renda, Massachusetts Institute of Technology +- Video Chair: + - Zixian Cai, Australia National U. + - John Hui, Columbia U. +- Volunteers Co-Chairs: + - Hanneli Tavante, McGill U. + - Michael James, U. of California at San Diego + - Hongyu Chen, U. of California at Irvine + +https://pldi24.sigplan.org/committee/pldi-2024-organizing-committee + From 91e151258ab8001f39ed88093865fdbdc7105e21 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Fri, 20 Oct 2023 10:15:04 -0400 Subject: [PATCH 07/64] TOC --- OpenTOC/dls23.html | 155 +++++++++++++++++ OpenTOC/ftscs23.html | 115 +++++++++++++ OpenTOC/gpce23.html | 180 ++++++++++++++++++++ OpenTOC/mplr23.html | 361 ++++++++++++++++++++++++++++++++++++++++ OpenTOC/onward23.html | 232 ++++++++++++++++++++++++++ OpenTOC/paint23.html | 149 +++++++++++++++++ OpenTOC/rebls23.html | 116 +++++++++++++ OpenTOC/sle23.html | 202 ++++++++++++++++++++++ OpenTOC/splash-e23.html | 138 +++++++++++++++ OpenTOC/splash23.html | 267 +++++++++++++++++++++++++++++ OpenTOC/vmil23.html | 203 ++++++++++++++++++++++ _data/OpenTOC.yaml | 44 +++++ 12 files changed, 2162 insertions(+) create mode 100644 OpenTOC/dls23.html create mode 100644 OpenTOC/ftscs23.html create mode 100644 OpenTOC/gpce23.html create mode 100644 OpenTOC/mplr23.html create mode 100644 OpenTOC/onward23.html create mode 100644 OpenTOC/paint23.html create mode 100644 OpenTOC/rebls23.html create mode 100644 OpenTOC/sle23.html create mode 100644 OpenTOC/splash-e23.html create mode 100644 OpenTOC/splash23.html create mode 100644 OpenTOC/vmil23.html diff --git a/OpenTOC/dls23.html b/OpenTOC/dls23.html new file mode 100644 index 0000000..015e341 --- /dev/null +++ b/OpenTOC/dls23.html @@ -0,0 +1,155 @@ +DLS 2023: Proceedings of the 19th ACM SIGPLAN International Symposium on Dynamic Languages

DLS 2023: Proceedings of the 19th ACM SIGPLAN International Symposium on Dynamic Languages

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

All Languages Are Dynamic (Invited Talk)

  • James Noble
+

Virtual Machines, Dynamic Compllers, and Implementation Frameworks make dynamic langauges easier and more efficient to optimize. Meanwhile, IDEs, provers, dependent types, type inferencers, and (so-called) “generative AI” mean programmers can express - statically - more information about the dynamic behaviour of their programs. Component libraries in these languages will come with assertions and proofs of their behaviour, and their advocates fantasise about transforming programming into the composition of dependently-typed higher-order yoneda morphisms, ensuring programs are correct-by-construction (where that construction is carried out by yet more generative AI). +In this talk, I’ll speculate about what the resulting world will be like for programmers. Rather than a static world of platonic mathematical abstractions, I argue that the opposite will be true: that all languages will be dynamic.

+
+ + +

Are We Heading towards a Dynamic Language Winter? (Invited Talk)

  • Maxime Chevalier-Boisvert
+

Though the 2010s saw many research publications about languages such as JavaScript and Python, there currently appears to be a general loss of interest in dynamic languages, with popular new languages such as Rust and Zig being statically typed, and AOT compilation often being viewed as a preferable option to JIT compilation. There is a legitimate question as to whether we are headed towards, or already in, a dynamic language “winter”, with reduced interest from industry and reduced access to funding for dynamic language research. However, despite this, many of the most popular languages (Python, JS, Julia, etc.) are still dynamically typed. In this talk, we discuss questions such as potential causes for a dynamic language winter, what makes statically typed languages so attractive at this time, the major strengths of dynamic languages that could help turn the tide, and what may come after.

+
+ + +

Is Polyglot Programming Really a Thing? (Invited Talk)

  • Walter Cazzola
+

Polyglot programming is the practice of writing an application with multiple languages to capture additional functionality and efficiency not available to a single language. This happens more often than people think. Some reasons are: to support different platforms (e.g., Android, iOS), to be more efficient on some parts, to take advantage of features unique to a different ecosystem (e.g., dedicated APIs). But are we ready for polyglot programming? This talk will try to explore the open issues from the point of view of both the multiple programming language integration and from the software engineering development for polyglot programming.

+
+ + +

JITs Are Nice, but Why Aren’t We Using Them? (Invited Talk)

  • Kevin Menard
+

Dynamic languages have evolved quite a bit over the past few decades. While there’s always room for improvement, the current generation of languages have rich semantics and expressive syntax, making for a pleasant developer experience. Developers can clearly represent ideas, decreasing the maintenance burden while supporting rapid development. Dynamic languages such as Python, Ruby, JavaScript, PHP, and Lua power a substantial portion of web applications and services today. However, diminishing returns in terms of single-core performance and memory bandwidth improvements combined with the limited computational resources available in budget-minded cloud computing have +highlighted the inefficiencies of language interpreters. To remain relevant in the decades to come, dynamic language VMs must make a concerted effort to reduce overhead and make effective use of performance features made available by the underlying platform. Dynamic optimization through JIT compilation has proven to be an effective mechanism for improving dynamic language performance, but building and maintaining a JIT compiler is an expensive undertaking. Meta-compilation promises to reduce those costs, but incurs other costs that hamper adoption in industry. Through the lens of a company deploying thousands of Ruby projects into production, we assess the limitations of current VMs, highlight the most impactful advancements, and consider what’s most important for the coming decades.

+
+ + +

Keeping the asm in Wasm: Running High-Level Languages on a Low-Level VM (Invited Talk)

  • Andreas Rossberg
+

WebAssembly (Wasm) is a virtual machine whose defining characteristic is that it is low-level: Wasm is designed to abstract the hardware below, not language concepts above. This is a prerequisite for providing predictable performance and for avoiding language bias without feature creep. At the same time, it is a hard requirement that Wasm is safe and portable, which sometimes necessitates raising its abstraction level above the raw metal. Yet ultimately, the intention is that language runtimes are largely implemented _on top_ of Wasm, in Wasm itself. +

+

+Dynamic languages pose a challenge for this model, because achieving acceptable performance for them often requires every dirty trick from the books. Not all of these techniques are easily ported to Wasm with some of its abstractions, or they incur higher cost because a Wasm engine cannot know or trust invariants in the higher-level runtime and may need to perform redundant checks to maintain its own safety. In particular, Wasm will need to supply additional mechanisms to efficiently support techniques like jit compilation or inline caches.

+
+ + +

Language Runtimes for the New Cloud Era (Invited Talk)

  • Rodrigo Bruno
+

Programming languages offer a number of abstractions such as dynamic typing, sandboxing, and automatic garbage collection which, however, come at a performance cost. Looking back, the most influential programming languages were proposed at a time when Moore’s Law was still in place. +Nowadays, post-Moore’s law, scalability, and elasticity become crucial requirements, leading to an increasing tension between programming language design and implementation, and performance. It is now time to discuss the impact of programming languages and language runtimes in the context of scalable and elastic cloud computing platforms with the goal of forecasting their role in the new cloud era.

+
+ + +

Programming Languages for AI Programing Agents (Invited Talk)

  • Mark Marron
+

Over the past decade software development has shifted from a process centered around writing code to a process that increasingly involves composition of external packages and managing the integration of code from other team members. The next decade-plus will be defined by the shift from a process where humans are the central developers of code into one where AI agents, likely Large Language Model (LLM) based, will be the major creators of code and humans will shift to a supervisory role as curators, integrating rich framework-functionality and code developed by AI programming agents. +

+

+In this new world we must ask ourselves – are programming languages as they exist today fit for purpose and how do they evolve to meet the needs of this future programming model. This talk represents an opinionated take on the question and attempts to outline specific areas of investigation that need to be addressed by the PL community as part of this journey including: +

+

+What programming language features help/hinder AI agents when understanding and generating code? +

+

+What programming language features help/hinder human agents when working with an AI Copilot? +

+

+What programming language tools are needed to empower AI agents in creating grounded and reliable outputs? +

+

+How can intents be expressed as part of the program representation – examples, constraints, natural language, external documents? +

+

+How do we empower end-users as part of this transformation? +

+

+What programming language features are needed to support new AI driven workflows – live coding, interactive requirement gathering, AI TDD? +

+

+Effectively answering these questions plays a key role in determining if AI driven programming represents a revolution in how software is developed or is limited to being a programming productivity aid for existing development workflows. As such our community should play a central role in understanding this space and leading in the development of this technological transformation!

+
+ + +

The Bright Future of Debuggers: Challenges and Opportunities (Invited Talk)

  • Christophe Scholliers
+

Since the first bug was discovered in the Mark Harvard II electromechanical computer it was clear that finding bugs and debugging of computer systems would be an extremely challenging task. Today, various reports indicated that programmers spend approximately 50% of their time on debugging related tasks resulting in an annual cost of $312 billion. Given these astronomical amounts of resources being put into debugging, any technique that improves debugging efficiency is tremendously valuable. +

+

+In the last decades various new debugging techniques have been put forward to ease debugging and finding the root cause of a failures. Techniques like record-replay, deltadebugging, model checking, tracing, visualisation, fuzzing, automated debugging, and many more help programmers to be more effective while debugging. Recently, we have seen that some of techniques are slowly finding their way into mainstream debugging practices. In this talk we first give an overview of recent exiting debugging techniques, show their advantages and limitations to then reflect on the challenges and opportunities for further research.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/ftscs23.html b/OpenTOC/ftscs23.html new file mode 100644 index 0000000..6454972 --- /dev/null +++ b/OpenTOC/ftscs23.html @@ -0,0 +1,115 @@ +FTSCS 2023: Proceedings of the 9th ACM SIGPLAN International Workshop on Formal Techniques for Safety-Critical Systems

FTSCS 2023: Proceedings of the 9th ACM SIGPLAN International Workshop on Formal Techniques for Safety-Critical Systems

+ Full Citation in the ACM Digital Library +

SESSION: Invited Talk

+

Bounded STL Model Checking for Hybrid Systems (Invited Talk)

  • Kyungmin Bae
+

Signal temporal logic (STL) is a temporal logic formalism for specifying properties of continuous signals. STL has been widely used for specifying, monitoring, and testing properties of hybrid systems that exhibit both discrete and continuous behavior. However, model checking techniques for hybrid systems have been primarily limited to invariant and reachability properties. This is mainly due to the intrinsic nature of hybrid systems, which involve uncountably many signals that continuously change over time. For hybrid systems, checking whether all possible behaviors satisfy an STL formula requires a certain form of abstraction and discretization, which has not been developed for general STL properties. +

+

+In this talk, I introduce bounded model checking algorithms and tools for general STL properties of hybrid systems. Central to our technique is a novel logical foundation for STL: (i) a syntactic separation of STL, which decomposes an STL formula into components, with each component relying exclusively on separate segments of a signal, and (ii) a signal discretization, which ensures a complete abstraction of a signal, given by a set of discrete elements. With this new foundation, the STL model checking problem can be reduced to the satisfiability of a first-order logic formula. This allows us to develop the first model checking algorithm for STL that can guarantee the correctness of STL up to given bound parameters, and a pioneering bounded model checker for hybrid systems, called STLmc.

+
+ +

SESSION: Papers

+

Formal Verification of a Mechanical Ventilator using UPPAAL

  • Jaime Cuartas
  • David Cortés
  • Joan S. Betancourt
  • Jesús Aranda
  • José I. García
  • Andrés M. Valencia
  • James Ortiz
+

Mechanical ventilators are increasingly used for life support of critically ill patients. In this sense, despite recent technological advances, the accurate specification of their properties remains challenging, and the use of formal tools is limited. This work focuses on verifying the properties of the architecture of a mechanical ventilator using UPPAAL as a modeling tool. As a result, the system requirements and specification of a functional prototype were verified and improved using the formal model of a mechanical ventilator. This approach provides a valuable means of ensuring the correctness and reliability of mechanical ventilator systems.

+
+ + +

Symbolic Analysis by Using Folding Narrowing with Irreducibility and SMT Constraints

  • Santiago Escobar
  • Raúl López-Rueda
  • Julia Sapiña
+

Symbolic reachability analysis using rewriting with Satisfiability Modulo Theories (SMT) has been used to model different systems, including a variety of security protocols. Recently, it has also been used to analyze systems modeled using Parametric Timed Automata (PTAs). These techniques are based on reachability in a finite state graph generated from symbolic initial states where each generated state is constrained by an SMT expression checked for satisfiability. In this work, by rewriting with SMT but by narrowing with SMT. we use narrowing with SMT instead of rewriting with SMT. Narrowing with SMT allows a greater generalization, since (i) an infinite number of initial states may be represented by a finite number of states with variables, not only SMT variables, and (ii) an infinite state graph from an initial state may be represented by a finite state graph from another initial state with variables, not only SMT variables. We use graph search pruning techniques via irreducible terms and SMT constraints on conditional rules. This is supported by a novel folding SMT narrowing technique to represent infinite computations in a finite way. Additionally, we present a new textual user interface that allows the use of the algorithm in a simpler and more readable way.

+
+ + +

Probabilistic Risk Assessment of an Obstacle Detection System for GoA 4 Freight Trains

  • Mario Gleirscher
  • Anne E. Haxthausen
  • Jan Peleska
+

We propose a quantitative risk assessment approach for the design of an obstacle detection function for low-speed freight trains with grade of automation 4. In this five-step approach, starting with single detection channels and ending with a three-out-of-three model comprised of three independent dual-channel modules and a voter, we exemplify a probabilistic assessment, using a combination of statistical methods and parametric stochastic model checking. We illustrate that, under certain not unreasonable assumptions, the resulting hazard rate becomes acceptable for the discussed application setting. The statistical approach for assessing the residual risk of misclassifications in convolutional neural networks and conventional image processing software suggests that high confidence can be placed into the safety-critical obstacle detection function, even though its implementation involves realistic machine learning uncertainties.

+
+ + +

Does Rust SPARK Joy? Safe Bindings from Rust to SPARK, Applied to the BBQueue Library

  • Aïssata Maiga
  • Cyrille Artho
  • Florian Gilcher
  • Yannick Moy
+

Both Rust and SPARK are memory-safe programming languages and feature stronger safety guarantees than other popular programming languages for embedded software. However, modern systems often combine software written in multiple programming languages using the Foreign Function Interface (FFI). When using safety-oriented programming languages such as Rust and SPARK, maintaining compile-time safety guarantees across a language boundary is a challenge. The objective of this study is to explore if/how the inherent safety guarantees of these languages are preserved, and their potential benefits when establishing a library interface between them. In particular, we apply our method to the BBQueue circular buffer library that features complex ownership hand-over patterns when using FFI. Results reveal that most of the inherent consistency and safety features of these languages can be maintained. Yet, special caution is required at the FFI boundary to prevent potential vulnerabilities.

+
+ + +

Solving Queries for Boolean Fault Tree Logic via Quantified SAT

  • Caz Saaltink
  • Stefano M. Nicoletti
  • Matthias Volk
  • Ernst Moritz Hahn
  • Mariëlle Stoelinga
+

Fault trees (FTs) are hierarchical diagrams used to model the propagation of faults in a system. Fault tree analysis (FTA) is a widespread technique that allows to identify the key factors that contribute to system failure. In recent work we introduced BFL, a Boolean Logic for Fault trees. BFL can be used to formally define simple yet expressive properties for FTA, e.g.: 1) we can set evidence to analyse what-if scenarios; 2) check whether two elements are independent or if they share a child that can influence their status; 3) and set upper/lower boundaries for failed elements. Furthermore, we provided algorithms based on binary decision diagrams (BDDs) to check BFL properties on FTs. In this work, we evaluate usability of a different approach by employing quantified Boolean formulae (QBFs) instead of BDDs. We present a translation from BFL to QBF and provide an implementation—making it the first tool for checking BFL properties—that builds on top of the Z3 solver. We further demonstrate its usability on a case study FT and investigate runtime, memory consumption and scalability on a number of benchmark FTs. Lastly, qualitative differences from a BDD-based approach are discussed.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/gpce23.html b/OpenTOC/gpce23.html new file mode 100644 index 0000000..e606084 --- /dev/null +++ b/OpenTOC/gpce23.html @@ -0,0 +1,180 @@ +GPCE 2023: Proceedings of the 22nd ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences

GPCE 2023: Proceedings of the 22nd ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

Automatically Generated Supernodes for AST Interpreters Improve Virtual-Machine Performance

  • Matteo Basso
  • Daniele Bonetta
  • Walter Binder
+

Abstract syntax tree (AST) interpreters allow implementing programming languages in a straight-forward way. However, AST interpreters implemented in object-oriented languages, such as e.g. in Java, often suffer from two serious performance issues. First, these interpreters commonly implement AST nodes by leveraging class inheritance and polymorphism, leading to many polymorphic call sites in the interpreter implementation and hence lowering interpreter performance. Second, widely used implementations of these interpreters throw costly runtime exceptions to model the control flow. Even though Just-in-Time (JIT) compilation mitigates these issues, performance in the first stages of the program execution remains poor. +

+

+In this paper, we propose a novel technique to improve both interpreter performance and steady-state performance, lowering also the pressure on the JIT compiler. Our technique automatically generates AST supernodes ahead-of-time, i.e., we automatically generate compound AST-node classes that encode the behavior of several other primitive AST nodes before the execution of the application. Our technique extracts common control-flow structures from an arbitrary, given set of ASTs, such as e.g. the functions of popular packages. It is based on matchmaking of AST structures, instantiation of matching supernodes, and replacement of the corresponding AST subtrees with the instantiated supernodes at load-time. We implement our technique in the GraalVM JavaScript engine, showing that our supernodes lead to an average interpreter speedup of 1.24x, an average steady-state speedup of 1.14x, and an average just-in-time compilation speedup of 1.33x on the web-tooling benchmark suite.

+
+ + +

A Monadic Framework for Name Resolution in Multi-phased Type Checkers

  • Casper Bach Poulsen
  • Aron Zwaan
  • Paul Hübner
+

An important aspect of type checking is name resolution --- i.e., determining the types of names by resolving them to a matching declaration. + For most languages, we can give typing rules that define name resolution in a way that abstracts from what order different units of code should be checked in. + However, implementations of type checkers in practice typically use multiple phases to ensure that declarations of resolvable names are available before names are resolved. + This gives rise to a gap between typing rules that abstract from order of type checking and multi-phased type checkers that rely on explicit ordering. +

+

+ This paper introduces techniques that reduce this gap. + First, we introduce a monadic interface for phased name resolution which detects and rejects type checking runs with name resolution phasing errors where names were wrongly resolved because some declarations were not available when they were supposed to be. + Second, building on recent work by Gibbons et al., we use applicative functors to compositionally map abstract syntax trees onto (phased) monadic computations that represent typing constraints. + These techniques reduce the gap between type checker implementations and typing rules in the sense that (1) both are given by compositional mappings over abstract syntax trees, and (2) type checker cases consist of computations that roughly correspond to typing rule premises, except these are composed using monadic combinators. + We demonstrate our approach by implementing type checkers for Mini-ML with Damas-Hindley-Milner type inference, and LM, a toy module language with a challenging import resolution policy.

+
+ + +

A pred-LL(*) Parsable Typed Higher-Order Macro System for Architecture Description Languages

  • Christoph Hochrainer
  • Andreas Krall
+

Macro systems are powerful language extension tools for +Architecture Description Languages (ADLs). +Their generative power in combination with +the simplicity of specification languages allows for a substantial +reduction of repetitive specification sections. +This paper explores how +the introduction of function- and record types +in a template-based macro system impacts the specification of ADLs. +We present design and implementation of a pattern-based syntax macro system for +the Vienna Architecture Description Language (VADL). +The macro system is directly integrated into the language and +is analyzed at parse time using a context-sensitive pred-LL(*) parser. +The usefulness of the macro system is illustrated by some typical macro +application design patterns. +The effectiveness is shown by a detailed evaluation of the Instruction Set +Architecture (ISA) specification of five different processor architectures. +The observed specification reduction can be up to 90 times, leading to improved +maintainability, readability and runtime performance of the specifications.

+
+ + +

C2TACO: Lifting Tensor Code to TACO

  • José Wesley de Souza Magalhães
  • Jackson Woodruff
  • Elizabeth Polgreen
  • Michael F. P. O'Boyle
+

Domain-specific languages (DSLs) promise a significant performance and portability advantage over traditional languages. DSLs are designed to be high-level and platform-independent, allowing an optimizing compiler significant leeway when targeting a particular device. Such languages are particularly popular with emerging tensor algebra workloads. However, DSLs present their own challenge: they require programmers to learn new programming languages and put in significant effort to migrate legacy code. +

+

+We present C2TACO, a synthesis tool for synthesizing TACO, a well-known tensor DSL, from C code. We develop a smart, enumerative synthesizer that uses automatically generated IO examples and source-code analysis to efficiently generate code. C2TACO is able to synthesize 95% bench marks from a tensor benchmark suite, out-performing an alternative neural machine translation technique, and demonstrates substantially higher levels of accuracy when evaluated against two state-of-the-art existing schemes, TF-Coder and ChatGPT. Our synthesized TACO programs are, by design, portable achieving significant performance improvement when evaluated on a multi-core and GPU platform.

+
+ + +

Partial Evaluation of Automatic Differentiation for Differential-Algebraic Equations Solvers

  • Oscar Eriksson
  • Viktor Palmkvist
  • David Broman
+

Differential-Algebraic Equations (DAEs) are the foundation of high-level equation-based languages for modeling physical dynamical systems. Simulating models in such languages requires a transformation known as index reduction that involves differentiating individual equations before numerical integration. Commercial and open-source implementations typically perform index reduction by symbolic differentiation (SD) and produce a Jacobian callback function with forward-mode automatic differentiation (AD). The former results in efficient runtime code, and the latter is asymptotically efficient in both runtime and code size. However, AD introduces runtime overhead caused by a non-standard representation of real numbers, and SD is not always applicable in models with general recursion. This work proposes a new approach that uses partial evaluation of AD in the context of numerical DAE solving to combine the strengths of the two differentiation methods while mitigating their weaknesses. Moreover, our approach selectively specializes partial derivatives of the Jacobian by exploiting structural knowledge while respecting a user-defined bound on the code size. Our evaluation shows that the new method both enables expressive modeling from AD and retains the efficiency of SD for many practical applications.

+
+ + +

Crossover: Towards Compiler-Enabled COBOL-C Interoperability

  • Mart van Assen
  • Manzi Aimé Ntagengerwa
  • Ömer Sayilir
  • Vadim Zaytsev
+

Interoperability across software languages is an important practical topic. In this paper, we take a deep dive into investigating and tackling the challenges involved with achieving interoperability between C and BabyCobol. The latter is a domain-specific language condensing challenges found in compiling legacy languages — borrowing directly from COBOL's data philosophy. Crossover, a compiler designed specifically to showcase the interoperability, exposes details of connecting a COBOL-like language with PICTURE clauses and re-entrant procedures, to C with primitive types and struct composites. Crossover features a C library for overcoming the differences between the data representations native to the respective languages. We illustrate the design process of Crossover and demonstrate its usage to provide a strategy to achieve interoperability between legacy and modern languages. The described process is aimed to be a blueprint for achievable interoperability between full-fledged COBOL and modern C-like programming languages.

+
+ + +

Generating Conforming Programs with Xsmith

  • William Hatch
  • Pierce Darragh
  • Sorawee Porncharoenwase
  • Guy Watson
  • Eric Eide
+

Fuzz testing is an effective tool for finding bugs in software, including programming language compilers and interpreters. +Advanced fuzz testers can find deep semantic bugs in language implementations through differential testing. +However, input programs used for differential testing must not only be syntactically and semantically valid, but also be free from nondeterminism and undefined behaviors. +Developing a fuzzer that produces such programs can require tens of thousands of lines of code and hundreds of person-hours. +Despite this significant investment, fuzzers designed for differential testing of different languages include many of the same features and analyses in their implementations. +To make the implementation of language fuzz testers for differential testing easier, we introduce Xsmith. +

+

+Xsmith is a Racket library and domain-specific language that provides mechanisms for implementing a fuzz tester in only a few hundred lines of code. +By sharing infrastructure, allowing declarative language specification, and by allowing procedural extensions, Xsmith allows developers to write correct fuzzers for differential testing with little effort. +We have developed fuzzers for several languages, and found bugs in implementations of Racket, Dafny, Standard ML, and WebAssembly.

+
+ + +

Multi-Stage Vertex-Centric Programming for Agent-Based Simulations

  • Zilu Tian
+

In vertex-centric programming, users express a graph algorithm as a vertex program and specify the iterative behavior of a vertex in a compute function, which is executed by all vertices in a graph in parallel, synchronously in a sequence of supersteps. While this programming model is straightforward for simple algorithms where vertices behave the same in each superstep, for complex vertex programs where vertices have different behavior across supersteps, a vertex needs to frequently dispatch on the value of supersteps in compute, which suffers from unnecessary interpretation overhead and complicates the control flow.

We address this using meta-programming: instead of branching on the value of a superstep, users separate instructions that should be executed in different supersteps via a staging-time wait() instruction. When a superstep starts, computations in a vertex program resume from the last execution point, and continue executing until the next wait(). We implement this in the programming model of an agent-based simulation framework CloudCity and show that avoiding the interpretation overhead caused by dispatching on the value of a superstep can improve the performance by up to 25% and lead to more robust performance.

+
+ + +

Unleashing the Power of Implicit Feedback in Software Product Lines: Benefits Ahead

  • Raul Medeiros
  • Oscar Díaz
  • David Benavides
+

Software Product Lines (SPLs) facilitate the development of a complete range of software products through systematic reuse. Reuse involves not only code but also the transfer of knowledge gained from one product to others within the SPL. This transfer includes bug fixing, which, when encountered in one product, affects the entire SPL portfolio. Similarly, feedback obtained from the usage of a single product can inform beyond that product to impact the entire SPL portfolio. Specifically, implicit feedback refers to the automated collection of data on software usage or execution, which allows for the inference of customer preferences and trends. While implicit feedback is commonly used in single-product development, its application in SPLs has not received the same level of attention. This paper promotes the investigation of implicit feedback in SPLs by identifying a set of SPL activities that can benefit the most from it. We validate this usefulness with practitioners using a questionnaire-based approach (n=8). The results provide positive insights into the advantages and practical implications of adopting implicit feedback at the SPL level.

+
+ + +

Virtual Domain Specific Languages via Embedded Projectional Editing

  • Niklas Korz
  • Artur Andrzejak
+

Domain Specific Languages (DSLs) can be implemented as either internal DSL, i.e. essentially a library in a host general-purpose programming language (GPL), or as external DSL which is a stand-alone language unconstrained in its syntax. This choice implies an inherent trade-off between a limited syntactic and representational flexibility (internal DSLs), or an involved integration with GPLs and the need for a full stack of tools from a parser to a code generator (external DSLs).

We propose a solution which addresses this problem by representing a subset of a GPL - from simple code patterns to complex API calls - as GUI widgets in a hybrid editor. Our approach relies on matching parametrized patterns against the GPL program, and displaying the matched parts as dynamically rendered widgets. Such widgets can be interpreted as components of an external DSL. Since the source code is serialized as GPL text without annotations, there is no DSL outside the editor - hence the term ‘virtual’ DSL.

This solution has several advantages. The underlying GPL and the virtual DSL can be mixed in a compositional way, with zero cost of their integration. The project infrastructure does not need to be adapted. Furthermore, our approach works with mainstream GPLs like Python or JavaScript.

To lower the development effort of such virtual DSLs, we also propose an approach to generate patterns and the corresponding text-only GUI widgets from pairs of examples.

We evaluate our approach and its implementation on use cases from several domains. A live demo of the system can be accessed at https://puredit.korz.dev/ and the source code with examples at https://github.com/niklaskorz/puredit/.

+
+ + +

Generating Constraint Programs for Variability Model Reasoning: A DSL and Solver-Agnostic Approach

  • Camilo Correa Restrepo
  • Jacques Robin
  • Raul Mazo
+

Verifying and configuring large Software Product Lines (SPL) requires automation tools. Current state-of-the-art approaches involve translating variability models into a formalism accepted as input by a constraint solver. There are currently no standards for variability modeling languages (VML). There is also a variety of constraint solver input languages. This has resulted in a multiplication of ad-hoc architectures and tools specialized for a single pair of VML and solver, fragmenting the SPL community. To overcome this limitation, we propose a novel architecture based on model-driven code generation, where the syntax and semantics of VMLs can be declaratively specified as data, and a standard, human-readable, formal pivot language is used between the VML and the solver input language. This architecture is the first to be fully generic by being agnostic to both VML and the solver paradigm. To validate the genericity of the approach, we have implemented a prototype tool together with declarative specifications for the syntax and semantics of two different VMLs and two different solver families. One VML is for classic, static SPL, and the other for run-time reconfigurable dynamic SPL with soft constraints to be optimized during configuration. The two solver families are Constraint Satisfaction Programs (CSP) and Constraint Logic Programs (CLP).

+
+ +
\ No newline at end of file diff --git a/OpenTOC/mplr23.html b/OpenTOC/mplr23.html new file mode 100644 index 0000000..1bb21aa --- /dev/null +++ b/OpenTOC/mplr23.html @@ -0,0 +1,361 @@ +MPLR 2023: Proceedings of the 20th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes

MPLR 2023: Proceedings of the 20th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes

+ Full Citation in the ACM Digital Library +

SESSION: Session 1

+

Is Wasm Becoming Garbage? (Keynote)

  • Andreas Rossberg
+

WebAssembly (a.k.a. Wasm) is a low-level virtual machine that is designed to be lightweight, close to the metal and agnostic to any source languages' opinions about how to construct programs. This is the defining characteristic of Wasm that distinguishes it from other popular virtual machines. Yet we recently finalised a new feature addition bringing direct support for garbage collection to Wasm. In this talk, I explain why we did that and how the GC extension is designed to preserve the low-level spirit of Wasm to the extent possible. I will show how it can be targeted by compilers for typical object-oriented and functional languages and where we left room for future improvements.

+
+ + +

On the Applicability of Annotation-Based Source Code Modification in Kotlin (Work in Progress)

  • Daniel Pfeffer
  • Markus Weninger
+

Annotations add metadata to source code entities such as classes or functions, which later can be processed by so-called annotation processors to, for example, modify the annotated program’s source code. While annotation processing has been well-explored in Java, the Kotlin community still lacks a comprehensive summary. Thus, in this paper, we summarize the main approaches available in Kotlin: (1) ‍Compile-time annotation processing using (a) ‍Kotlin Annotation Processing Tool (KAPT), (b) ‍Kotlin Symbolic Processing (KSP), or (c) ‍writing a custom Kotlin Compiler plugin; as well as (2) ‍load-time code modification using an agent or a custom class loader. We provide proof-of-concept implementations, discuss advantages and disadvantages, and specifically focus on how well each approach supports modifying the annotated source code. This should help developers and researchers to better decide when to use which approach.

+
+ + +

CloudJIT: A Just-in-Time FaaS Optimizer (Work in Progress)

  • Serhii Ivanenko
  • Rodrigo Bruno
  • Jovan Stevanovic
  • Luís Veiga
  • Vojin Jovanovic
+

Function-as-a-Service has emerged as a trending paradigm that provides attractive solutions to execute fine-grained and short-lived workloads referred to as functions. Functions are typically developed in a managed language such as Java and execute atop a language runtime. However, traditional language runtimes such as the HotSpot JVM are designed for peak performance as considerable time is spent profiling and Just-in-Time compiling code. As a consequence, warmup time and memory footprint are impacted. We observe that FaaS workloads, which are short-lived, do not fit this profile. +

+

+We propose CloudJIT, a self-optimizing FaaS platform that takes advantage of Ahead-of-Time compilation to achieve reduced startup latency and instantaneous peak performance with a smaller memory footprint. While AOT compilation is an expensive operation, the platform automatically detects which functions will benefit from it the most, performs all prerequisite preparation procedures, and compiles selected functions into native binaries. Our preliminary analysis, based on a public FaaS invocations trace, shows that optimizing a small fraction of all functions positively affects a vast majority of all cold starts.

+
+ +

SESSION: Session 2

+

Evaluating YJIT’s Performance in a Production Context: A Pragmatic Approach

  • Maxime Chevalier-Boisvert
  • Takashi Kokubun
  • Noah Gibbs
  • Si Xing (Alan) Wu
  • Aaron Patterson
  • Jemma Issroff
+

Ruby is a dynamically-typed programming language with a large breadth of features which +has grown in popularity with the rise of the modern web, and remains at the core of the +implementation of widely-used online platforms such as Shopify, GitHub, Discourse, +and Mastodon. +

+

+There have been many attempts to integrate JIT compilation into Ruby implementations, but until recently, despite impressive +performance on benchmarks, none had seen widespread adoption. +This has changed with the arrival of YJIT, a new JIT compiler based on a Lazy Basic Block Versioning (LBBV) architecture which has recently been upstreamed into CRuby, +and has since seen multiple large-scale production deployments. +

+

+This paper extends on previous work on YJIT and takes a pragmatic approach towards evaluating YJIT's performance in a production context. We evaluate and compare its performance on benchmarks as well as a large-scale real-world production deployment, and we look not only at peak performance, but also at memory usage and warm-up time. +

+

+On all of our benchmarks, YJIT is able to consistently outperform the CRuby interpreter by a wide +margin. It offers consistent speedups, full compatibility with existing Ruby code, much less memory overhead and faster warm-up compared to JRuby and TruffleRuby. +We also show that YJIT is able to deliver significant speedups on a real-world deployment on Shopify's worldwide StoreFront Renderer infrastructure, an application for which it is currently the only viable JIT compiler.

+
+ + +

CacheIR: The Benefits of a Structured Representation for Inline Caches

  • Jan de Mooij
  • Matthew Gaudet
  • Iain Ireland
  • Nathan Henderson
  • J. Nelson Amaral
+

Inline Caching is an important technique used to accelerate operations in dynamically typed language implementations by creating fast paths based on observed program behaviour. +Most software stacks that support inline caching use low-level, often ad-hoc, Inline-Cache (ICs) data structures for code generation. +This work presents CacheIR, a design for inline caching built entirely around an intermediate representation (IR) which: (i) simplifies the development of ICs by raising the abstraction level; and (ii) enables reusing compiled native code through IR matching techniques. +Moreover, this work describes WarpBuilder, a novel design for a Just-In-Time (JIT) compiler front-end that directly generates type-specialized code by lowering the CacheIR contained in ICs; and Trial Inlining, an extension to the inline-caching system that allows for context-sensitive inlining of context-sensitive ICs. +The combination of CacheIR and WarpBuilder have been powerful performance tools for the SpiderMonkey team, and have been key in providing improved performance with less security risk.

+
+ + +

Diagnosing Compiler Performance by Comparing Optimization Decisions

  • Andrej Pečimúth
  • David Leopoldseder
  • Petr Tůma
+

Modern compilers apply a set of optimization passes aiming to speed up the generated code. The combined effect of individual optimizations is difficult to predict. Thus, changes to a compiler's code may hinder the performance of generated code as an unintended consequence. +

+

+Performance regressions in compiled code are often related to misapplied optimizations. The regressions are hard to investigate, considering the vast number of compilation units and applied optimizations. A compilation unit consists of a root method and inlined methods. Thus, a method may be part of several compilation units and may be optimized differently in each. Moreover, inlining decisions are not invariant across runs of the virtual machine (VM). +

+

+We propose to solve the problem of diagnosing performance regressions by capturing the compiler's optimization decisions. We do so by representing the applied optimization phases, optimization decisions, and inlining decisions in the form of trees. This paper introduces an approach utilizing tree edit distance (TED) to detect optimization differences in a semi-automated way. We present an approach to compare optimization decisions in differently inlined methods. We employ these techniques to pinpoint the causes of performance problems in various benchmarks of the Graal compiler.

+
+ + +

Morello MicroPython: A Python Interpreter for CHERI

  • Duncan Lowther
  • Dejice Jacob
  • Jeremy Singer
+

Arm Morello is a prototype system that supports CHERI +hardware capabilities for improving runtime security. As +Morello becomes more widely available, there is a growing effort to port open source code projects to this novel +platform. Although high-level applications generally need +minimal code refactoring for CHERI compatibility, low-level +systems code bases require significant modification to comply with the stringent memory safety constraints that are +dynamically enforced by Morello. In this paper, we describe +our work on porting the MicroPython interpreter to Morello +with the CheriBSD OS. Our key contribution is to present a +set of generic lessons for adapting managed runtime execution environments to CHERI, including (1) a characterization +of necessary source code changes, (2) an evaluation of runtime performance of the interpreter on Morello, and (3) a +demonstration of pragmatic memory safety bug detection. +Although MicroPython is a lightweight interpreter, mostly +written in C, we believe that the changes we have implemented and the lessons we have learned are more widely +applicable. To the best of our knowledge, this is the first +published description of meaningful experience for scripting +language runtime engineering with CHERI and Morello.

+
+ +

SESSION: Session 3

+

A Multifaceted Memory Analysis of Java Benchmarks

  • Orion Papadakis
  • Andreas Andronikakis
  • Nikos Foutris
  • Michail Papadimitriou
  • Athanasios Stratikopoulos
  • Foivos S. Zakkak
  • Polychronis Xekalakis
  • Christos Kotselidis
+

Java benchmarking suites like Dacapo and Renaissance are employed by the research community to evaluate the performance of novel features in managed runtime systems. +These suites encompass various applications with diverse behaviors in order to stress test different subsystems of a managed runtime. +Therefore, understanding and characterizing the behavior of these benchmarks is important when trying to interpret experimental results. +

+

+This paper presents an in-depth study of the memory behavior of 30 Dacapo and Renaissance applications. +To realize the study, a characterization methodology based on a two-faceted profiling process of the Java applications is employed. +The two-faceted profiling offers comprehensive insights into the memory behavior of Java applications, as it is composed of high-level and low-level metrics obtained through a Java object profiler (NUMAProfiler) and a microarchitectural event profiler (PerfUtil) of MaxineVM, respectively. +By using this profiling methodology we classify the Dacapo and Renaissance applications regarding their intensity in object allocations, object accesses, LLC, and main memory pressure. +In addition, several other aspects such as the JVM impact on the memory behavior of the application are discussed.

+
+ + +

Improving Garbage Collection Observability with Performance Tracing

  • Claire Huang
  • Stephen Blackburn
  • Zixian Cai
+

+Debugging garbage collectors for performance and correctness is notoriously difficult. +Among the arsenal of tools available to systems engineers, support for one of the most +powerful, tracing, is lacking in most garbage collectors. Instead, engineers must rely on +counting, sampling, and logging. Counting and sampling are limited to statistical analyses while logging is limited to hard-wired metrics. +This results in cognitive friction, +curtailing innovation and optimization. +

+

+We demonstrate that tracing is well suited to GC performance debugging. +We leverage the modular design of MMTk to deliver a powerful VM and collector-neutral tool. +We find that tracing allows: + cheap insertion of tracepoints—just 14 lines of code and no measurable run-time overhead, + decoupling of the declaration of tracepoints from tracing logic, + high fidelity measurement able to detect subtle performance regressions, while also allowing + interrogation of a running binary. +

+

+Our tools crisply highlight several classes of +performance bug, such as poor scalability in multi-threaded GCs, and +lock contention in the allocation sequence. +These observations uncover optimization opportunities in collectors, +and even reveal bugs in application programs. +

+

+We showcase tracing as a powerful tool for GC designers and +practitioners. +Tracing can uncover missed opportunities and lead to novel +algorithms and new engineering practices. +

+
+ + +

Don’t Trust Your Profiler: An Empirical Study on the Precision and Accuracy of Java Profilers

  • Humphrey Burchell
  • Octave Larose
  • Sophie Kaleba
  • Stefan Marr
+

To identify optimisation opportunities, +Java developers often use +sampling profilers +that attribute +a percentage of run time +to the methods of a program. +Even so these profilers use sampling, +are probabilistic in nature, +and may suffer for instance from safepoint bias, +they are normally considered to be relatively reliable. +However, unreliable or inaccurate profiles +may misdirect developers +in their quest to resolve performance issues +by not correctly identifying +the program parts +that would benefit most +from optimisations. +

+

+With the wider adoption of profilers +such as async-profiler and Honest Profiler, +which are designed to avoid the safepoint bias, +we wanted to investigate how precise and accurate Java +sampling profilers are today. +We investigate the precision, reliability, accuracy, and overhead +of async-profiler, Honest Profiler, Java Flight Recorder, +JProfiler, perf, and YourKit, +which are all actively maintained. +We assess them on the fully deterministic +Are We Fast Yet benchmarks to have a stable foundation for the probabilistic +profilers. +

+

+We find that profilers are relatively reliable +over 30 runs and normally report the same hottest method. +Unfortunately, this is not true for all benchmarks, +which suggests their reliability may be application-specific. +Different profilers also report +different methods as hottest and cannot reliably +agree on the set of top 5 hottest methods. +On the positive side, +the average run time overhead is in the range of 1% to 5.4% +for the different profilers. +

+

+Future work should investigate how results +can become more reliable, +perhaps by reducing the observer effect of profilers +by using optimisation decisions of unprofiled runs +or by developing a principled approach +of combining multiple profiles that +explore different dynamic optimisations.

+
+ + +

Heap Size Adjustment with CPU Control

  • Sanaz Tavakolisomeh
  • Marina Shimchenko
  • Erik Österlund
  • Rodrigo Bruno
  • Paulo Ferreira
  • Tobias Wrigstad
+

This paper explores automatic heap sizing where developers let the frequency of GC expressed as a target overhead of the application's CPU utilisation, control the size of the heap, as opposed to the other way around. Given enough headroom and spare CPU, a concurrent garbage collector should be able to keep up with the application's allocation rate, and neither the frequency nor duration of GC should impact throughput and latency. Because of the inverse relationship between time spent performing garbage collection and the minimal size of the heap, this enables trading memory for computation and conversely, neutral to an application's performance. +

+

+We describe our proposal for automatically adjusting the size of a program's heap based on the CPU overhead of GC. We show how our idea can be relatively easily integrated into ZGC, a concurrent collector in OpenJDK, and study the impact of our approach on memory requirements, throughput, latency, and energy.

+
+ +

SESSION: Session 4

+

Comparing Rapid Type Analysis with Points-To Analysis in GraalVM Native Image

  • David Kozak
  • Vojin Jovanovic
  • Codrut Stancu
  • Tomáš Vojnar
  • Christian Wimmer
+

Whole-program analysis is an essential technique that enables advanced compiler optimizations. An important example of such a method is points-to analysis used by ahead-of-time (AOT) compilers to discover program elements (classes, methods, fields) used on at least one program path. GraalVM Native Image uses a points-to analysis to optimize Java applications, which is a time-consuming step of the build. We explore how much the analysis time can be improved by replacing the points-to analysis with a rapid type analysis (RTA), which computes reachable elements faster by allowing more imprecision. We propose several extensions of previous approaches to RTA: making it parallel, incremental, and supporting heap snapshotting. We present an extensive experimental evaluation of the effects of using RTA instead of points-to analysis, in which RTA allowed us to reduce the analysis time for Spring Petclinic (a popular demo application of the Spring framework) by 64% and the overall build time by 35% at the cost of increasing the image size due to the imprecision by 15%.

+
+ + +

Unified Shared Memory: Friend or Foe? Understanding the Implications of Unified Memory on Managed Heaps

  • Juan Fumero
  • Florin Blanaru
  • Athanasios Stratikopoulos
  • Steve Dohrmann
  • Sandhya Viswanathan
  • Christos Kotselidis
+

Adopting heterogeneous execution on GPUs and FPGAs in managed runtime systems, such as Java, is a challenging task due to the complexities of the underlying virtual machine. The majority of the current work has been focusing on compiler toolchains to solve the challenge of transparent just-in-time compilation of different code segments onto the accelerators. However, apart from providing automatic code generation, another paramount challenge is the seamless interoperability between the host memory manager and the Garbage Collector (GC). Currently, heterogeneous programming models that run on top of managed runtime systems, such as Aparapi and TornadoVM, need to block the GC when running native code (e.g, JNI code) in order to prevent the GC from moving data while the native code is still running on the hardware accelerator. +

+

+To tackle the inefficacy of locking the GC while the GPU operates, this paper proposes a novel Unified Memory (UM) memory allocator for heterogeneous programming frameworks for managed runtime systems. In this paper, we show how, by providing small changes to a Java runtime system, automatic memory management can be enhanced to perform object reclamation not only on the host, but also on the device. This is done by allocating the Java Virtual Machine's object heap in unified memory which is visible to all hardware accelerators. In this manner -although explicit data synchronization between the host and the device is still required to ensure data consistency- we enable transparent page migration of Java heap-allocated objects between the host and the accelerator, since our UM system is aware of pointers and object migration due to GC collections. This technique has been implemented in the context of MaxineVM, an open source research VM for Java written in Java. We evaluated our approach on a discrete and an integrated GPU, showcasing under which conditions UM can benefit execution across different benchmarks and configurations.We concluded that when hardware acceleration is not employed, UM does not pose significant overheads unless memory intensive workloads are encountered which can exhibit up to 12% (worst case) and 2% (average) slowdowns. In addition, if hardware acceleration is used, UM can achieve up to 9.3x speedup compared to the non-UM baseline implementation for integrated GPUs.

+
+ + +

Beyond RSS: Towards Intelligent Dynamic Memory Management (Work in Progress)

  • Christos Panagiotis Lamprakos
  • Sotirios Xydis
  • Peter Kourzanov
  • Manu Perumkunnil
  • Francky Catthoor
  • Dimitrios Soudris
+

The main goal of dynamic memory allocators is to minimize memory fragmentation. Fragmentation stems from the interaction between workload behavior and allocator policy. There are, however, no works systematically capturing said interaction. We view this gap as responsible for the absence of a standardized, quantitative fragmentation metric, the lack of workload dynamic memory behavior characterization techniques, and the absence of a standardized benchmark suite targeting dynamic memory allocation. Such shortcomings are profoundly asymmetric to the operation’s ubiquity.

This paper presents a trace-based simulation methodology for constructing representations of workload-allocator interaction. We use two-dimensional rectangular bin packing (2DBP) as our foundation. 2DBP algorithms minimize their products’ makespan, but virtual memory systems employing demand paging deem such a criterion inappropriate. We see an allocator’s placement decisions as a solution to a 2DBP instance, optimizing some unknown criterion particular to that allocator’s policy. Our end product is a data structure by design concerned with events residing entirely in virtual memory; no information on memory accesses, indexing costs or any other factor is kept.

We bootstrap our contribution’s utility by exploring its relationship to maximum resident set size (RSS). Our baseline is the assumption that less fragmentation amounts to smaller peak RSS. We thus define a fragmentation metric in the 2DBP substrate and compute it for both single- and multi-threaded workloads linked to 7 modern allocators. We also measure peak RSS for the resulting pairs. Our metric exhibits a monotonic relationship with memory footprint 94% of the time, as inferred via two-tailed statistical hypothesis testing with at least 99% confidence.

+
+ + +

Towards Safe HPC: Productivity and Performance via Rust Interfaces for a Distributed C++ Actors Library (Work in Progress)

  • John Parrish
  • Nicole Wren
  • Tsz Hang Kiang
  • Akihiro Hayashi
  • Jeffrey Young
  • Vivek Sarkar
+

In this work-in-progress research paper, we make the case for using Rust to develop applications in the High Performance Computing (HPC) domain which is critically dependent on native C/C++ libraries. This work explores one example of Safe HPC via the design of a Rust interface to an existing distributed C++ Actors library. This existing library has been shown to deliver high performance to C++ developers of irregular Partitioned Global Address Space (PGAS) applications. +

+

+Our key contribution is a proof-of-concept framework to express parallel programs safe-ly in Rust (and potentially other languages/systems), along with a corresponding study of the problems solved by our runtime, the implementation challenges faced, and user productivity. We also conducted an early evaluation of our approach by converting C++ actor implementations of four applications taken from the Bale kernels to Rust Actors using our framework. Our results show that the productivity benefits of our approach are significant since our Rust-based approach helped catch bugs statically during application development, without degrading performance relative to the original C++ actor versions.

+
+ + +

Generating Java Interfaces for Accessing Foreign Objects in GraalVM (Work in Progress)

  • Julian Garn
  • Florian Angerer
  • Hanspeter Mössenböck
+

Language interoperability (e.g., calling Python methods from Java programs) is a critical challenge in software development, often leading to code inconsistencies, human errors, and reduced readability. +

+

+This paper presents a work-in-progress project aimed at addressing this issue by providing a tool that automates the generation of Java interfaces for accessing data and methods written in other languages. +

+

+Using existing code analysis techniques the tool aims to produce easy to use abstractions for interop, intended to reduce human error and to improve code clarity. Although the tool is not yet finished, it has already shown promising results. Initial evaluations demonstrate its ability to identify language-specific features and automatically generate equivalent Java interfaces. This allows developers to efficiently integrate code written in foreign languages into Java projects while maintaining code readability and minimizing errors.

+
+ +

SESSION: Posters

+

Diagnosing Compiler Performance by Comparing Optimization Decisions (Poster Abstract)

  • Andrej Pečimúth
  • David Leopoldseder
  • Petr Tůma
+

This is an abstract accompanying a poster and a full paper. We introduce an approach to diagnose performance issues in dynamic compilers by logging and comparing optimization decisions.

+
+ + +

CloudJIT: A Just-in-Time FaaS Optimizer (Poster Abstract)

  • Serhii Ivanenko
  • Rodrigo Bruno
  • Jovan Stevanovic
  • Luís Veiga
  • Vojin Jovanovic
+

Function-as-a-Service provides attractive solutions to execute fine-grained and short-lived functions. Functions are typically developed in a managed language and execute atop a language runtime. However, traditional runtimes are designed for peak performance as considerable time is spent profiling and Just-in-Time compiling code. We observe that short-lived FaaS workloads do not fit this profile. +

+

+We propose CloudJIT, a self-optimizing FaaS platform that takes advantage of Ahead-of-Time compilation to achieve reduced startup latency and instantaneous peak performance with a smaller memory footprint. Our preliminary analysis shows that optimizing a small fraction of functions positively affects a majority of cold starts in a realistic environment.

+
+ + +

Don’t Trust Your Profiler: An Empirical Study on the Precision and Accuracy of Java Profilers (Poster Abstract)

  • Humphrey Burchell
  • Octave Larose
  • Sophie Kaleba
  • Stefan Marr
+

To identify optimisation opportunities, Java developers often +use sampling profilers that attribute a percentage of run +time to the methods of a program. Even so these profilers +use sampling, are probabilistic in nature, and may suffer for +instance from safepoint bias, they are normally considered +to be relatively reliable. However, unreliable or inaccurate +profiles may misdirect developers in their quest to resolve +performance issues by not correctly identifying the program +parts that would benefit most from optimisations. +With the wider adoption of profilers such as async-profiler +and Honest Profiler, which are designed to avoid the safepoint bias, we wanted to investigate how precise and accurate Java sampling profilers are today. In this Poster, we investigate +the precision, reliability, accuracy, and overhead of async-profiler, Honest Profiler, Java Flight Recorder, JProfiler, perf, +and YourKit, which are all actively maintained. We assess +them on the fully deterministic Are We Fast Yet benchmarks +to have a stable foundation for the probabilistic profilers. +We find that profilers are relatively reliable over 30 runs +and normally report the same hottest method. Unfortunately, +this is not true for all benchmarks, which suggests their +reliability may be application-specific. Different profilers +also report different methods as hottest and cannot reliably +agree on the set of top 5 hottest methods. On the positive +side, the average run time overhead is in the range of 1% to +5.4% for the different profilers. +Future work should investigate how results can become +more reliable, perhaps by reducing the observer effect of profilers by using optimisation decisions of unprofiled runs or by developing a principled approach of combining multiple +profiles that explore different dynamic optimisations.

+
+ + +

Capable VMs Project Overview (Poster Abstract)

  • Jacob Bramley
  • Dejice Jacob
  • Andrei Lascu
  • Duncan Lowther
  • Jeremy Singer
  • Laurence Tratt
+

In this poster, we will outline the scope and contributions of the Capable +VMs project, in the framework of the UKRI Digital Security by Design programme.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/onward23.html b/OpenTOC/onward23.html new file mode 100644 index 0000000..5911986 --- /dev/null +++ b/OpenTOC/onward23.html @@ -0,0 +1,232 @@ +Onward! 2023: Proceedings of the 2023 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software

Onward! 2023: Proceedings of the 2023 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

Scalable Spreadsheet-Driven End-User Applications with Incremental Computation

  • Sean Hadar
  • Shachar Itzhaky
+

Spreadsheets are a popular programming model among both novice and advanced users. +It allows for quick development of computational tasks over the user's data set. +It has also been suggested as a model for lightweight, low-code development of small-scale personal and collaborative applications for managing data. +A barrier is hit when trying to scale up these applications: as the volume of the data grows, performance of spreadsheet computations degrades noticeably, making their maintenance more difficult and frustrating. +This paper explores one aspect in which spreadsheets can be boosted significantly - by making computations more incremental, such that small changes to the data would incur a respectively small cost of update. +This is particularly interesting in the context of aggregate operations - applied to sets of data elements, producing a single value, such as their sum or average. +We propose a compilation phase in which a compiler transforms a spreadsheet table into a program that accepts a stream of changes and produces a stream of updates. +We show how to adapt classical results from finite differencing to this interesting modern scenario, and demonstrate that it yields asymptotic improvements to resource usage.

+
+ + +

Towards an Industrial Stateful Software Rejuvenation Toolchain using Model Learning

  • Mathijs Schuts
  • Jozef Hooman
+

We present our vision for creating an industrial legacy software rejuvenation toolchain. The goal is to semi automatically remove code smells from stateful software used in Cyber Physical Systems (CPS). Compared to existing tools that remove code smells, our toolchain can remove more than one type of code smell. Additionally, our approach supports multiple programming languages because we use abstract models obtained by means of model learning. Supporting more than one programming language is often lacking in state of art refactoring tools.

+
+ + +

Cloning and Beyond: A Quantum Solution to Duplicate Code

  • Samyak Jhaveri
  • Alberto Krone-Martins
  • Cristina V. Lopes
+

Quantum computers are becoming a reality. The advantage of quantum computing is that it has the potential to solve computationally complex problems in a fixed amount time, independent of the size of the problem. However, the kinds of problems for which these computers are a good fit, and the ways to express those problems, are substantially different from the kinds of problems and expressions used in classical computing. Quantum annealers, in particular, are currently the most promising and available quantum computing devices in the short term. However, they are also the most foreign compared to classical programs, as they require a different kind of computational thinking. +In order to ease the transition into this new world of quantum computing, we present a novel quantum approach to a well-known software problem: code clone detection. We express code clone detection as a subgraph isomorphism problem that is mapped into a quadratic optimization problem, and solve it using a DWave quantum annealing computer. We developed a quantum annealing algorithm that compares Abstract Syntax Trees (AST) and reports an energy value that indicates how similar they are. +

+

+The motivation behind this research goes well beyond code duplicate detection: our approach paves the way into how to express software engineering problems as optimization problems that can be solved by quantum annealers.

+
+ + +

Trustworthy Formal Natural Language Specifications

  • Colin S. Gordon
  • Sergey Matskevich
+

Interactive proof assistants are computer programs carefully constructed to check a human-designed proof of a mathematical claim with high confidence in the implementation. However, this only validates truth of a formal claim, which may have been mistranslated from a claim made in natural language. This is especially problematic when using proof assistants to formally verify the correctness of software with respect to a natural language specification. The translation from informal to formal remains a challenging, time-consuming process that is difficult to audit for correctness. +

+

+This paper shows that it is possible to build support for specifications written in expressive subsets of natural language, within existing proof assistants, consistent with the principles used to establish trust and auditability in proof assistants themselves. We implement a means to provide specifications in a modularly extensible formal subset of English, and have them automatically translated into formal claims, entirely within the Lean proof assistant. Our approach is extensible (placing no permanent restrictions on grammatical structure), modular (allowing information about new words to be distributed alongside libraries), and produces proof certificates explaining how each word was interpreted and how the sentence's structure was used to compute the meaning. +

+

+We apply our prototype to the translation of various English descriptions of formal specifications from a popular textbook into Lean formalizations; all can be translated correctly with a modest lexicon with only minor modifications related to lexicon size.

+
+ + +

Code Merging using Transformations and Member Identity

  • André Teles
  • André Santos
+

Conventionally, merging code files is performed using generic line-based merging algorithms (e.g., diff3) that are unaware of the syntax and semantics of the programming language, outputting conflicts that could be avoided. Structured and semistructured merging techniques are capable of reducing conflicts, but they still suffer from false positives (conflicts that could be avoided) and false negatives (conflicts that go undetected). We propose a merging technique that combines semistructured and transformation-based strategies, where conflict detection is aware of semantic aspects of the programming language. We extract transformations of two branches and apply a merging process that analyzes incompatible transformations, avoiding false positives and false negatives that occur in existing approaches. We developed Jaid, a prototype merging tool for Java based on the assumption that structural code elements evolve with attached UUIDs (representing identity). We performed an early experiment with 63 merge scenarios from two open-source projects to test the technique and assess its feasibility.

+
+ + +

Time-Awareness in Object Exploration Tools: Toward In Situ Omniscient Debugging

  • Christoph Thiede
  • Marcel Taeumel
  • Robert Hirschfeld
+

Exploration of state and behavior is essential for understanding and debugging object-oriented programs. Many time-related questions about object communication – an object’s history – only arise in the context of a specific error in the here and now. At such a specific point in time, however, it is often distracting to involve omniscient debugging tools such as program tracers, because they do not integrate well with the programmer’s current focus on space-related questions and the informational cues at hand. In this paper, we present a novel way to provide a tangible, consolidated notion of both space and time in object exploration tools to make it more likely that programmers will use the available means to explore the evolution of particular objects. With programmers remaining informed about and in control of a program’s space and time, we promote the scientific method for debugging and leverage exploratory programming practices. We evaluate our model with hands-on experiences in the Squeak/Smalltalk programming system, using a program tracer that we have integrated into existing exploration tools to promote both spatial and temporal views. We believe that a clear, tangible notion of spacetime can help tool designers provide a better programming experience for those constantly recurring “What happened to this object?” situations.

+
+ + +

Could No-Code Be Code? Toward a No-Code Programming Language for Citizen Developers

  • Assaf Avishahar-Zeira
  • David H. Lorenz
+

By 2030 for each filled position in Software Engineering, +two positions would remain unfilled. This already +apparent loss of productivity has the software +industry scrambling to fill the missing positions with +citizen developers---technical people with little or no +programming skills---who would be using No-Code platforms +to program various software solutions in specific domains. +However, currently available platforms have fairly limited +abstractions, lacking the flexibility of a general purpose +programming language. +

+

+To break the No-Code abstraction barrier, a very simple yet +expressive general purpose No-Code programming language +might provide citizen developers with an alternative to +domain-specific No-Code platforms. Unfortunately, these +requirements seem contradictory. Making a language very +simple and specific might render it crippled, thus limited +to a certain domain of problems. Conversely, making a +language very expressive and general, might render it too +complicated for citizen developers. +

+

+In this work we argue that a multi-paradigm minimalist +approach can bridge the gap between simplicity and +expressiveness by including only abstractions considered +intuitive to citizens. As a concrete proof-of-concept, we +present a general purpose programming language designed +for citizen developers that is on the one hand very +powerful and on the other hand very simple. In fact, +this language is so simple that the entire development +is accomplished by flowcharts using mouse actions only, +without typing a single line of code, thus demonstrating +a general purpose No-Code programming language candidate +for citizen developers.

+
+ + +

Concept-Centric Software Development: An Experience Report

  • Peter Wilczynski
  • Taylor Gregoire-Wright
  • Daniel Jackson
+

Developers have long recognized the importance of the concepts underlying the systems they build, and the primary role that concepts play in shaping user experience. To date, however, concepts have tended to be only implicit in software design with development being organized instead around more concrete artifacts (such as wireframes and code modules). +

+

+Palantir, a software company whose data analytics products are widely used by major corporations, recently reworked the internal representation of its software development process to bring concepts to the fore, making explicit the concepts underlying its products, including how they are clustered together, used in applications, and governed by teams. With a centralized repository of concepts, Palantir engineers are able to align products more closely based on shared concepts, evolve concepts in response to user needs, and communicate more effectively with non-engineering groups within the company. +

+

+This paper reports on Palantir's experiences to date, analyzing both successes and challenges, and offers advice to other organizations considering adopting a concept-centric approach to software development.

+
+ + +

Toward Programming Languages for Reasoning: Humans, Symbolic Systems, and AI Agents

  • Mark Marron
+

Integration, composition, mechanization, and AI assisted development are the driving themes in the future of software development. At their core these concepts are rooted in the increasingly important role of computing in our world, the desire to deliver functionality faster, with higher quality, and to empower more people to benefit from programmatic automation. These themes, and how they impact the human developers driving them, are the foundations for the next generation of programming languages. At first glance the needs of mechanization tools, AI agents, and human developers along with the various goals around development velocity, software quality, and software democratization are a broad and seemingly diverse set of needs. However, at their core is a single challenge that, once resolved, enables us to make radical progress in all of these areas.

Our hypothesis is that, fundamentally, software development is a problem of reasoning about code and semantics. This is true for human developers implementing a feature, symbolic tools building models of application behaviour, and even for language based AI agents as they perform tasks. While the particular aspects of reasoning that each agent struggles with varies to some degree, they share many common themes and, surprisingly, most mainstream languages extensively employ (anti)features that make this task harder or infeasible! This paper proposes a novel approach to this challenge – instead of new language features or logical constructs, that add more complexity to what is already a problem of complexity, we propose radical simplification in the form of the Bosque platform and language.

+
+ +

SESSION: Essays

+

Will Code Remain a Relevant User Interface for End-User Programming with Generative AI Models?

  • Advait Sarkar
+

The research field of end-user programming has largely been concerned with helping non-experts learn to code sufficiently well in order to achieve their tasks. Generative AI stands to obviate this entirely by allowing users to generate code from naturalistic language prompts. In this essay, we explore the extent to which "traditional" programming languages remain relevant for non-expert end-user programmers in a world with generative AI. We posit the "generative shift hypothesis": that generative AI will create qualitative and quantitative expansions in the traditional scope of end-user programming. We outline some reasons that traditional programming languages may still be relevant and useful for end-user programmers. We speculate whether each of these reasons might be fundamental and enduring, or whether they may disappear with further improvements and innovations in generative AI. Finally, we articulate a set of implications for end-user programming research, including the possibility of needing to revisit many well-established core concepts, such as Ko's learning barriers and Blackwell's attention investment model.

+
+ + +

Whither Problem-Solving Environments?

  • Matthew Dinmore
+

During the 1990s and first decade of the 2000s, problem-solving environments (PSEs) were a topic of research among a community with the vision to create software systems “with all of the computational facilities necessary to solve a target class of problems.” Use of the term has since declined, with fewer papers focused on core PSE research topics. What happened? Did we achieve the design vision for PSEs through other means – namely computational notebooks – or is there more to do? In this essay, we explore the history and objectives of PSE research, the rise of computational notebooks, whether they achieve these objectives, and why the time is right to renew our PSE research efforts.

+
+ + +

Sharing a Perspective on the 𝜆-Calculus

  • Beniamino Accattoli
+

The λ-calculus models the core of functional programming languages. This essay discusses a gap between the theory of the λ-calculus and functional languages, namely the fact that the former does not give a status to sharing, the essential ingredient for efficiency in the lattter.

The essay provides an overview of the perspective of the author, who has been and still is studying sharing from various angles. In particular, it explains how sharing impacts the equational and denotational semantics of the λ-calculus, breaking some expected properties, and demanding the development of new, richer semantics of the λ-calculus.

+
+ + +

programmingLanguage as Language;

  • James Noble
  • Robert Biddle
+

Programming languages are languages --- “unnatural” languages because +they are constructed explicitly; “formal” languages because they rely +on mathematical notations and are described mathematically; “machine” +languages because they are used to communicate with machines. Above +all, programming languages are “human” languages. Programs in +programming languages are spoken and read and written and designed and +debugged and debated by humans, supported by human communities and +forming those communities in turn. Langauge implementations, +being programs themselves, are likewise designed and +debugged and debated by humans. +

+

+ +Programming languages adopt structural elements from natural language, +including syntax, grammar, vocabulary, and even some sentence +structure. +Other aspects of language have received less attention, +including noun declension, verb tense, and situation-appropriate +register. Semiotics +shows how language use can connote and imply, and will lead to +interpretation. Language involves larger level structure too: +conversations, stories, and documents of all kinds. Language supports +both cognitive and affective processes, and is involved in building +mental models that we use to recall, reason, and respond. +

+

+Programming is a complex activity, uncertain yet precise, individual +and social, involving intent and interpretation. +Language is not the accident of programming --- it is the essence.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/paint23.html b/OpenTOC/paint23.html new file mode 100644 index 0000000..4e05f9a --- /dev/null +++ b/OpenTOC/paint23.html @@ -0,0 +1,149 @@ +PAINT 2023: Proceedings of the 2nd ACM SIGPLAN International Workshop on Programming Abstractions and Interactive Notations, Tools, and Environments

PAINT 2023: Proceedings of the 2nd ACM SIGPLAN International Workshop on Programming Abstractions and Interactive Notations, Tools, and Environments

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

A Penny a Function: Towards Cost Transparent Cloud Programming

  • Lukas Böhme
  • Tom Beckmann
  • Sebastian Baltes
  • Robert Hirschfeld
+

Understanding and managing monetary cost factors is crucial when developing cloud applications. +However, the diverse range of factors influencing costs for computation, storage, and networking in cloud applications poses a challenge for developers who want to manage and minimize costs proactively. +Existing tools for understanding cost factors are often detached from source code, causing opaqueness regarding the origin of costs. +Moreover, existing cost models for cloud applications focus on specific factors such as compute resources and necessitate manual effort to create the models. +This paper presents initial work toward a cost model based on a directed graph that allows deriving monetary cost estimations directly from code using static analysis. +Leveraging the cost model, we explore visualizations embedded in a code editor that display costs close to the code causing them. +This makes cost exploration an integrated part of the developer experience, thereby removing the overhead of external tooling for cost estimation of cloud applications at development time.

+
+ + +

Branching Compositional Data Transformations in jq, Visually

  • Michael Homer
+

jq is a widely-used command-line tool for filtering and transforming JSON +data, in the vein of sed and awk, including a bespoke programming language +for writing the filters. +The paradigm of that language is unusual: +while its appearance is somewhere between a shell pipeline and JavaScript, +the language is pure-functional and essentially concatenative, +the pipelines branch and interleave data invisibly, +implicit output flattening obscures all these effects, +and most users are unaware of any of its +semantics, +leading to confusion when encountering any of these latent +elements and difficulty in constructing appropriate non-trivial filters, +all the while common debugging techniques are also obstructed by +the paradigm. +These confusions can be eliminated by visually demonstrating the recursively +forking nature of evaluation on actual data, +and allowing manipulations of the program or data to be reflected live, +but no such tool exists for jq or any similar approaches. +We present a visualisation of jq's execution model that makes the branching +nature manifest, illustrating its effects on concrete values provided by the +user, and editing affordances that allow manipulating the program with +reference to real data.

+
+ + +

Toward Studying Example-Based Live Programming in CS/SE Education

  • Eva Krebs
  • Toni Mattis
  • Patrick Rein
  • Robert Hirschfeld
+

Source code is inherently abstract. While this is necessary to capture the generality of a program, it poses a barrier to understanding and learning to use the underlying concepts. In education, especially in abstract subjects like maths, the use of concrete examples is considered instrumental to the acquisition of knowledge and a frequently explored direction for teaching computational concepts. Besides concreteness, the importance of examples being close to their abstract descriptions as well as the immediacy of feedback has been highlighted. + + Babylonian Programming (BP) is a type of example-based live programming that fulfills all three criteria by introducing concrete values, moving them as close as possible to the code, and updating them immediately in response to changes of either the example or the code. This makes BP a promising tool in education, yet no studies on the suitability of BP in a learning context have been conducted. Hence, we propose to (1.) investigate usability of state-of-the-art BP to minimize the friction of introducing BP in education, and (2.) measure the learning effectiveness and quality of experience of a BP environment in undergraduate software engineering education. For these studies, we will use the Smalltalk-based Babylonian/S as our environment. + + Besides clearer guidelines on the design of BP and example-based systems in general, we expect to shed light on the qualities that teacher-provided examples need to exhibit and the opportunities for learners to create their own examples during experimentation with unknown concepts.

+
+ + +

Visual Replacements: Cross-Language Domain-Specific Representations in Structured Editors

  • Tom Beckmann
  • Daniel Stachnik
  • Jens Lincke
  • Robert Hirschfeld
+

To help developers work at the level of abstraction of their choice, some editors offer to replace parts of source code with domain-specific representations (DSRs). Typically, such replacements are language-specific and optimized to limited use-cases. In this paper, we extend a general-purpose structured editor with visual replacements, a mechanism to replace code of any programming language with DSRs. A visual replacement consists of language-dependent queries to map arbitrary syntax trees and a language-independent DSR of differing abstraction and interactivity, ranging from simple images to graphical user interfaces that modify source code. Our extension synchronizes source code and DSR automatically, while ensuring that language support such as autocompletion and error checking work even inside a replacement. We demonstrate the use and applicability of the replacement mechanism in three case studies.

+
+ + +

Game Engine Wizardry for Programming Mischief

  • Riemer van Rozen
+

Programming grants individuals the capability to design, create, and bring ideas to life. To improve their skills, programmers require powerful languages and programming environments for understanding the impact of gradual code changes. We investigate how modern game engine technology can be leveraged for creating visual input and feedback mechanisms that drive exploratory and live programming. +In this paper, we report experiences on creating a visual programming environment for Machinations, a domain-specific language for game design. We share initial findings on how to automate the development of graph- and tree- based editors in Godot, an open source game engine. Our results show that today’s game engine technology provides a solid foundation for future programming language research.

+
+ + +

PescaJ: A Projectional Editor for Java Featuring Scattered Code Aggregation

  • José Lopes
  • André Santos
+

Conventionally, source code (and its documentation) is simultaneously a storage and editing representation, through files and editors to manipulate them as text. Over the years, IDEs have become increasingly sophisticated, providing features to augment the visible text content with helpful information (e.g., overlay documentation popups, inlay type hints), or on the opposite, to decrease it to reduce clutter (e.g., code folds on imports, documentation, methods, etc). This is a sign that the developers seek more convenient code editing forms than the direct manipulation of text files. We present PescaJ, a prototype projectional editor for Java projects that breaks away from file-oriented source code editing, providing the possibility of forming views that aggregate methods that belong to different classes, where single methods may be simultaneously present and edited in multiple views. Furthermore, we provide documentation editors, also aggregating scattered Javadoc comments, that can be used in parallel with source code editing.

+
+ + +

Transforming an Internal Textual DSL into a Blended Modelling Environment

  • Aleandro Mifsud
  • Georgia Samaritaki
  • Ulyana Tikhonova
  • Jouke Stoel
+

Blended Modelling seamlessly integrates textual and visual representations of models, overcoming the limitations of either individually. This approach allows for greater complexity in coding while also lowering the entry barrier for less-technical users. While existing literature primarily focuses on external Domain Specific Languages (DSLs), there is a gap in the literature when it comes to incorporating internal DSLs into a Blended Modelling Environment, since migrating an internal DSL to an external DSL may not be feasible due to the internal DSL utilising many features of its host language. We focus on leveraging the Axini Modelling Language (AML), an industry-established internal DSL that is based on Ruby. By leveraging Ruby’s meta-language features, we transform AML into a Blended Modelling Environment, enabling real-time synchronization between the textual and visual representations of the model and ensuring instant reflection of updates across both models. To validate the usability of the solution, we conduct two case studies, demonstrating the seamless integration of the textual and visual models. Additionally, we develop a prototype Ruby API, facilitating the transformation of models into a parseable notation and ensuring synchronization of all nodes within the models. We also developed a web application as a platform for the textual and visual models, serving as a foundation for blended modelling environments. This work contributes to the field of blended modelling, providing practical demonstrations and laying the groundwork for further research and development in interactive modelling environments specifically based on internal DSLs.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/rebls23.html b/OpenTOC/rebls23.html new file mode 100644 index 0000000..102040d --- /dev/null +++ b/OpenTOC/rebls23.html @@ -0,0 +1,116 @@ +REBLS 2023: Proceedings of the 10th ACM SIGPLAN International Workshop on Reactive and Event-Based Languages and Systems

REBLS 2023: Proceedings of the 10th ACM SIGPLAN International Workshop on Reactive and Event-Based Languages and Systems

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

Thorium: A Language for Bounded Verification of Dynamic Reactive Objects

  • Kevin Baldor
  • Xiaoyin Wang
  • Jianwei Niu
+

Developing reliable reactive software is notoriously difficult – particularly when that software reacts by changing its behavior. Some of this difficulty is inherent; software that must respond to external events as they arrive tends to end up in states that are dependent on the value of that input and its order of arrival. This results in complicated corner cases that can be challenging to recognize. However, we find that some of the complexity is an accident of the features of the programming languages widely used in industry. The loops and subroutines of structured programming are well-suited to data transformation, but poorly capture – and sometimes obscure – the flow of data through reactive programs developed using the inversion-of-control paradigm; an event handler that modifies the data flow tends to be declared closer to the definition of the event that activates it than to the initial definition of the data flow that it modifies. This paper approaches both challenges with a language inspired by the declarative modules of languages SIGNAL and Lustre and the semantics of the SodiumFRP Functional Reactive Programming library with a declarative mechanism for self modification through module substitution. These language features lead to software with a code structure that closely matches the flow of data through the running program and thus makes software easier to understand. Further, we demonstrate how those language features enable a bounded model checking approach that can verify that a reactor meets its requirements or present a counterexample trace, a series of states and inputs that lead to a violation. We analyze the runtime performance of the verifier as a function of model size and trace length.

+
+ + +

Actix-Telepathy

  • Phillip Wenig
  • Thorsten Papenbrock
+

The actor programming model supports the development of concurrent applications by encapsulating state and behavior into independent actors. Each actor is a computational entity with strictly private state and behavior. Actors communicate via asynchronous messaging and, in this way, require neither shared memory nor locking. This makes the actor model suitable not only for parallel programming but also for distributed applications engineering. +

+

+The Rust programming language is a statically-typed language that gained a lot of attention in the past years due to its efficient, economical and safe memory management. To ease the development of parallel applications, several actor model frameworks have been built for Rust. However, no actively +maintained Rust actor framework provides the necessary features to write distributed applications. For this reason, we propose an extension for Rust’s Actix library, called Actix-Telepathy, that enables remote messaging and offers clustering support. It allows developers to setup remote actors that can communicate across a computer network with the help of a straight forward and easy to understand interface. Our evaluation demonstrates that Actix-Telepathy competes well in remote messaging performance and memory consumption with other actor libraries, such as Scala’s popular Akka library.

+
+ + +

Realizing Persistent Signals in JavaScript

  • Daichi Hidaka
  • Tetsuo Kamina
+

Reactive programming enables declarative descriptions of dependencies between and computations throughout signals, an abstraction of time-varying values. Signals have been extended to persistent signals (an abstraction of time-varying values with their execution histories) to enable them to go back in time with any given time. Currently, this feature is only supported by SignalJ, an extension to Java with signals. This limits the use of persistent signals only within the Java-based applications. This is an undesirable restriction, because mechanisms used in realizing persistent signals are actually language-independent. To tackle this problem, we propose an implementation of persistent signals in JavaScript, which makes application areas of persistent signals broader, including Web-frontend. To realize persistent signals in JavaScript, seamless connections between JavaScript programs that run on restricted environments such as browsers and time-series databases that serve histories of persistent signals are required. It is also desirable to reuse existing JavaScript ecosystem. To address these problems, we design a relay-server-based architecture and realize persistent signals in JavaScript as a DSL library.

+
+ + +

ComPOS: A DSL for Composing IoT Systems with Weak Connectivity

  • Alfred Åkesson
  • Görel Hedin
  • Niklas Fors
+

Future Internet-of-Things (IoT) systems need to combine heterogeneous IoT components and support weak connectivity. This paper introduces ComPOS, a domain-specific language for composing IoT services into systems. ComPOS is a small language but supports powerful message mediation, using stateful reactions with nested and parallel message sequences and anonymous futures. To deal with weak connectivity, we introduce the notion of abort semantics, i.e., aborting old reactions when a newer message arrives. Alternatives to the abort semantics can be obtained by adding strategy services. We evaluated our approach by implementing seven home automation scenarios.

+
+ + +

Periodic and Aperiodic Task Description Mechanisms in an FRP Language for Small-Scale Embedded Systems

  • Kento Sogo
  • Yuta Tsuji
  • Sosuke Moriguchi
  • Takuo Watanabe
+

This paper presents mechanisms for describing real-time tasks in functional reactive programming (FRP) languages for small-scale embedded systems. +We have designed and implemented Emfrp, an FRP language for resource-constrained systems, and demonstrated its usefulness with several applications. +However, the language requires using external clocks as time-varying values when describing time-dependent behaviors. +In this work, we extend the types of time-varying values that express their update timings to describe periodic and aperiodic tasks. +The extensions enable concise and precise descriptions of various timed behaviors. +We evaluate prototype implementations of the extended language concerning program size, execution time, and power consumption.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/sle23.html b/OpenTOC/sle23.html new file mode 100644 index 0000000..66ff077 --- /dev/null +++ b/OpenTOC/sle23.html @@ -0,0 +1,202 @@ +SLE 2023: Proceedings of the 16th ACM SIGPLAN International Conference on Software Language Engineering

SLE 2023: Proceedings of the 16th ACM SIGPLAN International Conference on Software Language Engineering

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

Exceptions all Over the Shop: Modular, Customizable, Language-Independent Exception Handling Layer

  • Walter Cazzola
  • Luca Favalli
+

The introduction of better abstractions is at the forefront of research and practice. Among many approaches, domain-specific languages are subject to an increase in popularity due to the need for easier, faster and more reliable application development that involves programmers and domain experts alike. To smooth the adoption of such a language-driven development process, researchers must create new engineering techniques for the development of programming languages and their ecosystems. Traditionally, programming languages are implemented from scratch and in a monolithic way. Conversely, modular and reusable language development solutions would improve maintainability, reusability and extensibility. Many programming languages share similarities that can be leveraged to reuse the same language feature implementations across several programming languages; recent language workbenches strive to achieve this goal by solving the language composition and language extension problems. Yet, some features are inherently complex and affect the behavior of several language features. Most notably, the exception handling mechanism involves varied aspects, such as the memory layout, variables, their scope, up to the execution of each statement that may cause an exceptional event—e.g., a division by zero. In this paper, we propose an approach to untangle the exception handling mechanism dubbed the exception handling layer: its components are modular and fully independent from one another, as well as from other language features. The exception handling layer is language-independent, customizable with regards to the memory layout and supports unconventional exception handling language features. To avoid any assumptions with regards to the host language, the exception handling layer is a stand-alone framework, decoupled from the exception handling mechanism offered by the back-end. Then, we present a full-fledged, generic Java implementation of the exception handling layer. The applicability of this approach is presented through a language evolution scenario based on a Neverlang implementation of JavaScript and LogLang, that we extend with conventional and unconventional exception handling language features using the exception handling layer, with limited impact on their original implementation.

+
+ + +

An Executable Semantics for Faster Development of Optimizing Python Compilers

  • Olivier Melançon
  • Marc Feeley
  • Manuel Serrano
+

Python is a popular programming language whose performance is known to be uncompetitive in comparison to static languages such as C. Although significant efforts have already accelerated implementations of the language, more efficient ones are still required. The development of such optimized implementations is nevertheless hampered by its complex semantics and the lack of an official formal semantics. We address this issue by presenting an approach to define an executable semantics targeting the development of optimizing compilers. This executable semantics is written in a format that highlights type checks, primitive values boxing and unboxing, and function calls, which are all known sources of overhead. We also present semPy, a partial evaluator of our executable semantics that can be used to remove redundant operations when evaluating arithmetic operators. Finally, we present Zipi, a Python optimizing compiler prototype developed with the aid of semPy. On some tasks, Zipi displays performance competitive with that of state-of-the-art Python implementations.

+
+ + +

Adaptive Structural Operational Semantics

  • Gwendal Jouneaux
  • Damian Frölich
  • Olivier Barais
  • Benoit Combemale
  • Gurvan Le Guernic
  • Gunter Mussbacher
  • L. Thomas van Binsbergen
+

Software systems evolve more and more in complex and changing environments, often requiring runtime adaptation +to best deliver their services. When self-adaptation is the main concern of the system, a manual implementation of the underlying feedback loop and trade-off analysis may be desirable. However, the required expertise and substantial development effort make such implementations prohibitively difficult when it is only a secondary concern for the given domain. In this paper, we present ASOS, a metalanguage abstracting the runtime adaptation concern of a given domain in the behavioral semantics of a domain-specific language (DSL), freeing the language user from implementing it from scratch for each system in the domain. We demonstrate our approach on RobLANG, a procedural DSL for robotics, where we abstract a recurrent energy-saving behavior depending on the context. We provide formal semantics for ASOS and pave the way for checking properties such as determinism, completeness, and termination of the resulting self-adaptable language. We provide first results on the performance of our approach compared to a manual implementation of this self-adaptable behavior. We demonstrate, for RobLANG, that our approach provides suitable abstractions for specifying sound adaptive operational semantics while being more efficient.

+
+ + +

A Reference GLL Implementation

  • Adrian Johnstone
+

The Generalised-LL (GLL) context-free parsing algorithm was introduced at the 2009 LDTA workshop, and since then a series of variant algorithms and implementations have been described. There is a wide variety of optimisations that may be applied to GLL, some of which were already present in the originally published form. +

+

+This paper presents a reference GLL implementation shorn of all optimisations as a common baseline for the real-world comparison of performance across GLL variants. This baseline version has particular value for non-specialists, since its simple form may be straightforwardly encoded in the implementer's preferred programming language. +

+

+We also describe our approach to low level memory management of GLL internal data structures. Our evaluation on large inputs shows a factor 3--4 speedup over a naïve implementation using the standard Java APIs and a factor 4--5 reduction in heap requirements. We conclude with notes on some algorithm-level optimisations that may be applied independently of the internal data representation.

+
+ + +

Sharing Trees and Contextual Information: Re-imagining Forwarding in Attribute Grammars

  • Lucas Kramer
  • Eric Van Wyk
+

It is not uncommon to design a programming language as a core language with additional features that define some semantic analyses, but delegate others to their translation to the core. Many analyses require contextual information, such as a typing environment. When this is the same for a term under a new feature and under that feature's core translation, then the term (and computations over it) can be shared, with context provided by the translation. This avoids redundant, and sometimes exponential computations. This paper brings sharing of terms and specification of context to forwarding, a language extensibility mechanism in attribute grammars. Here context is defined by equations for inherited attributes that provide (the same) values to shared trees. Applying these techniques to the ableC extensible C compiler replaced around 80% of the cases in which tree sharing was achieved by a crude mechanism that prevented sharing context specifications and limited language extensibility. It also replaced all cases in which this mechanism was used to avoid exponential computations and allowed the removal of many, now unneeded, inherited attribute equations.

+
+ + +

Nanopass Attribute Grammars

  • Nathan Ringo
  • Lucas Kramer
  • Eric Van Wyk
+

Compilers for feature-rich languages are complex; they perform many analyses and optimizations, and often lower complex language constructs into simpler ones. The nanopass compiler architecture manages this complexity by specifying the compiler as a sequence of many small transformations, over slightly different, but clearly defined, versions of the language that each perform a single straightforward action. This avoids errors that arise from attempting to solve multiple problems at once and allows for testing at each step. +

+

+Attribute grammars are ill-suited for this architecture, primarily because they cannot identify the many versions of the language in a non-repetitive and type-safe way. We present a formulation of attribute grammars that addresses these concerns, called nanopass attribute grammars, that (i) identifies a collection of all language constructs and analyses (attributes), (ii) concisely constructs specific (sub) languages from this set and transformations between them, and (iii) specifies compositions of transformations to form nanopass compilers. The collection of all features can be statically typed and individual languages can be checked for well-definedness and circularity. We evaluate the approach by implementing a significant subset of the Go programming language in a prototype nanopass attribute grammar system.

+
+ + +

Automated Extraction of Grammar Optimization Rule Configurations for Metamodel-Grammar Co-evolution

  • Weixing Zhang
  • Regina Hebig
  • Daniel Strüber
  • Jan-Philipp Steghöfer
+

When a language evolves, meta-models and associated gram- mars need to be co-evolved to stay mutually consistent. Previous work has supported the automated migration of a grammar after changes of the meta-model to retain manual optimizations of the grammar, related to syntax aspects such as keywords, brackets, and component order. Yet, doing so required the manual specification of optimization rule con- figurations, which was laborious and error-prone. In this work, to significantly reduce the manual effort during meta-model and grammar co-evolution, we present an automated approach for extracting optimization rule configurations. The inferred configurations can be used to automatically replay optimizations on later versions of the grammar, thus leading to a fully automated migration process for the supported types of changes. We evaluated our approach on six real cases. Full automation was possible for three of them, with agreement rates between ground truth and inferred grammar between 88% and 67% for the remaining ones.

+
+ + +

Reuse and Automated Integration of Recommenders for Modelling Languages

  • Lissette Almonte
  • Antonio Garmendia
  • Esther Guerra
  • Juan de Lara
+

Many recommenders for modelling tasks have recently appeared. They use a variety of recommendation methods,tailored to concrete modelling languages. Typically, recommenders are created as independent programs, and subsequently need to be integrated within a modelling tool, incurring in high development effort. Moreover, it is currently not possible to reuse a recommender created for a modelling language with a different notation, even if they are similar. +To attack these problems, we propose a methodology to reuse and integrate recommenders into modelling tools. It considers four orthogonal dimensions: the target modelling language, the tool, the recommendation source, and the recommended items. To make homogeneous the access to arbitrary recommenders, we propose a reference recommendation service that enables indexing recommenders, investigating their properties, and obtaining recommendations likely coming from several sources. Our methodology is supported by IronMan, an Eclipse plugin that automates the integration of recommenders within Sirius and tree-based editors, and can bridge recommenders created for a modelling language for their reuse with a different one. We evaluate the power of the tool by reusing 2 recommenders for 4 different languages, and integrating them into 6 modelling tools.

+
+ + +

GPT-3-Powered Type Error Debugging: Investigating the Use of Large Language Models for Code Repair

  • Francisco Ribeiro
  • José Nuno Castro de Macedo
  • Kanae Tsushima
  • Rui Abreu
  • João Saraiva
+

Type systems are responsible for assigning types to terms in programs. That way, they enforce the actions that can be taken and can, consequently, detect type errors during compilation. However, while they are able to flag the existence of an error, they often fail to pinpoint its cause or provide a helpful error message. Thus, without adequate support, debugging this kind of errors can take a considerable amount of effort. Recently, neural network models have been developed that are able to understand programming languages and perform several downstream tasks. We argue that type error debugging can be enhanced by taking advantage of this deeper understanding of the language’s structure. In this paper, we present a technique that leverages GPT-3’s capabilities to automatically fix type errors in OCaml programs. We perform multiple source code analysis tasks to produce useful prompts that are then provided to GPT-3 to generate potential patches. Our publicly available tool, Mentat, supports multiple modes and was validated on an existing public dataset with thousands of OCaml programs. We automatically validate successful repairs by using Quickcheck to verify which generated patches produce the same output as the user-intended fixed version, achieving a 39% repair rate. In a comparative study, Mentat outperformed two other techniques in automatically fixing ill-typed OCaml programs.

+
+ + +

Temporal Breakpoints for Multiverse Debugging

  • Matthias Pasquier
  • Ciprian Teodorov
  • Frédéric Jouault
  • Matthias Brun
  • Luka Le Roux
  • Loïc Lagadec
+

Multiverse debugging extends classical and omniscient debugging to allow the exhaustive exploration of non-deterministic and concurrent systems during debug sessions. +The introduction of user-defined reductions significantly improves the scalability of the approach. +However, the literature fails to recognize the importance of using more expressive logics, besides local-state predicates, to express breakpoints. +In this article, we address this problem by introducing temporal breakpoints for multiverse debugging. +Temporal breakpoints greatly enhance the expressivity of conditional breakpoints, allowing users to reason about the past and future of computations in the multiverse. +Moreover, we show that it is relatively straightforward to extend a language-agnostic multiverse debugger semantics with temporal breakpoints, while preserving its generality. +To show the elegance and practicability of our approach, we have implemented a multiverse debugger for the AnimUML modeling environment that supports 3 different temporal breakpoint formalisms: regular-expressions, statecharts, and statechart-based Büchi automata.

+
+ + +

Cross-Level Debugging for Static Analysers

  • Mats Van Molle
  • Bram Vandenbogaerde
  • Coen De Roover
+

Static analyses provide the foundation for several tools that help developers find problems before executing the program under analysis. Common applications include warning about unused code, deprecated API calls, or about potential security vulnerabilities within an IDE. A static analysis distinguishes itself from a dynamic analysis in that it is supposed to terminate even if the program under analysis does not. In many cases it is also desired for the analysis to be sound, meaning that its answers account for all possible program behavior. Unfortunately, analysis developers may make mistakes that violate these properties resulting in hard-to-find bugs in the analysis code itself. Finding these bugs can be a difficult task, especially since analysis developers have to reason about two separate code-bases: the analyzed code and the analysis implementation. The former is usually where the bug manifests itself, while the latter contains the faulty implementation. A recent survey has found that analysis developers prefer to reason about the analyzed program, indicating that debugging would be easier if debugging features such as (conditional) breakpoints and stepping were also available in the analyzed program. In this paper, we therefore propose cross-level debugging for static analysis. This novel technique moves debugging features such as stepping and breakpoints to the base-layer (i.e., analyzed program), while still making interactions with the meta-layer (i.e., analysis implementation) possible. To this end, we introduce novel conditional breakpoints that express conditions, which we call meta-predicates, about the current analysis’ state. We integrated this debugging technique in a framework for implementing modular abstract interpretation-based static analyses called MAF. Through a detailed case study on 4 real-world bugs taken from the repository of MAF, we demonstrate how cross-level debugging helps analysis developers in locating and solving bugs.

+
+ + +

Cascade: A Meta-language for Change, Cause and Effect

  • Riemer van Rozen
+

Live programming brings code to life with immediate and continuous feedback. To enjoy its benefits, programmers need powerful languages and live programming environments for understanding the effects of code modifications on running programs. Unfortunately, the enabling technology that powers these languages, is missing. Change, a crucial enabler for explorative coding, omniscient debugging and version control, is a potential solution. +We aim to deliver generic solutions for creating these languages, in particular Domain-Specific Languages (DSLs). We present Cascade, a meta-language for expressing DSLs with interface- and feedback-mechanisms that drive live programming. We demonstrate run-time migrations, ripple effects and live desugaring of three existing DSLs. Our results show that an explicit representation of change is instrumental for how these languages are built, and that cause-and-effect relationships are vital for delivering precise feedback.

+
+ + +

Seamless Code Generator Synchronization in the Composition of Heterogeneous Modeling Languages

  • Nico Jansen
  • Bernhard Rumpe
+

In Software Language Engineering, the composition of heterogeneous languages has become an increasingly relevant research area in recent years. Despite considerable advances in different composition techniques, they mainly focus on composing concrete and abstract syntax, while a thorough yet general concept for synchronizing code generators and their produced artifacts is still missing. Current solutions are either highly generic, typically increasing the complexity beyond their actual value, or strictly limited to specific applications. In this paper, we present a concept for lightweight generator composition, using the symbol tables of heterogeneous modeling languages to exchange generator-specific accessor and mutator information. The information is attached to the symbols of model elements via templates allowing code generators to communicate access routines at the code level without a further contract. Providing suitable synchronization techniques for code generation is essential to enable language composition in all aspects.

+
+ + +

Enabling Blended Modelling of Timing and Variability in EAST-ADL

  • Muhammad Waseem Anwar
  • Federico Ciccozzi
  • Alessio Bucaioni
+

EAST-ADL is a domain-specific modelling language for the design and analysis of vehicular embedded systems. Seamless modelling through multiple concrete syntaxes for the same language, known as blended modelling, offers enhanced modelling flexibility to boost collaboration, lower modelling time, and maximise the productivity of multiple diverse stakeholders involved in the development of complex systems, such as those in the automotive domain. Together with our industrial partner, which is one of the leading contributors to the definition of EAST-ADL and one of its main end-users, we provided prototypical blended modelling features for EAST-ADL. +In this article, we report on our language engineering work towards the provision of blended modelling for EAST-ADL to support seamless graphical and textual notations. Notably, for selected portions of the EAST-ADL language (i.e., timing and variability packages), we introduce ad-hoc textual concrete syntaxes to represent the language's abstract syntax in alternative textual notations, preserving the language's semantics. Furthermore, we propose a full-fledged runtime synchronisation mechanism, based on the standard EAXML schema format, to achieve seamless change propagation across the two notations. As EAXML serves as a central synchronisation point, the proposed blended modelling approach is workable with most existing EAST-ADL tools. The feasibility of the proposed approach is demonstrated through a car wiper use case from our industrial partner - Volvo. Results indicate that the proposed blended modelling approach is effective and can be applied to other EAST-ADL packages and supporting tools.

+
+ + +

Towards Efficient Model Comparison using Automated Program Rewriting

  • Qurat ul ain Ali
  • Dimitris Kolovos
  • Konstantinos Barmpis
+

Model comparison is a prerequisite task for several other model management tasks such as model merging, model differencing etc. We present a novel approach to efficiently compare models using programs written in a rule-based model comparison language. As the comparison is done at the model element level, and each element needs to be traversed and compared with its corresponding elements, the execution of these comparison algorithms can be computationally expensive for larger models. In this paper, we present an efficient comparison approach which provides an automated rewriting facility to compare (both homogeneous and heterogeneous) models, based on static program analysis. Using this analysis, we reduce the search space by pre-filtering/indexing model elements, before actually comparing them. Moreover, we reorder the comparison match rules according to the dependencies between these rules to +reduce the cost of jumping between rules. Our experiments demonstrate that the proposed model comparison approach delivers significant performance benefits in terms of execution time compared to the default ECL execution engine.

+
+ + +

Deriving Integrated Multi-Viewpoint Modeling Languages from Heterogeneous Modeling Languages: An Experience Report

  • Malte Heithoff
  • Nico Jansen
  • Jörg Christian Kirchhof
  • Judith Michael
  • Florian Rademacher
  • Bernhard Rumpe
+

In modern systems engineering, domain experts increasingly utilize models to define domain-specific viewpoints in a highly interdisciplinary context. Despite considerable advances in developing model composition techniques, their integration in a largely heterogeneous language landscape still poses a challenge. Until now, composition in practice mainly focuses on developing foundational language components or applying language composition in smaller scenarios, while the application to extensive, heterogeneous languages is still missing. In this paper, we report on our experiences of composing sophisticated modeling languages using different techniques simultaneously in the context of heterogeneous application areas such as assistive systems and cyber-physical systems in the Internet of Things. We apply state-of-the-art practices, show their realization, and discuss which techniques are suitable for particular modeling scenarios. Pushing model composition to the next level by integrating complex, heterogeneous languages is essential for establishing modeling languages for highly interdisciplinary development teams.

+
+ + +

A Low-Code Platform for Systematic Component-Oriented Language Composition

  • Jérôme Pfeiffer
  • Andreas Wortmann
+

Low-code platforms have gained popularity for accelerating complex software engineering tasks through visual interfaces and pre-built components. Software language engineering, specifically language composition, is such a complex task requiring expertise in composition mechanisms and language workbenches multi-dimensional language constituents (syntax and semantics). This paper presents an extensible low-code platform with a graphical web-based interface for language composition. It enables composition using language components, facilitating systematic composition within language families promoting reuse and streamlining the management, composition, and derivation of domain-specific languages.

+
+ + +

A Tool for the Definition and Deployment of Platform-Independent Bots on Open Source Projects

  • Adem Ait
  • Javier Luis Cánovas Izquierdo
  • Jordi Cabot
+

The development of Open Source Software (OSS) projects is a collaborative process that heavily relies on active contributions by passionate developers. Creating, retaining and nurturing an active community of developers is a challenging task; and finding the appropriate expertise to drive the development process is not always easy. To alleviate this situation, many OSS projects try to use bots to automate some development tasks, thus helping community developers to cope with the daily workload of their projects. However, the techniques and support for developing bots is specific to the code hosting platform where the project is being developed (e.g., GitHub or GitLab). Furthermore, there is no support for orchestrating bots deployed in different platforms nor for building bots that go beyond pure development activities. In this paper, we propose a tool to define and deploy bots for OSS projects, which besides automation tasks they offer a more social facet, improving community interactions. The tool includes a Domain-Specific Language (DSL) which allows defining bots that can be deployed on top of several platforms and that can be triggered by different events (e.g., creation of a new issue or a pull request). We describe the design and the implementation of the tool, and illustrate its use with examples.

+
+ + +

Online Name-Based Navigation for Software Meta-languages

  • Peter D. Mosses
+

Software language design and implementation often involve specifications written in various esoteric meta-languages. Language workbenches generally include support for precise name-based navigation when browsing language specifications locally, but such support is lacking when browsing the same specifications online in code repositories.

This paper presents a technique to support precise name-based navigation of language specifications in online repositories using ordinary web browsers. The idea is to generate hyperlinked twins: websites where verbatim copies of specification text are enhanced with hyperlinks between name references and declarations. By generating hyperlinks directly from the name binding analysis used internally in a language workbench, online navigation in hyperlinked twins is automatically consistent with local navigation.

The presented technique has been implemented for the Spoofax language workbench, and used to generate hyperlinked twin websites from various language specifications in Spoofax meta-languages. However, the applicability of the technique is not limited to Spoofax, and developers of other language workbenches could presumably implement similar tooling, to make their language specifications more accessible to those who do not have the workbench installed.

+
+ + +

Practical Runtime Instrumentation of Software Languages: The Case of SciHook

  • Dorian Leroy
  • Benoit Combemale
  • Benoît Lelandais
  • Marie-Pierre Oudot
+

Software languages have pros and cons, and are usually chosen accordingly. In this context, it is common to involve different languages in the development of complex systems, each one specifically tailored for a given concern. However, these languages create de facto silos, and offer little support for interoperability with other languages, be it statically or at runtime. In this paper, we report on our experiment on extracting a relevant behavioral interface from an existing language, and using it to enable interoperability at runtime. In particular, we present a systematic approach to define the behavioral interface and we discuss the expertise required to define it. We illustrate our work on the case study of SciHook, a C++ library enabling the runtime instrumentation of scientific software in Python. We present how the proposed approach, combined with SciHook, enables interoperability between Python and a domain-specific language dedicated to numerical analysis, namely NabLab, and discuss overhead at runtime.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/splash-e23.html b/OpenTOC/splash-e23.html new file mode 100644 index 0000000..2a9d394 --- /dev/null +++ b/OpenTOC/splash-e23.html @@ -0,0 +1,138 @@ +SPLASH-E 2023: Proceedings of the 2023 ACM SIGPLAN International Symposium on SPLASH-E

SPLASH-E 2023: Proceedings of the 2023 ACM SIGPLAN International Symposium on SPLASH-E

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

Teaching Programming with Graphics: Pitfalls and a Solution

  • Luca Chiodini
  • Juha Sorva
  • Matthias Hauswirth
+

Many introductory programming courses employ graphics +libraries that promote engagement and enable fun visuals. +However, student excitement over graphical outputs is not a +guarantee of conceptual understanding of programming, and +graphics may even distract from intended learning outcomes. +Our contribution is twofold. First, we analyze a selection of +existing graphics libraries designed for novice programmers. +We consider how these libraries foster clean decomposition, +direct students’ attention to key content, and manage complexity; we find shortcomings in these respects. These shortcomings involve the libraries’ support for global coordinates +and external graphics, as well as their rich APIs; we argue +that these features, although powerful, are also potential +pitfalls in student learning. Second, we present the design of +a new graphics library, PyTamaro, which avoids the pitfalls +with a minimalist design that eschews coordinates; we also +outline a pedagogical approach that builds on PyTamaro’s +strengths and deliberate limitations. We briefly discuss PyTamaro’s trade-offs in comparison to coordinate-based libraries. +The work reported here paves the way for future empirical +evaluations of PyTamaro and associated teaching practices.

+
+ + +

A Framework for the Localization of Programming Languages

  • Alaaeddin Swidan
  • Felienne Hermans
+

Most programming languages are only available in English, which means that speakers of other languages need to learn at least some English before they can learn to program. This creates well-documented barriers to entry into programming. While many educational programming languages are localized in some way (e.g. keywords), they often miss important other aspects (e.g. numerals or word order). This paper describes a framework of 12 aspects of programming languages that can be localized, helping tool designers localize their languages better and educators to make more informed decisions about introductory languages in non-English contexts.

+
+ + +

Centering Humans in the Programming Languages Classroom: Building a Text for the Next Generation

  • Rose Bohrer
+

This paper is a companion to the author's open-access textbook, "Human-Centered Programming Languages." Beyond the contributions of the textbook itself, this paper contributes a set of textbook design principles for overcoming those limitations and an analysis of students' stated needs and preferences drawn from anonymous course report data for three courses, the last of which was based on notes that became the basis of the textbook. The textbook is intended to be multi-purpose, with its primary audiences being undergraduate and master's-level elective courses on programming languages within computer science, but significant opportunity for cross-use in disciplines ranging from human-computer interaction and software engineering to gender studies and disability studies. The book is intended to be language-agnostic, but the course in which it will be used first is Rust-based.

+
+ + +

Composing Turing Machines in FSM

  • Marco Morazán
+

For Computer Science students, designing Turing machines is a Herculean task. Formal Languages and Automata Theory textbooks aid students by introducing a graphical notation for Turing machine composition. The difficulty of the task remains unchanged, because design principles are not emphasized and students rarely have the opportunity to program their designs in a textual programming language which allows them to write unit tests. To aid students that are trained as programmers, FSM--a domain-specific language for the Automata Theory classroom--has been developed. Using FSM, students design, program, validate, and establish the correctness of their Turing machines. Once they are familiar with Turing machines, students are introduced to Turing machine composition much like they are introduced to function composition when they learn to design programs. To compose Turing machines in FSM, there is an embedded domain-specific language that students may use. In this manner, students' training in programming is made relevant in the course. This article discusses how students are taught to design, program, validate, and establish the correctness of composed Turing machines.

+
+ + +

KOGI: A Seamless Integration of ChatGPT into Jupyter Environments for Programming Education

  • Kimio Kuramitsu
  • Yui Obara
  • Miyu Sato
  • Momoka Obara
+

The impact of ChatGPT has brought both anxiety and anticipation to schools and universities. Exploring a positive method to improve programming skills with ChatGPT is a new and pressing challenge. +In pursuit of this goal, we have developed KOGI, a learning support system that integrates ChatGPT into the Jupyter environment. This paper demonstrates how KOGI enables students to receive timely advice from ChatGPT in response to errors and other questions they encounter. +

+

+We immediately introduced KOGI in our two introductory courses: Algorithms and Data Science. The introduction of KOGI resulted in a significant decrease in the number of unresolved student errors. In addition, we report on student trends observed in the classroom regarding the type and frequency of help requested. Although our findings are preliminary, they are informative for programming instructors interested in using ChatGPT.

+
+ + +

Exploring Engagement and Self-Efficacy in an Introductory Computer Science Course

  • Rory Kelly
  • Meghan Allen
+

Introductory computer science courses often pose unique challenges for non-computer science majoring students, and understanding the factors that contribute to these struggles is crucial for enhancing students' learning experiences. This research delves into the engagement and self-efficacy of 14 international undergraduate students enrolled in an introductory computer science course tailored for non-CS majors. We use a combination of an initial online survey and the Experience Sampling Method (ESM) to gather data on students' experiences and perceptions throughout the course. The ESM interviews conducted during students' tutorials offer real-time insight into the fluctuations of their engagement and self-efficacy. Findings reveal a positive correlation between aspects of engagement and self-efficacy, indicating that students' higher levels of engagement coincide with stronger beliefs in their capabilities to succeed in the course. Moreover, we identified course topics with which students were disengaged and that corresponded to lower self-efficacy. By recognizing the challenges faced by non-CS majoring students and the impact of specific course topics and teaching styles on their engagement and self-efficacy, we provide advice for designing tailored interventions and instructional strategies.

+
+ + +

Witter: A Library for White-Box Testing of Introductory Programming Algorithms

  • Afonso Caniço
  • André Santos
+

Software testing is mostly performed in a black-box manner, that is, without incorporating any knowledge of the internal workings of programs into the tests. This practice usually suffices for enterprises and general practitioners, where the focus lies on producing reliable results while most algorithmic tasks are provided by third-party libraries. However, for computer science students and the like, it might not be straightforward to discern the underlying causes of an incorrect test result or to understand why certain algorithmic goals are not met. We present Witter, a software testing library that allows programming educators to define white-box tests for Java source code. Our tests analyze the execution of a method against a reference solution, to verify that the code not only produces correct results but is also in accordance with a desired algorithm behavior.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/splash23.html b/OpenTOC/splash23.html new file mode 100644 index 0000000..bb5f40d --- /dev/null +++ b/OpenTOC/splash23.html @@ -0,0 +1,267 @@ +SPLASH 2023: Companion Proceedings of the 2023 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity

SPLASH 2023: Companion Proceedings of the 2023 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity

+ Full Citation in the ACM Digital Library +

SESSION: Doctoral Symposium

+

Remote Just-in-Time Compilation for Dynamic Languages

  • Andrej Pečimúth
+

Cloud platforms allow applications to meet fluctuating levels of demand through automatic horizontal scaling. These deployment models are characterized by short-lived applications running in resource-constrained environments. This amplifies the overhead of dynamic languages with just-in-time (JIT) compilation. Dynamic-language runtimes suffer from a warmup phase and resource-usage peaks caused by JIT compilation. Offloading compilation jobs to a dedicated server is a possible mitigation for these problems. We propose leveraging remote JIT compilation as a means to enable coordination between the independent instances. By sharing compilation results, aggregating profiles, and adapting the compiler and compilation policy, we strive to improve the peak performance and further reduce the warmup time of these applications. Additionally, an implementation on top of the Truffle framework enables us to bring these benefits to many popular languages.

+
+ + +

Scaling up Program Synthesis to Efficient Algorithms

  • Ruyi Ji
+

The automatic synthesis of algorithms can effectively reduce the difficulty of algorithm design. However, multiple challenges exist for synthesizing algorithms. Among them, scalability of the synthesizer is the most prominent one because of the significant complexity of efficient algorithms. To address this scalability challenge, we propose several approaches from two aspects, improving the efficiency of existing program synthesizers and reducing the difficulty of algorithm synthesis by properly using algorithmic knowledge, respectively.

+
+ + +

Large Language Models for Automated Program Repair

  • Francisco Ribeiro
+

This paper introduces two methods for automated program repair (APR) utilizing pre-trained language models. The first method demonstrates program repair as a code completion task and is validated on a dataset of Java programs. The second method, Mentat, leverages OCaml’s parser and type system as fault localization techniques to generate prompts for GPT-3, producing candidate patches. Evaluation results show promising repair rates, with 27% and 39.2% effectiveness, respectively. For OCaml, a comparative study employing an automated validation strategy is presented in which the technique outperforms other tools. Language models are effective at APR, enhancing bug fixing and freeing developers to focus on other critical aspects of software engineering.

+
+ + +

Transforming Ideas into Code: Visual Sketching for ML Development

  • Luís Gomes
+

We propose a novel code assistant and generation paradigm aimed at closing the gap between visual sketching and code creation for Machine Learning (ML) development. This approach empowers developers and ML practitioners to translate hand-drawn sketches into functional code with enhanced accuracy and usability. Developers are recruited to assess the tool's performance. This research contributes to the future of low-code approaches, facilitating ML application development, and promoting an intuitive and accessible programming environment.

+
+ + +

Semantic Versioning for Python Programs

  • Luís Carvalho
+

We propose a language-based approach to software + versioning. Unlike the traditional approach of mainstream version control systems, + where each evolution step is represented by a textual diff, we treat + versions as programming elements. Each evolution step, merge operation, + and version relationship, is represented explicitly in the program. + This provides compile time guarantees for safety code reuse from previous versions, as + well as forward and backwards compatibility between versions, allowing clients to use newly introduced code without needing to refactor their program. + By lifting the versioning to the language level, we pave the way for tools that interact with + software repositories to have more insight regarding the evolution of the software semantics.

+
+ + +

Reusing Single-Language Analyses for Static Analysis of Multi-language Programs

  • Tobias Roth
+

State-of-the-art software is crafted in multiple programming languages. +Such multi-language software challenges static analyses: +Since many static analyses are focused on analyzing single-language programs, they are inherently unsound or imprecise in analyzing cross-language interaction. +Existing approaches that perform multi-language analysis are not analysis- or language independent and thus lack in extensibility for new analyses and languages. +We will develop an extensible, language-, framework-, and analysis-independent architecture to reuse existing static analyses for analyzing multi-language software. +Our hypotheses are that, our architecture allows reusing existing single-language analyses and improves precision and soundness compared to the state of the art. +We will evaluate our architecture with a points-to and data flow analysis for Java, JavaScript, and C/C++ code and compare it against the state of the art.

+
+ + +

A Pragmatic Approach to Syntax Repair

  • Breandan Considine
+

Programming languages share a social and formal heritage. These families were historically divided, but share deep roots, and we argue their destined matrimony heralds important consequences for language design and generative language modeling. In our work, we develop a sociotechnical framework for understanding the dynamics of programming and argue it captures many of the social and formal properties of language acquisition and evolution.

+
+ +

SESSION: SRC

+

Partial Gradual Dependent Type Theory

  • Zhan Shi
+

Gradual typing supports imprecise types in the type system, allowing incremental migration from untyped code to typed in the same language. Through the gradual typing approach, our ongoing work proposes a new theory based on the Martin-Löf type theory called Partial Gradual Dependent Type Theory. PGTT supports a gradual step from non-dependently typed code to dependently typed, enhancing the functionality of code reasoning while preserving the usability of widely used non-dependent type systems. PGTT restricts entirely unknown types and only permits dynamic terms on the type indices, making it naturally maintain better properties than existing gradual dependent type theories. It allows us to simplify runtime type checks into type parameter checks and elaborate the surface language into a static, dependently typed language, thereby reducing the performance overhead associated with gradual typing.

+
+ + +

Synthesizing Recursive Programs through Dataflow Constraints

  • Marta Davila Mateu
+

Despite great progress in algorithms for synthesizing recursive programs, state of the art approaches continue to have several limitations. Principal among these is their inability to “invent” auxiliary functions. This makes them sensitive to the available set of primitive components. In this paper, we present an alternative approach to recover recursive programs. We develop a system of constraints that characterizes patterns of data flow in the unrollings of a recursive program. Combined with a generator of seed nonrecursive circuits and a constraint solver, these constraints naturally form the basis of a general algorithm to synthesize recursive circuits.

+
+ + +

Modular Educational Languages

  • Jesse Hoobergs
+

Teaching novices to program is an unsolved problem. +One part of the problem lies in the fact that industrial languages are used for teaching novices, while they were not made for this purpose. +I am designing a Programming Education Runtime System to easily create modular languages for education. +This system utilizes object algebras, trampolining and algebraic effects and handlers. +It has been used to implement an interpreter for the Hedy programming language. +This implementation has several important advantages over the existing one, such as better debugging support and better integration with the Hedy platform.

+
+ + +

Historiographer: Strongly-Consistent Distributed Reactive Programming with Minimal Locking

  • Julia Freeman
  • Timothy Zhou
+

We propose a novel distributed reactive propagation semantics that provides strong consistency guarantees with minimal locking. This is achieved by decoupling reactive propagation from transaction execution, utilizing reactive histories to avoid propagating in-progress or inconsistent results. We formally define soundness properties in terms of histories, and sketch how our semantics upholds them. We implement Historiographer, a runtime incorporating our methods, and conduct a preliminary evaluation demonstrating performance improvements of up to 38% on select benchmarks.

+
+ + +

Clearing the Trail: Motivations for Maintenance Work in Open Source

  • Katrina Wilson
+

Introducing new maintainers to established projects is critical to the long-term sustainability of open-source projects. Yet, we have little understanding of what motivates developers to join and maintain already established projects. Previous research on volunteering motivations emphasizes that individuals are motivated by a unique set of factors to volunteer in a specific area, suggesting that the motivations behind open-source contributions also depend on the nature of the work. We aim to determine correlations between types of open-source contributions and their specific motivators through surveys of open-source contributors.

+
+ + +

Design and Implementation of Facets of Dynamic Policies

  • Antonio Zegarelli
+

Information Flow Control (IFC) in dynamic contexts is challenging due to different interpretations of security that arise. This paper introduces a modular framework to address this challenge. We present a dynamic floating-label enforcement mechanism that can be instantiated based on the intended security. Our approach formalizes a simply typed λ-calculus, extended with IFC operations, and adopts an epistemic perspective on security definition.

+
+ + +

Towards the Formal Verification of Wigderson’s Algorithm

  • Siraphob Phipathananunth
+

We present progress towards the formal verification of Wigderson’s graph coloring algorithm in Coq. We have created a library of formalized graph theory that aims to bridge the literature gap between introductory material on Coq and large-scale formal developments, while providing a motivating case study. Our library contains over 180 proven theorems. The development is available at https://github.com/siraben/coq-wigderson.

+
+ + +

An Optimal Structure-Aware Code Difference Framework with MaxSAT-Solver

  • Haolin Ye
+

The Abstract Syntax Tree (AST) serves as a pivotal representation of program codes, offering a structured and hierarchical view of the program’s syntax. When developers modify code, the underlying AST also evolves to reflect these changes. Tree-diff algorithms, such as truediff and Gumtreediff, are developed to compare different versions of the AST and identify the modifications made between them. However, these heuristics are based on certain vertex matching methods that do not ensure optimality and preciseness. In this study, I propose a novel tree-diff approach that utilizes a MaxSAT (Maximum satisfiability) solver to address this issue. By encoding potential vertex matches and edges with associated costs as a tree-diff SAT problem, the MaxSAT solver effectively minimizes the edit distance and reveals the optimal vertex matching plan.

+
+ + +

Rose: Extensible Autodiff on the Web

  • Raven Rothkopf
+

Automatic differentiation (AD) has become the backbone for a new wave of optimization-driven domains such as computer graphics and machine learning over the past decade. However, existing AD systems face limitations, either lacking support for in-browser development or failing to harness more recent, compiler-based approaches to achieve both expressiveness and size-preserving differentiation. This work introduces Rose, a portable, extensible AD library that runs on the web. Through Rose, we aim to increase accessibility to AD and empower end-user programming in optimization-driven domains. We plan to evaluate Rose by replacing the AD engines of real-world, client-side optimization systems and assess the improvements on the computation power and expressiveness of such systems.

+
+ +

SESSION: Posters

+

Involving Users in Design of a Widely Used Language: A Case of ECMAScript (JavaScript) Standardization

  • Mikhail Barash
  • Yulia Startsev
  • Rolf Martin Glomsrud
+

We present an overview of primary feedback mechanisms used by Ecma International Technical Committee 39 (TC39), the standardizing body of JavaScript programming language.

+
+ + +

Dynamic Library Compartmentalization

  • Octave Larose
+

Software is composed of different parts with different goals, each with different needs. Security-wise, this means not all necessarily need the same permissions: it can be beneficial to isolate some code such that it has limited control over the process, following the principle of least privilege. Without any sort of compartmentalization, a vulnerability found in a sensitive part of an application means the entire process can get corrupted, as its entire memory is now open to be read and modified by the attacker. +

+

+One notable example of dangerous code is the use of external libraries: using a library implies that it is trusted, as it is run within the program's context and can therefore read and modify any program state. This means malicious or vulnerable code can be introduced to the system this way, which can compromise sensitive information that is present in the process' memory. This begs the question: if parts of the software cannot necessarily be trusted, what can we do to limit their capabilities over the process? +

+

+We propose a new library sandboxing approach, focusing on isolating dynamically loaded libraries. While existing approaches usually leverage static analysis to perform instrumentation at the source level and during build time, we instead strive to work entirely during the program's run time.

+
+ + +

Sui Move: Modern Blockchain Programming with Objects

  • Adam Welc
  • Sam Blackshear
+

This paper presents Sui Move, a new smart contract language for programming blockchains using objects as an abstraction.

+
+ + +

JaMaBuild: Mass Building of Java Projects

  • Matúš Sulír
  • Milan Nosáľ
+

Many large-scale Java empirical studies require not only source code but also resulting binaries such as JAR files. Pre-compiled datasets quickly become obsolete, and the creation of a custom corpus for every study is tedious. We present a prototype of JaMaBuild, a tool and a framework for mass building of Java projects from source. Given a list of projects and optional settings, it downloads the projects, filters them by user-definable criteria, builds them using Maven or Gradle, and collects outputs such as JAR files and build logs. Our tool can also be used for local build breakage studies.

+
+ + +

Extensible Testing for Infrastructure as Code

  • David Spielmann
  • Daniel Sokolowski
  • Guido Salvaneschi
+

Developers automate deployments with +Programming Languages Infrastructure as Code (PL-IaC) +by implementing IaC programs in popular languages +like TypeScript and Python. +Yet, systematic testing---well established for high-velocity software development---is rarely applied to IaC programs +because IaC testing techniques +are either slow or require extensive development effort. +To solve this dilemma, +we develop ProTI, a novel IaC unit testing approach, +and implement it for Pulumi TypeScript. +Our preliminary experiments +with simple type-based test case generators and oracles show +that ProTI can find bugs reliably in a short time, +often without writing any additional testing code. +ProTI's extensible plugin architecture allows +combining, adopting, and experimenting with new approaches, +opening the discussion about novel generators and oracles +for efficient IaC testing.

+
+ + +

A Functional Reactive Programming Language for Wirelessly Connected Shape-Changeable Chiplet-Based Computers

  • Yusuke Izawa
  • Junichiro Kadomoto
  • Hidetsugu Irie
  • Shuichi Sakai
+

This work presents the concept of MorphLang, a functional reactive programming language +tailored for shape-changeable computers, which are built using wirelessly +interconnected chiplets. MorphLang simplifies the programming process for these systems +by concentrating on the basic behaviors of individual nodes and their asynchronous +communication. The language allows for compilation into binary or Arduino formats, and +programs can be transmitted to each node either wirelessly or through physical +connections.

+
+ + +

ReactCOP: Modular and Scalable Web Development with Context-Oriented Programming

  • David H. Lorenz
  • Ofir Shmuel
+

We present a library named ReactCOP that extends React's +capabilities with support for Context-Oriented Programming. +The library lets developers manage behavioral variations +in React applications through layers, and adapt the +application's behavior dynamically based on different +contexts.

+
+ + +

Safe Combination of Data-Centric and Operation-Centric Consistency

  • Mirko Köhler
  • Guido Salvaneschi
+

Programming distributed systems requires maintaining consistency among data replicas. In recent years, various frameworks have proposed language-level abstractions for this, falling into two fundamental approaches: data-centric and operation-centric solutions. The former allow developers to explicitly assign consistency levels to data, the latter enable attaching consistency constraints to operations. In practice, developers may benefit from both in the same application: data-centric consistency harmonizes well with object-oriented programming, yet one may need the flexibility to access the same data with a different consistency level depending on the operation. Currently, there is no solution that integrates both: it is a conceptual challenge to unify these two models and design a type system capable of ensuring +their correct interaction. +We present ConOpY, a programming language that integrates both data-centric and operation-centric consistency into the same design. The ConOpY type system guarantees the proper usage of consistency levels, preventing consistency violations resulting from an improper mix of consistency models. ConOpY is implemented as a Java extension based on annotations.

+
+ + +

Towards Reusable GUI Structures

  • Knut Anders Stokke
  • Mikhail Barash
  • Jaakko Järvi
+

Graphical user interfaces present data as structures (lists, trees, grids). Convenient features to manipulate these structures are tedious to implement. We are working towards a GUI programming approach, where concise specifications of structures give rise to full-fledged GUIs with a complete set of structure manipulation features.

+
+ + +

Generating Domain-Specific Programs for Diagram Authoring with Large Language Models

  • Rijul Jain
  • Wode Ni
  • Joshua Sunshine
+

Large language models (LLMs) can generate programs in general-purpose languages from prose descriptions, but are not trained on many domain-specific languages (DSLs). Diagram authoring with Penrose, a diagramming system using three DSLs, exemplifies the utility of DSL program generation with LLMs, which enables diagram creation from prose. We provide methods to conceptualize and evaluate the structures of one-shot LLM prompts to generate error-free DSL programs and implement Penrose diagram creation from prose using LLMs. We will evaluate our LLM prompt structures by testing prompt variations across different diagramming domains and plan to run a user study to assess the ease of LLM-augmented Penrose diagramming over other tools.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/vmil23.html b/OpenTOC/vmil23.html new file mode 100644 index 0000000..a9e1687 --- /dev/null +++ b/OpenTOC/vmil23.html @@ -0,0 +1,203 @@ +VMIL 2023: Proceedings of the 15th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages

VMIL 2023: Proceedings of the 15th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages

+ Full Citation in the ACM Digital Library +

SESSION: Papers

+

CHERI Performance Enhancement for a Bytecode Interpreter

  • Duncan Lowther
  • Dejice Jacob
  • Jeremy Singer
+

During our port of the MicroPython bytecode interpreter to the CHERI-based Arm Morello platform, we encountered a number of serious performance degradations. This paper explores several of these performance issues in detail, in each case +we characterize the cause of the problem, the fix, and the corresponding interpreter performance improvement over a set of standard Python benchmarks. +

+

+While we recognize that Morello is a prototypical physical instantiation of the CHERI concept, we show that it is possible to eliminate certain kinds of software-induced runtime overhead that occur due to the larger size of CHERI capabilities (128 bits) relative to native pointers (generally 64 bits). +In our case, we reduce a geometric mean benchmark slowdown from 5x (before optimization) to 1.7x (after optimization) relative to AArch64, non-capability, execution. The worst-case slowdowns are greatly improved, from 100x (before optimization) to 2x (after optimization). +

+

+The key insight is that implicit pointer size presuppositions pervade systems code; whereas previous CHERI porting projects highlighted compile-time and execution-time errors exposed by pointer size assumptions, we instead focus on the performance implications of such assumptions.

+
+ + +

Revisiting Dynamic Dispatch for Modern Architectures

  • Dave Mason
+

Since the 1980s, Deutsch-Schiffman dispatch has been the standard method dispatch mechanism for languages like Smalltalk, Ruby, and Python. + While it is a huge improvement over the simple, semantic execution model, it has some significant drawbacks for modern hardware and applications. +

+

+ + This paper proposes an alternative dispatch mechanism that addresses these concerns, with only memory space as a trade-off, that should demonstrate dynamic performance only slightly worse than the best possible with full type information for the program.

+
+ + +

Debugging Dynamic Language Features in a Multi-tier Virtual Machine

  • Anmolpreet Singh
  • Aayush Sharma
  • Meetesh Kalpesh Mehta
  • Manas Thakur
+

Multi-tiered virtual-machine (VM) environments with Just-In-Time (JIT) compilers are essential for optimizing dynamic language program performance, but comprehending and debugging them is challenging. +In this paper, we introduce Derir; a novel tool for tackling this issue in the context of Ř, a JIT compiler for R. +Derir demystifies Ř, catering to both beginners and experts. +It allows users to inspect the system's runtime state, make modifications, and visualize contextual specializations. +With a user-friendly interface and visualization features, Derir empowers developers to explore, experiment, and gain insights into the inner workings of a specializing JIT system. +We evaluate the effectiveness and usability of our tool through real-world use cases, demonstrating its benefits in learning as well as debugging scenarios. +We believe that our tool holds promise for enhancing the understanding and debugging of complex VMs.

+
+ + +

Array Bytecode Support in MicroJIT

  • Shubham Verma
  • Harpreet Kaur
  • Marius Pirvu
  • Kenneth B. Kent
+

Eclipse OpenJ9 is a Java virtual machine (JVM), which initially interprets Java programs. OpenJ9 uses Just-in-Time (JIT) compilers—like the default Testarossa JIT (TRJIT)—to translate the bytecodes of the Java program into native code, which executes faster than interpreting. TRJIT is an optimizing compiler, which boosts an application’s long-term performance but can increase start-up time due to initial compiling. Despite this overhead, more often than not, start-up time is still improved when compared to an interpreter-only solution. MicroJIT aims to reduce this initial slowdown, making start-up time even quicker. MicroJIT is a non-optim­izing, template-based compiler, which aims to reduce compilation overhead and start-up time. Array bytecodes were not supported in the initial implementation of MicroJIT, forcing them to either be interpreted or compiled using TRJIT. This work implements array bytecodes such as, newarray, aaload, aastore, in MicroJIT and measures their impact on execution of the programs. The implementation is tested with a regression test suite and the experiments are performed on the DaCapo benchmark suite. The results show that TRJIT along with MicroJIT including array bytecodes support is approximately 4.36x faster than the interpreter and 1.02x faster than the MicroJIT without array bytecodes support. These findings highlight the potential of MicroJIT in improving the performance of Java programs by efficiently handling array bytecodes.

+
+ + +

Hybrid Execution: Combining Ahead-of-Time and Just-in-Time Compilation

  • Christoph Pichler
  • Paley Li
  • Roland Schatz
  • Hanspeter Mössenböck
+

Ahead-of-time (AOT) compilation is a well-known approach to statically compile programs to native code before they are executed. +In contrast, just-in-time (JIT) compilation typically starts with executing a slower, less optimized version of the code and compiles frequently executed methods at run time. +In doing so, information from static and dynamic analysis is utilized to speculate and help generate highly efficient code. +However, generating such an efficient JIT-compiled code is challenging, and this introduces a trade-off between warm-up performance and peak performance. +

+

+In this paper, we present a novel way to execute programs by bringing together the divergence that existed between AOT and JIT compilation. +Instead of having the JIT compiler analyze the program during interpretation to produce optimal code, critical functions are initially executed natively with code produced by the AOT compiler in order to gain a head start. +Thus, we avoid the overhead of JIT compilation for natively executed methods and increase the warm-up performance. +We implemented our approach in GraalVM, which is a multi-language virtual machine based on the Java HotSpot VM. +Improvements in warm-up performance show a speed-up of up to 1.7x.

+
+ + +

Collecting Garbage on the Blockchain

  • Luc Bläser
  • Claudio Russo
  • Ulan Degenbaev
  • Ömer S. Ağacan
  • Gabor Greif
  • Jason Ibrahim
+

We present a garbage collector that is specifically designed for a WebAssembly-based blockchain, such as the Internet Computer. Applications on the blockchain implement smart contracts that may have indefinitely long lifetime and may hold substantial monetary value. This imposes a different set of requirements for garbage collection compared to traditional platforms. In this paper, we explain the differences and show how our garbage collector optimizes towards these goals.

+
+ + +

Beehive SPIR-V Toolkit: A Composable and Functional API for Runtime SPIR-V Code Generation

  • Juan Fumero
  • György Rethy
  • Athanasios Stratikopoulos
  • Nikos Foutris
  • Christos Kotselidis
+

The Standard Portable Intermediate Representation (SPIR-V) is a low-level binary format designed for representing shaders and compute kernels that can be consumed by OpenCL for computing kernels, and Vulkan for graphics rendering. As a binary representation, SPIR-V is meant to be used by compilers and runtime systems, and is usually performed by C/C++ programs and the LLVM software and compiler ecosystem. However, not all programming environments, runtime systems, and language implementations are C/C++ or based on LLVM. +

+

+This paper presents the Beehive SPIR-V Toolkit; a framework that can automatically generate a Java composable and functional library for dynamically building SPIR-V binary modules. The Beehive SPIR-V Toolkit can be used by optimizing compilers and runtime systems to generate and validate SPIR-V binary modules from managed runtime systems. Furthermore, our framework is architected to accommodate new SPIR-V releases in an easy-to-maintain manner, and it facilitates the automatic generation of Java libraries for other standards, besides SPIR-V. The Beehive SPIR-V Toolkit also includes an assembler that emits SPIR-V binary modules from disassembled SPIR-V text files, and a disassembler that converts the SPIR-V binary code into a text file. To the best of our knowledge, the Beehive SPIR-V Toolkit is the first Java programming framework that can dynamically generate SPIR-V binary modules. +

+

+To demonstrate the use of our framework, we showcase the integration of the SPIR-V Beehive Toolkit in the context of the TornadoVM, a Java framework for automatically offloading and running Java programs on heterogeneous hardware. We show that, via the SPIR-V Beehive Toolkit, TornadoVM is able to compile code 3x faster than its existing OpenCL C JIT compiler, and it performs up to 1.52x faster than the existing OpenCL C backend in TornadoVM.

+
+ + +

Gigue: A JIT Code Binary Generator for Hardware Testing

  • Quentin Ducasse
  • Pascal Cotret
  • Loïc Lagadec
+

Just-in-time compilers are the main virtual machine components responsible for performance. They recompile frequently used source code to machine code directly, avoiding the slower interpretation path. Hardware acceleration and performant security primitives would benefit the generated JIT code directly and increase the adoption of hardware-enforced primitives in a high-level execution component. +

+

+The RISC-V instruction set architecture presents extension capabilities to design and integrate custom instructions. It is available as open-source and several capable open-source cores coexist, usable for prototyping. Testing JIT-compiler-specific instruction extensions would require extending the JIT compiler itself, other VM components, the underlying operating system, and the hardware implementation. As the cost of hardware prototyping is already high, a lightweight representation of the JIT compiler code region in memory would ease prototyping and implementation of new solutions. +

+

+In this work, we present Gigue, a binary generator that outputs bare-metal executable code, representing a JIT code region snapshot composed of randomly filled methods. Its main goal is to speed up hardware extension prototyping by defining JIT-centered workloads over the newly defined instructions. It is modular and heavily configurable to qualify different JIT code regions' implementations from VMs and different running applications. We show how the generated binaries can be extended with three custom extensions, whose execution is guaranteed by Gigue's testing framework. We also present different application case generation and execution on top of a fully-featured RISC-V core.

+
+ + +

Approximating Type Stability in the Julia JIT (Work in Progress)

  • Artem Pelenitsyn
+

Julia is a dynamic language for scientific computing. For a dynamic language, +Julia is surprisingly typeful. Types are used not only to structure data but +also to guide dynamic dispatch – the main design tool in the language. No +matter the dynamism, Julia is performant: flexibility is compiled away at the +run time using a simple but smart type-specialization based optimization +technique called type stability. Based on a model of a JIT mimicking Julia +from previous works, we present the first algorithm to approximate type +stability of Julia code. Implementation and evaluation of the algorithm is +still a work in progress.

+
+ + +

Transpiling Slang Methods to C Functions: An Example of Static Polymorphism for Smalltalk VM Objects

  • Tom Braun
  • Marcel Taeumel
  • Eliot Miranda
  • Robert Hirschfeld
+

The OpenSmalltalk-VM is written in a subset of Smalltalk +which gets transpiled to C. Developing the VM in Smalltalk +allows to use the Smalltalk developer tooling and brings +a fast feedback cycle. However, transpiling to C requires +mapping Smalltalk constructs, i.e., object-oriented concepts, +to C, which sometimes requires developers to use a different +design than they would use when developing purely in +Smalltalk. +We describe a pragmatic extension for static polymorphism +in Slang, our experience using it as well as the shortcomings +of the new approach. While our solution extends the +concepts developers can express in Slang, which reduces the +burden of finding alternatives to well-known design patterns +and by enabling the use of such patterns the modularity, it +further complicates a fragile, already complicated system. +While our extension solves the task it was designed for, it +needs further enhancements, as does Slang itself in terms +of understandability in the field.

+
+ + +

Extraction of Virtual Machine Execution Traces

  • Daniel Pekarek
  • Hanspeter Mössenböck
+

Debugging virtual machines can be challenging. Advanced debugging techniques using execution trace analysis can simplify debugging, but they often show only the execution of the virtual machine (in terms of machine instructions) and not the execution of the guest program (in terms of VM instructions). Ideally, the virtual machine as well as the guest program should be inspectable simultaneously to quickly locate the bug.

Our approach provides a debugging environment which uses an execution trace of a virtual machine and derives the execution trace of the guest program running on it. The transformation is performed by transformation rules which inspect events from the virtual machine’s execution trace, collect necessary information, and then emit the events of the guest program’s execution trace. By linking both traces, navigation in the virtual machine’s execution trace is greatly simplified. When analyzing a simple virtual machine, our approach causes a 9.6% slowdown and an increase of 22% in memory consumption of the underlying execution trace analysis tool.

+
+ +
\ No newline at end of file diff --git a/_data/OpenTOC.yaml b/_data/OpenTOC.yaml index bc3b4b8..101abd0 100644 --- a/_data/OpenTOC.yaml +++ b/_data/OpenTOC.yaml @@ -1305,3 +1305,47 @@ event: TyDe year: 2023 title: "Proceedings of the 8th ACM SIGPLAN International Workshop on Type-Driven Development" +- + event: MPLR + year: 2023 + title: "Proceedings of the 20th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes" +- + event: FTSCS + year: 2023 + title: "Proceedings of the 9th ACM SIGPLAN International Workshop on Formal Techniques for Safety-Critical Systems" +- + event: SPLASH-E + year: 2023 + title: "Proceedings of the 2023 ACM SIGPLAN International Symposium on SPLASH-E" +- + event: PAINT + year: 2023 + title: "Proceedings of the 2nd ACM SIGPLAN International Workshop on Programming Abstractions and Interactive Notations, Tools, and Environments" +- + event: REBLS + year: 2023 + title: "Proceedings of the 10th ACM SIGPLAN International Workshop on Reactive and Event-Based Languages and Systems" +- + event: VMIL + year: 2023 + title: "Proceedings of the 15th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages" +- + event: Onward! + year: 2023 + title: "Proceedings of the 2023 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software" +- + event: GPCE + year: 2023 + title: "Proceedings of the 22nd ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences" +- + event: SLE + year: 2023 + title: "Proceedings of the 16th ACM SIGPLAN International Conference on Software Language Engineering" +- + event: DLS + year: 2023 + title: "Proceedings of the 19th ACM SIGPLAN International Symposium on Dynamic Languages" +- + event: SPLASH + year: 2023 + title: "Companion Proceedings of the 2023 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity" From bf5205476f76a39c5869fd0f0515f154593d2039 Mon Sep 17 00:00:00 2001 From: Antony Hosking Date: Fri, 27 Oct 2023 19:21:55 +1100 Subject: [PATCH 08/64] Add ICFP and OOPSLA MIPs --- _data/ICFP.yaml | 14 ++++++++++++++ _data/OOPSLA.yaml | 15 +++++++++++++++ 2 files changed, 29 insertions(+) diff --git a/_data/ICFP.yaml b/_data/ICFP.yaml index c753fd7..0721c2f 100644 --- a/_data/ICFP.yaml +++ b/_data/ICFP.yaml @@ -1,3 +1,17 @@ +2023: +- Awardee: Ohad Kammar, Sam Lindley and Nicolas Oury + Other: | + (for 2013) _[Handlers in Action](https://dl.acm.org/doi/abs/10.1145/2500365.2500590)_ + Citation: | + This paper drew the attention of the ICFP community to handlers as + an abstraction for effectful computation. In exposition, and in + providing the first operational semantics for handlers & effects, + and an effect system, it seeded many subsequent + works. Pragmatically, it detailed implementation of handlers in + Haskell, and outlined the ideas behind OCaml, SML, and Racket + implementations, as well as providing experimental results + comparing handlers with equivalent monadic code. + 2022: - Awardee: Deian Stefan, Alejandro Russo, Pablo Buiras, Amit Levy, John C. Mitchell and David Mazières Other: | diff --git a/_data/OOPSLA.yaml b/_data/OOPSLA.yaml index a89799d..b581a56 100644 --- a/_data/OOPSLA.yaml +++ b/_data/OOPSLA.yaml @@ -1,3 +1,18 @@ +2023: +- Awardee: Leo Meyerovich and Ariel Rabkin + Other: | + (for 2013) _[Empirical analysis of programming language adoption](https://dl.acm.org/doi/10.1145/2509136.2509515)_ + Citation: | + Some programming languages become wildly popular while others fade + away. This paper seeks to answer why, by performing an empirical + study spanning hundreds of thousands of open-source software + projects and interviews with thousands of programmers. The + methodology used in the paper is thorough, and the paper provides + insights of interest to the broader Programming Languages + community. Overall, this paper is a role model for large-scale + empirical studies of programming languages, making it worthy of + the OOPSLA 2013 Most Influential Paper Award. + 2022: - Awardee: Adam Betts, Nathan Chong, Alastair Donaldson, Shaz Qadeer and Paul Thomson Other: | From afa86186e17259191cefa1629003194e1d531aeb Mon Sep 17 00:00:00 2001 From: Stefan Marr Date: Thu, 2 Nov 2023 11:38:08 +0000 Subject: [PATCH 09/64] Fix old typos --- Conferences/DLS.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Conferences/DLS.md b/Conferences/DLS.md index 4299d1a..50e6910 100644 --- a/Conferences/DLS.md +++ b/Conferences/DLS.md @@ -1,6 +1,6 @@ --- layout: default -title: "Dynamic Languages Symposium (DLS) " +title: "Dynamic Languages Symposium (DLS)" --- The Dynamic Languages Symposium (DLS) is a forum for discussion of dynamic languages, their implementation and application. While mature @@ -17,7 +17,7 @@ DLS 2023 - Cascais, Portugal, October, 2023 - Co-located with SPLASH 2023 -- PC chair: Stefan, University of Kent, UK +- PC chair: Stefan Marr, University of Kent, UK - [https://2023.splashcon.org/home/dls-2023](https://conf.researchr.org/home/dls-2023) @@ -30,9 +30,9 @@ Awards - Conference: DLS 2012 - Paper: [https://dl.acm.org/doi/10.1145/2384577.2384587](https://dl.acm.org/doi/10.1145/2384577.2384587) - Citation: Over the past decade, the authors and their collaborators - have taken the ideas from this paper and turned it into the Truffle and GraalVMsystem, + have taken the ideas from this paper and turned it into the Truffle and GraalVM system, which has revolutionized how we implement languages on the JVM. - Today, the GraalVM is a major product and Truffle is a language implementationtechnology + Today, the GraalVM is a major product and Truffle is a language implementation technology producing high-performance implementations of everything from Ruby to C, all built upon the ideas of AST rewriting in the interpreter. From f7bdd14bef40e19c0ca11a7101f5c93c85cf895c Mon Sep 17 00:00:00 2001 From: Stefan Marr Date: Thu, 2 Nov 2023 11:38:24 +0000 Subject: [PATCH 10/64] Update Steering Committee --- Conferences/DLS.md | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/Conferences/DLS.md b/Conferences/DLS.md index 50e6910..5b48ad0 100644 --- a/Conferences/DLS.md +++ b/Conferences/DLS.md @@ -274,12 +274,15 @@ Steering Committee Members ### Present -* Chair: Tim Felgentreff, Oracle Labs, Germany (SC Chair 2018-2021, PC Chair 2018) +* Chair: Stefan Marr, University of Kent, UK (SC Chair 2022-2024, PC Chair 2019, 2023) * Davide Ancona, Università degli studi di Genova, Italy (PC Chair 2017) +* Wolfgang De Meuter, Vrije Universiteit Brussel, Belgium (PC Chair 2022) +* Tim Felgentreff, Oracle Labs, Germany (SC Chair 2018-2021, PC Chair 2018) +* Arjun Guha, Northeastern University, USA, (PC Chair 2021, 2022) * Carl Friedrich Bolz-Tereick, Heinrich-Heine-Universität Düsseldorf, Germany (Past SC Chair 2018-2021, SC Chair 2015-2018, PC Chair 2013) * Robert Hirschfeld, Hasso Plattner Institute and University of Potsdam, Germany (Member at Large 2018-2020, Past SC Chair 2015-2018, SC Chair 2007-2015, PC Chair 2007, PC Chair 2006) -* Stefan Marr, University of Kent, UK (PC Chair 2019) -* Benjamin C. Pierce, University of Pennsylvania, USA (SIGPLAN 2018-2021) + +* Anders Møller, Aarhus University, Denmark (SIGPLAN since 2021) * Laurence Tratt, King's College London, UK (Emeritus Member 2018-2020, Emeritus Member 2016-2018, PC Chair 2014) ### Past @@ -292,6 +295,7 @@ Steering Committee Members * Jeremy Gibbons (SIGPLAN 2012-2015) * Roberto Ierusalimschy (PC Chair 2016) * James Noble (PC Chair 2009) +* Benjamin C. Pierce, University of Pennsylvania, USA (SIGPLAN 2018-2021) * Manuel Serrano (PC Chair 2015) * Peter Thiemann (SIGPLAN 2015-2018) * Dave Thomas (Member at Large 2007-2013) From 5cb123e9cab7ea6721133ee25fa6421bf5759f77 Mon Sep 17 00:00:00 2001 From: Stefan Marr Date: Thu, 2 Nov 2023 11:38:36 +0000 Subject: [PATCH 11/64] Added details for 2023 and award --- Conferences/DLS.md | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/Conferences/DLS.md b/Conferences/DLS.md index 5b48ad0..d599de1 100644 --- a/Conferences/DLS.md +++ b/Conferences/DLS.md @@ -24,6 +24,22 @@ DLS 2023 Awards ------ +- Most Notable Paper Award 2023 for 2013 + - Recipients: Esteban Allende, Johan Fabry, Éric Tanter + - Title: Cast Insertion Strategies for Gradually-Typed Objects + - Conference: DLS 2013 + - Paper: [https://doi.org/10.1145/2508168.2508171](https://doi.org/10.1145/2508168.2508171) + - Citation: This paper explored the costs, both at micro and macro scale, + of various strategies for protecting gradual types in a gradually-typed + programming language, examining how different strategies affected untyped, + typed, or both components of code. It is a seminal contribution to understanding + the performance of gradual typing, which since then has been an area of important research. + The strategies used in gradually-typed languages today can trace their lineage + back to the strategies described and proposed in this paper. + In particular, the proposed hybrid approach has been adapted time and + time again by many systems, giving this work a lasting impact beyond its original scope. + + - Most Notable Paper Award 2022 for 2012 - Recipients: Thomas Würthinger, Andreas Wöß, Lukas Stadler, Gilles Duboscq, Doug Simon, and Christian Wimmer - Title: Self-optimizing AST interpreters @@ -135,6 +151,13 @@ Awards Past Events ----------- +- DLS 2023 + - Cascais, Portugal, October 24, 2023 + - Co-located with SPLASH 2023 + - PC chairs: Stefan Marr, University of Kent, UK + - [https://2023.splashcon.org/home/dls-2023](https://2023.splashcon.org/home/dls-2023) + - [http://www.dynamic-languages-symposium.org/dls-23/](http://www.dynamic-languages-symposium.org/dls-23/) + - DLS 2022 - Auckland, New Zealand, Dec 6, 2022 - Co-located with SPLASH 2022 From 04063239cb75b2fa304759dc3198b054220b1446 Mon Sep 17 00:00:00 2001 From: David Grove Date: Fri, 3 Nov 2023 13:34:18 -0400 Subject: [PATCH 12/64] update SPLASH SC post SPLASH 2023 --- _data/Committees.yaml | 4 ---- 1 file changed, 4 deletions(-) diff --git a/_data/Committees.yaml b/_data/Committees.yaml index 0e08934..dd077d2 100644 --- a/_data/Committees.yaml +++ b/_data/Committees.yaml @@ -199,19 +199,15 @@ SPLASH Steering Committee: - Chair: David Grove, IBM Research - Amal Ahmed, Northeastern University - Bor-Yuh Evan Chang, University of Colorado Boulder - - Wolfgang De Meuter, Vrije Universiteit Brussel - Sophia Drossopoulou, Imperial College London - Robert Hirschfeld, University of Potsdam; Hasso Plattner Institute - Antony Hosking, Australian National University - - Stephen Kell, King's College London - Shriram Krishnamurthi, Brown - - Hidehiko Masuhara, Tokyo Institute of Technology - Manu Sridharan, UC Riverside - Mira Mezini, TU Darmstadt - Alex Potanin, Victoria University of Wellington - Hridesh Rajan, Iowa State University - Sukyoung Ryu, Korea Advanced Institute of Science and Technology - - Yannis Smaragdakis, University of Athens - Tijs van der Storm, CWI & University of Groningen - Vasco T. Vasconcelos, University of Lisbon - Jan Vitek, Northeastern University / Czech Technical University From 4ace384b28c33a06014cc1207bda69f7463edecc Mon Sep 17 00:00:00 2001 From: Nadia Polikarpova Date: Sat, 4 Nov 2023 16:33:40 -0700 Subject: [PATCH 13/64] Add mentor and re-sort by last name --- LongTermMentoring.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/LongTermMentoring.md b/LongTermMentoring.md index b187f4e..9d48b87 100644 --- a/LongTermMentoring.md +++ b/LongTermMentoring.md @@ -83,6 +83,7 @@ We'd like to thank these amazing mentors: - Tom Ball - Sheng Chen - Michael Coblenz +- Jonathan DiLorenzo - Alastair Donaldson - Sebastian Erdweg - Tobias Grosser @@ -121,7 +122,7 @@ We'd like to thank these amazing mentors: - Max Willsey - Dominik Winterer - Li-yao Xia -- Jonathan DiLorenzo +- Jie Zhou And we'd of course also like to thank everyone else who has served or currently serves as a mentor for SIGPLAN-M! From a16b901588d4654720c8c3366657161b026a7ed0 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Sat, 11 Nov 2023 16:41:02 -0500 Subject: [PATCH 14/64] Announce --- _announce/2023-10-25-prisc_2024.txt | 121 ++++++++++++++++++++++++++++ 1 file changed, 121 insertions(+) create mode 100644 _announce/2023-10-25-prisc_2024.txt diff --git a/_announce/2023-10-25-prisc_2024.txt b/_announce/2023-10-25-prisc_2024.txt new file mode 100644 index 0000000..a5910e2 --- /dev/null +++ b/_announce/2023-10-25-prisc_2024.txt @@ -0,0 +1,121 @@ +--- +title: "PriSC 2024: Call for Presentations" +timestamp: "10/25/2023 15:39:33" +deadline: "11/2/2023" +--- +Short version: PriSC is a fun, welcoming and exciting venue. Share +updates, ideas, thoughts or send students for a friendly gathering +that may lead to future collaborations and ideas. Submit now! + +================================================ +Call for Presentations: PriSC 2024 @ POPL 2024 +================================================ + +Secure compilation is an emerging field that puts together advances in +security, programming languages, compilers, verification, systems, +and hardware architectures in order to devise more secure compilation +chains that eliminate many of today’s security vulnerabilities and +that allow sound reasoning about security properties in the source +language. For a concrete example, all modern languages provide a +notion of structured control flow and an invoked procedure is +expected to return to the right place. However, today’s compilation +chains (compilers, linkers, loaders, runtime systems, hardware) +cannot efficiently enforce this abstraction against linked low-level +code, which can call and return to arbitrary instructions or smash +the stack, blatantly violating the high-level abstraction. Other +problems arise because today’s languages fail to specify security +policies, such as data confidentiality, and the compilation chains +thus fail to enforce them, especially against powerful side-channel +attacks. The emerging secure compilation community aims to address +such problems by identifying precise security goals and attacker +models, designing more secure languages, devising efficient +enforcement and mitigation mechanisms, and developing effective +verification techniques for secure compilation chains. + +The goal of this workshop is to identify interesting research +directions and open challenges and to bring together researchers +interested in working on building secure compilation chains, on +developing proof techniques and verification tools, and on designing +software or hardware enforcement mechanisms for secure compilation. + +8th Workshop on Principles of Secure Compilation (PriSC 2024) +============================================================= + +The Workshop on Principles of Secure Compilation (PriSC) is an +informal 1-day workshop without any proceedings. The goal is to bring +together researchers interested in secure compilation and to identify +interesting research directions and open challenges. The 8th edition +of PriSC will be held on January 20, 2024 in London, United Kingdom +together with the ACM SIGPLAN Symposium on Principles of Programming +Languages (POPL) 2024. + +Important Dates +=============== + +* Thu 02 Nov 2023: Submission Deadline +* Thu 07 Dec 2023: Acceptance Notification +* Sat 20 Jan 2024: Workshop + +Presentation Proposals and Attending the Workshop +================================================= + +Anyone interested in presenting at the workshop should submit an +extended abstract (up to 2 pages, details below) covering past, +ongoing, or future work. Any topic that could be of interest to +secure compilation is in scope. Secure compilation should be +interpreted very broadly to include any work in security, programming +languages, architecture, systems or their combination that can be +leveraged to preserve security properties of programs when they are +compiled or to eliminate low-level vulnerabilities. Presentations +that provide a useful outside view or challenge the community are +also welcome. This includes presentations on new attack vectors such +as microarchitectural side-channels, whose defenses could benefit +from compiler techniques. + +Specific topics of interest include but are not limited to: + +* Attacker models for secure compiler chains. +* Secure compiler properties: fully abstract compilation and similar +properties, memory safety, control-flow integrity, preservation of +safety, information flow and other (hyper-)properties against +adversarial contexts, secure multi-language interoperability. +* Secure interaction between different programming languages: foreign +function interfaces, gradual types, securely combining different +memory management strategies. +* Enforcement mechanisms and low-level security primitives: static +checking, program verification, typed assembly languages, reference +monitoring, program rewriting, software-based isolation/hiding +techniques (SFI, crypto-based, randomization-based, +OS/hypervisor-based), security-oriented architectural features such +as Intel’s SGX, MPX and MPK, capability machines, side-channel +defenses, object capabilities. +* Experimental evaluation and applications of secure compilers. +* Proof methods relevant to compilation: (bi)simulation, logical +relations, game semantics, trace semantics, multi-language semantics, +embedded interpreters. +* Formal verification of secure compilation chains +(protection mechanisms, compilers, linkers, loaders), machine-checked +proofs, translation validation, property-based testing. + +Guidelines for Submitting Extended Abstracts +============================================ + +Extended abstracts should be submitted in PDF format and not exceed 2 +pages (references not included). They should be formatted in +two-column layout, 10pt font, and be printable on A4 and US Letter +sized paper. We recommend using the new acmart LaTeX style in sigplan +mode. + +Submissions are not anonymous and should provide sufficient +detail to be assessed by the program committee. Presentation at the +workshop does not preclude publication elsewhere. + +Contact and More Information +============================ + +You can find more information on the workshop website: +https://popl24.sigplan.org/home/prisc-2024 + +For questions please contact the workshop chairs, Marco Patrignani and +Shweta Shinde. + From 9ed76ca86522dae7c6a5a1fe75afdbc55d1fc169 Mon Sep 17 00:00:00 2001 From: Nadia Polikarpova Date: Mon, 13 Nov 2023 07:53:18 -0800 Subject: [PATCH 15/64] Add mentor (Yishuai Li) + ordering fix --- LongTermMentoring.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/LongTermMentoring.md b/LongTermMentoring.md index 9d48b87..192bd00 100644 --- a/LongTermMentoring.md +++ b/LongTermMentoring.md @@ -99,8 +99,9 @@ We'd like to thank these amazing mentors: - Ismail Kuru - Patrick Lam - Leonidas Lampropoulos -- Justin Lubin - John Leo +- Yishuai Li +- Justin Lubin - William Mansky - Mae Milano - Andrey Mokhov From 384139ed946778a50be84e4ffe2ad9d6dc461e1d Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Mon, 13 Nov 2023 11:13:21 -0500 Subject: [PATCH 16/64] Fix typo --- _data/Dissertation.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_data/Dissertation.yaml b/_data/Dissertation.yaml index 2576ffd..0010ea1 100644 --- a/_data/Dissertation.yaml +++ b/_data/Dissertation.yaml @@ -1,5 +1,5 @@ 2023: -- Awardee: "Sam Westrick, Carnegie Mellong University" +- Awardee: "Sam Westrick, Carnegie Mellon University" Other: _Efficient and Scalable Parallel Functional Programming through Disentanglement_ Advisor: "Umut Acar" Citation: | From 119ea6a113d4741b183a6d878d2a6e93410997fb Mon Sep 17 00:00:00 2001 From: David Grove Date: Mon, 13 Nov 2023 11:33:36 -0500 Subject: [PATCH 17/64] SPLASH SC updates: Jan is new chair; add Frank (GC'26) --- _data/Committees.yaml | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/_data/Committees.yaml b/_data/Committees.yaml index dd077d2..eacb406 100644 --- a/_data/Committees.yaml +++ b/_data/Committees.yaml @@ -196,21 +196,22 @@ SIGAPL Steering Committee: SPLASH Steering Committee: - SIGPLAN Chair: # - SIGPLAN Vice Chair: # - - Chair: David Grove, IBM Research + - Chair: Jan Vitek, Northeastern University / Czech Technical University - Amal Ahmed, Northeastern University - Bor-Yuh Evan Chang, University of Colorado Boulder - Sophia Drossopoulou, Imperial College London + - David Grove, IBM Research - Robert Hirschfeld, University of Potsdam; Hasso Plattner Institute - Antony Hosking, Australian National University - Shriram Krishnamurthi, Brown - - Manu Sridharan, UC Riverside - Mira Mezini, TU Darmstadt - Alex Potanin, Victoria University of Wellington - Hridesh Rajan, Iowa State University - Sukyoung Ryu, Korea Advanced Institute of Science and Technology + - Manu Sridharan, UC Riverside + - Frank Tip, Northeastern University - Tijs van der Storm, CWI & University of Groningen - Vasco T. Vasconcelos, University of Lisbon - - Jan Vitek, Northeastern University / Czech Technical University VEE Steering Committee: - Andrew Baumann, Microsoft Research From 1d80788b1a229213a84a858705454a4491ec317c Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Tue, 21 Nov 2023 17:48:18 -0500 Subject: [PATCH 18/64] HLF announce --- _announce/2023-11-18-hlf.txt | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 _announce/2023-11-18-hlf.txt diff --git a/_announce/2023-11-18-hlf.txt b/_announce/2023-11-18-hlf.txt new file mode 100644 index 0000000..ca00eec --- /dev/null +++ b/_announce/2023-11-18-hlf.txt @@ -0,0 +1,25 @@ +--- +title: "2024 Heidelberg Laureate Forum Young Researchers - Applications now open!" +timestamp: "11/18/2023 12:00:00" +deadline: "12/09/2024" +--- +Dear Colleague, + +I'm writing to seek your help in generating awareness of and interest in the [11th Heidelberg Laureate Forum (HLF)](https://www.heidelberg-laureate-forum.org/). + +HLF is where "Laureates of mathematics and computer science meet the next generation." It brings together Laureates in computing (recipients of the Turing Award and the ACM Prize in Computing) and mathematics (Abel Prize, Fields Medal, and the IMU Abacus Medal) with 100 young researchers in computing and 100 in mathematics. These young researchers are undergraduates, graduate students, and early-stage postdocs who represent a diverse group of global talent in the field. The event is a mix of Laureate lectures and discussions as well as social events for the young researchers to meet and talk with the Laureates. + +The 11th Heidelberg Laureate Forum will be held **September 22-27, 2024 in Heidelberg, Germany**. To be considered for participation, [young researchers can either apply directly](https://www.application.heidelberg-laureate-forum.org/site/index.php?a=cEs3NXRrRDJEelBFSDVsTTVBWkEzVlE5L3hPSzlEZmhwNnplMWJqRVhqd3BNUFRxblluVnZURnVqMzllWEFzVndDUUFWbi9qVXd6NHdaUWYzcU9GZzhBa0FGWi80MU1NK01HVUg5NmpoWU5sblBUVmp6VnAydE9zaEw5bVA3Rkg=) or be nominated by a colleague, professor, mentor, or manager who can attest to the quality of their work. In the selection process, nominated applications may carry a bit more weight than direct applications. If you or a colleague would like to make a nomination for a young researcher in computing, you will need to [register to be a nominator](https://www.application.heidelberg-laureate-forum.org/site/index.php?a=OE5vNVEyMGU1WUplUkJGUE51UUVkU0ZiUGVzNmZHWU9oeXowREt4OWJoc3BNUFRxblluVnZURnVqMzllWEFzVndDUUFWbi9qVXd6NHdaUWYzcU9GZzhBa0FGWi80MU1NK01HVUg5NmpoWU5sblBUVmp6VnAydE9zaEw5bVA3Rkg=) using the ACM "Organization code": **ACM59751**. In computing, the pool of applications and nominations will be reviewed by global computing experts from ACM. + +Applications must be completed by **February 9, 2024**. Read more about the young researcher HLF experience and how to apply in the [FAQ for Young Researchers](https://www.heidelberg-laureate-forum.org/young-researchers/faq.html). + +Through the Heidelberg Laureate Forum, ACM is helping to raise the visibility of the computing discipline worldwide as well as helping to provide an incomparable learning experience for young researchers. I hope you will share this information about the event with colleagues and students. I also hope your department (or school or laboratory or center) will be the source of several applications or nominations. + +Best regards, + +Vicki L. Hanson, PhD +Chief Executive Officer +Association for Computing Machinery (ACM) +1601 Broadway, 10th Floor +New York, NY 10019-7434 +USA From d1ec80d3248877c64cdadc5ab723a90b892eba96 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Fri, 1 Dec 2023 07:50:53 -0500 Subject: [PATCH 19/64] ICFP announcement --- _announce/2023-11-30-icfp_2024.txt | 204 +++++++++++++++++++++++++++++ 1 file changed, 204 insertions(+) create mode 100644 _announce/2023-11-30-icfp_2024.txt diff --git a/_announce/2023-11-30-icfp_2024.txt b/_announce/2023-11-30-icfp_2024.txt new file mode 100644 index 0000000..b9fde1a --- /dev/null +++ b/_announce/2023-11-30-icfp_2024.txt @@ -0,0 +1,204 @@ +--- +title: "ICFP 2024: Call for Papers" +deadline: "02/28/2024" +--- + PACMPL Volume 7, Issue ICFP 2024 + + Call for Papers + + Accepted papers to be invited for presentation at + +The 29th ACM SIGPLAN International Conference on Functional Programming + + Milan, Italy + +### Important dates + +(All dates are in 2023 at 11.59pm Anywhere on Earth.) + +Paper Submission -- Wed 28 Feb 2024 (AOE) +Paper Author Response -- Mon 29 Apr 12:00 - Wed 1 May 12:00 2024 +Paper Notification --Mon 20 May 2024 + + +### NEW THIS YEAR +------------------- + +* Full double blind reviewing + +### Scope +------------------- + +PACMPL issue ICFP 2024 seeks original papers on the art and science of functional programming. Submissions are invited on all topics from principles to practice, from foundations to features, and from abstraction to application. The scope includes all languages that encourage functional programming, including both purely applicative and imperative languages, as well as languages with objects, concurrency, or parallelism. Topics of interest include (but are not limited to): + +* Language Design: concurrency, parallelism, and distribution; modularity; components and composition; meta-programming; macros; pattern matching; type systems; type inference; dependent types; effect types; gradual types; refinement types; session types; interoperability; domain-specific languages; imperative programming; object-oriented programming; logic programming; probabilistic programming; reactive programming; generic programming; bidirectional programming. + +* Implementation: abstract machines; virtual machines; interpretation; compilation; compile-time and run-time optimisation; garbage collection and memory management; runtime systems; multi-threading; exploiting parallel hardware; interfaces to foreign functions, services, components, or low-level machine resources. + +* Software-Development Techniques: algorithms and data structures; design patterns; specification; verification; validation; proof assistants; debugging; testing; tracing; profiling; build systems; program synthesis. + +* Foundations: formal semantics; lambda calculus; program equivalence; rewriting; type theory; logic; category theory; computational effects; continuations; control; state; names and binding; program verification. + +* Analysis and Transformation: control flow; data flow; abstract interpretation; partial evaluation; program calculation. + +* Applications: symbolic computing; formal-methods tools; artificial intelligence; systems programming; distributed systems and web programming; hardware design; databases; scientific and numerical computing; graphical user interfaces; graphics and multimedia; GPU programming; scripting; system administration; security. + +* Education: teaching introductory programming; mathematical proof; algebra. + +Submissions will be evaluated according to their relevance, correctness, significance, originality, and clarity. Each submission should explain its contributions in both general and technical terms, clearly identifying what has been accomplished, explaining why it is significant, and comparing it with previous work. The technical content should be accessible to a broad audience. + +PACMPL issue ICFP 2024 also welcomes submissions in two separate categories — Functional Pearls and Experience Reports — that must be marked as such when submitted and that need not report original research results. Detailed guidelines on both categories are given at the end of this call. + +In an effort to achieve a balanced, diverse program, each author may be listed as a (co)author on a maximum of four submissions. Submissions from underrepresented groups are encouraged. Authors who require financial support to attend the conference can apply for PAC funding (http://www.sigplan.org/PAC/). + +The General Chair and PC Chair may not submit papers. PC members (other than the PC Chair) may submit papers. + +Please contact the Program Chair if you have questions or are concerned about the appropriateness of a topic. + +### Full Double-Blind Reviewing Process + +ICFP 2024 will use a full double-blind reviewing process (similar to the one used for POPL 2024 but different from the lightweight double-blind process used in previous years). This means that identities of authors will not be made visible to reviewers until after conditional-acceptance decisions have been made, and then only for the conditionally-accepted papers. The use of full double-blind reviewing has several consequences for authors. + +* Submissions: Authors must omit their names and institutions from their paper submissions. In addition, references to authors’ own prior work should be in the third person (e.g., not “We build on our previous work …” but rather “We build on the work of …”). + +* Supplementary material: Authors are permitted to provide supplementary material (e.g., detailed proofs, proof scripts, system implementations, or experimental data) along with their submission, which reviewers may (but are not required to) examine. This material may take the form of a single file, such as a PDF or a tarball. Authors must fully anonymize any supplementary material. Links to supplementary material on external websites are not permitted. + +* Author response: In responding to reviews, authors should not say anything that reveals their identity, since author identities will not be revealed to reviewers at that stage of the reviewing process. + +* Dissemination of work under submission: Authors are welcome to disseminate their ideas and post draft versions of their paper(s) on their personal website, institutional repository, or arXiv (reviewers will be asked to turn off arXiv notifications during the review period). But authors should not take steps that would almost certainly reveal their identities to members of the Program Committee, e.g., directly contacting PC members or publicizing the work on widely-visible social media or major mailing lists used by the community. + +The purpose of the above restrictions is to help the Program Committee and external reviewers come to a judgment about the paper without bias, not to make it impossible for them to discover the authors’ identities if they were to try. In particular, nothing should be done in the name of anonymity that weakens the quality of the submission. However, there are occasionally cases where adhering to the above restrictions is truly difficult or impossible for one reason or another. In such cases, the authors should contact the Program Chair to discuss the situation and how to handle it. + + +### Preparation of submissions +------------------------------- + +* Deadline: The deadline for submissions is Wednesday, 28 February , 2024, Anywhere on Earth (https://www.timeanddate.com/time/zones/aoe). This deadline will be strictly enforced. + +* Formatting: Submissions must be in PDF format, printable in black and white on US Letter sized paper and interpretable by common PDF tools. All submissions must adhere to the “ACM Small” template that is available (in both LaTeX and Word formats) from https://www.acm.org/publications/authors/submissions. + +There is a limit of 25 pages for a full paper or Functional Pearl and 12 pages for an Experience Report; in either case, the bibliography and an optional clearly marked appendix will not be counted against these limits. Submissions that exceed the page limits or, for other reasons, do not meet the requirements for formatting, will be summarily rejected. + +See also PACMPL’s Information and Guidelines for Authors at https://pacmpl.acm.org/authors.cfm. + +* Submission: Submissions will be accepted at https://icfp24.hotcrp.com/ + +Improved versions of a paper may be submitted at any point before the submission deadline using the same web interface. + +* Author Response Period: Authors will have a 72-hour period, starting at 12:00 (noon) AOE on Monday, 29 April, 2024, to read reviews and respond to them. + +* Appendix and Supplementary Material: Authors have the option to include a clearly marked appendix and/or to attach supplementary material to a submission, on the understanding that reviewers may choose not to look at such an appendix or supplementary material. Supplementary material may be uploaded as a separate PDF document or tarball. Any supplementary material must be uploaded at submission time, not by providing a URL in the paper that points to an external repository. All supplementary material must be anonymised. + +* Authorship Policies: All submissions are expected to comply with the ACM Policies for Authorship that are detailed at https://www.acm.org/publications/authors/information-for-authors. + +* Republication Policies: Each submission must adhere to SIGPLAN’s republication policy, as explained on the web at http://www.sigplan.org/Resources/Policies/Republication. + +* ORCID: ORCID provides a persistent digital identifier (an ORCID iD) that you own and control, and that distinguishes you from every other researcher: https://orcid.org/. ACM now require an ORCID iD for every author of a paper, not just the corresponding author. So, the author who is filling out the permission form should make sure they have the ORCID iDs for all of their coauthors before filling out the form. Any authors who do not yet have an ORCID iD can go to https://orcid.org/register to have one assigned. + +### Review Process +------------------- +This section outlines the two-stage process with lightweight double-blind reviewing that will be used to select papers for PACMPL issue ICFP 2024. New this year, ICFP 2024 will adapt a full double-blind reviewing process. More information see below. + +ICFP 2024 will have an Associate Chair who will help the PC Chair monitor reviews, solicit external expert reviews for submissions when there is not enough expertise on the committee, and facilitate reviewer discussions. + +PACMPL issue ICFP 2024 will employ a two-stage review process. The first stage in the review process will assess submitted papers using the criteria stated above and will allow for feedback and input on initial reviews through the author response period mentioned previously. As a result of the review process, a set of papers will be conditionally accepted and all other papers will be rejected. Authors will be notified of these decisions on 20 May, 2024. + +Authors of conditionally accepted papers will be provided with committee reviews along with a set of mandatory revisions. By 11 June, 2024, the authors should provide a second revised submission. The second and final reviewing phase assesses whether the mandatory revisions have been adequately addressed by the authors and thereby determines the final accept/reject status of the paper. The intent and expectation is that the mandatory revisions can feasibly be addressed within three weeks. + +The second submission should clearly identify how the mandatory revisions were addressed. To that end, the second submission must be accompanied by a cover letter mapping each mandatory revision request to specific parts of the paper. The cover letter will facilitate a quick second review, allowing for confirmation of final acceptance within two weeks. Conversely, the absence of a cover letter will be grounds for the paper’s rejection. + +### Information for Authors of Accepted Papers +---------------------------------------------- +As a condition of acceptance, final versions of all papers must adhere to the ACM Small format. The page limit for the final versions of papers will be increased by two pages to help authors respond to reviewer comments and mandatory revisions: 27 pages plus bibliography for a regular paper or Functional Pearl, 14 pages plus bibliography for an Experience Report. + +Authors of accepted submissions will be required to agree to one of the three ACM licensing options, one of which is Creative Commons CC-BY publication; this is the option recommended by the PACMPL editorial board. A reasoned argument in favour of this option can be found in the article Why CC-BY? published by OASPA, the Open Access Scholarly Publishers Association. The other options are copyright transfer to ACM or retaining copyright but granting ACM exclusive publication rights. + +PACMPL is a Gold Open Access journal, and authors are encouraged to publish their work under a CC-BY license. Gold Open Access guarantees permanent free online access to the definitive version in the ACM Digital Library, and the recommended CC-BY option also allows anyone to copy and distribute the work with attribution. Gold Open Access has been made possible by generous funding through ACM SIGPLAN, which will cover all open access costs in the event authors cannot. Authors who can cover the costs may do so by paying an Article Processing Charge (APC). PACMPL, SIGPLAN, and ACM Headquarters are committed to exploring routes to making Gold Open Access publication both affordable and sustainable. + +ACM Author-Izer is a unique service that enables ACM authors to generate and post links on either their home page or institutional repository for visitors to download the definitive version of their articles from the ACM Digital Library at no charge. Downloads through Author-Izer links are captured in official ACM statistics, improving the accuracy of usage and impact measurements. Consistently linking to the definitive version of an ACM article should reduce user confusion over article versioning. After an article has been published and assigned to the appropriate ACM Author Profile pages, authors should visit http://www.acm.org/publications/acm-author-izer-service to learn how to create links for free downloads from the ACM DL. + +The official publication date is the date the papers are made available in the ACM Digital Library. This date may be up to two weeks prior to the first day of the conference. The official publication date affects the deadline for any patent filings related to published work. + +Authors of each accepted submission are invited to attend and be available for the presentation of that paper at the conference. The schedule for presentations will be determined and shared with authors after the full program has been selected. + +### Artifact Evaluation +----------------------- +Authors of papers that are conditionally accepted in the first phase of the review process will be encouraged (but not required) to submit supporting materials for Artifact Evaluation. These items will then be reviewed by an Artifact Evaluation Committee, separate from the paper Review Committee, whose task is to assess how the artifacts support the work described in the associated paper. Papers that go through the Artifact Evaluation process successfully will receive a seal of approval printed on the papers themselves. Authors of accepted papers will be encouraged to make the supporting materials publicly available upon publication of the papers, for example, by including them as “source materials” in the ACM Digital Library. An additional seal will mark papers whose artifacts are made available, as outlined in the ACM guidelines for artifact badging. + +Participation in Artifact Evaluation is voluntary and will not influence the final decision regarding paper acceptance. + +### Special categories of papers +------------------------------- +In addition to research papers, PACMPL issue ICFP solicits two kinds of papers that do not require original research contributions: Functional Pearls, which are full papers, and Experience Reports, which are limited to half the length of a full paper. Authors submitting such papers should consider the following guidelines. + +* Functional Pearls +- A Functional Pearl is an elegant essay about something related to functional programming. Examples include, but are not limited to: + +- a new and thought-provoking way of looking at an old idea + +- an instructive example of program calculation or proof + +- a nifty presentation of an old or new data structure + +- an interesting application of functional programming techniques + +- a novel use or exposition of functional programming in the classroom + +While pearls often demonstrate an idea through the development of a short program, there is no requirement or expectation that they do so. Thus, they encompass the notions of theoretical and educational pearls. + +Functional Pearls are valued as highly and judged as rigorously as ordinary papers, but using somewhat different criteria. In particular, a pearl is not required to report original research, but, it should be concise, instructive, and entertaining. A pearl is likely to be rejected if its readers get bored, if the material gets too complicated, if too much-specialised knowledge is needed, or if the writing is inelegant. The key to writing a good pearl is polishing. + +A submission that is intended to be treated as a pearl must be marked as such on the submission web page and should contain the words “Functional Pearl” somewhere in its title or subtitle. These steps will alert reviewers to use the appropriate evaluation criteria. Pearls will be combined with ordinary papers, however, for the purpose of computing the conference’s acceptance rate. + +* Experience Reports +The purpose of an Experience Report is to describe the experience of using functional programming in practice, whether in industrial application, tool development, programming education, or any other area. + +Possible topics for an Experience Report include, but are not limited to: + +- insights gained from real-world projects using functional programming + +- comparison of functional programming with conventional programming in the context of an industrial project or a university curriculum + +- project-management, business, or legal issues encountered when using functional programming in a real-world project + +- curricular issues encountered when using functional programming in education + +- real-world constraints that created special challenges for an implementation of a functional language or for functional programming in general + +An Experience Report is distinguished from a normal PACMPL issue ICFP paper by its title, by its length, and by the criteria used to evaluate it. + +Both in the papers and in any citations, the title of each accepted Experience Report must end with the words “(Experience Report)” in parentheses. The acceptance rate for Experience Reports will be computed and reported separately from the rate for ordinary papers. + +Experience Report submissions can be at most 12 pages long, excluding bibliography. + +Each accepted Experience Report will be presented at the conference, but depending on the number of Experience Reports and regular papers accepted, authors of Experience Reports may be asked to give shorter talks. + +Because the purpose of Experience Reports is to enable our community to understand the application of functional programming, an acceptable Experience Report need not add to the body of knowledge of the functional-programming community by presenting novel results or conclusions. It is sufficient if the report describes an illuminating experience with functional programming, or provides evidence for a clear thesis about the use of functional programming. The experience or thesis must be relevant to ICFP, but it need not be novel. + +The review committee will accept or reject Experience Reports based on whether they judge the paper to illuminate some aspect of the use of functional programming. Anecdotal evidence will be acceptable provided it is well-argued and the author explains what efforts were made to gather as much evidence as possible. Typically, papers that show how functional programming was used are more convincing than papers that say only that functional programming was used. It can be especially effective to present comparisons of the situations before and after the experience described in the paper, but other kinds of evidence would also make sense, depending on context. Experience drawn from a single person’s experience may be sufficient, but more weight will be given to evidence drawn from the experience of groups of people. + +An Experience Report should be short and to the point. For an industrial project, it should make a claim about how well functional programming worked and why; for a pedagogy paper, it might make a claim about the suitability of a particular teaching style or educational exercise. Either way, it should produce evidence to substantiate the claim. If functional programming worked in this case in the same ways it has worked for others, the paper need only summarise the results — the main part of the paper should discuss how well it worked and in what context. Most readers will not want to know all the details of the experience and its implementation, but the paper should characterise it and its context well enough so that readers can judge to what degree this experience is relevant to their own circumstances. The paper should take care to highlight any unusual aspects; specifics about the experience are more valuable than generalities about functional programming. + +If the paper not only describes experience but also presents new technical results, or if the experience refutes cherished beliefs of the functional-programming community, it may be better to submit it as a full paper, which will be judged by the usual criteria of novelty, originality, and relevance. The Program Chair will be happy to advise on any concerns about which category to submit to. + +### About PACMPL +---------------- +Proceedings of the ACM on Programming Languages (PACMPL https://pacmpl.acm.org/) is a Gold Open Access journal publishing research on all aspects of programming languages, from design to implementation and from mathematical formalisms to empirical studies. Each issue of the journal is devoted to a particular subject area within programming languages and will be announced through publicised Calls for Papers, like this one. + + +### ICFP Organisers + +General Chair: + Marco Gaboardi (Boston University, USA) + +Programme Chair: + Brigitte Pientka (McGill University, Canada) + +Associate Programme Chair: + Gabriele Keller (Utrecht University, Netherlands) + +Publicity Chair: + Ilya Sergey (National University of Singapore, Singapore) + +Programme Committee: + https://icfp24.sigplan.org/committee/icfp-2024-papers-icfp-papers-and-events From d9d5ff05837615d9cb9fe88344378774fab28de8 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Fri, 1 Dec 2023 09:41:44 -0500 Subject: [PATCH 20/64] History announcement --- _announce/2023-11-27-history.txt | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 _announce/2023-11-27-history.txt diff --git a/_announce/2023-11-27-history.txt b/_announce/2023-11-27-history.txt new file mode 100644 index 0000000..66e5d11 --- /dev/null +++ b/_announce/2023-11-27-history.txt @@ -0,0 +1,12 @@ +--- +title: "ACM History Committee 2024 CFP - History and Archiving Fellowship Program" +deadline: "02/15/2024" +--- +The ACM History Committee’s call for proposals for the history and archiving fellowship program is now open. This year, there’s even more focus on SIG history as we incorporate our support of SIG Heritage and archiving more directly in the CFP. + +The full call can be found in this link: +https://history.acm.org/wp-content/uploads/2023/11/ACM-fellowship_CFP_2024.pdf + +The deadline for submissions is February 15th, 2024. + +The ACM History Committee’s 2024 fellowship competition is for research and archiving projects on topics centrally related to ACM history. The History Committee plans to support up to four projects with awards of up to $4,000. The History Committee has awarded over 40 fellowships since the start of this fellowship program in 2009. From 240a3be06a69402785ed661fe8ada0557400edfa Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Sun, 10 Dec 2023 11:16:38 -0500 Subject: [PATCH 21/64] Announce --- _announce/2023-11-22-aeic_2024.txt | 379 +++++++++++++++++++++++++++++ 1 file changed, 379 insertions(+) create mode 100644 _announce/2023-11-22-aeic_2024.txt diff --git a/_announce/2023-11-22-aeic_2024.txt b/_announce/2023-11-22-aeic_2024.txt new file mode 100644 index 0000000..71bfff9 --- /dev/null +++ b/_announce/2023-11-22-aeic_2024.txt @@ -0,0 +1,379 @@ +--- +title: "CfC, 28th Ada-Europe Conf. on Reliable Software Technologies (AEiC 2024)" +timestamp: "11/22/2023 12:25:13" +deadline: "2/26/2024" +--- +----------------------------------------------------------------------- + + UPDATED Call for Contributions + +28th Ada-Europe International Conference on +Reliable Software Technologies (AEiC 2024) + +11-14 June 2024, Barcelona, Spain + +www.ada-europe.org/conference2024 + +*** Journal track submissions by 15 January 2024 *** +*** Other submissions by 26 February 2024 *** + +Organized by Ada-Europe +and Barcelona Supercomputing Center (BSC), +in cooperation with ACM SIGAda, ACM SIGBED, ACM SIGPLAN, +and Ada Resource Association (ARA) + +#AEiC2024 #AdaEurope #AdaProgramming + +----------------------------------------------------------------------- + +*** General Information + +The 28th Ada-Europe International Conference on Reliable Software +Technologies (AEiC 2024) will take place in Barcelona, Spain. + +AEiC is a leading international forum for providers, practitioners, +and researchers in reliable software technologies. The conference +presentations will illustrate current work in the theory and practice +of the design, development, and maintenance of long-lived, high-quality +software systems for a challenging variety of application domains. +The program will also include keynotes, Q&A and discussion sessions, +and social events. Participants include practitioners and researchers +from industry, academia, and government organizations active in the +development of reliable software technologies. + +The topics of interest for the conference include but are not limited +to (more specific topics are described on the conference web page): +* Formal and Model-Based Engineering of Critical Systems; +* High-Integrity Systems and Reliability; +* AI for High-Integrity Systems Engineering; +* Real-Time Systems; +* Ada Language; +* Applications in Relevant Domains. + +The conference comprises different tracks and co-located events: +* Journal track papers present research advances supported by solid + theoretical foundation and thorough evaluation. +* Industrial track contributions highlight industrial open challenges + and/or the practitioners' side of a relevant case study or industrial + project. +* Work-in-progress track papers illustrate novel research ideas + that are still at an initial stage, between conception and first + prototype. +* Tutorials guide attenders through a hands-on familiarization with + innovative developments or with useful features related to reliable + software. +* Workshops provide discussion forums on themes related to the + conference topics. +* Vendor presentations and exhibitions allow for companies to showcase + their latest products and services. + +*** Important Dates + +15 January 2024 Deadline for submission of journal track papers +26 February 2024 Deadline for submission of industrial track papers, + work-in-progress papers, tutorial and workshop + proposals +22 March 2024 First round notification for journal track papers, + and notification of acceptance for all other types + of submissions +11-14 June 2024 Conference + +*** Call for Journal Track Submissions + +Following a journal-first model, this edition of the conference +includes a journal track, which seeks original and high-quality +papers that describe mature research work on the conference topics. +Accepted journal track papers will be published in a Special Issue +of Elsevier JSA - the Journal of Systems Architecture (Q1 ranked, +CiteScore 8.5, impact factor 4.5). Accordingly, the conference +is listed as "Journal Published" in the latest update of the CORE +Conference Ranking released in August 2023. Contributions must be +submitted by 15 January 2024. Submissions should be made online at +https://www.editorialmanager.com/jsa/, selecting the "Ada-Europe AEiC +2024" option (submission page open from 15 November 2023) as article +type of the paper. General information for submitting to the JSA +can be found at the Journal of Systems Architecture website. + +JSA has adopted the Virtual Special Issue model to speed up the +publication process, where Special Issue papers are published in +regular issues, but marked as SI papers. Acceptance decisions +are made on a rolling basis. Therefore, authors are encouraged to +submit papers early, and need not wait until the submission deadline. +Authors who have successfully passed the first round of review will +be invited to present their work at the conference. The abstract of +the accepted contributions will be included in the conference booklet. + +The Ada-Europe organization will waive the Open Access fees for +the first four accepted papers (whose authors do not already enjoy +Open Access agreements). Subsequent papers will follow JSA regular +publishing track. Prospective authors may direct all enquiries +regarding this track to the corresponding chairs, Bjorn Andersson +(baandersson@sei.cmu.edu) and Luis Miguel Pinho (lmp@isep.ipp.pt). + +*** Call for Industrial Track Submissions + +The conference seeks industrial practitioner presentations that deliver +insight on the challenges of developing reliable software. Especially +welcome kinds of submissions are listed on the conference website. +Given their applied nature, such contributions will be subject to a +dedicated practitioner-peer review process. Interested authors shall +submit a 1-to-2 pages abstract, by 26 February 2024, via EasyChair +at https://easychair.org/my/conference?conf=aeic2024, selecting the +"Industrial Track". The format for submission is strictly in PDF, +following the Ada User Journal style. Templates are available at +http://www.ada-europe.org/auj/guide. + +The abstract of the accepted contributions will be included in the +conference booklet. The corresponding authors will get a presentation +slot in the prime-time technical program of the conference and will +also be invited to expand their contributions into full-fledged +articles for publication in the Ada User Journal, which will form the +proceedings of the industrial track of the Conference. Prospective +authors may direct all enquiries regarding this track to its chairs +Luciana Provenzano (luciana.provenzano@mdu.se) and Michael Pressler +(Michael.Pressler@de.bosch.com). + +*** Call for Work-in-Progress Track Submissions + +The work-in-progress track seeks two kinds of submissions: (a) ongoing +research and (b) early-stage ideas. Ongoing research submissions +are 4-page papers describing research results that are not mature +enough to be submitted to the journal track. Early-stage ideas are +1-page papers that pitch new research directions that fall within +the scope of the conference. Both kinds of submissions must be +original and shall undergo anonymous peer review. Submissions +by recent MSc graduates and PhD students are especially sought. +Authors shall submit their work by 26 February 2024, via EasyChair +at https://easychair.org/my/conference?conf=aeic2024, selecting the +"Work-in-Progress Track". The format for submission is strictly in +PDF, following the Ada User Journal style. Templates are available +at http://www.ada-europe.org/auj/guide. + +The abstract of the accepted contributions will be included in the +conference booklet. The corresponding authors will get a presentation +slot in the prime-time technical program of the conference and +will also be offered the opportunity to expand their contributions +into 4-page articles for publication in the Ada User Journal, +which will form the proceedings of the WiP track of the Conference. +Prospective authors may direct all enquiries regarding this track +to the corresponding chairs Alejandro R. Mosteo (amosteo@unizar.es) +and Ruben Martins (rubenm@andrew.cmu.edu). + +*** Awards + +The organization will offer an honorary award for the best technical +presentation, to be announced in the closing session of the conference. + +*** Call for Tutorials + +The conference seeks tutorials in the form of educational seminars +on themes falling within the conference scope, with an academic or +practitioner slant, including hands-on or practical elements. Tutorial +proposals shall include a title, an abstract, a description of the +topic, an outline of the presentation, the proposed duration (half-day +or full-day), the intended level of the contents (introductory, +intermediate, or advanced), and a statement motivating attendance. +Tutorial proposals shall be submitted at any time but no later +than the 26 February 2024 to the respective chair Maria A. Serrano +(maria.serrano@nearbycomputing.com), with subject line: "[AEiC 2024: +tutorial proposal]". Once submitted, each tutorial proposal will +be evaluated by the conference organizers as soon as possible, +with decisions from January 1st. The authors of accepted full-day +tutorials will receive a complimentary conference registration, halved +for half-day tutorials. The Ada User Journal will offer space for +the publication of summaries of the accepted tutorials. + +*** Call for Workshops + +The conference welcomes satellite workshops centred on themes that fall +within the conference scope. Proposals may be submitted for half- or +full-day events, to be scheduled at either end of the AEiC conference. +Workshop organizers shall also commit to producing the proceedings of +the event, for publication in the Ada User Journal. Workshop proposals +shall be submitted at any time but no later than the 26 February +2024 to the respective chair Sergio Saez (ssaez@disca.upv.es), with +subject line: "[AEiC 2024: workshop proposal]". Once submitted, each +workshop proposal will be evaluated by the conference organizers as +soon as possible, with decisions from January 1st. + +*** Academic Listing + +The Journal of Systems Architecture, publication venue of the journal +track proceedings of the conference, is Q1 ranked, with CiteScore +8.5 and Impact Factor 4.5. The Ada User Journal, venue of all other +technical proceedings of the conference, is indexed by Scopus and by +EBSCOhost in the Academic Search Ultimate database. + +*** Call for Exhibitors and Sponsors + +The conference will include a vendor and technology exhibition with the +option of a 20 minutes presentation as part of the conference program. +Interested providers should direct inquiries to the Exhibition & +Sponsorship Chair Ahlan Marriot (ahlan@ada-switzerland.ch). + +*** Venue + +The conference will take place in Barcelona, Spain. Barcelona is +a major cultural, economic, and financial centre, known for its +architecture, culture, and Mediterranean atmosphere, a hub for +technology and innovation. There's plenty to see and visit in +Barcelona, so plan in advance! + +*** Organizing Committee + +- Conference Chair + Sara Royuela, Barcelona Supercomputing Center, Spain + sara.royuela@bsc.es + +- Journal Track Chairs + Bjorn Andersson, Carnegie Mellon University, USA + baandersson@sei.cmu.edu + Luis Miguel Pinho, ISEP & INESC TEC, Portugal + lmp@isep.ipp.pt + +- Industrial Track Chairs + Luciana Provenzano, Mälardalen University, Sweden + luciana.provenzano@mdu.se + Michael Pressler, Robert Bosch GmbH, Germany + Michael.Pressler@de.bosch.com + +- Work-In-Progress Track Chairs + Alejandro R. Mosteo, CUD Zaragoza, Spain + amosteo@unizar.es + Ruben Martins, Carnegie Mellon University, USA + rubenm@andrew.cmu.edu + +- Tutorial Chair + Maria A. Serrano, NearbyComputing, Spain + maria.serrano@nearbycomputing.com + +- Workshop Chair + Sergio Saez, Universitat Politècnica de València, Spain + ssaez@disca.upv.es + +- Exhibition & Sponsorship Chair + Ahlan Marriott, White Elephant GmbH, Switzerland + ahlan@Ada-Switzerland.ch + +- Publicity Chair + Dirk Craeynest, Ada-Belgium & KU Leuven, Belgium + Dirk.Craeynest@cs.kuleuven.be + +- Webmaster + Hai Nam Tran, University of Brest, France + hai-nam.tran@univ-brest.fr + +- Local Chair + Nuria Sirvent, Barcelona Supercomputing Center, Spain + nuria.sirvent@bsc.es + +*** Program Committees + +See the conference website for the Program Committees for the Journal, +Industrial, and Work-in-Progress tracks. + +*** Journal Track Committee + +Al Mok, University of Texas at Austin, USA +Alejandro Mosteo, CUD Zaragoza, Spain +Alwyn Godloe, NASA, USA +António Casimiro, University of Lisbon, Portugal +Barbara Gallina, Mälardalen University, Sweden +Bernd Burgstaller, Yonsei University, South Korea +C. Michael Holloway, NASA, USA +Cristina Seceleanu, Mälardalen University, Sweden +Doug Schmidt, Vanderbilt University, USA +Frank Singhoff, University of Brest, FR +George Lima, Universidade Federal da Bahia, Brazil +Isaac Amundson, Rockwell Collins, USA +Jérôme Hugues, CMU/SEI, USA +José Cruz, Lockeed Martin, USA +Kristoffer Nyborg Gregertsen, SINTEF Digital, Norway +Laurent Pautet, Telecom ParisTech, France +Leonidas Kosmidis, Barcelona Supercomputing Center, Spain +Mario Aldea Rivas, University of Cantabria, Spain +Matthias Becker, KTH - Royal Institute of Technology, Sweden +Patricia López Martínez, University of Cantabria, Spain +Sara Royuela, Barcelona Supercomputing Center, Spain +Sergio Sáez, Universitat Politècnica de València, Spain +Tucker Taft, AdaCore, USA +Tullio Vardanega, University of Padua, Italy +Xiaotian Dai, University of York, England + +*** Industrial Track Committee + +Aida Causevic, Alstom, Sweden +Alexander Viehl, Research Center for Information Technology, Germany +Ana Rodríguez, Silver Atena, Spain +Aurora Agar, NATO, Netherlands +Behnaz Pourmohseni, Robert Bosch GmbH, Germany +Claire Dross, AdaCore, France +Elena Lisova, Volvo CE, Sweden +Enricco Mezzeti, Barcelona Supercomputing Center, Spain +Federico Aromolo, Scuola Superiore Sant'Anna, Italy +Helder Silva, Edisoft, Portugal +Hugo Torres Vieira, Evidence Srl, Italy +Irune Agirre, Ikerlan, Spain +Jordi Cardona, Rapita Systems, Spain +José Ruiz, AdaCore, France +Joyce Tokar, Raytheon, USA +Luciana Alvite, Alstom, Germany +Marco Panunzio, Thales Alenia Space, France +Patricia Balbastre Betoret, Valencia Polytechnic University, Spain +Philippe Waroquiers, Eurocontrol NMD, Belgium +Raúl de la Cruz, Collins Aerospace, Ireland +Santiago Urueña, GMV, Spain +Stef Van Vlierberghe, Eurocontrol NMD, Belgium + +*** Work-in-Progress Track Committee + +Alan Oliveira, University of Lisbon, Portugal +J. Javier Gutiérrez, University of Cantabria, Spain +Jérémie Guiochet, LAAS-CNRS, France +Kalinka Branco, University of São Paulo, Brazil +Katherine Kosaian, University of Iowa, USA +Kevin Cheang, AWS, USA +Kristin Yvonne Rozier, Iowa State University, USA +Leandro Buss Becker, University of Manchester, UK +Li-Pin Chang, National Yang Ming Chiao Tung University, Taiwan +Mathias Preiner, Stanford University, USA +Raffaele Romagnoli, Carnegie Mellon University, USA +Robert Kaiser, RheinMain University of Applied Sciences, Germany +Sara Abbaspour, Mälardalen University, Sweden +Sergi Alcaide, Barcelona Supercomputing Center, Spain +Simona Bernardi, Unizar, Spain +Stefan Mitsch, School of Computing at DePaul University, USA +Teresa Lázaro, Aragon's Institute of Technology, Spain +Tiago Carvalho, ISEP, Portugal +Yannick Moy, AdaCore, France + +*** Previous Editions + +Ada-Europe organizes annual international conferences since the early +80's. This is the 28th event in the Reliable Software Technologies +series, previous ones being held at Montreux, Switzerland ('96), +London, UK ('97), Uppsala, Sweden ('98), Santander, Spain ('99), +Potsdam, Germany ('00), Leuven, Belgium ('01), Vienna, Austria +('02), Toulouse, France ('03), Palma de Mallorca, Spain ('04), York, +UK ('05), Porto, Portugal ('06), Geneva, Switzerland ('07), Venice, +Italy ('08), Brest, France ('09), Valencia, Spain ('10), Edinburgh, UK +('11), Stockholm, Sweden ('12), Berlin, Germany ('13), Paris, France +('14), Madrid, Spain ('15), Pisa, Italy ('16), Vienna, Austria ('17), +Lisbon, Portugal ('18), Warsaw, Poland ('19), online from Santander, +Spain ('21), Ghent, Belgium ('22), and Lisbon, Portugal ('23). + +Information on previous editions of the conference can be found at +www.ada-europe.org/confs/ae. + +----------------------------------------------------------------------- + +Our apologies if you receive multiple copies of this announcement. +Please circulate widely. + +Dirk Craeynest, AEiC 2024 Publicity Chair +Dirk.Craeynest@cs.kuleuven.be + +* 28th Ada-Europe Int. Conf. Reliable Software Technologies (AEiC 2024) +* June 11-14, 2024, Barcelona, Spain, www.ada-europe.org/conference2024 + + From bb5d966c4589c7b2d797cd2dc66ee9049ddacb3d Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Sun, 10 Dec 2023 11:18:39 -0500 Subject: [PATCH 22/64] More announce --- _announce/2023-12-08-cgo_2024_src.txt | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 _announce/2023-12-08-cgo_2024_src.txt diff --git a/_announce/2023-12-08-cgo_2024_src.txt b/_announce/2023-12-08-cgo_2024_src.txt new file mode 100644 index 0000000..e11d086 --- /dev/null +++ b/_announce/2023-12-08-cgo_2024_src.txt @@ -0,0 +1,12 @@ +--- +title: "CGO'24 - Student Research Competition (SRC) and more" +deadline: "12/22/2023" +--- +The International Symposium on Code Generation and Optimization (CGO) is hosting a Student Research Competition (SRC). Our SRC is a unique opportunity for undergraduate and graduate students to present their original research before a panel of judges and attendees at CGO'24. The winner will be invited to the Grand 2024 ACM SRC competition. If you are an undergraduate or postgraduate student doing research in compiler-related topics, consider applying. We look forward to meeting you! + +CGO'24 is a compiler conference happening in Edinburgh, March 2nd to 6th 2024. This conference is a great opportunity for anyone interested in compilers to connect with great researchers and professionals and will host four existing workshops: LLVM [1], the BuildIt Framework [2], LATHC [3], and C4ML [4]. Find more information on https://conf.researchr.org/home/cgo-2024 and share this message with anyone who might be interested! + +[1] LLVM Performance Workshop: https://llvm.org/devmtg/2024-03/ +[2] BuildIt: Building DSLs made easy with the BuildIt Framework: https://buildit.so/tutorial/ +[3] LATHC: Languages, Architectures, and Tools for Heterogeneous Computing Workshop: https://jnamaral.github.io/LATHC24/ +[4] C4ML - Compilers For Machine Learning: https://www.c4ml.org/c4ml-2024 From ecb7df21e4aa4a222aafec9ae1849118594111f3 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Fri, 22 Dec 2023 09:15:40 -0500 Subject: [PATCH 23/64] PACMPL: authors choose citation style --- Resources/Author.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/Resources/Author.md b/Resources/Author.md index 8fe3879..aabc780 100644 --- a/Resources/Author.md +++ b/Resources/Author.md @@ -53,9 +53,10 @@ The `acmart` format is maintained in a [GitHub repository](https://github.com/borisveytsman/acmart). Please use the following LaTeX commands: -* PACMPL journal issues: `\documentclass[acmsmall,screen]{acmart}`; - PACMPL requires author-year citation style: `\citestyle{acmauthoryear}` -* SIGPLAN proceedings: `\documentclass[sigplan,screen]{acmart}` + +* PACMPL journal issues: `\documentclass[acmsmall,screen]{acmart}`. + Authors can choose either author-year citations, with `\citestyle{acmauthoryear}`, or numeric citations, with `\citestyle{acmnumeric}`. +* SIGPLAN proceedings: `\documentclass[sigplan,screen]{acmart}`. The `review` option is strongly encouraged, but not required, for submissions. (The `review` option will add line numbers, which make it From 357d58fbe7400a59b111157c9d83c2872cc9565f Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Fri, 5 Jan 2024 17:34:18 -0500 Subject: [PATCH 24/64] Restore Educator award to front page --- _data/Awards.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_data/Awards.yaml b/_data/Awards.yaml index 6cacabc..cbdcba5 100644 --- a/_data/Awards.yaml +++ b/_data/Awards.yaml @@ -4,7 +4,7 @@ Achievement: Programming Languages Achievement Award Service: Distinguished Service Award -# Educator: Distinguished Educator Award +Educator: Distinguished Educator Award Software: Programming Languages Software Award Milner: Robin Milner Young Researcher Award Dissertation: John C. Reynolds Doctoral Dissertation Award From f3301a859acbf595cb79dd5516f8850f26d154ee Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Fri, 5 Jan 2024 17:50:01 -0500 Subject: [PATCH 25/64] TOC --- OpenTOC/popl24.html | 611 ++++++++++++++++++++++++++++++++++++++++++++ _data/OpenTOC.yaml | 4 + 2 files changed, 615 insertions(+) create mode 100644 OpenTOC/popl24.html diff --git a/OpenTOC/popl24.html b/OpenTOC/popl24.html new file mode 100644 index 0000000..2dd5437 --- /dev/null +++ b/OpenTOC/popl24.html @@ -0,0 +1,611 @@ +

Proceedings of the ACM on Programming Languages: Vol. 8, No. POPL. 2024

+ Full Citation in the ACM Digital Library +

SECTION: Papers

Ramsey Quantifiers in Linear Arithmetics

  • Pascal Bergsträßer
  • Moses Ganardi
  • Anthony W. Lin
  • Georg Zetzsche
+

We study Satisfiability Modulo Theories (SMT) enriched with the so-called Ramsey quantifiers, which assert the existence of cliques (complete graphs) in the graph induced by some formulas. The extended framework is known to have applications in proving program termination (in particular, whether a transitive binary predicate is well-founded), and monadic decomposability of SMT formulas. Our main result is a new algorithm for eliminating Ramsey quantifiers from three common SMT theories: Linear Integer Arithmetic (LIA), Linear Real Arithmetic (LRA), and Linear Integer Real Arithmetic (LIRA). In particular, if we work only with existentially quantified formulas, then our algorithm runs in polynomial time and produces a formula of linear size. One immediate consequence is that checking well-foundedness of a given formula in the aforementioned theory defining a transitive predicate can be straightforwardly handled by highly optimized SMT-solvers. We show also how this provides a uniform semi-algorithm for verifying termination and liveness with completeness guarantee (in fact, with an optimal computational complexity) for several well-known classes of infinite-state systems, which include succinct timed systems, one-counter systems, and monotonic counter systems. Another immediate consequence is a solution to an open problem on checking monadic decomposability of a given relation in quantifier-free fragments of LRA and LIRA, which is an important problem in automated reasoning and constraint databases. Our result immediately implies decidability of this problem with an optimal complexity (coNP-complete) and enables exploitation of SMT-solvers. It also provides a termination guarantee for the generic monadic decomposition algorithm of Veanes et al. for LIA, LRA, and LIRA. We report encouraging experimental results on a prototype implementation of our algorithms on micro-benchmarks.

+

Deciding Asynchronous Hyperproperties for Recursive Programs

  • Jens Oliver Gutsfeld
  • Markus Müller-Olm
  • Christoph Ohrem
+

We introduce a novel logic for asynchronous hyperproperties with a new mechanism to identify relevant positions on traces. While the new logic is more expressive than a related logic presented recently by Bozzelli et al., we obtain the same complexity of the model checking problem for finite state models. Beyond this, we study the model checking problem of our logic for pushdown models. We argue that the combination of asynchronicity and a non-regular model class studied in this paper constitutes the first suitable approach for hyperproperty model checking against recursive programs.

+

Shoggoth: A Formal Foundation for Strategic Rewriting

  • Xueying Qin
  • Liam O’Connor
  • Rob van Glabbeek
  • Peter Höfner
  • Ohad Kammar
  • Michel Steuwer
+

Rewriting is a versatile and powerful technique used in many domains. Strategic rewriting allows programmers to control the application of rewrite rules by composing individual rewrite rules into complex rewrite strategies. These strategies are semantically complex, as they may be nondeterministic, they may raise errors that trigger backtracking, and they may not terminate.

Given such semantic complexity, it is necessary to establish a formal understanding of rewrite strategies and to enable reasoning about them in order to answer questions like: How do we know that a rewrite strategy terminates? How do we know that a rewrite strategy does not fail because we compose two incompatible rewrites? How do we know that a desired property holds after applying a rewrite strategy?

In this paper, we introduce Shoggoth: a formal foundation for understanding, analysing and reasoning about strategic rewriting that is capable of answering these questions. We provide a denotational semantics of System S, a core language for strategic rewriting, and prove its equivalence to our big-step operational semantics, which extends existing work by explicitly accounting for divergence. We further define a location-based weakest precondition calculus to enable formal reasoning about rewriting strategies, and we prove this calculus sound with respect to the denotational semantics. We show how this calculus can be used in practice to reason about properties of rewriting strategies, including termination, that they are well-composed, and that desired postconditions hold. The semantics and calculus are formalised in Isabelle/HOL and all proofs are mechanised.

+

Reachability in Continuous Pushdown VASS

  • A. R. Balasubramanian
  • Rupak Majumdar
  • Ramanathan S. Thinniyam
  • Georg Zetzsche
+

Pushdown Vector Addition Systems with States (PVASS) consist of finitely many control states, a pushdown stack, and a set of counters that can be incremented and decremented, but not tested for zero. Whether the reachability problem is decidable for PVASS is a long-standing open problem. + +We consider continuous PVASS, which are PVASS with a continuous semantics. This means, the counter values are rational numbers and whenever a vector is added to the current counter values, this vector is first scaled with an arbitrarily chosen rational factor between zero and one. + +We show that reachability in continuous PVASS is NEXPTIME-complete. Our result is unusually robust: Reachability can be decided in NEXPTIME even if all numbers are specified in binary. On the other hand, NEXPTIME-hardness already holds for coverability, in fixed dimension, for bounded stack, and even if all numbers are specified in unary.

+

Answer Refinement Modification: Refinement Type System for Algebraic Effects and Handlers

  • Fuga Kawamata
  • Hiroshi Unno
  • Taro Sekiyama
  • Tachio Terauchi
+

Algebraic effects and handlers are a mechanism to structure programs with computational effects in a modular way. They are recently gaining popularity and being adopted in practical languages, such as OCaml. Meanwhile, there has been substantial progress in program verification via refinement type systems. While a variety of refinement type systems have been proposed, thus far there has not been a satisfactory refinement type system for algebraic effects and handlers. In this paper, we fill the void by proposing a novel refinement type system for languages with algebraic effects and handlers. The expressivity and usefulness of algebraic effects and handlers come from their ability to manipulate delimited continuations, but delimited continuations also complicate programs’ control flow and make their verification harder. To address the complexity, we introduce a novel concept that we call answer refinement modification (ARM for short), which allows the refinement type system to precisely track what effects occur and in what order when a program is executed, and reflect such information as modifications to the refinements in the types of delimited continuations. We formalize our type system that supports ARM (as well as answer type modification, or ATM) and prove its soundness. Additionally, as a proof of concept, we have extended the refinement type system to a subset of OCaml 5 which comes with a built-in support for effect handlers, implemented a type checking and inference algorithm for the extension, and evaluated it on a number of benchmark programs that use algebraic effects and handlers. The evaluation demonstrates that ARM is conceptually simple and practically useful. Finally, a natural alternative to directly reasoning about a program with delimited continuations is to apply a continuation passing style (CPS) transformation that transforms the program to a pure program without delimited continuations. We investigate this alternative in the paper, and show that the approach is indeed possible by proposing a novel CPS transformation for algebraic effects and handlers that enjoys bidirectional (refinement-)type-preservation. We show that there are pros and cons with this approach, namely, while one can use an existing refinement type checking and inference algorithm that can only (directly) handle pure programs, there are issues such as needing type annotations in source programs and making the inferred types less informative to a user.

+

An Iris Instance for Verifying CompCert C Programs

  • William Mansky
  • Ke Du
+

Iris is a generic separation logic framework that has been instantiated to reason about a wide range of programming languages and language features. Most Iris instances are defined on simple core calculi, but by connecting Iris to new or existing formal semantics for practical languages, we can also use it to reason about real programs. In this paper we develop an Iris instance based on CompCert, the verified C compiler, allowing us to prove correctness of C programs under the same semantics we use to compile and run them. We take inspiration from the Verified Software Toolchain (VST), a prior separation logic for CompCert C, and reimplement the program logic of VST in Iris. Unlike most Iris instances, this involves both a new model of resources for CompCert memories, and a new definition of weakest preconditions/Hoare triples, as the Iris defaults for both of these cannot be applied to CompCert as is. Ultimately, we obtain a complete program logic for CompCert C within Iris, and we reconstruct enough of VST's top-level automation to prove correctness of simple C programs.

+

Calculational Design of [In]Correctness Transformational Program Logics by Abstract Interpretation

  • Patrick Cousot
+

We study transformational program logics for correctness and incorrectness that we extend to explicitly handle both termination and nontermination. We show that the logics are abstract interpretations of the right image transformer for a natural relational semantics covering both finite and infinite executions. This understanding of logics as abstractions of a semantics facilitates their comparisons through their respective abstractions of the semantics (rather that the much more difficult comparison through their formal proof systems). More importantly, the formalization provides a calculational method for constructively designing the sound and complete formal proof system by abstraction of the semantics. As an example, we extend Hoare logic to cover all possible behaviors of nondeterministic programs and design a new precondition (in)correctness logic.

+

Internal and Observational Parametricity for Cubical Agda

  • Antoine Van Muylder
  • Andreas Nuyts
  • Dominique Devriese
+

Two approaches exist to incorporate parametricity into proof assistants based on dependent type theory. On the one hand, parametricity translations conveniently compute parametricity statements and their proofs solely based on individual well-typed polymorphic programs. But they do not offer internal parametricity: formal proofs that any polymorphic program of a certain type satisfies its parametricity statement. On the other hand, internally parametric type theories augment plain type theory with additional primitives out of which internal parametricity can be derived. But those type theories lack mature proof assistant implementations and deriving parametricity in them involves low-level intractable proofs. In this paper, we contribute Agda --bridges: the first practical internally parametric proof assistant. We provide the first mechanized proofs of crucial theorems for internal parametricity, like the relativity theorem. We identify a high-level sufficient condition for proving internal parametricity which we call the structure relatedness principle (SRP) by analogy with the structure identity principle (SIP) of HoTT/UF. We state and prove a general parametricity theorem for types that satisfy the SRP. Our parametricity theorem lets us obtain one-liner proofs of standard internal free theorems. We observe that the SRP is harder to prove than the SIP and provide in Agda --bridges a shallowly embedded type theory to compose types that satisfy the SRP. This type theory is an observational type theory of logical relations and our parametricity theorem ought to be one of its inference rules.

+

Trillium: Higher-Order Concurrent and Distributed Separation Logic for Intensional Refinement

  • Amin Timany
  • Simon Oddershede Gregersen
  • Léo Stefanesco
  • Jonas Kastberg Hinrichsen
  • Léon Gondelman
  • Abel Nieto
  • Lars Birkedal
+

Expressive state-of-the-art separation logics rely on step-indexing to model semantically complex features +and to support modular reasoning about imperative higher-order concurrent and distributed programs. Step- +indexing comes, however, with an inherent cost: it restricts the adequacy theorem of program logics to a fairly +simple class of safety properties. +In this paper, we explore if and how intensional refinement is a viable methodology for strengthening +higher-order concurrent (and distributed) separation logic to prove non-trivial safety and liveness properties. +Specifically, we introduce Trillium, a language-agnostic separation logic framework for showing intensional +refinement relations between traces of a program and a model. We instantiate Trillium with a concurrent +language and develop Fairis, a concurrent separation logic, that we use to show liveness properties of concurrent +programs under fair scheduling assumptions through a fair liveness-preserving refinement of a model. We also +instantiate Trillium with a distributed language and obtain an extension of Aneris, a distributed separation +logic, which we use to show refinement relations between distributed systems and TLA+ models.

+

Decalf: A Directed, Effectful Cost-Aware Logical Framework

  • Harrison Grodin
  • Yue Niu
  • Jonathan Sterling
  • Robert Harper
+

We present decalf, a directed, effectful cost-aware logical framework for studying quantitative aspects of functional programs with effects. Like calf, the language is based on a formal phase distinction between the extension and the intension of a program, its pure behavior as distinct from its cost measured by an effectful step-counting primitive. The type theory ensures that the behavior is unaffected by the cost accounting. Unlike calf, the present language takes account of effects, such as probabilistic choice and mutable state. This extension requires a reformulation of calf’s approach to cost accounting: rather than rely on a ”separable” notion of cost, here a cost bound is simply another program. To make this formal, we equip every type with an intrinsic preorder, relaxing the precise cost accounting intrinsic to a program to a looser but nevertheless informative estimate. For example, the cost bound of a probabilistic program is itself a probabilistic program that specifies the distribution of costs. This approach serves as a streamlined alternative to the standard method of isolating a cost recurrence and readily extends to higher-order, effectful programs.

The development proceeds by first introducing the decalf type system, which is based on an intrinsic ordering among terms that restricts in the extensional phase to extensional equality, but in the intensional phase reflects an approximation of the cost of a program of interest. This formulation is then applied to a number of illustrative examples, including pure and effectful sorting algorithms, simple probabilistic programs, and higher-order functions. Finally, we justify decalf via a model in the topos of augmented simplicial sets.

+

DisLog: A Separation Logic for Disentanglement

  • Alexandre Moine
  • Sam Westrick
  • Stephanie Balzer
+

Disentanglement is a run-time property of parallel programs that +facilitates task-local reasoning about the memory footprint of +parallel tasks. In particular, it ensures that a task does not access +any memory locations allocated by another concurrently executing task. +Disentanglement can be exploited, for example, to implement a +high-performance parallel memory manager, such as in the MPL (MaPLe) +compiler for Parallel ML. Prior research on disentanglement has +focused on the design of optimizations, either trusting the programmer +to provide a disentangled program or relying on runtime +instrumentation for detecting and managing entanglement. This paper +provides the first static approach to verify that a program is +disentangled: it contributes DisLog, a concurrent separation logic for +disentanglement. DisLog enriches concurrent separation logic with the +notions necessary for reasoning about the fork-join structure of +parallel programs, allowing the verification that memory accesses are +effectively disentangled. A large class of programs, including +race-free programs, exhibit memory access patterns that are +disentangled "by construction". To reason about these patterns, the +paper distills from DisLog an almost standard concurrent separation +logic, called DisLog+. In this high-level logic, no specific +reasoning about memory accesses is needed: functional correctness +proofs entail disentanglement. The paper illustrates the use of +DisLog and DisLog+ on a range of case studies, including two different +implementations of parallel deduplication via concurrent hashing. All +our results are mechanized in the Coq proof assistant using Iris.

+

Modular Denotational Semantics for Effects with Guarded Interaction Trees

  • Dan Frumin
  • Amin Timany
  • Lars Birkedal
+

We present guarded interaction trees — a structure and a fully formalized framework for representing higher-order computations with higher-order effects in Coq, inspired by domain theory and the recently proposed interaction trees. We also present an accompanying separation logic for reasoning about guarded interaction trees. To demonstrate that guarded interaction trees provide a convenient domain for interpreting higher-order languages with effects, we define an interpretation of a PCF-like language with effects and show that this interpretation is sound and computationally adequate; we prove the latter using a logical relation defined using the separation logic. Guarded interaction trees also allow us to combine different effects and reason about them modularly. To illustrate this point, we give a modular proof of type soundness of cross-language interactions for safe interoperability of different higher-order languages with different effects. All results in the paper are formalized in Coq using the Iris logic over guarded type theory.

+

Enriched Presheaf Model of Quantum FPC

  • Takeshi Tsukada
  • Kazuyuki Asada
+

Selinger gave a superoperator model of a first-order quantum programming language and proved that it is fully definable and hence fully abstract. This paper proposes an extension of the superoperator model to higher-order programs based on modules over superoperators or, equivalently, enriched presheaves over the category of superoperators. The enriched presheaf category can be easily proved to be a model of intuitionistic linear logic with cofree exponential, from which one can cave out a model of classical linear logic by a kind of bi-orthogonality construction. Although the structures of an enriched presheaf category are usually rather complex, a morphism in the classical model can be expressed simply as a matrix of completely positive maps. The model inherits many desirable properties from the superoperator model. A conceptually interesting property is that our model has only a state whose “total probability” is bounded by 1, i.e. ‍does not have a state where true and false each occur with probability 2/3. Another convenient property inherited from the superoperator model is a ωCPO-enrichment. Remarkably, our model has a sufficient structure to interpret arbitrary recursive types by the standard domain theoretic technique. We introduce Quantum FPC, a quantum λ-calculus with recursive types, and prove that our model is a fully abstract model of Quantum FPC.

+

Polymorphic Reachability Types: Tracking Freshness, Aliasing, and Separation in Higher-Order Generic Programs

  • Guannan Wei
  • Oliver Bračevac
  • Songlin Jia
  • Yuyan Bao
  • Tiark Rompf
+

Fueled by the success of Rust, many programming languages are adding substructural features to their type systems. The promise of tracking properties such as lifetimes and sharing is tremendous, not just for low-level memory management, but also for controlling higher-level resources and capabilities. But so are the difficulties in adapting successful techniques from Rust to higher-level languages, where they need to interact with other advanced features, especially various flavors of functional and type-level abstraction. What would it take to bring full-fidelity reasoning about lifetimes and sharing to mainstream languages? Reachability types are a recent proposal that has shown promise in scaling to higher-order but monomorphic settings, tracking aliasing and separation on top of a substrate inspired by separation logic. However, naive extensions on top of the prior reachability type system λ* with type polymorphism and/or precise reachability polymorphism are unsound, making λ* unsuitable for adoption in real languages. Combining reachability and type polymorphism that is precise, sound, and parametric remains an open challenge.

This paper presents a rethinking of the design of reachability tracking and proposes new polymorphic reachability type systems. We introduce a new freshness qualifier to indicate variables whose reachability sets may grow during evaluation steps. The new system tracks variables reachable in a single step and computes transitive closures only when necessary, thus preserving chains of reachability over known variables that can be refined using substitution. These ideas yield the simply-typed λ✦-calculus with precise lightweight, i.e., quantifier-free, reachability polymorphism, and the F<:✦-calculus with bounded parametric polymorphism over types and reachability qualifiers, paving the way for making true tracking of lifetimes and sharing practical for mainstream languages. We prove type soundness and the preservation of separation property in Coq. We discuss various applications (e.g., safe capability programming), possible effect system extensions, and compare our system with Scala’s capture types.

+

Nominal Recursors as Epi-Recursors

  • Andrei Popescu
+

We study nominal recursors from the literature on syntax with bindings and compare them with respect to expressiveness. The term "nominal" refers to the fact that these recursors operate on a syntax representation where the names of bound variables appear explicitly, as in nominal logic. We argue that nominal recursors can be viewed as epi-recursors, a concept that captures abstractly the distinction between the constructors on which one actually recurses, and other operators and properties that further underpin recursion. We develop an abstract framework for comparing epi-recursors and instantiate it to the existing nominal recursors, and also to several recursors obtained from them by cross-pollination. The resulted expressiveness hierarchies depend on how strictly we perform this comparison, and bring insight into the relative merits of different axiomatizations of syntax. We also apply our methodology to produce an expressiveness hierarchy of nominal corecursors, which are principles for defining functions targeting infinitary non-well-founded terms (which underlie lambda-calculus semantics concepts such as Böhm trees). Our results are validated with the Isabelle/HOL theorem prover.

+

Optimal Program Synthesis via Abstract Interpretation

  • Stephen Mell
  • Steve Zdancewic
  • Osbert Bastani
+

We consider the problem of synthesizing programs with numerical constants that optimize a quantitative objective, such as accuracy, over a set of input-output examples. We propose a general framework for optimal synthesis of such programs in a given domain specific language (DSL), with provable optimality guarantees. Our framework enumerates programs in a general search graph, where nodes represent subsets of concrete programs. To improve scalability, it uses A* search in conjunction with a search heuristic based on abstract interpretation; intuitively, this heuristic establishes upper bounds on the value of subtrees in the search graph, enabling the synthesizer to identify and prune subtrees that are provably suboptimal. In addition, we propose a natural strategy for constructing abstract transformers for monotonic semantics, which is a common property for components in DSLs for data classification. Finally, we implement our approach in the context of two such existing DSLs, demonstrating that our algorithm is more scalable than existing optimal synthesizers.

+

Pipelines and Beyond: Graph Types for ADTs with Futures

  • Francis Rinaldi
  • june wunder
  • Arthur Azevedo de Amorim
  • Stefan K. Muller
+

Parallel programs are frequently modeled as dependency or cost graphs, which can be used to detect various bugs, or simply to visualize the parallel structure of the code. However, such graphs reflect just one particular execution and are typically constructed in a post-hoc manner. Graph types, which were introduced recently to mitigate this problem, can be assigned statically to a program by a type system and compactly represent the family of all graphs that could result from the program.

Unfortunately, prior work is restricted in its treatment of futures, an increasingly common and especially dynamic form of parallelism. In short, each instance of a future must be statically paired with a vertex name. Previously, this led to the restriction that futures could not be placed in collections or be used to construct data structures. Doing so is not a niche exercise: such structures form the basis of numerous algorithms that use forms of pipelining to achieve performance not attainable without futures. All but the most limited of these examples are out of reach of prior graph type systems.

In this paper, we propose a graph type system that allows for almost arbitrary combinations of futures and recursive data types. We do so by indexing datatypes with a type-level vertex structure, a codata structure that supplies unique vertex names to the futures in a data structure. We prove the soundness of the system in a parallel core calculus annotated with vertex structures and associated operations. Although the calculus is annotated, this is merely for convenience in defining the type system. We prove that it is possible to annotate arbitrary recursive types with vertex structures, and show using a prototype inference engine that these annotations can be inferred from OCaml-like source code for several complex parallel algorithms.

+

Programming-by-Demonstration for Long-Horizon Robot Tasks

  • Noah Patton
  • Kia Rahmani
  • Meghana Missula
  • Joydeep Biswas
  • Işıl Dillig
+

The goal of programmatic Learning from Demonstration (LfD) is to learn a policy in a programming language that can be used to control a robot’s behavior from a set of user demonstrations. This paper presents a new programmatic LfD algorithm that targets long-horizon robot tasks which require synthesizing programs with complex control flow structures, including nested loops with multiple conditionals. Our proposed method first learns a program sketch that captures the target program’s control flow and then completes this sketch using an LLM-guided search procedure that incorporates a novel technique for proving unrealizability of programming-by-demonstration problems. We have implemented our approach in a new tool called PROLEX and present the results of a comprehensive experimental evaluation on 120 benchmarks involving complex tasks and environments. We show that, given a 120 second time limit, PROLEX can find a program consistent with the demonstrations in 80% of the cases. Furthermore, for 81% of the tasks for which a solution is returned, PROLEX is able to find the ground truth program with just one demonstration. In comparison, CVC5, a syntax-guided synthesis tool, is only able to solve 25% of the cases even when given the ground truth program sketch, and an LLM-based approach, GPT-Synth, is unable to solve any of the tasks due to the environment complexity.

+

With a Few Square Roots, Quantum Computing Is as Easy as Pi

  • Jacques Carette
  • Chris Heunen
  • Robin Kaarsgaard
  • Amr Sabry
+

Rig groupoids provide a semantic model of Π, a universal classical reversible programming language over finite types. We prove that extending rig groupoids with just two maps and three equations about them results in a model of quantum computing that is computationally universal and equationally sound and complete for a variety of gate sets. The first map corresponds to an 8th root of the identity morphism on the unit 1. The second map corresponds to a square root of the symmetry on 1+1. As square roots are generally not unique and can sometimes even be trivial, the maps are constrained to satisfy a nondegeneracy axiom, which we relate to the Euler decomposition of the Hadamard gate. The semantic construction is turned into an extension of Π, called √Π, that is a computationally universal quantum programming language equipped with an equational theory that is sound and complete with respect to the Clifford gate set, the standard gate set of Clifford+T restricted to ≤2 qubits, and the computationally universal Gaussian Clifford+T gate set.

+

The Logical Essence of Well-Bracketed Control Flow

  • Amin Timany
  • Armaël Guéneau
  • Lars Birkedal
+

A program is said to be well-bracketed if every called function must return before its caller can resume execution. This is often the case. Well-bracketedness has been captured semantically as a condition on strategies in fully abstract games models and multiple prior works have studied well-bracketedness by showing correctness/security properties of programs where such properties depend on the well-bracketed nature of control flow. The latter category of prior works have all used involved relational models with explicit state-transition systems capturing the relevant parts of the control flow of the program. In this paper we present the first Hoare-style program logic based on separation logic for reasoning about well-bracketedness and use it to show correctness of well-bracketed programs both directly and also through defining unary and binary logical relations models based on this program logic. All results presented in this paper are formalized on top of the Iris framework and mechanized in the Coq proof assistant.

+

An Axiomatic Basis for Computer Programming on the Relaxed Arm-A Architecture: The AxSL Logic

  • Angus Hammond
  • Zongyuan Liu
  • Thibaut Pérami
  • Peter Sewell
  • Lars Birkedal
  • Jean Pichon-Pharabod
+

Very relaxed concurrency memory models, like those of the Arm-A, RISC-V, and IBM Power hardware architectures, underpin much of computing but break a fundamental intuition about programs, namely that syntactic program order and the reads-from relation always both induce order in the execution. Instead, out-of-order execution is allowed except where prevented by certain pairwise dependencies, barriers, or other synchronisation. This means that there is no notion of the 'current' state of the program, making it challenging to design (and prove sound) syntax-directed, modular reasoning methods like Hoare logics, as usable resources cannot implicitly flow from one program point to the next. +

+

+We present AxSL, a separation logic for the relaxed memory model of Arm-A, that captures the fine-grained reasoning underpinning the low-overhead synchronisation mechanisms used by high-performance systems code. In particular, AxSL allows transferring arbitrary resources using relaxed reads and writes when they induce inter-thread ordering. We mechanise AxSL in the Iris separation logic framework, illustrate it on key examples, and prove it sound with respect to the axiomatic memory model of Arm-A. Our approach is largely generic in the axiomatic model and in the instruction-set semantics, offering a potential way forward for compositional reasoning for other similar models, and for the combination of production concurrency models and full-scale ISAs.

+

Regular Abstractions for Array Systems

  • Chih-Duo Hong
  • Anthony W. Lin
+

Verifying safety and liveness over array systems is a highly challenging problem. Array systems naturally capture parameterized systems such as distributed protocols with an unbounded number of processes. Such distributed protocols often exploit process IDs during their computation, resulting in array systems whose element values range over an infinite domain. In this paper, we develop a novel framework for proving safety and liveness over array systems. The crux of the framework is to overapproximate an array system as a string rewriting system (i.e. over a finite alphabet) by means of a new predicate abstraction that exploits the so-called indexed predicates. This allows us to tap into powerful verification methods for string rewriting systems that have been heavily developed in the last two decades or so (e.g. regular model checking). We demonstrate how our method yields simple, automatically verifiable proofs of safety and liveness properties for challenging examples, including Dijkstra's self-stabilizing protocol and the Chang-Roberts leader election protocol.

+

A Core Calculus for Documents: Or, Lambda: The Ultimate Document

  • Will Crichton
  • Shriram Krishnamurthi
+

Passive documents and active programs now widely comingle. Document languages include Turing-complete programming elements, and programming languages include sophisticated document notations. However, there are no formal foundations that model these languages. This matters because the interaction between document and program can be subtle and error-prone. In this paper we describe several such problems, then taxonomize and formalize document languages as levels of a document calculus. We employ the calculus as a foundation for implementing complex features such as reactivity, as well as for proving theorems about the boundary of content and computation. We intend for the document calculus to provide a theoretical basis for new document languages, and to assist designers in cleaning up the unsavory corners of existing languages.

+

The Essence of Generalized Algebraic Data Types

  • Filip Sieczkowski
  • Sergei Stepanenko
  • Jonathan Sterling
  • Lars Birkedal
+

This paper considers direct encodings of generalized algebraic data types (GADTs) in a minimal suitable lambda-calculus. To this end, we develop an extension of System Fω with recursive types and internalized type equalities with injective constant type constructors. We show how GADTs and associated pattern-matching constructs can be directly expressed in the calculus, thus showing that it may be treated as a highly idealized modern functional programming language. We prove that the internalized type equalities in conjunction with injectivity rules increase the expressive power of the calculus by establishing a non-macro-expressibility result in Fω, and prove the system type-sound via a syntactic argument. Finally, we build two relational models of our calculus: a simple, unary model that illustrates a novel, two-stage interpretation technique, necessary to account for the equational constraints; and a more sophisticated, binary model that relaxes the construction to allow, for the first time, formal reasoning about data-abstraction in a calculus equipped with GADTs.

+

Solvable Polynomial Ideals: The Ideal Reflection for Program Analysis

  • John Cyphert
  • Zachary Kincaid
+

This paper presents a program analysis method that generates program summaries involving polynomial arithmetic. Our approach builds on prior techniques that use solvable polynomial maps for summarizing loops. These techniques are able to generate all polynomial invariants for a restricted class of programs, but cannot be applied to programs outside of this class---for instance, programs with nested loops, conditional branching, unstructured control flow, etc. There currently lacks approaches to apply these prior methods to the case of general programs. This paper bridges that gap. Instead of restricting the kinds of programs we can handle, our method abstracts every loop into a model that can be solved with prior techniques, bringing to bear prior work on solvable polynomial maps to general programs. While no method can generate all polynomial invariants for arbitrary programs, our method establishes its merit through a monotonicty result. We have implemented our techniques, and tested them on a suite of benchmarks from the literature. Our experiments indicate our techniques show promise on challenging verification tasks requiring non-linear reasoning.

+

Asynchronous Probabilistic Couplings in Higher-Order Separation Logic

  • Simon Oddershede Gregersen
  • Alejandro Aguirre
  • Philipp G. Haselwarter
  • Joseph Tassarotti
  • Lars Birkedal
+

Probabilistic couplings are the foundation for many probabilistic relational program logics and arise when relating random sampling statements across two programs. In relational program logics, this manifests as dedicated coupling rules that, e.g., say we may reason as if two sampling statements return the same value. However, this approach fundamentally requires aligning or "synchronizing" the sampling statements of the two programs which is not always possible. +

+

+In this paper, we develop Clutch, a higher-order probabilistic relational separation logic that addresses this issue by supporting asynchronous probabilistic couplings. We use Clutch to develop a logical step-indexed logical relation to reason about contextual refinement and equivalence of higher-order programs written in a rich language with a probabilistic choice operator, higher-order local state, and impredicative polymorphism. Finally, we demonstrate our approach on a number of case studies. +

+

+All the results that appear in the paper have been formalized in the Coq proof assistant using the Coquelicot library and the Iris separation logic framework.

+

Quotient Haskell: Lightweight Quotient Types for All

  • Brandon Hewer
  • Graham Hutton
+

Subtypes and quotient types are dual type abstractions. However, while subtypes are widely used both explicitly and implicitly, quotient types have not seen much practical use outside of proof assistants. A key difficulty to wider adoption of quotient types lies in the significant burden of proof-obligations that arises from their use. In this article, we address this issue by introducing a class of quotient types for which the proof-obligations are decidable by an SMT solver. We demonstrate this idea in practice by presenting Quotient Haskell, an extension of Liquid Haskell with support for quotient types.

+

Semantic Code Refactoring for Abstract Data Types

  • Shankara Pailoor
  • Yuepeng Wang
  • Işıl Dillig
+

Modifications to the data representation of an abstract data type (ADT) can require significant semantic refactoring of the code. Motivated by this observation, this paper presents a new method to automate semantic code refactoring tasks. Our method takes as input the original ADT implementation, a new data representation, and a so-called relational representation invariant (relating the old and new data representations), and automatically generates a new ADT implementation that is semantically equivalent to the original version. Our method is based on counterexample-guided inductive synthesis (CEGIS) but leverages three key ideas that allow it to handle real-world refactoring tasks. First, our approach reduces the underlying relational synthesis problem to a set of (simpler) programming-by-example problems, one for each method in the ADT. Second, it leverages symbolic reasoning techniques, based on logical abduction, to deduce code snippets that should occur in the refactored version. Finally, it utilizes a notion of partial equivalence to make inductive synthesis much more effective in this setting. We have implemented the proposed approach in a new tool called Revamp ‍ for automatically refactoring Java classes and evaluated it on 30 Java class mined from Github. Our evaluation shows that Revamp can correctly refactor the entire ADT in 97% of the cases and that it can successfully re-implement 144 out of the 146 methods that require modifications.

+

EasyBC: A Cryptography-Specific Language for Security Analysis of Block Ciphers against Differential Cryptanalysis

  • Pu Sun
  • Fu Song
  • Yuqi Chen
  • Taolue Chen
+

Differential cryptanalysis is a powerful algorithmic-level attack, playing a central role in evaluating the security of symmetric cryptographic primitives. In general, the resistance against differential cryptanalysis can be characterized by the maximum expected differential characteristic probability. In this paper, we present generic and extensible approaches based on mixed integer linear programming (MILP) to bound such probability. We design a high-level cryptography-specific language EasyBC tailored for block ciphers and provide various rigorous procedures, as differential denotational semantics, to automate the generation of MILP from block ciphers written in EasyBC. We implement an open-sourced tool that provides support for fully automated resistance evaluation of block ciphers against differential cryptanalysis. The tool is extensively evaluated on 23 real-life cryptographic primitives including all the 10 finalists of the NIST lightweight cryptography standardization process. The experiments confirm the expressivity of EasyBC and show that the tool can effectively prove the resistance against differential cryptanalysis for all block ciphers under consideration. EasyBC makes resistance evaluation against differential cryptanalysis easily accessible to cryptographers.

+

Strong Invariants Are Hard: On the Hardness of Strongest Polynomial Invariants for (Probabilistic) Programs

  • Julian Müllner
  • Marcel Moosbrugger
  • Laura Kovács
+

We show that computing the strongest polynomial invariant for single-path loops with polynomial assignments is at least as hard as the Skolem problem, a famous problem whose decidability has been open for almost a century. While the strongest polynomial invariants are computable for affine loops, for polynomial loops the problem remained wide open. As an intermediate result of independent interest, we prove that reachability for discrete polynomial dynamical systems is Skolem-hard as well. Furthermore, we generalize the notion of invariant ideals and introduce moment invariant ideals for probabilistic programs. With this tool, we further show that the strongest polynomial moment invariant is (i) uncomputable, for probabilistic loops with branching statements, and (ii) Skolem-hard to compute for polynomial probabilistic loops without branching statements. Finally, we identify a class of probabilistic loops for which the strongest polynomial moment invariant is computable and provide an algorithm for it.

+

Coarser Equivalences for Causal Concurrency

  • Azadeh Farzan
  • Umang Mathur
+

Trace theory (formulated by Mazurkiewicz in 1987) is a principled framework for defining equivalence relations for concurrent program runs based on a commutativity relation over the set of atomic steps taken by individual program threads. Its simplicity, elegance, and algorithmic efficiency makes it useful in many different contexts including program verification and testing. It is well-understood that the larger the equivalence classes are, the more benefits they would bring to the algorithms and applications that use them. In this paper, we study relaxations of trace equivalence with the goal of maintaining its algorithmic advantages.

We first prove that the largest appropriate relaxation of trace equivalence, an equivalence relation that preserves the order of steps taken by each thread and what write operation each read operation observes, does not yield efficient algorithms. Specifically, we prove a linear space lower bound for the problem of checking, in a streaming setting, if two arbitrary steps of a concurrent program run are causally concurrent (i.e. they can be reordered in an equivalent run) or causally ordered (i.e. they always appear in the same order in all equivalent runs). The same problem can be decided in constant space for trace equivalence. Next, we propose a new commutativity-based notion of equivalence called grain equivalence that is strictly more relaxed than trace equivalence, and yet yields a constant space algorithm for the same problem. This notion of equivalence uses commutativity of grains, which are sequences of atomic steps, in addition to the standard commutativity from trace theory. We study the two distinct cases when the grains are contiguous subwords of the input program run and when they are not, formulate the precise definition of causal concurrency in each case, and show that they can be decided in constant space, despite being strict relaxations of the notion of causal concurrency based on trace equivalence.

+

Implementation and Synthesis of Math Library Functions

  • Ian Briggs
  • Yash Lad
  • Pavel Panchekha
+

Achieving speed and accuracy for math library functions like exp, sin, and log is difficult. This is because low-level implementation languages like C do not help math library developers catch mathematical errors, build implementations incrementally, or separate high-level and low-level decision making. This ultimately puts development of such functions out of reach for all but the most experienced experts. To address this, we introduce MegaLibm, a domain-specific language for implementing, testing, and tuning math library implementations. MegaLibm is safe, modular, and tunable. Implementations in MegaLibm can automatically detect mathematical mistakes like sign flips via semantic wellformedness checks, and components like range reductions can be implemented in a modular, composable way, simplifying implementations. Once the high-level algorithm is done, tuning parameters like working precisions and evaluation schemes can be adjusted through orthogonal tuning parameters to achieve the desired speed and accuracy. MegaLibm also enables math library developers to work interactively, compiling, testing, and tuning their implementations and invoking tools like Sollya and type-directed synthesis to complete components and synthesize entire implementations. MegaLibm can express 8 state-of-the-art math library implementations with comparable speed and accuracy to the original C code, and can synthesize 5 variations and 3 from-scratch implementations with minimal guidance.

+

An Infinite Needle in a Finite Haystack: Finding Infinite Counter-Models in Deductive Verification

  • Neta Elad
  • Oded Padon
  • Sharon Shoham
+

First-order logic, and quantifiers in particular, are widely used in deductive verification of +programs and systems. Quantifiers are essential for describing systems with unbounded domains, +but prove difficult for automated solvers. Significant effort has been dedicated to finding quantifier +instantiations that establish unsatisfiability of quantified formulas, thus ensuring validity of a +system’s verification conditions. However, in many cases the formulas are satisfiable—this is +often the case in intermediate steps of the verification process, e.g., when an invariant is not yet +inductive. For such cases, existing tools are limited to finding finite models as counterexamples. +Yet, some quantified formulas are satisfiable but only have infinite models, which current solvers +are unable to find. Such infinite counter-models are especially typical when first-order logic is used +to approximate the natural numbers, the integers, or other inductive definitions such as linked lists, +which is common in deductive verification. The inability of solvers to find infinite models makes +them diverge in these cases, providing little feedback to the user as they try to make progress in +their verification attempts. +In this paper, we tackle the problem of finding such infinite models, specifically, finite representations thereof that can be presented to the user of a deductive verification tool. These models give +insight into the verification failure, and allow the user to identify and fix bugs in the modeling of +the system and its properties. Our approach consists of three parts. First, we introduce symbolic +structures as a way to represent certain infinite models, and show they admit an efficient model +checking procedure. Second, we describe an effective model finding procedure that symbolically +explores a given (possibly infinite) family of symbolic structures in search of an infinite model for +a given formula. Finally, we identify a new decidable fragment of first-order logic that extends +and subsumes the many-sorted variant of EPR, where satisfiable formulas always have a model +representable by a symbolic structure within a known family, making our model finding procedure +a decision procedure for that fragment. +We evaluate our approach on examples from the domains of distributed consensus protocols +and of heap-manipulating programs (specifically, linked lists). Our implementation quickly finds +infinite counter-models that demonstrate the source of verification failures in a simple way, while +state-of-the-art SMT solvers and theorem provers such as Z3, cvc5, and Vampire diverge or return +“unknown”.

+

On Learning Polynomial Recursive Programs

  • Alex Buna-Marginean
  • Vincent Cheval
  • Mahsa Shirmohammadi
  • James Worrell
+

We introduce the class of P-finite automata. These are a generalisation of weighted automata, in which the weights of transitions can depend polynomially on the length of the input word. P-finite automata can also be viewed as simple tail-recursive programs in which the arguments of recursive calls can non-linearly refer to a variable that counts the number of recursive calls. The nomenclature is motivated by the fact that over a unary alphabet P-finite automata compute so-called P-finite sequences, that is, sequences that satisfy a linear recurrence with polynomial coefficients. Our main result shows that P-finite automata can be learned in polynomial time in Angluin's MAT exact learning model. This generalises the classical results that deterministic finite automata and weighted automata over a field are respectively polynomial-time learnable in the MAT model.

+

Mostly Automated Verification of Liveness Properties for Distributed Protocols with Ranking Functions

  • Jianan Yao
  • Runzhou Tao
  • Ronghui Gu
  • Jason Nieh
+

Distributed protocols have long been formulated in terms of their safety and liveness properties. Much recent work has focused on automatically verifying the safety properties of distributed protocols, but doing so for liveness properties has remained a challenging, unsolved problem. We present LVR, the first framework that can mostly automatically verify liveness properties for distributed protocols. Our key insight is that most liveness properties for distributed protocols can be reduced to a set of safety properties with the help of ranking functions. Such ranking functions for practical distributed protocols have certain properties that make them straightforward to synthesize, contrary to conventional wisdom. We prove that verifying a liveness property can then be reduced to a simpler problem of verifying a set of safety properties, namely that the ranking function is strictly decreasing and nonnegative for any protocol state transition, and there is no deadlock. LVR automatically synthesizes ranking functions by formulating a parameterized function of integer protocol variables, statically analyzing the lower and upper bounds of the variables as well as how much they can change on each state transition, then feeding the constraints to an SMT solver to determine the coefficients of the ranking function. It then uses an off-the-shelf verification tool to find inductive invariants to verify safety properties for both ranking functions and deadlock freedom. We show that LVR can mostly automatically verify the liveness properties of several distributed protocols, including various versions of Paxos, with limited user guidance.

+

Efficient CHAD

  • Tom J. Smeding
  • Matthijs I. L. Vákár
+

We show how the basic Combinatory Homomorphic Automatic Differentiation (CHAD) algorithm can be optimised, using well-known methods, to yield a simple, composable, and generally applicable reverse-mode automatic differentiation (AD) technique that has the correct computational complexity that we would expect of reverse-mode AD. Specifically, we show that the standard optimisations of sparse vectors and state-passing style code (as well as defunctionalisation/closure conversion, for higher-order languages) give us a purely functional algorithm that is most of the way to the correct complexity, with (functional) mutable updates taking care of the final log-factors. We provide an Agda formalisation of our complexity proof. Finally, we discuss how the techniques apply to differentiating parallel functional array programs: the key observations are 1) that all required mutability is (commutative, associative) accumulation, which lets us preserve task-parallelism and 2) that we can write down data-parallel derivatives for most data-parallel array primitives.

+

Positive Almost-Sure Termination: Complexity and Proof Rules

  • Rupak Majumdar
  • V. R. Sathiyanarayana
+

We study the recursion-theoretic complexity of Positive Almost-Sure Termination (PAST) in an imperative programming language with rational variables, bounded nondeterministic choice, and discrete probabilistic choice. A program terminates positive almost-surely if, for every scheduler, the program terminates almost-surely and the expected runtime to termination is finite. We show that PAST for our language is complete for the (lightface) co-analytic sets (Π11-complete). This is in contrast to the related notions of Almost-Sure Termination (AST) and Bounded Termination (BAST), both of which are arithmetical (Π20- and Σ20-complete respectively).

Our upper bound implies an effective procedure to reduce reasoning about probabilistic termination to non-probabilistic fair termination in a model with bounded nondeterminism, and to simple program termination in models with unbounded nondeterminism. Our lower bound shows the opposite: for every program with unbounded nondeterministic choice, there is an effectively computable probabilistic program with bounded choice such that the original program is terminating if, and only if, the transformed program is PAST.

We show that every program has an effectively computable normal form, in which each probabilistic choice either continues or terminates execution immediately, each with probability 1/2. For normal form programs, we provide a sound and complete proof rule for PAST. Our proof rule uses transfinite ordinals. We show that reasoning about PAST requires transfinite ordinals up to ω1CK; thus, existing techniques for probabilistic termination based on ranking supermartingales that map program states to reals do not suffice to reason about PAST.

+

Automatic Parallelism Management

  • Sam Westrick
  • Matthew Fluet
  • Mike Rainey
  • Umut A. Acar
+

On any modern computer architecture today, parallelism comes with a modest cost, +born from the creation and management of threads or tasks. Today, programmers +battle this cost by manually optimizing/tuning their codes to minimize the cost +of parallelism without harming its benefit, performance. This is a difficult +battle: programmers must reason about architectural constant factors hidden +behind layers of software abstractions, including thread schedulers and memory +managers, and their impact on performance, also at scale. In languages that +support higher-order functions, the battle hardens: higher order functions can +make it difficult, if not impossible, to reason about the cost and benefits of +parallelism. +

+

+Motivated by these challenges and the numerous advantages of high-level +languages, we believe that it has become essential to manage parallelism +automatically so as to minimize its cost and maximize its benefit. This is a +challenging problem, even when considered on a case-by-case, +application-specific basis. But if a solution were possible, then it could +combine the many correctness benefits of high-level languages with performance +by managing parallelism without the programmer effort needed to ensure +performance. This paper proposes techniques for such automatic management of +parallelism by combining static (compilation) and run-time techniques. +Specifically, we consider the Parallel ML language with task parallelism, and +describe a compiler pipeline that embeds "potential parallelism" directly into +the call-stack and avoids the cost of task creation by default. We then pair +this compilation pipeline with a run-time system that dynamically converts +potential parallelism into actual parallel tasks. Together, the compiler and +run-time system guarantee that the cost of parallelism remains low without +losing its benefit. We prove that our techniques have no asymptotic impact on +the work and span of parallel programs and thus preserve their asymptotic +properties. We implement the proposed techniques by extending the MPL compiler +for Parallel ML and show that it can eliminate the burden of manual optimization +while delivering good practical performance.

+

Orthologic with Axioms

  • Simon Guilloud
  • Viktor Kunčak
+

We study the proof theory and algorithms for orthologic, a logical system based on ortholattices, which have shown practical relevance in simplification and normalization of verification conditions. Ortholattices weaken Boolean algebras while having polynomial-time equivalence checking that is sound with respect to Boolean algebra semantics. We generalize ortholattice reasoning and obtain an algorithm for proving a larger class of classically valid formulas. +

+

+ As the key result, we analyze a proof system for orthologic augmented with axioms. An important feature of the system is that it limits the number of formulas in a sequent to at most two, which makes the extension with axioms non-trivial. We show a generalized form of cut elimination for this system, which implies a sub-formula property. From there we derive a cubic-time algorithm for provability from axioms, or equivalently, for validity in finitely presented ortholattices. We further show that propositional resolution of width 5 proves all formulas provable in orthologic with axioms. We show that orthologic system subsumes resolution of width 2 and arbitrarily wide unit resolution and is complete for reasoning about generalizations of propositional Horn clauses. +

+

+ Moving beyond ground axioms, we introduce effectively propositional orthologic (by analogy with EPR for classical logic), presenting its semantics as well as a sound and complete proof system. Our proof system implies the decidability of effectively propositional orthologic, as well as its fixed-parameter tractability for a bounded maximal number of variables in each axiom. As a special case, we obtain a generalization of Datalog with negation and disjunction.

+

Polymorphic Type Inference for Dynamic Languages

  • Giuseppe Castagna
  • Mickaël Laurent
  • Kim Nguyễn
+

We present a type system that combines, in a controlled way, +first-order polymorphism with intersection types, union types, and +subtyping, and prove its safety. We then define a type reconstruction +algorithm that is sound and terminating. This yields a system in which +unannotated functions are given polymorphic types (thanks to +Hindley-Milner) that can express the overloaded behavior of the +functions they type (thanks to the intersection introduction rule) and +that are deduced by applying advanced techniques of type narrowing +(thanks to the union elimination rule). This makes the system a prime +candidate to type dynamic languages.

+

Fusing Direct Manipulations into Functional Programs

  • Xing Zhang
  • Ruifeng Xie
  • Guanchen Guo
  • Xiao He
  • Tao Zan
  • Zhenjiang Hu
+

Bidirectional live programming systems (BLP) enable developers to modify a program by directly manipulating the program output, so that the updated program can produce the manipulated output. One state-of-the-art approach to BLP systems is operation-based, which captures the developer's intention of program modifications by taking how the developer manipulates the output into account. The program modifications are usually hard coded for each direct manipulation in these BLP systems, which are difficult to extend. Moreover, to reflect the manipulations to the source program, these BLP systems trace the modified output to appropriate code fragments and perform corresponding code transformations. Accordingly, they require direct manipulation users be aware of the source code and how it is changed, making "direct" manipulation (on output) be "indirect". +

+

+In this paper, we resolve this problem by presenting a novel operation-based framework for bidirectional live programming, which can automatically fuse direct manipulations into the source code, thus supporting code-insensitive direct manipulations. Firstly, we design a simple but expressive delta language DM capable of expressing common direct manipulations for output values. Secondly, we present a fusion algorithm that propagates direct manipulations into the source functional programs and applies them to the constants whenever possible; otherwise, the algorithm embeds manipulations into the "proper positions" of programs. We prove the correctness of the fusion algorithm that the updated program executes to get the manipulated output. To demonstrate the expressiveness of DM and the effectiveness of our fusion algorithm, we have implemented FuseDM, a prototype SVG editor that supports GUI-based operations for direct manipulation, and successfully designed 14 benchmark examples starting from blank code using FuseDM.

+

On-the-Fly Static Analysis via Dynamic Bidirected Dyck Reachability

  • Shankaranarayanan Krishna
  • Aniket Lal
  • Andreas Pavlogiannis
  • Omkar Tuppe
+

Dyck reachability is a principled, graph-based formulation of a plethora of static analyses. Bidirected graphs are used for capturing dataflow through mutable heap data, and are usual formalisms of demand-driven points-to and alias analyses. The best (offline) algorithm runs in O(m+n· α(n)) time, where n is the number of nodes and m is the number of edges in the flow graph, which becomes O(n2) in the worst case.

In the everyday practice of program analysis, the analyzed code is subject to continuous change, with source code being added and removed. On-the-fly static analysis under such continuous updates gives rise to dynamic Dyck reachability, where reachability queries run on a dynamically changing graph, following program updates. Naturally, executing the offline algorithm in this online setting is inadequate, as the time required to process a single update is prohibitively large.

In this work we develop a novel dynamic algorithm for bidirected Dyck reachability that has O(n· α(n)) worst-case performance per update, thus beating the O(n2) bound, and is also optimal in certain settings. We also implement our algorithm and evaluate its performance on on-the-fly data-dependence and alias analyses, and compare it with two best known alternatives, namely (i) the optimal offline algorithm, and (ii) a fully dynamic Datalog solver. Our experiments show that our dynamic algorithm is consistently, and by far, the top performing algorithm, exhibiting speedups in the order of 1000X. The running time of each update is almost always unnoticeable to the human eye, making it ideal for the on-the-fly analysis setting.

+

Quantum Bisimilarity via Barbs and Contexts: Curbing the Power of Non-deterministic Observers

  • Lorenzo Ceragioli
  • Fabio Gadducci
  • Giuseppe Lomurno
  • Gabriele Tedeschi
+

Past years have seen the development of a few proposals for quantum extensions of process calculi. The rationale is clear: with the development of quantum communication protocols, there is a need to abstract and focus on the basic features of quantum concurrent systems, like CCS and CSP have done +for their classical counterparts. So far, though, no accepted standard has emerged, neither for the syntax nor for the behavioural semantics. Indeed, the various proposals do not agree on what should be the observational properties of quantum values, and as a matter of fact, the soundness of such properties has never been validated against the prescriptions of quantum theory. +

+

+To this aim, we introduce a new calculus, Linear Quantum CCS (lqCCS), and investigate the features of behavioural equivalences based on barbs and contexts. Our calculus can be thought of as an asynchronous, linear version of qCCS, which is in turn based on value-passing CCS. The combination of linearity and asynchronous communication fits well with the properties of quantum systems (e.g. the no-cloning theorem), since it ensures that each qubit is sent exactly once, precisely specifying which qubits of a process interact with the context. +

+

+We exploit contexts to examine how bisimilarities relate to quantum theory. We show that the observational power of general contexts is incompatible with quantum theory: roughly, they can perform non-deterministic moves depending on quantum values without measuring (hence perturbing) them. +

+

+Therefore, we refine the operational semantics in order to prevent contexts from performing unfeasible non-deterministic choices. This induces a coarser bisimilarity that better fits the quantum setting: (i) it lifts the indistinguishability of quantum states to the distributions of processes and, despite the additional constraints, (ii) it preserves the expressiveness of non-deterministic choices based on classical information. To the best of our knowledge, our semantics is the first one that satisfies the two properties above.

+

Internalizing Indistinguishability with Dependent Types

  • Yiyun Liu
  • Jonathan Chan
  • Jessica Shi
  • Stephanie Weirich
+

In type systems with dependency tracking, programmers can assign an ordered set of levels to computations and prevent information flow from high-level computations to the low-level ones. The key notion in such systems is indistinguishability: a definition of program equivalence that takes into account the parts of the program that an observer may depend on. In this paper, we investigate the use of dependency tracking in the context of dependently-typed languages. We present the Dependent Calculus of Indistinguishability (DCOI), a system that adopts indistinguishability as the definition of equality used by the type checker. DCOI also internalizes that relation as an observer-indexed propositional equality type, so that programmers may reason about indistinguishability within the language. Our design generalizes and extends prior systems that combine dependency tracking with dependent types and is the first to support conversion and propositional equality at arbitrary observer levels. We have proven type soundness and noninterference theorems for DCOI and have developed a prototype implementation of its type checker.

+

Polyregular Functions on Unordered Trees of Bounded Height

  • Mikołaj Bojańczyk
  • Bartek Klin
+

We consider injective first-order interpretations that input and output trees of bounded height. The corresponding functions have polynomial output size, since a first-order interpretation can use a k-tuple of input nodes to represent a single output node. We prove that the equivalence problem for such functions is decidable, i.e. ‍given two such interpretations, one can decide whether, for every input tree, the two output trees are isomorphic.

We also give a calculus of typed functions and combinators which derives exactly injective first-order interpretations for unordered trees of bounded height. The calculus is based on a type system, where the type constructors are products, coproducts and a monad of multisets. Thanks to our results about tree-to-tree interpretations, the equivalence problem is decidable for this calculus.

As an application, we show that the equivalence problem is decidable for first-order interpretations between classes of graphs that have bounded tree-depth. In all cases studied in this paper, first-order logic and MSO have the same expressive power, and hence all results apply also to MSO interpretations.

+

The Complex(ity) Landscape of Checking Infinite Descent

  • Liron Cohen
  • Adham Jabarin
  • Andrei Popescu
  • Reuben N. S. Rowe
+

Cyclic proof systems, in which induction is managed implicitly, are a promising approach to automatic +verification. The soundness of cyclic proof graphs is ensured by checking them against a trace-based Infinite Descent property. Although the problem of checking Infinite Descent is known to be PSPACE-complete, this leaves much room for variation in practice. Indeed, a number of different approaches are employed across the various cyclic proof systems described in the literature. In this paper, we study criteria for Infinite Descent in an abstract, logic-independent setting. We look at criteria based on Büchi automata encodings and relational abstractions, and determine their parameterized time complexities in terms of natural dimensions of cyclic proofs: the numbers of vertices of the proof-tree graphs, and the vertex width—an upper bound on the number of components (e.g., formulas) of a sequent that can be simultaneously tracked for descent. We identify novel algorithms that improve upon the parameterised complexity of the existing algorithms. We implement the studied criteria and compare their performance on various benchmarks.

+

Deadlock-Free Separation Logic: Linearity Yields Progress for Dependent Higher-Order Message Passing

  • Jules Jacobs
  • Jonas Kastberg Hinrichsen
  • Robbert Krebbers
+

We introduce a linear concurrent separation logic, called LinearActris, designed to guarantee deadlock and leak freedom for message-passing concurrency. LinearActris combines the strengths of session types and concurrent separation logic, allowing for the verification of challenging higher-order programs with mutable state through dependent protocols. The key challenge is to prove the adequacy theorem of LinearActris, which says that the logic indeed gives deadlock and leak freedom “for free” from linearity. We prove this theorem by defining a step-indexed model of separation logic, based on connectivity graphs. To demonstrate the expressive power of LinearActris, we prove soundness of a higher-order (GV-style) session type system using the technique of logical relations. All our results and examples have been mechanized in Coq.

+

When Subtyping Constraints Liberate: A Novel Type Inference Approach for First-Class Polymorphism

  • Lionel Parreaux
  • Aleksander Boruch-Gruszecki
  • Andong Fan
  • Chun Yin Chau
+

Type inference in the presence of first-class or “impredicative” second-order polymorphism à la System F has been an active research area for several decades, with original works dating back to the end of the 80s. Yet, until now many basic problems remain open, such as how to type check expressions like (𝜆𝑥. (𝑥 123, 𝑥 True)) id reliably. We show that a type inference approach based on multi-bounded polymorphism, a form of implicit polymorphic subtyping with multiple lower and upper bounds, can help us resolve most of these problems in a uniquely simple and regular way. We define F{≤}, a declarative type system derived from the existing theory of implicit coercions by Cretin and Rémy (LICS 2014), and we introduce SuperF, a novel algorithm to infer polymorphic multi-bounded F{≤} types while checking user type annotations written in the syntax of System F. We use a recursion-avoiding heuristic to guarantee termination of type inference at the cost of rejecting some valid programs, which thankfully rarely triggers in practice. We show that SuperF is vastly more powerful than all first-class-polymorphic type inference systems proposed so far, significantly advancing the state of the art in type inference for general-purpose programming languages.

+

Validation of Modern JSON Schema: Formalization and Complexity

  • Lyes Attouche
  • Mohamed-Amine Baazizi
  • Dario Colazzo
  • Giorgio Ghelli
  • Carlo Sartiani
  • Stefanie Scherzinger
+

JSON Schema is the de-facto standard schema language for JSON data. The language went through many minor revisions, but the most recent versions of the language, starting from Draft 2019-09, added two novel features, dynamic references and annotation-dependent validation, that change the evaluation model. Modern JSON Schema is the name used to indicate all versions from Draft 2019-09, which are characterized by these new features, while Classical JSON Schema is used to indicate the previous versions. +

+

+These new “modern” features make the schema language quite difficult to understand and have generated many discussions about the correct interpretation of their official specifications; for this reason, we undertook the task of their formalization. During this process, we also analyzed the complexity of data validation in Modern JSON Schema, with the idea of confirming the polynomial complexity of Classical JSON Schema validation, and we were surprised to discover a completely different truth: data validation, which is expected to be an extremely efficient process, acquires, with Modern JSON Schema features, a PSPACE complexity. +

+

+In this paper, we give the first formal description of Modern JSON Schema, which we have discussed with the community of JSON Schema tool developers, and which we consider a central contribution of this work. We then prove that its data validation problem is PSPACE-complete. We prove that the origin of the problem lies in the Draft 2020-12 version of dynamic references, and not in annotation-dependent validation. We study the schema and data complexities, showing that the problem is PSPACE-complete with respect to the schema size even with a fixed instance but is in P when the schema is fixed and only the instance size is allowed to vary. Finally, we run experiments that show that there are families of schemas where the difference in asymptotic complexity between dynamic and static references is extremely visible, even with small schemas.

+

Thunks and Debits in Separation Logic with Time Credits

  • François Pottier
  • Armaël Guéneau
  • Jacques-Henri Jourdan
  • Glen Mével
+

A thunk is a mutable data structure that offers a simple memoization service: +it stores either a suspended computation or the result of this computation. +Okasaki [1999] presents many data structures that exploit thunks to achieve +good amortized time complexity. He analyzes their complexity by associating a +debit with every thunk. A debit can be paid off in several increments; a thunk +whose debit has been fully paid off can be forced. Quite strikingly, a debit is +associated also with future thunks, which do not yet exist in memory. Some of +the debit of a faraway future thunk can be transferred to a nearer future +thunk. We present a complete machine-checked reconstruction of Okasaki's +reasoning rules in Iris$, a rich separation logic with time credits. We +demonstrate the applicability of the rules by verifying a few operations on +streams as well as several of Okasaki's data structures, namely the +physicist's queue, implicit queues, and the banker's queue.

+

Unboxed Data Constructors: Or, How cpp Decides a Halting Problem

  • Nicolas Chataing
  • Stephen Dolan
  • Gabriel Scherer
  • Jeremy Yallop
+

We propose a new language feature for ML-family languages, the ability to selectively unbox certain data constructors, so that their runtime representation gets compiled away to just the identity on their argument. Unboxing must be statically rejected when it could introduce confusion, that is, distinct values with the same representation.

We discuss the use-case of big numbers, where unboxing allows to write code that is both efficient and safe, replacing either a safe but slow version or a fast but unsafe version. We explain the static analysis necessary to reject incorrect unboxing requests. We present our prototype implementation of this feature for the OCaml programming language, discuss several design choices and the interaction with advanced features such as Guarded Algebraic Datatypes.

Our static analysis requires expanding type definitions in type expressions, which is not necessarily normalizing in presence of recursive type definitions. In other words, we must decide normalization of terms in the first-order λ-calculus with recursion. We provide an algorithm to detect non-termination on-the-fly during reduction, with proofs of correctness and completeness. Our algorithm turns out to be closely related to the normalization strategy for macro expansion in the cpp preprocessor.

+

Efficient Bottom-Up Synthesis for Programs with Local Variables

  • Xiang Li
  • Xiangyu Zhou
  • Rui Dong
  • Yihong Zhang
  • Xinyu Wang
+

We propose a new synthesis algorithm that can efficiently search programs with local variables (e.g., those introduced by lambdas). Prior bottom-up synthesis algorithms are not able to evaluate programs with free local variables, and therefore cannot effectively reduce the search space of such programs (e.g., using standard observational equivalence reduction techniques), making synthesis slow. Our algorithm can reduce the space of programs with local variables. The key idea, dubbed lifted interpretation, is to lift up the program interpretation process, from evaluating one program at a time to simultaneously evaluating all programs from a grammar. Lifted interpretation provides a mechanism to systematically enumerate all binding contexts for local variables, thereby enabling us to evaluate and reduce the space of programs with local variables. Our ideas are instantiated in the domain of web automation. The resulting tool, Arborist, can automate a significantly broader range of challenging tasks more efficiently than state-of-the-art techniques including WebRobot and Helena.

+

Disentanglement with Futures, State, and Interaction

  • Jatin Arora
  • Stefan K. Muller
  • Umut A. Acar
+

Recent work has proposed a memory property for parallel programs, +called disentanglement, and showed that it is pervasive in a variety +of programs, written in different languages, ranging from C/C++ to +Parallel ML, and showed that it can be exploited to improve +the performance of parallel functional programs. +All existing work on disentanglement, however, considers the +"fork/join" model for parallelism and does not apply to "futures", +the more powerful approach to parallelism. +This is not surprising: +fork/join parallel programs exhibit a reasonably strict dependency +structure (e.g., series-parallel DAGs), which disentanglement exploits. +In contrast, with futures, parallel computations become first-class +values of the language, and thus can be created, and passed between +functions calls or stored in memory, just like other ordinary values, +resulting in complex dependency structures, especially in the +presence of mutable state. +For example, parallel programs with futures can have deadlocks, which +is impossible with fork-join parallelism. +

+

+In this paper, we are interested in the theoretical question of +whether disentanglement may be extended beyond fork/join parallelism, +and specifically to futures. +We consider a functional language with futures, Input/Output (I/O), +and mutable state (references) and show that a broad range of programs +written in this language are disentangled. +We start by formalizing disentanglement for futures and proving that +purely functional programs written in this language are disentangled. +We then generalize this result in three directions. +First, we consider state (effects) and prove that stateful programs +are disentangled if they are race free. +Second, we show that race freedom is sufficient but not a necessary +condition and non-deterministic programs, e.g. those that use atomic +read-modify-operations and some non-deterministic combinators, may +also be disentangled. +Third, we prove that disentangled task-parallel programs written with +futures are free of deadlocks, which arise due to interactions between +state and the rich dependencies that can be expressed with futures. +Taken together, these results show that disentanglement generalizes to +parallel programs with futures and, thus, the benefits of disentanglement +may go well beyond fork-join parallelism.

+

Soundly Handling Linearity

  • Wenhao Tang
  • Daniel Hillerström
  • Sam Lindley
  • J. Garrett Morris
+

We propose a novel approach to soundly combining linear types with multi-shot effect handlers. circear type systems statically ensure that resources such as file handles and communication channels are used exactly once. Effect handlers provide a rich modular programming abstraction for implementing features ranging from exceptions to concurrency to backtracking. Whereas conventional linear type systems bake in the assumption that continuations are invoked exactly once, effect handlers allow continuations to be discarded (e.g. for exceptions) or invoked more than once (e.g. for backtracking). This mismatch leads to soundness bugs in existing systems such as the programming language Links, which combines linearity (for session types) with effect handlers. We introduce control-flow linearity as a means to ensure that continuations are used in accordance with the linearity of any resources they capture, ruling out such soundness bugs.

We formalise the notion of control-flow linearity in a System F-style core calculus Feff∘ equipped with linear types, an effect type system, and effect handlers. We define a linearity-aware semantics in order to formally prove that Feff∘ preserves the integrity of linear values in the sense that no linear value is discarded or duplicated. In order to show that control-flow linearity can be made practical, we adapt circks based on the design of Feff∘, in doing so fixing a long-standing soundness bug.

Finally, to better expose the potential of control-flow linearity, we define an ML-style core calculus Qeff∘, based on qualified types, which requires no programmer provided annotations, and instead relies entirely on type inference to infer control-flow linearity. Both linearity and effects are captured by qualified types. Qeff∘ overcomes a number of practical limitations of Feff∘, supporting abstraction over linearity, linearity dependencies between type variables, and a much more fine-grained notion of control-flow linearity.

+

Monotonicity and the Precision of Program Analysis

  • Marco Campion
  • Mila Dalla Preda
  • Roberto Giacobazzi
  • Caterina Urban
+

It is widely known that the precision of a program analyzer is closely related to intensional program properties, +namely, properties concerning how the program is written. +This explains, for instance, the interest in code obfuscation techniques, namely, tools +explicitly designed to degrade the results of program analysis by operating syntactic program transformations. +Less is known about a possible relation between what the program extensionally computes, +namely, its input-output relation, and the precision of a program analyzer. +In this paper we explore this potential connection in an effort to isolate program fragments +that can be precisely analyzed by abstract interpretation, namely, +programs for which there exists a complete abstract interpretation. +In the field of static inference of numeric invariants, this happens for programs, +or parts of programs, that manifest a monotone (either non-decreasing or non-increasing) behavior. +We first formalize the notion of program monotonicity with respect to a given input and a set of numerical variables of interest. +A sound proof system is then introduced with judgments specifying whether a +program is monotone relatively to a set of variables and a set of inputs. +The interest in monotonicity is justified because we prove that the family +of monotone programs admits a complete abstract interpretation over +a specific class of non-trivial numerical abstractions and inputs. +This class includes all non-relational abstract domains that refine interval analysis +(i.e., at least as precise as the intervals abstraction) and that satisfy a topological convexity hypothesis.

+

Algebraic Effects Meet Hoare Logic in Cubical Agda

  • Donnacha Oisín Kidney
  • Zhixuan Yang
  • Nicolas Wu
+

This paper presents a novel formalisation of algebraic effects with equations in Cubical Agda. Unlike previous work in the literature that employed setoids to deal with equations, the library presented here uses quotient types to faithfully encode the type of terms quotiented by laws. Apart from tools for equational reasoning, the library also provides an effect-generic Hoare logic for algebraic effects, which enables reasoning about effectful programs in terms of their pre- and post- conditions. A particularly novel aspect is that equational reasoning and Hoare-style reasoning are related by an elimination principle of Hoare logic.

+

Solving Infinite-State Games via Acceleration

  • Philippe Heim
  • Rayna Dimitrova
+

Two-player graph games have found numerous applications, most notably in the synthesis of reactive systems from temporal specifications, but also in verification. The relevance of infinite-state systems in these areas has lead to significant attention towards developing techniques for solving infinite-state games. +

+

+We propose novel symbolic semi-algorithms for solving infinite-state games with temporal winning conditions. The novelty of our approach lies in the introduction of an acceleration technique that enhances fixpoint-based game-solving methods and helps to avoid divergence. Classical fixpoint-based algorithms, when applied to infinite-state games, are bound to diverge in many cases, since they iteratively compute the set of states from which one player has a winning strategy. Our proposed approach can lead to convergence in cases where existing algorithms require an infinite number of iterations. This is achieved by acceleration: computing an infinite set of states from which a simpler sub-strategy can be iterated an unbounded number of times in order to win the game. Ours is the first method for solving infinite-state games to employ acceleration. Thanks to this, it is able to outperform state-of-the-art techniques on a range of benchmarks, as evidenced by our evaluation of a prototype implementation.

+

Guided Equality Saturation

  • Thomas Kœhler
  • Andrés Goens
  • Siddharth Bhat
  • Tobias Grosser
  • Phil Trinder
  • Michel Steuwer
+

Rewriting is a principled term transformation technique with uses across theorem +proving and compilation. +In theorem proving, each rewrite is a proof step; in compilation, rewrites optimize a program term. +While developing rewrite sequences manually is possible, this process does not +scale to larger rewrite sequences. Automated rewriting +techniques, like greedy simplification or equality saturation, work well +without requiring human input. +Yet, they do not scale to large search spaces, limiting the complexity of tasks where automated rewriting is effective, +and meaning that just a small increase in term size or rewrite length may result in failure. + +This paper proposes a semi-automatic rewriting technique as a means to scale rewriting by allowing +human insight at key decision points. +Specifically, we propose guided equality saturation that embraces human guidance when fully automated equality saturation does not scale. +The rewriting is split into two simpler automatic equality saturation steps: from the original term to a human-provided intermediate guide, and from the guide to the target. Complex rewriting tasks may require multiple guides, resulting in a sequence of equality saturation steps. +A guide can be a complete term, or a sketch containing undefined elements that are instantiated by the equality saturation search. +Such sketches may be far more concise than complete terms. + +We demonstrate the generality and effectiveness of guided equality saturation using two case studies. +First, we integrate guided equality saturation in the Lean 4 proof assistant. +Proofs are written in the style of textbook proof sketches, as a series of calculations omitting details and skipping steps. +These proofs conclude in less than a second instead of minutes when compared to unguided equality saturation, and can +find complex proofs that previously had to be done manually. +Second, in the compiler of the Rise array language, where unguided equality saturation fails to perform optimizations within an hour and using 60 GB of memory, guided equality saturation performs the same optimizations with at most 3 guides, within seconds using less than 1 GB memory.

+

A Case for Synthesis of Recursive Quantum Unitary Programs

  • Haowei Deng
  • Runzhou Tao
  • Yuxiang Peng
  • Xiaodi Wu
+

Quantum programs are notoriously difficult to code and verify due to unintuitive quantum knowledge associated with quantum programming. Automated tools relieving the tedium and errors associated with low-level quantum details would hence be highly desirable. In this paper, we initiate the study of program synthesis for quantum unitary programs that recursively define a family of unitary circuits for different input sizes, which are widely used in existing quantum programming languages. Specifically, we present QSynth, the first quantum program synthesis framework, including a new inductive quantum programming language, its specification, a sound logic for reasoning, and an encoding of the reasoning procedure into SMT instances. By leveraging existing SMT solvers, QSynth successfully synthesizes ten quantum unitary programs including quantum adder circuits, quantum eigenvalue inversion circuits and Quantum Fourier Transformation, which can be readily transpiled to executable programs on major quantum platforms, e.g., Q#, IBM Qiskit, and AWS Braket.

+

A Formalization of Core Why3 in Coq

  • Joshua M. Cohen
  • Philip Johnson-Freyd
+

Intermediate verification languages like Why3 and Boogie have made it much easier to build program verifiers, transforming the process into a logic compilation problem rather than a proof automation one. +Why3 in particular implements a rich logic for program specification with polymorphism, algebraic data types, recursive functions and predicates, and inductive predicates; it translates this logic to over a dozen solvers and proof assistants. +Accordingly, it serves as a backend for many tools, including Frama-C, EasyCrypt, and GNATProve for Ada SPARK. +But how can we be sure that these tools are correct? +The alternate foundational approach, taken by tools like VST and CakeML, provides strong guarantees by implementing the entire toolchain in a proof assistant, but these tools are harder to build and cannot directly take advantage of SMT solver automation. +As a first step toward enabling automated tools with similar foundational guarantees, we give a formal semantics in Coq for the logic fragment of Why3. +We show that our semantics are useful by giving a correct-by-construction natural deduction proof system for this logic, using this proof system to verify parts of Why3's standard library, and proving sound two of Why3's transformations used to convert terms and formulas into the simpler logics supported by the backend solvers.

+

Probabilistic Programming Interfaces for Random Graphs: Markov Categories, Graphons, and Nominal Sets

  • Nate Ackerman
  • Cameron E. Freer
  • Younesse Kaddar
  • Jacek Karwowski
  • Sean Moss
  • Daniel Roy
  • Sam Staton
  • Hongseok Yang
+

We study semantic models of probabilistic programming languages over graphs, and establish a connection to graphons from graph theory and combinatorics. We show that every well-behaved equational theory for our graph probabilistic programming language corresponds to a graphon, and conversely, every graphon arises in this way. +

+

+We provide three constructions for showing that every graphon arises from an equational theory. The first is an abstract construction, using Markov categories and monoidal indeterminates. The second and third are more concrete. The second is in terms of traditional measure theoretic probability, which covers 'black-and-white' graphons. The third is in terms of probability monads on the nominal sets of Gabbay and Pitts. Specifically, we use a variation of nominal sets induced by the theory of graphs, which covers Erdős-Rényi graphons. In this way, we build new models of graph probabilistic programming from graphons.

+

API-Driven Program Synthesis for Testing Static Typing Implementations

  • Thodoris Sotiropoulos
  • Stefanos Chaliasos
  • Zhendong Su
+

We introduce a novel approach for testing static typing implementations based on the concept of API-driven program synthesis. The idea is to synthesize type-intensive but small and well-typed programs by leveraging and combining application programming interfaces (APIs) derived from existing software libraries. Our primary insight is backed up by real-world evidence: a significant number of compiler typing bugs are caused by small test cases that employ APIs from the standard library of the language under test. This is attributed to the inherent complexity of the majority of these APIs, which often exercise a wide range of sophisticated type-related features. The main contribution of our approach is the ability to produce small client programs with increased feature coverage, without bearing the burden of generating the corresponding well-formed API definitions from scratch. To validate diverse aspects of static typing procedures (i.e., soundness, precision of type inference), we also enrich our API-driven approach with fault-injection and semantics-preserving modes, along with their corresponding test oracles. +

+

+We evaluate our implemented tool, Thalia on testing the static typing implementations of the compilers for three popular languages, namely, Scala, Kotlin, and Groovy. Thalia has uncovered 84 typing bugs (77 confirmed and 22 fixed), most of which are triggered by test cases featuring APIs that rely on parametric polymorphism, overloading, and higher-order functions. Our comparison with state-of-the-art shows that Thalia yields test programs with distinct characteristics, offering additional and complementary benefits.

+

Inference of Probabilistic Programs with Moment-Matching Gaussian Mixtures

  • Francesca Randone
  • Luca Bortolussi
  • Emilio Incerto
  • Mirco Tribastone
+

Computing the posterior distribution of a probabilistic program is a hard task for which no one-fit-for-all solution exists. We propose Gaussian Semantics, which approximates the exact probabilistic semantics of a bounded program by means of Gaussian mixtures. It is parametrized by a map that associates each program location with the moment order to be matched in the approximation. We provide two main contributions. The first is a universal approximation theorem stating that, under mild conditions, Gaussian Semantics can approximate the exact semantics arbitrarily closely. The second is an approximation that matches up to second-order moments analytically in face of the generally difficult problem of matching moments of Gaussian mixtures with arbitrary moment order. We test our second-order Gaussian approximation (SOGA) on a number of case studies from the literature. We show that it can provide accurate estimates in models not supported by other approximation methods or when exact symbolic techniques fail because of complex expressions or non-simplified integrals. On two notable classes of problems, namely collaborative filtering and programs involving mixtures of continuous and discrete distributions, we show that SOGA significantly outperforms alternative techniques in terms of accuracy and computational time.

+

Decision and Complexity of Dolev-Yao Hyperproperties

  • Itsaka Rakotonirina
  • Gilles Barthe
  • Clara Schneidewind
+

The formal analysis of cryptographic protocols traditionally focuses on trace and equivalence properties, for which decision procedures in the symbolic (or Dolev-Yao, or DY) model are known. However, many relevant security properties are expressed as DY hyperproperties that involve quantifications over both execution paths and attacker computations (which are constrained by the attacker's knowledge in the underlying model of computation). DY hyperproperties generalise hyperproperties, for which many decision procedures exist, to the setting of DY models. Unfortunately, the subtle interactions between both forms of quantifications have been an obstacle to lifting decision procedures from hyperproperties to DY hyperproperties. +

+

+The central contribution of the paper is the first procedure for deciding DY hyperproperties, in the usual setting where the number of protocol sessions is bounded and where the equational theory modelling cryptography is subterm-convergent. We prove that our decision procedure can decide the validity of any hyperproperty in which quantifications over messages are guarded and quantifications over attacker computations are limited to expressing the attacker's knowledge. We also establish the complexity of the decision problem for several important fragments of the hyperlogic. Further, we illustrate the techniques and scope of our contributions through examples of related hyperproperties.

+

Parikh’s Theorem Made Symbolic

  • Matthew Hague
  • Artur Jeż
  • Anthony W. Lin
+

Parikh’s Theorem is a fundamental result in automata theory with numerous applications in computer science. These include software verification (e.g. infinite-state verification, string constraints, and theory of arrays), verification of cryptographic protocols (e.g. using Horn clauses modulo equational theories) and database querying (e.g. evaluating path-queries in graph databases), among others. Parikh’s Theorem states that the letter-counting abstraction of a language recognized by finite automata or context-free grammars is definable in Linear Integer Arithmetic (a.k.a. Presburger Arithmetic). In fact, there is a linear-time algorithm computing existential Presburger formulas capturing such abstractions, which enables an efficient analysis via SMT-solvers. Unfortunately, real-world applications typically require large alphabets (e.g. Unicode, containing a ‍million of characters) — which are well-known to be not amenable to explicit treatment of the alphabets — or even worse infinite alphabets.

Symbolic automata have proven in the last decade to be an effective algorithmic framework for handling large finite or even infinite alphabets. A symbolic automaton employs an effective boolean algebra, which offers a symbolic representation of character sets (i.e. in terms of predicates) and often lends itself to an exponentially more succinct representation of a language. Instead of letter-counting, Parikh’s Theorem for symbolic automata amounts to counting the number of times different predicates are satisfied by an input sequence. Unfortunately, naively applying Parikh’s Theorem from classical automata theory to symbolic automata yields existential Presburger formulas of exponential size. In this paper, we provide a new construction for Parikh’s Theorem for symbolic automata and grammars, which avoids this exponential blowup: our algorithm computes an existential formula in polynomial-time over (quantifier-free) Presburger and the base theory. In fact, our algorithm extends to the model of parametric symbolic grammars, which are one of the most expressive models of languages over infinite alphabets. We have implemented our algorithm and show it can be used to solve string constraints that are difficult to solve by existing solvers.

+

How Hard Is Weak-Memory Testing?

  • Soham Chakraborty
  • Shankara Narayanan Krishna
  • Umang Mathur
  • Andreas Pavlogiannis
+

Weak-memory models are standard formal specifications of concurrency across hardware, programming languages, and distributed systems. A fundamental computational problem is consistency testing: is the observed execution of a concurrent program in alignment with the specification of the underlying system? The problem has been studied extensively across Sequential Consistency (SC) and weak memory, and proven to be NP-complete when some aspect of the input (e.g., number of threads/memory locations) is unbounded. This unboundedness has left a natural question open: are there efficient parameterized algorithms for testing?

The main contribution of this paper is a deep hardness result for consistency testing under many popular weak-memory models: the problem remains NP-complete even in its bounded setting, where candidate executions contain a bounded number of threads, memory locations, and values. This hardness spreads across several Release-Acquire variants of C11, a popular variant of its Relaxed fragment, popular Causal Consistency models, and the POWER architecture. To our knowledge, this is the first result that fully exposes the hardness of weak-memory testing and proves that the problem admits no parameterization under standard input parameters. It also yields a computational separation of these models from SC, x86-TSO, PSO, and Relaxed, for which bounded consistency testing is either known (for SC), or shown here (for the rest), to be in polynomial time.

+

Ill-Typed Programs Don’t Evaluate

  • Steven Ramsay
  • Charlie Walpole
+

We introduce two-sided type systems, which are sequent calculi for typing formulas. Two-sided type systems allow for hypothetical reasoning over the typing of compound program expressions, and the refutation of typing formulas. By incorporating a type of all values, these type systems support more refined notions of well-typing and ill-typing, guaranteeing both that well-typed programs don't go wrong and that ill-typed programs don't evaluate - that is, reach a value. This makes two-sided type systems suitable for incorrectness reasoning in higher-order program verification, which we illustrate through an application to precise data-flow typing in a language with constructors and pattern matching. Finally, we investigate the internalisation of the meta-level negation in the system as a complement operator on types. This motivates an alternative semantics for the typing judgement, which guarantees that ill-typed programs don't evaluate, but in which well-typed programs may yet go wrong.

+

Total Type Error Localization and Recovery with Holes

  • Eric Zhao
  • Raef Maroof
  • Anand Dukkipati
  • Andrew Blinn
  • Zhiyi Pan
  • Cyrus Omar
+

Type systems typically only define the conditions under which an expression is well-typed, leaving ill-typed expressions formally meaningless. This approach is insufficient as the basis for language servers driving modern programming environments, which are expected to recover from simultaneously localized errors and continue to provide a variety of downstream semantic services. This paper addresses this problem, contributing the first comprehensive formal account of total type error localization and recovery: the marked lambda calculus. In particular, we define a gradual type system for expressions with marked errors, which operate as non-empty holes, together with a total procedure for marking arbitrary unmarked expressions. We mechanize the metatheory of the marked lambda calculus in Agda and implement it, scaled up, as the new basis for Hazel, a full-scale live functional programming environment with, uniquely, no meaningless editor states. +

+

+The marked lambda calculus is bidirectionally typed, so localization decisions are systematically predictable based on a local flow of typing information. Constraint-based type inference can bring more distant information to bear in discovering inconsistencies but this notoriously complicates error localization. We approach this problem by deploying constraint solving as a type-hole-filling layer atop this gradual bidirectionally typed core. Errors arising from inconsistent unification constraints are localized exclusively to type and expression holes, i.e. the system identifies unfillable holes using a system of traced provenances, rather than localized in an ad hoc manner to particular expressions. The user can then interactively shift these errors to particular downstream expressions by selecting from suggested partially consistent type hole fillings, which returns control back to the bidirectional system. We implement this type hole inference system in Hazel.

+

VST-A: A Foundationally Sound Annotation Verifier

  • Litao Zhou
  • Jianxing Qin
  • Qinshi Wang
  • Andrew W. Appel
  • Qinxiang Cao
+

Program verifiers for imperative languages such as C may be annotation-based, in which assertions and invariants are put into source files and then checked, or tactic-based, where proof scripts separate from programs are interactively developed in a proof assistant such as Coq. Annotation verifiers have been more automated and convenient, but some interactive verifiers have richer assertion languages and formal proofs of soundness. We present VST-A, an annotation verifier that uses the rich assertion language of VST, leverages the formal soundness proof of VST, but allows users to describe functional correctness proofs intuitively by inserting assertions. +

+

+VST-A analyzes control flow graphs, decomposes every C function into control flow paths between assertions, and reduces program verification problems into corresponding straightline Hoare triples. Compared to existing foundational program verification tools like VST and Iris, in VST-A such decompositions and reductions can nonstructural, which makes VST-A more flexible to use. +

+

+VST-A's decomposition and reduction is defined in Coq, proved sound in Coq, and computed call-by-value in Coq. The soundness proof for reduction is totally logical, independent of the complicated semantic model (and soundness proof) of +VST's Hoare triple. Because of the rich assertion language, not all reduced proof goals can be automatically checked, but the system allows users to prove residual proof goals using the full power of the Coq proof assistant.

+

Mechanizing Refinement Types

  • Michael H. Borkowski
  • Niki Vazou
  • Ranjit Jhala
+

Practical checkers based on refinement types use the combination of implicit semantic subtyping and parametric polymorphism to simplify the specification and automate the verification of sophisticated properties of programs. However, a formal metatheoretic accounting of the soundness of refinement type systems using this combination has proved elusive. We present λRF, a core refinement calculus that combines semantic subtyping and parametric polymorphism. We develop a metatheory for this calculus and prove soundness of the type system. Finally, we give two mechanizations of our metatheory. First, we introduce data propositions, a novel feature that enables encoding derivation trees for inductively defined judgments as refined data types, and use them to show that LiquidHaskell’s refinement types can be used for mechanization. Second, we mechanize our results in Coq, which comes with stronger soundness guarantees than LiquidHaskell, thereby laying the foundations for mechanizing the metatheory of LiquidHaskell.

+

Enhanced Enumeration Techniques for Syntax-Guided Synthesis of Bit-Vector Manipulations

  • Yuantian Ding
  • Xiaokang Qiu
+

Syntax-guided synthesis has been a prevalent theme in various computer-aided programming systems. However, the domain of bit-vector synthesis poses several unique challenges that have not yet been sufficiently addressed and resolved. In this paper, we propose a novel synthesis approach that incorporates a distinct enumeration strategy based on various factors. Technically, this approach weighs in subexpression recurrence by term-graph-based enumeration, avoids useless candidates by example-guided filtration, prioritizes valuable components identified by large language models. This approach also incorporates a bottom-up deduction step to enhance the enumeration algorithm by considering subproblems that contribute to the deductive resolution. We implement all the enhanced enumeration techniques in our SyGuS solver DryadSynth, which outperforms state-of-the-art solvers in terms of the number of solved problems, execution time, and solution size. Notably, DryadSynth successfully solved 31 synthesis problems for the first time, including 5 renowned Hacker's Delight problems.

+

Fully Composable and Adequate Verified Compilation with Direct Refinements between Open Modules

  • Ling Zhang
  • Yuting Wang
  • Jinhua Wu
  • Jérémie Koenig
  • Zhong Shao
+

Verified compilation of open modules (i.e., modules whose functionality depends on other modules) provides a foundation for end-to-end verification of modular programs ubiquitous in contemporary software. However, despite intensive investigation in this topic for decades,the proposed approaches are still difficult to use in practice as they rely on assumptions about the internal working of compilers which make it difficult for external users to apply the verification results. We propose an approach to verified compositional compilation without such assumptions in the setting of verifying compilation of heterogeneous modules written in first-order languages supporting global memory and pointers. Our approach is based on the memory model of CompCert and a new discovery that a Kripke relation with a notion of memory protection can serve as a uniform and composable semantic interface for the compiler passes. By absorbing the rely-guarantee conditions on memory evolution for all compiler passes into this Kripke Memory Relation and by piggybacking requirements on compiler optimizations onto it, we get compositional correctness theorems for realistic optimizing compilers as refinements that directly relate native semantics of open modules and that are ignorant of intermediate compilation processes. Such direct refinements support all the compositionality and adequacy properties essential for verified compilation of open modules. We have applied this approach to the full compilation chain of CompCert with its Clight source language and demonstrated that our compiler correctness theorem is open to composition and intuitive to use with reduced verification complexity through end-to-end verification of non-trivial heterogeneous modules that may freely invoke each other (e.g.,mutually recursively).

+

Predictive Monitoring against Pattern Regular Languages

  • Zhendong Ang
  • Umang Mathur
+

While current bug detection techniques for concurrent software focus on unearthing low-level issues such as data races or deadlocks, they often fall short of discovering more intricate temporal behaviours that can arise even in the absence of such low-level issues. In this paper, we focus on the problem of dynamically analysing concurrent software against high-level temporal specifications such as LTL. Existing techniques for runtime monitoring against such specifications are primarily designed for sequential software and remain inadequate in the presence of concurrency — violations may be observed only in intricate thread interleavings, requiring many re-runs of the underlying software in conjunction with the analysis. Towards this, we study the problem of predictive runtime monitoring, inspired by the analogous problem of predictive data race detection studied extensively recently. The predictive runtime monitoring question asks, given an execution σ, if it can be soundly reordered to expose violations of a specification. In general, this problem may become easily intractable when either the specifications or the notion of reorderings used is complex.

In this paper, we focus on specifications that are given in regular languages. Our notion of reorderings is trace equivalence, where an execution is considered a reordering of another if it can be obtained from the latter by successively commuting adjacent independent actions. We first show that, even in this simplistic setting, the problem of predictive monitoring admits a super-linear lower bound of O(nα), where n is the number of events in the execution, and α is a parameter describing the degree of commutativity, and typically corresponds to the number of threads in the execution. As a result, predictive runtime monitoring even in this setting is unlikely to be efficiently solvable, unlike in the non-predictive setting where the problem can be checked using a deterministic finite automaton (and thus, a constant-space streaming linear-time algorithm).

Towards this, we identify a sub-class of regular languages, called pattern languages (and their extension generalized pattern languages). Pattern languages can naturally express specific ordering of some number of (labelled) events, and have been inspired by popular empirical hypotheses underlying many concurrency bug detection approaches such as the “small bug depth” hypothesis. More importantly, we show that for pattern (and generalized pattern) languages, the predictive monitoring problem can be solved using a constant-space streaming linear-time algorithm. We implement and evaluate our algorithm PatternTrack on benchmarks from the literature and show that it is effective in monitoring large-scale applications.

+

Securing Verified IO Programs Against Unverified Code in F*

  • Cezar-Constantin Andrici
  • Ștefan Ciobâcă
  • Cătălin Hriţcu
  • Guido Martínez
  • Exequiel Rivas
  • Éric Tanter
  • Théo Winterhalter
+

We introduce SCIO*, a formally secure compilation framework for statically verified programs performing input-output (IO). The source language is an F* subset in which a verified program interacts with its IO-performing context via a higher-order interface that includes refinement types as well as pre- and post-conditions about past IO events. The target language is a smaller F* subset in which the compiled program is linked with an adversarial context that has an interface without refinement types, pre-conditions, or concrete post-conditions. To bridge this interface gap and make compilation and linking secure we propose a formally verified combination of higher-order contracts and reference monitoring for recording and controlling IO operations. Compilation uses contracts to convert the logical assumptions the program makes about the context into dynamic checks on each context-program boundary crossing. These boundary checks can depend on information about past IO events stored in the state of the monitor. But these checks cannot stop the adversarial target context before it performs dangerous IO operations. Therefore linking in SCIO* additionally forces the context to perform all IO actions via a secure IO library, which uses reference monitoring to dynamically enforce an access control policy before each IO operation. We prove in F* that SCIO* soundly enforces a global trace property for the compiled verified program linked with the untrusted context. Moreover, we prove in F* that SCIO* satisfies by construction Robust Relational Hyperproperty Preservation, a very strong secure compilation criterion. Finally, we illustrate SCIO* at work on a simple web server example.

+

ReLU Hull Approximation

  • Zhongkui Ma
  • Jiaying Li
  • Guangdong Bai
+

Convex hulls are commonly used to tackle the non-linearity of activation functions in the verification of neural networks. Computing the exact convex hull is a costly task though. In this work, we propose a fast and precise approach to over-approximating the convex hull of the ReLU function (referred to as the ReLU hull), one of the most used activation functions. Our key insight is to formulate a convex polytope that ”wraps” the ReLU hull, by reusing the linear pieces of the ReLU function as the lower faces and constructing upper faces that are adjacent to the lower faces. The upper faces can be efficiently constructed based on the edges and vertices of the lower faces, given that an n-dimensional (or simply nd hereafter) hyperplane can be determined by an (n−1)d hyperplane and a point outside of it. We implement our approach as WraLU, and evaluate its performance in terms of precision, efficiency, constraint complexity, and scalability. WraLU outperforms existing advanced methods by generating fewer constraints to achieve tighter approximation in less time. It exhibits versatility by effectively addressing arbitrary input polytopes and higher-dimensional cases, which are beyond the capabilities of existing methods. We integrate WraLU into PRIMA, a state-of-the-art neural network verifier, and apply it to verify large-scale ReLU-based neural networks. Our experimental results demonstrate that WraLU achieves a high efficiency without compromising precision. It reduces the number of constraints that need to be solved by the linear programming solver by up to half, while delivering comparable or even superior results compared to the state-of-the-art verifiers.

+

Polynomial Time and Dependent Types

  • Robert Atkey
+

We combine dependent types with linear type systems that soundly and completely capture polynomial time computation. We explore two systems for capturing polynomial time: one system that disallows construction of iterable data, and one, based on the LFPL system of Martin Hofmann, that controls construction via a payment method. Both of these are extended to full dependent types via Quantitative Type Theory, allowing for arbitrary computation in types alongside guaranteed polynomial time computation in terms. We prove the soundness of the systems using a realisability technique due to Dal Lago and Hofmann.

Our long-term goal is to combine the extensional reasoning of type theory with intensional reasoning about the resources intrinsically consumed by programs. This paper is a step along this path, which we hope will lead both to practical systems for reasoning about programs’ resource usage, and to theoretical use as a form of synthetic computational complexity theory.

+

Generating Well-Typed Terms That Are Not “Useless”

  • Justin Frank
  • Benjamin Quiring
  • Leonidas Lampropoulos
+

Random generation of well-typed terms lies at the core of effective +random testing of compilers for functional languages. +Existing techniques have had success following a top-down +type-oriented approach to generation that makes choices locally, which +suffers from an inherent limitation: the type of an expression is +often generated independently from the expression itself. +Such generation frequently yields functions with argument types that cannot +be used to produce a result in a meaningful way, leaving those +arguments unused. +Such "use-less" functions can hinder both performance, as the +argument generation code is dead but still needs to be compiled, and +effectiveness, as a lot of interesting optimizations are tested less +frequently. +

+

+In this paper, we introduce a novel algorithm that is significantly +more effective at generating functions that use their arguments. +We formalize both the "local" and the "nonlocal" algorithms as +step-relations in an extension of the simply-typed lambda calculus +with type and arguments holes, showing how delaying the generation of +types for subexpressions by allowing nonlocal generation steps leads +to "useful" functions.

+

Internal Parametricity, without an Interval

  • Thorsten Altenkirch
  • Yorgo Chamoun
  • Ambrus Kaposi
  • Michael Shulman
+

Parametricity is a property of the syntax of type theory implying, + e.g., that there is only one function having the type of the + polymorphic identity function. Parametricity is usually proven + externally, and does not hold internally. Internalising it is + difficult because once there is a term witnessing parametricity, it + also has to be parametric itself and this results in the appearance + of higher dimensional cubes. In previous theories with internal + parametricity, either an explicit syntax for higher cubes is present + or the theory is extended with a new sort for the interval. In this + paper we present a type theory with internal parametricity which is + a simple extension of Martin-Löf type theory: there are a few new + type formers, term formers and equations. Geometry is not explicit + in this syntax, but emergent: the new operations and equations only + refer to objects up to dimension 3. We show that this theory is + modelled by presheaves over the BCH cube category. Fibrancy + conditions are not needed because we use span-based rather than + relational parametricity. We define a gluing model for this theory + implying that external parametricity and canonicity hold. The theory + can be seen as a special case of a new kind of modal type theory, + and it is the simplest setting in which the computational properties + of higher observational type theory can be demonstrated.

+

Explicit Effects and Effect Constraints in ReML

  • Martin Elsman
+

An important aspect of building robust systems that execute on dedicated hardware and perhaps in constrained environments is to control and manage the effects performed by program code. +

+

+We present ReML, a higher-order statically-typed functional language, which allows programmers to be explicit about the effects performed by program code and in particular effects related to memory management. Allowing programmers to be explicit about effects, the regions in which values reside, and the constraints under which code execute, makes programs robust to changes in the program source code and to compiler updates, including compiler optimisations. +

+

+ReML is integrated with a polymorphic inference system that builds on top of region-inference, as it is implemented in the MLKit, a Standard ML compiler that uses region-based memory management as its primary memory management scheme.

+

Indexed Types for a Statically Safe WebAssembly

  • Adam T. Geller
  • Justin Frank
  • William J. Bowman
+

We present Wasm-prechk, a superset of WebAssembly (Wasm) that uses indexed types to express and check simple constraints over program values. This additional static reasoning enables safely removing dynamic safety checks from Wasm, such as memory bounds checks. We implement Wasm-prechk as an extension of the Wasmtime compiler and runtime, evaluate the run-time and compile-time performance of Wasm-prechk vs WebAssembly configurations with explicit dynamic checks, and find an average run-time performance gain of 1.71x faster in the widely used PolyBenchC benchmark suite, for a small overhead in binary size (7.18% larger) and type-checking time (1.4% slower). We also prove type and memory safety of Wasm-prechk, prove Wasm safely embeds into Wasm-prechk ensuring backwards compatibility, prove Wasm-prechk type-erases to Wasm, and discuss design and implementation trade-offs.

+

SimuQ: A Framework for Programming Quantum Hamiltonian Simulation with Analog Compilation

  • Yuxiang Peng
  • Jacob Young
  • Pengyu Liu
  • Xiaodi Wu
+

Quantum Hamiltonian simulation, which simulates the evolution of quantum systems and probes quantum phenomena, is one of the most promising applications of quantum computing. Recent experimental results suggest that Hamiltonian-oriented analog quantum simulation would be advantageous over circuit-oriented digital quantum simulation in the Noisy Intermediate-Scale Quantum (NISQ) machine era. However, programming analog quantum simulators is much more challenging due to the lack of a unified interface between hardware and software. In this paper, we design and implement SimuQ, the first framework for quantum Hamiltonian simulation that supports Hamiltonian programming and pulse-level compilation to heterogeneous analog quantum simulators. Specifically, in SimuQ, front-end users specify the target quantum system with Hamiltonian Modeling Language, and the Hamiltonian-level programmability of analog quantum simulators is specified through a new abstraction called the abstract analog instruction set (AAIS) and programmed in AAIS Specification Language by hardware providers. Through a solver-based compilation, SimuQ generates executable pulse schedules for real devices to simulate the evolution of desired quantum systems, which is demonstrated on superconducting (IBM), neutral-atom (QuEra), and trapped-ion (IonQ) quantum devices. Moreover, we demonstrate the advantages of exposing the Hamiltonian-level programmability of devices with native operations or interaction-based gates and establish a small benchmark of quantum simulation to evaluate SimuQ's compiler with the above analog quantum simulators.

+

A Universal, Sound, and Complete Forward Reasoning Technique for Machine-Verified Proofs of Linearizability

  • Prasad Jayanti
  • Siddhartha Jayanti
  • Ugur Yavuz
  • Lizzie Hernandez
+

We introduce simple, universal, sound, and complete proof methods for producing machine-verifiable proofs of linearizability and strong linearizability. Universality means that our method works for any object type; soundness means that an algorithm can be proved correct by our method only if it is linearizable (resp. strong linearizable); and completeness means that any linearizable (resp. strong linearizable) implementation can be proved so using our method. We demonstrate the simplicity and power of our method by producing proofs of linearizability for the Herlihy-Wing queue and Jayanti’s single-scanner snapshot, as well as a proof of strong linearizability of the Jayanti-Tarjan union-find object. All three of these proofs are machine-verified by TLAPS (the TLA+ Proof System).

+

Commutativity Simplifies Proofs of Parameterized Programs

  • Azadeh Farzan
  • Dominik Klumpp
  • Andreas Podelski
+

Commutativity has proven to be a powerful tool in reasoning about concurrent programs. Recent work has shown that a commutativity-based reduction of a program may admit simpler proofs than the program itself. The framework of lexicographical program reductions was introduced to formalize a broad class of reductions which accommodate sequential (thread-local) reasoning as well as synchronous programs. Approaches based on this framework, however, were fundamentally limited to program models with a fixed/bounded number of threads. In this paper, we show that it is possible to define an effective parametric family of program reductions that can be used to find simple proofs for parameterized programs, i.e., for programs with an unbounded number of threads. We show that reductions are indeed useful for the simplification of proofs for parameterized programs, in a sense that can be made precise: A reduction of a parameterized program may admit a proof which uses fewer or less sophisticated ghost variables. The reduction may therefore be within reach of an automated verification technique, even when the original parameterized program is not. As our first technical contribution, we introduce a notion of reductions for parameterized programs such that the reduction R of a parameterized program P is again a parameterized program (the thread template of R is obtained by source-to-source transformation of the thread template of P). Consequently, existing techniques for the verification of parameterized programs can be directly applied to R instead of P. Our second technical contribution is that we define an appropriate family of pairwise preference orders which can be effectively used as a parameter to produce different lexicographical reductions. To determine whether this theoretical foundation amounts to a usable solution in practice, we have implemented the approach, based on a recently proposed framework for parameterized program verification. The results of our preliminary experiments on a representative set of examples are encouraging.

+

Higher Order Bayesian Networks, Exactly

  • Claudia Faggian
  • Daniele Pautasso
  • Gabriele Vanoni
+

Bayesian networks are graphical first-order probabilistic models that allow for a compact representation of large probability distributions, and for efficient inference, both exact and approximate. We introduce a higher-order programming language, in the idealized form of a lambda-calculus, which we prove sound and complete w.r.t. Bayesian networks: each Bayesian network can be encoded as a term, and conversely each (possibly higher-order and recursive) program of ground type compiles into a Bayesian network. +The language allows for the specification of recursive probability models and hierarchical structures. Moreover, we provide a compositional and cost-aware semantics which is based on factors, the standard mathematical tool used in Bayesian inference. Our results rely on advanced techniques rooted into linear logic, intersection types, rewriting theory, and Girard's geometry of interaction, which are here combined in a novel way.

+

Sound Gradual Verification with Symbolic Execution

  • Conrad Zimmerman
  • Jenna DiVincenzo
  • Jonathan Aldrich
+

Gradual verification, which supports explicitly partial specifications +and verifies them with a combination of static and dynamic checks, makes +verification more incremental and provides earlier feedback to developers. +While an abstract, weakest precondition-based approach to gradual verification +was previously proven sound, the approach did not provide sufficient guidance +for implementation and optimization of the required run-time checks. More +recently, gradual verification was implemented using symbolic execution +techniques, but the soundness of the approach (as with related static +checkers based on implicit dynamic frames) was an open question. This paper +puts practical gradual verification on a sound footing with a formalization +of symbolic execution, optimized run-time check generation, and run time +execution. We prove our approach is sound; our proof also covers a core +subset of the Viper tool, for which we are aware of no previous soundness result. +Our formalization enabled us to find a soundness bug in an implemented gradual +verification tool and describe the fix necessary to make it sound.

+

Flan: An Expressive and Efficient Datalog Compiler for Program Analysis

  • Supun Abeysinghe
  • Anxhelo Xhebraj
  • Tiark Rompf
+

Datalog has gained prominence in program analysis due to its expressiveness and ease of use. Its generic fixpoint resolution algorithm over relational domains simplifies the expression of many complex analyses. The performance and scalability issues of early Datalog approaches have been addressed by tools such as Soufflé through specialized code generation. Still, while pure Datalog is expressive enough to support a wide range of analyses, there is a growing need for extensions to accommodate increasingly complex analyses. This has led to the development of various extensions, such as Flix, Datafun, and Formulog, which enhance Datalog with features like arbitrary lattices and SMT constraints.

Most of these extensions recognize the need for full interoperability between Datalog and a full-fledged programming language, a functionality that high-performance systems like Soufflé lack. Specifically, in most cases, they construct languages from scratch with first-class Datalog support, allowing greater flexibility. However, this flexibility often comes at the cost of performance due to the conflicting requirements of prioritizing modularity and abstraction over efficiency. Consequently, achieving both flexibility and compilation to highly-performant specialized code poses a significant challenge.

In this work, we reconcile the competing demands of expressiveness and performance with Flan, a Datalog compiler fully embedded in Scala that leverages multi-stage programming to generate specialized code for enhanced performance. Our approach combines the flexibility of Flix with Soufflé’s performance, offering seamless integration with the host language that enables the addition of powerful extensions while generating specialized code for the entire computation. Flan’s simple operator interface allows the addition of an extensive set of features, including arbitrary aggregates, user-defined functions, and lattices, with multiple execution strategies such as binary and multi-way joins, supported by different indexing structures like specialized trees and hash tables, with minimal effort. We evaluate our system on a variety of benchmarks and compare it to established Datalog engines. Our results demonstrate competitive performance and speedups in the range of 1.4× to 12.5× compared to state-of-the-art systems for workloads of practical importance.

+

On Model-Checking Higher-Order Effectful Programs

  • Ugo Dal Lago
  • Alexis Ghyselen
+

Model-checking is one of the most powerful techniques for verifying systems and programs, which since the pioneering results by Knapik et al., Ong, and Kobayashi, is known to be applicable to functional programs with higher-order types against properties expressed by formulas of monadic second-order logic. What happens when the program in question, in addition to higher-order functions, also exhibits algebraic effects such as probabilistic choice or global store? The results in the literature range from those, mostly positive, about nondeterministic effects, to those about probabilistic effects, in the presence of which even mere reachability becomes undecidable. This work takes a fresh and general look at the problem, first of all showing that there is an elegant and natural way of viewing higher-order programs producing algebraic effects as ordinary higher-order recursion schemes. We then move on to consider effect handlers, showing that in their presence the model checking problem is bound to be undecidable in the general case, while it stays decidable when handlers have a simple syntactic form, still sufficient to capture so-called generic effects. Along the way, we hint at how a general specification language could look like, this way justifying some of the results in the literature, and deriving new ones.

+

Effectful Software Contracts

  • Cameron Moy
  • Christos Dimoulas
  • Matthias Felleisen
+

Software contracts empower programmers to describe functional properties of components. When it comes to constraining effects, though, the literature offers only one-off solutions for various effects. It lacks a universal principle. This paper presents the design of an effectful contract system in the context of effect handlers. A key metatheorem shows that contracts cannot unduly interfere with a program's execution. An implementation of this design, along with an evaluation of its generality, demonstrates that the theory can guide practice.

+

Type-Based Gradual Typing Performance Optimization

  • John Peter Campora
  • Mohammad Wahiduzzaman Khan
  • Sheng Chen
+

Gradual typing has emerged as a popular design point in programming languages, attracting significant interests from both academia and industry. Programmers in gradually typed languages are free to utilize static and dynamic typing as needed. To make such languages sound, runtime checks mediate the boundary of typed and untyped code. Unfortunately, such checks can incur significant runtime overhead on programs that heavily mix static and dynamic typing. To combat this overhead without necessitating changes to the underlying implementations of languages, we present discriminative typing. Discriminative typing works by optimistically inferring types for functions and implementing an optimized version of the function based on this type. To preserve safety it also implements an un-optimized version of the function based purely on the provided annotations. With two versions of each function in hand, discriminative typing translates programs so that the optimized functions are called as frequently as possible while also preserving program behaviors. +

+

+We have implemented discriminative typing in Reticulated Python and have evaluated its performance +compared to guarded Reticulated Python. Our results show that discriminative typing improves the performance across 95% of tested programs, when compared to Reticulated, and achieves more than 4× speedup in more than 56% of these programs. We also compare its performance against a previous optimization approach and find that discriminative typing improved performance across 93% of tested programs, with 30% of these programs receiving speedups between 4 to 25 times. Finally, our evaluation shows that discriminative typing remarkably reduces the overhead of gradual typing on many mixed type configurations of programs. +

+

+In addition, we have implemented discriminative typing in Grift and evaluated its performance. Our +evaluation demonstrations that DT significantly improves performance of Grift

+

Parametric Subtyping for Structural Parametric Polymorphism

  • Henry DeYoung
  • Andreia Mordido
  • Frank Pfenning
  • Ankush Das
+

We study the interaction of structural subtyping with parametric polymorphism and recursively defined type constructors. Although structural subtyping is undecidable in this setting, we describe a notion of parametricity for type constructors and then exploit it to define parametric subtyping, a conceptually simple, decidable, and expressive fragment of structural subtyping that strictly generalizes rigid subtyping. We present and prove correct an effective saturation-based decision procedure for parametric subtyping, demonstrating its applicability using a variety of examples. We also provide an implementation of this decision procedure as an artifact.

+

Inference of Robust Reachability Constraints

  • Yanis Sellami
  • Guillaume Girol
  • Frédéric Recoules
  • Damien Couroussé
  • Sébastien Bardin
+

Characterization of bugs and attack vectors is in many practical scenarios as important as their finding. +Recently, Girol et. al. have introduced the concept of robust reachability, which ensures a perfect reproducibility of the reported violations by distinguishing inputs that are under the control of the attacker (controlled inputs) from those that are not (uncontrolled inputs), and proposed first automated analysis for it. +While it is a step toward distinguishing severe bugs from benign ones, it fails for example to describe violations that are mostly reproducible, +i.e., when triggering conditions are likely to happen, meaning that they happen for all uncontrolled inputs but a few corner cases. +To address this issue, we propose to leverage theory-agnostic abduction techniques to generate constraints on the uncontrolled program inputs +that ensure that a target property is robustly satisfied. +Our proposal comes with an extension of robust reachability that is generic on the type of trace property and on the technology used to verify the properties. +We show that our approach is complete w.r.t its inference language, and we additionally discuss strategies for the efficient exploration of the inference space. +We demonstrate the feasibility of the method and its practical ability to refine the notion of robust reachability with an implementation that uses robust reachability oracles to generate constraints on standard benchmarks from software verification and security analysis. +We illustrate the use of our implementation to a vulnerability characterization problem in the context of fault injection attacks. +Our method overcomes a major limitation of the initial proposal of robust reachability, +without complicating its definition. +From a practical view, this is a step toward new verification tools that are able to characterize program violations through high-level feedback.

+

Efficient Matching of Regular Expressions with Lookaround Assertions

  • Konstantinos Mamouras
  • Agnishom Chattopadhyay
+

Regular expressions have been extended with lookaround assertions, which are subdivided into lookahead and lookbehind assertions. These constructs are used to refine when a match for a pattern occurs in the input text based on the surrounding context. Current implementation techniques for lookaround involve backtracking search, which can give rise to running time that is super-linear in the length of input text. In this paper, we first consider a formal mathematical semantics for lookaround, which complements the commonly used operational understanding of lookaround in terms of a backtracking implementation. Our formal semantics allows us to establish several equational properties for simplifying lookaround assertions. Additionally, we propose a new algorithm for matching regular expressions with lookaround that has time complexity O(m · n), where m is the size of the regular expression and n is the length of the input text. The algorithm works by evaluating lookaround assertions in a bottom-up manner. Our algorithm makes use of a new notion of nondeterministic finite automata (NFAs), which we call oracle-NFAs. These automata are augmented with epsilon-transitions that are guarded by oracle queries that provide the truth values of lookaround assertions at every position in the text. We provide an implementation of our algorithm that incorporates three performance optimizations for reducing the work performed and memory used. We present an experimental comparison against PCRE and Java’s regex library, which are state-of-the-art regex engines that support lookaround assertions. Our experimental results show that, in contrast to PCRE and Java, our implementation does not suffer from super-linear running time and is several times faster.

+

Programmatic Strategy Synthesis: Resolving Nondeterminism in Probabilistic Programs

  • Kevin Batz
  • Tom Jannik Biskup
  • Joost-Pieter Katoen
  • Tobias Winkler
+

We consider imperative programs that involve both randomization and pure nondeterminism. The central question is how to find a strategy resolving the pure nondeterminism such that the so-obtained determinized program satisfies a given quantitative specification, i.e., bounds on expected outcomes such as the expected final value of a program variable or the probability to terminate in a given set of states. We show how memoryless and deterministic (MD) strategies can be obtained in a semi-automatic fashion using deductive verification techniques. For loop-free programs, the MD strategies resulting from our weakest precondition-style framework are correct by construction. This extends to loopy programs, provided the loops are equipped with suitable loop invariants - just like in program verification. We show how our technique relates to the well-studied problem of obtaining strategies in countably infinite Markov decision processes with reachability-reward objectives. Finally, we apply our technique to several case studies.

+
\ No newline at end of file diff --git a/_data/OpenTOC.yaml b/_data/OpenTOC.yaml index 101abd0..286a612 100644 --- a/_data/OpenTOC.yaml +++ b/_data/OpenTOC.yaml @@ -1349,3 +1349,7 @@ event: SPLASH year: 2023 title: "Companion Proceedings of the 2023 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity" +- + event: POPL + year: 2024 + title: "Proceedings of the ACM on Programming Languages: Vol. 8, No. POPL. 2024" From e7b2655a34290e174823632680785dfe59260243 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Wed, 10 Jan 2024 08:29:46 -0500 Subject: [PATCH 26/64] TOC --- OpenTOC/cpp24.html | 264 +++++++++++++++++++++++++++++++++++++++++++++ _data/OpenTOC.yaml | 4 + 2 files changed, 268 insertions(+) create mode 100644 OpenTOC/cpp24.html diff --git a/OpenTOC/cpp24.html b/OpenTOC/cpp24.html new file mode 100644 index 0000000..68602da --- /dev/null +++ b/OpenTOC/cpp24.html @@ -0,0 +1,264 @@ +CPP 2024: Proceedings of the 13th ACM SIGPLAN International Conference on Certified Programs and Proofs

CPP 2024: Proceedings of the 13th ACM SIGPLAN International Conference on Certified Programs and Proofs

+ Full Citation in the ACM Digital Library +

SESSION: Keynote

+

Under-Approximation for Scalable Bug Detection (Keynote)

  • Azalea Raad
+

Incorrectness Logic (IL) has recently been advanced as a logical under-approximate theory for proving the presence of bugs - dual to Hoare Logic, which is an over-approximate theory for proving the absence of bugs. To facilitate scalable bug detection, later we developed incorrectness separation logic (ISL) by marrying the under-approximate reasoning of IL with the local reasoning of separation logic and its frame rule. This locality leads to techniques that are compositional both in code (concentrating on a program component) and in the resources accessed (spatial locality), without tracking the entire global state or the global program within which a component sits. This enables reasoning to scale to large teams and codebases: reasoning can be done even when a global program is not present. We then developed Pulse-X, an automatic program analysis for catching memory safety errors, underpinned by ISL. Using PulseX, deployed at Meta, we found a number of real bugs in codebases such as OpenSSL, which were subsequently confirmed and fixed. We have compared the performance of Pulse-X against the state-of-the-art tool Infer on a number of large programs; our comparison shows that Pulse-X is comparable with Infer in terms of performance, and in certain cases its fix-rate surpasses that of Infer.

+
+ +

SESSION: Papers

+

UTC Time, Formally Verified

  • Ana de Almeida Borges
  • Mireia González Bedmar
  • Juan Conejero Rodríguez
  • Eduardo Hermo Reyes
  • Joaquim Casals Buñuel
  • Joost Joosten
+

FV Time is a small-scale verification project developed in the Coq proof assistant using the Mathematical Components libraries. It is a library for managing conversions between time formats (UTC and timestamps), as well as commonly used functions for time arithmetic. As a library for time conversions, its novelty is the implementation of leap seconds, which are part of the UTC standard but usually not implemented in existing libraries. Since the verified functions of FV Time are reasonably simple yet non-trivial, it nicely illustrates our methodology for verifying software with Coq. +

+

+In this paper we present a description of the project, emphasizing the main problems faced while developing the library, as well as some general-purpose solutions that were produced as by-products and may be used in other verification projects. These include a refinement package between proof-oriented MathComp numbers and computation-oriented primitive numbers from the Coq standard library, as well as a set of tactics to automatically prove certain decidable statements over finite ranges through brute-force computation.

+
+ + +

VCFloat2: Floating-Point Error Analysis in Coq

  • Andrew Appel
  • Ariel Kellison
+

The development of sound and efficient tools that automatically perform floating-point round-off error analysis is an active area of research with applications to embedded systems and scientific computing. In this paper we describe VCFloat2, a novel extension to the VCFloat tool for verifying floating-point C programs in Coq. Like VCFloat1, VCFloat2 soundly and automatically computes round-off error bounds on floating-point expressions, but does so to higher accuracy; with better performance; with more generality for nonstandard number formats; with the ability to reason about external (user-defined or library) functions; and with improved modularity for interfacing with other program verification tools in Coq. We evaluate the performance of VCFloat2 using common benchmarks; compared to other state-of-the art tools, VCFloat2 computes competitive error bounds and transparent certificates that require less time for verification.

+
+ + +

The Last Yard: Foundational End-to-End Verification of High-Speed Cryptography

  • Philipp G. Haselwarter
  • Benjamin Salling Hvass
  • Lasse Letager Hansen
  • Théo Winterhalter
  • Cătălin Hriţcu
  • Bas Spitters
+

The field of high-assurance cryptography is quickly maturing, yet a unified foundational framework for end-to-end formal verification of efficient cryptographic implementations is still missing. +To address this gap, we use the Coq proof assistant to formally connect three existing tools: +(1) the Hacspec emergent cryptographic specification language; +(2) the Jasmin language for efficient, high-assurance cryptographic implementations; and +(3) the SSProve foundational verification framework for modular cryptographic proofs. +We first connect Hacspec with SSProve by devising a new translation from Hacspec specifications to imperative SSProve code. +We validate this translation by considering a second, more standard translation from Hacspec to purely functional Coq code and generate a proof of the equivalence between the code produced by the two translations. +We further define a translation from Jasmin to SSProve, which allows us to formally reason in SSProve about efficient cryptographic implementations in Jasmin. +We prove this translation correct in Coq with respect to Jasmin's operational semantics. +Finally, we demonstrate the usefulness of our approach by giving a foundational end-to-end Coq proof of an efficient AES implementation. +For this case study, we start from an existing Jasmin implementation of AES that makes use of hardware acceleration and prove that it conforms to a specification of the AES standard written in Hacspec. We use SSProve to formalize the security of the encryption scheme based on the Jasmin implementation of AES.

+
+ + +

Rooting for Efficiency: Mechanised Reasoning about Array-Based Trees in Separation Logic

  • Qiyuan Zhao
  • George Pîrlea
  • Zhendong Ang
  • Umang Mathur
  • Ilya Sergey
+

Array-based encodings of tree structures are often preferable to linked or abstract data type-based representations for efficiency reasons. Compared to the more traditional encodings, array-based trees do not immediately offer convenient induction principles, and the programs that manipulate them often implement traversals non-recursively, requiring complex loop invariants for their correctness proofs. +

+

+In this work, we provide a set of definitions, lemmas, and reasoning principles that streamline proofs about array-based trees and programs that work with them. We showcase our proof techniques via a series of small but characteristic examples, culminating with a large case study: verification of a C implementation of a recently published tree clock data structure in a Separation Logic embedded into Coq.

+
+ + +

Compositional Verification of Concurrent C Programs with Search Structure Templates

  • Duc-Than Nguyen
  • Lennart Beringer
  • William Mansky
  • Shengyi Wang
+

Concurrent search structure templates are a technique for separating the verification of a concurrent data structure into concurrency-control and data-structure components, which can then be modularly combined with no additional proof effort. In this paper, we implement the template approach in the Verified Software Toolchain (VST), and use it to prove correctness of C implementations of fine-grained concurrent data structures. This involves translating code, specifications, and proofs to the idiom of C and VST, and gives us another look at the requirements and limitations of the template approach. +We encounter several questions about the boundaries between template and data structure, as well as some common data structure operations that cannot naturally be decomposed into templates. Nonetheless, the approach appears promising for modular verification of real-world concurrent data structures.

+
+ + +

Unification for Subformula Linking under Quantifiers

  • Ike Mulder
  • Robbert Krebbers
+

Subformula linking is a technique that allows one to simplify proof goals by identifying subformulas of hypotheses that share atoms with the goal. It has been used by recent prototypes for gesture-based interactive theorem proving, but also for theorem proving in separation logic.

When linking formulas, we should avoid information loss, i.e., subformula linking should succeed precisely when a provable simplification can be generated. Avoiding information loss is challenging when quantifiers are involved. Existing approaches either generate simplifications that involve equalities, or determine substitutions for variables via unification. The first approach can produce unprovable simplifications, while the second approach can fail to find desired links.

We propose a third approach, called Quantifying on the Uninstantiated (QU), which is also based on unification and lies between the two existing approaches. We show that QU has practical applications for proof automation, by improving tactics for resource framing in the Iris framework for separation logic in Coq.

+
+ + +

PfComp: A Verified Compiler for Packet Filtering Leveraging Binary Decision Diagrams

  • Clément Chavanon
  • Frédéric Besson
  • Tristan Ninet
+

We present PfComp, a verified compiler for stateless firewall policies. The policy is first compiled into an intermediate representation taking the form of a binary decision diagram that is optimised in terms of decision nodes. The decision diagram is then compiled into a program. The compiler is proved correct using the Coq proof assistant and extracted into OCaml code. Our preliminary experiments show promising results. The compiler generates code for relatively large firewall policies and the generated code outperforms a sequential evaluation of the policy rules.

+
+ + +

Memory Simulations, Security and Optimization in a Verified Compiler

  • David Monniaux
+

Current compilers implement security features and optimizations that require nontrivial semantic reasoning about pointers and memory allocation: the program after the insertion of the security feature, or after applying the optimization, must simulate the original program despite a different memory layout. +

+

+In this article, we illustrate such reasoning on pointer allocations through memory extensions and injections, as well as fine points on undefined values, by explaining how we implemented and proved correct two security features (stack canaries and pointer authentication) and one optimization (tail recursion elimination) in the CompCert formally verified compiler.

+
+ + +

Lean Formalization of Extended Regular Expression Matching with Lookarounds

  • Ekaterina Zhuchko
  • Margus Veanes
  • Gabriel Ebner
+

We present a formalization of a matching algorithm for extended regular expression matching based on locations and symbolic derivatives which supports intersection, complement and lookarounds and whose implementation mirrors an extension of the recent .NET NonBacktracking regular expression engine. The formalization of the algorithm and its semantics uses the Lean 4 proof assistant. The proof of its correctness is with respect to standard matching semantics.

+
+ + +

Formal Probabilistic Methods for Combinatorial Structures using the Lovász Local Lemma

  • Chelsea Edmonds
  • Lawrence C. Paulson
+

Formalised libraries of combinatorial mathematics have rapidly expanded over the last five years, but few use one of the most important tools: probability. How can often intuitive probabilistic arguments on the existence of combinatorial structures, such as hypergraphs, be translated into a formal text? We present a modular framework using locales in Isabelle/HOL to formalise such probabilistic proofs, including the basic existence method and first formalisation of the Lovász local lemma, a fundamental result in probability. The formalisation focuses on general, reusable formal probabilistic lemmas for combinatorial structures, and highlights several notable gaps in typical intuitive probabilistic reasoning on paper. The applicability of the techniques is demonstrated through the formalisation of several classic lemmas on the existence of hypergraphs with certain colourings.

+
+ + +

Certification of Confluence- and Commutation-Proofs via Parallel Critical Pairs

  • Nao Hirokawa
  • Dohan Kim
  • Kiraku Shintani
  • René Thiemann
+

Parallel critical pairs (PCPs) have been used to design sufficient criteria for +confluence of term rewrite systems. In this work we formalize PCPs and the +criteria of Gramlich, Toyama, and Shintani and Hirokawa in the proof assistant +Isabelle. In order to reduce the amount of bureaucracy we deviate from the +paper-definition of PCPs, i.e., we switch from a position-based definition to a +context-based definition. This switch not only simplifies the formalization +task, but also gives rise to a simple recursive algorithm to compute PCPs. We +further generalize all mentioned criteria from confluence to commutation and +integrate them in the certifier CeTA, so that it can now validate confluence- +and commutation-proofs based on PCPs. Because of our results, CeTA is now able +to certify proofs by the automatic confluence tool Hakusan, which makes heavy +use of PCPs. These proofs include term rewrite systems for which no previous +certified confluence proof was known.

+
+ + +

A Temporal Differential Dynamic Logic Formal Embedding

  • Lauren White
  • Laura Titolo
  • J. Tanner Slagel
  • César Muñoz
+

Differential temporal dynamic logic dTL2 is a logic to specify and verify temporal properties of hybrid systems. It extends differential dynamic logic (dL) with temporal operators that enable reasoning on intermediate states in both discrete and continuous dynamics. This paper presents an embedding of dTL2 in the Prototype Verification System (PVS). The embedding includes the formalization of a trace semantics as well as the logic and proof calculus of dTL, which have been enhanced to support the verification of universally quantified reachability properties. The embedding is fully functional and can be used to interactively verify hybrid programs in PVS using a combination of PVS proof commands and specialized proof strategies.

+
+ + +

Formalizing Giles Gardam’s Disproof of Kaplansky’s Unit Conjecture

  • Siddhartha Gadgil
  • Anand Rao Tadipatri
+

We describe a formalization in Lean 4 of Giles Gardam's disproof of Kaplansky's Unit Conjecture. This makes use of a combination of deductive proving and formally verified computation, using the nature of Lean 4 as a programming language which is also a proof assistant. +

+

+ Our goal in this work, besides formalization of the specific result, is to show what is possible with the current state of the art and illustrate how it can be achieved. Specifically we illustrate real time formalization of an important mathematical result and the seamless integration of proofs and computations in Lean 4.

+
+ + +

A Formalization of Complete Discrete Valuation Rings and Local Fields

  • María Inés de Frutos-Fernández
  • Filippo Alberto Edoardo Nuccio Mortarino Majno di Capriglio
+

Local fields, and fields complete with respect to a discrete valuation, are essential objects in commutative algebra, with applications to number theory and algebraic geometry. We formalize in Lean the basic theory of discretely valued fields. In particular, we prove that the unit ball with respect to a discrete valuation on a field is a discrete valuation ring and, conversely, that the adic valuation on the field of fractions of a discrete valuation ring is discrete. We define finite extensions of valuations and of discrete valuation rings, and prove some localization results.

Building on this general theory, we formalize the abstract definition and some fundamental properties of local fields. As an application, we show that finite extensions of the field ℚp of p-adic numbers and of the field Fp((X)) of Laurent series over Fp are local fields.

+
+ + +

Strictly Monotone Brouwer Trees for Well Founded Recursion over Multiple Arguments

  • Joseph Eremondi
+

Ordinals can be used to prove the termination of dependently typed programs. +Brouwer trees are a particular ordinal notation that +make it very easy to assign sizes to higher order data structures. +They extend unary natural numbers with a limit constructor, +so a function's size can be the least upper bound of the sizes of values from its image. +These can then be used to define well-founded recursion: any recursive calls are allowed +so long as they are on values whose sizes are strictly smaller than the current size. +

+

+Unfortunately, Brouwer trees are not algebraically well-behaved. +They can be characterized equationally as a join-semilattice, where the join takes the maximum +of two trees. However, this join does not interact well with +the successor constructor, so it does not interact properly with +the strict ordering used in well-founded recursion. +

+

+We present Strictly Monotone Brouwer trees (SMB-trees), a refinement of Brouwer trees +that are algebraically well-behaved. SMB-trees are built using functions with the same +signatures as Brouwer tree constructors, and they satisfy all Brouwer tree inequalities. +However, their join operator distributes over the successor, making them +suited for well-founded recursion or equational reasoning. +

+

+This paper teaches how, using dependent pairs and careful definitions, an ill-behaved +definition can be turned into a well-behaved one. +Our approach is axiomatically lightweight: +it does not rely on Axiom K, univalence, quotient types, or Higher Inductive Types. +We implement a recursively-defined maximum operator for Brouwer trees that matches +on successors and handles them specifically. +Then, we define SMB-trees as the subset of Brouwer trees for which the recursive maximum +computes a least upper bound. +Finally, we show that every Brouwer tree can be transformed into a corresponding SMB-tree +by infinitely joining it with itself. +All definitions and theorems are implemented in Agda.

+
+ + +

A Mechanised and Constructive Reverse Analysis of Soundness and Completeness of Bi-intuitionistic Logic

  • Ian Shillito
  • Dominik Kirst
+

Using the Coq proof assistant, we investigate the minimal non-constructive principles needed to show soundness and completeness of propositional bi-intuitionistic logic. Before being revisited and corrected by Goré and Shillito, the completeness of bi-intuitionistic logic, an extension of intuitionistic logic with a dual operation to implication, had a rather erratic history, making it an ideal case for computer mechanisation. Moreover, contributing a constructive perspective, we observe that the completeness of bi-intuitionistic logic explicates the same characteristics already observed in an ongoing effort to analyse completeness theorems in general.

+
+ + +

Martin-Löf à la Coq

  • Arthur Adjedj
  • Meven Lennon-Bertrand
  • Kenji Maillard
  • Pierre-Marie Pédrot
  • Loïc Pujet
+

We present an extensive mechanization of the metatheory of Martin-Löf Type Theory (MLTT) in the Coq proof assistant. Our development builds on pre-existing work in Agda to show not only the decidability of conversion, but also the decidability of type checking, using an approach guided by bidirectional type checking. From our proof of decidability, we obtain a certified and executable type checker for a full-fledged version of MLTT with support for Π, Σ, ℕ, and Id types, and one universe. Our development does not rely on impredicativity, induction-recursion or any axiom beyond MLTT extended with indexed inductive types and a handful of predicative universes, thus narrowing the gap between the object theory and the metatheory to a mere difference in universes. Furthermore, our formalization choices are geared towards a modular development that relies on Coq's features, e.g. universe polymorphism and metaprogramming with tactics.

+
+ + +

Univalent Double Categories

  • Niels van der Weide
  • Nima Rasekh
  • Benedikt Ahrens
  • Paige Randall North
+

Category theory is a branch of mathematics that provides a formal framework for understanding the relationship between mathematical structures. To this end, a category not only incorporates the data of the desired objects, but also "morphisms", which capture how different objects interact with each other. Category theory has found many applications in mathematics and in computer science, for example in functional programming. +

+

+Double categories are a natural generalization of categories which incorporate the data of two separate classes of morphisms, allowing a more nuanced representation of relationships and interactions between objects. Similar to category theory, double categories have been successfully applied to various situations in mathematics and computer science, in which objects naturally exhibit two types of morphisms. Examples include categories themselves, but also lenses, petri nets, and spans. +

+

+While categories have already been formalized in a variety of proof assistants, double categories have received far less attention. In this paper we remedy this situation by presenting a formalization of double categories via the proof assistant Coq, relying on the Coq UniMath library. As part of this work we present two equivalent formalizations of the definition of a double category, an unfolded explicit definition and a second definition which exhibits excellent formal properties via 2-sided displayed categories. As an application of the formal approach we establish a notion of univalent double category along with a univalence principle: equivalences of univalent double categories coincide with their identities.

+
+ + +

Displayed Monoidal Categories for the Semantics of Linear Logic

  • Benedikt Ahrens
  • Ralph Matthes
  • Niels van der Weide
  • Kobe Wullaert
+

We present a formalization of different categorical structures used to interpret linear logic. Our formalization takes place in UniMath, a library of univalent mathematics based on the Coq proof assistant. +

+

+All the categorical structures we formalize are based on monoidal categories. As such, one of our contributions is a practical, usable library of formalized results on monoidal categories. Monoidal categories carry a lot of structure, and instances of monoidal categories are often built from complicated mathematical objects. This can cause challenges of scalability, regarding both the vast amount of data to be managed by the user of the library, as well as the time the proof assistant spends on checking code. To enable scalability, and to avoid duplication of computer code in the formalization, we develop "displayed monoidal categories". These gadgets allow for the modular construction of complicated monoidal categories by building them in layers; we demonstrate their use in many examples. Specifically, we define linear-non-linear categories and construct instances of them via Lafont categories and linear categories.

+
+ + +

Formalizing the ∞-Categorical Yoneda Lemma

  • Nikolai Kudasov
  • Emily Riehl
  • Jonathan Weinberger
+

Formalized 1-category theory forms a core component of various libraries of mathematical proofs. However, more sophisticated results in fields from algebraic topology to theoretical physics, where objects have “higher structure,” rely on infinite-dimensional categories in place of 1-dimensional categories, and ∞-category theory has thusfar proved unamenable to computer formalization.

Using a new proof assistant called Rzk, which is designed to support Riehl–Shulman’s simplicial extension of homotopy type theory for synthetic ∞-category theory, we provide the first formalizations of results from ∞-category theory. This includes in particular a formalization of the Yoneda lemma, often regarded as the fundamental theorem of category theory, a theorem which roughly states that an object of a given category is determined by its relationship to all of the other objects of the category. A key feature of our framework is that, thanks to the synthetic theory, many constructions are automatically natural or functorial. We plan to use Rzk to formalize further results from ∞-category theory, such as the theory of limits and colimits and adjunctions.

+
+ +
\ No newline at end of file diff --git a/_data/OpenTOC.yaml b/_data/OpenTOC.yaml index 286a612..37b210a 100644 --- a/_data/OpenTOC.yaml +++ b/_data/OpenTOC.yaml @@ -1353,3 +1353,7 @@ event: POPL year: 2024 title: "Proceedings of the ACM on Programming Languages: Vol. 8, No. POPL. 2024" +- + event: CPP + year: 2024 + title: "Proceedings of the 13th ACM SIGPLAN International Conference on Certified Programs and Proofs" From 12689af238165f1f583fe0791f92fedb5e929765 Mon Sep 17 00:00:00 2001 From: Michael Bond Date: Wed, 10 Jan 2024 20:21:58 -0500 Subject: [PATCH 27/64] Update ISMM SC --- _data/Committees.yaml | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/_data/Committees.yaml b/_data/Committees.yaml index eacb406..c3ad28c 100644 --- a/_data/Committees.yaml +++ b/_data/Committees.yaml @@ -107,12 +107,15 @@ ICFP Steering Committee: - Chair: Greg Morrisett ISMM Steering Committee: - - Chair: "[Michael Lippautz](https://research.google/people/MichaelLippautz/), 2022 General Chair" + - "[Michael Bond](https://mdbond.github.io/), 2024 General Chair" + - "[Jae W. Lee](https://iamjaelee.github.io/www/), 2024 Program Co-chair" + - "[Hannes Payer](http://research.google.com/pubs/HannesPayer.html), 2024 Program Co-chair" + - Chair: "[Steve Blackburn](http://users.cecs.anu.edu.au/~steveb/), 2023 General Chair" + - "[Erez Petrank](https://csaws.cs.technion.ac.il/~erez/), 2023 Program Chair" + - "[Michael Lippautz](https://research.google/people/MichaelLippautz/), 2022 General Chair" - "[David Chisnall](https://www.microsoft.com/en-us/research/people/dachisna/), 2022 Program Chair" - - "[Tobias Wrigstad](http://wrigstad.com), 2021, General Chair" + - "[Tobias Wrigstad](http://wrigstad.com), 2021 General Chair" - "[Zhenlin Wang](https://pages.mtu.edu/~zlwang/), 2021 Program Chair" - - "[Chen Ding](https://www.cs.rochester.edu/~cding/), 2020 General Chair" - - "[Martin Maas](http://www.martin-maas.com/), 2020 Program Chair" LCTES Steering Committee: - David B. Whalley, Florida State University From ba5d53d5d25d17f1342a5da6766cc0ea96561a8e Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Fri, 12 Jan 2024 07:28:18 -0500 Subject: [PATCH 28/64] Announce --- _announce/2024-01-06-pldi_2024_src.txt | 103 ++++++++++++++++++ .../2024-01-09-cgo_ppopp_hpca_2024_travel.txt | 28 +++++ 2 files changed, 131 insertions(+) create mode 100644 _announce/2024-01-06-pldi_2024_src.txt create mode 100644 _announce/2024-01-09-cgo_ppopp_hpca_2024_travel.txt diff --git a/_announce/2024-01-06-pldi_2024_src.txt b/_announce/2024-01-06-pldi_2024_src.txt new file mode 100644 index 0000000..8930218 --- /dev/null +++ b/_announce/2024-01-06-pldi_2024_src.txt @@ -0,0 +1,103 @@ +--- +title: "Call for Submissions: PLDI 2024 Student Research Competition" +timestamp: "1/6/2024 19:16:20" +deadline: "3/22/2024" +--- +[The Student Research Competition (SRC) at PLDI](https://pldi24.sigplan.org/track/pldi-2024-src) allows students to present their +research and get feedback from prominent members of the programming language +research community. It’s an opportunity for students to network, practice +presentation skills, and showcase their work. PLDI invites students (both at the +graduate and undergraduate level) to submit their research. If you are an +undergraduate student interested in applying to graduate programs, we highly +encourage you to participate and get a glimpse of what academic life looks like! + +# Eligibility Criteria + +Participants must have current student status, either graduate or undergraduate, +at the time of the submission deadline. Participants in the SRC must also apply +and obtain an ACM student membership. There are two separate categories: + +- **Undergraduate**: Currently enrolled for a bachelor’s degree (or equivalent) +- **Graduate**: Currently enrolled for either a master’s or PhD degree (or + equivalent) If have any questions on if your work is a good fit for the SRC + track, please reach out to the SRC Co-Chairs. + +# Call for Papers +The main body of the submission is a title and extended abstract consisting of +the following: + +- **Problem and Motivation**: Clearly state the problem being addressed and + explain the reasons for seeking a solution to this problem. +- **Background and Related Work**: Describe the specialized (but pertinent) + background necessary to appreciate the work in the context of PLDI areas of + interest. Include references to the literature where appropriate, and briefly + explain where your work departs from that done by others. +- **Approach and Uniqueness**: Describe your approach in addressing the problem + and clearly state how your approach is novel. +- **Results and Contributions**: Clearly show how the results of your work + contribute to programming language design and implementation in particular and + to computer science in general; explain the significance of those results. + +Submissions must be original research that is not already published at PLDI or +another conference or journal. One of the goals of the SRC is to give students +feedback on ongoing, unpublished work. Furthermore, the abstract must be +authored solely by the student. If the work is collaborative with others and/or +part of a larger group project, the abstract should make clear what the +student’s role was and should focus on that portion of the work. + +# Participation +The SRC has three rounds: + +- **Paper round**: Student papers are accepted by a committee of reviewers +- **Poster round**: During the conference, students present a poster to + in-person judges and conference attendees. +- **Presentation round**: In-person judges select students from the poster round + who then give a final talk. +- **Results**: Three students from each category (graduate and undergraduate) + are selected as winners. The top student in each category is invited to + participate in the ACM grand finale. +- **Prizes**: Winners receive a cash prize: $500, $300, and $200 for the first, + second, and third place respectively as well as an award medal. + +# Submissions +The submission form will require the following: + +- The submissions are double blind (the uploaded PDFs should not have your name + or any other identifying information). +- In the supplementary form, please specify: + - Student author’s name, email address, institutional affiliation, and + category (undergraduate or graduate) + - Student’s ACM member number. If you don’t already have one, please apply for + the discounted student member rate. + - Research advisor’s name(s) + - Mode of presentation (in-person or virtual). Please be conservative in your + response: if you think there is a possibility that you might not be able to + attend in-person, select the “virtual” option. We are able to accommodate + transition to in-person more easily than to virtual. + +For the paper submission, ensure: + +- Use the `acmart` template file ([overleaf + template](https://www.overleaf.com/read/yggzbgjwjntv), [latex + template](https://asplos-conference.org/wp-content/uploads/2024/asplos24-templates.zip)). + - Set the options to the class file using + `\documentclass[sigconf,nonacm,screen,review]{acmart}` +- No more than 2 pages. Reference lists do not count towards these limits. + +When you’re ready, submit your extended abstract at the submission site: **TBA**. + +## Writing Resources + +- [How to Write Papers and Give Talks that People Can + Follow](https://www.youtube.com/watch?v=ZmFXMREURBI) by Derek Dreyer +- [How to Write a Conference + Talk](http://www.pl-enthusiast.net/2019/01/02/how-to-write-a-conference-talk/) + by Mike Hicks + +# Attendance +PLDI waives registration costs for all students with accepted papers. We +additionally encourage students to apply to PLMW, which might cover travel +expenses. Furthermore, we encourage students to apply for conference +volunteering positions (**TBA**). + +Good luck, and we hope to see you in June! diff --git a/_announce/2024-01-09-cgo_ppopp_hpca_2024_travel.txt b/_announce/2024-01-09-cgo_ppopp_hpca_2024_travel.txt new file mode 100644 index 0000000..71b5691 --- /dev/null +++ b/_announce/2024-01-09-cgo_ppopp_hpca_2024_travel.txt @@ -0,0 +1,28 @@ +--- +title: "Student Travel Grant, CGO/PPoPP/HPCA 2024" +timestamp: "1/9/2024 0:14:27" +start: "3/2/2024" +end: "3/6/2024" +--- +Student Travel Grant for PPoPP, CGO, and HPCA 2024 + +Please consider applying for the student travel grant program to attend the prestigious colocated international symposia on Code Generation and Optimization (CGO), Principles and Practices of Parallel Programming (PPoPP) and High-Performance Computer Architecture (HPCA). This year, all 3 symposia will be colocated in Edinburgh, Scotland from March 2-6, 2024. + +Thanks to the National Science Foundation (NSF) and other sources, the conferences have funding to support student travel grants to defray the cost of attending. + +We encourage all in need of a travel grant to apply. Selection of grantees will be based on need, participation in the symposia (e.g. papers or posters), and to encourage a diversity of attendees. + +Please make an application via this form: +https://forms.gle/4YWcoCaKyW213FtZ7 +Deadline: January 24, 2024 + +Details: +* An estimate of conference-related expenses is required. +* Information about other sources of funding available to supplement the travel grant must be provided. +* Written confirmation from the student’s advisor must be supplied with the application. +* Students will be required to supply receipts and a report on their experience after the conference. + +See the conference websites for more information: +https://conf.researchr.org/attending/cgo-2024/travel-grants +https://conf.researchr.org/attending/PPoPP-2024/travel-grant +https://www.hpca-conf.org/2024/attend/travelgrants.php From 9018d6a88e4189d79f988285f6f7849d22774634 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Fri, 12 Jan 2024 07:28:33 -0500 Subject: [PATCH 29/64] TOC --- OpenTOC/pepm24.html | 210 ++++++++++++++++++++++++++++++++++++++++++++ _data/OpenTOC.yaml | 4 + 2 files changed, 214 insertions(+) create mode 100644 OpenTOC/pepm24.html diff --git a/OpenTOC/pepm24.html b/OpenTOC/pepm24.html new file mode 100644 index 0000000..26b1204 --- /dev/null +++ b/OpenTOC/pepm24.html @@ -0,0 +1,210 @@ +PEPM 2024: Proceedings of the 2024 ACM SIGPLAN International Workshop on Partial Evaluation and Program Manipulation

PEPM 2024: Proceedings of the 2024 ACM SIGPLAN International Workshop on Partial Evaluation and Program Manipulation

+ Full Citation in the ACM Digital Library +

SESSION: Invited Contributions

+

The Genesis of Mix: Early Days of Self-Applicable Partial Evaluation (Invited Contribution)

  • Peter Sestoft
  • Harald Søndergaard
+

Forty years ago development started on Mix, a partial evaluator designed specifically for the purpose of self-application. +The effort, led by Neil D. Jones at the University of Copenhagen, eventually demonstrated that +non-trivial compilers could be generated automatically by applying a partial evaluator to itself. +The possibility, in theory, of such self-application had been known for more than a decade, +but remained unrealized by the start of 1984. +We describe the genesis of Mix, including the research environment, the challenges, and the main insights that led to success. +We emphasize the critical role played by program annotation as a pre-processing step, +later automated in the form of binding-time analysis.

+
+ + +

In memoriam Neil Deaton Jones

  • Fritz Henglein
+

Neil Deaton Jones, professor emeritus at DIKU, the Department of Computer Science at the University of Copenhagen, passed away March 27th, 2023, shortly after his 82nd birthday. He is remembered for his seminal contributions to programming language research and theory of computation and for the impact his visions and his work have had on an entire generation of researchers, students and collaborators.

+
+ + +

A Historical Perspective on Program Transformation and Recent Developments (Invited Contribution)

  • Alberto Pettorossi
  • Maurizio Proietti
  • Fabio Fioravanti
  • Emanuele De Angelis
+

This paper presents some ideas concerning +program manipulation and program transformation from the +early days of their development. +Particular emphasis will be given to +program transformation techniques in the area of functional +programming and constraint logic programming. +We will also indicate current applications of program transformation +techniques to the verification of program properties and program +synthesis.

+
+ + +

Incremental Computation: What Is the Essence? (Invited Contribution)

  • Yanhong A. Liu
+

Incremental computation aims to compute more efficiently on changed input +by reusing previously computed results. +We give a high-level overview of works on incremental computation, +and highlight the essence underlying all of them, which we call +incrementalization---the discrete counterpart of differentiation in calculus. +We review the gist of a systematic method for incrementalization, +and a systematic method centered around it, called +Iterate-Incrementalize-Implement, +for program design and optimization, as well as algorithm design and +optimization. +At a meta-level, with historical contexts and for future directions, +we stress the power of high-level data, control, and module abstractions +in developing new and better algorithms and programs as well as their precise +complexities.

+
+ + +

The 0'th PEPM Event: October 1987—and Andrei Petrovich Ershov: 1977–1988 (Invited Contribution)

  • Dines Bjørner
+

An attempt is made to record events leading up to the The 0'th PEPM Event: the October 1987 Partial Evaluation and Mixed Computation IFIP TC2 Working Conference at Gl. Avernæs, Denmark.

+
+ +

SESSION: Papers

+

Complete Stream Fusion for Software-Defined Radio

  • Tomoaki Kobayashi
  • Oleg Kiselyov
+

Strymonas is a code-generation--based library (embedded DSL) for fast, +bulk, single-thread in-memory stream processing -- with the declarative +description of stream pipelines and yet achieving the speed and memory +efficiency of hand-written state machines. It guarantees complete +stream fusion in all cases. +

+

+So far, strymonas has been used on small examples and +micro-benchmarks. In this work, we evaluate strymonas on a large, +real-life application of Software-Defined Radio -- FM Radio +reception, -- contrasting and benchmarking it against the synchronous +dataflow system StreamIt, and the state-of-the art: GNU Radio. +

+

+Strymonas, despite being declarative, single-thread single-core with +no explicit support for SIMD, no built-in windowing or convolution, +turns out to offer portable high performance, well enough for +real-time FM Radio reception. It is on par with (or, on Raspberry Pi +Zero, outstripping) GNU Radio, while providing static guarantees of +complete fusion and type safety.

+
+ + +

Productivity Verification for Functional Programs by Reduction to Termination Verification

  • Ren Fukaishi
  • Naoki Kobayashi
  • Ryosuke Sato
+

A program generating a co-inductive data structure is called productive if the program eventually generates all the elements of the data structure. We propose a new method for verifying the productivity, which transforms a co-inductive data structure into a function that takes a path as an argument and returns the corresponding element. For example, an infinite binary tree is converted to a function that takes a sequence consisting of 0 (left) and 1 (right), and returns the element in the specified position, and a stream is converted into a function that takes a sequence of the form 0^n (or, simply a natural number n) and returns the n-th element of the stream. A stream-generating program is then productive just if the function terminates for every n. The transformation allows us to reduce the productivity verification problem to the termination problem for call-by-name higher-order functional programs without co-inductive data structures. We formalize the transformation and prove its correctness. We have implemented an automated productivity checker based on the proposed method, by extending an automated HFL(Z) validity checker, which can be used as a termination checker.

+
+ + +

Scoped and Typed Staging by Evaluation

  • Guillaume Allais
+

Using a dependently typed host language, we give a well +scoped-and-typed by construction presentation of a minimal +two level simply typed calculus with a static and a dynamic +stage. +The staging function partially evaluating the parts of a term +that are static is obtained by a model construction inspired +by normalisation by evaluation. +

+

+We then go on to demonstrate how this minimal language can be +extended to provide additional metaprogramming capabilities, +and to define a higher order functional language evaluating +to digital circuit descriptions.

+
+ + +

Ownership Types for Verification of Programs with Pointer Arithmetic

  • Izumi Tanaka
  • Ken Sakayori
  • Naoki Kobayashi
+

Toman et al. have proposed a type system for automatic verification of low-level programs, which combines ownership types and refinement types to enable strong updates of refinement types in the presence of pointer aliases. We extend their type system to support pointer arithmetic, and prove its soundness. Based on the proposed type system, we have implemented a prototype tool for automated verification of the lack of assertion errors of low-level programs with pointer arithmetic, and confirmed its effectiveness through experiments.

+
+ + +

A Case Study in Functional Conversion and Mode Inference in miniKanren

  • Ekaterina Verbitskaia
  • Igor Engel
  • Daniil Berezun
+

Many programs which solve complicated problems can be seen as inversions of other, much simpler, programs. One particular example is transforming verifiers into solvers, which can be achieved with low effort by implementing the verifier in a relational language and then executing it in the backward direction. Unfortunately, as it is common with inverse computations, interpretation overhead may lead to subpar performance compared to direct program inversion. In this paper we discuss functional conversion aimed at improving relational miniKanren specifications with respect to a known fixed direction. Our preliminary evaluation demonstrates a significant performance increase for some programs which exemplify the approach.

+
+ + +

Partial Evaluation of Reversible Flowchart Programs

  • Louis Normann
  • Robert Glück
+

Flowchart languages are traditionally used to study the foundations of partial evaluation. This article presents a systematic and formal development of a method for partial evaluation of a reversible flowchart language. The results confirm that partial evaluation in this unconventional computing paradigm shows effects consistent with traditional partial evaluation. Experiments include specializing a symmetric encryption algorithm and a reversible interpreter for Bennett's reversible Turing machines. A defining feature of reversible languages is their invertibility. This study reports the first experiments composing program inversion and partial evaluation. The presented method is fully implemented. It is potentially of interest because reversible computing has found applications in areas as diverse as low-power computing, debugging, robotics, and quantum-inspired computing.

+
+ + +

An Intrinsically Typed Compiler for Algebraic Effect Handlers

  • Syouki Tsuyama
  • Youyou Cong
  • Hidehiko Masuhara
+

A type-preserving compiler converts a well-typed input program into a well-typed output program. +Previous studies have developed type-preserving compilers for various source languages, +including the simply-typed lambda calculus and calculi with control constructs. +Our goal is to realize type-preserving compilation of languages that have facilities for manipulating first-class continuations. +In this paper, we focus on algebraic effects and handlers, a generalization of exceptions and their handlers with resumable continuations. +Specifically, we choose an effect handler calculus and a typed stack-machine-based assembly language as the source and the target languages, respectively, and formalize the target language and a type preserving compiler. +The main challenge posed by first-class continuation is how to ensure safety of continuation capture and resumption, which involves concatenation of unknown stacks. +We solve this challenge by incorporating stack polymorphism, a technique that has been used for compilation from a language without first-class continuations to a stack-based assembly language. +To prove that our compiler is type preserving, we implemented the compiler in Agda as a function between intrinsically typed ASTs. +We believe that our contributions could lead to correct and efficient compilation of continuation-manipulating facilities in general.

+
+ +
\ No newline at end of file diff --git a/_data/OpenTOC.yaml b/_data/OpenTOC.yaml index 37b210a..57bff15 100644 --- a/_data/OpenTOC.yaml +++ b/_data/OpenTOC.yaml @@ -1357,3 +1357,7 @@ event: CPP year: 2024 title: "Proceedings of the 13th ACM SIGPLAN International Conference on Certified Programs and Proofs" +- + event: PEPM + year: 2024 + title: "Proceedings of the 2024 ACM SIGPLAN International Workshop on Partial Evaluation and Program Manipulation" From 304af2f5ea085023823d651a739abf22f045f92d Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Sun, 14 Jan 2024 16:57:21 -0500 Subject: [PATCH 30/64] Update PLDI SC --- _data/Committees.yaml | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/_data/Committees.yaml b/_data/Committees.yaml index c3ad28c..6729079 100644 --- a/_data/Committees.yaml +++ b/_data/Committees.yaml @@ -156,15 +156,16 @@ Onward! Steering Committee: PLDI Steering Committee: - SIGPLAN Chair: # - SIGPLAN Vice Chair: # - - "[Jeff Foster](https://www.eecs.tufts.edu/~jfoster/), PLDI Steering Committee Chair (2019-2022)" - - "[Kathryn McKinley](https://www.cs.utexas.edu/users/mckinley/), 2019 General Chair" - - "[Kathleen Fisher](http://www.cs.tufts.edu/~kfisher/Kathleen_Fisher/Home.html), 2019 Program Chair" - - "[Sriram Rajamani](https://www.microsoft.com/en-us/research/people/sriram/), 2019 Member at Large" - - "[Alastair Donaldson](http://multicore.doc.ic.ac.uk), 2020 General Chair" - - "[Emina Torlak](https://homes.cs.washington.edu/~emina/), 2020 Program Chair" - - "[Michelle Strout](http://cgi.cs.arizona.edu/~mstrout/), 2020 Member at Large" - - "[Stephen Freund](http://www.cs.williams.edu/~freund/index.html), 2021 General Chair" - - "[Eran Yahav](http://www.cs.technion.ac.il/~yahave/), 2021 Program Chair" + - "[Alastair Donaldson](http://multicore.doc.ic.ac.uk) (Imperial College London), PLDI Steering Committee Chair (2022-2025)" + - "[Stephen Freund](http://www.cs.williams.edu/~freund/index.html) (Williams College), 2021 General Chair" + - "[Eran Yahav](http://www.cs.technion.ac.il/~yahave/) (Technion), 2021 Program Chair" + - "[Ilya Sergey](https://ilyasergey.net) (National University of Singapore), 2021 Member at Large" + - "[Ranjit Jhala](https://ranjitjhala.github.io/) (University of California San Diego), 2022 General Chair" + - "[Işıl Dillig](https://www.cs.utexas.edu/~isil/) (University of Texas, Austin), 2022 Program Chair" + - "[Nadia Polikarpova](https://cseweb.ucsd.edu/~npolikarpova/) (University of California San Diego), 2022 Member at Large" + - "[Steve Blackburn](http://users.cecs.anu.edu.au/~steveb/), 2023 General Chair" + - "[Nate Foster](https://www.cs.cornell.edu/~jnfoster/) (Cornell University), 2023 Program Chair" + - "[Sukyoung Ryu](https://plrg.kaist.ac.kr/ryu) (Korea Advanced Institute of Science and Technology), 2023 Member at Large" POPL Steering Committee: - SIGPLAN Chair: # From d98a7fb1b4a7d386b9e561e6f50376e751f9625e Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Sun, 14 Jan 2024 17:13:13 -0500 Subject: [PATCH 31/64] Try redirecting http to https --- _layouts/htaccess.html | 3 +++ 1 file changed, 3 insertions(+) diff --git a/_layouts/htaccess.html b/_layouts/htaccess.html index 33c3ce3..cf60048 100644 --- a/_layouts/htaccess.html +++ b/_layouts/htaccess.html @@ -12,5 +12,8 @@ {% endif %} {% endfor %} +RewriteCond %{HTTPS} off +RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI} [R=301,L] + ErrorDocument 404 /404.html From 723cec461e5a8f955d6b220acce3ff19a9a63f6e Mon Sep 17 00:00:00 2001 From: Antony Hosking Date: Wed, 17 Jan 2024 20:17:59 +1100 Subject: [PATCH 32/64] POPL'14 MIP --- _data/POPL.yaml | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/_data/POPL.yaml b/_data/POPL.yaml index a5f943d..e9e5b8a 100644 --- a/_data/POPL.yaml +++ b/_data/POPL.yaml @@ -1,3 +1,24 @@ +2024: +- Awardee: Ramana Kumar, Magnus Myreen, Michael Norrish, Scott Owens + Other: | + (for 2014): _[CakeML: A Verified Implementation of ML](https://dl.acm.org/doi/10.1145/2535838.2535841)_ + Citation: | + This paper provided exciting evidence that the idea of + machine-checked verified compilation can generalize beyond + Compcert-style optimization verification to end-to-end correctness + statements in the context of ML. A particularly novel feature of + CakeML that distinguished it from contemporary efforts like + CompCert was its support for bootstrapping that facilitates + verification of the compiler implementation along with the runtime + system. Because all of this functionality is fully expressed and + verified within HOL4, the correctness theorem naturally extends to + the machine-code implementation generated by bootstrapping, + essentially for free. This paper has spurred a long line of + productive follow-on work that has been quite impactful in + broadening our understanding of verified compilation, particularly + with respect to the number of new techniques and methods it + spearheaded. + 2023: - Awardee: Thomas Dinsdale-Young, Lars Birkedal, Philippa Gardner, Matthew Parkinson, Hongseok Yang Other: | From a1ee18a8551ea83fa63901fa0e1109d83490a163 Mon Sep 17 00:00:00 2001 From: Antony Hosking Date: Wed, 17 Jan 2024 20:19:12 +1100 Subject: [PATCH 33/64] Capitalisation --- _data/POPL.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_data/POPL.yaml b/_data/POPL.yaml index e9e5b8a..17b328d 100644 --- a/_data/POPL.yaml +++ b/_data/POPL.yaml @@ -5,7 +5,7 @@ Citation: | This paper provided exciting evidence that the idea of machine-checked verified compilation can generalize beyond - Compcert-style optimization verification to end-to-end correctness + CompCert-style optimization verification to end-to-end correctness statements in the context of ML. A particularly novel feature of CakeML that distinguished it from contemporary efforts like CompCert was its support for bootstrapping that facilitates From 8993e4f06f731e88deaf82d9f025e501c7a5ceb8 Mon Sep 17 00:00:00 2001 From: Antony Hosking Date: Fri, 19 Jan 2024 00:37:34 +1100 Subject: [PATCH 34/64] Whitespace reformat --- _data/Milner.yaml | 138 +++++++++++++++++++++++++--------------------- 1 file changed, 75 insertions(+), 63 deletions(-) diff --git a/_data/Milner.yaml b/_data/Milner.yaml index d7f5d3b..1558654 100644 --- a/_data/Milner.yaml +++ b/_data/Milner.yaml @@ -1,7 +1,6 @@ 2023: - Awardee: Nate Foster Citation: | - Nate Foster is a world leader in programming languages and software-defined networking. His skills as a PL researcher run the gamut: adept at design, theory, implementation, and applications, @@ -92,80 +91,93 @@ 2020: - Awardee: Eran Yahav Citation: | - Eran Yahav has a record of sustained, high-impact contributions to the programming - languages research community over nearly two decades. Much of his work has - concerned effective static reasoning about concurrent programs, which is a - longstanding challenge due to the complex and non-local ways in which threads - can interact with one another. Yahav developed novel abstractions for verifying - safety and correctness properties of concurrent programs and used them to validate - non-trivial concurrent algorithms in Java. Later, he extended and applied - program synthesis techniques to concurrent programs in creative ways, for - example, demonstrating how to synthesize a correct concurrent version of a - sequential algorithm and how to automatically repair an existing concurrent - algorithm through additional synchronization. Most recently, Yahav has been - an early leader in the area of "big code," leveraging machine learning techniques - to solve difficult programming tasks, including code search, code completion, and - reverse engineering. This work has influenced others in the research community - to pursue this research direction and has led to practical software engineering - tools for programmers. + Eran Yahav has a record of sustained, high-impact contributions to + the programming languages research community over nearly two + decades. Much of his work has concerned effective static + reasoning about concurrent programs, which is a longstanding + challenge due to the complex and non-local ways in which threads + can interact with one another. Yahav developed novel abstractions + for verifying safety and correctness properties of concurrent + programs and used them to validate non-trivial concurrent + algorithms in Java. Later, he extended and applied program + synthesis techniques to concurrent programs in creative ways, for + example, demonstrating how to synthesize a correct concurrent + version of a sequential algorithm and how to automatically repair + an existing concurrent algorithm through additional + synchronization. Most recently, Yahav has been an early leader in + the area of "big code," leveraging machine learning techniques to + solve difficult programming tasks, including code search, code + completion, and reverse engineering. This work has influenced + others in the research community to pursue this research direction + and has led to practical software engineering tools for + programmers. * Selection committee: Emery Berger, Michelle Strout, Derek Dreyer, Eijiro Sumii, Todd Millstein. 2019: - Awardee: Martin Vechev Citation: | - Martin Vechev is a prolific researcher who has made major contributions to - many areas of programming languages. He is a pioneer who is often one of - the first in the PL community to move into a new area. He is particularly - well known for his seminal papers and tools at the interface of programming - languages and machine learning. An example tool is JSNice, which deobfuscates - JavaScript code by learning a probabilistic graphical model from a large - corpus of programs, which is then used to predict improved variable names - and perform statistical type inference. Another example at this interface is - his work on using abstract interpretation for proving safety properties of - deep neural networks, such as robustness. His many other contributions include - significant advances in concurrent memory management, synthesis of - synchronization code for concurrent programs, and efficient program analysis. + Martin Vechev is a prolific researcher who has made major + contributions to many areas of programming languages. He is a + pioneer who is often one of the first in the PL community to move + into a new area. He is particularly well known for his seminal + papers and tools at the interface of programming languages and + machine learning. An example tool is JSNice, which deobfuscates + JavaScript code by learning a probabilistic graphical model from a + large corpus of programs, which is then used to predict improved + variable names and perform statistical type inference. Another + example at this interface is his work on using abstract + interpretation for proving safety properties of deep neural + networks, such as robustness. His many other contributions include + significant advances in concurrent memory management, synthesis of + synchronization code for concurrent programs, and efficient + program analysis. 2018: - Awardee: Ranjit Jhala Citation: | - Ranjit Jhala has demonstrated a long track-record of producing foundational - and impactful contributions to our understanding of programming language - theory and implementation. Jhala was one of the principal developers of the - BLAST automatic verification tool for checking temporal safety properties of - C programs. A key contribution was the notion of lazy abstraction which - integrates three phases of the software model checking loop: abstraction, - checking and refinement. Jhala developed an algorithm for model checking - safety properties that continuously builds and refines a single abstract - model on demand by the model checker. This allows different parts of the - model to exhibit just the degrees of freedom required to verify a desired - property. The work on lazy abstraction has proved to be very influential in - the verification community. Jhala also used Craig interpolation to - efficiently construct, from a given abstract error trace that cannot be - concretized, a parsimonious abstraction that removes the trace. He developed - the method for programs with arithmetic and pointer expressions, and - call-by-value function calls. This resulting technique was successfully - applied to programs over 130,000 lines which was previously not possible. + Ranjit Jhala has demonstrated a long track-record of producing + foundational and impactful contributions to our understanding of + programming language theory and implementation. Jhala was one of + the principal developers of the BLAST automatic verification tool + for checking temporal safety properties of C programs. A key + contribution was the notion of lazy abstraction which integrates + three phases of the software model checking loop: abstraction, + checking and refinement. Jhala developed an algorithm for model + checking safety properties that continuously builds and refines a + single abstract model on demand by the model checker. This allows + different parts of the model to exhibit just the degrees of + freedom required to verify a desired property. The work on lazy + abstraction has proved to be very influential in the verification + community. Jhala also used Craig interpolation to efficiently + construct, from a given abstract error trace that cannot be + concretized, a parsimonious abstraction that removes the trace. He + developed the method for programs with arithmetic and pointer + expressions, and call-by-value function calls. This resulting + technique was successfully applied to programs over 130,000 lines + which was previously not possible. - Jhala has significantly advanced the practical application of refinement - types which allow programmers to attach additional specifications to - existing types. These additional specifications allow interesting properties - to be proved about code, such as invariants over recursively defined data - structures. The problem with such specifications is that they can be too - onerous to write down and get right. Jhala's work on Liquid Types showed - that a useful and expressive class of these specifications can be inferred - in a largely automatic way, making the approach far more practical at a - reasonable cost. Jhala's work with Liquid Types has significantly extended - the state-of-the-art, adding a notion of predictability and decidability - often not found in SMT-based software verification, and extending the - usability and expressiveness of formal type systems. + Jhala has significantly advanced the practical application of + refinement types which allow programmers to attach additional + specifications to existing types. These additional specifications + allow interesting properties to be proved about code, such as + invariants over recursively defined data structures. The problem + with such specifications is that they can be too onerous to write + down and get right. Jhala's work on Liquid Types showed that a + useful and expressive class of these specifications can be + inferred in a largely automatic way, making the approach far more + practical at a reasonable cost. Jhala's work with Liquid Types has + significantly extended the state-of-the-art, adding a notion of + predictability and decidability often not found in SMT-based + software verification, and extending the usability and + expressiveness of formal type systems. - Jhala has also worked on data race detection, information flow and timing - analysis for Javascript and code analytics. Jhala has also written a lengthy - tutorial on Liquid Haskell, proved to be an excellent communicator and - mentor who has given many engaging and inspiring presentations, and served - extensively on program committees of top conferences. + Jhala has also worked on data race detection, information flow and + timing analysis for Javascript and code analytics. Jhala has also + written a lengthy tutorial on Liquid Haskell, proved to be an + excellent communicator and mentor who has given many engaging and + inspiring presentations, and served extensively on program + committees of top conferences. * Selection committee: Antony Hosking, Chandra Krintz, Xavier Leroy, François Pottier and Satnam Singh. From 4e42e0fc67ed957541ee4b08de0188c7da6172f5 Mon Sep 17 00:00:00 2001 From: Antony Hosking Date: Fri, 19 Jan 2024 03:01:11 +1100 Subject: [PATCH 35/64] Update link --- Awards/Milner.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Awards/Milner.md b/Awards/Milner.md index c065d3c..78dd98f 100644 --- a/Awards/Milner.md +++ b/Awards/Milner.md @@ -84,7 +84,7 @@ Award recipients are selected by a committee constituted as follows: committee. The current committee is: -* [Tony Hosking](https://cs.anu.edu.au/tony-hosking/), Australian +* [Tony Hosking](https://comp.anu.edu.au/antony-hosking/), Australian National U (Chair) * [Jeff Foster](https://www.eecs.tufts.edu/~jfoster/), Tufts U (ex-officio) * [Sandrine Blazy](https://people.irisa.fr/Sandrine.Blazy/), U Rennes From b0bb03d614f5983645c8a0b71f1071dd8f56545c Mon Sep 17 00:00:00 2001 From: Antony Hosking Date: Fri, 19 Jan 2024 03:01:14 +1100 Subject: [PATCH 36/64] Update link --- Awards/Service.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Awards/Service.md b/Awards/Service.md index f1c0acc..8195fed 100644 --- a/Awards/Service.md +++ b/Awards/Service.md @@ -47,7 +47,7 @@ Award recipients are selected by a committee constituted as follows: committee. The current committee comprises:* -* [Tony Hosking](https://cs.anu.edu.au/tony-hosking/), Australian +* [Tony Hosking](https://comp.anu.edu.au/antony-hosking/), Australian National U (Chair) * [Jeff Foster](https://www.eecs.tufts.edu/~jfoster/), Tufts U (ex-officio) From dcc14f2249677b375445bbd8a918d4a8533544f7 Mon Sep 17 00:00:00 2001 From: Antony Hosking Date: Fri, 19 Jan 2024 03:01:18 +1100 Subject: [PATCH 37/64] Update link --- Awards/Software.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Awards/Software.md b/Awards/Software.md index 4330cf9..8a55ccb 100644 --- a/Awards/Software.md +++ b/Awards/Software.md @@ -50,7 +50,7 @@ Award recipients are selected by a committee constituted as follows: committee. The current committee comprises: -* [Tony Hosking](https://cs.anu.edu.au/tony-hosking/), Australian +* [Tony Hosking](https://comp.anu.edu.au/antony-hosking/), Australian National U (Chair) * [Jeff Foster](https://www.eecs.tufts.edu/~jfoster/), Tufts U (ex-officio) * [Dominique From 21c0d101609b382326fa832441265bb2be8cd881 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Thu, 1 Feb 2024 14:22:12 -0500 Subject: [PATCH 38/64] POPL SC update --- _data/Committees.yaml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/_data/Committees.yaml b/_data/Committees.yaml index 6729079..22d012e 100644 --- a/_data/Committees.yaml +++ b/_data/Committees.yaml @@ -170,16 +170,16 @@ PLDI Steering Committee: POPL Steering Committee: - SIGPLAN Chair: # - SIGPLAN Vice Chair: # - - "[Peter Thiemann](http://www2.informatik.uni-freiburg.de/~thiemann/), Steering Committee Chair (2021-2024)" + - "[Ranjit Jhala](https://ranjitjhala.github.io/), Steering Committee Chair (2024–2027)" - "[Ilya Sergey](https://ilyasergey.net), Member at large and Industrial Relation Chair (2022-2025)" - "[Alexandra Silva](https://alexandrasilva.org/#/main.html), Member at large (2021-2024)" - - "[Michael Greenberg](https://cs.pomona.edu/~michael/), Member at large (2021-2024)" + - "[Michael Greenberg](https://cs.pomona.edu/~michael/), Member at large and Industrial Relations (2024–2027)" - "[Andrew Myers](https://www.cs.cornell.edu/andru/), 2023 General Chair" - "[Amal Ahmed](https://www.ccs.neu.edu/home/amal/), 2023 Program Chair" - - "[Rajeev Alur](https://www.cis.upenn.edu/~alur/), 2022 General Chair" - - "[Hongseok Yang](https://sites.google.com/view/hongseokyang/home), 2022 Program Chair" - "[Philippa Gardner](https://www.doc.ic.ac.uk/~pg/), 2024 General Chair" - "[Derek Dreyer](https://people.mpi-sws.org/~dreyer/), 2024 Program Chair" + - "[Steve Zdancewic](https://www.cis.upenn.edu/~stevez/), 2025 General Chair" + - "[Armando Solar-Lezama](https://people.csail.mit.edu/asolar/), 2025 Program Chair" PPOPP Steering Committee: - Chair: Albert Cohen From 5b4645fe1bcee22a579f6cb957ab99dc7e20fe0a Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Thu, 8 Feb 2024 14:07:06 -0500 Subject: [PATCH 39/64] PC fixes from Anders --- Resources/Guidelines/ProChair.md | 4 ++-- Resources/Policies/Diversity.md | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Resources/Guidelines/ProChair.md b/Resources/Guidelines/ProChair.md index 5893b0f..f6f42f6 100644 --- a/Resources/Guidelines/ProChair.md +++ b/Resources/Guidelines/ProChair.md @@ -124,7 +124,7 @@ Recommendations: - The PCC of year X+1 can be invited to serve on the PC (with a lighter reviewing load) for year X as soon as he or she is selected. - The PCC should strive to avoid selecting PC members that collaborate regularly with each other or with the PCC, or PC members from the same institution in the exact same area. -- For conferences, all PC members should have PhDs by the submission deadline of the conference. For affiliated workshops, the PC can include PhD students in their final year, as long as the total number does not exceed 10% (rounded up) the PC. +- For conferences, all PC members should have PhDs (or other appropriate qualifications) by the submission deadline of the conference. For affiliated workshops, the PC can include PhD students in their final year, as long as the total number does not exceed 10% (rounded up) the PC. @@ -178,7 +178,7 @@ care-provider in order to attend. Author Response --------------- -Many SIGPLAN conferences have included author response mecbhanisms as part of +Many SIGPLAN conferences have included author response mechanisms as part of the paper review process, and the general feedback concerning author response has been positive (see [Experiences with Author Response at PLDI and ICFP 2004](http://portalparts.acm.org/1060000/1052883/fm/frontmatter.pdf), diff --git a/Resources/Policies/Diversity.md b/Resources/Policies/Diversity.md index a543400..4771826 100644 --- a/Resources/Policies/Diversity.md +++ b/Resources/Policies/Diversity.md @@ -38,7 +38,7 @@ committees from the pool of qualified candidates include: mid-level, and senior members of the community. (Workshop PCs may include at most one PhD student in their final year; please include a comment detailing their qualifications. Conference PC members should - all have PhDs by the submission deadline.) + all have PhDs, or other appropriate qualifications, by the submission deadline.) 6. Geographic distribution: members should come from all parts of the world active in the given research area. 7. Gender. From 1a195c02c4d9b0cec75748fcf14d98999c374de7 Mon Sep 17 00:00:00 2001 From: David Grove Date: Sun, 11 Feb 2024 14:55:42 -0500 Subject: [PATCH 40/64] add Charles Zhang (GC'25) to SPLASH SC --- _data/Committees.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/_data/Committees.yaml b/_data/Committees.yaml index 22d012e..fbb4930 100644 --- a/_data/Committees.yaml +++ b/_data/Committees.yaml @@ -216,6 +216,7 @@ SPLASH Steering Committee: - Frank Tip, Northeastern University - Tijs van der Storm, CWI & University of Groningen - Vasco T. Vasconcelos, University of Lisbon + - Charles Zhang, Hong Kong University of Science and Technology VEE Steering Committee: - Andrew Baumann, Microsoft Research From 6ad731cafa9c24d4550c256698ef5ba740d569ee Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Sun, 11 Feb 2024 15:19:51 -0500 Subject: [PATCH 41/64] Announcements --- _announce/2024-01-30-asplos_2025.txt | 50 ++++++++++++++++++++++++++++ _announce/2024-02-09-soap_2024.txt | 38 +++++++++++++++++++++ 2 files changed, 88 insertions(+) create mode 100644 _announce/2024-01-30-asplos_2025.txt create mode 100644 _announce/2024-02-09-soap_2024.txt diff --git a/_announce/2024-01-30-asplos_2025.txt b/_announce/2024-01-30-asplos_2025.txt new file mode 100644 index 0000000..6de7c43 --- /dev/null +++ b/_announce/2024-01-30-asplos_2025.txt @@ -0,0 +1,50 @@ +--- +title: "Call for Papers, 30th ACM Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS 2025)" +timestamp: "1/30/2024 10:15:06" +deadline: "2/23/2025" +--- +## Synopsis + +ASPLOS, the ACM International Conference on Architectural Support for Programming Languages and Operating Systems, is the premier academic forum for multidisciplinary applied computer systems research spanning hardware, software, and their interaction. It focuses on practical aspects of computer architecture, programming languages, operating systems, and associated areas such as networking and storage. ASPLOS 2025 will take place in March-April 2025 in Rotterdam, co-located with EuroSys 2025. + +ASPLOS 2025 has three submission deadlines – spring, summer and fall – which are meant to encourage authors to submit their papers when they are ready. As in recent years, ASPLOS 2025 will allow the authors of some submissions to choose to apply a major revision to their submission in order to fix a well-defined list of problems. + +## General Chair + +Lieven Eeckhout (Ghent University) + +## Program Co-chairs + +Martha Kim (Columbia University) +Chris Rossbach (The University of Texas at Austin) +Adrian Sampson (Cornell University) + +## Important Dates + +### Spring Cycle + ++ Abstract Deadline: February 23, 2024 ++ Paper Deadline: March 1, 2024 ++ Author Response Period: May 15-17, 2024 ++ Notification Date (Approx): June 6, 2024 + +### Summer Cycle + ++ Abstract Deadline: June 17, 2024 ++ Paper Deadline: June 24, 2024 ++ Author Response Period: September 9-11, 2024 ++ Notification Date (Approx): October 2, 2024 + +### Fall Cycle + ++ Abstract Deadline: October 11, 2024 ++ Paper Deadline: October 18, 2024 ++ Author Response Period: January 15-17, 2025 ++ Notification Date (Approx): February 7, 2025 + +*All deadlines are AoE.* + +## Call for Papers + +See the full CFP: +https://www.asplos-conference.org/asplos-2025-call-for-papers/ diff --git a/_announce/2024-02-09-soap_2024.txt b/_announce/2024-02-09-soap_2024.txt new file mode 100644 index 0000000..0dd86a4 --- /dev/null +++ b/_announce/2024-02-09-soap_2024.txt @@ -0,0 +1,38 @@ +--- +title: "OAP 2024 Call for Papers (co-located with PLDI'24, taking place in Copenhagen)" +timestamp: "2/9/2024 8:56:03" +deadline: "3/4/2024" +--- +SOAP 2024 (https://pldi24.sigplan.org/home/SOAP-2024) aims to bring together the members of the program analysis community to share new developments and shape new innovations in program analysis. SOAP is an ACM SIGPLAN workshop, co-located with PLDI’24, taking place in Copenhagen, Denmark on June 25th, 2024. + +We invite contributions from researchers and practitioners working with program analysis. We are particularly interested in exciting analysis framework ideas, application of existing static analysis techniques to industrial software, adoption of static analysis in software engineering practices (such as DevOps), innovative designs, and analysis techniques, including preliminary results or work in progress. + +Papers can be submitted through HotCRP (https://soap24.hotcrp.com/). + + +Important dates + +4 March Submission deadline +19 April Author notification +03 May Camera ready deadline +25 June Workshop + + +Submission topics + +Possible submissions include, but are not limited to: +A report on a novel implementation of a program analysis, with a focus on practical details or optimization techniques for obtaining precision and performance. +A new research tool, data, and other artifacts, that showcase early implementations of novel program analysis concepts, as well as mature prototypes. +A description of a novel analysis component, for example, front-ends or abstract domains. +A report describing an innovative tool built on top of an existing framework. +A compelling use case for a feature that is not yet supported by existing analysis tools, with good examples and an informal design of the proposed feature. +An idea paper proposing the integration of existing program analyses to answer interesting novel questions about programs, for example in IDEs and DevOps practices. +An experience report on the use of an existing program analysis framework. +A description of a program analysis tool and screenshots of the main parts of the demo. + +Submission format + +Submissions should be four to six-page papers and should be formatted according to the two-column ACM proceedings format. We strongly encourage authors to make their tool and experimental evaluation public and reproducible, through Docker or virtual machines archived on Zenodo.org. +Similar to SOAP 2023, the Program Committee of SOAP 2024 plans to invite a selection of accepted papers to submit extended versions to a special issue of the International Journal on Software Tools for Technology Transfer (STTT). + + From 099e8fc6c070d2dfad48fb77c107abc7047104e9 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Sun, 11 Feb 2024 15:23:48 -0500 Subject: [PATCH 42/64] ASPLOS 2024 announce --- _announce/2024-02-11-asplos_2024.txt | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 _announce/2024-02-11-asplos_2024.txt diff --git a/_announce/2024-02-11-asplos_2024.txt b/_announce/2024-02-11-asplos_2024.txt new file mode 100644 index 0000000..5278759 --- /dev/null +++ b/_announce/2024-02-11-asplos_2024.txt @@ -0,0 +1,19 @@ +--- +title: "Call for Participation, ASPLOS 2024" +start: "4/27/2024" +end: "5/1/2024" +--- +Dear Colleagues, + +ASPLOS, the ACM International Conference on Architectural Support for Programming Languages and Operating Systems, is the premier academic forum for multidisciplinary computer systems research spanning hardware, software, and their interaction. It focuses on computer architecture, programming languages, operating systems, and associated areas such as networking and storage. + +ASPLOS'24 is being held in San Diego, in beautiful Southern California April 27th-May 1st 2024. Early registration is now open until March 22: you can find the links to register and reserve your hotel room on the conference website: +https://www.asplos-conference.org/asplos2024/attend/ + +Because ASPLOS moved to a three-deadline model, the program will not be finalized with papers under review from the third deadline. We will be filling in program details as this review process is completed. Please check the conference website for details: +https://www.asplos-conference.org/asplos2024/ + +On behalf of the organizing committee, we look forward to seeing in San Diego! + +Rajiv Gupta and Nael Abu-Ghazaleh +General Chairs, ASPLOS'24 From 80324e8e5223521532223de1ea8968aa60fcfd63 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Sun, 11 Feb 2024 15:29:13 -0500 Subject: [PATCH 43/64] LATTE announcement --- _announce/2024-02-11-latte_2024.txt | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 _announce/2024-02-11-latte_2024.txt diff --git a/_announce/2024-02-11-latte_2024.txt b/_announce/2024-02-11-latte_2024.txt new file mode 100644 index 0000000..889f130 --- /dev/null +++ b/_announce/2024-02-11-latte_2024.txt @@ -0,0 +1,10 @@ +--- +title: "LATTE: Workshop on Languages, Tools, and Techniques for Accelerator Design" +deadline: "03/08/2024" +--- +LATTE is a venue for discussion, debate, and brainstorming about language-oriented approaches to hardware acceleration. The focus is on new languages and tools that aim to let domain specialists, not just hardware experts, produce efficient accelerators: +https://capra.cs.cornell.edu/latte24/ + +LATTE '24 is co-located with ASPLOS, in San Diego, California. + +Submit your 2-page position paper by March 8. From 031f149e98cc94aa3597eda6b3a313faaee65017 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Wed, 21 Feb 2024 20:03:33 -0500 Subject: [PATCH 44/64] TOC --- OpenTOC/cc24.html | 224 +++++++++++++++++++++++++++++ OpenTOC/ppopp24.html | 330 +++++++++++++++++++++++++++++++++++++++++++ _data/OpenTOC.yaml | 8 ++ 3 files changed, 562 insertions(+) create mode 100644 OpenTOC/cc24.html create mode 100644 OpenTOC/ppopp24.html diff --git a/OpenTOC/cc24.html b/OpenTOC/cc24.html new file mode 100644 index 0000000..1304739 --- /dev/null +++ b/OpenTOC/cc24.html @@ -0,0 +1,224 @@ +CC 2024: Proceedings of the 33rd ACM SIGPLAN International Conference on Compiler Construction

CC 2024: Proceedings of the 33rd ACM SIGPLAN International Conference on Compiler Construction

+ Full Citation in the ACM Digital Library +

SESSION: Code Generation and Synthesis

+

Fast Template-Based Code Generation for MLIR

  • Florian Drescher
  • Alexis Engelke
+

Fast compilation is essential for JIT-compilation use cases like dynamic languages or databases as well as development productivity when compiling static languages. Template-based compilation allows fast compilation times, but in existing approaches, templates are generally handwritten, limiting flexibility and causing substantial engineering effort.

In this paper, we introduce an approach based on MLIR that derives code templates for the instructions of any dialect automatically ahead-of-time. Template generation re-uses the existing compilation path present in the MLIR lowering of the instructions and thereby inherently supports code generation from different abstraction levels in a single step.

Our results on compiling database queries and standard C programs show a compile-time improvement of 10–30x compared to LLVM -O0 with only moderate run-time slowdowns of 1–3x, resulting in an overall improvement of 2x in a JIT-compilation-based database setting.

+
+ + +

A Unified Memory Dependency Framework for Speculative High-Level Synthesis

  • Jean-Michel Gorius
  • Simon Rokicki
  • Steven Derrien
+

Heterogeneous hardware platforms that leverage application-specific hardware accelerators are becoming increasingly popular as the demand for high-performance compute intensive applications rises. The design of such high-performance hardware accelerators is a complex task. High-Level Synthesis (HLS) promises to ease this process by synthesizing hardware from a high-level algorithmic description. Recent works have demonstrated that speculative execution can be inferred from the latter by leveraging compilation transformation and analysis techniques in HLS flows. However, existing work on speculative HLS lacks support for the intricate memory interactions in data-processing applications. In this paper, we introduce a unified memory speculation framework, which allows aggressive scheduling and high-throughput accelerator synthesis in the presence of complex memory dependencies. We show that our technique can generate high-throughput designs for various applications and describe a complete implementation inside an existing speculative HLS toolchain.

+
+ +

SESSION: Static and Dynamic Analysis

+

If-Convert as Early as You Must

  • Dorit Nuzman
  • Ayal Zaks
  • Ziv Ben-Zion
+

Optimizing compilers employ a rich set of transformations that generate highly efficient code for a variety of source languages and target architectures. These transformations typically operate on general control flow constructs which trigger a range of optimization opportunities, such as moving code to less frequently executed paths, and more. Regular loop nests are specifically relevant for accelerating certain domains, leveraging architectural features including vector instructions, hardware-controlled loops and data flows, provided their internal control-flow is eliminated. Compilers typically apply predicating if-conversion late, in their backend, to remove control-flow undesired by the target. Until then, transformations triggered by control-flow constructs that are destined to be removed may end up doing more harm than good. +We present an approach that leverages the existing powerful and general optimization flow of LLVM when compiling for targets without control-flow in loops. Rather than trying to teach various transformations how to avoid misoptimizing for such targets, we propose to introduce an aggressive if-conversion pass as early as possible, along with carefully addressing pass-ordering implications. This solution outperforms the traditional compilation flow with only a modest tuning effort, thereby offering a robust and promising compilation approach for branch-restricted targets.

+
+ + +

Paguroidea: Fused Parser Generator with Transparent Semantic Actions

  • Yifan Zhu
  • Quartic Cat
  • Boluo Ge
  • Shaotong Sun
+

Parser generators have long been a savior for programmers, liberating them from the daunting task of crafting correct and maintainable parsers. Yet, this much-needed simplicity often comes at the expense of efficiency. +

+

+We present, Paguroidea, a parser generator that harnesses the power of lexer-parser fusion techniques to create parsers that boast user-friendly grammar definitions while delivering performance that rivals specialized parsers. Building upon the foundations of the flap parser, our work introduces a series of extensions. +

+

+One of our key contributions is a novel approach to the normalization method. By encoding reduction actions directly into the Deterministic Greibach Normal Form (DGNF), we provide parser generators with flexibility in manipulating semantic actions. This unique approach empowers developers with the freedom to customize their parser generators to their specific needs while maintaining semantic correctness. +

+

+Furthermore, we formulate the execution of the parser in substructural logic, providing an elegant way to prove the correctness of the amended normalization procedure. In this exposition, we offer a glimpse into efficacious, user-friendly, and correctness-provable parser generation.

+
+ + +

Region-Based Data Layout via Data Reuse Analysis

  • Caio Salvador Rohwedder
  • João P. L. De Carvalho
  • José Nelson Amaral
+

Data-structure splicing techniques, such as structure splitting, field reordering, and pointer inlining reorganize data structures to improve cache and translation look-aside buffer (TLB) utilization. Structure types are typically transformed globally in the program, requiring updates to all references to elements of a transformed type. These techniques often rely on instrumentation, tracing, or sampling to create models that guide their transformations. Furthermore, compilers often cannot prove that their transformations are legal and must rely on manual inspection and manual transformation. Applying data-layout transformations locally -- as opposed to globally -- to regions of code removes the need for expensive profiling and simplifies legality verification. This work introduces RebaseDL, a static analysis that finds profitable and legal region-based data layout transformation opportunities that improve access locality. These opportunities are found within code regions that exhibit data reuse. Going beyond structure splicing, RebaseDL also identifies transformation opportunities that do not involve structure types, that is, it identifies data packing transformations. The analysis is implemented in LLVM and it detects multiple transformation opportunities within the SPEC CPU benchmark suite, where the transformation obtains speedups of up to 1.34x for transformed regions.

+
+ + +

A Context-Sensitive Pointer Analysis Framework for Rust and Its Application to Call Graph Construction

  • Wei Li
  • Dongjie He
  • Yujiang Gui
  • Wenguang Chen
  • Jingling Xue
+

Existing program analysis tools for Rust lack the ability to effectively detect security vulnerabilities due to the absence of an accurate call graph and precise points-to information. We present Rupta, the first context-sensitive pointer analysis framework designed for Rust, with a particular focus on its role in constructing call graphs. Operating on Rust MIR, Rupta employs callsite-based context-sensitivity and on-the-fly call graph construction to address a range of pointer analysis challenges, including method/function calls, pointer casts, and nested structs, while preserving type information. +

+

+Our assessment of Rupta against two state-of-the-art call graph construction techniques, Rurta (Rapid Type Analysis-based) and Ruscg (static dispatch-only), across 13 real-world Rust programs demonstrates its high efficiency and precision. In particular, our results reveal that Rupta surpasses Ruscg in soundness by discovering 29% more call graph edges and outperforms Rurta in precision by eliminating approximately 70% of spurious dynamic call edges. Consequently, Rupta has the potential to enhance existing security analysis tools, enabling them to identify a greater number of security vulnerabilities in Rust programs.

+
+ + +

CoSense: Compiler Optimizations using Sensor Technical Specifications

  • Pei Mu
  • Nikolaos Mavrogeorgis
  • Christos Vasiladiotis
  • Vasileios Tsoutsouras
  • Orestis Kaparounakis
  • Phillip Stanley-Marbell
  • Antonio Barbalace
+

Embedded systems are ubiquitous, but in order to maximize their lifetime on batteries there is a need for faster code execution – i.e., higher energy efficiency, and for reduced memory usage. The large number of sensors integrated into embedded systems gives us the opportunity to exploit sensors’ technical specifications, like a sensor’s value range, to guide compiler optimizations for faster code execution, small binaries, etc. We design and implement such an idea in COSENSE, a novel compiler (extension) based on the LLVM infrastructure, using an existing domain-specific language (DSL), NEWTON, to describe the bounds of and relations between physical quantities measured by sensors. COSENSE utilizes previously unexploited physical information correlated to program variables to drive code optimizations. COSENSE computes value ranges of variables and proceeds to overload functions, compress variable types, substitute code with constants and simplify the condition statements. We evaluated COSENSE using several microbenchmarks and two real-world applications on various platforms and CPUs. For microbenchmarks, COSENSE achieves 1.18× geomean speedup in execution time and 12.35% reduction on average in binary code size with 4.66% compilation time overhead on x86, and 1.23× geomean speedup in execution time and 10.95% reduction on average in binary code size with 5.67% compilation time overhead on ARM. For real-world applications, COSENSE achieves 1.70× and 1.50× speedup in execution time, 12.96% and 0.60% binary code reduction, 9.69% and 30.43% lower energy consumption, with a 26.58% and 24.01% compilation time overhead, respectively.

+
+ +

SESSION: Runtime Techniques

+

UNIFICO: Thread Migration in Heterogeneous-ISA CPUs without State Transformation

  • Nikolaos Mavrogeorgis
  • Christos Vasiladiotis
  • Pei Mu
  • Amir Khordadi
  • Björn Franke
  • Antonio Barbalace
+

Heterogeneous-ISA processor designs have attracted considerable research interest. However, unlike their homogeneous-ISA counterparts, explicit software support for bridging ISA heterogeneity is required. The lack of a compilation toolchain ready to support heterogeneous-ISA targets has been a major factor hindering research in this exciting emerging area. For any such compiler “getting right” the mechanics involved in state transformation upon migration and doing this efficiently is of critical importance. In particular, any runtime conversion of the current program stack from one architecture to another would be prohibitively expensive. In this paper, we design and develop Unifico, a new multi-ISA compiler that generates binaries that maintain the same stack layout during their execution on either architecture. Unifico avoids the need for runtime stack transformation, thus eliminating overheads associated with ISA migration. Additional responsibilities of the Unifico compiler backend include maintenance of a uniform ABI and virtual address space across ISAs. Unifico is implemented using the LLVM compiler infrastructure, and we are currently targeting the x86-64 and ARMv8 ISAs. We have evaluated Unifico across a range of compute-intensive NAS benchmarks and show its minimal impact on overall execution time, where less than 6% overhead is introduced on average. When compared against the state-of-the-art Popcorn compiler, Unifico reduces binary size overhead from ∼200% to ∼10%, whilst eliminating the stack transformation overhead during ISA migration.

+
+ + +

BLQ: Light-Weight Locality-Aware Runtime for Blocking-Less Queuing

  • Qinzhe Wu
  • Ruihao Li
  • Jonathan Beard
  • Lizy John
+

Message queues are used widely in parallel processing systems for worker thread synchronization. When there is a throughput mismatch between the upstream and downstream tasks, the message queue buffer will often exist as either empty or full. Polling on an empty or full queue will affect the performance of upstream or downstream threads, since such polling cycles could have been spent on other computation. Non-blocking queue is an alternative that allow polling cycles to be spared for other tasks per applications’ choice. However, application programmers are not supposed to bear the burden, because a good decision of what to do upon blocking has to take many runtime environment information into consideration. +

+

+This paper proposes Blocking-Less Queuing Runtime (BLQ), a systematic solution capable of finding the proper strategies at (or before) blocking, as well as lightening the programmers’ burden. BLQ collects a set of solutions, including yielding, advanced dynamic queue buffer resizing, and resource-aware task scheduling. The evaluation on high-end servers shows that a set of diverse parallel queuing workloads could reduce blocking and lower cache misses with BLQ. BLQ outperforms the baseline runtime considerably (with up to 3.8× peak speedup).

+
+ +

SESSION: Debugging, Profiling, and Parallelism

+

APPy: Annotated Parallelism for Python on GPUs

  • Tong Zhou
  • Jun Shirako
  • Vivek Sarkar
+

GPUs are increasingly being used used to speed up Python applications in the scientific computing and machine learning domains. Currently, the two common approaches to leveraging GPU acceleration in Python are 1) create a custom native GPU kernel, and import it as a function that can be called from Python; 2) use libraries such as CuPy, which provides pre-defined GPU-implementation-backed tensor operators. The first approach is very flexible but requires tremendous manual effort to create a correct and high performance GPU kernel. While the second approach dramatically improves productivity, it is limited in its generality, as many applications cannot be expressed purely using CuPy’s pre-defined tensor operators. Additionally, redundant memory access can often occur between adjacent tensor operators due to the materialization of intermediate results. In this work, we present APPy (Annotated Parallelism for Python), which enables users to parallelize generic Python loops and tensor expressions for execution on GPUs by adding simple compiler directives (annotations) to Python code. Empirical evaluation on 20 scientific computing kernels from the literature on a server with an AMD Ryzen 7 5800X 8-Core CPU and an NVIDIA RTX 3090 GPU demonstrates that with simple pragmas APPy is able to generate more efficient GPU code and achieves significant geometric mean speedup relative to CuPy (30× on average), and to three state-of-the-art Python compilers, Numba (8.3× on average), DaCe-GPU (3.1× on average) and JAX-GPU (18.8× on average).

+
+ + +

Accurate Coverage Metrics for Compiler-Generated Debugging Information

  • J. Ryan Stinnett
  • Stephen Kell
+

Many debugging tools rely on compiler-produced metadata to present a source-language view of program states, such as variable values and source line numbers. While this tends to work for unoptimised programs, current compilers often generate only partial debugging information in optimised programs. +Current approaches for measuring the extent of coverage of local variables are based on crude assumptions (for example, assuming variables could cover their whole parent scope) and are not comparable from one compilation to another. In this work, we propose some new metrics, computable by our tools, which could serve as motivation for language implementations to improve debugging quality.

+
+ + +

FlowProf: Profiling Multi-threaded Programs using Information-Flow

  • Ahamed Al Nahian
  • Brian Demsky
+

Amdahl's law implies that even small sequential bottlenecks can seriously limit the scalability of multi-threaded programs. To achieve scalability, developers must painstakingly identify sequential bottlenecks in their program and eliminate these bottlenecks by either changing synchronization strategies or rearchitecting and rewriting any code with sequential bottlenecks. This can require significant effort by the developer to find and understand how to fix sequential bottlenecks. To address the issue, we bring a new tool, information flow, to the problem of understanding sequential bottlenecks. Information flow can help developers understand whether a bottleneck is fundamental to the computation, or merely an artifact of the implementation. +

+

+First, our strategy tracks memory access conflicts to find over-synchronized applications where redesigning the synchronization strategy on existing implementation can improve performance. Then, information flow analysis finds optimization opportunities where changing the existing implementation can improve performance of applications that have bottlenecks due to unnecessary memory access conflicts. We implemented this in FlowProf. We have evaluated FlowProf on a set of multi-threaded Java applications where the generated optimization insights achieve performance gains of up to 58%.

+
+ + +

Reducing the Overhead of Exact Profiling by Reusing Affine Variables

  • Leon Frenot
  • Fernando Magno Quintão Pereira
+

An exact profiler inserts counters in a program to record how many times each edge of that program's control-flow graph has been traversed during an execution of it. It is common practice to instrument only edges in the complement of a minimum spanning tree of the program's control-flow graph, following the algorithm proposed by Knuth and Stevenson in 1973. Yet, even with this optimization, the overhead of exact profiling is high. As a consequence, mainstream profile-guided code optimizers resort to sampling, i.e., approximate, profiling, instead of exact frequency counts. This paper introduces a technique to reduce the overhead of exact profiling. We show that it is possible to use the values of variables incremented by constant steps within loops---henceforth called SESE counters---as a replacement for some profiling counters. Such affine variables are common, for they include the induction variable of typical loops. This technique, although simple, is effective. We have implemented it in the LLVM compilation infrastructure. Standard Knuth-Stevenson instrumentation increases the running time of the 135 programs in the LLVM test suite from 648 seconds to 817. The optimization suggested in this paper brings this time down to 738 seconds. In the 949 Jotai programs, standard instrumentation increases the number of processed x86 instructions from 2.96 billion to 3.34 billion, whereas the proposed technique causes 3.07 billion instructions to be fetched.

+
+ + +

Stale Profile Matching

  • Amir Ayupov
  • Maksim Panchenko
  • Sergey Pupyrev
+

Profile-guided optimizations rely on profile data for directing compilers to generate optimized code. To achieve the maximum performance boost, profile data needs to be collected on the same version of the binary that is being optimized. In practice however, there is typically a gap between the profile collection and the release, which makes a portion of the profile invalid for optimizations. This phenomenon is known as profile staleness, and it is a serious practical problem for data-center workloads both for compilers and binary optimizers.

In this paper we thoroughly study the staleness problem and propose the first practical solution for utilizing profiles collected on binaries built from several revisions behind the release. Our algorithm is developed and implemented in a mainstream open-source post-link optimizer, BOLT. An extensive evaluation on a variety of standalone benchmarks and production services indicates that the new method recovers up to 0.8 of the maximum BOLT benefit, even when most of the input profile data is stale and would have been discarded by the optimizer otherwise.

+
+ +

SESSION: Safety and Correctness

+

From Low-Level Fault Modeling (of a Pipeline Attack) to a Proven Hardening Scheme

  • Sébastien Michelland
  • Christophe Deleuze
  • Laure Gonnord
+

Fault attacks present unique safety and security challenges that require dedicated countermeasures, even for bug-free programs. Models of these complex attacks are made workable by approximating their effects to a suitable level of abstraction. The common practice of targeting the Instruction Set Architecture (ISA) level isn't ideal because it discards important micro-architectural information, leading to weaker security guarantees. Conversely, including micro-architectural details makes countermeasures harder to model and reason about, creating a new challenge in validating and trusting protections. +

+

+We show that a semantic approach to modeling faults makes micro-architectural models workable, and enables precise cooperation between software and hardware in the design of countermeasures. We demonstrate the approach by designing and implementing a compiler/hardware countermeasure, which protects against a state-of-the-art pipeline fetch attack that generalizes multi-fault instruction skips. Crucially, we provide a formal security proof that guarantees faults are detected by the end of every basic block. This result shows that carefully embracing the complexity of low-level systems enables finer, more secure countermeasures.

+
+ + +

Clog: A Declarative Language for C Static Code Checkers

  • Alexandru Dura
  • Christoph Reichenbach
+

We present Clog, a declarative language for describing static code checkers for C. +Unlike other extensible state-of-the-art checker frameworks, Clog +enables powerful interprocedural checkers without exposing the +underlying program representation: +Clog checkers consist of Datalog-style recursive rules that access the program +under analysis via syntactic pattern matching and control flow edges only. +We have implemented Clog on top of Clang, using a custom Datalog evaluation strategy +that piggy-backs on Clang's AST matching facilities while working around Clang's limitations +to achieve our design goal of representation independence. +

+

+Our experiments demonstrate that Clog can concisely express a wide +variety of checkers for different security vulnerabilities, with +performance that is similar to Clang's own analyses and highly +competitive on real-world programs.

+
+ +

SESSION: Compilers and Machine Learning

+

Compiler-Based Memory Encryption for Machine Learning on Commodity Low-Power Devices

  • Kiwan Maeng
  • Brandon Lucia
+

Running machine learning (ML) on low-power IoT devices exposes unique security concerns. Attackers can easily steal or manipulate sensitive user data or proprietary ML models from the devices’ off-chip memory by leveraging their simple hardware structure and the lack of memory encryption hardware. To protect against these real-world threats, we propose a lightweight compiler-based memory encryption scheme, Spitz. Spitz achieves full off-chip memory encryption only with common architectural components on commodity devices, such as programmable on-chip SRAM, AES hardware, and Direct-Memory Access (DMA). Our evaluation on real hardware shows that Spitz maintains competitive performance while realizing full off-chip memory encryption. Spitz is only 1.16–1.73× slower than our best-effort non-secure baseline, and is even faster by 1.5–2.23× compared to a non-secure popular vendor library.

+
+ + +

YFlows: Systematic Dataflow Exploration and Code Generation for Efficient Neural Network Inference using SIMD Architectures on CPUs

  • Cyrus Zhou
  • Zack Hassman
  • Dhirpal Shah
  • Vaughn Richard
  • Yanjing Li
+

We address the challenges associated with deploying neural networks on CPUs, with a particular focus on minimizing inference time while maintaining accuracy. Our novel approach is to use the dataflow (i.e., computation order) of a neural network to explore data reuse opportunities using heuristic-guided analysis and a code generation framework, which enables exploration of various Single Instruction, Multiple Data (SIMD) implementations to achieve optimized neural network execution. Our results demonstrate that the dataflow that keeps outputs in SIMD registers while also maximizing both input and weight reuse consistently yields the best performance for a wide variety of inference workloads, achieving up to 3x speedup for 8-bit neural networks, and up to 4.8x speedup for binary neural networks, respectively, over the optimized implementations of neural networks today.

+
+ + +

Fast and Accurate Context-Aware Basic Block Timing Prediction using Transformers

  • Abderaouf Nassim Amalou
  • Elisa Fromont
  • Isabelle Puaut
+

This paper introduces ORXESTRA, a context-aware execution time prediction model based on Transformers XL, specifically designed to accurately estimate performance in embedded system applications. Unlike traditional machine learning models that often overlook contextual information, resulting in biased predictions for individual isolated basic blocks, ORXESTRA overcomes this limitation by incorporating execution context awareness. By doing so, ORXESTRA effectively accounts for the processor micro-architecture without explicitly modeling micro-architectural elements such as caches, pipelines, and branch predictors. Our evaluations demonstrate ORXESTRA's ability to provide precise timing estimations for different ARM targets (Cortex M4, M7, A53, and A72), surpassing existing machine learning-based approaches in both prediction accuracy and prediction speed.

+
+ + +

The Next 700 ML-Enabled Compiler Optimizations

  • S. VenkataKeerthy
  • Siddharth Jain
  • Umesh Kalvakuntla
  • Pranav Sai Gorantla
  • Rajiv Shailesh Chitale
  • Eugene Brevdo
  • Albert Cohen
  • Mircea Trofin
  • Ramakrishna Upadrasta
+

There is a growing interest in enhancing compiler optimizations with ML models, yet interactions between compilers and ML frameworks remain challenging. Some optimizations require tightly coupled models and compiler internals, raising issues with modularity, performance and framework independence. Practical deployment and transparency for the end-user are also important concerns. We propose ML-Compiler-Bridge to enable ML model development within a traditional Python framework while making end-to-end integration with an optimizing compiler possible and efficient. We evaluate it on both research and production use cases, for training and inference, over several optimization problems, multiple compilers and its versions, and gym infrastructures.

+
+ + +

Exponentially Expanding the Phase-Ordering Search Space via Dormant Information

  • Ruobing Han
  • Hyesoon Kim
+

Applying compilation transformations in optimal sequences can significantly improve program speed and reduce code size. However, finding these optimal sequences—a problem known as the phase-ordering problem—remains a long-standing challenge. Specifically, modern compilers offer hundreds of available transformations, making the search space too large to explore efficiently within a reasonable timeframe. Existing solutions address this problem by grouping transformations into short sequences based on prior knowledge from human experts, and then searching for optimal orders among these sequences. Such pruning methods are aggressive, potentially excluding optimal solutions from the search space. Additionally, they rely on prior knowledge and lack scalability when applied to new transformations.

In this paper, we propose a more conservative pruning approach. The insight of this new approach is to capture the dormant information and utilize it to guide the search process. By excluding dormant transformations, this approach significantly prunes the search space while retaining the optimal solutions. Moreover, it does not rely on any prior human knowledge, making it scalable to new transformations.

To demonstrate the efficacy of the conservative approach, we integrate it with a classical Reinforcement Learning model, which was previously used with aggressive pruning methods. Our solution, named FlexPO, is capable of exploring a search space exponentially larger than those considered in existing solutions. Experimental results show that FlexPO generates programs that are 12% faster or 17.6% smaller than the programs produced by modern compilers.

+
+ +
\ No newline at end of file diff --git a/OpenTOC/ppopp24.html b/OpenTOC/ppopp24.html new file mode 100644 index 0000000..251c242 --- /dev/null +++ b/OpenTOC/ppopp24.html @@ -0,0 +1,330 @@ +PPoPP '24: Proceedings of the 29th ACM SIGPLAN Annual Symposium on Principles and Practice of Parallel Programming

PPoPP '24: Proceedings of the 29th ACM SIGPLAN Annual Symposium on Principles and Practice of Parallel Programming

+ Full Citation in the ACM Digital Library +

SESSION: Keynote

+

Sparsity in Deep Neural Nets (Keynote)

  • Nir N Shavit
+

Our brain executes very sparse computation, allowing for great speed and energy savings. Deep neural networks can also be made to exhibit high levels of sparsity without significant accuracy loss. As their size grows, it is becoming imperative that we use sparsity to improve their efficiency. This is a challenging task because the memory systems and SIMD operations that dominate todays CPUs and GPUs do not lend themselves easily to the irregular data patterns sparsity introduces. This talk will survey the role of sparsity in neural network computation, and the parallel algorithms and hardware features that nevertheless allow us to make effective use of it.

+
+ +

SESSION: Synchronization and Concurrency Control I

+

Scaling Up Transactions with Slower Clocks

  • Pedro Ramalhete
  • Andreia Correia
+

Concurrency controls with optimistic read accesses and pessimistic write accesses are among the fastest in the literature. However, during write transactions these algorithms need to increment an atomic variable, the central clock, limiting parallelism and preventing scalability at high core counts.

+

In this paper, we propose a new concurrency control, Deferred Clock Transactional Locking (DCTL), which significantly reduces the heartbeat of the central clock, thus increasing scalability. DCTL will not increment the clock for consecutive disjoint transactions. An optimized variant, named DCOTL, allows for consecutive transactions with nondisjoint write-accesses to commit without incrementing the clock. Moreover, we show variants of these two algorithms with starvation-free transactions.

+

Transactions in DCTL are opaque, which means it can be applied to concurrent data structures, Database Management Systems, Software Transactional Memory, and Persistent Transactional Memory. Our experiments show that these DCTL algorithms match or surpass the current state of the art for most workloads. We adapted both algorithms using an existing durability technique and implemented a fully transactional DBMS with disk persistence, whose scalability in write transactions exceeds the current state of the art.

+
+ + +

Locks as a Resource: Fairly Scheduling Lock Occupation with CFL

  • Jonggyu Park
  • Young Ik Eom
+

In multi-container environments, applications oftentimes experience unexpected performance fluctuations due to undesirable interference among applications. Synchronization such as locks has been targeted as one of the reasons but still remains an uncontrolled resource while a large set of locks are still shared across applications. In this paper, we demonstrate that this lack of lock scheduling incurs significant real-world problems including performance unfairness and interference among applications. To address this problem, we propose a new synchronization design with an embedded scheduling capability, called CFL (Completely Fair Locking). CFL fairly distributes a fair amount of lock occupation time to applications considering their priorities and cgroup information. For scalability, CFL also considers the NUMA topology in the case of NUMA machines. Experimental results demonstrate that CFL significantly improves performance fairness while achieving comparable or sometimes even superior performance to state-of-the-art locks.

+
+ + +

Are Your Epochs Too Epic? Batch Free Can Be Harmful

  • Daewoo Kim
  • Trevor Brown
  • Ajay Singh
+

Epoch based memory reclamation (EBR) is one of the most popular techniques for reclaiming memory in lock-free and optimistic locking data structures, due to its ease of use and good performance in practice. However, EBR is known to be sensitive to thread delays, which can result in performance degradation. Moreover, the exact mechanism for this performance degradation is not well understood.

+

This paper illustrates this performance degradation in a popular data structure benchmark, and does a deep dive to uncover its root cause---a subtle interaction between EBR and state of the art memory allocators. In essence, modern allocators attempt to reduce the overhead of freeing by maintaining bounded thread caches of objects for local reuse, actually freeing them (a very high latency operation) only when thread caches become too large. EBR immediately bypasses these mechanisms whenever a particularly large batch of objects is freed, substantially increasing overheads and latencies. Beyond EBR, many memory reclamation algorithms, and data structures, that reclaim objects in large batches suffer similar deleterious interactions with popular allocators.

+

We propose a simple algorithmic fix for such algorithms to amortize the freeing of large object batches over time, and apply this technique to ten existing memory reclamation algorithms, observing performance improvements for nine out of ten, and over 50% improvement for six out of ten in experiments on a high performance lock-free ABtree. We also present an extremely simple token passing variant of EBR and show that, with our fix, it performs 1.5--2.6× faster than the fastest known memory reclamation algorithm, and 1.2--1.5× faster than not reclaiming at all, on a 192 thread four socket Intel system.

+
+ +

SESSION: Compilers and Runtimes for Parallel Systems

+

Liger: Interleaving Intra- and Inter-Operator Parallelism for Distributed Large Model Inference

  • Jiangsu Du
  • Jinhui Wei
  • Jiazhi Jiang
  • Shenggan Cheng
  • Dan Huang
  • Zhiguang Chen
  • Yutong Lu
+

Distributed large model inference is still in a dilemma where balancing cost and effect. The online scenarios demand intraoperator parallelism to achieve low latency and intensive communications makes it costly. Conversely, the inter-operator parallelism can achieve high throughput with much fewer communications, but it fails to enhance the effectiveness.

+

In this paper, we present Liger, a distributed large model inference runtime system that is of capability to achieve low latency at high throughput on the multi-GPU architecture. The key idea lies in the novel interleaved parallelism, which interleaves the computation and communication across requests. Liger enables this parallelism by carefully scheduling computation and communication kernels across requests onto multiple streams of multiple GPUs. It achieves precise control of kernel execution order efficiently by mixing use the CPU-GPU synchronization and the inter-stream synchronization. To prevent scheduling failures caused by resource contention, Liger introduces a contention factor strategy to anticipate the penalty of contention. It enables a higher degree of overlap by decomposing lengthy kernels into smaller, more manageable units at runtime.

+

Extensive evaluations show that Liger, in most cases, outperforms existing parallelism approaches across models and devices, presenting the best latency and throughput results. In a 4-device case, Liger reduces the average latency by 36.0% while maintaining the same throughput compared to the inter-operator approach. Meanwhile, it improves the throughput by 1.34× with improved average latency compared to the intra-operator approach.

+
+ + +

A Holistic Approach to Automatic Mixed-Precision Code Generation and Tuning for Affine Programs

  • Jinchen Xu
  • Guanghui Song
  • Bei Zhou
  • Fei Li
  • Jiangwei Hao
  • Jie Zhao
+

Reducing floating-point (FP) precision is used to trade the quality degradation of a numerical program's output for performance, but this optimization coincides with type casting, whose overhead is undisclosed until a mixed-precision code version is generated. This uncertainty enforces the decoupled implementation of mixed-precision code generation and autotuning in prior work. In this paper, we present a holistic approach called PrecTuner that consolidates the mixed-precision code generator and the autotuner by defining one parameter. This parameter is first initialized by some automatically sampled values and used to generate several code variants, with various loop transformations also taken into account. The generated code variants are next profiled to solve a performance model formulated using the aforementioned parameter, possibly under a pre-defined quality degradation budget. The best-performing value of the defined parameter is finally predicted without evaluating all code variants. Experimental results of the PolyBench benchmarks on CPU demonstrate that PrecTuner outperforms LuIs by 3.28× while achieving smaller errors, and we also validate its effectiveness in optimizing a real-life large-scale application. In addition, PrecTuner also obtains a mean speedup of 1.81× and 1.52×-1.73× over Pluto on single- and multi-core CPU, respectively, and 1.71× over PPCG on GPU.

+
+ + +

Language-Agnostic Static Deadlock Detection for Futures

  • Stefan K Muller
+

Deadlocks, in which threads wait on each other in a cyclic fashion and can't make progress, have plagued parallel programs for decades. In recent years, as the parallel programming mechanism known as futures has gained popularity, interest in preventing deadlocks in programs with futures has increased as well. Various static and dynamic algorithms exist to detect and prevent deadlock in programs with futures, generally by constructing some approximation of the dependency graph of the program but, as far as we are aware, all are specialized to a particular programming language.

+

A recent paper introduced graph types, by which one can statically approximate the dependency graphs of a program in a language-independent fashion. By analyzing the graph type directly instead of the source code, a graph-based program analysis, such as one to detect deadlock, can be made language-independent. Indeed, the paper that proposed graph types also proposed a deadlock detection algorithm. Unfortunately, the algorithm was based on an unproven conjecture which we show to be false. In this paper, we present, and prove sound, a type system for finding possible deadlocks in programs that operates over graph types and can therefore be applied to many different languages. As a proof of concept, we have implemented the algorithm over a subset of the OCaml language extended with built-in futures.

+
+ + +

Recurrence Analysis for Automatic Parallelization of Subscripted Subscripts

  • Akshay Bhosale
  • Rudolf Eigenmann
+

Introducing correct and optimal OpenMP parallelization directives in applications is a challenge. To parallelize a loop in an input application code automatically, parallelizing compilers need to disprove dependences with respect to variables across iterations of the loop. Performing such dependence analysis in the presence of index arrays or subscripted subscripts - a[b[i]] - has long been a challenge for automatic parallelizers. Loops with subscripted subscripts can be parallelized if the subscript array is known to possess a property such as monotonicity. This paper presents a compiletime algorithm that can analyze complex recurrence relations and determine irregular or intermittent monotonicity of one-dimensional and monotonicity of multi-dimensional subscript arrays. The new algorithm builds on a prior approach that is capable of analyzing simple recurrence relations and determining monotonic one-dimensional subscript arrays. Experimental results show that automatic parallelizers equipped with our new analysis techniques can substantially improve the performance of ten out of twelve or 83.33% of the benchmarks evaluated, 25--33.33% more than possible with state-of-the-art compile-time automatic parallelization techniques.

+
+ +

SESSION: High Performance Computing

+

OsirisBFT: Say No to Task Replication for Scalable Byzantine Fault Tolerant Analytics

  • Kasra Jamshidi
  • Keval Vora
+

We present a verification-based Byzantine Fault Tolerant processing system, called OsirisBFT, for distributed task-parallel applications. OsirisBFT treats computation tasks differently from state update tasks, allowing the application to scale independently from number of expected failures. OsirisBFT captures application-specific verification semantics via generic verification operators and employs lightweight verification strategies with little coordination during graceful execution. Evaluation across multiple applications and workloads shows that OsirisBFT delivers high processing throughput and scalability compared to replicated processing. Importantly, the scalable nature of OsirisBFT enables it to reduce the performance gap compared to baseline with no fault tolerance by simply scaling out.

+
+ + +

Towards Scalable Unstructured Mesh Computations on Shared Memory Many-Cores

  • Haozhong Qiu
  • Chuanfu Xu
  • Jianbin Fang
  • Liang Deng
  • Jian Zhang
  • Qingsong Wang
  • Yue Ding
  • Zhe Dai
  • Yonggang Che
  • Shizhao Chen
  • Jie Liu
+

Due to data conflicts or data dependences, exploiting shared memory parallelism on unstructured mesh applications is highly challenging. The prior approaches are neither general nor scalable on emerging many-core processors. This paper presents a general and scalable shared memory approach for unstructured mesh computations. We recursively divide and reorder an unstructured mesh to construct a task dependency tree (TDT), where massive parallelism is exposed and data conflicts as well as data dependences are respected. We propose two recursion strategies to support popular programming models on both CPUs and GPUs for TDT. We evaluate our approach by applying it to an industrial unstructured Computational Fluid Dynamics (CFD) software. Experimental results show that our approach significantly outperforms the prior shared memory approaches, delivering up to 8.1× performance improvement over the engineer-tuned implementations.

+
+ + +

Extreme-scale Direct Numerical Simulation of Incompressible Turbulence on the Heterogeneous Many-core System

  • Jiabin Xie
  • Guangnan Feng
  • Han Huang
  • Junxuan Feng
  • Zhiguang Chen
  • Yutong Lu
+

Direct numerical simulation (DNS) is a technique that directly solves the fluid Navier-Stokes equations with high spatial and temporal resolutions, which has driven much research regarding the nature of turbulence. For high-Reynolds number (Re) incompressible turbulence of particular interest, where the nondimensional Re characterizes the flow regime, the application of DNS is hindered by the fact that the numerical grid size (i.e., the memory requirement) scales with Re3, while the overall computational cost scales with Re4. Recent studies have shown that developing efficient parallel methods for heterogeneous many-core systems is promising to solve this computational challenge.

+

We develop PowerLLEL++, a high-performance and scalable implicit finite difference solver for heterogeneous many-core systems, to accelerate the extreme-scale DNS of incompressible turbulence. To achieve this goal, an adaptive multi-level parallelization strategy is first proposed to fully exploit the multi-level parallelism and computing power of heterogeneous many-core systems. Second, hierarchical-memory-adapted data reuse/tiling strategy and kernel fusion are adopted to improve the performance of memory-bound stencil-like operations. Third, a parallel tridiagonal solver based on the parallel diagonal dominant (PDD) algorithm is developed to minimize the number of global data transposes. Fourth, three effective communication optimizations are implemented by Remote Direct Memory Access (RDMA) to maximize the performance of the remaining global transposes and halo exchange.

+

Results show that the solver exploits the heterogeneous computing power of the new Tianhe supercomputer and achieves a speedup of up to 10.6× (against the CPU-only performance). Linear strong scaling is obtained with a grid size of up to 25.8 billion.

+
+ + +

Pure: Evolving Message Passing To Better Leverage Shared Memory Within Nodes

  • James Psota
  • Armando Solar-Lezama
+

Pure is a new programming model and runtime system explicitly designed to take advantage of shared memory within nodes in the context of a mostly message passing interface enhanced with the ability to use tasks to make use of idle cores. Pure leverages shared memory in two ways: (a) by allowing cores to steal work from each other while waiting on messages to arrive, and, (b) by leveraging efficient lock-free data structures in shared memory to achieve high-performance messaging and collective operations between the ranks within nodes. We use microbenchmarks to evaluate Pure's key messaging and collective features and also show application speedups up to 2.1× on the CoMD molecular dynamics and the miniAMR adaptive mesh refinement applications scaling up to 4,096 cores.

+
+ +

SESSION: Graph Processing

+

INFINEL: An efficient GPU-based processing method for unpredictable large output graph queries

  • Sungwoo Park
  • Seyeon Oh
  • Min-Soo Kim
+

With the introduction of GPUs, which are specialized for iterative parallel computations, the execution of computation-intensive graph queries using a GPU has seen significant performance improvements. However, due to the memory constraints of GPUs, there has been limited research on handling large-scale output graph queries with unpredictable output sizes on a GPU. Traditionally, two-phase methods have been used, where the query is re-executed after splitting it into sub-tasks while only considering the size of the output in a static manner. However, two-phase methods become highly inefficient when used with graph data with extreme skew, failing to maximize the GPU performance. This paper proposes INFINEL, which handles unpredictable large output graph queries in a one-phase method through chunk allocation per thread and kernel stop/restart methods. We also propose applicable optimization techniques due to the corresponding unique characteristics of operating with low time/space overhead and not heavily relying on the GPU output buffer size. Through extensive experiments, we demonstrate that our one-phase method of INFINEL improves the performance by up to 31.5 times over the conventional two-phase methods for triangle listing ULO query.

+
+ + +

GraphCube: Interconnection Hierarchy-aware Graph Processing

  • Xinbiao Gan
  • Guang Wu
  • Shenghao Qiu
  • Feng Xiong
  • Jiaqi Si
  • Jianbin Fang
  • Dezun Dong
  • Chunye Gong
  • Tiejun Li
  • Zheng Wang
+

Processing large-scale graphs with billions to trillions of edges requires efficiently utilizing parallel systems. However, current graph processing engines do not scale well beyond a few tens of computing nodes because they are oblivious to the communication cost variations across the interconnection hierarchy. We introduce GraphCube, a better approach to optimizing graph processing on large-scale parallel systems with complex interconnections. GraphCube features a new graph partitioning approach to achieve better load balancing and minimize communication overhead across multiple levels of the interconnection hierarchy. We evaluate GraphCube by applying it to fundamental graph operations performed on synthetic and real-world graph datasets. Our evaluation used up to 79,024 computing nodes and 1.2+ million processor cores. Our large-scale experiments show that GraphCube outperforms state-of-the-art parallel graph processing methods in throughput and scalability. Furthermore, GraphCube outperformed the top-ranked systems on the Graph 500 list.

+
+ + +

Exploiting Fine-Grained Redundancy in Set-Centric Graph Pattern Mining

  • Zhiheng Lin
  • Ke Meng
  • Chaoyang Shui
  • Kewei Zhang
  • Junmin Xiao
  • Guangming Tan
+

Graph Pattern Mining (GPM) applications are memory intensive as they require a tremendous amount of edge checks. In recent years, the "set-centric" abstraction has gained attention for its powerful expressive abilities. By leveraging relational algebra, they optimized algorithms with methods like matching orders, early termination, automorphism-breaking, and result reuse to reduce redundancy. However, these approaches primarily address coarse-grained redundancy from exactly the same set formulas, neglecting that the data graph's inherent locality may lead to fine-grained duplicated edge checks. In fact, even unrelated set operations may check the same pair of vertices. This paper introduces the set union operation to the set-centric abstraction to fuse duplicated edge checks into one. It maintains the expressive power of relational algebra and previous optimizations while effectively avoids fine-grained redundancy in GPM tasks. Compared to state-of-the-art methods, our method achieves significant speedup on a V100 GPU cluster, demonstrating up to 305 × faster performance than the state-of-the-art GPM system G2Miner.

+
+ +

SESSION: Synchronization and Concurrency Control II

+

Memory Bounds for Concurrent Bounded Queues

  • Vitaly Aksenov
  • Nikita Koval
  • Petr Kuznetsov
  • Anton Paramonov
+

Concurrent data structures often require additional memory for handling synchronization issues in addition to memory for storing elements. Depending on the amount of this additional memory, implementations can be more or less memory-friendly. A memory-optimal implementation enjoys the minimal possible memory overhead, which, in practice, reduces cache misses and unnecessary memory reclamation.

+

In this paper, we discuss the memory-optimality of non-blocking bounded queues. Essentially, we investigate the possibility of constructing an implementation that utilizes a pre-allocated array to store elements and constant memory overhead, e.g., two positioning counters for enqueue(..) and dequeue() operations. Such an implementation can be readily constructed when the ABA problem is precluded, e.g., assuming that the hardware supports LL/SC instructions or all inserted elements are distinct. However, in the general case, we show that a memory-optimal non-blocking bounded queue incurs linear overhead in the number of concurrent processes. These results not only provide helpful intuition for concurrent algorithm developers but also open a new research avenue on the memory-optimality phenomenon in concurrent data structures.

+

The full version of this paper is available on arXiv [2].

+
+ + +

VERLIB: Concurrent Versioned Pointers

  • Guy E. Blelloch
  • Yuanhao Wei
+

Recent work has shown how to augment any CAS-based concurrent data structure to support taking a snapshot of the current memory state. Taking the snapshot, as well as loads and CAS (Compare and Swap) operations, take constant time. Importantly, such snapshotting can be used to easily implement linearizable queries, such as range queries, over any part of a data structure.

+

In this paper, we make two significant improvements over this approach. The first improvement removes a subtle and hard to reason about restriction that was needed to avoid a level of indirection on pointers. We introduce an approach, which we refer to as indirection-on-need, that removes the restriction, but yet almost always avoids indirection. The second improvement is to efficiently support snapshotting with lock-free locks. This requires supporting an idempotent CAS. We show a particularly simple solution to the problem that leverages the data structures used for snapshotting.

+

Based on these ideas we implemented an easy-to-use C++ library, verlib, centered around a versioned pointer type. The library works with lock (standard or lock-free) and CAS based algorithms, or any combination. Converting existing concurrent data-structures to use the library takes minimal effort. We present results for experiments that use verlib to convert state-of-the-art data structures for ordered maps (a B-tree), radix-ordered maps (an ART-tree), and unordered maps (an optimized hash table) to be snapshottable. The snapshottable versions perform almost as well as the original versions and far outperform any previous implementations that support atomic range queries.

+
+ + +

Practical Hardware Transactional vEB Trees

  • Mohammad Khalaji
  • Trevor Brown
  • Khuzaima Daudjee
  • Vitaly Aksenov
+

van Emde Boas (vEB) trees are sequential data structures optimized for extremely fast predecessor and successor queries. Such queries are an important incentive to use ordered sets or maps such as vEB trees. All operations in a vEB tree are doubly logarithmic in the universe size. Attempts to implement concurrent vEB trees have either simplified their structure in a way that eliminated their ability to perform fast predecessor and successor queries, or have otherwise compromised on doubly logarithmic complexity. In this work, we leverage Hardware Transactional Memory (HTM) to implement vEB tree-based sets and maps in which operations are doubly logarithmic in the absence of contention. Our proposed concurrent vEB tree is the first to implement recursive summaries, the key algorithmic component of fast predecessor and successor operations. Through extensive experiments, we demonstrate that our algorithm outperforms state-of-the-art concurrent maps by an average of 5× in a moderately skewed workload, and the single-threaded C++ standard ordered map and its unordered map by 70% and 14%, respectively. And, it does so while using two orders of magnitude less memory than traditional vEB trees.

+
+ +

SESSION: ML Workloads

+

Tetris: Accelerating Sparse Convolution by Exploiting Memory Reuse on GPU

  • Xiaoyan Liu
  • Xuegui Zheng
  • Hailong Yang
  • Zhongzhi Luan
  • Depei Qian
+

Convolutional neural networks (CNNs) have achieved remarkable success in various application fields. Although model compression techniques mitigate the ever-increasing resource demands of large CNN models, the compressed models usually exhibit irregular memory access and unstructured sparsity, which are difficult for dominant operators such as sparse convolution to achieve expected performance speedup on popular inference platforms such as GPU. In this paper, we propose Tetris, an efficient sparse convolution approach optimized for GPU. Tetris first fully exploits the input reuse opportunity of sparse convolution to reduce the memory accesses to global memory. It then adopts a stride packed filter (SPF) format and a bank-sensing reorganization scheme to eliminate the irregular memory accesses caused by unstructured sparsity. It also leverages a filter group reorder technique to address load imbalance among threads, and a parameter tuning method to determine the optimal parameters of the sparse convolution implementation. The experiment results show that Tetris outperforms dense/sparse convolution libraries and cutting-edge implementations with promising performance speedup.

+
+ + +

Shared Memory-contention-aware Concurrent DNN Execution for Diversely Heterogeneous System-on-Chips

  • Ismet Dagli
  • Mehmet E. Belviranli
+

Two distinguishing features of state-of-the-art mobile and autonomous systems are: 1) There are often multiple workloads, mainly deep neural network (DNN) inference, running concurrently and continuously. 2) They operate on shared memory System-on-Chips (SoC) that embed heterogeneous accelerators tailored for specific operations. State-of-the-art systems lack efficient performance and resource management techniques necessary to either maximize total system throughput or minimize end-to-end workload latency. In this work, we propose HaX-CoNN, a novel scheme that characterizes and maps layers in concurrently executing DNN inference workloads to a diverse set of accelerators within an SoC. Our scheme uniquely takes per-layer execution characteristics, shared memory (SM) contention, and inter-accelerator transitions into account to find optimal schedules. We evaluate HaX-CoNN on NVIDIA Orin, NVIDIA Xavier, and Qualcomm Snapdragon 865 SoCs. Our experimental results indicate that HaX-CoNN can minimize memory contention by up to 45% and improve total latency and throughput by up to 32% and 29%, respectively, compared to the state-of-the-art.

+
+ + +

Training one DeePMD Model in Minutes: a Step towards Online Learning

  • Siyu Hu
  • Tong Zhao
  • Qiuchen Sha
  • Enji Li
  • Xiangyu Meng
  • Liping Liu
  • Lin-Wang Wang
  • Guangming Tan
  • Weile Jia
+

Neural Network Molecular Dynamics (NNMD) has become a major approach in material simulations, which can speedup the molecular dynamics (MD) simulation for thousands of times, while maintaining ab initio accuracy, thus has a potential to fundamentally change the paradigm of material simulations. However, there are two time-consuming bottlenecks of the NNMD developments. One is the data access of ab initio calculation results. The other, which is the focus of the current work, is reducing the training time of NNMD model. The training of NNMD model is different from most other neural network training because the atomic force (which is related to the gradient of the network) is an important physical property to be fit. Tests show the traditional stochastic gradient methods, like the Adam algorithms, cannot efficiently deploy the multisample minibatch algorithm. As a result, a typical training (taking the Deep Potential Molecular Dynamics (DeePMD) as an example) can take many hours. In this work, we designed a heuristic minibatch quasi-Newtonian optimizer based on Extended Kalman Filter method. An early reduction of gradient and error is adopted to reduce memory footprint and communication. The memory footprint, communication and settings of hyper-parameters of this new method are analyzed in detail. Computational innovations such as customized kernels of the symmetry-preserving descriptor are applied to exploit the computing power of the heterogeneous architecture. Experiments are performed on 8 different datasets representing different real case situations, and numerical results show that our new method has an average speedup of 32.2 compared to the Reorganized Layer-wised Extended Kalman Filter with 1 GPU, reducing the absolute training time of one DeePMD model from hours to several minutes, making it one step toward online training.

+
+ +

SESSION: Parallel Algorithms

+

ParlayANN: Scalable and Deterministic Parallel Graph-Based Approximate Nearest Neighbor Search Algorithms

  • Magdalen Dobson Manohar
  • Zheqi Shen
  • Guy Blelloch
  • Laxman Dhulipala
  • Yan Gu
  • Harsha Vardhan Simhadri
  • Yihan Sun
+

Approximate nearest-neighbor search (ANNS) algorithms are a key part of the modern deep learning stack due to enabling efficient similarity search over high-dimensional vector space representations (i.e., embeddings) of data. Among various ANNS algorithms, graph-based algorithms are known to achieve the best throughput-recall tradeoffs. Despite the large scale of modern ANNS datasets, existing parallel graph-based implementations suffer from significant challenges to scale to large datasets due to heavy use of locks and other sequential bottlenecks, which 1) prevents them from efficiently scaling to a large number of processors, and 2) results in non-determinism that is undesirable in certain applications.

+

In this paper, we introduce ParlayANN, a library of deterministic and parallel graph-based approximate nearest neighbor search algorithms, along with a set of useful tools for developing such algorithms. In this library, we develop novel parallel implementations for four state-of-the-art graph-based ANNS algorithms that scale to billion-scale datasets. Our algorithms are deterministic and achieve high scalability across a diverse set of challenging datasets. In addition to the new algorithmic ideas, we also conduct a detailed experimental study of our new algorithms as well as two existing non-graph approaches. Our experimental results both validate the effectiveness of our new techniques, and lead to a comprehensive comparison among ANNS algorithms on large scale datasets with a list of interesting findings.

+
+ + +

Parallel k-Core Decomposition with Batched Updates and Asynchronous Reads

  • Quanquan C. Liu
  • Julian Shun
  • Igor Zablotchi
+

Maintaining a dynamic k-core decomposition is an important problem that identifies dense subgraphs in dynamically changing graphs. Recent work by Liu et al. [SPAA 2022] presents a parallel batch-dynamic algorithm for maintaining an approximate k-core decomposition. In their solution, both reads and updates need to be batched, and therefore each type of operation can incur high latency waiting for the other type to finish. To tackle most real-world workloads, which are dominated by reads, this paper presents a novel hybrid concurrent-parallel dynamic k-core data structure where asynchronous reads can proceed concurrently with batches of updates, leading to significantly lower read latencies. Our approach is based on tracking causal dependencies between updates, so that causally related groups of updates appear atomic to concurrent readers. Our data structure guarantees linearizability and liveness for both reads and updates, and maintains the same approximation guarantees as prior work. Our experimental evaluation on a 30-core machine shows that our approach reduces read latency by orders of magnitude compared to the batch-dynamic algorithm, up to a (4.05 · 105)-factor. Compared to an unsynchronized (non-linearizable) baseline, our read latency overhead is only up to a 3.21-factor greater, while improving accuracy of coreness estimates by up to a factor of 52.7.

+
+ + +

Parallel Integer Sort: Theory and Practice

  • Xiaojun Dong
  • Laxman Dhulipala
  • Yan Gu
  • Yihan Sun
+

Integer sorting is a fundamental problem in computer science. This paper studies parallel integer sort both in theory and in practice. In theory, we show tighter bounds for a class of existing practical integer sort algorithms, which provides a solid theoretical foundation for their widespread usage in practice and strong performance. In practice, we design a new integer sorting algorithm, DovetailSort, that is theoretically-efficient and has good practical performance.

+

In particular, DovetailSort overcomes a common challenge in existing parallel integer sorting algorithms, which is the difficulty of detecting and taking advantage of duplicate keys. The key insight in DovetailSort is to combine algorithmic ideas from both integer- and comparison-sorting algorithms. In our experiments, DovetailSort achieves competitive or better performance than existing state-of-the-art parallel integer and comparison sorting algorithms on various synthetic and real-world datasets.

+
+ + +

Fast American Option Pricing using Nonlinear Stencils

  • Zafar Ahmad
  • Reilly Browne
  • Rezaul Chowdhury
  • Rathish Das
  • Yushen Huang
  • Yimin Zhu
+

We study the binomial, trinomial, and Black-Scholes-Merton models of option pricing. We present fast parallel discrete-time finite-difference algorithms for American call option pricing under the binomial and trinomial models and American put option pricing under the Black-Scholes-Merton model. For T-step finite differences, each algorithm runs in O (T log2 T)/p + T) time under a greedy scheduler on p processing cores, which is a significant improvement over the Θ (T2/p) + Ω (T log T) time taken by the corresponding state-of-the-art parallel algorithm. Even when run on a single core, the O (T log2 T) time taken by our algorithms is asymptotically much smaller than the Θ (T2) running time of the fastest known serial algorithms. Implementations of our algorithms significantly outperform the fastest implementations of existing algorithms in practice, e.g., when run for T ≈ 1000 steps on a 48-core machine, our algorithm for the binomial model runs at least 15× faster than the fastest existing parallel program for the same model with the speedup factor gradually reaching beyond 500× for T ≈ 0.5 × 106. It saves more than 80% energy when T ≈ 4000, and more than 99% energy for T > 60,000.

+

Our algorithms can be viewed as solving a class of nonlinear 1D stencil (i.e., finite-difference) computation problems efficiently using the Fast Fourier Transform (FFT). To our knowledge, ours are the first algorithms to handle such stencils in o (T2) time. These contributions are of independent interest as stencil computations have a wide range of applications beyond quantitative finance.

+
+ +

SESSION: Optimizing for Memory

+

ConvStencil: Transform Stencil Computation to Matrix Multiplication on Tensor Cores

  • Yuetao Chen
  • Kun Li
  • Yuhao Wang
  • Donglin Bai
  • Lei Wang
  • Lingxiao Ma
  • Liang Yuan
  • Yunquan Zhang
  • Ting Cao
  • Mao Yang
+

Tensor Core Unit (TCU) is increasingly integrated into modern high-performance processors to enhance matrix multiplication performance. However, constrained to its over-specification, its potential for improving other critical scientific operations like stencil computations remains untapped.

+

This paper presents ConvStencil1, a novel stencil computing system designed to efficiently transform stencil computation to matrix multiplication on Tensor Cores. We first develop a performance model for ConvStencil to guide algorithm design and optimization on TCUs. Based on this model, we propose three techniques: (1) Memory-efficient Layout Transformation using the stencil2row method; (2) Computation-dense Compute Adaptation with Dual Tessellation and kernel fusion; and (3) Performance-boosting Conflict Removal using a Lookup Table and Dirty Bits Padding. ConvStencil outperforms other stencil optimization frameworks, achieving significant speedups compared to solutions like AMOS, cuDNN, Brick, DRStencil, and TCStencil. By transforming stencil computation on Tensor Cores, ConvStencil promises to improve the performance of various scientific and engineering applications.

+
+ + +

CPMA: An Efficient Batch-Parallel Compressed Set Without Pointers

  • Brian Wheatman
  • Randal Burns
  • Aydin Buluc
  • Helen Xu
+

This paper introduces the batch-parallel Compressed Packed Memory Array (CPMA), a compressed, dynamic, ordered set data structure based on the Packed Memory Array (PMA). Traditionally, batch-parallel sets are built on pointer-based data structures such as trees because pointer-based structures enable fast parallel unions via pointer manipulation. When compared with cache-optimized trees, PMAs were slower to update but faster to scan.

+

The batch-parallel CPMA overcomes this tradeoff between updates and scans by optimizing for cache-friendliness. On average, the CPMA achieves 3× faster batch-insert throughput and 4× faster range-query throughput compared with compressed PaC-trees, a state-of-the-art batch-parallel set library based on cache-optimized trees.

+

We further evaluate the CPMA compared with compressed PaC-trees and Aspen, a state-of-the-art system, on a real-world application of dynamic-graph processing. The CPMA is on average 1.2× faster on a suite of graph algorithms and 2× faster on batch inserts when compared with compressed PaC-trees. Furthermore, the CPMA is on average 1.3× faster on graph algorithms and 2× faster on batch inserts compared with Aspen.

+
+ + +

Gallatin: A General-Purpose GPU Memory Manager

  • Hunter Mccoy
  • Prashant Pandey
+

Dynamic memory management is critical for efficiently porting modern data processing pipelines to GPUs. However, building a general-purpose dynamic memory manager on GPUs is challenging due to the massive parallelism and weak memory coherence. Existing state-of-the-art GPU memory managers, Ouroboros and Reg-Eff, employ traditional data structures such as arrays and linked lists to manage memory objects. They build specialized pipelines to achieve performance for a fixed set of allocation sizes and fall back to the CUDA allocator for allocating large sizes. In the process, they lose general-purpose usability and fail to support critical applications such as streaming graph processing.

+

In this paper, we introduce Gallatin, a general-purpose and high-performance GPU memory manager. Gallatin uses the van Emde Boas (vEB) tree data structure to manage memory objects efficiently and supports allocations of any size. Furthermore, we develop a highly-concurrent GPU implementation of the vEB tree which can be broadly used in other GPU applications. It supports constant time insertions, deletions, and successor operations for a given memory size.

+

In our evaluation, we compare Gallatin with state-of-the-art specialized allocator variants. Gallatin is up to 374× faster on single-sized allocations and up to 264× faster on mixed-size allocations than the next-best allocator. In scalability benchmarks, Gallatin is up to 254× times faster than the next-best allocator as the number of threads increases. For the graph benchmarks, Gallatin is 1.5× faster than the state-of-the-art for bulk insertions, slightly faster for bulk deletions, and is 3× faster than the next-best allocator for all graph expansion tests.

+
+ +

SESSION: Linear Algebra

+

A Row Decomposition-based Approach for Sparse Matrix Multiplication on GPUs

  • Meng Pang
  • Xiang Fei
  • Peng Qu
  • Youhui Zhang
  • Zhaolin Li
+

Sparse-Matrix Dense-Matrix Multiplication (SpMM) and Sampled Dense Dense Matrix Multiplication (SDDMM) are important sparse kernels in various computation domains. The uneven distribution of nonzeros in the sparse matrix and the tight data dependence between sparse and dense matrices make it a challenge to run sparse matrix multiplication efficiently on GPUs. By analyzing the aforementioned problems, we propose a row decomposition (RoDe)-based approach to optimize the two kernels on GPUs, using the standard Compressed Sparse Row (CSR) format. Specifically, RoDe divides the sparse matrix rows into regular parts and residual parts, to fully optimize their computations separately. We also devise the corresponding load balancing and finegrained pipelining technologies. Profiling results show that RoDe can achieve more efficient memory access and reduce warp stall cycles significantly. Compared to the state-of-the-art (SOTA) alternatives, RoDe achieves a speedup of up to 7.86× with a geometric mean of 1.45× for SpMM, and a speedup of up to 8.99× with a geometric mean of 1.49× for SDDMM; the dataset is SuiteSparse. RoDe also outperforms its counterpart in the deep learning dataset. Furthermore, its preprocessing overhead is significantly smaller, averaging only 16% of the SOTA.

+
+ + +

Fast Kronecker Matrix-Matrix Multiplication on GPUs

  • Abhinav Jangda
  • Mohit Yadav
+

Kronecker Matrix-Matrix Multiplication (Kron-Matmul) is the multiplication of a matrix with the Kronecker Product of several smaller matrices. Kron-Matmul is a core operation for many scientific and machine learning computations. State-of-the-art Kron-Matmul implementations utilize existing tensor algebra operations, such as matrix multiplication, transpose, and tensor matrix multiplication. However, this design choice prevents several Kron-Matmul specific optimizations, thus, leaving significant performance on the table.

+

To address this issue, we present FastKron, an efficient technique for Kron-Matmul on single and multiple GPUs. FastKron is independent of linear algebra operations enabling several new optimizations for Kron-Matmul. Thus, it performs up to 40.7× and 7.85× faster than existing implementations on 1 and 16 GPUs respectively.

+
+ + +

Arrow Matrix Decomposition: A Novel Approach for Communication-Efficient Sparse Matrix Multiplication

  • Lukas Gianinazzi
  • Alexandros Nikolaos Ziogas
  • Langwen Huang
  • Piotr Luczynski
  • Saleh Ashkboosh
  • Florian Scheidl
  • Armon Carigiet
  • Chio Ge
  • Nabil Abubaker
  • Maciej Besta
  • Tal Ben-Nun
  • Torsten Hoefler
+

We propose a novel approach to iterated sparse matrix dense matrix multiplication, a fundamental computational kernel in scientific computing and graph neural network training. In cases where matrix sizes exceed the memory of a single compute node, data transfer becomes a bottleneck. An approach based on dense matrix multiplication algorithms leads to sub-optimal scalability and fails to exploit the sparsity in the problem. To address these challenges, we propose decomposing the sparse matrix into a small number of highly structured matrices called arrow matrices, which are connected by permutations. Our approach enables communication-avoiding multiplications, achieving a polynomial reduction in communication volume per iteration for matrices corresponding to planar graphs and other minor-excluded families of graphs. Our evaluation demonstrates that our approach outperforms a state-of-the-art method for sparse matrix multiplication on matrices with hundreds of millions of rows, offering near-linear strong and weak scaling.

+
+ +

SESSION: Applications

+

FastFold: Optimizing AlphaFold Training and Inference on GPU Clusters

  • Shenggan Cheng
  • Xuanlei Zhao
  • Guangyang Lu
  • Jiarui Fang
  • Tian Zheng
  • Ruidong Wu
  • Xiwen Zhang
  • Jian Peng
  • Yang You
+

Protein structure prediction helps to understand gene translation and protein function, which is of growing interest and importance in structural biology. The AlphaFold model, which used transformer architecture to achieve atomic-level accuracy in protein structure prediction, was a significant breakthrough. However, training and inference of AlphaFold model are challenging due to its high computation and memory cost. In this work, we present FastFold, an efficient implementation of AlphaFold for both training and inference. We propose Dynamic Axial Parallelism (DAP) as a novel model parallelism method. Additionally, we have implemented a series of low-level optimizations aimed at reducing communication, computation, and memory costs. These optimizations include Duality Async Operations, highly optimized kernels, and AutoChunk (an automated search algorithm finds the best chunk strategy to reduce memory peaks). Experimental results show that FastFold can efficiently scale to more GPUs using DAP and reduces overall training time from 11 days to 67 hours and achieves 7.5 ~ 9.5× speedup for long-sequence inference. Furthermore, AutoChunk can reduce memory cost by over 80% during inference by automatically partitioning the intermediate tensors during the computation.

+
+ + +

AGAThA: Fast and Efficient GPU Acceleration of Guided Sequence Alignment for Long Read Mapping

  • Seongyeon Park
  • Junguk Hong
  • Jaeyong Song
  • Hajin Kim
  • Youngsok Kim
  • Jinho Lee
+

With the advance in genome sequencing technology, the lengths of deoxyribonucleic acid (DNA) sequencing results are rapidly increasing at lower prices than ever. However, the longer lengths come at the cost of a heavy computational burden on aligning them. For example, aligning sequences to a human reference genome can take tens or even hundreds of hours. The current de facto standard approach for alignment is based on the guided dynamic programming method. Although this takes a long time and could potentially benefit from high-throughput graphic processing units (GPUs), the existing GPU-accelerated approaches often compromise the algorithm's structure, due to the GPU-unfriendly nature of the computational pattern. Unfortunately, such compromise in the algorithm is not tolerable in the field, because sequence alignment is a part of complicated bioinformatics analysis pipelines. In such circumstances, we propose AGAThA, an exact and efficient GPU-based acceleration of guided sequence alignment. We diagnose and address the problems of the algorithm being unfriendly to GPUs, which comprises strided/redundant memory accesses and workload imbalances that are difficult to predict. According to the experiments on modern GPUs, AGAThA achieves 18.8× speedup against the CPU-based baseline, 9.6× against the best GPU-based baseline, and 3.6× against GPU-based algorithms with different heuristics.

+
+ +

POSTER SESSION: Posters

+

POSTER: Accelerating High-Precision Integer Multiplication used in Cryptosystems with GPUs

  • Zhuoran Ji
  • Zhaorui Zhang
  • Jiming Xu
  • Lei Ju
+

High-precision integer multiplication is crucial in privacy-preserving computational techniques but poses acceleration challenges on GPUs due to its complexity and the diverse bit lengths in cryptosystems. This paper introduces GIM, an efficient high-precision integer multiplication algorithm accelerated with GPUs. It employs a novel segmented integer multiplication algorithm that separates implementation details from bit length, facilitating code optimizations. We also present a computation diagram to analyze parallelization strategies, leading to a series of enhancements. Experiments demonstrate that this approach achieves a 4.47× speedup over the commonly used baseline.

+
+ + +

POSTER: Enabling Extreme-Scale Phase Field Simulation with In-situ Feature Extraction

  • Zhichen Feng
  • Jialin Li
  • Yaqian Gao
  • Shaobo Tian
  • Huang Ye
  • Jian Zhang
+

In this paper, we present an integrated framework composed of a highly efficient phase field simulator and an in-situ feature extraction library. This novel framework enables us to conduct extreme-scale micro-structure evolution simulations while the characteristic features of each individual grain are extracted on the fly. After systematic design and optimization on the new generation Sunway supercomputer, the code scales up to 39 million cores and achieves 582 PFlops in double precision and 637 POps in mixed precision.

+
+ + +

POSTER: FineCo: Fine-grained Heterogeneous Resource Management for Concurrent DNN Inferences

  • Lixian Ma
  • Haoruo Chen
  • En Shao
  • Leping Wang
  • Quan Chen
  • Guangming Tan
+

Co-locating multiple DNN servings to share GPU resource is widely used to improve resource utilization while guaranteeing user QoS. Existing GPU sharing mechanism is restricted to model level, and fluctuations in kernel-level resource demands highlight a suboptimal utilization of the current sharing mechanism. We design a multi-DNN serving system, FineCo, that leverages a novel fine-grained resource sharing mechanism to optimize concurrent inference without modifications to the hardware or operating system. Our prototype implementation demonstrates that FineCo achieves up to 40% throughput improvement over the state-of-the-art work.

+
+ + +

POSTER: Optimizing Collective Communications with Error-bounded Lossy Compression for GPU Clusters

  • Jiajun Huang
  • Sheng Di
  • Xiaodong Yu
  • Yujia Zhai
  • Jinyang Liu
  • Yafan Huang
  • Ken Raffenetti
  • Hui Zhou
  • Kai Zhao
  • Zizhong Chen
  • Franck Cappello
  • Yanfei Guo
  • Rajeev Thakur
+

GPU-aware collective communication has become a major bottleneck for modern computing platforms as GPU computing power rapidly rises. To address this issue, traditional approaches integrate lossy compression directly into GPU-aware collectives, which still suffer from serious issues such as underutilized GPU devices and uncontrolled data distortion. In this paper, we propose GPU-LCC, a general framework that designs and optimizes GPU-aware, compression-enabled collectives with well-controlled error propagation. To validate our framework, we evaluate the performance on up to 64 NVIDIA A100 GPUs with real-world applications and datasets. Experimental results demonstrate that our GPU-LCC-accelerated collective computation (Allreduce), can outperform NCCL as well as Cray MPI by up to 3.4× and 18.7×, respectively. Furthermore, our accuracy evaluation with an image-stacking application confirms the high reconstructed data quality of our accuracy-aware framework.

+
+ + +

POSTER: Optimizing Sparse Tensor Contraction with Revisiting Hash Table Design

  • Guofeng Feng
  • Weile Jia
  • Ninghui Sun
  • Guangming Tan
  • Jiajia Li
+

Sparse tensor contraction (SpTC) serves as an essential operation in high-performance applications. The high dimensionality of sparse tensors makes SpTC fundamentally challenging in aspects such as costly multidimensional index search, extensive intermediate output data, and indirect addressing. Previous state-of-the-art work addresses some of these challenges through hash-table implementation. In this paper, we propose a hash-table based and fully optimized SpTC by providing a more carefully designed customized hash table design, proposing an architecture-aware algorithm for hash table selection with size prediction, applying cross-stage optimizations to exploit shared information and avoid redundant operations. Evaluating on a set of tensors extracted from the real world, our method can achieve superior speedup and reduce the memory footprint substantially compared to the current state-of-the-art work.

+
+ + +

POSTER: LLM-PQ:Serving LLM on Heterogeneous Clusters with Phase-Aware Partition and Adaptive Quantization

  • Juntao Zhao
  • Borui Wan
  • Chuan Wu
  • Yanghua Peng
  • Haibin Lin
+

The immense sizes of Large-scale language models (LLMs) have led to high resource demand and cost for running the models. Though the models are largely served using uniform high-caliber GPUs nowadays, utilizing a heterogeneous cluster with a mix of available high- and low-capacity GPUs can potentially substantially reduce the serving cost. This paper proposes LLM-PQ, a system that advocates adaptive model quantization and phase-aware partition to improve LLM serving efficiency on heterogeneous GPU clusters. Extensive experiments on production inference workloads demonstrate throughput improvement in inference, showing great advantages over state-of-the-art works.

+
+ + +

POSTER: OCToPus: Semantic-aware Concurrency Control for Blockchain Transactions

  • dePaul Miller
  • Henry F. Korth
  • Roberto Palmieri
+

Many blockchain implementations offer APIs to send and receive money between accounts exclusively. In this paper, we introduce OCToPus, a deterministic concurrency control scheme that uses a semantic-aware fast path and a GPU-accelerated directed acyclic graph-based fallback path to parallelize the execution of a block aggressively.

+
+ + +

POSTER: Pattern-Aware Sparse Communication for Scalable Recommendation Model Training

  • Jiaao He
  • Shengqi Chen
  • Jidong Zhai
+

Recommendation models are an important category of deep learning models whose size is growing enormous. They consist of a sparse part with TBs of memory footprint and a dense part that demands PFLOPs of computing capability to train. Unfortunately, the high sparse communication cost to re-organize data for different parallel strategies of the two parts impedes the scalability in training.

+

Based on observations of sparse access patterns, we design a two-fold fine-grained parallel strategy to accelerate sparse communication. A performance model is built to select an optimal set of items that are replicated across all GPUs so that all-to-all communication volume is reduced, while keeping memory consumption acceptable. The all-to-all overhead is further reduced by parallel scheduling techniques. In our evaluation on 32 GPUs over real-world datasets, 2.16 -- 16.8× end-to-end speedup is achieved over the baselines.

+
+ + +

POSTER: ParGNN: Efficient Training for Large-Scale Graph Neural Network on GPU Clusters

  • Shunde Li
  • Junyu Gu
  • Jue Wang
  • Tiechui Yao
  • Zhiqiang Liang
  • Yumeng Shi
  • Shigang Li
  • Weiting Xi
  • Shushen Li
  • Chunbao Zhou
  • Yangang Wang
  • Xuebin Chi
+

Full-batch graph neural network (GNN) training is essential for interdisciplinary applications. Large-scale graph data is usually divided into subgraphs and distributed across multiple compute units to train GNN. The state-of-the-art load balancing method based on direct graph partition is too rough to effectively achieve true load balancing on GPU clusters. We propose ParGNN, which employs a profiler-guided load balance workflow in conjunction with graph repartition to alleviate load imbalance and minimize communication traffic. Experiments have verified that ParGNN has the capability to scale to larger clusters.

+
+ + +

POSTER: RadiK: Scalable Radix Top-K Selection on GPUs

  • Yifei Li
  • Bole Zhou
  • Jiejing Zhang
  • Xuechao Wei
  • Yinghan Li
  • Yingda Chen
+

By identifying the k largest or smallest elements in a set of data, top-k selection is critical for modern high-performance databases and machine learning systems, especially with large data volumes. However, previous studies on its GPU implementation are mostly merge-based and rely heavily on the high-speed but size-limited on-chip memory, thereby resulting in a restricted upper bound on k. This paper introduces RadiK, a highly optimized GPU-parallel radix top-k selection that is scalable with k, input length, and batch size. With a carefully designed optimization framework targeting high memory bandwidth and resource utilization, RadiK supports far larger k than the prior art, achieving up to 2.5× speedup for non-batch queries and up to 4.8× speedup for batch queries. We also propose a lightweight refinement that strengthens the robustness of RadiK against skewed distributions by adaptively scaling the input elements.

+
+ + +

POSTER: RELAX: Durable Data Structures with Swift Recovery

  • Almog Zur
  • Nachshon Cohen
  • Michal Friedman
  • Erez Petrank
+

Recent non-volatile main memory technology gave rise to an abundance of research on building persistent data structures, whose content can be recovered after a system crash. While there has been significant progress in making durable data structures efficient, shortening the length of the recovery phase after a crash has not received much attention. In this paper we present the RELAX general transformation. RELAX generates lock-free durable data structures that provide the best of both worlds: almost zero recovery time and high performance.

+
+ + +

POSTER: StructMG: A Fast and Scalable Structured Multigrid

  • Yi Zong
  • Xinliang Wang
  • Haopeng Huang
  • Chensong Zhang
  • Xiaowen Xu
  • Jian Sun
  • Bowen Yan
  • Qin Wang
  • Sicong Li
  • Zhaohui Ding
  • Wei Xue
+

Parallel multigrid is widely used as preconditioners in solving large-scale sparse linear systems. However, the current multigrid library still needs more satisfactory performance for structured grid problems regarding speed and scalability. To this end, we design and implement StructMG, a fast and scalable multigrid that constructs hierarchical grids automatically based on the original matrix. As a preconditioner, StructMG can achieve both low cost per iteration and good convergence. Two idealized and five real-world problems from four application fields, including radiation hydrodynamics, petroleum reservoir simulation, numerical weather prediction, and solid mechanics, are evaluated on ARM and X86 platforms. In comparison to hypre's multigrid preconditioners, StructMG achieves the fastest time-to-solutions in all cases with average speedups of 17.6x, 5.7x, 4.6x, 8.5x over SMG, PFMG, SysPFMG, and BoomerAMG, respectively. Additionally, StructMG significantly improves strong and weak scaling efficiencies in most tests.

+
+ +
\ No newline at end of file diff --git a/_data/OpenTOC.yaml b/_data/OpenTOC.yaml index 57bff15..75943cb 100644 --- a/_data/OpenTOC.yaml +++ b/_data/OpenTOC.yaml @@ -1361,3 +1361,11 @@ event: PEPM year: 2024 title: "Proceedings of the 2024 ACM SIGPLAN International Workshop on Partial Evaluation and Program Manipulation" +- + event: PPoPP + year: 2024 + title: "Proceedings of the 29th ACM SIGPLAN Annual Symposium on Principles and Practice of Parallel Programming" +- + event: CC + year: 2024 + title: "Proceedings of the 33rd ACM SIGPLAN International Conference on Compiler Construction" From a6186d24237619a845ec4f87cbf4369b1c8859b8 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Thu, 14 Mar 2024 09:08:46 -0400 Subject: [PATCH 45/64] PMAM TOC --- OpenTOC/pmam24.html | 112 ++++++++++++++++++++++++++++++++++++++++++++ _data/OpenTOC.yaml | 4 ++ 2 files changed, 116 insertions(+) create mode 100644 OpenTOC/pmam24.html diff --git a/OpenTOC/pmam24.html b/OpenTOC/pmam24.html new file mode 100644 index 0000000..5b6a26c --- /dev/null +++ b/OpenTOC/pmam24.html @@ -0,0 +1,112 @@ +PMAM '24: Proceedings of the 15th International Workshop on Programming Models and Applications for Multicores and Manycores

PMAM '24: Proceedings of the 15th International Workshop on Programming Models and Applications for Multicores and Manycores

+ Full Citation in the ACM Digital Library +
+

Acceleration of the Pre-processing Stage of the MVS Workflow using Graphics Processors

  • Roberto Díaz-Cano Lozano
  • Francesc Folch
  • Pedro Alonso-Jordá
  • Enrique S. Quintana-Ortí
+

Migrating CPU code to the CUDA programming language has been a challenge for some time. While the code for many high-performance and massively data-parallel applications has been successfully ported to GPUs, this task has received comparatively less attention for other applications that do not lend themselves so well to the characteristics of GPUs. Among the latter are applications of particular value to industry, where the use of GPUs can significantly improve the productivity of the system as a whole.

This article presents a real-world, industrial use case that shows (part of) a complex computer vision workflow. The processes in the workflow have low arithmetic intensity and work with simple data (integers). The main challenge is therefore to minimise the overhead of data transfers between the host and the GPU, or even within the memory of the device itself. While the speed-up achieved may not be as impressive as for applications that are perfectly tuned to the GPU architecture, the algorithms and data distribution proposed in this work allow a significant part of the overall workflow to be offloaded to the GPU, freeing the CPU to process other components of the workflow. As a result, this approach has a significant impact on the productivity and economic performance of the company.

+
+ + +

Automatic Static Analysis-Guided Optimization of CUDA Kernels

  • Mark Lou
  • Stefan K. Muller
+

We propose a framework for using static resource analysis to guide the automatic optimization of general-purpose GPU (GPGPU) kernels written in CUDA, NVIDIA's framework for GPGPU programming. In our proposed framework, optimizations are applied to the kernel and candidate kernels are evaluated for performance by running a static analysis that predicts the execution cost of GPU kernels. The use of static analysis, in contrast to many existing frameworks for performance tuning GPU kernels, lends itself to high-level, hardware-independent optimizations that can be of particular benefit to novice programmers unfamiliar with CUDA's performance pitfalls. As a proof of concept, we have implemented two example optimizations and a simple search strategy in a tool called COpPER (CUDA Optimization through Programmatic Estimation of Resources), which makes use of a static resource analysis tool for CUDA from prior work. The prototype tool automatically improves the performance of sample kernels by 2-4% in initial experiments, and demonstrates the feasibility of using static analysis as part of automated performance tuning for GPU kernels.

+
+ + +

MUPPET: Optimizing Performance in OpenMP via Mutation Testing

  • Dolores Miao
  • Ignacio Laguna
  • Giorgis Georgakoudis
  • Konstantinos Parasyris
  • Cindy Rubio-González
+

Performance optimization continues to be a challenge in modern HPC software. Existing performance optimization techniques, including profiling-based and auto-tuning techniques, fail to indicate program modifications at the source level thus preventing their portability across compilers. This paper describes Muppet, a new approach that identifies program modifications called mutations aimed at improving program performance. Muppet's mutations help developers reason about performance defects and missed opportunities to improve performance at the source code level. In contrast to compiler techniques that optimize code at intermediate representations (IR), Muppet uses the idea of source-level mutation testing to relax correctness constraints and automatically discover optimization opportunities that otherwise are not feasible using the IR. We demonstrate the Muppet's concept in the OpenMP programming model. Muppet generates a list of OpenMP mutations that alter the program parallelism in various ways, and is capable of running a variety of optimization algorithms such as Bayesian Optimization and delta debugging to find a subset of mutations which, when applied to the original program, cause the most speedup while maintaining program correctness. When Muppet is evaluated against a diverse set of benchmark programs and proxy applications, it is capable of finding sets of mutations in 70% of the evaluated programs that induce speedup.

+
+ + +

Parallel Pattern Language Code Generation

  • Adrian Schmitz
  • Julian Miller
  • Semih Burak
  • Matthias S. Müller
+

Memory and power constraints limit the current landscape of high-performance computing. Hardware specializations in clusters lead to heterogeneity, Non-Uniform Memory Architecture (NUMA) effects, and accelerator offloading. These increase the complexity of developing and optimizing scientific software.

To ease these challenges for domain scientists, the code generator for a prototype of the Parallel Pattern Language (PPL) is implemented, enabling its evaluation. The proof of concept uses parallel patterns to define parallelism and apply static global optimizations automatically. Most notably, an assignment between tasklets and the provided heterogeneous cluster architecture is calculated during compile time, the new code generator creates a source file combining shared-memory, distributed-memory, and accelerator offloading according to the generated mapping.

The prototype successfully optimizes and compiles most Rodinia benchmarks. Six Rodinia benchmarks already show significant speedups. The tools limitations include dynamic algorithms that are challenging to analyze statically and overheads during the compile time optimization.

+
+ + +

Pure C++ Approach to Optimized Parallel Traversal of Regular Data Structures

  • Jiří Klepl
  • Adam Šmelko
  • Lukáš Rozsypal
  • Martin Kruliš
+

Many computational problems consider memory throughput a performance bottleneck. The problem becomes even more pronounced in the case of parallel platforms, where the ratio between computing elements and memory bandwidth shifts towards computing. Software needs to be attuned to hardware features like cache architectures or memory banks to reach a decent level of performance efficiency. This can be achieved by selecting the right memory layouts for data structures or changing the order of data structure traversal. In this work, we present an abstraction for traversing a set of regular data structures (e.g., multidimensional arrays) that allows the design of traversal-agnostic algorithms. Such algorithms can be adjusted for particular memory layouts of the data structures, semi-automated parallelization, or autotuning without altering their internal code. The proposed solution was implemented as an extension of the Noarr library that simplifies a layout-agnostic design of regular data structures. It is implemented entirely using C++ template meta-programming without any nonstandard dependencies, so it is fully compatible with existing compilers, including CUDA NVCC. We evaluate the performance and expressiveness of our approach on the Polybench-C benchmarks.

+
+ + +

Zero-Overhead Parallel Scans for Multi-Core CPUs

  • Ivo Gabe de Wolff
  • David P. van Balen
  • Gabriele K. Keller
  • Trevor L. McDonell
+

We present three novel parallel scan algorithms for multi-core CPUs which do not need to fix the number of available cores at the start, and have zero overhead compared to sequential scans when executed on a single core. These two properties are in contrast with most existing parallel scan algorithms, which are asymptotically optimal, but have a constant factor overhead compared to sequential scans when executed on a single core. We achieve these properties by adapting the classic three-phase scan algorithms. The resulting algorithms also exhibit better performance than the original ones on multiple cores. Furthermore, we adapt the chained scan with decoupled look-back algorithm to also have these two properties. While this algorithm was originally designed for GPUs, we show it is also suitable for multi-core CPUs, outperforming the classic three-phase scans in our benchmarks, by better using the caches of the processor at the cost of more synchronisation. In general our adaptive chained scan is the fastest parallel scan, but in specific situations our assisted reduce-then-scan is better.

+
+ +
\ No newline at end of file diff --git a/_data/OpenTOC.yaml b/_data/OpenTOC.yaml index 75943cb..571b2cc 100644 --- a/_data/OpenTOC.yaml +++ b/_data/OpenTOC.yaml @@ -1369,3 +1369,7 @@ event: CC year: 2024 title: "Proceedings of the 33rd ACM SIGPLAN International Conference on Compiler Construction" +- + event: PMAM + year: 2024 + title: "Proceedings of the 15th International Workshop on Programming Models and Applications for Multicores and Manycores" From 2e0049cf76abfdccff39694c1a4ad22f4b07c13b Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Thu, 14 Mar 2024 09:09:30 -0400 Subject: [PATCH 46/64] New PPoPP 2014 TOC --- OpenTOC/ppopp14.html | 1303 +++++++++++------------------------------- 1 file changed, 328 insertions(+), 975 deletions(-) diff --git a/OpenTOC/ppopp14.html b/OpenTOC/ppopp14.html index c12d54e..4f2edbc 100644 --- a/OpenTOC/ppopp14.html +++ b/OpenTOC/ppopp14.html @@ -1,975 +1,328 @@ - - - - - -PPoPP '14- Proceedings of the 19th ACM SIGPLAN symposium on Principles and practice of parallel programming - - - - - - -
-
-

PPoPP '14- Proceedings of the 19th ACM SIGPLAN symposium on Principles and practice of parallel programming

- Full Citation in the ACM Digital Library -
-
-

SESSION: Session order 1: opening and conference keynote address

-

- - - 21st century computer architecture - -

- -
    - -
  • Mark D. Hill
    • - -
-

SESSION: Session order 2: bugs session

-
    - -
  • Madan Musuvathi
    • - -
- -

- - - PREDATOR: predictive false sharing detection - -

- -
    - -
  • Tongping Liu
    • - -
  • Chen Tian
    • - -
  • Ziang Hu
    • - -
  • Emery D. Berger
    • - -
- -

- - - Concurrency testing using schedule bounding: an empirical study - -

- -
    - -
  • Paul Thomson
    • - -
  • Alastair F. Donaldson
    • - -
  • Adam Betts
    • - -
- -

- - - Trace driven dynamic deadlock detection and reproduction - -

- -
    - -
  • Malavika Samak
    • - -
  • Murali Krishna Ramanathan
    • - -
- -

- - - Efficient search for inputs causing high floating-point errors - -

- -
    - -
  • Wei-Fan Chiang
    • - -
  • Ganesh Gopalakrishnan
    • - -
  • Zvonimir Rakamaric
    • - -
  • Alexey Solovyev
    • - -
-

SESSION: Session order 3: HPC session

-
    - -
  • Milind Kulkarni
    • - -
- -

- - - X10 and APGAS at Petascale - -

- -
    - -
  • Olivier Tardieu
    • - -
  • Benjamin Herta
    • - -
  • David Cunningham
    • - -
  • David Grove
    • - -
  • Prabhanjan Kambadur
    • - -
  • Vijay Saraswat
    • - -
  • Avraham Shinnar
    • - -
  • Mikio Takeuchi
    • - -
  • Mandana Vaziri
    • - -
- -

- - - Resilient X10: efficient failure-aware programming - -

- -
    - -
  • David Cunningham
    • - -
  • David Grove
    • - -
  • Benjamin Herta
    • - -
  • Arun Iyengar
    • - -
  • Kiyokuni Kawachiya
    • - -
  • Hiroki Murata
    • - -
  • Vijay Saraswat
    • - -
  • Mikio Takeuchi
    • - -
  • Olivier Tardieu
    • - -
- -

- - - Portable, MPI-interoperable coarray fortran - -

- -
    - -
  • Chaoran Yang
    • - -
  • Wesley Bland
    • - -
  • John Mellor-Crummey
    • - -
  • Pavan Balaji
    • - -
-

SESSION: Session order 4: GPU session

-
    - -
  • Chen Ding
    • - -
- -

- - - CUDA-NP: realizing nested thread-level parallelism in GPGPU applications - -

- -
    - -
  • Yi Yang
    • - -
  • Huiyang Zhou
    • - -
- -

- - - yaSpMV: yet another SpMV framework on GPUs - -

- -
    - -
  • Shengen Yan
    • - -
  • Chao Li
    • - -
  • Yunquan Zhang
    • - -
  • Huiyang Zhou
    • - -
- -

- - - Singe: leveraging warp specialization for high performance on GPUs - -

- -
    - -
  • Michael Bauer
    • - -
  • Sean Treichler
    • - -
  • Alex Aiken
    • - -
-

SESSION: Session order 5: synchronization session

-
    - -
  • Ganesh Gopalakrishnan
    • - -
- -

- - - Eliminating global interpreter locks in ruby through hardware transactional memory - -

- -
    - -
  • Rei Odaira
    • - -
  • Jose G. Castanos
    • - -
  • Hisanobu Tomari
    • - -
- -

- - - Leveraging hardware message passing for efficient thread synchronization - -

- -
    - -
  • Darko Petrović
    • - -
  • Thomas Ropars
    • - -
  • André Schiper
    • - -
- -

- - - Well-structured futures and cache locality - -

- -
    - -
  • Maurice Herlihy
    • - -
  • Zhiyu Liu
    • - -
- -

- - - Time-warp: lightweight abort minimization in transactional memory - -

- -
    - -
  • Nuno Diegues
    • - -
  • Paolo Romano
    • - -
-

SESSION: Session order 6: PPoPP keynote address

-

- - - Beyond parallel programming with domain specific languages - -

- -
    - -
  • Kunle Olukotun
    • - -
-

SESSION: Session order 7: algorithms session

-
    - -
  • Virendra J. Marathe
    • - -
- -

- - - Designing and auto-tuning parallel 3-D FFT for computation-communication overlap - -

- -
    - -
  • Sukhyun Song
    • - -
  • Jeffrey K. Hollingsworth
    • - -
- -

- - - A decomposition for in-place matrix transposition - -

- -
    - -
  • Bryan Catanzaro
    • - -
  • Alexander Keller
    • - -
  • Michael Garland
    • - -
- -

- - - In-place transposition of rectangular matrices on accelerators - -

- -
    - -
  • I-Jui Sung
    • - -
  • Juan Gómez-Luna
    • - -
  • José María González-Linares
    • - -
  • Nicolás Guil
    • - -
  • Wen-Mei W. Hwu
    • - -
- -

- - - Parallelizing dynamic programming through rank convergence - -

- -
    - -
  • Saeed Maleki
    • - -
  • Madanlal Musuvathi
    • - -
  • Todd Mytkowicz
    • - -
-

SESSION: Session order 8: programming systems session

-
    - -
  • Kunle Olukotun
    • - -
- -

- - - Revisiting loop fusion in the polyhedral framework - -

- -
    - -
  • Sanyam Mehta
    • - -
  • Pei-Hung Lin
    • - -
  • Pen-Chung Yew
    • - -
- -

- - - Triolet: a programming system that unifies algorithmic skeleton interfaces for high-performance cluster computing - -

- -
    - -
  • Christopher Rodrigues
    • - -
  • Thomas Jablin
    • - -
  • Abdul Dakkak
    • - -
  • Wen-Mei Hwu
    • - -
- -

- - - A tool to analyze the performance of multithreaded programs on NUMA architectures - -

- -
    - -
  • Xu Liu
    • - -
  • John Mellor-Crummey
    • - -
-

SESSION: Session order 9: scheduling and determinism session

-
    - -
  • Chen Wenguang
    • - -
- -

- - - Towards fair and efficient SMP virtual machine scheduling - -

- -
    - -
  • Jia Rao
    • - -
  • Xiaobo Zhou
    • - -
- -

- - - Efficient deterministic multithreading without global barriers - -

- -
    - -
  • Kai Lu
    • - -
  • Xu Zhou
    • - -
  • Tom Bergan
    • - -
  • Xiaoping Wang
    • - -
- -

- - - Race directed scheduling of concurrent programs - -

- -
    - -
  • Mahdi Eslamimehr
    • - -
  • Jens Palsberg
    • - -
-

SESSION: Session order 10: conference keynote address

-

- - - Heterogeneous computing: what does it mean for compiler research? - -

- -
    - -
  • Norm Rubin
    • - -
-

SESSION: Session order 11: non-blocking data structures session

-
    - -
  • James Larus
    • - -
- -

- - - Fast concurrent lock-free binary search trees - -

- -
    - -
  • Aravind Natarajan
    • - -
  • Neeraj Mittal
    • - -
- -

- - - A general technique for non-blocking trees - -

- -
    - -
  • Trevor Brown
    • - -
  • Faith Ellen
    • - -
  • Eric Ruppert
    • - -
- -

- - - Practical concurrent binary search trees via logical ordering - -

- -
    - -
  • Dana Drachsler
    • - -
  • Martin Vechev
    • - -
  • Eran Yahav
    • - -
- -

- - - A practical wait-free simulation for lock-free data structures - -

- -
    - -
  • Shahar Timnat
    • - -
  • Erez Petrank
    • - -
-

POSTER SESSION: Session order 11: poster session

-

- - - Lock contention aware thread migrations - -

- -
    - -
  • Kishore Kumar Pusukuri
    • - -
  • Rajiv Gupta
    • - -
  • Laxmi Narayan Bhuyan
    • - -
- -

- - - Infrastructure-free logging and replay of concurrent execution on multiple cores - -

- -
    - -
  • Kyu Hyung Lee
    • - -
  • Dohyeong Kim
    • - -
  • Xiangyu Zhang
    • - -
- -

- - - Parallelization hints via code skeletonization - -

- -
    - -
  • Cfir Aguston
    • - -
  • Yosi Ben Asher
    • - -
  • Gadi Haber
    • - -
- -

- - - Concurrency bug localization using shared memory access pairs - -

- -
    - -
  • Wenwen Wang
    • - -
  • Chenggang Wu
    • - -
  • Pen-Chung Yew
    • - -
  • Xiang Yuan
    • - -
  • Zhenjiang Wang
    • - -
  • Jianjun Li
    • - -
  • Xiaobing Feng
    • - -
- -

- - - Task mapping stencil computations for non-contiguous allocations - -

- -
    - -
  • Vitus J. Leung
    • - -
  • David P. Bunde
    • - -
  • Jonathan Ebbers
    • - -
  • Stefan P. Feer
    • - -
  • Nickolas W. Price
    • - -
  • Zachary D. Rhodes
    • - -
  • Matthew Swank
    • - -
- -

- - - Data structures for task-based priority scheduling - -

- -
    - -
  • Martin Wimmer
    • - -
  • Francesco Versaci
    • - -
  • Jesper Larsson Träff
    • - -
  • Daniel Cederman
    • - -
  • Philippas Tsigas
    • - -
- -

- - - Detecting silent data corruption through data dynamic monitoring for scientific applications - -

- -
    - -
  • Leonardo Bautista Gomez
    • - -
  • Franck Cappello
    • - -
- -

- - - Fine-grain parallel megabase sequence comparison with multiple heterogeneous GPUs - -

- -
    - -
  • Edans F. de O. Sandes
    • - -
  • Guillermo Miranda
    • - -
  • Alba C.M.A. Melo
    • - -
  • Xavier Martorell
    • - -
  • Eduard Ayguade
    • - -
- -

- - - Automatic semantic locking - -

- -
    - -
  • Guy Golan-Gueta
    • - -
  • G. Ramalingam
    • - -
  • Mooly Sagiv
    • - -
  • Eran Yahav
    • - -
- -

- - - Optimistic transactional boosting - -

- -
    - -
  • Ahmed Hassan
    • - -
  • Roberto Palmieri
    • - -
  • Binoy Ravindran
    • - -
- -

- - - Provably good scheduling for parallel programs that use data structures through implicit batching - -

- -
    - -
  • Kunal Agrawal
    • - -
  • Jeremy T. Fineman
    • - -
  • Brendan Sheridan
    • - -
  • Jim Sukha
    • - -
  • Robert Utterback
    • - -
- -

- - - Theoretical analysis of classic algorithms on highly-threaded many-core GPUs - -

- -
    - -
  • Lin Ma
    • - -
  • Kunal Agrawal
    • - -
  • Roger D. Chamberlain
    • - -
- -

- - - SCCMulti: an improved parallel strongly connected components algorithm - -

- -
    - -
  • Daniel Tomkins
    • - -
  • Timmie Smith
    • - -
  • Nancy M. Amato
    • - -
  • Lawrence Rauchwerger
    • - -
- -

- - - Initial study of multi-endpoint runtime for MPI+OpenMP hybrid programming model on multi-core systems - -

- -
    - -
  • Miao Luo
    • - -
  • Xiaoyi Lu
    • - -
  • Khaled Hamidouche
    • - -
  • Krishna Kandalla
    • - -
  • Dhabaleswar K. Panda
    • - -
- -

- - - Extracting logical structure and identifying stragglers in parallel execution traces - -

- -
    - -
  • Katherine E. Isaacs
    • - -
  • Todd Gamblin
    • - -
  • Abhinav Bhatele
    • - -
  • Peer-Timo Bremer
    • - -
  • Martin Schulz
    • - -
  • Bernd Hamann
    • - -
- -
-
- - - +PPoPP '14: Proceedings of the 19th ACM SIGPLAN symposium on Principles and practice of parallel programming

PPoPP '14: Proceedings of the 19th ACM SIGPLAN symposium on Principles and practice of parallel programming

+ Full Citation in the ACM Digital Library +

SESSION: Session order 1: opening and conference keynote address

+

21st century computer architecture

  • Mark D. Hill
+

This talk has two parts. The first part will discuss possible directions for computer architecture research, including architecture as infrastructure, energy first, impact of new technologies, and cross-layer opportunities. This part is based on a 2012 Computing Community Consortium (CCC) whitepaper effort led by Hill, as well as other recent National Academy and ISAT studies. See: http://cra.org/ccc/docs/init/21stcenturyarchitecturewhitepaper.pdf. The second part of the talk will discuss one or more exam-ples of cross-layer research advocated in the first part. For example, our analysis shows that many "big-memory" server workloads, such as databases, in-memory caches, and graph analytics, pay a high cost for page-based virtual memory: up to 50% of execution time wasted. Via small changes to the operating system (Linux) and hardware (x86-64 MMU), this work reduces execution time these workloads waste to less than 0.5%. The key idea is to map part of a process's linear virtual address space with a new incarnation of segmentation, while providing compatibility by mapping the rest of the virtual address space with pag-ing.

+
+ +

SESSION: Session order 2: bugs session

+

Session details: Session order 2: bugs session

  • Madan Musuvathi
+ +

PREDATOR: predictive false sharing detection

  • Tongping Liu
  • Chen Tian
  • Ziang Hu
  • Emery D. Berger
+

False sharing is a notorious problem for multithreaded applications that can drastically degrade both performance and scalability. Existing approaches can precisely identify the sources of false sharing, but only report false sharing actually observed during execution; they do not generalize across executions. Because false sharing is extremely sensitive to object layout, these detectors can easily miss false sharing problems that can arise due to slight differences in memory allocation order or object placement decisions by the compiler. In addition, they cannot predict the impact of false sharing on hardware with different cache line sizes.

This paper presents PREDATOR, a predictive software-based false sharing detector. PREDATOR generalizes from a single execution to precisely predict false sharing that is latent in the current execution. PREDATOR tracks accesses within a range that could lead to false sharing given different object placement. It also tracks accesses within virtual cache lines, contiguous memory ranges that span actual hardware cache lines, to predict sharing on hardware platforms with larger cache line sizes. For each, it reports the exact program location of predicted false sharing problems, ranked by their projected impact on performance. We evaluate PREDATOR across a range of benchmarks and actual applications. PREDATOR identifies problems undetectable with previous tools, including two previously-unknown false sharing problems, with no false positives. PREDATOR is able to immediately locate false sharing problems in MySQL and the Boost library that had eluded detection for years.

+
+ + +

Concurrency testing using schedule bounding: an empirical study

  • Paul Thomson
  • Alastair F. Donaldson
  • Adam Betts
+

We present the first independent empirical study on schedule bounding techniques for systematic concurrency testing (SCT). We have gathered 52 buggy concurrent software benchmarks, drawn from public code bases, which we call SCTBench. We applied a modified version of an existing concurrency testing tool to SCTBench to attempt to answer several research questions, including: How effective are the two main schedule bounding techniques, preemption bounding and delay bounding, at bug finding? What challenges are associated with applying SCT to existing code? How effective is schedule bounding compared to a naive random scheduler at finding bugs? Our findings confirm that delay bounding is superior to preemption bounding and that schedule bounding is more effective at finding bugs than unbounded depth-first search. The majority of bugs in SCTBench can be exposed using a small bound (1-3), supporting previous claims, but there is at least one benchmark that requires 5 preemptions. Surprisingly, we found that a naive random scheduler is at least as effective as schedule bounding for finding bugs. We have made SCTBench and our tools publicly available for reproducibility and use in future work.

+
+ + +

Trace driven dynamic deadlock detection and reproduction

  • Malavika Samak
  • Murali Krishna Ramanathan
+

Dynamic analysis techniques have been proposed to detect potential deadlocks. Analyzing and comprehending each potential deadlock to determine whether the deadlock is feasible in a real execution requires significant programmer effort. Moreover, empirical evidence shows that existing analyses are quite imprecise. This imprecision of the analyses further void the manual effort invested in reasoning about non-existent defects.

In this paper, we address the problems of imprecision of existing analyses and the subsequent manual effort necessary to reason about deadlocks. We propose a novel approach for deadlock detection by designing a dynamic analysis that intelligently leverages execution traces. To reduce the manual effort, we replay the program by making the execution follow a schedule derived based on the observed trace. For a real deadlock, its feasibility is automatically verified if the replay causes the execution to deadlock.

We have implemented our approach as part of WOLF and have analyzed many large (upto 160KLoC) Java programs. Our experimental results show that we are able to identify 74% of the reported defects as true (or false) positives automatically leaving very few defects for manual analysis. The overhead of our approach is negligible making it a compelling tool for practical adoption.

+
+ + +

Efficient search for inputs causing high floating-point errors

  • Wei-Fan Chiang
  • Ganesh Gopalakrishnan
  • Zvonimir Rakamaric
  • Alexey Solovyev
+

Tools for floating-point error estimation are fundamental to program understanding and optimization. In this paper, we focus on tools for determining the input settings to a floating point routine that maximizes its result error. Such tools can help support activities such as precision allocation, performance optimization, and auto-tuning. We benchmark current abstraction-based precision analysis methods, and show that they often do not work at scale, or generate highly pessimistic error estimates, often caused by non-linear operators or complex input constraints that define the set of legal inputs. We show that while concrete-testing-based error estimation methods based on maintaining shadow values at higher precision can search out higher error-inducing inputs, suit able heuristic search guidance is key to finding higher errors. We develop a heuristic search algorithm called Binary Guided Random Testing (BGRT). In 45 of the 48 total benchmarks, including many real-world routines, BGRT returns higher guaranteed errors. We also evaluate BGRT against two other heuristic search methods called ILS and PSO, obtaining better results.

+
+ +

SESSION: Session order 3: HPC session

+

Session details: Session order 3: HPC session

  • Milind Kulkarni
+ +

X10 and APGAS at Petascale

  • Olivier Tardieu
  • Benjamin Herta
  • David Cunningham
  • David Grove
  • Prabhanjan Kambadur
  • Vijay Saraswat
  • Avraham Shinnar
  • Mikio Takeuchi
  • Mandana Vaziri
+

X10 is a high-performance, high-productivity programming language aimed at large-scale distributed and shared-memory parallel applications. It is based on the Asynchronous Partitioned Global Address Space (APGAS) programming model, supporting the same fine-grained concurrency mechanisms within and across shared-memory nodes.

We demonstrate that X10 delivers solid performance at petascale by running (weak scaling) eight application kernels on an IBM Power 775 supercomputer utilizing up to 55,680 Power7 cores (for 1.7 Pflop/s of theoretical peak performance). We detail our advances in distributed termination detection, distributed load balancing, and use of high-performance interconnects that enable X10 to scale out to tens of thousands of cores.

For the four HPC Class 2 Challenge benchmarks, X10 achieves 41% to 87% of the system's potential at scale (as measured by IBM's HPCC Class 1 optimized runs). We also implement K-Means, Smith-Waterman, Betweenness Centrality, and Unbalanced Tree Search (UTS) for geometric trees. Our UTS implementation is the first to scale to petaflop systems.

+
+ + +

Resilient X10: efficient failure-aware programming

  • David Cunningham
  • David Grove
  • Benjamin Herta
  • Arun Iyengar
  • Kiyokuni Kawachiya
  • Hiroki Murata
  • Vijay Saraswat
  • Mikio Takeuchi
  • Olivier Tardieu
+

Scale-out programs run on multiple processes in a cluster. In scale-out systems, processes can fail. Computations using traditional libraries such as MPI fail when any component process fails. The advent of Map Reduce, Resilient Data Sets and MillWheel has shown dramatic improvements in productivity are possible when a high-level programming framework handles scale-out and resilience automatically.

We are concerned with the development of general-purpose languages that support resilient programming. In this paper we show how the X10 language and implementation can be extended to support resilience. In Resilient X10, places may fail asynchronously, causing loss of the data and tasks at the failed place. Failure is exposed through exceptions. We identify a {\em Happens Before Invariance Principle} and require the runtime to automatically repair the global control structure of the program to maintain this principle. We show this reduces much of the burden of resilient programming. The programmer is only responsible for continuing execution with fewer computational resources and the loss of part of the heap, and can do so while taking advantage of domain knowledge.

We build a complete implementation of the language, capable of executing benchmark applications on hundreds of nodes. We describe the algorithms required to make the language runtime resilient. We then give three applications, each with a different approach to fault tolerance (replay, decimation, and domain-level checkpointing). These can be executed at scale and survive node failure. We show that for these programs the overhead of resilience is a small fraction of overall runtime by comparing to equivalent non-resilient X10 programs. On one program we show end-to-end performance of Resilient X10 is ~100x faster than Hadoop.

+
+ + +

Portable, MPI-interoperable coarray fortran

  • Chaoran Yang
  • Wesley Bland
  • John Mellor-Crummey
  • Pavan Balaji
+

The past decade has seen the advent of a number of parallel programming models such as Coarray Fortran (CAF), Unified Parallel C, X10, and Chapel. Despite the productivity gains promised by these models, most parallel scientific applications still rely on MPI as their data movement model. One reason for this trend is that it is hard for users to incrementally adopt these new programming models in existing MPI applications. Because each model use its own runtime system, they duplicate resources and are potentially error-prone. Such independent runtime systems were deemed necessary because MPI was considered insufficient in the past to play this role for these languages.

The recently released MPI-3, however, adds several new capabilities that now provide all of the functionality needed to act as a runtime, including a much more comprehensive one-sided communication framework. In this paper, we investigate how MPI-3 can form a runtime system for one example programming model, CAF, with a broader goal of enabling a single application to use both MPI and CAF with the highest level of interoperability.

+
+ +

SESSION: Session order 4: GPU session

+

Session details: Session order 4: GPU session

  • Chen Ding
+ +

CUDA-NP: realizing nested thread-level parallelism in GPGPU applications

  • Yi Yang
  • Huiyang Zhou
+

Parallel programs consist of series of code sections with different thread-level parallelism (TLP). As a result, it is rather common that a thread in a parallel program, such as a GPU kernel in CUDA programs, still contains both se-quential code and parallel loops. In order to leverage such parallel loops, the latest Nvidia Kepler architecture intro-duces dynamic parallelism, which allows a GPU thread to start another GPU kernel, thereby reducing the overhead of launching kernels from a CPU. However, with dynamic parallelism, a parent thread can only communicate with its child threads through global memory and the overhead of launching GPU kernels is non-trivial even within GPUs. In this paper, we first study a set of GPGPU benchmarks that contain parallel loops, and highlight that these bench-marks do not have a very high loop count or high degrees of TLP. Consequently, the benefits of leveraging such par-allel loops using dynamic parallelism are too limited to offset its overhead. We then present our proposed solution to exploit nested parallelism in CUDA, referred to as CUDA-NP. With CUDA-NP, we initially enable a high number of threads when a GPU program starts, and use control flow to activate different numbers of threads for different code sections. We implemented our proposed CUDA-NP framework using a directive-based compiler approach. For a GPU kernel, an application developer only needs to add OpenMP-like pragmas for parallelizable code sections. Then, our CUDA-NP compiler automatically gen-erates the optimized GPU kernels. It supports both the reduction and the scan primitives, explores different ways to distribute parallel loop iterations into threads, and effi-ciently manages on-chip resource. Our experiments show that for a set of GPGPU benchmarks, which have already been optimized and contain nested parallelism, our pro-posed CUDA-NP framework further improves the perfor-mance by up to 6.69 times and 2.18 times on average.

+
+ + +

yaSpMV: yet another SpMV framework on GPUs

  • Shengen Yan
  • Chao Li
  • Yunquan Zhang
  • Huiyang Zhou
+

SpMV is a key linear algebra algorithm and has been widely used in many important application domains. As a result, numerous attempts have been made to optimize SpMV on GPUs to leverage their massive computational throughput. Although the previous work has shown impressive progress, load imbalance and high memory bandwidth remain the critical performance bottlenecks for SpMV. In this paper, we present our novel solutions to these problems. First, we devise a new SpMV format, called blocked compressed common coordinate (BCCOO), which uses bit flags to store the row indices in a blocked common coordinate (COO) format so as to alleviate the bandwidth problem. We further improve this format by partitioning the matrix into vertical slices to enhance the cache hit rates when accessing the vector to be multiplied. Second, we revisit the segmented scan approach for SpMV to address the load imbalance problem. We propose a highly efficient matrix-based segmented sum/scan for SpMV and further improve it by eliminating global synchronization. Then, we introduce an auto-tuning framework to choose optimization parameters based on the characteristics of input sparse matrices and target hardware platforms. Our experimental results on GTX680 GPUs and GTX480 GPUs show that our proposed framework achieves significant performance improvement over the vendor tuned CUSPARSE V5.0 (up to 229% and 65% on average on GTX680 GPUs, up to 150% and 42% on average on GTX480 GPUs) and some most recently proposed schemes (e.g., up to 195% and 70% on average over clSpMV on GTX680 GPUs, up to 162% and 40% on average over clSpMV on GTX480 GPUs).

+
+ + +

Singe: leveraging warp specialization for high performance on GPUs

  • Michael Bauer
  • Sean Treichler
  • Alex Aiken
+

We present Singe, a Domain Specific Language (DSL) compiler for combustion chemistry that leverages warp specialization to produce high performance code for GPUs. Instead of relying on traditional GPU programming models that emphasize data-parallel computations, warp specialization allows compilers like Singe to partition computations into sub-computations which are then assigned to different warps within a thread block. Fine-grain synchronization between warps is performed efficiently in hardware using producer-consumer named barriers. Partitioning computations using warp specialization allows Singe to deal efficiently with the irregularity in both data access patterns and computation. Furthermore, warp-specialized partitioning of computations allows Singe to fit extremely large working sets into on-chip memories. Finally, we describe the architecture and general compilation techniques necessary for constructing a warp-specializing compiler. We show that the warp-specialized code emitted by Singe is up to 3.75X faster than previously optimized data-parallel GPU kernels.

+
+ +

SESSION: Session order 5: synchronization session

+

Session details: Session order 5: synchronization session

  • Ganesh Gopalakrishnan
+ +

Eliminating global interpreter locks in ruby through hardware transactional memory

  • Rei Odaira
  • Jose G. Castanos
  • Hisanobu Tomari
+

Many scripting languages use a Global Interpreter Lock (GIL) to simplify the internal designs of their interpreters, but this kind of lock severely lowers the multi-thread per-formance on multi-core machines. This paper presents our first results eliminating the GIL in Ruby using Hardware Transactional Memory (HTM) in the IBM zEnterprise EC12 and Intel 4th Generation Core processors. Though prior prototypes replaced a GIL with HTM, we tested real-istic programs, the Ruby NAS Parallel Benchmarks (NPB), the WEBrick HTTP server, and Ruby on Rails. We devised a new technique to dynamically adjust the transaction lengths on a per-bytecode basis, so that we can optimize the likelihood of transaction aborts against the relative overhead of the instructions to begin and end the transactions. Our results show that HTM achieved 1.9- to 4.4-fold speedups in the NPB programs over the GIL with 12 threads, and 1.6- and 1.2-fold speedups in WEBrick and Ruby on Rails, respectively. The dynamic transaction-length adjustment chose the best transaction lengths for any number of threads and applications with sufficiently long running times.

+
+ + +

Leveraging hardware message passing for efficient thread synchronization

  • Darko Petrović
  • Thomas Ropars
  • André Schiper
+

As the level of parallelism in manycore processors keeps increasing, providing efficient mechanisms for thread synchronization in concurrent programs is becoming a major concern. On cache-coherent shared-memory processors, synchronization efficiency is ultimately limited by the performance of the underlying cache coherence protocol. This paper studies how hardware support for message passing can improve synchronization performance. Considering the ubiquitous problem of mutual exclusion, we adapt two state-of-the-art solutions used on shared-memory processors, namely the server approach and the combining approach, to leverage the potential of hardware message passing. We propose HybComb, a novel combining algorithm that uses both message passing and shared memory features of emerging hybrid processors. We also introduce MP-Server, a straightforward adaptation of the server approach to hardware message passing. Evaluation on Tilera's TILE-Gx processor shows that MP-Server can execute contended critical sections with unprecedented throughput, as stalls related to cache coherence are removed from the critical path. HybComb can achieve comparable performance, while avoiding the need to dedicate server cores. Consequently, our queue and stack implementations, based on MP-Server and HybComb, largely outperform their most efficient pure-shared-memory counterparts.

+
+ + +

Well-structured futures and cache locality

  • Maurice Herlihy
  • Zhiyu Liu
+

In fork-join parallelism, a sequential program is split into a directed acyclic graph of tasks linked by directed dependency edges, and the tasks are executed, possibly in parallel, in an order consistent with their dependencies. A popular and effective way to extend fork-join parallelism is to allow threads to create futures. A thread creates a future to hold the results of a computation, which may or may not be executed in parallel. That result is returned when some thread touches that future, blocking if necessary until the result is ready. Recent research has shown that while futures can, of course, enhance parallelism in a structured way, they can have a deleterious effect on cache locality. In the worst case, futures can incur Ω(P T∞ + t T∞) deviations, which implies Ω(C P T∞ + C t T∞) additional cache misses, where C is the number of cache lines, P is the number of processors, t is the number of touches, and T∞ is the computation span. Since cache locality has a large impact on software performance on modern multicores, this result is troubling.

In this paper, however, we show that if futures are used in a simple, disciplined way, then the situation is much better: if each future is touched only once, either by the thread that created it, or by a later descendant of the thread that created it, then parallel executions with work stealing can incur at most O(C P T2∞) additional cache misses, a substantial improvement. This structured use of futures is characteristic of many (but not all) parallel applications.

+
+ + +

Time-warp: lightweight abort minimization in transactional memory

  • Nuno Diegues
  • Paolo Romano
+

The notion of permissiveness in Transactional Memory (TM) translates to only aborting a transaction when it cannot be accepted in any history that guarantees correctness criterion. This property is neglected by most TMs, which, in order to maximize implementation's efficiency, resort to aborting transactions under overly conservative conditions. In this paper we seek to identify a sweet spot between permissiveness and efficiency by introducing the Time-Warp Multi-version algorithm (TWM). TWM is based on the key idea of allowing an update transaction that has performed stale reads (i.e., missed the writes of concurrently committed transactions) to be serialized by committing it in the past, which we call a time-warp commit. At its core, TWM uses a novel, lightweight validation mechanism with little computational overheads. TWM also guarantees that read-only transactions can never be aborted. Further, TWM guarantees Virtual World Consistency, a safety property that is deemed as particularly relevant in the context of TM. We demonstrate the practicality of this approach through an extensive experimental study, where we compare TWM with four other TMs, and show an average performance improvement of 65% in high concurrency scenarios.

+
+ +

SESSION: Session order 6: PPoPP keynote address

+

Beyond parallel programming with domain specific languages

  • Kunle Olukotun
+

Today, almost all computer architectures are parallel and heterogeneous; a combination of multiple CPUs, GPUs and specialized processors. This creates a challenging problem for application developers who want to develop high performance programs without the effort required to use low-level, architecture specific parallel programming models (e.g. OpenMP for CMPs, CUDA for GPUs, MPI for clusters). Domain-specific languages (DSLs) are a promising solution to this problem because they can provide an avenue for high-level application-specific abstractions with implicit parallelism to be mapped directly to low level architecture-specific programming models; providing both high programmer productivity and high execution performance.

In this talk I will describe an approach to building high performance DSLs, which is based on DSL embedding in a general purpose programming language, metaprogramming and a DSL infrastructure called Delite. I will describe how we transform DSL programs into efficient first-order low-level code using domain specific optimization, parallelism and locality optimization with parallel patterns, and architecture-specific code generation. All optimizations and transformations are implemented in Delite: an extensible DSL compiler infrastucture that significantly reduces the effort required to develop new DSLs. Delite DSLs for machine learning, data querying, graph analysis, and scientific computing all achieve performance competitive with manually parallelized C++ code.

+
+ +

SESSION: Session order 7: algorithms session

+

Session details: Session order 7: algorithms session

  • Virendra J. Marathe
+ +

Designing and auto-tuning parallel 3-D FFT for computation-communication overlap

  • Sukhyun Song
  • Jeffrey K. Hollingsworth
+

This paper presents a method to design and auto-tune a new parallel 3-D FFT code using the non-blocking MPI all-to-all operation. We achieve high performance by optimizing computation-communication overlap. Our code performs fully asynchronous communication without any support from special hardware. We also improve cache performance through loop tiling. To cope with the complex trade-off regarding our optimization techniques, we parameterize our code and auto-tune the parameters efficiently in a large parameter space. Experimental results from two systems confirm that our code achieves a speedup of up to 1.76x over the FFTW library.

+
+ + +

A decomposition for in-place matrix transposition

  • Bryan Catanzaro
  • Alexander Keller
  • Michael Garland
+

We describe a decomposition for in-place matrix transposition, with applications to Array of Structures memory accesses on SIMD processors. Traditional approaches to in-place matrix transposition involve cycle following, which is difficult to parallelize, and on matrices of dimension m by n require O(mn log mn) work when limited to less than O(mn) auxiliary space. Our decomposition allows the rows and columns to be operated on independently during in-place transposition, reducing work complexity to O(mn), given O(max(m, n)) auxiliary space. This decomposition leads to an efficient and naturally parallel algorithm: we have measured median throughput of 19.5 GB/s on an NVIDIA Tesla K20c processor. An implementation specialized for the skinny matrices that arise when converting Arrays of Structures to Structures of Arrays yields median throughput of 34.3 GB/s, and a maximum throughput of 51 GB/s.

Because of the simple structure of this algorithm, it is particularly suited for implementation using SIMD instructions to transpose the small arrays that arise when SIMD processors load from or store to Arrays of Structures. Using this algorithm to cooperatively perform accesses to Arrays of Structures, we measure 180 GB/s throughput on the K20c, which is up to 45 times faster than compiler-generated Array of Structures accesses.

In this paper, we explain the algorithm, prove its correctness and complexity, and explain how it can be instantiated efficiently for solving various transpose problems on both CPUs and GPUs.

+
+ + +

In-place transposition of rectangular matrices on accelerators

  • I-Jui Sung
  • Juan Gómez-Luna
  • José María González-Linares
  • Nicolás Guil
  • Wen-Mei W. Hwu
+

Matrix transposition is an important algorithmic building block for many numeric algorithms such as FFT. It has also been used to convert the storage layout of arrays. With more and more algebra libraries offloaded to GPUs, a high performance in-place transposition becomes necessary. Intuitively, in-place transposition should be a good fit for GPU architectures due to limited available on-board memory capacity and high throughput. However, direct application of CPU in-place transposition algorithms lacks the amount of parallelism and locality required by GPUs to achieve good performance. In this paper we present the first known in-place matrix transposition approach for the GPUs. Our implementation is based on a novel 3-stage transposition algorithm where each stage is performed using an elementary tiled-wise transposition. Additionally, when transposition is done as part of the memory transfer between GPU and host, our staged approach allows hiding transposition overhead by overlap with PCIe transfer. We show that the 3-stage algorithm allows larger tiles and achieves 3X speedup over a traditional 4-stage algorithm, with both algorithms based on our high-performance elementary transpositions on the GPU. We also show our proposed low-level optimizations improve the sustained throughput to more than 20 GB/s. Finally, we propose an asynchronous execution scheme that allows CPU threads to delegate in-place matrix transposition to GPU, achieving a throughput of more than 3.4 GB/s (including data transfers costs), and improving current multithreaded implementations of in-place transposition on CPU.

+
+ + +

Parallelizing dynamic programming through rank convergence

  • Saeed Maleki
  • Madanlal Musuvathi
  • Todd Mytkowicz
+

This paper proposes an efficient parallel algorithm for an important class of dynamic programming problems that includes Viterbi, Needleman-Wunsch, Smith-Waterman, and Longest Common Subsequence. In dynamic programming, the subproblems that do not depend on each other, and thus can be computed in parallel, form stages or wavefronts. The algorithm presented in this paper provides additional parallelism allowing multiple stages to be computed in parallel despite dependences among them. The correctness and the performance of the algorithm relies on rank convergence properties of matrix multiplication in the tropical semiring, formed with plus as the multiplicative operation and max as the additive operation.

This paper demonstrates the efficiency of the parallel algorithm by showing significant speed ups on a variety of important dynamic programming problems. In particular, the parallel Viterbi decoder is up-to 24x faster (with 64 processors) than a highly optimized commercial baseline.

+
+ +

SESSION: Session order 8: programming systems session

+

Session details: Session order 8: programming systems session

  • Kunle Olukotun
+ +

Revisiting loop fusion in the polyhedral framework

  • Sanyam Mehta
  • Pei-Hung Lin
  • Pen-Chung Yew
+

Loop fusion is an important compiler optimization for improving memory hierarchy performance through enabling data reuse. Traditional compilers have approached loop fusion in a manner decoupled from other high-level loop optimizations, missing several interesting solutions. Recently, the polyhedral compiler framework with its ability to compose complex transformations, has proved to be promising in performing loop optimizations for small programs. However, our experiments with large programs using state-of-the-art polyhedral compiler frameworks reveal suboptimal fusion partitions in the transformed code. We trace the reason for this to be lack of an effective cost model to choose a good fusion partitioning among the possible choices, which increase exponentially with the number of program statements. In this paper, we propose a fusion algorithm to choose good fusion partitions with two objective functions - achieving good data reuse and preserving parallelism inherent in the source code. These objectives, although targeted by previous work in traditional compilers, pose new challenges within the polyhedral compiler framework and have thus not been addressed. In our algorithm, we propose several heuristics that work effectively within the polyhedral compiler framework and allow us to achieve the proposed objectives. Experimental results show that our fusion algorithm achieves performance comparable to the existing polyhedral compilers for small kernel programs, and significantly outperforms them for large benchmark programs such as those in the SPEC benchmark suite.

+
+ + +

Triolet: a programming system that unifies algorithmic skeleton interfaces for high-performance cluster computing

  • Christopher Rodrigues
  • Thomas Jablin
  • Abdul Dakkak
  • Wen-Mei Hwu
+

Functional algorithmic skeletons promise a high-level programming interface for distributed-memory clusters that free developers from concerns of task decomposition, scheduling, and communication. Unfortunately, prior distributed functional skeleton frameworks do not deliver performance comparable to that achievable in a low-level distributed programming model such as C with MPI and OpenMP, even when used in concert with high-performance array libraries. There are several causes: they do not take advantage of shared memory on each cluster node; they impose a fixed partitioning strategy on input data; and they have limited ability to fuse loops involving skeletons that produce a variable number of outputs per input.

We address these shortcomings in the Triolet programming language through a modular library design that separates concerns of parallelism, loop nesting, and data partitioning. We show how Triolet substantially improves the parallel performance of algorithms involving array traversals and nested, variable-size loops over what is achievable in Eden, a distributed variant of Haskell. We further demonstrate how Triolet can substantially simplify parallel programming relative to C with MPI and OpenMP while achieving 23--100% of its performance on a 128-core cluster.

+
+ + +

A tool to analyze the performance of multithreaded programs on NUMA architectures

  • Xu Liu
  • John Mellor-Crummey
+

Almost all of today's microprocessors contain memory controllers and directly attach to memory. Modern multiprocessor systems support non-uniform memory access (NUMA): it is faster for a microprocessor to access memory that is directly attached than it is to access memory attached to another processor. Without careful distribution of computation and data, a multithreaded program running on such a system may have high average memory access latency. To use multiprocessor systems efficiently, programmers need performance tools to guide the design of NUMA-aware codes. To address this need, we enhanced the HPCToolkit performance tools to support measurement and analysis of performance problems on multiprocessor systems with multiple NUMA domains. With these extensions, HPCToolkit helps pinpoint, quantify, and analyze NUMA bottlenecks in executions of multithreaded programs. It computes derived metrics to assess the severity of bottlenecks, analyzes memory accesses, and provides a wealth of information to guide NUMA optimization, including information about how to distribute data to reduce access latency and minimize contention. This paper describes the design and implementation of our extensions to HPCToolkit. We demonstrate their utility by describing case studies in which we use these capabilities to diagnose NUMA bottlenecks in four multithreaded applications.

+
+ +

SESSION: Session order 9: scheduling and determinism session

+

Session details: Session order 9: scheduling and determinism session

  • Chen Wenguang
+ +

Towards fair and efficient SMP virtual machine scheduling

  • Jia Rao
  • Xiaobo Zhou
+

As multicore processors become prevalent in modern computer systems, there is a growing need for increasing hardware utilization and exploiting the parallelism of such platforms. With virtualization technology, hardware utilization is improved by encapsulating independent workloads into virtual machines (VMs) and consolidating them onto the same machine. SMP virtual machines have been widely adopted to exploit parallelism. For virtualized systems, such as a public cloud, fairness between tenants and the efficiency of running their applications are keys to success. However, we find that existing virtualization platforms fail to enforce fairness between VMs with different number of virtual CPUs (vCPU) that run on multiple CPUs. We attribute the unfairness to the use of per-CPU schedulers and the load imbalance on these CPUs that incur inaccurate CPU allocations. Unfortunately, existing approaches to reduce unfairness, e.g., dynamic load balancing and CPU capping, introduce significant inefficiencies to parallel workloads.

In this paper, we present Flex, a vCPU scheduling scheme that enforces fairness at VM-level and improves the efficiency of hosted parallel applications. Flex centers on two key designs: (1) dynamically adjusting vCPU weights (FlexW) on multiple CPUs to achieve VM-level fairness and (2) flexibly scheduling vCPUs (FlexS) to minimize wasted busy-waiting time. We have implemented Flex in Xen and performed comprehensive evaluations with various parallel workloads. Results show that Flex is able to achieve CPU allocations with on average no more than 5% error compared to the ideal fair allocation. Further, Flex outperforms Xen's credit scheduler and two representative co-scheduling approaches by as much as 10X for parallel applications using busy-waiting or blocking synchronization methods.

+
+ + +

Efficient deterministic multithreading without global barriers

  • Kai Lu
  • Xu Zhou
  • Tom Bergan
  • Xiaoping Wang
+

Multithreaded programs execute nondeterministically on conventional architectures and operating systems. This complicates many tasks, including debugging and testing. Deterministic multithreading (DMT) makes the output of a multithreaded program depend on its inputs only, which can totally solve the above problem. However, current DMT implementations suffer from a common inefficiency: they use frequent global barriers to enforce a deterministic ordering on memory accesses. In this paper, we eliminate that inefficiency using an execution model we call deterministic lazy release consistency (DLRC). Our execution model uses the Kendo algorithm to enforce a deterministic ordering on synchronization, and it uses a deterministic version of the lazy release consistency memory model to propagate memory updates across threads. Our approach guarantees that programs execute deterministically even when they contain data races. We implemented a DMT system based on these ideas (RFDet) and evaluated it using 16 parallel applications. Our implementation targets C/C++ programs that use POSIX threads. Results show that RFDet gains nearly 2x speedup compared with DThreads-a start-of-the-art DMT system.

+
+ + +

Race directed scheduling of concurrent programs

  • Mahdi Eslamimehr
  • Jens Palsberg
+

Detection of data races in Java programs remains a difficult problem. The best static techniques produce many false positives, and also the best dynamic techniques leave room for improvement. We present a new technique called race directed scheduling that for a given race candidate searches for an input and a schedule that lead to the race. The search iterates a combination of concolic execution and schedule improvement, and turns out to find useful inputs and schedules efficiently. We use an existing technique to produce a manageable number of race candidates. Our experiments on 23 Java programs found 72 real races that were missed by the best existing dynamic techniques. Among those 72 races, 31 races were found with schedules that have between 1 million and 108 million events, which suggests that they are rare and hard-to-find races.

+
+ +

SESSION: Session order 10: conference keynote address

+

Heterogeneous computing: what does it mean for compiler research?

  • Norm Rubin
+

The current trend in computer architecture is to increase the number of cores, to create specialized types of cores within a single machine, and to network such machines together in very fluid web/cloud computing arrangements. Compilers have traditionally focused on optimizations to code that improve performance, but is that the right target to speed up real applications? Consider loading a web page (like starting GMAIL) the page is transferred to the client, any JavaScript is compiled, the JavaScript executes, and the page gets displayed. The classic compiler model (which was first developed in the late 50's) was a great fit for single core machines but has fallen behind architecture, and language. For example how do you compile a single program for a machine that has both a CPU and a graphics coprocessor (a GPU) with a very different programming and memory model? Together with the changes in architecture there have been changes in programming languages. Dynamic languages are used more, static languages are used less. How does this effect compiler research? In this talk, I'll review a number of traditional compiler research challenges that have (or will) become burning issues and will describe some new problems areas that were not considered in the past. For example language specifica-tions are large complex technical documents that are difficult for non-experts to follow. Application programmers are often not willing to read these documents; can a compiler bridge the gap?

+
+ +

SESSION: Session order 11: non-blocking data structures session

+

Session details: Session order 11: non-blocking data structures session

  • James Larus
+ +

Fast concurrent lock-free binary search trees

  • Aravind Natarajan
  • Neeraj Mittal
+

We present a new lock-free algorithm for concurrent manipulation of a binary search tree in an asynchronous shared memory system that supports search, insert and delete operations. In addition to read and write instructions, our algorithm uses (single-word) compare-and-swap (CAS) and bit-test-and-set (SETB) atomic instructions, both of which are commonly supported by many modern processors including Intel~64 and AMD64.

In contrast to existing lock-free algorithms for a binary search tree, our algorithm is based on marking edges rather than nodes. As a result, when compared to other lock-free algorithms, modify (insert and delete) operations in our algorithm work on a smaller portion of the tree, thereby reducing conflicts, and execute fewer atomic instructions (one for insert and three for delete). Our experiments indicate that our lock-free algorithm significantly outperforms all other algorithms for a concurrent binary search tree in many cases, especially when contention is high, by as much as 100%.

+
+ + +

A general technique for non-blocking trees

  • Trevor Brown
  • Faith Ellen
  • Eric Ruppert
+

We describe a general technique for obtaining provably correct, non-blocking implementations of a large class of tree data structures where pointers are directed from parents to children. Updates are permitted to modify any contiguous portion of the tree atomically. Our non-blocking algorithms make use of the LLX, SCX and VLX primitives, which are multi-word generalizations of the standard LL, SC and VL primitives and have been implemented from single-word CAS. To illustrate our technique, we describe how it can be used in a fairly straightforward way to obtain a non-blocking implementation of a chromatic tree, which is a relaxed variant of a red-black tree. The height of the tree at any time is O(c + log n), where n is the number of keys and c is the number of updates in progress. We provide an experimental performance analysis which demonstrates that our Java implementation of a chromatic tree rivals, and often significantly outperforms, other leading concurrent dictionaries.

+
+ + +

Practical concurrent binary search trees via logical ordering

  • Dana Drachsler
  • Martin Vechev
  • Eran Yahav
+

We present practical, concurrent binary search tree (BST) algorithms that explicitly maintain logical ordering information in the data structure, permitting clean separation from its physical tree layout. We capture logical ordering using intervals, with the property that an item belongs to the tree if and only if the item is an endpoint of some interval. We are thus able to construct efficient, synchronization-free and intuitive lookup operations. We present (i) a concurrent non-balanced BST with a lock-free lookup, and (ii) a concurrent AVL tree with a lock-free lookup that requires no synchronization with any mutating operations, including balancing operations. Our algorithms apply on-time deletion; that is, every request for removal of a node, results in its immediate removal from the tree. This new feature did not exist in previous concurrent internal tree algorithms.

We implemented our concurrent BST algorithms and evaluated them against several state-of-the-art concurrent tree algorithms. Our experimental results show that our algorithms with lock-free contains and on-time deletion are practical and often comparable to the state-of-the-art.

+
+ + +

A practical wait-free simulation for lock-free data structures

  • Shahar Timnat
  • Erez Petrank
+

Lock-free data structures guarantee overall system progress, whereas wait-free data structures guarantee the progress of each and every thread, providing the desirable non-starvation guarantee for concurrent data structures. While practical lock-free implementations are known for various data structures, wait-free data structure designs are rare. Wait-free implementations have been notoriously hard to design and often inefficient. In this work we present a transformation of lock-free algorithms to wait-free ones allowing even a non-expert to transform a lock-free data-structure into a practical wait-free one. The transformation requires that the lock-free data structure is given in a normalized form defined in this work. Using the new method, we have designed and implemented wait-free linked-list, skiplist, and tree and we measured their performance. It turns out that for all these data structures the wait-free implementations are only a few percent slower than their lock-free counterparts, while still guaranteeing non-starvation.

+
+ +

POSTER SESSION: Session order 11: poster session

+

Lock contention aware thread migrations

  • Kishore Kumar Pusukuri
  • Rajiv Gupta
  • Laxmi Narayan Bhuyan
+

On a cache-coherent multicore multiprocessor system, the performance of a multithreaded application with high lock contention is very sensitive to the distribution of application threads across multiple processors. This is because the distribution of threads impacts the frequency of lock transfers between processors, which in turn impacts the frequency of last-level cache (LLC) misses that lie on the critical path of execution. Inappropriate distribution of threads across processors increases LLC misses in the critical path and significantly degrades performance of multithreaded programs. To alleviate the above problem, this paper overviews a thread migration technique, which migrates threads of a multithreaded program across multicore processors so that threads seeking locks are more likely to find the locks on the same processor.

+
+ + +

Infrastructure-free logging and replay of concurrent execution on multiple cores

  • Kyu Hyung Lee
  • Dohyeong Kim
  • Xiangyu Zhang
+

We develop a logging and replay technique for real concurrent execution on multiple cores. Our technique directly works on binaries and does not require any hardware or complex software infrastructure support. We focus on minimizing logging overhead as it only logs a subset of system calls and thread spawns. Replay is on a single core. During replay, our technique first tries to follow only the event order in the log. However, due to schedule differences, replay may fail. An exploration process is then triggered to search for a schedule that allows the replay to make progress. Exploration is performed within a window preceding the point of replay failure. During exploration, our technique first tries to reorder synchronized blocks. If that does not lead to progress, it further reorders shared variable accesses. The exploration is facilitated by a sophisticated caching mechanism. Our experiments on real world programs and real workload show that the proposed technique has very low logging overhead (2.6% on average) and fast schedule reconstruction.

+
+ + +

Parallelization hints via code skeletonization

  • Cfir Aguston
  • Yosi Ben Asher
  • Gadi Haber
+

Tools that provide optimization hints for program developers are facing severe obstacles and often unable to provide meaningful guidance on how to parallelize real--life applications. The main reason is due to the high code complexity and its large size when considering commercially valuable code. Such code is often rich with pointers, heavily nested conditional statements, nested while--based loops, function calls, etc. These constructs prevent existing compiler analysis from extracting the full parallelization potential. We propose a new paradigm to overcome this issue by automatically transforming the code into a much simpler skeleton-like form that is more conductive for auto-parallelization. We then apply existing tools of source--level automatic parallelization on the skeletonized code in order to expose possible parallelization patterns. The skeleton code, along with the parallelized version, are then provided to the programmer in the form of an IDE (Integrated Development Environment) recommendation.

The proposed skeletonization algorithm replaces pointers by integer indexes and C-struct references by references to multi-dimensional arrays. This is because automatic parallelizers cannot handle pointer expressions. For example, while(p != NULL){ p->val++; p=p->next; } will be skeletonized to the parallelizable for(Ip=0;Ip<N;Ip++){ Aval[Ip]++; } where Aval[] holds the embedding of the original list. It follows that the main goal of the skeletonization process is to embed pointer-based data structures into arrays. Though the skeletonized code is not semantically equivalent to the original code, it points out a possible parallelization pattern for this code segment and can be used as an effective parallelization hint to the programmer. We applied the method on several representative benchmarks from SPEC CPU 2000 and reached up to 80% performance gain after several sequential code segments had been manually parallelized based on the parallelization patterns of the generated skeletons. In a different set of experiments we tried to estimate the potential of skeletonization for a larger set of programs in SPEC 2000 and obtained an estimation of 27% additional loops that can be parallelized/vectorized due to skeletonization.

+
+ + +

Concurrency bug localization using shared memory access pairs

  • Wenwen Wang
  • Chenggang Wu
  • Pen-Chung Yew
  • Xiang Yuan
  • Zhenjiang Wang
  • Jianjun Li
  • Xiaobing Feng
+

Non-determinism in concurrent programs makes their debugging much more challenging than that in sequential programs. To mitigate such difficulties, we propose a new technique to automatically locate buggy shared memory accesses that triggered concurrency bugs. Compared to existing fault localization techniques that are based on empirical statistical approaches, this technique has two advantages. First, as long as enough successful runs of a concurrent program are collected, the proposed technique can locate buggy memory accesses to the shared data even with only one single failed run captured, as opposed to the need of capturing multiple failed runs in other statistical approaches. Second, the proposed technique is more precise because it considers memory accesses in those failed runs that terminate prematurely.

+
+ + +

Task mapping stencil computations for non-contiguous allocations

  • Vitus J. Leung
  • David P. Bunde
  • Jonathan Ebbers
  • Stefan P. Feer
  • Nickolas W. Price
  • Zachary D. Rhodes
  • Matthew Swank
+

We examine task mapping algorithms for systems that allocate jobs non-contiguously. Several studies have shown that task placement affects job running time. We focus on jobs with a stencil communication pattern and use experiments on a Cray XE to evaluate novel task mapping algorithms as well as some adapted to this setting. This is done with the miniGhost miniApp which mimics the performance of CTH, a shock physics application. Our strategies improve average and single-run times by as much as 28% and 36% over a baseline strategy, respectively.

+
+ + +

Data structures for task-based priority scheduling

  • Martin Wimmer
  • Francesco Versaci
  • Jesper Larsson Träff
  • Daniel Cederman
  • Philippas Tsigas
+

We present three lock-free data structures for priority task scheduling: a priority work-stealing one, a centralized one with ρ-relaxed semantics, and a hybrid one combining both concepts. With the single-source shortest path (SSSP) problem as example, we show how the different approaches affect the prioritization and provide upper bounds on the number of examined nodes. We argue that priority task scheduling allows for an intuitive and easy way to parallelize the SSSP problem, notoriously a hard task. Experimental evidence supports the good scalability of the resulting algorithm. The larger aim of this work is to understand the trade-offs between scalability and priority guarantees in task scheduling systems. We show that ρ-relaxation is a valuable technique for improving the first, while still allowing semantic constraints to be satisfied: the lock-free, hybrid $k$-priority data structure can scale as well as work-stealing, while still providing strong priority scheduling guarantees, which depend on the parameter k. Our theoretical results open up possibilities for even more scalable data structures by adopting a weaker form of ρ-relaxation, which still enables the semantic constraints to be respected.

+
+ + +

Detecting silent data corruption through data dynamic monitoring for scientific applications

  • Leonardo Bautista Gomez
  • Franck Cappello
+

Parallel programming has become one of the best ways to express scientific models that simulate a wide range of natural phenomena. These complex parallel codes are deployed and executed on large-scale parallel computers, making them important tools for scientific discovery. As supercomputers get faster and larger, the increasing number of components is leading to higher failure rates. In particular, the miniaturization of electronic components is expected to lead to a dramatic rise in soft errors and data corruption. Moreover, soft errors can corrupt data silently and generate large inaccuracies or wrong results at the end of the computation. In this paper we propose a novel technique to detect silent data corruption based on data monitoring. Using this technique, an application can learn the normal dynamics of its datasets, allowing it to quickly spot anomalies. We evaluate our technique with synthetic benchmarks and we show that our technique can detect up to 50% of injected errors while incurring only negligible overhead.

+
+ + +

Fine-grain parallel megabase sequence comparison with multiple heterogeneous GPUs

  • Edans F. de O. Sandes
  • Guillermo Miranda
  • Alba C.M.A. Melo
  • Xavier Martorell
  • Eduard Ayguade
+

This paper proposes and evaluates a parallel strategy to execute the exact Smith-Waterman (SW) algorithm for megabase DNA sequences in heterogeneous multi-GPU platforms. In our strategy, the computation of a single huge SW matrix is spread over multiple GPUs, which communicate border elements to the neighbour, using a circular buffer mechanism that hides the communication overhead. We compared 4 pairs of human-chimpanzee homologous chromosomes using 2 different GPU environments, obtaining a performance of up to 140.36 GCUPS (Billion of cells processed per second) with 3 heterogeneous GPUS.

+
+ + +

Automatic semantic locking

  • Guy Golan-Gueta
  • G. Ramalingam
  • Mooly Sagiv
  • Eran Yahav
+

In this paper, we consider concurrent programs in which the shared state consists of instances of linearizable ADTs (abstract data types). We develop a novel automated approach to concurrency control that addresses a common need: the need to atomically execute a code fragment, which may contain multiple ADT operations on multiple ADT instances. In our approach, each ADT implements ADT-specific semantic locking operations that serve to exploit the semantics of ADT operations. We develop a synthesis algorithm that automatically inserts calls to these locking operations in a set of given code fragments (in a client program) to ensure that these code fragments execute atomically without deadlocks, and without rollbacks.

We have implemented the synthesis algorithm and several general-purpose ADTs with semantic locking. We have applied the synthesis algorithm to several Java programs that use these ADTs. Our results show that our approach enables efficient and scalable synchronization.

+
+ + +

Optimistic transactional boosting

  • Ahmed Hassan
  • Roberto Palmieri
  • Binoy Ravindran
+

Herlihy and Koskinen's transactional boosting methodology addressed the challenge of converting concurrent data structures into transactional ones. We present an optimistic methodology for boosting concurrent collections. Optimistic boosting allows greater data structure-specific optimizations, easier integration with STM frameworks, and lower restrictions on the boosted operations than the original boosting methodology.

+
+ + +

Provably good scheduling for parallel programs that use data structures through implicit batching

  • Kunal Agrawal
  • Jeremy T. Fineman
  • Brendan Sheridan
  • Jim Sukha
  • Robert Utterback
+

This poster proposes an efficient runtime scheduler that provides provable performance guarantees to parallel programs that use data structures through the use of implicit batching.

+
+ + +

Theoretical analysis of classic algorithms on highly-threaded many-core GPUs

  • Lin Ma
  • Kunal Agrawal
  • Roger D. Chamberlain
+

The Threaded many-core memory (TMM) model provides a framework to analyze the performance of algorithms on GPUs. Here, we investigate the effectiveness of the TMM model by analyzing algorithms for 3 classic problems -- suffix tree/array for string matching, fast Fourier transform, and merge sort -- under this model. Our findings indicate that the TMM model can explain and predict previously unexplained trends and artifacts in experimental data.

+
+ + +

SCCMulti: an improved parallel strongly connected components algorithm

  • Daniel Tomkins
  • Timmie Smith
  • Nancy M. Amato
  • Lawrence Rauchwerger
+

Tarjan's famous linear time, sequential algorithm for finding the strongly connected components (SCCs) of a graph relies on depth first search, which is inherently sequential. Deterministic parallel algorithms solve this problem in logarithmic time using matrix multiplication techniques, but matrix multiplication requires a large amount of total work. Randomized algorithms based on reachability -- the ability to get from one vertex to another along a directed path -- greatly improve the work bound in the average case. However, these algorithms do not always perform well; for instance, Divide-and-Conquer Strong Components (DCSC), a scalable, divide-and-conquer algorithm, has good expected theoretical limits, but can perform very poorly on graphs for which the maximum reachability of any vertex is small. A related algorithm, MultiPivot, gives very high probability guarantees on the total amount of work for all graphs, but this improvement introduces an overhead that increases the average running time. This work introduces SCCMulti, a multi-pivot improvement of DCSC that offers the same consistency as MultiPivot without the time overhead. We provide experimental results demonstrating SCCMulti's scalability; these results also show that SCCMulti is more consistent than DCSC and is always faster than MultiPivot.

+
+ + +

Initial study of multi-endpoint runtime for MPI+OpenMP hybrid programming model on multi-core systems

  • Miao Luo
  • Xiaoyi Lu
  • Khaled Hamidouche
  • Krishna Kandalla
  • Dhabaleswar K. Panda
+

State-of-the-art MPI libraries rely on locks to guarantee thread-safety. This discourages application developers from using multiple threads to perform MPI operations. In this paper, we propose a high performance, lock-free multi-endpoint MPI runtime, which can achieve up to 40\% improvement for point-to-point operation and one representative collective operation with minimum or no modifications to the existing applications.

+
+ + +

Extracting logical structure and identifying stragglers in parallel execution traces

  • Katherine E. Isaacs
  • Todd Gamblin
  • Abhinav Bhatele
  • Peer-Timo Bremer
  • Martin Schulz
  • Bernd Hamann
+

We introduce a new approach to automatically extract an idealized logical structure from a parallel execution trace. We use this structure to define intuitive metrics such as the lateness of a process involved in a parallel execution. By analyzing and illustrating traces in terms of logical steps, we leverage a developer's understanding of the happened-before relations in a parallel program. This technique can uncover dependency chains, elucidate communication patterns, and highlight sources and propagation of delays, all of which may be obscured in a traditional trace visualization.

+
+ +
\ No newline at end of file From cbaae017e1172bd007727a8bef94ccbd0e76145b Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Thu, 14 Mar 2024 11:00:14 -0400 Subject: [PATCH 47/64] Announce --- _announce/2024-02-11-acm_topml_si.txt | 42 +++++ _announce/2024-02-13-ssft.txt | 16 ++ _announce/2024-02-19-pact_2024.txt | 115 ++++++++++++ _announce/2024-02-26-asplos_waci.txt | 22 +++ _announce/2024-02-28-concur_2024.txt | 95 ++++++++++ _announce/2024-03-05-plmw_pldi_2024.txt | 17 ++ _announce/2024-03-08-sigmetrics_ifip_2024.txt | 114 ++++++++++++ _announce/2024-03-13-funarch_2024.txt | 172 ++++++++++++++++++ 8 files changed, 593 insertions(+) create mode 100644 _announce/2024-02-11-acm_topml_si.txt create mode 100644 _announce/2024-02-13-ssft.txt create mode 100644 _announce/2024-02-19-pact_2024.txt create mode 100644 _announce/2024-02-26-asplos_waci.txt create mode 100644 _announce/2024-02-28-concur_2024.txt create mode 100644 _announce/2024-03-05-plmw_pldi_2024.txt create mode 100644 _announce/2024-03-08-sigmetrics_ifip_2024.txt create mode 100644 _announce/2024-03-13-funarch_2024.txt diff --git a/_announce/2024-02-11-acm_topml_si.txt b/_announce/2024-02-11-acm_topml_si.txt new file mode 100644 index 0000000..e6d552f --- /dev/null +++ b/_announce/2024-02-11-acm_topml_si.txt @@ -0,0 +1,42 @@ +--- +title: "Call for Papers, ACM TOPML Special Issue on Probabilistic Programming" +timestamp: "2/11/2024 16:02:18" +deadline: "5/1/2024" +--- +Call for Papers: Special Issue on "Probabilistic Programming" of + + ACM Transactions on Probabilistic Machine Learning (ACM-TOPML) + +Probabilistic programming is a very active research area that brings together diverse fields, such as statistics, machine learning and AI, applications, programming languages, and formal verification. The aim of this special issue is to present new approaches, techniques, tools, theories and experience reports about adopting, creating, applying and improving probabilistic programming. + +Topics of interest include, but are not limited to: + +Applications of probabilistic programming +Approximate inference algorithms for probabilistic programs +Automatic differentiation for probabilistic programs +Automated program analysis for probabilistic programs +Deep probabilistic programming languages +Design and implementation of probabilistic programming languages +Differentiable programming +Exact inference algorithms for probabilistic programs +Model learning and checking for probabilistic programs +Statistical theory on inference schemes +Semantics for probabilistic programming +Synthesis and learning of probabilistic programs +Theoretical analysis of probabilistic programs +Types for probabilistic programming and differentiable programming +Verification and testing probabilistic programming paradigms + +Guest editors: + +Joost-Pieter Katoen +RWTH Aachen University (DE) and University of Twente (NL) + +Tom Rainforth +University of Oxford (UK) + +Hongseok Yang +Korea Advanced Institute of Science & Technology (KAIST, KR) + +More details, see: +https://dl.acm.org/pb-assets/static_journal_pages/topml/pdf/TOPML_CfP_SI_Probabilistic_Programming-1704743488800.pdf diff --git a/_announce/2024-02-13-ssft.txt b/_announce/2024-02-13-ssft.txt new file mode 100644 index 0000000..ea251cf --- /dev/null +++ b/_announce/2024-02-13-ssft.txt @@ -0,0 +1,16 @@ +--- +title: "2024 Summer School on Formal Techniques, Atherton, California (May 25-31, 2024) + Formal Methods in the Field Bootcamp (June 1/2, 2024)" +timestamp: "2/13/2024 18:49:19" +start: "5/25/2024" +end: "6/3/2024" +--- +Thirteenth Summer School on Formal Techniques, May 25 - June 3, 2024 (http://fm.csl.sri.com/SSFT24) + Menlo College, Atherton, California + +Techniques based on formal logic, such as model checking, satisfiability, static analysis, and automated theorem proving, are finding a broad range of applications in modeling, analysis, verification, and synthesis. This school, the thirteenth in the series, focuses on the principles and practice of formal techniques, with a strong emphasis on the hands-on use and development of this technology. It primarily targets graduate students and young researchers who are interested in studying and using formal techniques in their research. A prior background in formal methods is helpful but not required. Participants at the school can expect to have a seriously fun time experimenting with the tools and techniques presented in the lectures during the laboratory sessions. The main lectures run from Monday May 27 to Fri May 31. They are preceded by a background course "Speaking Logic" taught by Natarajan Shankar and Stephane Graham-Lengrand (SRI CSL) on May 25/26. The summer school is immediately followed by a two-day Bootcamp to reinforce some of the skills acquired during the school. Participants in the Bootcamp work with formal tools and techniques (including those taught in this and prior summer school editions) under the supervision of the Bootcamp faculty to create verified artifacts. + +The lecturers at the school include: Josef Urban (CIIRC): Combining Machine Learning and Theorem Proving; Marsha Chechik (U. Toronto): Elicitation and Formal Reasoning about Normative Requirements; Leonardo de Moura and David Thrane Christiansen: The Lean 4 programming language and theorem prover; Cesare Tinelli (U. Iowa): Modeling and analyzing reactive systems with logic-based symbolic model checkers; Armando Solar-Lezama (MIT): Neurosymbolic Programming for better learning. The program also includes invited talks from distinguished speakers (to be announced). + +This year, the school/bootcamp will take place in a hybrid mode: the lectures and labs will be live-streamed and recorded. We strongly encourage in-person participation so that you can benefit from interactions outside the classroom. We have funding from NSF to cover transportation/food/lodging expenses for selected US-based students. Non-student and non-US in-person participants are expected to cover their own transportation and will be charged a fee (around $150/day) to cover the cost of food and lodging. + +The registration link is at the URL: http://fm.csl.sri.com/SSFT24. Applications should be submitted together with names of two references (preferably advisors, professors, or senior colleagues). Applicants are urged to submit their applications as early as possible (no later than April 30, 2024), since there are only a limited number of spaces available. Those needing invitation letters for visa purposes are encouraged to complete their applications as early as possible. We strongly encourage the participation of women and under-represented minorities in the summer school. diff --git a/_announce/2024-02-19-pact_2024.txt b/_announce/2024-02-19-pact_2024.txt new file mode 100644 index 0000000..a283d58 --- /dev/null +++ b/_announce/2024-02-19-pact_2024.txt @@ -0,0 +1,115 @@ +--- +title: "Call for Papers, The International Conference on Parallel Architectures and Compilation Techniques (PACT)" +timestamp: "2/19/2024 12:26:46" +deadline: "3/27/2024" +--- +# Call for papers + +PACT 2024 will be held in Long Beach, California, USA, 13-16 October, 2024. + +**Submissions due: March 27, 2024** + +**PACT 2024 includes a New Call for Tools and Practical Experience Papers** + +##Scope + +The International Conference on Parallel Architectures and Compilation Techniques (PACT) is a unique technical conference sitting at the intersection of hardware and software, with a special emphasis on parallelism. The PACT conference series brings together researchers from computer architectures, compilers, execution environments, programming languages, and applications, to present and discuss their latest research results. + +PACT 2024 will be held as an in-person event in Long Beach, California, USA. At least one of the authors of accepted papers will be required to attend the conference, and we encourage all the authors to participate. + +Specific topics of interest include (but are not limited to): + +- Parallel architectures, including accelerator architectures for AI or other domains +- Compilers and tools for parallel architectures (as above) +- Applications and experimental systems studies of parallel processing +- Computational models for concurrent execution +- Multicore, multithreaded, superscalar, and VLIW architectures +- Compiler and hardware support for hiding memory latencies +- Support for correctness in hardware and software +- Reconfigurable parallel computing +- Dynamic translation and optimization +- I/O issues in parallel computing and their relation to applications +- Parallel programming languages, algorithms, and applications +- Middleware and run-time system support for parallel computing +- Application-specific parallel systems +- Distributed computing architectures and systems +- Heterogeneous systems using various types of accelerators +- In-core and in-chip accelerators and their exploitation +- Applications of machine learning to parallel computing +- Large scale data processing, including computing in memory accelerators +- Insights for the design of parallel architectures and compilers from modern parallel applications PACT for Quantum and Neurmorphic +- Neuromorphic computing both as an application for and a tool applied to architectures and compilers +- Quantum computing architectures and compilers. + +In addition to the regular research papers, PACT 2024 has a special category of papers called “tools and practical experience” (TPE). Such papers are subject to the same page length guidelines and will be reviewed by the same Program Committee. +TPE papers focus on applicability (such as traditional methods employed in emerging fields), exposing challenges and experiences the industry is facing as an opportunity to steer the research. A TPE paper must clearly explain its functionality, provide a summary about the practice experience with realistic case studies, and describe all thesupporting artifacts available (if relevant). The selection criteria are: +- Originality: Papers should present PACT-related technologies applied to real-world problems withscope or characteristics that set them apart from previous solutions. +- Usability: The presented Tools or compilers should have broad usage or applicability. They are expected to assist in PACT-related research, or could be extended to investigate or demonstrate new technologies. If significant components are not yet implemented, the paper will not be considered. +- Documentation: The tool or compiler should be presented on a web-site giving documentation and further information about the tool. +- Benchmark Repository: A suite of benchmarks for testing should be provided. +- Availability: Preferences will be given to tools or compilers that are freely available (at either the source orbinary level). Exceptions may be made for industry and commercial tools that cannot be made publicly available for business reasons. +- Foundations: Papers should incorporate the principles underpinning Parallel Architectures and Compilation Techniques (PACT). However, a thorough discussion of theoretical foundations is not required; a summary of such should suffice. + + +## Submitting your work + +Paper **submissions are due March 27, 2024** by posting on the conference [submission site](https://pact24.hotcrp.com). Please make sure that your paper satisfies all the following requirements before being submitted. Submissions not adhering to these submission guidelines will be rejected by the submission system and/or subject to an administrative rejection. + +- Mark TPE papers clearly by preceding their title with “TPE: ” both in the submission site and in the submitted pdf +- The paper must have an abstract under 300 words. +- The paper must be original material that has not been previously published in another conference or journal, nor is currently under review by another conference or journal. You may submit material presented previously at a workshop without copyrighted proceedings. +- The submission is limited to ten (10) pages in the ACM 8.5" x 11" format (US letter size paper) using 9pt font, with no more than 7 lines per inch. This page limit applies to all content NOT INCLUDING references, and there is no page limit for references. Your paper must print satisfactorily on both Letter paper (8.5"x11") and A4 paper (8.27"x11.69"). The box containing the text should be no larger than 7.15"x9" (18.2cm x 22.9cm). Templates are available on the [ACM Author Gateway](https://authors.acm.org/proceedings/production-information/taps-production-workflow). +- Paper submission is double-blind to reduce reviewer bias against authors or institutions. Thus, the submissions cannot include author names, institutions or hints based on references to prior work. If authors are extending their own work, they need to reference and discuss the past work in third person, as if they were extending someone else’s research. We realize that for some papers it will still reveal authorship, but as long as an effort was made to follow these guidelines, the submission will not be penalized. +- Anonymized supplementary material may be provided in a single PDF file uploaded at paper submission time, containing material that supports the content of the paper, such as proofs, additional experimental results, data sets, etc. Reviewers are not required to read the supplementary material but may choose to do so. +- Please make sure that the labels on your graphs are readable without the aid of a magnifying glass. +- The paper must be submitted in PDF. We cannot accept any other format, and we must be able to print the document just as we receive it. We suggest that you use only the four widely used printer fonts: Times, Helvetica, Courier and Symbol. + +Poster submissions must conform to the same format restrictions, but may not exceed 2 pages in length. Paper submissions that are not accepted for regular presentations will automatically be considered for posters; authors who do not want their paper considered for the poster session should indicate this in their abstract submission. Two-page summaries of accepted posters will be included in the conference proceedings. + +Please submit your work via the conference [submission site](https://pact24.hotcrp.com). + +## Conflicts of interest + +Authors must identify any conflicts-of-interest with PC members and external members of the community. We ask all authors of a submitted paper to register their conflicts at the submission site. If a paper is found to have an undeclared conflict that causes a problem OR if a paper is found to declare false conflicts in order to abuse or game the review system, the paper may be rejected. Conflicts of interests are defined according to ACM’s [conflict of interest policy](https://www.acm.org/publications/policies/conflict-of-interest). + +## Artifact evaluation + +Authors of accepted PACT 2024 papers are encouraged to formally submit their supporting materials for Artifact Evaluation. The Artifact Evaluation process is run by a separate committee whose task is to assess the availability, functionality, and reproducibility ofthe work and experimental results described in the paper. Submission is voluntary. We strongly encourage authors to consider submitting artifacts for their work, including simulators for new architectural designs and extensions. + +We encourage authors to prepare their artifacts for submission and make them more portable, reusable and customizable usingopen-source frameworks including [Docker](https://www.docker.com), [OCCAM](https://occam.cs.pitt.edu), [reprozip](https://www.reprozip.org), [CodeOcean](https://codeocean.com) and [CK](https://cknowledge.io/docs/). + +Papers that successfully go through the Artifact Evaluation process will receive a seal of approval printed on the papers themselves.Authors of such papers will have an option to include their Artifact Appendix to the final paper (up to 2 pages). Authors are also encouraged to make their artifacts publicly available. + +## Key dates + +- Abstract submission deadline: Mar 22, 2024 +- Paper submission deadline: Mar 27, 2024 +- Rebuttal period: Jun 3-9, 2024 +- Author notification: Jul 1, 2024 +- Artifact submission: Jul 8, 2024 +- Camera ready papers: Aug 10, 2024 + +All deadlines are firm at midnight anywhere on earth (AoE). + +## Code of Conduct + +All individuals participating in PACT or involved with its organization are expected to follow the + +[ACM Code of Ethics and Professional Conduct](https://www.acm.org/code-of-ethics); +The [IEEE Code of Ethics](https://www.ieee.org/about/corporate/governance/p7-8.html) and [Code of Conduct](https://www.ieee.org/content/dam/ieee-org/ieee/web/org/about/ieee_code_of_conduct.pdf); and the +[Policy Against Harassment at ACM activities](https://www.acm.org/about-acm/policy-against-harassment). + +## Publication policies + +PACT is supported by both ACM and IEEE and articles accepted for publication are available on both the ACM digital library and IEEE Xplore. By submitting your article to an PACT, you are hereby acknowledging that you and your co-authors are subject to all [ACM Publications Policies](https://www.acm.org/publications/policies), including ACM’s new [Publications Policy on Research Involving Human Participants and Subjects](https://www.acm.org/publications/policies/research-involving-human-participants-and-subjects), and the [IEEE Publication Policies](https://ieeexplore.ieee.org/Xplorehelp/author-center/publishing-policies). Alleged violations of these policies will be investigated by officers of ACM or IEEE and may result in a full retraction of your paper, in addition to other potential penalties, as per their policies. + +Please ensure that you and your co-authors [obtain an ORCID ID](https://orcid.org/register), so you can complete the publishing process for your accepted paper. ACM has been involved in ORCID from the start and we have recently made a [commitment to collect ORCID IDs](https://authors.acm.org/author-resources/orcid-faqs) from all of our published authors. The collection process has started and will roll out as a requirement throughout 2022. We are committed to improve author discoverability, ensure proper attribution and contribute to ongoing community efforts around name normalization; your ORCID ID will help in these efforts. + + +## General co-chairs +Nael Abu-Ghazaleh (University of California, Riverside) +Rajiv Gupta (University of California, Riverside) + +## Publicity Chairs +Ihsen Alouani (Queen's University Belfast) +Khaled N. Khasawneh (George Mason University) diff --git a/_announce/2024-02-26-asplos_waci.txt b/_announce/2024-02-26-asplos_waci.txt new file mode 100644 index 0000000..c44c877 --- /dev/null +++ b/_announce/2024-02-26-asplos_waci.txt @@ -0,0 +1,22 @@ +--- +title: "Call for Contributions: ASPLOS Wild and Crazy Ideas" +timestamp: "2/26/2024 20:38:32" +deadline: "3/15/2024" +--- +**TLDR: Submit a 5-min video to pitch your ambitious research idea at ASPLOS WACI session by March 16.** + +The Wild and Crazy Ideas (WACI) session (https://www.asplos-conference.org/asplos2024/call-for-waci/) is a time-honored tradition at ASPLOS that frees researchers from the shackles of realism, removes the blinders of short-term thinking, and opens the scientific mind to uncharted frontiers. Since 1998, WACI has provided a counterweight to the conservative impulses wrought by the traditional peer review path. + +This is your moment to propose something huge—something no one else is talking about. Craft a talk that: +* Falls within the ASPLOS purview and is related to architecture, programming languages, and operating systems in some capacity. Interdisciplinary ideas that touch on multiple topics are preferred, but not required. +* Is not (yet) publishable research. Propose something neither you nor anyone else in the community is actually working on—for example, because it seems only barely feasible, because it requires thinking far into the future, because it strays into intellectual domains too far from core ASPLOS expertise, or because it directly contradicts the conventional wisdom. +* Might change the world. Your idea must be enormous. Unshackle your ambition. +* Ideas may also be funny—we encourage it!—but really great WACI talks contain an element of real, world-changing, convention-challenging research thought. + +This year, we’re soliciting submissions as short videos. Think of this as a beta-quality teaser for what your real, on-stage talk would be like. **Upload a video at most 5 minutes in length to the [submission form](https://docs.google.com/forms/d/e/1FAIpQLSdCXYLL4BYhRnwgepUdSbGBENgswVt4i2ufKl3yAQwQJaS-Ww/viewform) by March 16 (AoE).** We will select talks based on their potential to provoke thoughts and discussion, not their production value—so it’s OK to submit a rough prototype. + +If the WACI chairs select your talk, here’s what you can expect: +* You write a longer version of your idea (limit: two pages) for publication on the WACI website. +* The WACI chairs work with you to craft an excellent, compact, entertaining talk for the WACI session. + +Contact the WACI chairs, sachour@stanford.edu and mangpo@google.com, with any questions. diff --git a/_announce/2024-02-28-concur_2024.txt b/_announce/2024-02-28-concur_2024.txt new file mode 100644 index 0000000..a68510a --- /dev/null +++ b/_announce/2024-02-28-concur_2024.txt @@ -0,0 +1,95 @@ +--- +title: "CONCUR 2024: Call for Papers" +timestamp: "2/28/2024 16:31:13" +deadline: "4/26/2024" +--- +============================ +CONCUR 2024: Call for Papers +============================ + +September 9-13, 2024 +Calgary, Canada + +https://confest2024.github.io/CONCUR_call_for_papers.html + +Co-located with QEST+Formats as part of CONFEST 2024 +https://confest2024.github.io/ + +Overview +======== + +CONCUR conferences bring together researchers, developers, and +students interested in advancing the theory of concurrency, and its +applications. CONCUR 2024 solicits high quality papers reporting +research results and/or experience related to semantics, logics, +verification and analysis of concurrent systems. + +Important dates +=============== +(Times are Anywhere on Earth) +Paper Submission: April 26, 2024 +Rebuttal Response: June 4-6, 2024 +Notification: June 21, 2024 +Camera Ready: July 12, 2024 +Conference(s): September 9-13, 2024 +Workshops: Co-located with CONFEST (see the website for more info) +https://confest2024.github.io/workshops_call_for_proposals.html + +Topics +====== +Submissions are solicited in the theory and practice of concurrent +systems. The principal topics include (but are not limited to): + +-- Basic models of concurrency such as abstract machines, +domain-theoretic models, categorical and coalgebraic models, +game-theoretic models, process algebras, graph transformation +systems, Petri nets, hybrid systems, mobile and collaborative +systems, probabilistic systems, real-time systems, quantum systems, +biology-inspired systems, and synchronous systems; + +-- Logics for concurrency such as modal logics, program logics, +probabilistic and stochastic logics, temporal logics, and resource +logics; + +-- Verification and analysis techniques for concurrent systems such +as abstract interpretation, atomicity checking, model checking, race +detection, pre-order and equivalence checking, run-time verification, +state-space exploration, static analysis, synthesis, testing, theorem +proving, type systems, and security analysis; + +-- Distributed algorithms and data structures: design, analysis, +complexity, correctness, fault tolerance, reliability, availability, +consistency, self-organization, self-stabilization, protocols; + +-- Theoretical foundations, tools, and empirical evaluations of +architectures, execution environments, and software development for +concurrent systems such as geo-replicated systems, communication +networks, multiprocessor and multi-core architectures, shared and +transactional memory, resource management and awareness, compilers +and tools for concurrent programming, programming models such as +component-based, object- and service-oriented. + +Paper Submission +================ + +-- All papers must be original, unpublished, and not submitted for +publication elsewhere. + +-- Each paper will undergo a thorough review process. The paper may +be supplemented with a clearly marked appendix, which will be reviewed +at the discretion of the program committee. + +-- The CONCUR 2024 proceedings will be published by LIPIcs. Papers +must be submitted electronically as PDF files via HotCRP. + +https://concur2024.hotcrp.com/ + +-- Submissions follow a light double blind process. Papers must not +exceed 14 pages (excluding references and clearly marked appendices) +using the LIPIcs style. + +Awards +====== + +In 2024, CONCUR Test-of-Time and best paper awards will be given for +the fourth time. The winners will be announced at the conference. diff --git a/_announce/2024-03-05-plmw_pldi_2024.txt b/_announce/2024-03-05-plmw_pldi_2024.txt new file mode 100644 index 0000000..f0971b8 --- /dev/null +++ b/_announce/2024-03-05-plmw_pldi_2024.txt @@ -0,0 +1,17 @@ +--- +title: "Call for Scholarship Applications, Programming Language Mentoring Workshop (PLMW) @PLDI 2024" +timestamp: "3/5/2024 13:57:11" +--- +he application for attending the Programming Language Mentoring Workshop (PLMW) @PLDI 2024 is open. The deadline is March 25th AOE for full consideration but we'll continue on a rolling basis after that as long as we have funding. The application link is here https://forms.gle/2haU1bMM7UKxU39y8. + +Please encourage undergraduates, MS students, and junior PhD students that you think could benefit from the workshop to apply. Below is more information about PLMW@PLDI 2024. + +PLMW aims to broaden the exposure of late-stage undergraduate students and early-stage graduate students to research and career opportunities in programming languages. The workshop includes mentoring sessions that cover effective habits for navigating research careers, technical sessions that cover core subfields of programming languages research, and social sessions that create opportunities for students to interact with researchers in the field. Applications from underrepresented groups in computing are especially welcome. +PLMW @ PLDI 2024 will be co-located with the conference on Programming Language Design and Implementation. It will be held on June 24-25, 2024, Copenhagen, Denmark. The workshop program will cover important topics such as: + +• Career paths after graduate school +• Interplay between PL and other areas of research in Computer Science +• Useful research skills such as giving good talks and writing papers +• Overview of key PL research areas both in academia and industry + +Find out more about the workshop at https://pldi24.sigplan.org/track/PLMW-PLDI-2024 diff --git a/_announce/2024-03-08-sigmetrics_ifip_2024.txt b/_announce/2024-03-08-sigmetrics_ifip_2024.txt new file mode 100644 index 0000000..b6daf24 --- /dev/null +++ b/_announce/2024-03-08-sigmetrics_ifip_2024.txt @@ -0,0 +1,114 @@ +--- +title: "2024 ACM SIGMETRICS / IFIP Performance: Call for Participation" +timestamp: "3/8/2024 12:08:31" +start: "6/10/2024" +end: "6/14/2024" +--- +Dear SIGPLAN Members, + +You are cordially invited to ACM SIGMETRICS / IFIP Performance 2024 +held June 10-14, 2024, at San Servolo Congress Center, Venice, Italy. +SIGMETRICS and Performance are respectively the flagship conferences +of the ACM special interest group for the computer systems performance +evaluation community and of the IFIP working group WG7.3 on +performance modeling and analysis. Every 3 years or so, the two +conferences join, and this is the 16th joint conference. We also +celebrate the 50th ACM SIGMETRICS conference. + +https://www.sigmetrics.org/sigmetrics2024/ + +PROGRAM +======= + +Mon, June 10: Tutorials +Tue, June 11 to Thu, June 13: Main conference +Fri, June 14: Workshops + + +KEYNOTE SPEAKERS +================ + +Michele Zorzi, University of Padova +John Wilkes, Google + +WORKSHOPS: +========== +28th International Conference on Analytical and Stochastic Modelling +Techniques and Applications (ASMTA 2024) + +20th European Performance Engineering Workshop (EPEW 2024) + +Learning-augmented Algorithms: Theory and Applications (LATA 2024) + +MAthematical performance Modeling and Analysis (MAMA 2024) + +Teaching Performance Analysis of Computer Systems (TeaPACS 2024) + +ACCOMMODATION +============= + +The organizing committee has been negotiating accommodation agreements +and discounted rates for ACM SIGMETRICS / IFIP PERFORMANCE 2024 +participants. Considering that June is the high season for Venice, +we encourage you to take advantage of this opportunity and book your +accommodation as soon as possible. Rate agreements expire soon. For +further information, please visit: + +https://www.sigmetrics.org/sigmetrics2024/accommodation.html + + +ORGANIZING COMMITTEE +==================== + +General Chairs +- Andrea Marin (Univ. of Venice “Ca’ Foscari”, Italy) +- Michele Garetto (Univ. of Turin, Italy) + +Program Chairs +- Giulia Fanti (Carnegie Mellon University, US) +- Florin Ciucu (University of Warwick, UK) +- Rhonda Righter (University of California, Berkeley, US) + +Financial Chair +Sabina Rossi (Univ. of Venice “Ca’ Foscari”, Italy) + +Tutorial Chair +Sara Alouf (INRIA, Sophia Antipolis, France) + +Workshops Chairs +- Valeria Cardellini (Univ. of Rome “Tor Vergata”, Italy) +- Dieter Fiems (Univ. Ghent, Belgium) + +Travel Grants Chair +- Qiaomin Xie (University of Wisconsin-Madison, US) + +SRC Chairs +- Lishan Yang (George Mason University, US) +- Nicolas Gast (INRIA, France) + +Proceedings Chair +- Siva Theja Maguluri (Georgia Tech, Atlanta, US) +- Debankur Mukherjee (Georgia Tech, Atlanta, US) + +Publicity Chairs +- Marco Paolieri (Univ. of Southern California, US) +- Maryam Elahi (Mount Royal University, Canada) + +Web Chair +- Paolo Castagno (Univ. of Turin, Italy) + +Registration Chair +- Bo Ji (Virginia Tech, US) + +Local Arrangement Chairs +- Diletta Olliaro (Univ. Ca' Foscari of Venice, Italy) +- Sabina Rossi (Univ. Ca' Foscari of Venice, Italy) + + +CONTACTS +======== + +Contact the SIGMETRICS / Performance 2024 General chairs Andrea Marin +(marin@unive.it) or Michele Garetto (michele.garetto@unito.it) in case +of questions or concerns. + diff --git a/_announce/2024-03-13-funarch_2024.txt b/_announce/2024-03-13-funarch_2024.txt new file mode 100644 index 0000000..64ad731 --- /dev/null +++ b/_announce/2024-03-13-funarch_2024.txt @@ -0,0 +1,172 @@ +--- +title: "Call for Papers: Second ACM SIGPLAN Workshop on Functional Software Architecture - FP in the Large" +timestamp: "3/13/2024 15:23:53" +deadline: "6/3/2024" +--- +====================================================================== + + *** FUNARCH 2024 -- CALL FOR PAPERS *** + + Second ACM SIGPLAN Workshop on + Functional Software Architecture - FP in the Large + + 6th September 2025, Milan, Italy + Co-located with ICFP 2024 + + https://functional-architecture.org/events/funarch-2024/ + +====================================================================== + +TIMELINE: + +Paper submission 3rd June 2024 +Author notification 30th June 2024 +Camera ready copy 18th July 2024 +Workshop 6th Sept 2024 + +BACKGROUND: + +"Functional Software Architecture" refers to methods of construction +and structure of large and long-lived software projects that are +implemented in functional languages and released to real users, +typically in industry. The goals for the workshop are: + +- To assemble a community interested in software architecture + techniques and technologies specific to functional programming; + +- To identify, categorize, and document topics relevant to + the field of functional software architecture; + +- To connect the functional programming community to the software + architecture community to cross-pollinate between the two. + +The workshop follows on from the Functional Software Architecture +open space that was held at ICFP 2022 in Slovenia. + +SCOPE: + +The workshop seeks submissions in a range of categories: + +- You're a member of the FP community and have thought about how + to support programming in the large, for example by framing + functional ideas in architectural terms or vice verse, comparing + different languages in terms of their architectural capabilities, + clarifying architectural roles played by formal methods, proof + assistants and DSLs, or observing how functional concepts are + used in other language and architecture communities. + + Great, submit a research paper! + +- You're a member of the architecture community, and have thought + about how your discipline might help functional programmers, for + example by applying domain-driven design, implementing hexagonal + architecture, or designing self-contained systems. + + Excellent, submit a research paper! + +- You've worked on a large project using functional programming, + and it's worked out well, or terribly, or a mix of both; bonus + points for deriving architectural principles from your experience. + + Wonderful, submit an experience report! + +- You know a neat architectural idiom or pattern that may be useful + to others developing large functional software systems. + + Fabulous, submit an architectural pearl! + +- You have something that doesn't fit the above categories, but + that still relates to functional software architecture, such + as something that can be written up, or that could be part of + the workshop format like a panel debate or a fishbowl. + + Superb, submit to the open category! + +Research papers should explain their research contributions in both +general and technical terms, identifying what has been accomplished, +explaining why it is significant, and relating it to previous work, +and to other languages where appropriate. + +Experience reports and architectural pearls need not necessarily +report original research results. The key criterion for such papers +is that they make a contribution from which others can benefit. +It is not enough simply to describe a large software system, or +to present ideas that are specific to a particular system. + +Open category submissions that are not intended for publication +are not required to follow the formatting guidelines, and can +submit in PDF, word or plain text format as preferred. Not knowing +what kinds of submissions we will receive, we cannot be specific as to +how they will be evaluated. However, submissions that seem likely to +stimulate discussion around practices in functional architecture +are encouraged. + +If you are unsure whether your contribution is suitable, or if +you need any kind of help with your submission, please email +the program chairs at . + +Papers must be submitted by 3rd June 2024 using the EasyChair +submission page: + +https://easychair.org/my/conference?conf=funarch2024 + +Formatting: submissions intended for publication must be +in PDF format and follow the ACM SIGPLAN style guidelines, +using the acmart format and the sigplan +sub-format. Please use the review option when submitting, as this +enables line numbers for easy reference in reviews. For further +details, see SIGPLAN's author information: + +http://www.sigplan.org/Resources/Author/#acmart-format + +If your submission is not a research paper, please mark this using +a subtitle (Experience Report, Architectural Pearl, Open Category). + +Length: submissions must adhere to the limits specified below. +However, there is no requirement or expectation that all pages +are used, and authors are encouraged to strive for brevity. + +Research papers 5 to 12+ pages +Architectural pearls 5 to 12 pages +Experience reports 3 to 6 pages +Open category 1 to 6 pages + +Publication: The proceedings of FUNARCH 2024 will be published in the ACM Digital +Library, and authors of accepted papers are required to agree to one +of the standard ACM licensing options. Accepted papers must be +presented at the workshop by one of the authors, but in special cases +we may consider remote presentation. + +The official publication date is the date the papers are made +available in the ACM Digital Library. This date may be up to two +weeks prior to the first day of the conference. The official +publication date affects the deadline for any patent filings +related to published work. + +PROGRAM CHAIRS: + +Mike Sperber (Active Group, Germany) +Perdita Stevens (University of Edinburgh, UK) + +PROGRAM COMMITTEE: + +Annette Bieniusa (University of Kaiserslautern) +Jeffrey Young (IOG) +Will Crichton (Brown University) +Isabella Stilkerich (Schaeffler Technologies AG) +Kiko Fernandez-Reyes (Ericsson) +Ryan Scott (Galois) +Satnam Singh (Groq) +Facundo Dominguez (Tweag) +Ilya Sergey (University of Singapore) +Martin Elsman (University of Copenhagen) +Benjamin Pierce (University of Pennsylvania) +Matthew Flatt (University of Utah) +Nada Amin (Harvard University) +Richard Eisenberg (Jane Street) + +WORKSHOP VENUE: + +The workshop will be co-located with the ICFP 2024 conference at +the Fiera Milano Congressi, Milan, Italy. + From 27157ad36321cc2e67e0c85a78dee6682087290b Mon Sep 17 00:00:00 2001 From: Amin Timany Date: Sun, 17 Mar 2024 15:21:31 +0100 Subject: [PATCH 48/64] add a CPP page --- Conferences/CPP.md | 41 +++++++++++++++++++++++++++++++++++++++++ _data/Conferences.yaml | 2 +- 2 files changed, 42 insertions(+), 1 deletion(-) create mode 100644 Conferences/CPP.md diff --git a/Conferences/CPP.md b/Conferences/CPP.md new file mode 100644 index 0000000..20f95aa --- /dev/null +++ b/Conferences/CPP.md @@ -0,0 +1,41 @@ +--- +layout: default +title: "Certified Programs and Proofs (CPP)" +--- +Certified Programs and Proofs (CPP) is an international conference on practical and theoretical topics in all areas that consider formal verification and certification as an essential paradigm for their work. CPP spans areas of computer science, mathematics, logic, and education. CPP is sponsored by ACM SIGPLAN, in cooperation with ACM SIGLOG. + +**Steering Committee** + +* [Lennart Beringer](https://www.cs.princeton.edu/~eberinge/), Princeton University, USA +* [Sandrine Blazy](https://people.irisa.fr/Sandrine.Blazy/), University of Rennes, France +* [Adam Chlipala](http://adam.chlipala.net), MIT, USA +* Georges Gonthier, Inria, France +* [Cătălin Hriţcu](https://catalin-hritcu.github.io) (Chair), MPI-SP, Germany +* [Gerwin Klein](https://doclsf.de), CSIRO's Data61 and UNSW Sydney, Australia +* [Robbert Krebbers](https://robbertkrebbers.nl), Radboud University Nijmegen, Netherlands +* [Dale Miller](http://www.lix.polytechnique.fr/Labo/Dale.Miller/), INRIA Saclay and LIX/Institut Polytechnique de Paris, France +* [Tobias Nipkow](https://www21.in.tum.de/~nipkow/), Technische Universität München, Germany +* [Brigitte Pientka](https://www.cs.mcgill.ca/~bpientka/), McGill University, Canada +* [Andrei Popescu](https://www.andreipopescu.uk), University of Sheffield, United Kingdom +* [Zhong Shao](http://www.cs.yale.edu/homes/shao/), Yale University, USA +* [Kathrin Stark](https://www.k-stark.de), Heriot-Watt University, United Kingdom +* [Nicolas Tabareau](https://tabareau.fr), Inria, France +* [Amin Timany](https://cs.au.dk/~timany/), Aarhus University, Denmark +* [Dmitriy Traytel](https://traytel.bitbucket.io), University of Copenhagen, Denmark +* [Steve Zdancewic](https://www.cis.upenn.edu/~stevez/), University of Pennsylvania, USA + +**Previous CPP Conferences** + +* [CPP 2024](https://popl24.sigplan.org/home/CPP-2024), London, UK, January 15-16, 2024 (co-located with POPL’24) +* [CPP 2023](https://popl23.sigplan.org/home/CPP-2023), Boston, USA, January 16-17, 2023 (co-located with POPL’23) +* [CPP 2022](https://popl22.sigplan.org/home/CPP-2022), Philadelphia, USA, January 17-18, 2022 (co-located with POPL’22) +* [CPP 2021](https://popl21.sigplan.org/home/CPP-2021), Online, January 17-19, 2021 (co-located with POPL’21) +* [CPP 2020](https://popl20.sigplan.org/home/CPP-2020), New Orleans, USA, January 20-21, 2020 (co-located with POPL’20) +* [CPP 2019](https://popl19.sigplan.org/track/CPP-2019), Cascais/Lisbon, Portugal, January 14-15, 2019 (co-located with POPL’19) +* [CPP 2018](https://popl18.sigplan.org/track/CPP-2018), Los Angeles, USA, January 8-9, 2018 (co-located with POPL’18) +* [CPP 2017](https://cpp2017.mpi-sws.org), Paris, France, January 16-17, 2017 (co-located with POPL’17) +* [CPP 2016](https://people.csail.mit.edu/adamc/cpp16/), Saint Petersburg, Florida, USA, January 18-19, 2016 (co-located with POPL’16) +* [CPP 2015](http://cpp2015.inria.fr), Mumbai, India, January 13-14, 2015 (co-located with POPL’15) +* [CPP 2013](https://dblp2.uni-trier.de/db/conf/cpp/cpp2013.html), Melbourne, Australia, December 11-13, 2013 (co-located with APLAS’13) +* [CPP 2012](http://cpp12.kuis.kyoto-u.ac.jp), Kyoto, Japan, December 13-15, 2012 (collocation with APLAS’12) +* [CPP 2011](https://dblp.uni-trier.de/db/conf/cpp/cpp2011.html), Kenting, Taiwan, December 7-9, 2011 (co-located with APLAS’11) diff --git a/_data/Conferences.yaml b/_data/Conferences.yaml index 84d6863..373097c 100644 --- a/_data/Conferences.yaml +++ b/_data/Conferences.yaml @@ -221,7 +221,7 @@ - name: Certified Programs and Proofs (CPP) - link: 'https://popl23.sigplan.org/series/CPP' + link: /Conferences/CPP description: | Certified Programs and Proofs (CPP) is an international conference on practical and theoretical topics in all areas that consider formal From a86286d43355c6e94a99d1df2cfb9d8590cf97e0 Mon Sep 17 00:00:00 2001 From: Amin Timany Date: Mon, 18 Mar 2024 17:03:39 +0100 Subject: [PATCH 49/64] update the CPP page --- Conferences/CPP.md | 51 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 50 insertions(+), 1 deletion(-) diff --git a/Conferences/CPP.md b/Conferences/CPP.md index 20f95aa..4a6af9b 100644 --- a/Conferences/CPP.md +++ b/Conferences/CPP.md @@ -2,7 +2,7 @@ layout: default title: "Certified Programs and Proofs (CPP)" --- -Certified Programs and Proofs (CPP) is an international conference on practical and theoretical topics in all areas that consider formal verification and certification as an essential paradigm for their work. CPP spans areas of computer science, mathematics, logic, and education. CPP is sponsored by ACM SIGPLAN, in cooperation with ACM SIGLOG. +Certified Programs and Proofs (CPP) is an international conference on practical and theoretical topics in all areas that consider formal verification and certification as an essential paradigm for their work. CPP spans areas of computer science, mathematics, logic, and education. CPP is sponsored by ACM SIGPLAN, usually in cooperation with ACM SIGLOG. **Steering Committee** @@ -24,6 +24,7 @@ Certified Programs and Proofs (CPP) is an international conference on practical * [Dmitriy Traytel](https://traytel.bitbucket.io), University of Copenhagen, Denmark * [Steve Zdancewic](https://www.cis.upenn.edu/~stevez/), University of Pennsylvania, USA +--- **Previous CPP Conferences** * [CPP 2024](https://popl24.sigplan.org/home/CPP-2024), London, UK, January 15-16, 2024 (co-located with POPL’24) @@ -39,3 +40,51 @@ Certified Programs and Proofs (CPP) is an international conference on practical * [CPP 2013](https://dblp2.uni-trier.de/db/conf/cpp/cpp2013.html), Melbourne, Australia, December 11-13, 2013 (co-located with APLAS’13) * [CPP 2012](http://cpp12.kuis.kyoto-u.ac.jp), Kyoto, Japan, December 13-15, 2012 (collocation with APLAS’12) * [CPP 2011](https://dblp.uni-trier.de/db/conf/cpp/cpp2011.html), Kenting, Taiwan, December 7-9, 2011 (co-located with APLAS’11) + +--- +**Given Distinguished Paper Awards** + +* CPP 2024: [Formal Probabilistic Methods for Combinatorial Structures using the Lovász Local Lemma](https://popl24.sigplan.org/details/CPP-2024-papers/7/Formal-Probabilistic-Methods-for-Combinatorial-Structures-using-the-Lov-sz-Local-Lemma). Chelsea Edmonds and Lawrence Paulson. +* CPP 2024: [Martin-Löf à la Coq](https://popl24.sigplan.org/details/CPP-2024-papers/12/Martin-L-f-la-Coq). Arthur Adjedj, Meven Lennon-Bertrand, Kenji Maillard, Pierre-Marie Pédrot, and Loïc Pujet. +* CPP 2024: [Rooting for Efficiency: Mechanised Reasoning about Array-Based Trees in Separation Logic](https://popl24.sigplan.org/details/CPP-2024-papers/5/Rooting-for-Efficiency-Mechanised-Reasoning-about-Array-Based-Trees-in-Separation-Logic). Qiyuan Zhao, George Pîrlea, Zhendong Ang, Umang Mathur, and Ilya Sergey. +* CPP 2023: [A Formalization of the Development Closedness Criterion for Left-Linear Term Rewrite Systems](https://popl23.sigplan.org/details/CPP-2023-papers/1/A-Formalization-of-the-Development-Closedness-Criterion-for-Left-Linear-Term-Rewrite-Systems). Christina Kohl and Aart Middeldorp. +* CPP 2023: [Computing Cohomology Rings in Cubical Agda](https://popl23.sigplan.org/details/CPP-2023-papers/11/Computing-Cohomology-Rings-in-Cubical-Agda). Thomas Lamiaux, Axel Ljungström, and Anders Mörtberg. +* CPP 2023: [Aesop: White-Box Best-First Proof Search for Lean](https://popl23.sigplan.org/details/CPP-2023-papers/5/Aesop-White-Box-Best-First-Proof-Search-for-Lean). Jannis Limperg, Asta Halkjær From. +* CPP 2022: [Specification and Verification of a Transient Stack](https://popl22.sigplan.org/details/CPP-2022-papers/22/Specification-and-Verification-of-a-Transient-Stack). Alexandre Moine, Arthur Charguéraud, and François Pottier. +* CPP 2022: [CertiStr: A Certified String Solver](https://popl22.sigplan.org/details/CPP-2022-papers/10/CertiStr-A-Certified-String-Solver). Shuanglong Kan, Anthony Widjaja Lin, Philipp Ruemmer, and Micha Schrader. +* CPP 2022: [Semantic cut elimination for the logic of bunched implications, formalized in Coq](https://popl22.sigplan.org/details/CPP-2022-papers/21/Semantic-cut-elimination-for-the-logic-of-bunched-implications-formalized-in-Coq). Dan Frumin. +* CPP 2021: [A Minimalistic Verified Bootstrapped Compiler (Proof Pearl)](https://popl21.sigplan.org/details/CPP-2021/6/A-Minimalistic-Verified-Bootstrapped-Compiler-Proof-Pearl-). Magnus O. Myreen. +* CPP 2021: [Formalizing the Ring of Witt Vectors](https://popl21.sigplan.org/details/CPP-2021/10/Formalizing-the-Ring-of-Witt-Vectors). Johan Commelin and Robert Y. Lewis. +* CPP 2021: [Machine-Checked Semantic Session Typing](https://popl21.sigplan.org/details/CPP-2021/5/Machine-Checked-Semantic-Session-Typing). Jonas Kastberg Hinrichsen, Daniël Louwrink, Robbert Krebbers, and Jesper Bengtson. + +**Given Amazing Reviewer Awards** + +* CPP 2023: [Théo Winterhalter](https://theowinterhalter.github.io) +* CPP 2023: [Anja Petković Komel](https://anjapetkovic.com) +* CPP 2022: [Armaël Guéneau](http://cambium.inria.fr/~agueneau/) +* CPP 2021: [Kathrin Stark](https://www.k-stark.de) + +**The CPP Manifesto (from 2011)** + +In this manifesto, we advocate for the creation of a new international conference in the area of formal methods and programming languages, called Certified Programs and Proofs (CPP). Certification here means formal, mechanized verification of some sort, preferably with the production of independently checkable certificates. CPP would target any research promoting formal development of certified software and proofs, that is: + +The development of certified or certifying programs +The development of certified mathematical theories +The development of new languages and tools for certified programming +New program logics, type systems, and semantics for certified code +New automated or interactive tools and provers for certification +Results assessed by an original open source formal development +Original teaching material based on a proof assistant +Software today is still developed without precise specification. A developer often starts the programming task with a rather informal specification. After careful engineering, the developer delivers a program that may not fully satisfy the specification. Extensive testing and debugging may shrink the gap between the two, but there is no assurance that the program accurately follows the specification. Such inaccuracy may not always be significant, but when a developer links a large number of such modules together, these “noises” may multiply, leading to a system that nobody can understand and manage. System software built this way often contains hard-to-find “zero-day vulnerabilities” that become easy targets for Stuxnet-like attacks. CPP aims to promote the development of new languages and tools for building certified programs and for making programming precise. + +Certified software consists of an executable program plus a formal proof that the software is free of bugs with respect to a particular dependability claim. With certified software, the dependability of a software system is measured by the actual formal claim that it is able to certify. Because the claim comes with a mechanized proof, the dependability can be checked independently and automatically in an extremely reliable way. The formal dependability claim can range from making almost no guarantee, to simple type safety property, or all the way to deep liveness, security, and correctness properties. It provides a great metric for comparing different techniques and making steady progress in constructing dependable software. + +The conventional wisdom is that certified software will never be practical because any real software must also rely on the underlying runtime system which is too low-level and complex to be verifiable. In recent years, however, there have been many advances in the theory and engineering of mechanized proof systems applied to verification of low-level code, including proof-carrying code, certified assembly programming, local reasoning and separation logic, certified linking of heterogeneous components, certified protocols, certified garbage collectors, certified or certifying compilation, and certified OS-kernels. CPP intends to be a driving force that would facilitate the rapid development of this exciting new area, and be a natural international forum for such work. + +The recent development in several areas of modern mathematics requires mathematical proofs containing enormous computation that cannot be verified by mathematicians in an entire lifetime. Such development has puzzled the mathematical community and prompted some of our colleagues in mathematics and computer science to start developing a new paradigm, formal mathematics, which requires proofs to be verified by a reliable theorem prover. As particular examples, such an effort has been made for the four-color theorem and has started for the sphere packing problem and the classification of finite groups. We believe that this emerging paradigm is the beginning of a new era. No essential existing theorem in computer science has yet been considered worth a similar effort, but it could well happen in the very near future. For example, existing results in security would often benefit from a formal development allowing us to exhibit the essential hypotheses under which the result really holds. CPP would again be a natural international forum for this kind of work, either in mathematics or in computer science, and would participate strongly in the emergence of this paradigm. + +On the other hand, there is a recent trend in computer science to formally prove new results in highly technical subjects such as computational logic, at least in part. In whichever scientific area, formal proofs have three major advantages: no assumption can be missing, as is sometimes the case; the result cannot be disputed by a wrong counterexample, as sometimes happens; and more importantly, a formal development often results in a better understanding of the proof or program, and hence results in easier and better implementation. This new trend is becoming strong in computer science work, but is not recognized yet as it should be by traditional conferences. CPP would be a natural forum promoting this trend. + +There are not many proof assistants around. There should be more, because progress benefits from competition. On the other hand, there is much theoretical work that could be implemented in the form of a proof assistant, but this does not really happen. One reason is that it is hard to publish a development work, especially when this requires a long-term effort as is the case for a proof assistant. It is even harder to publish work about libraries which, we all know, are fundamental for the success of a proof assistant. CPP would pay particular attention in publishing, publicizing, and promoting this kind of work. + +Finally, CPP also aims to be a publication arena for innovative teaching experiences, in computer science or mathematics, using proof assistants in an essential way. These experiences could be submitted in an innovative format to be defined. \ No newline at end of file From fe013f5aad6b5b94e7cd1f7427302e3f4f6ed81d Mon Sep 17 00:00:00 2001 From: Amin Timany Date: Fri, 22 Mar 2024 12:58:45 +0100 Subject: [PATCH 50/64] minor --- Conferences/CPP.md | 1 + 1 file changed, 1 insertion(+) diff --git a/Conferences/CPP.md b/Conferences/CPP.md index 4a6af9b..7bceacf 100644 --- a/Conferences/CPP.md +++ b/Conferences/CPP.md @@ -64,6 +64,7 @@ Certified Programs and Proofs (CPP) is an international conference on practical * CPP 2022: [Armaël Guéneau](http://cambium.inria.fr/~agueneau/) * CPP 2021: [Kathrin Stark](https://www.k-stark.de) +--- **The CPP Manifesto (from 2011)** In this manifesto, we advocate for the creation of a new international conference in the area of formal methods and programming languages, called Certified Programs and Proofs (CPP). Certification here means formal, mechanized verification of some sort, preferably with the production of independently checkable certificates. CPP would target any research promoting formal development of certified software and proofs, that is: From e78a109441097fcc0448de9cc864e0f8811283cf Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Thu, 28 Mar 2024 19:53:57 -0400 Subject: [PATCH 51/64] New affiliation for Alex Potanin --- _data/Committees.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_data/Committees.yaml b/_data/Committees.yaml index fbb4930..8666c2b 100644 --- a/_data/Committees.yaml +++ b/_data/Committees.yaml @@ -209,7 +209,7 @@ SPLASH Steering Committee: - Antony Hosking, Australian National University - Shriram Krishnamurthi, Brown - Mira Mezini, TU Darmstadt - - Alex Potanin, Victoria University of Wellington + - Alex Potanin, Australian National University - Hridesh Rajan, Iowa State University - Sukyoung Ryu, Korea Advanced Institute of Science and Technology - Manu Sridharan, UC Riverside From 00cfb32ca871e28d274accda41e866d6e01e1656 Mon Sep 17 00:00:00 2001 From: Apoorv Ingle <1269003+fxdpntthm@users.noreply.github.com> Date: Thu, 21 Mar 2024 13:21:12 -0500 Subject: [PATCH 52/64] Create AV/index.md Co-authored-by: Adrian Sampson --- AV/index.md | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 AV/index.md diff --git a/AV/index.md b/AV/index.md new file mode 100644 index 0000000..1f1a682 --- /dev/null +++ b/AV/index.md @@ -0,0 +1,37 @@ +--- +layout: default +title: "SIGPLAN-AV" +--- + +SIGPLAN-AV is a subcommitee of SIGPLAN whose goal is to centralize the efforts of finding innovative and cost effective ways to: + 1. enable remote participation (hybridization of conferences), and; + 2. record conference talks for archival + +#### Current Members + +1. Bhakti Shah +2. Chris Lam +3. Jan-Paul Ramos +4. John Hui +5. Zixian Cai +6. Guilherme Espada +7. Apoorv Ingle + +#### Past Members + +1. Lief Anderson +2. Benjamin Chung (and many more) + + +#### For general chairs + +If you are a general chair of a SIGPLAN conference and are interested in using SIGPLAN-AV please email . + +SIGPLAN owns enough hardware (laptops, cameras and microphones) which can be used to setup streaming and recording of upto 8 parallel co-located events. + +It is advisable to include the AV team atleast 3 months in advance, ideally before the contract with the conference venue is finalized to enable smooth functioning. + + +#### For Prospective members + +If you are interested in helping us, we are always looking for more volunteers to help us at conferences! Please get in touch with us using the above email. From c1cb81668df00081824e732c438e520f55aabdc3 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Fri, 5 Apr 2024 15:25:58 -0400 Subject: [PATCH 53/64] TOC --- OpenTOC/exhet24.html | 97 ++++++++++++++++++++++++++++++++++++++++++++ _data/OpenTOC.yaml | 4 ++ 2 files changed, 101 insertions(+) create mode 100644 OpenTOC/exhet24.html diff --git a/OpenTOC/exhet24.html b/OpenTOC/exhet24.html new file mode 100644 index 0000000..4af84a2 --- /dev/null +++ b/OpenTOC/exhet24.html @@ -0,0 +1,97 @@ +ExHET '24: Proceedings of the 3rd International Workshop on Extreme Heterogeneity Solutions

ExHET '24: Proceedings of the 3rd International Workshop on Extreme Heterogeneity Solutions

+ Full Citation in the ACM Digital Library +

SESSION: Publications

+

GPU-Initiated Resource Allocation for Irregular Workloads

  • Ilyas Turimbetov
  • Muhammad Aditya Sasongko
  • Didem Unat
+

GPU kernels may suffer from resource underutilization in multi-GPU systems due to insufficient workload to saturate devices when incorporated within an irregular application. To better utilize the resources in multi-GPU systems, we propose a GPU-sided resource allocation method that can increase or decrease the number of GPUs in use as the workload changes over time. Our method employs GPU-to-CPU callbacks to allow GPU device(s) to request additional devices while the kernel execution is in flight. We implemented and tested multiple callback methods required for GPU-initiated workload offloading to other devices and measured their overheads on Nvidia and AMD platforms. To showcase the usage of callbacks in irregular applications, we implemented Breadth-First Search (BFS) that uses device-initiated workload offloading. Apart from allowing dynamic device allocation in persistently running kernels, it reduces time to solution on average by 15.7% at the cost of callback overheads with a minimum of 6.50 microseconds on AMD and 4.83 microseconds on Nvidia, depending on the chosen callback mechanism. Moreover, the proposed model can reduce the total device usage by up to 35%, which is associated with higher energy efficiency.

+
+ + +

Enhancing Intra-Node GPU-to-GPU Performance in MPI+UCX through Multi-Path Communication

  • Amirhossein Sojoodi
  • Yiltan H. Temucin
  • Ahmad Afsahi
+

Efficient communication among GPUs is crucial for achieving high performance in modern GPU-accelerated applications. This paper introduces a multi-path communication framework within the MPI+UCX library to enhance P2P communication performance between intra-node GPUs, by concurrently leveraging multiple paths, including available NVLinks and PCIe through the host. Through extensive experiments, we demonstrate significant performance gains achieved by our approach, surpassing baseline P2P communication methods. More specifically, in a 4-GPU node, multi-path P2P improves UCX Put bandwidth by up to 2.85x when utilizing the host path and 2 other GPU paths. Furthermore, we demonstrate the effectiveness of our approach in accelerating the Jacobi iterative solver, achieving up to 1.27x runtime speedup.

+
+ + +

Preparing for Future Heterogeneous Systems Using Migrating Threads

  • Peter Michael Kogge
  • Jayden Vap
  • Derek Pepple
+

Heterogeneity in computing systems is clearly increasing, especially as “accelerators” burrow deeper and deeper into different parts of an architecture. What is new, however, is a rapid change in not only the number of such heterogeneous processors, but in their connectivity to other structures, such as cores with different ISAs or smart memory interfaces. Technologies such as chiplets are accelerating this trend. This paper is focused on the problem of how to architect efficient systems that combine multiple heterogeneous concurrent threads, especially when the underlying heterogeneous cores are separated by networks or have no shared-memory access paths. The goal is to eliminate today’s need to invoke significant software stacks to cross any of these boundaries. A suggestion is made of using migrating threads as the glue. Two experiments are described: using a heterogeneous platform where all threads share the same memory to solve a rich ML problem, and a fast PageRank approximation that mirrors the kind of computation for which thread migration may be useful. Architectural “lessons learned” are developed that should help guide future development of such systems.

+
+ +
\ No newline at end of file diff --git a/_data/OpenTOC.yaml b/_data/OpenTOC.yaml index 571b2cc..6817ba5 100644 --- a/_data/OpenTOC.yaml +++ b/_data/OpenTOC.yaml @@ -1373,3 +1373,7 @@ event: PMAM year: 2024 title: "Proceedings of the 15th International Workshop on Programming Models and Applications for Multicores and Manycores" +- + event: ExHET + year: 2024 + title: "Proceedings of the 3rd International Workshop on Extreme Heterogeneity Solutions" From 0c739cfe17ec80495d95dc06baf3509d724752e5 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Fri, 5 Apr 2024 15:28:06 -0400 Subject: [PATCH 54/64] Add link to AV page --- _data/Links.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/_data/Links.yaml b/_data/Links.yaml index 32fdc26..d401880 100644 --- a/_data/Links.yaml +++ b/_data/Links.yaml @@ -36,6 +36,7 @@ Conference Information: - Sponsorship Proposal - In-cooperation Proposal - PACMPL +- Audio/Video Policies: - SIGPLAN Conference Policies From 7d34c90e162e9f12e245a7d239043c3f5486ed4c Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Sun, 14 Apr 2024 16:24:53 -0400 Subject: [PATCH 55/64] Announce --- _announce/2024-03-15-oopsla_2024.txt | 321 ++++++++++++++++++ _announce/2024-03-17-smt_2024.txt | 46 +++ _announce/2024-03-21-pact_2024.txt | 102 ++++++ _announce/2024-03-25-mit_plr_2024.txt | 17 + _announce/2024-04-03-pldi_2024.txt | 98 ++++++ _announce/2024-04-04-farm_2024.txt | 140 ++++++++ _announce/2024-04-08-concur_2024.txt | 97 ++++++ _announce/2024-04-08-sigmetrics_ifip_2024.txt | 133 ++++++++ _announce/2024-04-10-lipari_ss.txt | 35 ++ 9 files changed, 989 insertions(+) create mode 100644 _announce/2024-03-15-oopsla_2024.txt create mode 100644 _announce/2024-03-17-smt_2024.txt create mode 100644 _announce/2024-03-21-pact_2024.txt create mode 100644 _announce/2024-03-25-mit_plr_2024.txt create mode 100644 _announce/2024-04-03-pldi_2024.txt create mode 100644 _announce/2024-04-04-farm_2024.txt create mode 100644 _announce/2024-04-08-concur_2024.txt create mode 100644 _announce/2024-04-08-sigmetrics_ifip_2024.txt create mode 100644 _announce/2024-04-10-lipari_ss.txt diff --git a/_announce/2024-03-15-oopsla_2024.txt b/_announce/2024-03-15-oopsla_2024.txt new file mode 100644 index 0000000..ba82cba --- /dev/null +++ b/_announce/2024-03-15-oopsla_2024.txt @@ -0,0 +1,321 @@ +--- +title: "Call for Papers -- Object-oriented Programming, Systems, Languages, and Applications 2024" +timestamp: "3/15/2024 19:27:38" +deadline: "4/5/2024" +--- +======================================================================== + PACMPL Issue OOPSLA 2024 + + Call for Papers + + OOPSLA 2024 will be held as part of +The ACM Conference on Systems, Programming, Languages, and Applications: + Software for Humanity (SPLASH'24) + + October 20-25, 2024, Pasadena, California, United States + + https://2024.splashcon.org/track/splash-2024-oopsla +======================================================================== + +### Important dates + +#### ROUND 2: +Submission Deadline: Fri Apr 5, 2024 +Author Response: Mon Jun 3 - Wed Jun 5, 2024 +Author Notification: Fri Jun 21, 2024 +Artifact Submission: Fri Jul 5, 2024 +Artifact kick-tires: Sat Jul 6 - Fri Jul 19, 2024 +Submission of Revisions: Sun Aug 4, 2024 +Author Notification of Revisions: Sun Aug 18, 2024 +Artifact Notification: Fri Aug 23, 2024 +Camera Ready: Sun Sep 1, 2024 + + +Papers accepted at either of the rounds will be published in the 2024 +volume of PACMPL(OOPSLA) and invited to be presented at the SPLASH +conference in October 2024. + +### Scope + +The OOPSLA issue of the Proceedings of the ACM on Programming Languages +(PACMPL) welcomes papers focusing on all practical and theoretical +investigations of programming languages, systems and environments. +Papers may target any stage of software development, including +requirements, modelling, prototyping, design, implementation, +generation, analysis, verification, testing, evaluation, maintenance, +and reuse of software systems. Contributions may include the +development of new tools, techniques, principles, and evaluations. + +#### Review Process + +PACMPL(OOPSLA) has two rounds of reviewing with submission deadlines +around October and April each year. As you submit your paper you will +receive around three reviews and an opportunity to provide an author +response that will be read and addressed by the reviewers in the final +decision outcome summary. There are 5 possible outcomes at the end of +the round: + +*Accept*: Your paper will appear in the upcoming volume of PACMPL +(OOPSLA). + +*Conditional Accept*: You will receive a list of required revisions +that you will need to address. You must submit a revised paper, a clear +explanation of how your revision addresses these comments, and +"if possible" a diff of the PDF as supplementary material. Assuming +you meet the listed requirements, after further review by the same +reviewers, your paper will very likely be accepted. This process +*has to be completed within two months of the initial decision* for the +paper to be accepted, so we encourage timely turnaround in case +revisions take more than one cycle to be accepted. + +*Minor Revision*: The reviewers have concerns that go beyond what can +be enumerated in a list. Therefore, while you may receive a list of +revisions suggested by the reviewers, this will not necessarily be +comprehensive. You will have the opportunity to resubmit your revised +paper and have it re-reviewed by the same reviewers, which may or may +not result in your paper's acceptance. When you resubmit, you should +clearly explain how the revisions address the comments of the +reviewers, by including a document describing the changes and "if +possible" a diff of the PDF as supplementary material. This process +*has to be completed within two months of the initial decision* for the +paper to be accepted in the current round, so we encourage timely +turnaround in case revisions take more than one cycle to be accepted. + +*Major Revision*: You will receive a list of revisions suggested by the +reviewers. Papers in this category are *invited to submit a revision +to the next round of submissions* with a specific set of expectations +to be met. When you resubmit, you should clearly explain how the +revisions address the comments of the reviewers, by including a +document describing the changes and "if possible" a diff of the PDF as +supplementary material. The revised paper will be re-evaluated in the +next round. Resubmitted papers will retain the same reviewers +throughout the process to the extent possible. + +*Reject*: Rejected papers will not be included in the upcoming volume +of PACMPL(OOPSLA). Papers in this category are not guaranteed a review +if resubmitted less than one year from the date of the original +submission. A paper will be judged to be a resubmission if it is +substantially similar to the original submission. The Chairs will +decide whether or not a paper is a resubmission of the same work. + +### Submissions + +Submitted papers must be at most **23 pages** in 10 point font. There +is no page limit on references. No appendices are allowed on the main +paper, instead authors can upload supplementary material with no page +or content restrictions, but reviewers may choose to ignore it. +Submissions must adhere to the "ACM Small" template available from +[the ACM](http://www.acm.org/publications/authors/submissions). Papers +are expected to use author-year citations. Author-year citations may be +used as either a noun phrase, such as "The lambda calculus was +originally conceived by Church (1932)", or a parenthetic phase, such +as "The lambda calculus (Church 1932) was intended as a foundation for +mathematics". + +PACMPL uses double-blind reviewing. Authors' identities are only +revealed if a paper is accepted. Papers must + +1. omit author names and institutions, +2. use the third person when referencing your work, +3. anonymise supplementary material. + +Nothing should be done in the name of anonymity that weakens the +submission; see the DBR FAQ. When in doubt, contact the Review +Committee Chairs. + +Papers must describe unpublished work that is not currently submitted +for publication elsewhere as described by [SIGPLAN's Republication +Policy](http://www.sigplan.org/Resources/Policies/Republication). +Submitters should also be aware of [ACM's Policy and Procedures on +Plagiarism](http://www.acm.org/publications/policies/plagiarism_policy). +Submissions are expected to comply with the [ACM Policies for +Authorship](https://www.acm.org/publications/authors/information-for-authors). + +#### Artifacts + +Authors should indicate with their initial submission if an artifact +exists, describe its nature and limitations, and indicate if it will +be submitted for evaluation. Accepted papers that fail to provide an +artifact will be requested to explain the reason they cannot support +replication. It is understood that some papers have no artifacts. +Please note that the artifact submission deadline will be following +closely the paper submission deadline so make sure you check the +Artifact Call as soon as you submit your paper to PACMPL(OOPSLA). + +##### Data-Availability Statement + +To help readers find data and software, OOPSLA recommends adding a +section just before the references titled Data-Availability Statement. +If the paper has an artifact, cite it here. If there is no artifact, +this section can explain how to obtain relevant code. The statement +does not count toward the OOPSLA 2024 page limit. It may be included +in the submitted paper; in fact we encourage this, even if the DOI is +not ready yet. + +Example: + +\section{Conclusion} +.... + +\section*{Data-Availability Statement} +The software that supports~\cref{s:design,s:evaluation} +is available on Software Heritage~\cite{artifact-swh} +and Zenodo~\cite{artifact-doi}. + +\begin{acks} +.... + +#### Expert PC Members + +During the submission, we will ask you to list up to 3 non-conflicted +PC members who you think are experts on the topic of this submission, +starting with the most expert. This list will not be used as an input +during the paper assignment and it will not be visible to the PC. It +may be used by the PC Chair and Associate Chairs for advice on +external experts if the paper lacks expert reviews. + +### Publication + +PACMPL is a Gold Open Access journal, all papers will be freely +available to the public. Authors can voluntarily cover the article +processing charge ($400 USD), but payment is not required. The +official publication date is the date the journal is made available in +the ACM Digital Library. The journal issue and associated papers may +be published up to two weeks prior to the first day of the conference. +The official publication date affects the deadline for any patent +filings related to published work. + +By submitting your article to an ACM Publication, you are +acknowledging that you and your co-authors are subject to all [ACM +Publications Policies](https://www.acm.org/publications/policies), +including ACM’s [new Publications Policy on Research Involving Human +Participants and Subjects](https://www.acm.org/publications/policies/research-involving-human-participants-and-subjects). +Alleged violations of this policy or an ACM Publications Policy will +be investigated by ACM and may result in a full retraction of your +paper, in addition to other potential penalties, as per ACM +Publications Policy. + +Please ensure that you and your co-authors obtain [an ORCID ID](https://orcid.org/register), +so you can complete the publishing process for your accepted paper. +ACM has been involved in ORCID from the start and we have recently +made a [commitment to collect ORCID IDs from all of our published +authors](https://authors.acm.org/author-resources/orcid-faqs). +We are committed to improving author discoverability, ensuring proper +attribution and contributing to ongoing community efforts around name +normalization; your ORCID ID will help in these efforts. + +The ACM Publications Board has recently updated the ACM Authorship +Policy in several ways: + +- Addressing the use of generative AI systems in the publications +process +- Clarifying criteria for authorship and the responsibilities of +authors +- Defining prohibited behaviour, such as gift, ghost, or purchased +authorship +- Providing a linked FAQ explaining the rationale for the policy and +providing additional details + +You can find the updated policy here: + +[https://www.acm.org/publications/policies/new-acm-policy-on-authorship](https://www.acm.org/publications/policies/new-acm-policy-on-authorship) + +##### Review Committee + +Review Committee Chairs: + +Alex Potanin, Australian National University, Australia +Bor-Yuh Evan Chang, University of Colorado Boulder, USA + +Review Committee Associate Chairs: + +Anders Møller, Aarhus University, Denmark +Lingming Zhang, UIUC, USA + +Review Committee: + +Aleksandar Nanevski, IMDEA Software Institute, Spain +Alex Summers, University of British Columbia, Canada +Alexandra Bugariu, ETH Zurich, Switzerland +Ana Milanova, Rensselaer Polytechnic Institute, USA +Andreas Zeller, CISPA Helmholtz Center for Information Security, Germany +Anitha Gollamudi, UMass, USA +Ankush Desai, AWS, USA +Ashish Tiwari, Microsoft Research, USA +Ben Hermann, TU Dortmund, Germany +Ben Titzer, CMU, USA +Benjamin Delaware, Purdue University, USA +Bernardo Toninho, Universidade Nova de Lisboa, Portugal +Bruno C. d. S. Oliveira, U. Hong Kong, Hong Kong +Burcu Kulahcioglu Ozkan, Delft University of Technology, The Netherlands +Casper Bach Poulsen, Delft University of Technology, Netherlands +Colin Gordon, Drexel University, USA +Corina Pasarenau, NASA, USA +Cyrus Omar, University of Michigan, USA +Damien Zufferey, Sonar Source, Switzerland +Dana Drachsler Cohen, Technion, Israel +David Darais, Galois, USA +David Pearce, ConsenSys, New Zealand +Di Wang, Peking University, China +Emma Söderberg, Lund University, Sweden +Emma Tosch, Northeastern University, USA +Fabian Muehlboeck, Australian National University, Australia +Fei He, Tsinghua University, China +Filip Niksic, Google, USA +Fredrik Kjolstad, Stanford University, USA +Guido Salvaneschi, University of St. Gallen, Switzerland +Hila Peleg, Technion, Israel +Jiasi Shen, The Hong Kong University of Science and Technology, China (Hong Kong) +Jonathan Bell, Northeastern University, USA +Jonathan Brachthäuser, University of Tübingen, Germany +Joseph Tassarotti, New York University, USA +Justin Hsu, Cornell University, USA +Karine Even-Mendoza, King's College London, UK +Kenji Maillard, Inria Rennes, France +Matthew Flatt, U. Utah, USA +Matthew Parkinson, Microsoft, UK +Max Schaefer, GitHub, UK +Michael Coblenz, UCSD, USA +Milos Gligoric, UT Austin, USA +Minseok Jeon, Korea University, Korea +Mohamed Faouzi Atig, Uppsala University, Sweden +Owolabi Legunsen, Cornell University, USA +Pamela Zave, AT&T Laboratories, USA +Pavel Panchekha, University of Utah, USA +Rahul Gopinath, University of Sydney, Australia +Rajiv Gupta, UC Riverside, USA +Saman Amarasinghe, MIT, USA +Santosh Pande, Georgia Institute of Technology, USA +Sean Treichler, NVIDIA, USA +Shachar Itzhaky, Technion, Israel +Shaz Qadeer, Facebook, USA +Sheng Chen, University of Louisiana at Lafayette, USA +Shigeru Chiba, University of Tokyo, Japan +Shriram Krishnamurthi, Brown University, USA +Sreepathi Pai, University of Rochester, USA +Stefan Brunthaler, University of the Federal Armed Forces in Munchen, Germany +Steve Blackburn, Google, Australia +Subhajit Roy, IIT Kanpur, India +Sukyoung Ryu, KAIST, Korea +Swarnendu Biswas, IIT Kanpur, India +Thanh Vu Nguyen, George Mason University, USA +Tiark Rompf, Purdue, USA +Tien Nguyen, University of Texas at Dallas, USA +Tomas Petricek, Charles University, Czech Republic +Umut Acar, CMU, USA +Wei Le, Iowa State, USA +Wei Zhang , Meta, USA +Xiaokang Qiu, Purdue University, USA +Yingfei Xiong, Peking University, China +Yizhou Zhang, University of Waterloo, Canada +Youyou Cong, Tokyo Institute of Technology, Japan +Yu David Liu, Binghamton, USA +Yu Feng, UCSB, USA +Yuepeng Wang, Simon Fraser University, Canada + +##### Artifact Evaluation Committee + +Artifact Evaluation Committee Chairs: + +Guillaume Baudart, Inria - École normale supérieure, France +Sankha Narayan Guria, University of Kansas, USA diff --git a/_announce/2024-03-17-smt_2024.txt b/_announce/2024-03-17-smt_2024.txt new file mode 100644 index 0000000..4c818c3 --- /dev/null +++ b/_announce/2024-03-17-smt_2024.txt @@ -0,0 +1,46 @@ +--- +title: "Call for Papers, SMT 2024" +timestamp: "3/17/2024 10:49:42" +deadline: "4/17/2024" +--- +======================================================== +SMT 2024: 22nd International Workshop on Satisfiability Modulo Theories +Montreal, Canada, July 22-23, 2024 +======================================================== + +Paper Submission: April 28, 2024 11.59 pm AoE (Anywhere on Earth) +Notification: June 1, 2024 +Conference website http://smt-workshop.cs.uiowa.edu/2024/ +Submission link https://easychair.org/conferences/?conf=smt2024 + +== Overview +The aim of the workshop is to bring together researchers and users of SMT tools and techniques. Relevant topics include but are not limited to: +- Decision procedures and theories of interest +- Combinations of decision procedures +- Novel implementation techniques +- Applications and case studies +- Benchmarks and evaluation methodologies +- Theoretical results + +== Paper submission and Proceedings + +Three categories of submissions are invited: + +1. Extended abstracts : given the informal style of the workshop, we strongly encourage the submission of preliminary reports of work in progress. They may range in length from very short (a couple of pages) to the full 10 pages and they will be judged based on the expected level of interest for the SMT community. They will be included in the informal proceedings. + +2. Original papers: contain original research (simultaneous submissions are not allowed) and sufficient detail to assess the merits and relevance of the submission. For papers reporting experimental results, authors are strongly encouraged to make their data available. + +3. Presentation-only papers: describe work recently published or submitted and will not be included in the proceedings. We see this as a way to provide additional access to important developments that SMT Workshop attendees may be unaware of. + +Papers in all three categories will be peer-reviewed. Extended abstracts and original papers should not exceed 10 pages. All papers should be in standard-conforming PDF. Technical details may be included in an appendix to be read at the reviewers' discretion. Final versions should be prepared in LaTeX using the easychair.cls class file. (The 10 page limit does not include references.). Presentation-only papers may be submitted as originally published, if published elsewhere, and should not exceed 10 pages otherwise. + +== Invited Speakers +TBD + +== Program Chairs +Giles Reger - Amazon Web Services +Yoni Zohar - Bar-Ilan University + +== Program Committee +TBD + diff --git a/_announce/2024-03-21-pact_2024.txt b/_announce/2024-03-21-pact_2024.txt new file mode 100644 index 0000000..e120f0d --- /dev/null +++ b/_announce/2024-03-21-pact_2024.txt @@ -0,0 +1,102 @@ +--- +title: "Extended Submission Deadline, The International Conference on Parallel Architectures and Compilation Techniques (PACT) 2024" +timestamp: "3/21/2024 2:10:42" +deadline: "4/1/2024" +--- +PACT 2024 will be held in Long Beach, California, USA, 13-16 October, 2024. +PACT 2024 includes a New Call for Tools and Practical Experience Papers + +## Scope + +The International Conference on Parallel Architectures and Compilation Techniques (PACT) is a unique technical conference sitting at the intersection of hardware and software, with a special emphasis on parallelism. The PACT conference series brings together researchers from computer architectures, compilers, execution environments, programming languages, and applications, to present and discuss their latest research results. + +PACT 2024 will be held as an in-person event in Long Beach, California, USA. At least one of the authors of accepted papers will be required to attend the conference, and we encourage all the authors to participate. + +## Specific topics of interest include (but are not limited to): + ++ Parallel architectures, including accelerator architectures for AI or other domains ++ Compilers and tools for parallel architectures (as above) ++ Applications and experimental systems studies of parallel processing ++ Computational models for concurrent execution ++ Multicore, multithreaded, superscalar, and VLIW architectures ++ Compiler and hardware support for hiding memory latencies ++ Support for correctness in hardware and software ++ Reconfigurable parallel computing ++ Dynamic translation and optimization ++ I/O issues in parallel computing and their relation to applications ++ Parallel programming languages, algorithms, and applications ++ Middleware and run-time system support for parallel computing ++ Application-specific parallel systems ++ Distributed computing architectures and systems ++ Heterogeneous systems using various types of accelerators ++ In-core and in-chip accelerators and their exploitation ++ Applications of machine learning to parallel computing ++ Large scale data processing, including computing in memory accelerators ++ Insights for the design of parallel architectures and compilers from modern parallel applications PACT for Quantum and Neurmorphic ++ Neuromorphic computing both as an application for and a tool applied to architectures and compilers ++ Quantum computing architectures and compilers. + +In addition to the regular research papers, PACT 2024 has a special category of papers called “tools and practical experience” (TPE). Such papers are subject to the same page length guidelines and will be reviewed by the same Program Committee. +TPE papers focus on applicability (such as traditional methods employed in emerging fields), exposing challenges and experiences the industry is facing as an opportunity to steer the research. A TPE paper must clearly explain its functionality, provide a summary about the practice experience with realistic case studies, and describe all thesupporting artifacts available (if relevant). The selection criteria are: + ++ Originality: Papers should present PACT-related technologies applied to real-world problems with scope or characteristics that set them apart from previous solutions. ++ Usability: The presented Tools or compilers should have broad usage or applicability. They are expected to assist in PACT-related research, or could be extended to investigate or demonstrate new technologies. If significant components are not yet implemented, the paper will not be considered. ++ Documentation: The tool or compiler should be presented on a web-site giving documentation and further information about the tool. ++ Benchmark Repository: A suite of benchmarks for testing should be provided. ++ Availability: Preferences will be given to tools or compilers that are freely available (at either the source or binary level). Exceptions may be made for industry and commercial tools that cannot be made publicly available for business reasons. ++ Foundations: Papers should incorporate the principles underpinning Parallel Architectures and Compilation Techniques (PACT). However, a thorough discussion of theoretical foundations is not required; a summary of such should suffice. + +## Key dates + ++ Abstract submission deadline: Mar 25, 2024 ++ Paper submission deadline: Apr 1, 2024 ++ Rebuttal period: Jun 3-9, 2024 ++ Author notification: Jul 1, 2024 ++ Artifact submission: Jul 8, 2024 ++ Camera ready papers: Aug 10, 2024 + +*All deadlines are firm at midnight anywhere on earth (AoE)* + +## General co-chairs + +Rajiv Gupta, University of California, Riverside +Nael Abu-Ghazaleh, University of California, Riverside + +## Program Chairs: + +Stefanos Kaxiras, Uppsala University +Alexandra Jimborean, University of Murcia + +## Workshop/Tutorial Chair + +Hoda Naghibijouybari, Binghamton University + +## ACM Student Research Competition Chair: + +Samira Ajorpaz, NCSU + +## Travel Grant Chair: + +Changhee Jung, Purdue University + +## Publications Chair: + +Jongouk Choi, UCF + +## Publicity Co-Chairs: + +Americas: Khaled Khasawneh, George Mason University +Europe: Ihsen Alouani, Queen’s University Belfast + +## Web Chair: + +Daniel Wong, University of California, Riverside + +## Webmaster: + +Pedram Zaree, University of California, Riverside + +## Call for Papers + +See the full CFP: +https://pact2024.github.io/submit/ diff --git a/_announce/2024-03-25-mit_plr_2024.txt b/_announce/2024-03-25-mit_plr_2024.txt new file mode 100644 index 0000000..544fe05 --- /dev/null +++ b/_announce/2024-03-25-mit_plr_2024.txt @@ -0,0 +1,17 @@ +--- +title: "Call for Participation, MIT Programming Languages Review 2024" +timestamp: "3/25/2024 13:01:22" +start: "5/4/2024" +end: "5/4/2024" +--- +Save the date! + +Come join us for this year's MIT Programming Languages Review workshop on May 4th! Registration is now open: https://mit.co1.qualtrics.com/jfe/form/SV_dlZXiXeYScmhc9M + +The MIT PLR is a student-run committee that aims to highlight recent developments that we believe have significant potential to shape the future direction of PL research and/or industry practice. We aim to select papers that may substantially transform the PL community and beyond, with a focus on emerging trends rather than established lines of research. + +Stay tuned for our full program details and selected papers here: http://plr.csail.mit.edu/ + +To get a sense of what this year might offer, take a look at last year's program here: https://plr.csail.mit.edu/plr2023.html + +We hope to see you there! diff --git a/_announce/2024-04-03-pldi_2024.txt b/_announce/2024-04-03-pldi_2024.txt new file mode 100644 index 0000000..fef75dc --- /dev/null +++ b/_announce/2024-04-03-pldi_2024.txt @@ -0,0 +1,98 @@ +--- +title: "Call for Participation, ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2024)" +timestamp: "4/3/2024 1:34:06" +start: "6/24/2024" +end: "6/28/2024" +--- +PLDI is a premier forum for programming language research, broadly construed, +including design, implementation, theory, applications, and performance. Come +join us, online or in Copenhagen, Denmark, to discuss the latest programming +languages research! + +* Website : https://pldi24.sigplan.org/attending/registration +* Time : Mon 24--Fri 28 June 2024 +* Place : Radisson Blu Scandinavia, Amager Boulevard 70, 2300 Copenhagen S, + Denmark + +### Important dates + +* Early Registration: 15th of May, 2024 + +### Important rates (Registration rates include a 25% VAT; The prices displayed include tax) + +Registration rates (in-person) On or before 15 May, 2024 After 15 May, 2024 +Regular (ACM or SIGPLAN member) €770.00 €850.00 +Regular (non-member) €850.00 €935.00 +Student (ACM or SIGPLAN member) €425.00 €505.00 +Student (non-member) €475.00 €540.00 + +Registration rates (virtual) On or before 15 May, 2024 After 15 May, 2024 +Regular (ACM or SIGPLAN member) €37.50 €50.00 +Regular (non-member) €37.50 €50.00 +Student (ACM or SIGPLAN member) €37.50 €50.00 +Student (non-member) €37.50 €50.00 + +1-Day Pass (Co-Located events) On or before 15 May, 2024 After 15 May, 2024 +Regular (ACM or SIGPLAN member) €225.00 €250.00 +Regular (non-member) €250.00 €275.00 +Student (ACM or SIGPLAN member) €150.00 €175.00 +Student (non-member) €175.00 €200.00 + + +### Co-located events: + +Co-located Conferences: +- ISMM, ACM SIGPLAN International Symposium on Memory Management + https://conf.researchr.org/home/ismm-2024 +- LCTES, ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, and Tools for Embedded Systems + https://pldi24.sigplan.org/home/LCTES-2024 + +Workshops: +- ARRAY, the Array Programming Workshop + https://pldi24.sigplan.org/home/ARRAY-2024 +- CP, International Workshop on Choreographic Programming + https://pldi24.sigplan.org/home/cp-2024 +- EGRAPH, the E-Graph Research, Applications, Practices, and Human-factors Symposium + https://pldi24.sigplan.org/home/egraphs-2024 +- Infer, the Infer Practitioners Workshop + https://pldi24.sigplan.org/home/infer-2024 +- PLMW, the Programming Languages Mentoring Workshop + https://pldi24.sigplan.org/track/PLMW-PLDI-2024 +- PODELSKI, PLDI 2024 Workshop Honoring Andreas Podelsk + https://pldi24.sigplan.org/home/podelski-2024 +- RTFM, Red-Hot Topics in Faculty Mentoring + https://pldi24.sigplan.org/home/rtfm-2024 +- SOAP, the ACM SIGPLAN International Workshop on the State Of the Art in Program Analysis + https://pldi24.sigplan.org/home/SOAP-2024 +- Sparse, the Sparse workshop (formerly CTSTA) + https://pldi24.sigplan.org/home/sparse-2024 +- WQS, Workshop on Quantum Software + https://pldi24.sigplan.org/home/wqs-2024 + +Tutorials: +https://pldi24.sigplan.org/track/pldi-2024-tutorials + +- Algorithms and Applications for Provable Repair of Deep Neural Networks + Aditya V. Thakur +- Concurrent Algorithms in Kotlin Coroutines + Nikita Koval +- Democratizing DSL development with the BuildIt Framework + Ajay Brahmakshatriya, Saman Amarasinghe +- PODELSKI + Thomas Wies, Martin Schäf, Andrey Rybalchenko +- Quick and dirty development of static analyses with LiSA + Luca Negrini, Pietro Ferrara +- Static Code Analysis with SootUp + Eric Bodden, Markus Schmidt, Jonas Klauke, Kadiray Karakaya, Stefan Schott + +Student Research Competition! +https://pldi24.sigplan.org/track/pldi-2024-src + +### Student Volunteering + +Sign up to be a Volunteer and help us make PLDI 2024 a great experience for all +attendants! + +https://pldi24.sigplan.org/track/pldi-2024-student-volunteering + +Apply here: https://forms.gle/QB9Tdmhr9v9ZPGx9A. The deadline is 15th of April. diff --git a/_announce/2024-04-04-farm_2024.txt b/_announce/2024-04-04-farm_2024.txt new file mode 100644 index 0000000..edff57a --- /dev/null +++ b/_announce/2024-04-04-farm_2024.txt @@ -0,0 +1,140 @@ +--- +title: "Call for Papers: ACM Workshop on Functional Art, Music, Modelling and Design (Deadline June 1)" +timestamp: "4/4/2024 4:20:14" +deadline: "6/1/2024" +--- +=============================================================================== + 12th ACM SIGPLAN International Workshop on + Functional Art, Music, Modelling and Design + (FARM) + Call for Papers, Demos, and Performance + Milan, Italy, 2nd September 2024 + Deadline: June 1 + https://functional-art.org/2024 +=============================================================================== + +Key Dates +--------- + +Submission deadline June 1 (AoE) +Author notification July 1 +Camera-ready deadline July 15 +Workshop September 2 + +AUTHORS TAKE NOTE: +The official publication date is the date the proceedings are made +available in the ACM Digital Library. This date may be up to two weeks +prior to the first day of your conference. The official publication date +affects the deadline for any patent filings related to published work. + +Call for Papers +--------------- + +The ACM SIGPLAN International Workshop on Functional Art, Music, +Modelling and Design (FARM) encourages submissions from across art, +craft, and design, including textiles, visual art, music, 3D +sculpture, animation, GUIs, video games, 3D printing and architectural +models, choreography, poetry, and even VLSI layouts, GPU +configurations, or mechanical engineering designs. Theoretical +foundations, language design, implementation issues, and applications +in industry or the arts are all within the scope of the workshop. + +In addition to the main workshop, FARM hosts a traditional evening of +performances. Thus, this call encompasses both papers/demos for the +workshop (and its published proceedings) as well as performance +proposals for the evening's event. Authors are invited to make a +single submission for each. Authors may submit both a paper/demo and +performance proposal, but the submissions will be considered +independently. + +Note on Finances +---------------- + +Paid registration to the FARM workshop is usually required for paper +and demo submitters, but will be waived for performers. + +If you would have financial difficulty attending, you can apply for +conference “PAC” funds. Please get in touch for more information. + +Papers +------ + +Paper submissions are invited in three categories: + +- Original research +- Overview / state of the art +- Technology tutorial (especially tools and environments for distributed artistic workflow) + +Papers must be submitted via HotCRP (https://farm24.hotcrp.com) +and meet the following requirements: + +- 5 to 12 pages +- PDF format +- Adhere to the ACM SIGPLAN template + +Accepted papers will be published in the ACM Digital Library as part +of the FARM 2024 proceedings. + +Authors are encouraged to submit auxiliary material for publication +along with their paper (source code, data, videos, images, +etc.). Authors retain all rights to the auxiliary material. + +Demos +----- + +Demo submissions should describe a demonstration and its context, +connecting it with the themes of FARM. A demo could be in the form of +a short (10 to 20 minute) tutorial, a presentation of work in +progress, an exhibition of some work, or even a performance. + +Demos must be submitted via HotCRP (https://farm24.hotcrp.com) +and meet the following requirements: + +- 500 to 2000 words +- Have a title starting with “Demo: ” +- PDF format +- Adhere to the ACM SIGPLAN template (https://www.sigplan.org/Resources/ProceedingsFormat) + +Accepted demos will be published in the ACM Digital Library as part of +the FARM 2024 proceedings. + +Performances +------------ + +FARM seeks proposals for performances which employ programming +techniques (or are generated by programs), in whole or in part. We +invite a diverse range of functionally-themed submissions including +music, video, dance, and performance art. Both live performances and +fixed-media submissions are welcome. We encourage risk-taking +proposals that push forward the state of the art as well as refined +presentations of highly developed practice. In either case, please +support your submission with a clear description of your performance, +including how your performance employs functional programming and a +discussion of influences and prior art as appropriate. If desired, you +may use some of your performance time for a short lecture or +presentation; this must supplement, and not take the place of, a +primary performance. + +Performance proposals should be emailed to +performance@functional-art.org or submitted via HotCRP, and must +include: + +- A description of the performance (please be as specific as possible) +- An explanation of the use of functional programming in the work +- A list of technical requirements +- A link to an audio or video example (YouTube, Vimeo, Bandcamp, etc.) + +Accepted performances will be presented at the performance evening. + +Workshop Organization +--------------------- + +Program Chair: Mae Milano (Princeton University) +Workshop Chair: Stephen Taylor (University of Illinois Urbana-Champaign) + +Contact +------- + +For any questions, issues or comments, email +farm-2024@functional-art.org. + diff --git a/_announce/2024-04-08-concur_2024.txt b/_announce/2024-04-08-concur_2024.txt new file mode 100644 index 0000000..d290dc3 --- /dev/null +++ b/_announce/2024-04-08-concur_2024.txt @@ -0,0 +1,97 @@ +--- +title: "CONCUR 2024: Call for Papers (deadline April 26)" +timestamp: "4/8/2024 10:54:45" +deadline: "4/26/2024" +--- +============================ +CONCUR 2024: Call for Papers +============================ + +September 9-13, 2024 +Calgary, Canada +https://confest2024.github.io/CONCUR_call_for_papers.html + +Co-located with QEST+Formats as part of CONFEST 2024 +https://confest2024.github.io/ + +Overview +======== + +CONCUR conferences bring together researchers, developers, and +students interested in advancing the theory of concurrency, and its +applications. CONCUR 2024 solicits high quality papers reporting +research results and/or experience related to semantics, logics, +verification and analysis of concurrent systems. + +Important dates +=============== +(Times are Anywhere on Earth) +Paper Submission: April 26, 2024 +Rebuttal Response: June 4-6, 2024 +Notification: June 21, 2024 +Camera Ready: July 12, 2024 +Conference(s): September 9-13, 2024 +Workshops: Co-located with CONFEST (see the website for more info) + +Topics +====== +Submissions are solicited in the theory and practice of concurrent +systems. The principal topics include (but are not limited to): + +-- Basic models of concurrency such as abstract machines, +domain-theoretic models, categorical and coalgebraic models, +game-theoretic models, process algebras, graph transformation +systems, Petri nets, hybrid systems, mobile and collaborative +systems, probabilistic systems, real-time systems, quantum systems, +biology-inspired systems, and synchronous systems; + +-- Logics for concurrency such as modal logics, program logics, +probabilistic and stochastic logics, temporal logics, and resource +logics; + +-- Verification and analysis techniques for concurrent systems such +as abstract interpretation, atomicity checking, model checking, race +detection, pre-order and equivalence checking, run-time verification, +state-space exploration, static analysis, synthesis, testing, theorem +proving, type systems, and security analysis; + +-- Distributed algorithms and data structures: design, analysis, +complexity, correctness, fault tolerance, reliability, availability, +consistency, self-organization, self-stabilization, protocols; + +-- Theoretical foundations, tools, and empirical evaluations of +architectures, execution environments, and software development for +concurrent systems such as geo-replicated systems, communication +networks, multiprocessor and multi-core architectures, shared and +transactional memory, resource management and awareness, compilers +and tools for concurrent programming, programming models such as +component-based, object- and service-oriented. + +Paper Submission +================ + +-- All papers must be original, unpublished, and not submitted for +publication elsewhere. + +-- Each paper will undergo a thorough review process. The paper may +be supplemented with a clearly marked appendix, which will be reviewed +at the discretion of the program committee. + +-- The CONCUR 2024 proceedings will be published by LIPIcs. Papers +must be submitted electronically as PDF files via HotCRP. + +https://concur2024.hotcrp.com/ + +-- Submissions follow a light double blind process. Papers must not +exceed 14 pages (excluding references and clearly marked appendices) +using the LIPIcs style. + +Awards +====== + +In 2024, CONCUR Test-of-Time and best paper awards will be given for +the fourth time. The winners will be announced at the conference. + +If you have any questions, please contact the CONCUR 2024 PC chairs +Alexandra Silva (alexandra.silva@cornell.edu) or Rupak Majumdar +(rupak@mpi-sws.org). diff --git a/_announce/2024-04-08-sigmetrics_ifip_2024.txt b/_announce/2024-04-08-sigmetrics_ifip_2024.txt new file mode 100644 index 0000000..48e705e --- /dev/null +++ b/_announce/2024-04-08-sigmetrics_ifip_2024.txt @@ -0,0 +1,133 @@ +--- +title: "2024 ACM SIGMETRICS / IFIP Performance: Registration is Open" +timestamp: "4/8/2024 11:13:37" +start: "6/10/2024" +end: "6/14/2024" +--- +Dear SIGPLAN Members, + +Registration is now open for ACM SIGMETRICS / IFIP Performance 2024, +held June 10-14, 2024, at San Servolo Congress Center, Venice, Italy. +SIGMETRICS and Performance are respectively the flagship conferences +of the ACM special interest group for the computer systems performance +evaluation community and of the IFIP working group WG7.3 on +performance modeling and analysis. Every 3 years or so, the two +conferences join, and this is the 16th joint conference. We also +celebrate the 50th ACM SIGMETRICS conference. + +https://www.sigmetrics.org/sigmetrics2024/ + + +REGISTRATION +============ + +Registration is open at: +https://www.sigmetrics.org/sigmetrics2024/registration.html + +The Early Registration deadline is May 15, 2024 + +Please consider that June is high season for Venice. We recommend +booking your hotel at least a few months before the conference. + +Hotel agreements are available at: +https://www.sigmetrics.org/sigmetrics2024/accommodation.html + + +PROGRAM +======= + +Mon, June 10: Tutorials +Tue, June 11 to Thu, June 13: Main conference +Fri, June 14: Workshops + + +KEYNOTE SPEAKERS +================ + +- Michele Zorzi, University of Padova +- John Wilkes, Google + + +WORKSHOPS +========= + +28th International Conference on Analytical and Stochastic Modelling +Techniques and Applications (ASMTA 2024) + +20th European Performance Engineering Workshop (EPEW 2024) + +Learning-augmented Algorithms: Theory and Applications (LATA 2024) + +MAthematical performance Modeling and Analysis (MAMA 2024) + +Teaching Performance Analysis of Computer Systems (TeaPACS 2024) + + +ACCOMMODATION +============= + +The organizing committee has been negotiating accommodation agreements +and discounted rates for ACM SIGMETRICS / IFIP PERFORMANCE 2024 +participants. Considering that June is the high season for Venice, +we encourage you to take advantage of this opportunity and book your +accommodation as soon as possible. Rate agreements expire soon. For +further information, please visit: + +https://www.sigmetrics.org/sigmetrics2024/accommodation.html + + +ORGANIZING COMMITTEE +==================== + +General Chairs +- Andrea Marin (Univ. of Venice “Ca’ Foscari”, Italy) +- Michele Garetto (Univ. of Turin, Italy) + +Program Chairs +- Giulia Fanti (Carnegie Mellon University, US) +- Florin Ciucu (University of Warwick, UK) +- Rhonda Righter (University of California, Berkeley, US) + +Financial Chair +Sabina Rossi (Univ. of Venice “Ca’ Foscari”, Italy) + +Tutorial Chair +Sara Alouf (INRIA, Sophia Antipolis, France) + +Workshops Chairs +- Valeria Cardellini (Univ. of Rome “Tor Vergata”, Italy) +- Dieter Fiems (Univ. Ghent, Belgium) + +Travel Grants Chair +- Qiaomin Xie (University of Wisconsin-Madison, US) + +SRC Chairs +- Lishan Yang (George Mason University, US) +- Nicolas Gast (INRIA, France) + +Proceedings Chair +- Siva Theja Maguluri (Georgia Tech, Atlanta, US) +- Debankur Mukherjee (Georgia Tech, Atlanta, US) + +Publicity Chairs +- Marco Paolieri (Univ. of Southern California, US) +- Maryam Elahi (Mount Royal University, Canada) + +Web Chair +- Paolo Castagno (Univ. of Turin, Italy) + +Registration Chair +- Bo Ji (Virginia Tech, US) + +Local Arrangement Chairs +- Diletta Olliaro (Univ. Ca' Foscari of Venice, Italy) +- Sabina Rossi (Univ. Ca' Foscari of Venice, Italy) + + +CONTACTS +======== + +Contact the SIGMETRICS / Performance 2024 General chairs Andrea Marin +(marin@unive.it) or Michele Garetto (michele.garetto@unito.it) in case +of questions or concerns. + diff --git a/_announce/2024-04-10-lipari_ss.txt b/_announce/2024-04-10-lipari_ss.txt new file mode 100644 index 0000000..12f2fe1 --- /dev/null +++ b/_announce/2024-04-10-lipari_ss.txt @@ -0,0 +1,35 @@ +--- +title: "Call for Participation, Lipari Summer School on Abstract Interpretation" +timestamp: "4/10/2024 3:10:21" +start: "9/1/2024" +end: "9/7/2024" +--- +The Lipari Summer School on Abstract Interpretation will be held on the beautiful island of Lipari, Italy, from September 1st to September 7th, 2024. + +This immersive week-long journey, set in the stunning surroundings of Lipari Island, aims to provide MSc, Ph.D. students, postdocs, and young researchers with a rich learning environment dedicated to the exploration of abstract interpretation, its applications, and its recent advances both in industry and research academia. + +The list of topics covered during the summer school includes abstract interpretation, static analysis, program analysis, software verification, formal methods, formal methods for artificial intelligence, and use of static analysis in industry. + +Deadline for applications: 15th June 2024 +For more information regarding travel, accommodations, and fees, please visit the website: https://absint24.liparischool.it/ + +Speakers + - Patrick Cousot (New York University, USA) + - Helmut Seidl (Technical University of Munich, Germany) + - Laurent Mauborgne (AbsInt) + - Thomas Jensen (University of Rennes & INRIA, France) + - Caterina Urban (INRIA & École Normal Supérieure, France) + - Enea Zaffanella (University of Parma, Italy) + - Raphaël Monat (University of Lille & INRIA, France) + - Luca Negrini (University Ca’ Foscari of Venice, Italy) + +Scientific Committee + - Vincenzo Arceri (University of Parma, Italy) + - Isabella Mastroeni (University of Verona, Italy) + - Antoine Miné (Sorbonne Université, France) + +Organizing Committee and Contacts + - Vincenzo Arceri (University of Parma, Italy, vincenzo.arceri@unipr.it) + - Isabella Mastroeni (University of Verona, Italy, isabella.mastroeni@univr.it) + - Antoine Miné (Sorbonne Université, France, antoine.mine@lip6.fr) + - Michele Pasqua (University of Verona, Italy, michele.pasqua@univr.it) From 653944eb68eeae8bbdeebf792f99e5af8f62acc1 Mon Sep 17 00:00:00 2001 From: j-hui Date: Mon, 15 Apr 2024 10:50:18 -0400 Subject: [PATCH 56/64] Obfuscate sigplan-av email with scripted base64 decoding --- AV/index.md | 4 +++- AV/mail.png | Bin 0 -> 6139 bytes 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 AV/mail.png diff --git a/AV/index.md b/AV/index.md index 1f1a682..a589b97 100644 --- a/AV/index.md +++ b/AV/index.md @@ -25,7 +25,9 @@ SIGPLAN-AV is a subcommitee of SIGPLAN whose goal is to centralize the efforts o #### For general chairs -If you are a general chair of a SIGPLAN conference and are interested in using SIGPLAN-AV please email . +

+If you are a general chair of a SIGPLAN conference and are interested in working with SIGPLAN-AV, please email +

SIGPLAN owns enough hardware (laptops, cameras and microphones) which can be used to setup streaming and recording of upto 8 parallel co-located events. diff --git a/AV/mail.png b/AV/mail.png new file mode 100644 index 0000000000000000000000000000000000000000..ed89ce26042ff91ee0608fcd30e148744771e552 GIT binary patch literal 6139 zcmb7IXIK+kw@yHMM-Y?_(uDvb%@B~@J4h17U^*joxKy4blxS-oAH zT@g~=((FGFQds#y4Ps~g0daSdW;fQ4-+p&rX3JD6aLx@>fS;25ydnr8yrC)UH zl{EVUcXyZ+2;}AECFpfi&<%bcBrGW@2@(QL{~SN#ba$}-*OM#aS6bKvK^H3^VL>6#f1}xXJNzHC ziwM{BO?h%0CGv|Bdjw@=t;`+`$few=M#M2>%M|cinIJ zixNux*x1Gj4lZ`CKXSi$QxpvPuPc8t<=vd!;QBDAjopQ#AC%uzf1-c*G5Obzh~)2X zep~pBh`o(c@^HJ0t}}3RbB6q{CIo~2g#5wQbhCA^_fdel+d(e+RX|8oK=_uy-~IZN z{u|~O8w|SG&A;vLpRMyli|rih{=+YE(>UWb$-ESH+(D1rj0#i^M| zkm0W{vT4p+1d5|6H=pJ4=N!$LkF0QKz9iUa@q*rZpxqR_?CcNIFU5oH(KnOYUIV#J^kKtRF_=XXQAA!?IHeo z7|K)Gys{}eL9Wl5B%rzqY%(|<I6|7MN@>!6S2363ml2f$WSkN<<5&$MSXf}SJ;J+7uyZXT% z{b-0KX2@6mv=So7DadhZMqkl?bS%CJdq+KqXUB0!)IfYJ%`!!vLlItuhQLZHH}H<_ z!2T@9t-(T!N_TjRvL&un1BXA#!=!sc+otVmf$;Klf)>wyme*~wR!xhyKZmzhdC@PP z)3zWxD>j;9oK!i^iVTPG=~Lgf^piMG9eMRSsy42%Xe%CXvBLtLwWm(WF*s~{hpkoR zjHkqtkBKWbFU?dh1-^W~Yepqjf3W+7igHIZ+54{+58c>Wqt$Mm5u(XQk72Y86uE=% zs+$z?y4%7tv=8tOo~(E>P7v*ng2z@PPG(hW=_f3A$v34(B#h;w1o`96~+K1>grN8}r z_#+(?mfal=E@B6^;;F9sH?y}@(=BoGO+mz<%!6*W4>-j5F75RXjjGB;@0nD zV*tMS`wxoe*ha1y;foI;LwxD9WC*X`Q3&vX)o%{=g=9}h2@wVYmvIRwsh=&hW0+z> z4Xwx|aGg)c9t6jk66A^3x_A?gVz@H0wL?B;tZB!oSC-08h3Z53N3NQ8CO&2B*WH3W z3HN|Jr1)IblJtI_(qmm4+zu&3-K0@myi;^msew`)xR3zpxlYy6xTLM>VlJ1Nv#;Iqo`N5V$Q7xBYf)iv- zAqh(Uy0>0ekBtSo^a)qmb{U_HVaS5l49ZZH@aBH5y7jDrCHSm*5*JDkdA4@d=A?HA)oc&rX|I3xmv^p)oD=t&H}9;@ z$R-S1*Y;C!Y&xM(vBAQH8QU+fSmcC#mSaQodX+QRN_t@Mf#_cMA}S<>dk8M*J(-pC z%pL0Zn)AL)jm(JtMyq7?_!5qmmqu_qpUgP<>@em0XPpkyO0{Z4ZE=Y44j7blV3 zp5>ck`JgUg+M(+GZ(?R5@=g1(UAt7$>5+EZjSIO2uHXa_n(&>u@X>5hqa5k{VkfCL z1|!34(j=8E3C_`P1fqH`t@sf8C(Li-5V`cOHBZQzr$5-yDW+kvc~q3iD0}dP+K^zO zsUYTrf4gXa%Cpz=k!+_5`|_&@JNe}BCewxB2>6ILmuvE8${DURVp0-CD#zG;@lVd5 zF;2;XvB%fSiW%VZ>@$t!8)RpWbGJzvJz{uQ#W~L&hhr9VP}%+G$-AV4D2WbKhzAQv z?xE?f)mMyV_~#U(Mwf7~oWi&DOrBPfX93Qyky1-d$xGXd_}8tOTV*0%izKck-tV1B z$^j4C)?@eCmSjN*rl6!z&zB2YyuYF9Gts~nUClzUaFCUC!+DTy{zV0!S@!f!Vh^Pg z>Q!US&G~zmF{(C6Z%QIPV^s)Rb?3@U&hwuhFf2y2b$rB#W*)7Wm|gL(5LlSaNGQ^I z@UB!eZjyJjVQ@h`_NcrX7eO(g+}wgzs%3HwrOV)`(Cjh@Bvv-LEkkzvD2wo37z?e` zv(iwz#>di|4Y@__DZNs14JKj{pR8C(gXwoF+SPr^4RUsOX^#1HeOva6%fpe(O7kJU zl2CGSYmyPVla1+hCBv@3zvLFIB^evmlQwizNdp^V>wuo~^gEUio-8axpy+JyF}V8f%>nag7!@wF#KQ@8*f# zEiImFMWtMSju3}K5k(z+j-11eVJWjV6>& z0~Yg1wXQl9mrmWMUD{CkYGkB1Z?dn}rQ^|iM5udZBu{$Gy%?2!u6Z*++cL)icE8>=lo)rS`=t@ejX zuR3QQ@`QKcc7*G3GWQ;EwVR0?_%h<*5yHU@ZLggp40UM;^-C; zfi%s2aAQlb4?p%b%QR+YFr8o3c~{+^Y$*O!73rcMXUa2Ub;dq2w5_j%W*9+pXfwka z(Wcmq57C8&d}%ZtH&WG4lW(LcSMk0JiC7^<-|-d)lkQK)3Q-4==6a7rKe{|^IbBKP z$#H5~cFs1v;3aowk*x?kbmhkGiv4ikP1dO!{PFvoV6qvV*dupR=2O=vdR<5UAiG7a zT9F<;lAPUT-qf^Ko*KvK)52~M><%&76Lvd@pUyH(j)xrAON^D)Ph??y{hxY`R_Q%K ztmm4jFMsp1$TUZ%}@ut-q>*hX{pz?```Qou-Z7 zrU6kVTeNeqLmX zlsS5g>l&(Uu;Vspo|K#<$;Jt8N7N;>Z*P9lSmK-)XrPwJiMt+YOVcZuHpGc{C;LlN*j-i-(T7e?FMPtXWB?s;OF0hK4!(VSndX*2v8BkxEw) zOP(h3uFy3__q@=oomsSlA&pGU)2~-2W$mQxrEw;7s%*tcos8(EWz9*SL0!Y84Q}Uk zdbe)(56+R%4@^q1YiC12#N-;`AlAR|nDzwJ+wn3D_GVRg_fay8_@T{5ycF+}7aKIT z6*ruWMk%ZV&1g?aAKB=!AN27q#)J`|={~xm%_m9L z1!s!FfcxpxIGl=#=kj(}qF0oz;^o?aRKzGc;;0mQkO&^V!;~CkWWU*UTM)Zjh@CBA zSS_zS^48X=(31M`ku8fBJzRvU`!905X$REl05;o#g9dC}A4KLzjWX zcLn{!YGX(W@9tDx+ku)G;p2yX&{*5bC7fFus!$%evsGZF=YStkFMc=Ub9a2dp!B<+ z*9+Q*gWp;)FW#hB)Wgr(gn8;SreD3wwa)eUxWm4>l=JK)tQ_68O5&kbVM*UbV;Zq{ z#=K2pl%Dp=IVMvkOmsk|yB9d#wNlTv#C&~Fysq8f*j~l{LFJioRAOnolK(WO5?Mk7 zTA&2sptLGgSqQJHUf(TIA9hu-WHUP zZzk|gJng?VcN`UZ?$qw`ZnEmu&F4|RD!obRly7^Z7MviDB_J;Av1(TzeInE_L6N(sr09!P&iPkK*>H}DhZY0`ZgXmF2{>~7%ih$HQ#?} z#(WCnZ{EKbyF3Tx$$h%tMiEn|c5Ul@lL5_Hs+K>^U$_hFy0Bu04O}*k$N5nKv&Kva zKWtH>x2z-&4$olZ6U1-tH2UQ-gw=8lb(>

73*no#t!MclHStFkd1U20F*!kYYEO zh3*rtWprgsY1?H=CNcL}8NeiIU9EBDR4TuI1NZc3hWr$scoB)KB5c;gl`^b-?px%H z%BCTd`Jr4|r$4odpuPvJkcF7}lI~H5ip0G0parJ0A6$TLzyMS8hGb1>J;OjL zJhp^OPAyRjWVLvn;Tu5#4a{nir0=^aXT5AR!fs~XHuxyTQ;K^+H{Sq8l2`_t>baeN z*Lk{k0OH$a$tVdcQ)XfOQ1hh0r($xS&I4xZ#nCj94lfB`tf5P7Lb!h54j_T5U_T@k zj;<(-n)>xsIE4_r*i#N{8*V;Y!>_CKg1zhud?&b5Z^0cvli-o*cy`%H+R2H_?u}nr zILXp(%hkOj#|iT4NAvP^^m5|r4d!B<%iY}CRWV~Y)#1-GEy~j%W$MI5jIj=nI~^;t zSoZF7*et1VH*SIxSnw%U%^jofvCLOcKPE!YNO6nbV8^r>eBbumK588y`uc!d+hIA_ zn$j7sszWESK+P)$X*j(3p{}K_>QvwWarqjj&hx2AjyKIZ!UQ9;TB|J+Sf4LRogT8P3 zr3Q&(S-BTkQCR|+?TGU?>dpB zOn=QyxsklQ`@W2<2OvH=8mErfhP#PgIWUB?9cCTu`7j+8Opp}X`XscWuN_j}@M6yI zn>VNK9sPplXKf#z?YlFsVa!r5S6`33_bu>#z~qEq+8)}Pj|I5{m;V$@w2A*B(NgYc zX($z(TJgfxW_gQtZn^-~*l7_Gfxfc2(c9PJ94T4%yf)p;a0V!e$G%}1c_Ov9@qBqQ zOdzu;r|4vOXwB>E#;3+%6AHnOZ9m;%CN#+xvQ?$VYcavw{R%_JDDUl{y?xiNnXRDo zsk~-d7)S$mp>;TyZqx<_S;dc{K96y~0>;JI1f4$+x^kL*3|MqrTE=*IoTP1?2h+H& zH}-mO>hrB|+v-CYm^anElc-K6JLSyf33UCAOl)e2A1h7cE4e SyH{WQhpnoprBEVg74koh5;g1q literal 0 HcmV?d00001 From 292d34c52acdf564645ae1d23ee42846effaa9d5 Mon Sep 17 00:00:00 2001 From: Michael Bond Date: Sun, 28 Apr 2024 15:07:22 -0700 Subject: [PATCH 57/64] Add ISMM 2023 and 2024 web pages --- Conferences/ISMM.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Conferences/ISMM.md b/Conferences/ISMM.md index 6114186..e8c73ef 100644 --- a/Conferences/ISMM.md +++ b/Conferences/ISMM.md @@ -18,6 +18,8 @@ Steering Committee **Web Pages of Previous Conferences** +- [ISMM 2024](https://conf.researchr.org/home/ismm-2024) (Copenhagen, Denmark) +- [ISMM 2023](https://conf.researchr.org/home/ismm-2023) (Orlando, Florida) - [ISMM 2022](https://pldi22.sigplan.org/home/ismm-2022) (San Diego, California) - [ISMM 2021](http://conf.researchr.org/home/ismm-2021) (virtual) - [ISMM 2020](http://conf.researchr.org/home/ismm-2020) (virtual) From 88f50c72322bbabc147a4ea945b13352ba87c080 Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Mon, 29 Apr 2024 11:26:38 -0700 Subject: [PATCH 58/64] TOC --- OpenTOC/oopsla24.html | 344 ++++++++++++++++++++++++++++++++++++++++++ _data/OpenTOC.yaml | 4 + 2 files changed, 348 insertions(+) create mode 100644 OpenTOC/oopsla24.html diff --git a/OpenTOC/oopsla24.html b/OpenTOC/oopsla24.html new file mode 100644 index 0000000..d3e555f --- /dev/null +++ b/OpenTOC/oopsla24.html @@ -0,0 +1,344 @@ +

Proceedings of the ACM on Programming Languages: Vol. 8, No. OOPSLA1. 2024

+ Full Citation in the ACM Digital Library +

SECTION: Papers

Quantum Control Machine: The Limits of Control Flow in Quantum Programming

  • Charles Yuan
  • Agnes Villanyi
  • Michael Carbin
+

Quantum algorithms for tasks such as factorization, search, and simulation rely on control flow such as branching and iteration that depends on the value of data in superposition. High-level programming abstractions for control flow, such as switches, loops, higher-order functions, and continuations, are ubiquitous in classical languages. By contrast, many quantum languages do not provide high-level abstractions for control flow in superposition, and instead require the use of hardware-level logic gates to implement such control flow. +

+

+The reason for this gap is that whereas a classical computer supports control flow abstractions using a program counter that can depend on data, the typical architecture of a quantum computer does not analogously provide a program counter that can depend on data in superposition. As a result, the complete set of control flow abstractions that can be correctly realized on a quantum computer has not yet been established. +

+

+In this work, we provide a complete characterization of the properties of control flow abstractions that are correctly realizable on a quantum computer. First, we prove that even on a quantum computer whose program counter exists in superposition, one cannot correctly realize control flow in quantum algorithms by lifting the classical conditional jump instruction to work in superposition. This theorem denies the ability to directly lift general abstractions for control flow such as the λ-calculus from classical to quantum programming. +

+

+In response, we present the necessary and sufficient conditions for control flow to be correctly realizable on a quantum computer. We introduce the quantum control machine, an instruction set architecture featuring a conditional jump that is restricted to satisfy these conditions. We show how this design enables a developer to correctly express control flow in quantum algorithms using a program counter in place of logic gates.

+

Profiling Programming Language Learning

  • Will Crichton
  • Shriram Krishnamurthi
+

This paper documents a year-long experiment to “profile” the process of learning a programming language: gathering data to understand what makes a language hard to learn, and using that data to improve the learning process. We added interactive quizzes to The Rust Programming Language, the official textbook for learning Rust. Over 13 months, 62,526 readers answered questions 1,140,202 times. First, we analyze the trajectories of readers. We find that many readers drop-out of the book early when faced with difficult language concepts like Rust’s ownership types. Second, we use classical test theory and item response theory to analyze the characteristics of quiz questions. We find that better questions are more conceptual in nature, such as asking why a program does not compile vs. whether a program compiles. Third, we performed 12 interventions into the book to help readers with difficult questions. We find that on average, interventions improved quiz scores on the targeted questions by +20

+

Synthetiq: Fast and Versatile Quantum Circuit Synthesis

  • Anouk Paradis
  • Jasper Dekoninck
  • Benjamin Bichsel
  • Martin Vechev
+

To implement quantum algorithms on quantum computers it is crucial to decompose their operators into the limited gate set supported by those computers. Unfortunately, existing works automating this essential task are generally slow and only applicable to narrow use cases.We present Synthetiq, a method to synthesize quantum circuits implementing a given specification over arbitrary finite gate sets, which is faster and more versatile than existing works. Synthetiq utilizes Simulated Annealing instantiated with a novel, domain-specific energy function that allows developers to leverage partial specifications for better efficiency. Synthetiq further couples this synthesis method with a custom simplification pass, to ensure efficiency of the found circuits.

We experimentally demonstrate that Synthetiq can generate better implementations than were previously known for multiple relevant quantum operators including RCCCX, CCT, CCiSWAP, C√SWAP, and C√iSWAP. Our extensive evaluation also demonstrates Synthetiq frequently outperforms a wide variety of more specialized tools in their own domains, including (i) ‍the well-studied task of synthesizing fully specified operators in the Clifford+T gate set, (ii) ‍є-approximate synthesis of multi-qubit operators in the same gate set, and (iii) ‍synthesis tasks with custom gate sets. On all those tasks, Synthetiq is typically one to two orders of magnitude faster than previous state-of-the-art and can tackle problems that were previously out of the reach of any synthesis tool.

+

A Learning-Based Approach to Static Program Slicing

  • Aashish Yadavally
  • Yi Li
  • Shaohua Wang
  • Tien N. Nguyen
+

Traditional program slicing techniques are crucial for early bug detection and manual/automated debugging of online code snippets. Nevertheless, their inability to handle incomplete code hinders their real-world applicability in such scenarios. To overcome these challenges, we present NS-Slicer, a novel learning-based approach that predicts static program slices for both complete and partial code Our tool leverages a pre-trained language model to exploit its understanding of fine-grained variable-statement dependencies within source code. With this knowledge, given a variable at a specific location and a statement in a code snippet, NS-Slicer determines whether the statement belongs to the backward slice or forward slice, respectively. We conducted a series of experiments to evaluate NS-Slicer's performance. On complete code, it predicts the backward and forward slices with an F1-score of 97.41% and 95.82%, respectively, while achieving an overall F1-score of 96.77%. Notably, in 85.20% of the cases, the static program slices predicted by NS-Slicer exactly match entire slices from the oracle. For partial programs, it achieved an F1-score of 96.77%–97.49% for backward slicing, 92.14%–95.40% for forward slicing, and an overall F1-score of 94.66%–96.62%. Furthermore, we demonstrate NS-Slicer's utility in vulnerability detection (VD), integrating its predicted slices into an automated VD tool. In this setup, the tool detected vulnerabilities in Java code with a high F1-score of 73.38%. We also include the analyses studying NS-Slicer’s promising performance and limitations, providing insights into its understanding of intrinsic code properties such as variable aliasing, leading to better slicing.

+

Finding Cross-Rule Optimization Bugs in Datalog Engines

  • Chi Zhang
  • Linzhang Wang
  • Manuel Rigger
+

Datalog is a popular and widely-used declarative logic programming language. Datalog engines apply many cross-rule optimizations; bugs in them can cause incorrect results. To detect such optimization bugs, we propose an automated testing approach called Incremental Rule Evaluation (IRE), which synergistically tackles the test oracle and test case generation problem. The core idea behind the test oracle is to compare the results of an optimized program and a program without cross-rule optimization; any difference indicates a bug in the Datalog engine. Our core insight is that, for an optimized, incrementally-generated Datalog program, we can evaluate all rules individually by constructing a reference program to disable the optimizations that are performed among multiple rules. Incrementally generating test cases not only allows us to apply the test oracle for every new rule generated—we also can ensure that every newly added rule generates a non-empty result with a given probability and eschew recomputing already-known facts. We implemented IRE as a tool named Deopt, and evaluated Deopt on four mature Datalog engines, namely Soufflé, CozoDB, μZ, and DDlog, and discovered a total of 30 bugs. Of these, 13 were logic bugs, while the remaining were crash and error bugs. Deopt can detect all bugs found by queryFuzz, a state-of-the-art approach. Out of the bugs identified by Deopt, queryFuzz might be unable to detect 5. Our incremental test case generation approach is efficient; for example, for test cases containing 60 rules, our incremental approach can produce 1.17× (for DDlog) to 31.02× (for Soufflé) as many valid test cases with non-empty results as the naive random method. We believe that the simplicity and the generality of the approach will lead to its wide adoption in practice.

+

UniSparse: An Intermediate Language for General Sparse Format Customization

  • Jie Liu
  • Zhongyuan Zhao
  • Zijian Ding
  • Benjamin Brock
  • Hongbo Rong
  • Zhiru Zhang
+

The ongoing trend of hardware specialization has led to a growing use of custom data formats when processing sparse workloads, which are typically memory-bound. These formats facilitate optimized software/hardware implementations by utilizing sparsity pattern- or target-aware data structures and layouts to enhance memory access latency and bandwidth utilization. However, existing sparse tensor programming models and compilers offer little or no support for productively customizing the sparse formats. Additionally, because these frameworks represent formats using a limited set of per-dimension attributes, they lack the flexibility to accommodate numerous new variations of custom sparse data structures and layouts. +To overcome this deficiency, we propose UniSparse, an intermediate language that provides a unified abstraction for representing and customizing sparse formats. Unlike the existing attribute-based frameworks, UniSparse decouples the logical representation of the sparse tensor (i.e., the data structure) from its low-level memory layout, enabling the customization of both. As a result, a rich set of format customizations can be succinctly expressed in a small set of well-defined query, mutation, and layout primitives. We also develop a compiler leveraging the MLIR infrastructure, which supports adaptive customization of formats, and automatic code generation of format conversion and compute operations for heterogeneous architectures. We demonstrate the efficacy of our approach through experiments running commonly-used sparse linear algebra operations with specialized formats on multiple different hardware targets, including an Intel CPU, an NVIDIA GPU, an AMD Xilinx FPGA, and a simulated processing-in-memory (PIM) device.

+

Cocoon: Static Information Flow Control in Rust

  • Ada Lamba
  • Max Taylor
  • Vincent Beardsley
  • Jacob Bambeck
  • Michael D. Bond
  • Zhiqiang Lin
+

Information flow control (IFC) provides confidentiality by enforcing noninterference, which ensures that high-secrecy values cannot affect low-secrecy values. Prior work introduces fine-grained IFC approaches that modify the programming language and use non-standard compilation tools, impose run-time overhead, or report false secrecy leaks—all of which hinder adoption. + +This paper presents Cocoon, a Rust library for static type-based IFC that uses the unmodified Rust language and compiler. The key insight of Cocoon lies in leveraging Rust’s type system and procedural macros to establish an effect system that enforces noninterference. A performance evaluation shows that using Cocoon increases compile time but has no impact on application performance. To demonstrate Cocoon’s utility, we retrofitted two popular Rust programs, the Spotify TUI client and Mozilla’s Servo browser engine, to use Cocoon to enforce limited confidentiality policies

+

Fulfilling OCaml Modules with Transparency

  • Blaudeau Clement
  • Didier Rémy
  • Gabriel Radanne
+

ML modules come as an additional layer on top of a core language to offer +large-scale notions of composition and abstraction. They largely +contributed to the success of OCaml and SML. While modules are easy to write +for common cases, their advanced use may become tricky. Additionally, +despite a long line of works, their meta-theory remains difficult to +comprehend, with involved soundness proofs. In fact, the module layer of +OCaml does not currently have a formal specification and its implementation +has some surprising behaviors. +

+

+Building on previous translations from ML modules to Fω, we propose a type +system, called Mω, that covers a large subset of OCaml modules, including +both applicative and generative functors, and extended with transparent +ascription. This system produces signatures in an OCaml-like syntax extended +with Fω quantifiers. We provide a reverse translation from Mω signatures to +path-based source signatures along with a characterization of signature +avoidance cases, making Mω signatures well suited to serve as a new internal +representation for a typechecker. +

+

+The soundness of the type system is shown by elaboration in Fω. We improve +over previous encodings of sealing within applicative functors, by the +introduction of transparent existential types, a weaker form of existential +types that can be lifted out of universal and arrow types. This shines a new +light on the form of abstraction provided by applicative functors and brings +their treatment much closer to those of generative functors.

+

HOL4P4: Mechanized Small-Step Semantics for P4

  • Anoud Alshnakat
  • Didrik Lundberg
  • Roberto Guanciale
  • Mads Dam
+

We present the first semantics of the network data plane programming language P4 able to adequately capture all key features of P416, the most recent version of P4, including external functions (externs) and concurrency. These features are intimately related since, in P4, extern invocations are the only points at which one execution thread can affect another. Reflecting P4’s lack of a general-purpose memory and the presence of multithreading the semantics is given in small-step style and eschews the use of a heap. In addition to the P4 language itself, we provide an architectural level semantics, which allows the composition of P4-programmed blocks, models end-to-end packet processing, and can take into account features such as arbitration and packet recirculation. A corresponding type system is provided with attendant progress, preservation, and type-soundness theorems. Semantics, type system, and meta-theory are formalized in the HOL4 theorem prover. From this formalization, we derive a HOL4 executable semantics that supports verified execution of programs with partially symbolic packets able to validate simple end-to-end program properties.

+

Compiling Recurrences over Dense and Sparse Arrays

  • Shiv Sundram
  • Muhammad Usman Tariq
  • Fredrik Kjolstad
+

We present a framework for compiling recurrence equations into native code. In our framework, users specify a system of recurrences, the types of data structures that store inputs and outputs, and scheduling commands for optimization. Our compiler then lowers these specifications into native code that respects the dependencies in the recurrence equations. Our compiler can generate code over both sparse and dense data structures, and determines if the recurrence system is solvable with the provided scheduling primitives. We evaluate the performance and correctness of the generated code on several recurrences, from domains as diverse as dense and sparse matrix solvers, dynamic programming, graph problems, and sparse tensor algebra. We demonstrate that the generated code has competitive performance to hand-optimized implementations in libraries. However, these handwritten libraries target specific recurrences, specific data structures, and specific optimizations. Our system, on the other hand, automatically generates implementations from recurrences, data formats, and schedules, giving our system more generality than library approaches.

+

Outcome Separation Logic: Local Reasoning for Correctness and Incorrectness with Computational Effects

  • Noam Zilberstein
  • Angelina Saliling
  • Alexandra Silva
+

Separation logic’s compositionality and local reasoning properties have led to significant advances in scalable static analysis. But program analysis has new challenges—many programs display computational effects and, orthogonally, static analyzers must handle incorrectness too. We present Outcome Separation Logic (OSL), a program logic that is sound for both correctness and incorrectness reasoning in programs with varying effects. OSL has a frame rule—just like separation logic—but uses different underlying assumptions that open up local reasoning to a larger class of properties than can be handled by any single existing logic.

Building on this foundational theory, we also define symbolic execution algorithms that use bi-abduction to derive specifications for programs with effects. This involves a new tri-abduction procedure to analyze programs whose execution branches due to effects such as nondeterministic or probabilistic choice. This work furthers the compositionality promised by separation logic by opening up the possibility for greater reuse of analysis tools across two dimensions: bug-finding vs verification in programs with varying effects.

+

Newtonian Program Analysis of Probabilistic Programs

  • Di Wang
  • Thomas Reps
+

Due to their quantitative nature, probabilistic programs pose non-trivial challenges for designing compositional and efficient program analyses. Many analyses for probabilistic programs rely on iterative approximation. This article presents an interprocedural dataflow-analysis framework, called NPA-PMA, for designing and implementing (partially) non-iterative program analyses of probabilistic programs with unstructured control-flow, nondeterminism, and general recursion. NPA-PMA is based on Newtonian Program Analysis (NPA), a generalization of Newton's method to solve equation systems over semirings. The key challenge for developing NPA-PMA is to handle multiple kinds of confluences in both the algebraic structures that specify analyses and the equation systems that encode control flow: semirings support a single confluence operation, whereas NPA-PMA involves three confluence operations (conditional, probabilistic, and nondeterministic). +

+

+Our work introduces ω-continuous pre-Markov algebras (ωPMAs) to factor out common parts of different analyses; adopts regular infinite-tree expressions to encode probabilistic programs with unstructured control-flow; and presents a linearization method that makes Newton's method applicable to the setting of regular-infinite-tree equations over ωPMAs. NPA-PMA allows analyses to supply a non-iterative strategy to solve linearized equations. Our experimental evaluation demonstrates that (i) NPA-PMA holds considerable promise for outperforming Kleene iteration, and (ii) provides great generality for designing program analyses.

+

Identifying and Correcting Programming Language Behavior Misconceptions

  • Kuang-Chen Lu
  • Shriram Krishnamurthi
+

Misconceptions about core linguistic concepts like mutable +variables, mutable compound data, and their interaction with scope +and higher-order functions seem to be widespread. +But +how do we detect +them, given that experts have blind spots and may not realize the +myriad ways in which students can misunderstand programs? +Furthermore, once identified, what can we do to correct them? +

+

+In this paper, we present a curated list of misconceptions, and an +instrument to detect them. These are distilled from student work +over several years and match and extend prior research. We also +present an automated, self-guided tutoring system. The tutor builds +on strategies in the education literature and is explicitly designed +around identifying and correcting misconceptions. +

+

+We have tested the tutor in multiple settings. +Our data consistently show that (a) the misconceptions we tackle are +widespread, and (b) the tutor appears to improve understanding.

+

Quantitative Bounds on Resource Usage of Probabilistic Programs

  • Krishnendu Chatterjee
  • Amir Kafshdar Goharshady
  • Tobias Meggendorfer
  • Đorđe Žikelić
+

Cost analysis, also known as resource usage analysis, is the task of finding bounds on the total cost of a program and is a well-studied problem in static analysis. In this work, we consider two classical quantitative problems in cost analysis for probabilistic programs. The first problem is to find a bound on the expected total cost of the program. This is a natural measure for the resource usage of the program and can also be directly applied to average-case runtime analysis. The second problem asks for a tail bound, i.e. ‍given a threshold t the goal is to find a probability bound p such that ℙ[total cost ≥ t] ≤ p. Intuitively, given a threshold t on the resource, the problem is to find the likelihood that the total cost exceeds this threshold.

First, for expectation bounds, a major obstacle in previous works on cost analysis is that they can handle only non-negative costs or bounded variable updates. In contrast, we provide a new variant of the standard notion of cost martingales, that allows us to find expectation bounds for a class of programs with general positive or negative costs and no restriction on the variable updates. More specifically, our approach is applicable as long as there is a lower bound on the total cost incurred along every path.

Second, for tail bounds, all previous methods are limited to programs in which the expected total cost is finite. In contrast, we present a novel approach, based on a combination of our martingale-based method for expectation bounds with a quantitative safety analysis, to obtain a solution to the tail bound problem that is applicable even to programs with infinite expected cost. Specifically, this allows us to obtain runtime tail bounds for programs that do not terminate almost-surely.

In summary, we provide a novel combination of martingale-based cost analysis and quantitative safety analysis that is able to find expectation and tail cost bounds for probabilistic programs, without the restrictions of non-negative costs, bounded updates, or finiteness of the expected total cost. Finally, we provide experimental results showcasing that our approach can solve instances that were beyond the reach of previous methods.

+

CYCLE: Learning to Self-Refine the Code Generation

  • Yangruibo Ding
  • Marcus J. Min
  • Gail Kaiser
  • Baishakhi Ray
+

Pre-trained code language models have achieved promising performance in code generation and improved the programming efficiency of human developers. However, their self-refinement capability is typically overlooked by the existing evaluations of code LMs, which focus only on the accuracy of the one-time prediction. For the cases when code LMs fail to implement the correct program, developers actually find it hard to debug and fix the faulty prediction since it is not written by the developers themselves. Unfortunately, our study reveals that code LMs cannot efficiently self-refine their faulty generations as well.

In this paper, we propose CYCLE framework, learning to self-refine the faulty generation according to the available feedback, such as the execution results reported by the test suites. We evaluate CYCLE on three popular code generation benchmarks, HumanEval, MBPP, and APPS. The results reveal that CYCLE successfully maintains, sometimes improves, the quality of one-time code generation, while significantly improving the self-refinement capability of code LMs. We implement four variants of CYCLE with varied numbers of parameters across 350M, 1B, 2B, and 3B, and the experiments show that CYCLE consistently boosts the code generation performance, by up to 63.5

+

AdoB: Bridging Benign and Byzantine Consensus with Atomic Distributed Objects

  • Wolf Honoré
  • Longfei Qiu
  • Yoonseung Kim
  • Ji-Yong Shin
  • Jieung Kim
  • Zhong Shao
+

Achieving consensus is a challenging and ubiquitous problem in distributed systems that is only made harder by the introduction of malicious byzantine servers. While significant effort has been devoted to the benign and byzantine failure models individually, no prior work has considered the mechanized verification of both in a generic way. We claim this is due to the lack of an appropriate abstraction that is capable of representing both benign and byzantine consensus without either losing too much detail or becoming impractically complex. We build on recent work on the atomic distributed object model to fill this void with a novel abstraction called AdoB. In addition to revealing important insights into the essence of consensus, this abstraction has practical benefits for easing distributed system verification. As a case study, we proved safety and liveness properties for AdoB in Coq, which are the first such mechanized proofs to handle benign and byzantine consensus in a unified manner. We also demonstrate that AdoB faithfully models real consensus protocols by proving it is refined by standard network-level specifications of Fast Paxos and a variant of Jolteon.

+

PROMPT: A Fast and Extensible Memory Profiling Framework

  • Ziyang Xu
  • Yebin Chon
  • Yian Su
  • Zujun Tan
  • Sotiris Apostolakis
  • Simone Campanoni
  • David I. August
+

Memory profiling captures programs’ dynamic memory behavior, assisting programmers in debugging, tuning, and enabling advanced compiler optimizations like speculation-based automatic parallelization. As each use case demands its unique program trace summary, various memory profiler types have been developed. Yet, designing practical memory profilers often requires extensive compiler expertise, adeptness in program optimization, and significant implementation effort. This often results in a void where aspirations for fast and robust profilers remain unfulfilled. To bridge this gap, this paper presents PROMPT, a framework for streamlined development of fast memory profilers. With PROMPT, developers need only specify profiling events and define the core profiling logic, bypassing the complexities of custom instrumentation and intricate memory profiling components and optimizations. Two state-of-the-art memory profilers were ported with PROMPT where all features preserved. By focusing on the core profiling logic, the code was reduced by more than 65% and the profiling overhead was improved by 5.3× and 7.1× respectively. To further underscore PROMPT’s impact, a tailored memory profiling workflow was constructed for a sophisticated compiler optimization client. In 570 lines of code, this redesigned workflow satisfies the client’s memory profiling needs while achieving more than 90% reduction in profiling overhead and improved robustness compared to the original profilers.

+

Enhancing Static Analysis for Practical Bug Detection: An LLM-Integrated Approach

  • Haonan Li
  • Yu Hao
  • Yizhuo Zhai
  • Zhiyun Qian
+

While static analysis is instrumental in uncovering software bugs, its precision in analyzing large and intricate codebases remains challenging. The emerging prowess of Large Language Models (LLMs) offers a promising avenue to address these complexities. In this paper, we present LLift, a pioneering framework that synergizes static analysis and LLMs, with a spotlight on identifying use-before-initialization (UBI) bugs within the Linux kernel. Drawing from our insights into variable usage conventions in Linux, we enhance path analysis using post-constraint guidance. This approach, combined with our methodically crafted procedures, empowers LLift to adeptly handle the challenges of bug-specific modeling, extensive codebases, and the unpredictable nature of LLMs. Our real-world evaluations identified four previously undiscovered UBI bugs in the mainstream Linux kernel, which the Linux community has acknowledged. This study reaffirms the potential of marrying static analysis with LLMs, setting a compelling direction for future research in this area.

+

Evaluating the Effectiveness of Deep Learning Models for Foundational Program Analysis Tasks

  • Qian Chen
  • Chenyang Yu
  • Ruyan Liu
  • Chi Zhang
  • Yu Wang
  • Ke Wang
  • Ting Su
  • Linzhang Wang
+

While deep neural networks provide state-of-the-art solutions to a wide range of programming language tasks, their effectiveness in dealing with foundational program analysis tasks remains under explored. In this paper, we present an empirical study that evaluates four prominent models of code (i.e., CuBERT, CodeBERT, GGNN, and Graph Sandwiches) in two such foundational tasks: (1) alias prediction, in which models predict whether two pointers must alias, may alias or must not alias; and (2) equivalence prediction, in which models predict whether or not two programs are semantically equivalent. At the core of this study is CodeSem, a dataset built upon the source code of real-world flagship software (e.g., Linux Kernel, GCC, MySQL) and manually validated for the two prediction tasks. +Results show that all models are accurate in both prediction tasks, especially CuBERT with an accuracy of 89% and 84% in alias prediction and equivalence prediction, respectively. We also conduct a comprehensive, in-depth analysis of the results of all models in both tasks, concluding that deep learning models are generally capable of performing foundational tasks in program analysis even though in specific cases their weaknesses are also evident. +

+

+Our code and evaluation data are publicly available at https://github.com/CodeSemDataset/CodeSem.

+

Inductive Diagrams for Causal Reasoning

  • Jonathan Castello
  • Patrick Redmond
  • Lindsey Kuper
+

The Lamport diagram is a pervasive and intuitive tool for informal reasoning about “happens-before” relationships in a concurrent system. However, traditional axiomatic formalizations of Lamport diagrams can be painful to work with in a mechanized setting like Agda. We propose an alternative, inductive formalization — the causal separation diagram (CSD) — that takes inspiration from string diagrams and concurrent separation logic, but enjoys a graphical syntax similar to Lamport diagrams. Critically, CSDs are based on the idea that causal relationships between events are witnessed by the paths that information follows between them. To that end, we model “happens-before” as a dependent type of paths between events.

The inductive formulation of CSDs enables their interpretation into a variety of semantic domains. We demonstrate the interpretability of CSDs with a case study on properties of logical clocks, widely-used mechanisms for reifying causal relationships as data. We carry out this study by implementing a series of interpreters for CSDs, culminating in a generic proof of Lamport’s clock condition that is parametric in a choice of clock. We instantiate this proof on Lamport’s scalar clock, on Mattern’s vector clock, and on the matrix clocks of Raynal et al. and of Wuu and Bernstein, yielding verified implementations of each. The CSD formalism and our case study are mechanized in the Agda proof assistant.

+

Quarl: A Learning-Based Quantum Circuit Optimizer

  • Zikun Li
  • Jinjun Peng
  • Yixuan Mei
  • Sina Lin
  • Yi Wu
  • Oded Padon
  • Zhihao Jia
+

Optimizing quantum circuits is challenging due to the very large search space of functionally equivalent circuits and the necessity of applying transformations that temporarily decrease performance to achieve a final performance improvement. This paper presents Quarl, a learning-based quantum circuit optimizer. Applying reinforcement learning (RL) to quantum circuit optimization raises two main challenges: the large and varying action space and the non-uniform state representation. Quarl addresses these issues with a novel neural architecture and RL-training procedure. Our neural architecture decomposes the action space into two parts and leverages graph neural networks in its state representation, both of which are guided by the intuition that optimization decisions can be mostly guided by local reasoning while allowing global circuit-wide reasoning. Our evaluation shows that Quarl significantly outperforms existing circuit optimizers on almost all benchmark circuits. Surprisingly, Quarl can learn to perform rotation merging—a complex, non-local circuit optimization implemented as a separate pass in existing optimizers.

+

Qualifying System F<:: Some Terms and Conditions May Apply

  • Edward Lee
  • Yaoyu Zhao
  • Ondřej Lhoták
  • James You
  • Kavin Satheeskumar
  • Jonathan Immanuel Brachthäuser
+

Type qualifiers offer a lightweight mechanism for enriching existing type systems to enforce additional, desirable, program invariants. + +They do so by offering a restricted but effective form of subtyping. + +While the theory of type qualifiers is well understood and present in many programming languages today, polymorphism over type qualifiers remains an area less well examined. + +We explore how such a polymorphic system could arise by constructing a calculus, System F-sub-Q, which combines the higher-rank bounded polymorphism of System F-sub with the theory of type qualifiers. We explore how the ideas used to construct System F-sub-Q can be reused in situations where type qualifiers naturally arise---in reference immutability, function colouring, and capture checking. Finally, we re-examine other qualifier systems in the literature in light of the observations presented while developing System F-sub-Q.

+

Forge: A Tool and Language for Teaching Formal Methods

  • Tim Nelson
  • Ben Greenman
  • Siddhartha Prasad
  • Tristan Dyer
  • Ethan Bove
  • Qianfan Chen
  • Charles Cutting
  • Thomas Del Vecchio
  • Sidney LeVine
  • Julianne Rudner
  • Ben Ryjikov
  • Alexander Varga
  • Andrew Wagner
  • Luke West
  • Shriram Krishnamurthi
+

This paper presents the design of Forge, a tool for teaching formal methods gradually. Forge is based on the widely-used Alloy language and analysis tool, but contains numerous improvements based on more than a decade of experience teaching Alloy to students. Although our focus has been on the classroom, many of the ideas in Forge likely also apply to training in industry.

Forge offers a progression of languages that improve the learning experience by only gradually increasing in expressive power. Forge supports custom visualization of its outputs, enabling the use of widely-understood domain-specific representations. Finally, Forge provides a variety of testing features to ease the transition from programming to formal modeling. We present the motivation for and design of these aspects of Forge, and then provide a substantial evaluation based on multiple years of classroom use.

+

Design and Implementation of an Aspect-Oriented C Programming Language

  • Zhe Chen
  • Yunlong Zhu
  • Zhemin Wang
+

Aspect-Oriented Programming (AOP) is a programming paradigm that implements crosscutting concerns in a modular way. People have witnessed the prosperity of AOP languages for Java and C++, such as AspectJ and AspectC++, which has propelled AOP to become an important programming paradigm with many interesting application scenarios, e.g., runtime verification. In contrast, the AOP languages for C are still poor and lack compiler support. In this paper, we design a new general-purpose and expressive aspect-oriented C programming language, namely Aclang, and implement a compiler for it, which brings fully-fledged AOP support into the C domain. We have evaluated the effectiveness and performance of our compiler against two state-of-the-art tools, ACC and AspectC++. In terms of effectiveness, Aclang outperforms ACC and AspectC++. In terms of performance, Aclang outperforms ACC in execution time and outperforms AspectC++ in both execution time and memory consumption.

+

Cedar: A New Language for Expressive, Fast, Safe, and Analyzable Authorization

  • Joseph W. Cutler
  • Craig Disselkoen
  • Aaron Eline
  • Shaobo He
  • Kyle Headley
  • Michael Hicks
  • Kesha Hietala
  • Eleftherios Ioannidis
  • John Kastner
  • Anwar Mamat
  • Darin McAdams
  • Matt McCutchen
  • Neha Rungta
  • Emina Torlak
  • Andrew M. Wells
+

Cedar is a new authorization policy language designed to be ergonomic, fast, safe, and analyzable. Rather than embed authorization logic in an application’s code, developers can write that logic as Cedar policies and delegate access decisions to Cedar’s evaluation engine. Cedar’s simple and intuitive syntax supports common authorization use-cases with readable policies, naturally leveraging concepts from role-based, attribute-based, and relation-based access control models. Cedar’s policy structure enables access requests to be decided quickly. Cedar’s policy validator leverages optional typing to help policy writers avoid mistakes, but not get in their way. Cedar’s design has been finely balanced to allow for a sound and complete logical encoding, which enables precise policy analysis, e.g., to ensure that when refactoring a set of policies, the authorized +permissions do not change. We have modeled Cedar in the Lean programming language, and used Lean’s proof assistant to prove important properties of Cedar’s design. We have implemented Cedar in Rust, and released it open-source. Comparing Cedar to two open-source languages, OpenFGA and Rego, we find (subjectively) that Cedar has equally or more readable policies, but (objectively) performs far better.

+

Persimmon: Nested Family Polymorphism with Extensible Variant Types

  • Anastasiya Kravchuk-Kirilyuk
  • Gary Feng
  • Jonas Iskander
  • Yizhou Zhang
  • Nada Amin
+

Many obstacles stand in the way of modular, extensible code. Some language constructs, such as pattern matching, are not easily extensible. Inherited code may not be type safe in the presence of extended types. The burden of setting up design patterns can discourage users, and parameter clutter can make the code less readable. Given these challenges, it is no wonder that extensibility often gives way to code duplication. We present our solution: Persimmon, a functional system with nested family polymorphism, extensible variant types, and extensible pattern matching. Most constructs in our language are built-in "extensibility hooks," cutting down on the parameter clutter and user burden associated with extensible code. Persimmon preserves the relationships between nested families upon inheritance, enabling extensibility at a large scale. Since nested family polymorphism can express composable extensions, Persimmon supports mixins via an encoding. We show how Persimmon can be compiled into a functional language without extensible variants with our translation to Scala. Finally, we show that our system is sound by proving the properties of progress and preservation.

+

Hydra: Generalizing Peephole Optimizations with Program Synthesis

  • Manasij Mukherjee
  • John Regehr
+

Optimizing compilers rely on peephole optimizations to simplify +combinations of instructions and remove redundant instructions. +Typically, a new peephole optimization is added when a compiler +developer notices an optimization opportunity---a collection of +dependent instructions that can be improved---and manually derives a +more general rewrite rule that optimizes not only the original code, +but also other, similar collections of instructions. +In this paper, we present Hydra, a tool that automates the process of +generalizing peephole optimizations using a collection of techniques +centered on program synthesis. +One of the most important problems we have solved is finding a version +of each optimization that is independent of the bitwidths of the +optimization's inputs (when this version exists). +We show that Hydra can generalize 75% of the ungeneralized missed +peephole optimizations that LLVM developers have posted to the LLVM +project's issue tracker. +All of Hydra's generalized peephole optimizations have been formally +verified, and furthermore we can automatically turn them into C++ code +that is suitable for inclusion in an LLVM pass.

+

Multiverse Notebook: Shifting Data Scientists to Time Travelers

  • Shigeyuki Sato
  • Tomoki Nakamaru
+

Computational notebook environments are popular and de facto standard +tools for programming in data science, whereas computational notebooks are notorious in +software engineering. The criticism there stems from the characteristic +of facilitating unrestricted dynamic patching of running programs, which +makes exploratory coding quick but the resultant code messy and +inconsistent. In this work, we first reveal that dynamic patching is a +natural demand rather than a mere bad practice in data science +programming on Kaggle. We then develop Multiverse Notebook, a +computational notebook engine for time-traveling exploration. It +enables users to time-travel to any past state and restart with new code +from there under state isolation. We present an approach to efficiently +implementing time-traveling exploration. We empirically evaluate +Multiverse Notebook on ten real-world tasks from Kaggle. Our experiments +show that time-traveling exploration on Multiverse Notebook is +reasonably efficient.

+

Hopping Proofs of Expectation-Based Properties: Applications to Skiplists and Security Proofs

  • Martin Avanzini
  • Gilles Barthe
  • Benjamin Grégoire
  • Georg Moser
  • Gabriele Vanoni
+

We propose, implement, and evaluate a hopping proof approach for + proving expectation-based properties of probabilistic programs. Our + approach combines EHL, a syntax-directed proof system for reducing + proof goals of a program to proof goals of simpler programs, with a + "hopping" proof rule for reducing proof goals of an + original program to proof goal of a different program which is + suitably related (by means of pRHL, a relational program logic for + probabilistic program) to the original program. We prove that EHL + is sound for a core language with procedure calls and adversarial + computations, and complete for the adversary-free fragment of the + language. We also provide an implementation of EHL into + EasyCrypt, a proof assistant tailored for reasoning about + relational properties of probabilistic programs. We provide a tight + integration of EHL with other program logics supported by + EasyCrypt, and in particular probabilistic Relational Hoare Logic + (pRHL). Using this tight integration, we give mechanized proofs of + expected complexity of in-place implementations of randomized + quickselect and skip lists. We also sketch applications of our + approach to cryptographic proofs and discuss the broader impact of + EHL in the EasyCrypt proof assistant.

+

Accurate Data Race Prediction in the Linux Kernel through Sparse Fourier Learning

  • Gabriel Ryan
  • Burcu Cetin
  • Yongwhan Lim
  • Suman Jana
+

Testing for data races in the Linux OS kernel is challenging because there is an exponentially large space of system calls and thread interleavings that can potentially lead to concurrent executions with races. In this work, we introduce a new approach for modeling execution trace feasibility and apply it to Linux OS Kernel race prediction. To address the fundamental scalability challenge posed by the exponentially large domain of possible execution traces, we decompose the task of predicting trace feasibility into independent prediction subtasks encoded as learning Boolean indicator functions for specific memory accesses, and apply a sparse fourier learning approach to learning each feasibility subtask. +

+

+Boolean functions that are sparse in their fourier domain can be efficiently learned by estimating the coefficients of their fourier expansion. Since the feasibility of each memory access depends on only a few other relevant memory accesses or system calls (e.g., relevant inter-thread communications), we observe that trace feasibility functions often have this sparsity property and can be learned efficiently. We use learned trace feasibility functions in conjunction with conservative alias analysis to implement a kernel race-testing system, HBFourier, that uses sparse fourier learning to efficiently model feasibility when making predictions. We evaluate our approach on a recent Linux development kernel and show it finds 44 more races with 15.7% more accurate race predictions than the next best performing system in our evaluation, in addition to identifying 5 new race bugs confirmed by kernel developers.

+

TorchQL: A Programming Framework for Integrity Constraints in Machine Learning

  • Aaditya Naik
  • Adam Stein
  • Yinjun Wu
  • Mayur Naik
  • Eric Wong
+

Finding errors in machine learning applications requires a thorough exploration of their behavior over data. Existing approaches used by practitioners are often ad-hoc and lack the abstractions needed to scale this process. We present TorchQL, a programming framework to evaluate and improve the correctness of machine learning applications. TorchQL allows users to write queries to specify and check integrity constraints over machine learning models and datasets. It seamlessly integrates relational algebra with functional programming to allow for highly expressive queries using only eight intuitive operators. We evaluate TorchQL on diverse use-cases including finding critical temporal inconsistencies in objects detected across video frames in autonomous driving, finding data imputation errors in time-series medical records, finding data labeling errors in real-world images, and evaluating biases and constraining outputs of language models. Our experiments show that TorchQL enables up to 13x faster query executions than baselines like Pandas and MongoDB, and up to 40% shorter queries than native Python. We also conduct a user study and find that TorchQL is natural enough for developers familiar with Python to specify complex integrity constraints.

+

Gradually Typed Languages Should Be Vigilant!

  • Olek Gierczak
  • Lucy Menon
  • Christos Dimoulas
  • Amal Ahmed
+

In gradual typing, different languages perform different dynamic type checks for the same program even +though the languages have the same static type system. This raises the question of whether, given a gradually +typed language, the combination of the translation that injects checks in well-typed terms and the dynamic +semantics that determines their behavior sufficiently enforce the static type system of the language. Neither +type soundness, nor complete monitoring, nor any other meta-theoretic property of gradually typed languages +to date provides a satisfying answer. +

+

+In response, we present vigilance, a semantic analytical instrument that defines when the check-injecting +translation and dynamic semantics of a gradually typed language are adequate for its static type system. +Technically, vigilance asks if a given translation-and-semantics combination enforces the complete run-time +typing history of a value, which consists of all of the types associated with the value. We show that the standard +combination for so-called Natural gradual typing is vigilant for the standard simple type system, but the +standard combination for Transient gradual typing is not. At the same time, the standard combination for +Transient is vigilant for a tag type system but the standard combination for Natural is not. Hence, we clarify +the comparative type-level reasoning power between the two most studied approaches to sound gradual typing. +Furthermore, as an exercise that demonstrates how vigilance can guide design, we introduce and examine +a new theoretical static gradual type system, dubbed truer, that is stronger than tag typing and more faithfully +reflects the type-level reasoning power that the dynamic semantics of Transient gradual typing can guarantee.

+

Distributions for Compositionally Differentiating Parametric Discontinuities

  • Jesse Michel
  • Kevin Mu
  • Xuanda Yang
  • Sai Praveen Bangaru
  • Elias Rojas Collins
  • Gilbert Bernstein
  • Jonathan Ragan-Kelley
  • Michael Carbin
  • Tzu-Mao Li
+

Computations in physical simulation, computer graphics, and probabilistic inference often require the differentiation of discontinuous processes due to contact, occlusion, and changes at a point in time. Popular differentiable programming languages, such as PyTorch and JAX, ignore discontinuities during differentiation. This is incorrect for parametric discontinuities—conditionals containing at least one real-valued parameter and at least one variable of integration. We introduce Potto, the first differentiable first-order programming language to soundly differentiate parametric discontinuities. We present a denotational semantics for programs and program derivatives and show the two accord. We describe the implementation of Potto, which enables separate compilation of programs. Our prototype implementation overcomes previous compile-time bottlenecks achieving an 88.1x and 441.2x speed up in compile time and a 2.5x and 7.9x speed up in runtime, respectively, on two increasingly large image stylization benchmarks. We showcase Potto by implementing a prototype differentiable renderer with separately compiled shaders.

+

Exact Bayesian Inference for Loopy Probabilistic Programs using Generating Functions

  • Lutz Klinkenberg
  • Christian Blumenthal
  • Mingshuai Chen
  • Darion Haase
  • Joost-Pieter Katoen
+

We present an exact Bayesian inference method for inferring posterior distributions encoded by probabilistic programs featuring possibly unbounded loops. Our method is built on a denotational semantics represented by probability generating functions, which resolves semantic intricacies induced by intertwining discrete probabilistic loops with conditioning (for encoding posterior observations). We implement our method in a tool called Prodigy; it augments existing computer algebra systems with the theory of generating functions for the (semi-)automatic inference and quantitative verification of conditioned probabilistic programs. Experimental results show that Prodigy can handle various infinite-state loopy programs and exhibits comparable performance to state-of-the-art exact inference tools over loop-free benchmarks.

+

Learning Abstraction Selection for Bayesian Program Analysis

  • Yifan Zhang
  • Yuanfeng Shi
  • Xin Zhang
+

We propose a learning-based approach to select abstractions for Bayesian program analysis. Bayesian program analysis converts a program analysis into a Bayesian model by attaching probabilities to analysis rules. It computes probabilities of analysis results and can update them by learning from user feedback, test runs, and other information. Its abstraction heavily affects how well it learns from such information. There exists a long line of works in selecting abstractions for conventional program analysis but they are not effective for Bayesian program analysis. This is because they do not optimize for generalization ability. We propose a data-driven framework to solve this problem by learning from labeled programs. Starting from an abstraction, it decides how to change the abstraction based on analysis derivations. To be general, it considers graph properties of analysis derivations; to be effective, it considers the derivations before and after changing the abstraction. We demonstrate the effectiveness of our approach using a datarace analysis and a thread-escape analysis.

+

Deriving Dependently-Typed OOP from First Principles

  • David Binder
  • Ingo Skupin
  • Tim Süberkrüb
  • Klaus Ostermann
+

The expression problem describes how most types can easily be extended with new ways to produce the type or new ways to consume the type, but not both. When abstract syntax trees are defined as an algebraic data type, for example, they can easily be extended with new consumers, such as print or eval, but adding a new constructor requires the modification of all existing pattern matches. The expression problem is one way to elucidate the difference between functional or data-oriented programs (easily extendable by new consumers) and object-oriented programs (easily extendable by new producers). This difference between programs which are extensible by new producers or new consumers also exists for dependently typed programming, but with one core difference: Dependently-typed programming almost exclusively follows the functional programming model and not the object-oriented model, which leaves an interesting space in the programming language landscape unexplored. In this paper, we explore the field of dependently-typed object-oriented programming by deriving it from first principles using the principle of duality. That is, we do not extend an existing object-oriented formalism with dependent types in an ad-hoc fashion, but instead start from a familiar data-oriented language and derive its dual fragment by the systematic use of defunctionalization and refunctionalization. Our central contribution is a dependently typed calculus which contains two dual language fragments. We provide type- and semantics-preserving transformations between these two language fragments: defunctionalization and refunctionalization. We have implemented this language and these transformations and use this implementation to explain the various ways in which constructions in dependently typed programming can be explained as special instances of the general phenomenon of duality.

+

Verification of Neural Networks’ Global Robustness

  • Anan Kabaha
  • Dana Drachsler Cohen
+

Neural networks are successful in various applications but are also susceptible to adversarial attacks. To show the safety of network classifiers, many verifiers have been introduced to reason about the local robustness of a given input to a given perturbation. While successful, local robustness cannot generalize to unseen inputs. Several works analyze global robustness properties, however, neither can provide a precise guarantee about the cases where a network classifier does not change its classification. In this work, we propose a new global robustness property for classifiers aiming at finding the minimal globally robust bound, which naturally extends the popular local robustness property for classifiers. We introduce VHAGaR, an anytime verifier for computing this bound. VHAGaR relies on three main ideas: encoding the problem as a mixed-integer programming and pruning the search space by identifying dependencies stemming from the perturbation or the network's computation and generalizing adversarial attacks to unknown inputs. We evaluate VHAGaR on several datasets and classifiers and show that, given a three hour timeout, the average gap between the lower and upper bound on the minimal globally robust bound computed by VHAGaR is 1.9, while the gap of an existing global robustness verifier is 154.7. Moreover, VHAGaR is 130.6x faster than this verifier. Our results further indicate that leveraging dependencies and adversarial attacks makes VHAGaR 78.6x faster.

+

Functional Ownership through Fractional Uniqueness

  • Daniel Marshall
  • Dominic Orchard
+

Ownership and borrowing systems, designed to enforce safe memory management without the need for garbage collection, have been brought to the fore by the Rust programming language. Rust also aims to bring some guarantees offered by functional programming into the realm of performant systems code, but the type system is largely separate from the ownership model, with type and borrow checking happening in separate compilation phases. Recent models such as RustBelt and Oxide aim to formalise Rust in depth, but there is less focus on integrating the basic ideas into more traditional type systems. An approach designed to expose an essential core for ownership and borrowing would open the door for functional languages to borrow concepts found in Rust and other ownership frameworks, so that more programmers can enjoy their benefits. +

+

+One strategy for managing memory in a functional setting is through uniqueness types, but these offer a coarse-grained view: either a value has exactly one reference, and can be mutated safely, or it cannot, since other references may exist. Recent work demonstrates that linear and uniqueness types can be combined in a single system to offer restrictions on program behaviour and guarantees about memory usage. We develop this connection further, showing that just as graded type systems like those of Granule and Idris generalise linearity, a Rust-like ownership model arises as a graded generalisation of uniqueness. We combine fractional permissions with grading to give the first account of ownership and borrowing that smoothly integrates into a standard type system alongside linearity and graded types, and extend Granule accordingly with these ideas.

+

VeriEQL: Bounded Equivalence Verification for Complex SQL Queries with Integrity Constraints

  • Yang He
  • Pinhan Zhao
  • Xinyu Wang
  • Yuepeng Wang
+

The task of SQL query equivalence checking is important in various real-world applications (including query rewriting and automated grading) that involve complex queries with integrity constraints; yet, state-of-the-art techniques are very limited in their capability of reasoning about complex features (e.g., those that involve sorting, case statement, rich integrity constraints, etc.) in real-life queries. To the best of our knowledge, we propose the first SMT-based approach and its implementation, VeriEQL, capable of proving and disproving bounded equivalence of complex SQL queries. VeriEQL is based on a new logical encoding that models query semantics over symbolic tuples using the theory of integers with uninterpreted functions. It is simple yet highly practical -- our comprehensive evaluation on over 20,000 benchmarks shows that VeriEQL outperforms all state-of-the-art techniques by more than one order of magnitude in terms of the number of benchmarks that can be proved or disproved. VeriEQL can also generate counterexamples that facilitate many downstream tasks (such as finding serious bugs in systems like MySQL and Apache Calcite).

+

PyDex: Repairing Bugs in Introductory Python Assignments using LLMs

  • Jialu Zhang
  • José Pablo Cambronero
  • Sumit Gulwani
  • Vu Le
  • Ruzica Piskac
  • Gustavo Soares
  • Gust Verbruggen
+

Students often make mistakes in their introductory programming assignments as part of their learning process. Unfortunately, providing custom repairs for these mistakes can require a substantial amount of time and effort from class instructors. Automated program repair (APR) techniques can be used to synthesize such fixes. Prior work has explored the use of symbolic and neural techniques for APR in the education domain. Both types of approaches require either substantial engineering efforts or large amounts of data and training. We propose to use a large language model trained on code, such as Codex (a version of GPT), to build an APR system -- PyDex -- for introductory Python programming assignments. Our system can fix both syntactic and semantic mistakes by combining multi-modal prompts, iterative querying, test-case-based selection of few-shots, and program chunking. We evaluate PyDex on 286 real student programs and compare to three baselines, including one that combines a state-of-the-art Python syntax repair engine, BIFI, and a state-of-the-art Python semantic repair engine for student assignments, Refactory. We find that PyDex can fix more programs and produce smaller patches on average.

+

Seneca: Taint-Based Call Graph Construction for Java Object Deserialization

  • Joanna C. S. Santos
  • Mehdi Mirakhorli
  • Ali Shokri
+

Object serialization and deserialization are widely used for storing and preserving objects in files, memory, or database as well as for transporting them across machines, enabling remote interaction among processes and many more. This mechanism relies on reflection, a dynamic language that introduces serious challenges for static analyses. Current state-of-the-art call graph construction algorithms do not fully support object serialization/deserialization, i.e., they are unable to uncover the callback methods that are invoked when objects are serialized and deserialized. Since call graphs are a core data structure for multiple types of analysis (e.g., vulnerability detection), an appropriate analysis cannot be performed since the call graph does not capture hidden (vulnerable) paths that occur via callback methods. In this paper, we present Seneca, an approach for handling serialization with improved soundness in the context of call graph construction. Our approach relies on taint analysis and API modeling to construct sound call graphs. We evaluated our approach with respect to soundness, precision, performance, and usefulness in detecting untrusted object deserialization vulnerabilities. Our results show that Seneca can create sound call graphs with respect to serialization features. The resulting call graphs do not incur significant runtime overhead and were shown to be useful for performing identification of vulnerable paths caused by untrusted object deserialization.

+

A Pure Demand Operational Semantics with Applications to Program Analysis

  • Scott Smith
  • Robert Zhang
+

This paper develops a novel minimal-state operational semantics for higher-order functional languages that uses only the call stack and a source program point or a lexical level as the complete state information: there is no environment, no substitution, no continuation, etc. We prove this form of operational semantics equivalent to standard presentations.

We then show how this approach can open the door to potential new applications: we define a program analysis as a direct finitization of this operational semantics. The program analysis that naturally emerges has a number of novel and interesting properties compared to standard program analyses for higher-order programs: for example, it can infer recurrences and does not need value widening. We both give a formal definition of the analysis and describe our current implementation.

+

Degrees of Separation: A Flexible Type System for Safe Concurrency

  • Yichen Xu
  • Aleksander Boruch-Gruszecki
  • Martin Odersky
+

Data races have long been a notorious problem in concurrent programming. They are hard to detect, and lead to non-deterministic behaviours. There has been a lot of interest in type systems that statically guarantee data race freedom. Significant progress has been made in this area, and these type systems are increasingly usable and practical. However, their adoption in mainstream programming languages is still limited, which is largely attributed to their strict alias prevention principles that obstruct the usage of existing programming patterns. This is a deterrent to the migration of existing code bases. To tackle this problem, we propose Capture Separation Calculus (System CSC), a calculus that models fork-join parallelism and statically prevents data races while being compatible with established programming patterns. It follows a control-as-you-need philosophy: by default, aliases are allowed, but they are tracked in the type system. When data races are a concern, the tracked aliases are controlled to prevent data-race-prone patterns. We study the formal properties of System CSC. Type soundness is proven via the standard progress and preservation theorems. Additionally, we formally verify the data race freedom property of System CSC by proving that the reduction of a well-typed program is confluent.

+

ParDiff: Practical Static Differential Analysis of Network Protocol Parsers

  • Mingwei Zheng
  • Qingkai Shi
  • Xuwei Liu
  • Xiangzhe Xu
  • Le Yu
  • Congyu Liu
  • Guannan Wei
  • Xiangyu Zhang
+

Countless devices all over the world are connected by networks and communicated via network protocols. Just like common software, protocol implementations suffer from bugs, many of which only cause silent data corruption instead of crashes. Hence, existing automated bug-finding techniques focused on memory safety, such as fuzzing, can hardly detect them. In this work, we propose a static differential analysis called ParDiff to find protocol implementation bugs, especially silent ones hidden in message parsers. Our key observation is that a network protocol often has multiple implementations and any semantic discrepancy between them may indicate bugs. However, different implementations are often written in disparate styles, e.g., using different data structures or written with different control structures, making it challenging to directly compare two implementations of even the same protocol. To exploit this observation and effectively compare multiple protocol implementations, ParDiff (1) automatically extracts finite state machines from programs to represent protocol format specifications, and (2) then leverages bisimulation and SMT solvers to find fine-grained and +semantic inconsistencies between them. We have extensively evaluated ParDiff using 14 network protocols. The results show that ParDiff outperforms both differential symbolic execution and differential fuzzing tools. To date, we have detected 41 bugs with 25 confirmed by developers.

+

A Constraint Solving Approach to Parikh Images of Regular Languages

  • Amanda Stjerna
  • Philipp Rümmer
+

A common problem in string constraint solvers is computing the Parikh image, a linear arithmetic formula that describes all possible combinations of character counts in strings of a given language. Automata-based string solvers frequently need to compute the Parikh image of products (or intersections) of finite-state automata, in particular when solving string constraints that also include the integer data-type due to operations like string length and indexing. In this context, the computation of Parikh images often turns out to be both prohibitively slow and memory-intensive. This paper contributes a new understanding of how the reasoning about Parikh images can be cast as a constraint solving problem, and questions about Parikh images be answered without explicitly computing the product automaton or the exact Parikh image. The paper shows how this formulation can be efficiently implemented as a calculus, PC*, embedded in an automated theorem prover supporting Presburger logic. The resulting standalone tool Catra is evaluate on constraints produced by the Ostrich+ string solver when solving standard string constraint benchmarks involving integer operations. The experiments show that PC* strictly outperforms the standard approach by Verma et al. to extract Parikh images from finite-state automata, as well as the over-approximating method recently described by Janků and Turoňová by a wide margin, and for realistic timeouts (under 60 s) also the nuXmv model checker. When added as the Parikh image backend of Ostrich+ to the Ostrich string constraint solver’s portfolio, it boosts its results on the quantifier-free strings with linear integer algebra track of SMT-COMP 2023 (QF_SLIA) enough to solve the most Unsat instances in that track of all competitors.

+

PP-CSA: Practical Privacy-Preserving Software Call Stack Analysis

  • Zhaoyu Wang
  • Pingchuan Ma
  • Huaijin Wang
  • Shuai Wang
+

Software call stack is a sequence of function calls that are executed during the runtime of a software program. Software call stack analysis (CSA) is widely used in software engineering to analyze the runtime behavior of software, which can be used to optimize the software performance, identify bugs, and profile the software. Despite the benefits of CSA, it has recently come under scrutiny due to concerns about privacy. To date, software is often deployed at user-side devices like mobile phones and smart watches. The collected call stacks may thus contain privacy-sensitive information, such as healthy information or locations, depending on the software functionality. Leaking such information to third parties may cause serious privacy concerns such as discrimination and targeted advertisement.

This paper presents PP-CSA, a practical and privacy-preserving CSA framework that can be deployed in real-world scenarios. Our framework leverages local differential privacy (LDP) as a principled privacy guarantee, to mutate the collected call stacks and protect the privacy of individual users. Furthermore, we propose several key design principles and optimizations in the technical pipeline of PP-CSA, including an encoder-decoder scheme to properly enforce LDP over software call stacks, and several client/server-side optimizations to largely improve the efficiency of PP-CSA. Our evaluation over real-world Java and Android programs shows that our privacy-preserving CSA pipeline can achieve high utility and privacy guarantees while maintaining high efficiency. We have released our implementation of PP-CSA as an open-source project at https://github.com/wangzhaoyu07/PP-CSA for results reproducibility. We will provide more detailed documents to support and the usage and extension of the community.

+

Scenario-Based Proofs for Concurrent Objects

  • Constantin Enea
  • Eric Koskinen
+

Concurrent objects form the foundation of many applications that exploit multicore architectures and their importance has lead to informal correctness arguments, as well as formal proof systems. Correctness arguments (as found in the distributed computing literature) give intuitive descriptions of a few canonical executions or "scenarios" often each with only a few threads, yet it remains unknown as to whether these intuitive arguments have a formal grounding and extend to arbitrary interleavings over unboundedly many threads. +

+

+We present a novel proof technique for concurrent objects, based around identifying a small set of scenarios (representative, canonical interleavings), formalized as the commutativity quotient of a concurrent object. We next give an expression language for defining abstractions of the quotient in the form of regular or context-free languages that enable simple proofs of linearizability. These quotient expressions organize unbounded interleavings into a form more amenable to reasoning and make explicit the relationship between implementation-level contention/interference and ADT-level transitions. +

+

+We evaluate our work on numerous non-trivial concurrent objects from the literature (including the Michael-Scott queue, Elimination stack, SLS reservation queue, RDCSS and Herlihy-Wing queue). We show that quotients capture the diverse features/complexities of these algorithms, can be used even when linearization points are not straight-forward, correspond to original authors' correctness arguments, and provide some new scenario-based arguments. Finally, we show that discovery of some object's quotients reduces to two-thread reasoning and give an implementation that can derive candidate quotients expressions from source code.

+

Mechanizing the CMP Abstraction for Parameterized Verification

  • Yongjian Li
  • Bohua Zhan
  • Jun Pang
+

Parameterized verification is a challenging problem that is known to be undecidable in the general case.  ‍is a widely-used method for parameterized verification, originally proposed by Chou, Mannava and Park in 2004. It involves abstracting the protocol to a small fixed number of nodes, and strengthening by auxiliary invariants to refine the abstraction. In most of the existing applications of CMP, the abstraction and strengthening procedures are carried out manually, which can be tedious and error-prone. Existing theoretical justification of the  ‍method is also done at a high level, without detailed descriptions of abstraction and strengthening rules. In this paper, we present a formally verified theory of  ‍in Isabelle/HOL, with detailed, syntax-directed procedure for abstraction and strengthening that is proven correct. The formalization also includes correctness of symmetry reduction and assume-guarantee reasoning. We also describe a tool AutoCMP for automatically carrying out abstraction and strengthening in , as well as generating Isabelle proof scripts showing their correctness. We applied the tool to a number of parameterized protocols, and discovered some inaccuracies in previous manual applications of  ‍to the FLASH cache coherence protocol.

+

Message-Observing Sessions

  • Ryan Kavanagh
  • Brigitte Pientka
+

We present Most, a process language with message-observing session types. Message-observing session types extend binary session types with type-level computation to specify communication protocols that vary based on messages observed on other channels. Hence, Most allows us to express global invariants about processes, rather than just local invariants, in a bottom-up, compositional way. We give Most a semantic foundation using traces with binding, a semantic approach for compositionally reasoning about traces in the presence of name generation. We use this semantics to prove type soundness and compositionality for Most processes. We see this as a significant step towards capturing message-dependencies and providing more precise guarantees about processes.

+

Understanding and Finding Java Decompiler Bugs

  • Yifei Lu
  • Weidong Hou
  • Minxue Pan
  • Xuandong Li
  • Zhendong Su
+

Java decompilers are programs that perform the reverse process of Java compilers, i.e., they translate Java bytecode to Java source code. They are essential for reverse engineering purposes and have become more sophisticated and reliable over the years. However, it remains challenging for modern Java decompilers to reliably perform correct decompilation on real-world programs. To shed light on the key challenges of Java decompilation, this paper provides the first systematic study on the characteristics and causes of bugs in mature, widely-used Java decompilers. We conduct the study by investigating 333 unique bugs from three popular Java decompilers. Our key findings and observations include: (1) Although most of the reported bugs were found when decompiling large, real-world code, 40.2% of them have small test cases for bug reproduction; (2) Over 80% of the bugs manifest as exceptions, syntactic errors, or semantic errors, and bugs with source code artifacts are very likely semantic errors; (3) 57.7%, 39.0%, and 41.1% of the bugs respectively are attributed to three stages of decompilers—loading structure entities from bytecode, optimizing these entities, and generating source code from these entities; (4) Bugs in decompilers’ type inference are the most complex to fix; and (5) Region restoration for structures like loop, sugaring for special structures like switch, and type inference of variables of generic types or indistinguishable types are the three most significant challenges in Java decompilation, which to some extent explains our findings in (3) and (4).

Based on these findings, we present JD-Tester, a differential testing framework for Java decompilers, and our experience of using it in testing the three popular Java decompilers. JD-Testerutilizes different Java program generators to construct executable Java tests and finds exceptions, syntactic, and semantic inconsistencies (i.e. bugs) between a generated test and its compiled-decompiled version (through compilation and execution). In total, we have found 62 bugs in the three decompilers, demonstrating both the effectiveness of JD-Tester, and the importance of testing and validating Java decompilers.

+

Taypsi: Static Enforcement of Privacy Policies for Policy-Agnostic Oblivious Computation

  • Qianchuan Ye
  • Benjamin Delaware
+

Secure multiparty computation (MPC) techniques enable multiple parties to compute joint functions over their private data without sharing that data with other parties, typically by employing powerful cryptographic protocols to protect individual's data. One challenge when writing such functions is that most MPC languages force users to intermix programmatic and privacy concerns in a single application, making it difficult to change or audit a program's underlying privacy policy. Prior policy-agnostic MPC languages relied on dynamic enforcement to decouple privacy requirements from program logic. Unfortunately, the resulting overhead makes it difficult to scale MPC applications that manipulate structured data. This work proposes to eliminate this overhead by instead transforming programs into semantically equivalent versions that statically enforce user-provided privacy policies. We have implemented this approach in a new MPC language, called Taypsi; our experimental evaluation demonstrates that the resulting system features considerable performance improvements on a variety of MPC applications involving structured data and complex privacy policies.

+

Iterative-Epoch Online Cycle Elimination for Context-Free Language Reachability

  • Pei Xu
  • Yuxiang Lei
  • Yulei Sui
  • Jingling Xue
+

Context-free language reachability (CFL-reachability) is a fundamental framework for implementing various static analyses. CFL-reachability utilizes context-free grammar (CFG) to extend the expressiveness of ordinary graph reachability from an unlabeled graph to an edge-labeled graph. Solving CFL-reachability requires a (sub)cubic time complexity with respect to the graph size, which limits its scalability in practice. Thus, an approach that can effectively reduce the graph size while maintaining the reachability result is highly desirable. Most of the existing graph simplification techniques for CFL-reachability work during the preprocessing stage, i.e., before the dynamic CFL-reachability solving process. However, in real-world CFL-reachability analyses, there is a large number of reducible nodes and edges that can only be discovered during dynamic solving, leaving significant room for on-the-fly improvements. +

+

+This paper aims to reduce the graph size of CFL-reachability dynamically via online cycle elimination. We propose a simple yet effective approach to detect collapsible cycles in the graph based on the input context-free grammar. Our key insight is that symbols with particular forms of production rules in the grammar are the essence of transitivity of reachability relations in the graph. Specifically, in the graph, a reachability relation to a node v_i can be "transited" to another node v_j if there is a transitive relation from v_i to v_j, and cycles formed by transitive relations are collapsible. In this paper, we present an approach to identify the transitive symbols in a context-free grammar and propose an iterative-epoch framework for online cycle elimination. From the perspective of non-parallelized CFL-reachability solving, our iterative-epoch framework is well compatible with both the standard (unordered) solver and the recent ordered solver, and can significantly improve their performance. Our experiment on context-sensitive value-flow analysis for C/C++ and field-sensitive alias analysis for Java demonstrates promising performance improvement by our iterative-epoch cycle elimination technique. By collapsing cycles online, our technique accelerates the standard solver by 17.17× and 13.94× for value-flow analysis and alias analysis, respectively, with memory reductions of 48.8% and 45.0%. Besides, our technique can also accelerate the ordered solver by 14.32× and 8.36× for value-flow analysis and alias analysis, respectively, with memory reductions of 55.2% and 57.8%.

+

Modeling Dynamic (De)Allocations of Local Memory for Translation Validation

  • Abhishek Rose
  • Sorav Bansal
+

End-to-End Translation Validation is the problem of verifying the executable code generated by a compiler against the corresponding input source code for a single compilation. This becomes particularly hard in the presence of dynamically-allocated local memory where addresses of local memory may be observed by the program. In the context of validating the translation of a C procedure to executable code, a validator needs to tackle constant-length local arrays, address-taken local variables, address-taken formal parameters, variable-length local arrays, procedure-call arguments (including variadic arguments), and the alloca() operator. We provide an execution model, a definition of refinement, and an algorithm to soundly convert a refinement check into first-order logic queries that an off-the-shelf SMT solver can handle efficiently. In our experiments, we perform blackbox translation validation of C procedures (with up to 100+ SLOC), involving these local memory allocation constructs, against their corresponding assembly implementations (with up to 200+ instructions) generated by an optimizing compiler with complex loop and vectorizing transformations.

+
\ No newline at end of file diff --git a/_data/OpenTOC.yaml b/_data/OpenTOC.yaml index 6817ba5..6fcaec3 100644 --- a/_data/OpenTOC.yaml +++ b/_data/OpenTOC.yaml @@ -1377,3 +1377,7 @@ event: ExHET year: 2024 title: "Proceedings of the 3rd International Workshop on Extreme Heterogeneity Solutions" +- + event: OOPSLA + year: 2024 + title: "Proceedings of the 2019 ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications" From a93bfaaa3eb756c89c46c0e527010f42ea7e089e Mon Sep 17 00:00:00 2001 From: Adrian Sampson Date: Sun, 12 May 2024 20:35:32 -0400 Subject: [PATCH 59/64] Announce --- _announce/2024-04-16-aeic_2024.txt | 294 ++++++++++++++++++++++++++++ _announce/2024-04-18-aplas_2024.txt | 72 +++++++ _announce/2024-04-29-sle_2024.txt | 176 +++++++++++++++++ _announce/2024-05-01-rtfm_2024.txt | 42 ++++ 4 files changed, 584 insertions(+) create mode 100644 _announce/2024-04-16-aeic_2024.txt create mode 100644 _announce/2024-04-18-aplas_2024.txt create mode 100644 _announce/2024-04-29-sle_2024.txt create mode 100644 _announce/2024-05-01-rtfm_2024.txt diff --git a/_announce/2024-04-16-aeic_2024.txt b/_announce/2024-04-16-aeic_2024.txt new file mode 100644 index 0000000..0e8129a --- /dev/null +++ b/_announce/2024-04-16-aeic_2024.txt @@ -0,0 +1,294 @@ +--- +title: "28th Ada-Europe Conf. on Reliable Software Technologies (AEiC 2024)" +timestamp: "4/16/2024 7:26:35" +start: "6/11/2024" +end: "6/14/2024" +--- +----------------------------------------------------------------------- + +Call for Participation + +28th Ada-Europe International Conference on +Reliable Software Technologies (AEiC 2024) + +11-14 June 2024, Barcelona, Spain + +www.ada-europe.org/conference2024 + +*** Online registration open! *** +*** Extensive info on conference site *** + +Organized by Ada-Europe and Barcelona Supercomputing Center (BSC), +in cooperation with ACM SIGAda, ACM SIGBED, ACM SIGPLAN, +and Ada Resource Association (ARA), +supported and sponsored by ASCENDER project, ACM-W, Eurocity, +AdaCore, Rising STARS project, ACM-W Barcelona Chapter, and OpenMP + +#AEiC2024 #AdaEurope #AdaProgramming + +*** Early registration discount until May 20 *** +*** Highly recommended to book your hotel ASAP *** + +----------------------------------------------------------------------- + +*** Exciting News! + +Preparations for AEiC 2024, the 28th Ada-Europe International +Conference on Software Reliable Technologies, are well underway! + +Registrations opened Tuesday April 16, and we've got some exciting +offers lined up for you, courtesy of our generous sponsors Rising +STARS and AdaCore, as well as an inspiring program. + +See below for an overview, and visit our website for more details about +accepted contributions, registration fees, social events and many more. + +*** General Information + +The 28th Ada-Europe International Conference on Reliable Software +Technologies (AEiC 2024) will take place in Barcelona, Spain. +The conference schedule comprises a keynote and an invited talk, +a panel with invited experts, a journal track, an industrial track, +a work-in-progress track, a vendor exhibition, parallel tutorials and +hackaton, and satellite workshops. There will be time for networking +during breaks and lunches, as well as various social events. + +AEiC 2024 is the latest in a series of annual international conferences +started in the early 80's, under the auspices of Ada-Europe, the +international organization that promotes knowledge and use of the Ada +programming language and reliable software in general, into academic +education and research, and industrial practice. + +The Ada-Europe series of conferences has over the years become +a leading international forum for providers, practitioners and +researchers in reliable software technologies. These events +highlight the increased relevance of Ada in general and in safety- +and security-critical systems in particular, and provide a unique +opportunity for interaction and collaboration between academics and +industrial practitioners. + +The 2024 edition of the conference continues a number of important +innovations started in previous years: +- reduced conference registration fee for all authors; +- low registration fee for all tutorials and workshops; +- journal-based open-access publication model for peer-reviewed papers; +- compact program with two core days (Wednesday & Thursday); +- tutorials on Tuesday, followed by welcome event for all participants; +- workshops on Friday, optional chill event on Thursday evening. + +*** Overview of the Week + +- Tue 11: six half-day tutorials, full-day hackaton, welcome reception +- Wed 12: core technical program, conference banquet +- Thu 13: core technical program, post conference chill-out +- Fri 17: four full-day workshops + +Extensive information on AEiC 2024 is on the conference website, +such as an overview of the program, the list of accepted papers and +presentations, and descriptions of workshops, tutorials, hackaton, +keynote and invited presentations, panel, and social events. +Also check the conference site for registration, accommodation and +travel information. The Advance Program brochure will be available +there as well. + +*** Venue + +The conference will take place in UPC Campus Nord, easily accessible by +metro from the airport and city centre. If you can stay over before or +after the conference, there's a lot to see around. Check the Practical +Information section of the conference website for more info. + +*** Invited Speakers + +This year the conference will feature a keynote talk on the first +day, and a panel with three invited speakers on the second, plus an +invited talk. All will address topics of relevance in the conference +scope, with time for questions and answers. + +- On Wed June 12, a keynote talk by Francisco J. Cazorla and Jaume + Abella, from Barcelona Supercomputing Center, who will talk about + "Strategies to Build Safety Relevant High-Performance HW/SW Platforms + for Critical Embedded Systems". + +- On Thu June 13, a panel on "AI for Safety-Critical Systems: How + 'I' Should the AI be?", moderated by Cristina Seceleanu, Mälardalen + University, with three invited experts: Kerstin Bach (Norwegian + University of Science and Technology), Irune Yarza (Ikerlan), + Marta Barroso (Barcelona Supercomputing Center). + +- And an invited talk by Rosa Maria Badia, Barcelona Supercomputing + Center, on "Simplifying the Life-Cycle Management of Complex + Application Workflows". + +*** Conference Core Composition + +The core conference program features three distinct types of technical +presentations, with different duration, in addition to the keynote +talk and the pannel session: journal-track talks (25 minutes), +industrial-track talks (15 minutes), work-in-progress-track talks +(10 minutes). + +All papers presented in the journal track, the industrial track and +the work-in-progress track have undergone peer review. Presentations +are combined into by-theme and not by-track sessions, in order that +authors and participants alike enjoy all flavors of the program in +a mixed as opposed to segregated combination. + +Papers and Presentations: +- 6 sessions with a mix of presentations on specific topics +- 13 journal-track talks +- 8 work-in-progress reports +- 5 industrial presentations and experience reports +- submissions from around the world +- accepted contributions by authors from Belgium, China, France, + Germany, India, Italy, Portugal, Spain, Sweden, UK, USA + +*** Tutorials + +Six three-hour tutorials are offered on Tuesday 11th: + +- "Lock-Free Programming in Ada-2022: Implementing a Work-Stealing + Scheduler for Ada-2022's Light-Weight Parallelism", by S. Tucker + Taft, AdaCore, USA + +- "Ada for Business Applications", by Gautier de Montmollin, + Ada-Switzerland, Switzerland + +- "Rust Fundamentals", by Luis Miguel Pinho and Tiago Carvalho, + ISEP, Portugal + +- "Concurrency and Parallelism in Rust", by Luis Miguel Pinho and + Tiago Carvalho, ISEP, Portugal + +- "Modeling Concurrent State Machines in TLA+", by J. Germán Rivera, + Tesla, USA + +- "Introduction to the Development of Safety-Critical Software", + by Jean-Pierre Rosen, Adalog, France + +- "METASAT: Programming High Performance RISC-V Technologies for + Space", by Leonidas Kosmidis, Barcelona Supercomputing Center, + Alejandro Calderon, Ikerlan, Aridane Alvarez Suarez, fentISS, + Lorenzo Lazzara, Collins Aerospace, Eckart Göhler, OHB + +- "Introduction to Certifiable General Purpose GPU Programming + for Safety-Critical Systems", by Leonidas Kosmidis, Barcelona + Supercomputing Center, Rod Burns and Verena Beckham, Codeplay/Intel + +as well as a "hackaton": + +- "Optimizing AI-driven Workflows within a Mission-Critical + Cyber-Physical System", if you're keen to explore the latest AI + techniques for Adaptive Optics applications in giant telescopes + with Damien Gratadour, Observatoire de Paris, CNRS, France + +*** Satellite Events + +Four workshops are held on Friday 11th: + +- 3rd ADEPT workshop "AADL by its practitioners" + +- 9th International Workshop on "Challenges and New Approaches for + Dependable and Cyber-Physical System Engineering" (DeCPS 2024) + +- "Enabling the use of AI in Safety-Critical Systems" + +- "Ada Developers Workshop", an informal yet dynamic gathering for + developers in the Ada community to meet, share insights, and present + their latest projects or project updates, using the Ada programming + language and Ada-related technology + +*** Social Program + +The conference provides several opportunities to socialize: + +- Each day: coffee breaks and lunches offer ample time for interaction + and networking with participants and vendors. + +- Tuesday early evening: welcome reception at the picturesque gardens + of Torre Girona. Guests will be treated to a curated selection + of local wines paired with the globally renowned Iberian ham, and + an array of delectable appetizers representing the rich culinary + heritage of Catalonia and Spain. Attendees will have the unique + opportunity to explore the cutting-edge facilities of the Barcelona + Supercomputing Center, and marvel at its latest addition, the + Marenostrum V supercomputer, and its predecessor, Marenostrum IV, + housed within the historic chapel of Torre Girona. + +- Wednesday evening: Conference Banquet at the emblematic restaurant + "7 portes". Attendees will have the opportunity to savor the + finest flavors of the Catalan and Mediterranean cuisines, such as + the renowned "Paella Perallada", a masterpice that harmoniously + combines semi-dry rice with succulent peeliled shellfish, delectable + seafood and tender meats. With a history spanning over 180 years, + "7 portes" stands as a witness to the evolution of some of the + most illustrious artists of their time, including Pablo Picasso and + Antoni Tàpies. Their presence has left an indelible mark, forming + a captivating small art gallery within the restaurant's walls, + waiting to be discovered by guests. + +- Thursday evening: Chill event at the Moritz Barcelona Brewery, + the brewery of the first beer of Barcelona. The event is divided + in three parts: a visit to the brewery, a welcome drink at the + Brasserie room, offering an exclusive vantage point overlooking the + maceration tanks, and a banquet served within the same Brasserie + room, by renowned chef Jordi Vilà, adorned with a Michelin star, + promising a gastronomic experience to be savored and remembered. + +*** Further Information + +Registration: +- registration information is provided at + +- early registration discount until Monday May 20, 2024 +- payment possible by credit card or bank transfer +- special low conference fee for authors +- discount for Ada-Europe, ACM SIGAda, SIGBED and SIGPLAN members +- registration includes coffee breaks, lunches and social events +- low tutorial and workshop fees for all participants +- strong discount on all fees for students +- minimal fee for AI Hackaton and Ada Developers Workshop +- see registration page for all details + +Promotion: +- recommended Twitter hashtags: #AEiC2024 #AdaEurope #AdaProgramming + +AEiC 2024 Sponsors: +- Barcelona Supercomputing Center: +- ASCENDER project: + +- ACM-W: +- Eurocity: +- AdaCore: +- Rising STARS project: +- ACM-W Barcelona Chapter: +- OpenMP: + +The conference is supported and sponsored by +- Ada-Europe: + +and organized in cooperation with +- ACM SIGAda: +- ACM SIGBED: +- ACM SIGPLAN: +- ARA: + +Please make sure you book accommodation as soon as possible. + +For more info and latest updates see the conference website at +. + +We look forward to seeing you in Barcelona in June 2024! + +----------------------------------------------------------------------- + +Our apologies if you receive multiple copies of this announcement. +Please circulate widely. + +Dirk Craeynest, AEiC 2024 Publicity Chair +Dirk.Craeynest@cs.kuleuven.be + +* 28th Ada-Europe Int. Conf. Reliable Software Technologies (AEiC 2024) +* June 11-14, 2024, Barcelona, Spain, www.ada-europe.org/conference2024 + diff --git a/_announce/2024-04-18-aplas_2024.txt b/_announce/2024-04-18-aplas_2024.txt new file mode 100644 index 0000000..16d5a18 --- /dev/null +++ b/_announce/2024-04-18-aplas_2024.txt @@ -0,0 +1,72 @@ +--- +title: "Call for Papers, APLAS 2024 -- The 22nd Asian Symposium on Programming Languages and Systems" +timestamp: "4/18/2024 22:17:56" +deadline: "5/24/2024" +--- +APLAS 2024 -- The 22nd Asian Symposium on Programming Languages and Systems +October 22-24, 2024, Kyoto, Japan + + https://conf.researchr.org/home/aplas-2024/ + +APLAS 2024 aims to bring together programming language researchers, +practitioners and implementors *worldwide*, to present and discuss the +latest results and exchange ideas in all areas of programming +languages and systems. APLAS 2024 is co-located with the +22nd International Symposium on Automated Technology for Verification +and Analysis (ATVA). + + +We solicit submissions in the form of regular research papers +describing original scientific research results, including system +development and case studies. Among others, solicited topics include: +programming paradigms and styles; methods and tools to specify and +reason about programs and languages; programming language foundations; +methods and tools for implementation; concurrency and distribution; +applications, case studies and emerging topics. + +Submissions should not exceed 17 pages, excluding bibliography, in the +Springer LNCS format. The reviewing process is light double-blind, +with a rebuttal phase to address factual errors and minor +misunderstandings. + +Proceedings of APLAS 2024 will be published by Springer as part of +Lecture Notes in Computer Science (LNCS). +https://link.springer.com/conference/aplas + +APLAS 2024 continues the tradition of the best paper award. + + Submission deadline: Fri May 24 + + Response period: Jul 24-26 + Acceptance notification: Fri Aug 2 + Camera-ready: Sat Aug 31 + +The submission website is now open: https://aplas24.hotcrp.com/ + +General Chair: Jacques Garrigue (Nagoya U.) +Publicity Chairs: Ryosuke Sato (TUAT U.), Mirai Ikebuchi (Kyoto U.) + +Program Committee: + +Beniamino Accattoli (Inria & Ecole Polytechnique) +Pierre-Evariste Dagand (IRIF / CNRS) +Silvia Ghilezan (University of Novi Sad, Mathematical Institute SASA) +Fritz Henglein (DIKU and Deon Digital) +Mirai Ikebuchi (Kyoto University) +Patrik Jansson (Chalmers University of Technology and University of Gothenburg) +Oleg Kiselyov (Tohoku University, PC Chair) +Hsiang-Shang ‘Josh’ Ko (Academia Sinica) +Daan Leijen (Microsoft Research) +Martin Lester (University of Reading) +Fredrik Nordvall Forsberg (University of Strathclyde) +Matija Pretnar (University of Ljubljana) +Peter Schachte (The University of Melbourne) +Sven-Bodo Scholz (Radboud University) +Philipp Schuster (University of Tübingen) +Taro Sekiyama (NII) +Amir Shaikhha (University of Edinburgh) +Pavle Subotic (Fantom Foundation) +Yong Kiam Tan (Institute for Infocomm Research, A*STAR) +Kazunori Ueda (Waseda University) +Yuting Wang (Shanghai Jiao Tong University) +Ki Yung Ahn (Hannam University) diff --git a/_announce/2024-04-29-sle_2024.txt b/_announce/2024-04-29-sle_2024.txt new file mode 100644 index 0000000..f33390a --- /dev/null +++ b/_announce/2024-04-29-sle_2024.txt @@ -0,0 +1,176 @@ +--- +title: "1st CfP: SLE 2024 - 17th ACM SIGPLAN International Conference on Software Language Engineering" +timestamp: "4/29/2024 8:42:12" +deadline: "6/14/2024" +--- +------------------------------------------------------------------------ +17th ACM SIGPLAN International Conference on Software Language Engineering (SLE 2024) +October 20-25, 2024 +Pasadena, California, United States + +http://www.sleconf.org/2024/ +https://2024.splashcon.org/track/sle-2024 +Follow us on X: https://x.com/sleconf +------------------------------------------------------------------------ + +We are pleased to invite you to submit papers to the 17th ACM SIGPLAN International Conference on Software Language Engineering (SLE 2024), held in conjunction with SPLASH 2024. The conference will be hosted in Pasadena, California, United States on October 20-25, 2024. + +--------------------------- +Topics of Interest +--------------------------- + +SLE covers software language engineering in general, rather than engineering a specific software language. Topics of interest include, but are not limited to: + +* Software Language Design and Implementation + - Approaches to and methods for language design + - Static semantics (e.g., design rules, well-formedness constraints) + - Techniques for specifying behavioral/executable semantics + - Generative approaches (incl. code synthesis, compilation) + - Meta-languages, meta-tools, language workbenches +* Validation of Software Language Tools and Implementations + - Verification and formal methods for language tools and implementations + - Testing techniques for language tools and implementations + - Simulation techniques for language tools and implementations +* Software Language Maintenance + - Software language reuse + - Language evolution + - Language families and variability, language and software product lines +* Software Language Integration and Composition + - Coordination of heterogeneous languages and tools + - Mappings between languages (incl. transformation languages) + - Traceability between languages + - Deployment of languages to different platforms +* Domain-Specific Approaches for Any Aspects of SLE (analysis, design, implementation, validation, maintenance) +* Empirical Studies and Experience Reports of Tools + - User studies evaluating usability + - Performance benchmarks + - Industrial applications +* Synergies between Language Engineering and Emerging/Promising Research Areas + - AI and ML language engineering (e.g., ML compiler testing, code classification) + - Quantum language engineering (e.g., language design for quantum machines) + - Language engineering for cyber-physical systems, IoT, digital twins, etc. + - Socio-technical systems and language engineering (e.g., language evolution to adapt to social requirements) + - Etc. + +--------------------------- +Types of Submissions +--------------------------- + +SLE accepts the following types of papers: + +Research papers: These are “traditional” papers detailing research contributions to SLE. Papers may range from 6 to 12 pages in length and may optionally include 2 further pages of bibliography/appendices. Papers will be reviewed with an understanding that some results do not need 12 full pages and may be fully described in fewer pages. + +New ideas/vision papers: These papers may describe new, unconventional software language engineering research positions or approaches that depart from standard practice. They can describe well-defined research ideas that are at an early stage of investigation. They could also provide new evidence to challenge common wisdom, present new unifying theories about existing SLE research that provides novel insight or that can lead to the development of new technologies or approaches, or apply SLE technology to radically new application areas. New ideas/vision papers must not exceed 5 pages and may optionally include 1 further page of bibliography/appendices. + +SLE Body of Knowledge: The SLE Body of Knowledge (SLEBoK) is a community-wide effort to provide a unique and comprehensive description of the concepts, best practices, tools, and methods developed by the SLE community. These papers can focus on, but are not limited to, methods, techniques, best practices, and teaching approaches. Papers in this category can have up to 20 pages, including bibliography/appendices. + +Tool papers: These papers focus on the tooling aspects often forgotten or neglected in research papers. A good tool paper focuses on practical insights that will likely be useful to other implementers or users in the future. Any of the SLE topics of interest are appropriate areas for tool demonstrations. Submissions must not exceed 5 pages and may optionally include 1 further page of bibliography/appendices. They may optionally include an appendix with a demo outline/screenshots and/or a short video/screencast illustrating the tool. + +**Workshops**: Workshops will be organized by SPLASH. Please inform us and contact the SPLASH organizers if you would like to organize a workshop of interest to the SLE audience. Information on how to submit workshops can be found on the SPLASH 2024 Website. + +--------------------------- +Submission +--------------------------- + +SLE 2024 has a single submission round for papers, including a rebuttal phase, where all authors of research papers will have the possibility of responding to the reviews on their submissions. + +Authors of accepted research papers will be invited to submit artifacts. + +--------------------------- +Important Dates +--------------------------- + +All dates are Anywhere on Earth (http://en.wikipedia.org/wiki/Anywhere_on_Earth). + +* Abstract Submissions: Fri 14 Jun, 2024 +* Paper Submissions: Mon 24 Jun, 2024 +* Authors Response Period: Mon 12 Aug - Sat 17 Aug, 2024 +* Authors Notification: Fri 30 Aug 2024 +* Conference: Sun 20 October - Fri 25 October 2024 (co-located with SPLASH, precise dates to be announced) + +--------------------------- +Format +--------------------------- + +Submissions have to use the ACM SIGPLAN Conference Format “acmart” (https://sigplan.org/Resources/Author/#acmart-format); please make sure that you always use the latest ACM SIGPLAN acmart LaTeX template, and that the document class definition is `\documentclass[sigplan,anonymous,review]{acmart}`. Do not make any changes to this format! + +Ensure that your submission is legible when printed on a black and white printer. In particular, please check that colors remain distinct and font sizes in figures and tables are legible. + +To increase fairness in reviewing, a double-blind review process has become standard across SIGPLAN conferences. Accordingly, SLE will follow the double-blind process. Author names and institutions must be omitted from submitted papers, and references to the authors’ own related work should be in the third person. No other changes are necessary, and authors will not be penalized if reviewers are able to infer their identities in implicit ways. + +All submissions must be in PDF format. The submission website is: https://sle24.hotcrp.com + +--------------------------- +Concurrent Submissions +--------------------------- + +Papers must describe unpublished work that is not currently submitted for publication elsewhere as described by SIGPLAN’s Republication Policy (https://www.sigplan.org/Resources/Policies/Republication/). Submitters should also be aware of ACM’s Policy and Procedures on Plagiarism (https://www.acm.org/publications/policies/plagiarism-overview). Submissions that violate these policies will be desk-rejected. + + +--------------------------- +Policy on Human Participant and Subject Research +--------------------------- + +Authors conducting research involving human participants and subjects must ensure that their research complies with their local governing laws and regulations and the ACM’s general principles, as stated in the ACM’s Publications Policy on Research Involving Human Participants and Subjects (https://www.acm.org/publications/policies/research-involving-human-participants-and-subjects). If submissions are found to be violating this policy, they will be rejected. + + +--------------------------- +Reviewing Process +--------------------------- + +All submitted papers will be reviewed by at least three members of the program committee. Research papers and tool papers will be evaluated concerning soundness, relevance, novelty, presentation, and replicability. New ideas/vision papers will be evaluated primarily concerning soundness, relevance, novelty, and presentation. SLEBoK papers will be reviewed on their soundness, relevance, originality, and presentation. Tool papers will be evaluated concerning relevance, presentation, and replicability. + +For fairness reasons, all submitted papers must conform to the above instructions. Submissions that violate these instructions may be rejected without review at the discretion of the PC chairs. + +For research papers, authors will get a chance to respond to the reviews before a final decision is made. + + +--------------------------- +Artifact Evaluation +--------------------------- + +SLE will use an evaluation process to assess the quality of artifacts on which papers are based to foster the culture of experimental reproducibility. Authors of accepted research papers are invited to submit artifacts. For more information, please see the Artifact Evaluation (https://2024.splashcon.org/track/sle-2024#Artifact-Evaluation) page. + +--------------------------- +Awards +--------------------------- + +Distinguished paper: Award for the most notable paper, as determined by the PC +chairs based on the recommendations of the program committee. + +Distinguished artifact: Award for the artifact most significantly exceeding +expectations, as determined by the AEC chairs based on the recommendations of +the artifact evaluation committee. + +--------------------------- +Publication +--------------------------- + +All accepted papers will be published in the ACM Digital Library. + +**AUTHORS TAKE NOTE**: The official publication date is the date the proceedings are made available in the ACM Digital Library. This date may be up to two weeks prior to the first day of the conference. The official publication date affects the deadline for any patent filings related to published work. + +--------------------------- +SLE and Doctoral Students +--------------------------- + +SLE encourages students to submit to the SPLASH doctoral symposium. Authors of accepted doctoral symposium papers on SLE topics will also have the chance to present their work to the SLE audience. + +--------------------------- +Organisation +--------------------------- + +Chairs: + +* General chair: Ralf Lämmel, Universität Koblenz, Germany +* PC co-chair: Peter Mosses, Swansea University and Delft University of Technology, Netherlands +* PC co-chair: Juliana Alves Pereira, Pontifícia Universidade Católica do Rio de Janeiro, Brazil +* Publicity chair: Andrei Chis, feenk gmbh, Switzerland + + +--------------------------- +Contact +--------------------------- + +For additional information, clarification, or answers to questions, please get in touch with the program co-chairs (P.D.Mosses at tudelft.nl and Juliana at inf.puc-rio.br). + diff --git a/_announce/2024-05-01-rtfm_2024.txt b/_announce/2024-05-01-rtfm_2024.txt new file mode 100644 index 0000000..f41153a --- /dev/null +++ b/_announce/2024-05-01-rtfm_2024.txt @@ -0,0 +1,42 @@ +--- +title: "Call for Participation: First PLDI Workshop on Red-Hot Topics in Faculty Mentoring (RTFM)" +timestamp: "5/1/2024 16:25:50" +start: "6/25/2024" +end: "6/25/2024" +--- +Call for Participation in the First PLDI Workshop +on +Red-Hot Topics in Faculty Mentoring (RTFM) +(aka Read the Faculty Manual) + +https://pldi24.sigplan.org/home/rtfm-2024 +Tuesday, June 25, 2024 +co-located with PLDI'24 in Copenhagen, Denmark + +We believe our community has come a long way in acknowledging that junior researchers need as much mentoring as they can get to prepare them for future jobs and help them succeed. The PLMW workshop series has made it possible for us to talk openly with students about the challenges and stresses facing graduate students: problems with advisors, paper rejections, mental health, and career planning. However, the same can’t be said about the challenges of being faculty: many junior faculty don’t feel comfortable discussing their doubts or asking for advice about how to manage a research group or build a tenure case, and not every junior professor is lucky enough to have a suitable mentor at their own institution to ask for help. + +The goal of this workshop is to provide a forum for full-time academics to comfortably share their experience in non-technical aspects related to faculty life. Not all such experiences are positive. Sometimes things don’t work out: PhD students change advisors, grants are rejected, topics go out of fashion. We believe many of the not-so-junior members of the community would love to learn about how “the magic is done” in other research groups, and what are the non-technical ingredients that enable long-term successful research and a happy work environment. + +The workshop is targeting academic faculty of any seniority level, as well as senior PhD students and postdocs who have accepted faculty positions but have not officially started yet. + +For the inaugural edition of the RTFM workshop, we are delighted to confirm the following speakers: + +- Işıl Dillig (UT Austin), on running a research group +- Nate Foster (Cornell), on doing interdisciplinary research +- Ranjit Jhala (UCSD), on writing grants +- Peter Müller (ETH Zurich), on long-term research problem selection + +The workshop will also feature three discussion panels on + +- Getting tenure +- Recruiting and supporting students +- Work-life balance, service, and teaching + +The workshop will conclude with a slot for one-on-one mentoring sessions. + +RTFM@PLDI’24 organizers: + +- Amal Ahmed (Northeastern University) +- Derek Dreyer (MPI-SWS) +- Ilya Sergey (NUS) + From b64ad815deebe90b09c3c033c832e879d57419c0 Mon Sep 17 00:00:00 2001 From: Catalin Hritcu Date: Thu, 16 May 2024 10:52:17 +0200 Subject: [PATCH 60/64] Updated SC list CPP.md --- Conferences/CPP.md | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/Conferences/CPP.md b/Conferences/CPP.md index 7bceacf..a2783f6 100644 --- a/Conferences/CPP.md +++ b/Conferences/CPP.md @@ -6,24 +6,26 @@ Certified Programs and Proofs (CPP) is an international conference on practical **Steering Committee** -* [Lennart Beringer](https://www.cs.princeton.edu/~eberinge/), Princeton University, USA * [Sandrine Blazy](https://people.irisa.fr/Sandrine.Blazy/), University of Rennes, France * [Adam Chlipala](http://adam.chlipala.net), MIT, USA -* Georges Gonthier, Inria, France +* [Georges Gonthier](https://scholar.google.co.uk/citations?user=cbtN84wAAAAJ&hl=en), Inria, France * [Cătălin Hriţcu](https://catalin-hritcu.github.io) (Chair), MPI-SP, Germany * [Gerwin Klein](https://doclsf.de), CSIRO's Data61 and UNSW Sydney, Australia * [Robbert Krebbers](https://robbertkrebbers.nl), Radboud University Nijmegen, Netherlands * [Dale Miller](http://www.lix.polytechnique.fr/Labo/Dale.Miller/), INRIA Saclay and LIX/Institut Polytechnique de Paris, France * [Tobias Nipkow](https://www21.in.tum.de/~nipkow/), Technische Universität München, Germany * [Brigitte Pientka](https://www.cs.mcgill.ca/~bpientka/), McGill University, Canada -* [Andrei Popescu](https://www.andreipopescu.uk), University of Sheffield, United Kingdom * [Zhong Shao](http://www.cs.yale.edu/homes/shao/), Yale University, USA -* [Kathrin Stark](https://www.k-stark.de), Heriot-Watt University, United Kingdom -* [Nicolas Tabareau](https://tabareau.fr), Inria, France * [Amin Timany](https://cs.au.dk/~timany/), Aarhus University, Denmark * [Dmitriy Traytel](https://traytel.bitbucket.io), University of Copenhagen, Denmark * [Steve Zdancewic](https://www.cis.upenn.edu/~stevez/), University of Pennsylvania, USA +** Former SC members ** +* [Andrei Popescu](https://www.andreipopescu.uk), University of Sheffield, United Kingdom +* [Lennart Beringer](https://www.cs.princeton.edu/~eberinge/), Princeton University, USA +* ... + + --- **Previous CPP Conferences** @@ -88,4 +90,4 @@ On the other hand, there is a recent trend in computer science to formally prove There are not many proof assistants around. There should be more, because progress benefits from competition. On the other hand, there is much theoretical work that could be implemented in the form of a proof assistant, but this does not really happen. One reason is that it is hard to publish a development work, especially when this requires a long-term effort as is the case for a proof assistant. It is even harder to publish work about libraries which, we all know, are fundamental for the success of a proof assistant. CPP would pay particular attention in publishing, publicizing, and promoting this kind of work. -Finally, CPP also aims to be a publication arena for innovative teaching experiences, in computer science or mathematics, using proof assistants in an essential way. These experiences could be submitted in an innovative format to be defined. \ No newline at end of file +Finally, CPP also aims to be a publication arena for innovative teaching experiences, in computer science or mathematics, using proof assistants in an essential way. These experiences could be submitted in an innovative format to be defined. From f2178c4d85981c6ec386dcf60bbd0a4344a7b689 Mon Sep 17 00:00:00 2001 From: Catalin Hritcu Date: Thu, 16 May 2024 11:26:39 +0200 Subject: [PATCH 61/64] Added former SC members who were PC chairs --- Conferences/CPP.md | 24 +++++++++++++++++++----- 1 file changed, 19 insertions(+), 5 deletions(-) diff --git a/Conferences/CPP.md b/Conferences/CPP.md index a2783f6..735bd54 100644 --- a/Conferences/CPP.md +++ b/Conferences/CPP.md @@ -6,13 +6,13 @@ Certified Programs and Proofs (CPP) is an international conference on practical **Steering Committee** +* [Cătălin Hriţcu](https://catalin-hritcu.github.io) (SC Chair), MPI-SP, Germany * [Sandrine Blazy](https://people.irisa.fr/Sandrine.Blazy/), University of Rennes, France * [Adam Chlipala](http://adam.chlipala.net), MIT, USA * [Georges Gonthier](https://scholar.google.co.uk/citations?user=cbtN84wAAAAJ&hl=en), Inria, France -* [Cătălin Hriţcu](https://catalin-hritcu.github.io) (Chair), MPI-SP, Germany -* [Gerwin Klein](https://doclsf.de), CSIRO's Data61 and UNSW Sydney, Australia +* [Gerwin Klein](https://doclsf.de), Proofcraft and UNSW Sydney, Australia * [Robbert Krebbers](https://robbertkrebbers.nl), Radboud University Nijmegen, Netherlands -* [Dale Miller](http://www.lix.polytechnique.fr/Labo/Dale.Miller/), INRIA Saclay and LIX/Institut Polytechnique de Paris, France +* [Dale Miller](http://www.lix.polytechnique.fr/Labo/Dale.Miller/), Inria Saclay and LIX/Institut Polytechnique de Paris, France * [Tobias Nipkow](https://www21.in.tum.de/~nipkow/), Technische Universität München, Germany * [Brigitte Pientka](https://www.cs.mcgill.ca/~bpientka/), McGill University, Canada * [Zhong Shao](http://www.cs.yale.edu/homes/shao/), Yale University, USA @@ -20,12 +20,26 @@ Certified Programs and Proofs (CPP) is an international conference on practical * [Dmitriy Traytel](https://traytel.bitbucket.io), University of Copenhagen, Denmark * [Steve Zdancewic](https://www.cis.upenn.edu/~stevez/), University of Pennsylvania, USA -** Former SC members ** +**Former SC members** + * [Andrei Popescu](https://www.andreipopescu.uk), University of Sheffield, United Kingdom * [Lennart Beringer](https://www.cs.princeton.edu/~eberinge/), Princeton University, USA +* [Jasmin Blanchette](https://www.tcs.ifi.lmu.de/mitarbeiter/jasmin-blanchette_de.html), Ludwig-Maximilians-Universität München, Germany +* [Assia Mahboubi](https://people.rennes.inria.fr/Assia.Mahboubi/), Inria, France and Vrije Universiteit Amsterdam, Netherlands +* [Magnus Myreen](https://www.cse.chalmers.se/~myreen/), Chalmers University of Technology, Sweden +* [June Andronick](https://proofcraft.systems/), Proofcraft and UNSW Sydney, Australia +* [Amy Felty](https://www.site.uottawa.ca/~afelty/), University of Ottawa, Canada +* [Yves Bertot](https://www-sop.inria.fr/members/Yves.Bertot/research.html), Inria, France +* [Viktor Vafeiadis](https://people.mpi-sws.org/~viktor/), MPI-SWS, Germany +* [Jeremy Avigad](https://www.andrew.cmu.edu/user/avigad/), Carnegie Mellon University, USA +* [Adam Chlipala](http://adam.chlipala.net), MIT, USA +* [Xavier Leroy](https://xavierleroy.org), Collège de France, PSL University, France +* [Alwen Tiu](http://users.cecs.anu.edu.au/~tiu/), Australian National University, Australia +* [Michael Norrish](https://comp.anu.edu.au/people/michael-norrish/), Australian National University, Australia +* [Chris Hawblitzel](https://www.microsoft.com/en-us/research/people/chrishaw/), Microsoft Research, USA +* [Jean-Pierre Jouannaud](https://www.lix.polytechnique.fr/Labo/Jean-Pierre.Jouannaud/), Université de Paris-Saclay, France * ... - --- **Previous CPP Conferences** From e08953fe21ff2d55eb8163739678de346bed0e15 Mon Sep 17 00:00:00 2001 From: Catalin Hritcu Date: Thu, 16 May 2024 11:37:00 +0200 Subject: [PATCH 62/64] Added link to OpenTOC --- Conferences/CPP.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Conferences/CPP.md b/Conferences/CPP.md index 735bd54..5526d02 100644 --- a/Conferences/CPP.md +++ b/Conferences/CPP.md @@ -57,6 +57,8 @@ Certified Programs and Proofs (CPP) is an international conference on practical * [CPP 2012](http://cpp12.kuis.kyoto-u.ac.jp), Kyoto, Japan, December 13-15, 2012 (collocation with APLAS’12) * [CPP 2011](https://dblp.uni-trier.de/db/conf/cpp/cpp2011.html), Kenting, Taiwan, December 7-9, 2011 (co-located with APLAS’11) +The official **CPP proceedings** since 2015 are publicly available via [SIGPLAN OpenTOC](http://www.sigplan.org/OpenTOC/#cpp). + --- **Given Distinguished Paper Awards** From d0b9f2ff9e04f639fb7ad24a05bb870ca2dd9e73 Mon Sep 17 00:00:00 2001 From: Catalin Hritcu Date: Thu, 16 May 2024 11:49:59 +0200 Subject: [PATCH 63/64] Added affiliations to Reviewer Awards --- Conferences/CPP.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Conferences/CPP.md b/Conferences/CPP.md index 5526d02..9a3adcb 100644 --- a/Conferences/CPP.md +++ b/Conferences/CPP.md @@ -77,10 +77,10 @@ The official **CPP proceedings** since 2015 are publicly available via [SIGPLAN **Given Amazing Reviewer Awards** -* CPP 2023: [Théo Winterhalter](https://theowinterhalter.github.io) -* CPP 2023: [Anja Petković Komel](https://anjapetkovic.com) -* CPP 2022: [Armaël Guéneau](http://cambium.inria.fr/~agueneau/) -* CPP 2021: [Kathrin Stark](https://www.k-stark.de) +* CPP 2023: [Théo Winterhalter](https://theowinterhalter.github.io), Inria, France +* CPP 2023: [Anja Petković Komel](https://anjapetkovic.com), TU Wien, Austria +* CPP 2022: [Armaël Guéneau](http://cambium.inria.fr/~agueneau/), Inria, France +* CPP 2021: [Kathrin Stark](https://www.k-stark.de), Heriot-Watt University, UK --- **The CPP Manifesto (from 2011)** From cfab50fc84096db4daf9d0088f0c8ccc37bb9bdc Mon Sep 17 00:00:00 2001 From: Catalin Hritcu Date: Fri, 17 May 2024 08:39:10 +0200 Subject: [PATCH 64/64] Added former CPP SC members at large too --- Conferences/CPP.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Conferences/CPP.md b/Conferences/CPP.md index 9a3adcb..d4bd0b9 100644 --- a/Conferences/CPP.md +++ b/Conferences/CPP.md @@ -38,7 +38,9 @@ Certified Programs and Proofs (CPP) is an international conference on practical * [Michael Norrish](https://comp.anu.edu.au/people/michael-norrish/), Australian National University, Australia * [Chris Hawblitzel](https://www.microsoft.com/en-us/research/people/chrishaw/), Microsoft Research, USA * [Jean-Pierre Jouannaud](https://www.lix.polytechnique.fr/Labo/Jean-Pierre.Jouannaud/), Université de Paris-Saclay, France -* ... +* [Andrew Appel](https://www.cs.princeton.edu/~appel/), Princeton University, USA +* [Nikolaj Bjorner](https://www.microsoft.com/en-us/research/people/nbjorner/), Microsoft Research, USA +* [John Harrison](https://www.cl.cam.ac.uk/~jrh13/), Amazon Web Services, USA --- **Previous CPP Conferences**