Cybersecurity education has been emphasized by several national organizations in the United States, including the National Academy of Engineering, which recognizes securing cyberspace as one of the 14 Engineering Grand Challenges. To prepare students for such challenges and to enhance cybersecurity education opportunities at our large research university, we implemented an NSF-funded cybersecurity education project. This project is a collaborative effort between faculty and graduate students in the Engineering Education, Computer Science (CS) and Computer Engineering (CPE) departments at a major US research university. In this effort, we integrated cybersecurity learning modules into multiple existing core CS and CPE courses following Jerome Bruner's spiral-theory model, which has previously been used to reformulate several academic curricula. In this paper, we present our cybersecurity curriculum initiative, describe the spiral-theory based process we developed to implement the curriculum and provide an in-depth description of four reusable cybersecurity learning modules that we developed. A core tenet of spiral theory holds to revisit topics as students advance through their curriculum. This work applies this approach to Cybersecurity education by carefully designing the learning objectives of the modules and its contents. For evaluating these learning modules we implemented pre and post-tests to assess students' technical knowledge, their perceptions towards the modules' learning objectives, and how it influenced their motivation to learn cybersecurity. Our findings are overwhelmingly positive and the students' feedback has helped us improve these learning modules. Since its inception, our initiative has educated more than $2\,000$ students and is currently being used to revise the affected courses' syllabi.

The current emphasis on cybersecurity worldwide, demonstrates the importance of this topic. This poster describes a unique NSF funded project that aims to create cybersecurity education opportunities at Virginia Tech (VT). It is a collaborative effort among faculty and graduate students in the Engineering Education, Computer Science (CS), Electrical and Computer Engineering (includes two majors, Electrical Engineering (EE) and Computer Engineering (CPE)) Departments, and the Hume Center in the College of Engineering at VT. The goal is to integrate cybersecurity modules into eight required CS and CPE courses, from freshman to junior levels, utilizing Jeremy Bruner's spiral-theory-based1,2 curriculum model. A spiraling theme of "handling threats to software for securing information" is chosen that will be returned to repeatedly as learners advance in their knowledge and intellectual capacity. Cybersecurity goals of the Confidentiality, Integrity, Availability, Authenticity, Anonymity, Assurance (CIA/AAA) triad, as appropriate for various academic levels, are adopted to develop the cybersecurity modules. Each module engages students in an authentic activity that reinforces the cybersecurity concepts. The project includes an engineering education research component, which is focused on evaluating the effectiveness of the curriculum in enhancing students' knowledge, skills, and motivation in cybersecurity concepts. The first year of the project has been completed by introducing cybersecurity modules into four courses (CS: Introduction to Software Design, and Software Design and Data Structures, and CPE: Engineering Problem Solving with C++, and Data Structures and Algorithms) impacting ~1600 students. The details of curriculum development, implementation and, preliminary findings of the research will be presented.

We present core elements of Samhita, a new user level software distributed shared memory (DSM) system. Our work is motivated by two observations. First, the rise of many-core architectures is producing a growing emphasis on threaded codes to achieve performance. Second, architectural trends, especially in high performance interconnects, suggest a new look at overcoming the bottlenecks that have hindered DSM performance. Samhita leverages the capabilities of remote direct memory access (RDMA) interconnects, and views the problem of providing a shared global address space as a cache management problem. Performance results on two 256 processor clusters demonstrate scalability on micro benchmarks and two real applications. The results are the largest scale tests and achieve the highest performance of any DSM system reported to date.

Speculative execution at coarse granularities (e.g., code-blocks, methods, algorithms) offers a promising programming model for exploiting parallelism on modern architectures. In this paper we present Anumita, a framework that includes programming constructs and a supporting runtime system to enable the use of coarse-grain speculation to improve program performance, without burdening the programmer with the complexity of creating, managing and retiring speculations. Speculations may be composed by specifying surrogate code blocks at any arbitrary granularity, which are then executed concurrently, with a single winner ultimately modifying program state. Anumita provides expressive semantics for winner selection that go beyond time to solution to include user-defined notions of quality of solution. Anumita can be used to improve the performance of hard to parallelize algorithms whose performance is highly dependent on input data. Anumita is implemented as a user-level runtime with programming interfaces to C, C++, Fortran and as an OpenMP extension. Performance results from several applications show the efficacy of using coarse-grain speculation to achieve (a) robustness when surrogates fail and (b) significant speedup over static algorithm choices.

Abstract Despite using multiple concurrent processors, a typical high‐performance parallel application is long‐running, taking hours, even days to arrive at a solution. To modify a running high‐performance parallel application, the programmer has to stop the computation, change the code, redeploy, and enqueue the updated version to be scheduled to run, thus wasting not only the programmer's time, but also expensive computing resources. To address these inefficiencies, this article describes how dynamic software updates (DSU) can be used to modify a parallel application on the fly, thus saving the programmer's time and using expensive computing resources more productively. The net effect of updating parallel applications dynamically can reduce the total time that elapses between posing a problem and arriving at a solution, otherwise known as time‐to‐discovery. To explore the benefits of dynamic updates for high performance applications, this article takes a two‐pronged approach. First, we describe our experiences of building and evaluating a system for dynamically updating applications running on a parallel cluster. We then review a large body of literature describing the existing state of the art in DSU and point out how this research can be applied to high‐performance applications. Our experimental results indicate that DSU have the potential to become a powerful tool in reducing time‐to‐discovery for high‐performance parallel applications. Copyright © 2010 John Wiley & Sons, Ltd.

Pattern-based Representation (PBR) is a novel approach to improving the performance of Sparse Matrix-Vector Multiply (SMVM) numerical kernels. Motivated by our observation that many matrices can be divided into blocks that share a small number of distinct patterns, we generate custom multiplication kernels for frequently recurring block patterns. The resulting reduction in index overhead significantly reduces memory bandwidth requirements and improves performance. Unlike existing methods, PBR requires neither detection of dense blocks nor zero filling, making it particularly advantageous for matrices that lack dense nonzero concentrations. SMVM kernels for PBR can benefit from explicit prefetching and vectorization, and are amenable to parallelization. We present sequential and parallel performance results for PBR on two current multicore architectures, which show that PBR outperforms available alternatives for the matrices to which it is applicable.

Most conventional parallel job schedulers only support static scheduling thereby restricting schedulers from being able to modify the number of processors allocated to parallel applications at runtime. The drawbacks of static scheduling can be overcome by using scheduling policies that can exploit dynamic resizability in distributed-memory parallel applications and a scheduler that supports these policies. The scheduler must be capable of adding and removing processors from a parallel application at runtime. This ability of a scheduler to resize parallel applications increases the possibilities for parallel schedulers to manage a large cluster. Our ReSHAPE framework includes an application scheduler that supports dynamic resizing of parallel applications. In this paper, we illustrate the impact of dynamic resizability on parallel scheduling. We propose and evaluate new scheduling policies made possible by our ReSHAPE framework. Experimental results show that these scheduling policies significantly improve individual application turn around time as well as overall cluster utilization.

A traditional application scheduler running on a parallel cluster only supports static scheduling where the number of processors allocated to an application remains fixed throughout the lifetime of the job. Due to unpredictability in job arrival times and varying resource requirements, static scheduling can result in idle system resources thereby decreasing the overall system throughput. In this paper we present a prototype framework called ReSHAPE, which supports dynamic resizing of parallel MPI applications executed on distributed memory platforms. The framework includes a scheduler that supports resizing of applications, an API to enable applications to interact with the scheduler, and a library that makes resizing viable. Applications executed using the ReSHAPE scheduler framework can expand to take advantage of additional free processors or can shrink to accommodate a high priority application, without getting suspended. Experimental results show that the ReSHAPE framework can improve individual job turn-around time and overall system throughput.

Iterative solutions of sparse problems often achieve only a small fraction of the peak theoretical performance on modern architectures. This problem is highly challenging because sparse matrix storage schemes require data to be accessed irregularly, which leads to massive cache misses. Furthermore, the inner loop of typical sparse matrix operations accesses only a small and variable amount of data, which not only leads to low utilization of floating point registers, but also prevents optimization techniques that improve instruction level parallelism (ILP), such as unroll and jam. Although a general solution to this problem has not been found, significant performance improvements can be made for at least one important special case, namely large ensemble computations, which run the same application repeatedly on different data sets. In this paper, we present the Operation Stacking Framework (OSF), which runs multiple sparse problems simultaneously, stacking their data and solving them as one, thus improving both cache and ILP utilization. Programmers can use stacked solvers transparently in their applications. Moreover, OSF provides an API that makes it simple to convert existing solvers such as the conjugate gradient (CG) and generalized minimal residual (GMRES) methods into a stacked form. Our experimental results show that stacking can reduce the number of L2 misses by 25% to 44%, resulting in performance improvements of up to 1.95x with an average of 1.60x for stacked CG and GMRES algorithms on a single CPU.

Driven by the increasing componentization of scientific codes, the deployment of high-end system infrastructures such as the grid, and the desire to support high level problem solving primitives, application composition systems have become prevalent in computational science practice. We present the adaptive code kitchen which, as the name connotes, is a loose collection of capabilities to help realize complex adaptive composition scenarios. These include function interception, continuation modification, dynamic process checkpointing and rollback, and runtime recommendation. Using these broad primitives, a computational scientist can specify many 'recipes' of adaptivity as complete control systems around native object codes. Runtime systems support then enables loading and linking of native code components, monitoring of performance indicators, consulting a recommender system for algorithmic decisions, and dynamically updating application components in response to the recommendations. We present the architecture of the adaptive code kitchen and the key enabling technologies with brief mention of the applications that will be investigated henceforth during the course of the project.

Abstract As the power of computational Grids increases, there is a corresponding need for better usability for large and diverse communities. The focus in this paper is on supporting multidisciplinary communities of scientists and engineers. We discuss requirements for Grid computing environments (GCEs) in this context, and describe several core support technologies developed to meet these requirements. Our work extends the notion of a programming environment beyond the compile–schedule–execute paradigm, to include functionality such as collaborative application composition, information services, and data and simulation management. Systems designed for five different applications communities are described. These systems illustrate common needs and characteristics arising in multidisciplinary communities and motivate a high‐level design framework for building GCEs that meet those needs. Copyright © 2002 John Wiley & Sons, Ltd.

In this paper we extend previous work in mining recommendation spaces based on symbolic problem features to PDE problems with continuous-valued attributes. We identify the research issues in mining such spaces, present a dynamic programming algorithm form the data-mining literature, and describe how a priori domain metaknowledge can be used to control the complexity of induction. A visualization aid for continuous-valued recommendation spaces is also outlined. Two case studies are presented to illustrate our approach and tools: (i) a comparison of an iterative and a direct linear system solver on nearly singular problems, and (ii) a comparison of two iterative solvers on problems posed on nonrectangular domains. Both case studies involve continuously varying problem and method parameters which strongly influence the choice of best algorithm in particular cases. By mining the results from thousands of PDE solves, we can gain valuable insight into the relative performance of these methods on similar problems.

Three approaches to parallelizing important components of the mathematical software package ELLPACK are considered: an explicit approach using compiler directives available only on the target machine, an automatic approach using an optimizing and parallelizing precompiler, and a two-level approach based on extensive use of a set of low level computational kernels. The focus is on shared memory architectures. Each approach to parallelization is described in detail, along with a discussion of the effort involved. Performance on a test problem, using up to sixteen processors of a Sequent Symmetry S81, is reported and discussed. Implications for the parallelization of a broad class of mathematical software are drawn.

Embedding algorithms used to solve nonlinear systems of equations do so by constructing a continuous family of systems and solving the given system by tracking the continuous curve of solutions to the family. Solving nonlinear equations by a globally convergent embedding algorithm requires the evaluation and factoring of a Jacobian matrix at many points along the embedding curve. Ways to optimize the Jacobian matrix on a hypercube are described. Several static and dynamical strategies for assigning components of the Jacobian to processors on the hypercube are investigated. It is found that a static rectangular grid mapping is the preferred choice for inclusion in a robust parallel mathematical software package. The static linear mapping is a viable alternative when there are many common subexpressions in the component evaluation, and the dynamic assignment strategy should only be considered when there is large variation in the evaluation times for the components, leading to a load imbalance on the processors.>

We describe the Recursive Subdivision (RS) method-an efficient and effective adaptive grid scheme for two-dimensional elliptic partial differential equations (PDEs). The RS method generates a new grid by recursively subdividing a rectangular domain. We use a heuristic approach which attempts to equidistribute a given density function over the domain. The resulting grid is used to generate an adaptive grid domain mapping (AGDM), which may be applied to transform the PDE problem to another coordinate system. The PDE is then solved in the transformed coordinate system using a uniform grid. We believe parallelism is most easily exploited when computations are carried out on uniform grids; the AGDM framework allows the power of adaptation to be applied while still preserving this uniformity. Our method generates good adaptive grid domain mappings at a small cost compared to the cost of the entire computation. We describe the RS algorithm in detail, briefly describe the AGDM framework, and illustrate the effectiveness of our scheme on several realistic test problems.

ELLPACK is a versatile, very high-level language for solving elliptic partial differential equations. Solving elliptic problems with ELLPACK typically involves a process in which one repeatedly computes a solution, analyzes the results, and modifies the solution technique. Although this process is best suited for an interactive environment, ELLPACK itself is batch oriented. With this in mind, we have developed Interactive ELLPACK, an extension of ELLPACK that provides true interactive elliptic problem solving by allowing the user to interactively build grids, choose solution methods, and analyze computed results. Interactive ELLPACK features a sophisticated interface with window- ing, color graphics output, and graphics input.

THE MACROPROCESSORA macroprocessor is a tool for substituting values from a symbol table into a text.Thus, if DATE has the value 'JULY 10, 1983' and PLACE has the value 'HONG KONG', then the text fragment DATELINE: $DATE, $PLACE.