Browsing by Author "Warburton, Timothy C"

Now showing 1 - 2 of 2
  • Thumbnail Image
    Item
    Discontinuous Galerkin and Finite Difference Methods for the Acoustic Equations with Smooth Coefficients
    (2015-04-20) Bencomo, Mario Javier; Symes, William W.; Warburton, Timothy C; Riviere, Beatrice M
    This thesis analyzes the computational efficiency of two types of numerical methods: finite difference (FD) and discontinuous Galerkin (DG) methods, in the context of 2D acoustic equations in pressure-velocity form with smooth coefficients. The acoustic equations model propagation of sound waves in elastic fluids, and are of particular interest to the field of seismic imaging. The ubiquity of smooth trends in real data, and thus in the acoustic coefficients, validates the importance of this novel study. Previous work, from the discontinuous coefficient case of a two-layered media, demonstrates the efficiency of DG over FD methods but does not provide insight for the smooth coefficient case. Floating point operation (FLOPs) counts are compared, relative to a prescribed accuracy, for standard 2-2 and 2-4 staggered grid FD methods, and a myriad of standard DG implementations. This comparison is done in a serial framework, where FD code is implemented in C while DG code is written in Matlab. Results show FD methods considerably outperform DG methods in FLOP count. More interestingly, implementations of quadrature based DG with mesh refinement (for lower velocity zones) yield the best results in the case of highly variable media, relative to other DG methods.
  • Thumbnail Image
    Item
    Portable Programming Models for Heterogeneous Platforms
    (2015-09-14) Majeti, Deepak; Sarkar, Vivek; Mellor-Crummey, John; Warburton, Timothy C; Barik, Rajkishore
    With the end of Dennard scaling and emergence of dark silicon, the bets are high on heterogeneous architectures to achieve both application performance and energy efficiency. However, diversity in heterogeneous architectures poses severe programming challenges in terms of data layout, memory coherence, task partitioning, data distribution, and sharing of virtual addresses. Existing high-level programming languages are inadequate to address these new architectural features since they lack the necessary abstractions to address the challenges mentioned above. It is necessary for existing languages to be extended minimally with high-level constructs while maintaining existing standards of portability, performance, and productivity. The compiler and runtime together must efficiently map these constructs to a target architecture. We develop Concord, a C++ based programming model that extends the Intel Threading Building Blocks onto integrated heterogeneous CPU+GPU architectures that do not share the same virtual address between CPU and GPU. Concord supports many C++ features including virtual functions. We implement Shared Virtual Memory to map applications with pointer intensive data structures onto heterogeneous architectures that do not share the same virtual address. We introduce Heterogeneous Habanero-C (H2C), an implementation of the Habanero execution model targeting modern heterogeneous architectures with multiple devices. H2C provides high-level constructs to specify the computation, communication and synchronization in a given application. The H2C compiler and runtime frameworks efficiently map these high-level constructs onto the underlying heterogeneous hardware. The highlights of H2C include: a data layout framework to generate code with best data layout suited for a given memory hierarchy; constructs to specify a task partition, leaving the complex analysis of determining the resultant data distribution to the compiler; and a unified event framework that allows a programmer to write applications with a macro data-flow model onto heterogeneous architectures. Experimental results show Concord and H2C provide good portability, productivity, and performance. In the future, we believe heterogeneous architectures will be more diverse and more pervasive. We believe programming systems like H2C and Concord that have a tight integration of language, compiler and runtime are the right way to target current and future heterogeneous systems.