yusuke1997/dblp-id-title huggingface dataset:
Autotuning algorithmic choice for input sensitivity
A design proposal for Gen: probabilistic programming with fast custom inference via code generation
Run-time Code Generation and Modal-ML
Toward compositional verification of interruptible OS kernels and device drivers
Ethainter: a smart contract security analyzer for composite vulnerabilities
Can parallel data structures rely on automatic memory managers?
A Member Lookup Algorithm for C++
Type Reconstruction with First-Class Polymorphic Values
Proceedings of the 6th ACM SIGPLAN Workshop on X10, X10@PLDI 2016, Santa Barbara, CA, USA, June 14, 2016
Leapfrog: certified equivalence for protocol parsers
Auto-vectorization of interleaved data for SIMD
Automatic error elimination by horizontal code transfer across multiple applications
RefinedC: automating the foundational verification of C code with refined ownership types
Optimizing Programs over the Constructive Reals
The tao of parallelism in algorithms
Compiler testing via a theory of sound optimisations in the C11/C++11 memory model
Refined Types: Highly Differentiated Type Systems and Their Use in the Design of Intermediate Langages
Crafty: efficient, HTM-compatible persistent transactions
Data Transformations for Eliminating Conflict Misses
Scalable and precise dynamic datarace detection for structured parallelism
Dynamic software updates: a VM-centric approach
Complete Removal of Redundant Computations
From folklore to fact: comparing implementations of stacks and continuations
Flatten and conquer: a framework for efficient analysis of string constraints
Breadcrumbs: efficient context sensitivity for dynamic bug detection analyses
CGCExplorer: a semi-automated search procedure for provably correct concurrent collectors
A Sparse Algorithm for Predicated Global Value Numbering
MixT: a language for mixing consistency in geodistributed transactions
Modular interprocedural pointer analysis using access paths: design, implementation, and evaluation
A typed continuation-passing translation for lexical effect handlers
Mace: language support for building distributed systems
Synthesis of loop-free programs
Proceedings of the 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2011, San Jose, CA, USA, June 4-8, 2011
CoStar: a verified ALL(*) parser
Low overhead dynamic binary translation on ARM
Formal loop merging for signal transforms
Implementation of the memory-safe full ANSI-C compiler
Checking and inferring local non-aliasing
Proceedings of the ACM SIGPLAN 2005 Conference on Programming Language Design and Implementation, Chicago, IL, USA, June 12-15, 2005
Capabilities for information flow
Array program transformation with Loo.py by example: high-order finite elements
Efficient purely-dynamic information flow analysis
Learned garbage collection
DIY assistant: a multi-modal end-user programmable virtual assistant
Thin Locks: Featherweight Synchronization for Java
Revamping hardware persistency models: view-based and axiomatic persistency models for Intel-x86 and Armv8
Using Cohort Scheduling to Enhance Server Performance (Extended Abstract)
Skeletal program enumeration for rigorous compiler testing
Boosting SMT solver performance on mixed-bitwise-arithmetic expressions
RockSalt: better, faster, stronger SFI for the x86
An Automatically Generated, Realistic Compiler for an Imperative Programming Language
GreenWeb: language extensions for energy-efficient mobile web computing
Split-stream dictionary program compression
Flexible data views: design and implementation
Securing smart contract with runtime validation
Supporting Array Programming in X10
TS4J: a fluent interface for defining and computing typestate analyses
Efficient Formulation for Optimal Modulo Schedulers
Automatic inference of optimizer flow functions from semantic meanings
DI: an interactive debugging interpreter for applicative languages
RbSyn: type- and effect-guided program synthesis
Towards a taint mode for cloud computing web applications
Compass: strong and compositional library specifications in relaxed memory separation logic
VCODE: a Retargetable, Extensible, Very Fast Dynamic Code Generation System
Automatic loop interchange (with retrospective)
Parallel processing: a smart compiler and a dumb machine (with retrospective)
Bitwidth analysis with application to silicon compilation
Safe programmable speculative parallelism
Design and Implementation of the UW Illustrated Compiler
Region inference for an object-oriented language
The Illinois functional programming interpreter
Quantitative analysis of leakage for multi-threaded programs
A randomized dynamic program analysis technique for detecting real deadlocks
A lightweight symbolic virtual machine for solver-aided host languages
On PDG-based noninterference and its modular proof
Componential Set-Based Analysis
Simple, fast, and safe manual memory management
The Push/Pull model of transactions
Validating SMT solvers via semantic fusion
Portable vectorization and parallelization of C++ multi-dimensional array computations
Verifying optimizations of concurrent programs in the promising semantics
Fair stateless model checking
Efficiently and precisely locating memory leaks and bloat
Pin: building customized program analysis tools with dynamic instrumentation
The potential of sampling for dynamic analysis
LifeJacket: verifying precise floating-point optimizations in LLVM
Target-Sensitive Construction of Diagnostic Programs for Procedure Calling Sequence Generators
Composing concurrency control
ESP: A Language for Programmable Devices
Abstraction for conflict-free replicated data types
Pinpoint: fast and precise sparse value flow analysis for million lines of code
VeriCon: towards verifying controller programs in software-defined networks
Proceedings of the ACM SIGPLAN International Workshop on State of the Art in Java Program analysis, SOAP 2012, Beijing, China, June 14, 2012
The ExoVM system for automatic VM and application reduction
Taming compiler fuzzers
SnapQueue: lock-free queue with constant time snapshots
APT: A Data Structure for Optimal Control Dependence Computation
Language Support for Regions
SAFECode: enforcing alias analysis for weakly typed languages
Combining events and threads for scalable network services implementation and evaluation of monadic, application-level concurrency primitives
Temporal NetKAT
GIVE-N-TAKE - A Balanced Code Placement Framework
Diaframe: automated verification of fine-grained concurrent programs in Iris
Array languages make neural networks fast
Responsive parallel computation: bridging competitive and cooperative threading
Interactive parser synthesis by example
SSA-based MATLAB-to-C compilation and optimization
Eventrons: a safe programming construct for high-frequency hard real-time applications
Faster APL with Lazy Extensions
Compiler-directed soft error resilience for lightweight GPU register file protection
Input-sensitive profiling
Searching for type-error messages
A Safe Approximate Algorithm for Interprocedural Pointer Aliasing
Engage: a deployment management system
Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2019, Phoenix, AZ, USA, June 22-26, 2019
Network configuration synthesis with abstract topologies
Experience with CST: Programming and Implementation
Embedded Control Systems Development with Giotto
Relay: a new IR for machine learning frameworks
Wootz: a compiler-based framework for fast CNN pruning via composability
Termination and non-termination specification inference
Bytecode Compression via Profiled Grammar Rewriting
ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI '14, Edinburgh, United Kingdom - June 09 - 11, 2014
Living on the edge: rapid-toggling probes with cross-modification on x86
Specification synthesis with constrained Horn clauses
Co-optimizing memory-level parallelism and cache-level parallelism
Supporting virtual memory in GPGPU without supporting precise exceptions
Efficient handling of string-number conversion
ATOM - A System for Building Customized Program Analysis Tools
Padding in the mathematics of arrays
Precise alias analysis for static detection of web application vulnerabilities
Fast synthesis of fast collections
Test-case reduction and deduplication almost for free with transformation-based compiler testing
Computing summaries of string loops in C for better testing and refactoring
A Fresh Look at Combinator Graph Reduction
Simple Translation of Goal-Directed Evaluation
Software Pipelining Showdown: Optimal vs. Heuristic Methods in a Production Compiler
Tag-Free Garbage Collection for Strongly Typed Programming Languages
Type Inference in the Presence of Type Abstraction
Pointer Analysis for Programs with Structures and Casting
Type-based data structure verification
Differential register allocation
Using q-learning to select the best among functionally equivalent implementations
Deferred gratification: engineering for high performance garbage collection from the get go
Compiling a high-level language for GPUs: (via language support for architectures and compilers)
Practical Dependence Testing
Transfinite Iris: resolving an existential dilemma of step-indexed separation logic
BARRACUDA: binary-level analysis of runtime RAces in CUDA programs
Register Allocation for Software Pipelined Loops
Lazy code motion (with retrospective)
Automatic Predicate Abstraction of C Programs
Interprocedural Conditional Branch Elimination
Similarity of binaries through re-optimization
Bootstrapping: a technique for scalable flow and context-sensitive pointer alias analysis
Argosy: verifying layered storage systems with recovery refinement
D4: fast concurrency debugging with parallel differential analysis
Scalable parallel numerical constraint solver using global load balancing
Using Lifetime Predictors to Improve Memory Allocation Performance
Machine-verified network controllers
Interval-Based Analysis of Software Processes
First-Class Data-Type Representations in SchemeXerox
Quickstrom: property-based acceptance testing with LTL specifications
PADS: a domain-specific language for processing ad hoc data
FaCT: a DSL for timing-sensitive computation
Automatic generation of peephole optimizations (with retrospective)
Bounded expectations: resource analysis for probabilistic programs
C Compiler Design for an Industrial Network Processor
Introspective analysis: context-sensitivity, across the board
Dynascope: A Tool for Program Directing
Finding counterexamples from parsing conflicts
Program Analysis Using Binary Relations
Blame and coercion: together again for the first time
Optimizing Component Interaction
Flow-sensitive semantics for dynamic information flow policies
Using Data Groups to Specify and Check Side Effects
Dealing with Hardware in Embedded Software: A General Framework Based on the Devil Language
Decidable verification under a causally consistent shared memory
Beyond the elementary representations of program invariants over algebraic data types
Threads cannot be implemented as a library
Compiling Dataflow Analysis of Logic Programs
CSSV: towards a realistic tool for statically detecting all buffer overflows in C
A marriage of pointer- and epoch-based reclamation
An evaluation of staged run-time optimizations in DyC (with retrospective)
Explaining bug provenance with trace witnesses
Data-driven inference of representation invariants
Proceedings of the ACM SIGPLAN 2007 Conference on Programming Language Design and Implementation, San Diego, California, USA, June 10-13, 2007
Mapping spiking neural networks onto a manycore neuromorphic architecture
Cache Performance of Garbage-Collected Programs
Abstract Debugging of Higher-Order Imperative Languages
Proceedings of the 2001 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), Snowbird, Utah, USA, June 20-22, 2001
Promising-ARM/RISC-V: a simpler and faster operational concurrency model
Debugging of Globally Optimized Programs Using Data Flow Analysis
High-level accelerated array programming in the web browser
Spatial: a language and compiler for application accelerators
Dynamic race prediction in linear time
Checking robustness to weak persistency models
Verifiable composition of deterministic grammars
Falsifiability of network security research: the good, the bad, and the ugly
Enforcing isolation and ordering in STM
Optimizing Direct-threaded Code by Selective Inlining
Quad Ropes: immutable, declarative arrays with parallelizable operations
Effective static race detection for Java
Generating piecewise-regular code from irregular structures
DemoMatch: API discovery from demonstrations
Post-Pass Binary Adaptation for Software-Based Speculative Precomputation
A Customizable Substrate for Concurrent Languages
TAJ: effective taint analysis of web applications
Modular control-flow integrity
Guarded impredicative polymorphism
Type-directed automatic incrementalization
Taming the wildcards: combining definition- and use-site variance
Context-Insensitive Alias Analysis Reconsidered
A study of connected object locality in NUMA heaps
Elimination of Redundant Array Subscript Range Checks
Predicate abstraction and CEGAR for higher-order model checking
Towards an API for the real numbers
Automatic induction proofs of data-structures in imperative programs
Rank polymorphism viewed as a constraint problem
PyLSE: a pulse-transfer level language for superconductor electronics
Polymorphic Types with Polynomial Sizes
A generic approach for security policies composition: position paper
Automatic generation of library bindings using static analysis
A certifying compiler for Java
How to Analyze Large Programs Efficiently and Informatively
APE: accelerator processor extensions to optimize data-compute co-location
First-order quantified separators
On the principles of differentiable quantum programming languages
BEG - A Generator for Efficient Back Ends
Compiler-assisted object inlining with value fields
Synthesizing database programs for schema refactoring
"Synthesizing input grammars": a replication study
Hybrid context-sensitivity for points-to analysis
Timestamped Whole Program Path Representation and its Applications
Miniphases: compilation using modular and efficient tree transformations
Static analysis for dummies: experiencing LiSA
Offline compression for on-chip ram
The ant and the grasshopper: fast and accurate pointer analysis for millions of lines of code
Storage Assignment Optimizations to Generate Compact and Efficient Code on Embedded DSPs
SPL LIFT : statically analyzing software product lines in minutes instead of years
WARio: efficient code generation for intermittent computing
Dependence-Based Program Analysis
Proceedings of the ACM SIGPLAN '98 Conference on Programming Language Design and Implementation (PLDI), Montreal, Canada, June 17-19, 1998
A compiler framework for extracting superword level parallelism
Catch me if you can: permissive yet secure error handling
EVA: an encrypted vector arithmetic language and compiler for efficient homomorphic computation
Sharlit - A Tool for Building Optimizers
All-window data liveness
Proceedings of the 9th ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, ARRAY 2023, Orlando, FL, USA, 18 June 2023
Design and Implementation of Generics for the .NET Common Language Runtime
Demystifying on-the-fly spill code
Cache-conscious coallocation of hot data streams
Predictable accelerator design with time-sensitive affine types
Minimizing Register Usage Penalty at Procedure Calls
KISS: keep it simple and sequential
Unifying Data and Control Transformations for Distributed Shared Memory Machines
Explaining failures of program analyses
Modular data-race-freedom guarantees in the promising semantics
Cache-Conscious Structure Layout
Compiler analysis of irregular memory accesses
Data-race exceptions have benefits beyond the memory model
Extensible and Scalable Architecture for Hybrid Analysis
A General Framework for Iteration-Reordering Loop Transformations
Proceedings of the 2006 Workshop on Programming Languages and Analysis for Security, PLAS 2006, Ottawa, Ontario, Canada, June 10, 2006
On Slicing Programs with Jump Statements
OOElala: order-of-evaluation based alias analysis for compiler optimization
Neural query expansion for code search
Synchronising C/C++ and POWER
Relational compilation for performance-critical applications: extensible proof-producing translation of functional models into low-level code
Bayonet: probabilistic inference for networks
Enhancement through extension: the extension interpreter
Interprocedural dependence analysis and parallelization (with retrospective)
Modeling code manipulation in JIT compilers
Chimera: hybrid program analysis for determinism
Modular verification of assembly code with stack-based control abstractions
How to build the perfect Swiss army knife, and keep it sharp?: Challenges for the soot program-analysis framework in the light of past, current and future demands
Parameterized verification of transactional memories
Composable asynchronous events
Using Node Merging to Enhance Graph Coloring
Proving acceptability properties of relaxed nondeterministic approximate programs
Improving Semi-static Branch Prediction by Code Replication
CHET: an optimizing compiler for fully-homomorphic neural-network inferencing
A Local-View Array Library for Partitioned Global Address Space C++ Programs
A Framework for Construction and Evaluation of High-Level Specifications for Program Analysis Techniques
Petalisp: run time code generation for operations on strided arrays
Towards a verified range analysis for JavaScript JITs
Program analysis as constraint solving
A Compiler Approach to Fast Hardware Design Space Exploration in FPGA-based Systems
An experimental analysis of self-adjusting computation
PMThreads: persistent memory threads harnessing versioned shadow copies
Automatic storage optimization (with retrospective)
Profile-guided proactive garbage collection for locality optimization
Lasagne: a static binary translator for weak memory model architectures
Register Allocation Using Lazy Saves, Eager Restores, and Greedy Shuffling
Programmable Syntax Macros
Parallelism-centric what-if and differential analyses
The set constraint/CFL reachability connection in practice
A general framework for certifying garbage collectors and their mutators
Integration verification across software and hardware for a simple embedded system
Transactional data structure libraries
A Parallel, Real-Time Garbage Collector
Dynamic synthesis for relaxed memory models
Cache locality optimization for recursive programs
Is Continuation-Passing Useful for Data Flow Analysis?
MILAN: A Model Based Integrated Simulation Framework for Design of Embedded Systems
Correctness-preserving derivation of concurrent garbage collection algorithms
Efficient Building and Placing of Gating Functions
Detection and Recovery of Endangered Variables Caused by Instruction Scheduling
Backtracking without Trailing in CLP(R Lin )
A Timed Petri-Net Model for Fine-Grain Loop Scheduling
A decision procedure for subset constraints over regular languages
Finding optimum abstractions in parametric dataflow analysis
Beyond Induction Variables
Debugging Optimized Code with Dynamic Deoptimization
Concurrent data representation synthesis
Configuration synthesis for programmable analog devices with Arco
Symbolic pointer analysis revisited
Automatic Recognition of Induction Variables and Recurrence Relations by Abstract Interpretation
SafeTSA: A Type Safe and Referentially Secure Mobile-Code Representation Based on Static Single Assignment Form
Specialization slicing
A language for information flow: dynamic tracking in multiple interdependent dimensions
Module-Sensitive Program Specialisation
Improving data-flow analysis with path profiles (with retrospective)
Grammar-based whitebox fuzzing
Proving differential privacy with shadow execution
ADA: a tool for visualizing the architectural overview of open-source repositories
Shared memory programming for large scale machines
Inducing heuristics to decide whether to schedule
Gradual synthesis for static parallelization of single-pass array-processing programs
Android taint flow analysis for app sets
SWE-X10: an actor-based and locally coordinated solver for the shallow water equations
Loo.py: from fortran to performance via transformation and substitution rules
Verified enforcement of stateful information release policies
On Bounding Time and Space for Multiprocessor Garbage Collection
Escape Analysis on Lists
KJS: a complete formal semantics of JavaScript
Synthesizing racy tests
Weldr: fusing binaries for simplified analysis
Snugglebug: a powerful approach to weakest preconditions
Silq: a high-level quantum language with safe uncomputation and intuitive semantics
Sketching stencils
Don't sweat the small stuff: formal verification of C code without the pain
Synthesis of divide and conquer parallelism for loops
Knowledge-oriented secure multiparty computation
Loop and data transformations for sparse matrix code
Parallelizing Complex Scans and Reductions
Component-based synthesis of table consolidation and transformation tasks from examples
Optimizing database-backed applications with query synthesis
Robustness against release/acquire semantics
Parallelizing top-down interprocedural analyses
Garbage collection without paging
Aggressive Inlining
Global Communication Analysis and Optimization
Global Instruction Scheduling for Superscalar Machines
Data-driven precondition inference with learned features
Bind the gap: compiling real software to hardware FFT accelerators
FlumeJava: easy, efficient data-parallel pipelines
Efficient Discovery of Regular Stride Patterns in Irregular Programs
The JADE interpreter: a RISC interpreter for syntax directed editing
DFix: automatically fixing timing bugs in distributed systems
Using web application construction frameworks to protect against code injection attacks
Proceedings of the third ACM SIGPLAN X10 Workshop, X10 2013, Seattle, Washington, USA, June 20, 2013
Adaptive low-overhead scheduling for periodic and reactive intermittent execution
Verification of a cryptographic primitive: SHA-256 (abstract)
EnerJ: approximate data types for safe and general low-power computation
Proceedings of the 2nd ACM SIGPLAN International Workshop on Libraries, Languages, and Compilers for Array Programming, ARRAY@PLDI, Portland, OR, USA, June 15 - 17, 2015
Proceedings of the 2009 ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2009, Dublin, Ireland, June 15-21, 2009
Semi-static type, shape, and symbolic shape inference for dynamic computation graphs
Teapot: Language Support for Writing Memory Coherence Protocols
Data Flow Frequency Analysis
An analysis of the dynamic behavior of JavaScript programs
Relaxing safely: verified on-the-fly garbage collection for x86-TSO
Stretching transactional memory
Scalable variable and data type detection in a binary rewriter
Fast and precise certification of transformers
Coloring heuristics for register allocation (with retrospective)
SCAF: a speculation-aware collaborative dependence analysis framework
Just-in-time shape inference for array-based languages
Understanding POWER multiprocessors
A Practical Data Flow Framework for Array Reference Analysis and its Use in Optimizations
Fold-based fusion as a library: a generative programming pearl
Trusted declassification: : high-level policy for a security-typed language
Meta optimization: improving compiler heuristics with machine learning
List-based Monadic Computations for Dynamically Typed Languages
Cruiser: concurrent heap buffer overflow monitoring using lock-free data structures
SCCharts: sequentially constructive statecharts for safety-critical applications: HW/SW-synthesis for a conservative extension of synchronous statecharts
Optimal Loop Parallelization
Lightweight annotations for controlling sharing in concurrent data structures
LoCal: a language for programs operating on serialized data
Proceedings of the 2008 Workshop on Programming Languages and Analysis for Security, PLAS 2008, Tucson, AZ, USA, June 8, 2008
Multi-language static code analysis on the LARA framework
Translation validation for an optimizing compiler
Probalistic Register Allocation
Functional reactive programming from first principles