COMP-1200 Basic Memory Operations

Course Overview

Course Title: COMP-1200 Basic Memory Operations

Presented by: Prof. Gyllinsky
Additional Contributors: Prof. Park, Prof. Firouzbakht, Prof. Anwaruddinta, McGraw-Hill.

Learning Objectives

  • Describe the address space in memory, including various memory segments and their roles in program execution.

  • Effectively utilize load/store instructions for manipulating data within registers and memory.

  • Implement assembly directives for variable management within different segments of memory.

Memory Address Space

The memory address space is a crucial aspect of computer architecture, divided into several segments:

  1. Stack:

    • Stores local variables and function call information; memory allocated for function calls is released after calls.

    • Maintains a Last In, First Out (LIFO) structure, where most recent items are processed first.

  2. Heap:

    • Used for dynamic memory allocation, allowing programs to request memory at runtime.

    • Example in Java: Objects are created using the new keyword, which allocates memory on the heap.

  3. Data Segment:

    • Contains global variables and static variables which retain their values throughout the program's execution.

    • Variables in this segment are initialized before execution begins and can be accessed from any function.

  4. Text Segment:

    • Houses the executable instructions of the program, written in the programming language.

    • Uses the .text assembler directive to denote the start of this segment, which is essential for program execution.

  5. OS Kernel:

    • Consists of the underlying operating system code, providing essential services to programs, such as memory management and hardware interaction.

    • Contains critical system-level instructions and handles low-level operations that user programs cannot perform directly.

Memory Segments Explained

  1. Text Segment:

    • Contains program instructions, typically labeled with the .text assembler directive.

    • Example instructions include arithmetic operations, loading data into registers, storing data back to memory, calling functions, and returning from functions.

  2. Stack Segment:

    • Each function maintains its own set of local variables, allowing for organized memory management within function scopes.

    • Example function for comparing two integers:

     int max(int n1, int n2) {
     int val = n1;
     if (n2 > n1) { val = n2; }
     return val;
 }

  3. Data Segment:

    • Utilizes the .data assembler directive for variable declaration, clearly distinguishing it from code segments.

    • Contains global or static variables; these variables are beneficial for data that needs to persist across function calls and access throughout the program.

  4. Heap:

    • Critical for dynamic memory allocation in programming. Variables allocated here are managed manually through pointers.

    • Example in Java:
      java int[] array1 = new int[100];

Address Manipulation Instructions

  1. Load Address Instruction (LA):

    • Syntax: la ra, LABEL

    • Loads the memory address associated with LABEL into the register ra. This allows for indirect addressing when accessing memory contents.

  2. Load/Store Instructions:

    • lw rd, (ra): Loads a word from the address in register ra into register rd.

    • sw rs, (ra): Stores a word from register rs into the address pointed to by ra.

Practical Example of Load/Store

Given a variable val1 initialized as follows:

.data  
val1:  .word 11  # Equivalent to int val1 = 11 in higher-level languages

Use of Load/Store instructions:

main:
    la t0, val1  # Load address of val1 into t0
    lw t1, (t0)  # Load integer from memory address in t0 into t1
    li t2, 27    # Load integer 27 into t2
    sw t2, (t0)  # Store value of t2 into memory address of val1

Loop Structures

Utilizing a loop to process array values is essential in programming:
Example Java-like pseudo-code for initializing an array:

p = ARRAY;  // Pointer to the start of an array
v = 0xFF;  // Value to copy into each element of the array
for(c = 5; c > 0; c--) {
    M[p] = v;  // Store value v at memory location pointed to by p
    p += 4;    // Move the pointer to the next element (assuming 4-byte integers)
}

Control Instructions

Example control flow for decision making:

if(x < 0) {
    x = 10;
} else {
    x = -9;
}

Example in assembly language:

    bge t0, zero, lbl2  # Branch if greater than or equal to zero
    li t0, AAA           # Load immediate value if condition is false
    j lbl3               # Jump to next label
lbl2:
    li t0, BBB          # Load immediate value if condition is true
lbl3:

Alignment and Sizes

Understanding the importance of instruction size alignment:

  • For lw/sw: Word (4-byte) operations require addresses aligned to multiples of 4 for optimal access speed.

  • For lh/sh: Half-word (2-byte) operations require addresses to be even.

  • For lb/sb: Byte operations have no restrictions on address alignment, but misalignment can lead to performance penalties.

Pointers

A pointer holds the address of another variable, essential for managing dynamic data structures like arrays and linked lists:

  • Pointers enable manipulation of memory directly by adding/subtracting offsets (4 bytes for word-sized data, 1 byte for byte-sized data).

  • They lead to more efficient algorithms when dealing with large datasets by allowing direct access to data locations.

Conclusion

Understanding these memory management concepts is crucial for effective programming and system design, especially regarding performance, optimization, and resource management in the COMP-1200 coursework. Knowledge of memory segments, instructions, and allocation methods directly influences overall program efficiency and functionality.