Graphics Processing Units (GPUs) are increasingly used to accelerate scientific applications. The state-of-the-art limits the adaptability of GPU kernels to both problem parameters and hardware characteristics. This makes writing high performance libraries for GPUs challenging. We address these challenges through Kernel Specialization (KS) which supports both user and hardware parameters and produces highly optimized GPU code. We apply KS to Particle Image Velocimetry (PIV), a technique used to obtain instantaneous velocity measurements in fluids for such diverse applications as aircraft design and artificial heart design. KS helps the user search PIV’s highly non-linear design space, supports a wide range of PIV parameters, and results in improved acceleration times over existing kernels.

Graphics processing units (GPUs) offer significant speedups over CPUs for certain classes of applications. However, programming for GPUs is challenging. There are many parameters that affect performance and their values may change depending on both problem instance and GPU hardware specifics. In addition, most GPU kernels are compiled once; performance optimizations are applied at application compile time. As a result, many GPU libraries and programs have limited adaptability to variations among problem instances and hardware configurations. These factors limit code reuse and the applicability of GPU computing to a wider variety of problems. This paper introduces GPGPU kernel specialization, a technique used to describe highly adaptable kernels that exhibit high performance across a wide range of programmer variables as well as different generations of GPUs. We also introduce our GPU Prototyping Framework (GPU-PF) for dynamic runtime generation of customized GPU kernels incorporating both problem and implementation-specific parameters. GPU-PF fully separates the GPU and CPU code so the GPU code can be compiled during program execution once all the parameters are known. This work explores the implementation and parameterization of two real world applications targeting two generations of NVIDIA CUDA-enabled GPUs using kernel specialization and GPU-PF: large template matching and cone-beam image reconstruction via backprojection. Starting with high performance GPU kernels that compare favorably to multi-threaded reference implementations, kernel specialization is shown to increase adaptability while providing performance improvements including improved run time and reduction in resource usage. Kernel specialization offers productivity benefits, improved library code, and a means to increase the parameterizability of GPGPU implementations.

Powerful multicomputer platforms that combine FPGAs and programmable processors promise tremendous performance benefits for applications that take advantage of these rapidly emerging architectures. Portable applications are desirable because they can be easily adapted to take advantage of different reconfigurable computing platforms. raditional practices, however, intertwine application code with hardware specific code such that porting entails a significant rewrite of the application and reuse is difficult. Vforce, based on the VSIPL++ standard, is an exten sible framework we created that allows the same application code to run on different reconfigurable computing platforms. Vforce offers application-level portability, framework-level extensibility to new hardware, and system-level run time resource management. In particular, Vforce supports very late binding of the application to a specific hardware platform such that binding does not occur until run time. This paper describes Vforce with a focus on late run time binding to a specific hardware platform. Results using Vforce to implement an FFT and a time domain adaptive beam- former are presented.

The combination of hardware acceleration and flexibility make FPGAs (field programmable gate arrays) important to image processing applications. There is also a need for efficient, flexible hardware/software codesign environments that can balance the benefits and costs of using FPGAs. Image processing applications often consist of pipeline of components where each component applies a different processing algorithm. Components can be implemented for FPGAs or software. Such systems enable an image analyst to work with either FPGA or software implementations of image processing algorithms for a given problem. The pipeline assignment problem chooses from alternative implementations of pipeline components to yield the fastest pipeline. Our codesign system solves the pipeline assignment problem to provide the most effective implementation automatically, so the image analyst can focus solely on choosing components, which make up the pipeline. However, the pipeline assignment problem is NP complete. An efficient, dynamic solution to the pipeline assignment problem is a desirable enabler of codesign systems which use both FPGA and software implementations. This paper is concerned with solving pipeline assignment in this context. Consequently, we focus on optimal and heuristic methods for fast (fixed time limit) runtime pipeline assignment are investigated. We present experimental finding for pipelines of twenty or fewer components, which show that in our environment, optimal runtime solutions are possible for smaller pipelines and nearly optimal heuristic solutions are possible for larger pipelines.

Computer ethics courses differ from technical courses in the manner in which they are taught and assessed. A common assignment in a computer ethics course is to write an essay that addresses a technical dilemma. Computer science faculty typically do not have training or experience in grading essays. The purpose of this paper is to present a scoring rubric that has been successfully used to grade and track students' knowledge development as they progress through a computer ethics course. Although this paper focuses upon a specific rubric, general principles will be emphasized to show how scoring rubrics can be used across different courses.

We present tools that support the run-time execution of applications that mix software running on networks of workstations and reconfigurable hardware. We use JHDL to describe the reconfigurable hardware, and JavaPorts to handle the communications between nodes in the network. The heterogeneous resources are handled by interposing a communication layer between the application and the hardware. The communication layer provides (i) the ability to modify the target hardware without modifying the application, (ii) co-design of the application and hardware, (iii) simulation of the entire system before the hardware design is complete, and (iv) remote execution so the application can reside on a different host from the hardware. We demonstrate the feasibility of this approach with a Java-based system which has a communication layer called the packet exchange platform (PEP). We present the system, describe the PEP and its implementation, and show how this approach has been applied to an image processing application.

The last few years has seen renewed interest in teaching programming-in-the-large (PIL) and programming-in-context of a larger existing program (PIC) throughout the computer science curriculum. Although these skills have been a focus of software engineering courses and capstone projects, there is an emphasis to teach these skills in other courses across the curriculum. This paper addresses incorporation of PIL and PIC in the programming language course, and presents specific PIC and PIL projects using an interpreter for SLic, a simple logic (declarative) language. SLic itself is part of a family of interpreters in MuLE, a software environment designed to support interpreter-based projects in the programming languages course. MuLE is written in DrScheme (from Rice's PLT software project distributed under the GNU Library General Public License) and runs under Windows 95/98/NT/2000, MacOS, and Unix/X.

Computers are faster and cheaper than ever before and at the same time user interface advances make powerful applications more accessible to the non-computer scientist. In a diverse range of industries, it is now essential for non-computer scientists to create, modify and interact with sophisticated computer applications. Although improved interfaces like high-level scripting languages and visual programming environments, have changed the skill set needed to use the computer, a conceptual understanding of computing and computer interfaces is still required. The very advances allowing direct computer use by non-computer scientists have actually increased the need for computer literacy. Thus computer science departments should expand and enhance course offerings to give non-majors the conceptual understanding and skills they need to become sophisticated users/developers in their particular fields. This paper describes a series of courses developed at Ithaca College that are designed to provide multimedia programming skills and concepts to liberal arts majors.

This paper presents an approach to introducing multiple programming language paradigms in the CS I course through the use of a single multiparadigm language. The approach uses multiple paradigms in the design and implementation of solutions to computer projects. The paper illustrates the approach by outlining a solution to a sample project which utilizes the imperative, object-oriented, and the functional paradigms.

This paper discusses the programming language course and presents an approach to some of the pedagogical challenges presented. We aim to expose students to all the concepts central to a traditional programming language course but also give experience with the implementation of various languages. To this end, we are developing a software environment, MULE, which supports this teaching goal. This paper gives an overview of MULE and discusses our recent experiences using MULE as a teaching tool.