Recongurable computing technology has progressed to a stage where it is now possible to achieve orders of magnitude performance and power eciency gains over conventional computer architectures for a subset of high performance computing applications. In this thesis, we investigate the potential of recongurable computers to accelerate genomic sequence alignment specically for genome sequencing applications. We present a highly optimized implementation of a parallel sequence alignment algorithm for the Berkeley Emulation Engine (BEE2) recongurable computer, allowing a single BEE2 to align simultaneously hundreds of sequences. For each recongurable processor (FPGA), we demonstrate a 61X speedup versus a state-of-the-art implementation on a modern conventional CPU core, and a 56X improvement in performance-per-Watt. We also show that our implementation is highly scalable and we provide performance results from a cluster implementation using 32 FPGAs. We conclude that reconfigurable computers provide an excellent platform on which to run sequence alignment, and that clusters of recongurable computers will be able to cope far more easily with the vast quantities of data produced by new ultra-high-throughput sequencers.

There exist several challenges in supporting mobile applications. For example, creating a separate target application for each device type, leaving developers with a huge maintenance chore. Most desktop applications run on largely homogenous hardware so instead of writing the same code over and over again, developers only need to write modules to implement a particular need. This is because even though there are differences in PC hardware configurations, the same desktop application will work fine on any hardware as the operating system provides an abstract layer. This is the way mobile applications are expected to work. However, this has been divided into dozens of ill-assorted versions. Java mobile applications developers spend more time rewriting code to run on different versions of mobile devices more than they do actually creating application in the first place. This is an intolerable burden for small mobile developers, and it stifles mobile software innovation overall. Mobile devices differ in a variety of attributes, such as screen size, colour depth and the optional hardware devices they support such as cameras, GPS etc. The differences often require special code or project settings for successful deployment for each device a developer is targeting but this creates a huge logistical overhead. One potential solution that is shipped with NetBeans IDE is to add a new configuration for each device, modify the project properties, add some pre-processing code, then build and deploy the application. In most cases, one configuration for each distribution of the Java Archive (JAR) one plans to build for the project is created. For example, if a developer is planning to support three different screen sizes using two sets of vendor specific APIs, one needs to create six configurations. This reduces the performance of the application drastically and increases the size at the same time. This is not acceptable for mobile devices where memory size and processor performance are limited. The goal of this research work is to support mobile application development through a Java IDE (the NetBeans IDE in this case). Therefore, our approach will be to modify the NetBeans IDE to better address the difficulty that was mentioned above – namely targeting applications for different platforms. Our solution is to integrate another type of a preprocessor into the NetBeans IDE that will help alleviate the problems of the existing tool. Our approach is to directly implement this inside the NetBeans IDE to further support mobile application development with the NetBeans IDE.

The Weighted Histogram Analysis Method (WHAM) is a technique used to calculate free energy from molecular simulation data. WHAM recombines biased distributions of samples from multiple Umbrella Sampling simulations to yield an estimate of the global unbiased distribution. The WHAM algorithm iterates two coupled, non-linear, equations, until convergence at an acceptable level of accuracy. The equations have quadratic time complexity for a single reaction coordinate. However, this increases exponentially with the number of reaction coordinates under investigation, which makes multidimensional WHAM a computationally expensive procedure. There is potential to use general purpose graphics processing units (GPGPU) to accelerate the execution of the algorithm. Here we develop and evaluate a multidimensional GPGPU WHAM implementation to investigate the potential speed-up attained over its CPU counterpart. In addition, to avoid the cost of multiple Molecular Dynamics simulations and for validation of the implementations we develop a test system to generate samples analogous to Umbrella Sampling simulations. We observe a maximum problem size dependent speed-up of approximately 19 for the GPGPU optimized WHAM implementation over our single threaded CPU optimized version. We find that the WHAM algorithm is amenable to GPU acceleration, which provides the means to study ever more complex molecular systems in reduced time periods.

With the rise of modern programming languages like Java that include native support for multi-threading, the issue of concurrency in graphical applications becomes more and more important. Traditional graphical component libraries for Java have always used the threading concepts provided by the language very carefully, telling the programmer that the use of threads in this context is often unnecessarily burdensome and complex. On the other hand, experience gained from systems like Inferno or BeOS shows that the use of concurrency in graphical applications is clearly manageable and leads to a different program design, once you dissociate the application from the limitations of the GUI library. This thesis describes the design of a general architecture that allows for the separation of a program´s user interface from the application logic using thread communication. It enables the use of concurrency in the application code without requiring any degree of thread-safety at the native interface component level.