yusuke1997/dblp-id-title huggingface dataset:
Simple and Efficient BURS Table Generation
Cartesian hoare logic for verifying k-safety properties
Parallel programming with arrays in Kappa
A framework for unrestricted whole-program optimization
A generational on-the-fly garbage collector for Java
A Dynamic Programming Approach to Optimal Integrated Code Generation
Logical inference techniques for loop parallelization
Smooth interpretation
Compiler-assisted detection of transient memory errors
Code completion with statistical language models
Proceedings of the 2001 ACM SIGPLAN Workshop on Optimization of Middleware and Distributed Systems, OM '01, Snow Bird, Utah, USA
MapReduce program synthesis
A more precise security type system for dynamic security tests
Improving usability of information flow security in java
Constructive real interpretation of numerical programs
ARRAY'14: Proceedings of the 2014 ACM SIGPLAN International Workshop on Libraries, Languages, and Compilers for Array Programming, Edinburgh, United Kingdom, June 12-13, 2014
Two-level hybrid interpreter/native code execution for combined space-time program efficiency
Task Granularity Analysis in Logic Programs
Optimizing indirect branch prediction accuracy in virtual machine interpreters
Model checking transactional memories
Remix: online detection and repair of cache contention for the JVM
Printing floating-point numbers quickly and accurately with integers
Proceedings of the 6th ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, ARRAY@PLDI 2019, Phoenix, AZ, USA, June 22, 2019
Dynamic partial order reduction for relaxed memory models
SuperC: parsing all of C by taming the preprocessor
Distance-in-time versus distance-in-space
Proceedings of the ACM SIGPLAN 2006 Conference on Programming Language Design and Implementation, Ottawa, Ontario, Canada, June 11-14, 2006
Unfold/Fold Transformations and Loop Optimization of Logic Programs
Data Distribution Support on Distributed Shared Memory Multiprocessors
Optimal Spilling for CISC Machines with Few Registers
Know your analysis: how instrumentation aids understanding static analysis
A region-based compilation technique for a Java just-in-time compiler
Synthesizing transformations on hierarchically structured data
An array API for finite difference methods
Eliminating Array Bound Checking Through Dependent Types
Natural proofs for data structure manipulation in C using separation logic
Scalable taint specification inference with big code
Type-and-example-directed program synthesis
Quartz: superoptimization of Quantum circuits
CURD: a dynamic CUDA race detector
Model checking for weakly consistent libraries
User-Assisted Code Query Optimization
Balanced scheduling: instruction scheduling when memory latency is uncertain (with retrospective)
Reverse Interpretation + Mutation Analysis = Automatic Retargeting
Exposing errors related to weak memory in GPU applications
Higher-Order Abstract Syntax
Units: Cool Modules for HOT Languages
The Marion System for Retargetable Instruction Scheduling
Bliss: auto-tuning complex applications using a pool of diverse lightweight learning models
The Implementation of the Cilk-5 Multithreaded Language
Jinn: synthesizing dynamic bug detectors for foreign language interfaces
Permission-based ownership: encapsulating state in higher-order typed languages
Generalized Algorithmic Debugging and Testing
DISTAL: the distributed tensor algebra compiler
Compact Representations for Control Dependence
Synthesizing software verifiers from proof rules
Proceedings of the 2nd ACM SIGPLAN International Workshop on Machine Learning and Programming Languages, MAPL@PLDI 2018, Philadelphia, PA, USA, June 18-22, 2018
Speculative separation for privatization and reductions
Vectorization for SIMD architectures with alignment constraints
Grammatical Abstraction and Incremental Syntax Analysis in a Language-Based Editor
Zooid: a DSL for certified multiparty computation: from mechanised metatheory to certified multiparty processes
Efficient Context-Sensitive Pointer Analysis for C Programs
Orchestrating Interactions Among Parallel Computations
Proceedings of the 2007 Workshop on Programming Languages and Analysis for Security, PLAS 2007, San Diego, California, USA, June 14, 2007
Fast Breakpoints: Design and Implementation
Bringing extensibility to verified compilers
Abstract interpretation under speculative execution
Finding root causes of floating point error
Proceedings of the ACM SIGPLAN 2008 Conference on Programming Language Design and Implementation, Tucson, AZ, USA, June 7-13, 2008
A typed, algebraic approach to parsing
IOOpt: automatic derivation of I/O complexity bounds for affine programs
A Unified Framework for Schedule and Storage Optimization
Type-based dependency analysis for javascript
Incremental incrementally compacting garbage collection
Synthesis and machine learning for heterogeneous extraction
Termination analysis without the tears
Modernizing parsing tools: parsing and analysis with object-oriented programming
Object capabilities for security
An efficient tunable selective points-to analysis for large codebases
Synthesizing program input grammars
Proceedings of the ACM SIGPLAN '97 Conference on Programming Language Design and Implementation (PLDI), Las Vegas, Nevada, USA, June 15-18, 1997
Differential cost analysis with simultaneous potentials and anti-potentials
An implementation and semantics for transactional memory introspection in Haskell
Region-Based Memory Management in Cyclone
Type-based race detection for Java
Machine learning in Python with no strings attached
Multi-Target C Code Generation from MATLAB
A generator for language-specific debugging systems
The essence of Bluespec: a core language for rule-based hardware design
Aspect-oriented in-lined reference monitors
On the challenges in programming mixed-precision deep neural networks
Formal reasoning and the hacker way (keynote)
Terra: a multi-stage language for high-performance computing
Implementation of a high-speed Prolog interpreter
Trace-based just-in-time type specialization for dynamic languages
Peer-to-peer affine commitment using bitcoin
Race detection for Android applications
Just-in-time static type checking for dynamic languages
Predicting Program Behavior Using Real or Estimated Profiles
Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2017, Barcelona, Spain, June 18-23, 2017
Register allocation by priority-based coloring (with retrospective)
Cutting out the middleman: OS-level support for x10 activities
Incremental precision-preserving symbolic inference for probabilistic programs
Composing parallel software efficiently with lithe
Unification-based pointer analysis with directional assignments
Polynomial reachability witnesses via Stellensätze
Interprocedural data flow analysis in Soot using value contexts
Proving thread termination
Expressive and safe static reflection with MorphJ
Program synthesis from polymorphic refinement types
FreeTensor: a free-form DSL with holistic optimizations for irregular tensor programs
Usuba: high-throughput and constant-time ciphers, by construction
EXOCHI: architecture and programming environment for a heterogeneous multi-core multithreaded system
Garbage collection for multicore NUMA machines
A data locality optimizing algorithm (with retrospective)
Abstract interpretation of Michelson smart-contracts
Free-Me: a static analysis for automatic individual object reclamation
The Atomos transactional programming language
Abstract expressionism for parallel performance
Development of secured systems by mixing programs, specifications and proofs in an object-oriented programming environment: a case study within the FoCaLiZe environment
An Abstract Machine for CLP(R)
Detecting inefficiently-used containers to avoid bloat
Pointer Analysis for Multithreaded Programs
Counter-example complete verification for higher-order functions
A Dynamic Scheduling Technique for Irregular Parallel Programs
Verifying read-copy-update in a logic for weak memory
Cache topology aware computation mapping for multicores
Automatically classifying benign and harmful data racesallusing replay analysis
Finding typing compiler bugs
Practical partial evaluation for high-performance dynamic language runtimes
High-coverage, unbounded sound predictive race detection
TOOLS: a unifying approach to object-oriented language interpretation
A compiler framework for speculative analysis and optimizations
A Type-Based Compiler for Standard ML
Detecting network load violations for distributed control planes
ANOSY: approximated knowledge synthesis with refinement types for declassification
Race directed random testing of concurrent programs
Continuations and transducer composition
StreamQRE: modular specification and efficient evaluation of quantitative queries over streaming data
Applying flow-sensitive CQUAL to verify MINIX authorization check placement
Automated derivation of parametric data movement lower bounds for affine programs
Mixing type checking and symbolic execution
Lifetime-Sensitive Modulo Scheduling
PDL: a high-level hardware design language for pipelined processors
Learning a classifier for false positive error reports emitted by static code analysis tools
Debugging probabilistic programs
Thresher: precise refutations for heap reachability
Optimising aspectJ
Register Promotion in C Programs
Synthesizing structured CAD models with equality saturation and inverse transformations
Transactional concurrency control for intermittent, energy-harvesting computing systems
Balanced Scheduling: Instruction Scheduling When Memory Latency is Uncertain
A study towards optimal data layout for GPU computing
Min-cut program decomposition for thread-level speculation
Test-driven repair of data races in structured parallel programs
Error propagation analysis for file systems
The Pointer Assertion Logic Engine
The transactional manifesto: software engineering and non-blocking synchronization
Garbage Collection Using a Dynamic Threatening Boundary
Expressing and verifying probabilistic assertions
2010 Athena lecture
TraceBack: first fault diagnosis by reconstruction of distributed control flow
SWOOP: software-hardware co-design for non-speculative, execute-ahead, in-order cores
Stack Caching for Interpreters
Inferring locks for atomic sections
A type and effect system for atomicity
Avoiding Unconditional Jumps by Code Replication
ILP-based Instruction Scheduling for IA-64
Debugging Concurrent Processes: A Case Study
Parametric regular path queries
Shape analysis with inductive recursion synthesis
Toward an automated benchmark management system
Real-Time Replication Garbage Collection
Defining the undefinedness of C
Size and Access Inference for Data-Parallel Programs
Security correctness for secure nested transactions: position paper
Proceedings of the ACM SIGPLAN'88 Conference on Programming Language Design and Implementation (PLDI), Atlanta, Georgia, USA, June 22-24, 1988
A Parallel, Incremental and Concurrent GC for Servers
Compositional recurrence analysis revisited
A framework for enhancing data reuse via associative reordering
Developer and user-transparent compiler optimization for interactive applications
RunTime-assisted convergence in replicated data types
SmartTrack: efficient predictive race detection
XMem: type-safe, transparent, shared memory for cross-runtime communication and coordination
Chlorophyll: synthesis-aided compiler for low-power spatial architectures
Fast graph simplification for interleaved Dyck-reachability
Context-Sensitive Interprocedural Points-to Analysis in the Presence of Function Pointers
Fortran at Ten Gigaflops: The Connection Machine Convolution Compiler
A block-and-actions generator as an alternative to a simulator for collecting architecture measurements
TIL: a type-directed, optimizing compiler for ML (with retrospective)
Exploring and enforcing security guarantees via program dependence graphs
Checking race freedom via linear programming
Automatic inversion generates divide-and-conquer parallel programs
Persistent pointer information
Incremental Analysis of real Programming Languages
Reticle: a virtual machine for programming modern FPGAs
Path-based inductive synthesis for program inversion
The Program Summary Graph and Flow-Sensitive InterproceduralData Flow Analysis
Debug information validation for optimized code
Software-controlled transparent management of heterogeneous memory resources in virtualized systems
Measuring channel capacity to distinguish undue influence
Adaptive input-aware compilation for graphics engines
Ivy: safety verification by interactive generalization
A higher order theory of locality
Ignis: scaling distribution-oblivious systems with light-touch distribution
Localized delimited release: combining the what and where dimensions of information release
Accurate Static Branch Prediction by Value Range Propagation
Realistic Compilation by Partial Evaluation
SyRust: automatic testing of Rust libraries with semantic-aware program synthesis
ALPyNA: acceleration of loops in Python for novel architectures
Optimizing ML with run-time code generation (with retrospective)
Diagnosing type errors with class
Concurrent deferred reference counting with constant-time overhead
Near-optimal Intraprocedural Branch Alignment
Collection disjointness analysis
A simulation-based proof technique for dynamic information flow
Automatic generation of parallel C code for stencil applications written in MATLAB
Semantics-aware trace analysis
User-guided program reasoning using Bayesian inference
Efficient algorithms for bidirectional debugging
Load-Reuse Analysis: Design and Evaluation
Instruction punning: lightweight instrumentation for x86-64
Continuously reasoning about programs using differential Bayesian inference
Compilation of Haskell Array Comprehensions for Scientific Computing
Proceedings of the 2013 ACM SIGPLAN Workshop on Programming Languages and Analysis for Security, PLAS 2013, Seattle, WA, USA, June 20, 2013
Register windows vs. register allocation (with retrospective)
Statically detecting data leakages in data science code
Look up!: your future is in the cloud
Towards Structured Algebraic Programming
MaJIC: Compiling MATLAB for Speed and Responsiveness
Reagents: expressing and composing fine-grained concurrency
An Optimizer for Ada - Design, Experiences and Results
Software-hardware codesign for efficient in-memory regular pattern matching
Certified concurrent abstraction layers
Rigorous analysis of software countermeasures against cache attacks
Storage Assignment to Decrease Code Size
Write-rationing garbage collection for hybrid memories
Space-Time Trade-Off Optimization for a Class of Electronic Structure Calculations
Wire sorts: a language abstraction for safe hardware composition
Effective function merging in the SSA form
Demonic Memories for Process Histories
Effective "Static-Graph" Reorganization to Improve Locality in Garbage-Collected Systems
iReplayer: in-situ and identical record-and-replay for multithreaded applications
Efficient and Language-Independent Mobile Programs
Isolation and Analysis of Optimization Errors
Prototyping Fortran-90 Compilers for Massively Parallel Machines
CLAP: recording local executions to reproduce concurrency failures
Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation, Portland, OR, USA, June 15-17, 2015
Inferable object-oriented typed assembly language
Verification of programs under the release-acquire semantics
Code generation in a machine-independent compiler (with retrospective)
Fast probabilistic simulation, nontermination, and secure information flow
Decoupled lifeguards: enabling path optimizations for dynamic correctness checking tools
Ryū: fast float-to-string conversion
EffectiveSan: type and memory error detection using dynamically typed C/C++
MemSAT: checking axiomatic specifications of memory models
Completeness Thresholds for Memory Safety of Array Traversing Programs
A systematic evaluation of large language models of code
Pure tensor program rewriting via access patterns (representation pearl)
Laminar: practical fine-grained decentralized information flow control
Enforcing High-Level Protocols in Low-Level Software
Efficient approximations for cache-conscious data placement
Proceedings of the 2012 ACM SIGPLAN workshop on Memory Systems Performance and Correctness: held in conjunction with PLDI '12, Beijing, China, June 16, 2012
Spill Code Minimization Techniques for Optimizing Compilers
NVTraverse: in NVRAM data structures, the destination is more important than the journey
Modular verification of linearizability with non-fixed linearization points
Fault-tolerant non-interference: invited talk abstract
General data structure expansion for multi-threading
Compositional certified resource bounds
Synchronous Operations as First-Class Values
Cautious virus detection in the extreme
Records with rank polymorphism
LOCKSMITH: context-sensitive correlation analysis for race detection
Go with the flow: profiling copies to find runtime bloat
Reconciling enumerative and deductive program synthesis
Proceedings of the ACM SIGPLAN 2003 Conference on Programming Language Design and Implementation 2003, San Diego, California, USA, June 9-11, 2003
Automatically enforcing fresh and consistent inputs in intermittent systems
A System and Language for Building System-Specific, Static Analyses
Program analysis for process migration
Using active learning to synthesize models of applications that access databases
Interprocedural constant propagation (with retrospective)
An LR Substring Parser for Noncorrecting Syntax Error Recovery
Lock elision for read-only critical sections in Java
Dynamic enforcement of determinism in a parallel scripting language
Jifclipse: development tools for security-typed languages
Reasoning about nondeterminism in programs
Affinity-based hash tables
A Reduced Multipipeline Machine Description that Preserves Scheduling Constraints
Task parallel assembly language for uncompromising parallelism
Language-independent sandboxing of just-in-time compilation and self-modifying code
Dynamic trace-based analysis of vectorization potential of applications
A Composable Array Function Interface for Heterogeneous Computing in Java
Prefetch inection based on hardware monitoring and object metadata
How to fit program footprint curves
Exploiting Hardware Performance Counters with Flow and Context Sensitive Profiling
Tile Size Selection Using Cache Organization and Data Layout
Sound and precise analysis of web applications for injection vulnerabilities
A study of concurrent real-time garbage collectors
Obfuscation resilient search through executable classification
Static detection of asymptotic performance bugs in collection traversals
A comparison of empirical and model-driven optimization
Learning nonlinear loop invariants with gated continuous logic networks
Cost analysis of nondeterministic probabilistic programs
Optimizing data permutations for SIMD devices
SOAP@PLDI 2021: Proceedings of the 10th ACM SIGPLAN International Workshop on the State Of the Art in Program Analysis, Virtual Event, Canada, 22 June, 2021
Binary analysis for measurement and attribution of program performance
Profile-based vectorization for MATLAB
Performance search engine driven by prior knowledge of optimization
HERO-ML: A Very High-Level Array Language for Executable Modelling of Data Parallel Algorithms
Software data spreading: leveraging distributed caches to improve single thread performance
A case for distributed work-stealing in regular applications
Scooter & Sidecar: a domain-specific approach to writing secure database migrations
Delinearization: An Efficient Way to Break Multiloop Dependence Equations
Taming wildcards in Java's type system
Improving register allocation for subscripted variables (with retrospective)
Input responsiveness: using canary inputs to dynamically steer approximation
Persistency for synchronization-free regions
The essence of compiling with continuations (with retrospective)
Python Interpreter Performance Deconstructed
Optimizing Parallel Programs with Explicit Synchronization
Hermes: assessment and creation of effective test corpora
Typilus: neural type hints
Snapshot-free, transparent, and robust memory reclamation for lock-free data structures
IRDL: an IR definition language for SSA compilers
Occurrence typing modulo theories
Academia 2.0: removing the publisher middle-man while retaining impact
Serialization-aware call graph construction
Schism: fragmentation-tolerant real-time garbage collection
A Rosetta Stone for array languages
Parametric analysis for adaptive computation offloading
Improving Balanced Scheduling with Compiler Optimizations that Increase Instruction-Level Parallelism
Concurrency debugging with differential schedule projections
Effective parallelization of loops in the presence of I/O operations
Refinement types for TypeScript
Verification modulo versions: towards usable verification
WebRobot: web robotic process automation using interactive programming-by-demonstration
DAG inlining: a decision procedure for reachability-modulo-theories in hierarchical programs
GC assertions: using the garbage collector to check heap properties
A Semantics for Imprecise Exceptions
Foundations of the C++ concurrency memory model
An eductive interpreter for Lucid
Interprocedural May-Alias Analysis for Pointers: Beyond k -limiting
Nonvolatile memory is a broken time machine
Droidel: a general approach to Android framework modeling
Synthesizing geometry constructions
Learning to find naming issues with big code and small supervision
What is a Recursive Module?
Analyzing recursive programs using a fixed-point calculus
Repairing and mechanising the JavaScript relaxed memory model
Online optimizations driven by hardware performance monitoring
Implementation of the Data-Flow Synchronous Language SIGNAL
Mirror: making lock-free data structures persistent
Soft Typing
Abstracting Vector Architectures in Library Generators: Case Study Convolution Filters
GL-a denotational testbed with continuations and partial continuations as first-class objects
Fully automatic and precise detection of thread safety violations
Fast algorithms for Dyck-CFL-reachability with applications to alias analysis
SOAP '22: 11th ACM SIGPLAN International Workshop on the State Of the Art in Program Analysis, San Diego, CA, USA, 14 June 2022
Program verification using templates over predicate abstraction
Giallar: push-button verification for the qiskit Quantum compiler
A Framework for Reducing the Cost of Instrumented Code
Formally verified lifting of C-compiled x86-64 binaries
When polyhedral transformations meet SIMD code generation
Efficient execution of recursive programs on commodity vector hardware
Optimal Tracing and Incremental Reexecution for Debugging Long-Running Programs
Safety Considerations for Storage Allocation Optimizations
Optimizing homomorphic evaluation circuits by program synthesis and term rewriting
Incremental Evaluation for a General Class of Circular Attribute Grammars
Design and GPGPU performance of Futhark's redomap construct
Kill-safe synchronization abstractions
Composing security policies with polymer
Linear-time Subtransitive Control Flow Analysis
Proceedings of the workshop on Memory Systems Performance and Correctness, MSPC '14, Edinburgh, United Kingdom, June 13, 2014
The design and implementation of a certifying compiler (with retrospective)
Complete functional synthesis
Speeding up Static Analysis with the Split Operator
Extended sequential reasoning for data-race-free programs
Sound regular expression semantics for dynamic symbolic execution of JavaScript
Copy coalescing by graph recoloring
Towards cross-platform cross-language analysis with soot
Global Code Motion / Global Value Mumbering
Slicing probabilistic programs
Type-directed completion of partial expressions
tcc: A System for Fast, Flexible, and High-level Dynamic Code Generation
Epistemic temporal logic for information flow security
Crosys: Cross Architectural Dynamic Analysis
Software Pipelining Irregular Loops On the TMS320C6000 VLIW DSP Architecture
Quantum abstract interpretation
Spreadsheet table transformations from examples
Path invariants
A domain-specific programming language for secure multiparty computation
Commutativity race detection