Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages

/ray/src/lib/tl/test-bitfield.cc

Go to the documentation of this file.
00001 /*
00002  * lib/tl/test-bitfield.cc
00003  * 
00004  * Test TL*BitField implementation. 
00005  * 
00006  * Copyright (c) 2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
00007  * 
00008  * This file may be distributed and/or modified under the terms of the 
00009  * GNU General Public License version 2 as published by the Free Software 
00010  * Foundation. (See COPYING.GPL for details.)
00011  * 
00012  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
00013  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
00014  * 
00015  */
00016 
00017 #include <stdio.h>
00018 #include "tlbitfield.h"
00019 
00020 char *prg_name="test-bitfield";
00021 
00022 
00023 static int DoTestBitFields()
00024 {
00025     int nerr=0;
00026     const size_t size=64*64;
00027     TLStaticBitField<size_t,size> sbfA;
00028     TLStaticBitField<int16,size> sbfB;
00029     TLStaticBitField<size_t,size+21> sbfC;
00030     TLDynamicBitField<size_t> dbfA(size);
00031     TLDynamicBitField<int16> dbfB(size);
00032     TLDynamicBitField<size_t> dbfC(size+21);
00033     char array[size];
00034     
00035     fprintf(stderr,
00036         "  sA: nents=%d, band=0x%x, bshift=%d, exmask=0x%x\n",
00037         sbfA.nents,sbfA.band,sbfA.bshift,sbfA.exmask);
00038     fprintf(stderr,
00039         "  sB: nents=%d, band=0x%x, bshift=%d, exmask=0x%x\n",
00040         sbfB.nents,sbfB.band,sbfB.bshift,sbfB.exmask);
00041     fprintf(stderr,
00042         "  sC: nents=%d, band=0x%x, bshift=%d, exmask=0x%x\n",
00043         sbfC.nents,sbfC.band,sbfC.bshift,sbfC.exmask);
00044     
00045     fprintf(stderr,
00046         "  dA: nents=%d, band=0x%x, bshift=%d, exmask=0x%x\n",
00047         dbfA.nents,dbfA.band,dbfA.bshift,dbfA.exmask);
00048     fprintf(stderr,
00049         "  dB: nents=%d, band=0x%x, bshift=%d, exmask=0x%x\n",
00050         dbfB.nents,dbfB.band,dbfB.bshift,dbfB.exmask);
00051     fprintf(stderr,
00052         "  dC: nents=%d, band=0x%x, bshift=%d, exmask=0x%x\n",
00053         dbfC.nents,dbfC.band,dbfC.bshift,dbfC.exmask);
00054     
00055     // First, clear them all: 
00056     sbfA.ClrAll();
00057     sbfB.ClrAll();
00058     sbfC.ClrAll();
00059     dbfA.ClrAll();
00060     dbfB.ClrAll();
00061     dbfC.ClrAll();
00062     for(size_t j=0; j<size; j++) array[j]=0;
00063     
00064     // Set and clear random bits. 
00065     fprintf(stderr,"  SetBit/ClrBit");
00066     for(int i=0; i<200000; i++)
00067     {
00068         int rand_val=rand();
00069         bool val=rand_val&1;
00070         size_t adr=(rand_val>>1)%size;
00071         
00072         if(val)
00073         {
00074             sbfA.SetBit(adr);
00075             sbfB.SetBit(adr);
00076             sbfC.SetBit(adr);
00077             dbfA.SetBit(adr);
00078             dbfB.SetBit(adr);
00079             dbfC.SetBit(adr);
00080             array[adr]=1;
00081             if(!sbfA.GetBit(adr) || !sbfB.GetBit(adr) || !sbfC.GetBit(adr))
00082             {
00083                 fprintf(stderr,"  OOPS: adr=%u, val=%d (size=%u, i=%d) [s]\n",
00084                     adr,int(val),size,i);
00085                 ++nerr;  break;
00086             }
00087             if(!dbfA.GetBit(adr) || !dbfB.GetBit(adr) || !dbfC.GetBit(adr))
00088             {
00089                 fprintf(stderr,"  OOPS: adr=%u, val=%d (size=%u, i=%d) [d]\n",
00090                     adr,int(val),size,i);
00091                 ++nerr;  break;
00092             }
00093         }
00094         else
00095         {
00096             sbfA.ClrBit(adr);
00097             sbfB.ClrBit(adr);
00098             sbfC.ClrBit(adr);
00099             dbfA.ClrBit(adr);
00100             dbfB.ClrBit(adr);
00101             dbfC.ClrBit(adr);
00102             array[adr]=0;
00103             if(sbfA.GetBit(adr) || sbfB.GetBit(adr) || sbfC.GetBit(adr))
00104             {
00105                 fprintf(stderr,"  OOPS: adr=%u, val=%d (size=%u, i=%d) [s]\n",
00106                     adr,int(val),size,i);
00107                 ++nerr;  break;
00108             }
00109             if(dbfA.GetBit(adr) || dbfB.GetBit(adr) || dbfC.GetBit(adr))
00110             {
00111                 fprintf(stderr,"  OOPS: adr=%u, val=%d (size=%u, i=%d) [d]\n",
00112                     adr,int(val),size,i);
00113                 ++nerr;  break;
00114             }
00115         }
00116         
00117         if(!(rand()%1000))
00118         {
00119             {
00120                 size_t sA=sbfA.CountSet();
00121                 size_t sB=sbfA.CountSet();
00122                 size_t sC=sbfA.CountSet();
00123                 size_t dA=dbfA.CountSet();
00124                 size_t dB=dbfA.CountSet();
00125                 size_t dC=dbfA.CountSet();
00126                 size_t sarr=0;
00127                 for(size_t j=0; j<size; j++) if(array[j]) ++sarr;
00128                 if(sA!=sarr || sB!=sarr || sC!=sarr)
00129                 {  fprintf(stderr,"  OOPS: counter: sA=%u, sB=%u, sC=%u, "
00130                     "sarr=%u, i=%d, size=%u\n",sA,sB,sC,sarr,i,size);
00131                     ++nerr;  break;  }
00132                 if(dA!=sarr || dB!=sarr || dC!=sarr)
00133                 {  fprintf(stderr,"  OOPS: counter: dA=%u, dB=%u, dC=%u, "
00134                     "sarr=%u, i=%d, size=%u\n",dA,dB,dC,sarr,i,size);
00135                     ++nerr;  break;  }
00136             }
00137             {
00138                 ssize_t sA=sbfA.SearchFirstSet();
00139                 ssize_t sB=sbfA.SearchFirstSet();
00140                 ssize_t sC=sbfA.SearchFirstSet();
00141                 ssize_t dA=dbfA.SearchFirstSet();
00142                 ssize_t dB=dbfA.SearchFirstSet();
00143                 ssize_t dC=dbfA.SearchFirstSet();
00144                 ssize_t sarr=-1;
00145                 for(size_t j=0; j<size; j++)  if(array[j]) { sarr=j; break; }
00146                 if(sA!=sarr || sB!=sarr || sC!=sarr)
00147                 {  fprintf(stderr,"  OOPS: FirstSet: sA=%u, sB=%u, sC=%u, "
00148                     "sarr=%u, i=%d, size=%u\n",sA,sB,sC,sarr,i,size);
00149                     ++nerr;  break;  }
00150                 if(dA!=sarr || dB!=sarr || dC!=sarr)
00151                 {  fprintf(stderr,"  OOPS: FirstSet: dA=%u, dB=%u, dC=%u, "
00152                     "sarr=%u, i=%d, size=%u\n",dA,dB,dC,sarr,i,size);
00153                     ++nerr;  break;  }
00154             }
00155             {
00156                 ssize_t sA=sbfA.SearchFirstClr();
00157                 ssize_t sB=sbfA.SearchFirstClr();
00158                 ssize_t sC=sbfA.SearchFirstClr();
00159                 ssize_t dA=dbfA.SearchFirstClr();
00160                 ssize_t dB=dbfA.SearchFirstClr();
00161                 ssize_t dC=dbfA.SearchFirstClr();
00162                 ssize_t sarr=-1;
00163                 for(size_t j=0; j<size; j++)  if(!array[j]) { sarr=j; break; }
00164                 if(sA!=sarr || sB!=sarr || sC!=sarr)
00165                 {  fprintf(stderr,"  OOPS: FirstClr: sA=%u, sB=%u, sC=%u, "
00166                     "sarr=%u, i=%d, size=%u\n",sA,sB,sC,sarr,i,size);
00167                     ++nerr;  break;  }
00168                 if(dA!=sarr || dB!=sarr || dC!=sarr)
00169                 {  fprintf(stderr,"  OOPS: FirstClr: dA=%u, dB=%u, dC=%u, "
00170                     "sarr=%u, i=%d, size=%u\n",dA,dB,dC,sarr,i,size);
00171                     ++nerr;  break;  }
00172             }
00173         }
00174         
00175         if(!(i&0x3fff))  fprintf(stderr,".");
00176     }
00177     
00178     // Compare: 
00179     fprintf(stderr,"cmp: ");
00180     for(size_t j=0; j<size; j++)
00181     {
00182         bool val=array[j];
00183         if(sbfA.GetBit(j)!=val)  ++nerr;
00184         if(sbfB.GetBit(j)!=val)  ++nerr;
00185         if(sbfC.GetBit(j)!=val)  ++nerr;
00186         if(dbfA.GetBit(j)!=val)  ++nerr;
00187         if(dbfB.GetBit(j)!=val)  ++nerr;
00188         if(dbfC.GetBit(j)!=val)  ++nerr;
00189     }
00190     fprintf(stderr,"%d errors\n",nerr);
00191     if(nerr)  return(nerr);
00192     
00193     
00194     // Clear them all: 
00195     sbfA.ClrAll();
00196     sbfB.ClrAll();
00197     sbfC.ClrAll();
00198     dbfA.ClrAll();
00199     dbfB.ClrAll();
00200     dbfC.ClrAll();
00201     for(size_t j=0; j<size; j++) array[j]=0;
00202     
00203     {
00204         ssize_t sA=sbfA.SearchFirstSet();
00205         ssize_t sB=sbfA.SearchFirstSet();
00206         ssize_t sC=sbfA.SearchFirstSet();
00207         ssize_t dA=dbfA.SearchFirstSet();
00208         ssize_t dB=dbfA.SearchFirstSet();
00209         ssize_t dC=dbfA.SearchFirstSet();
00210         ssize_t sarr=-1;   // No bits are currently set. 
00211         if(sA!=sarr || sB!=sarr || sC!=sarr)
00212         {  fprintf(stderr,"  OOPS: FirstSet: sA=%d, sB=%d, sC=%d, "
00213             "sarr=%d, size=%u\n",sA,sB,sC,sarr,size);
00214             ++nerr;  return(nerr);  }
00215         if(dA!=sarr || dB!=sarr || dC!=sarr)
00216         {  fprintf(stderr,"  OOPS: FirstSet: dA=%d, dB=%d, dC=%d, "
00217             "sarr=%d, size=%u\n",dA,dB,dC,sarr,size);
00218             ++nerr;  return(nerr);  }
00219     }
00220     
00221     fprintf(stderr,"  SearchFirstSet");
00222     size_t keepfree=size-1;
00223     while(keepfree>0)
00224     {
00225         int rand_val=rand();
00226         bool val=rand_val&1;
00227         size_t adr=keepfree+(rand_val>>1)%(size-keepfree);
00228         
00229         sbfA.AssBit(adr,val);
00230         sbfB.AssBit(adr,val);
00231         sbfC.AssBit(adr,val);
00232         dbfA.AssBit(adr,val);
00233         dbfB.AssBit(adr,val);
00234         dbfC.AssBit(adr,val);
00235         array[adr]=val;
00236         
00237         {
00238             ssize_t sA=sbfA.SearchFirstSet();
00239             ssize_t sB=sbfA.SearchFirstSet();
00240             ssize_t sC=sbfA.SearchFirstSet();
00241             ssize_t dA=dbfA.SearchFirstSet();
00242             ssize_t dB=dbfA.SearchFirstSet();
00243             ssize_t dC=dbfA.SearchFirstSet();
00244             ssize_t sarr=-1;
00245             for(size_t j=0; j<size; j++)  if(array[j]) { sarr=j; break; }
00246             CritAssert(sarr<0 || size_t(sarr)>=keepfree);
00247             if(sA!=sarr || sB!=sarr || sC!=sarr)
00248             {  fprintf(stderr,"  OOPS: FirstSet: sA=%d, sB=%d, sC=%d, "
00249                 "sarr=%d, keepfree=%u, size=%u\n",sA,sB,sC,sarr,keepfree,size);
00250                 ++nerr;  break;  }
00251             if(dA!=sarr || dB!=sarr || dC!=sarr)
00252             {  fprintf(stderr,"  OOPS: FirstSet: dA=%d, dB=%d, dC=%d, "
00253                 "sarr=%d, keepfree=%u, size=%u\n",dA,dB,dC,sarr,keepfree,size);
00254                 ++nerr;  break;  }
00255         }
00256         
00257         if(!(rand()%5))
00258         {
00259             --keepfree;
00260             if(!(keepfree&127))  fprintf(stderr,".");
00261         }
00262     }
00263     fprintf(stderr,"OK\n");
00264     if(nerr)  return(nerr);
00265     
00266     // Set them all: 
00267     sbfA.SetAll();
00268     sbfB.SetAll();
00269     sbfC.SetAll();
00270     dbfA.SetAll();
00271     dbfB.SetAll();
00272     dbfC.SetAll();
00273     for(size_t j=0; j<size; j++) array[j]=1;
00274     
00275     {
00276         ssize_t sA=sbfA.SearchFirstClr();
00277         ssize_t sB=sbfA.SearchFirstClr();
00278         ssize_t sC=sbfA.SearchFirstClr();
00279         ssize_t dA=dbfA.SearchFirstClr();
00280         ssize_t dB=dbfA.SearchFirstClr();
00281         ssize_t dC=dbfA.SearchFirstClr();
00282         ssize_t sarr=-1;   // No bits are currently cleared. 
00283         if(sA!=sarr || sB!=sarr || sC!=sarr)
00284         {  fprintf(stderr,"  OOPS: FirstClr: sA=%d, sB=%d, sC=%d, "
00285             "sarr=%d, size=%u\n",sA,sB,sC,sarr,size);
00286             ++nerr;  return(nerr);  }
00287         if(dA!=sarr || dB!=sarr || dC!=sarr)
00288         {  fprintf(stderr,"  OOPS: FirstClr: dA=%d, dB=%d, dC=%d, "
00289             "sarr=%d, size=%u\n",dA,dB,dC,sarr,size);
00290             ++nerr;  return(nerr);  }
00291     }
00292     
00293     fprintf(stderr,"  SearchFirstClr");
00294     keepfree=size-1;
00295     while(keepfree>0)
00296     {
00297         int rand_val=rand();
00298         bool val=rand_val&1;
00299         size_t adr=keepfree+(rand_val>>1)%(size-keepfree);
00300         
00301         sbfA.AssBit(adr,val);
00302         sbfB.AssBit(adr,val);
00303         sbfC.AssBit(adr,val);
00304         dbfA.AssBit(adr,val);
00305         dbfB.AssBit(adr,val);
00306         dbfC.AssBit(adr,val);
00307         array[adr]=val;
00308         
00309         {
00310             ssize_t sA=sbfA.SearchFirstClr();
00311             ssize_t sB=sbfA.SearchFirstClr();
00312             ssize_t sC=sbfA.SearchFirstClr();
00313             ssize_t dA=dbfA.SearchFirstClr();
00314             ssize_t dB=dbfA.SearchFirstClr();
00315             ssize_t dC=dbfA.SearchFirstClr();
00316             ssize_t sarr=-1;
00317             for(size_t j=0; j<size; j++)  if(!array[j]) { sarr=j; break; }
00318             CritAssert(sarr<0 || size_t(sarr)>=keepfree);
00319             if(sA!=sarr || sB!=sarr || sC!=sarr)
00320             {  fprintf(stderr,"  OOPS: FirstClr: sA=%d, sB=%d, sC=%d, "
00321                 "sarr=%d, keepfree=%u, size=%u\n",sA,sB,sC,sarr,keepfree,size);
00322                 ++nerr;  break;  }
00323             if(dA!=sarr || dB!=sarr || dC!=sarr)
00324             {  fprintf(stderr,"  OOPS: FirstClr: dA=%d, dB=%d, dC=%d, "
00325                 "sarr=%d, keepfree=%u, size=%u\n",dA,dB,dC,sarr,keepfree,size);
00326                 ++nerr;  break;  }
00327         }
00328         
00329         if(!(rand()%5))
00330         {
00331             --keepfree;
00332             if(!(keepfree&127))  fprintf(stderr,".");
00333         }
00334     }
00335     fprintf(stderr,"OK\n");
00336     if(nerr)  return(nerr);
00337     
00338     return(nerr);
00339 }
00340 
00341 
00342 int main()
00343 {
00344     fprintf(stderr,"Testing TL*BitField...\n");
00345     
00346     int rv=DoTestBitFields();
00347     if(rv)
00348     {
00349         fprintf(stderr,"OOPS: Test failed.\n");
00350         return(1);
00351     }
00352     
00353     // Allocation debugging: 
00354     LMallocUsage lmu;
00355     LMallocGetUsage(&lmu);
00356     fprintf(stderr,"%s: %sAlloc: %u bytes in %d chunks; Peak: %u by,%d chks; "
00357         "(%u/%u/%u)%s\n",
00358         prg_name,
00359         lmu.curr_used ? "*** " : "",
00360         lmu.curr_used,lmu.used_chunks,lmu.max_used,lmu.max_used_chunks,
00361         lmu.malloc_calls,lmu.realloc_calls,lmu.free_calls,
00362         lmu.curr_used ? " ***" : "");
00363     if(lmu.curr_used)  return(1);
00364     
00365     fprintf(stderr,"TL*BitField test SUCCESSFUL.\n");
00366     return(0);
00367 }
Generated on Sat Feb 19 22:33:46 2005 for Ray by doxygen 1.3.5