Merge-sorting with the system stack as temporary storage

Transcription

1 Merge-sorting with the system stack as temporary storage M.H. van Emden Abstract Logic programming not only interprets positive Horn clauses as procedures, but also dictates the use of Prolog as the procedural programming language. We are interested in the possibility of expressing algorithms in Horn clauses, but selecting a procedural language other than Prolog. As example we use merge sort and develop C and C++ programs on the basis of the Horn clause version of merge sort. This may be more than an academic exercise. In the resulting code all auxiliary storage is in arrays local to recursive calls, so that their allocation and de-allocation happens automatically and eciently. 1 Introduction Merge-sorting was rst describing Mauchly in That makes it the oldest algorithm that is specic to computers as we understand them today. The idea of merge sort, stripped of all the complications necessary in other programming language, is most succinctly expressed in Prolog: 1 mrgsrt(v, W) :- 2 ( ((V = []; V = [X]) -> V = W) 3 ; ( split(v, V0, V1), 4 mrgsrt(v0, W0), mrgsrt(v1, W1), 5 merge(w0, W1, W) 6 ) 7 ). The following commentary explains. 1 To sort list V into list W 2 if V has at most one element, then copy V to W else 3 split V into V0 and V1 4 sort V0 into W0, sort V1 into W1 5 merge W0 and W1 into W 6 return W0 and W1 are temporarily needed storage. In Prolog the programmer does not need to allocate lists and cannot deallocate them; that is the task of the garbage collection system. This is just as well, because the recursive calls to sort need their own temporary storage so that a considerable number of temporary lists is created. The simplicity of the Prolog program can be reproduced in C++ with vectors from the standard library. W0 and W1 can be local to the recursive calls and are deallocated whenever a call, usually a recursive one, is exited. Still, even with the most sophisticated management system, use of the heap causes fragmentation, and fragmentation may occasionally have to be eliminated by reorganization. This suggests the use of arrays, were it not for the fact that C++ disallows dynamic arrays. We therefore switch to C. 1

2 2 Merge sorting arrays in C First we package arrays into vectors, a type named vec. See le merge.h: #include<stdio.h> typedef char T; typedef struct{ T* a; // pointer to first of array segment of length n int n; // length of the array vec; vec mkvec(t* a, int n); // Purpose: make vec from array a of length n. T* ndx(vec* v, int i); // Purpose: return pointer to the i-th element of v // Precondition: i within range of v. void copyvec(vec* v, vec* w); void printvec(vec* v); void merge(vec* in0, vec* in1, vec* out); The implementation is in merge.c: #include"merge.h" vec mkvec(t* a, int n) { // Purpose: make vec from array a of length n. vec v; v.a = a; v.n = n; return v; T* ndx(vec* v, int i) { return v->a + i; void copyvec(vec* v, vec* w) { for(int i=0; i < v->n; ++i) *ndx(w, i) = *ndx(v, i); void printvec(vec* v) { for (int i=0; i < v->n; ++i) printf("%c ", *((v->a)+i)); printf("\n"); void merge(vec* in0, vec* in1, vec* out) { int n0 = -1 + in0 -> n; int n1 = -1 + in1 -> n; int n = -1 + out -> n; while (n0 >= 0 && n1 >= 0) { if (*ndx(in0, n0) > *ndx(in1, n1)) { *ndx(out, n) = *ndx(in0, n0); --n0; else { *ndx(out, n) = *ndx(in1, n1); --n1; while (n0 >= 0) { *ndx(out, n) = *ndx(in0, n0); --n0; while (n1 >= 0) { *ndx(out, n) = *ndx(in1, n1); --n1; Now that vectors, their merging, and sundry auxiliary functions are taken care of, we can proceed to merge sort itself. File mrgsrt.h: #include"merge.h" void mrgsrt(vec* v, vec* w); The implementation is: 1 #include"mrgsrt.h" 2 3 void mrgsrt(vec* v, vec* w) { 2

3 4 if (v -> n <= 1) { copyvec(v, w); return; 5 int lenv = v -> n; 6 int len0 = lenv/2, len1 = lenv - len0; 7 vec v0 = mkvec(v->a, len0); 8 vec v1 = mkvec(v->a + len0, len1); 9 T a0[len0], a1[len1]; 10 vec w0 = mkvec(a0, len0); 11 vec w1 = mkvec(a1, len1); 12 mrgsrt(&v0, &w0); mrgsrt(&v1, &w1); 13 merge(&w0, &w1, w); 14 What is the basis of my claim that this is a transcription of the Prolog program? It is based on the following correspondence. Line 2 in Prolog corresponds to line 4 in C. Line 3 in Prolog splits the input list into two lists. This is done by a recursive Prolog program the way one would split a linked list. In C we take the opportunity of using arrays that allow splitting without traversing the input. In C the splitting is not encapsulated in a function; it happens in lines 5 { 8. The arrays are created in line 9. They are local to mrgsrt. Their lifetime is that of each recursive invocation of that function. They are allocated in line 9 and de-allocated on exit. Line 4 in Prolog corresponds to line 12 in C. Line 5 in Prolog corresponds to line 13 in C. For sorting an array of length n, the extra storage allocated is at most about (1 + 1=2 + 1=4 + 1=8 + )n; that is, at most about 2n for large n. Thus if amount of memory is a constraint, this algorithm is not an option. The advantage lies in the eciency of the allocation and de-allocation and the simplicity of the algorithm. Postscript Paul McJones was so kind to investigate whether the extra storage can be reduced to the minimum required for merge-sorting, namely n=2. He showed that this can be done by introducing a buer of this size once and to pass it to the recursive calls via an additional parameter. An example of this technique is: #include"mrgsrt.h" void mrgsrt1(vec* v, vec* w, vec* buf) { if (v -> n <= 1) { copyvec(v, w); return; int lenv = v -> n; int len0 = lenv/2, len1 = lenv - len0; vec v0 = mkvec(v->a, len0); vec v1 = mkvec(v->a + len0, len1); // input vector split vec w0 = mkvec(w->a, len0); vec w1 = mkvec(w->a + len0, len1); // output vector split vec u = mkvec(buf->a, len1); // segment of buffer; const length struct is local mrgsrt1(&v0, &w0, &w1); mrgsrt1(&v1, &u, &w1); merge(&w0, &u, &w1); void mrgsrt(vec* v, vec* w) { int lenbuf = (v -> n) - (v -> n)/2; T a[lenbuf]; // allocation for buffer done once vec buf = mkvec(a, lenbuf); mrgsrt1(v, w, &buf); Each recursive invocation allocates storage for ve structs. This takes a constant amount of storage and happens up to log n times. To speed up algorithms like quicksort and merge sort one can use a simpler algorithm such as selection sort for segments of length less than, say, 32. This would reduce the storage overhead for local structs by ve. 3

4 3 Merge sorting arrays in C++ Once one is used to C++ it hurts to have to invoke constructors explicitly. Fortunately compiler writers do not see any reason for disallowing dynamic arrays in C++. So if one is willing to brave some warnings, one can ignore the ban. 1 #include<iostream> 2 using namespace std; 3 4 typedef char T; 5 typedef unsigned nat; // natural number 6 7 class Seg { // segment of an array 8 public: 9 T* bgn; nat n; 10 Seg() { 11 Seg(T* bgn, nat n): bgn(bgn), n(n) { 12 void copy(seg& w) { 13 for (nat i=0; i<n; ++i) *(bgn+i) = *((w.bgn)+i); void print() { 16 for (nat i=0; i<n; ++i) cout << *(bgn+i) << " "; 17 cout << "\n"; ; 20 void merge(seg& w0, Seg& w1, Seg& w) { 21 int n0 = -1 + w0.n; int n1 = -1 + w1.n; 22 int n = -1 + w.n; 23 while (n0 >= 0 && n1 >= 0) { 24 if (*((w0.bgn)+n0) > *((w1.bgn)+n1)) { 25 *((w.bgn)+n) = *((w0.bgn)+n0); --n0; 26 else { 27 *((w.bgn)+n) = *((w1.bgn)+n1); --n1; while (n0 >= 0) { 32 *((w.bgn)+n) = *((w0.bgn)+n0); --n0; while (n1 >= 0) { 35 *((w.bgn)+n) = *((w1.bgn)+n1); --n1; void split(seg& v, Seg& v0, Seg& v1) { 39 nat n0 = (v.n)/2, n1 = (v.n) - (v.n)/2; 40 v0.bgn = v.bgn; v0.n = n0; 41 v1.bgn = v.bgn+n0; v1.n = n1; void sort(seg& v, Seg& w) { 44 if ((v.n) <= 1) { w.copy(v); return; 45 // sort([], []) and sort([x], [x]) 46 Seg v0, v1; split(v, v0, v1); 47 // split(v, v0, v1) 48 T a[v0.n], b[v1.n]; 49 Seg w0(a, v0.n), w1(b, v1.n); 50 // local storage 51 sort(v0, w0); sort(v1, w1); 52 // sort(v0, w0), sort(v1, w1) 53 merge(w0, w1, w); 54 // merge(w0, w1, w) int main() { 57 T a[] = "thequickbrownfxjmpsvlazydg"; 58 Seg v(a, -1+sizeof(a)/sizeof(a[0])); 59 T b[] = "xxxxxxxxxxxxxxxxxxxxxxxxxx"; 60 Seg w(b, -1+sizeof(b)/sizeof(b[0])); 61 sort(v, w); 62 w.print(); 63 In lines 43 through 55 the sort function is commented by the successive lines of the corresponding Prolog program. Note that occasionally a close match is obtained. 4

5 4 Conclusions The most succinct and elegant formulation of merge sort can be found in Prolog. In addition, the Prolog code suggests that the temporary storage needed by merge sort be made local to the recursive calls. However, it seems that this locality is not exploited by Prolog implementations. The suggestion by Prolog that temporary storage be made local is a welcome simplication for merge sort, and a novel suggestion as far as the author is concerned. We present an implementation in C that follows Prolog as closely as possible. C++ allows code to follow Prolog more closely, provided one is willing to sacrice portability by using the nonstandard dynamic arrays provided by the GNU C++ compiler. 5