> ## 9. Memory Management

> Processor instructions can specify 16-bit addresses, giving a logical address space of 64K (65,536 bytes). Dynamic C supports a 1M physical address space (20-bit addresses).

> An on-chip memory management unit (MMU) translates 16-bit addresses to 20-bit memory addresses. Four MMU registers (SEGSIZE, STACKSEG, DATASEG and XPC ) divide and maintain the logical sections and map each section onto physical memory.

> ### 9.1 Memory Map

> A typical Dynamic C memory mapping of logical and physical address space is shown in the figure below.

> Figure 3. Dynamic C Memory Mapping

> This figure illustrates how the logical address space is divided and where code resides in physical memory. Both the Static RAM and the Flash Memory are 128K in the diagram. Physical memory starts at address 0x00000 and Flash Memory is usually mapped to the same address. SRAM typically begins at address 0x80000.

> If BIOS code runs from Flash Memory, the BIOS code starts in the root code section at address 0x00000 and fills upward. The rest of the root code will continue to fill upward immediately following the BIOS code. If the BIOS code runs from SRAM, the root code section along with root data and stack sections will be place at a starting address 0x80000.

> #### 9.1.1 Memory Mapping Control

> The advanced user of Dynamic C can control how Dynamic C allocates and maps memory. For details on memory mapping, refer to the Rabbit 2000 Microprocessor User's Manual or the Rabbit 3000 Microprocessor User's Manual.

> ### 9.2 Extended Memory Functions

> A program can use many pages of extended memory. Under normal execution, code in extended memory maps to the logical address region E000H to FFFFH.

> Extended memory addresses are 20-bit physical addresses (the lower 20 bits of a long integer). Pointers, on the other hand, are 16-bit machine addresses. They are not interchangeable. However, there are library functions to convert address formats.

> To access xmem data, use function calls to exchange data between xmem and root memory. Use the Dynamic C functions `root2xmem()`, `xmem2root()` and `xmem2xmem()`to move blocks of data between logical memory and physical memory.

> #### 9.2.1 Code Placement in Memory

> Code runs just as quickly in extended memory as it does in root memory, but calls to and returns from the functions in extended memory take a few extra machine cycles. Code placement in memory can be changed by the keywords `xmem` and `root`, depending on the type of code:

> #### Pure Assembly Routines

> Pure assembly functions may be placed in root memory or extended memory. Prior to Dynamic C v 7.10 pure assembly routines had to be in root memory.

> #### C Functions

> C functions may be placed in root memory or extended memory. Access to variables in C statements is not affected by the placement of the function. Dynamic C will automatically place C functions in extended memory as root memory fills. Short, frequently used functions may be declared with the `root` keyword to force Dynamic C to load them in root memory.

> #### Inline Assembly in C Functions

> Inline assembly code may be written in any C function, regardless of whether it is compiled to extended memory or root memory.

> All static variables, even those local to extended memory functions, are placed in root memory. Keep this in mind if the functions have many variables or large arrays. Root memory can fill up quickly.

Z-World http://www.zworld.com Voice: (530) 757-3737 FAX: (530) 757-3792 sales@zworld.com