Brad Richards

Protocol-based data-race detection

Distributed Shared-Memory (DSM )c omputers, which partition physical memory among a collection of workstationlike computing nodes, are now a common way to implement parallel machines. Recently, there has been much interest in DSM machines that use software, instead of hardware, to implement coherence protocols to manage data replication and cache coherence. Software offers many advantages, not th el east of which is the possibility of adding significant functionality — such as race detection — to a protocol. This paper describes a new, transparent, protocol-base dt echnique for automatically detecting data races on-the-fly. An implementation of this approach in a DSM system running on a Thinking Machines CM-5 found data races in two of a set of five shared-memory benchmarks. Monitored applications had slowdowns ranging from 0–3 on 32 nodes. 1I ntroduction Race conditions arise in shared-memory parallel programs when accesses to shared memory are not properly synchronized. There has been much interest in efficient tools for detecting and reporting these race conditions since a lack of synchronization can lead programs to behave unpredictably. One promising approach to implementing these tools exploits recent fine-grained distributed shared-memory systems in which the coherence policies are implemented in software, instead of being rigidly encoded in hardware. Experiments have shown that the performance penalties for implementing coherence actions in software, instead of hardware, are relatively small (especially if there is hardware support for common operations [7, 17]), and that using the flexibility of software to tailor protocols to th en eeds of applications can result in tremendous performance increases [5]. Research platforms, such as FLASH [7] and Tempest [16], have paved the way for systems from Sequent [8] and DEC [20]. This paper describes a new use for the flexibility offered by software coherence policies: Implementing a transparent, This research supported by: NSF NYI Award CCR-9357779, with support from Sun Microsystems, and NSF Grant MIP-9625558. protocol-based technique for detecting data races on-the-fly. Fine graine dD SM systems enable efficient, real-time detection of data races, since they already contain a mechanism to invoke the coherence protocol in response to shared-memory accesses. The protocol need only be extended to monitor each access to shared memory and maintain a history of the accesses. The information in the histories is sufficient to detect data races on-the-fly in programs with barrieronly synchronization. Data races can be found in programs with pairwise synchronization by using the access histories in conjunction with additional sequencing information, such as vector timestamps [24], or by using techniques like lockset refinement [19]. Most previous race-detection techniques required support from a custom parallelizing compiler or other tools. This tied race detection to a particula rl anguage, implementation, and platform .T hefine-grained, protocol-based race detection schem ed escribed in this paper has low overheads and is completely independent of program source code. Race detection can be performed on programs written in any language, and on library routines for which the source may not be available. The approach therefore makes efficient racedetection available to a wider audience than was previously the case. 2B ackground

Teapot: language support for writing memory coherence protocols

Recent shared-memory parallel computer systems offer the exciting possibility of customizing memory coherence protocols to fit an applications semantics and sharing patterns. Custom protocols have been used to achieve message-passing performance---while retaining the convenient programming model of a global address space---and to implement high-level language constructs. Unfortunately, coherence protocols written in a conventional language such as C are difficult to write, debug, understand, or modify. This paper describes Teapot, a small, domain-specific language for writing coherence protocols. Teapot uses continuations to help reduce the complexity of writing protocols. Simple static analysis in the Teapot compiler eliminates much of the overhead of continuations and results in protocols that run nearly as fast as hand-written C code. A Teapot specification can be compiled both to an executable coherence protocol and to input for a model checking system, which permits the specification to be verified. We report our experiences coding and verifying several protocols written in Teapot, along with measurements of the overhead incurred by writing a protocol in a higher-level language.

LCM: memory system support for parallel language implementation

Higher-level parallel programming languages can be difficult to implement efficiently on parallel machines. This paper shows how a flexible, compiler-controlled memory system can help achieve good performance for language constructs that previously appeared too costly to be practical. Our compiler-controlled memory system is called Loosely Coherent Memory (LCM). It is an example of a larger class of Reconcilable Shared Memory (RSM) systems, which generalize the replication and merge policies of cache-coherent shared-memory. RSM protocols differ in the action taken by a processor in response to a request for a location and the way in which a processor reconciles multiple outstanding copies of a location. LCM memory becomes temporarily inconsistent to implement the semantics of C** parallel functions efficiently. RSM provides a compiler with control over memory-system policies, which it can use to implement a languages semantics, improve performance, or detect errors. We illustrate the first two points with LCM and our compiler for the data-parallel language C**.

Analyzing Student Work Patterns Using Programming Exercise Data

Web-based programming exercises are a useful way for students to practice and master essential concepts and techniques presented in introductory programming courses. Although these systems are used fairly widely, we have a limited understanding of how students use these systems, and what can be learned from the data collected by these systems. In this paper, we perform a preliminary exploratory analysis of data collected by the CloudCoder programming exercise system from five introductory courses taught in two programming languages across three colleges and universities. We explore a number of interesting correlations in the data that confirm existing hypotheses. Finally, and perhaps most importantly, we demonstrate the effectiveness and future potential of systems like CloudCoder to help us study novice programmers.

Information technology fluency in practice

Recent work has stressed the importance of fluency with information technology (IT) in the modern world. This report presents a set of context profiles that detail courses and programs to realize increased IT fluency across a small sampling of academic institutions. The goal is to provide some representative examples for other schools interested in addressing the issues associated with IT fluency.

Applying data structures in exams

It is important for students to be able to select and apply the appropriate data structure for the problem to be solved. Testing this knowledge on exams can be difficult, however. We examined 59 data structures final exams and found only 36 that contained questions involving the application of data structures. To promote assessment of this knowledge in the data structures course, we present a framework for classifying apply exam questions, with illustrations from the exams collected. We then show how a number of questions can be developed by varying a single rich apply question along the dimensions of this framework

Bugs as features: teaching network protocols through debugging

Being exposed to well-written code is a valuable experience for students—especially when the code is larger or more complex than they are currently capable of writing. In addition to the mechanics of a particular computation, students learn organization and documentation skills, and general concepts illustrated by the specific program. However, to obtain these benefits, students must thoroughly familiarize themselves with the code. This paper describes recent successes using software bugs as a means to force familiarization with network protocol code. The bugs become tools by which the students learn the inner workings of network protocols. As a side benefit, the approach provides a concrete basis for the discussion of debugging approaches and techniques. The technique is appropriate for any course involving programming, and is especially good for upper-level courses like networks, operating systems, and parallel and distributed programming, where difficult concepts can be illustrated via sample programs.

Stories of change: How educators change their practice

Innovative tools and teaching practices often fail to be adopted by educators in the field, despite evidence of their effectiveness. Naïve models of educational change assume this lack of adoption arises from failure to properly disseminate promising work, but evidence suggests that dissemination via publication is simply not effective. Instead of studying the adoption or rejection of a particular intervention, this paper turns the problem around. We asked educators to describe changes they had made to their teaching practice and analyzed the resulting stories to learn more about: the kinds of changes being made, their motivations for changing their practice, and the means by which they learned of pedagogical innovations. Of the 99 change stories analyzed, only three demonstrate an active search for new practices or materials on the part of teachers, and published materials were consulted in just eight of the stories. Most of the changes occurred locally, without input from outside sources, or involved only personal interaction with other educators. These results have important implications for educational developers, or researchers wishing to propagate information about new teaching materials or techniques.

DCER: sharing empirical computer science education data

Data sharing is common, and sometimes even required, in other disciplines. Creating a mechanism for data sharing in computer science education research will benefit both individual researchers and the community. While it is easy to say that data sharing is desirable, it is much more difficult to make it a practical reality. This paper reports on an examination of the issues involved by researchers who gathered at a one-day NSF-sponsored workshop held in connection with SIGCSE 2008. We outline the advantages and challenges of developing a repository, show how the challenges have been addressed by repositories in other fields, describe a possible prototype system for empirical computer science education data, and discuss how to move the project forward.

Teaching wireless networking with limited resources

The rapid growth of wireless communications services and networks has led departments to consider offering elective courses on the topic. Textbooks exist that can help support such a course, but providing students with hands-on wireless networking experience can be difficult and expensive.We present the outline of a wireless networking course that can be offered with minimal resources, and describe our experiences using the approach. The students who took the initial offering of the course gained hands-on experience with wireless networking, did traditional sockets programming, and acquired the theoretical foundations of both traditional and wireless networking.Students implement a simplified IEEE 802.11 Wireless Ethernet MAC layer as a course project. In our case, the implementations took advantage of the Cybiko, a