Denna rapport beskriver utvecklingen av en webbaserad applikation för SCA i Falkenberg som är det första steget för att ersätta nuvarande lösning för DOM-rapporten.   DOM-rapporten är ett stort Excel dokument som innehåller mycket information och funktioner som används dagligen på företaget. Dokumentet har nu blivit så stort att det är långsamt att arbeta med. Webbapplikationen som utvecklats överför två av de större delarna av DOM-rapporten, vilket resulterar i en mycket snabbare hantering av data. Eftersom en webbapplikation går att använda på alla enheter med en webbläsare kan den användas på en surfplatta.  Att kunna använda DOM-rapporten på en surfplatta ökar effektivitet och säkerhet på företaget genom att bl.a. minska gångavstånden och sänka tiden för att utföra arbetsmoment.  Applikationen har utvecklats med ASP.NET MVC och med responsiv design för att anpassas till olika enheter. / This report describes the development of a web based application for SCA in Falkenberg this is the first step in replacing the current solution for the DOM-report.  The DOM-report is a large Excel-document that contains a lot of information and functions used daily on the company. The document has now become very large and this has resulted in a very slow working environment. The web application that has been developed transfers two of the larger parts of the DOM-report. Which results in a much faster handling of data. Because it is a web application it can be used on all devices that has a web browser and this makes it possible to use the application on a tablet.  Using the DOM-report on a tablet would increase efficiency and safety on the company by decreasing walking distance and reducing the time it takes to perform the work activities.  The application has been developed with ASP.NET MVC and with a responsive design to adapt to different devices.

Digitala bevis ökar i takt med att tekniken i samhället blir vanligare. Ett perfekt exempel på detta är mobiltelefoner som idag är mer lik en dator än någonsin förr, och den används flitigt i vardagen. Men även datorer och annan teknik har blivit en större del av vardagen. Tack vare att det används som de gör, så följer en del teknikutrustning alltid med användaren och genom att ta en titt i, ex. en mobil eller dator kan du få rätt mycket information av användaren.Framför allt mobiltelefoner har blivit en värdefull källa för bevis i en rättegång. Men hur ser den tekniska kunskapen ut i rättssamhället? Lyckas man följa med tekniken och utnyttja detta?I takt med att digitala bevis ökar så ökar så klart även den digitala forensiken, IT-forensiken. Hur ser IT-forensiken ut i praktiken?I detta arbete så är målet att ta reda på hur den tekniska kunskapen ser ut inom rättsväsendet men även få en större inblick över hur insamlingen av bevis m.m. ser ut i praktiken. Stämmer det med teorin?

No description available.

This project is based on a wish from the employees at Umeå Energi to have a solution for remote control of TV monitors in the office. The idea is a web-based solution to make it possible for the employees to open a web page and access basic functions on the four monitors in the office. The project has been done with the help of an old PC that works as an intermediary between the monitors and the users. The PC was running a webserver that could control functions on the monitors using scripts. The server was connected to the monitors through a serial interface (RS-232). All software being used was free and open, and most of the hardware Umeå Energi already had on site, thus costs have remained low. The final solution was a Linux-based server with Ubuntu and Apache, and the scripts used Bash code. A USB hub and four USB-to-serial adapters were used to connect the monitors to the server. All basic functions worked as intended, except that commands sometimes had to be applied twice by pressing the refresh button in the web browser. This is believed to have been caused by weak power supply to the USB hub.

Traffic volumes on the Internet continue to increase, with the same links carrying the same data multiple times. In-network caching can alleviate much of the redundant traffic by storing popular items close to the users. This was a master thesis project that involved building on existing research and simulators, simulating a multi-level hierarchical network cache system and its resulting performance, with varying parameters such as placement and sizing of the individual cache nodes. One of the goals of the thesis work was to improve and integrate the simulation frameworks used as a starting point. Another goal was to run simulations with the improved framework and shed light on how a high Quality of Experience (QoE) can be achieved within this kind of cache system, varying the input parameters. An improved and integrated simulation framework was produced, including improved visualization capabilities. Using this improved simulation framework, the behavior of the cache system was studied, in particular how the system behaves with static and dynamic cache sizing approaches. Conclusions drawn are e.g. that the dynamic sizing approach deployed can be a good way to achieve a high QoE. Finally, future research opportunities are identified.

No description available.

Since real-time systems often operate in safety-critical environments it is extremely important that they function correctly. UPPAAL is a tool that can be used for validation and verification of real-time systems. The user models the system using networks of timed automata and uses a simple logic to express safety requirements that the modelled system must satisfy to guarantee its correct behaviour. UPPAAL then performs reachability analysis using constraint solving techniques to check if the model satisfies the given requirements. In addition, the tool is also able to provide the user with a sample execution that explains why a requirement is (or is not) satisfied by the model. The analysis is fully automated. This thesis describes various techniques adopted when implementing UPPAAL. Some of the techniques have improved the performance of UPPAAL significantly. We have studied the techniques with performance measurements in several case-studies. One of the main contributions is the comparison of different strategies in implementing the basic data structures and searching algorithms. The measurements can be used as hints on what parts of the model-checker that are most important to optimise. Though the techniques are studied in the context of timed automata, we believe that they are applicable to the implementation of general software tools for automated analysis.

To reduce latency and increase bandwidth to memory, modern microprocessors are designed with deep memory hierarchies including several levels of caches. For such microprocessors, the service time for fetching data from off-chip memory is about two orders of magnitude longer than fetching data from the level-one cache. Consequently, the performance of applications is largely determined by how well they utilize the caches in the memory hierarchy, captured by their miss ratio curves. However, efficiently obtaining an application's miss ratio curve and interpreting its performance implications is hard. This task becomes even more challenging when analyzing application performance on multicore processors where several applications/threads share caches and memory bandwidths. To accomplish this, we need powerful techniques that capture applications' cache utilization and provide intuitive performance metrics. In this thesis we present three techniques for analyzing application performance, StatStack, StatCC and Cache Pirating. Our main focus is on providing memory hierarchy related performance metrics such as miss ratio, fetch ratio and bandwidth demand, but also execution rate. These techniques are based on profiling information, requiring both runtime data collection and post processing. For such techniques to be broadly applicable the data collection has to have minimal impact on the profiled application, allow profiling of unmodified binaries, and not depend on custom hardware and/or operating system extensions. Furthermore, the information provided has to be accurate and easy to interpret by programmers, the runtime environment and compilers. StatStack estimates an application's miss ratio curve, StatCC estimates the miss ratio of co-running application sharing the last-level cache and Cache Pirating measures any desired performance metric available through hardware performance counters as a function of cache size. We have experimentally shown that our methods are both efficient and accurate. The runtime information required by StatStack and StatCC can be collected with an average runtime overhead of 40%. The Cache Pirating method measures the desired performance metrics with an average runtime overhead of 5%. / UPMARC

Most applications have time-varying runtime phase behavior. For example, alternating between memory-bound and compute-bound phases. Nonetheless, the predominant approach in computer research has been to categorize an application based on its average runtime behavior. However, this can be misleading since the application may appear to be neither memory nor compute bound. In this thesis we introduce tools and techniques to enable researchers and software developers to capture the true time-varying behavior of their applications. To do so, we 1) develop an efficient technique to detect runtime phases, 2) give new insight into applications' runtime phase behaviors using this technique, and, finally, 3) explore different ways to exploit runtime phase detection. The results are ScarPhase, a low-overhead phase detection library, and three new methods for exploring applications' phase behaviors with respect to: 1) cache performance as a function of cache allocation, 2) performance when sharing cache with co-running applications, and finally, 3) performance and power as a function of processor frequency. These techniques enable us to better understand applications' performance and how to adapt different settings to runtime changes. Ultimately, this insight allow us to create new faster and more power efficient applications and runtime systems that can better handle the increasing computation demands and power constraints of tomorrow's problems. / UPMARC

A software architecture is a high-level design description of a software system. In terms of the architecture, early design decisions can be analyzed to improve the quality of a real-time software system, which depends very much on how it is structured rather than how it is implemented. Architectural analysis techniques vary in their degree of formality. The least formal is based on reviews and scenarios, whereas the most formal analysis methods are based on mathematics. In this thesis, we propose to use a formal approach to software architectural analysis. We use networks of timed automata to model the architecture of real-time systems and transform architectural analysis problems to reachability problems that can be checked by the existing tools for timed automata. The typical properties that can be handled using this approach are schedulability and safety properties. As the first technical contribution, we extend the classic model of timed automata with a notion of real-time tasks. This yields a general model for real-time systems in which tasks may be periodic and non-periodic. We show that the schedulability problem for the extended model can be transformed to a reachability problem for standard timed automata, and thus it can be checked by existing model-checking tools, e.g., UPPAAL for timed automata. As the second contribution, we present a method to check general high level temporal requirements e.g. timing constraints on data flowing in multi-rate transactions, which cannot be handled by traditional approach to schedulability analysis. We have developed an algorithm that given a data dependency model and a schedule for a transaction constructs a timed automaton describing the behavior of the transaction. Thus, by using existing verification tools we can verify that a given architecture is schedulable and more importantly, it is correctly constructed with respect to the high level temporal constraints.