8,376 research outputs found
Topological Optimization of the Evaluation of Finite Element Matrices
We present a topological framework for finding low-flop algorithms for
evaluating element stiffness matrices associated with multilinear forms for
finite element methods posed over straight-sided affine domains. This framework
relies on phrasing the computation on each element as the contraction of each
collection of reference element tensors with an element-specific geometric
tensor. We then present a new concept of complexity-reducing relations that
serve as distance relations between these reference element tensors. This
notion sets up a graph-theoretic context in which we may find an optimized
algorithm by computing a minimum spanning tree. We present experimental results
for some common multilinear forms showing significant reductions in operation
count and also discuss some efficient algorithms for building the graph we use
for the optimization
Julia: A Fresh Approach to Numerical Computing
Bridging cultures that have often been distant, Julia combines expertise from
the diverse fields of computer science and computational science to create a
new approach to numerical computing. Julia is designed to be easy and fast.
Julia questions notions generally held as "laws of nature" by practitioners of
numerical computing:
1. High-level dynamic programs have to be slow.
2. One must prototype in one language and then rewrite in another language
for speed or deployment, and
3. There are parts of a system for the programmer, and other parts best left
untouched as they are built by the experts.
We introduce the Julia programming language and its design --- a dance
between specialization and abstraction. Specialization allows for custom
treatment. Multiple dispatch, a technique from computer science, picks the
right algorithm for the right circumstance. Abstraction, what good computation
is really about, recognizes what remains the same after differences are
stripped away. Abstractions in mathematics are captured as code through another
technique from computer science, generic programming.
Julia shows that one can have machine performance without sacrificing human
convenience.Comment: 37 page
Simit: A Language for Physical Simulation
Using existing programming tools, writing high-performance simulation code is labor intensive and requires sacrificing readability and portability. The alternative is to prototype simulations in a high-level language like Matlab, thereby sacrificing performance. The Matlab programming model naturally describes the behavior of an entire physical system using the language of linear algebra. However, simulations also manipulate individual geometric elements, which are best represented using linked data structures like meshes. Translating between the linked data structures and linear algebra comes at significant cost, both to the programmer and the machine. High-performance implementations avoid the cost by rephrasing the computation in terms of linked or index data structures, leaving the code complicated and monolithic, often increasing its size by an order of magnitude. In this paper, we present Simit, a new language for physical simulations that lets the programmer view the system both as a linked data structure in the form of a hypergraph, and as a set of global vectors, matrices and tensors depending on what is convenient at any given time. Simit provides a novel assembly construct that makes it conceptually easy and computationally efficient to move between the two abstractions. Using the information provided by the assembly construct, the compiler generates efficient in-place computation on the graph. We demonstrate that Simit is easy to use: a Simit program is typically shorter than a Matlab program; that it is high-performance: a Simit program running sequentially on a CPU performs comparably to hand-optimized simulations; and that it is portable: Simit programs can be compiled for GPUs with no change to the program, delivering 5-25x speedups over our optimized CPU code
Fast Matlab compatible sparse assembly on multicore computers
We develop and implement in this paper a fast sparse assembly algorithm, the
fundamental operation which creates a compressed matrix from raw index data.
Since it is often a quite demanding and sometimes critical operation, it is of
interest to design a highly efficient implementation. We show how to do this,
and moreover, we show how our implementation can be parallelized to utilize the
power of modern multicore computers. Our freely available code, fully Matlab
compatible, achieves about a factor of 5 times in speedup on a typical 6-core
machine and 10 times on a dual-socket 16 core machine compared to the built-in
serial implementation
DOLFIN: Automated Finite Element Computing
We describe here a library aimed at automating the solution of partial differential equations using the finite element method. By employing novel techniques for automated code generation, the library combines a high level of expressiveness with efficient computation. Finite element variational forms may be expressed in near mathematical notation, from which low-level code is automatically generated, compiled and seamlessly integrated with efficient implementations of
computational meshes and high-performance linear algebra. Easy-to-use object-oriented interfaces to the library are provided in the form of a C++ library and a Python module. This paper discusses the mathematical abstractions and methods used in the design of the library and its implementation. A number of examples are presented to demonstrate the use of the library in application code
Unified Framework for Finite Element Assembly
At the heart of any finite element simulation is the assembly of matrices and
vectors from discrete variational forms. We propose a general interface between
problem-specific and general-purpose components of finite element programs.
This interface is called Unified Form-assembly Code (UFC). A wide range of
finite element problems is covered, including mixed finite elements and
discontinuous Galerkin methods. We discuss how the UFC interface enables
implementations of variational form evaluation to be independent of mesh and
linear algebra components. UFC does not depend on any external libraries, and
is released into the public domain
- ā¦