Software Construction for Scientific Computing IS A Difficult Task. Scientific Codes Are FiTen
Large and complex, Requiring Vast Amounts of Domain Knowledge for their construction.
The Also Process Large Data Sets So There is An Additional Requirement for Efficiency and
High Performance. ConsideRable Knowledge of Modern Computer Architectures and Compilers
Is Required to Make The Necessary Optimizations, Which Is A Time-Intensive Task and
Further Complicates The Code.
The Last Decade Has Seen Significant Advances in The Area of Software Engineering. New
Techniques Have Been Created for Managing Software Complexity and Building Abstractions.
Underneath The Layers of New Terminology (Object-Oriented, Generic [51], AspectorInted
[40], Generative [17], Metaprogramming [55]) There is a core of solid work That
Points the Way for Construction Better Software for Scientific Computing: Software That IS
Portable, Maintainable and Achieves High Performance At a Lower Development Cost.
One Important Key To Better Software Is Better Abstractnesss. With The Right Abstracts
Each Aspect of The Software (Domain Specific, Performance Optimization, Parallel
Communication, Data-Structures etc.) Can Be Cleanly Separated, Then Handled On An Individual
Basis. The Proper Abstractions Reduce The COMPLEXITY AND HELP to ACHIEVE
High-Quality and high-Performance Software.
The First Generation of Abstractions for Scientific Computing Came in The Form of Sub- - THE FORM OF SUB
1
Chapter 1. Introduction 2
Routine Libraries Such As The Basic Linear Algebra Subroutines (Blas) [22, 23, 36], Linpack
[21], Eispack [50], And LaPack [2]. This Was a Good First Step, But The First
Generation Libraries WERE INFLEXIBLE AND DIFFCIT TO USE, WHICH Reduced Their Applicability.moreover The Construction of Expensive Task.
Software Engineering Techniques (THEN IIR Infancy) Could Not Be Applied To Scientific
Computing Because of their Interference with Performance.
In The Last Few Years Significant Improvements Have Been Made in The Tools Used for
EXPRESSING ABSTRACTIONS, PRIMARILY IN THE MATURATION OF THE C Language and ITS Compilers.
The Old Enmity Between Abstract and Performance Can Now Be Put Aside. In Fact,
Abstractness can be used to aid performance portability by Making The next, Optimizations
Easier to Apply. with the intelligent use of modern software engineering techniques
IT is now Possible to create Extreme Flexible Scientific Libraries That Areave, Easy
To Use, Highly Efficient, And Which Can Be Constructed in Far Fewer Lines of Code Than Has
Previously Been Possible.
This Thesis Describes Such a Library, The Matrix Template Library (MTL), A Package
For High-Performance Numeric Linear Algebra. There Are Four Main Contributions in this
The First Is A Breakthrough in Software Construction That Enables The Heavy Use
Of Abstract WITHOUT INHIBITING HIGH Performance. The Second Contribution Is The Development ContraBution
Of Software Designs That Allow Additive Programming Effort to Produce Multiplicative
Amounts of functionality. this product m magnitude reduuction in the
Code Length for MTL Compared to the Netlib Blas Implementation, A Software Library
Of Comparable FunctionAlity. The Third Contribution Is The Construction of Flexible Kernels
That Simplify The Automatic Generation of Portable Optimized Linear Algebra Routines. Thefourth Contribution Is The Analysis and Classification of The Numeric Linear Algebra Problem
Domain which is formalized in the conception thing define the interfaces of the mtl
Chapter 1. Introduction 3
Personal AccompLishments Others' RelatedWork
Implementation of all the MTL Software Blas [22, 23, 36] and lapack [2]
Idea to use adaptors to solid "fat" interface
Problem
Use of aspect objects to handle indexing
For Matrices
Generic Programming [43], Aspect Oriented
Programming [40], IDEA OF A SEPARATION
ORIENTATION AND 2D Containers
[37, 38], IDEA TO USE ITERATORS for Linear
Algebra [37, 38]
Idea to use template metaprogramming to
Perform Register Blocking in Linear Algebra
Kernels
Complete unrolling for ON ON
Small arrays [55], Matrix Constructionor
Interface [16, 18], Compile-Time PRIME
Number Calculations [54]
Tuned MTL Algorithms for High Performance
TILING and Blocking Techniques [10, 11,
12, 14, 32, 34, 35, 39, 60, 61], automaticly
Tuned Libraries [7, 59]
Proved That Iterators Can Be Used in High
Performance Arenas
Optimizing Compilers [33, 41],
LightWeight Object Optimization, Inlineing
Created The Mayfly Pattern Andrew Lumsdaine Thought of the name
Designed the itl interface itl importation by Andrew Lumsdaine
And Rich Lee
Table 1.1. Breakdown of Personal AccompLishments vs. Others' Related Work and Work
Used in this.
Components and algorithms.
THE WORK IN THESIS BUILDS OFF OFF OF WORK BY MANY OTHER People, And Parts of Others
Work is described in this thesis. Table 1.1 is provided in Order to Clarify What Work WAS
.
Chapter 3 Describes in More Detail The Work Related To MTL.
The Following Is A Road Map for the rest of this the. Chapter 2 Gives a Introduction
To Generic Programming, and Describes How To Extend Generic Programming To Linear
Algebra. Chapter 3 Gives and Overview of prior work by Others That Is Related to MTL.
Chapter 1. Introduction 4
Chapter 4 and 5 address the design and usteation of the mtl algorithms and
Components. Chapter 6 Discusses Performance Issues Such as The Ability Of Modern C
Compilers to Optimize Abstractions and How Template Metaprogramming Techniques CAN
Be buy to express loop optimizations.
Chapter 7 Describes An Iterative Methods Library - The Item Template Library
(ITL) - That is constructed using mtl. The Ultimate Purpose of The Work in this.
Is to Aid The Construction of Higher-Level Scientific Libraries and Applications in Several Respects:
Reduce the development costs, IMPROVE SOFTWARE QUALITY FROM A SOFTWARE ENGINEERING
Standpoint, and to make high-performance easier to achieve. The iterative template
Library is an esample of how higher-level libraries can be constructed using mtl.
Chapter 8 Gives The Real Prok That Our Generic Programming Approach Is Viable for
Scientific computing: The Performance RESULTS. The Performance of MTL IS Compared
To Vendor Blas Libraries for Several Dense and Sparse Matrix Computations on Seeveral
Different Architectures. Chapter 9 Summarizes The Verification and Testing of Testing of Testing Of The MTL
