A theme of my teaching at Knox is the integration of parallel
computing.
Now that multicore processors are the norm and large numbers of cores
are on the horizon, all students need to lear about concurrency and
parallelism.
Because of this, I have been trying to include relevant topics
throughout my courses.
I have previously received NSF support for a
project doing this
with high-level languages and a broad range of examples.
To continue the idea of promoting cool examples and assignments, I now
curate the collection of
Peachy Parallel Assignments,
which are peer-reviewed assignments to teach parallel programming
concepts selected according to the following criteria: (i) Tested,
(ii) Adoptable, (iii) Cool and inspirational.

Research

I work on a bunch of cool problems for my research.
Currently, my main focus is on resource management for
supercomputers.
I am currently finishing an NSF-supported
project to maximize
supercomputer performance on a new kind of system topology.
Supercomputers are really large expensive systems with many (10K+) processors.
They are used to solve important scientific and engineering problems.
My group doesn't worry so much about using such systems (Knox doesn't
have one...), instead focusing on the software required to run them.
Primarily, we evaluate our ideas via simulation, but we have done some
experiments on real systems at
Sandia National Labs.
Some of our work has been implemented in
SLURM, an open
source system for managing clusters.
If this sounds interesting to you, please contact me; I'm always
looking for students to work with.

I also do theoretical work in scheduling.
When taking a theoretical approach, I'm looking to prove desirable
properties of algorithms, the recipes computers use to solve problems.
These properties might be that the algorithm always finds an optimal
solution.
In scheduling, this is often not possible because the scheduler needs
to make decisions without knowing about tasks that are going to arrive
in the future.
In these cases, I try to find an algorithm that finds schedules that
are always nearly as good as the optimal schedule.
(It's not clear how you can do this without finding an optimal
solution, but it's actually possible for many problems.)