void NSV::create_level_r(LCP *lcp, size_t level, TextIndex *csa) {
uint *P_aux;
uint *R_aux;
uint size = (n+W-1)/W;
uint last_nsv = 0;
uint j, far_aux, lcp_value, nsv_aux;
P_aux = new uint[size];
R_aux = new uint[size];
for(uint i=0; i < size; i++) {
P_aux[i]=0;
R_aux[i]=0;
}
uint num_elements = R[level-1]->rank1(n-1);
uint *lcp_r = new uint[num_elements];
for(uint i=0; i<num_elements; i++) {
lcp_r[i] = lcp->get_LCP(R[level-1]->select1(i+1), csa);
}
/*for each i find his NSV position*/
for(uint i=0; i<num_elements; i++) {
lcp_value = lcp_r[i];
for(j=i+1; j<num_elements; j++) {
nsv_aux = lcp_r[j];
if(lcp_value > nsv_aux) {
/*if is not near*/
if( i/b < j/b ) {
if( j/b != last_nsv/b) {
/*mark the pioneer in P*/
far_aux = R[level-1]->select1(i+1);
bitset(P_aux,far_aux);
/*mark the pioneer and the NSV of the pioneer in R*/
bitset(R_aux, far_aux);
bitset(R_aux, R[level-1]->select1(j+1));
}
last_nsv=j;
}
break;
}
} /*close for j*/
if(j==num_elements) {
if( i/b < j/b ) {
if( j/b != last_nsv/b) {
/*mark the pioneer in P*/
far_aux = R[level-1]->select1(i+1);
bitset(P_aux,far_aux);
/*mark the pioneer and the NSV of the pioneer in R*/
bitset(R_aux,far_aux);
bitset(R_aux, n);
}
last_nsv=j;
}
}
} /*close for i*/
delete [] lcp_r;
P[level] = new BitSequenceRRR(P_aux, n);
R[level] = new BitSequenceRRR(R_aux, n);
delete[] P_aux;
delete[] R_aux;
}
//loads the structure containing the bitmap-type posting lists.
int RepairPost::load_bitmap(char *basename) {
int file;
char *filename;
filename = (char *)malloc(sizeof(char)*(strlen(basename)+20));
strcpy(filename, basename); strcat(filename, "."); strcat(filename, "bitmappost");
fprintf(stderr,"\nLoading bitmap-type postings: %s\n", filename);
if( (file = open(filename, O_RDONLY)) < 0) {
printf("Cannot open file %s\n", filename);
exit(0);
}
fprintf(stdout,"\n file %s opened sucessfully",filename);
/** Loading the posting lists using bitmaps.*/
{ ssize_t rf;
rf= read(file, &(il->lenBitmapThreshold), sizeof(uint));
// fprintf(stdout,"\n read: [%d]",il->lenBitmapThreshold); exit(0);
rf= read(file, &(il->bits_bitmaps), sizeof(uint));
rf= read(file, &(il->ints_bitmaps_aligned), sizeof(uint));
rf= read(file, &(il->numBitmaps), sizeof(uint));
fprintf(stdout,"\n read: [%d][%d][%d][%d]",il->lenBitmapThreshold, il-> bits_bitmaps,il->ints_bitmaps_aligned , il->numBitmaps);
fflush(stderr);
if (il->numBitmaps) {
il->zoneBitmaps = (uint *) malloc (sizeof(uint) * ( il->numBitmaps * il->ints_bitmaps_aligned));
il->zoneBitmaps[( il->numBitmaps * il->ints_bitmaps_aligned) -1] =0000; //so valgrind is shut up
rf= read(file, il->zoneBitmaps, ( il->numBitmaps * il->ints_bitmaps_aligned) * sizeof(uint));
}
else il->zoneBitmaps=NULL;
}
{
// uint * ptr2 = new uint[nodes+2]; //** longitud = nodes + 2 !!
// for(uint i=0;i<nodes+1;i++) {
// ptr2[i] = BR->rank(GetField(ptrs,plen,i))-1; //** ptr2[i] = rank(BR,ptr[i]); == nº símbolos "finales" hasta la posición del ptr[i] en la seq comprimida
// }
//uint * occsBitmap = (uint*)malloc(sizeof(uint)*(((nodes+2)+WW32-1)/WW32));
uint *occsBitmap = new uint [(((nodes+2)+WW32-1)/WW32)];
for(uint i=0; i<(((nodes+2)+WW32-1)/WW32);i++)
occsBitmap[i]=0;
for(uint i=1; i<=nodes;i++) {
if (shouldUseBitmap(i)) {
bitset(occsBitmap,i +1 );
/** adds +1 to the actual position so that given Bitmap[0]=0, Bitmap[1]=1 (the first node),
* Rank(1) == 0 ==> 0 is the index in "zoneBitmaps" (as zoneBitmaps starts at position "0").
* */
}
}
BR_ptr_bitmap = new BitRankW32Int(occsBitmap, nodes+2 , true, 20);
/* cerr<< "\nRAnk en pos 1 =" <<BR_ptr_bitmap->rank(1);
cerr<< "\nRAnk en pos 2 =" <<BR_ptr_bitmap->rank(2);
cerr<< "\nRAnk en pos 3 =" <<BR_ptr_bitmap->rank(3);
cerr<< "\nRAnk en pos 100000 =" <<BR_ptr_bitmap->rank(100000);
*/
//exit(0);
}
close(file);
free(filename);
return 0;
}
FTRep* createFT(uint *list,uint listLength){
FTRep * rep = (FTRep *) malloc(sizeof(struct sFTRep));
uint *levelSizeAux;
uint *cont;
uint *contB;
ushort* kvalues;
uint nkvalues;
rep->listLength = listLength;
register uint i;
int j, k;
uint value, newvalue;
uint bits_BS_len = 0;
kvalues = optimizationk(list,listLength,&nkvalues);
uint kval;
uint oldval =0;
uint newval =0;
i=0;
uint multval=1;
do{
oldval=newval;
if(i>=nkvalues){
kval = 1<<(kvalues[nkvalues-1]);
}
else
kval=1<<(kvalues[i]);
multval*=kval;
newval = oldval+multval;
i++;
}
while(oldval<newval);
rep->tamtablebase = i;
rep->tablebase = (uint *) malloc(sizeof(uint)*rep->tamtablebase);
levelSizeAux = (uint *) malloc(sizeof(uint)*rep->tamtablebase);
cont = (uint *) malloc(sizeof(uint)*rep->tamtablebase);
contB = (uint *) malloc(sizeof(uint)*rep->tamtablebase);
oldval =0;
newval =0;
multval=1;
for(i=0;i<rep->tamtablebase;i++){
oldval=newval;
if(i>=nkvalues){
kval = 1<<(kvalues[nkvalues-1]);
}
else
kval=1<<(kvalues[i]);
multval*=kval;
newval = oldval+multval;
rep->tablebase[i]=oldval;
}
for(i=0;i<rep->tamtablebase;i++){
levelSizeAux[i]=0;
}
for (i=0;i<listLength;i++){
value = list[i];
for(j=0;j<rep->tamtablebase;j++)
if(value>=rep->tablebase[j])
levelSizeAux[j]++;
}
j=0;
while((j<rep->tamtablebase)&&(levelSizeAux[j]!=0)){
j++;
}
rep->nLevels = j;
rep->levelsIndex = (uint *) malloc(sizeof(uint)*(rep->nLevels+1));
bits_BS_len =0;
rep->base = (uint *)malloc(sizeof(uint)*rep->nLevels);
rep->base_bits = (ushort *)malloc(sizeof(ushort)*rep->nLevels);
for(i=0;i<rep->nLevels;i++){
if(i>=nkvalues){
rep->base[i]=1<<(kvalues[nkvalues-1]);
rep->base_bits[i]=kvalues[nkvalues-1];
}
else{
rep->base[i]=1<<(kvalues[i]);
rep->base_bits[i]=kvalues[i];
}
}
uint tamLevels =0;
tamLevels=0;
for(i=0;i<rep->nLevels;i++)
tamLevels+=rep->base_bits[i]*levelSizeAux[i];
rep->iniLevel = (uint *)malloc(sizeof(uint)*rep->nLevels);
rep->tamCode=tamLevels;
uint indexLevel=0;
rep->levelsIndex[0]=0;
for(j=0;j<rep->nLevels;j++){
rep->levelsIndex[j+1]=rep->levelsIndex[j] + levelSizeAux[j];
rep->iniLevel[j] = indexLevel;
cont[j]=rep->iniLevel[j];
indexLevel+=levelSizeAux[j]*rep->base_bits[j];
contB[j]=rep->levelsIndex[j];
}
rep->levels = (uint *) malloc(sizeof(uint)*(tamLevels/W+1));
bits_BS_len = rep->levelsIndex[rep->nLevels-1]+1;
uint * bits_BS = (uint *) malloc(sizeof(uint)*(bits_BS_len/W+1));
for(i=0; i<((bits_BS_len)/W+1);i++)
bits_BS[i]=0;
for(i=0;i<listLength;i++){
value = list[i];
j=rep->nLevels-1;
while(j>=0){
if(value >= rep->tablebase[j]){
newvalue = value- rep->tablebase[j];
for(k=0;k<j;k++){
bitwrite(rep->levels,cont[k],rep->base_bits[k],newvalue%rep->base[k]);
cont[k]+=rep->base_bits[k];
contB[k]++;
newvalue = newvalue/rep->base[k];
}
k=j;
bitwrite(rep->levels,cont[j],rep->base_bits[j],newvalue%rep->base[j]);
cont[j]+=rep->base_bits[j];
contB[j]++;
if(j<rep->nLevels-1){
bitset(bits_BS,contB[j]-1);
}
break;
}
j--;
}
}
bitset(bits_BS,bits_BS_len-1);
rep->bS = createBitRankW32Int(bits_BS, bits_BS_len , 1, 20);
rep->rankLevels = (uint *) malloc(sizeof(uint)*rep->nLevels);
for(j=0;j<rep->nLevels;j++)
rep->rankLevels[j]= rank(rep->bS, rep->levelsIndex[j]-1);
free(cont);
free(contB);
free(levelSizeAux);
free(kvalues);
return rep;
}
int main(int argc, char* argv[])
{
FILE* debugfile;
disk_t* disk;
unt8* buffer;
unt8* clusterbuffer;
unsigned i;
unsigned j;
unsigned k;
void* fat_bitmap;
void* trifs_bitmap;
unsigned diskbitmapsize;
unt32* cluster_buffer;
printf("Trinary File System Tools : Convert FAT32 to TriFS\n\r"
"Copryright (c) 2003, Rudy Koot (Trinary Technologies)\n\r"
"\n\r"
"This program is free software; you can redistribute it and/or modify\n\r"
"it under the terms of the GNU General Public License as published by\n\r"
"the Free Software Foundation; either version 2 of the License, or\n\r"
"(at your option) any later version.\n\r");
disk = disk_open(argv[1]);
disk->blocksize = 512;
fat_super = malloc(disk->blocksize);
disk_read(disk, ((unt8*)(fat_super)), 0, 1);
printf("\n\rBIOS Parameter Block:\n\r");
printf(" File System Creator: %.8s\n\r", fat_super->system);
printf(" Bytes per Sector : %i\n\r", fat_super->bytespersector);
printf(" Sectors per Cluster: %i\n\r", fat_super->sectorspercluster);
printf(" Reserved Sectors : %i\n\r", fat_super->reservedsectors);
printf(" Number of FATs : %i\n\r", fat_super->numberoffats);
printf(" Root Entries : %i\n\r", fat_super->rootentries);
printf(" Legacy Sectors : %i\n\r", fat_super->legacysectors);
printf(" Media : %X\n\r", fat_super->media);
printf(" Legacy FAT Size : %i\n\r", fat_super->legacyfatsize);
printf(" Sectors Per Track : %i\n\r", fat_super->sectorspertrack);
printf(" Number of Tracks : %i\n\r", fat_super->numberoftracks);
printf(" Hidden Sectors : %i\n\r", fat_super->hiddensectors);
printf(" Total Sectros : %i\n\r", fat_super->totalsectors);
printf(" FAT Size : %i\n\r", fat_super->fatsize);
printf(" Extension Flags : %i\n\r", fat_super->extensionflags);
printf(" File System Version: %X\n\r", fat_super->filesystemversion);
printf(" Root Cluster : %i\n\r", fat_super->rootcluster);
printf(" File System Info : %i\n\r", fat_super->fsinfo);
printf(" Boot Sector Backup : %i\n\r", fat_super->bootsectorbackup);
printf(" Drive Number : %X\n\r", fat_super->drivenumber);
printf(" Boot Signature : %X\n\r", fat_super->bootsignature);
printf(" Volume ID : %X\n\r", fat_super->volid);
printf(" Label : %.11s\n\r", fat_super->label);
printf(" File System Type : %.8s\n\r", fat_super->fstype);
printf("\n\rFile System Layout:\n\r");
printf(" %.10i - %.10i: Boot Sector\n\r", 0, fat_super->reservedsectors - 1);
printf(" %.10i - %.10i: FAT 1\n\r", fat_super->reservedsectors, fat_super->fatsize + fat_super->reservedsectors - 1);
printf(" %.10i - %.10i: FAT 2\n\r", fat_super->fatsize + fat_super->reservedsectors, 2 * fat_super->fatsize + fat_super->reservedsectors - 1);
printf(" %.10i - %.10i: Data Area\n\r", 2 * fat_super->fatsize + fat_super->reservedsectors, fat_super->totalsectors - 1);
/* Setup the Conversion Table. */
ct.blocksize = 4096;
ct.bandsize = (256 * 1024 * 1024) / ct.blocksize;
ct.trifsmetadata = 4;
ct.sectorsize = fat_super->bytespersector;
ct.clustersize = (fat_super->bytespersector * fat_super->sectorspercluster) / ct.blocksize;
ct.fatmetadata = ((fat_super->reservedsectors + fat_super->fatsize * fat_super->numberoffats) * fat_super->bytespersector) / ct.blocksize;
ct.disksize = (fat_super->totalsectors * fat_super->bytespersector) / ct.blocksize;
if (((fat_super->reservedsectors + fat_super->fatsize * fat_super->numberoffats) * fat_super->bytespersector) % ct.blocksize != 0)
{
printf("Sorry the FAT alignment of this disk SUCKS!!!");
exit(1);
}
if (ct.blocksize > (fat_super->bytespersector * fat_super->sectorspercluster))
{
printf("The new Block Size must be small or equal to the original Cluster Size.");
exit(1);
}
printf("\n\rConversion Settings:\n\r");
printf(" Block Size : %i bytes\n\r", ct.blocksize);
printf(" Band Size : %i blocks\n\r", ct.bandsize);
printf(" Sector Size : %i bytes\n\r", ct.sectorsize);
printf(" Cluster Size : %i blocks\n\r", ct.clustersize);
printf(" FAT Metadata Size : %i blocks\n\r", ct.fatmetadata);
printf(" TriFS Metadata Size: %i blocks\n\r", ct.trifsmetadata);
printf(" Disk Size : %i blocks\n\r", ct.disksize);
printf("\n\rConverting File System:\n\r");
printf(" Loading FAT\n\r");
fat_buffer = malloc(fat_super->fatsize * fat_super->bytespersector);
disk_read(disk, fat_buffer, fat_super->reservedsectors, fat_super->fatsize);
/* Build the FAT Bitmap, by reserving the FAT Meta Data and the allocated *
* freestore. */
printf(" Building FAT Bitmap\n\r");
diskbitmapsize = ((fat_super->totalsectors * fat_super->bytespersector) / ct.blocksize + 7) / 8;
fat_bitmap = malloc(diskbitmapsize);
memset(fat_bitmap, 0, diskbitmapsize);
for (i = 0; i < ct.fatmetadata; i++)
{
bitset(fat_bitmap, i);
}
for (i = 0; i < (fat_super->fatsize * fat_super->bytespersector) / 4; i++)
{
if (fat_buffer[i] != 0)
{
for (j = 0; j < ct.clustersize; j++)
{
bitset(fat_bitmap, i * ct.clustersize + j);
}
}
}
/* Build the TriFS Bitmap, by reserving the TriFS Meta Data. */
printf(" Building TriFS Bitmap\n\r");
trifs_bitmap = malloc(diskbitmapsize);
memset(trifs_bitmap, 0, diskbitmapsize);
for (i = 0; i < ct.disksize; i += ct.bandsize)
{
for (j = 0; j < ct.trifsmetadata; j++)
{
bitset(trifs_bitmap, i + j);
}
}
printf(" Moving Conflicting Clusters\n\r");
disk->blocksize = ct.blocksize;
buffer = malloc(ct.clustersize * ct.blocksize);
for (i = 0; i < ct.disksize; i++)
{
if (bitget(trifs_bitmap, i) && bitget(fat_bitmap, i) && block2cluster(i) != 0)
{
printf(" %i (%i) ", i, block2cluster(i));
for (j = 0; j < (fat_super->fatsize * fat_super->bytespersector) / 4; j++)
{
if (fat_buffer[j] == 0)
{
printf("=> %i (%i)\n\r", j, cluster2block(j));
disk_read(disk, buffer, i, ct.clustersize);
disk_write(disk, buffer, cluster2block(j), ct.clustersize);
for (k = 0; k < (fat_super->fatsize * fat_super->bytespersector) / 4; k++)
{
if (fat_buffer[k] == block2cluster(i))
{
fat_buffer[k] = j;
break;
}
}
fat_buffer[j] = block2cluster(i);
break;
}
}
}
}
printf(" Building Directory Structure\n\r");
fat_builddirectory(disk, fat_super->rootcluster, ":", 0);
printf(" Updating Metadata\n\r");
debugfile = fopen("c:\\fat.bitmap.dump", "wb");
fwrite(fat_bitmap, diskbitmapsize, 1, debugfile);
fclose(debugfile);
debugfile = fopen("c:\\trifs.bitmap.dump", "wb");
fwrite(trifs_bitmap, diskbitmapsize, 1, debugfile);
fclose(debugfile);
return 0;
}
void *
memalloc(size_t nb, long flg)
{
struct mempool *physpool = &memphyspool;
struct mempool *virtpool = &memvirtpool;
struct memmag **magtab = (struct maghdr **)virtpool->tab;
void *ptr = NULL;
size_t sz = max(MEMMIN, nb);
size_t bsz;
unsigned long slab = 0;
unsigned long bkt = memcalcbkt(sz);
#if defined(MEMPARANOIA)
unsigned long *bmap;
#endif
struct memmag *mag;
uint8_t *u8ptr;
unsigned long ndx;
unsigned long n;
struct membkt *hdr = &virtpool->tab[bkt];
mtxlk(&hdr->lk);
if (bkt >= MEMSLABMINLOG2) {
ptr = slaballoc(physpool, sz, flg);
if (ptr) {
#if (!MEMTEST)
vminitvirt(&_pagetab, ptr, sz, flg);
#endif
slab++;
mag = memgetmag(ptr, virtpool);
mag->base = (uintptr_t)ptr;
mag->n = 1;
mag->ndx = 1;
mag->bkt = bkt;
mag->prev = NULL;
mag->next = NULL;
}
} else {
mag = magtab[bkt];
if (mag) {
ptr = mempop(mag);
if (memmagempty(mag)) {
if (mag->next) {
mag->next->prev = NULL;
}
magtab[bkt] = mag->next;
}
} else {
ptr = slaballoc(physpool, sz, flg);
if (ptr) {
#if (!MEMTEST)
vminitvirt(&_pagetab, ptr, sz, flg);
#endif
u8ptr = ptr;
slab++;
bsz = (uintptr_t)1 << bkt;
n = (uintptr_t)1 << (MEMSLABMINLOG2 - bkt);
mag = memgetmag(ptr, virtpool);
mag->base = (uintptr_t)ptr;
mag->n = n;
mag->ndx = 1;
mag->bkt = bkt;
for (ndx = 1 ; ndx < n ; ndx++) {
u8ptr += sz;
mag->ptab[ndx] = u8ptr;
}
mag->prev = NULL;
mag->next = NULL;
if (n > 1) {
mag->next = magtab[bkt];
magtab[bkt] = mag;
}
}
}
}
if (ptr) {
#if defined(MEMPARANOIA)
#if ((MEMSLABMINLOG2 - MEMMINLOG2) < (LONGSIZELOG2 + 3))
bmap = &mag->bmap;
#else
bmap = mag->bmap;
#endif
ndx = ((uintptr_t)ptr - mag->base) >> bkt;
if (bitset(bmap, ndx)) {
kprintf("duplicate allocation %p (%ld/%ld)\n",
ptr, ndx, mag->n);
panic(k_curproc->pid, TRAPNONE, -EINVAL);
}
setbit(bmap, ndx);
#endif /* defined(MEMPARANOIA) */
if (!slab && (flg & MEMZERO)) {
kbzero(ptr, 1UL << bkt);
}
}
if (!ptr) {
panic(k_curproc->pid, TRAPNONE, -ENOMEM);
}
mtxunlk(&hdr->lk);
return ptr;
}
/*===========================================================================*/
short print_idinfo(FILE *fp,identifier_info_type *idinfo,int col0,int indent)
{
object_table_type ooo;
char *msg;
Boolean is_array,is_scalar,is_double;
void *vvv;
short iii,jjj,kkk,mmm,nnn,col,www,wix,extra;
char symbolic[90];
/*-------------------------------------------------------*/
col=col0;
extra=0;
DECIDE_IS_ARRAY_IS_DOUBLE(idinfo);
is_scalar = (Boolean) (!is_array);
fprintf(fp,"%c",OPENPAREN);
++col;
if (bitset(debug_flagword,DBG_XEQ)){
col += (3+HEX_DEC_PLACES);
fprintf_hex_pointer(fp,(*idinfo).ptr.vvv);
fprintf(fp,"-->");}
if ((*idinfo).ptr.vvv==((void *) NULL)){
fprintf(fp,"NULL"); col += 4;}
else{
ooo = cvt_to_object_table_type((*idinfo).flags);
mmm=nnn=1;
if (is_array && (ooo!=OBJ_SOFF_DATA)){
mmm = dim_range((*idinfo).index.dims.first);
nnn = dim_range((*idinfo).index.dims.second);}
if (is_array && (ooo!=OBJ_SOFF_DATA)){
fprintf(fp,"%c",OPENBRACKET); ++col;}
for (www=kkk=iii=0;iii<mmm;++iii){
if (iii>0) {
fprintf(fp,","); ++col;
if ((col+nnn*www)>88){
col=indent; fprintf(fp,"\n"); ++extra;
for (wix=0;wix<indent;++wix) fprintf(fp," ");}}
if (is_double && (ooo!=OBJ_SOFF_DATA)){
fprintf(fp,"%c",OPENBRACKET); ++col;}
for (jjj=0;jjj<nnn;++jjj,++kkk){
if (jjj>0) {fprintf(fp,","); ++col;}
vvv=arr_addr((*idinfo).ptr.vvv,kkk,ooo);
msg=enk_aux_val(vvv,ooo);
www=strlen(msg);
if ((col+www)>88){
col=www+indent; fprintf(fp,"\n"); ++extra;
for (wix=0;wix<indent;++wix) fprintf(fp," ");}
else col += www;
fprintf(fp,"%s",msg);}
if (is_double && (ooo!=OBJ_SOFF_DATA)) fprintf(fp,"%c",CLOSEBRACKET);}
if (is_array && (ooo!=OBJ_SOFF_DATA)) fprintf(fp,"%c",CLOSEBRACKET);}
if (col>40){
col=indent; fprintf(fp,"\n"); ++extra;
for (wix=0;wix<indent;++wix) fprintf(fp," ");}
if (is_scalar) {fprintf(fp,",SCALAR"); col+=7;}
else if (is_double)
fprintf(fp,",ARRAY[%d..%d,%d..%d]",
(int) (*idinfo).index.dims.first.lower,
(int) (*idinfo).index.dims.first.upper,
(int) (*idinfo).index.dims.second.lower,
(int) (*idinfo).index.dims.second.upper);
else
fprintf(fp,",ARRAY[%d..%d]",
(int) (*idinfo).index.dims.first.lower,
(int) (*idinfo).index.dims.first.upper);
fprintf(fp,",%d",(int) (*idinfo).scope_level);
fprintf(fp,",\"%s\"",(*idinfo).name);
if (bitset(debug_flagword,DBG_XEQ))
fprintf(fp,",0x%02x",(unsigned int) (*idinfo).flags);
make_symbolic_type_list(symbolic,(*idinfo).flags);
fprintf(fp,",[%s]%c",symbolic,CLOSEPAREN);
/*-------------------------------------------------------*/
return(extra);
}
perm createPerm(uint *elems, uint nelems, uint t)
{
perm P;
uint *b, *baux, nextelem, i, j, bptr,
aux, antbptr,nbwdptrs, elem,nbits, firstelem, cyclesize;
auxbwd *auxbwdptr;
P = malloc(sizeof(struct sperm));
P->elems = elems;
P->nelems = nelems;
nbits = P->nbits = bits(nelems-1);
P->t = t;
if (t==1) {
P->bwdptrs = malloc((((unsigned long long)nelems*nbits+W-1)/W)*sizeof(uint));
P->nbwdptrs = nelems;
for (i=0; i<nelems; i++)
bitput(P->bwdptrs, bitget(elems, i*nbits, nbits)*nbits, nbits, i);
P->bmap = NULL;
}
else {
auxbwdptr = malloc(sizeof(auxbwd)*(t+((int)ceil((double)nelems/t))));
b = calloc(((nelems+W-1)/W), sizeof(uint));
baux = calloc(((nelems+W-1)/W), sizeof(uint));
nbwdptrs = 0;
for (i = 0; i < nelems; i++) {
if (bitget1(baux,i) == 0) {
nextelem = j = bptr = antbptr = i;
aux = 0;
bitset(baux, j);
cyclesize = 0;
firstelem = j;
while ((elem=bitget(elems,j*nbits,nbits)) != nextelem) {
j = elem;
bitset(baux, j);
aux++;
if (aux >= t) {
auxbwdptr[nbwdptrs].key = j;
auxbwdptr[nbwdptrs++].pointer = bptr;
antbptr = bptr;
bptr = j;
aux = 0;
bitset(b, j);
}
cyclesize++;
}
if (cyclesize >= t) {
auxbwdptr[nbwdptrs].key = nextelem;
auxbwdptr[nbwdptrs++].pointer = bptr;
bitset(b, nextelem);
}
}
}
qsort(auxbwdptr, nbwdptrs, sizeof(auxbwd), &compare);
aux = ((unsigned long long)nbwdptrs*P->nbits+W-1)/W;
P->bwdptrs = malloc(sizeof(uint)*aux);
P->nbwdptrs = nbwdptrs;
for (i = 0; i < nbwdptrs; i++)
bitput(P->bwdptrs, i*nbits, nbits, auxbwdptr[i].pointer);
P->bmap = createBitmap(b, nelems, false);
free(baux);
free(auxbwdptr);
}
#ifdef QUERYREPORT
P->cont_invperm = 0;
P->cont_perm = 0;
#endif
return P;
}
symbolnode_ref insert_symbolnode(symboltable_ref sym_tab,
astree astnode, stringnode_ref strnode, int att_i){
uintptr_t node_addr;
int bucket_number = 0;
symbolnode_ref new_symnode;
symbolnode_ref ptr;
symbolnode_ref tmp_symnode;
double hash_percent_full = 0;
assert(strnode != NULL);
assert(astnode != NULL);
new_symnode = calloc(1, sizeof(symbolnode_ref) );
node_addr = (uintptr_t) strnode;
new_symnode->hashcode = node_addr;
new_symnode->filenr = astnode->filenr;
new_symnode->linenr = astnode->linenr;
new_symnode->offset = astnode->offset;
new_symnode->lexinfo = astnode->lexinfo;
new_symnode->sn = strnode;
new_symnode->attribs = bitset(att_i);
bucket_number = node_addr%sym_tab->size;
tmp_symnode = sym_tab->buckets[bucket_number];
for(ptr = sym_tab->buckets[bucket_number];
ptr != NULL; ptr = ptr->next){
if(strcmp(ptr->lexinfo, new_symnode->lexinfo)){
sym_tab->buckets[bucket_number] = tmp_symnode;
return ptr;
}
}
hash_percent_full = (double) sym_tab->entries/
(double) sym_tab->size;
if(hash_percent_full >= HASH_LIMIT){
sym_tab->size *= 2;
sym_tab->size++;
sym_tab->buckets = realloc(sym_tab->buckets,
(sizeof(symbolnode_ref)*sym_tab->size));
}
tmp_symnode = sym_tab->buckets[bucket_number];
if(tmp_symnode == NULL){
new_symnode->next = NULL;
new_symnode->prev = NULL;
sym_tab->buckets[bucket_number] = new_symnode;
sym_tab->entries++;
}else{
symbolnode_ref first = sym_tab->buckets[bucket_number];
for(tmp_symnode = sym_tab->buckets[bucket_number];
tmp_symnode != NULL; tmp_symnode = tmp_symnode->next);
tmp_symnode->next = new_symnode;
new_symnode->next = NULL;
new_symnode->prev = NULL;
sym_tab->entries++;
sym_tab->buckets[bucket_number] = first;
}
return NULL;
}
//Fastest version
void systimer_Handler_3(void)
{
bitset(PISCR, PISCR_PS);
__sys_mickey++;
}
WaveletTreeNoptrs::WaveletTreeNoptrs(uint * symbols, size_t n, BitSequenceBuilder * bmb, Mapper * am, bool deleteSymbols) : Sequence(n) {
bmb->use();
this->n=n;
this->am=am;
am->use();
for(uint i=0;i<n;i++)
symbols[i] = am->map(symbols[i]);
max_v=max_value(symbols,n);
height=bits(max_v);
uint *occurrences=new uint[max_v+1];
for(uint i=0;i<=max_v;i++) occurrences[i]=0;
for(uint i=0;i<n;i++)
occurrences[symbols[i]]++;
uint to_add=0;
for(uint i=0;i<max_v;i++)
if(occurrences[i]==0) to_add++;
uint * new_symb = new uint[n+to_add];
for(uint i=0;i<n;i++)
new_symb[i] = symbols[i];
if (deleteSymbols) {
delete [] symbols;
symbols = 0;
}
to_add = 0;
for(uint i=0;i<max_v;i++)
if(occurrences[i]==0) {
occurrences[i]++;
new_symb[n+to_add]=i;
to_add++;
}
uint new_n = n+to_add;
for(uint i=1;i<=max_v;i++)
occurrences[i] += occurrences[i-1];
uint *oc = new uint[(new_n+1)/W+1];
for(uint i=0;i<(new_n+1)/W+1;i++)
oc[i] = 0;
for(uint i=0;i<=max_v;i++)
bitset(oc,occurrences[i]-1);
bitset(oc,new_n);
occ = bmb->build(oc,new_n+1);
delete [] occurrences;
this->n = new_n;
uint ** _bm=new uint*[height];
for(uint i=0;i<height;i++) {
_bm[i] = new uint[new_n/W+1];
for(uint j=0;j<new_n/W+1;j++)
_bm[i][j]=0;
}
build_level(_bm,new_symb,0,new_n,0);
bitstring = new BitSequence*[height];
for(uint i=0;i<height;i++) {
bitstring[i] = bmb->build(_bm[i],new_n);
delete [] _bm[i];
}
delete [] _bm;
if (!deleteSymbols)
for(uint i=0;i<n;i++)
symbols[i] = am->unmap(symbols[i]);
// delete [] new_symb; // already deleted in build_level()!
delete [] oc;
bmb->unuse();
}
void drawwavform(void * renderbutton) {
unsigned long x,i,y1,y2;
unsigned long counter;
unsigned long smoothval;
unsigned char * ptr;
int zoom;
wavbuf * wavbuff;
wavbuff = JWGetData(renderbutton);
zoom = atoi(JTxfGetText(wavbuff->zoominput));
//printf("Zoom is %d\n", zoom);
if(zoom > 200)
zoom = 200;
else if(zoom < 1)
zoom = 1;
//Clear all bitmap bits
memset(bitmap+2, 0, COLS * ROWS * 8);
ptr = wavbuff->wavbuffer;
y1 = *ptr;
counter = 0;
//for(x = 0; x < wavbuff->totalbytes; x++) {
for(x = 0; x<COLS*8;x++) {
if(counter > wavbuff->totalbytes)
break;
for(i=0;i<zoom;i++) {
ptr += i;
counter += i;
if(counter > wavbuff->totalbytes)
break;
smoothval += *ptr;
}
smoothval /= i;
y2 = smoothval;
if(y1>y2) {
while(y1 != y2) {
//printf("drawing line %d\n", x);
bitset(x,y1,ON);
y1--;
}
} else if(y2>y1){
while(y2 != y1) {
//printf("drawing line %d\n", x);
bitset(x,y1,ON);
y1++;
}
} else
bitset(x,y1,ON);
y1 = y2;
}
//printf("done!\n");
JWReDraw(image);
}
/* write fn to device */
int nrf_program_nrf24lu(devp dev, const char *fn){
unsigned char cmd[2], data[64], *flash_copy, dirty_bv[64];
FILE *fp = NULL;
int ecode, block, page, rc;
unsigned int first_addr, last_addr;
IHexRecord record;
printf("Programming nRF24LU\n");
/* read the entire ROM into memory
*
* Why? Because Nordic doesn't have decent software. Their flash write
* command erases the page first, instead of letting me decide if the page
* should be erased first.
*
* Byte-level writing is offered by using a read-modify-write operation.
* It would be smarter to operate on a per-page basis, but Intel HEX files
* are not guaranteed to have sequential addressing. Since Nordic screwed
* up and wild IHX files are adhoc, let's work with the whole 32k flash
* memory at once.
*/
if((flash_copy = malloc(FLASH_SIZE)) == NULL){
ecode = -4;
goto err;
}
printf("[*] Reading device.\n");
for(block = 0; block < 0x200; block++){
/* set address MSB */
if((block % 0x100) == 0){
cmd[0] = 0x06;
cmd[1] = (unsigned char)(block / 256);
if(nrf_cmd(dev, cmd, 2, data, 1)){
ecode = -2;
goto err;
}
}
/* request the block */
cmd[0] = 0x03;
cmd[1] = (unsigned char)block;
if(nrf_cmd(dev, cmd, 2, &flash_copy[block2addr(block)], 64)){
ecode = -2;
goto err;
}
}
/* overwrite in-memory with IHX contents */
if((fp = fopen(fn, "r")) == NULL){
ecode = -1;
goto err;
}
memset(dirty_bv, 0, sizeof(dirty_bv));
while((rc = Read_IHexRecord(&record, fp)) == IHEX_OK &&
record.type != IHEX_TYPE_01){
if(record.type != IHEX_TYPE_00){
/* we cannot process segment or linear ihex files */
printf("[!] IHX file contains segment or linear addressing.\n");
ecode = -5;
goto err;
}
/* first and last byte that is touched by this record */
first_addr = record.address;
last_addr = record.address + record.dataLen - 1;
if(!addr_valid(first_addr) || !addr_valid(last_addr)){
printf("[!] IHX record touches invalid or protected bytes: "
"0x%04X - 0x%04X\n", first_addr, last_addr);
ecode = -6;
goto err;
}
/* only write if the ihx record changes memory */
if(memcmp(&flash_copy[first_addr], record.data, record.dataLen)){
/* copy record into memory */
memcpy(&flash_copy[first_addr], record.data, record.dataLen);
/* mark dirty blocks */
for(block = addr2block(first_addr); block <= addr2block(last_addr);
block++){
/* check the block since we might have some *really* long
* record
*/
if(!addr_valid(block2addr(block))){
printf("[!] IHX record touches invalid or protected bytes:"
" 0x%04X\n", block2addr(block));
ecode = -6;
goto err;
}
bitset(dirty_bv, block);
}
}
}
if(rc != IHEX_OK && rc != IHEX_ERROR_EOF){
/* we had an error that isn't EOF */
ecode = -4;
goto err;
}
/* write to flash */
printf("[*] Writing device");
fflush(stdout);
for(page = 0; page < 64; page++){
/* Each page is 8 blocks, which conviently maps to our dirty bit vector
* on byte boundries.
*/
if(dirty_bv[page]){
printf(".");
fflush(stdout);
if(nrf_write_page(dev, page, &flash_copy[page2addr(page)])){
printf("\n[!] Write failed.\n");
ecode = -7;
goto err;
}
}
}
printf("\n");
/* verify */
printf("[*] Verifying device");
fflush(stdout);
for(block = 0; block < 512; block++){
if(bitisset(dirty_bv, block)){
if(nrf_compare_block(dev, block, &flash_copy[block2addr(block)])){
printf("\n[!] Block %d failed.\n", block);
ecode = -8;
goto err;
} else {
printf(".");
fflush(stdout);
}
}
}
printf("\n");
ecode = 0;
err:
if(flash_copy){
free(flash_copy);
}
if(fp){
fclose(fp);
}
return ecode;
}
Graph *
geo(long seed, geo_parms *pp)
{
double p,d,L,radius,r;
u_char *occ;
register int scale;
unsigned nbytes, index, x, y;
u_long units,pertrange;
int mallocd;
register i,j;
Graph *G;
Vertex *up,*vp;
char namestr[128];
gb_trouble_code = 0;
if (seed) /* zero seed means "already init'd */
gb_init_rand(seed);
scale = pp->scale;
L = sqrt(2.0) * scale;
gb_trouble_code = 0;
if ((pp->alpha <= 0.0) || (pp->alpha > 1.0)) gb_trouble_code=bad_specs+1;
if (pp->gamma < 0.0) gb_trouble_code=bad_specs+GEO_TRBL;
if (pp->beta < 0.0) gb_trouble_code=bad_specs+GEO_TRBL;
if (pp->n > (scale * scale)) gb_trouble_code=bad_specs+GEO_TRBL;
if (gb_trouble_code)
return NULL;
radius = pp->gamma * L; /* comes in as a fraction of diagonal */
#define posn(x,y) ((x)*scale)+(y)
#define bitset(v,i) (v[(i)/NBBY]&(1<<((i)%NBBY)))
#define setbit(v,i) v[(i)/NBBY] |= (1<<((i)%NBBY))
/* create a new graph structure */
if ((G=gb_new_graph(pp->n)) == NULL)
return NULL;
nbytes = ((scale*scale)%NBBY ? (scale*scale/NBBY)+1 : (scale*scale)/NBBY);
if (nbytes < STACKMAX) { /* small amount - just do it in the stack */
occ = (u_char *) alloca(nbytes);
mallocd = 0;
} else {
occ = (u_char *) malloc(nbytes);
mallocd = 1;
}
for (i=0; i<nbytes; i++) occ[i] = 0;
/* place each of n points in the plane */
for (i=0,vp = G->vertices; i<pp->n; i++,vp++) {
sprintf(namestr,"%d",i); /* name is just node number */
vp->name = gb_save_string(namestr);
do {
vp->xpos = gb_next_rand()%scale; /* position: 0..scale-1 */
vp->ypos = gb_next_rand()%scale; /* position: 0..scale-1 */
index = posn(vp->xpos,vp->ypos);
} while (bitset(occ,index));
setbit(occ,index);
}
/* Now go back and add the edges */
for (i=0,up = G->vertices; i<(pp->n)-1; i++,up++)
for (j=i+1, vp = &G->vertices[i+1]; j<pp->n; j++,vp++) {
d = distance(up,vp);
switch (pp->method) {
case RG2: /* Waxman's */
d = randfrac()*L;
/* fall through */
case RG1: /* Waxman's */
p = pp->alpha * exp(-d/(L*pp->beta));
break;
case RANDOM: /* the classic */
p = pp->alpha;
break;
case EXP:
p = pp->alpha * exp(-d/(L-d));
break;
case DL: /* Doar-Leslie */
p = pp->alpha * (pp->gamma/pp->n) * exp(-d/(L*pp->beta));
break;
case LOC: /* Locality model, two probabilities */
if (d <= radius) p = pp->alpha;
else p = pp->beta;
break;
default:
die("Bad edge method in geo()!");
}
if (randfrac() < p)
gb_new_edge(up,vp,(int)rint(d));
}
/* Fill in the "id" string to say how the graph was created */
G->Gscale = scale;
sprintf(G->id,"geo(%ld,", seed);
i = strlen(G->id);
i += printparms(G->id+i,pp);
G->id[i] = ')';
G->id[i+1] = (char) 0;
strcpy(G->util_types,GEO_UTIL);
/* clean up */
if (mallocd) free(occ);
return G;
}
void ObjectPool::setused(size_t pos, char flag)
{
bitset(&_pool_status, pos, flag);
}
wt_node_internal::wt_node_internal(uchar * symbols, size_t n, uint l, wt_coder * c, BitSequenceBuilder * bmb, size_t left, uint *done) {
uint * ibitmap = new uint[n/W+1];
for(size_t i=0;i<n/W+1;i++)
ibitmap[i]=0;
for(size_t i=0;i<n;i++)
if(c->is_set((uint)symbols[i + left],l))
bitset(ibitmap,i);
bitmap = bmb->build(ibitmap, n);
delete [] ibitmap;
size_t count_right = bitmap->rank1(n-1);
size_t count_left = n-count_right;
for (size_t i=0;i<n;i++)
set_field(done, 1, i+left, 0);
for (size_t i = 0; i < n; ) {
size_t j = i;
uchar swap = symbols[j+left];
// swapping
while (!get_field(done, 1, j+left)) {
ulong k = j;
if (!c->is_set(swap,l))
j = bitmap->rank0(k)-1;
else
j = count_left + bitmap->rank1(k)-1;
uchar temp = symbols[j+left];
symbols[j+left] = swap;
swap = temp;
set_field(done,1,k+left,1);
}
while (get_field(done,1,i+left))
++i;
}
bool match_left = true, match_right = true;
for (size_t i=1; i < count_left; i++)
if (symbols[i+left] != symbols[i+left-1])
match_left = false;
for (size_t i=count_left + 1; i < n; i++)
if (symbols[i+left] != symbols[i+left-1])
match_right = false;
if(count_left>0) {
if(match_left/* && c->done(left[0],l+1)*/)
left_child = new wt_node_leaf((uint)symbols[left], count_left);
else
left_child = new wt_node_internal(symbols, count_left, l+1, c, bmb, left, done);
}
else {
left_child = NULL;
}
if(count_right>0) {
if(match_right/* && c->done(right[0],l+1)*/)
right_child = new wt_node_leaf((uint)symbols[left+count_left], count_right);
else
right_child = new wt_node_internal(symbols, count_right, l+1, c, bmb, left+count_left, done);
}
else {
right_child = NULL;
}
}
DAC_VLS::DAC_VLS(int *list, uint l_Length, uint log_r, uint max_seq_length){
uint *levelSizeAux;
uint *contB;
uint bits_BS_len = 0;
listLength =0;
nLevels = max_seq_length;
levelSizeAux = new uint[nLevels];
for(uint i=0;i<nLevels;i++)
levelSizeAux[i]=0;
//Space needed for each level
for(uint i=0;i<l_Length;i++){
for(uint j=0; j < nLevels;j++){
if(list[i] >= 0){
levelSizeAux[j]++;
i++;
}
else
break;
}
listLength++;
}
levelsIndex = new uint[nLevels+1];
bits_BS_len =0;
base_bits = log_r;
//space needed for levels in bits
uint tamLevels =0;
for(uint i=0;i<nLevels;i++)
tamLevels+=base_bits*levelSizeAux[i];
tamCode=tamLevels;
levelsIndex[0]=0;
contB = new uint[nLevels];
for(uint j=0;j<nLevels;j++){
levelsIndex[j+1]=levelsIndex[j] + levelSizeAux[j];
contB[j]=levelsIndex[j];
}
//init levels
levels = new uint[tamLevels/W+1];
for(uint i=0; i< (tamLevels/W+1); i++)
levels[i] = 0;
//size of the bitmap
bits_BS_len = levelsIndex[nLevels-1]+1;
//tha last position is 0. this save us time later in the queries
//init bitmap
uint * bits_BS = new uint[bits_BS_len/W+1];
for(uint i=0; i<((bits_BS_len)/W+1);i++)
bits_BS[i]=0;
for(uint i=0;i<l_Length;i++){
for(uint j=0; j<nLevels; j++){
if(list[i]>=0){
set_field(levels, base_bits, contB[j], (uint)list[i]);
contB[j]++;
i++;
if(j>0)
bitset(bits_BS, contB[j-1]-1);
}
else
break;
}
}
//set the bitmap data structure
bitset(bits_BS,bits_BS_len-1);
bS = new BitSequenceRG(bits_BS, bits_BS_len , 4);
rankLevels = new uint[nLevels];
rankLevels[0]=0;
for(uint j=1;j<nLevels;j++)
rankLevels[j]= bS->rank1(levelsIndex[j]-1);
delete [] contB;
delete [] levelSizeAux;
delete [] bits_BS;
}
void __leds_update(_TIMER *timer) {
oc_pwm(&oc1, &A[5], NULL, LEDS_FREQ, 0x0000);
bitset(&IEC0, 2); // enable OC1 interrupt
}
/* TODO: deal with unmapping/freeing physical memory */
void
kfree(void *ptr)
{
struct mempool *physpool = &memphyspool;
struct mempool *virtpool = &memvirtpool;
struct memmag *mag = memgetmag(ptr, virtpool);
unsigned long bkt = (mag) ? mag->bkt : 0;
#if defined(MEMPARANOIA)
unsigned long ndx;
unsigned long *bmap;
#endif
struct membkt *hdr = &virtpool->tab[bkt];
struct memmag *list = hdr->list;
if (!ptr || !mag) {
return;
}
mtxlk(&hdr->lk);
#if defined(MEMPARANOIA)
ndx = ((uintptr_t)ptr - mag->base) >> bkt;
#if ((MEMSLABMINLOG2 - MEMMINLOG2) < (LONGSIZELOG2 + 3))
bmap = &mag->bmap;
#else
bmap = mag->bmap;
#endif
if (!bitset(bmap, ndx)) {
kprintf("invalid free: %p (%ld/%ld)\n",
ptr, ndx, mag->n);
panic(k_curproc->pid, TRAPNONE, -EINVAL);
}
#endif
mempush(mag, ptr);
if (memmagfull(mag)) {
if (gtpow2(mag->n, 1)) {
if ((mag->prev) && (mag->next)) {
mag->prev->next = mag->next;
mag->next->prev = mag->prev;
} else if (mag->prev) {
mag->prev->next = NULL;
} else if (mag->next) {
mag->next->prev = NULL;
hdr->list = mag->next;
} else {
hdr->list = NULL;
}
}
slabfree(physpool, ptr);
mag->base = 0;
} else if (mag->ndx == mag->n - 1) {
mag->prev = NULL;
if (list) {
list->prev = mag;
}
mag->next = list;
hdr->list = mag;
}
#if defined(MEMPARANOIA)
clrbit(bmap, ndx);
#endif
mtxunlk(&hdr->lk);
return;
}
bool
CRePair::compress_pair_table()
{
uint aux,j,i;
/* Compress table of pairs */
fillBR();
uint *symbols_pair_tmp = (uint*) malloc(sizeof(uint)*(max_assigned-max_value));
for (i =0 ; i< (max_assigned-max_value) ; i++) symbols_pair_tmp[i]=0;
for (i =0 ; i< (max_assigned-max_value) ; i++)
{
aux=symbols_pair[2*i];
if (aux > max_value) symbols_pair_tmp[aux-max_value-1]++;
aux=symbols_pair[2*i+1];
if (aux > max_value) symbols_pair_tmp[aux-max_value-1]++;
}
j=0;
for (i =0 ; i< (max_assigned-max_value); i++)
{
if (symbols_pair_tmp[i] != 0) j++;
}
symbols_new_len = 2*(max_assigned-max_value)-j;
symbols_new = (uint*) malloc(sizeof(uint)*(symbols_new_len));
symbols_new_bit = new uint[((symbols_new_len+(max_assigned-max_value))/W+1)];
uint *symbols_new_value = (uint*) malloc(sizeof(uint)*(max_assigned-max_value));
for (i =0 ; i<((symbols_new_len+(max_assigned-max_value))/W+1);i++) symbols_new_bit[i]=0;
for (i =0 ; i<symbols_new_len;i++) symbols_new[i]=0;
for (i =0 ; i<(max_assigned-max_value);i++) symbols_new_value[i]=0;
j=1;
uint k1=0;
for (i =0 ; i< (max_assigned-max_value) ; i++)
{
if (symbols_pair_tmp[i] == 0)
{
symbols_new_value[i]=j;
bitset(symbols_new_bit,j-1); j++;
new_value(symbols_pair,symbols_new_value,&k1,&j,i);
}
}
uint symbols_new_bit_len = j;
free(symbols_pair_tmp);
{
// OBTAINING THE FINAL SEQUENCE
for (i =0 ; i< m ; i++)
{
if (symbols[i] > max_value)
{
cout << symbols[i] << " -> " << symbols_new_value[symbols[i]-max_value-1]+max_value << endl;
symbols[i] = symbols_new_value[symbols[i]-max_value-1]+max_value;
}
}
delete [] symbols_pair;
free(symbols_new_value);
}
{
// OBTAINING THE COMPRESSED GRAMMAR
uint *symbols_new_bit_aux = new uint [(symbols_new_bit_len/W+1)];
for (i =0 ; i<symbols_new_bit_len/W+1;i++) symbols_new_bit_aux[i]= symbols_new_bit[i];
delete [] symbols_new_bit;
symbols_new_bit=symbols_new_bit_aux;
BRR = new BitSequenceRG((uint*)symbols_new_bit, (uint)symbols_new_bit_len, 20);
delete [] symbols_new_bit;
uint max_nd = symbols_new[0];
for(uint k = 1; k<symbols_new_len; k++)
{
cerr << symbols_new[k] << endl;
if(max_nd < symbols_new[k]) max_nd = symbols_new[k];
}
cerr << "**** " << symbols_new_len << " (" << max_nd << ") ***" << endl;
final_symbols_dict = new Array(symbols_new_len, max_nd);
for(uint k=0; k<symbols_new_len; k++) final_symbols_dict->setField(k, symbols_new[k]);
free(symbols_new);
}
return true;
}
int build_il (uint *source, uint length, char *build_options, void **ail) {
printf("\n CALL TO BUILD_IL !!\n");
t_il *il;
il = (t_il *) malloc (sizeof (t_il) * 1);
*ail = il;
/** processing the parameters */
char delimiters[] = " =;";
char filename[256] = "unnamed";
int j,num_parameters;
char ** parameters;
il->path2lzmaEncoder[0]= '\0';
il->minbcssize = MINBCSSIZE;
if (build_options != NULL) {
parse_parameters(build_options,&num_parameters, ¶meters, delimiters);
for (j=0; j<num_parameters;j++) {
if ((strcmp(parameters[j], "filename") == 0 ) && (j < num_parameters-1) ) {
strcpy(filename,parameters[j+1]);
j++;
}
else if ((strcmp(parameters[j], "minbcssize") == 0 ) && (j < num_parameters-1) ) {
il->minbcssize = atoi (parameters[j+1]);
j++;
}
else if ((strcmp(parameters[j], "path2lzmaencoder") == 0 ) && (j < num_parameters-1) ) {
strcpy(il->path2lzmaEncoder, (parameters[j+1]));
j++;
}
}
/*
if (il->path2lzmaEncoder[0] == '\0') {
printf("\n path2lzmaencoder NOT PROVIDED... Cannot continue!!"); exit(0);
}
*/
free_parameters(num_parameters, ¶meters);
}
printf("\n parameters of method: filename = %s, path2lzmaencoder=%s, minbcssize = %d\n", filename,il->path2lzmaEncoder, il->minbcssize);
{ /** 4 ** creates a temporal list of occurrences of each word (block-oriented).
gives also the len of each list */
uint i;
uint **occList;
uint *lenList;
uint maxPostValue;
fprintf(stderr,"\n paso 1 ");fflush(stderr);
parseAllPostingList(&(il->nlists), &lenList, &occList, &maxPostValue, source,length);
free(source);
fprintf(stderr,"\n paso 2 ");fflush(stderr);
il->lenList = lenList;
il->maxPostingValue = maxPostValue;
printf("numOflists = %u, maxPost = %u, \n", il->nlists, maxPostValue);
//calculates an stimation of the uncompressed representation of the index (using uints per posting)
il->sizeUncompressed = sizeof(uint) * (il->nlists) + //sizeoflenList
sizeof(uint*) * (il->nlists); //pointers to each posting (occs[i])
for (i=0; i< il->nlists;i++) { il->sizeUncompressed += (lenList[i] * sizeof(uint));}
fprintf(stderr,"stimated mem-usage of uncompressed posting-lists = %u bytes\n", il->sizeUncompressed);
/** 5 ** Encoding the occurrences **/
il->occs = (uint *) malloc (sizeof(uint) * (il->nlists+1));
//uint *numAbsSamplesperID = (uint *) malloc (sizeof(uint) * (il->nlists));
/** 5.b **
Computes the size of bc vector by simulating encoding process of gaps.
Sets also bitmaps for those terms indexed with a bitmap.
Computes and sets the values for "occs[]".
*/
uint bcssize=0;
{
uint nwords = il->nlists;
uint id,j;
uint prevvalue, gap, numbytes;
uint len, sampleP;
uint counterBCcodes =0;
uint counterBitmaps=0;
for (id=0; id<nwords; id++) {
len= il->lenList[id];
prevvalue= 0;
il->occs[id] = bcssize;
for (j=0; j<len; j++){
gap = occList[id][j]-prevvalue;
prevvalue = occList[id][j];
SIZE_DEC_TO_BC(gap,numbytes);
bcssize += numbytes;
counterBCcodes++;
}
}
il->occs[nwords] = bcssize;
fprintf(stderr,"\n Number of gaps to store is = %d",counterBCcodes);
fprintf(stderr,"\n Size of bcs Vector should be %d bytes",bcssize);
}
il->bcsSize = bcssize;
il->bcs = (byte *) malloc (sizeof(byte) * il->bcsSize);
/** 5.c ** encodes gaps into bcs */
{
uint nwords = il->nlists;
byte *bcs = il->bcs;
uint id,j;
uint prevvalue, gap;
uint len;
uint bcpos=0;
for (id=0; id<nwords; id++) {
len= il->lenList[id];
prevvalue=0;
for (j=0; j<len; j++){
gap = occList[id][j]-prevvalue;
prevvalue = occList[id][j];
DEC_TO_BC(bcs, bcpos, gap); //bcpos is increased.
}
}
fprintf(stderr,"\n Gaps were encoded with bc ==> %d bytes",bcpos);
}
/** 6. Now the lists that compress much better by using vbyte+lzma
* instead of just vbyte, are compressed with vbyte+lzma
*/
/*
{ uint j,id;
uint nwords = il->nlists;
byte *newbcs = (byte *) malloc (sizeof(byte) * il->bcsSize);
uint *newoccs = (uint *) malloc (sizeof (uint) * (nwords+1));
il->useslzma = (uint *) malloc (sizeof(uint) * ((nwords + W -1)/W));
initLzmaStruct (&il->lzmadata);
for (j=0;j< ((nwords + W -1)/W) ; j++) il->useslzma[j]= 0000;
uint bcpos=0;
int res=0;
uint lenbcs;
uint lenlzma;
for (id=0; id<nwords; id++) {
byte *inb; uint inn; //pointer to compressed file in RAM and its size.
newoccs[id]= bcpos;
lenbcs = il->occs[id+1]-il->occs[id];
byte *bcsdata = &(il->bcs[il->occs[id]]); // ** ptr to bytecoded data * /
if (lenbcs> il->minbcssize) // * CHECKS THE THRESHOLD FOR lenbcs TO CHECK IF LZMA COULD BE OK ** /
{
byte *bcsdata = &(il->bcs[il->occs[id]]); // ** ptr to bytecoded data * /
res = compressDataExt(bcsdata,lenbcs, il->path2lzmaEncoder);
if (!res) {
loadDataExt(&inb,&inn);
createLzmaExt(inb, inn, il->lzmadata);
lenlzma = sizeBytesLzmaStruct(il->lzmadata); // ** memory need if lzma is used * /
printf("\n [id= %6d/%6d] lenbcs = %8d, lenbcs+lzma = %8d ==> usesLzma = %d (f/t?) (bcpos=%d)",id, nwords,lenbcs,lenlzma, (lenlzma<lenbcs),bcpos);
if (lenlzma < lenbcs) {
writeBuffLzmaStruct(newbcs,bcpos,il->lzmadata);
bcpos +=lenlzma;
bitset(il->useslzma, id);
}
else {
memcpy( (void *) &(newbcs[bcpos]), (const void *) bcsdata, lenbcs);
bcpos +=lenbcs;
}
free(inb);
}
else {
printf("\n LZMA compression failed!. Aborting... \n");exit(0);
}
}
else {
memcpy( (void *) &(newbcs[bcpos]), (const void *) bcsdata, lenbcs);
bcpos +=lenbcs;
}
}// * for * /
newoccs[nwords]=bcpos;
free(il->bcs);
free(il->occs);
il->bcs = newbcs;
il->bcsSize = bcpos;
il->occs = newoccs;
}
}
*/
{ uint j,id;
uint nwords = il->nlists;
// byte *newbcs = (byte *) malloc (sizeof(byte) * il->bcsSize);
// uint *newoccs = (uint *) malloc (sizeof (uint) * (nwords+1));
uint bcpos=0;
int res=0;
uint lenbcs;
uint lenlzma;
tvbytelzma *data = generateData(il,nwords);
il->useslzma=NULL;
OCCLISTCHILD =occList;
res = compressedParallelFather(il,data, nwords, il->minbcssize);
if (!res) {
printf("\n compression in parallel worked fine!\n");
}
else {
printf("\n compression in parallel failed!\n");
}
initLzmaStruct (&il->lzmadata);
byte *newbcs = (byte *) malloc (sizeof(byte) * il->bcsSize);
uint *newoccs = (uint *) malloc (sizeof (uint) * (nwords+1));
il->useslzma = (uint *) malloc (sizeof(uint) * ((nwords + W -1)/W));
for (j=0;j< ((nwords + W -1)/W) ; j++) il->useslzma[j]= 0000;
for (id=0; id<nwords; id++) {
newoccs[id]= bcpos;
lenbcs = il->occs[id+1]-il->occs[id];
byte *bcsdata = &(il->bcs[il->occs[id]]); // ** ptr to bytecoded data * /
if (lenbcs != data[id].ilen) { printf("\n ilen does not coincide for term %lu", (ulong)id); exit(0);}
if (lenbcs> il->minbcssize) /** CHECKS THE THRESHOLD FOR lenbcs TO CHECK IF LZMA COULD BE OK **/
{
lenbcs = data[id].ilen;
lenlzma = data[id].olen;
printf("\n [id= %6d/%6d] lenbcs = %8d, lenbcs+lzma = %8d ==> usesLzma = %d (f/t?) (bcpos=%d)",id, nwords,lenbcs,lenlzma, (lenlzma<lenbcs),bcpos);
if (lenlzma < lenbcs) {
memcpy( (void *) &(newbcs[bcpos]), (const void *) data[id].outputdata, lenlzma);
bcpos +=lenlzma;
bitset(il->useslzma, id);
}
else {
if (lenbcs != lenlzma) {printf("\n LENBCS != LENLZMA y deberían ser iguales\n"); exit(0);}
memcpy( (void *) &(newbcs[bcpos]), (const void *) bcsdata, lenbcs);
bcpos +=lenbcs;
}
//free(data[id].outputdata);
}
else {
memcpy( (void *) &(newbcs[bcpos]), (const void *) bcsdata, lenbcs);
bcpos +=lenbcs;
}
free(data[id].outputdata);
}/* for */
newoccs[nwords]=bcpos;
//for (i=0;i< nwords; i++) free(data[i].outputdata);
free(data);
free(il->bcs);
free(il->occs);
il->bcs = newbcs;
il->bcsSize = bcpos;
il->occs = newoccs;
}
/** checking that the lists are decoded successfully *************/
fprintf(stderr,"\n ! CHECKING that the decoded lists are identical to the original ones. ");
{ //checking:: decoding a list
uint i, id ,len;
uint *list;
for (id=0;id < il->nlists;id++) {
//if ( shouldUseBitmap(il,id) ) continue;
extractList_il (*ail, id, &list, &len);
//extractList (void *ail, uint id, uint **list, uint *len)
for (i=0;i<len;i++){
if (list[i] != (occList[id][i]-DOCid_ADD) ) {
fprintf(stderr,"\n decoding of lists failed for id = %d: DIFFERENT!!: (%d,%d)",id, list[i],occList[id][i]);
exit(0);
}
}
free(list);
}
}
fprintf(stderr,"\n ! Decoding the list of occurrences worked fine (the same as previous values) ");
fprintf(stderr,"\n ! CHECKING that the decoded lists are identical to the original ones (extract_no_malloc). ");
{ //checking:: decoding a list
uint i, id ,len;
uint *list = (uint *) malloc(sizeof(uint) * (il->maxPostingValue+1));
for (id=0;id < il->nlists;id++) {
//if ( shouldUseBitmap(il,id) ) continue;
//extractList_il (*ail, id, &list, &len);
extractListNoMalloc_il(*ail,id,list,&len);
//extractList (void *ail, uint id, uint **list, uint *len)
for (i=0;i<len;i++){
if (list[i] != (occList[id][i]-DOCid_ADD)) {
//fprintf(stderr,"\n decoding of lists failed for id = %d: DIFFERENT!!",id);
fprintf(stderr,"\n decoding of lists failed for id = %d: DIFFERENT!!: (%d,%d)",id, list[i],occList[id][i]);
exit(0);
}
}
}
free(list);
}
fprintf(stderr,"\n ! Decoding the list of occurrences worked fine (the same as previous values) ");
/******************************************************/
//frees memory
for (i=0;i<il->nlists;i++) free(occList[i]);
free(occList);
}
fprintf(stderr,"\n The index has already been built!!\n");
return 0;
}
void IsometryNode::Process()
{
m_entries.clear();
int32_t currentQuadIndex = 0;
auto func = [&](CCNode* node)
{
auto sprite = dynamic_cast<CCSprite*>(node);
if(sprite == nullptr)
{
return;
}
if(!sprite->isVisible())
{
return;
}
sprite->updateTransform();
auto texture = sprite->getTexture()->getName();
auto quad = sprite->getQuad();
m_entries.push_back(IsometryNode::Entry(texture, quad));
currentQuadIndex++;
};
Each((CCNode*)this, func);
size_t entriesLeft = m_entries.size();
int beginIndex = 0;
std::vector<bool> bitset(entriesLeft);
size_t numBatches = 0;
while (entriesLeft)
{
const bool debugOutput = false;
if(debugOutput)
{
CCLOG("Batch %zi", numBatches);
}
m_buffer.Clear();
bool consecutive = true;
const auto texture = m_entries[beginIndex].texture;
if(debugOutput)
{
CCLOG("begin index = %zi(%zi)", beginIndex, texture);
}
for(size_t i = beginIndex; i < m_entries.size(); i++)
{
auto& quad = m_entries[i].quad;
if(bitset[i])
{
continue;
}
if(consecutive)
{
beginIndex = i;
}
consecutive = false;
if(m_entries[i].texture != texture)
{
continue;
}
bool canSubmitQuad = true;
for(int j = i - 1; j >= beginIndex; j--)
{
if(bitset[j])
{
continue;
}
if(QuadOverlaps(quad, m_entries[j].quad))
{
if(debugOutput)
{
CCLOG("Can't submit %zi(%zi) - itersects with %zi(%zi)", i, m_entries[i].texture, j, m_entries[j].texture);
}
canSubmitQuad = false;
break;
}
else if(debugOutput)
{
CCLOG("%zi(%zi) doesn't itersects with %zi(%zi)", i, m_entries[i].texture, j, m_entries[j].texture);
}
}
if(canSubmitQuad)
{
if(debugOutput)
{
CCLOG("Submiting %zi(%zi)", i, m_entries[i].texture);
}
m_buffer.AddQuad(quad);
bitset[i] = true;
if(i == beginIndex)
{
beginIndex++;
}
//DebugQuad(quad);
entriesLeft--;
}
}
if(m_buffer.Quads())
{
if(debugOutput)
{
CCLOG("Drawing batch with %zi elements", m_buffer.Quads());
}
getShaderProgram()->use();
m_buffer.DrawAll(texture);
numBatches++;
}
}
if(numBatches != m_numBatches)
{
m_numBatches = numBatches;
CCLOG("IsometryNode has %zi batches", m_numBatches);
}
}
//ticsa *createIntegerCSA(uint **aintVector, uint textSize, char *build_options) {
int buildIntIndex (uint *aintVector, uint n, char *build_options, void **index ){
uint textSize=n;
intVector = aintVector; //global variable
ticsa *myicsa;
myicsa = (ticsa *) malloc (sizeof (ticsa));
uint *Psi, *SAI, *C, vocSize;
register uint i, j;
uint nsHUFF;
parametersCSA(myicsa, build_options);
nsHUFF=myicsa->tempNSHUFF;
// Almacenamos o valor dalguns parametros
myicsa->suffixArraySize = textSize;
myicsa->D = (uint*) malloc (sizeof(uint) * ((textSize+31)/32));
myicsa->samplesASize = (textSize + myicsa->T_A - 1) / myicsa->T_A;// + 1;
myicsa->samplesA = (uint *)malloc(sizeof(int) * myicsa->samplesASize);
myicsa->BA = (uint*) malloc (sizeof(uint) * ((textSize+31)/32));
myicsa->samplesAInvSize = (textSize + myicsa->T_AInv - 1) / myicsa->T_AInv;
myicsa->samplesAInv = (uint *)malloc(sizeof(int) * myicsa->samplesAInvSize);
// Reservamos espacio para os vectores
Psi = (uint *) malloc (sizeof(uint) * textSize);
// CONSTRUIMOS A FUNCION C
vocSize = 0;
for(i=0;i<textSize;i++) if(intVector[i]>vocSize) vocSize = intVector[i];
C = (uint *) malloc(sizeof(uint) * (vocSize + 1)); // Para contar o 0 terminador
for(i=0;i<vocSize;i++) C[i] = 0;
for(i=0;i<textSize;i++) C[intVector[i]]++;
for (i=0,j=0;i<=vocSize;i++) {
j = j + C[i];
C[i] = j;
}
for(i=vocSize;i>0;i--) C[i] = C[i-1];
C[0] = 0;
// Construimos o array de sufixos (en Psi) - con quicksort
printf("\n\t *BUILDING THE SUFFIX ARRAY over %d integers... (with qsort)", textSize);fflush(stdout);
for(i=0; i<textSize; i++) Psi[i]=i;
qsort(Psi, textSize, sizeof(uint), suffixCmp);
printf("\n\t ...... ended.");
// CONSTRUIMOS A INVERSA DO ARRAY DE SUFIXOS
SAI = (uint *) malloc (sizeof(uint) * (textSize + 1)); // +1 para repetir na ultima posición. Evitamos un if
for(i=0;i<textSize;i++) SAI[Psi[i]] = i;
SAI[textSize] = SAI[0];
// ALMACENAMOS AS MOSTRAS DO ARRAY DE SUFIXOS
for(i=0;i<((textSize+31)/32);i++) myicsa->BA[i] = 0;
for(i=0; i<textSize; i+=myicsa->T_A) bitset(myicsa->BA, SAI[i]);
bitset(myicsa->BA, SAI[textSize-1]); // A ultima posicion sempre muestreada
//printf("TextSize = %d\n", textSize);
myicsa->bBA = createBitmap(myicsa->BA, textSize);
for(i=0,j=0; i<textSize; i++) if(bitget(myicsa->BA, i)) myicsa->samplesA[j++] = Psi[i];
// ALMACENAMOS AS MOSTRAS DA INVERSA DO ARRAY DE SUFIXOS
for(i=0,j=0;i<textSize;i+=myicsa->T_AInv) myicsa->samplesAInv[j++] = SAI[i];
// CONSTRUIMOS E COMPRIMIMOS PSI
printf("\n\t Creating compressed Psi...");
for(i=0;i<textSize;i++) Psi[i] = SAI[Psi[i]+1];
//FILE *ff = fopen("psi.log","w");
//for (i=0;i<textSize;i++) fprintf(ff,"%d::%u",i,Psi[i]);
//fclose(ff);
free(SAI);
#ifdef PSI_HUFFMANRLE
myicsa->hcPsi = huffmanCompressPsi(Psi,textSize,myicsa->T_Psi,nsHUFF);
#endif
#ifdef PSI_GONZALO
myicsa->gcPsi = gonzaloCompressPsi(Psi,textSize,myicsa->T_Psi,nsHUFF);
#endif
#ifdef PSI_DELTACODES
myicsa->dcPsi = deltaCompressPsi(Psi,textSize,myicsa->T_Psi);
#endif
free(Psi);
// Contruimos D
for(i=0;i<((textSize+31)/32);i++) myicsa->D[i] = 0;
for(i=0;i<=vocSize;i++) bitset(myicsa->D, C[i]);
myicsa->bD = createBitmap(myicsa->D,textSize);
free(C);
// VARIABLE GLOBAL QUE ALMACENA O ESTADO DOS DISPLAYS (IMPORTANTE PARA DISPLAY SECUENCIAL)
// Almacena a última posición do array de sufixos que mostramos con display ou displayNext
// Se nos piden un displayNext, aplicamos PSI sobre esta posición e obtemos a seguinte,
// coa que podemos obter o símbolo pedido, e actualizamos displayState
myicsa->displayCSAState = 0;
myicsa->displayCSAPrevPosition = -2; //needed by DisplayCSA(position)
aintVector = intVector;
// Liberamos o espacion non necesario
*index = myicsa;
//return (myicsa);
return 0;
}
void CompressedPixmap::loadFromStream(std::istream& inputStream)
{
PixmapHeader header;
inputStream.read((char*)&header, sizeof(PixmapHeader));
int bitAccessor = 1;
for (int i = 0; i < header.domainRegionCount; ++i)
{
unsigned long packed;
inputStream.read((char*)&packed, 4);
std::bitset<32> bitset(packed);
DomainRegionDescriptor domainRegion = { 0, 0, 0 };
for (int j = 0; j < 13; ++j)
{
if (bitset[j])
domainRegion.x += bitAccessor;
bitAccessor <<= 1;
}
bitAccessor = 1;
for (int j = 0; j < 13; ++j)
{
if (bitset[13 + j])
domainRegion.y += bitAccessor;
bitAccessor <<= 1;
}
bitAccessor = 1;
for (int j = 0; j < 6; ++j)
{
if (bitset[26 + j])
domainRegion.size += bitAccessor;
bitAccessor <<= 1;
}
m_domainRegions.push_back(domainRegion);
bitAccessor = 1;
}
for (int i = 0; i < header.rangeRegionCount; ++i)
{
unsigned long long packed;
inputStream.read((char*)&packed, 7);
std::bitset<58> bitset(packed);
RangeRegionDescriptor rangeRegion = { 0, 0, 0, 0, 0, 0 };
for (int j = 0; j < 13; ++j)
{
if (bitset[j])
rangeRegion.x += bitAccessor;
bitAccessor <<= 1;
}
bitAccessor = 1;
for (int j = 0; j < 13; ++j)
{
if (bitset[13 + j])
rangeRegion.y += bitAccessor;
bitAccessor <<= 1;
}
bitAccessor = 1;
for (int j = 0; j < 4; ++j)
{
if (bitset[26 + j])
rangeRegion.size += bitAccessor;
bitAccessor <<= 1;
}
bitAccessor = 1;
for (int j = 0; j < 14; ++j)
{
if (bitset[30 + j])
rangeRegion.domainRegionIndex += bitAccessor;
bitAccessor <<= 1;
}
bitAccessor = 1;
for (int j = 0; j < 4; ++j)
{
if (bitset[44 + j])
rangeRegion.transformation += bitAccessor;
bitAccessor <<= 1;
}
bitAccessor = 1;
for (int j = 0; j < 8; ++j)
{
if (bitset[48 + j])
rangeRegion.firstPixelValue += bitAccessor;
bitAccessor <<= 1;
}
m_rangeRegions.push_back(rangeRegion);
bitAccessor = 1;
}
refreshSize();
}
void _E(void)
{
bitset(P2OUT,E); //toggle E for LCD
Delay(_10us);
bitclr(P2OUT,E);
}
perm createPerm(uint *elems, uint nelems, uint t, static_bitsequence_builder * bmb) {
perm P;
uint *b, *baux, nextelem, i, j, bptr,
aux, antbptr,nbwdptrs, elem,nbits, firstelem, cyclesize;
auxbwd *auxbwdptr;
P = new struct sperm;
P->elems = elems;
P->nelems = nelems;
P->nbits = bits(nelems-1);
nbits = bits(nelems-1);
P->t = t;
if (t==1) {
P->bwdptrs = new uint[uint_len(nelems,nbits)];
assert(P->bwdptrs!=NULL);
P->nbwdptrs = nelems;
for (i=0; i<nelems; i++) {
uint bg = get_field(elems, nbits, i);
assert(bg<nelems);
set_field(P->bwdptrs, nbits, bg, i);
}
P->bmap = NULL;
}
else {
auxbwdptr = new auxbwd[(t+((int)ceil((double)nelems/t)))];
assert(auxbwdptr!=NULL);
b = new uint[uint_len(nelems,1)];
for(i=0;i<uint_len(nelems,1);i++)
b[i]=0;
assert(b!=NULL);
baux = new uint[uint_len(nelems,1)];
for(i=0;i<uint_len(nelems,1);i++)
baux[i] = 0;
assert(baux!=NULL);
nbwdptrs = 0;
for (i = 0; i < nelems; i++) {
if (bitget(baux,i) == 0) {
nextelem = j = bptr = antbptr = i;
aux = 0;
bitset(baux, j);
cyclesize = 0;
firstelem = j;
while ((elem=get_field(elems,nbits,j)) != nextelem) {
j = elem;
bitset(baux, j);
aux++;
if (aux >= t) {
auxbwdptr[nbwdptrs].key = j;
auxbwdptr[nbwdptrs++].pointer = bptr;
antbptr = bptr;
bptr = j;
aux = 0;
bitset(b, j);
}
cyclesize++;
}
if (cyclesize >= t) {
auxbwdptr[nbwdptrs].key = nextelem;
auxbwdptr[nbwdptrs++].pointer = bptr;
bitset(b, nextelem);
}
}
}
qsort(auxbwdptr, nbwdptrs, sizeof(auxbwd), &compare);
aux = uint_len(nbwdptrs,P->nbits);
P->bwdptrs = new uint[aux];
assert(P->bwdptrs!=NULL);
for(i=0;i<aux;i++) P->bwdptrs[i] = 0;
P->nbwdptrs = nbwdptrs;
for (i = 0; i < nbwdptrs; i++) {
set_field(P->bwdptrs, nbits, i, auxbwdptr[i].pointer);
//if(i<5)
// printf(" %d ",get_field(P->bwdptrs,nbits,i));
}
//printf("\n");
P->bmap = bmb->build(b, nelems);
//delete [] P->bmap;
delete [] b;
delete [] (baux);
delete [] (auxbwdptr);
}
return P;
}
void int_enableInterrupt(_INT *self) {
bitset(self->IECn, self->flagbit);
}
uint64 perft(int depth)
{
int i,move_count;
move_t ms[MOVE_STACK];
uint64 nodes;
uint64 val;
#ifdef EVASIONS
char strbuff[256];
move_t ms_test[MOVE_STACK];
#endif
#ifdef BITS
bitboard_t bb;
#endif
if(depth == 0) return 1;
if((val = probe_hash(depth)) != 0)
return val;
nodes = 0;
val = 0;
#ifdef BITS
bb = 0;
for(i = PLS(WP); i <= H8; i = PLN(i))
bitset(&bb, rsz[i]);
if(bb != board->bb_pawns[W])
printf("pawn_error\n");
bb = 0;
for(i = PLS(BP); i <= H8; i = PLN(i))
bitset(&bb, rsz[i]);
if(bb != board->bb_pawns[B])
printf("pawn_error\n");
#endif
#ifdef EVASIONS
if(is_in_check(board->side))
{ move_count = move_gen_evasions(&ms[0]);
if(move_count != move_gen_legal(&ms_test[0]))
{ board_to_fen(&strbuff[0]);
printf("error: \n %s \n",strbuff);
}
}
else
{ move_count = move_gen(&ms[0]);
}
#else
move_count = move_gen(&ms[0]);
#endif
for(i = 0; i < move_count; i++)
{ if(!move_make(ms[i])) continue;
if(depth == 1)
nodes++;
else
nodes += perft(depth - 1);
move_undo();
}
record_hash(depth,nodes);
return (nodes);
}
