<p>This report carries out a relative performance comparison between two DBMS architectures on the Multi Core, Single Die (MCSD) realization Niagara. The two DBMS architectures in question are Shared Nothing (SN) and Shared Everything (SE). The MCSD field is rapidly evolving, and we expect that this technology will become increasingly important in the near future. In order to carry out the comparison, the performance of the architectures must be calculated. This calculation depends on the cost figures associated with each architectural approach. To identify these costs, we present the design solutions made and results discovered in our previous work. Based on this, the most significant costs are determined and scheduled to be micro benchmarked. The natural next step is to examine possible techniques to implement the benchmarks. In order to do this, we first expand on the Niagara chip and the platform on which the micro benchmarks will run. Having a sufficient theoretical platform to continue, we move on to describe the implementation of each micro benchmark in detail. After benchmarking all the most significant costs, we thoroughly discuss the results, some of which are indeed surprising. The costs which are not benchmarked are based on assumptions from our previous work and recalculated to apply to Niagara. For both SN and SE, we evaluate the system for two classes of transactions. The first class is transactions touching one tuple (called simple), the second is transactions touching four tuples (called complex). Each class has two instances, read and update. In order to perform the subsequent analysis, the decomposition of each transaction is presented in detail. When analyzing the outcome of the calculations, interesting results emerge. First, we note that SE is the cheapest alternative when evaluating the simple transactions. This is because the SN approach includes an administrative overhead component that does not pay off when the transaction only touches one tuple. However, for complex transactions, the overhead component results in a parallel gain for SN which outperforms SE. Based on the most dominant costs of both architectures, we perform a sensitivity analysis. For SN, the analysis is based on the cost for message passing. For SE, it is based on the cost for synchronization. The goal of this analysis is two folded. First, it is interesting to see how the results vary. For example, what the ratio between the cost for message passing and the cost for synchronization must be in order to make the two approaches perform equally well. Second, the analysis indicate how error-prone each architecture is to erroneous estimation. The sensitivity analysis examine the performance of SN and SE when the ratio between the cost for message passing and the cost for synchronization is varied. This is done in both the read and the update cases. In addition to examining the simple and the complex transactions, we examine general transactions were the number of operations are not predetermined. The analysis of the general read transaction suggests that when the number of operations increases, the message passing and synchronization costs wipe out the impact of the other costs. It also suggests that when the cost of message passing is greater than 4 times the cost of synchronization, SE performs better when increasing the number of read operations. Similarly, if message passing is cheaper than 4 times the cost of synchronizing, SN is preferable. When increasing the number of update operations, the ratio is 3.33. After concluding the analysis, we suggest a hybrid architecture that might combine the advantages of SN and SE. At the cost of introducing both message passing and synchronization, the architecture introduce parallelism in SE. Lastly, we identify suggestions for future work. Realized and applied to the DBMS model introduced in this report, we believe that several of these suggestions can shrink some of the costs presented.</p>

<p>XML is a tremendous popular markup language in internet applications as well as a storage format. XML document access is often done through an API, and perhaps the most important of these is the W3C DOM. The recommendation from W3C defines a number of interfaces for a developer to access and manipulate XML documents. The recommendation does not define implementation specific approaches used behind the interfaces. A problem with the W3C DOM approach however, is that documents often are loaded in to memory as a node tree of objects, representing the structure of the XML document. This tree is memory consuming and can take up to 4-10 times the document size. Lazy processing have been proposed, building the node tree as it accesses new parts of the document. But when the whole document has been accessed, the overhead compared to traditional parsers, both in terms of memory usage and performance, is high. In this thesis a new approach is introduced. With the use of well known indexing schemes for XML, basic techniques for reducing memory consumption, and principles for memoryhandling in operation systems, a new and alternative approach is introduced. By using a memory cache repository for DOM nodes and simultaneous utilize principles for lazy processing, the proposed implementation has full control over memory consumption. The proposed prototype is called Demand Driven Dom Parser, D3P. The proposed approach removes least recently used nodes from the memory when the cache has exceeded its memory limit. This makes the D3P able to process the document with low memory requirements. An advantage with this approach is that the parser is able to process documents that exceed the size of the main memory, which is impossible with traditional approaches. The implementation is evaluated and compared with other implementations, both lazy and traditional parsers that builds everything in memory on load. The proposed implementation performs well when the bottleneck is memory usage, because the user can set the desired amount of memory to be used by the XML node tree. On the other hand, as the coverage of the document increases, time spend processing the node tree grows beyond what is used by traditional approaches.</p>

<p>This thesis aims at applying and exploring the DEVS-based theory for the purpose of gaining experiences and recommendations with regards to the usefulness of DEVS in the analysis of a submarine combat system and in establishing simulation credibility. In this regard, first a literature study of the DEVS-based literature is performed, before a case study is carried out, targeting a subset of the submarine combat system test bed under construction at Forsvarets forskningsinstitutt (FFI). In doing so, an architectural description of the subset based on DEVS is created and special requirements are discussed with regards to legacy components and technologies. Finally, the usefulness of DEVS is discussed based on experiences made during the first two tasks. Note that implementation and aspects with regards to an executable framework for the simulator is not covered. The findings of this study indicates that DEVS with its formal nature can be a valuable tool both with regards to analysis as well as in establishing credibility. Especially with regards to couplings and composability DEVS might prove helpful. The formal specifications and definitions can ensure that consistency is achieved. A formal experimental frame also ensures an unambiguous foundation for creating the simulation. With this in mind, an issue was discovered with regards to how far DEVS should go in covering aspects which can be argued to be part of the simulator within the abstract model. A solution involving the use of one or more lumped models is suggested, but need further study. Finally, the need for a proper tools and a graph notation is emphasised if DEVS is to be practical in complex simulations.</p>

<p>The approach used in this document is to create an assisting table as a bridge between the base table and view, on which only projection of non-identifying attributes is performed. This makes it possibly to distinguish individual records to enable log recovery methods to keep the assisting table consistent with the base table. The assisting table can then be used to create and maintain the view without blocking the base table.</p>

<p>MapReduce is a programming model for distributed processing, originally designed by Google Inc. It is designed to simplify the implementation and deployment of distributed programs. Vespa Document Store (VDS) is a distributed document storage solution developed by Yahoo! Technologies Norway. VDS does not currently have any feature allowing distributed aggregation of data. Therefore, a prototype of the MapReduce distributed programming model was previously developed. However, the implementation requires manual tuning of several parameters before each deployment. The goal of this thesis is to allow as many as possible of these parameters to be either automatically configured or set to universally suitable defaults. We have created a working MapReduce implementation based on previous work, and a framework for monitoring of VDS nodes. Various VDS features have been documented in detail, this documentation has been used to analyse how the performance of these features may be improved. We have also performed various experiments to validate the analysis and gain additional insight. Numerous configuration options for either VDS in general or the MapReduce implementation have been considered, and recommended settings have been proposed. The propositions are either in the form of default values or algorithms for computing the most suitable setting. Finally, we provide a list of suggested further work, with suggestions for both general VDS improvements and MapReduce-specific research.</p>

<p>http://odc.opentheweb.org/</p>

<p>MMOGs (Massively Multiplayer Online Games) are today a multi-bilion dollar industry where typically thousands of players interact in a virtual world. Two of the main complaints of the MMOG community are the lack of interaction with the virtual universe, and the repetitive gameplay patterns. Introducing a virtual alimentary chain for the targets would allow for a much more exciting experience since the genetic evolution of the opponents would make each fight more unique, and collaboration among player community would be necessary to keep a sustainable balance in the virtual world. As these kind of games are designed for many thousands of players in real-time, a lot of compute power will be needed to simulate the genetic evolution. Parallel computing can greatly improve the performance, assuming the software is properly designed with parallelizations in mind. A couple of different schemes will be considered. Trying to fetch the ecology studies, a prototype architecture is presented here. A non-linear genotype-phenotype transformation mechanism (also called morphogenesis) has been designed with the purpose of obtaining Lotka-Volterra equations result. These research will lead to discussions and conclusion, hopefully guiding further development in this area.</p>

<p>This report is for my research of Collaboration Instance Manager of UbiCollab project. UbiCollab want to be the platform for ubiquitous collaborative active. UbiCollab project aims to develop a distributed collaborative platform which makes people in distributed space ubiquitous collaborate with friends and colleagues. Collaboration instance manager (CIM) is a core component of the UbiCollab platform, which manage such collaborative activities. My research topics of CIM include in the P2P network development by using JXME, the data synchronization through this P2P network and how to manage these synchronized date by using a local file system. The result of my research is a CIM system, which deployed as OSGI bundle. User can use that do some collaborative active. This CIM system manage the service level of data synchronization, other modules and applications can use that to handle data synchronization between each other without know the details of how to implement it. For that purpose I first reviewed the related theories of distributed systems, ubiquitous systems, mobile systems and CSCW. After that review I researched on some alternatives for developing such system and choose the candidate technologies for my prototype. Secondly I analyzed the requirements of UbiCollab and designed the prototype. Based on that design, I implemented and tested that CIM system based on agreed common scenarios and developed a simple GUI for show the utility. Finally, I evaluate the system by analysis system requirements and scenario criteria.</p>

<p>This report aims to describe and improve a system recovery process in large-scale storage systems. Inevitable, a recovery process results in the system being loaded with internal replication of data, and will extensively utilize several storage nodes. Such internal load can be categorized and generalized into a maintenance workload class. Obviously, a storage system will have external clients which also introduce load into the system. This can be users altering their data, uploading new content, etc. Load generated by clients can be generalized into a production workload class. When both workload classes are actively present in a system, i.e. the system is recovering while users are simultaneously accessing their data, there will be a competition of system resources between the different workload classes. The storage must ensure Quality of Service (QoS) for each workload class so that both are guaranteed system resources. We have created Dynamic Tree with Observed Metrics (DTOM), an algorithm designed to gracefully throttle resources between multiple different workload classes. DTOM can be used to enforce and ensure QoS for the variety of workloads in a system. Experimental results demonstrate that DTOM outperforms another well-known scheduling algorithm. In addition, we have designed a recovery model which aims to improve handling of critical maintenance workload. Although the model is intentionally intended for system recovery, it can also be applied to many other contexts.</p>

<p>XQuery is a flexible language for querying XML data across a variety of storage methods. This thesis is a part of iAD, an ongoing research effort in next generation information access solutions. iAD is hosted by Fast Search & Transfer, a company developing their next search engine platform MARS. This project seeks to investigate the utilisation of XQuery as a query language for MARS. The result of this project is a novel method of translation, dubbed “Tainting Dependencies” (TD), which seeks to avoid unecessary denormalisation of intermediate results, and is designed specifically for translation to MARS’ relational algebra. This method supports a large subset of XQuery features. Furthermore, we have developed a prototype implementation which supports basic constructs such as FLWOR and sequence construction. TD is then compared head-on to a similar method dubbed “Loop Lifting”, and the results of this comparison is evaluated through discussion. The outcome of this project is a novel and well-documented method for translation of XQuery to MQL – a method which is designed to perform equally or better than existing implementations.</p>