Boyana Norris

Boyana Norris

Auto-generated profile, based on publicly available information

Boyana Norris

University of Oregon, Eugene, OR, USA

Research Focus & Metrics

Academic Career Length

29Years (1998-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
1 April 2013 in Computers & Geosciences
Verified
Journal Article
Closed access
SPScott D. Peckham
Scott D. Peckham
EHEric W.H. Hutton
Eric W.H. Hutton
BNBoyana Norris
Boyana Norris

1 May 2006 in The International Journal of High Performance Computing Applications
Verified
Journal Article
Closed access
PDF file
DBDavid E. Bernholdt
David E. Bernholdt
BABenjamin A. Allan
Benjamin A. Allan
RARobert Armstrong
Robert Armstrong
FBFelipe Bertrand
Felipe Bertrand
KCKenneth Chiu
Kenneth Chiu
SZShujia Zhou
Shujia Zhou
The Common Component Architecture (CCA) provides a means for software developers to manage the complexity of large-scale scientific simulations and to move toward a plug-and-play environment for high-performance coputing. In the scientific computing context, component models also promote collaboration using independently developed software, thereby allowing particular individals or groups to focus on the aspects of greatest interest to them. The CCA supports parallel and distributed coputing as well as local high-performance connections between components in a language-independent manner. The design places minimal requirements on components and thus facilitates the integration of existing code into the CCA environment. The CCA model imposes minimal ovehead to minimize the impact on application performance. The focus on high performance distinguishes the CCA from most other component models. The CCA is being applied within an increasing range of disciplines, including cobustion research, global climate simulation, and computtional chemistry.

31 July 2018 in Proceedings of the IEEE
Verified
Journal Article
Closed access
PBPrasanna Balaprakash
Prasanna Balaprakash
JDJack Dongarra
Jack Dongarra
TGTodd Gamblin
Todd Gamblin
MHMary Hall
Mary Hall
JHJeffrey K. Hollingsworth
Jeffrey K. Hollingsworth
RVRichard Vuduc
Richard Vuduc
Autotuning refers to the automatic generation of a search space of possible implementations of a computation that are evaluated through models and/or empirical measurement to identify the most desirable implementation. Autotuning has the potential to dramatically improve the performance portability of petascale and exascale applications. To date, autotuning has been used primarily in high-performance applications through tunable libraries or previously tuned application code that is integrated directly into the application. This paper draws on the authors’ extensive experience applying autotuning to high-performance applications, describing both successes and future challenges. If autotuning is to be widely used in the HPC community, researchers must address the software engineering challenges, manage configuration overheads, and continue to demonstrate significant performance gains and portability across architectures. In particular, tools that configure the application must be integrated into the application build process so that tuning can be reapplied as the application and target architectures evolve.

1 May 2009
Verified
Conference Paper
Closed access
AHAlbert Hartono
Albert Hartono
BNBoyana Norris
Boyana Norris
PSP. Sadayappan
P. Sadayappan
For many scientific applications, significant time is spent in tuning codes for a particular high-performance architecture. Tuning approaches range from the relatively nonintrusive (e.g., by using compiler options) to extensive code modifications that attempt to exploit specific architecture features. Intrusive techniques often result in code changes that are not easily reversible, and can negatively impact readability, maintainability, and performance on different architectures. We introduce an extensible annotation-based empirical tuning system called Orio that is aimed at improving both performance and productivity. It allows software developers to insert annotations in the form of structured comments into their source code to trigger a number of low-level performance optimizations on a specified code fragment. To maximize the performance tuning opportunities, the annotation processing infrastructure is designed to support both architecture-independent and architecture-specific code optimizations. Given the annotated code as input, Orio generates many tuned versions of the same operation and empirically evaluates the alternatives to select the best performing version for production use. We have also enabled the use of the Pluto automatic parallelization tool in conjunction with Orio to generate efficient OpenMP-based parallel code. We describe our experimental results involving a number of computational kernels, including dense array and sparse matrix operations.

8 June 2009
Verified
Conference Paper
Open access
PDF file
AHAlbert Hartono
Albert Hartono
MBMuthu Manikandan Baskaran
Muthu Manikandan Baskaran
CBCédric Bastoul
Cédric Bastoul
ACAlbert Cohen
Albert Cohen
SKSriram Krishnamoorthy
Sriram Krishnamoorthy
PSP. Sadayappan
P. Sadayappan

1 September 2015
Verified
Conference Paper
Closed access
TNThomas Nelson
Thomas Nelson
ARAxel Rivera
Axel Rivera
PBPrasanna Balaprakash
Prasanna Balaprakash
MHMary Hall
Mary Hall
PHPaul D. Hovland
Paul D. Hovland
BNBoyana Norris
Boyana Norris
Many scientific and numerical applications, including quantum chemistry modeling and fluid dynamics simulation, require tensor product and tensor contraction evaluation. Tensor computations are characterized by arrays with numerous dimensions, inherent parallelism, moderate data reuse and many degrees of freedom in the order in which to perform the computation. The best-performing implementation is heavily dependent on the tensor dimensionality and the target architecture. In this paper, we map tensor computations to GPUs, starting with a high-level tensor input language and producing efficient CUDA code as output. Our approach is to combine tensor-specific mathematical transformations with a GPU decision algorithm, machine learning and auto tuning of a large parameter space. Generated code shows significant performance gains over sequential and Open MP parallel code, and a comparison with Open ACC shows the importance of auto tuning and other optimizations in our framework for achieving efficient results.