Introducing Flexible Assessment into a Computer Networks Course: A Case Study [PDF]

Journal of Mathematics and Science: Collaborative Explorations: Vol. 19: No. 1, Article 5.

With overall positive results and limited drawbacks, I have adapted modern pedagogical techniques to address a common difficulty encountered when teaching a computer networks course. Due to the tiered nature of the skills taught in the course, students often fail unnecessarily. Using mastery learning, competency-based education, and specifications grading as a foundation, I have developed a course that allows students with varied skills and abilities to pass. The heart of this approach is the flexible assessment of programming assignments which eliminates due dates and allows students to have their work graded and regraded without penalty. Flexible assessment also defines an interactive approach to grading which gives students immediate formative feedback and does not penalize initial failure. Using these instructional techniques, I improved the course completion rate by 30 percentage points compared to similar courses. Flexible assessment works best for upper-level courses that are not prerequisite courses because a student can pass without mastering all of the skills; their grade reflects the percentage of skills mastered rather than an average of the competency of all the skills taught. Drawbacks of flexible assessment include limited time for in-class preparation, limited opportunities to review programming assignments and the increase in time required for grading.

Markov Bot: Automated Text Generation [PDF]

Consortium for Computing Sciences in Colleges: Southeastern Region, November 2022

Markov Bot is a project which uses regular expressions, Markov chains, and n-grams to generate text in the style of a specific author.  This is a moderately difficult project which I assign as a capstone for CS2. It uses several data structures and provides nice scaffolding to support students in developing a reasonable complex project

Harmony [PDF]

Computing Frontiers, May 2013

Harmony is a technique for extracting the multiprocessor scheduling policy from commodity operating systems. This technique combines high-level synthetic workloads with low-level instrumentation to fingerprint an operating system's multiprocessor scheduling policy. Harmony can be used to detect simple aspects of multiprocessor scheduling policy, like the expected latency in detecting processor load imbalances. This tool can also be used to infer information about more complex multiprocessor scheduling behavior, such as how heterogeneous workloads are distributed amongst processors. We demonstrate Harmony's ability to extract multiprocessor scheduling policy by performing an analysis of three Linux schedulers: O(1), CFS, and BFS. Using Harmony, we discover some interesting facets of multiprocessor scheduling policy under Linux. Most intriguing, perhaps, is BFS's policy of providing increased processor affinity to low priority processes.

Towards Transparent CPU Scheduling [PDF]

Doctoral Dissertation, August 2011

In this thesis we propose using the scientific method to develop a deeper understanding of CPU schedulers; we use this approach to explain and understand the sometimes erratic behavior of CPU schedulers. This approach begins with introducing controlled workloads into commodity operating systems and observing the CPU scheduler's behavior. From these observations we are able to infer the underlying CPU scheduling policy and create models that predict scheduling behavior. We have made two advances in the area of applying scientific analysis to CPU schedulers. The first, CPU Futures, is a combination of predictive scheduling models embedded into the CPU scheduler and user-space controller that steers applications using feedback from these models. We have developed these predictive models for two different Linux schedulers (CFS and O(1)), based on two different scheduling paradigms (timesharing and proportional-share). Using three different case studies, we demonstrate that applications can use our predictive models to reduce interference from low-importance applications by over 70%, reduce web server starvation by an order of magnitude, and enforce scheduling policies that contradict the CPU scheduler's. Harmony, our second contribution, is a framework and set of experiments for extracting multiprocessor scheduling policy from commodity operating systems. We used this tool to extract and analyze the policies of three Linux schedulers: O(1), CFS, and BFS. These schedulers often implement strikingly different policies. At the high level, the O(1) scheduler carefully selects processes for migration and strongly values processor affinity. In contrast, CFS continuously searches for a better balance and, as a result, selects processes for migration at random. BFS strongly values fairness and often disregards processor affinity.

CPU Futures [TechReport]

Technical Report, 2010

CPU Futures is a system designed to enable application control of scheduling for server workloads, even during system overload. CPU Futures contains two components: a novel in-kernel herald that anticipates application CPU performance degradation and a user-level feedback controller that responds to these predictions on behalf of the application. In combination, these two subsystems enable fine-grained application control of scheduling; with this control applications can define their own policies for avoiding or mitigating performance degradation under overload. We implement CPU Futures within two different Linux schedulers, and show its utility by building two case studies on top of the system: Empathy, which limits the CPU interference caused by low-importance batch programs, and SheepDog, which prevents web requests from starving on a heavily-loaded web server. Through experiment, we find that CPU Futures are not only useful, but also have a low-overhead.

Logical Image Migration Based on Overlays [TechReport]

Technical Report, 2006

Virtual machine technology is becoming an increasingly popular vehicle for enabling process and service migration. Many migration frameworks rely on a distributed file system to avoid worrying about the burden of migrating a large virtual disk. While this assumption is valid in some contexts, there are other environments where it is not feasible. In these cases, disk migration becomes the primary bottleneck for achieving efficient migration. We discuss the design, implementation, and evaluation of LIMBO, a system for efficient migration of VM local file systems. We've found that overlay-based migration using a copy-on-write block device can significantly improve migration costs while imposing a small amount of overhead on file system operations.