Search

Open XDMoD is an open source tool designed to facilitate the management of high-performance computing (HPC) systems. The Open XDMoD portal provides a rich set of analysis and charting tools that let users quickly display a wide variety of job accounting metrics over any desired timeframe. Two additional tools, which provide quality-of-service metrics and job-level performance data, have been developed and integrated with Open XDMoD to extend its functionality. These tools, combined in an integrated package through Open XDMoD, enable the comprehensive management of HPC resources, allowing HPC center personnel to ensure that the resource is operating efficiently and to determine what applications are running, how efficiently they're running, and what resources they're consuming, all of which are important to optimizing the HPC system. [ABSTRACT FROM AUTHOR]

SUMMARY The important role high-performance computing (HPC) resources play in science and engineering research, coupled with its high cost (capital, power and manpower), short life and oversubscription, requires us to optimize its usage - an outcome that is only possible if adequate analytical data are collected and used to drive systems management at different granularities - job, application, user and system. This paper presents a method for comprehensive job, application and system-level resource use measurement, and analysis and its implementation. The steps in the method are system-wide collection of comprehensive resource use and performance statistics at the job and node levels in a uniform format across all resources, mapping and storage of the resultant job-wise data to a relational database, which enables further implementation and transformation of the data to the formats required by specific statistical and analytical algorithms. Analyses can be carried out at different levels of granularity: job, user, application or system-wide. Measurements are based on a new lightweight job-centric measurement tool 'TACC_Stats', which gathers a comprehensive set of resource use metrics on all compute nodes and data logged by the system scheduler. The data mapping and analysis tools are an extension of the XDMoD project. The method is illustrated with analyses of resource use for the Texas Advanced Computing Center's Lonestar4, Ranger and Stampede supercomputers and the HPC cluster at the Center for Computational Research. The illustrations are focused on resource use at the system, job and application levels and reveal many interesting insights into system usage patterns and also anomalous behavior due to failure/misuse. The method can be applied to any system that runs the TACC_Stats measurement tool and a tool to extract job execution environment data from the system scheduler. Copyright © 2014 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

This paper is a case study of the effectiveness of component-oriented development for enhancing both productivity and performance for parallel programs. A process for converting monolithic applications into semantically composable components is described. The supporting software, the P-COM2 compositional compiler, is briefly described. The componentized version of Sweep3D is described. Productivity is illustrated by composing different instances of the Sweep3D code through automated composition of components using P-COM2. These instances, each of which targets improving performance for some execution environment or problem case, are examples of a family of instances which are composable from a modest set of components. It is found that customization of componentized codes by component-level adaptation may yield substantial performance improvement for specific execution environments. We identify and explain some of the benefits of component-oriented development for high-performance parallel systems. [ABSTRACT FROM AUTHOR]

The Grid is rapidly emerging as the dominant paradigm for wide area distributed application systems. As a result, there is a need for modeling and analyzing the characteristics and requirements of Grid systems and programming models. This paper adopts the well-established body of models for distributed computing systems, which are based upon carefully stated assumptions or axioms, as a basis for defining and characterizing Grids and their programming models and systems. The requirements of programming Grid applications and the resulting requirements on the underlying virtual organizations and virtual machines are investigated. The assumptions underlying some of the programming models and systems currently used for Grid applications are identified and their validation Grid environments is discussed. A more in-depth analysis of two programming systems, the Imperial College E-Science Networked Infrastructure (ICENI) and Accord using the proposed definitions' structure is presented. [ABSTRACT FROM AUTHOR]

The POEMS project is creating an environment for end-to-end performance modeling of complex parallel and distributed systems, spanning the domains of application software, runtime and operating system software, and hardware architecture. Toward this end, the POEMS framework supports composition of component models from these different domains into an end-to-end system model. This composition can be specified using a generalized graph model of a parallel system, together with interface specifications that carry information about component behaviors and evaluation methods. The POEMS Specification Language compiler, under development, will generate an end-to-end system model automatically from such a specification. The components of the target system may be modeled using different modeling paradigms (analysis, simulation, or direct measurement) and may be modeled at various levels of detail. As a result, evaluation of a POEMS end-to-end system model may require a variety of evaluation tools including specialized equation solvers, queuing network solvers, and discrete-event simulators. A single application representation based on static and dynamic task graphs serves as a common workload representation for all these modeling approaches. Sophisticated parallelizing compiler techniques allow this representation to be generated automatically for a given parallel program. POEMS includes a library of predefined analytical and simulation component models of the different domains and a knowledge base that describes performance properties of widely used algorithms. This paper provides an overview of the POEMS methodology and illustrates several of its key components. The methodology and modeling capabilities are demonstrated by predicting the performance of alternative configurations of Sweep3D, a complex benchmark for evaluating wavefront application technologies and high-performance, parallel architectures. [ABSTRACT FROM AUTHOR]

Looks at three challenges to system research and development in the Workshop on New Challenges and Directions for Systems Research sponsored by the United States National Science Foundation. Characteristics of computer system research. INSETS: Defining a research agenda;Outlook on applications: Reshaping relationships around the...;Outlook on networks: Experimentation to hardness the power of...;Outlook on systems architecture: How to use a billion...

Focuses on a study which developed and evaluated declarative primitives for rule-based computer programs that expanded opportunities for parallel execution. Definition of decomposition abstraction; How the primitives related to the data; How semantics of the primitives were presented.

Rule-based expert systems are increasingly used to monitor and control the operations of complex real-time systems which require intensive knowledge-decision processing and human expertise. These embedded Al systems must respond to events in the rapidly changing external environment so that the results of the expert system's computation in each monitor-respond cycle are valid in safely operating the real-time system. Determining how fast an expert system can respond under all possible situations is a difficult problem. We have developed an efficient analysis methodology for a large class of rule-based EQL programs to determine whether a program in this class has bounded response time. In particular, we have identified several sets of primitive behavioral constraint assertions: an EQL program which satisfies all constraints in one of these sets of assertions is guaranteed to have bounded response time. Here, we enhance the applicability of our analysis technique by introducing a facility with which the rule-based programmer can specify application-specific knowledge that is too difficult to be mechanically detected in the new language Estella in order to determine the performance of an even wider range of programs. We also describe efficient algorithms for implementing the analysis tools. [ABSTRACT FROM AUTHOR]

The problem of resource management for many processor architectures can be viewed as the problem of simultaneously updating data structures that hold system state. Consistency requirements of strict data structures introduce serialization in the resource management functions thereby leading to performance bottlenecks in highly parallel systems. Our approach is to examine the possibility of using structures with weakened specifications. Specifically, this paper introduces data structures that weaken the specification of a priority queue permitting it to be updated simultaneously by multiple processes. Two structures are proposed, the concurrent heap and the software banyan along with their associated algorithms for update. The algorithms are shown to possess attractive properties of simultaneous update and throughput. The results of simulation and actual implementations show that such data structures can improve the execution times of parallel algorithms quite significantly. These structures are proposed as possible basic building blocks for implementation of resource allocation in operating systems. [ABSTRACT FROM AUTHOR]

This paper reports on the initial experimental evaluation of the Reusability-Oriented Parallel programming Environment (ROPE), a software component reuse system developed at the University of Texas at Austin. ROPE helps the designer find and understand components by using a new classification method called structured relational classification. ROPE is a part of a development environment for parallel programs which uses a declarative/hierarchical graphical programming interface. This interface allows use of components with different levels of abstraction, ranging from design units to actual code modules. ROPE supports reuse of all of the component types defined in the development environment. The experimental design included metrics such as fraction of code in a program consisting of reused components, development time and error rates, and qualitative metrics such as user satisfaction and user perceived utility. The subjects for the experiments were undergraduate and graduate students in the Departments of Computer Sciences and Electrical and Computer Engineering. The development time was drastically cut for all programs and the average fraction of code in a given program which was reused from the ROPE library was about 80 percent. Programs developed with the aid of ROPE were found to have error rates far less than those developed without ROPE. These results, while gratifying, are not surprising. They show that ROPE attains a high level of reuse for programs of modest size and complexity. These experiments are the necessary first step in a systematic evaluation of reuse in the CODE/ROPE environment. [ABSTRACT FROM AUTHOR]

It has long been believed that object-oriented system structuring offers advantages for design and implementation of computer software systems with respect to comprehensibility, verifiability, maintainability, etc. The major obstacle to widespread use of object- oriented systems has been that their execution has been intrinsically inefficient due to excessive overhead. This paper contends that much of the execution overhead of object-oriented systems has been due to the implementation structure, that is, the objects are built upon a conventional layered software structure. This paper proposes a vertically partitioned structure for design and implementation of object-oriented systems and demonstrates their performance. We show that the application independent portion of the execution overheads in object-oriented systems can be less than the application independent overheads in conventionally organized systems built upon layered structures. Vertical partitioning implements objects through extended type managers. An extended type manager not only implements the functionality which defines a type but also implements all state management functions such as storage, access control and consistency management (including concurrency control, error detection, and fault recovery) for the occurrences of that type. Two key design concepts result in performance improvement: object semantics can be used, in the state management functions of an object type and atomicity is maintained at the type manager boundaries providing efficient recovery points. The performance evaluation is based upon a case study of a simple but nontrivial distributed real-time system application. Evaluation of overheads was accomplished by implementing system control, but not implementing application functionality for both conventional layered and vertically partitioned versions of the application. The results show a clear diminution of overhead in the vertically partitioned, object-oriented structured system over the functionally oriented, layered structured system. [ABSTRACT FROM AUTHOR]

This paper proposes a model or paradigm for the development of parallel algorithms, gives an example of the proposed paradigm, and displays algorithms developed by application of the technique. The algorithm for the merge of two ordered fists developed through application of this technique is thought to be original. The paradigm proposed is to create composite unit operations which combine data movement between data structures with a conventional operation such as compare or add. The composite operation constructed for this study is based upon partitioning the data elements into two linear lists. Exchange of data between adjacent elements in each list are then combined with compares and adds to complete the composite operations. This composite operation can be implemented on at least the following computational architectures. 1) SIMD with all processors sharing a common memory. 2) SIMD with local memories and a linear interconnection (circular pipeline or ring network of processors). 3) Vector processor with common memory, such as a CDC CYBER 205 or a Cray Research CRAY-1. The algorithms developed all have the property of linear speed-up with the number of processing elements. The algorithms developed include sorting, merging, selection among sets, set interconnection, set difference, subset testing, and string matching. [ABSTRACT FROM AUTHOR]

Discusses parallel architectures for computer systems. Usefulness of having several parts of a system simultaneously performing different parts of a task; Potential power in the systems; Models of computation; Languages and architectures; Connecting the elements; Commercial architectures; Specialized processors; Future architectures.

In this paper we describe a purely declarative method for introducing modularity into forward-chaining, rule-based languages. The method is enforced by the syntax of the language and includes the ability to parameterize the rule groups. We also describe the Venus programming environment, which implements the presented ideas. Drawing from two of three Venus applications developed to date, we illustrate how this form of modularity contributes directly to the resolution of certain software engineering problems associated with rule languages. We also discuss key implementation details and present performance data. [ABSTRACT FROM AUTHOR]

Styling of automotive upholstery is trending away from plain solid shade fabrics toward multicolor stripes and patterns. These color mixes range from tonals to bold contrasting shades. In piece dyed fabrics, tonals are readily achieved through the use of differential or step-dye acid-dyeable nylons or by combining yarns with different lusters (e.g., bright with dull) as practiced with polyester yarns. Color and white shades are obtained by combining nylon and polyester and only dyeing the nylon. Adding a color seal black yarn will extend the styling to three colors. Cross-dye shades, on the other hand, are more difficult to obtain because most cationic dyes do not meet the high dye lightfastness standards imposed by the car manufacturers. A few dyes, however, when applied to cationic-dyeable acrylic fibers meet exposure requirements. The selection, multifiber cross-dye procedures and limitations of these dyes for automotive fabric styling are discussed. [ABSTRACT FROM AUTHOR]