TempleOSTS_140317.ISO

Demo/MultiCore/Clouds.CPP

@@ -0,0 +1,209 @@
+//This uses $LK,"fixed-point",A="FI:::/Demo/Lectures/FixedPoint.CPP"$.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+$SP,"<1>",BI=1,BP="::/Demo/Graphics/Camp.CPP.Z,Mountain"$ //Pointer to sprite in Camp.CPP.Z file
+
+#define NUM_CLOUDS		16
+#define SKY_LINES		30
+#define CLOUD_PTS		512
+#define CLOUD_PENS		8
+#define CLOUD_PEN_PTS	16
+#define CLOUD_PEN_SIZE		16
+
+class Cloud
+{
+  I64 i,x,y,w,h,dx,dy;
+  I64 color;
+  I64 px[CLOUD_PTS],py[CLOUD_PTS],pc[CLOUD_PTS];
+} clouds[NUM_CLOUDS];
+
+class CloudPen
+{
+  CDC *img;
+  I64 px[CLOUD_PEN_PTS],py[CLOUD_PEN_PTS];
+} cloud_pens[CLOUD_PENS];
+
+CDC *cloud_pen;
+
+I64 mp_not_done_flags;
+U0 MPDrawClouds(CTask *task)
+{
+  Cloud *c;
+  CDC *dc=DCAlias(gr_dc2,task);
+  I64 i,j,k,xx,yy,lo=Gs->num*CLOUD_PTS/mp_cnt,hi=(Gs->num+1)*CLOUD_PTS/mp_cnt;
+
+  for (j=0,c=clouds;j<NUM_CLOUDS;j++,c++)
+    for (i=lo;i<hi;i++) {
+      k=c->pc[i];
+      if (k<c->color)
+	dc->color=ROP_MONO+LTGRAY;
+      else
+	dc->color=ROP_MONO+WHITE;
+      xx=c->x.i32[1]+c->px[i];
+      yy=c->y.i32[1]+c->py[i];
+
+      k=RandU16&31-16;
+      if (k==-16)
+	k=-c->px[i];
+      c->px[i]+=SignI64(k);
+
+      k=RandU16&31-16;
+      if (k==-16)
+	k=-c->py[i];
+      c->py[i]+=SignI64(k);
+
+      GrBlot(dc,xx,yy,cloud_pens[i&(CLOUD_PENS-1)].img);
+    }
+  DCDel(dc);
+  LBtr(&mp_not_done_flags,Gs->num);
+}
+
+U0 DrawIt(CTask *task,CDC *dc)
+{
+  I64 i;
+  Sprite3(dc,0,SKY_LINES*FONT_HEIGHT,0,$IB,"<1>",BI=1$);
+  mp_not_done_flags=1<<mp_cnt-1;
+  for (i=0;i<mp_cnt;i++)
+    JobQue(&MPDrawClouds,task,i);
+  while (mp_not_done_flags)
+    Yield;
+}
+
+U0 AnimateTask(I64)
+{
+  I64 i,j;
+  Cloud *c;
+  CloudPen *cp;
+  while (TRUE) {
+    WinMgrSync;
+
+    for (i=0,cp=cloud_pens;i<CLOUD_PENS;i++,cp++) {
+      DCClear(cp->img);
+      cp->img->color=COLOR_MONO;
+      for (j=0;j<CLOUD_PEN_PTS;j++) {
+	GrPlot(cp->img,cp->px[j],cp->py[j]);
+	cp->px[j]=ClampI64(cp->px[j]+RandU16%3-1,0,CLOUD_PEN_SIZE-1);
+	cp->py[j]=ClampI64(cp->py[j]+RandU16%3-1,0,CLOUD_PEN_SIZE-1);
+      }
+    }
+
+    for (i=0,c=clouds;i<NUM_CLOUDS;i++,c++) {
+      c->x+=c->dx;
+      c->y=ClampI64(c->y+c->dy,0,0.7*(SKY_LINES*FONT_HEIGHT)<<32);
+      c->color=MAX_U16*c->y.i32[1]/(0.8*(SKY_LINES*FONT_HEIGHT));
+    }
+
+    Sleep(20);
+  }
+}
+
+#define SAMPLES	6
+U0 Init()
+{
+  Cloud *c=clouds;
+  CloudPen *cp=cloud_pens;
+  I64 i,j,k,l,
+     w=Fs->pix_width,
+     h=SKY_LINES*FONT_HEIGHT;
+
+  for (i=0;i<NUM_CLOUDS;i++,c++) {
+    c->x=ToI64(w/2+Rand*w/2-w/4)<<32;
+    c->y=ToI64(h/2+Rand*h/2-h/4)<<32;
+    c->dx=RandI32;
+    c->dy=RandI32;
+    c->w=100;
+    c->h=50;
+    c->color=RandU16;
+    for (l=0;l<CLOUD_PTS;l++) {
+      k=0;
+      for (j=0;j<SAMPLES;j++)
+	k+=RandI16;
+      c->px[l]=(k*c->w/MAX_I16)/SAMPLES;
+
+      k=0;
+      for (j=0;j<SAMPLES;j++)
+	k+=RandI16;
+      c->py[l]=(k*c->h/MAX_I16)/SAMPLES;
+
+      c->pc[l]=RandU16;
+    }
+  }
+
+  for (i=0;i<CLOUD_PENS;i++,cp++) {
+    cp->img=DCNew(CLOUD_PEN_SIZE,CLOUD_PEN_SIZE);
+    for (j=0;j<CLOUD_PEN_PTS;j++) {
+      cp->px[j]=RandU16%CLOUD_PEN_SIZE;
+      cp->py[j]=RandU16%CLOUD_PEN_SIZE;
+    }
+  }
+}
+
+U0 CleanUp()
+{
+  I64 i;
+  CloudPen *cp=cloud_pens;
+  for (i=0;i<CLOUD_PENS;i++,cp++)
+    DCDel(cp->img);
+}
+
+U0 SongTask(I64)
+{ //Song by the Holy Spirit
+//This specifies a callback routine
+//to be called when the task dies.
+  Fs->task_end_cb=&SndTaskEndCB;
+  MusicSettingsRst;
+  while (TRUE) {
+    Play("3qBetDA2G3qD2sG3E2G3EetCEDqFEeDC");
+    Play("qBetDA2G3qD2sG3E2G3EetCEDqFEeDC");
+    Play("CGqDeADsDCDCqGEetDAD2sG3D2G3D");
+    Play("eCGqDeADsDCDCqGEetDAD2sG3D2G3D");
+  }
+}
+
+U0 CloudScene()
+{
+  SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$
+  try {
+    Fs->text_attr=YELLOW<<4+BLUE;
+    Fs->song_task=Spawn(&SongTask,NULL,"Song",,Fs);
+    DocCursor;
+    WinMax;
+    WinBorder;
+    WordStat;
+    Init;
+    Fs->animate_task=Spawn(&AnimateTask,NULL,"Animate",,Fs);
+
+    DocClear;
+    "$$BG,LTCYAN$$"; NewLine(SKY_LINES);
+    "$$BG,YELLOW$$"; NewLine(5);
+    BibleVerse(,"Exodus,14:19",7);
+
+    Preempt(OFF);
+    Fs->draw_it=&DrawIt;
+    GetChar;
+    WinMgrSync;
+  } catch
+    PutExcept;
+  SettingsPop;
+  CleanUp;
+}
+
+//This is so I can use this file stand alone
+//or as a component of a program.
+#if IncludeDepth<2
+CloudScene;
+#endif

Demo/MultiCore/Interrupts.CPP

@@ -0,0 +1,24 @@
+interrupt U0 BeepOn()
+{
+  *LAPIC_EOI(U32 *)=0; //signal end of interrupt
+  Snd(100);
+}
+
+interrupt U0 BeepOff()
+{
+  *LAPIC_EOI(U32 *)=0;
+  Snd(0);
+}
+
+U0 IntTest()
+{
+  //Modify interrupt descriptor table
+  //for CPU #1.
+  IntEntrySet(I_USER,&BeepOn,IDTET_TRAP);
+  IntEntrySet(I_USER+1,&BeepOff,IDTET_TRAP);
+  MPInt(I_USER,1);
+  Sleep(1000);
+  MPInt(I_USER+1,1);
+}
+
+IntTest;

Demo/MultiCore/LoadTest.CPP

@@ -0,0 +1,51 @@
+Bool app_done;
+I64 app_done_ack;
+
+U0 Job1(I64)
+{ //Compile Compiler
+  Preempt(ON);	 //Off by default
+  Silent(ON);
+  while (!app_done) {
+    Cd("::/Compiler");
+    Cmp("Compiler");
+  }
+  lock {app_done_ack--;}
+}
+
+U0 Job2(I64)
+{ //Log a file
+  Preempt(ON);	 //Off by default
+  while (!app_done) {
+    AdamLog("%F","::/Demo/MultiCore/LoadTest.CPP");
+    Yield;
+  }
+  lock {app_done_ack--;}
+}
+
+U0 Job3(I64)
+{ //Log a file
+  Preempt(ON);	 //Off by default
+  while (!app_done) {
+    Cd("::/Compiler");
+    AdamLog("%F","Compiler.PRJ.Z");
+    Yield;
+  }
+  lock {app_done_ack--;}
+}
+
+U0 Main()
+{
+  app_done=FALSE;
+  "Running MultiCore Test...\n";
+  Spawn(&Job1,,,1); //core #1
+  Spawn(&Job2,,,1);
+  Spawn(&Job3,,,1);
+  PressAKey;
+//We don't want to yank code from under MP cores.
+  app_done_ack=3;
+  app_done=TRUE;
+  while (app_done_ack)
+    Yield;
+}
+
+Main;

Demo/MultiCore/Lock.CPP

@@ -0,0 +1,56 @@
+/*
+  lock{} is a compiler statement
+  which places asm LOCK instruction
+  prefixes on code.  Only use it on
+  read-modify-write statements.
+  It will generate invalid instructions
+  if you misuse it and it will crash.
+  $LK,"U",A="MN:U"$() to see what code was generated.
+*/
+
+#define CNT	0x1000000
+
+I64 glbl;
+
+
+U0 MPUnlockedInc(I64)
+{
+  I64 i;
+  for (i=0;i<CNT;i++)
+    glbl++;
+}
+
+U0 UnlockedInc()
+{
+  CSrvCmd *tempm0,*tempm1;
+  glbl=0;
+  tempm0=JobQue(&MPUnlockedInc,NULL,0,0);
+  tempm1=JobQue(&MPUnlockedInc,NULL,1,0);
+  GetResult(tempm0);
+  GetResult(tempm1);
+  "Correct Cnt:%X Actual Cnt:%X\n",CNT*2,glbl;
+}
+
+
+
+U0 MPLockedInc(I64)
+{
+  I64 i;
+  for (i=0;i<CNT;i++)
+    lock  //Can be used without {}
+      glbl++;
+}
+
+U0 LockedInc()
+{
+  CSrvCmd *tempm0,*tempm1;
+  glbl=0;
+  tempm0=JobQue(&MPLockedInc,NULL,0,0);
+  tempm1=JobQue(&MPLockedInc,NULL,1,0);
+  GetResult(tempm0);
+  GetResult(tempm1);
+  "Correct Cnt:%X Actual Cnt:%X\n",CNT*2,glbl;
+}
+
+UnlockedInc;
+LockedInc;

Demo/MultiCore/MPAdd.CPP

@@ -0,0 +1,86 @@
+I64 mp_n;
+
+I64 MPSum(I64 my_mp_cnt)
+{ //We could use the formula n*(n+1)/2
+  I64 lo=mp_n*Gs->num/my_mp_cnt,
+     hi=mp_n*(Gs->num+1)/my_mp_cnt,
+     result=0,i;
+  for (i=lo;i<hi;i++)
+    result+=i;
+  return result;
+}
+
+I64 Sum(I64 n,I64 my_mp_cnt)
+{
+  CSrvCmd *tempm[MP_MAX_PROCESSORS];
+  I64 result=0,i;
+  mp_n=n+1;
+  for (i=0;i<my_mp_cnt;i++)
+    tempm[i]=JobQue(&MPSum,my_mp_cnt,i,0);
+  for (i=0;i<my_mp_cnt;i++)
+    result+=GetResult(tempm[i]);
+  return result;
+}
+
+
+#define SAMPLE_SIZE 100
+
+F64 Test(I64 n,I64 my_mp_cnt)
+{
+  I64 i,val=0;
+  F64 start,end;
+  start=tS;
+  for (i=0;i<SAMPLE_SIZE;i++)
+    val+=Sum(n,my_mp_cnt);
+  end=tS;
+  "Val:%,d\n",val/SAMPLE_SIZE;
+  "$$RED$$N:%12,d Time:%10.8f$$FG$$\n",n,(end-start)/SAMPLE_SIZE;
+  return end-start;
+}
+
+#define MIN_VAL		1000
+#define MIN_TEST	3
+#define MAX_TEST	7
+#define NUM_TESTS	(MAX_TEST-MIN_TEST+1)
+#define MAX_PERCENT	200
+
+U0 MPAdd()
+{
+  I64 i,n,
+    h=Fs->pix_width,
+    v=Fs->pix_height;
+  F64 t1,t2,results[NUM_TESTS];
+  CDC *dc=DCAlias;
+
+  for (i=0,n=MIN_VAL;i<NUM_TESTS;i++,n*=10) {
+    t1=Test(n,1);
+    t2=Test(n,mp_cnt);
+    results[i]=t2*100.0/t1;
+    "$$GREEN$$%8.4f%%$$FG$$\n\n",results[i];
+  }
+  PressAKey;
+
+  DocClear;
+
+  dc->color=BLUE;
+  for (i=MAX_PERCENT/10;i<MAX_PERCENT;i+=MAX_PERCENT/10) {
+    GrPrint(dc,0,v-ToF64(i)/MAX_PERCENT*v-FONT_HEIGHT,"%3d%%",i);
+    GrLine(dc,0,v-ToF64(i)/MAX_PERCENT*v,h,v-ToF64(i)/MAX_PERCENT*v);
+  }
+
+  for (i=0;i<NUM_TESTS-1;i++) {
+    dc->color=RED;
+    dc->pen_width=2;
+    GrLine3(dc,i*h/(NUM_TESTS-1),      v-results[i  ]/MAX_PERCENT*v,0,
+		 (i+1)*h/(NUM_TESTS-1),v-results[i+1]/MAX_PERCENT*v,0);
+    dc->color=GREEN;
+    GrPrint(dc,i*h/(NUM_TESTS-1),v-FONT_HEIGHT,"10e%d",i+MIN_TEST);
+    GrLine(dc,i*h/(NUM_TESTS-1),0,i*h/(NUM_TESTS-1),v);
+  }
+  PressAKey;
+
+  DCFill;
+  DCDel(dc);
+}
+
+MPAdd;

Demo/MultiCore/MPPrint.CPP

@@ -0,0 +1,18 @@
+U0 Job(CDoc *doc)
+{
+  I64 i;
+  for (i=0;i<2;i++)
+    DocPrint(doc,"$$FG,%d$$CPU%d ",Gs->num,Gs->num);
+}
+
+
+U0 MPPrintDemo()
+{
+  I64 i;
+  for (i=0;i<500;i++)
+    JobQue(&Job,DocPut,i%mp_cnt);
+  Sleep(500);
+  "$$FG$$\n";
+}
+
+MPPrintDemo;

Demo/MultiCore/Palindrome.CPP

@@ -0,0 +1,97 @@
+#define BORDER_CHARS	1
+
+U8 *buf;
+I64 size,mp_not_done_flags;
+CDoc *doc;
+
+U0 PDNormalize()
+{
+  U8 *r=MAlloc(size+2*BORDER_CHARS),
+     *src=buf,*dst=r;
+  I64 ch;
+  *dst++='['; //Border
+  while (size--) {
+    ch=*src++;
+    if ('a'<=ch<='z') //lower is most common so do first
+      *dst++=ch;
+    else if ('A'<=ch<='Z')
+      *dst++=ch+'a'-'A'; //Convert to lower
+  }
+  *dst++=']'; //Border
+  Free(buf);
+  buf=r;
+  size=dst-r-2*BORDER_CHARS;
+}
+
+
+U0 PDAnswer(U8 *a,I64 len)
+{
+  DocLock(doc);
+  a-=(len-1)/2;
+  DocPrint(doc,"CPU:%d Len:%2d ",Gs->num,len);
+  while (len--)
+    DocPrint(doc,"%C",*a++); //%C is toupper char
+  DocPrint(doc,"\n");
+  DocUnlock(doc);
+}
+
+U0 MPPalindrome(I64 dummy=0)
+{
+  nounusedwarn dummy;
+  U8 *src=buf+BORDER_CHARS+size*Gs->num/mp_cnt,
+     *f,*b;
+  I64 len,best=0,
+     my_size=(size+mp_cnt-1)/mp_cnt;
+  while (my_size--) {
+
+//Odd
+    f=src+1;
+    b=src-1;
+    while (*f==*b) {
+      f++;
+      b--;
+    }
+    len=f-b+1-2;
+    if (len>best) {
+      best=len;
+      PDAnswer(src,len);
+    }
+
+//Even
+    f=src+1;
+    b=src;
+    while (*f==*b) {
+      f++;
+      b--;
+    }
+    len=f-b+1-2;
+    if (len>best) {
+      best=len;
+      PDAnswer(src,len);
+    }
+
+    src++;
+  }
+  LBtr(&mp_not_done_flags,Gs->num);
+}
+
+U0 Palindrome(U8 *filename)
+{
+  I64 i;
+  F64 t0=tS;
+
+  buf=FileRead(filename,&size);
+  PDNormalize;
+
+  doc=DocPut;
+  mp_not_done_flags=1<<mp_cnt-1;
+  for (i=0;i<mp_cnt;i++)
+    JobQue(&MPPalindrome,NULL,i);
+  while (mp_not_done_flags)
+    Yield;
+
+  Free(buf);
+  "Time:%9.5f\n",tS-t0;
+}
+
+Palindrome(Define("ST_BIBLE_FILE"));

Demo/MultiCore/Primes.CPP

@@ -0,0 +1,75 @@
+U8 *master_bitmap;
+I64 prime_range,my_mp_cnt,pending;
+
+U0 PrimesJob(I64 i)
+{
+  I64 j,k,l=Sqrt(prime_range),
+     lo=i*prime_range/my_mp_cnt,
+     hi=(i+1)*prime_range/my_mp_cnt,
+     lo2=lo+sys_cache_line_width,
+     hi2=hi-sys_cache_line_width;
+  if (lo2>hi2) lo2=hi2;
+  for (j=2;j<=l;j++) {
+    if (!Bt(master_bitmap,j)) {
+      if (j>=lo)
+	k=j+j;
+      else {
+	k=lo-lo%j;
+	if (k<lo)
+	  k+=j;
+      }
+      while (k<lo2) {
+	LBts(master_bitmap,k);
+	k+=j;
+      }
+      while (k<hi2) {
+	Bts(master_bitmap,k);
+	k+=j;
+      }
+      while (k<hi) {
+	LBts(master_bitmap,k);
+	k+=j;
+      }
+    }
+  }
+  lock pending--;
+}
+
+I64 Primes(I64 range,I64 _my_mp_cnt)
+{
+  I64 i,prime_cnt=0;
+  F64 t0=tS,tf;
+  prime_range=range;
+  if (_my_mp_cnt<=mp_cnt)
+    my_mp_cnt=_my_mp_cnt;
+  else
+    my_mp_cnt=mp_cnt;
+  master_bitmap=CAlloc((prime_range+7)/8+1);
+  Bts(master_bitmap,0);
+  Bts(master_bitmap,1);
+  pending=my_mp_cnt;
+  for (i=0;i<my_mp_cnt;i++)
+    JobQue(&PrimesJob,i,i);
+  while (pending)
+    Yield;
+  tf=tS;
+
+  for (i=0;i<prime_range;i++)
+    if (!Bt(master_bitmap,i))
+      prime_cnt++;
+
+  for (i=MaxI64(prime_range-100,0);i<prime_range;i++)
+    if (!Bt(master_bitmap,i))
+      "%d ",i;
+
+  "\n$$RED$$CPUs:%d PrimeRange:%,d PrimeCnt:%,d Time:%9.6,f$$FG$$\n",
+    my_mp_cnt,prime_range,prime_cnt,tf-t0;
+
+  Free(master_bitmap);
+  return prime_cnt;
+}
+
+Primes(100,1);
+Primes(100,mp_cnt);
+Primes(1000000,1);
+Primes(1000000,mp_cnt);

Demo/MultiCore/RadixSort.CPP

@@ -0,0 +1,164 @@
+#define NUM	1000000
+
+I64 my_mp_cnt=1<<Bsr(mp_cnt);//Power of 2
+
+I32 *a1,*a2;
+I32 *b[my_mp_cnt],bn[my_mp_cnt];
+I64 mp_not_done_flags;
+
+I64 Compare(I32 *e1,I32 *e2)
+{
+  return *e1-*e2;
+}
+
+
+U0 QSortU32(I32 *base,I64 num)
+{
+// By customizing, we dramatically improve it!
+// Cut and paste from $LK,"QSortI64",A="MN:QSortI64"$().
+  I64 i;
+  I32 *less,*greater,pivot;
+  if (num>1) {
+    do {
+      less=base;
+      greater=base+num;
+      pivot=base[num/2];
+      while (less<greater) {
+	if (*less<=pivot)
+	  less++;
+	else {
+	  greater--;
+	  SwapU32(less,greater);
+	}
+      }
+      i=less-base;
+      if (i==num) { //All less or equal to pivot
+
+      //Point greater to first less
+	do greater--;
+	while (--i && *greater==pivot);
+
+	if (i) {
+	  less=base+num/2; //Pivot was not moved, point to it
+	  if (less<greater)
+	    SwapU32(less,greater);
+	  num=i;
+	} else //All equal
+	  break;
+      } else if (i<num/2) {
+	QSortU32(base,i);
+	num-=i;
+	base=greater;
+      } else {
+	QSortU32(greater,num-i);
+	num=i;
+      }
+    } while (num>1);
+  }
+}
+
+U0 MPSort(I64 dummy=0)
+{
+  nounusedwarn dummy;
+  QSortU32(b[Gs->num],bn[Gs->num]);
+  LBtr(&mp_not_done_flags,Gs->num);
+}
+
+U0 MPRadixSortDemo(I64 dummy=0)
+{
+  nounusedwarn dummy;
+  I64 i,j,k1,k2;
+  F64 t0;
+  a1=MAlloc(NUM*sizeof(I32));
+  for (i=0;i<NUM;i++)
+    a1[i]=RandI32;
+
+
+  a2=MAlloc(NUM*sizeof(I32));
+
+  "$$GREEN$$QSort$$FG$$\n";
+  t0=tS;
+  MemCpy(a2,a1,sizeof(I32)*NUM);
+  QSort(a2,NUM,sizeof(I32),&Compare);
+  "Time:%9.6f\n",tS-t0;
+  D(a2+NUM/4);
+
+
+  "$$GREEN$$QSortU32$$FG$$\n";
+  t0=tS;
+  MemCpy(a2,a1,sizeof(I32)*NUM);
+  QSortU32(a2,NUM);
+  "Time:%9.6f\n",tS-t0;
+  D(a2+NUM/4);
+
+  for (i=0;i<my_mp_cnt;i++) {
+    //$WW,0$We must do full size, just in case.
+    //There will be uneven split between cores
+    //depending on the distribution of rand numbers.
+    b[i]=MAlloc(NUM*sizeof(I32));
+    bn[i]=0;
+  }
+
+  if (my_mp_cnt<2) throw('MultCore');
+
+  "$$GREEN$$MP Radix QSortU32$$FG$$\n";
+  t0=tS;
+  k1=32-Bsr(my_mp_cnt);
+  k2=my_mp_cnt/2;
+  for (i=0;i<NUM;i++) {
+    j=a1[i]>>k1+k2; //This is a preliminary radix sort.
+    b[j][bn[j]++]=a1[i];
+  }
+  mp_not_done_flags=1<<my_mp_cnt-1;
+  for (i=0;i<my_mp_cnt;i++)
+    Spawn(&MPSort,NULL,NULL,i);
+  while (mp_not_done_flags)
+    Yield;
+  j=0;
+  for (i=0;i<my_mp_cnt;i++) {
+    MemCpy(&a2[j],b[i],bn[i]*sizeof(I32));
+    j+=bn[i];
+  }
+  "Time:%9.6f\n",tS-t0;
+  D(a2+NUM/4);
+
+  Free(a1);
+  Free(a2);
+  for (i=0;i<my_mp_cnt;i++)
+    Free(b[i]);
+}
+
+MPRadixSortDemo;
+
+/*$HL,0$ Results on 8 Cores 2.660GHz Core i7:
+$FG,2$QSort$FG$
+Time: 1.535474
+00000000 EA 1D F6 BF 16 2E F6 BF 0B 3C F6 BF CD 44 F6 BF ê.ö¿..ö¿.<ö¿ÍDö¿
+00000010 B1 45 F6 BF 52 4A F6 BF 96 71 F6 BF 9F 78 F6 BF ±Eö¿RJö¿–qö¿Ÿxö¿
+00000020 52 87 F6 BF 23 9F F6 BF EF AD F6 BF 2D B4 F6 BF R‡ö¿#Ÿö¿ï­ö¿-´ö¿
+00000030 4B EE F6 BF 60 FA F6 BF 31 08 F7 BF 1A 0E F7 BF Kîö¿`úö¿1.÷¿..÷¿
+00000040 5C 39 F7 BF 26 3B F7 BF C7 3D F7 BF CF 3D F7 BF \9÷¿&;÷¿Ç=÷¿Ï=÷¿
+00000050 7D 51 F7 BF 2F 79 F7 BF 7B 7A F7 BF CF 8C F7 BF }Q÷¿/y÷¿{z÷¿ÏŒ÷¿
+00000060 09 95 F7 BF 04 A3 F7 BF D2 A8 F7 BF 61 EA F7 BF .•÷¿.£÷¿Ò¨÷¿aê÷¿
+00000070 2D ED F7 BF F2 03 F8 BF 4C 09 F8 BF BB 09 F8 BF -í÷¿ò.ø¿L.ø¿».ø¿
+$FG,2$QSortU32$FG$
+Time: 0.132599
+00000000 EA 1D F6 BF 16 2E F6 BF 0B 3C F6 BF CD 44 F6 BF ê.ö¿..ö¿.<ö¿ÍDö¿
+00000010 B1 45 F6 BF 52 4A F6 BF 96 71 F6 BF 9F 78 F6 BF ±Eö¿RJö¿–qö¿Ÿxö¿
+00000020 52 87 F6 BF 23 9F F6 BF EF AD F6 BF 2D B4 F6 BF R‡ö¿#Ÿö¿ï­ö¿-´ö¿
+00000030 4B EE F6 BF 60 FA F6 BF 31 08 F7 BF 1A 0E F7 BF Kîö¿`úö¿1.÷¿..÷¿
+00000040 5C 39 F7 BF 26 3B F7 BF C7 3D F7 BF CF 3D F7 BF \9÷¿&;÷¿Ç=÷¿Ï=÷¿
+00000050 7D 51 F7 BF 2F 79 F7 BF 7B 7A F7 BF CF 8C F7 BF }Q÷¿/y÷¿{z÷¿ÏŒ÷¿
+00000060 09 95 F7 BF 04 A3 F7 BF D2 A8 F7 BF 61 EA F7 BF .•÷¿.£÷¿Ò¨÷¿aê÷¿
+00000070 2D ED F7 BF F2 03 F8 BF 4C 09 F8 BF BB 09 F8 BF -í÷¿ò.ø¿L.ø¿».ø¿
+$FG,2$MP Radix QSortU32$FG$
+Time: 0.024471
+00000000 EA 1D F6 BF 16 2E F6 BF 0B 3C F6 BF CD 44 F6 BF ê.ö¿..ö¿.<ö¿ÍDö¿
+00000010 B1 45 F6 BF 52 4A F6 BF 96 71 F6 BF 9F 78 F6 BF ±Eö¿RJö¿–qö¿Ÿxö¿
+00000020 52 87 F6 BF 23 9F F6 BF EF AD F6 BF 2D B4 F6 BF R‡ö¿#Ÿö¿ï­ö¿-´ö¿
+00000030 4B EE F6 BF 60 FA F6 BF 31 08 F7 BF 1A 0E F7 BF Kîö¿`úö¿1.÷¿..÷¿
+00000040 5C 39 F7 BF 26 3B F7 BF C7 3D F7 BF CF 3D F7 BF \9÷¿&;÷¿Ç=÷¿Ï=÷¿
+00000050 7D 51 F7 BF 2F 79 F7 BF 7B 7A F7 BF CF 8C F7 BF }Q÷¿/y÷¿{z÷¿ÏŒ÷¿
+00000060 09 95 F7 BF 04 A3 F7 BF D2 A8 F7 BF 61 EA F7 BF .•÷¿.£÷¿Ò¨÷¿aê÷¿
+00000070 2D ED F7 BF F2 03 F8 BF 4C 09 F8 BF BB 09 F8 BF -í÷¿ò.ø¿L.ø¿».ø¿
+$HL,1$*/