String Sorts (Algorithm Review) PDF

STRING SORTS ‣ Key-indexed counting ‣ LSD radix sort ‣ MSD radix sort ‣ 3-way radix quicksort ‣ Suf x arrays fi Review: summary of the performance of sorting algorithms Frequency of operations = key compares. algorithm guarantee random extra space stabl...

STRING SORTS ‣ Key-indexed counting ‣ LSD radix sort ‣ MSD radix sort ‣ 3-way radix quicksort ‣ Suf x arrays fi Review: summary of the performance of sorting algorithms Frequency of operations = key compares. algorithm guarantee random extra space stable? operations on keys insertion sort N2 / 2 N2 / 4 1 yes compareTo() mergesort N lg N N lg N N yes compareTo() quicksort 1.39 N lg N * 1.39 N lg N c lg N no compareTo() heapsort 2 N lg N 2 N lg N 1 no compareTo() * probabilistic Lower bound. ~ N lg N compares required by any compare-based algorithm. Q. Can we do better (despite the lower bound)? A. Yes, if we don't depend on key compares. 3 Key-indexed counting: assumptions about keys Assumption. Keys are integers between 0 and R - 1. Implication. Can use key as an array index. input sorted result name section (by section) Anderson 2 Harris 1 Applications. Brown 3 Martin 1 Davis 3 Moore 1 Sort string by rst letter. Garcia 4 Anderson 2 Sort class roster by section. Harris Jackson 1 3 Martinez Miller 2 2 Sort phone numbers by area code. Johnson Jones 4 3 Robinson White 2 2 Subroutine in a sorting algorithm. [stay tuned] Martin Martinez 2 1 Brown Davis 3 3 Miller 2 Jackson 3 Moore 1 Jones 3 Remark. Keys may have associated data ⇒ Robinson 2 Taylor 3 Smith 4 Williams 3 can't just count up number of keys of each value. Taylor 3 Garcia 4 Thomas 4 Johnson 4 Thompson 4 Smith 4 White 2 Thomas 4 Williams 3 Thompson 4 Wilson 4 Wilson 4 keys are small integers Typical candidate for key-indexed counting 4 fi Key-indexed counting demo (Count Sort) R=6 Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] use a for 0 0 d int N = a.length; b for 1 1 a c for 2 int[] count = new int[R+1]; 2 c d for 3 for (int i = 0; i < N; i++) 3 f e for 4 count[a[i]+1]++; 4 f f for 5 5 b for (int r = 0; r < R; r++) 6 d count[r+1] += count[r]; b 7 8 f for (int i = 0; i < N; i++) 9 b aux[count[a[i]]++] = a[i]; 10 e for (int i = 0; i < N; i++) 11 a a[i] = aux[i]; 5 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. offset by 1 i a[i] [stay tuned] 0 d int N = a.length; 1 a int[] count = new int[R+1]; 2 c r count[r] count for (int i = 0; i < N; i++) 3 f a 0 frequencies count[a[i]+1]++; 4 f b 2 5 b c 3 for (int r = 0; r < R; r++) 6 d d 1 count[r+1] += count[r]; b 7 e 2 8 f f 1 for (int i = 0; i < N; i++) 9 b - 3 aux[count[a[i]]++] = a[i]; 10 e for (int i = 0; i < N; i++) 11 a a[i] = aux[i]; 6 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] 0 d int N = a.length; 1 a int[] count = new int[R+1]; 2 c r count[r] for (int i = 0; i < N; i++) 3 f a 0 count[a[i]+1]++; 4 f b 2 5 b c 5 compute for (int r = 0; r < R; r++) 6 d d 6 cumulates count[r+1] += count[r]; b 7 e 8 or pre x-sum 8 f f 9 for (int i = 0; i < N; i++) 9 b - 12 aux[count[a[i]]++] = a[i]; 10 e for (int i = 0; i < N; i++) 11 a a[i] = aux[i]; 6 keys < d, 8 keys < e so d’s go in a and a 7 fi Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 d 0 int N = a.length; 1 a 1 int[] count = new int[R+1]; 2 c r count[r] 2 for (int i = 0; i < N; i++) 3 f a 0 3 count[a[i]+1]++; 4 f b 2 4 5 b c 5 5 for (int r = 0; r < R; r++) 6 d 6 d 6 count[r+1] += count[r]; b 7 7 e 8 8 f f 9 8 for (int i = 0; i < N; i++) move 9 b 9 aux[count[a[i]]++] = a[i]; - 12 items 10 e 10 for (int i = 0; i < N; i++) 11 a 11 a[i] = aux[i]; 8 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 d 0 int N = a.length; 1 a 1 int[] count = new int[R+1]; 2 c r count[r] 2 for (int i = 0; i < N; i++) 3 f a 0 3 count[a[i]+1]++; 4 f b 2 4 5 b c 5 5 for (int r = 0; r < R; r++) 6 d 6 d d 7 count[r+1] += count[r]; b 7 7 e 8 8 f f 9 8 for (int i = 0; i < N; i++) move 9 b 9 aux[count[a[i]]++] = a[i]; - 12 items 10 e 10 for (int i = 0; i < N; i++) 11 a 11 a[i] = aux[i]; 9 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 d 0 a int N = a.length; 1 a 1 int[] count = new int[R+1]; 2 c r count[r] 2 for (int i = 0; i < N; i++) 3 f a 1 3 count[a[i]+1]++; 4 f b 2 4 5 b c 5 5 for (int r = 0; r < R; r++) 6 d 6 d d 7 count[r+1] += count[r]; b 7 7 e 8 8 f f 9 8 for (int i = 0; i < N; i++) move 9 b 9 aux[count[a[i]]++] = a[i]; - 12 items 10 e 10 for (int i = 0; i < N; i++) 11 a 11 a[i] = aux[i]; 10 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 d 0 a int N = a.length; 1 a 1 int[] count = new int[R+1]; 2 c r count[r] 2 for (int i = 0; i < N; i++) 3 f a 1 3 count[a[i]+1]++; 4 f b 2 4 5 b c 6 5 c for (int r = 0; r < R; r++) 6 d 6 d d 7 count[r+1] += count[r]; b 7 7 e 8 8 f f 9 8 for (int i = 0; i < N; i++) move 9 b 9 aux[count[a[i]]++] = a[i]; - 12 items 10 e 10 for (int i = 0; i < N; i++) 11 a 11 a[i] = aux[i]; 11 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 d 0 a int N = a.length; 1 a 1 int[] count = new int[R+1]; 2 c r count[r] 2 for (int i = 0; i < N; i++) 3 f a 1 3 count[a[i]+1]++; 4 f b 2 4 5 b c 6 5 c for (int r = 0; r < R; r++) 6 d 6 d d 7 count[r+1] += count[r]; b 7 7 e 8 8 f f 10 8 for (int i = 0; i < N; i++) move 9 b 9 f aux[count[a[i]]++] = a[i]; - 12 items 10 e 10 for (int i = 0; i < N; i++) 11 a 11 a[i] = aux[i]; 12 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 d 0 a int N = a.length; 1 a 1 int[] count = new int[R+1]; 2 c r count[r] 2 for (int i = 0; i < N; i++) 3 f a 1 3 count[a[i]+1]++; 4 f b 2 4 5 b c 6 5 c for (int r = 0; r < R; r++) 6 d 6 d d 7 count[r+1] += count[r]; b 7 7 e 8 8 f f 11 8 for (int i = 0; i < N; i++) move 9 b 9 f aux[count[a[i]]++] = a[i]; - 12 items 10 e 10 f for (int i = 0; i < N; i++) 11 a 11 a[i] = aux[i]; 13 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 d 0 a int N = a.length; 1 a 1 int[] count = new int[R+1]; 2 c r count[r] 2 b for (int i = 0; i < N; i++) 3 f a 1 3 count[a[i]+1]++; 4 f b 3 4 5 b c 6 5 c for (int r = 0; r < R; r++) 6 d 6 d d 7 count[r+1] += count[r]; b 7 7 e 8 8 f f 11 8 for (int i = 0; i < N; i++) move 9 b 9 f aux[count[a[i]]++] = a[i]; - 12 items 10 e 10 f for (int i = 0; i < N; i++) 11 a 11 a[i] = aux[i]; 14 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 d 0 a int N = a.length; 1 a 1 int[] count = new int[R+1]; 2 c r count[r] 2 b for (int i = 0; i < N; i++) 3 f a 1 3 count[a[i]+1]++; 4 f b 3 4 5 b c 6 5 c for (int r = 0; r < R; r++) 6 d 6 d d 8 count[r+1] += count[r]; b 7 d 7 e 8 8 f f 11 8 for (int i = 0; i < N; i++) move 9 b 9 f aux[count[a[i]]++] = a[i]; - 12 items 10 e 10 f for (int i = 0; i < N; i++) 11 a 11 a[i] = aux[i]; 15 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 d 0 a int N = a.length; 1 a 1 int[] count = new int[R+1]; 2 c r count[r] 2 b for (int i = 0; i < N; i++) 3 f a 1 3 b count[a[i]+1]++; 4 f b 4 4 5 b c 6 5 c for (int r = 0; r < R; r++) 6 d 6 d d 8 count[r+1] += count[r]; b 7 d 7 e 8 8 f f 11 8 for (int i = 0; i < N; i++) move 9 b 9 f aux[count[a[i]]++] = a[i]; - 12 items 10 e 10 f for (int i = 0; i < N; i++) 11 a 11 a[i] = aux[i]; 16 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 d 0 a int N = a.length; 1 a 1 int[] count = new int[R+1]; 2 c r count[r] 2 b for (int i = 0; i < N; i++) 3 f a 1 3 b count[a[i]+1]++; 4 f b 4 4 5 b c 6 5 c for (int r = 0; r < R; r++) 6 d 6 d d 8 count[r+1] += count[r]; b 7 d 7 e 8 8 f f 12 8 for (int i = 0; i < N; i++) move 9 b 9 f aux[count[a[i]]++] = a[i]; - 12 items 10 e 10 f for (int i = 0; i < N; i++) 11 a 11 f a[i] = aux[i]; 17 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 d 0 a int N = a.length; 1 a 1 int[] count = new int[R+1]; 2 c r count[r] 2 b for (int i = 0; i < N; i++) 3 f a 1 3 b count[a[i]+1]++; 4 f b 5 4 b 5 b c 6 5 c for (int r = 0; r < R; r++) 6 d 6 d d 8 count[r+1] += count[r]; b 7 d 7 e 8 8 f f 12 8 for (int i = 0; i < N; i++) move 9 b 9 f aux[count[a[i]]++] = a[i]; - 12 items 10 e 10 f for (int i = 0; i < N; i++) 11 a 11 f a[i] = aux[i]; 18 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 d 0 a int N = a.length; 1 a 1 int[] count = new int[R+1]; 2 c r count[r] 2 b for (int i = 0; i < N; i++) 3 f a 1 3 b count[a[i]+1]++; 4 f b 5 4 b 5 b c 6 5 c for (int r = 0; r < R; r++) 6 d 6 d d 8 count[r+1] += count[r]; b 7 d 7 e 9 8 f f 12 8 e for (int i = 0; i < N; i++) move 9 b 9 f aux[count[a[i]]++] = a[i]; - 12 items 10 e 10 f for (int i = 0; i < N; i++) 11 a 11 f a[i] = aux[i]; 19 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 d 0 a int N = a.length; 1 a 1 a int[] count = new int[R+1]; 2 c r count[r] 2 b for (int i = 0; i < N; i++) 3 f a 2 3 b count[a[i]+1]++; 4 f b 5 4 b 5 b c 6 5 c for (int r = 0; r < R; r++) 6 d 6 d d 8 count[r+1] += count[r]; b 7 d 7 e 9 8 f f 12 8 e for (int i = 0; i < N; i++) move 9 b 9 f aux[count[a[i]]++] = a[i]; - 12 items 10 e 10 f for (int i = 0; i < N; i++) 11 a 11 f a[i] = aux[i]; 20 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 d 0 a int N = a.length; 1 a 1 a int[] count = new int[R+1]; 2 c r count[r] 2 b for (int i = 0; i < N; i++) 3 f a 2 3 b count[a[i]+1]++; 4 f b 5 4 b 5 b c 6 5 c for (int r = 0; r < R; r++) 6 d 6 d d 8 count[r+1] += count[r]; b 7 d 7 e 9 8 f f 12 8 e for (int i = 0; i < N; i++) move 9 b 9 f aux[count[a[i]]++] = a[i]; - 12 items 10 e 10 f for (int i = 0; i < N; i++) 11 a 11 f a[i] = aux[i]; 21 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 a 0 a int N = a.length; 1 a 1 a int[] count = new int[R+1]; 2 b r count[r] 2 b for (int i = 0; i < N; i++) 3 b a 2 3 b count[a[i]+1]++; 4 b b 5 4 b 5 c c 6 5 c for (int r = 0; r < R; r++) 6 d 6 d d 8 count[r+1] += count[r]; d 7 d 7 e 9 8 e f 12 8 e for (int i = 0; i < N; i++) 9 f - 12 9 f aux[count[a[i]]++] = a[i]; 10 f 10 f for (int i = 0; i < N; i++) 11 f 11 f copy a[i] = aux[i]; back 22 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. offset by 1 i a[i] [stay tuned] 0 d int N = a.length; 1 a int[] count = new int[R+1]; 2 c r count[r] count for (int i = 0; i < N; i++) 3 f a 0 frequencies count[a[i]+1]++; 4 f b 2 5 b c 3 for (int r = 0; r < R; r++) 6 d d 1 count[r+1] += count[r]; b 7 e 2 8 f f 1 for (int i = 0; i < N; i++) 9 b - 3 aux[count[a[i]]++] = a[i]; 10 e for (int i = 0; i < N; i++) 11 a a[i] = aux[i]; 23 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] 0 d int N = a.length; 1 a int[] count = new int[R+1]; 2 c r count[r] 3 f a 0 for (int i = 0; i < N; i++) count[a[i]+1]++; 4 f b 2 5 b c 5 compute for (int r = 0; r < R; r++) 6 d d 6 cumulates count[r+1] += count[r]; 7 b e 8 8 f f 9 for (int i = 0; i < N; i++) 9 b - 12 aux[count[a[i]]++] = a[i]; 10 e 11 a for (int i = 0; i < N; i++) 6 keys < d, 8 keys < e a[i] = aux[i]; so d’s go in a and a 24 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 d 0 a int N = a.length; 1 a 1 a int[] count = new int[R+1]; 2 c r count[r] 2 b for (int i = 0; i < N; i++) 3 f a 2 3 b count[a[i]+1]++; 4 f b 5 4 b 5 b c 6 5 c for (int r = 0; r < R; r++) 6 d 6 d d 8 count[r+1] += count[r]; b 7 d 7 e 9 8 f f 12 8 e for (int i = 0; i < N; i++) move 9 b 9 f aux[count[a[i]]++] = a[i]; - 12 items 10 e 10 f For the index for (int i = 0; i < N; i++) 11 a 11 f of duplicates a[i] = aux[i]; 25 Key-indexed counting demo Goal. Sort an array a[] of N integers between 0 and R - 1. Count frequencies of each letter using key as index. Compute frequency cumulates which specify destinations. Access cumulates using key as index to move items. Copy back into original array. i a[i] i aux[i] 0 a 0 a int N = a.length; 1 a 1 a int[] count = new int[R+1]; 2 b r count[r] 2 b for (int i = 0; i < N; i++) 3 b a 2 3 b count[a[i]+1]++; 4 b b 5 4 b 5 c c 6 5 c for (int r = 0; r < R; r++) 6 d 6 d d 8 count[r+1] += count[r]; d 7 d 7 e 9 8 e f 12 8 e for (int i = 0; i < N; i++) 9 f - 12 9 f aux[count[a[i]]++] = a[i]; 10 f 10 f for (int i = 0; i < N; i++) 11 f 11 f copy a[i] = aux[i]; back 26 Key-indexed counting: analysis Proposition. Key-indexed counting uses ~ 11 N + 4 R array accesses to sort N items whose keys are integers between 0 and R - 1. for (int i = 0; i < N; i++) aux[count[a[i].key(d)]++] = a[i]; Proposition. Key-indexed count[] counting uses extra space proportional to N + R. 1 2 3 4 0 3 8 14 Depends on the Stable? 0 0 4 4 8 9 14 14 a a Anderson Brown 2 3 Harris Martin 1 1 aux aux Alphabet size / Max ✔ 0 4 10 14 a Davis 3 Moore 1 aux integer value 0 4 10 15 a Garcia 4 Anderson 2 aux 1 4 10 15 a Harris 1 Martinez 2 aux 1 4 11 15 a Jackson 3 Miller 2 aux 1 4 11 16 a Johnson 4 Robinson 2 aux 1 4 12 16 a Jones 3 White 2 aux 2 4 12 16 a Martin 1 Brown 3 aux 2 5 12 16 a Martinez 2 Davis 3 aux 2 6 12 16 a Miller 2 Jackson 3 aux 3 6 12 16 a Moore 1 Jones 3 aux 3 7 12 16 a Robinson 2 Taylor 3 aux 3 7 12 17 a Smith 4 Williams 3 aux 3 7 13 17 a Taylor 3 Garcia 4 aux 3 7 13 18 a Thomas 4 Johnson 4 aux 3 7 13 19 a Thompson 4 Smith 4 aux 3 8 13 19 a White 2 Thomas 4 aux 3 8 14 19 a Williams 3 Thompson 4 aux 3 8 14 20 a Wilson 4 Wilson 4 aux Distributing the data (records with key 3 highlighted) 27  STRING SORTS ‣ Key-indexed counting ‣ LSD radix sort ‣ MSD radix sort ‣ 3-way radix quicksort ‣ Suf x arrays fi Least-signi cant-digit- rst string sort LSD string (radix) sort. Consider characters from right to left. Stably sort using dth character as the key (using key-indexed counting). sort key (d=2) sort key (d=1) sort key (d=0) 0 d a b 0 d a b 0 d a b 0 a c e 1 a d d 1 c a b 1 c a b 1 a d d 2 c a b 2 e b b 2 f a d 2 b a d 3 f a d 3 a d d 3 b a d 3 b e d 4 f e e 4 f a d 4 d a d 4 b e e 5 b a d 5 b a d 5 e b b 5 c a b 6 d a d 6 d a d 6 a c e 6 d a b 7 b e e 7 f e d 7 a d d 7 d a d 8 f e d 8 b e d 8 f e d 8 e b b 9 b e d 9 f e e 9 b e d 9 f a d 10 e b b 10 b e e 10 f e e 10 f e d 11 a c e 11 a c e 11 b e e 11 f e e sort must be stable (arrows do not cross) 29 fi fi LSD string sort: correctness proof Proposition. LSD sorts xed-length strings in ascending order. sort key Pf. [by induction on i] After pass i, strings are sorted by last i characters. 0 d a b 0 a c e If two strings differ on sort key, 1 2 c f a a b d 1 2 a b d a d d key-indexed sort puts them in proper relative order. 3 b a d 3 b e d If two strings agree on sort key, 4 d a d 4 b e e stability keeps them in proper relative order. 5 e b b 5 c a b 6 a c e 6 d a b [Thinking about the future] 7 a d d 7 d a d - If the characters not yet examined differ, it doesn’t matter 8 f e d 8 e b b what we do now 9 b e d 9 f a d - If the characters not yet examined agree, stability ensures 10 f e e 10 f e d later pass won’t affect order. 11 b e e 11 f e e sorted from previous passes (by induction) 30 fi  LSD string sort: Java implementation public class LSD { public static void sort(String[] a, int W) xed-length W strings { int R = 256; radix R int N = a.length; String[] aux = new String[N]; for (int d = W-1; d >= 0; d--) do key-indexed counting { for each digit from right to left int[] count = new int[R+1]; for (int i = 0; i < N; i++) count[a[i].charAt(d) + 1]++; for (int r = 0; r < R; r++) key-indexed counting count[r+1] += count[r]; (count sort) for (int i = 0; i < N; i++) aux[count[a[i].charAt(d)]++] = a[i]; for (int i = 0; i < N; i++) a[i] = aux[i]; } } } 31 fi Summary of the performance of sorting algorithms Frequency of operations. algorithm guarantee random extra space stable? operations on keys insertion sort N2 / 2 N2 / 4 1 yes compareTo() mergesort N lg N N lg N N yes compareTo() quicksort 1.39 N lg N * 1.39 N lg N c lg N no compareTo() heapsort 2 N lg N 2 N lg N 1 no compareTo() LSD † 2WN 2WN N+R yes charAt() * probabilistic † xed-length W keys Q. What if strings do not have same length? 32 fi  Chapter 1: Introduction Operating System Concepts – 9th Edit9on Silberschatz, Galvin and Gagne ©2013  Chapter 1: Introduction
What Operating Systems Do
Computer-System Organization
Computer-System Architecture
Operating-System Structure
Operating-System Operations
Process Management
Memory Management
Storage Management
Protection and Security
Kernel Data Structures
Computing Environments
Open-Source Operating Systems Operating System Concepts – 9th Edition 1.2 Silberschatz, Galvin and Gagne ©2013  Objectives
To describe the basic organization of computer systems
To provide a grand tour of the major components of operating systems
To give an overview of the many types of computing environments
To explore several open-source operating systems Operating System Concepts – 9th Edition 1.3 Silberschatz, Galvin and Gagne ©2013  What is an Operating System?
A program that acts as an intermediary between a user of a computer and the computer hardware
Operating system goals:  Execute user programs and make solving user problems easier  Make the computer system convenient to use  Use the computer hardware in an efficient manner Operating System Concepts – 9th Edition 1.4 Silberschatz, Galvin and Gagne ©2013  Computer System Structure
Computer system can be divided into four components:  Hardware – provides basic computing resources
CPU, memory, I/O devices  Operating system
Controls and coordinates use of hardware among various applications and users  Application programs – define the ways in which the system resources are used to solve the computing problems of the users
Word processors, compilers, web browsers, database systems, video games  Users
People, machines, other computers Operating System Concepts – 9th Edition 1.5 Silberschatz, Galvin and Gagne ©2013  Four Components of a Computer System Operating System Concepts – 9th Edition 1.6 Silberschatz, Galvin and Gagne ©2013  What Operating Systems Do
Depends on the point of view
Users want convenience, ease of use  Don’t care about resource utilization
But shared computer such as mainframe or minicomputer must keep all users happy
Users of dedicate systems such as workstations have dedicated resources but frequently use shared resources from servers
Handheld computers are resource poor, optimized for usability and battery life
Some computers have little or no user interface, such as embedded computers in devices and automobiles Operating System Concepts – 9th Edition 1.7 Silberschatz, Galvin and Gagne ©2013  Operating System Definition
OS is a resource allocator  Manages all resources  Decides between conflicting requests for efficient and fair resource use
OS is a control program  Controls execution of programs to prevent errors and improper use of the computer Operating System Concepts – 9th Edition 1.8 Silberschatz, Galvin and Gagne ©2013  Operating System Definition (Cont.)
No universally accepted definition
“Everything a vendor ships when you order an operating system” is good approximation  But varies wildly
“The one program running at all times on the computer” is the kernel. Everything else is either a system program (ships with the operating system) or an application program. Operating System Concepts – 9th Edition 1.9 Silberschatz, Galvin and Gagne ©2013  Computer Startup
bootstrap program is loaded at power-up or reboot  Typically stored in ROM or EPROM, generally known as firmware  Initializes all aspects of system  Loads operating system kernel and starts execution Operating System Concepts – 9th Edition 1.10 Silberschatz, Galvin and Gagne ©2013  Computer System Organization
Computer-system operation  One or more CPUs, device controllers connect through common bus providing access to shared memory  Concurrent execution of CPUs and devices competing for memory cycles Operating System Concepts – 9th Edition 1.11 Silberschatz, Galvin and Gagne ©2013  Computer-System Operation
I/O devices and the CPU can execute concurrently
Each device controller is in charge of a particular device type
Each device controller has a local buffer
CPU moves data from/to main memory to/from local buffers
I/O is from the device to local buffer of controller
Device controller informs CPU that it has finished its operation by causing an interrupt Operating System Concepts – 9th Edition 1.12 Silberschatz, Galvin and Gagne ©2013  Common Functions of Interrupts
Interrupt transfers control to the interrupt service routine generally, through the interrupt vector, which contains the addresses of all the service routines
Interrupt architecture must save the address of the interrupted instruction
A trap or exception is a software-generated interrupt caused either by an error or a user request
An operating system is interrupt driven Operating System Concepts – 9th Edition 1.13 Silberschatz, Galvin and Gagne ©2013  Interrupt Handling
The operating system preserves the state of the CPU by storing registers and the program counter
Determines which type of interrupt has occurred:  polling  vectored interrupt system
Separate segments of code determine what action should be taken for each type of interrupt Operating System Concepts – 9th Edition 1.14 Silberschatz, Galvin and Gagne ©2013  Interrupt Timeline Operating System Concepts – 9th Edition 1.15 Silberschatz, Galvin and Gagne ©2013  I/O Structure
After I/O starts, control returns to user program only upon I/O completion  Wait instruction idles the CPU until the next interrupt  Wait loop (contention for memory access)  At most one I/O request is outstanding at a time, no simultaneous I/O processing
After I/O starts, control returns to user program without waiting for I/O completion  System call – request to the OS to allow user to wait for I/O completion  Device-status table contains entry for each I/O device indicating its type, address, and state  OS indexes into I/O device table to determine device status and to modify table entry to include interrupt Operating System Concepts – 9th Edition 1.16 Silberschatz, Galvin and Gagne ©2013  Storage Definitions and Notation Review The basic unit of computer storage is the bit. A bit can contain one of two values, 0 and 1. All other storage in a computer is based on collections of bits. Given enough bits, it is amazing how many things a computer can represent: numbers, letters, images, movies, sounds, documents, and programs, to name a few. A byte is 8 bits, and on most computers it is the smallest convenient chunk of storage. For example, most computers don’t have an instruction to move a bit but do have one to move a byte. A less common term is word, which is a given computer architecture’s native unit of data. A word is made up of one or more bytes. For example, a computer that has 64-bit registers and 64-bit memory addressing typically has 64-bit (8-byte) words. A computer executes many operations in its native word size rather than a byte at a time. Computer storage, along with most computer throughput, is generally measured and manipulated in bytes and collections of bytes. A kilobyte, or KB, is 1,024 2 3 bytes; a megabyte, or MB, is 1,024 bytes; a gigabyte, or GB, is 1,024 bytes; a 4 5 terabyte, or TB, is 1,024 bytes; and a petabyte, or PB, is 1,024 bytes. Computer manufacturers often round off these numbers and say that a megabyte is 1 million bytes and a gigabyte is 1 billion bytes. Networking measurements are an exception to this general rule; they are given in bits (because networks move data a bit at a time). Operating System Concepts – 9th Edition 1.17 Silberschatz, Galvin and Gagne ©2013  Storage Structure
Main memory – only large storage media that the CPU can access directly  Random access  Typically volatile
Secondary storage – extension of main memory that provides large nonvolatile storage capacity
Magnetic disks – rigid metal or glass platters covered with magnetic recording material  Disk surface is logically divided into tracks, which are subdivided into sectors  The disk controller determines the logical interaction between the device and the computer
Solid-state disks – faster than magnetic disks, nonvolatile  Various technologies  Becoming more popular Operating System Concepts – 9th Edition 1.18 Silberschatz, Galvin and Gagne ©2013  Storage Hierarchy
Storage systems organized in hierarchy  Speed  Cost  Volatility
Caching – copying information into faster storage system; main memory can be viewed as a cache for secondary storage
Device Driver for each device controller to manage I/O  Provides uniform interface between controller and kernel Operating System Concepts – 9th Edition 1.19 Silberschatz, Galvin and Gagne ©2013  Storage-Device Hierarchy Operating System Concepts – 9th Edition 1.20 Silberschatz, Galvin and Gagne ©2013  Caching
Important principle, performed at many levels in a computer (in hardware, operating system, software)
Information in use copied from slower to faster storage temporarily
Faster storage (cache) checked first to determine if information is there  If it is, information used directly from the cache (fast)  If not, data copied to cache and used there
Cache smaller than storage being cached  Cache management important design problem  Cache size and replacement policy Operating System Concepts – 9th Edition 1.21 Silberschatz, Galvin and Gagne ©2013  Computer-System Architecture
Most systems use a single general-purpose processor  Most systems have special-purpose processors as well
Multiprocessors systems growing in use and importance  Also known as parallel systems, tightly-coupled systems  Advantages include: 1. Increased throughput 2. Economy of scale 3. Increased reliability – graceful degradation or fault tolerance  Two types: 1. Asymmetric Multiprocessing 2. Symmetric Multiprocessing Operating System Concepts – 9th Edition 1.22 Silberschatz, Galvin and Gagne ©2013  How a Modern Computer Works A von Neumann architecture Operating System Concepts – 9th Edition 1.23 Silberschatz, Galvin and Gagne ©2013  Symmetric Multiprocessing Architecture Operating System Concepts – 9th Edition 1.24 Silberschatz, Galvin and Gagne ©2013  Clustered Systems
Like multiprocessor systems, but multiple systems working together  Usually sharing storage via a storage-area network (SAN)  Provides a high-availability service which survives failures
Asymmetric clustering has one machine in hot-standby mode
Symmetric clustering has multiple nodes running applications, monitoring each other  Some clusters are for high-performance computing (HPC)
Applications must be written to use parallelization  Some have distributed lock manager (DLM) to avoid conflicting operations Operating System Concepts – 9th Edition 1.25 Silberschatz, Galvin and Gagne ©2013  Clustered Systems Operating System Concepts – 9th Edition 1.26 Silberschatz, Galvin and Gagne ©2013  Operating System Structure
Multiprogramming needed for efficiency  Single user cannot keep CPU and I/O devices busy at all times  Multiprogramming organizes jobs (code and data) so CPU always has one to execute  A subset of total jobs in system is kept in memory  One job selected and run via job scheduling  When it has to wait (for I/O for example), OS switches to another job
Timesharing (multitasking) is logical extension in which CPU switches jobs so frequently that users can interact with each job while it is running, creating interactive computing  Response time should be < 1 second  Each user has at least one program executing in memory
process  If several jobs ready to run at the same time
CPU scheduling  If processes don’t fit in memory, swapping moves them in and out to run  Virtual memory allows execution of processes not completely in memory Operating System Concepts – 9th Edition 1.27 Silberschatz, Galvin and Gagne ©2013  Memory Layout for Multiprogrammed System Operating System Concepts – 9th Edition 1.28 Silberschatz, Galvin and Gagne ©2013  Operating-System Operations
Interrupt driven by hardware
Software error or request creates exception or trap  Division by zero, request for operating system service
Other process problems include infinite loop, processes modifying each other or the operating system
Dual-mode operation allows OS to protect itself and other system components  User mode and kernel mode  Mode bit provided by hardware
Provides ability to distinguish when system is running user code or kernel code
Some instructions designated as privileged, only executable in kernel mode
System call changes mode to kernel, return from call resets it to user
Increasingly CPUs support multi-mode operations  i.e. virtual machine manager (VMM) mode for guest VMs Operating System Concepts – 9th Edition 1.29 Silberschatz, Galvin and Gagne ©2013  Transition from User to Kernel Mode
Timer to prevent infinite loop / process hogging resources  Set interrupt after specific period  Operating system decrements counter  When counter zero generate an interrupt  Set up before scheduling process to regain control or terminate program that exceeds allotted time Operating System Concepts – 9th Edition 1.30 Silberschatz, Galvin and Gagne ©2013  Process Management
A process is a program in execution. It is a unit of work within the system. Program is a passive entity, process is an active entity.
Process needs resources to accomplish its task  CPU, memory, I/O, files  Initialization data
Process termination requires reclaim of any reusable resources
Single-threaded process has one program counter specifying location of next instruction to execute  Process executes instructions sequentially, one at a time, until completion
Multi-threaded process has one program counter per thread
Typically system has many processes, some user, some operating system running concurrently on one or more CPUs  Concurrency by multiplexing the CPUs among the processes / threads Operating System Concepts – 9th Edition 1.31 Silberschatz, Galvin and Gagne ©2013  Process Management Activities The operating system is responsible for the following activities in connection with process management:
Creating and deleting both user and system processes
Suspending and resuming processes
Providing mechanisms for process synchronization
Providing mechanisms for process communication
Providing mechanisms for deadlock handling Operating System Concepts – 9th Edition 1.32 Silberschatz, Galvin and Gagne ©2013  Memory Management
All data in memory before and after processing
All instructions in memory in order to execute
Memory management determines what is in memory when  Optimizing CPU utilization and computer response to users
Memory management activities  Keeping track of which parts of memory are currently being used and by whom  Deciding which processes (or parts thereof) and data to move into and out of memory  Allocating and deallocating memory space as needed Operating System Concepts – 9th Edition 1.33 Silberschatz, Galvin and Gagne ©2013  Storage Management
OS provides uniform, logical view of information storage  Abstracts physical properties to logical storage unit - file  Each medium is controlled by device (i.e., disk drive, tape drive)
Varying properties include access speed, capacity, data- transfer rate, access method (sequential or random)
File-System management  Files usually organized into directories  Access control on most systems to determine who can access what  OS activities include
Creating and deleting files and directories
Primitives to manipulate files and dirs
Mapping files onto secondary storage
Backup files onto stable (non-volatile) storage media Operating System Concepts – 9th Edition 1.34 Silberschatz, Galvin and Gagne ©2013  Mass-Storage Management
Usually disks used to store data that does not fit in main memory or data that must be kept for a “long” period of time
Proper management is of central importance
Entire speed of computer operation hinges on disk subsystem and its algorithms
OS activities  Free-space management  Storage allocation  Disk scheduling
Some storage need not be fast  Tertiary storage includes optical storage, magnetic tape  Still must be managed – by OS or applications  Varies between WORM (write-once, read-many-times) and RW (read-write) Operating System Concepts – 9th Edition 1.35 Silberschatz, Galvin and Gagne ©2013  Performance of Various Levels of Storage
Movement between levels of storage hierarchy can be explicit or implicit Operating System Concepts – 9th Edition 1.36 Silberschatz, Galvin and Gagne ©2013  Migration of Integer A from Disk to Register
Multitasking environments must be careful to use most recent value, no matter where it is stored in the storage hierarchy
Multiprocessor environment must provide cache coherency in hardware such that all CPUs have the most recent value in their cache
Distributed environment situation even more complex  Several copies of a datum can exist  Various solutions covered in Chapter 17 Operating System Concepts – 9th Edition 1.37 Silberschatz, Galvin and Gagne ©2013  I/O Subsystem
One purpose of OS is to hide peculiarities of hardware devices from the user
I/O subsystem responsible for  Memory management of I/O including buffering (storing data temporarily while it is being transferred), caching (storing parts of data in faster storage for performance), spooling (the overlapping of output of one job with input of other jobs)  General device-driver interface  Drivers for specific hardware devices Operating System Concepts – 9th Edition 1.38 Silberschatz, Galvin and Gagne ©2013  Protection and Security
Protection – any mechanism for controlling access of processes or users to resources defined by the OS
Security – defense of the system against internal and external attacks  Huge range, including denial-of-service, worms, viruses, identity theft, theft of service
Systems generally first distinguish among users, to determine who can do what  User identities (user IDs, security IDs) include name and associated number, one per user  User ID then associated with all files, processes of that user to determine access control  Group identifier (group ID) allows set of users to be defined and controls managed, then also associated with each process, file  Privilege escalation allows user to change to effective ID with more rights Operating System Concepts – 9th Edition 1.39 Silberschatz, Galvin and Gagne ©2013  Computing Environments - Traditional
Stand-alone general purpose machines
But blurred as most systems interconnect with others (i.e. the Internet)
Portals provide web access to internal systems
Network computers (thin clients) are like Web terminals
Mobile computers interconnect via wireless networks
Networking becoming ubiquitous – even home systems use firewalls to protect home computers from Internet attacks Operating System Concepts – 9th Edition 1.40 Silberschatz, Galvin and Gagne ©2013  Computing Environments - Mobile
Handheld smartphones, tablets, etc
What is the functional difference between them and a “traditional” laptop?
Extra feature – more OS features (GPS, gyroscope)
Allows new types of apps like augmented reality
Use IEEE 802.11 wireless, or cellular data networks for connectivity
Leaders are Apple iOS and Google Android Operating System Concepts – 9th Edition 1.41 Silberschatz, Galvin and Gagne ©2013  Computing Environments – Distributed
Distributed  Collection of separate, possibly heterogeneous, systems networked together
Network is a communications path, TCP/IP most common – Local Area Network (LAN) – Wide Area Network (WAN) – Metropolitan Area Network (MAN) – Personal Area Network (PAN)  Network Operating System provides features between systems across network
Communication scheme allows systems to exchange messages
Illusion of a single system Operating System Concepts – 9th Edition 1.42 Silberschatz, Galvin and Gagne ©2013  Computing Environments – Client-Server
Client-Server Computing  Dumb terminals supplanted by smart PCs  Many systems now servers, responding to requests generated by clients
Compute-server system provides an interface to client to request services (i.e., database)
File-server system provides interface for clients to store and retrieve files Operating System Concepts – 9th Edition 1.43 Silberschatz, Galvin and Gagne ©2013  Computing Environments - Peer-to-Peer
Another model of distributed system
P2P does not distinguish clients and servers  Instead all nodes are considered peers  May each act as client, server or both  Node must join P2P network
Registers its service with central lookup service on network, or
Broadcast request for service and respond to requests for service via discovery protocol  Examples include Napster and Gnutella, Voice over IP (VoIP) such as Skype Operating System Concepts – 9th Edition 1.44 Silberschatz, Galvin and Gagne ©2013  Computing Environments - Virtualization
Allows operating systems to run applications within other OSes  Vast and growing industry
Emulation used when source CPU type different from target type (i.e. PowerPC to Intel x86)  Generally slowest method  When computer language not compiled to native code – Interpretation
Virtualization – OS natively compiled for CPU, running guest OSes also natively compiled  Consider VMware running WinXP guests, each running applications, all on native WinXP host OS  VMM provides virtualization services Operating System Concepts – 9th Edition 1.45 Silberschatz, Galvin and Gagne ©2013  Computing Environments - Virtualization
Use cases involve laptops and desktops running multiple OSes for exploration or compatibility  Apple laptop running Mac OS X host, Windows as a guest  Developing apps for multiple OSes without having multiple systems  QA testing applications without having multiple systems  Executing and managing compute environments within data centers
VMM can run natively, in which case they are also the host  There is no general purpose host then (VMware ESX and Citrix XenServer) Operating System Concepts – 9th Edition 1.46 Silberschatz, Galvin and Gagne ©2013  Computing Environments - Virtualization Operating System Concepts – 9th Edition 1.47 Silberschatz, Galvin and Gagne ©2013  Computing Environments – Cloud Computing
Delivers computing, storage, even apps as a service across a network
Logical extension of virtualization as based on virtualization  Amazon EC2 has thousands of servers, millions of VMs, PBs of storage available across the Internet, pay based on usage
Many types  Public cloud – available via Internet to anyone willing to pay  Private cloud – run by a company for the company’s own use  Hybrid cloud – includes both public and private cloud components  Software as a Service (SaaS) – one or more applications available via the Internet (i.e. word processor)  Platform as a Service (PaaS) – software stack ready for application use via the Internet (i.e a database server)  Infrastructure as a Service (IaaS) – servers or storage available over Internet (i.e. storage available for backup use) Operating System Concepts – 9th Edition 1.48 Silberschatz, Galvin and Gagne ©2013  Computing Environments – Cloud Computing
Cloud compute environments composed of traditional OSes, plus VMMs, plus cloud management tools  Internet connectivity requires security like firewalls  Load balancers spread traffic across multiple applications Operating System Concepts – 9th Edition 1.49 Silberschatz, Galvin and Gagne ©2013  Computing Environments – Real-Time Embedded Systems
Real-time embedded systems most prevalent form of computers  Vary considerable, special purpose, limited purpose OS, real-time OS  Use expanding
Many other special computing environments as well  Some have OSes, some perform tasks without an OS
Real-time OS has well-defined fixed time constraints  Processing must be done within constraint  Correct operation only if constraints met Operating System Concepts – 9th Edition 1.50 Silberschatz, Galvin and Gagne ©2013  Open-Source Operating Systems
Operating systems made available in source-code format rather than just binary closed-source
Counter to the copy protection and Digital Rights Management (DRM) movement
Started by Free Software Foundation (FSF), which has “copyleft” GNU Public License (GPL)
Examples include GNU/Linux and BSD UNIX (including core of Mac OS X), and many more
Can use VMM like VMware Player (Free on Windows), Virtualbox (open source and free on many platforms - http://www.virtualbox.com)  Use to run guest operating systems for exploration Operating System Concepts – 9th Edition 1.51 Silberschatz, Galvin and Gagne ©2013  Chapter 2: System Structures Operating System Concepts – 9th Edition Silberschatz, Galvin and Gagne ©2013  Chapter 2: System Structures
Operating System Services
User Operating System Interface
System Calls
Types of System Calls
System Programs
Operating System Design and Implementation
Operating System Structure
Operating System Debugging
Operating System Generation
System Boot Operating System Concepts – 9th Edition 2.2 Silberschatz, Galvin and Gagne ©2013  Objectives
To describe the services an operating system provides to users, processes, and other systems
To discuss the various ways of structuring an operating system
To explain how operating systems are installed and customized and how they boot Operating System Concepts – 9th Edition 2.3 Silberschatz, Galvin and Gagne ©2013  Operating System Services
Operating systems provide an environment for execution of programs and services to programs and users
One set of operating-system services provides functions that are helpful to the user:  User interface - Almost all operating systems have a user interface (UI).
Varies between Command-Line (CLI), Graphics User Interface (GUI), Batch  Program execution - The system must be able to load a program into memory and to run that program, end execution, either normally or abnormally (indicating error)  I/O operations - A running program may require I/O, which may involve a file or an I/O device  File-system manipulation - The file system is of particular interest. Programs need to read and write files and directories, create and delete them, search them, list file Information, permission management. Operating System Concepts – 9th Edition 2.4 Silberschatz, Galvin and Gagne ©2013  Operating System Services (Cont.)  Communications – Processes may exchange information, on the same computer or between computers over a network
Communications may be via shared memory or through message passing (packets moved by the OS)  Error detection – OS needs to be constantly aware of possible errors
May occur in the CPU and memory hardware, in I/O devices, in user program
For each type of error, OS should take the appropriate action to ensure correct and consistent computing
Debugging facilities can greatly enhance the user’s and programmer’s abilities to efficiently use the system Operating System Concepts – 9th Edition 2.5 Silberschatz, Galvin and Gagne ©2013  Operating System Services (Cont.)
Another set of OS functions exists for ensuring the efficient operation of the system itself via resource sharing  Resource allocation - When multiple users or multiple jobs running concurrently, resources must be allocated to each of them
Many types of resources - Some (such as CPU cycles, main memory, and file storage) may have special allocation code, others (such as I/O devices) may have general request and release code  Accounting - To keep track of which users use how much and what kinds of computer resources  Protection and security - The owners of information stored in a multiuser or networked computer system may want to control use of that information, concurrent processes should not interfere with each other
Protection involves ensuring that all access to system resources is controlled
Security of the system from outsiders requires user authentication, extends to defending external I/O devices from invalid access attempts
If a system is to be protected and secure, precautions must be instituted throughout it. A chain is only as strong as its weakest link. Operating System Concepts – 9th Edition 2.6 Silberschatz, Galvin and Gagne ©2013  A View of Operating System Services Operating System Concepts – 9th Edition 2.7 Silberschatz, Galvin and Gagne ©2013  User Operating System Interface - CLI
CLI or command interpreter allows direct command entry
Sometimes implemented in kernel, sometimes by systems program
Sometimes multiple flavors implemented – shells
Primarily fetches a command from user and executes it – Sometimes commands built-in, sometimes just names of programs » If the latter, adding new features doesn’t require shell modification Operating System Concepts – 9th Edition 2.8 Silberschatz, Galvin and Gagne ©2013  Bourne Shell Command Interpreter Operating System Concepts – 9th Edition 2.9 Silberschatz, Galvin and Gagne ©2013  User Operating System Interface - GUI
User-friendly desktop metaphor interface  Usually mouse, keyboard, and monitor  Icons represent files, programs, actions, etc  Various mouse buttons over objects in the interface cause various actions (provide information, options, execute function, open directory (known as a folder)  Invented at Xerox PARC
Many systems now include both CLI and GUI interfaces  Microsoft Windows is GUI with CLI “command” shell  Apple Mac OS X is “Aqua” GUI interface with UNIX kernel underneath and shells available  Unix and Linux have CLI with optional GUI interfaces (CDE, KDE, GNOME) Operating System Concepts – 9th Edition 2.10 Silberschatz, Galvin and Gagne ©2013  Touchscreen Interfaces
Touchscreen devices require new interfaces  Mouse not possible or not desired  Actions and selection based on gestures  Virtual keyboard for text entry Operating System Concepts – 9th Edition 2.11 Silberschatz, Galvin and Gagne ©2013  The Mac OS X GUI Operating System Concepts – 9th Edition 2.12 Silberschatz, Galvin and Gagne ©2013  System Calls
Pr