University Memory Manager and Smart Pointer Design Report - COMP5813M

This report delves into the critical aspects of memory management and smart pointer implementation using C++. It examines the challenges of memory management in C++, including issues like insufficient memory allocation, pointer administration, and memory leaks. The report explores various memory management techniques, such as automatic, static, and dynamic allocation, with a focus on the 'new' and 'delete' keywords. It also introduces smart pointers as a solution for managing memory more efficiently, discussing their role in automatic destruction, reference checking, and resource management. The report covers the application of smart pointers in different contexts like file handles and network sockets. The report references several sources to support the discussion, including works on memory disclosures, compiler-level analysis, and heap bounds protection.

The design of Memory Manager and the smart pointer
Name:
Student ID:
University Name:
Submission Date:

Table of Contents
Introduction..................................................................................................................3
1. Memory Management..............................................................................................3
2. Smart Pointer...........................................................................................................5
Conclusion.....................................................................................................................7
References.....................................................................................................................8

Introduction
Bigelow et al. (2015) opined that memory management is one of the big issues in
fundamental programming. Though, it's an important aspect to manage memory in the
programming environment using C++ [1]. Lakhotia, Harman and Gross (2013) stated that
smart pointers are the class objects which look as well as feel like pointer, but they are
smarter [2].
This report is designed to explain the use of C++ language in memory management
and smart pointer in programming environment.
1. Memory Management
Consider we have numerous procedures for which we have to assign memory, if we
designate memory for one process and move to second process for portion, so in what manner
will you monitor last distributed memory obstruct, for this we have to store some metadata
with dispensed memory square, for example, pointer focuses to a next square, memory
address, is free and so on [3].
Memory administration is most likely the most concerning issue when utilising C++.
Memory administration mistakes are both simple to make and hard to recognise. C++ infers
three implicit memory administration issues -
 C++ does not check cluster limits. Consequently, issues happen when
insufficient memory is designated.
 Another issue includes pointer administration and emerges when pointers
speak to objects. The ill-advised utilisation of pointers brings about dangling
references, which happen when memory is dispensed and afterwards de-
assigned, yet the pointer is still being used.

 Also, it is conceivable to allow memory and never de-dispense it, even after
all pointers to it have been pulverised. This outcomes in memory spill.
In C++ we perceive three sorts of memory administration – programmed, static
assignment and dynamic portion -
 Automatic management: It is confined to managing neighbourhood factors. It
is also known as Stack Allocation. For this situation, the memory dispensed
for a nearby consideration is de-designated consequently toward the finish of
the variable's extension [4]. Henceforth, it is risky to utilise pointers with
adjacent factors, since this is a potential dangling reference case.
 Static Allocation: It is utilised for putting away common factors and factors
pronounced static (both neighbourhood static factors and immobile class
individuals). Those factors need to persevere for the whole keep running of the
program [5]. In static allotment, a specific scope of memory is put aside for
the capacity of static factors, and this memory can never be utilised for
whatever else for the span of the program.
 Dynamic allocation: It is asked for by utilising the new and erase
catchphrases. Generally speaking, C++ does not naturally de-apportion
anything assigned with new, i.e. to free progressively distributed articles we
should employ the erase watchword. We should refer to here that new and
delete conceivably costly tasks, "on account of the additional accounting the
memory director must do, and regularly because of the additional accounting
the software engineer must do" [7]. Furthermore, C++ executes a capacity
malloc() that like new powerfully designates memory. The malloc() work
restores a pointer of sort void to a memory cradle of the asked for memory
square.

2. Smart Pointer
Utilising smart pointers, we can make pointers to work in way that we don't have to
call erase unequivocally. Shrewd pointer is a wrapper class over a pointer with administrator
like * and - > over-burden. The objects of keen pointer class look like pointer, however, can
do numerous things that a typical pointer cannot care for programmed decimation (truly, we
don't need to utilise erase expressly), reference checking and that's just the beginning [14].
The thought is to make a class with a pointer, destructor and over-burden administrators like
* and - >. Since destructor is naturally considered when a protest leaves scope, the
progressively apportioned memory would consequently be erased (or reference tally can be
decremented). Consider the accompanying basic smartPtr class. Smart pointers are likewise
valuable in the administration of assets, for example, document handles or system
attachments. C++ libraries give executions of savvy pointers as auto_ptr, unique_ptr,
shared_ptr and weak_ptr [6].
Smart pointer is utilised to make more effective utilisation of accessible memory and
to abbreviate distribution and deallocation time. A typical methodology for utilising memory
all the more proficiently is duplicate on compose (COW) [13]. This implies a similar question
is shared by many COW pointers as long as it is just perused and not changed. At the point
when some piece of the program endeavours to change the protest ("compose"), the COW
pointer makes another duplicate of the question and alters this duplicate rather than the first
question [8]. The standard string class is usually actualised utilising COW semantics (see the
<string> header).

Improved distribution plans are conceivable when you can make a few suspicions
about the articles to be allotted or the working condition [9]. For instance, you may realise
that every one of the articles will have a similar size, or that they will all live in a single
string. Even though it is conceivable to execute improved designation plans utilising class-
particular new and erase administrators, brilliant pointers give you the opportunity to pick
whether to utilise the upgraded plan for each protest, rather than having the plan set for all
objects of a class [10]. It is subsequently conceivable to coordinate the portion plan to various
working conditions and applications, without altering the code for the whole class.
The C++ standard library incorporates an arrangement of holders and calculations
known as the standard layout library (STL). STL is intended to be conventional (can be
utilised with any protest) and proficient (does not acquire time overhead contrasted with
options) [11]. To accomplish these two plan objectives, STL holders store their items by
esteem. This implies if you have an STL compartment that stores objects of class Base, it
can't store of objects of classes got from Base.

Conclusion
It is noticed that programming of memory management using C++ is more powerful
that gives full control over the entire memory management process. However, it is also
identified that lack of automatic memory mechanism exposed by C++ may result in the
memory leak and dangling pointer.

References
[1] D. Bigelow, T. Hobson, R. Rudd, W. Streilein, and H. Okhravi, “Timely
Rerandomization for Mitigating Memory Disclosures,” in The 22nd ACM SIGSAC
Conference on Computer and Communications Security (CCS2015), 2015.
[2] K. Lakhotia, M. Harman, and H. Gross, "AUSTIN: An open source tool for search-based
software testing of C programs," in Information and Software Technology, 2013.
[3] K. Anand et al., “A compiler-level intermediate representation based binary analysis
and rewriting system,” in Proceedings of the 8th ACM European Conference on
Computer Systems - EuroSys ’13, 2013.
[4] S. Nagarakatte and M. Zdancewic, “WatchdogLite: Hardware-Accelerated Compiler-
Based Pointer Checking,” Cgo, 2014.
[5] G. J. Duck and R. H. C. Yap, "Heap bounds protection with low-fat pointers," in CC
2016: Proceedings of the 25th International Conference on Compiler Construction,
2016.
[6] T. C. Stewart, F.-X. Choo, and C. Eliasmith, “Spaun: A Perception-Cognition-Action
Model Using Spiking Neurons,” Proc. 34th Annu. Meet. Cogn. Sci. Soc. CogSci 2012,
2012.
[7] M. C. Rodriguez-Sanchez and J. Martinez-Romo, “GAWA – Manager for accessibility
Wayfinding apps,” Int. J. Inf. Manage., 2017.
[8] J. Qiu et al., “Going Deeper with Embedded FPGA Platform for Convolutional Neural
Network,” in Proceedings of the 2016 ACM/SIGDA International Symposium on
Field-Programmable Gate Arrays - FPGA ’16, 2016.
[9] A. Sivieri, L. Mottola, and G. Cugola, “Building Internet of Things software with
ELIoT,” Comput. Commun., 2016.
[10] Y. Sui, D. Ye, and J. Xue, “Static memory leak detection using full-sparse value-flow
analysis,” in Proceedings of the 2012 International Symposium on Software Testing
and Analysis - ISSTA 2012, 2012.
[11] F. Winterstein, S. Bayliss, and G. A. Constantinides, “High-level synthesis of dynamic
data structures: A case study using Vivado HLS,” in FPT 2013 - Proceedings of the
2013 International Conference on Field Programmable Technology, 2013.
[12] F. J. Winterstein, S. R. Bayliss, and G. A. Constantinides, “Separation Logic for High-
Level Synthesis,” ACM Trans. Reconfigurable Technol. Syst., 2015.
[13] G. Weisz, J. Melber, Y. Wang, K. Fleming, E. Nurvitadhi, and J. C. Hoe, “A Study of
Pointer-Chasing Performance on Shared-Memory Processor-FPGA Systems,” in

Proceedings of the 2016 ACM/SIGDA International Symposium on Field-
Programmable Gate Arrays - FPGA ’16, 2016.
[14] S. Ullrich, Y. C. de Vries, S. Kühn, D. Repantis, M. Dresler, and K. Ohla, “Feeling
smart: Effects of caffeine and glucose on cognition, mood and self-judgment,”
Physiol. Behav., 2015.