Changeset: dc9095374fc7 for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=dc9095374fc7
Modified Files:
monetdb5/extras/bwd/bwd.c
monetdb5/extras/bwd/operations.c
monetdb5/extras/bwd/utilities.c
Branch: bwd
Log Message:
* working on varchar-attribute decomposition to ge TPC-H Q1 running
Unterschiede (218 Zeilen):
diff --git a/monetdb5/extras/bwd/bwd.c b/monetdb5/extras/bwd/bwd.c
--- a/monetdb5/extras/bwd/bwd.c
+++ b/monetdb5/extras/bwd/bwd.c
@@ -110,21 +110,21 @@ str bwdecompose(bat * res, bat * subject
if (VIEWtparent(subject))
subject = BATdescriptor(abs(VIEWtparent(subject)));
result = BATnew(TYPE_void, TYPE_str, 0);
+ if(approximationBits[0] > Tsize(subject)*8)
+ die("dude, bat %d only has %d bits, how am I supposed to use %d
bits for approximation\n", subject->batCacheid, Tsize(subject)*8,
approximationBits[0]);
+
if(batTailIsDecomposed(subject)) {
snprintf(buffer, 4096, "bat %d already decomposed",
subject->batCacheid);
} else if (Tsize(subject) == 4){
BATsetprop(subject, batRegistryIndex, TYPE_int,
(int[]){decomposeIntArray((int*)Tloc(subject, BUNfirst(subject)),
subject->batCount, *approximationBits)});
snprintf(buffer, 4096, "successfully decomposed integer bat
%d", subject->batCacheid);
} else if(Tsize(subject) == 1){
- if(approximationBits[0] > Tsize(subject)*8){
- die("dude, bat %d only has %d bits, how am I supposed
to use %d bits for approximation\n", subject->batCacheid, Tsize(subject)*8,
approximationBits[0]);
- } else {
BATsetprop(subject, batRegistryIndex, TYPE_int,
(int[]){decomposeVarchar1Array(Tloc(subject, BUNfirst(subject)),
subject->batCount, Tsize(subject), Tbase(subject), *approximationBits)});
snprintf(buffer, 4096, "successfully decomposed char
bat %d", subject->batCacheid);
- }
} else {
snprintf(buffer, 4096, "bat %d cannot be decomposed because it
is not a 32 or 8-bit type", subject->batCacheid);
}
+ printf ("%s\n", buffer);
BUNappend(result, buffer, 0);
BBPkeepref(*res = result->batCacheid);
BBPreleaseref(subject->batCacheid);
diff --git a/monetdb5/extras/bwd/operations.c b/monetdb5/extras/bwd/operations.c
--- a/monetdb5/extras/bwd/operations.c
+++ b/monetdb5/extras/bwd/operations.c
@@ -195,7 +195,7 @@ str BWDLeftJoinApproximate(bat * res, ba
return NOT_IMPLEMENTED;
};
-static inline int decompressIntValue(const int approximationI, const int
approximationBits, const int offsetBits, const clTail* compressedTail, const
unsigned int* residuals, const unsigned int residualI){
+static inline int decompress_int_Value(const int approximationI, const int
approximationBits, const int offsetBits, const clTail* compressedTail, const
unsigned int* residuals, const unsigned int residualI){
const unsigned int residualBits = 32-approximationBits-offsetBits;
const unsigned int residualMask = (1 << residualBits)-1;
const int approximationMask = (1<<(approximationBits))-1;
@@ -232,6 +232,43 @@ static inline int decompressIntValue(con
return deCompressedValue;
}
+static inline char decompress_char_Value(const int approximationI, const int
approximationBits, const int offsetBits, const clTail* compressedTail, const
unsigned int* residuals, const unsigned int residualI){
+ const unsigned int residualBits = 8-approximationBits-offsetBits;
+ const unsigned int residualMask = (1 << residualBits)-1;
+ const int approximationMask = (1<<(approximationBits))-1;
+ const unsigned int* vals = (unsigned int*) compressedTail->elements;
+ const unsigned int targetTypeBits = sizeof(int)*8;
+
+
+ const unsigned int slotI =
(approximationBits)*approximationI/(sizeof(int)*8);
+ const unsigned int offset =
((approximationBits)*approximationI)%(sizeof(int)*8);
+
+ const unsigned int compressedValue =
+ (((offset+approximationBits)<=targetTypeBits)*
+ (vals[slotI] >> (targetTypeBits-offset-approximationBits)) &
approximationMask)
+ + (((offset+approximationBits)>targetTypeBits)?
+
(((vals[slotI]<<(approximationBits-targetTypeBits+offset))
+ +
(vals[slotI+1]>>(targetTypeBits-(approximationBits-targetTypeBits+offset))))&approximationMask):0);
+
+
+ const size_t residualSlotI = (((unsigned long)residualI)*((unsigned
long)residualBits))/32UL;
+ const unsigned int residualOffset = (residualI*residualBits)%32;
+ const unsigned int residual =
+ (residualOffset+residualBits <= targetTypeBits)*
+ ((residuals[residualSlotI]
+ >>
(targetTypeBits-residualOffset-residualBits))&residualMask)
+ + (residualOffset+residualBits > targetTypeBits)*
+
(((residuals[residualSlotI]<<(residualBits-targetTypeBits+residualOffset))
+ + (residuals[residualSlotI+1] >>
+
(targetTypeBits-(residualBits-targetTypeBits+residualOffset))) )& residualMask);
+
+ const int deCompressedValue = compressedTail->base+
+ (compressedValue << residualBits)
+ + residual;
+
+ return deCompressedValue;
+}
+
str BWDLeftJoinRefine(bat * res, bat * l, bat * r, bat * approx){
if (!approx || !*approx) {
@@ -279,22 +316,37 @@ str BWDLeftJoinRefine(bat * res, bat * l
supersetApproximateValuesColumn =
getApproximateValuesColumn(batTailApproximation(approximation),
GDKmalloc(bufferSize), &bufferSize);
-
refinement = BATnew(TYPE_void, ATOMtype(right->ttype),
left->batCount);
{
-
- int* refinementRegion = (int*) Tloc(refinement,
BUNfirst(refinement));
-
oid* positionRegion = (oid*) Tloc(left,
BUNfirst(left));
size_t refinementCount = 0;
const unsigned int* residuals = (unsigned
int*)batTailResiduals(right);
uint i;
- for (i = 0; i < supersetPositionsColumn->count;
++i) {
-
if(supersetPositionsColumn->positions[i] == *positionRegion){
-
refinementRegion[refinementCount++] = decompressIntValue(i, approximationBits,
offsetBits, supersetApproximateValuesColumn, residuals, *positionRegion);
- positionRegion++;
- }
+
+#define refinementLoop(type) {
\
+ type* refinementRegion = (type*)
Tloc(refinement, \
+
BUNfirst(refinement)); \
+ for (i = 0; i <
supersetPositionsColumn->count; ++i) { \
+
if(supersetPositionsColumn->positions[i] == *positionRegion){ \
+
refinementRegion[refinementCount++] =
\
+
decompress_##type##_Value(i, approximationBits, offsetBits, \
+
supersetApproximateValuesColumn, \
+
residuals,
*positionRegion); \
+ positionRegion++;
\
+ }
\
+ }
\
}
+ switch(right->T->width){
+ case 4:
+ refinementLoop(int);
+ break;
+ case 1:
+ refinementLoop(char);
+ break;
+ default:
+ throw (MAL, "bwd problem", "this type
(%d-byte) for %s is not implemented, %s:%d", ATOMsize(right->ttype), __func__,
__FILE__, __LINE__);
+ }
+#undef refinementLoop
BATsetcount(refinement, refinementCount);
BATseqbase(refinement, 0);
}
@@ -912,7 +964,7 @@ str BWDSemijoinRefine(int *res, int *lid
}
\
}
\
refinementRegion[refinementCount++] =
\
-
decompressIntValue(i, approximationBits,
\
+
decompress_int_Value(i, approximationBits,
\
offsetBits, supersetApproximateValuesColumn, \
residuals, supersetPositionsColumn->positions[i]); \
}
@@ -1234,6 +1286,8 @@ str BWDMulticolumnGroupApproximate(Clien
printf("bwd.%s : bat is not decomposed: %d, no
approximation can be provided\n", __func__, inputs[i]->batCacheid);
result = NOT_DECOMPOSED;
}
+ assert(batTailResidualBits(inputs[i]) == 0); // we don't yet do
A&R grouping, thus we need all data on the GPU
+
}
if(result == MAL_SUCCEED){ // get input objects and parameters
@@ -1348,6 +1402,33 @@ str BWDGroupRefine(int *rethisto, int *r
return MAL_SUCCEED;
}
+BAT* materializeBATInHostMemory(BAT* input){
+ return input;
+}
+
str BWDMulticolumnGroupRefine(Client cntxt, MalBlkPtr mb, MalStkPtr stk,
InstrPtr pci){
- throw(MAL, __func__, "not implemented yet: %s", __func__);
+ int *retbid = (int*) getArgReference(stk,pci,0);
+ int *rethisto = (int*) getArgReference(stk,pci,1);
+ str result = MAL_SUCCEED;
+ int i;
+ BAT **inputs = (BAT**) GDKzalloc(sizeof(BAT*) * pci->argc);
+
+ for (i = 0; i < pci->argc-4; ++i){
+ inputs[i] = BATdescriptor(*(int*) getArgReference(stk,pci,i+2));
+ if (inputs[i] == NULL)
+ throw(MAL, __func__, RUNTIME_OBJECT_MISSING);
+ }
+
+ {
+ BAT *approximationretbid = BATdescriptor(*(int*)
getArgReference(stk,pci,pci->argc-2));
+ BAT *approximationrethisto = BATdescriptor(*(int*)
getArgReference(stk,pci, pci->argc-1));
+ BBPincref(*retbid =
materializeBATInHostMemory(approximationretbid)->batCacheid, 1);
+ BBPincref(*rethisto =
materializeBATInHostMemory(approximationrethisto)->batCacheid, 1);
+ BBPreleaseref(*retbid);
+ BBPreleaseref(*rethisto);
+ }
+ for (i = 0; i< pci->argc-4; ++i)
+ BBPreleaseref(inputs[i]->batCacheid);
+
+ return result;
}
diff --git a/monetdb5/extras/bwd/utilities.c b/monetdb5/extras/bwd/utilities.c
--- a/monetdb5/extras/bwd/utilities.c
+++ b/monetdb5/extras/bwd/utilities.c
@@ -269,9 +269,9 @@ int batTailOffsetValue(const BAT* subjec
return
bwdRegistry[rightTailApproximationProperty->v.val.ival].isPersistentBAT;
}
- size_t batTailResidualBits(const BAT* subject){
+size_t batTailResidualBits(const BAT* subject){
assert(ATOMsize(subject->ttype) > 0);
- return ATOMsize(subject->ttype)*8 - batTailApproximationBits(subject) -
batTailOffsetBits(subject);
+ return subject->T->width*8 - batTailApproximationBits(subject) -
batTailOffsetBits(subject);
}
const unsigned char* batTailResiduals(const BAT* subject){
PROPrec* rightTailApproximationProperty;
@@ -440,7 +440,7 @@ bounds findVarchar1Bounds(const char* su
bounds result = {value, value};
unsigned int i;
for (i = 1; i < size; ++i) {
- value = *getVarcharValue(subject, dictionary, i, width);
+ value = VarHeapValRaw(subject, i, width);
result.min = MIN(result.min, value);
result.max = MAX(result.max, value);
}
@@ -472,7 +472,7 @@ unsigned int decomposeVarchar1Array(cons
approximation->count = size;
for (i = 0; i < size; ++i) {
- const char value = *getVarcharValue(subject, dictionary, i,
width);
+ const int value = VarHeapValRaw(subject, i, width);
{ // approximation
const size_t slotI = (i*approximationBits)/32;
const unsigned int offset = (i*approximationBits)%32;
_______________________________________________
checkin-list mailing list
[email protected]
https://www.monetdb.org/mailman/listinfo/checkin-list
