|
|
Debugging the SLUB allocator in the Linux kernel
Glitta, Oliver ; Babka, Vlastimil (advisor) ; Horký, Vojtěch (referee)
This thesis is focused on the SLUB memory allocator and its debugging functionalities. The SLUB allocator implementation included several tests, but nobody was running them. It was because no automated kernel testing infrastructure existed for them. This project added one of the kernel testing frameworks, the KUnit testing, for SLUB. Existing tests were integrated into this framework with some minor changes. Also, new regression tests were added based on a systematic review of commits associated with SLUB. Another part of the thesis extends the SLUB debug options for tracking allocation events, including more efficient stack trace storage. The last part improves the virtual file system debugfs that provide information about kernel components to userspace by including stack traces in SLUB's virtual files. Also, this project helps to track the efficiency of the SLUB cache usage in terms of object size. All of these changes to the Linux kernel should help with SLUB debugging. Some of the changes were also submitted and even accepted by the community, they were added into Linux version 5.14. 1
|
|
|
An Application for Taking 360° Photographs using Mi Sphere Camera
Cífka, Martin ; Mirbauer, Martin (advisor) ; Horký, Vojtěch (referee)
Xiaomi Mi Sphere is camera that captures 360ř panoramatic photographs. With si- multaneous use of high dynamic range (HDR) capturing, such photographs are used in realistic rendering as a background as well as for creating realistic lighting and light re- flections. The advantage of this camera is that it's lightweight and easily carried, but the official application is available only for Android and iOS devices and it does not support simultaneous use of time-lapse and bracketing for capturing HDR images. Other unoffi- cial applications do not support this functionality either. In this thesis we analyze the communication protocol between camera and the official application and subsequently we develop our own cross-platform application with web-based graphical user interface. In addition to standard capturing, our application supports simultaneous use of bracketing and time-lapse. The created application does not run on the user's device but directly on the camera. This allows us to continue shooting even after client disconnects from the application. 1
|
|
|
Syscall emulation support in HelenOS
Kabele, Vít ; Horký, Vojtěch (advisor) ; Tůma, Petr (referee)
There are two main options for running a program intended for one oper- ating system on a different one. We can modify the program to use the API of the new OS. Alternatively, we can provide a compatibility layer in the new OS, transparent to the program, without changing the application. HelenOS ecosystem already allows the first. This thesis focuses on supporting the lat- ter. This thesis describes the kernel binary interface and analyses existing solutions on Linux, Windows, and specialised systems. Then we describe our prototype that transparently traps syscalls and emulates them. The emula- tion is implemented fully in userspace (except for a small kernel trampoline), and its code is executed in the context of the original application. The result allows running some of the unmodified Linux programs (focusing on GCC toolchain) on the x86_64 instance of the HelenOS system. 1
|
|
|
User alerts with real-time data monitoring for IVIS framework
Janda, Jan ; Bureš, Tomáš (advisor) ; Horký, Vojtěch (referee)
As the number of IoT devices and the size of CPS grow, the amount of critical data, which needs to be ceaselessly monitored, also increase. IVIS is a web-based data processing and visualization framework for IoT as well as CPS data and it would clearly benefit from the ability to monitor data in real time, issue alerts and send notifications. In this thesis, we extend the IVIS framework with such ability, which has not been developed for the framework yet. This extension can be used to set up an automatic monitoring of incoming data with appropriate level of detail. An emphasis is given to versatility of possible configurations. It is possible to precisely define conditions for the monitoring and rules for the notifications across a wide range of requirements. It is also important that the system has adjustable temporal stability, and therefore is not affected by outliers and random noise.
|
|
|
Tokenization-aware Diff and Patch
Antoniewicz, Arkadiusz Martin ; Kratochvíl, Miroslav (advisor) ; Horký, Vojtěch (referee)
File comparison algorithms and utilities 'diff', 'patch' and 'diff3' are widely used in programming for the purpose of code comparison, and in many version control systems. Despite the usefulness, the differences and patches produced by the tools are strictly line-oriented, which complicates processing of differently formatted data, such as free flowing text, markup, and various other formats where line breaks are not crucial. This thesis de- scribes and implements a customizable version of these tools, which allows the user to specify an arbitrary tokenization of the input, thus allowing easy diffing, patching and change-merging of content not supported by the tradi- tional diff. Additionally, the thesis describes a newly appearing challenge of managing the whitespace in the patches, and demonstrates the functional- ity on a practical use-case that can not be performed with the current diff utilities. 1
|
|
|
ALTREP Data Representation in FastR
Marek, Pavel ; Šindelář, Štěpán (advisor) ; Horký, Vojtěch (referee)
R is a programming language and a tool used mostly in statistics and data analysis domains, with a rich package-based extension system. GNU-R, the standard interpreter of R, in version 3.5.0 introduced a new native API (ALTREP) for R extensions developers. The goal of the thesis is to implement this API for FastR, an interpreter of R based on GraalVM and Truffle, and explore options for optimization of FastR in context of this API. The motivation is to increase the number of extensions that can be installed and run on FastR. 1
|
|
|
Tokenization-aware Diff and Patch
Antoniewicz, Arkadiusz Martin ; Kratochvíl, Miroslav (advisor) ; Horký, Vojtěch (referee)
File comparison algorithms and utilities 'diff', 'patch' and 'diff3' are widely used in programming for the purpose of code comparison, and in many version control systems. Despite the usefulness, the differences and patches produced by the tools are strictly line-oriented, which complicates processing of differently formatted data, such as free flowing text, markup, and various other formats where line breaks are not crucial. This thesis de- scribes and implements a customizable version of these tools, which allows the user to specify an arbitrary tokenization of the input, thus allowing easy diffing, patching and change-merging of content not supported by the tradi- tional diff. Additionally, the thesis describes a newly appearing challenge of managing the whitespace in the patches, and demonstrates the functional- ity on a practical use-case that can not be performed with the current diff utilities. 1
|
|
|
Transparent Restarts of Stateless Linux Services
Šraier, Václav ; Koutný, Michal (advisor) ; Horký, Vojtěch (referee)
Services running on servers have to be updated once in a while with security patches and new features. Full-service restarts provide a simple way to update the running code, but they usually lead to costly downtime. That can, however, be avoided by preserving network connections and internal state across restarts. There is currently no general way how to do that easily. We introduce an easy-to-use library for Linux which handles transparent restarts for stateless services with minimal code requirements. We demonstrate that support from the system's service manager can significantly improve correctness. We provide an implementation of such integration into systemd, popular Linux service manager and init system. 1
|
|
|
Integrated Server for Dynamic Program Analysis
Kabele, Vít ; Bulej, Lubomír (advisor) ; Horký, Vojtěch (referee)
Dynamic analysis aids in many software development tasks, such as debugging, pro- gram comprehension, and performance optimization. However, implementing a new dy- namic analysis tool is a non-trivial tasks. To simplify development of dynamic analyses, researchers at Charles University and Università della Svizzera italiana in Lugano have jointly developed the DiSL and Shad- owVM frameworks, which raise the level of abstraction for analysis tool developers and provide a convenient programming model both for bytecode instrumentation and for analysis execution. Even though those frameworks were successfully used to develop many different dy- namic analyses, it turned out that the internal design of the original implementation of both frameworks made further development of new features, such as support for instrumentation-time reflection, extremely difficult. Both frameworks provide a client and server part and while they are designed to be used together, the design prevents sharing of information between the two client parts and the two server parts. This not only increases the amount of data that need to be exchanged over network, but also makes configuration of all parts more difficult. In this work we propose and implement a new architecture of the analysis suite so that the functionality the functionality...
|
|
|
Performance Awareness in Agile Software Development
Horký, Vojtěch ; Tůma, Petr (advisor) ; Rabiser, Rick (referee) ; Koziolek, Anne (referee)
Broadly, agile software development is an approach where code is frequently built, tested and shipped, leading to short release cycles. Extreme version is the DevOps approach where the development, testing and deployment pipelines are merged and software is continuously tested and updated. In this context our work focuses on identifying spots where the participants should be more aware of the performance and offers approaches and tools to improve their awareness with the ultimate goal of producing better software in shorter time. In general, the awareness is raised by testing, documenting, and monitoring the performance in all phases of the development cycle. In this thesis we (1) show a framework for writing performance tests for individual components (e.g. libraries). The tests capture and codify assumptions about the performance into runnable artifacts that simplify repeatability and automation. For evaluation of the performance tests we (2) propose new methods, which can automatically detect performance regressions. These methods are designed with inherent variation of performance data in mind and are able to filter it out in order to detect true regressions. Then we (3) reuse the performance tests to provide the developers with accurate and up-to-date performance API documentation that steer them...
|
guest ::
RSS feed.