Welcome to the iOS Basics series (suggested in order)
IOS low-level – Alloc and init explore
IOS Bottom – Isa for everything
IOS low-level – Analysis of the nature of classes
IOS Underlying – cache_t Process analysis
IOS basics – Analysis of the nature of methods and search processes
Alloc and init are known to be the simplest API that we’re most familiar with, but do you know it completely, or is it a stranger that you’re most familiar with? So let’s start with the source code and see what alloc and init do.
To see what a piece of code does, the most direct way to do it is to look at the underlying source code, but you can just click on alloc and see that when you get here, you can’t see the underlying code, there are four ways to do it, okay
1. Set breakpoint: control + in to objc_alloc
Libobjc.a. dylib ‘+[NSObject alloc]:
Debug ->Always Show Disassemby to libobjc.a.dylib ‘objc_alloc:
4. Run directly in the source code, the most convenient but need to be configured, opensource.apple.com/tarballs/ob… Open source objC source, alloc source is in it
1. Start debugging
Register read x0 to read x0 because x0 holds the return object for the x0-x7 function argument
After alloc is executed, x0 stores a pointer to the object, indicating that alloc does have the ability to create memory space, but how much memory space is allocated, step by step click on the instanceSize method
2. Align memory resources
Let’s start with a simple problem, as shown here
The above code prints: 24,16.
Why does the system allocate different sizes of memory to the same structure? This is the result of allocating memory according to the “memory alignment” rule.
In simple terms, when allocating the StructOne A, it cannot be allocated to the same address with the following 8 bytes of B, so 8 bytes need to be allocated to A for storage. The length of C and D can be stored in the same address at the same time, so the size of StructOne is 8 + 8 + 8 = 24. The length of a, D, and C can be stored at the same address, so the size of StructTwo is 8 + 8 = 16. Of course, the rules of memory alignment are more than that. The rules are as follows:
1: Alignment rules for data members: Struct (or union) data members, the first data member is placed at offset 0, and the starting position of each data member is from the size of the member or the size of the member’s children (as long as the member has child members, such as arrays, Structure, etc.) (for example, if int is 4 bytes, it is stored from the address that is a multiple of 4.
2: Struct as members: If a structure has some struct members, then the struct members are stored from an integer multiple of the size of the largest element in the structure.
The total sizeof the structure, the result of sizeof, must be an integer multiple of its largest internal member. What is lacking must be made up.
Ok, so with memory alignment, let’s see what the system does.
InstanceSize = (x + 7) &~ 7 (x + 7) = (x + 7) &~ 7 (x + 8) = (x + 7)
X plus 7 times 7 times 7, which is 15 times 7.
1111/0000/15
1111 / / 1000 ~ 7
After the & operation, it is a multiple of 8. The memory size requested by the object is a multiple of 8, and the minimum size is 16, because
if(size <16) size =16;Copy the code8 byte alignment, CPU read data constantly changing the length of reading is affecting the speed, so in order to speed up the CPU read, you can set a fixed value, with space for time, because the 8 byte data type is more, so 8 bytes to its calculation
When the register_notification mapping file is loaded, dyLD loads the structure of the class. The structure of the class contains the whole data segment, and there is ro in the data. Ro has ivar_list, PROTOCOL_list, etc., get class information, do byte alignment, 8 byte alignment
Let’s say that this object has five 8-byte attributes, so the sISE that’s passed in here is 40, the algorithm above
k = (size + NANO_REGIME_QUANTA_SIZE - 1) >> SHIFT_NANO_QUANTUM;
slot_bytes = k << SHIFT_NANO_QUANTUM;Copy the codeThat is, slot_bytes = (40 + 16-1) >> 4 <<4. In this case, the algorithm of moving 4 bits to the right and 4 bits to the left is used for 16-byte alignment. Therefore, when the memory size requested by the object is 40, the memory size allocated by the system is aligned with 16 bytes and the required complement is 48.
Summary: The size of memory requested by an object is not necessarily the same as the size allocated by the system
8-byte alignment – Attributes within the object 16-byte alignment – the object itself
The reason for this design is that if you give the object just the right size, you may overflow at some point and need to leave some threshold
3. Initialize isa
After memory allocation, it goes to
obj->initInstanceIsa(cls, dtor);Copy the codeWhat it does is bind objects and classes through an ISA, which contains a lot of class information, and it assigns an owner to this space.
4. The init the bottom
Alloc basically does that, but init, let’s look at the bottom of init.
The underlying source code for init is as simple as that; it simply returns the object and does nothing. In theory, init is useless code that should not be written, but it is usually done for the sake of development custom and specification, and init is a factory design that subclasses can override from the definition.
Conclusion:
Alloc: Alloc allocates space in memory by means of memory alignment and initializes isa. It is equivalent to building a house of a fixed size and identifying the owner of the house.
Init: Init returns the object itself without any additional operations. Because it does nothing, it is more developer-friendly and can be overridden at will, providing developers with an initial interface. Equivalent to letting developers enjoy the inside of the house to do fine decoration.