Wednesday, March 29, Implementation of sets in an efficient manner illustrates some bit-manipulation ideas.

Transcription

1 Wednesday, March 29, 2017 Topics for today Sets: representation and manipulation using bits Dynamic memory allocation Addressing mode summary Sets Implementation of sets in an efficient manner illustrates some bit-manipulation ideas. Few languages have sets as built-in types. SETL is based on sets and Pascal has sets but with limitations. In a language having the set type we would expect to be able to have things like var A, B, C : set of integer; A = [ 2, -5, 7, 29]; B = [ 1, 5, 29, 17, 30]; C = A union B; C = A intersect B; if ismember(c,32)... A = A + 14; /* insert 14 to set A */ B = B - 5; /* remove 5 from set B */ In Standard Pascal, the base type could have no more than 64(?) possible members. One way of implementing sets is with linked lists. Items in the lists are typically stored in ascending (or descending) order so that union and intersection operator can be implemented efficiently. However, if we know the range of the base type and the members are enumerable, we can use bit vectors (arrays of bits) In a bit vector A, bit I is 1 if the Ith possible member is in the set and bit I is 0 if the possible member is not in the set. This method of representing a set does not support multisets where a member may appear more than once. Operations such as union and intersection are now extremely fast. In what follows we will assume that our sets are sets of integers. Q: How many bytes to do we need if there are N possible set members? A: ceiling(n/8) Comp 162 Notes Page 1 of 16 March 29, 2017

2 Q: How do we know which byte contains the bit that represents the membership of integer k. A: Numbering bytes from 0 upwards, assuming 8 bits per byte then the bit is in byte k/8. Q: Which bit in this byte represents membership of k? A: Assuming bits are numbered 0 through 7 then the bit is number k%8. Example Assume underlying base type is We need 5 bytes (ceiling(38/8) = 5). We can represent the set [ ] as The leftmost bit represents membership of 0, the bit next to it represents the membership of 1 and so on. The locations of the 5 bits set to 1 correspond to the 5 members of set [ ]. Bit vectors in Pep/9 We look at assembly code fragments to * test bit i (membership test) * set bit i (adding to set) * clear bit i (removing from set) Our code uses two arrays of 16-bit bit masks (bit patterns); these enable us to isolate individual bits within a byte Each entry in the first table (bits1) is all zeros except for a single one. Each entry in the second table (bits2) is all ones except for a single zero. We use full words because the Pep/9 AND and OR instructions operate on words. Here are the tables. Comp 162 Notes Page 2 of 16 March 29, 2017

3 bits1:.word 0x0080 ; word 0x0040 ; word 0x0020 ; word 0x0010 ; etc.word 0x0008.word 0x0004.word 0x0002.word 0x0001 bits2:.word 0xff7f ; word 0xffbf ; word 0xffdf ; word 0xffef ; etc.word 0xfff7.word 0xfffb.word 0xfffd.word 0xfffe The following code is common to all three operations (test bit i, set bit i and clear bit i) ; assume S is the array of bytes ; get appropriate byte ldwx i,d ; bit number ; i/8 is byte number ldba S,x ; get byte containing bit i ldwx i,d ; bit number again andx 7,i ; bit number within the byte i.e. i%8 aslx ; turn into a byte offset to index bit mask array Having got the byte of interest into register A, here are the code sequences for the three operations Test bit i anda bits1,x breq... ; branch if bit is zero Set bit i ora bits1,x Clear bit i anda bits2,x Both the Set and Clear operations need to be followed by code that updates S as follows Comp 162 Notes Page 3 of 16 March 29, 2017

4 ldwx i,d stba S,x ; bit number ; the byte number ; put the modified byte back into S Applications of bit maps Indexes Bit maps or bit vectors are commonly used in indexes of various kinds. For example A bit map might be used by an operating system as a record of the free space on a disc. Bit I indicates if disc block I is free or in use. Suppose space is allocated by the operating system in 4Kbyte sections. The ratio between disc and map is to 1 so on a 1Tbytes disc, about 256 Mbytes is occupied by the map In a document retrieval system bit I might indicate if document I contains the keyword of interest. Queries such as Find bank and (finance or account) and not river Can be implemented as set operations. Consider the following code ldwx 2000,I top: ldwa River,x nota stwa -2,s ldwa Finance,x ora Account,x anda -2,s anda Bank,x stwa result,x subx 2,i brge top ; or whatever the size is In a lottery, a lottery ticket can be implemented as a bit map. The winning numbers can also be implemented in this way then matched quickly with the tickets. Comp 162 Notes Page 4 of 16 March 29, 2017

5 Prime numbers We can use a bitmap to represent the set of prime numbers. If we assume that no even number is prime then our bitlist represents the prime-ness of the odd numbers 3, 5, 7,,32767 Such a bit list would occupy 2048 bytes, a relatively small amount of memory. The first few bits are shown below together with the numbers they represent Our code below, lets the user enter a sequence of numbers terminated by zero. The program reports, for each number, whether it is prime. The bitmap primemap is omitted for space reasons. It differs from the earlier examples in that the relevant parts of the bit masks are 16 bits long rather than 8 bits. ; prime number tester top: deci N,d breq done ; zero terminates program brv badin ; warn if number out of range brlt top ; negative numbers ignored ldwa N,d cpwa 1,i breq top ; 1 is ignored cpwa 2,i breq prime ; 2 is prime anda 1,i breq notprime ; even number is not prime ldwa N,d suba 3,i asra stwa K,d ; K=(N-3)/2 = bit position to test ldwx K,d ; K/16 is number of word containing bit of interest aslx ; byte offset of this word ldwa primemap,x ; get the word of interest ldwx K,d ; bit number again andx 15,i ; bit within word aslx ; byte offset for bitmask table anda bitmask,x ; zero out all other bits breq notprime ; if bit of interest is zero, N is not prime prime: stro isprime,d br top notprime: stro noprime,d br top badin: stro badinput,d br top done: stop Comp 162 Notes Page 5 of 16 March 29, 2017

6 N:.block 2 K:.block 2 badinput:.ascii "overflow on input\n\x00" noprime:.ascii "is not prime\n\x00" isprime:.ascii "is prime\n\x00"; bitmask:.word 0x8000.word 0x4000.word 0x2000.word 0x1000.word 0x0800.word 0x0400.word 0x0200.word 0x0100.word 0x0080.word 0x0040.word 0x0020.word 0x0010.word 0x0008.word 0x0004.word 0x0002.word 0x0001 Dynamic memory allocation (section 6.5) In C there are three general classes of variable: Globals, Locals and Heap. In many high-level languages there is a mechanism to request/allocate space from a memory pool dynamically as the program runs. The pool is often referred to as the heap. The space can be returned to the pool in an order different from its allocation. This is what makes the heap different from and separate from the stack. In C space no longer needed has to be returned explicitly to the heap, in Java a garbage collector finds space that can no longer be accessed and can thus be reused In the following.the function malloc (found in stdlib.h) returns the address of the space requested or NULL is the request cannot be satisfied. int *P,*Q; char *str; P = malloc (sizeof(int)); // sizeof returns the size in bytes Q = malloc (4 * sizeof(int)); // array of 4 int str = malloc (15); We may not know how big our table needs to be until run-time. int *Table; int N; scanf( %d,&n); // size of table Table = malloc (N*sizeof(int)); Comp 162 Notes Page 6 of 16 March 29, 2017

7 In C, we can free up the space after we have finished with it enabling it to be reused free(q); free(table); In Pep/9 we can mimic the allocation of space (using Warford s malloc subroutine). However, there is no easy way to duplicate the action of free to return space. Space allocation (the malloc subroutine) We need a mechanism to get the address of a block of bytes of a certain size. Warford's solution is to use as the heap the space immediately following the program in memory.... stop hpptr:.addrss heap heap:.block 1.end Visually Program hpptr: heap: Heap space allocated stack Comp 162 Notes Page 7 of 16 March 29, 2017

8 We use the malloc subroutine (without a parameter) to implement the C malloc mechanism: malloc: ldwx hpptr,d adda hpptr,d stwa hpptr,d ret ; Get current heap pointer; this is the address result ; Adding the space requested and the old hpptr ; gives us the new value of the hpptr Pre-conditions: Register A contains size of request in bytes Variable hpptr ( heap pointer ) points to the next free space. Post-conditions: Register X contains a pointer to the bytes allocated. Variable hpptr is advanced over the allocated space. Note that there is no check to see if we have tried to allocate space in use on the stack. In theory this is possible to add such a check because we can copy the SP into Register A and compare it with hpptr. In practice it is difficult because addresses are unsigned numbers. If we did determine that there was not enough free space above the stack we could return 0 in Register X like the C malloc returning NULL. Example trace The following trace of a sequence of high-level language declarations and statements and their Pep/9 equivalents. This example also introduces the 8 th and last addressing mode. Comp 162 Notes Page 8 of 16 March 29, 2017

9 High-level Language Pep/9 e.g. hpptr Register A Register X P Q int *P,*Q; P:.block 2 Q:.block P = malloc(8); ldwa 8,i call malloc stwx P,d Q = malloc(2); ldwa 2,i call malloc stwx Q,d *Q = 99; ldwa 99,i stwa Q,n 99 P[i] = 45; ldwa 45,i ldwx i,d aslx addx P,d stwa 0,x 45 i 2*i P + 2*i The last addressing mode in Pep/9 is indirect addressing. The designation means that the operand is Memory[Memory[operand ]],n Suppose variable Q is at address 300 and it contains the value 430. Suppose further that at location 430 is the word containing 47 Then Q,i is 300 Q,d is 430 Q,n is 47 Local pointers What if pointer variables are local? It turns out we just use an addressing mode we have seen before when the stack contains pointers. Consider the following example. Comp 162 Notes Page 9 of 16 March 29, 2017

10 int main() { int *A, *B, *C; A = malloc(4*sizeof(int)); B = malloc(sizeof(int)); C = malloc(sizeof(int)); } A[2] = 40; *C = 30; *B = 2 + *C; Assume that the stack is C B A main: subsp 6,i ; space for locals ; assignment to A ldwa 8,i ; size of request call malloc stwx 4,s ; address of array to A ; assignment to B ldwa 2,i call malloc stwx 2,s ; address of new int to B ; assignment to C ldwa 2,i call malloc stwx 0,s ; address of new int to C At this point we have Comp 162 Notes Page 10 of 16 March 29, 2017

11 C B A The assignments use modes we saw earlier ; assignment to A[2] ldwx 2,i ; index for array access aslx ; make it a byte offset ldwa 40,i ; the value to assign stwa 4,sfx ; put in element 2 of array pointed to from 4,s ; assignment to *C ldwa 30,i stwa 0,sf ; put 30 in element pointed to by 0,s ; assignment to *B ldwa 0,sf adda 2,i stwa 2,sf ; redundant statement because of previous instruction ; update location pointed to by B Summary of addressing modes We have now seen all eight of the Pep/9 addressing modes. The following page is an attempt to illustrate all of them on a single page by grouping them into three groups. Comp 162 Notes Page 11 of 16 March 29, 2017

12 Group 1 (i,d,n) These are basic modes Immediate, Direct and Indirect. Consider the following example: br main A:.addrss B B:.word 99 (3)A main: deco A,i deco A,d deco A,n (5)B stop.end 5 99 Output is : 3 value of A 5 contents of address A 99 contents of address that A points to Group 2 (s,sf,sx,sfx) These are the modes that involve the stack 0 s for simple items on the stack 2 sf for simple items pointed to from the stack 4 sx for arrays on the stack sfx for arrays pointed to from the stack 6 8 Following code prints from memory shown 10 deco 4,s ; 1 12 deco 0,sf ; 2 14 ldwx 4,i ; byte offset of 3 deco 6,sfx ; ldwx 6,i ; index of 4 in array in stack deco 10,sx ; Assume this is array Group 3 (x) Indexing: Base + register X The ith element of array of words M is at address M + 2 * i. Each of the following code fragments prints this element ldwx i,d aslx deco M,x ; i ; 2 * i ; output memory[m + 2*i] ldwx i,d addx i,d addx M,i deco 0,x ; i ; 2 * i ; M + 2 * i ; output memory[m + 2*i] Comp 162 Notes Page 12 of 16 March 29, 2017

13 Addressing mode costs At the microprogramming level, some addressing modes take longer to execute than others. Memory reads in particular take longer than additions. In the following table, modes are ranked in their probable order from slowest to fastest assuming a memory read takes longer than an addition. Mode Operand Memory Reads Additions sfx mem[mem[sp+op]+x] 2 2 sf mem[mem[sp+op]] 2 1 n mem[mem[op]] 2 0 sx mem[sp+op+x] 1 2 s mem[sp+op] 1 1 x mem[x+op] 1 1 d mem[op] 1 0 i op 0 0 Reading The last Pep/9 topic we cover is the implementation and manipulation of structures, particularly how they are used with heap storage. This is on pages Comp 162 Notes Page 13 of 16 March 29, 2017

14 Review Questions 1. In arrays A, B and C (each 100 bytes) are bitmaps that show the documents containing terms A, B and C respectively. Thus, for example bit I in B indicates if document I contains the term B. Write code that puts into array D (also 100 bytes) a bit map showing the documents that contain term A or term B but not term C. 2. Subroutine bitcount takes a word parameter (N) and returns the number of bits in N that are 1. Assuming the availability of this subroutine, write code that reports the number of documents in bitmap D of question We can detect when the heap is out of space by comparing heapptr with the SP register. Why is this difficult? 4. In Pep/9, addressing mode n is allowed with stro. Array days contains the names of the days of the week (padded out to 10 characters each) as follows days:.ascii "Monday\x00\x00\x00\x00".ascii "Tuesday\x00\x00\x00".ascii "Wednesday\x00".ascii "Thursday\x00\x00".ascii "Friday\x00\x00\x00\x00".ascii "Saturday\x00\x00".ascii "Sunday\x00\x00\x00\x00" Write code that inputs N and outputs the Nth day of the week using mode n. 5. If mode sfx were not available (but we could use the other 7 modes, how could we code the equivalent of ldwa 6,sfx 6. In Pep/8, mode sfx was named sxf. Why is the Pep/9 name more appropriate? Comp 162 Notes Page 14 of 16 March 29, 2017

15 Review Answers 1. ldwx 98,i ; offset of last word loop: ldwa C,x nota stwa -2,s ; not C lda A,x ora B,x ; A or B anda -2,s ; (A or B) and not C stwa D,x subx 2,i brge loop 2. ldwa 0,i stwa total,d ldwx 98,i loop: subsp 4,i ; for parameter and result of bitcount ldwa D,x stwa 0,s ; parameter is word from D call bitcount addsp 2,I ; get rid of parameter ldwa 0,s ; number of 1s adda total,d stwa total,d ; is added to total addsp 2,I ; and removed subx 2,i brge loop ; branch if more 3. The comparison needs to treat heapptr and SP as unsigned numbers. 4. The following uses indirect addressing deci N,d ldwa N,d asla stwa -2,s ; 2N asla ; 4N asla ; 8N adda -2,s ; 10N adda days,i ; days+10*n = address of start of string to output stwa P,d ; is stored in pointer P stro P,n ; output day name stop N:.block 2 P:.block 2 Comp 162 Notes Page 15 of 16 March 29, 2017

16 5. The following is one way addx 6,s ldwa 0,x 6. It better reflects the order of operations in calculating the operand address. For example, ldwa 4,sfx s: Mem[SP+ 4] f: Mem[Mem[SP + 4]] x: Mem[Mem[SP + 4] + X] Comp 162 Notes Page 16 of 16 March 29, 2017