Janche Sang

A performance comparison of event calendar algorithms: an empirical approach

We propose a suite of tests based on two‐state Markov chains for experimentally assessing the dynamic performance of a variety of simulation event calendar implementations. In contrast to previous studies based on the standard hold model for evaluation of performance statically, the proposed Markov hold model is more general and can be used to examine how different implementations respond dynamically to dependent sequences of insertion and deletion requests. The Markov hold model is used to conduct tests based on random, stressed, and correlated input sequences of requests, with performance measures including completion times, sensitivity to correlations, sensitivity to duplication, and efficiency of data‐handling. We apply these tests to fourteen different event calendar implementations. To demonstrate the utility of the proposed model, we also include a comparison of the event calendar algorithms on a token ring protocol with bursty Markovian packet‐traffic.

Development of CORBA-based engineering applications from legacy Fortran programs

Abstract A majority of scientific and engineering applications in aerodynamics and solid mechanics are written in Fortran. To reduce the high cost of software development, NASA researchers reuse most of the legacy Fortran codes instead of developing them from scratch in the numerical propulsion system simulation project. In this paper, we present an efficient methodology for integrating legacy applications written in Fortran into a distributed object framework. Issues and strategies regarding the conversion and wrapping of Fortran codes into common object request broker architecture objects are discussed. Fortran codes are modified as little as possible when they are decomposed into modules and wrapped as objects. We implement a wrapper generator which takes the Fortran application as input and generates the C++ wrapper files and interface definition language file. Tedious programming tasks for wrapping the codes can therefore be reduced.

An empirical analysis of debugging performance — differences between iterative and recursive constructs

An experiment involving more than 500 responses from over 250 subjects was conducted for the purpose of identifying differences in debugging performance among subjects who debugged iterative code and those who debugged recursive code. The subjects, classified as novices or experienced, based on programming experience, were asked to locate and fix a single logical bug in small segments of C code. Two different tasks – searching a linked list and copying a linked list, were used in the experiment. Statistical analyses yielded the following significant results: (i) 63.2% of all subjects located the bug in the recursive constructs compared to 41.5% for the iterative constructs (p<.00001); (ii) Grouped by task, and level of programmer experience, there were significantly more correct responses for the recursive code than for the iterative code (p<.02 in all four groupings); (iii) In terms of locating and fixing the bug, more responses were correct for the recursive version of the copy task than for the iterative version (p=.01875). Results of a t-test procedure showed no significant difference between the iterative and recursive constructs in terms of mean times needed for successful completion of the debugging tasks.

Factors related to the difficulty of learning to program in Java¿an empirical study of non-novice programmers

Abstract Due to its relative newness and popularity, Java is being taught to numerous non-novice programmers both in industry and in academia. Claims have been made that certain background characteristics of programmers relate to ease in learning Java. In this study, background information of 135 non-novice programmers was obtained, together with data relating to their difficulty of learning several different features of Java. Results of this study could be used by software project managers contemplating the use of Java, and by academicians involved in curricular planning.

Process mobility in distributed-memory simulation systems

Our focus is on the novel use of a process-oriented methodology in distributed-memory simulation systems. To the best of our knowledge, the few existing systems which adopt a process-view strictly use message-passing to effect process-interaction in distributed-memory settings. As a result, these systems avoid scenarios in which processes access passive but shared components. This can restrict the manner in which a system is modelled and hinder the phase of distributed model construction. In this paper, we propose an approach which utilizes mobile processes in distributed-memory simulation systems. Mobile processes can move around the system at will, with easy access to remote system components. The approach basically entails the migration of a requesting process with its timestamp to the remote site hosting the requested passive object. Major advantages of this approach include one-time transmission, fixed communication topology, and increased locality of reference. Early results based on lightweight processes show that the mobile process paradigm can be as efficient as the message-passing paradigm.

The Xthreads library: Design, implementation, and applications

The purpose of the Xthreads library is to provide a cheap concurrent programming environment. The design of the Xthreads library is patterned after Xinu, a small and elegant operating system in which all processes share a single address space and hence enjoy reduced overheads in process creation, interprocess communication, and so on. Our approach is to map the Xinu process structure into the Xthreads thread structure in a Unix-like process. Easy extensions and modifications to the Xthreads library are a major objective, accomplished through modularity and layering. We ported Xthreads to the nCUBE2, iPSC860 and RS6000 computers. This paper describes the library, our experiences with its design and implementation, the early performance measurements, and its applicability to simulation modeling.<<ETX>>

A CORBA-based development environment for wrapping and coupling legacy scientific codes

Within NASAs High Performance Computing and Communication (HPCC) program, the NASA Glenn Research Center (GRC) is developing a large scale, detailed simulation environment for the analysis and design of aircraft engines called the Numerical Propulsion System Simulation (NPSS). The three major aspects of modeling capabilities focused in NPSS, including integration of different engine components, coupling of multiple disciplines, and engine component zooming at appropriate level of fidelity, require relatively tight coupling of different analysis codes. Most of these codes in aerodynamics and solid mechanics are written in Fortran. Refitting these legacy Fortran codes with distributed objects can increase the code reusability. We describe our experiences in building a CORBA-based development environment for programmers to easily wrap and couple legacy Fortran codes. This environment consists of a C++ wrapper library to hide the details of CORBA and an efficient remote variable scheme to facilitate data exchange between the client and the server. We also report empirical performance evaluation results and describe current applications.

An improved computational algorithm for round-robin service

We present an efficient algorithm for effecting round-robin service in discrete-event simulation systems. The approach generalizes and improves upon a previous approach in which a single arrival and a single departure event is considered and handled at a time; further, the previous approach is already an improvement over naive round-robin scheduling currently in use in simulation libraries. The prior proposal offered a run-time complexity of O(n/sup 2/), because the processing of each event required an entire traversal of the job pool. We propose a generalized algorithm which includes the previous case and also accommodates burst arrivals and batch departures, further reducing run-time complexity to O(n log n). This is achieved through a detailed but efficient computation of multiple departure times, while simultaneously obviating the need for a job pool update with each departure. Empirical results are presented to compare performance with previously proposed algorithms.

Migrating legacy scientific applications towards CORBA-based client-server architectures

A distributed object is a reusable, self‐contained piece of software that cooperates with other objects on the same machine or across a network in a plug‐and‐play fashion via a well‐defined interface. The Numerical Propulsion System Simulation (NPSS) attempts to provide a collaborative aircraft engine design and simulation environment based on this concept. Many scientific applications in aerodynamics and solid mechanics are written in Fortran. Refitting this legacy Fortran code with distributed objects can increase code reusability. In this paper, we focus on the novel use of a remote variable scheme to help programmers migrate the Fortran code towards a client–server architecture. This scheme gives the client the capability of accessing variables at the server site and makes it easier for programmers to couple component engine code. Through the operator overloading features in C++, remote variables can be used in much the same way as traditional variables. The remote variable scheme adopts the lazy update approach and the prefetch method. Preliminary performance evaluation shows that communication overhead can be greatly reduced. Copyright

Mobile-Process-Based Parallel Simulation

Our focus is on the novel use of a process-oriented methodology in software systems for parallel simulation on distributed memory. To the best of our knowledge, the few existing systems which adopt a process view strictly use message passing to effect process interaction in distributed-memory settings. As a result, these systems avoid scenarios in which processes directly access passive but shared components. This can restrict the manner in which a system is modeled and hinder the phase of distributed model construction. In this paper, we propose an approach which utilizes mobile processes in distributed-memory simulation systems. The approach entails the migration of a requesting process with its timestamp to the remote site hosting the requested passive object. Major advantages of this approach include one-time transmission, fixed communication topology, and increased locality of reference. Empirical results based on lightweight processes show that the mobile process paradigm can be as efficient as the message-passing paradigm.