Lecture 3:
Storage Diagrams and Object Diagrams; Using a debugger

You can't be a good programmer if you don't understand how data structures are laid out in storage. Here's a short quiz: What is allocated in storage by these declarations?

• int x = 3 (a fullword named x is allocated to hold integer 3.)

• int[] r = new int[5] (a sequence of five fullwords is allocated for the array, and the addresss --- handle --- of the array is stored in a fullword named r)

• This example is from C:

  struct BankAccount {  // template for allocating a "frame" (namespace) of vars
     int acct_number;
     char[50] *name;
     float balance;
  };
  BankAccount s;   // allocates a frame and names it  s
  s.acct_number = 999;
  

  A sequence of fullwords, large enough to hold an int, fifty chars, and a float, is allocated and the handle of the sequence is saved in a fullword named s. The sequence of fullwords is indexed by acct_number, name, and balance. Call this a frame.

• This example is from C#:

  class BankAccount {  // template for allocating a frame/namespace of vars
                       // and for associating methods to compute on the frame
    public readonly int acct_number;
    public readonly string name;
    private float balance;
  
    public BankAccount(int num, string n) { acct_number = num;  name = n; }
    public void deposit(float m) { if (m>0){ balance = balance + m; } }
    public float getBalance() { return balance; }
  }
  
  class Program {
    static BankAccount master_acct = new BankAccount(000, "Bank");
  
    public static void Main() {
      BankAccount customer = new BankAccount(999, "Edward");  // allocates and names object
      ...
  }
  

  Two sequences are allocated. Each sequence is large enough to hold an int, a (handle to a) string, and a float. The handles to the sequences are saved in fullwords named master_acct and customer.

A struct in C is a template for allocating a frame. A class in C++/Java/C# is a template for allocating a frame and defining functions (methods) that access the frame.

An object is the frame that is allocated when you construct a new instance of a class template. A static variable or method is a single instance that is "pre-declared" (and not constructed while the program executes).

3.1 Storage layout

+-----------------------+------------------+------------------------+
| operating system code | web browser code | ... ( free space ) ... |
+-----------------------+------------------+------------------------+

+-- ... --+------------+-------------+----------------------------+------------------------------------------+
| OS etc. | C# program | static area | stack --> (empty) <-- heap | ...(remaining free space)... |
+-- ... --+------------+-------------+----------------------------+------------------------------------------+

When a new object is allocated, its frame is allocated in the heap part.

When a method is called, its parameter-argument bindings and its local variables are saved in a new frame that is allocated "on top of" the stack. (When the method finishes, the frame is "popped" from the stack.)

So, a frame and an object are the same thing in computer storage, but they are allocated at different places. (The reason they look the same is due to a lot of pre-computation, embedded in the .exe file, done by the C# compiler.)

3.1.1 Storage diagram: Example with static vars, an array, and a dictionary

===================================================

using System;
public class Prog {
     public static int size = 4;
     
     public static void Main() {
       int[] r = new int[size];
       r[0] = size;
       int j = size - 1;
       r[j] = f(j);
     }

     public static int f(int x) {
       // the dictionary is a kind of array, indexed by strings, that can grow:
       Dictionary<string, int> d = new Dictionary<string, int>();
       d["a"] = x; d["c"] = d["a"] + x;
       //***
       return size + x;
     }
}

===================================================

Data structures likes arrays and dictionaries are allocated in the heap. (Note: I drew the dictionary as a kind-of array, but most languages implement a dictionary as a hash table.) Frames for method/procedure/function calls are saved on the stack. When a method completes, its frame is "popped" (erased). A frame in the heap is never popped (but if the frame is no longer used by the program, a garbage collector program, running in background, erases the frame).

Now, run VS on the example and break at point //*** to see how VS presents the storage layout in its Debug windows; compare it to the storage diagram --- you will see VS is not so good at displaying static variables. Also, it displays the dictionary as a complicated array (it's really a hash table!). Also, VS does not show that the array and the dictionary are saved in the heap.

3.1.2 Storage diagram: Example with user-defined class

===================================================

using System;
public class Ex2 {
   public static void Main() {
     Clock c = new Clock(80);
     Clock d = new Clock(90);
     c.tick(2);
     Clock e = d;
     d.tick(3);
     Console.WriteLine(e.getTime());  Console.ReadLine();
   }
}

class Clock {
    static int count = 0;
    private int t = 0;
    public Clock(int start) { t = start; count = count + 1;
    }
    public void tick(int n) {
        ///***
        t = t + n;
    }
    public int getTime() { return t; }
}

===================================================

The methods for the two Clocks are saved in the Code area, and not in the objects (frames). Doing the latter would be correct but a waste of storage. This little optimization causes a serious complication --- see below.

Now, run VS on the example and break at point //*** to see how VS presents the storage layout. Match it to the above diagram.

Visual Studio is not good at showing the handles (addresses) of objects, and VS does not show the difference between the stack and the heap, and it does not show that c and e hold the same handle to (that is, they alias) the same object, which is really bad! Be careful!

Now, consider the code in tick:

public void tick(int n) {
   t = t + n ;
}

d.tick(3);

public void tick(Clock this, int n) {
  this.t = this.t + n;
}

This setup lets the code for tick, saved in the Code Area, work correctly with all of object c and d (and e).

3.1.3 Object diagrams

The object diagrams for the two previous examples are really simple! Here is the second example's object diagram:

Real programs have interesting object diagrams. Here is an example: This code allocates and uses a table that is a ragged array:

===================================================

public static void Main() {
  int size = Int32.Parse(Console.ReadLine("Type size:"));
  int[][] table = new int[size][];
  for(int i = 0; i != table.Length; i++) {
     table[i] = new int[i+1]; 
  }
  ... compute on table ...
}   

===================================================

The diagram displays the pattern of data structure maintained by the program.

An object diagram is used by a programmer to explain to others what the program "builds" in storage. It is a standard form of documentation that accompanies a system. You will use object diagrams a lot when you design, implement, test, and explain complex systems.

3.2 Object diagrams for design

When an object diagram is used for design, only the heap is drawn and details about fields within the objects are optional. Class names are usually attached to the objects.

Here is an example: We plan to build a database of bank accounts and customers, where a customer might own multiple bank accounts. Access to the accounts is made through two "manager" objects, which enforce the rules for "checking out", using, and "checking in" the accounts. The data base also has a global clock and an "administrator" object. Here is a design object diagram that shows how the heap might look once the system is executing:

The example shows how there is exactly one clock in the system; there are two databases, one holding customers and one holding accounts. A customer can own handles/pointers to zero or more accounts. Each account must be owned/pointed-to by exactly one customer.

An object diagram like this can be shown to the other engineers on the project and even the bank manager, so that everyone understands what must be built.

Another example: we are designing a card game that uses Cards, a Deck to hold the cards, and a Hand-of-Cards for each Player. Here is a design expressed as an object diagram:

When you code this system, you compare the storage layouts generated by the execution to the object diagram.

There is more to say about this next time.

Exercise