Wednesday, March 14, 2018

Size: px

Start display at page:

Download "Wednesday, March 14, 2018"

Rosalyn Hill
6 years ago
Views:

1 Wednesday, March 14, 2018 Topics for today Arrays and Indexed Addressing Arrays as parameters of functions Multi-dimensional arrays Option A: Space-minimal solution Option B: Iliffe vectors Array bound checking Arrays: special cases Memo functions Arrays as parameters of functions We need to be able to translate functions that have arrays as parameters. This is not such a big leap because we already know how to pass scalars by reference and we can think of a scalar as being an array of size 1. When we pass an array as parameter we pass it by reference; we put its address on the stack. Separately, we typically have to pass its size (or at least the number of elements we need to process). This is what we have to do in most high-level languages also. For example, here is a C function for adding up the first N elements of an array. int sum (int V[], int N) { int j,temp = 0; for (j=0; j<n; j++) temp += V[j]; } return temp; If we have int T[320]; global array then the following are typical calls of sum total = sum(t,60); // address of array and number of elements to process all = sum(t,320); first = sum(t,1); Comp 162 Notes Page 1 of 15 March 14, 2018

2 Here is the call sum(t,60) in Pep/9 subsp subsp ldwa stwa ldwa stwa call 2,i ; for returned value 4,i ; for parameters; T,i ; address of array 0,s ; is the first parameter 60,i ; count of elements 2,s ; is the second parameter sum After sum creates space for local variables j and temp, the stack looks like j temp Return Address Address of T For return value To access the elements of the array parameter we combine two ideas we have already seen deferred addressing (we saw this when looking at "pass by reference") indexing (we saw this when accessing global and local arrays). The body of our function is for (j=0; j<n; j++) temp += V[j]; The assignment to temp translates to ldwx 0,s ; the local variable j in index register ldwa 2,s ; temp in Reg. A aslx ; index converted to byte offset adda 6,sfx ; add V[j] stwa 2,s ; update temp Comp 162 Notes Page 2 of 15 March 14, 2018

3 The new mode (,sfx) is stack-deferred indexed. The operand is memory[ memory [operand + SP] + register X ] It is used when the stack contains a pointer to an array. The operand indicates how far down the stack the pointer to the array is. The contents of Register X are used (as usual) to index within the array. Thus in the case of adda 6,sfx We are accessing the array that is pointed to from the word 6 bytes down from the top of the stack (below the local variables and return address) and using register X to select a particular element within the array, that is memory[ memory [6 + SP] + register X ] As far as our function sum is concerned it makes no difference whether the array being passed is global or local as long as the stack contains a pointer to the place where the array is stored. In the former case the array is stored in the global area in the latter case it is stored on the stack but in each case we are just passing an address. More on arrays as parameters (1) Local array Here is an example of a call where the parameter is a local array void A() { int numbers[10]; int X,Y,Z; } X = sum(numbers,10); The only difference between this and the previous example is the calling environment and how the pointer to the array is figured out. We use the movspa instruction just as we did when passing local scalars by reference. Here is this call of sum in Pep/9 movspa ; save address of top of stack subsp 2,i ; for returned value subsp 4,i ; for parameters adda 6,i ; address of array numbers is 6 greater than old top of ; stack i.e. beyond space for X, Y and Z stwa 0,s ; array parameter ldwa 10,i stwa 2,s ; size parameter call sum Comp 162 Notes Page 3 of 15 March 14, 2018

4 Pictorially: Pointer to numbers (2 bytes) 10 (2 bytes) 00 0A Space for returned value (2 bytes) Z (2 bytes) Saved SP value Y (2 bytes) X (2 bytes) Array numbers (not all shown) (20 bytes) (2) Array parameter from an outer call Consider quicksort, a recursive sorting algorithm. In C, the implementation might be void quicksort (int first, int last, int AR[]) { int P; if (first<last) { P = partition(first,last,ar); quicksort(first,p-1,ar); quicksort(p+1,last,ar); } } The following is an implementation of this function as a Pep/9 subroutine. Highlighted are the three instances where the array address parameter is copied from the outer call to location used by a recursive call or call to partition. Comp 162 Notes Page 4 of 15 March 14, 2018

5 quiksort: subsp 2,i ldwa 4,s cpwa 6,s brge end subsp 8,i ldwa 12,s stwa 0,s ldwa 14,s stwa 2,s ldwa 16,s stwa 4,s call partitio ldwa 6,s stwa 8,s addsp 8,i subsp 6,i ldwa 10,s stwa 0,s ldwa 6,s suba 1,i stwa 2,s ldwa 14,s stwa 4,s call quiksort ldwa 6,s adda 1,i stwa 0,s ldwa 12,s stwa 2,s call quiksort addsp 6,i end: addsp 2,i ret Our own stro If there were no stro instruction, the following subroutine could be used to output a null-terminated string with address passed as parameter (but note how registers A and X may be changed by the subroutine more on this later). mystro: ldwa 0,i ; clearing reg A to hold characters from string ldwx 0,i ; string index loop: ldba 2,sfx ; char from string breq exit ; if null byte we are done stba charout,d ; otherwise output addx 1,i ; move to next br loop exit: ret Comp 162 Notes Page 5 of 15 March 14, 2018

6 Finally, here are two examples of C array-processing functions translated into Pep/9. Example 1: copies N elements from one array to another. C void copy (int ar[1], int ar2[], int N) { int i; for (i=0; i<n; i++) ar2[i] = ar1[i]; } Pep/9 Local: i Ret. Addr.... N... The same value of register X is used to access both arrays so the Pep/9 is relatively straightforward copy: subsp 2,I ; for i ldwx 0,i stwx 0,s ; initialized to 0 top: cpwx 8,s ; i<n? brge done ; no, we are finished aslx ; convert to byte offset ldwa 4,sfx ; ar1[i] stwa 6,sfx ; ar2[i] = ar1[i] asrx ; convert back to index addx 1,i br top done: addsp 2,i ret Comp 162 Notes Page 6 of 15 March 14, 2018

7 Example 2: partial sort of an N-element array. The function partsort makes a pass through the array exchanging out-of-order neighbors. C void partsort(int ar[], int N) { int i,temp; } for (i=0; i<n-1; i++) if (ar[i]>ar[i+1]) { temp = ar[i]; ar[i]=ar[i+1]; ar[i+1]=temp; } Pep/9 Version 1 Local: temp Local: i Ret. Addr N... The relevant part of our example is the if statement which, given the stack above, translates to ldwx 2,s aslx ldwa 6,sfx addx 2,i cpwa 6,sfx brle skip stwa 0,s ldwa 6,sfx subx 2,i stwa 6,sfx ldwa 0,s addx 2,i stwa 6,sfx skip: ; i ; as byte offset ; ar[i] ; compare with ar[i+1] ; skip if no swap ; temp = ar[i] ; ar[i+1] ; ar[i] = ar[i+1] ; temp ; ar[i+1] = temp Comp 162 Notes Page 7 of 15 March 14, 2018

8 Note that three instructions just change the value in Register X. (This is a consequence of Pep/9 having only a single index register.) One way to eliminate these changes (and thus make the program run faster) is to have a second pointer to the array. The pointer is stored in the scratch space above the top of the stack and points not to the first element of the array but to the second thus: Pep/9 Version 2 Local: temp.local: i Ret. Addr N... Setting up the pointer is straightforward: ldwa 6,s adda 2,i stwa -2,s Now the code for the if statement is shorter skip: ldwx 2,s ; i aslx ; as byte offset ldwa 6,sfx ; ar[i] cpwa -2,sfx ; compare with ar[i+1] brle skip ; skip if no swap stwa 0,s ; temp = ar[i] ldwa -2,sfx ; ar[i+1] stwa 6,sfx ; ar[i] = ar[i+1] ldwa 0,s ; temp stwa -2,sfx ; ar[i+1] = temp We have added three instructions at the top of the subroutine to set up the pointer but shorted the then part of the if statement by three instructions. So the space required by this version of the subroutine is the same as the earlier one. However, if the array is large and many swaps are made we would expect our new version to run faster. Comp 162 Notes Page 8 of 15 March 14, 2018

9 Storage and manipulation of multi-dimensional arrays We need multi-dimensional arrays for representing matrices, chessboards, spreadsheets, timetables and so on. There are two main ways in which we can organize their storage. There is somewhat of a trade-off between space and time Option A: single contiguous block Store the array elements systematically in a single block either row-by-row or column-by-column. Suppose our array is declared as follows Values: array[1..3, 2..5] of integer; [ Some languages, e.g., Pascal, let us have non-zero lower bounds.] The contents are Row-by-row it is stored Column-by-column it is stored What is the address of element Values[i,j] (given that both i and j are in bounds)? For our example: Row-by-row mapping: the element is found at Values + 2 * ( (i-1) * 4 + (j-2)) [ In general at : Base-address + element-size * ((row_number row_lower_bound) * row_size + column_number - column_lower_bound) ] Column-by-column mapping: the element is found at Values + 2 * ((j-2) * 3 + (i-1)) For example, Values[3,4] is at M+20 in a row-by-row mapping and at M+16 in a column-bycolumn mapping. Comp 162 Notes Page 9 of 15 March 14, 2018

10 Many systems will store and access multi-dimensional arrays in this way because a MULTIPLY instruction is usually available to compute element addresses. But MULTIPLY is often a timeconsuming operation and some machines (e.g., Pep/9) may not have a multiply instruction so we need to look at another way to store and access multi-dimensional arrays. Option B: using Iliffe vectors We can devise a storage scheme that uses pointers instead of multiplication. Access may be faster than the multiply method although requiring more space (another example of trading time for space). Assume we store the array row by row (ideas are similar if it is stored column by column). Our method works by using an array of pointers to the array. This array of pointers is called an Iliffe vector (after J. K. Iliffe who proposed its use). Each pointer in the Iliffe vector points to the beginning of a row of the actual array. We label the Iliffe vector with the name of the array. In the following depiction of our array Values stored in this way we assume that the actual array starts at location 600 and the Iliffe vector starts at location 300. Note that there is no requirement for the rows to be adjacent in memory or even the same size. Values Comp 162 Notes Page 10 of 15 March 14, 2018

11 Now the Pep/9 code to implement is K = Values[Row,Col] ldwx Row,d ; the row number subx 1,i ; the row lower bound aslx ; make a byte offset ldwx Values,x ; get element from array of pointers and put in Reg. X ; this is pointer to row Row addx Col,d ; add 2 times addx Col,d ; Col subx 4,i ; and subtract 2* column lower bound ; so reg X now has address of element we need ldwa 0,x ; get the element stwa K,d ; and assign to K Here is a trace of Register X values for Row=3, Col=4 Reg. X 3 ldwx Row,d ; the row number 2 subx 1,i ; the row lower bound 4 aslx ; as byte offset 616 ldwx Values,x ; get element from array of pointers and put in Reg. X ; this is pointer to row Row 620 addx Col,d ; add 2 times 624 addx Col,d ; Col 620 subx 4,i ; and subtract 2* column lower bound ; so reg X now has address of element we need 30 ldwx 0,x ; get the element stwx K,d ; and assign to K C uses this method to store arrays. Advantages of the pointer method compared with the multiplication method include: (1) may be faster (2) storage for different rows of the actual array need not be adjacent (3) rows need not be the same length! Can have triangular and irregular arrays. We can extend the technique to higher number of dimensions with additional Iliffe vectors. Comp 162 Notes Page 11 of 15 March 14, 2018

12 Array bound checking Adding bound checking to either the multiplication method or the pointer-based method typically adds three or more instructions per dimension for each array access. The Option B code with checking highlighted is ldwx Row,d ; the row number cpwx MinRow ; the row lower bound brlt Error cpwx MaxRow ; the row upper bound brgt Error subx 1,i ; the row lower bound aslx ; as byte offset ldwx M,x ; get element from array of pointers and put in Reg. X ; this is pointer to row Row ldwa Col,d cpwa MinCol ; column lower bound brlt Error ; if Col < lower bound cpwa MaxCol brgt Error ; if Col > upper bound addx Col,d ; add 2 times addx Col,d ; subx 4,i ; subtract twice lower bound ; so reg X now has address of element we need ldwa 0,x ; get the element stwa K,d ; and assign to K Because it makes the program larger and slower, perhaps bound checking should be a compiler option. Special arrays: special access techniques (a) triangular arrays If a matrix is symmetric (M[i][j] = M[j][i]) we need only store half of it, for example elements M[i[[j] where j i. Storing the (variable-length) rows in adjacent memory locations: M[0][0] M[1][0] M[1][1] M[2][0] M[2][1] and so on the address of M[i][j] is M + (i+1)(i)/2 + j (b) sparse arrays If a large number of elements in an array (e.g., >90%) are zero, there may be ways to represent the contents in a more space-efficient manner. For example, we could store a list of triples (row, column, value) Comp 162 Notes Page 12 of 15 March 14, 2018

13 Identifying the locations of the non-zero values. Now accessing and updating functions are written in terms of this list. Memo functions A memo function is one that remembers (in some data structure) parameter-result pairs. If it is called again with the same parameter, it can recall the previous result to save recomputation. We might imagine such a function having N integer parameters saving the results in an N-dimensional array. The Fibonacci series can be computer, very inefficiently, using a recursive function: Fib(N) = if N=0 or N=1 then 1 else Fib(N-1)+Fib(N-2) Consider calculating Fib(20). Fib(20)=Fib(19)+Fib(18) = Fib(18)+Fib(17)+Fib(17)+Fib(16) The following table shows, the number of calls of Fib required to compute Fib(N) ( for N from 17 to 21) and the number of calls of memfib (a memoised version that saves computed values in an array. N Fib(N) Calls of fib Calls of memfib Reading Warford does not cover multi-dimensional arrays. Next we will look at how a switch statement can be implemented using an array. This starts on page 350 in the book. Comp 162 Notes Page 13 of 15 March 14, 2018

14 Review Questions 1. We have a Pep/9 subroutine CLEARA that takes two parameters: Address of an integer array (A) An integer N. A call to CLEARA sets the first N elements of A to zero. In our program we have X:.block 60 Y:.block 60 Intending to clear X, we call CLEARA with parameters X and 60. What happens to Y? 2. We have an integer matrix M with 30 rows and 30 columns. (a) how many bytes does M occupy? (b) The matrix is symmetric: M[i][j] = M[j][i]. What is the fewest number of elements we need to store to eliminate duplicates? 3. Consider M from question 2. We decide to store M[i][j] where i j. How can we calculate the address of M[i][j]? 4. We have seen that having a null-byte terminator in a character array (string) means we can just pass the string address to string handling subroutines no need for a second length parameter. Can we do the same for integer arrays? 5. A 100-byte ASCII string followed by a null byte is at label S. How can we replace all the non-null characters with spaces using fewer than 100 iterations of a loop? 6. Mode sfx in Pep/9 was called sxf in Pep/8. If mode sxf were added to Pep/9 how should it be interpreted? Comp 162 Notes Page 14 of 15 March 14, 2018

15 Review Answers 1. X has 30 integers (60 bytes) so CLEARA continues past the end of X and clears Y also. 2. (a) 1800 (b) 1 element from row 1, 2 from row 2, 30 from row 30 = If we store elements of M in this order M0,0, M0,1, M1,1, M0,2, M1,2, M2,2, then Mi,j is at M + 2 * [ i + j*(j+1) ] 4. Not in general. There is no integer that would be a universal terminator. 5. Treat the string as 50 words and loop assigning integer 0x2020 to each word. 6. It would let us access an item pointed to from an element of a local array. First the CPU would evaluate,sx to get the array element then follow the pointer to the item. Comp 162 Notes Page 15 of 15 March 14, 2018

Monday, October 24, 2016

Monday, October 24, 2016 Topics for today Arrays and Indexed Addressing Arrays as parameters of functions Multi-dimensional arrays Option A: Space-minimal solution Option B: Iliffe vectors Array bound