Memory Management Flashcards
How malloc/new works on memory allocation?
According with the size of the memory requested, there will be one blocks of 2^n size wich fits the required size.
The size of 2^n is used to avoid fragment memory.
In this code:
char* s = new char[357]; ... delete[] s;
How delete knows how many memory needs to release?
s points to the address where the memory request is llocated, but there is another sector of memory immideatly before that addres, usually the same side of the word that OS uses, which indiicates the size of bytes that OS had assigned to in a previous new.
[Size of Bock][Data]
The addresss points to the begin of the [Data]
Which command can you use to check the memory of a variable with dgb?
$ x <expr>
of examinate
or$ p /f <expr>
of print
What are the segments of memory that a program uses?
Stack
Heap
Global/Static
Code
What information is allocated into the Code Segment?
All the progrma to execute, in machine language (asm)
What information is allocated into the Static/Global segment
All the static/globla variables.
What information is allocated into the Heap segment?
All the Dynamic memory used by the program.
What is the information allocated into the Stack Segment.
All the stack that the execution produces, in each stack element, is allocated the information of the local variables that the function uses.
what is the output of next code
char* ptr = "12345";
size_t size{0};
while(*ptr != '\0')
{
size++;
ptr++;
}
cout << size;
It prints the size of the string, which is 5;
From where Does the address of Heap Memory grow?
From a low addres and it goes upward direction.
From where Does the address of Stack Memory grow?
From a high addres to downward direction.
What are the characteistics of Stack Memory
a) It never gets fragmented, it’s assignemt is contiguous.
b) It has a limit that raise an stack overflow if it is exceded.
c) It assignment is consecotive.
d) Each thread has it’s own stack memory.
e) Allocating memory in the stack is fast and efficient.
What is the instrucction in c++ to get the addres of a variable/entity?
std::addressof(expr)
What is the effect of allocating and deallocating memory on the Heap (Free Sotre)
The Heap Memory is fregmented.
What is the difference from:
new and new(ptr)
operators?
a) new allocate and initizalice the memory.
b) new(ptr) creates a new object from a previous block of memory allocated, like:
auto* memory = std::malloc(sizeof(User));
auto* user = ::new(memory) User("MyName")
This last one is well know as placement new operator.
> :: ensures is to use the global namespace and an overlaped operator new.
What is the consecuence of creating an instance with ::new?
The destructor isn’t invoked at the end of the life of the context, it’s neccesary to invoke the destructor in as specifyc way:
auto* memory = std::malloc(sizeof(User));
auto* user = ::new(memory) User("MyName")
...
user->~User(); //Destructor is invoked
std::free(memory); //free memory
on C++ What is RVO?
RVO (Return Value Optimization) is a compiler optimization. In some cases, it allows not to create a local object that is used as a return value.
Instead, the returned object is constructed in place of the function call, eliminatin unnecessary move/copy constructor call.
Besides, with C++17, RVO is no longer an optimization, but a rule that compilers must follow. This rule is applied even if a move/copy constructor has side effects.
Which of these functions apply RVO and RVO?
a)
~~~
// A)
std::vector<int> GetVector()
{
return std::vector<int>(1'000'000, 1);
}
// B)
std::vector<int> GetVector()
{
std::vector<int> result(1'000'000, 1);
return result;
}</int></int></int></int>
void foo()
{
auto vect = GetVector();
}
~~~
A as RVO because the object is constructed in place
B as NRVO because the compiler pre-allocates and initializes the object which is supposed to receive the result of a function.
What is NRVO?
Named Return Value Optimization, Instead of creating a local return object and then moving/copying it in place of the function call, this optimization instantly creates it in the right place.
The compiler gets a code like this:
~~~
std::vector<int> GetVector2()
{
std::vector<int> result(1'000'000, 1);
return result;
}</int></int>
auto vect = GetVector();
~~~
to be optimized like this:
~~~
void GetVector2(std::vector<int> *x)
{
new (x) std::vector<int>(1'000'000, 0);
}</int></int>
auto *x = static_cast<std::vector<int> *>(
alloca(sizeof(std::vector<int>)));
GetVector2(x);
....
delete x;
~~~</int></int>
Givining the number 5206981, how is transfered in Big Endien Vs Little Endien, if the byte sequence is 4F-73-C5?
Big Endian means that the Byte less significan is set first and the most significan is sent at last:
4F-73-C5
Mean while, little endia is the opposite, Most significan Byte is transfered at the begin mean while the less significant at the end
C5-73-4F
https://www.freecodecamp.org/news/what-is-endianness-big-endian-vs-littl
How can you check if the OS work with Little Endian or Big Endian?
Using a cast to check if the less significant byte is stored in the same position when a cast is performed:
int main()
{
short int word = 0x0001;
char *b = (char *)&word;
cout << (b[0] ? "LITTLE_ENDIAN" : "BIG_ENDIAN");
return 0;
}
