yusuke1997/dblp-id-title huggingface dataset:
Frequent background polling on a shared thread, using light-weight compiler interrupts
O-structures: semantics for versioned memory
Scheduling and Mapping: Software Pipelining in the Presence of Structural Hazards
A Retargetable Debugger
Simple and Effective Link-Time Optimization of Modula-3 Programs
Coloring Heuristics for Register Allocation
Encoding information flow in Aura
PACER: proportional detection of data races
kb -anonymity: a model for anonymized behaviour-preserving test and debugging data
ALTER: exploiting breakable dependences for parallelization
Typing illegal information flows as program effects
Understanding caller-sensitive method vulnerabilities: a class of access control vulnerabilities in the Java platform
Communication Optimization and Code Generation for Distributed Memory Machines
Helium: lifting high-performance stencil kernels from stripped x86 binaries to halide DSL code
Iterative Type Analysis and Extended Message Splitting: Optimizing Dynamically-Typed Object-Oriented Programs
And then there were none: a stall-free real-time garbage collector for reconfigurable hardware
TRANSIT: specifying protocols with concolic snippets
CARAT: a case for virtual memory through compiler- and runtime-based address translation
DeepCuts: a deep learning optimization framework for versatile GPU workloads
λPSI: exact inference for higher-order probabilistic programs
Proof repair across type equivalences
Understanding memory and thread safety practices and issues in real-world Rust programs
Automatic CPU-GPU communication management and optimization
Specifying distributed trust management in LolliMon
Partial Dead Code Elimination
Static flow-sensitive & context-sensitive information-flow analysis for software product lines: position paper
Effective floating-point analysis via weak-distance minimization
Dynamic Program Slicing
Improved error reporting for software that uses black-box components
Array processing on steroids for the SKA radio-telescope (keynote)
A Datalog model of must-alias analysis
Automatic program inversion using symbolic transducers
Soot class loading in the rootbeer GPU compiler
Syntax-guided program reduction for understanding neural code intelligence models
Dependence Analysis for Pointer Variables
Satisfiability modulo ordering consistency theory for multi-threaded program verification
Stride prefetching by dynamically inspecting objects
A graph neural network-based performance model for deep learning applications
Proceedings of the 2009 Workshop on Programming Languages and Analysis for Security, PLAS 2009, Dublin, Ireland, 15-21 June, 2009
Iterative context bounding for systematic testing of multithreaded programs
CCured in the real world
How to Read Floating-Point Numbers Accurately
Safety checking of machine code
When Long Jumps Fall Short: Control-Flow Tracking and Misuse Detection for Non-local Jumps in C
Towards certified separate compilation for concurrent programs
Beltway: Getting Around Garbage Collection Gridlock
Improving Data-flow Analysis with Path Profiles
Parameterized Partial Evaluation
All you need is superword-level parallelism: systematic control-flow vectorization with SLP
Spill Code Minimization via Interference Region Spilling
Proceedings of the 3rd ACM SIGPLAN International Workshop on Libraries, Languages, and Compilers for Array Programming, ARRAY@PLDI 2016, Santa Barbara, CA, USA, June 14, 2016
Verifying message-passing programs with dependent behavioural types
Efficient Representations and Abstractions for Quantifying and Exploiting Data Reference Locality
Representing Control in the Presence of One-Shot Continuations
A tutorial on X10 and its implementation
Explicit and symbolic techniques for fast and scalable points-to analysis
Printing Floating-Point Numbers Quickly and Accurately
Synthesising graphics card programs from DSLs
The Program Dependence Web: A Representation Supporting Control, Data, and Demand-Driven Interpretation of Imperative Languages
Fusing effectful comprehensions
Incremental re-execution of programs
Joogie: from Java through Jimple to Boogie
SPPL: probabilistic programming with fast exact symbolic inference
Mako: a low-pause, high-throughput evacuating collector for memory-disaggregated datacenters
Automatic Inline Allocation of Objects
Compiling Programs for a Linear Systolic Array
Porcupine: a synthesizing compiler for vectorized homomorphic encryption
Verifying GPU kernels by test amplification
Rehearsal: a configuration verification tool for puppet
On the complexity and performance of parsing with derivatives
Advanced automata-based algorithms for program termination checking
Directed incremental symbolic execution
Analysis of pure methods using garbage collection
A fast Fourier transform compiler (with retrospective)
Transforming loops to recursion for multi-level memory hierarchies
Type-directed program synthesis for RESTful APIs
Language-based security on Android
Towards locating execution omission errors
Rank idle time prediction driven last-level cache writeback
Global Optimizations for Parallelism and Locality on Scalable Parallel Machines
Termination proofs for systems code
Monitoring Semantics: A Formal Framework for Specifying, Implementing, and Reasoning about Execution Monitors
Certified mergeable replicated data types
Cache-Conscious Structure Definition
Type-Based Alias Analysis
Identifying optimal multicore cache hierarchies for loop-based parallel programs via reuse distance analysis
Adapton: composable, demand-driven incremental computation
ControlFlag: a self-supervised idiosyncratic pattern detection system for software control structures
Thin locks: featherweight Synchronization for Java (with retrospective)
Cint: a RISC interpreter for the C programming language
Sharing classes between families
A fast analytical model of fully associative caches
Towards region-based memory management for Go
Statistical similarity of binaries
Modular information flow through ownership
Multicore acceleration of priority-based schedulers for concurrency bug detection
Referential integrity with Scala types
Efficient and Exact Data Dependence Analysis
Analyzing locality of memory references in GPU architectures
Semantic soundness for language interoperability
20 Years of the ACM SIGPLAN Conference on Programming Language Design and Implementation 1979-1999, A Selection
Software-level scheduling to exploit non-uniformly shared data cache on GPGPU
Kleene algebra modulo theories: a framework for concrete KATs
Blended, precise semantic program embeddings
Secure information flow analysis for hardware design: using the right abstraction for the job
FlowDroid: precise context, flow, field, object-sensitive and lifecycle-aware taint analysis for Android apps
Sketching concurrent data structures
Warping cache simulation of polyhedral programs
Race detection for event-driven mobile applications
From perception to programs: regularize, overparameterize, and amortize
NDSeq: runtime checking for nondeterministic sequential specifications of parallel correctness
Software pipelining: an effective scheduling technique for VLIW machines (with retrospective)
Reliable and efficient programming abstractions for wireless sensor networks
Abstract interpretation repair
Contaminated garbage collection
Context-sensitive domain-independent algorithm composition and selection
Automatic Generation of DAG Parallelism
Soft typing (with retrospective)
Design your analysis: a case study on implementation reusability of data-flow functions
Representing Control in the Presence of First-Class Continuations
The impact of diverse memory architectures on multicore consumer software: an industrial perspective from the video games domain
Polymorphic type inference for machine code
Static deadlock detection for asynchronous C# programs
Process Decomposition Through Locality of Reference
Register Allocation for Banked Register File
ActorX10: an actor library for X10
ILC: a calculus for composable, computational cryptography
Commutative set: a language extension for implicit parallel programming
Event-driven network programming
EEL: Machine-Independent Executable Editing
Artemis: practical runtime monitoring of applications for execution anomalies
On probabilistic termination of functional programs with continuous distributions
MAPS@PLDI 2021: Proceedings of the 5th ACM SIGPLAN International Symposium on Machine Programming, Virtual Event, Canada, 21 June, 2021
Static path conditions for Java
The Power of Assignment Motion
Proper Tail Recursion and Space Efficiency
Determining Average Program Execution Times and their Variance
Synthesizing analytical SQL queries from computation demonstration
Path-sensitive sparse analysis without path conditions
Convolutional neural networks in APL
A formal C memory model supporting integer-pointer casts
Type-preserving compilation for large-scale optimizing object-oriented compilers
A Technique for Summarizing Data Access and Its Use in Parallelism Enhancing Transformations
Progress guarantee for parallel programs via bounded lock-freedom
CML: A Higher-Order Concurrent Language
A Fortran 77 interpreter for mutation analysis
Guardians in a Generation-Based Garbage Collector
A recursive interpreter for the Icon programming language
Parallel memory defragmentation on a GPU
Resource bound analysis for database queries
Language-based control and mitigation of timing channels
Thin slicing
Mimic: a fast system/370 simulator
Automatically partitioning packet processing applications for pipelined architectures
Hybrid parallel task placement in X10
Managing stack frames in Smalltalk
Interpreting ABF - a language for document construction
INC: A Language for Incremental Computations
DoubleChecker: efficient sound and precise atomicity checking
Renaissance: benchmarking suite for parallel applications on the JVM
Combining Region Inference and Garbage Collection
Revisiting loop transformations with x10 clocks
Minor memory references matter in collaborative caching
Can seqlocks get along with programming language memory models?
Optimizing off-chip accesses in multicores
Exploiting superword level parallelism with multimedia instruction sets
ATOM: a system for building customized program analysis tools (with retrospective)
Flow-Sensitive Interprocedural Constant Propagation
VYRD: verifYing concurrent programs by runtime refinement-violation detection
Algorithm specialization in generic programming: challenges of constrained generics in C++
Green: a framework for supporting energy-conscious programming using controlled approximation
Division by Invariant Integers using Multiplication
Zero-overhead metaprogramming: reflection and metaobject protocols fast and without compromises
Visualization question answering using introspective program synthesis
Cardinalities and universal quantifiers for verifying parameterized systems
A Mechanism for Efficient Debugging of Parallel Programs
JPortal: precise and efficient control-flow tracing for JVM programs with Intel processor trace
Pruning dynamic slices with confidence
Performance implications of fence-based memory models
Compiling C for Vectorization, Parallelization, and Inline Expansion
A framework for interprocedural optimization in the presence of dynamic class loading
Scalable lock-free dynamic memory allocation
Reverse engineering for reduction parallelization via semiring polynomials
A certified type-preserving compiler from lambda calculus to assembly language
Compiling Markov chain Monte Carlo algorithms for probabilistic modeling
Fast condensation of the program dependence graph
Combining Global Code and Data Compaction
ABCD: eliminating array bounds checks on demand
Cause clue clauses: error localization using maximum satisfiability
A Portable Global Optimizer and Linker
A MultiGPU Performance-Portable Solution for Array Programming Based on Kokkos
Proceedings of the 5th ACM SIGPLAN International Workshop on Libraries, Languages, and Compilers for Array Programming, ARRAY@PLDI 2018, Philadelphia, PA, USA, June 19, 2018
Inductive sequentialization of asynchronous programs
The design, implementation, and evaluation of a compiler algorithm for CPU energy reduction
Safe to the last instruction: automated verification of a type-safe operating system
Test-case reduction for C compiler bugs
Proceedings of the ACM SIGPLAN'94 Conference on Programming Language Design and Implementation (PLDI), Orlando, Florida, USA, June 20-24, 1994
Deoptless: speculation with dispatched on-stack replacement and specialized continuations
Iceberg: a tool for static analysis of Java critical sections
Experiences Creating a Portable Cedar
Finding and understanding bugs in C compilers
Proceedings of the 9th ACM SIGPLAN International Workshop on the State Of the Art in Program Analysis, SOAP@PLDI 2020, London, UK, June 15, 2020
DRFX: a simple and efficient memory model for concurrent programming languages
Trace-driven simulation of memory system scheduling in multithread application
Selective context-sensitivity guided by impact pre-analysis
A study of memory management for web-based applications on multicore processors
Futhark: purely functional GPU-programming with nested parallelism and in-place array updates
Self-stabilizing Java
Z-rays: divide arrays and conquer speed and flexibility
Refactoring programs to secure information flows
Verified perceptron convergence theorem
Designing an Efficient and Scalable Server-side Asynchrony Model for CORBA
Low-latency graph streaming using compressed purely-functional trees
Race detection for web applications
Exact Analysis of the Cache Behavior of Nested Loops
Genie: a generator of natural language semantic parsers for virtual assistant commands
End-to-end verification of stack-space bounds for C programs
GlassTube: a lightweight approach to web application integrity
MetaDL: analysing Datalog in Datalog
A case for an SC-preserving compiler
Jungloid mining: helping to navigate the API jungle
A Concurrent Compiler for Modula-2+
Detecting Conflicts Between Structure Accesses
UCC: update-conscious compilation for energy efficiency in wireless sensor networks
Higher-order control-flow analysis in retrospect: lessons learned, lessons abandoned (with retrospective)
Practical smart contract sharding with ownership and commutativity analysis
Two-Directional Record Layout for Multiple Inheritance
Higher-order and tuple-based massively-parallel prefix sums
Achieving load-balancing in power system parallel contingency analysis using X10 programming language
Adaptive restarts for stochastic synthesis
An Evaluation of Staged Run-Time Optimizations in DyC
Source-Level Debugging of Scalar Optimized Code
Accurate, efficient, and adaptive calling context profiling
ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI '13, Seattle, WA, USA, June 16-19, 2013
Valgrind: a framework for heavyweight dynamic binary instrumentation
Efficient array slicing on the Intel Xeon Phi coprocessor
Inter-procedural data-flow analysis with IFDS/IDE and Soot
Communication Optimizations for Parallel C Programs
Polynomial invariant generation for non-deterministic recursive programs
Automatically Closing Open Reactive Programs
Proceedings of the ACM SIGPLAN'89 Conference on Programming Language Design and Implementation (PLDI), Portland, Oregon, USA, June 21-23, 1989
Programming support for autonomizing software
Control-flow recovery from partial failure reports
Optimal instruction scheduling using integer programming
Scalable string analysis: an experience report
DITTO: automatic incrementalization of data structure invariant checks (in Java)
Acceleration of lattice models for pricing portfolios of fixed-income derivatives
Modular divide-and-conquer parallelization of nested loops
Loo.py: transformation-based code generation for GPUs and CPUs
Array regrouping and structure splitting using whole-program reference affinity
Load/Store Range Analysis for Global Register Allocation
Efficient, context-sensitive detection of real-world semantic attacks
New Tiling Techniques to Improve Cache Temporal Locality
Programming model for a heterogeneous x86 platform
Scenic: a language for scenario specification and scene generation
Partial control-flow linearization
DNNFusion: accelerating deep neural networks execution with advanced operator fusion
Region-based hierarchical operation partitioning for multicluster processors
Restricted delegation and revocation in language-based security: (position paper)
Concise, type-safe, and efficient structural diffing
Herding cats: modelling, simulation, testing, and data-mining for weak memory
Fluid: a framework for approximate concurrency via controlled dependency relaxation
Dynamic determinacy analysis
Program-centric cost models for locality
Proceedings of the Workshop on Dynamic Languages and Applications, Dyla 2014, Edinburgh, United Kingdom, June 9-11, 2014
Zippy LL(1) parsing with derivatives
The Design and Implementation of HoME
Multiprocessor Smalltalk: A Case Study of a Multiprocessor-Based Programming Environment
Promising 2.0: global optimizations in relaxed memory concurrency
Local parallel iteration in x10
Safe and timely updates to multi-threaded programs
Permissive dynamic information flow analysis
Profile-guided meta-programming
Generational Stack Collection and Profile-Driven Pretenuring
A General Data Dependence Test for Dynamic, Pointer-Based Data Structures
On-the-fly detection of access anomalies (with retrospective)
Precise Compile-Time Performance Prediction for Superscalar-Based Computers
Semantic Analysis in a Concurrent Compiler
Flick: A Flexible, Optimizing IDL Compiler
SympleGraph: distributed graph processing with precise loop-carried dependency guarantee
Synthesizing data structure refinements from integrity constraints
Data Specialization
Incremental whole-program analysis in Datalog with lattices
Karp: a language for NP reductions
Improving the Cache Locality of Memory Allocation
Exploiting Idle Floating-Point Resources for Integer Execution
P: safe asynchronous event-driven programming
Accurate Static Estimators for Program Optimization
Many-core compiler fuzzing
Software behavior oriented parallelization
Levity polymorphism
Separate Compilation for Standard ML
Proceedings of the ACM SIGPLAN Workshop on Memory Systems Performance and Correctness, June, 21, 2013, Seattle, Washington, USA, Co-located with PLDI 2013
Whole Program Paths
Efficient and Precise Datarace Detection for Multithreaded Object-Oriented Programs
Preference-Directed Graph Coloring
Dynamic Feedback: An Effective Technique for Adaptive Computing
Using Static Single Assignment Form to Improve Flow-Insensitive Pointer Analysis
Type-Dependent Parameter Inference
A low overhead method for recovering unused memory inside regions
Shangri-La: achieving high performance from compiled network applications while enabling ease of programming
Alphonse: Incremental Computation as a Programming Abstraction
X10 at scale
Thread-modular shape analysis
Techniques for efficient MATLAB-to-C compilation
PerfLens: a data-driven performance bug detection and fix platform
Context transformations for pointer analysis
Crellvm: verified credible compilation for LLVM
Compiling Stan to generative probabilistic languages and extension to deep probabilistic programming
ESPeciaL: an embedded systems programming language
Enhanced Code Compression for Embedded RISC Processors
The Compressor: concurrent, incremental, and parallel compaction
Static serializability analysis for causal consistency
GPU code optimization using abstract kernel emulation and sensitivity analysis
Types from data: making structured data first-class citizens in F#
The Semantics of Program Dependence
Analysis of Pointers and Structures
Harmonizing classes, functions, tuples, and type parameters in virgil iii
Register Allocation via Hierarchical Graph Coloring
Light: replay via tightly bounded recording
RustHornBelt: a semantic foundation for functional verification of Rust programs with unsafe code
Implementing Type Classes
TIL: A Type-Directed Optimizing Compiler for ML
Path slicing
A case study on machine learning for synthesizing benchmarks
Typed self-representation
Quipper: a scalable quantum programming language
Proceedings of the 6th ACM SIGPLAN International Workshop on State Of the Art in Program Analysis, SOAP@PLDI 2017, Barcelona, Spain, June 18, 2017
Efficient state merging in symbolic execution
A memory model for X10
Proceedings of the 2002 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), Berlin, Germany, June 17-19, 2002
Commit-time incremental analysis
FastTrack: efficient and precise dynamic race detection
Control-Flow Analysis in Scheme
Scalable Cross-Module Optimization
Corpus-Based Static Branch Prediction
On bounding time and space for multiprocessor garbage collection (with retrospective)
Velodrome: a sound and complete dynamic atomicity checker for multithreaded programs
Eliminating False Data Dependences using the Omega Test
Proceedings of the ACM SIGPLAN'96 Conference on Programming Language Design and Implementation (PLDI), Philadephia, Pennsylvania, USA, May 21-24, 1996
Security and quality: two sides of the same coin?
GUM: A Portable Parallel Implementation of Haskell
Compiling Real-Time Programs into Schedulable Code
Quantitative analysis of assertion violations in probabilistic programs
Mint: Java multi-stage programming using weak separability
Laws of concurrent programming
How to Print Floating-Point Numbers Accurately
Reducing NoC energy consumption through compiler-directed channel voltage scaling
HPTT: a high-performance tensor transposition C++ library
Register allocation for software pipelined multi-dimensional loops
Simple Garbage-Collector-Safety
Effective synchronization removal for Java
Essential language support for generic programming
Sound, fine-grained traversal fusion for heterogeneous trees
SoftBound: highly compatible and complete spatial memory safety for c
PetaBricks: a language and compiler for algorithmic choice
BinFPE: accurate floating-point exception detection for GPU applications
Clone-hunter: accelerated bound checks elimination via binary code clone detection
A security policy oracle: detecting security holes using multiple API implementations
Triton: an intermediate language and compiler for tiled neural network computations
PMAF: an algebraic framework for static analysis of probabilistic programs
SharC: checking data sharing strategies for multithreaded C
Mostly Parallel Garbage Collection
Monadic abstract interpreters
Position paper: Sapper - a language for provable hardware policy enforcement
Systematic approaches for increasing soundness and precision of static analyzers
register Allocation over the Program Dependence Graph
Taming the parallel effect zoo: extensible deterministic parallelism with LVish
An Accurate Instruction-Level Energy Consumption Model for Embedded RISC Processors
Analysis of pointers and structures (with retrospective)
Efficient interpretation of Prolog programs
Symbolic Boolean derivatives for efficiently solving extended regular expression constraints
Formal verification of SSA-based optimizations for LLVM
Symbolic bounds analysis of pointers, array indices, and accessed memory regions
Static analysis and compiler design for idempotent processing
Field analysis: getting useful and low-cost interprocedural information
Limitations of partial compaction: towards practical bounds
A coldness metric for cache optimization
Automatically debugging AutoML pipelines using maro: ML automated remediation oracle
Revisiting recency abstraction for JavaScript: towards an intuitive, compositional, and efficient heap abstraction
Hash-flow taint analysis of higher-order programs
Java interoperability in managed X10
LeakChaser: helping programmers narrow down causes of memory leaks
Semantic code search via equational reasoning
Program analysis and transformation for holistic optimization of database applications
DOC: A Practical Approach to Source-Level Debugging of Globally Optimized Code
Profile-based global live-range splitting
Proceedings of the 2012 Workshop on Programming Languages and Analysis for Security, PLAS 2012, Beijing, China, 15 June, 2012
Generating correctness proofs with neural networks
A static analyzer for large safety-critical software
Resilient X10 over MPI user level failure mitigation