As the field of quantum computing rapidly advances, there is a growing demand for skilled professionals adept in quantum computing and programming. Recognizing this need, in this paper, we share our experiences teaching an introductory-level quantum computing course to students at Cleveland State University (CSU). The course integrates dedicated hands-on programming labs, allowing students to verify their experimental results with corresponding examples from the textbook. These labs cover a diverse range of topics, including fundamental elements such as quantum gates and circuits, quantum key distribution protocols, and quantum algorithms. As educators, our goal is to share teaching insights and resources with fellow instructors in the field. This article elucidates the rationale behind the design of each experiment, providing a deeper understanding of quantum computing.

In recent years, persistent homology has become an attractive method for data analysis. It captures topological features, such as connected components, holes, and voids from point cloud data and summarizes the way in which these features appear and disappear in a filtration sequence. In this project, we focus on improving the performance of Eirene, a computational package for persistent homology. Eirene is a 5000-line open-source software library implemented in the dynamic programming language Julia. We use the Julia profiling tools to identify performance bottlenecks and develop novel methods to manage them, including the parallelization of some time-consuming functions on multicore/manycore hardware. Empirical results show that performance can be greatly improved.

In recent years, persistent homology has become an attractive method for data analysis. It captures topological features, such as connected components, holes, voids, etc., from a point cloud by finding out when these features appear and disappear in the filtration sequence. In this project, we focus on improving the performance of Eirene, a fancy computational persistent homology package. Eirene is a 5000-line open-source software implemented by using the dynamic programming language Julia. We use the Julia profiling tools to identify the performance bottlenecks and develop different methods to manage the bottlenecks, including the parallelization of some time-consuming functions on the multicore/manycore hardware. The empirical results show that the performance can be greatly improved.

Within NASA's 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.

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 these legacy Fortran codes with distributed objects can increase the code reusability. The remote variable scheme provided in NPSS helps programmers easily migrate the Fortran codes towards a client-server platform. This scheme gives the client the capability of accessing the variables at the server site. 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.

Abstract 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 © 2001 John Wiley & Sons, Ltd.

With the advances of wireless communication technology, using the wireless LAN as a platform to perform distributed network computing becomes feasible. We study the characteristics of end-to-end communication over wireless links. With the advantage of reduced bandwidth competition in each LAN segment separated by the wireless bridges, and with the overlap of wireless and wired communications, an analytical comparison showed that the group communications over wireless links can be more efficient than over a single segment wired LAN. We conducted experiments of running distributed applications and the results showed that with the support of threads, wireless network computing can achieve the same performance as the wired networks. Furthermore, the statistical results from our survey showed that the users cannot tell the difference between wireless and wired settings in terms of the data access speed.

Describes a technique to provide multi-threading an an enhanced C language. In contrast to the traditional design of a thread library, which usually utilizes a few lines of assembly code to effect context-switching between threads, the technique we use is based on compile-time program transformations and a run-time library. Since this approach transforms a thread's physical states into logical forms, thread migration in a heterogeneous distributed environment becomes practically feasible. Performance measurements of the current implementation are reported.

Abstract The Si lightweight‐process based system for simulating process interactions is an enhancement to the C programming languge in the form of library primitives with sets of predefined data structures. The Si system encapsulates an existing lightweight‐process library to provide a discrete‐event simulation environment supporting the process view. It was developed as a research testbed for investigating methods which support simulations efficiently. Easy extensions and modifications to the Si system are a major design objective, accomplished through modularity and layering. This paper describes the system, our experiences with its implementation, and its applicability to simulation modeling. We report on performance measurements of different implementations of the simulation scheduler, and of different algorithms for simulating service disciplines.

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.>

Abstract 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.