Computer Science Education

Active Learning Materials for Computer Organization and Architecture

Surveys of computer science and engineering instructors have indicated that two of the common reasons they do not adopt research-based instruction strategies are preparation time and lack of materials. This lack of materials to support research-based instruction was evident in Computer Architecture & Organization (AR). We are creating, piloting, revising, and sharing activities inspired by Process Oriented Guided Inquiry Learning (POGIL). POGIL is a research-based instruction strategy that comprises self-managed teams, development of process skills, and activities designed based on a theory of instruction called learning cycles.

Find out more about the activities. Or, find these and other POGIL activities for computer science at CS-POGIL.

Systems for high-performance and data-intensive computing

Fast query processing with parallel languages

Recent efforts have shown that compiling queries to machine code for a single-core can remove iterator and control overhead for significant performance gains. So far, systems that generate distributed programs only compile plans for single processors and stitch them together with messaging. The low-level compiler can only look at these fragments in isolation! We are investigating a different approach with Radish: take advantage of parallel language compilers and runtimes by generating parallel programs from queries.

Verified relational query optimizers

Query optimizers need to apply transformations to plans to find the fastest implementation. How do we know the resulting program is correct and our query will return the intended answer? In correctness-critical applications, testing may not be sufficient to ensure queries return the right answer. Crimp is a query transformer written in Coq that generates verified imperative (C-like) implementations of query specifications (e.g., programs written in SQL).

Productivity and performance for parallel irregular applications

A number of important, data intensive applications are irregular. These applications may involve irregular and unbalanced data structures (such as natural graphs) and unpredictable data accesses. A large effort is usually required to achieve good performance for such programs, the key being supporting enough concurrency to keep the machine (efficiently) busy. The programmer must write non-application logic like batching/sorting communication and managing fine-grained synchronization.

Our system, Grappa, is a C++11 library that addresses this problem by providing an intuitive and flexible PGAS programming model and runtime support for high-performance irregular data access.

Dissertation

Papers

Peer-reviewed Posters and Demos