Lecture #20

Administrivia

• Recap, Final Exam Review

Recap

• operating systems: kernel vs userland

• processes: essentially a running program

  • kernel view; data structure
  • system calls: user request for kernel services
  • process creation & termination
  • inter-process communication
    • pipes

• threads: concurrent paths of execution within single process

  • deadlocks & race conditions
  • mutual exclusion & signaling
  • message passing (abstraction)

• filesystems

  • data structure on top of block devices
  • disk allocation algorithm
    • contiguous
    • linked list
    • file allocation table (FAT)
    • indexed

• networking

  • layered protocols: OSI 7-layer model
  • Ethernet/Internet: basically 4 layers
    1. Ethernet: data link layer
    2. Internet Protocol
    3. TCP & UDP
    4. application
  • distributed systems
    • client-server
    • datacenter-wide operating system
      • manage resources of entire datacenter
  • remote procedure call: abstraction
    • not entirely dissimilar to message passing

Final Exam

• 4 questions @ 8 points each
  • file allocation table
  • indexed filesystem
  • networking
  • virtual memory

Direct vs. Indirect Indexing

TODO: diagram

Indirect Indexing

• indirect index: trie-like data structure (aka radix tree)

  • squat, with high fanout

• suppose index block holds 256 (2⁸) (radix block pointers)

  • each level is digit in base 256

TODO: diagram

• level 1 offset: block_num / 256<sup>2</sup> (or block_num >> 16)
• level 2 offset: block_num / 256 mod 256 (orblock_num >> 8 & 0xff )

• level 3 offset: blocknum mod 256 (or block_num & 0xff)

• three levels of lookup:

  level2block = getblock(level1[offset1]) level3block = getblock(level2[offset2]) data = get-block(level3[offset3])

Combining Direct & Indirect Indexing

• example: suppose:

  • an index block holds M block addresses (e.g. 64, 128, 256)
    • bM bits (6, 7, 8)
    • mM mask (0x3f, 0x7f, 0xff) mM = (1 << bM) - 1
  • an inode holds
    • d direct pointers (e.g. 3, 5, 10)
    • i index pointers (e.g. 2, 3, 4)
    • i2 double indirect pointers (e.g. 2, 3, 4)
    • i3 triple indirect pointers (e.g. 1, 2, 3)

• to find block address for given block number:

  if blockknum < d return direct_pointer[blocknum]

  blocknum -= d if blocknum < i * M indexblock = indirectpointer[blocknum / M] (or: indexblock = indirectpointer[blocknum >> bM]) return indexblock[blockNum % M] (or: return indexblock[blockNum & mM])

  blocknum -= i * M if blocknum < i2 * M * M indexblock1 = doubleindirectpointer[blocknum / (M*M)] (or: indexblock1 = doubleindirectpointer[blocknum >> (2 * M)]) indexblock2 = indexblock1[(blocknum >> M) & mM] return index_block2[blocknum & mM]

  blocknum -- i2 * M * M indexblock1 = tripleindirectpointer[blocknum / (M * M * M)] indexblock2 = indexblock1[blocknum / (M * M) % M] indexblock3 = indexblock2[blocknum / M % M] return indexblock3[blocknum % M]

Bitwise operations

• Boolean identities:

  • x & 0 = 0 (clear)
  • x & 1 = x (keep)
  • x | 0 = x (keep)
  • x | 1 = 1 (set)
  • x ~ 0 = x` (keep)
  • x ~ 1 = ~x` (toggle)

• Bitwise operations treat a word as a vector of individual bits. A bit field is (contiguous) a group of 1 or more bits in a word. The bit field may be extracted by shifting to the right and clearing the bits outside the field (or clearing first, then shifting).

• strength reduction is the replacement of expensive operations by less-expensive ones

• depending on the architecture, multiplication, division and remainder are relatively expensive operations

  • multiplication and division by powers of 2 can replaced by a single-cycle shift instruction
    • x * 2<sup>n</sup> can be replaced by x << n
    • x / 2<sup>n</sup> can be replaced by x >> n
  • remainder by a power of 2 can be replaced by a mask operation
    • x mod 2<sup>n</sup> can be replaced by x & (n - 1)

File Allocation Table

• blocks contain data only

• index node (inode) contains the address at block 0 (1st block)

• global FAT is an array of block addresses

  • block addresses are integers
  • array indexes are integers

• there is a 1:1 correspondence between blok addresses & FAT array indexes

  • array value is block address of next block in file
  • array value is array index of next entry in list

TODO: diagram