998 Matching Results

Search Results

Advanced search parameters have been applied.


Description: A Fortran program is described for calculating the absorption correction for application to single crystal x ray or neutron intensity measurements. The program is available in the form of symbolic punched cards. InstrucPions are included. (J.R.D.)
Date: April 1, 1962
Creator: Wehe, D.J.; Busing, W.R. & Levy, H.A.
Partner: UNT Libraries Government Documents Department

nu-TRLan User Guide Version 1.0: A High-Performance Software Package for Large-Scale Harmitian Eigenvalue Problems

Description: The original software package TRLan, [TRLan User Guide], page 24, implements the thick restart Lanczos method, [Wu and Simon 2001], page 24, for computing eigenvalues {lambda} and their corresponding eigenvectors v of a symmetric matrix A: Av = {lambda}v. Its effectiveness in computing the exterior eigenvalues of a large matrix has been demonstrated, [LBNL-42982], page 24. However, its performance strongly depends on the user-specified dimension of a projection subspace. If the dimension is too small, TRLan suffers from slow convergence. If it is too large, the computational and memory costs become expensive. Therefore, to balance the solution convergence and costs, users must select an appropriate subspace dimension for each eigenvalue problem at hand. To free users from this difficult task, nu-TRLan, [LNBL-1059E], page 23, adjusts the subspace dimension at every restart such that optimal performance in solving the eigenvalue problem is automatically obtained. This document provides a user guide to the nu-TRLan software package. The original TRLan software package was implemented in Fortran 90 to solve symmetric eigenvalue problems using static projection subspace dimensions. nu-TRLan was developed in C and extended to solve Hermitian eigenvalue problems. It can be invoked using either a static or an adaptive subspace dimension. In order to simplify its use for TRLan users, nu-TRLan has interfaces and features similar to those of TRLan: (1) Solver parameters are stored in a single data structure called trl-info, Chapter 4 [trl-info structure], page 7. (2) Most of the numerical computations are performed by BLAS, [BLAS], page 23, and LAPACK, [LAPACK], page 23, subroutines, which allow nu-TRLan to achieve optimized performance across a wide range of platforms. (3) To solve eigenvalue problems on distributed memory systems, the message passing interface (MPI), [MPI forum], page 23, is used. The rest of this document is organized as follows. In Chapter 2 ...
Date: October 27, 2008
Creator: Yamazaki, Ichitaro; Wu, Kesheng & Simon, Horst
Partner: UNT Libraries Government Documents Department

Semantic-Aware Automatic Parallelization of Modern Applications Using High-Level Abstractions

Description: Automatic introduction of OpenMP for sequential applications has attracted significant attention recently because of the proliferation of multicore processors and the simplicity of using OpenMP to express parallelism for shared-memory systems. However, most previous research has only focused on C and Fortran applications operating on primitive data types. Modern applications using high-level abstractions, such as C++ STL containers and complex user-defined class types, are largely ignored due to the lack of research compilers that are readily able to recognize high-level object-oriented abstractions and leverage their associated semantics. In this paper, we use a source-to-source compiler infrastructure, ROSE, to explore compiler techniques to recognize high-level abstractions and to exploit their semantics for automatic parallelization. Several representative parallelization candidate kernels are used to study semantic-aware parallelization strategies for high-level abstractions, combined with extended compiler analyses. Preliminary results have shown that semantics of abstractions can help extend the applicability of automatic parallelization to modern applications and expose more opportunities to take advantage of multicore processors.
Date: December 21, 2009
Creator: Liao, C; Quinlan, D J; Willcock, J J & Panas, T
Partner: UNT Libraries Government Documents Department


Description: An IBM 7090 FORTRAN program was written for the preliminary design and cost estimation of unfired pressure vessels with or without a jacket. Both vessel and jacket designs conform to the 1959 ASME Boiler and Pressure Vessel Code, Section VIII, Unfired Pressure Vessels. Vessels and jackets from 5 in. pipe through 84 in. o.d. and 1/4 in. through 1 1/2 in. in metal thickness may be designed by this program as written. Total vessel cost is the sum of metal and fabrication costs, each on a weight basis. (auth)
Date: October 17, 1962
Creator: Prince, C.E. & Milford, R.P.
Partner: UNT Libraries Government Documents Department


Description: A fraction of the possibilities of Fortran are described, but at all times an effort was made to indicate where only a partial expose was made. Many specific examples are included to illustrate the word descriptions of Fortran programming. An appendix, which gives specific information concerning procedures relative to the use of the 704, is included. (auth)
Date: March 1, 1962
Creator: Pawlicki, G.S.
Partner: UNT Libraries Government Documents Department

FORTRAN Optimizations at the Source Code Level

Description: This paper discusses FORTRAN optimizations that the user can perform manually at the source code level to improve object code performance. It makes use of descriptive examples within the text of the paper for explanatory purposes. The paper defines key areas in writing a FORTRAN program and recommends ways to improve efficiency in these areas.
Date: August 1977
Creator: Barber, Willie D.
Partner: UNT Libraries


Description: This report is a summary of work done towards developing an AutoCAD based system for design and analysis of magnets. The computer programs that have been developed are an attempt to integrate the new SUN computer based system with existing software on the old HP1000 System. We believe this is a good start for the further development of the whole system. The programming languages used are AutoLISP for the programs used by AutoCAD, and Fortran (Microsoft Fortran) for all others. The entire work has been done on IBM-AT, with the well known limits of the memory, speed of execution and operating system, therefore, some adjustment may be needed for the more powerful SUN system.
Date: February 1, 1988
Creator: Sorin, M. & Caspi, S.
Partner: UNT Libraries Government Documents Department

Babel Fortran 2003 Binding for Structured Data Types

Description: Babel is a tool aimed at the high-performance computing community that addresses the need for mixing programming languages (Java, Python, C, C++, Fortran 90, FORTRAN 77) in order to leverage the specific benefits of those languages. Scientific codes often rely on structured data types (structs, derived data types) to encapsulate data, and Babel has been lacking in this type of support until recently. We present a new language binding that focuses on their interoperability of C/C++ with Fortran 2003. The new binding builds on the existing Fortran 90 infrastructure by using the iso-c-binding module defined in the Fortran 2003 standard as the basis for C/C++ interoperability. We present the technical approach for the new binding and discuss our initial experiences in applying the binding in FACETS (Framework Application for Core-Edge Transport Simulations) to integrate C++ with legacy Fortran codes.
Date: May 2, 2008
Creator: Muszala, S; Epperly, T & Wang, N
Partner: UNT Libraries Government Documents Department

OpenMP for Accelerators

Description: OpenMP [13] is the dominant programming model for shared-memory parallelism in C, C++ and Fortran due to its easy-to-use directive-based style, portability and broad support by compiler vendors. Similar characteristics are needed for a programming model for devices such as GPUs and DSPs that are gaining popularity to accelerate compute-intensive application regions. This paper presents extensions to OpenMP that provide that programming model. Our results demonstrate that a high-level programming model can provide accelerated performance comparable to hand-coded implementations in CUDA.
Date: March 15, 2011
Creator: Beyer, J C; Stotzer, E J; Hart, A & de Supinski, B R
Partner: UNT Libraries Government Documents Department

Automated component creation for legacy C++ and fortran codes.

Description: A significant amount of work has been spent creating component models and programming environments, but little support exists for automation in the process of creating components from existing codes. To entice users to adopt the component-based paradigm over traditional programming models, integration of legacy codes must be as simple and fast as possible, We present a system for automating the IDL generation stage of component development based on source code analysis of legacy C, C-t-4 and Fortran codes using the Program Database Toolkit. Together with IDL compilation tools such as Babel, we provide an alternative to hand-written IDL code for legacy applications and libraries. In addition to generating IDL, we propose an XML-based method for specifying meta-data related to type mapping and wrapper generation that can be shared between our tools and IDL compilers. The component model of choice for this work is the Common Component Architecture (CCA) using the Scientific Interface Definition Language (SIDL), though the concepts presented can be applied to other models.
Date: January 1, 2001
Creator: Sottile, M. J. (Matthew J.) & Rasmussen, C. E. (Craig E.)
Partner: UNT Libraries Government Documents Department

Restructuring of RELAP5-3D

Description: The RELAP5-3D source code is unstructured with many interwoven logic flow paths. By restructuring the code, it becomes easier to read and understand, which reduces the time and money required for code development, debugging, and maintenance. A structured program is comprised of blocks of code with one entry and exit point and downward logic flow. IF tests and DO loops inherently create structured code, while GOTO statements are the main cause of unstructured code. FOR_STRUCT is a commercial software package that converts unstructured FORTRAN into structured programming; it was used to restructure individual subroutines. Primarily it transforms GOTO statements, ARITHMETIC IF statements, and COMPUTED GOTO statements into IF-ELSEIF-ELSE tests and DO loops. The complexity of RELAP5-3D complicated the task. First, FOR_STRUCT cannot completely restructure all the complex coding contained in RELAP5-3D. An iterative approach of multiple FOR_STRUCT applications gave some additional improvements. Second, FOR_STRUCT cannot restructure FORTRAN 90 coding, and RELAP5-3D is partially written in FORTRAN 90. Unix scripts for pre-processing subroutines into coding that FOR_STRUCT could handle and post-processing it back into FORTRAN 90 were written. Finally, FOR_STRUCT does not have the ability to restructure the RELAP5-3D code which contains pre-compiler directives. Variations of a file were processed with different pre-compiler options switched on or off, ensuring that every block of code was restructured. Then the variations were recombined to create a completely restructured source file. Unix scripts were written to perform these tasks, as well as to make some minor formatting improvements. In total, 447 files comprising some 180,000 lines of FORTRAN code were restructured. These showed significant reduction in the number of logic jumps contained as measured by reduction in the number of GOTO statements and line labels. The average number of GOTO statements per subroutine dropped from 8.8 before restructuring to 5.3 afterwards, a reduction of ...
Date: September 1, 2005
Creator: Mesina, George & Hykes, Joshua
Partner: UNT Libraries Government Documents Department


Description: The Fortran program TRANFT simulates transverse instabilities in circular accelerators using fast Fourier transform algorithms. It may be used for any particle type. Forces from transverse wakefields, longitudinal wakefields, and transverse detuning wakes are included, with linear transverse space charge forces included as a special case. This note describes the algorithms and their implementation in TRANFT.
Date: August 30, 2006
Partner: UNT Libraries Government Documents Department

Ax-1, a Computing Program for Coupled Neutronics-Hydrodynamics Calculations on the Ibm-704

Description: The presentation includes a very general outline of the program, a semi- detailed flow diagram which emphasizes the physics and control aspects of the calculation, and then a detailed flow diagram and listing of the program (which is written in Fortran). Explanatory notes accompany thc diagrams. Following the notes on the program, master lists detailing thc roles of the sense switches, sense lights, pauses, and stops are presented. The operating instructions are then given, followed by a sample problem, including detailed information on input data. The theoretical discussion has been kept primarily in the appendices, and is generally in outline form with references, rather than in full exposition. (auth)
Date: May 1, 1959
Creator: Okrent, D.; Cook, J. M.; Satkus, D.; Lazarus, R. B. & Wells, M. B.
Partner: UNT Libraries Government Documents Department

A ROSE-based OpenMP 3.0 Research Compiler Supporting Multiple Runtime Libraries

Description: OpenMP is a popular and evolving programming model for shared-memory platforms. It relies on compilers for optimal performance and to target modern hardware architectures. A variety of extensible and robust research compilers are key to OpenMP's sustainable success in the future. In this paper, we present our efforts to build an OpenMP 3.0 research compiler for C, C++, and Fortran; using the ROSE source-to-source compiler framework. Our goal is to support OpenMP research for ourselves and others. We have extended ROSE's internal representation to handle all of the OpenMP 3.0 constructs and facilitate their manipulation. Since OpenMP research is often complicated by the tight coupling of the compiler translations and the runtime system, we present a set of rules to define a common OpenMP runtime library (XOMP) on top of multiple runtime libraries. These rules additionally define how to build a set of translations targeting XOMP. Our work demonstrates how to reuse OpenMP translations across different runtime libraries. This work simplifies OpenMP research by decoupling the problematic dependence between the compiler translations and the runtime libraries. We present an evaluation of our work by demonstrating an analysis tool for OpenMP correctness. We also show how XOMP can be defined using both GOMP and Omni and present comparative performance results against other OpenMP compilers.
Date: January 25, 2010
Creator: Liao, C; Quinlan, D & Panas, T
Partner: UNT Libraries Government Documents Department


Description: ABS>The Gauss-Jordan, Choleski, congruent transformation, and rank annihilation methods for inverting large symmetric positive definite matrices were compared. An attempt was made to consider the effects of both condition and order of the matrix to be inverted on the closeness of the computed inverse to the exact inverse. Each method was programmed in FORTRAN using only single precision arithmetic. Then the error indicators were computed using double precision arithmetic so that the latter calculation was not a limiting factor. It was found that any one of the methods is satisfactory for a well-conditioned least squares matrix of order 10-30. However, when the matrix becomes ill- conditioned then the Gauss-Jordan method appears to be clearly superior (at least for the matrices studied). Algorithms and FORTRAN subroutines for each method are presented. (auth)
Date: May 13, 1963
Creator: Lietzke, M.H.; Stoughton, R.W. & Lietzke, M.P.
Partner: UNT Libraries Government Documents Department