Identification of Genomic Regions Associated with Phenotypic Variation between Dog Breeds using Selection Mapping

Peer reviewe

Flexible Debugging with Controllable Overhead

This thesis is concerned with the problem of discovering bugs in a program. This crucial part of debugging is becoming ever more relevant as the complexity of software systems increases. Symbolic debuggers retain their relevance for bug diagnosis once a bug has been isolated in a development environment; however, instrumentation continues to grow in relevance because it allows the programmer to specify execution points of interest in advance and let the program run normally. Instrumentation’s has a strong appeal if the nature of the bug is uncertain: the programmer can add checks or logging for a variety of interesting events and let the program run, automating what would otherwise be a painstaking manual process. Instrumentation is widely-used in development environments; nearly every large software project has benefited from verbose logging or some kind of execution profiling. In fact, recently DTrace has brought instrumentation to system administrators as well, allowing them to diagnose performance problems and errors on production servers. However, particularly with the proliferation of consumer devices running full Unix software stacks, it is becoming more and more useful to be able to apply the same techniques that were available in development and system-administration environments remotely, in end-user environments with minimal user impact. In this thesis, we present a body of work that addresses this desire. We have developed a GCC-based instrumentation system called adb that leverages the compiler’s intermediate representation, which includes type, control-flow, and dominator information, to enable instrumentation at a variety of locations, called probes, in a program. A developer can ship a program with deactivated probes, and later develop small consumers that use the data at these probes and insert them into deployed copies of the program dynamically, with no end-user intervention required. We have also developed a novel overhead-management policy called SMCO that ensures that instrumentation incurs fixed overhead. In addition to presenting adb and evaluating its performance guarantees, we also discuss a GCC plug-in system that we developed and that is being adopted by the GCC community for inclusion in release 4.5. Finally, we also describe overhead-control approaches we developed before SMCO, which put the design decisions made for adb in context

Extending GCC with Modular GIMPLE Optimizations

We present a system of plug-ins for GCC that allows GCC to load GIMPLE transformations at run-time. This system reduces the support effort required for GCC by separating transformations from the core compiler. It also makes it possible for developers not connected with the GCC project to develop and distribute transformations independently. We demonstrate two plug-ins we have developed with this system, one of which reduces the effort required to develop transformations significantly by allowing visualization of the GCC controlflow graph and the GIMPLE tree structure. We enumerate portions of the compiler that could be extracted into plug-ins, and describe future applications of the plug-in system.

Molecular and pharmacological characterization of an acetylcholine-gated chloride channel (ACC-2) from the parasitic nematode Haemonchus contortus

Nematode cys-loop ligand-gated ion channels (LGICs) have been shown to be attractive targets for the development of novel anti-parasitic drugs. The ACC-1 family of receptors are a unique group of acetylcholine-gated chloride channels present only in invertebrates, and sequence analysis suggests that they contain a novel binding site for acetylcholine. We have isolated a novel member of this family, Hco-ACC-2, from the parasitic nematode Haemonchus contortus and using site-directed mutagenesis, electrophysiology and molecular modelling examined how two aromatic amino acids in the binding site contributed to agonist recognition. It was found that instead of a tryptophan residue in binding loop B, which essential for ligand binding in mammalian nAChRs, there is a phenylalanine (F200) in Hco-ACC-2. Amino acid changes at F200 to either a tyrosine or tryptophan were fairly well tolerated, where a F200Y mutation resulted in a channel hypersensitive to ACh and nicotine as well as other cholinergic agonists such as carbachol and methacholine. In addition, both pyrantel and levamisole were partial agonists at the wild-type receptor and like the other agonists showed an increase in sensitivity at F200Y. On the other hand, in Hco-ACC-2 there is a tryptophan residue at position 248 in loop C that appears to be essential for receptor function, as mutations to either phenylalanine or tyrosine resulted in a marked decrease in agonist sensitivity. Moreover, mutations that swapped the residues F200 and W248 (ie. F200W/W248F) produced non-functional receptors. Overall, Hco-ACC-2 appears to have a novel cholinergic binding site that could have implications for the design of specific anthelmintics that target this family of receptors in parasitic nematodes. Keywords: Cholinergic receptor, Nicotinic acetylcholine receptors (nAChR), Acetylcholine-gated chloride channel, Mutagenesis, Haemonchus contortus, Anthelminti

Model predictive control for memory profiling

We make two contributions in the area of memory profiling. The first is a real-time, memory-profiling toolkit we call Memcov that provides both allocation/deallocation and access profiles of a running program. Memcov requires no recompilation or relinking and significantly reduces the barrier to entry for new applications of memory profiling by providing a clean, non-invasive way to perform two major functions: processing of the stream of memory-allocation events in real time, and monitoring of regions in order to receive notification the next time they are hit. Our second contribution is an adaptive memory profiler and leak detector called MemcovMP C. Built on top of Memcov, MemcovMP C uses Model Predictive Control [?]to derive an optimal control strategy for leak detection that maximizes the number of areas monitored for leaks, while minimizing the associated runtime overhead. Areas that are observed not to have been accessed for a user-definable period of time are reported as potential leaks. Our approach requires neither mark-and-sweep leak detection nor static analysis, and reports a superset of the memory leaks actually occurring as the program runs. The set of leaks reported by MemcovMP C can be made to approximate the actual set more closely by lengthening the threshold period.

Compiler-assisted software verification using plug-ins

We present Protagoras, a new plug-in architecture for the GNU compiler collection that allows one to modify GCC’s internal representation of the program under compilation. We illustrate the utility of Protagoras by presenting plug-ins for both compile-time and runtime software verification and monitoring. In the compiletime case, we have developed plug-ins that interpret the GIMPLE intermediate representation to verify properties statically. In the runtime case, we have developed plug-ins for GCC to perform memory leak detection, array bounds checking, and reference-count access monitoring.

Efficient and safe execution of user-level code in the kernel

This project has two goals. The first goal is to improve application performance by reducing context switches and data copies. We do this by either running select sections of the application in kernel-mode, or by creating new, more efficient system calls. The second goal is to ensure that kernel safety is not violated when running user-level code in the kernel. We do this by implementing various hardware- and software-based techniques for runtime monitoring of memory buffers, pointers, as well as higher-level, OS-specific constructs such as spinlocks and reference counters; the latter techniques can also be used for code written specifically for the OS. We prototyped several of these techniques. For certain applications, we demonstrate performance improvements as high as 80%. Moreover, our kernel safety checks show overheads that are as little as 2%.

MBT 2006 Runtime Verification for High-Confidence Systems: A

We present a new approach to runtime verification that utilizes classical statistical techniques such as Monte Carlo simulation, hypothesis testing, and confidence interval estimation. Our algorithm, MCM, uses sampling-policy automata to vary its sampling rate dynamically as a function of the current confidence it has in the correctness of the deployed system. We implemented MCM within the Aristotle tool environment, an extensible, GCC-based architecture for instrumenting C programs for the purpose of runtime monitoring. For a case study involving the dynamic allocation and deallocation of objects in the Linux kernel, our experimental results show that Aristotle reduces the runtime overhead due to monitoring, which is initially high when confidence is low, to levels low enough to be acceptable in the long term as confidence in the monitored system grows.