Fast, Interactive Worst-Case Execution Time Analysis With Back-Annotation

Abstract—For hard real-time systems, static code analysis is needed to derive a safe bound on the worst-case execution time (WCET). Virtually all prior work has focused on the accuracy of WCET analysis without regard to the speed of analysis. The resulting algorithms are often too slow to be integrated into the development cycle, requiring WCET analysis to be postponed until a final verification phase. In this paper we propose interactive WCET analysis as a new method to provide near-instantaneous WCET feedback to the developer during software programming. We show that interactive WCET analysis is feasible using tree-based WCET calculation. The feedback is realized with a plugin for the Java editor jEdit, where the WCET values are back-annotated to the Java source at the statement level. Comparison of this treebased approach with the implicit path enumeration technique (IPET) shows that tree-based analysis scales better with respect to program size and gives similar WCET values. Index Terms—Real time systems, performance analysis, software performance, software reliability, software algorithms, safety I

Gerçek zamanlı Java’ da büyük nesnelere bellek ayırmak için anahtarlamalı yaklaşım

06.03.2018 tarihli ve 30352 sayılı Resmi Gazetede yayımlanan “Yükseköğretim Kanunu İle Bazı Kanun Ve Kanun Hükmünde Kararnamelerde Değişiklik Yapılması Hakkında Kanun” ile 18.06.2018 tarihli “Lisansüstü Tezlerin Elektronik Ortamda Toplanması, Düzenlenmesi ve Erişime Açılmasına İlişkin Yönerge” gereğince tam metin erişime açılmıştır.Son yirmi yılda nesne yönelimli programlama dilleri ve yönetilen çalışma zamanları, yazılım mühendisliği yönünden sağladıkları avantajlardan ötürü oldukça popüler hale geldiler. Ancak birçok uygulama alanındaki bu popülerliklerinin aksine, aynı programlama dilleri ve çalışma zamanları, gerçek zamanlı programlama için uygun görülmediler. Birçok faktörün yanı sıra, bunların gerçek zamanlı sistemlerin geliştirilmesi için kullanılmalarının önündeki bariyerlerden bir tanesi, büyük nesnelere bellek ayırma esnasında karşılaşılma olasılığı olan uzun bekleme zamanlarıdır. Bu tez gerçek zamanlı Java için zamanımıza kadar geliştirilmiş olan farklı büyük nesnelere bellek ayırma çözümlerini inceler ve bu çözümlere alternatif olarak anahtarlamalı yeni bir yaklaşım sunar. Sunulan tekniğin performansının hali hazırda uygulanmış diğer tekniklerle karşılaştırılması amacıyla geliştirilmiş olan sentetik bir kıyaslama uygulaması da bu tezde açıklanmıştır.Over the last twenty years object oriented programming languages and managed runtimes like Java have been very popular because of their software engineering benefits. Despite their popularity in many application areas, they have not been considered suitable for real-time programming. Besides many other factors, one of the barriers that prevent their acceptance in the development of real-time systems is the long pause times that may arise during large object allocation. This thesis examines different kinds of solutions which have been developed so far and introduces a switchable approach to large object allocation in real-time Java. A synthetic benchmark application which is developed to evaluate the effectiveness of the presented technique against other currently implemented techniques is also described

Gerçek zamanlı Java’ da büyük nesnelere bellek ayırmak için anahtarlamalı yaklaşım

06.03.2018 tarihli ve 30352 sayılı Resmi Gazetede yayımlanan “Yükseköğretim Kanunu İle Bazı Kanun Ve Kanun Hükmünde Kararnamelerde Değişiklik Yapılması Hakkında Kanun” ile 18.06.2018 tarihli “Lisansüstü Tezlerin Elektronik Ortamda Toplanması, Düzenlenmesi ve Erişime Açılmasına İlişkin Yönerge” gereğince tam metin erişime açılmıştır.Son yirmi yılda nesne yönelimli programlama dilleri ve yönetilen çalışma zamanları, yazılım mühendisliği yönünden sağladıkları avantajlardan ötürü oldukça popüler hale geldiler. Ancak birçok uygulama alanındaki bu popülerliklerinin aksine, aynı programlama dilleri ve çalışma zamanları, gerçek zamanlı programlama için uygun görülmediler. Birçok faktörün yanı sıra, bunların gerçek zamanlı sistemlerin geliştirilmesi için kullanılmalarının önündeki bariyerlerden bir tanesi, büyük nesnelere bellek ayırma esnasında karşılaşılma olasılığı olan uzun bekleme zamanlarıdır. Bu tez gerçek zamanlı Java için zamanımıza kadar geliştirilmiş olan farklı büyük nesnelere bellek ayırma çözümlerini inceler ve bu çözümlere alternatif olarak anahtarlamalı yeni bir yaklaşım sunar. Sunulan tekniğin performansının hali hazırda uygulanmış diğer tekniklerle karşılaştırılması amacıyla geliştirilmiş olan sentetik bir kıyaslama uygulaması da bu tezde açıklanmıştır.Over the last twenty years object oriented programming languages and managed runtimes like Java have been very popular because of their software engineering benefits. Despite their popularity in many application areas, they have not been considered suitable for real-time programming. Besides many other factors, one of the barriers that prevent their acceptance in the development of real-time systems is the long pause times that may arise during large object allocation. This thesis examines different kinds of solutions which have been developed so far and introduces a switchable approach to large object allocation in real-time Java. A synthetic benchmark application which is developed to evaluate the effectiveness of the presented technique against other currently implemented techniques is also described

Scoped types and aspects for real-time Java memory management

Abstract. Real-time systems are notoriously difficult to design and implement, and, as many real-time problems are safety-critical, their solutions must be reliable as well as efficient and correct. While higher-level programming models (such as the Real-Time Specification for Java) permit real-time programmers to use language features that most programmers take for granted (objects, type checking, dynamic dispatch, and memory safety) the compromises required for real-time execution, especially concerning memory allocation, can create as many problems as they solve. This paper presents Scoped Types and Aspects for Real-Time Systems (STARS) a novel programming model for real-time systems. Scoped Types give programmers a clear model of their programs ’ memory use, and, being statically checkable, prevent the run-time memory errors that bedevil the RTSJ. Adopting the integrated Scoped Types and Aspects approach can significantly improve both the quality and performance of a real-time Java systems, resulting in simpler systems that are reliable, efficient, and correct.

Adaptive Constraint Solving for Information Flow Analysis

In program analysis, unknown properties for terms are typically represented symbolically as variables. Bound constraints on these variables can then specify multiple optimisation goals for computer programs and nd application in areas such as type theory, security, alias analysis and resource reasoning. Resolution of bound constraints is a problem steeped in graph theory; interdependencies between the variables is represented as a constraint graph. Additionally, constants are introduced into the system as concrete bounds over these variables and constants themselves are ordered over a lattice which is, once again, represented as a graph. Despite graph algorithms being central to bound constraint solving, most approaches to program optimisation that use bound constraint solving have treated their graph theoretic foundations as a black box. Little has been done to investigate the computational costs or design e cient graph algorithms for constraint resolution. Emerging examples of these lattices and bound constraint graphs, particularly from the domain of language-based security, are showing that these graphs and lattices are structurally diverse and could be arbitrarily large. Therefore, there is a pressing need to investigate the graph theoretic foundations of bound constraint solving. In this thesis, we investigate the computational costs of bound constraint solving from a graph theoretic perspective for Information Flow Analysis (IFA); IFA is a sub- eld of language-based security which veri es whether con dentiality and integrity of classified information is preserved as it is manipulated by a program. We present a novel framework based on graph decomposition for solving the (atomic) bound constraint problem for IFA. Our approach enables us to abstract away from connections between individual vertices to those between sets of vertices in both the constraint graph and an accompanying security lattice which defines ordering over constants. Thereby, we are able to achieve significant speedups compared to state-of-the-art graph algorithms applied to bound constraint solving. More importantly, our algorithms are highly adaptive in nature and seamlessly adapt to the structure of the constraint graph and the lattice. The computational costs of our approach is a function of the latent scope of decomposition in the constraint graph and the lattice; therefore, we enjoy the fastest runtime for every point in the structure-spectrum of these graphs and lattices. While the techniques in this dissertation are developed with IFA in mind, they can be extended to other application of the bound constraints problem, such as type inference and program analysis frameworks which use annotated type systems, where constants are ordered over a lattice

Optimizing scoped and immortal memory management in real-time java

This thesis was submitted for the degree of Doctor of Philosophy and awarded by Brunel University.The Real-Time Specification for Java (RTSJ) introduces a new memory management model which avoids interfering with the garbage collection process and achieves better deterministic behaviour. In addition to the heap memory, two types of memory areas are provided - immortal and scoped. The research presented in this Thesis aims to optimize the use of the scoped and immortal memory model in RTSJ applications. Firstly, it provides an empirical study of the impact of scoped memory on execution time and memory consumption with different data objects allocated in scoped memory areas. It highlights different characteristics for the scoped memory model related to one of the RTSJ implementations (SUN RTS 2.2). Secondly, a new RTSJ case study which integrates scoped and immortal memory techniques to apply different memory models is presented. A simulation tool for a real-time Java application is developed which is the first in the literature that shows scoped memory and immortal memory consumption of an RTSJ application over a period of time. The simulation tool helps developers to choose the most appropriate scoped memory model by monitoring memory consumption and application execution time. The simulation demonstrates that a developer is able to compare and choose the most appropriate scoped memory design model that achieves the least memory footprint. Results showed that the memory design model with a higher number of scopes achieved the least memory footprint. However, the number of scopes per se does not always indicate a satisfactory memory footprint; choosing the right objects/threads to be allocated into scopes is an important factor to be considered. Recommendations and guidelines for developing RTSJ applications which use a scoped memory model are also provided. Finally, monitoring scoped and immortal memory at runtime may help in catching possible memory leaks. The case study with the simulation tool developed showed a space overhead incurred by immortal memory. In this research, dynamic code slicing is also employed as a debugging technique to explore constant increases in immortal memory. Two programming design patterns are presented for decreasing immortal memory overheads generated by specific data structures. Experimental results showed a significant decrease in immortal memory consumption at runtime

Deductive Verification of Safety-Critical Java Programs

This work investigates the application of deductive verification techniques to safety critical Java programs, in particular RTSJ programs. A focus is put on the formalization of the RTSJ memory model in dynamic logic, the utilization of a region-based memory model for ensuring non-interference and a design-by-contract based approach for the formal specification and verification of worst case memory consumption