Nim Memory

https://github.com/zevv/nim-memory
Admin
Educational documentation explaining Nim's memory management model, including reference counting,...
Tokens:3,293
Snippets:48
Trust Score:9
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Sequence Initialization

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

Initializes a sequence of integers with specific values. This is a basic setup for experimenting with sequence memory.

```nim
var a = @[ 30, 40, 50 ]
```

--------------------------------

### Memory Layout Example: 32-bit Integer Storage

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

Visual representation of how a 32-bit integer (0x12345) might be stored in memory starting at address 0x100000, showing byte-by-byte representation. Assumes a specific endianness for display.

```text
0x100000  | 00 | 01 | 23 | 45 | ..
```

--------------------------------

### Getting the Address of a Variable

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

Demonstrates how to get and print the memory address of an integer variable using `addr()` and `repr()` for formatting.

```nim
var a: int
echo a.addr.repr
```

--------------------------------

### Object Memory Layout Output

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

Example output showing the size of object fields and the total object size, along with memory addresses for the object and its fields. Illustrates memory alignment.

```text
size t.a 4
size t.b 1
size t.c 2
size t   8
addr t   ptr 0x300000 --> [a = 0, b = 0, c = 0]
addr t.a ptr 0x300000 --> 0
addr t.b ptr 0x300004 --> 0
addr t.c ptr 0x300006 --> 0
```

--------------------------------

### Little Endian Example: Storing 0x1234

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

Demonstrates how the integer 0x1234 is stored in memory on a little-endian system, where the least significant byte comes first.

```text
00   01
  +----+----+
  | 34 | 12 |
  +----+----+
```

--------------------------------

### Observing Sequence Growth and Reallocation

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

This example iteratively adds elements to a sequence and prints its internal header (`len` and `reserved` fields) after each addition. It highlights how Nim reallocates memory and doubles the reserved space for efficiency.

```nim
type TGenericSeq = object
  len, reserved: int

var a = @[10, 20, 30]

for i in 0..4:
  echo cast[ptr TGenericSeq](a).repr
  a.add i
```

--------------------------------

### Sequence Representation Output

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

Example output showing the memory address of a sequence, its length, and the memory addresses of its individual elements. This output helps understand how sequences are stored in memory.

```text
ptr 0x300000 --> 0x900000@[0x30, 0x40, 0x50]
3
ptr 0x900010 --> 0x30
ptr 0x900018 --> 0x40
```

--------------------------------

### Assembly Example: Storing a 32-bit Integer

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

This assembly instruction demonstrates storing a 32-bit integer value (0x12345) at a specific memory address (0x100000). It illustrates a low-level memory operation.

```assembly
mov [0x100000], 0x12345
```

--------------------------------

### Big Endian (Network) Example: Storing 0x1234

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

Illustrates how the integer 0x1234 is stored in memory on a big-endian system, where the most significant byte comes first. This is also known as network endianness.

```text
00   01
  +----+----+
  | 12 | 34 |
  +----+----+
```

--------------------------------

### Object Memory Layout and Size

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

Demonstrates the memory layout and size of an object with different integer types. Shows how fields are laid out and the effect of alignment on total object size.

```nim
type Thing = object
  a: uint32
  b: uint8
  c: uint16

var t: Thing

echo "size t.a ", t.a.sizeof
echo "size t.b ", t.b.sizeof
echo "size t.c ", t.c.sizeof
echo "size t   ", t.sizeof

echo "addr t.a ", t.a.addr.repr
echo "addr t.b ", t.b.addr.repr
echo "addr t.c ", t.c.addr.repr
echo "addr t   ", t.addr.repr
```

--------------------------------

### Sequence Type and Representation

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

Demonstrates how to declare a sequence and print its type and representation. Shows the memory address of the sequence and its elements.

```nim
var a = @[ 0x30, 0x40, 0x50 ]
echo a.repr
echo a.len
echo a[0].addr.repr
echo a[1].addr.repr
```

--------------------------------

### Heap Allocation with `new()`

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

Allocates memory on the heap for a new object of a specified type. The address of the allocated memory is returned as a `ref` type.

```nim
type Thing = object
  a: int

var t = new Thing
```

--------------------------------

### Enabling ARC Garbage Collector

Source: https://github.com/zevv/nim-memory/blob/master/nim-arc.md

To use the ARC memory management system, compile your Nim project with the `--gc:arc` flag.

```nim
--gc:arc
```

--------------------------------

### Dereferencing a Pointer in Nim

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

Demonstrates how to create a pointer to an integer and modify its value by dereferencing the pointer using the `[]` operator. This shows that `a` and `p[]` refer to the same memory location.

```nim
var a = 20
var p = a.addr
p[] = 30
echo a  # --> 30
```

--------------------------------

### Inspecting a Sequence's Header

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

This code demonstrates how to cast a Nim sequence to a pointer of `TGenericSeq` to view its internal `len` and `reserved` fields. This is an unsafe operation.

```nim
var a = @[10, 20, 30]
var b = cast[ptr TGenericSeq](a)
echo b.repr
```

--------------------------------

### Memory Representation of Primitive Types

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

Examines how Nim stores primitive types like integers in memory. It shows the value and size of an integer variable and its corresponding pointer.

```nim
var a = 9
echo a.repr
echo sizeof(a)

var b = a.addr
echo b.repr
echo sizeof(b)
```

--------------------------------

### Stack-Allocated Variables in Nim

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

Illustrates the declaration of various local variables that are stored on the stack. These variables exist within the scope of the function where they are declared.

```nim
type Thing = object
  a, b: int

var a: int
var b = 14
var c: Thing
var d = Thing(a: 5, b: 18)
```

--------------------------------

### Destructor Signature in Nim

Source: https://github.com/zevv/nim-memory/blob/master/nim-arc.md

Custom destructors in Nim are implemented using a proc named `=destroy`. This proc is automatically called by the compiler when the reference count of a managed object drops to zero. The default destructors handle memory deallocation, but custom ones can manage other resources.

```nim
proc `=destroy`(x: var T)

```

--------------------------------

### Defining TGenericSeq for Inspection

Source: https://github.com/zevv/nim-memory/blob/master/nim-memory.md

This snippet defines a local `TGenericSeq` type to inspect the internal structure of Nim sequences. It's used in conjunction with casting a sequence to a pointer of this type.

```nim
type TGenericSeq = object
  len, reserved: int
```
Tokens:
Raw