CbC/old/device: mc-codegen.c comparison

comparison mc-codegen.c @ 296:284aa4eaab0d

case merge for cascade, table.

author	kono
date	Sun, 06 Jun 2004 02:40:32 +0900
parents	2437a94a1538
children	0f79c95df73a

comparison

equal deleted inserted replaced

-:2437a94a1538
+:284aa4eaab0d
 // cslist is already sorted
 delta = 0;
 list = list4(cslist,0,1,list3(0,car(cslist) /* min */,0));
 count=1;
 for(p=0;cadr(cslist);cslist = cadr(cslist),count++) {
+// compute new delta
 	delta1 = car(cadr(cslist))-car(cslist);
+// empty case
 	if (!caddr(cslist)) count--;
 	if (delta==0) {
+// 2nd element
 	    caddr(list) = delta = delta1;
 	    if (p) cadr(p)=0;  // terminate previous chunk
 	} else if (delta1!=delta) {
 	    // not contiguous, start new list
 	    caddr(cadddr(list)) = car(cslist);      // max
 	    car(cadddr(list)) = count; count=0;
 delta = 0;
 	    list = list4(cadr(cslist),list,1,list3(0,0,0));
 	    cadr(cadddr(list)) = car(cadr(cslist)); // min
+// prepare terminate point for next turn
 	    p=cslist;
 	}
 }
 if (p) cadr(p)=0;  // terminate previous chunk
 car(cadddr(list)) = count;
 caddr(cadddr(list)) = car(cslist);   // max
 return list;
 }
-#define CASE_MERGE_RATE 80
+#define CASE_MERGE_RATE 70
-/*
-rate = (sum count(c_i))/(max-min)
-list3(count,min,max)
-*/
 static int gcd(int i,int j)
 {
 int k;
 if (i<j) { k=i; i=j; j=k;}
 int
 merge_chunk_p(int *delta,int max,int min,int *count,int delta1,int count1)
 {
 int range = max-min;
 int g;
+// compute possible merge delta
 g = gcd(*delta,delta1);
 g = gcd(g,range);
 range /= g;
 *count = count1 = count1+*count;
 *delta = g;
 #if 1
-printf("# min %d, max %d, count %d, delta %d, rate %g t=%d\n",
+if (count1*128>(range*128*CASE_MERGE_RATE/100)) {
-	min,max,count1,g,
+	printf("# min %d, max %d, count %d, delta %d, rate %g t=%d\n",
-	     ((double)count1)*100.0/range,
+	    min,max,count1,g,
-count1*128>(range*128*CASE_MERGE_RATE/100)
+		 ((double)count1)*100.0/range,
-);
+	       count1*128>(range*128*CASE_MERGE_RATE/100)
-#endif
+	);
+}
+#endif
+//    count/((max-min)/delta) > 0.8
 return count1*128>(range*128*CASE_MERGE_RATE/100);
 }
 /*
 merge possible chunk
 input:  list4(cslist,next,delta,list3(count,min,max))
-output: list3(continuous number of chunk,next,delta);
+output: list3(continuous number of chunk,next,delta,case_count);
 */
 static int
 merge_chunk(int cslist)
 {
 int list = cslist;
 int tail,last,max,min,i;
-int count,p,widest,delta=1;
+int count,c_count,p,widest,delta=1;
 int chunks = 0;
 while(cadr(list)) {
 	p = cadddr(list);
-	count = car(p); max=caddr(p);
+	c_count = count = car(p); max=caddr(p);
 	widest = 1; last = list;
 	delta = caddr(list);
+// check possible merge against the end of the chunks
 	for(i=1,tail=cadr(list);cadr(tail); tail=cadr(tail),i++) {
 	    p = cadddr(tail);
 	    min = cadr(p);
 	    if (merge_chunk_p(&delta,max,min,&count,caddr(tail),car(p))) {
-		widest = i+1; last = tail;
+// It is mergeable.
+		widest = i+1; last = tail; c_count=count;
 	    }
 	}
-	chunks = list3(widest,chunks,delta);
+	chunks = list4(widest,chunks,delta,c_count);
+// skip merged chunks
 	list = cadr(last);
 }
-if (list) chunks = list3(1,chunks,delta);
+// last one can remain.
-return reverse0(chunks);
+if (list) chunks = list4(1,chunks,caddr(list),car(cadddr(list)));
-}
+return chunks;
+}
-static void
-table_jump(int cslist)
+static int
-{
+table_jump(int count,int delta,int cslist)
-for(;cslist; cslist=cadr(cslist)) {
+{
-	if (caddr(cslist))
+int list;
-	    cmpdimm(car(cslist),csvalue1,caddr(cslist),0);
+for(;count-->0;cslist=cadr(cslist)) {
-}
+	list = car(cslist);
-}
+	printf("# table cases delta=%d count=%d min=%d max=%d\n",
+		caddr(cslist),car(cadddr(cslist)),
-static void
+				cadr(cadddr(cslist)),caddr(cadddr(cslist))
-cascade_compare(int cslist)
+		);
-{
+	for(;list; list=cadr(list)) {
-for(;cslist; cslist=cadr(cslist)) {
+	    if (caddr(list))
-	if (caddr(cslist))
+		cmpdimm(car(list),csvalue1,caddr(list),0);
-	    cmpdimm(car(cslist),csvalue1,caddr(cslist),0);
+	}
 }
+return cslist;
+}
+static int
+cascade_compare(int count,int cslist)
+{
+int list;
+for(;count-->0;cslist=cadr(cslist)) {
+	list = car(cslist);
+	printf("# cascade cases delta=%d count=%d min=%d max=%d\n",
+		caddr(cslist),car(cadddr(cslist)),
+				cadr(cadddr(cslist)),caddr(cadddr(cslist))
+		);
+	for(;list; list=cadr(list)) {
+	    if (caddr(list))
+		cmpdimm(car(list),csvalue1,caddr(list),0);
+	}
+}
+return cslist;
 }
 #define CASE_TABLE_COUNT 10
 void
 chunks++;
 }
 j = chunks;
 #endif
 chunks = merge_chunk(cslist);
-#if 1
+#if 0
 //  chunks: list3(widest,next,delta);
 printf("# chunks %d = sum ",j);
 j = 0;
 for(i=chunks;i;i=cadr(i)) {
 	printf(" %d/%d",car(i),caddr(i));
 	j+=car(i);
 }
 printf(" sum = %d\n",j);
 #endif
 fwddef(cslabel);
-for(;cslist;cslist=cadr(cslist)) {
+cslist = reverse0(cslist);
-	printf("# case chunk delta=%d count=%d min=%d max=%d\n",
+for(;chunks;chunks=cadr(chunks)) {
-		caddr(cslist),car(cadddr(cslist)),
+	printf("# chunk count %d delta %d c_count %d\n",
-				cadr(cadddr(cslist)),caddr(cadddr(cslist))
+		car(chunks),caddr(chunks),cadddr(chunks));
-		);
+	if (cadddr(chunks)>CASE_TABLE_COUNT)
-	if (cadddr(cslist)>CASE_TABLE_COUNT)
+	    cslist = table_jump(car(chunks),caddr(chunks),cslist);
-	    table_jump(car(cslist));
 	else
-	    cascade_compare(car(cslist));
+	    cslist = cascade_compare(car(chunks),cslist);
 }
 if (dlabel) jmp(dlabel);
 }
 #endif

Mercurial > hg > CbC > old > device

comparison mc-codegen.c @ 296:284aa4eaab0d