DOCSLIB.ORG

Detecting Memory Errors in a Constrained Embedded Linux System Fredrik Nyberg, Emil Bengtsson

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Detecting Memory Errors in a Constrained Embedded Linux System Fredrik Nyberg, Emil Bengtsson MASTER’S THESIS 2020 Detecting Memory Errors in a Constrained Embedded Linux System Fredrik Nyberg, Emil Bengtsson ISSN 1650-2884 LU-CS-EX: 2020-28 DEPARTMENT OF COMPUTER SCIENCE LTH j LUND UNIVERSITY EXAMENSARBETE Datavetenskap LU-CS-EX: 2020-28 Detecting Memory Errors in a Constrained Embedded Linux System Fredrik Nyberg, Emil Bengtsson Detecting Memory Errors in a Constrained Embedded Linux System (Perspective from the Automotive Industry) Fredrik Nyberg Emil Bengtsson [email protected] [email protected] June 22, 2020 Master’s thesis work carried out at Volvo Cars. Supervisors: Flavius Gruian, [email protected] Paul Asterland, [email protected] Examiner: Jonas Skeppstedt, [email protected] Abstract Memory errors are the cause of many bugs in software written in C and C++. Embedded systems often run software written in these languages, and it is com- mon for these systems to have limited resources. Embedded systems are also susceptible to errors, since they are often supposed to run for long times with- out crashing. Finding errors is therefore important, which makes analysing the software rewarding, but the low resource availability can make dynamic analysis tools challenging to use. We have evaluated different dynamic memory analy- sis tools by assessing their error finding capabilities, and their impact on the analysed programs’ performance. We have carried out our work for Volvo Cars, and performed our evaluations on one of their embedded systems. As part of the evaluation, we also used the most promising tools to analyse some of Volvo’s pro- grams in a real setting. We managed to find two memory leaks in one of Volvo’s programs by analysing them with the tools. The leaks were confirmed to be real by a developer, and Volvo could fix them. Based on our findings, we recommend a selection of tools that we consider useful for analysing software on embedded Linux. We conclude that using 2-3 less advanced tools in separate analysis runs works better than using a more advanced tool on Volvo’s embedded system. This approach introduces less overhead while still being able to find as many errors as the more advanced tools. Keywords: Memory Errors, Limited Resources, Embedded Systems, Automotive, Mem- ory Analysis 2 Acknowledgements We would like to thank our LTH supervisor Flavius Gruian for his guidance during the entire thesis process, especially for his detailed and constructive feedback on our writing. We would also like to thank Paul Asterland at Volvo Cars for guiding our work in a direction which made the thesis relevant for Volvo Cars and for making sure we felt welcome and had all the support and equipment we needed. Additionally, we want to thank all developers at Volvo who helped us with any technical questions we had, and with giving suggestions for the thesis: Johan Bohlin, Ola Lilja, Piotr Tomaszewski, and Mikael Persson. Lastly, we would like to thank everyone else who helped proof-reading our thesis; your feedback has greatly improved our writing. 3 4 Contents 1 Introduction 9 1.1 Problem Definition . 10 1.2 Research Questions . 11 1.3 Limitations . 11 1.4 Delimitations . 11 1.5 Division of Work . 12 2 Background 13 2.1 Embedded systems . 13 2.1.1 Embedded Software . 14 2.2 Hardware Dependent Software . 15 2.3 Memory Leaks and Memory Faults . 16 2.3.1 Memory Leaks . 17 Memory Leak Detection and Prevention . 17 2.3.2 Memory Faults . 18 2.4 Common Weakness Enumeration . 18 2.4.1 List of Errors and Their CWE Classification . 19 2.5 Memory Analysis . 22 2.5.1 Static Analysis . 22 2.5.2 Dynamic Analysis . 24 2.6 The Automotive Industry and Software . 25 2.7 Automotive Standards and Guidelines . 27 2.8 Volvo and the TCAM .............................. 28 2.9 Related Work . 29 3 Method 33 3.1 Literature Review . 33 3.2 Initial Tool Selection . 34 3.3 Benchmarks . 35 3.3.1 Memory Errors . 35 5 CONTENTS 3.3.2 Overhead . 36 Description of Benchmarking Programs . 37 3.4 Evaluation . 39 3.4.1 Memory Faults . 39 3.4.2 Overhead . 40 Execution Time . 40 Memory Consumption . 40 3.5 Revised Tool Selection . 40 3.6 Testing on Volvo’s Programs . 42 3.7 Final Tool Selection . 43 4 Tool Survey 45 4.1 General Usage of Tools . 45 4.2 Implementation Details of Tools . 46 4.2.1 Valgrind . 46 4.2.2 Dr. Memory . 47 4.2.3 AddressSanitizer . 47 4.2.4 Debug_new . 48 4.2.5 Heaptrack . 48 4.2.6 Heapusage . 48 4.2.7 Gperftools . 48 5 Results 51 5.1 Initial Tool Selection . 51 5.2 Evaluation . 51 5.2.1 Memory Fault and Leak Detection . 52 5.2.2 Tool Feedback . 53 5.2.3 Execution Time . 54 5.2.4 Memory Consumption . 56 5.3 Analysing Volvo’s Programs . 58 5.3.1 AddressSanitizer . 58 5.3.2 Debug_new . 59 5.3.3 Heapusage . 60 5.3.4 Heaptrack, Dr. Memory, and Gperftools . 60 6 Discussion 61 6.1 Memory Leaks and Memory Faults . 61 6.2 Overhead . 63 6.3 Development and Maintenance of Tools . 64 6.4 Testing on Volvo’s Programs . 64 6.5 Tool Usage in the Workflow . 65 6.6 Possible Pitfalls . 65 7 Conclusions 67 7.1 Answers to Research Questions . 67 7.2 Future Work . 69 6 CONTENTS References 73 Appendix A Description of Terms 85 Appendix B Usage of Tools 87 B.1 Volvo Script . 87 B.2 Debug_new . 87 B.3 Memwatch . 88 B.4 Heaptrack . 89 B.5 Heapusage . 90 B.6 Valgrind (Memcheck) . 91 B.7 Leaktracer . 91 B.8 Gperftools Heapcheck . 92 B.9 AddressSanitizer . 92 B.10 Duma . 92 B.11 Malloc_count . 93 B.12 Libleak . 93 B.13 Mtrace . 93 B.14 Rmdebug . 94 B.15 Dr. Memory . 94 Appendix C Tables 95 Appendix D Graphs 119 7 CONTENTS 8 Chapter 1 Introduction “Since human beings themselves are not fully debugged yet, there will be bugs in your code no matter what you do.” — Chris Mason [67] Embedded systems are present in many objects we use every day. For convenience and safety, it is important to minimise the risk of these systems malfunctioning. One way an embedded system can malfunction is if there is an error in the software running on it. Some of these errors can be found with analysis tools, but since embedded systems often have limited memory and processing power, not all tools are able to run on them. We have evaluated different tools, to see if they can be used to find memory errors in an embedded environment. We have carried out our work at Volvo Cars and performed our evaluations on an embedded Linux system used for telecommunications in future cars. The final product of our evaluations is a suggestion of tools which we consider useful for finding memory errors in embedded software. In this chapter, we define the problem we want to solve and why it is important, present our research questions, list the limitations and delimitations we worked with, and describe how we divided the work. 9 1. Introduction 1.1 Problem Definition Finding errors related to how memory is used in software is important, since memory errors can cause malfunctions and crashes. There are many tools that can be used for finding these errors: some of them only find a specific subset of errors, and some of them find manydiffer- ent kinds. A few of these tools, especially the ones that find many types of errors, introduce large overheads on the programs they analyse, both in memory consumption and in execu- tion time. One such tool, which is arguably one of the more common memory analysis tools, is the Valgrind skin Memcheck. Since it is able to find multiple types of errors, Memcheck can be a useful asset during software development. However, the usefulness comes at a price; as described in Section 4.2.1, Memcheck imposes considerable overheads on the programs it analyses. Finding memory errors in embedded software is especially important, since embedded systems are often intended to run for extended periods of time without crashing. Many of these systems have limited amounts of memory and are not as powerful as desktop computers, which can make demanding analysis tools, such as Memcheck, difficult to use on them. This is not a problem if the software can be compiled for a more powerful computer. However, sometimes the software is dependent on the embedded system. For example, it might need some specific hardware component to be present. Because of this, it would be desirable to find other tools that are not just effective at finding errors, but are also efficient inhowmuch resource overhead they introduce.
Load more

Recommended publications
  • HALO: Post-Link Heap-Layout Optimisation
    HALO: Post-Link Heap-Layout Optimisation Joe Savage Timothy M. Jones University of Cambridge, UK University of Cambridge, UK [email protected] [email protected] Abstract 1 Introduction Today, general-purpose memory allocators dominate the As the gap between memory and processor speeds continues landscape of dynamic memory management. While these so- to widen, efficient cache utilisation is more important than lutions can provide reasonably good behaviour across a wide ever. While compilers have long employed techniques like range of workloads, it is an unfortunate reality that their basic-block reordering, loop fission and tiling, and intelligent behaviour for any particular workload can be highly subop- register allocation to improve the cache behaviour of pro- timal. By catering primarily to average and worst-case usage grams, the layout of dynamically allocated memory remains patterns, these allocators deny programs the advantages of largely beyond the reach of static tools. domain-specific optimisations, and thus may inadvertently Today, when a C++ program calls new, or a C program place data in a manner that hinders performance, generating malloc, its request is satisfied by a general-purpose allocator unnecessary cache misses and load stalls. with no intimate knowledge of what the program does or To help alleviate these issues, we propose HALO: a post- how its data objects are used. Allocations are made through link profile-guided optimisation tool that can improve the fixed, lifeless interfaces, and fulfilled by
    [Show full text]
  • Transparent Garbage Collection for C++
    Document Number: WG21/N1833=05-0093 Date: 2005-06-24 Reply to: Hans-J. Boehm [email protected] 1501 Page Mill Rd., MS 1138 Palo Alto CA 94304 USA Transparent Garbage Collection for C++ Hans Boehm Michael Spertus Abstract A number of possible approaches to automatic memory management in C++ have been considered over the years. Here we propose the re- consideration of an approach that relies on partially conservative garbage collection. Its principal advantage is that objects referenced by ordinary pointers may be garbage-collected. Unlike other approaches, this makes it possible to garbage-collect ob- jects allocated and manipulated by most legacy libraries. This makes it much easier to convert existing code to a garbage-collected environment. It also means that it can be used, for example, to “repair” legacy code with deficient memory management. The approach taken here is similar to that taken by Bjarne Strous- trup’s much earlier proposal (N0932=96-0114). Based on prior discussion on the core reflector, this version does insist that implementations make an attempt at garbage collection if so requested by the application. How- ever, since there is no real notion of space usage in the standard, there is no way to make this a substantive requirement. An implementation that “garbage collects” by deallocating all collectable memory at process exit will remain conforming, though it is likely to be unsatisfactory for some uses. 1 Introduction A number of different mechanisms for adding automatic memory reclamation (garbage collection) to C++ have been considered: 1. Smart-pointer-based approaches which recycle objects no longer ref- erenced via special library-defined replacement pointer types.
    [Show full text]
  • An Evolutionary Study of Linux Memory Management for Fun and Profit Jian Huang, Moinuddin K
    An Evolutionary Study of Linux Memory Management for Fun and Profit Jian Huang, Moinuddin K. Qureshi, and Karsten Schwan, Georgia Institute of Technology https://www.usenix.org/conference/atc16/technical-sessions/presentation/huang This paper is included in the Proceedings of the 2016 USENIX Annual Technical Conference (USENIX ATC ’16). June 22–24, 2016 • Denver, CO, USA 978-1-931971-30-0 Open access to the Proceedings of the 2016 USENIX Annual Technical Conference (USENIX ATC ’16) is sponsored by USENIX. An Evolutionary Study of inu emory anagement for Fun and rofit Jian Huang, Moinuddin K. ureshi, Karsten Schwan Georgia Institute of Technology Astract the patches committed over the last five years from 2009 to 2015. The study covers 4587 patches across Linux We present a comprehensive and uantitative study on versions from 2.6.32.1 to 4.0-rc4. We manually label the development of the Linux memory manager. The each patch after carefully checking the patch, its descrip- study examines 4587 committed patches over the last tions, and follow-up discussions posted by developers. five years (2009-2015) since Linux version 2.6.32. In- To further understand patch distribution over memory se- sights derived from this study concern the development mantics, we build a tool called MChecker to identify the process of the virtual memory system, including its patch changes to the key functions in mm. MChecker matches distribution and patterns, and techniues for memory op- the patches with the source code to track the hot func- timizations and semantics. Specifically, we find that tions that have been updated intensively.
    [Show full text]
  • Declarative Computation Model Memory Management Last Call
    Memory Management Declarative Computation Model Memory management (VRH 2.5) • Semantic stack and store sizes during computation – analysis using operational semantics Carlos Varela – recursion used for looping RPI • efficient because of last call optimization October 5, 2006 – memory life cycle Adapted with permission from: – garbage collection Seif Haridi KTH Peter Van Roy UCL C. Varela; Adapted w/permission from S. Haridi and P. Van Roy 1 C. Varela; Adapted w/permission from S. Haridi and P. Van Roy 2 Last call optimization Last call optimization • Consider the following procedure ST: [ ({Loop10 0}, E0) ] proc {Loop10 I} ST: [({Browse I}, {I→i ,...}) proc {Loop10 I} 0 if I ==10 then skip ({Loop10 I+1}, {I→i ,...}) ] else if I ==10 then skip 0 else σ : {i =0, ...} {Browse I} 0 {Browse I} Recursive call {Loop10 I+1} {Loop10 I+1} end is the last call end ST: [({Loop10 I+1}, {I→i0,...}) ] end end σ : {i0=0, ...} • This procedure does not increase the size of the STACK ST: [({Browse I}, {I→i1,...}) • It behaves like a looping construct ({Loop10 I+1}, {I→i1,...}) ] σ : {i0=0, i1=1,...} C. Varela; Adapted w/permission from S. Haridi and P. Van Roy 3 C. Varela; Adapted w/permission from S. Haridi and P. Van Roy 4 Stack and Store Size Garbage collection proc {Loop10 I} proc {Loop10 I} ST: [({Browse I}, {I→ik,...}) ST: [({Browse I}, {I→ik,...}) if I ==10 then skip if I ==10 then skip ({Loop10 I+1}, {I i ,...}) ] ({Loop10 I+1}, {I i ,...}) ] else → k else → k {Browse I} σ : {i0=0, i1=1,..., ik-i=k-1, ik=k,..
    [Show full text]
  • Ubuntu Server Guide Basic Installation Preparing to Install
    Ubuntu Server Guide Welcome to the Ubuntu Server Guide! This site includes information on using Ubuntu Server for the latest LTS release, Ubuntu 20.04 LTS (Focal Fossa). For an offline version as well as versions for previous releases see below. Improving the Documentation If you find any errors or have suggestions for improvements to pages, please use the link at thebottomof each topic titled: “Help improve this document in the forum.” This link will take you to the Server Discourse forum for the specific page you are viewing. There you can share your comments or let us know aboutbugs with any page. PDFs and Previous Releases Below are links to the previous Ubuntu Server release server guides as well as an offline copy of the current version of this site: Ubuntu 20.04 LTS (Focal Fossa): PDF Ubuntu 18.04 LTS (Bionic Beaver): Web and PDF Ubuntu 16.04 LTS (Xenial Xerus): Web and PDF Support There are a couple of different ways that the Ubuntu Server edition is supported: commercial support and community support. The main commercial support (and development funding) is available from Canonical, Ltd. They supply reasonably- priced support contracts on a per desktop or per-server basis. For more information see the Ubuntu Advantage page. Community support is also provided by dedicated individuals and companies that wish to make Ubuntu the best distribution possible. Support is provided through multiple mailing lists, IRC channels, forums, blogs, wikis, etc. The large amount of information available can be overwhelming, but a good search engine query can usually provide an answer to your questions.
    [Show full text]
  • Cryptographic Software: Vulnerabilities in Implementations 1
    Pobrane z czasopisma Annales AI- Informatica http://ai.annales.umcs.pl Data: 03/10/2021 00:10:27 Annales UMCS Informatica AI XI, 4 (2011) 1–10 DOI: 10.2478/v10065-011-0030-7 Cryptographic software: vulnerabilities in implementations Michał Łuczaj1∗ 1Institute of Telecommunications, Warsaw University of Technology Poland Abstract – Security and cryptographic applications or libraries, just as any other generic software products may be affected by flaws introduced during the implementation process. No matter how much scrutiny security protocols have undergone, it is — as always — the weakest link that holds everything together to makes products secure. In this paper I take a closer look at problems usually resulting from a simple human made mistakes, misunderstanding of algorithm details or a plain lack of experience with tools and environment. In other words: everything that can and will happen during software development but in the fragile context of cryptography. UMCS1 Introduction I begin with a brief introduction of typical mistakes and oversights that can be made during program implementation in one of the most popular programming languages, C[1]. I also explain the concept of exploitable memory corruption, how critical it is and where it leads from the attacker’s point of view. A set of real-world examples is given. Some well known previously disclosed vulner- abilities are brought to illustrate how a flaw (sometimes even an innocent looking) can fatally injune security of the whole protocol, algorithm. There is much to discuss as failed attempts at implementing cryptographic primitives — or making use of cryptog- raphy in general — range broadly.
    [Show full text]
  • Memory Management
    Memory management The memory of a computer is a finite resource. Typical Memory programs use a lot of memory over their lifetime, but not all of it at the same time. The aim of memory management is to use that finite management resource as efficiently as possible, according to some criterion. Advanced Compiler Construction In general, programs dynamically allocate memory from two different areas: the stack and the heap. Since the Michel Schinz — 2014–04–10 management of the stack is trivial, the term memory management usually designates that of the heap. 1 2 The memory manager Explicit deallocation The memory manager is the part of the run time system in Explicit memory deallocation presents several problems: charge of managing heap memory. 1. memory can be freed too early, which leads to Its job consists in maintaining the set of free memory blocks dangling pointers — and then to data corruption, (also called objects later) and to use them to fulfill allocation crashes, security issues, etc. requests from the program. 2. memory can be freed too late — or never — which leads Memory deallocation can be either explicit or implicit: to space leaks. – it is explicit when the program asks for a block to be Due to these problems, most modern programming freed, languages are designed to provide implicit deallocation, – it is implicit when the memory manager automatically also called automatic memory management — or garbage tries to free unused blocks when it does not have collection, even though garbage collection refers to a enough free memory to satisfy an allocation request. specific kind of automatic memory management.
    [Show full text]
  • Eviction Based on Implicit Entry Reachability
    University of Texas at El Paso ScholarWorks@UTEP Open Access Theses & Dissertations 2020-01-01 Finalcache: Eviction Based On Implicit Entry Reachability Adrian Veliz University of Texas at El Paso Follow this and additional works at: https://scholarworks.utep.edu/open_etd Part of the Computer Sciences Commons, and the Sustainability Commons Recommended Citation Veliz, Adrian, "Finalcache: Eviction Based On Implicit Entry Reachability" (2020). Open Access Theses & Dissertations. 3128. https://scholarworks.utep.edu/open_etd/3128 This is brought to you for free and open access by ScholarWorks@UTEP. It has been accepted for inclusion in Open Access Theses & Dissertations by an authorized administrator of ScholarWorks@UTEP. For more information, please contact [email protected]. FINALCACHE: EVICTION BASED ON IMPLICIT ENTRY REACHABILITY ADRIAN EDWARD VELIZ Doctoral Program in Computer Science APPROVED: Eric Freudenthal, Ph.D., Chair Omar Badreddin, Ph.D. Yoonsik Cheon, Ph.D. Art Duval, Ph.D. Stephen L. Crites, Jr., Ph.D. Dean of the Graduate School Copyright © by Adrian Veliz 2020 Dedication This dissertation is dedicated to my brother Oscar, mother Martha, and father Jesus. Your love and support mean the world to me. This would not have been possible without you. Love you. FINALCAHCE: EVICTION BASED ON IMPLICIT ENTRY REACHABILITY by ADRIAN EDWARD VELIZ, B.S. & M.S. OF CS DISSERTATION Presented to the Faculty of the Graduate School of The University of Texas at El Paso in Partial Fulfillment of the Requirements for the Degree of DOCTOR OF PHILOSOPHY Department of Computer Science THE UNIVERSITY OF TEXAS AT EL PASO August 2020 Acknowledgements I would like to thank everyone who has helped me with research and writing.
    [Show full text]
  • Mitigating the Performance-Efficiency Tradeoff in Resilient Memory Disaggregation
    Mitigating the Performance-Efficiency Tradeoff in Resilient Memory Disaggregation Youngmoon Lee∗, Hasan Al Maruf∗, Mosharaf Chowdhury∗, Asaf Cidonx, Kang G. Shin∗ University of Michigan∗ Columbia Universityx ABSTRACT State-of-the-art solutions take three primary approaches: (i) local We present the design and implementation of a low-latency, low- disk backup [36, 66], (ii) remote in-memory replication [31, 50], and overhead, and highly available resilient disaggregated cluster mem- (iii) remote in-memory erasure coding [61, 64, 70, 73] and compres- ory. Our proposed framework can access erasure-coded remote sion [45]. Unfortunately, they suffer from some combinations of memory within a single-digit `s read/write latency, significantly the following problems. improving the performance-efficiency tradeoff over the state-of- High latency: The first approach has no additional memory the-art – it performs similar to in-memory replication with 1.6× overhead, but the access latency is intolerably high in the presence lower memory overhead. We also propose a novel coding group of any of the aforementioned failure scenarios. The systems that placement algorithm for erasure-coded data, that provides load bal- take the third approach do not meet the single-digit `s latency ancing while reducing the probability of data loss under correlated requirement of disaggregated cluster memory even when paired failures by an order of magnitude. with RDMA (Figure 1). High cost: While the second approach has low latency, it dou- bles memory consumption as well as network bandwidth require- ments. The first and second approaches represent the two extreme 1 INTRODUCTION points in the performance-vs-efficiency tradeoff space for resilient To address the increasing memory pressure in datacenters, two cluster memory (Figure 1).
    [Show full text]
  • Garbage Collection
    GARBAGE COLLECTION Prof. Chris Jermaine [email protected] Prof. Scott Rixner [email protected] 1 What Is Garbage Collection? • A “garbage collected” PL implementation (like Java)... — Provides automatic support for reclaiming memory you are done with — The imp itself checks to see if there is any way to reach some allocated memory — And if there is not, it deletes it • Key thing to be aware of: — It’s a bit strong to say a “language” itself is garbage collected (or not) — Though that is what we (and everyone else) will say — Why is the claim that “C is not garbage collected” a bit silly? • What is alternative to GC? — Ask the programmer to free memory when done with it. Always have: SparseDoubleVector foo = new SparsDoubleVector (100, 1.0) some code; delete foo; 2 Short History of Garbage Collection • Way back when, there was no dynamic memory allocation — We’re talking Fortran in the mid 1950’s — You declared all your vars up front, at compile time — So no need for PL system to dynamically reclaim memory... — In first implementations, compiler claimed space for each var • GC was invented with Lisp in the late 1950s — But remained a fringe idea — Lisp was never tremendously popular — Then, with advent of C/C++ in early 70’s, self-memory management was “in” • I’d say it only became mainstream with first Java in mid 90’s — Now, a very common idea 3 Pros And Cons of GC • Pros? Cons? 4 Pros And Cons of GC • Pros — Don’t need to worry about adding “free” or “delete” statements to code — Never have bugs related to dangling references/pointers
    [Show full text]
  • Automatic Memory Management Policies for Low Power, Memory Limited, and Delay Intolerant Devices Md Abu Jahid University of Texas at El Paso, [email protected]
    University of Texas at El Paso DigitalCommons@UTEP Open Access Theses & Dissertations 2013-01-01 Automatic Memory Management Policies For Low Power, Memory Limited, And Delay Intolerant Devices Md Abu Jahid University of Texas at El Paso, [email protected] Follow this and additional works at: https://digitalcommons.utep.edu/open_etd Part of the Computer Sciences Commons, and the Oil, Gas, and Energy Commons Recommended Citation Jahid, Md Abu, "Automatic Memory Management Policies For Low Power, Memory Limited, And Delay Intolerant Devices" (2013). Open Access Theses & Dissertations. 1849. https://digitalcommons.utep.edu/open_etd/1849 This is brought to you for free and open access by DigitalCommons@UTEP. It has been accepted for inclusion in Open Access Theses & Dissertations by an authorized administrator of DigitalCommons@UTEP. For more information, please contact [email protected]. AUTOMATIC MEMORY MANAGEMENT POLICIES FOR LOW POWER, MEMORY LIMITED, AND DELAY INTOLERANT DEVICES MD ABU JAHID Department of Computer Science APPROVED: Eric Freudenthal, Chair, Ph.D. Luc Longpr´e,Ph.D. Bryan Usevitch, Ph.D. Salamah I. Salamah, Ph.D. Benjamin C. Flores, Ph.D. Dean of the Graduate School c Copyright by Md Abu Jahid 2013 to my PARENTS with love AUTOMATIC MEMORY MANAGEMENT POLICIES FOR LOW POWER, MEMORY LIMITED, AND DELAY INTOLERANT DEVICES by MD ABU JAHID THESIS Presented to the Faculty of the Graduate School of The University of Texas at El Paso in Partial Fulfillment of the Requirements for the Degree of MASTER OF SCIENCE Department of Computer Science THE UNIVERSITY OF TEXAS AT EL PASO August 2013 Acknowledgements I would like to express my gratitude to my advisor, Dr.
    [Show full text]
  • Garbage Collection Hoping to Cover Motivation Garbage Collection (GC)
    Hoping to cover Garbage Collection ! Motivation & basics ! Introduction to three families of collection algorithms: ! Reference Counting ! Mark & Sweep Andrew Tolmach ! Copying Collection ! Advanced issues and topics (Slides prepared by Marius Nita.) 1 2 Motivation Garbage Collection (GC) Problems with manual memory management: ! The automatic reclamation of unreachable memory (aka garbage). ! It is extremely tedious and error-prone. ! Universally used for high level languages with closures ! It introduces software engineering issues (Who is and complex data structures that are allocated supposed to free the memory?) implicitly. ! It is by no means intrinsically efficient. (free is not free.) ! Useful for any language that supports heap allocation. ! In many cases, the costs outweigh the benefits. ! It removes the need for explicit deallocation (no more delete and free). ! Let the GC implementor deal with memory corruption issues once and for all. 3 4 How does it work? Terminology Typically: Heap: Adirectedgraphwhosenodesaredynamically ! The user program (mutator)islinkedagainstalibrary allocated records and whose edges are pointers between known as the runtime system (RTS) (e.g. libc). nodes. Typically laid out in a contiguous memory space. ! In the RTS resides the memory allocation service,which Root set: The set of pointers into the heap from an external exposes an allocation routine to the user program. source (e.g. the stack, global variables). ! When the user program desires more memory, it Live data: The set of heap records that are reachable by invokes the allocation routine (e.g. malloc). following paths starting at members of the root set. ! The allocation service may then perform a collection to Garbage: The set of heap records that are not live.
    [Show full text]