scholarly journals Profiling Initialisation Behaviour in Java

2021 ◽  
Author(s):  
◽  
Stephen Frank Nelson
Keyword(s):  
Programming Languages ◽  
Program Analysis ◽  
Garbage Collection ◽  
Hybrid Approach ◽  
Memory Consumption ◽  
Aspect Oriented Programming ◽  
Analysis Study ◽  
Programming Tools ◽  
Mutable State ◽  
Blank Slate

<p>Freshly created objects are a blank slate: their mutable state and their constant properties must be initialised before they can be used. Programming languages like Java typically support object initialisation by providing constructor methods. This thesis examines the actual initialisation of objects in real-world programs to determine whether constructor methods support the initialisation that programmers actually perform. Determining which object initialisation techniques are most popular and how they can be identified will allow language designers to better understand the needs of programmers, and give insights that VM designers could use to optimise the performance of language implementations, reduce memory consumption, and improve garbage collection behaviour. Traditional profiling typically either focuses on timing, or uses sampling or heap snapshots to approximate whole program analysis. Classifying the behaviour of objects throughout their lifetime requires analysis of all program behaviour without approximation. This thesis presents two novel whole-program object profilers: one using purely class modification (#prof ), and a hybrid approach utilising class modification and JVM support (rprof ). #prof modifies programs using aspect-oriented programming tools to generate and aggregate data and examines objects that enter different collections to determine whether correlation exists between initialisation behaviour and the use of equality operators and collections. rprof confirms the results of an existing static analysis study of field initialisation using runtime analysis, and provides a novel study of object initialisation behaviour patterns.</p>

scholarly journals Profiling Initialisation Behaviour in Java

2021 ◽  
Author(s):  
◽  
Stephen Frank Nelson
Keyword(s):  
Programming Languages ◽  
Program Analysis ◽  
Garbage Collection ◽  
Hybrid Approach ◽  
Memory Consumption ◽  
Aspect Oriented Programming ◽  
Analysis Study ◽  
Programming Tools ◽  
Mutable State ◽  
Blank Slate

<p>Freshly created objects are a blank slate: their mutable state and their constant properties must be initialised before they can be used. Programming languages like Java typically support object initialisation by providing constructor methods. This thesis examines the actual initialisation of objects in real-world programs to determine whether constructor methods support the initialisation that programmers actually perform. Determining which object initialisation techniques are most popular and how they can be identified will allow language designers to better understand the needs of programmers, and give insights that VM designers could use to optimise the performance of language implementations, reduce memory consumption, and improve garbage collection behaviour. Traditional profiling typically either focuses on timing, or uses sampling or heap snapshots to approximate whole program analysis. Classifying the behaviour of objects throughout their lifetime requires analysis of all program behaviour without approximation. This thesis presents two novel whole-program object profilers: one using purely class modification (#prof ), and a hybrid approach utilising class modification and JVM support (rprof ). #prof modifies programs using aspect-oriented programming tools to generate and aggregate data and examines objects that enter different collections to determine whether correlation exists between initialisation behaviour and the use of equality operators and collections. rprof confirms the results of an existing static analysis study of field initialisation using runtime analysis, and provides a novel study of object initialisation behaviour patterns.</p>

Integrated Hardware Garbage Collection

2021 ◽  
Vol 20 (5) ◽  
pp. 1-25
Author(s):  
Andrés Amaya García ◽  
David May ◽  
Ed Nutting
Keyword(s):  
Software Development ◽  
Programming Languages ◽  
Real Time ◽  
Program Analysis ◽  
Garbage Collection ◽  
Data Representation ◽  
Garbage Collector ◽  
Tightly Coupled ◽  
Memory Cycle ◽  
High Level

Garbage collected programming languages, such as Python and C#, have accelerated software development. These modern languages increase productivity and software reliability as they provide high-level data representation and control structures. Modern languages are widely used in software development for mobile, desktop, and server devices, but their adoption is limited in real-time embedded systems. There is clear interest in supporting modern languages in embedded devices as emerging markets, like the Internet of Things, demand ever smarter and more reliable products. Multiple commercial and open-source projects, such as Zerynth and MicroPython, are attempting to provide support. But these projects rely on software garbage collectors that impose high overheads and introduce unpredictable pauses, preventing their use in many embedded applications. These limitations arise from the unsuitability of conventional processors for performing efficient, predictable garbage collection. We propose the Integrated Hardware Garbage Collector (IHGC); a garbage collector tightly coupled with the processor that runs continuously in the background. Further, we introduce a static analysis technique to guarantee that real-time programs are never paused by the collector. Our design allocates a memory cycle to the collector when the processor is not using the memory. The IHGC achieves this by careful division of collection work into single-memory-access steps that are interleaved with the processor’s memory accesses. As a result, our collector eliminates run-time overheads and enables real-time program analysis. The principles behind the IHGC can be used in conjunction with existing architectures. For example, we simulated the IHGC alongside the ARMv6-M architecture. Compared to a conventional processor, our experiments indicate that the IHGC offers 1.5–7 times better performance for programs that rely on garbage collection. The IHGC delivers the benefits of garbage-collected languages with real-time performance but without the complexity and overheads inherent in software collectors.

Programming languages and program analysis for security

2009 ◽  
Vol 43 (12) ◽  
pp. 32-39 ◽  
Author(s):  
Marco Pistoia ◽  
Úlfar Erlingsson
Keyword(s):  
Programming Languages ◽  
Program Analysis

scholarly journals A concurrent constraint programming interpretation of access permissions

2018 ◽  
Vol 18 (2) ◽  
pp. 252-295
Author(s):  
CARLOS OLARTE ◽  
ELAINE PIMENTEL ◽  
CAMILO RUEDA
Keyword(s):  
Programming Languages ◽  
Linear Logic ◽  
Object Oriented Programming ◽  
Theorem Prover ◽  
Deadlock Detection ◽  
Program Correctness ◽  
Detection Program ◽  
Mutable State ◽  
Verification Techniques ◽  
Access Permissions

AbstractA recent trend in object-oriented programming languages is the use of access permissions (APs) as an abstraction for controlling concurrent executions of programs. The use of AP source code annotations defines a protocol specifying how object references can access the mutable state of objects. Although the use of APs simplifies the task of writing concurrent code, an unsystematic use of them can lead to subtle problems. This paper presents a declarative interpretation of APs as linear concurrent constraint programs (lcc). We represent APs as constraints (i.e., formulas in logic) in an underlying constraint system whose entailment relation models the transformation rules of APs. Moreover, we use processes inlccto model the dependencies imposed by APs, thus allowing the faithful representation of their flow in the program. We verify relevant properties about AP programs by taking advantage of the interpretation oflccprocesses as formulas in Girard's intuitionistic linear logic (ILL). Properties include deadlock detection, program correctness (whether programs adhere to their AP specifications or not), and the ability of methods to run concurrently. By relying on a focusing discipline for ILL, we provide a complexity measure for proofs of the above-mentioned properties. The effectiveness of our verification techniques is demonstrated by implementing the Alcove tool that includes an animator and a verifier. The former executes thelccmodel, observing the flow of APs, and quickly finding inconsistencies of the APs vis-à-vis the implementation. The latter is an automatic theorem prover based on ILL.

JOIN POINT DESIGNATION DIAGRAMS: A GRAPHICAL REPRESENTATION OF JOIN POINT SELECTIONS

2006 ◽  
Vol 16 (03) ◽  
pp. 317-346 ◽  
Author(s):  
DOMINIK STEIN ◽  
STEFAN HANENBERG ◽  
RAINER UNLAND
Keyword(s):  
Software Development ◽  
Programming Languages ◽  
Graphical Representation ◽  
Point Selection ◽  
Aspect Oriented Programming ◽  
Specific Language ◽  
Design Issue ◽  
Language Constructs ◽  
Join Point

The specification of join point selections (also known as "pointcuts") is a major design issue in Aspect-Oriented Software Development. Aspect-oriented systems generally provide specific language constructs (subsumed by the term "pointcut language") for specifying such a join point selection. Pointcut languages differ widely with respect to their syntax and semantics. Consequently, developers familiar with one specific language can hardly benefit from this knowledge when designing and implementing pointcuts in another language. This implies that developers working with different aspect-oriented languages can hardly communicate their design to each other, and knowledge about aspect-oriented design can hardly be transferred among developers developing in different languages. In order to overcome this problem, we present novel specification means based on the UML to represent diverse ways of join point selections — without relying on language-specific syntax and semantics. Instead, the proposed language constructs are able to express join point selections in a variety of different aspect-oriented programming languages.

scholarly journals End-to-End Prediction of Buffer Overruns from Raw Source Code via Neural Memory Networks

2017 ◽  
Author(s):  
Min-je Choi ◽  
Sehun Jeong ◽  
Hakjoo Oh ◽  
Jaegul Choo
Keyword(s):  
Programming Languages ◽  
Program Analysis ◽  
Question Answering ◽  
Source Code ◽  
Source Codes ◽  
Program Language ◽  
Proposed Model ◽  
Challenging Tasks ◽  
Data Driven Approach ◽  
End To End

Detecting buffer overruns from a source code is one of the most common and yet challenging tasks in program analysis. Current approaches based on rigid rules and handcrafted features are limited in terms of flexible applicability and robustness due to diverse bug patterns and characteristics existing in sophisticated real-world software programs. In this paper, we propose a novel, data-driven approach that is completely end-to-end without requiring any hand-crafted features, thus free from any program language-specific structural limitations. In particular, our approach leverages a recently proposed neural network model called memory networks that have shown the state-of-the-art performances mainly in question-answering tasks. Our experimental results using source code samples demonstrate that our proposed model is capable of accurately detecting different types of buffer overruns. We also present in-depth analyses on how a memory network can learn to understand the semantics in programming languages solely from raw source codes, such as tracing variables of interest, identifying numerical values, and performing their quantitative comparisons.

scholarly journals Towards a Hybrid Approach to Protect Against Memory Safety Vulnerabilities

2021 ◽  
Author(s):  
Ahmed Bhayat ◽  
Lucas Cordeiro ◽  
Giles Reger ◽  
Fedor Shmarov ◽  
Konstantin Korovin ◽  
...  
Keyword(s):  
Programming Languages ◽  
Symbolic Execution ◽  
Hybrid Approach ◽  
Bounded Model Checking ◽  
Position Paper ◽  
Memory Safety ◽  
Systems Software ◽  
Static Checking ◽  
Runtime Information ◽  
Deployment Analysis

Memory corruption bugs continue to plague low-level systems software generally written in unsafe programming languages. In order to detect and protect against such exploits, many pre- and post-deployment techniques exist. In this position paper, we propose and motivate the need for a <i>hybrid</i> approach for the protection against memory safety vulnerabilities, combining techniques that can identify the presence (and absence) of vulnerabilities pre-deployment with those that can detect and mitigate such vulnerabilities post-deployment. Our hybrid approach involves three layers: hardware runtime protection provided by capability hardware, software runtime protection provided by compiler instrumentation, and static analysis provided by bounded model checking and symbolic execution. The key aspect of the proposed hybrid approach is that the protection offered is greater than the sum of its parts -- the expense of post-deployment runtime checks is reduced via information obtained during pre-deployment analysis. During pre-deployment analysis, static checking can be guided by runtime information. <br>

scholarly journals Towards a Hybrid Approach to Protect Against Memory Safety Vulnerabilities

2021 ◽  
Author(s):  
Ahmed Bhayat ◽  
Lucas Cordeiro ◽  
Giles Reger ◽  
Fedor Shmarov ◽  
Konstantin Korovin ◽  
...  
Keyword(s):  
Programming Languages ◽  
Symbolic Execution ◽  
Hybrid Approach ◽  
Bounded Model Checking ◽  
Position Paper ◽  
Memory Safety ◽  
Systems Software ◽  
Static Checking ◽  
Runtime Information ◽  
Deployment Analysis

Memory corruption bugs continue to plague low-level systems software generally written in unsafe programming languages. In order to detect and protect against such exploits, many pre- and post-deployment techniques exist. In this position paper, we propose and motivate the need for a <i>hybrid</i> approach for the protection against memory safety vulnerabilities, combining techniques that can identify the presence (and absence) of vulnerabilities pre-deployment with those that can detect and mitigate such vulnerabilities post-deployment. Our hybrid approach involves three layers: hardware runtime protection provided by capability hardware, software runtime protection provided by compiler instrumentation, and static analysis provided by bounded model checking and symbolic execution. The key aspect of the proposed hybrid approach is that the protection offered is greater than the sum of its parts -- the expense of post-deployment runtime checks is reduced via information obtained during pre-deployment analysis. During pre-deployment analysis, static checking can be guided by runtime information. <br>

Sign in / Sign up

Export Citation Format

Share Document