Locks, the enduring de-facto standard for synchronization in parallel programs, suffer from non-composability and are conducive to a variety of hard-to-find bugs such as data races and deadlocks. In this paper, we propose a straightforward replacement of the traditional lock-based mutex with the Guard, a construct providing mutual exclusion through efficient, dynamic serialization of tasks in a dynamic task graph. Unlike with locks, programming with Guards is lock-free, composable, and immune to deadlock. Guards are compatible with arbitrary executor services, and can be implemented on any platform which supports atomic variables and compare-and-set operations. We will describe the general construction and API for Guards, introduce our reference implementation, and analyze through various benchmarks the performance of our reference implementation against the standard ReentrantLock class used in Java. The practice of writing multithreaded code will benefit from the safety, ease of use, and performance of Guards.

Abstract Teaching C ++ programming to noncomputer science majors comes with the burden of setting up an integrated development environment, a struggle for most students. Therefore, we present the open source tool, C ++ Explorer, a JupyterHub deployment for interactively developing C ++ code. Students can connect to the server without installing anything, and, almost instantly, they can begin to engage with code using the notebooks. Another aspect of code development is remote communication with coworkers or the community. To develop this skill, we use GitHub classroom to provide feedback on the assignments and practice remote communication. C ++ Explorer was used in the fall of 2019 and 2020 to teach parallel computation to mathematics students. At the end of the class, we gather students' feedback. This data will be used to continue improving the course. In addition, we present a Telegram ® bot for the communication with the server using smart phones or tablets. However, this tool was not used in the course and will be explored in future teaching.

Understanding the behavior of software in execution is a key step in identifying and fixing performance issues. This is especially important in high performance computing contexts where even minor performance tweaks can translate into large savings in terms of computational resource use. To aid performance analysis, developers may collect an execution trace-a chronological log of program activity during execution. As traces represent the full history, developers can discover a wide array of possibly previously unknown performance issues, making them an important artifact for exploratory performance analysis. However, interactive trace visualization is difficult due to issues of data size and complexity of meaning. Traces represent nanosecond-level events across many parallel processes, meaning the collected data is often large and difficult to explore. The rise of asynchronous task parallel programming paradigms complicates the relation between events and their probable cause. To address these challenges, we conduct a continuing design study in collaboration with high performance computing researchers. We develop diverse and hierarchical ways to navigate and represent execution trace data in support of their trace analysis tasks. Through an iterative design process, we developed Traveler, an integrated visualization platform for task parallel traces. Traveler provides multiple linked interfaces to help navigate trace data from multiple contexts. We evaluate the utility of Traveler through feedback from users and a case study, finding that integrating multiple modes of navigation in our design supported performance analysis tasks and led to the discovery of previously unknown behavior in a distributed array library.

We propose a scalable, cycle-collecting, decentralized, reference counting garbage collector with partial tracing. The algorithm is based on the Brownbridge system but uses four different types of references to label edges. Memory usage is O (log n) bits per node, where n is the number of nodes in the graph. The algorithm assumes an asynchronous network model with a reliable reordering channel. It collects garbage in O (E a ) time, where E a is the number of edges in the in- duced subgraph. The algorithm uses termination detection to manage the distributed computation, a unique identifier to break the symmetry among multiple collectors, and a transaction-based approach when multiple collectors conflict. Unlike existing algorithms, ours is not centralized, does not require barriers, does not require migration of nodes, does not require back-pointers on every edge, and is stable against concurrent mutation.

This paper presents a new concurrent garbage collection algorithm based on two types of reference, strong and weak, to link the graph of objects. Strong references connect the roots to all the nodes in the graph but do not contain cycles. Weak references may, however, contain cycles.

We present CaCUDA - a GPGPU kernel abstraction and a parallel programming framework for developing highly efficient large scale scientific applications using stencil computations on hybrid CPU/GPU architectures. CaCUDA is built upon the Cactus computational toolkit, an open source problem solving environment designed for scientists and engineers. Due to the flexibility and extensibility of the Cactus toolkit, the addition of a GPGPU programming framework required no changes to the Cactus infrastructure, guaranteeing that existing features and modules will continue to work without modification. CaCUDA was tested and benchmarked using a 3D CFD code based on a finite difference discretization of Navier-Stokes equations.