George Kola PhD

Research Interests:
Operating Systems, Distributed Systems, Networking, Performance Analysis and Performance Modeling

Course Projects

• Comparison of Native XML Databases and XML-enabled Relational Databases (Fall 2003)

  
  

  With the wide-spread usage of XML, it has become necessary to build databases to store the XML content. There are two approaches to storing XML content: one is to have a fully native XML database and the other approach is to add features to existing relational database to support XML. The former approach has been taken by object database vendors and the later approach has been taken by relational database vendors. In this study we intend to highlight some important features of the two approaches and show the cases where one approach performs better than the other.
  [Project Report in PDF format]

  
  

• Linux Process Control via the File System (Spring 2002)

  
  

  The Linux 2.4 kernel has only primitive process control features. The inability to attach multiple tools to a process makes debugging of tools that attach to a process (e.g. Paradyn) extremely difficult. The Linux ptrace system call, used to attach to a process, changes the parent pointer to that of the tracing process. This causes problems for processes which care about their children. This causes problems when processes launched by distributed batch schedulers like Condor are traced. In this project, we address most of the Linux process control limitations. Our enhancement allows multiple tracing processes, gives the ability to detach from a stopped process leaving it stopped, enables tracing a subset of system calls, signals, and hardware faults and it does not change the parent pointer. We profile the overhead this enhanced functionality adds to kernel critical path and find that selective system call tracing adds only one extra instruction to the common case of an untraced process. Performance gains are impressive, improving upon ptrace by 374% by allowing fine-grained system call tracing. This modification was done to Linux Kernel 2.4.17. This work was done in a group of two for the CS739 course under Prof. Barton Miller.
  [Project Report in PDF format]

  
  

• Scaling SMP Machines through Hierarchical Snooping (Spring 2002)

  
  

  Symmetric Multi Processors (SMPs) have become a runaway success. Scalability is one of the main problems being faced by symmetric multiprocessors. In this work we examine an approach to increasing SMP scalability by introducing a hierarchical bus with transaction filtering to reduce bus traffic. We implemented our filtering mechanism in Simics/Ruby, a full-system simulator and evaluated the effect of this filtering on commercial and scientific workloads. We also discuss the effect of transaction filtering on memory consistency. This work was done in a group of two for the CS757 course under Prof. Mark Hill.
  [Project Report in PDF format]

  
  

• Fingerprinting the CPU Scheduler (Fall 2001)

  
  

  Many cool ideas in Operating Systems do not get introduced into commercial systems because they require kernel modifications and users prefer to use out of the box machines and standard kernels and prefer not to tinker with the OS. Gray Box techniques try to solve this problem by influencing the OS to behave the way that best suits the application needs. For influencing the OS, gray box software should have a good algorithmic and empirical knowledge of the system. Empirical knowledge is gained by running carefully designed micro benchmarks. In the project, we fingerprinted the CPU schedulers of Solaris 8, Linux 2.4 and FreeBSD 4.4 and used the gained knowledge to implement a user-level proportional share scheduler. This was done in a group of 3 people for the CS736 course under Prof. Andrea Arpaci-Dusseau.
  [Project Report in PDF format]

  
  

• Fetch Directed Instruction Prefetching (Fall 2001)

  
  

  In modern processors instruction execution rate is limited by I-cache misses. Trace Caches were introduced (e.g. In Intel P4) to address the problem. Fetch Directed Prefetching is another approach which has a lower memory requirement. We wanted to get a get a good understanding of the implications of using Fetch Directed Prefetching and evaluate its performance on a commercial workload. In Fetch Directed Prefetching, the branch predictor runs ahead (independent) of the main pipeline, and the 'Branch Target Buffer' is modified into 'Fetch Target Buffer'. We implemented this on SimpleScalar3.0b/Pisa, a detailed out-of-order superscalar processor simulator. We had to significantly modify SimpleScalar to implement this functionality. We found a performance improvement of 20%-40% for the Spec 2000 benchmarks. This project was done in a group of 3 people for the CS752 course under Prof. David Wood.
  [Project Report in PDF format]