My primary research area is programming languages, in which I study concurrency, visualization and debugging, polymorphism, and persistence.
New computers support multiple simultaneous threads of execution in the form of multi-threading, multi-core, and multi-processors; programming multiple threads is more complex than a single thread, and is called concurrent programming. My initial work in concurrency began by providing concurrency for the C language, called the μSystem. While much was learned about designing and constructing thread libraries during this project, the work was abandoned because it is impossible to construct statically type-safe direct communication among threads in C.
Subsequently, the work shifted to C++ because of its object-oriented features allowing concurrent communication to be statically type-safe. However, it is still impossible to add concurrency without extending C++; as a result, a new concurrent dialect of C++ was created, called μC++.
Getting a concurrent program to work correctly, efficiently and with maximal parallelism can be very difficult. I develop techniques and tools to help understand the dynamic behaviour of a concurrent program with the goal of increasing program performance. This work has produced a toolkit for monitoring, visualizing, and debugging μC++ programs, called MVD.
The ability to write generic reusable programs, called polymorphism, is fundamental to advanced software engineering. I am interested in static type-systems providing polymorphism without the use of subtyping. The problem with subtyping is that it imposes significant restrictions on reuse when static type-checking is required. This work has resulted in a new dialect of C language, called Cforall, which adds parametric polymorphism and extensive overloading to provide a more general type-system.
Data structures containing pointers (versus values) cannot be stored directly to/from disk, because pointers represent absolute locations in memory. I am also interested in memory-mapped single-level stores, which allow data, including pointers, to be transparently transferred to and retrieved from disk storage implicitly via virtual memory. To handle the address consistency problem, i.e., pointers to addresses that have changed location, exact positioning of data is used so no relocation or adjusting of pointers is necessary. This work has produced a toolkit, called μDatabase, for building persistent data structures using the exact-positioning approach to memory-mapped single-level stores.
Back to PLG Home Page