The Simplest Variables in Any Language

• Static Variables

  • the compiler allocates them; i.e., their memory address is a constant

• Scalars and Arrays

  • a scalar is a variable that stores a single value

  • an array stores multiple values named by a single variable and an index

    • the array data can be allocated either statically or dynamically
    • the array variable can BE the array (static) or can store a pointer to it (dynamic)
    • the index is generally a dynamic value

• Now for some other types of variables...

Instance Variables

• Variables that are an instance of a class or struct

  • created dynamically
  • many instances of the same variable can co-exist

• Java vs C

  • Java: objects are instances of non-static variables of a class
  • C: structs are named variable groups, instance is also called a construct

• Accessing an instance variable

  • requires a reference to a particular object (pointer to a struct)
  • then variable name chooses a variable in that object (struct)

Structs in C

• A struct is a

  • collection of variables of arbitrary type, allocated and accessed together

• Declarations

  • similar to declaring a Java class without methods
  • name is "struct" plus name provided by programmer
  • static struct D d0;
  • dynamic struct D* d1;

• Access

  • static d0.e = d0.f;
  • dynamic d1->e = d1->f

Struct Allocation

 
xxxxxxxxxx
4
1
struct D {
2
    int e;
3
    int f;
4
}

• Static structs are allocated by the compiler

  

• Dynamic structs are allocated at runtime

  • the variable that stores the struct pointer may be static or dynamic
  • the struct itself is allocated when the program calls malloc

  

• runtime allocation of dynamic struct

   
  xxxxxxxxxx
  3
  1
  void foo() {
  2
      d1 = malloc (sizeof(struct D));
  3
  }
  

• assume that this code allocates the struct at address 0x2000

  

Struct Access

• Static and dynamic differ by an extra memory access

  • dynamic structs have dynamic address that must be read from memory

  • in both cases the offset to variable from base of struct is static

    

• The revised load/store base plus offset instructions

  • dynamic base address in a register plus a static offset (displacement)

    ld 4(r1), r2

The Revised Load-Stored ISA

• Machine format for base+offset

  • note that the offset will be in our case always be a multiple f 4
  • also note that we only have a single instruction byte to store it
  • and so, we will store offset / 4 in the instruction

• The revised ISA

  

Memory Addressing Modes

• Scalars

  • address in register (r1)
  • access memory at address in register
  • ld (r1), r0

• Arrays

  • base address in register (r1)
  • dynamic index in register (r2)
  • access memory at base plus index time element-size (4)
  • ld (r1,r2,4), r0

• Struct Members (Instance Variables)

  • base address in register (r1)
  • static/constant offset (X)
  • access memory at base plus offset
  • ld X(r1), r0

Structs Declared Inside of Other Structs

• The struct variable is

  • the variable that stores the struct for static structs or
  • the variable that stores a pointer to the struct or dynamic structs

• Struct variables can be declared inside other structs

  

  • X: 12 bytes
  • Y: 8 bytes

• 

  • x: 40 bytes
  • y: 8 bytes

Dynamic Allocation in C and Java

• Programs can allocate memory dynamically

  • allocation reserves a range of memory for a purpose

• In Java, instances of classes are allocated by the new statement

• In C, byte ranges are allocated by call to malloc procedure

  • these bytes can be used for any type that can fit in them

Dynamic Allocation in C

• Memory allocation

  void* malloc(int n);

  • n is the number of of bytes to allocate

  • returning type is void*

    • pointer to anything (no specific type assigned)
    • can be cast to/from any other pointer type
    • cannot be dereferenced directly

• Use sizeof to determine number of bytes to allocated struct Foo* f = malloc(sizeof(struct Foo));

  • statically computes number of bytes in type or variable

Memory Deallocation

• Wise management of memory requires deallocation

  • Memory is a scarce resource
  • Deallocation frees previously allocated memory for re-use

• In Java:

  • Garbage collection: memory is deallocated when no longer in use
  • Requires keep track of every reference to an object

• In C:

  • Dynamic memory must be deallocated explicitly by calling free
  • Memory is deallocated immediately, no checks if it's still in use

Memory Heap

• The heap is a large section of memory from which malloc allocates objects

  • malloc finds unused space in the heap, marks as used and returns it
  • free marks space as unused
  • heaps may be increased if necessary

• all objects are stored in the heap

Problems with Explicit Deallocation

• What free(x) does

  • deallocates "object" at address x
  • this memory can be reused by subsequent call to malloc

• What free(X) does not do

  • after call to free, x still points to freed object
  • other variables may still point there too.