Monday, October 24, 2016

Transcription

1 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 checking 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 14 October 24, 2016

2 Here is the call sum(t,60) in Pep/8 subsp 2,i ; for returned value subsp 4,i ; for parameters; lda T,i ; address of array sta 0,s ; is the first parameter lda 60,i ; count of elements sta 2,s ; is the second parameter call 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 ldx 0,s ; the local variable j in index register lda 2,s ; temp in Reg. A aslx ; index converted to byte offset adda 6,sxf ; add V[j] sta 2,s ; update temp Comp 162 Notes Page 2 of 14 October 24, 2016

3 The new mode (,sxf) is stack-indexed deferred 1. 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,sxf 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/8 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 sta 0,s ; array parameter lda 10,i sta 2,s ; size parameter call sum 1 To be consistent, this mode should really be sfx and will be renamed in this way in Pep/9. Comp 162 Notes Page 3 of 14 October 24, 2016

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/8 subroutine. Highlighted are the two instructions where the array address parameter is copied from the outer call to location used by a recursive call. Comp 162 Notes Page 4 of 14 October 24, 2016

5 quiksort: subsp 2,i lda 4,s cpa 6,s brge end subsp 8,i lda 12,s sta 0,s lda 14,s sta 2,s lda 16,s sta 4,s call partitio lda 6,s sta 8,s addsp 8,i subsp 6,i lda 10,s sta 0,s lda 6,s suba 1,i sta 2,s lda 14,s sta 4,s call quiksort lda 6,s adda 1,i sta 0,s lda 12,s sta 2,s call quiksort addsp 6,i end: ret2 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. mystro: lda 0,i ; clearing reg A to hold characters from string ldx 0,i ; string index loop: ldbytea 2,sxf ; char from string breq exit ; if null byte we are done charo 2,sxf ; otherwise output addx 1,i ; move to next br loop exit: ret0 Comp 162 Notes Page 5 of 14 October 24, 2016

6 Finally, here are two examples of C array-processing functions translated into Pep/8. 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/8 Local: i Ret. Addr.... N... The same value of register X is used to access both arrays so the Pep/8 is relatively straightforward copy: subsp 2,i ; for i ldx 0,i stx 0,s ; initialized to 0 top: cpx 8,s ; i<n? brge done ; no, we are finished aslx ; convert to byte offset lda 4,sxf ; ar1[i] sta 6,sxf ; ar2[i] = ar1[i] asrx ; convert back to index addx 1,i br top done: ret2 Comp 162 Notes Page 6 of 14 October 24, 2016

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/8 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 ldx 2,s aslx lda 6,sxf addx 2,i cpa 6,sxf brle skip sta 0,s lda 6,sxf subx 2,i sta 6,sxf lda 0,s addx 2,i sta 6,sxf 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 14 October 24, 2016

8 Note that three instructions just change the value in Register X. (This is a consequence of Pep/8 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/8 Version 2 Local: temp.local: i Ret. Addr N... Setting up the pointer is straightforward: lda 6,s adda 2,i sta -2,s Now the code for the if statement is shorter skip: ldx 2,s ; i aslx ; as byte offset lda 6,sxf ; ar[i] cpa -2,sxf ; compare with ar[i+1] brle skip ; skip if no swap sta 0,s ; temp = ar[i] lda -2,sxf ; ar[i+1] sta 6,sxf ; ar[i] = ar[i+1] lda 0,s ; temp sta -2,sxf ; 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 14 October 24, 2016

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 14 October 24, 2016

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/8) 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 14 October 24, 2016

11 Now the Pep/8 code to implement is K = Values[Row,Col] ldx Row,d ; the row number subx 1,i ; the row lower bound aslx ; make a byte offset ldx 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 lda 0,x ; get the element sta K,d ; and assign to K Here is a trace of Register X values for Row=3, Col=4 Reg. X 3 ldx Row,d ; the row number 2 subx 1,i ; the row lower bound 4 aslx ; as byte offset 616 ldx 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 ldx 0,x ; get the element stx 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 14 October 24, 2016

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 added in bold is ldx Row,d ; the row number cpx MinRow ; the row lower bound brlt Error cpx MaxRow ; the row upper bound brgt Error subx 1,i ; the row lower bound aslx ; as byte offset ldx M,x ; get element from array of pointers and put in Reg. X ; this is pointer to row Row lda Col,d cpa MinCol ; column lower bound brlt Error ; if Col < lower bound cpa 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 lda 0,x ; get the element sta 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 14 October 24, 2016

13 Identifying the locations of the non-zero values. Now accessing and updating functions are written in terms of this list. 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 297 in the book. Review Questions 1. We have a Pep/8 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? 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? Comp 162 Notes Page 13 of 14 October 24, 2016

14 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. Comp 162 Notes Page 14 of 14 October 24, 2016