Hardware

• Although the user can now refer to objects in the program by a two-dimensional address, the actual physical memory is still, of course, a one-dimensional sequence of bytes.
• Thus, we must define an implementation to map two-dimensional user-defined addresses into one-dimensional physical addresses.
• This mapping is effected by a segment table. Each entry in the segment table has a segment base and a segment limit.
• The segment base contains the starting physical address where the segment resides in memory, whereas the segment limit specifies the length of the segment (see Fig. 12).

  Figure 12: Segmentation hardware.

  
  • A logical address consists of two parts: a segment number, $s$, and an offset into that segment, $d$.
  • The segment number is used as an index to the segment table. The offset $d$ of the logical address must be between 0 and the segment limit. If it is not, we trap to the OS (logical addressing attempt beyond end of segment).
  • When an offset is legal, it is added to the segment base to produce the address in physical memory of the desired byte. The segment table is thus essentially an array of base-limit register pairs.
• As an example, consider the situation shown in Fig. 13.

  Figure 13: Example of segmentation.

  
  • We have five segments numbered from 0 through 4. The segments are stored in physical memory as shown.
  • The segment table has a separate entry for each segment, giving the beginning address of the segment in physical memory (or base) and the length of that segment (or limit).
  • For example, segment 2 is 400 bytes long and begins at location 4300.
  • Thus, a reference to byte 53 of segment 2 is mapped onto location 4300 + 53 = 4353.
  • A reference to segment 3, byte 852, is mapped to 3200 (the base of segment 3) + 852 = 4052.
  • A reference to byte 1222 of segment would result in a trap to the OS, as this segment is only 1,000 bytes long.