More Like this

1. Work-efficient parallel union-find: Work-efficient parallel union-find

   https://doi.org/10.1002/cpe.4333  

   Simsiri, Natcha; Tangwongsan, Kanat; Tirthapura, Srikanta; Wu, Kun-Lung (February 2018, Concurrency and Computation: Practice and Experience)
2. Parallel Automata Processor

   https://doi.org/10.1145/3140659.3080207  

   Subramaniyan, Arun; Das, Reetuparna (September 2017, ACM SIGARCH Computer Architecture News)
3. Parallel Assisted Learning

   https://doi.org/10.1109/TSP.2022.3229637  

   Wang, Xinran; Zhang, Jiawei; Hong, Mingyi; Yang, Yuhong; Ding, Jie (January 2022, IEEE Transactions on Signal Processing)
4. Democratizing Parallel Filesystem Monitoring

   https://doi.org/10.1109/CLUSTER49012.2020.00065  

   Evans, Richard Todd (November 2020, 2020 IEEE International Conference on Cluster Computing (CLUSTER))

   null (Ed.)

   Parallel filesystems (PFSs) are one of the most critical high-availability components of High Performance Computing (HPC) systems. Most HPC workloads are dependent on the availability of a POSIX compliant parallel filesystem that provides a globally consistent view of data to all compute nodes of a HPC system. Because of this central role, failure or performance degradation events in the PFS can impact every user of a HPC resource. There is typically insufficient information available to users and even many HPC staff to identify the causes of these PFS events, impeding the implementation of timely and targeted remedies to PFS issues. The relevant information is distributed across PFS servers; however, access to these servers is highly restricted due to the sensitive role they play in the operations of a HPC system. Additionally, the information is challenging to aggregate and interpret, relegating diagnosis and treatment of PFS issues to a select few experts with privileged system access. To democratize this information, we are developing an open-source and user-facing Parallel FileSystem TRacing and Analysis SErvice (PFSTRASE) that analyzes the requisite data to establish causal relationships between PFS activity and events detrimental to stability and performance. We are implementing the service for the open-source Lustre filesystem, which is the most commonly used PFS at large-scale HPC sites. Server loads for specific PFS I/O operations (IOPs) will be measured and aggregated by the service to automatically estimate an effective load generated by every client, job, and user. The infrastructure provides a realtime, user accessible text-based interface and a publicly accessible web interface displaying both real-time and historical data. To democratize this information, we are developing an open-source and user-facing Parallel FileSystem TRacing and Analysis SErvice (PFSTRASE) that analyzes the requisite data to establish causal relationships between PFS activity and events detrimental to stability and performance. We are implementing the service for the open-source Lustre filesystem, which is the most commonly used PFS at large-scale HPC sites. Server loads for specific PFS I/O operations (IOPs) will be measured and aggregated by the service to automatically estimate an effective load generated by every client, job, and user. The infrastructure provides a realtime, user accessible text-based interface and a publicly accessible web interface displaying both real-time and historical data. 

   more » « less
5. Parallel block-delayed sequences

   https://doi.org/10.1145/3503221.3508434  

   Westrick, Sam; Rainey, Mike; Anderson, Daniel; Blelloch, Guy E. (March 2022, ACM Symposium on Principles and Practice of Parallel Programming)

   Jaejin Lee, Kunal Agrawal (Ed.)

   Programming languages using functions on collections of values, such as map, reduce, scan and filter, have been used for over fifty years. Such collections have proven to be particularly useful in the context of parallelism because such functions are naturally parallel. However, if implemented naively they lead to the generation of temporary intermediate collections that can significantly increase memory usage and runtime. To avoid this pitfall, many approaches use "fusion" to combine operations and avoid temporary results. However, most of these approaches involve significant changes to a compiler and are limited to a small set of functions, such as maps and reduces. In this paper we present a library-based approach that fuses widely used operations such as scans, filters, and flattens. In conjunction with existing techniques, this covers most of the common operations on collections. Our approach is based on a novel technique which parallelizes over blocks, with streams within each block. We demonstrate the approach by implementing libraries targeting multicore parallelism in two languages: Parallel ML and C++, which have very different semantics and compilers. To help users understand when to use the approach, we define a cost semantics that indicates when fusion occurs and how it reduces memory allocations. We present experimental results for a dozen benchmarks that demonstrate significant reductions in both time and space. In most cases the approach generates code that is near optimal for the machines it is running on. 

   more » « less