Current Programming Models Research Articles

RenderKernel: High-level programming for real-time rendering systems

Real-time rendering applications leverage heterogeneous computing to optimize performance. However, software development across multiple devices presents challenges, including data layout inconsistencies, synchronization issues, resource management complexities, and architectural disparities. Additionally, the creation of such systems requires verbose and unsafe programming models. Recent developments in domain-specific and unified shading languages aim to mitigate these issues. Yet, current programming models primarily address data layout consistency, neglecting other persistent challenges.In this paper, we introduce RenderKernel, a programming model designed to simplify the development of real-time rendering systems. Recognizing the need for a high-level approach, RenderKernel addresses the specific challenges of real-time rendering, enabling development on heterogeneous systems as if they were homogeneous. This model allows for early detection and prevention of errors due to system heterogeneity at compile-time. Furthermore, RenderKernel enables the use of common programming patterns from homogeneous environments, freeing developers from the complexities of underlying heterogeneous systems. Developers can focus on coding unique application features, thereby enhancing productivity and reducing the cognitive load associated with real-time rendering system development.

Application of performance portability solutions for GPUs and many-core CPUs to track reconstruction kernels

Next generation High-Energy Physics (HEP) experiments are presented with significant computational challenges, both in terms of data volume and processing power. Using compute accelerators, such as GPUs, is one of the promising ways to provide the necessary computational power to meet the challenge. The current programming models for compute accelerators often involve using architecture-specific programming languages promoted by the hardware vendors and hence limit the set of platforms that the code can run on. Developing software with platform restrictions is especially unfeasible for HEP communities as it takes significant effort to convert typical HEP algorithms into ones that are efficient for compute accelerators. Multiple performance portability solutions have recently emerged and provide an alternative path for using compute accelerators, which allow the code to be executed on hardware from different vendors. We apply several portability solutions, such as Kokkos, SYCL, C++17 std::execution::par, Alpaka, and OpenMP/OpenACC, on two mini-apps extracted from the mkFit project: p2z and p2r. These apps include basic kernels for a Kalman filter track fit, such as propagation and update of track parameters, for detectors at a fixed z or fixed r position, respectively. The two mini-apps explore different memory layout formats. We report on the development experience with different portability solutions, as well as their performance on GPUs and many-core CPUs, measured as the throughput of the kernels from different GPU and CPU vendors such as NVIDIA, AMD and Intel.

Robust multiobjective reservoir operation and risk decision-making model for real-time flood control coping with forecast uncertainty

Forecast uncertainty in real-time flood forecasting is the primary source of risk regarding reservoir flood control operation, affecting both reliability and safety of the entire system. Informing reservoir operation for real-time flood control coping with forecast uncertainty encourages overall robust control of risk probability, vulnerability, and resilience of upstream and downstream protection areas. Current stochastic programming models or chance constrained programming models (CCP) focuses on reducing either risk loss or vulnerability, thereby failing to ensure systematic control. This study established a robust multiobjective operation and risk decision-making model to inform reservoir operations. The proposed model includes three modules. First, a copula function was applied to capture multidimensional temporal dependences of forecast uncertainties, following which stochastic inflow scenarios were generated. Second, a robust multiobjective optimization (RMOO) model was established with the objectives of minimizing the probability of risk events, Conditional Value-at-Risk of risk loss (vulnerability) and the maximum sequential duration for both upstream and downstream areas. Then, an adaptive reference multiobjective evolutionary algorithm was used to solve the model and obtain noninferior solutions. Finally, the TOPSIS multicriteria decision-making method was introduced to select the compromise solution. Methodologies were verified by application to Xianghongdian reservoir, China. The main findings were as follows. (1) The copula function effectively captured the multidimensional positive temporal dependences of forecast uncertainties. (2) RMOO provided more widely distributed noninferior solutions than CCP, and performed better in lowering vulnerability of the system. (3) RMOO reduced the maximum release by 135.6 m3/s (7.33%) by increasing prerelease before the occurrence of flood peak. The proposed methodologies provide insights for supporting robust control of real-time operations of a reservoir system through simultaneous control of flood risk probability, vulnerability, and resilience.

Two-stage stochastic optimization frameworks to aid in decision-making under uncertainty for variable resource generators participating in a sequential energy market

Decisions for a variable renewable resource generator’s commitment in the energy market are typically made in advance when little information is obtainable about wind availability and market prices. Much research has been published recommending various frameworks for addressing this issue. However, these frameworks are limited as they do not consider all markets a producer can participate in. Moreover, current stochastic programming models do not allow for uncertainty data to be updated as more accurate information becomes available. This work proposes two decision-making frameworks for a wind energy generator participating in day-ahead, intraday, reserve, and balancing markets. The first framework is a two-stage stochastic convex optimization approach, where both scenario-independent and scenario-dependent decisions are made concurrently. The second framework is a series of four two-stage stochastic optimization models wherein the results from each model feed into each subsequent model allowing for scenarios to be updated as more information becomes available to the decision-maker. In the simulation experiments, the multi-phase framework performs better than the single-phase in every run, and results in an average profit increase of 7%. The proposed optimization frameworks aid in better decision-making while addressing uncertainty related to variable resource generators and maximize the return on investment.

Protocols Over Things: A Decentralized Programming Model for the Internet of Things

Current programming models for developing Internet of Things (IoT) applications are logically centralized and ill-suited for most IoT applications. We contribute Protocols over Things, a decentralized programming model that represents an IoT application via a protocol between the parties involved and provides improved performance over network-level delivery guarantees.

CScript: A distributed programming language for building mixed-consistency applications

Current programming models only provide abstractions for sharing data under a homogeneous consistency model. It is, however, not uncommon for a distributed application to provide strong consistency for one part of the shared data and eventual consistency for another part. Because mixing consistency models is not supported by current programming models, writing such applications is extremely difficult. In this paper we propose CScript, a distributed object-oriented programming language with built-in support for data replication. At its core are consistent and available replicated objects. CScript regulates the interactions between these objects to avoid subtle inconsistencies that arise when mixing consistency models. Our evaluation compares a collaborative text editor built atop CScript with a state-of-the-art implementation. The results show that our approach is flexible and more memory efficient.

Community food assistance, informal social networks, and the labor of care

In 2016, the Atlanta Community Food Bank (ACFB) launched the Stabilizing Lives project to develop programs and policies that could better address clients’ needs as well as including clientele as part of the planning process. The ACFB partnered with a research team at the University of Georgia to conduct a participatory research project aimed at developing deeper insights into the factors contributing to both instability and stability in the lives of pantry clientele. This article describes the outcomes this research, offering both a substantive contribution to scholarship on food insecurity and emergency food systems and a methodological innovation through a staged mixed-method participatory research project. Through use of a culture-centered approach, this project created discursive spaces within which to outline emergency food models that support informal networks of care. We used a range of methods, including photo elicitation, concept mapping, individual interviews, and focus groups, to facilitate conversation among agency staff, volunteers, and clientele about the effectiveness of current program models and potential new ideas. Specifically, we suggest that through such practices, food pantries and local agencies may help inform new program models that contribute to household stability, and push back against the sometimes alienating and atomizing paradigm found in current emergency food programs.

Sustainable supplier selection and order allocation: A novel multi-objective programming model with a hybrid solution approach

Sustainable supplier selection is the process of identifying the appropriate supply partners of an organization with the most beneficial monetary value, while diminishing the various effects of its operations on society and environment. Therefore, it plays a significant role in moving an organization toward sustainable development. Alongside sustainable supplier selection, assigning proper quantity of orders to suppliers satisfying sustainability criteria is another activity that should be simultaneously carried out in order to develop a comprehensive tool in sustainable supplier management. Meanwhile, the issue of sustainable supplier selection and order allocation has attracted limited attention in the literature. The present paper aims at developing an inclusive multi-objective mixed integer linear programming model, which accounts for multiple periods, multiple products and multimodal transportation, to evaluate suppliers and allocate order quantities. Furthermore, the developed model that includes all sustainability aspects also takes both shortage and discount conditions into account. A hybrid three-step solution methodology is then presented, using which the original multi-objective problem is firstly converted to a single objective model by ε-constraint method. In the second step, the current single objective programming model is solved using the Benders decomposition algorithm that in turn is accelerated by a variety of algorithmic enhancements. Finally, among all the Pareto optimal solutions of the original multi-objective programming problem, the preferable solution is intelligently selected based on the DEA super efficiency score of all purchasing firms as a decision support tool. The applicability of the proposed approach is illustrated by a real-world case study in automotive industry.

Osmotic computing as a distributed multi-agent system: The Body Area Network scenario

Nowadays, the latest technological advancements have changed the centralized Cloud Computing model, going through Edge and Internet of Things (IoT), which are closer to end users. In particular, current Cloud Computing programming models deal with the recent evolution of the IoT phenomenon because smart devices are becoming more and more pervasive, powerful and inexpensive. Therefore, services need to be placed near such devices and resource orchestration techniques need to be redesigned. In this regard, Osmotic Computing aims at providing a new computing paradigm based on the deployment and migration strategies related to the infrastructures and applications requirements across Cloud, Edge, and IoT layers. The objective of this scientific work is to propose an Osmotic Computing architecture, based on a multi-agent system, according to a new software abstraction called MicroELement (MEL), that encapsulates resources, services and data necessary to run IoT applications. A Body Area Network (BAN) scenario is proposed in order to explore the Osmotic Computing potentiality and explain the reasons behind this new paradigm.

Refuge in the City

This paper highlights the changing nature of refugee displacement and the resultant challenges in addressing the needs of refugees in urban areas. It reflects on the failures of traditional models in delivering needed services in these complex environments. It argues that current humanitarian program models are outdated, expensive, and ill-equipped for an effective response in urban areas. The article goes on to propose a myriad of new and emerging models and approaches that could increase efficiencies and enhance sustainability in humanitarian response.

FUX-Sim: Implementation of a fast universal simulation/reconstruction framework for X-ray systems.

The availability of digital X-ray detectors, together with advances in reconstruction algorithms, creates an opportunity for bringing 3D capabilities to conventional radiology systems. The downside is that reconstruction algorithms for non-standard acquisition protocols are generally based on iterative approaches that involve a high computational burden.The development of new flexible X-ray systems could benefit from computer simulations, which may enable performance to be checked before expensive real systems are implemented. The development of simulation/reconstruction algorithms in this context poses three main difficulties. First, the algorithms deal with large data volumes and are computationally expensive, thus leading to the need for hardware and software optimizations. Second, these optimizations are limited by the high flexibility required to explore new scanning geometries, including fully configurable positioning of source and detector elements. And third, the evolution of the various hardware setups increases the effort required for maintaining and adapting the implementations to current and future programming models. Previous works lack support for completely flexible geometries and/or compatibility with multiple programming models and platforms.In this paper, we present FUX-Sim, a novel X-ray simulation/reconstruction framework that was designed to be flexible and fast. Optimized implementation for different families of GPUs (CUDA and OpenCL) and multi-core CPUs was achieved thanks to a modularized approach based on a layered architecture and parallel implementation of the algorithms for both architectures.A detailed performance evaluation demonstrates that for different system configurations and hardware platforms, FUX-Sim maximizes performance with the CUDA programming model (5 times faster than other state-of-the-art implementations). Furthermore, the CPU and OpenCL programming models allow FUX-Sim to be executed over a wide range of hardware platforms.

Compiling Affine Loop Nests for a Dynamic Scheduling Runtime on Shared and Distributed Memory

Current de-facto parallel programming models like OpenMP and MPI make it difficult to extract task-level dataflow parallelism as opposed to bulk-synchronous parallelism . Task parallel approaches that use point-to-point synchronization between dependent tasks in conjunction with dynamic scheduling dataflow runtimes are thus becoming attractive. Although good performance can be extracted for both shared and distributed memory using these approaches, there is little compiler support for them. In this article, we describe the design of compiler--runtime interaction to automatically extract coarse-grained dataflow parallelism in affine loop nests for both shared and distributed-memory architectures. We use techniques from the polyhedral compiler framework to extract tasks and generate components of the runtime that are used to dynamically schedule the generated tasks. The runtime includes a distributed decentralized scheduler that dynamically schedules tasks on a node. The schedulers on different nodes cooperate with each other through asynchronous point-to-point communication, and all of this is achieved by code automatically generated by the compiler. On a set of six representative affine loop nest benchmarks, while running on 32 nodes with 8 threads each, our compiler-assisted runtime yields a geometric mean speedup of 143.6× (70.3× to 474.7× ) over the sequential version and a geometric mean speedup of 1.64× (1.04× to 2.42× ) over the state-of-the-art automatic parallelization approach that uses bulk synchronization . We also compare our system with past work that addresses some of these challenges on shared memory, and an emerging runtime (Intel Concurrent Collections) that demands higher programmer input and effort in parallelizing. To the best of our knowledge, ours is also the first automatic scheme that allows for dynamic scheduling of affine loop nests on a cluster of multicores.

Architecture supported register stash for GPGPU

GPGPU provides abundant hardware resources to support a large number of light-weighted threads. They are organized into blocks and run in warps. All threads of a block must be dispatched to one stream multiprocessor (SM) of GPGPU together. When the remaining resources of an SM cannot support one more block, all threads of the block are held back until former blocks retire from the SM. We found that the register file is prone to be the most limited one among all the resources, especially for SMs with less registers. Meanwhile, we revealed the dynamics of a thread’s register requirement: only part of its pre-allocated registers are used for different instructions at run time. This results in considerable register underutilization.We proposed the architecture supported register stash (ASRS). It removes the limitation of registers when dispatching blocks. The hardware registers are allocated at run time according to each instruction’s live registers, which can be analyzed statically by a compiler. When the hardware registers cannot meet the requirements of all running warps, some warps are suspended and their registers are reclaimed temporarily. The data in these registers are stashed to memory. On the other hand, if there are spare hardware registers, it will start a new warp or resume a suspended warp after all the warp’s stashed register data are loaded from memory. The intra-block synchronization is also taken care of when some of the warps of the same block are not schedulable due to the ASRS.The ASRS alleviates the register underutilization and improves performance without modifying the current programming model or demanding extra effort from the programmers. It also enables an SM with limited registers that cannot even support a single block to execute it. Besides, it helps lower the register file energy consumption and increase the power efficiency. The ASRS achieved speedups of 1.59 and 1.14 when the registers of each SM are limited to 8K and 16K respectively with an insignificant overhead. The speedups compared with the infinite register files are 0.84 and 0.98 with 8K and 16K registers respectively. Compared with the baseline 32K register file, the ASRS decreases the 8K and 16K register file energy consumption to 66.5% and 75.8% respectively. Their power efficiencies (in ratio of performance and power) are increased to 1.29x and 1.31x respectively.

NestedMP: Enabling cache-aware thread mapping for nested parallel shared memory applications

Abstract It is beneficial to exploit multiple levels of parallelism for a wide range of applications, because a typical server already has tens of processor cores now. As the number of cores in a computer is increasing rapidly, efficient support of nested parallelism will be more and more important. We observe that different task-core mapping schemas may result significant performance difference because modern HPC servers are NUMA multi-core systems. So it is important to control the task-core mapping for nested parallelism. However, the number of threads management mechanism in current parallel programming models, such as OpenMP, does not provide enough information for runtime systems to make optimized decision. As a result, current nested parallel applications often suffer from suboptimal task-core mapping and get significant performance loss. To address this problem, we propose NestedMP, a set of directives which extends OpenMP. NestedMP specifies the number of threads of each nested parallel branch in a declarative way and allows runtime systems to see the whole picture of task trees to make locality-aware task-core mapping. We have implemented NestedMP in GCC 4.8.2 and tested the performance on a 4-way 8-core SandyBridge server. The result shows NestedMP improves the performance significantly over GCC’s OpenMP implementation.

A Modified Key Partitioning for BigData Using MapReduce in Hadoop

In the period of BigData, massive amounts of structured and unstructured data are being created every day by a multitude of ever-present sources. BigData is complicated to work with and needs extremely parallel software executing on a huge number of computers. MapReduce is a current programming model that makes simpler writing distributed applications which manipulate BigData. In order to make MapReduce to work, it has to divide the workload between the computers in the network. As a result, the performance of MapReduce vigorously depends on how consistently it distributes this study load. This can be a challenge, particularly in the arrival of data skew. In MapReduce, workload allocation depends on the algorithm that partitions the data. How consistently the partitioner distributes the data depends on how huge and delegate the sample is and on how healthy the samples are examined by the partitioning method. This study recommends an enhanced partitioning algorithm using modified key partitioning that advances load balancing and memory utilization. This is completed via an enhanced sampling algorithm and partitioner. To estimate the proposed algorithm, its performance was compared against a high-tech partitioning mechanism employed by TeraSort. Experimentations demonstrate that the proposed algorithm is quicker, more memory efficient and more accurate than the existing implementation.

Working “Upstream”: Why We Shouldn't Use Heterosexual Women as Health Promotion Change Agents in HIV-Prevention Interventions Aimed at Heterosexual Men

The use of cognitive–behavioral interventions that aim to improve men's health-seeking behaviors via women—a trend that grows increasingly troublesome as gender inequality persists—cannot address the deep-seated social, economic, and political inequalities contributing to the spread of HIV/AIDS, such as sexism and poverty. Such methods often rely on generalizations about men and women and regard female empowerment as a key goal, despite employing shaky definitions of the concept. Here we use the principles of health promotion, particularly determinants of health, to reflect upon and critique current interventions and present alternative programming models that engage both men and women in changing men's health-seeking behaviors and working “upstream” rather than “downstream” of the epidemic.

Parallel computing on graphics processing units and heterogeneous platforms

Parallel computing on graphics processing units and heterogeneous platforms

Extendable pattern-oriented optimization directives

Algorithm-specific, that is, semantic-specific optimizations have been observed to bring significant performance gains, especially for a diverse set of multi/many-core architectures. However, current programming models and compiler technologies for the state-of-the-art architectures do not exploit well these performance opportunities. In this article, we propose a pattern-making methodology that enables algorithm-specific optimizations to be encapsulated into “optimization patterns”. Such optimization patterns are expressed in terms of preprocessor directives so that simple annotations can result in significant performance improvements. To validate this new methodology, a framework, named EPOD, is developed to map these directives into the underlying optimization schemes for a particular architecture. It is difficult to create an exact performance model to determine an optimal or near-optimal optimization scheme (including which optimizations to apply and in which order) for a specific application, due to the complexity of applications and architectures. However, it is trackable to build individual optimization components and let compiler developers synthesize an optimization scheme from these components. Therefore, our EPOD framework provides an Optimization Programming Interface (OPI) for compiler developers to define new optimization schemes. Thus, new patterns can be integrated into EPOD in a flexible manner. We have identified and implemented a number of optimization patterns for three representative computer platforms. Our experimental results show that a pattern-guided compiler can outperform the state-of-the-art compilers and even achieve performance as competitive as hand-tuned code. Therefore, such a pattern-making methodology represents an encouraging direction for domain experts' experience and knowledge to be integrated into general-purpose compilers.

Can GPGPU Programming Be Liberated from the Data-Parallel Bottleneck?

With the growth in transistor counts in modern hardware, heterogeneous systems are becoming commonplace. Core counts are increasing such that GPU and CPU designs are reaching deep into the tens of cores. For performance reasons, different cores in a heterogeneous platform follow different design choices. Based on throughput computing goals, GPU cores tend to support wide vectors and substantial register files. Current designs optimize CPU cores for latency, dedicating logic to caches and out-of-order dependence control. Heterogeneous parallel primitives (HPP) addresses two major shortcomings in current GPGPU programming models: it supports full composability by defining abstractions and increases flexibility in execution by introducing braided parallelism. Heterogeneous parallel primitives is an object-oriented, C++11-based programming model that addresses these shortcomings on both CPUs and massively multithreaded GPUs: it supports full composability by defining abstractions using distributed arrays and barrier objects, and it increases flexibility in execution by introducing braided parallelism. This paper implemented a feature-complete version of HPP, including all syntactic constructs, that runs on top of a task-parallel runtime executing on the CPU. They continue to develop and improve the model, including reducing overhead due to channel management, and plan to make a public version available sometime in the future.

A Survey of Parallel Programming Models and Tools in the Multi and Many-Core Era

In this work, we present a survey of the different parallel programming models and tools available today with special consideration to their suitability for high-performance computing. Thus, we review the shared and distributed memory approaches, as well as the current heterogeneous parallel programming model. In addition, we analyze how the partitioned global address space (PGAS) and hybrid parallel programming models are used to combine the advantages of shared and distributed memory systems. The work is completed by considering languages with specific parallel support and the distributed programming paradigm. In all cases, we present characteristics, strengths, and weaknesses. The study shows that the availability of multi-core CPUs has given new impulse to the shared memory parallel programming approach. In addition, we find that hybrid parallel programming is the current way of harnessing the capabilities of computer clusters with multi-core nodes. On the other hand, heterogeneous programming is found to be an increasingly popular paradigm, as a consequence of the availability of multi-core CPUs+GPUs systems. The use of open industry standards like OpenMP, MPI, or OpenCL, as opposed to proprietary solutions, seems to be the way to uniformize and extend the use of parallel programming models.