Changeset: 32300072972e for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=32300072972e
Modified Files:
monetdb5/modules/mal/mosaic.h
monetdb5/modules/mal/mosaic_delta.c
monetdb5/modules/mal/mosaic_dictionary.c
monetdb5/modules/mal/mosaic_linear.c
monetdb5/modules/mal/mosaic_literal.c
monetdb5/modules/mal/mosaic_runlength.c
monetdb5/modules/mal/mosaic_variance.c
monetdb5/modules/mal/mosaic_zone.c
Branch: mosaic
Log Message:
Make estimation more precise and consistent.
diffs (truncated from 401 to 300 lines):
diff --git a/monetdb5/modules/mal/mosaic.h b/monetdb5/modules/mal/mosaic.h
--- a/monetdb5/modules/mal/mosaic.h
+++ b/monetdb5/modules/mal/mosaic.h
@@ -81,7 +81,7 @@ typedef int *MosaicBlk;
* We use an encoding that fits the column type requirements
*/
#define wordaligned(SZ,TYPE) \
- ((SZ) + ((SZ) % sizeof(int)? sizeof(int) - ((SZ)%sizeof(TYPE)) : 0))
+ ((SZ) + ((SZ) % sizeof(TYPE)? sizeof(TYPE) - ((SZ)%sizeof(TYPE)) : 0))
#define MosaicHdrSize wordaligned(sizeof(struct MOSAICHEADER),lng)
#define MosaicBlkSize wordaligned(sizeof(lng),lng)
diff --git a/monetdb5/modules/mal/mosaic_delta.c
b/monetdb5/modules/mal/mosaic_delta.c
--- a/monetdb5/modules/mal/mosaic_delta.c
+++ b/monetdb5/modules/mal/mosaic_delta.c
@@ -35,21 +35,21 @@ MOSadvance_delta(Client cntxt, MOStask t
task->start += MOSgetCnt(blk);
switch(task->type){
//case TYPE_bte: case TYPE_bit: no compression achievable
- case TYPE_sht: task->blk = (MosaicBlk)( ((char*) blk) + MosaicBlkSize +
wordaligned(sizeof(sht) + MOSgetCnt(blk)-1,sht)); break ;
- case TYPE_int: task->blk = (MosaicBlk)( ((char*) blk) + MosaicBlkSize +
wordaligned(sizeof(int) + MOSgetCnt(blk)-1,int)); break ;
- case TYPE_oid: task->blk = (MosaicBlk)( ((char*) blk) + MosaicBlkSize +
wordaligned(sizeof(oid) + MOSgetCnt(blk)-1,oid)); break ;
- case TYPE_wrd: task->blk = (MosaicBlk)( ((char*) blk) + MosaicBlkSize +
wordaligned(sizeof(wrd) + MOSgetCnt(blk)-1,wrd)); break ;
- case TYPE_lng: task->blk = (MosaicBlk)( ((char*) blk) + MosaicBlkSize +
wordaligned(sizeof(lng) + MOSgetCnt(blk)-1,lng)); break ;
+ case TYPE_sht: task->blk = (MosaicBlk)( ((char*) blk)+
wordaligned(sizeof(sht) + MosaicBlkSize + MOSgetCnt(blk)-1,sht)); break ;
+ case TYPE_int: task->blk = (MosaicBlk)( ((char*) blk)+
wordaligned(sizeof(int) + MosaicBlkSize + MOSgetCnt(blk)-1,int)); break ;
+ case TYPE_oid: task->blk = (MosaicBlk)( ((char*) blk)+
wordaligned(sizeof(oid) + MosaicBlkSize + MOSgetCnt(blk)-1,oid)); break ;
+ case TYPE_wrd: task->blk = (MosaicBlk)( ((char*) blk)+
wordaligned(sizeof(wrd) + MosaicBlkSize + MOSgetCnt(blk)-1,wrd)); break ;
+ case TYPE_lng: task->blk = (MosaicBlk)( ((char*) blk)+
wordaligned(sizeof(lng) + MosaicBlkSize + MOSgetCnt(blk)-1,lng)); break ;
//case TYPE_flt: case TYPE_dbl: to be looked into.
#ifdef HAVE_HGE
- case TYPE_hge: task->blk = (MosaicBlk)( ((char*) blk) + MosaicBlkSize +
wordaligned(sizeof(hge) + MOSgetCnt(blk)-1,hge)); break ;
+ case TYPE_hge: task->blk = (MosaicBlk)( ((char*) blk) +
wordaligned(MosaicBlkSize + sizeof(hge) + MOSgetCnt(blk)-1,hge)); break ;
#endif
case TYPE_str:
switch(task->b->T->width){
- case 1: task->blk = (MosaicBlk)( ((char*) blk) + MosaicBlkSize
+ wordaligned(sizeof(bte)* MOSgetCnt(blk)-1,bte)); break ;
- case 2: task->blk = (MosaicBlk)( ((char*) blk) + MosaicBlkSize
+ wordaligned(sizeof(sht)* MOSgetCnt(blk)-1,sht)); break ;
- case 4: task->blk = (MosaicBlk)( ((char*) blk) + MosaicBlkSize
+ wordaligned(sizeof(int)* MOSgetCnt(blk)-1,int)); break ;
- case 8: task->blk = (MosaicBlk)( ((char*) blk) + MosaicBlkSize
+ wordaligned(sizeof(lng)* MOSgetCnt(blk)-1,lng)); break ;
+ case 1: task->blk = (MosaicBlk)( ((char*) blk) +
wordaligned(sizeof(bte)+ MosaicBlkSize + MOSgetCnt(blk)-1,bte)); break ;
+ case 2: task->blk = (MosaicBlk)( ((char*) blk) +
wordaligned(sizeof(sht)+ MosaicBlkSize + MOSgetCnt(blk)-1,sht)); break ;
+ case 4: task->blk = (MosaicBlk)( ((char*) blk) +
wordaligned(sizeof(int)+ MosaicBlkSize + MOSgetCnt(blk)-1,int)); break ;
+ case 8: task->blk = (MosaicBlk)( ((char*) blk) +
wordaligned(sizeof(lng)+ MosaicBlkSize + MOSgetCnt(blk)-1,lng)); break ;
}
break;
default:
@@ -88,7 +88,7 @@ MOSskip_delta(Client cntxt, MOStask task
val = *w;\
}\
if ( i > MOSlimit() ) i = MOSlimit();\
- factor = ((float) i * sizeof(TYPE))/ (2 * MosaicBlkSize +
sizeof(TYPE)+i-1);\
+ factor = ((float) i * sizeof(TYPE))/ wordaligned(sizeof(int) +
MosaicBlkSize + i-1,TYPE);\
}
// estimate the compression level
@@ -125,7 +125,7 @@ MOSestimate_delta(Client cntxt, MOStask
val = *w;
}
if ( i > MOSlimit() ) i = MOSlimit();
- factor = ((float) i * sizeof(int))/ (2 * MosaicBlkSize
+ sizeof(int)+i-1);
+ factor = ((float) i * sizeof(int))/
wordaligned(sizeof(int) + MosaicBlkSize + i-1,int);
}
break;
//case TYPE_flt: case TYPE_dbl: to be looked into.
diff --git a/monetdb5/modules/mal/mosaic_dictionary.c
b/monetdb5/modules/mal/mosaic_dictionary.c
--- a/monetdb5/modules/mal/mosaic_dictionary.c
+++ b/monetdb5/modules/mal/mosaic_dictionary.c
@@ -38,23 +38,23 @@ MOSadvance_dictionary(Client cntxt, MOSt
task->start += MOSgetCnt(task->blk);
switch(task->type){
//case TYPE_bte: CASE_bit: no compression achievable
- case TYPE_sht: task->blk = (MosaicBlk)( ((char*)task->blk) + 2*
MosaicBlkSize + task->dictsize * sizeof(sht)+ wordaligned(sizeof(bte) *
MOSgetCnt(task->blk),sht)); break;
- case TYPE_int: task->blk = (MosaicBlk)( ((char*)task->blk) + 2*
MosaicBlkSize + task->dictsize * sizeof(int)+ wordaligned(sizeof(bte) *
MOSgetCnt(task->blk),int)); break;
- case TYPE_lng: task->blk = (MosaicBlk)( ((char*)task->blk) + 2*
MosaicBlkSize + task->dictsize * sizeof(lng)+ wordaligned(sizeof(bte) *
MOSgetCnt(task->blk),lng)); break;
- case TYPE_oid: task->blk = (MosaicBlk)( ((char*)task->blk) + 2*
MosaicBlkSize + task->dictsize * sizeof(oid)+ wordaligned(sizeof(bte) *
MOSgetCnt(task->blk),oid)); break;
- case TYPE_wrd: task->blk = (MosaicBlk)( ((char*)task->blk) + 2*
MosaicBlkSize + task->dictsize * sizeof(wrd)+ wordaligned(sizeof(bte) *
MOSgetCnt(task->blk),wrd)); break;
- case TYPE_flt: task->blk = (MosaicBlk)( ((char*)task->blk) + 2*
MosaicBlkSize + task->dictsize * sizeof(flt)+ wordaligned(sizeof(bte) *
MOSgetCnt(task->blk),flt)); break;
- case TYPE_dbl: task->blk = (MosaicBlk)( ((char*)task->blk) + 2*
MosaicBlkSize + task->dictsize * sizeof(dbl)+ wordaligned(sizeof(bte) *
MOSgetCnt(task->blk),dbl)); break;
+ case TYPE_sht: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned(2* MosaicBlkSize + task->dictsize * sizeof(sht)+ sizeof(bte) *
MOSgetCnt(task->blk),sht)); break;
+ case TYPE_int: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned(2* MosaicBlkSize + task->dictsize * sizeof(int)+ sizeof(bte) *
MOSgetCnt(task->blk),int)); break;
+ case TYPE_lng: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned(2* MosaicBlkSize + task->dictsize * sizeof(lng)+ sizeof(bte) *
MOSgetCnt(task->blk),lng)); break;
+ case TYPE_oid: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned(2* MosaicBlkSize + task->dictsize * sizeof(oid)+ sizeof(bte) *
MOSgetCnt(task->blk),oid)); break;
+ case TYPE_wrd: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned(2* MosaicBlkSize + task->dictsize * sizeof(wrd)+ sizeof(bte) *
MOSgetCnt(task->blk),wrd)); break;
+ case TYPE_flt: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned(2* MosaicBlkSize + task->dictsize * sizeof(flt)+ sizeof(bte) *
MOSgetCnt(task->blk),flt)); break;
+ case TYPE_dbl: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned(2* MosaicBlkSize + task->dictsize * sizeof(dbl)+ sizeof(bte) *
MOSgetCnt(task->blk),dbl)); break;
#ifdef HAVE_HGE
- case TYPE_hge: task->blk = (MosaicBlk)( ((char*)task->blk) + 2*
MosaicBlkSize + task->dictsize * sizeof(hge)+ wordaligned(sizeof(bte) *
MOSgetCnt(task->blk),hge)); break;
+ case TYPE_hge: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned(2* MosaicBlkSize + task->dictsize * sizeof(hge)+ sizeof(bte) *
MOSgetCnt(task->blk),hge)); break;
#endif
default:
if( task->type == TYPE_timestamp)
- task->blk = (MosaicBlk)( ((char*)task->blk) +
2* MosaicBlkSize + task->dictsize * sizeof(timestamp)+ wordaligned(sizeof(bte)
* MOSgetCnt(task->blk),timestamp));
+ task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned(2* MosaicBlkSize + task->dictsize * sizeof(timestamp)+ sizeof(bte)
* MOSgetCnt(task->blk),timestamp));
if( task->type == TYPE_date)
- task->blk = (MosaicBlk)( ((char*)task->blk) +
2* MosaicBlkSize + task->dictsize * sizeof(date)+ wordaligned(sizeof(bte) *
MOSgetCnt(task->blk),date));
+ task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned(2* MosaicBlkSize + task->dictsize * sizeof(date)+ sizeof(bte) *
MOSgetCnt(task->blk),date));
if( task->type == TYPE_daytime)
- task->blk = (MosaicBlk)( ((char*)task->blk) +
2* MosaicBlkSize + task->dictsize * sizeof(date)+ wordaligned(sizeof(bte) *
MOSgetCnt(task->blk),daytime));
+ task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned(2* MosaicBlkSize + task->dictsize * sizeof(date)+ sizeof(bte) *
MOSgetCnt(task->blk),daytime));
}
}
@@ -117,7 +117,7 @@ MOSskip_dictionary(Client cntxt, MOStask
#define estimateDict(TPE)\
{ TPE *val = (TPE*)task->src;\
- TPE *dict = (TPE*)((char*)task->dst + 3 * MosaicBlkSize);\
+ TPE *dict = (TPE*)((char*)task->dst + 2 * MosaicBlkSize);\
for(i =0; i<task->elm; i++, val++){\
for(j= 0; j< *size; j++)\
if( dict[j] == *val) {cnt++;break;}\
@@ -130,7 +130,7 @@ MOSskip_dictionary(Client cntxt, MOStask
}\
}\
if ( i > MOSlimit() ) i = MOSlimit();\
- if(i) factor = (flt) ((int)i * sizeof(int)) / (3 * MosaicBlkSize +
sizeof(int) * task->dictsize +i);\
+ if(i) factor = (flt) ((int)i * sizeof(int)) / wordaligned(2*
MosaicBlkSize + task->dictsize * sizeof(TPE)+ sizeof(bte) *
MOSgetCnt(task->blk),TPE);\
}
// calculate the expected reduction using DICT in terms of elements compressed
@@ -158,7 +158,7 @@ MOSestimate_dictionary(Client cntxt, MOS
#endif
case TYPE_int:
{ int *val = (int*)task->src;
- int *dict = (int*)((char*)task->dst + 3 *
MosaicBlkSize);
+ int *dict = (int*)((char*)task->dst + 2 *
MosaicBlkSize);
for(i =0; i<task->elm; i++, val++){
for(j= 0; j< *size; j++)
if( dict[j] == *val) {cnt++;break;}
@@ -171,7 +171,7 @@ MOSestimate_dictionary(Client cntxt, MOS
}
}
if ( i > MOSlimit() ) i = MOSlimit();
- if(i) factor = (flt) ((int)i * sizeof(int)) / (3 *
MosaicBlkSize + sizeof(int) * task->dictsize +i);
+ if(i) factor = (flt) ((int)i * sizeof(int)) /
wordaligned(2* MosaicBlkSize + task->dictsize * sizeof(int)+ sizeof(bte) *
MOSgetCnt(task->blk),int);
}
}
#ifdef _DEBUG_MOSAIC_
diff --git a/monetdb5/modules/mal/mosaic_linear.c
b/monetdb5/modules/mal/mosaic_linear.c
--- a/monetdb5/modules/mal/mosaic_linear.c
+++ b/monetdb5/modules/mal/mosaic_linear.c
@@ -92,24 +92,24 @@ MOSadvance_linear(Client cntxt, MOStask
(void) cntxt;
task->start += MOSgetCnt(task->blk);
switch(ATOMstorage(task->type)){
- case TYPE_bte: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(2 * sizeof(bte),bte)); break;
- case TYPE_bit: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(2 * sizeof(bit),bit)); break;
- case TYPE_sht: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(2 * sizeof(sht),sht)); break;
- case TYPE_int: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(2 * sizeof(int),int)); break;
- case TYPE_oid: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(2 * sizeof(oid),oid)); break;
- case TYPE_lng: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(2 * sizeof(lng),lng)); break;
- case TYPE_wrd: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(2 * sizeof(wrd),wrd)); break;
- case TYPE_flt: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(2 * sizeof(flt),flt)); break;
- case TYPE_dbl: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(2 * sizeof(dbl),dbl)); break;
+ case TYPE_bte: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + 2 * sizeof(bte),bte)); break;
+ case TYPE_bit: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + 2 * sizeof(bit),bit)); break;
+ case TYPE_sht: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + 2 * sizeof(sht),sht)); break;
+ case TYPE_int: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + 2 * sizeof(int),int)); break;
+ case TYPE_oid: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + 2 * sizeof(oid),oid)); break;
+ case TYPE_lng: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + 2 * sizeof(lng),lng)); break;
+ case TYPE_wrd: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + 2 * sizeof(wrd),wrd)); break;
+ case TYPE_flt: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + 2 * sizeof(flt),flt)); break;
+ case TYPE_dbl: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + 2 * sizeof(dbl),dbl)); break;
#ifdef HAVE_HGE
- case TYPE_hge: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(2 * sizeof(hge),hge)); break;
+ case TYPE_hge: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + 2 * sizeof(hge),hge)); break;
#endif
case TYPE_str:
switch(task->b->T->width){
- case 1: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(2 *sizeof(bte),bte)); break ;
- case 2: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(2 *sizeof(sht),sht)); break ;
- case 4: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(2 *sizeof(int),int)); break ;
- case 8: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(2 *sizeof(lng),lng)); break ;
+ case 1: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + 2 *sizeof(bte),bte)); break ;
+ case 2: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + 2 *sizeof(sht),sht)); break ;
+ case 4: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + 2 *sizeof(int),int)); break ;
+ case 8: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + 2 *sizeof(lng),lng)); break ;
}
}
}
@@ -129,7 +129,7 @@ MOSskip_linear(Client cntxt, MOStask tas
if ( ((TYPE*)task->src)[i] != (TYPE)(val + (int)i * step))\
break;\
if( i >= MOSlimit()) i = MOSlimit();\
- factor = ( (flt)i * sizeof(TYPE))/(2 * MosaicBlkSize + 2 *
sizeof(TYPE));\
+ factor = ( (flt)i * sizeof(TYPE))/wordaligned( MosaicBlkSize + 2 *
sizeof(TYPE),TYPE);\
}
// calculate the expected reduction using LINEAR in terms of elements
compressed
@@ -167,7 +167,7 @@ MOSestimate_linear(Client cntxt, MOStask
if ( ((int*)task->src)[i] != (int)(val + (int)i * step))
break;
if( i >= MOSlimit()) i = MOSlimit();
- factor = ( (flt)i * sizeof(int))/(2 * MosaicBlkSize +
2 * sizeof(int));
+ factor = ( (flt)i * sizeof(int))/wordaligned(
MosaicBlkSize + 2 * sizeof(int),int);
}
}
#ifdef _DEBUG_MOSAIC_
diff --git a/monetdb5/modules/mal/mosaic_literal.c
b/monetdb5/modules/mal/mosaic_literal.c
--- a/monetdb5/modules/mal/mosaic_literal.c
+++ b/monetdb5/modules/mal/mosaic_literal.c
@@ -41,24 +41,24 @@ MOSadvance_literal(Client cntxt, MOStask
task->start += MOSgetCnt(blk);
switch(ATOMstorage(task->type)){
- case TYPE_bte: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(sizeof(bte)* MOSgetCnt(blk),bte)); break ;
- case TYPE_bit: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(sizeof(bit)* MOSgetCnt(blk),bit)); break ;
- case TYPE_sht: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(sizeof(sht)* MOSgetCnt(blk),sht)); break ;
- case TYPE_int: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(sizeof(int)* MOSgetCnt(blk),int)); break ;
- case TYPE_oid: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(sizeof(oid)* MOSgetCnt(blk),oid)); break ;
- case TYPE_lng: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(sizeof(lng)* MOSgetCnt(blk),lng)); break ;
+ case TYPE_bte: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + sizeof(bte)* MOSgetCnt(blk),bte)); break ;
+ case TYPE_bit: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + sizeof(bit)* MOSgetCnt(blk),bit)); break ;
+ case TYPE_sht: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + sizeof(sht)* MOSgetCnt(blk),sht)); break ;
+ case TYPE_int: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + sizeof(int)* MOSgetCnt(blk),int)); break ;
+ case TYPE_oid: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + sizeof(oid)* MOSgetCnt(blk),oid)); break ;
+ case TYPE_lng: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + sizeof(lng)* MOSgetCnt(blk),lng)); break ;
#ifdef HAVE_HGE
- case TYPE_hge: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(sizeof(hge)* MOSgetCnt(blk),hge)); break ;
+ case TYPE_hge: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + sizeof(hge)* MOSgetCnt(blk),hge)); break ;
#endif
- case TYPE_wrd: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(sizeof(wrd)* MOSgetCnt(blk),wrd)); break ;
- case TYPE_flt: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(sizeof(flt)* MOSgetCnt(blk),flt)); break ;
- case TYPE_dbl: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(sizeof(dbl)* MOSgetCnt(blk),dbl)); break;
+ case TYPE_wrd: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + sizeof(wrd)* MOSgetCnt(blk),wrd)); break ;
+ case TYPE_flt: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + sizeof(flt)* MOSgetCnt(blk),flt)); break ;
+ case TYPE_dbl: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + sizeof(dbl)* MOSgetCnt(blk),dbl)); break;
case TYPE_str:
switch(task->b->T->width){
- case 1: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(sizeof(bte)* MOSgetCnt(blk),bte)); break ;
- case 2: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(sizeof(sht)* MOSgetCnt(blk),sht)); break ;
- case 4: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(sizeof(int)* MOSgetCnt(blk),int)); break ;
- case 8: task->blk = (MosaicBlk)( ((char*) task->blk) +
MosaicBlkSize + wordaligned(sizeof(lng)* MOSgetCnt(blk),lng)); break ;
+ case 1: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + sizeof(bte)* MOSgetCnt(blk),bte)); break ;
+ case 2: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + sizeof(sht)* MOSgetCnt(blk),sht)); break ;
+ case 4: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + sizeof(int)* MOSgetCnt(blk),int)); break ;
+ case 8: task->blk = (MosaicBlk)( ((char*) task->blk) +
wordaligned( MosaicBlkSize + sizeof(lng)* MOSgetCnt(blk),lng)); break ;
}
}
}
diff --git a/monetdb5/modules/mal/mosaic_runlength.c
b/monetdb5/modules/mal/mosaic_runlength.c
--- a/monetdb5/modules/mal/mosaic_runlength.c
+++ b/monetdb5/modules/mal/mosaic_runlength.c
@@ -75,25 +75,25 @@ MOSadvance_runlength(Client cntxt, MOSta
task->start += MOSgetCnt(task->blk);
switch(ATOMstorage(task->type)){
- case TYPE_bte: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(sizeof(bte),bte)); break;
- case TYPE_bit: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(sizeof(bit),bit)); break;
- case TYPE_sht: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(sizeof(sht),sht)); break;
- case TYPE_int: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(sizeof(int),int)); break;
- case TYPE_lng: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(sizeof(lng),lng)); break;
- case TYPE_oid: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(sizeof(oid),oid)); break;
- case TYPE_wrd: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(sizeof(wrd),wrd)); break;
- case TYPE_flt: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(sizeof(flt),flt)); break;
- case TYPE_dbl: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(sizeof(dbl),dbl)); break;
+ case TYPE_bte: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + sizeof(bte),bte)); break;
+ case TYPE_bit: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + sizeof(bit),bit)); break;
+ case TYPE_sht: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + sizeof(sht),sht)); break;
+ case TYPE_int: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + sizeof(int),int)); break;
+ case TYPE_lng: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + sizeof(lng),lng)); break;
+ case TYPE_oid: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + sizeof(oid),oid)); break;
+ case TYPE_wrd: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + sizeof(wrd),wrd)); break;
+ case TYPE_flt: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + sizeof(flt),flt)); break;
+ case TYPE_dbl: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + sizeof(dbl),dbl)); break;
#ifdef HAVE_HGE
- case TYPE_hge: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(sizeof(hge),hge)); break;
+ case TYPE_hge: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + sizeof(hge),hge)); break;
#endif
case TYPE_str:
// we only have to look at the index width, not the values
switch(task->b->T->width){
- case 1: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(sizeof(bte),bte)); break;
- case 2: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(sizeof(sht),sht)); break;
- case 4: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(sizeof(int),int)); break;
- case 8: task->blk = (MosaicBlk)( ((char*)task->blk) +
MosaicBlkSize + wordaligned(sizeof(lng),lng)); break;
+ case 1: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + sizeof(bte),bte)); break;
+ case 2: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + sizeof(sht),sht)); break;
+ case 4: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + sizeof(int),int)); break;
+ case 8: task->blk = (MosaicBlk)( ((char*)task->blk) +
wordaligned( MosaicBlkSize + sizeof(lng),lng)); break;
}
break;
}
@@ -113,7 +113,7 @@ MOSskip_runlength(Client cntxt, MOStask
if ( ((TYPE*)task->src)[i] != val)\
break;\
if ( i > MOSlimit() ) i = MOSlimit();\
- factor = ( (flt)i * sizeof(TYPE))/ (MosaicBlkSize + sizeof(TYPE));\
+ factor = ( (flt)i * sizeof(TYPE))/ wordaligned( MosaicBlkSize +
sizeof(TYPE),TYPE);\
}
// calculate the expected reduction using RLE in terms of elements compressed
@@ -141,7 +141,7 @@ MOSestimate_runlength(Client cntxt, MOSt
if ( ((int*)task->src)[i] != val)
break;
if ( i > MOSlimit() ) i = MOSlimit();
- factor = ( (flt)i * sizeof(int))/ (MosaicBlkSize +
sizeof(int));
+ factor = ( (flt)i * sizeof(int))/ wordaligned(
MosaicBlkSize + sizeof(int),int);
}
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
https://www.monetdb.org/mailman/listinfo/checkin-list
