A Graphics Processing Unit–Based, Industrial Grade Compositional Reservoir Simulator

This paper describes an Adaptive Implicit Method (AIM) for reservoir simulation. The method is based on an extension of the generalized compositional solution procedure. In addition to the creation of a robust method, we have tried to minimize the overhead associated with the method, so that our implementation is almost as fast as an IMPES (implicit-pressure-explicit-saturation) method when few implicit blocks are needed. Several test problems demonstrate important aspects of the switching logic and the tradeoffs between large highly implicit time steps and smaller time steps with less implicitness. We find that in most cases the greatest efficiency occurs when only a small number of blocks (less than 5 percent) are treated implicitly. In many cases the most efficient method is IMPES with time steps selected using the numerical stability calculations of AIM, Smaller time steps lead not only to higher efficiency, but also to solutions with less numerical dispersion. In general. AIM appears to benefit compositional problems more frequently than black oil problems.

There are two inherent obstacles to effectively using Graphics Processing Units (GPUs) for query processing in search engines: (a) the highly restricted GPU memory space, and (b) the CPU-GPU transfer latency. Previously, Ao et al. presented a GPU method for lists intersection, an essential component in AND-based query processing. However, this work assumes the whole inverted index can be stored in GPU memory and does not address document ranking. In this paper, we describe and analyze a GPU query processing method which incorporates both lists intersection and top-k ranking. We introduce a parameterized pruned posting list GPU caching method where the parameter determines how much GPU memory is used for caching. This method allows list caching for large inverted indexes using the limited GPU memory, thereby making a qualitative improvement over previous work. We also give a mathematical model which can identify an approximately optimal choice of the parameter. Experimental results indicate that this GPU approach under the pruned list caching policy achieves better query throughput than its CPU counterpart, even when the inverted index size is much larger than the GPU memory space.

The graphics processing unit (GPU) is extensively used in diverse domains, such as finance, machine learning, and image processing. The GPU can be underutilized as multiple applications may not share the same GPU concurrently owing to a memory oversubscription issue. For example, when applications that require fewer computational resources but a larger GPU memory are running instantaneously, the GPU memory may be insufficient; consequently, the number of GPU applications running simultaneously is restricted, decreasing GPU utilization. Further, it can even stop the execution of applications that are running on the GPU. To this end, we propose FlexGPU, which schedules the kernels of the GPU applications that run on the same GPU according to their features. This framework 1) schedules the kernel at the launching time according to its features to improve GPU utilization and 2) temporarily checkpoints and restores non-dependent content in the GPU memory to/from the host memory, which avoids oversubscription of the GPU when out-of-memory failure occurs and allows more kernels to run concurrently on the GPU. The experimental results show that compared to existing methods, our approach demonstrates a 7 times improvement in performance in terms of execution time and enables a 2.5 times increase in the concurrent execution of applications.

A comparative performance evaluation of cubic equations of state for predicting the compositional distribution of hydrate inhibitors in reservoir fluid systems

In data-parallel computing that uses a graphic processing unit (GPU), processing of large data requires that multiple GPUs be used in the computer to increase its execution performance. Increasing processing performance by using multiple computing resources has been enabled by the development of computing frameworks based on a directed acyclic graph (DAG). However, their performance degrades in out-of-core processing, which often occurs in processing of large data on GPUs with limited memory capacity. The GPU data input/output (I/O) for data swapping between host memory and GPU memory during the execution of a user DAG is usually a performance bottleneck. A computing framework called is proposed to overcome this drawback. It uses a novel scheduler that involves two methods to minimize the total amount of GPU data I/O of data swapping. First, it performs locality-aware scheduling. When it schedules a task, it selects one that requires the minimum amount of data swapping and reuses as much of the data residing in GPU memory as possible. Second, it extends the locality-aware scheduling so that GPUs can execute data prefetching. Prefetching data that are swapped out from a GPU enables efficient use of bottleneck GPU I/O resources. To prefetch the input data of future tasks, it is required to determine the schedule of future tasks. Victream's scheduler (hereafter, the Victream scheduler) extends the locality-aware scheduling so that it can schedule future tasks to enable data prefetching that is executed in the way that minimizes the amount of data I/O of data swapping. Evaluation of a Victream prototype showed that the performance of Victream is better than that of conventional frameworks by up to 117%.

Sequential Fully Implicit (SFI) schemes have been proposed as an alternative to the Fully Implicit Method (FIM). A significant advantage of SFI is that one can employ scalable strategies to the flow and transport problems. However, the primary disadvantage of using SFI compared with FIM is the fact that the splitting errors induced by the decoupling operator, which separates the pressure from the saturation(s), can lead to serious convergence difficulties of the overall nonlinear problem. Thus, it is important to quantify the coupling strength in an adaptive manner in both space and time. We present criteria that localize the computational cells where the pressure and saturation solutions are tightly coupled. The approach is using terms in the FIM Jacobian matrix, we quantify the sensitivity of the mass and volume-balance equations to changes in the pressure and the saturations. We identify three criteria that provide a measure of the coupling strength across the equations and variables. The standard CFL stability criteria, which are based entirely on the saturation equations, are a subset of the new criteria. Here, the pressure equation is solved using Algebraic MultiGrid (AMG), or a multiscale solver, such as the Multiscale Restricted-Smooth Basis (MsRSB) approach. The transport equations are then solved using a fixed total-velocity. These ‘coupling strength’ criteria are used to identify the cells where the pressure-saturation coupling is strong. The applicability of the derived coupling-strength criteria is tested using several test cases. The first test is using a gravitational immiscible dead-oil lock-exchange under a unit mobility ratio and large differences in density. For this case, the SFI algorithm fails to converge to the fully coupled solution due to the large splitting errors. Introducing a fully coupled solution stage on the local subdomains as an additional correction step restores nonlinear convergence. Detailed analysis of the ‘coupling strength’ criteria indicates that the criteria related to the sensitivity of the mass balance to changes in the pressure and the sensitivity of the volume balance to changes in the saturations are the most important ones to satisfy. Other test cases include an alternate gas-water-gas injection in a top layer of the SPE 10 test case and an injection-production scenario in a three-dimensional reservoir with layered lognormally distributed permeability. We propose novel criteria to estimate the strength of coupling between pressure and saturation. These CFL-like numbers are used to identify the cells that require fully implicit treatment in the nonlinear solution strategy. These criteria can also be used to improve the nonlinear convergence rates of Adaptive Implicit Methods (AIM).

An efficient, non-iterative flash calculation algorithm has been developed for equation of state (EOS) compositional reservoir simulation problems. In this algorithm, the flash calculation is carried out by solving two sets of linear equations. The solution of these equations is the mole number of each component in each phase. The phase saturation can thus be obtained without solving the Rachford-Rice equation1. Tests against many PVT data sets show that the new approach gives the same results as those computed by the fugacity iteration based on the EOS. However, the computation time is reduced significantly. A series of reservoir simulations has been conducted by an EOS compositional reservoir simulator, UTCOMP, with this new flash approach. Comparisons are made with those performed by UTCOMP with a rigorous fugacity iteration of the Peng-Robinson5 EOS. The results obtained by these two methods are in very good agreement. However, a considerable reduction of the CPU time is generally accompanied by using the new approach. For the runs in which an immiscible displacement process takes place in the reservoir, the computational burden in the phase behavior calculations is reduced by around 90%. Correspondingly, the reduction of the total simulation time is as much as 65%. Besides, it is found that the number of components used affects on the CPU time of the simulations much less with the new approach. These observations may lead to the time used for an EOS compositional reservoir simulations with the new approach being comparable to a black-oil simulation without sacrificing computational accuracy. Also in this work an attempt is made to employ the non-iterative approach as a tool for providing the initial guess for the rigorous EOS iteration. A considerable reduction of the CPU time is still observed.

Feedback control has become a crucial tool in the research on magnetic confinement of plasmas for achieving controlled nuclear fusion. This thesis presents a novel plasma feedback control system that, for the first time, employs a Graphics Processing Unit (GPU) for microsecond-latency, real-time control computations. This novel application area for GPU computing is opened up by a new system architecture that is optimized for low-latency computations on less than kilobyte sized data samples as they occur in typical plasma control algorithms. In contrast to traditional GPU computing approaches that target complex, high-throughput computations with massive amounts of data, the architecture presented in this thesis uses the GPU as the primary processing unit rather than as an auxiliary of the CPU, and data is transferred from A-D/D-A converters directly into GPU memory using peer-to-peer PCI Express transfers. The described design has been implemented in a new, GPU-based control system for the High-Beta Tokamak – Extended Pulse (HBT-EP) device. The system is built from commodity hardware and uses an NVIDIA GeForce GPU and D-TACQ A-D/D-A converters providing a total of 96 input and 64 output channels. The system is able to run with sampling periods down to 4 μs and latencies down to 8 μs. The GPU provides a total processing power of 1.5 x 1012 floating point operations per second. To illustrate the performance and versatility of both the general architecture and concrete implementation, a new control algorithm has been developed. The algorithm is designed for the control of multiple rotating magnetic perturbations in situations where the plasma equilibrium is not known exactly and features an adaptive system model: instead of requiring the rotation frequencies and growth rates embedded in the system model to be set a priori, the adaptive algorithm derives these parameters from the evolution of the perturbation amplitudes themselves. This results in non-linear control computations with high computational demands, but is handled easily by the GPU based system. Both digital processing latency and an arbitrary multi-pole response of amplifiers and control coils is fully taken into account for the generation of control signals. To separate sensor signals into perturbed and equilibrium components without knowledge of the equilibrium fields, a new separation method based on biorthogonal decomposition is introduced and used to derive a filter that performs the separation in real-time. The control algorithm has been implemented and tested on the new, GPU-based feedback control system of the HBT-EP tokamak. In this instance, the algorithm was set up to control four rotating n = 1 perturbations at different poloidal angles. The perturbations were treated as coupled in frequency but independent in amplitude and phase, so that the system effectively controls a helical n = 1 perturbation with unknown poloidal spectrum. Depending on the plasma's edge safety factor and rotation frequency, the control system is shown to be able to suppress the amplitude of the dominant 8 kHz mode by up to 60% or amplify the saturated amplitude by a factor of up to two. Intermediate feedback phases combine suppression and amplification with a speed up or slow down of the mode rotation frequency. Increasing feedback gain results in the excitation of an additional, slowly rotating 1.4 kHz mode without further effects on the 8 kHz mode. The feedback performance is found to exceed previous results obtained with an FPGA- and Kalman-filter based control system without requiring any tuning of system model parameters. Experimental results are compared with simulations based on a combination of the Boozer surface current model and the Fitzpatrick-Aydemir model. Within the subset of phenomena that can be represented by the model as well as determined experimentally, qualitative agreement is found.

3D Freehand Ultrasound Reconstruction of the Carotid Artery.

Detailed compositional simulation of a giant reservoir with many components is not practical. However, detailed multi-million cell black oil simulation of giant reservoirs is now quite feasible. In this work we apply an efficient method to generate the compositional rates from a black oil simulation of the giant Shaybah field. In situations where the reservoir recovery mechanism is not dominated by compositional effects, an Equation of State (EOS) based stream conversion method can be used. This stream conversion method relies on the fact that when laboratory PVT data measured on available well stream compositions are used to generate the black oil PVT tables, some of the compositional information is lost. The stream conversion model retains this valuable compositional information and applies it to each producing well completion in the black oil simulation at every time step. As proof of concept, the stream conversion method was applied to a black oil simulation and to a limited (eight-component) compositional simulation to generate a 17-component compositional stream and the results were compared to the respective full EOS compositional simulation for a relatively small sector (250,000 cells) of the giant Shaybah field. The compositional stream rates are in excellent agreement with the stream converted black oil results. As would be expected, the computational costs of using the EOS based compositional simulator (with 17 components) is in excess of 40 times the black oil simulation time for the small sector model. In general, the stream conversion method can be used to generate the dynamically varying compositional streams from any black oil simulation for use in the design and operation of surface facilities and in calculating the amounts of a certain cut (e.g. NGL) from the production streams.

Graphics processing units (GPUs) are important components of modern computing devices for not only graphics rendering, but also efficient parallel computations. However, their security problems are ignored despite their importance and popularity. In this paper, we first perform an in-depth security analysis on GPUs to detect security vulnerabilities. We observe that contemporary, widely-used GPUs, both NVIDIA's and AMD's, do not initialize newly allocated GPU memory pages which may contain sensitive user data. By exploiting such vulnerabilities, we propose attack methods for revealing a victim program's data kept in GPU memory both during its execution and right after its termination. We further show the high applicability of the proposed attacks by applying them to the Chromium and Firefox web browsers which use GPUs for accelerating webpage rendering. We detect that both browsers leave rendered webpage textures in GPU memory, so that we can infer which web pages a victim user has visited by analyzing the remaining textures. The accuracy of our advanced inference attack that uses both pixel sequence matching and RGB histogram matching is up to 95.4%.

Nowadays, Graphics Processing Unit (GPU) is essential for general-purpose high-performance computing, because of its dominant performance in parallel computing compare to that of CPU. There have been many successful trials on the use of GPU in virtualized environment. Especially, NVIDIA Docker obtained a most practical way to bring GPU into the container-based virtualized environment. However, most of these trials did not consider sharing GPU among multiple containers. Without the above consideration, a system will experience a program failure or a deadlock situation in the worst case. In this paper, we propose ConVGPU, a solution to share the GPU in multiple containers. With ConVGPU, the system can guarantee the required GPU memory which the container needs to execute. To achieve it, we introduce four scheduling algorithms that manage the GPU memory to be taken by the containers. These algorithms can prevent the system from falling into deadlock situations between containers during execution.

Graphics processing units (GPUs) have been widely adopted to accelerate the training of deep neural networks (DNNs). Although the computational performance of GPUs has been improving steadily, the memory size of modern GPUs is still quite limited, which restricts the sizes of DNNs that can be trained on GPUs, and hence raises serious challenges. This paper introduces a framework, referred to as moDNN (memory optimal DNN training on GPUs), to optimize the memory usage in DNN training. moDNN supports automatic tuning of DNN training code to match any given memory budget (not smaller than the theoretical lower bound). By taking full advantage of overlapping computations and data transfers, we develop new heuristics to judiciously schedule data offloading and prefetching transfers, together with convolution algorithm selection, to optimize memory usage. We further devise a new sub-batch size selection method which also greatly reduces memory usage. moDNN can save memory usage up to 59×, compared with an ideal case which assumes that the GPU memory is sufficient to hold all data. When executing moDNN on a GPU with 12 GB memory, the training time is increased by only 3 percent, which is much shorter than that incurred by the best known approach, vDNN. Furthermore, we propose an optimization strategy for moDNN on multiple GPUs again by utilizing the idea of overlapping data transfers and GPU computations. The results show that 3.7× speedup is attained on four GPUs.

Graphics Processing Units (GPUs) have been successfully used to accelerate scientific applications due to their computation power and the availability of programming languages that make more approachable writing scientific applications for GPUs. However, since the programming model of GPUs requires offloading all the data to the GPU memory, the memory footprint of the application is limited to the size of the GPU memory. Multi-GPU systems can make memory limited problems tractable by parallelizing the computation and data among the available GPUs. Parallelizing applications written for running on single-GPU systems can be done (i) at runtime through an environment that captures the memory operations and kernel calls and distributes among the available GPUs, and (ii) at compile time through a pre-compiler that transforms the application for decomposing the data and computation among the available GPUs. In this paper we propose a framework and implement a tool that transforms an OpenCL application written to run on single-GPU systems into one that runs on multi-GPU systems. Based on data dependencies and data usage analysis, the application is transformed to decompose data and computation among the available GPUs. To reduce the data transfer overhead, computation-communication overlapping techniques are utilized. We tested our tool using two applications with different data transfer requirements, for the application with no data transfer requirements, a linear speedup is achieved, while for the application with data transfers, the computation-communication overlapping reduces the communication overhead by 40%.

An improved generalized three-parameter cubic equation of state for pure fluids