yusuke1997/dblp-id-title huggingface dataset:
Efficiency vs. portability in cluster-based network servers
Dynamic multigrain parallelization on the cell broadband engine
Program Development for a Systolic Array
Open nesting in software transactional memory
Efficient Support for Irregular Applications on Distributed-Memory Machines
A peta-scalable CPU-GPU algorithm for global atmospheric simulations
Proceedings of the 2012 PPOPP International Workshop on Programming Models and Applications for Multicores and Manycores, PMAM 2012, New Orleans, LA, USA, February 26, 2012
A Data Layout Transformation for Vectorizing Compilers
Exploiting Efficient Mapping and Pipelined Execution for Accelerating SpMV on Tensor Cores
Adapting convergent scheduling using machine learning
Energy efficiency and performance frontiers for sparse computations on GPU supercomputers
GLumin: Fast Connectivity Check Based on LUTs For Efficient Graph Pattern Mining
RACECAR: a heuristic for automatic function specialization on multi-core heterogeneous systems
QoS aware storage cache management in multi-server environments
Reachability Analysis of Cost-Reward Timed Automata for Energy Efficiency Scheduling
Communication-avoiding parallel minimum cuts and connected components
Committing conflicting transactions in an STM
Comparability graph coloring for optimizing utilization of stream register files in stream processors
Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPOPP 2006, New York, New York, USA, March 29-31, 2006
BEEMS: Boosting Machine Vision Efficiency via Computation Graph-Based Memory Smoothing
POSTER: An Infrastructure for HPC Knowledge Sharing and Reuse
GAMBIT: effective unit testing for concurrency libraries
Fast concurrent lock-free binary search trees
Programming Task and Data Parallelism on a Multicomputer
Optimizing sparse computations jointly
GPTune: multitask learning for autotuning exascale applications
Automatic safety proofs for asynchronous memory operations
GPU technology applied to reverse time migration and seismic modeling via OpenACC
Optimistic Active Messages: A Mechanism for Scheduling Communication with Computation
High-Performance and Scalable Agent-Based Simulation with BioDynaMo
Code Motion for Explicitly Parallel Programs
Automatic semantic locking
Automatic Static Analysis-Guided Optimization of CUDA Kernels
Towards Maximum Throughput of Dataflow Software Pipeline under Resource Constraints
Parallel thinking
POSTER: MAPA: An Automatic Memory Access Pattern Analyzer for GPU Applications
PANA: A Fine-Grained Runtime-Adaptive Load Balancing for Parallel SpMV on Multicore CPUs
Event-Based Performance Perturbation: A Case Study
Software transactional distributed shared memory
The Shared Regions Approach to Software Cache Coherence on Multiprocessors
Perturbation Analysis of High Level Instrumentation for SPMD Programs
Elastic Averaging for Efficient Pipelined DNN Training
Experience on optimizing irregular computation for memory hierarchy in manycore architecture
ParGeo: a library for parallel computational geometry
Automated multi-dimensional elasticity for streaming runtimes: poster
Split hardware transactions: true nesting of transactions using best-effort hardware transactional memory
High-throughput image alignment for connectomics using frugal snap judgments: poster
Simple, portable and fast SIMD intrinsic programming: generic simd library
Throughput-oriented GPU memory allocation
Mario: Near Zero-cost Activation Checkpointing in Pipeline Parallelism
High Performance Synchronization Algorithms for Multiprogrammed Multiprocessors
Parallel Discrete-Event Simulation Of FCFS Stochastic Queuing Networks
Optimization for performance and energy for batched matrix computations on GPUs
A persistent lock-free queue for non-volatile memory
Exploring different automata representations for efficient regular expression matching on GPUs
Adaptive scheduling with parallelism feedback
Latency hiding through multithreading on a network processor
On Guided Installation of Basic Linear Algebra Routines in Nodes with Manycore Components
pC++/streams: a Library for I/O on Complex Distributed Data Structures
Proceedings of the 13th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPOPP 2008, Salt Lake City, UT, USA, February 20-23, 2008
BID@PPOPP 2022: Benchmarking in the Data Center: Expanding to the Cloud, Seoul, Republic of Korea, April 2, 2022
Understanding the GPU Microarchitecture to Achieve Bare-Metal Performance Tuning
Deadlock-free buffer configuration for stream computing
Efficient shuffle management with SCache for DAG computing frameworks
Using data structure knowledge for efficient lock generation and strong atomicity
Dynamic Partitioning-based JPEG Decompression on Heterogeneous Multicore Architectures
2PLSF: Two-Phase Locking with Starvation-Freedom
Serialization sets: a dynamic dependence-based parallel execution model
Wait-free Dynamic Transactions for Linked Data Structures
FlashTensor: Optimizing Tensor Programs by Leveraging Fine-grained Tensor Property
OpenCL as a unified programming model for heterogeneous CPU/GPU clusters
GPGPU performance estimation for frequency scaling using cross-benchmarking
Weak atomicity under the x86 memory consistency model
Exploiting global optimizations for openmp programs in the openuh compiler
Proceedings of the Sixth ACM SIGPLAN Symposium on Principles & Practice of Parallel Programming (PPOPP), Las Vegas, Nevada, USA, June 18-21, 1997
Forma: a DSL for image processing applications to target GPUs and multi-core CPUs
Parallel-Program Transformation Using A Metalanguage
Optimizing N-dimensional, winograd-based convolution for manycore CPUs
Compiler and Software Distributed Shared Memory Support for Irregular Applications
A novel approach for partitioning iteration spaces with variable densities
A parallel algorithm for global states enumeration in concurrent systems
Statistical scalability analysis of communication operations in distributed applications
Exploring the vectorization of python constructs using pythran and boost SIMD
Proceedings of the 10th International Workshop on Programming Models and Applications for Multicores and Manycores, PMAM@PPoPP 2019, Washington, DC, USA, February 17, 2019
POSTER: STAR (Space-Time Adaptive and Reductive) Algorithms for Real-World Space-Time Optimality
Frontier-guided Graph Reordering
An Evaluation of Emerging Many-Core Parallel Programming Models
Designing scalable FPGA architectures using high-level synthesis
COCCL: A Collective Communication Library Supporting Easy Integration and Configuration of Customized Compression for Scalable LLM Training
Compact data structure and scalable algorithms for the sparse grid technique
DisCVar: discovering critical variables using algorithmic differentiation for transient faults
Proceedings of the 22nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, Austin, TX, USA, February 4-8, 2017
Hierarchical memory management for mutable state
Tiles: a new language mechanism for heterogeneous parallelism
Deadlock-free asynchronous message reordering in rust with multiparty session types
Efficient load balancing for wide-area divide-and-conquer applications
Scaling GPU-to-CPU Migration for Efficient Distributed Execution on CPU Clusters
Chestnut: a GPU programming language for non-experts
Assessing One-to-One Parallelism Levels Mapping for OpenMP Offloading to GPUs
Synchronization views for event-loop actors
Enhancing the performance of MPI-IO applications by overlapping I/O, computation and communication
Rigorous specification and low-latency implementation of technical market indicators
A novel data transformation and execution strategy for accelerating sparse matrix multiplication on GPUs
Proving correctness of highly-concurrent linearisable objects
Function Call Re-Vectorization
Near-optimal sparse allreduce for distributed deep learning
Parallelization hints via code skeletonization
Making pull-based graph processing performant
Idempotent work stealing
WuKong: effective diagnosis of bugs at large system scales
OpenMP to GPGPU: a compiler framework for automatic translation and optimization
Mapping Concurrent Programs to VLIW Processors
Towards OmpSs-2 and OpenACC interoperation
Near LLC versus near main memory processing
RoMeo: Mitigating Dual-dimensional Outliers with Rotated Mixed Precision Quantization
Are Your Epochs Too Epic? Batch Free Can Be Harmful
Automatic Parallelization of Divide and Conquer Algorithms
Adoption protocols for fanout-optimal fault-tolerant termination detection
Multi-GPU implementation of the Horizontal Diffusion method of the Weather Research and Forecast Model
Contention elimination by replication of sequential sections in distributed shared memory programs
RDMA read based rendezvous protocol for MPI over InfiniBand: design alternatives and benefits
Generating Parallel Code from Object Oriented Mathematical Models
Scalable deterministic replay in a parallel full-system emulator
Tapir: Embedding Fork-Join Parallelism into LLVM's Intermediate Representation
ISP: a tool for model checking MPI programs
Portable parallel performance from sequential, productive, embedded domain-specific languages
PLUTO+: near-complete modeling of affine transformations for parallelism and locality
Helper locks for fork-join parallel programming
MPI+Threads: runtime contention and remedies
Basic Compiler Algorithms for Parallel Programs
Implementing an Irregular Application on a Distributed Memory Multiprocessor
Locality-aware connection management and rank assignment for wide-area MPI
From relational verification to SIMD loop synthesis
SPIRIT: a runtime system for distributed irregular tree applications
Patty: a pattern-based parallelization tool for the multicore age
TaskInsight: Understanding Task Schedules Effects on Memory and Performance
Towards an energy estimator for fault tolerance protocols
Fast concurrent queues for x86 processors
High-level adaptive program optimization with ADAPT
Thread to strand binding of parallel network applications in massive multi-threaded systems
Application heartbeats for software performance and health
Understanding The Security of Discrete GPUs
FliT: a library for simple and efficient persistent algorithms
RT-BarnesHut: Accelerating Barnes-Hut Using Ray-Tracing Hardware
ParDiff: Efficiently Parallelizing Reverse-Mode Automatic Differentiation with Direct Indexing
Expressing and exploiting concurrency in networked applications with aspen
Scalable adaptive NUMA-aware lock: combining local locking and remote locking for efficient concurrency
High-Throughput Non-uniformly Quantized 3-bit LLM Inference
Compiler optimizations for parallelizing general-purpose applications under thread-level speculation
Scheduling parallel programs by work stealing with private deques
Adaptive work stealing with parallelism feedback
Efficient, portable implementation of asynchronous multi-place programs
An effective fusion and tile size model for optimizing image processing pipelines
Proceedings of the ACM/SIGPLAN PPEALS 1988, Parallel Programming: Experience with Applications, Languages and Systems, New Haven, Connecticut, USA, July 19-21, 1988
POSTER: HythTM: Extending the Applicability of Intel TSX Hardware Transactional Support
User-controllable coherence for high performance shared memory multiprocessors
A Concurrent Copying Garbage Collector for Languages that Distinguish (Im)mutable Data
Custom code generation for a graph DSL
Promised messages: recovering from inconsistent global states
Modeling optimistic concurrency using quantitative dependence analysis
Extracting SMP parallelism for dense linear algebra algorithms from high-level specifications
CUDA acceleration for Xen virtual machines in infiniband clusters with rCUDA
S: a scripting language for high-performance RESTful web services
Language-Agnostic Static Deadlock Detection for Futures
A New Model for Integrated Nested Task and Data Parallel Programming
Asynchrony versus bulk-synchrony for a generalized N-body problem from genomics
Fast concurrent data sketches
Optimizing GPU programs by partial evaluation
Systematically extending a high-level code generator with support for tensor cores
Parallel k-Core Decomposition with Batched Updates and Asynchronous Reads
Ordered vs. unordered: a comparison of parallelism and work-efficiency in irregular algorithms
Using thread-level speculation to simplify manual parallelization
Transfer Learning Across Heterogeneous Features For Efficient Tensor Program Generation
Harnessing Inter-GPU Shared Memory for Seamless MoE Communication-Computation Fusion
Harmonia: a high throughput B+tree for GPUs
Testing concurrency on the JVM with lincheck
Reasoning about recursive tree traversals
OsirisBFT: Say No to Task Replication for Scalable Byzantine Fault Tolerant Analytics
PAM: parallel augmented maps
An adaptive memory conscious approach for mining frequent trees: implications for multi-core architectures
Debugging parallel programs using fork handlers
Self-Configuration and Self-Optimization Autonomic Skeletons using Events
Accelerating distributed stochastic gradient descent with adaptive periodic parameter averaging: poster
CPMA: An Efficient Batch-Parallel Compressed Set Without Pointers
Designing high performance communication runtime for GPU managed memory: early experiences
Modeling advanced collective communication algorithms on cell-based systems
POSTER: A GPU-Friendly Skiplist Algorithm
Aggregating Funnels for Faster Fetch&Add and Queues
Task mapping stencil computations for non-contiguous allocations
Algorithm-based recovery for HPL
Formal specification of the MPI-2.0 standard in TLA+
Parallelization spectroscopy: analysis of thread-level parallelism in hpc programs
Magneto: Accelerating Parallel Structures in DNNs via Co-Optimization of Operators
Detectable recovery of lock-free data structures
Self-Checkpoint: An In-Memory Checkpoint Method Using Less Space and Its Practice on Fault-Tolerant HPL
OPR: deterministic group replay for one-sided communication
Formal Verification through Combinatorial Topology: the CAS-Extended Model
Bounded incoherence: a programming model for non-cache-coherent shared memory architectures
Thread-level parallelization and optimization of NWChem for the Intel MIC architecture
LoPC: Modeling Contention in Parallel Algorithms
No barrier in the road: a comprehensive study and optimization of ARM barriers
FlexBFS: a parallelism-aware implementation of breadth-first search on GPU
Active workflow system for near real-time extreme-scale science
Towards Composable GPU Programming: Programming GPUs with Eager Actions and Lazy Views
Interval-based memory reclamation
Eunomia: Scaling Concurrent Search Trees under Contention Using HTM
Cache-aware iteration space partitioning
A sampling-based framework for parallel data mining
Vapro: performance variance detection and diagnosis for production-run parallel applications
Preliminary results on nb-feb, a synchronization primitive for parallel programming
Soar/PSM-E: Investigating Match Parallelism in a Learning Production System
Low-overhead software transactional memory with progress guarantees and strong semantics
Parallel Skeletons for Structured Composition
Qlisp: Experience and New Directions
Proceedings of the 20th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPoPP 2015, San Francisco, CA, USA, February 7-11, 2015
TileSpGEMM: a tiled algorithm for parallel sparse general matrix-matrix multiplication on GPUs
Design and evaluation of a novel dataflow based bigdata solution
Dynamic Detection of Inefficient Data Mapping Patterns in Heterogeneous OpenMP Applications
Continuous speculative program parallelization in software
Locks as a Resource: Fairly Scheduling Lock Occupation with CFL
Using multiple energy gears in MPI programs on a power-scalable cluster
A generate-test-aggregate parallel programming library: systematic parallel programming for MapReduce
Compiler Optimizations for Eliminating Barrier Synchronization
Software-managed Cache Coherence for fast One-Sided Communication
Blocking and array contraction across arbitrarily nested loops using affine partitioning
T-thinker: a task-centric distributed framework for compute-intensive divide-and-conquer algorithms
Algorithm-based fault tolerance for dense matrix factorizations
Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPOPP 2003, June 11-13, 2003, San Diego, CA, USA
Efficient Parallel Implementations of Multiple Sequence Alignment using BSP/CGM Model
Concurrent breakpoints
Lifeline-based global load balancing
Supporting Fine-grained Dataflow Parallelism in Big Data Systems
Elastor: Elastic and Efficient Model Partitioning and Checkpointing for Fault-Tolerant Distributed Training
Provably Good Randomized Strategies for Data Placement in Distributed Key-Value Stores
Proceedings of the 31st ACM SIGPLAN Annual Symposium on Principles and Practice of Parallel Programming, PPoPP 2026, Sydney, NSW, Australia, 31 January 2026 - 4 February 2026
High performance dense linear algebra on a spatially distributed processor
Compiler-assisted scheduling for multi-instance GPUs
Stochastic gradient descent on GPUs
Work Stealing Strategies For Multi-Core Parallel Branch-and-Bound Algorithm Using Factorial Number System
Scalable top-k retrieval with Sparta
Practical concurrent binary search trees via logical ordering
Is transactional programming actually easier?
NOrec: streamlining STM by abolishing ownership records
Design and implementation of a high-performance MPI for C# and the common language infrastructure
Performance analysis of parallel constraint-based local search
Scheduling support for transactional memory contention management
A wait-free universal construction for large objects
Implementing parallel and concurrent tree structures
Fast and Accurate Performance Analysis of Synchronization
Real-Time, Concurrent Checkpoint for Parallel Programs
CuLDA_CGS: solving large-scale LDA problems on GPUs
Hardware profile-guided automatic page placement for ccNUMA systems
Bundled references: an abstraction for highly-concurrent linearizable range queries
A Multi-Level Load Balancing Scheme for OR-Parallel Exhaustive Search Programs on the Multi-PSI
Multi-queues can be state-of-the-art priority schedulers
Understanding and detecting deep memory persistency bugs in NVM programs with DeepMC
Graphs & networks: computing and analytics at lincoln laboratory
An efficient uncertain graph processing framework for heterogeneous architectures
Multi-level parallel computing of reverse time migration for seismic imaging on blue Gene/Q
Leveraging parallel nesting in transactional memory
Exploiting communication concurrency on high performance computing systems
An AI-Enhanced 1km-Resolution Seamless Global Weather and Climate Model to Achieve Year-Scale Simulation Speed using 34 Million Cores
Kremlin: like gprof, but for parallelization
Strong trylocks for reader-writer locks
Provably and practically efficient granularity control
Bundling linked data structures for linearizable range queries
Sierra: a SIMD extension for C++
Advanced synchronization techniques for task-based runtime systems
Improving the Performance of Runtime Parallelization
Performance evaluation of the cray XT3 configured with dual core opteron processors
DSMR: a shared and distributed memory algorithm for single-source shortest path problem
Alert-on-update: a communication aid for shared memory multiprocessors
Breaking master-slave model between host and FPGAs
ZOID: I/O-forwarding infrastructure for petascale architectures
PREDATOR: predictive false sharing detection
A parallel sparse tensor benchmark suite on CPUs and GPUs
Triolet: a programming system that unifies algorithmic skeleton interfaces for high-performance cluster computing
vSensor: leveraging fixed-workload snippets of programs for performance variance detection
Automated test generation for OpenCL kernels using fuzzing and constraint solving
TailWAG: Tail Latency Workload Analysis and Generation
Collective communication on architectures that support simultaneous communication over multiple links
On the Implementation of Applicative Languages on Shared-Memory, MIMD Multiprocessors
Refined transactional lock elision
Are dynamic memory managers on GPUs slow?: a survey and benchmarks
I/O lower bounds for auto-tuning of convolutions in CNNs
Scaling graph traversal to 281 trillion edges with 40 million cores
Compilation for explicitly managed memory hierarchies
Extreme-scale Direct Numerical Simulation of Incompressible Turbulence on the Heterogeneous Many-core System
Non-blocking interpolation search trees with doubly-logarithmic running time
Proceedings of the 8th International Workshop on Programming Models and Applications for Multicores and Manycores, PMAM@PPoPP 2017, Austin, TX, USA, February 5, 2017
Increasing the parallelism of graph coloring via shortcutting
The Effectiveness of Task-Level Parallelism for High-Level Vision
Juggler: a dependence-aware task-based execution framework for GPUs
Practical experiences with Java software transactional memory
Accelerating Sparse Transformer Inference on GPU
Training one DeePMD Model in Minutes: a Step towards Online Learning
Revisiting shared virtual memory systems for non-coherent memory-coupled cores
RaftLib: a C++ template library for high performance stream parallel processing
DSP: Efficient GNN Training with Multiple GPUs
POSTER: Pattern-Aware Sparse Communication for Scalable Recommendation Model Training
VAIL: A Victim-Aware Cache Policy for Improving Lifetime of Hybrid Memory
Scaling out speculative execution of finite-state machines with parallel merge
Analyzing lock contention in multithreaded applications
Helios: Efficient Distributed Dynamic Graph Sampling for Online GNN Inference
Scaling implicit parallelism via dynamic control replication
Elimination (a, b)-trees with fast, durable updates
Characterizing the Synchronization Behavior of Parallel Programs
Distributed memory code generation for mixed Irregular/Regular computations
Leveraging hardware TM in Haskell
Constant-time snapshots with applications to concurrent data structures
Extreme scale computing: challenges and opportunities
WPMVP@PPoPP '20: Sixth Workshop on Programming Models for SIMD/Vector Processing lolocated with the 25th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, San Diego, CA, USA, February 22, 2020
Revocable locks for non-blocking programming
Performance evaluation of adaptive MPI
COMPSO: Optimizing Gradient Compression for Distributed Training with Second-Order Optimizers
Communication-Sensitive Heuristics and Algorithms for Mapping Compilers
Automatic data movement and computation mapping for multi-level parallel architectures with explicitly managed memories
Nonblocking persistent software transactional memory
Automated application-level checkpointing of MPI programs
FlashAttention-T: Towards Fully Tensorized Attention by Exploiting Tensor-Vector Parallelism
AUTOGEN: automatic discovery of cache-oblivious parallel recursive algorithms for solving dynamic programs
Speculative thread decomposition through empirical optimization
A scalable queue for work distribution on GPUs
Swift: Expedited Failure Recovery for Large-Scale DNN Training
Proceedings of the Second ACM SIGPLAN Symposium on Princiles & Practice of Parallel Programming (PPOPP), Seattle, Washington, USA, March 14-16, 1990
Processor-Oblivious Record and Replay
Effects of source-code optimizations on GPU performance and energy consumption
Dynamic scaling for low-precision learning
JanusQuant: Accurate and Efficient 2-bit KV Cache Quantization for Long-Context Inference
Improving Tridiagonalization Performance on GPU Architectures
Programming for parallelism and locality with hierarchically tiled arrays
Scanning Polyhedra with DO Loops
Generating Local Address and Communication Sets for Data-Parallel Programs
MCSTL: the multi-core standard template library
Effective Fine-Grain Synchronization for Automatically Parallelized Programs Using Optimistic Synchronization Primitives
Efficient data race detection of async-finish programs using vector clocks
Affinity-aware work-stealing for integrated CPU-GPU processors
Work stealing for interactive services to meet target latency