The proceedings contain 68 papers. The topics discussed include: modular information flow through ownership;ANOSY: approximated knowledge synthesis with refinement types for declassification;hardening attack surfaces ...
ISBN:
(纸本)9781450392655
The proceedings contain 68 papers. The topics discussed include: modular information flow through ownership;ANOSY: approximated knowledge synthesis with refinement types for declassification;hardening attack surfaces with formally proven binary format parsers;turning manual concurrent memory reclamation into automatic reference counting;low-latency, high-throughput garbage collection;mako: a low-pause, high-throughput evacuating collector for memory-disaggregated datacenters;visualization question answering using introspective program synthesis;synthesizing analytical SQL queries from computation demonstration;sequential reasoning for optimizing compilers under weak memory concurrency;and can reactive synthesis and syntax-guided synthesis be friends?.
The proceedings contain 87 papers. The topics discussed include: incremental whole-program analysis in datalog with lattices;revamping hardware persistency models: view-based and axiomatic persistency models for intel...
ISBN:
(纸本)9781450383912
The proceedings contain 87 papers. The topics discussed include: incremental whole-program analysis in datalog with lattices;revamping hardware persistency models: view-based and axiomatic persistency models for intel-x86 and armv8;repairing serializability bugs in distributed database programs via automated schema refactoring;Gleipnir: toward practical error analysis for quantum programs;transfinite iris: resolving an existential dilemma of step-indexed separation logic;Perceus: garbage free reference counting with reuse;unleashing the hidden power of compiler optimization on binary code difference: an empirical study;RefinedC: automating the foundational verification of C code with refined ownership types;and wire sorts: a language abstraction for safe hardware composition.
The proceedings contain 77 papers. The topics discussed include: data-driven inference of representation invariants;type error feedback via analytic program repair;synthesizing structured CAD models with equality satu...
ISBN:
(纸本)9781450376136
The proceedings contain 77 papers. The topics discussed include: data-driven inference of representation invariants;type error feedback via analytic program repair;synthesizing structured CAD models with equality saturation and inverse transformations;compiler and runtime support for continuation marks;from folklore to fact: comparing implementations of stacks and continuations;learning nonlinear loop invariants with gated continuous logic networks;blended, precise semantic program embeddings;and BlankIt library debloating: getting what you want instead of cutting what you don't.
The proceedings contain 55 papers. The topics discussed include: BLeak: automatically debugging memory leaks in web applications;putting in all the stops: execution control for JavaScript;persistency for synchronizati...
ISBN:
(纸本)9781450356985
The proceedings contain 55 papers. The topics discussed include: BLeak: automatically debugging memory leaks in web applications;putting in all the stops: execution control for JavaScript;persistency for synchronization-free regions;write-rationing garbage collection for hybrid memories;mapping spiking neural networks onto a manycore neuromorphic architecture;static serializability analysis for causal consistency;Cuba: interprocedural context-unbounded analysis of concurrent programs;advanced automata-based algorithms for program termination checking;HHVM JIT: a profile-guided, region-based compiler for PHP and Hack;EffectiveSan: type and memory error detection using dynamically typed C/C++;calling-to-reference context translation via constraint-guided CFL-reachability;the semantics of transactions and weak memory in x86, power, ARM, and C++;MixT: a language for mixing consistency in geodistributed transactions;finding root causes of floating point error;to-many or to-one? all-in-one! efficient purely functional multi-maps with type-heterogeneous hash-tries;spatial: a language and compiler for application accelerators;enhancing computation-to-core assignment with physical location information;and SWOOP: so ware-hardware co-design for non-speculative, execute-ahead, in-order cores.
We present associated effects, a programminglanguage feature that enables type classes to abstract over the effects of their function signatures, allowing each type class instance to specify its concrete effects. Ass...
详细信息
We present associated effects, a programminglanguage feature that enables type classes to abstract over the effects of their function signatures, allowing each type class instance to specify its concrete effects. Associated effects significantly increase the flexibility and expressive power of a programminglanguage that combines a type and effect system with type classes. In particular, associated effects allow us to (i) abstract over total and partial functions, where partial functions may throw exceptions, (ii) abstract over immutable data structures and mutable data structures that have heap effects, and (iii) implement adaptors that combine type classes with algebraic effects. We implement associated effects as an extension of the Flix programminglanguage and refactor the Flix Standard Library to use associated effects, significantly increasing its flexibility and expressive power. Specifically, we add associated effects to 11 type classes, which enables us to add 28 new type class instances.
Power modeling is an essential building block for computer systems in support of energy optimization, energy profiling, and energy-aware application development. We introduce VESTA, a novel approach to modeling the po...
详细信息
Power modeling is an essential building block for computer systems in support of energy optimization, energy profiling, and energy-aware application development. We introduce VESTA, a novel approach to modeling the power consumption of applications with one key insight: language runtime events are often correlated with a sustained level of power consumption. When compared with the established approach of power modeling based on hardware performance counters (HPCs), VESTA has the benefit of solely requiring application-scoped information and enabling a higher level of explainability, while achieving comparable or even higher precision. Through experiments performed on 37 real-world applications on the Java Virtual Machine (JVM), we find the power model built by VESTA is capable of predicting energy consumption with a mean absolute percentage error of 1.56%, while the monitoring of language runtime events incurs small performance and energy overhead.
A key promise of probabilistic programming is the ability to specify rich models using an expressive programminglanguage. However, the expressive power that makes probabilistic programminglanguages enticing also pos...
详细信息
A key promise of probabilistic programming is the ability to specify rich models using an expressive programminglanguage. However, the expressive power that makes probabilistic programminglanguages enticing also poses challenges to inference, so much so that specialized approaches to inference ban language features such as recursion. We present an approach to variable elimination and marginal inference for probabilistic programs featuring bounded recursion, discrete distributions, and sometimes continuous distributions. A compiler eliminates probabilistic side effects, using a novel information-flow type system to factorize probabilistic computations and hoist independent subcomputations out of sums or integrals. For a broad class of recursive programs with dynamically recurring substructure, the compiler effectively decomposes a global marginal-inference problem, which may otherwise be intractable, into tractable subproblems. We prove the compilation correct by showing that it preserves denotational semantics. Experiments show that the compiled programs subsume widely used PTIME algorithms for recursive models and that the compilation time scales with the size of the inference problems. As a separate contribution, we develop a denotational, logical-relations model of information-flow types in the novel measure-theoretic setting of probabilistic programming;we use it to prove noninterference and consequently the correctness of variable elimination.
Graphics Processing Units (GPU) offer tremendous computational power by following a throughput oriented paradigm where many thousand computational units operate in parallel. programming such massively parallel hardwar...
详细信息
Graphics Processing Units (GPU) offer tremendous computational power by following a throughput oriented paradigm where many thousand computational units operate in parallel. programming such massively parallel hardware is challenging. Programmers must correctly and efficiently coordinate thousands of threads and their accesses to various shared memory spaces. Existing mainstream GPU programminglanguages, such as CUDA and OpenCL, are based on C/C++ inheriting their fundamentally unsafe ways to access memory via raw pointers. This facilitates easy to make, but hard to detect bugs, such as data races and deadlocks. In this paper, we present Descend: a safe GPU programminglanguage. In contrast to prior safe high-level GPU programming approaches, Descend is an imperative GPU systems programminglanguage in the spirit of Rust, enforcing safe CPU and GPU memory management in the type system by tracking Ownership and Lifetimes. Descend introduces a new holistic GPU programming model where computations are hierarchically scheduled over the GPU's execution resources: grid, blocks, warps, and threads. Descend's extended Borrow checking ensures that execution resources safely access memory regions without data races. For this, we introduced views describing safe parallel access patterns of memory regions, as well as atomic variables. For memory accesses that can't be checked by our type system, users can annotate limited code sections as unsafe. We discuss the memory safety guarantees offered by Descend and evaluate our implementation using multiple benchmarks, demonstrating that Descend is capable of expressing real-world GPU programs showing competitive performance compared to manually written CUDA programs lacking Descend's safety guarantees.
Producing efficient array code is crucial in high-performance domains like image processing and machine learning. It requires the ability to control factors like compute intensity and locality by reordering computatio...
详细信息
Producing efficient array code is crucial in high-performance domains like image processing and machine learning. It requires the ability to control factors like compute intensity and locality by reordering computations into different stages and granularities with respect to where they are stored. However, traditional pure, functional tensor languages struggle to do so. In a previous publication, we introduced ATL as a pure, functional tensor language capable of systematically decoupling compute and storage order via a set of high-level combinators known as reshape operators. Reshape operators are a unique functional-programming construct since they manipulate storage location in the generated code by modifying the indices that appear on the left-hand sides of storage expressions. We present a formal correctness proof for an implementation of the compilation algorithm, marking the first verification of a lowering algorithm targeting imperative loop nests from a source functional language that enables separate control of compute and storage ordering. One of the core difficulties of this proof required properly formulating the complex invariants to ensure that these storage-index remappings were well-formed. Notably, this exercise revealed a soundness bug in the original published compilation algorithm regarding the truncation reshape operators. Our fix is a new type system that captures safety conditions that were previously implicit and enables us to prove compiler correctness for well-typed source programs. We evaluate this type system and compiler implementation on a range of common programs and optimizations, including but not limited to those previously studied to demonstrate performance comparable to established compilers like Halide.
暂无评论