yusuke1997/dblp-id-title huggingface dataset:
An ownership policy and deadlock detector for promises
FlashSparse: Minimizing Computation Redundancy for Fast Sparse Matrix Multiplications on Tensor Cores
Data Flow Equations for Explicitly Parallel Programs
Reduction to Band Form for the Singular Value Decomposition on Graphics Accelerators
The problem-based benchmark suite (PBBS), V2
A high-performance portable abstract interface for explicit SIMD vectorization
Using Data Partitioning to Implement a Parallel Assembler
Morph algorithms on GPUs
GLB: lifeline-based global load balancing library in x10
Programming the FlexRAM parallel intelligent memory system
Locality aware dynamic load management for massively multiplayer games
Performance modeling and optimization of parallel out-of-core tensor contractions
Visibility Algorithms for Dynamic Dependence Analysis and Distributed Coherence
A Holistic Approach to Automatic Mixed-Precision Code Generation and Tuning for Affine Programs
Proceedings of the 23rd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPoPP 2018, Vienna, Austria, February 24-28, 2018
MatRox: modular approach for improving data locality in hierarchical (Mat)rix App(Rox)imation
Software transactional memory for large scale clusters
Programming the memory hierarchy revisited: supporting irregular parallelism in sequoia
Waste-Efficient Work Stealing
Tiling Framework for Heterogeneous Computing of Matrix based Tiled Algorithms
ConvStencil: Transform Stencil Computation to Matrix Multiplication on Tensor Cores
PIM-zd-tree: A Fast Space-Partitioning Index Leveraging Processing-in-Memory
Revisiting linpack algorithm on large-scale CPU-GPU heterogeneous systems
Parallelizing a discrete event simulation application using the Habanero-Java multicore library
Concurrent GC leveraging transactional memory
DAPPLE: a pipelined data parallel approach for training large models
GraphCube: Interconnection Hierarchy-aware Graph Processing
Achieving a single compute device image in OpenCL for multiple GPUs
Data transformations enabling loop vectorization on multithreaded data parallel architectures
Automatic mapping of nested loops to FPGAS
Gunrock: a high-performance graph processing library on the GPU
EGEMM-TC: accelerating scientific computing on tensor cores with extended precision
The performance power of software combining in persistence
All-window profiling of concurrent executions
Faster topology-aware collective algorithms through non-minimal communication
TAC: Cache-Based System for Accelerating Billion-Scale GNN Training on Multi-GPU Platform
TurboFFT: Co-Designed High-Performance and Fault-Tolerant Fast Fourier Transform on GPUs
A performance evaluation of open source graph databases
Heterogeneous computing: what does it mean for compiler research?
Block-STM: Scaling Blockchain Execution by Turning Ordering Curse to a Performance Blessing
Scaling model checking of dataraces using dynamic information
A pattern-supported parallelization approach
Benchmarking weak memory models
Beyond human-level accuracy: computational challenges in deep learning
Enhancing Metaheuristic-based Virtual Screening Methods on Massively Parallel and Heterogeneous Systems
POSTER: State Teleportation via Hardware Transactional Memory
Writing scalable SIMD programs with ISPC
Massive parallel LDPC decoding on GPU
A W-cycle algorithm for efficient batched SVD on GPUs
DORADD: Deterministic Parallel Execution in the Era of Microsecond-Scale Computing
Architectural support for cilk computations on many-core architectures
Compiler-enhanced incremental checkpointing for OpenMP applications
Does cache sharing on modern CMP matter to the performance of contemporary multithreaded programs?
Layout Lock: A Scalable Locking Paradigm for Concurrent Data Layout Modifications
Scaling Up Transactions with Slower Clocks
Work-stealing with configurable scheduling strategies
Distributed merge trees
Compile/Run-Time Support for Threaded MPI Execution on Multiprogrammed Shared Memory Machines
GPU centric extensions for parallel strongly connected components computation
Modeling transactional memory workload performance
Accelerating GNNs on GPU Sparse Tensor Cores through N: M Sparsity-Oriented Graph Reordering
Pointer and escape analysis for multithreaded programs
Language support for Morton-order matrices
Pure: Evolving Message Passing To Better Leverage Shared Memory Within Nodes
In-situ workflow auto-tuning through combining component models
Automatic differentiation of parallel loops with formal methods
The Parallel Decomposition and Implementation of an Integrated Circuit Global Router
Parallel computing in 2010: opportunities and challenges in a networked world (abstract)
Creating repeatable, reusable experimentation pipelines with popper: tutorial
SBMGT: Scaling Bayesian Multinomial Group Testing
Automatic multithreading and multiprocessing of C programs for IXP
On the correctness of transactional memory
Parallel Algorithms for Image Histogramming and Connected Components with an Experimental Study (Extended Abstract)
Gecko: Hierarchical Distributed View of Heterogeneous Shared Memory Architectures
CUDA-NP: realizing nested thread-level parallelism in GPGPU applications
Ikra-Cpp: A C++/CUDA DSL for Object-Oriented Programming with Structure-of-Arrays Layout
Vectorizing Unstructured Mesh Computations for Many-core Architectures
High-Throughput GPU Random Walk with Fine-Tuned Concurrent Query Processing
Proceedings of the 16th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPOPP 2011, San Antonio, TX, USA, February 12-16, 2011
Unveiling kernel concurrency in multiresolution filters on GPUs with an image processing DSL
Parallel time-space processing model based fast N -body simulation on GPUs
Trojan Horse: Aggregate-and-Batch for Scaling Up Sparse Direct Solvers on GPU Clusters
Benchmarking Apache Arrow Flight - A wire-speed protocol for data transfer, querying and microservices
Effective performance measurement and analysis of multithreaded applications
Turbocharging boosted transactions or: how i learnt to stop worrying and love longer transactions
Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPOPP 2005, June 15-17, 2005, Chicago, IL, USA
Groute: An Asynchronous Multi-GPU Programming Model for Irregular Computations
Gallatin: A General-Purpose GPU Memory Manager
Layrub: layer-centric GPU memory reuse and data migration in extreme-scale deep learning systems
Adaptive execution techniques for SMT multiprocessor architectures
Lock contention aware thread migrations
High performance GPU concurrent B+tree
Performance portable C++ programming with RAJA
A component architecture for LAM/MPI
A portable runtime interface for multi-level memory hierarchies
A new SIMD iterative connected component labeling algorithm
waveSZ: a hardware-algorithm co-design of efficient lossy compression for scientific data
An Evaluation of Vectorization and Cache Reuse Tradeoffs on Modern CPUs
High performance distributed deep learning: a beginner's guide
Space-Time Memory: A Parallel Programming Abstraction for Interactive Multimedia Applications
A framework for practical parallel fast matrix multiplication
Balanced Allocations over Efficient Queues: A Fast Relaxed FIFO Queue
Techniques for the parallelization of unstructured grid applications on multi-GPU systems
An overview of CMPI: network performance aware MPI in the cloud
On group mutual exclusion for dynamic systems
TensorMD: Molecular Dynamics Simulation with Ab Initio Accuracy of 50 Billion Atoms
AC-Cache: A Memory-Efficient Caching System for Small Objects via Exploiting Access Correlations
Parallel programming with big operators
A New Generation of Task-Parallel Algorithms for Matrix Inversion in Many-Threaded CPUs
Efficient memory management of a hierarchical and a hybrid main memory for MN-MATE platform
A framework for adaptive algorithm selection in STAPL
EffiSha: A Software Framework for Enabling Effficient Preemptive Scheduling of GPU
Reduction Operations in Parallel Loops for GPGPUs
Deciphering Predictive Schedulers for Heterogeneous-ISA Multicore Architectures
Methods of inference and learning for performance modeling of parallel applications
Hybrid dynamic data race detection
DFOGraph: an I/O- and communication-efficient system for distributed fully-out-of-core graph processing
A study of tracing overhead on a high-performance linux cluster
Merge-based sparse matrix-vector multiplication (SpMV) using the CSR storage format
Reciprocating Locks
Enhanced speculative parallelization via incremental recovery
Parallel suffix array and least common prefix for the GPU
Internally deterministic parallel algorithms can be fast
Programming support for reconfigurable custom vector architectures
PerFlow: a domain specific framework for automatic performance analysis of parallel applications
A compiler infrastructure for embedded heterogeneous MPSoCs
SIMD code generation for stencils on brick decompositions
A Framework for Multiplatform HPC Applications
Popcorn: Accelerating Kernel K-means on GPUs through Sparse Linear Algebra
Using fine grain multithreading for energy efficient computing
Sparta: high-performance, element-wise sparse tensor contraction on heterogeneous memory
Accelerating CUDA graph algorithms at maximum warp
Proceedings of the 24th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPoPP 2019, Washington, DC, USA, February 16-20, 2019
Mobile MPI programs in computational grids
Asymmetry-aware scalable locking
ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPoPP '14, Orlando, FL, USA, February 15-19, 2014
MARLIN: Mixed-Precision Auto-Regressive Parallel Inference on Large Language Models
Procs and Locks: A Portable Multiprocessing Platform for Standard ML of New Jersey
A theory of memory models
Helium: a transparent inter-kernel optimizer for OpenCL
Compactly representing parallel program executions
Scalable communication protocols for dynamic sparse data exchange
Performance without pain = productivity: data layout and collective communication in UPC
High-Performance Filters for GPUs
21st century computer architecture
Self-adjusting task granularity for Global load balancer library on clusters of many-core processors
PANNS: Enhancing Graph-based Approximate Nearest Neighbor Search through Recency-aware Construction and Parameterized Search
Support for data parallelism in the CAL actor language
Automatic Node Selection for High Performance Applications on Networks
POSTER: Reuse, don't Recycle: Transforming Algorithms that Throw Away Descriptors
Revisiting the combining synchronization technique
Parallel programming in modern web search engines
Vectorization of a spectral finite-element numerical kernel
High-level hardware feature extraction for GPU performance prediction of stencils
Applying the concurrent collections programming model to asynchronous parallel dense linear algebra
Applications Experience with Linda
Efficient nonblocking software transactional memory
A comparative investigation of device-specific mechanisms for exploiting HPC accelerators
Using Scheduler Information to Achieve Optimal Barrier Synchronization Performance
Incremental flattening for nested data parallelism
Scalable synchronous queues
Techniques for efficient placement of synchronization primitives
Overcoming the difficulty of large-scale CGH generation on multi-GPU cluster
A Novel CPU-GPU Cooperative Implementation of A Parallel Two-List Algorithm for the Subset-Sum Problem
Comparing the performance of different x86 SIMD instruction sets for a medical imaging application on modern multi- and manycore chips
Wait-free linked-lists
Towards Scalable Unstructured Mesh Computations on Shared Memory Many-Cores
A fast work-efficient SSSP algorithm for GPUs
An evaluation of global address space languages: co-array fortran and unified parallel C
The lazy happens-before relation: better partial-order reduction for systematic concurrency testing
Peer to peer and distributed computing (abstract)
Programming with hardware lock elision
MaxPair: Enhance OpenCL Concurrent Kernel Execution by Weighted Maximum Matching
LB-HM: load balance-aware data placement on heterogeneous memory for task-parallel HPC applications
An Approach to Ordering Optimizing Transformations
Compiling Dynamic Mappings with Array Copies
Building parallel programming language constructs in the AbleC extensible C compiler framework: a PPoPP tutorial
Hardening selective protection across multiple program inputs for HPC applications
Petascale computing with accelerators
A Unified Framework for Systemic Loop Transformation
Parallelism vs. speculation: exploiting speculative genetic algorithm on GPU
Proceedings of the 12th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPOPP 2007, San Jose, California, USA, March 14-17, 2007
Performance implications of dynamic memory allocators on transactional memory systems
Symbolically modeling concurrent MCAPI executions
Modeling optimization of stencil computations via domain-level properties
Optimistic transactional boosting
Proceedings of the 2001 ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPOPP'01), Snowbird, Utah, USA, June 18-20, 2001
Transitive joins: a sound and efficient online deadlock-avoidance policy
Towards a portable hierarchical view of distributed shared memory systems: challenges and solutions
Verification of MPI Java programs using software model checking
Proceedings of the 2nd International Workshop on Extreme Heterogeneity Solutions, ExHET 2023, Montreal, QC, Canada, 25 February 2023
ElasGNN: An Elastic Training Framework for Distributed GNN Training
StackThreads/MP: Integrating Futures into Calling Standards
A Methodology for Implementing Highly Concurrent Data Structures
Scalable parallel minimum spanning forest computation
Optimizing GPU programs by register demotion: poster
Efficient utilization of GPGPU cache hierarchy
Brie: A Specialized Trie for Concurrent Datalog
CPHASH: a cache-partitioned hash table
Fast and transparent recovery for continuous availability of cluster-based servers
Efficient deterministic multithreading without global barriers
Optimizing Communication in HPF programs for Fine-Grain Distributed Shared Memory
POSTER: Accelerating High-Precision Integer Multiplication used in Cryptosystems with GPUs
Lock-free transactional vector
Parallel schedule synthesis for attribute grammars
Load balanced clustering coefficients
Binary Compatible Critical Section Delegation
NUMA-aware reader-writer locks
A comprehensive strategy for contention management in software transactional memory
High performance model based image reconstruction
Transactional programming in a multi-core environment
Teaching parallel computing to science faculty: best practices and common pitfalls
Dynamic N: M Fine-Grained Structured Sparse Attention Mechanism
Generating Fast FFT Kernels on CPUs via FFT-Specific Intrinsics
Beyond parallel programming with domain specific languages
Zero-Overhead Parallel Scans for Multi-Core CPUs
Reference idempotency analysis: a framework for optimizing speculative execution
GPGPU@PPoPP '20: 13th Annual Workshop on General Purpose Processing using Graphics Processing Unit colocated with 25th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, San Diego, California, USA, February 23, 2020
Parallel Breadth-First BDD Construction
Extending the limit of molecular dynamics with ab initio accuracy to 10 billion atoms
Evaluating the Locality Benefits of Active Messages
Efficient deadlock avoidance for streaming computation with filtering
BDDT: : block-level dynamic dependence analysis for deterministic task-based parallelism
Simple, Accurate, Analytical Time Modeling and Optimal Tile Size Selection for GPGPU Stencils
Optimizing consistency for partially replicated data stores
GPGPU@PPoPP 2022: Proceedings of the 14th Workshop on General Purpose Processing Using GPU, Virtual Event, Seoul, Republic of Korea, 3 April 2022
Rethinking the parallelization of random-restart hill climbing: a case study in optimizing a 2-opt TSP solver for GPU execution
Extracting clean performance models from tainted programs
JParEnt: Parallel Entropy Decoding for JPEG Decompression on Heterogeneous Multicore Architectures
Non-Intrusive and Interactive Profiling in Parasight
Implementing directed acyclic graphs with the heterogeneous system architecture
Contention in Structured Concurrency: Provably Efficient Dynamic Non-Zero Indicators for Nested Parallelism
High-speed graph analytics with the galois system
Generating energy-efficient code for parallel applications specified by streaming task graphs with dynamic elements
Compiling C* Programs for a Hypercube Multicomputer
On optimizing machine learning workloads via kernel fusion
An emerging co-array fortran compiler
Sharded Elimination and Combining for Highly-Efficient Concurrent Stacks
APERTURE: Algorithm-System Co-optimization for Temporal Graph Network Inference
Runtime elision of transactional barriers for captured memory
SuperMatrix: a multithreaded runtime scheduling system for algorithms-by-blocks
Performance portable GPU code generation for matrix multiplication
Detecting silent data corruption through data dynamic monitoring for scientific applications
TL4x: Buffered Durable Transactions on Disk as Fast as in Memory
CSX: an extended compression format for spmv on shared memory systems
Race Frontier: Reproducing Data Races in Parallel-Program Debugging
Time-warp: lightweight abort minimization in transactional memory
POSTER: Poor Man's URCU
Supporting multiple accelerators in high-level programming models
ScalaExtrap: trace-based communication extrapolation for spmd programs
Pagoda: Fine-Grained GPU Resource Virtualization for Narrow Tasks
Fast Kronecker Matrix-Matrix Multiplication on GPUs
Efficient distributed workstealing via matchmaking
A hybrid approach of OpenMP for clusters
Lightweight preemptive user-level threads
GStream: a graph streaming processing method for large-scale graphs on GPUs
Automatic formal verification of MPI-based parallel programs
Efficient Convex Optimization on GPUs for Embedded Model Predictive Control
Proceedings of the 2014 Workshop on Programming models for SIMD/Vector processing, WPMVP 2014, Orlando, Florida, USA, February 16, 2014
DiggerBees: Depth First Search Leveraging Hierarchical Block-Level Stealing on GPUs
Proceedings of the 5th International Workshop on Benchmarking in the Data Center, BID@PPoPP 2023, Montreal, QC, Canada, 25 February 2023
POSTER: RELAX: Durable Data Structures with Swift Recovery
ELDA: LDA made efficient via algorithm-system codesign submission
In-place transposition of rectangular matrices on accelerators
Grammar-aware Parallelization for Scalable XPath Querying
Kokkos Array performance-portable manycore programming model
HPVM: heterogeneous parallel virtual machine
SLAW: a scalable locality-aware adaptive work-stealing scheduler for multi-core systems
Effect of portable fine-grained locality on energy efficiency and performance in concurrent search trees
Discovering Pipeline Parallel Patterns in Sequential Legacy C++ Codes
Speculations: providing fault-tolerance and improving performance of parallel applications
Combining phase identification and statistic modeling for automated parallel benchmark generation
Tight analysis of the performance potential of thread speculation using spec CPU 2006
Unexpected Scaling in Path Copying Trees
Experiences with Poker
Optimization of asynchronous graph processing on GPU with hybrid coloring model
MetaAttention: A Unified and Performant Attention Framework across Hardware Backends
A Programming Model for GPU Load Balancing
A domain-specific approach to heterogeneous parallelism
Resilient X10: efficient failure-aware programming
Efficient parallel determinacy race detection for two-dimensional dags
StreamScan: fast scan algorithms for GPUs without global barrier synchronization
Proceedings of the 15th International Workshop on Programming Models and Applications for Multicores and Manycores, PMAM 2024, Edinburgh, United Kingdom, 3 March 2024
Generating High Performance GPU Code using Rewrite Rules with Lift
Oversubscribed Command Queues in GPUs
Exploiting Operating System Support for Dynamic Page Placement on a NUMA Shared Memory Multiprocessor
Lazy binary-splitting: a run-time adaptive work-stealing scheduler
OpenMP-style parallelism in data-centered multicore computing with R
Barrier matching for programs with textually unaligned barriers
Optimizing data aggregation for cluster-based internet services
ChituDiffusion: A Data-Characteristic-Aware Serving System for Diffusion Models
A tool for top-down performance analysis of GPU-accelerated applications
How to speed Connected Component Labeling up with SIMD RLE algorithms
May-happen-in-parallel analysis of X10 programs
An Equational Language for Data-Parallelism
Nesting and composition in transactional data structure libraries
PLUM: static parallel program locality analysis under uniform multiplexing
Proceedings of the 14th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPOPP 2009, Raleigh, NC, USA, February 14-18, 2009
Exploiting Fine-Grained Redundancy in Set-Centric Graph Pattern Mining
Isoefficiency in Practice: Configuring and Understanding the Performance of Task-based Applications
Fast Longest Common Subsequence with General Integer Scoring Support on GPUs
CUDAlign: using GPU to accelerate the comparison of megabase genomic sequences
An infrastructure for dynamic optimization of parallel programs
BaGuaLu: targeting brain scale pretrained models with over 37 million cores
Adapting the polyhedral model as a framework for efficient speculative parallelization
Scalable parallel debugging with statistical assertions
Evaluation of Predicated Array Data-Flow Analysis for Automatic Parallelization
Fairer and More Scalable Reader-Writer Locks by Optimizing Queue Management
Understanding a program's resiliency through error propagation
Transactional Data Structures with Orthogonal Metadata
Neighbor-list-free molecular dynamics on sunway TaihuLight supercomputer
11th Workshop on General Purpose Processing using GPUs, GPGPU@PPoPP 2018, February 25, 2018, Vosendorf (Vienna), Austria
Exploring deep reuse in winograd CNN inference
A collection-oriented programming model for performance portability
Parallel type-checking with haskell using saturating LVars and stream generators
Adaptive structured parallelism for computational grids
Transforming High-Level Data-Parallel Programs into Vector Operations
Shared work list: hacking amorphous data parallelism in UPC
High performance spatial data mining for very large data-sets
An Array Operation Synthesis Scheme to Optimize Fortran 90 Programs
Performance Implications of Communication Mechanisms in All-Software Global Address Space Systems
Effectively Virtual Page Prefetching via Spatial-Temporal Patterns for Memory-intensive Cloud Applications
Automatic Placement of Communications in Mesh-Partitioning Parallelization
Reducing False Sharing on Shared Memory Multiprocessors through Compile Time Data Transformations
Programming Techniques for Efficiently Exploiting Parallelism in Logic Programming Languages
Scheduling directives for shared-memory many-core processor systems
Automatic synthesis of parallel unix commands and pipelines with KumQuat
Ligra: a lightweight graph processing framework for shared memory
SCOOP It up!
Static analysis of atomicity for programs with non-blocking synchronization
The Process Trellis Architectur for Real-Time Monitors
yaSpMV: yet another SpMV framework on GPUs
An Efficient Implementation of Java's Remote Method Invocation
The tasks with effects model for safe concurrency
Empirical measurement of instruction level parallelism for four generations of ARM CPUs
Probabilistic advanced reservations for batch-scheduled parallel machines
Engineering a high-performance GPU B-Tree
Understanding and bridging the gaps in current GNN performance optimizations
Lock cohorting: a general technique for designing NUMA locks
Teleport messaging for distributed stream programs
Efficient search for inputs causing high floating-point errors
The Evolution of HPC/VORX
Toward efficient architecture-independent algorithms for dynamic programs: poster