yusuke1997/dblp-id-title huggingface dataset:
Generating fast sparse matrix vector multiplication from a high level generic functional IR
Extending Modulo Scheduling with Memory Reference Merging
Efficiency and expressiveness in UW-OpenMP
Converting Intermediate Code to Assembly Code Using Declarative Machine Descriptions
Value-Based Partial Redundancy Elimination
Restrictification of function arguments
Iterative Collective Loop Fusion
Refactoring MATLAB
Fast and Accurate Context-Aware Basic Block Timing Prediction using Transformers
(De/Re)-Compositions Expressed Systematically via MDH-Based Schedules
A Static Study of Java Exceptions Using JESP
Compiler Transformation of Pointers to Explicit Array Accesses in DSP Applications
Training of deep learning pipelines on memory-constrained GPUs via segmented fused-tiled execution
A Symbolic Approach to Bernstein Expansion for Program Analysis and Optimization
Delayed Exceptions - Speculative Execution of Trapping Instructions
CHEHAB: Automatic Compiler Code Optimization for Fully Homomorphic Encryption
An efficient data structure for must-alias analysis
Influence of Loop Optimizations on Energy Consumption of Multi-bank Memory Systems
Sambamba: A Runtime System for Online Adaptive Parallelization
Iguana: a practical data-dependent parsing framework
Visual Patterns in the VLEli System
Programming Paradigm Driven Heap Analysis
Compiler-Guaranteed Safety in Code-Copying Virtual Machines
A Faster Earley Parser
Preference-Guided Register Assignment
Inter-iteration Scalar Replacement Using Array SSA Form
Mixed-data-model heterogeneous compilation and OpenMP offloading
Faster Scannerless GLR Parsing
From Specification to Optimisation: An Architecture for Optimisation of Java Bytecode
Mapping parallelism in a functional IR through constraint satisfaction: a case study on convolution for mobile GPUs
Interpreter Instruction Scheduling
FESA: Fold- and Expand-Based Shape Analysis
OASIS: An Optimizing Action-Based Compiler Generator
Mixed Dialogue Control Defined by an Attribute Grammar (Abstract)
Controlled Node Splitting
Matching Linear Algebra and Tensor Code to Specialized Hardware Accelerators
A polyhedral compilation framework for loops with dynamic data-dependent bounds
An Overview of Door Attribute Grammars
Register Allocation for Programs in SSA-Form
On fast large-scale program analysis in Datalog
Scalable pointer analysis of data structures using semantic models
Fusion of Operators of Computational Graphs via Greedy Clustering: The XNNC Experience
An Attributed ELL(1)-Parser Generator (Abstract)
Cool: A Control-Flow Generator for System Analysis
A Bounded Graph-Connect Construction for LR-regular Parsers
The Interprocedural Express-Lane Transformation
The Limits of Alias Analysis for Scalar Optimizations
Path sensitive MFP solutions in presence of intersecting infeasible control flow path segments
Addressing JavaScript JIT Engines Performance Quirks: A Crowdsourced Adaptive Compiler
Correcting the Dynamic Call Graph Using Control-Flow Constraints
Proceedings of the 33rd ACM SIGPLAN International Conference on Compiler Construction, CC 2024, Edinburgh, United Kingdom, March 2-3, 2024
A Multi-threaded Fast Hardware Compiler for HDLs
Attribute-influenced LR parsing
Towards a compiler analysis for parallel algorithmic skeletons
Writing and verifying a Quantum optimizing compiler (keynote)
Task Partitioning for Multi-core Network Processors
The MAGICA Type Inference Engine for MATLAB
Data-Efficient Performance Modeling via Pre-training
CC '22: 31st ACM SIGPLAN International Conference on Compiler Construction, Seoul, South Korea, April 2 - 3, 2022
CC '21: 30th ACM SIGPLAN International Conference on Compiler Construction, Virtual Event, March 2-3, 2021
Integrating a functional pattern-based IR into MLIR
A Symbolic Emulator for Shuffle Synthesis on the NVIDIA PTX Code
HyBF: A Hybrid Branch Fusion Strategy for Code Size Reduction
Reducing memory buffering overhead in software thread-level speculation
A Comparison of Compiler Tiling Algorithms
Transport-Triggering versus Operation-Triggering
Expansion-Based Removal of Semantic Partial Redundancies
A First Step Towards Time Optimal Software Pipelining of Loops with Control Flows
Incremental Symbol Processing
Intermodular Slicing of Object-oriented Programs
Interprocedural Path Profiling
Automatic Detection of Uninitialized Variables
Optimizing Matlab through Just-In-Time Specialization
Link-Time Improvement of Scheme Programs
Effective Representation of Aliases and Indirect Memory Operations in SSA Form
Specification of compilers as abstract data type representations
A Compilation and Optimization Model for Aspect-Oriented Programs
Basic-Block Graphs: Living Dinosaurs?
Staged Points-to Analysis for Large Code Bases
VMAD: An Advanced Dynamic Program Analysis and Instrumentation Framework
Compile-time function memoization
Register allocation and promotion through combined instruction scheduling and loop unrolling
Improving Performance of OpenCL on CPUs
Java Bytecode Verification for @NonNull Types
A New One-Pass Transformation into Monadic Normal Form
Strength Reduction via SSAPRE
Analytical Bounds for Optimal Tile Size Selection
Efficient Storage Reuse of Aggregates in Single Assignment Languages
Tools and Techniques of Annotated Programming
LAGrad: Statically Optimized Differentiable Programming in MLIR
Automating reinforcement learning architecture design for code optimization
Codon: A Compiler for High-Performance Pythonic Applications and DSLs
Schedgehammer: Auto-tuning Compiler Optimizations beyond Numerical Parameters
Building a Compiled Query Engine in Python
Lightweight Lexical Closures for Legitimate Execution Stack Access
Speculative Prefetching of Induction Pointers
Effective Enhancement of Loop Versioning in Java
A Compiler for Natural Semantics
Generating Efficient Code from Continuation Semantics
Polyhedral Code Generation in the Real World
Compiler-based graph representations for deep learning models of code
Compiling for concise code and efficient I/O
Future-Proofing Collections: From Mutable to Persistent to Parallel
Dynamic Look Ahead Compilation: A Technique to Hide JIT Compilation Latencies in Multicore Environment
Deep NLP-based co-evolvement for synthesizing code analysis from natural language
Enhancing Program Analysis with Deterministic Distinguishable Calling Context
Compiler generation from denotational semantics
Graph transformations for register-pressure-aware instruction scheduling
PPOpenCL: a performance-portable OpenCL compiler with host and kernel thread code fusion
Compare less, defer more: scaling value-contexts based whole-program heap analyses
Run-Time Type Checking for Binary Programs
Loner: utilizing the CPU vector datapath to process scalar integer data
Completeness Analysis for Incomplete Object-Oriented Programs
MATOU: An Implementation of Mode-Automata
A Suite of Analysis Tools Based on a General Purpose Abstract Interpreter
Points-to Analysis by Type Inference of Programs with Structures and Unions
A Parallel Debugger with Support for Distributed Arrays, Multiple Executables and Dynamic Processes
Resolvable ambiguity: principled resolution of syntactically ambiguous programs
A static slicing method for functional programs and its incremental version
Automatic fault location for data structures
A Portable and Optimizing Back End for the SML/NJ Compiler
Accelerating web application loading with snapshot of event and DOM handling
Compile Time Instruction Cache Optimizations
Detecting Parallelism in C Programs with Recursive Darta Structures
Pipelining-Dovetailing: A Transformation to Enhance Software Pipelining for Nested Loops
Runtime multi-versioning and specialization inside a memoized speculative loop optimizer
Automatic Removal of Array Memory Leaks in Java
Efficient Flow-Sensitive Interprocedural Data-Flow Analysis in the Presence of Pointers
Improving the Performance of X10 Programs by Clock Removal
Compilation of Generic Regular Path Expressions Using C++ Class Templates
A Study of Type Analysis for Speculative Method Inlining in a JIT Environment
Experiences with the compiler writing system HLP
Layout Transformations for Heap Objects Using Static Access Patterns
Coupling Evaluators for Attribute Coupled Grammars
Memory access scheduling to reduce thread migrations
Punctual Coalescing
The Next 700 ML-Enabled Compiler Optimizations
Generation of Incremental Indirect Threaded Code for Language-Based Programming Environments
Efficient Organization of Control Structures in Distributed Implementations
A Framework for Optimizing Java Using Attributes
Adding Semantic and Syntactic Predicates To LL(k): pred-LL(k)
A Novel Probabilistic Data Flow Framework
Solving Demand Versions of Interprocedural Analysis Problems
Optimized two-level parallelization for GPU accelerators using the polyhedral model
A Backend Extension Mechanism for PQL/Java with Free Run-Time Optimisation
OPTRAN - A Language/System for the Specification of Program Transformations: System Overview and Experiences
State transition machines for lambda calculus expressions
Making no-fuss compiler fuzzing effective
Automatic Transformations for Communication-Minimized Parallelization and Locality Optimization in the Polyhedral Model
Software Pipelining of Nested Loops
Syntax Directed Translation with LR Parsing
It's about Time: Temporal Abstractions for Asynchronous GPU Tensor Computations
Algorithmic Debugging for Imperative Languages with Side-Effects (Abstract)
Efficient concolic testing of MPI applications
Compiling Mercury to High-Level C Code
Rapid and Robust Compiler Construction Using Template-Based Metacompilation
Optimizing Object-Oriented Languages Through Architechtural Transformations
Dynamic symbolic execution for polymorphism
Sparse representation of implicit flows with applications to side-channel detection
Code Optimization by Integer Linear Programming
A study of event frequency profiling with differential privacy
Improved MHP Analysis
Optimizing C Multithreaded Memory Management Using Thread-Local Storage
Compile-Time Analysis and Specialization of Clocks in Concurrent Programs
Experiences with Enumeration of Integer Projections of Parametric Polytopes
Online Subpath Profiling
Compiler Construction, 5th International Conference, CC'94, Edinburgh, UK, April 7-9, 1994, Proceedings
A Sound and Complete Algorithm for Code Generation in Distance-Based ISA
Parallel and Customizable Equality Saturation
Boosting the Performance of Multimedia Applications Using SIMD Instructions
Incremental Computation of Static Single Assignment Form
Lrc - A Generator for Incremental Language-Oriented Tools
Compiling first-order functions to session-typed parallel code
On the Determination of Inlining Vectors for Program Optimization
Accurate Coverage Metrics for Compiler-Generated Debugging Information
Recursive Ascent-Descent Parsers
Generating an Efficient Compiler for a Data Parallel Language from a Denotational Specification
One compiler: deoptimization to optimized code
Pipelined Java Virtual Machine Interpreters
Compiler Construction - 22nd International Conference, CC 2013, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2013, Rome, Italy, March 16-24, 2013. Proceedings
Implementing 2DT on a Multiprocessor
GreenThumb: superoptimizer construction framework
Compiler-Guided Identification of Critical Sections in Parallel Code
A Tool Box for Compiler Construction
Compiler Support for Fine-Grain Software-Only Checkpointing
Goal-Directed Value Profiling
Unrestricted Code Motion: A Program Representation and Transformation Algorithms Based on Future Values
Demand-Driven Construction of Call Graphs
Optimal and Heuristic Global Code Motion for Minimal Spilling
Is Reuse Distance Applicable to Data Locality Analysis on Chip Multiprocessors?
Multiversioned decoupled access-execute: the key to energy-efficient compilation of general-purpose programs
Hardware JIT Compilation for Off-the-Shelf Dynamically Reconfigurable FPGAs
Performance implications of transient loop-carried data dependences in automatically parallelized loops
Abstract Compilation: A New Implementation Paradigm for Static Analysis
Storage Allocation Strategies for Recursive Attributes Evaluators
Two Tree Pattern Matchers for Code Selection
Revec: program rejuvenation through revectorization
Declarative Composition of Stack Frames
Alias Analysis by Means of a Model Checker
Processing Array Statements and Procedure Interfaces in the PREPARE High Performance Fortran Compiler
Is stateful packrat parsing really linear in practice? a counter-example, an improved grammar, and its parsing algorithms
Reducing the Overhead of Exact Profiling by Reusing Affine Variables
Evaluating a Demand Driven Technique for Call Graph Construction
Verifying Fast and Sparse SSA-Based Optimizations in Coq
More on advice on structuring compilers and proving them correct
Techniques for Reducing the Overhead of Run-Time Parallelization
Jazz: A Tool for Demand-Driven Structural Testing
From standard to implementation denotational semantics
Extensible Proof-Producing Compilation
Techniques for Effectively Exploiting a Zero Overhead Loop Buffer
Proceedings of the 34th ACM SIGPLAN International Conference on Compiler Construction, CC 2025, Las Vegas, NV, USA, March 1-2, 2025
Path-Based Reuse Distance Analysis
Register allocation and instruction scheduling in Unison
A Practical Implementation of DCGs (Abstract)
An Efficient On-the-Fly Cycle Collection
Automatic Restructuring of GPU Kernels for Exploiting Inter-thread Data Locality
Abstract Interfaces for Compiler Generating Tools
String Analysis for Dynamic Field Access
Granullar: gradual nullable types for Java
Practical Extensions to the IFDS Algorithm
RIFS: Run-Time Invariant Function Specialization
Semantic reasoning about the sea of nodes
Programming Clouds
Compiler Construction, 11th International Conference, CC 2002, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2002, Grenoble, France, April 8-12, 2002, Proceedings
A New Approach to Control Flow Analysis
Transformation of Attributed Trees Using Pattern Matching
Faster Alias Set Analysis Using Summaries
Software Engineering Aspects in Language Implementation
Recovery of Class Hierarchies and Composition Relationships from Machine Code
Compiler Construction, 6th International Conference, CC'96, Linköping, Sweden, April 24-26, 1996, Proceedings
A New Fast Algorithm for Optimal Register Allocation in Modulo Scheduled Loops
Efficiently Learning Locality Optimizations by Decomposing Transformation Domains
A Comprehensive Approach to Array Bounds Check Elimination for Java
Generalised Recursive Descent parsing and Fellow-Determinism
BLQ: Light-Weight Locality-Aware Runtime for Blocking-Less Queuing
Compact Dispatch Tables for Dynamically Typed Object Oriented Languages
Protocols by Default - Safe MPI Code Generation Based on Session Types
Implementing High-Level Identification Specifications
Register Pipelining: An Integrated Approach to Register Allocation for Scalar and Subscripted Variables
Proceedings of the 32nd ACM SIGPLAN International Conference on Compiler Construction, CC 2023, Montréal, QC, Canada, February 25-26, 2023
The Hot Path SSA Form: Extending the Static Single Assignment Form for Speculative Optimizations
Dynamic property caches: a step towards faster JavaScript proxy objects
Dimensions of Precision in Reference Analysis of Object-Oriented Programming Languages
ILALR: An Incremental Generator of LALR(1) Parsers
Live Range Splitting in a Graph Coloring Register Allocator
STARLET: An Affix-Based Compiler Compiler Designed as a Logic Programming System
A Pattern Matching Compiler for Multiple Target Languages
CAnDL: a domain specific language for compiler analysis
A Refactoring Library for Scala Compiler Extensions
Type Checking in the Large
FCG: A Code Generator for Lazy Functional Languages
SmartTools: A Generator of Interactive Environments Tools
Generating LR(1) Parsers of Small Size
On the definition of attribute grammar
Scalable Data-Flow Modeling and Validation of Distributed-Memory Algorithms
Reducing the Cost of Data Flow Analysis By Congruence Partitioning
Spinal code: automatic code extraction for near-user computation in fogs
Compiler and language design for quantum computing (keynote)
Fast Escape Analysis and Stack Allocation for Object-Based Programs
Communication-safe web programming in TypeScript with routed multiparty session types
A Graph-Free Approach to Data-Flow Analysis
PolyBench/Python: benchmarking Python environments with polyhedral optimizations
Compiler Construction, 9th International Conference, CC 2000, Held as Part of the European Joint Conferences on the Theory and Practice of Software, ETAPS 2000, Berlin, Germany, March 25 - April 2, 2000, Proceedings
Compact native code generation for dynamic languages on micro-core architectures
QRANE: lifting QASM programs to an affine IR
Compiler Construction, 8th International Conference, CC'99, Held as Part of the European Joint Conferences on the Theory and Practice of Software, ETAPS'99, Amsterdam, The Netherlands, 22-28 March, 1999, Proceedings
Towards the Global Optimization of Functional Logic Programs
A Term Pattern-Match Compiler Inspired by Finite Automata Theory
rev.ng: a unified binary analysis framework to recover CFGs and function boundaries
Tainted Flow Analysis on e-SSA-Form Programs
A session type provider: compile-time API generation of distributed protocols with refinements in F#
Compiler Support for Value-Based Indirect Branch Prediction
Efficiency, Precision, Simplicity, and Generality in Interprocedural Data Flow Analysis: Resurrecting the Classical Call Strings Method
LISA: An Interactive Environment for Programming Language Development
Hybrid Optimizations: Which Optimization Algorithm to Use?
A Flexible and Efficient ML Lexer Tool Based on Extended Regular Expression Submatching
Directly-Executable Earley Parsing
Semantics-Directed Compiler Generation, Proceedings of a Workshop, Aarhus, Denmark, January 14-18, 1980
Taming Control Divergence in GPUs through Control Flow Linearization
Compiler Construction, 4th International Conference on Compiler Construction, CC'92, Paderborn, Germany, October 5-7, 1992, Proceedings
Provable Correctness of Prototype Interpreters in LDL
Lightweight data race detection for production runs
FlowProf: Profiling Multi-threaded Programs using Information-Flow
Supporting Legacy Binary Code in a Software Transaction Compiler with Dynamic Binary Translation and Optimization
Accelerating Sparse Algebra with Program Synthesis
Verifying Local Transformations on Relaxed Memory Models
APPy: Annotated Parallelism for Python on GPUs
SARA: Combining Stack Allocation and Register Allocation
Generalized profile-guided iterator recognition
Using Ownership to Reason about Inherent Parallelism in Object-Oriented Programs
Live Debugging of Distributed Systems
Safe and flexible adaptation via alternate data structure representations
A Framework for Exploring Optimization Properties
Optimizing Sparse Tensor Compilation for Sparse Output
Advanced Scalarization of Array Syntax
Delegating Compiler Objects: An Object-Oriented Approach to Crafting Compilers
Exponentially Expanding the Phase-Ordering Search Space via Dormant Information
New Algorithms for SIMD Alignment
A Fresh Look at PRE as a Maximum Flow Problem
Overloading the Dot
Tail call elimination and data representation for functional languages on the Java virtual machine
MimIrADe: Automatic Differentiation in MimIR
From functional programs to pipelined dataflow circuits
Transforming denotational semantics into practical attribute grammars
Robust quantization of deep neural networks
Optgen: A Generator for Local Optimizations
Specification and Implementation of a Tree-Abiding Interface for Ada (Extended Abstract)
When Abstraction Fails
Source-Level Debugging for Multiple Languages with Modest Programming Effort
The Design of the PROMIS Compiler
Using Disjoint Reachability for Parallelization
Loop-Aware Instruction Scheduling with Dynamic Contention Tracking for Tiled Dataflow Architectures
Verified construction of static single assignment form
Compiling data-parallel Datalog
Combined Code Motion and Register Allocation Using the Value State Dependence Graph
An Adaptive Strategy for Inline Substitution
Automatic Generation of Program Affinity Policies Using Machine Learning
To unify or not to unify: a case study on unified builds (in WebKit)
Another Kind of Modular Attribute Grammars
Compiler Construction Using LOTOS NT
User-Extensible Simplification - Type-Based Optimizer Generators
IDE Dataflow Analysis in the Presence of Large Object-Oriented Libraries
The Eli System
Automatic Test Case Generation for Jasper App HDL Compiler: An Industry Experience
Using an LALR Compiler Compiler to Generate Incremental Parsers
Automatic data layout generation and kernel mapping for CPU+GPU architectures
BinPointer: towards precise, sound, and scalable binary-level pointer analysis
Data Compression Transformations for Dynamically Allocated Data Structures
GPU-accelerated fixpoint algorithms for faster compiler analyses
Heap bounds protection with low fat pointers
CC '20: 29th International Conference on Compiler Construction, San Diego, CA, USA, February 22-23, 2020
Using the SSA-Form in a Code Generator
Automatic Transformation of Bit-Level C Code to Support Multiple Equivalent Data Layouts
Compilation and Memory Management for ASF+SDF
Parameterized Construction of Program Representations for Sparse Dataflow Analyses
DiTOX: Fault Detection and Localization in the ONNX Optimizer
Exploitation of GPUs for the Parallelisation of Probably Parallel Legacy Code
Instruction Schedulimg over Regions: A Framework for Scheduling Across Basic Blocks
Value-Profile Guided Stride Prefetching for Irregular Code
Reachability and error diagnosis in LR(1) parsers
Efficient Context-Sensitive Shape Analysis with Graph Based Heap Models
Proceedings of the 25th International Conference on Compiler Construction, CC 2016, Barcelona, Spain, March 12-18, 2016
Balancing performance and productivity for the development of dynamic binary instrumentation tools: a case study on Arm systems
Optimal Live Range Merge for Address Register Allocation in Embedded Programs
Compilation for Instruction Parallel Processors
Virtual Cache Line: A New Technique to Improve Cache Exploitation for Recursive Data Structures
Incremental Attribute Evaluation with Side-effects
A Compiler-Based Approach to Data Security
Maptool - Supporting Modular Syntax Development
Partially redundant fence elimination for x86, ARM, and power processors
Early Control of Register Pressure for Software Pipelined Loops
Periodic Polyhedra
Exploring the space of optimization sequences for code-size reduction: insights and tools
Proceedings of the 27th International Conference on Compiler Construction, CC 2018, February 24-25, 2018, Vienna, Austria
Scaling Java Points-to Analysis Using SPARK
Creation of a Family of Compilers and Runtime Environments by Combining Reusable Components
Analyzing Memory Accesses in x86 Executables
Global Software Pipelining with Iteration Preselection
Compile-Time Analysis of Object-Oriented Programs
Stochastic Bit-Width Approximation Using Extreme Value Theory for Customizable Processors
Improving the Performance of Parallel LISP by Compile Time Analysis
Clean Translation of an Imperative Reversible Programming Language
Using Dependent Types to Port Type Systems to Low-Level Languages
The PAPAGENO Parallel-Parser Generator
Improved Memory-Access Analysis for x86 Executables
LLM Compiler: Foundation Language Models for Compiler Optimization
Decompiling Java Bytecode: Problems, Traps and Pitfalls
Generating SIMD Vectorized Permutations
Architecture-Independent Dynamic Information Flow Tracking
Postcondition-preserving fusion of postorder tree transformations
Generators for High-Speed Front-Ends
Validating Register Allocation and Spilling
Global Code Selection of Directed Acyclic Graphs
How to Uniformly Specify Program Analysis and Transformation with Graph Rewrite Systems
Analysis of Loops
A Deep Technical Review of nZDC Fault Tolerance
Application Development with the FNC-2 Attribute Grammar System
Cosy Compiler Phase Embedding with the CoSy Compiler Model
Points-to and Side-Effect Analyses for Programs Built with Precompiled Libraries