TableStreamerContext* ElasticContext::cloneForTruncatedTable(PersistentTableSurgeon &surgeon)
{
if ( ! m_indexActive) {
return NULL;
}
ElasticContext *cloned = new ElasticContext(surgeon.getTable(), surgeon,
getPartitionId(), getSerializer(), m_predicateStrings, m_nTuplesPerCall);
cloned->handleActivation(TABLE_STREAM_ELASTIC_INDEX);
TupleOutputStreamProcessor dummyProcessor;
std::vector<int> dummyPosition;
while (true) {
int64_t retCode = cloned->handleStreamMore(dummyProcessor, dummyPosition);
if (retCode == 0) {
break;
} else if (retCode == TABLE_STREAM_SERIALIZATION_ERROR) {
break;
} else if (retCode == 1) {
continue;
} else {
char errMsg[1024];
snprintf(errMsg,
1024,
"Received an unrecognized return value %jd from handleStreamMore()",
(intmax_t)retCode);
LogManager::getThreadLogger(LOGGERID_HOST)->log(LOGLEVEL_ERROR, errMsg);
break;
}
}
return cloned;
}
TableStreamerContext* ElasticContext::cloneForTruncatedTable(PersistentTableSurgeon &surgeon)
{
if ( ! m_indexActive) {
return NULL;
}
ElasticContext *cloned = new ElasticContext(surgeon.getTable(), surgeon,
getPartitionId(), getSerializer(), m_predicateStrings, m_nTuplesPerCall);
cloned->handleActivation(TABLE_STREAM_ELASTIC_INDEX);
return cloned;
}
ISetImpl::ISetImpl(const std::string& instanceName, spi::ClientContext *clientContext)
: ProxyImpl("hz:impl:setService", instanceName, clientContext) {
serialization::pimpl::Data keyData = context->getSerializationService().toData<std::string>(&instanceName);
partitionId = getPartitionId(keyData);
}
int createPartitionsByMovingPos(int type, int maxThreshhold) {
UINT32 i, j, k;
UINT32 partitionPresent = INT_MAX, partitionLast;
UINT32 partitionStart, partitionEnd, firstVictimLoc;
BOOL flag;
UINT32 presentVictim;
UINT32 *currPartitionPtr = (UINT32*) MALLOC((numSplits + 1) * sizeof (int));
;
UINT32 partitionId;
UINT32 * count ;
if(type == TYPE_SORT){
count= (UINT32*) MALLOC(numSplits * sizeof (UINT32));
}
else{
count = partitionBeginnings_sorting;
}
memset(count, 0, numSplits * sizeof (int));
for (i = 0; i < arrayElemCount; i++) {
partitionId = getPartitionId(type, array + arrayElemSize * i);
count[partitionId]++;
}
if (type == TYPE_HASH){
int currValAtIndex = partitionBeginnings_sorting[0];
int lastCurrVal;
partitionBeginnings_sorting[0] = 0;
for(i=1; i<=numSplits; i++){
lastCurrVal = currValAtIndex;
currValAtIndex = partitionBeginnings_sorting[i];
partitionBeginnings_sorting[i] = partitionBeginnings_sorting[i-1] + lastCurrVal;
}
partitionBeginnings_sorting[numSplits] = arrayElemCount;
goto partitioning; //Since we shouldn't go through coalescing stage.
}
/*Coalesce empty partitions / partitions less than threshold.
Each split i corresponds to pivot (i-1) and pivot (i) except.
* Example split 2 corresponds to pivot 1 and pivot 2.
* Hence, when we coalesce array split i with i+1, pivot i
* should be removed. Note: We do this run 1 less times than numSplits
* as last split's count is immaterial __|__|__|__|__ */
UINT32 runningCount = 0,
windowCount;
UINT32 newNumPivots = 0, newNumSplits = 1;
partitionBeginnings_sorting[0] = 0;
for (i = 0; i < numSplits - 1; i++) {
runningCount += count[i];
windowCount = count[i];
while ((i < (numSplits - 1)) && (windowCount < maxThreshhold)) {
i++;
runningCount += count[i];
windowCount += count[i];
}
if (i != (numSplits - 1)) {
memcpy(pivots + (newNumPivots * arrayElemSize),
pivots + (arrayElemSize * i),
arrayElemSize);
newNumPivots++;
partitionBeginnings_sorting[newNumSplits++] = runningCount;
}
}
partitionBeginnings_sorting[newNumSplits] = arrayElemCount;
numPivots = newNumPivots;
numSplits = newNumSplits;
printf("Partition Counting Over [Partitions:%d]\n", numSplits);
#if 0 /*Can be used for debuggin later if required*/
for (i = 0; i < numPivots; i++) {
printf("Pivots:%d\n", *(int*) (pivots + (sizeof (int)*i)));
}
#endif
partitioning:
maxPartitionSize = 0;
for (i = 0; i < numSplits; i++) {
if (partitionBeginnings_sorting[i + 1] - partitionBeginnings_sorting[i] > maxPartitionSize) {
maxPartitionSize = partitionBeginnings_sorting[i + 1] - partitionBeginnings_sorting[i];
}
printf("partitions[%d]:%d\n", i, partitionBeginnings_sorting[i]);
}
printf("maxPartitionSize is %d\n", maxPartitionSize);
partitionBeginnings_sorting[numSplits] = arrayElemCount;
memcpy(currPartitionPtr, partitionBeginnings_sorting, (numSplits + 1) * sizeof (int));
UINT32 temp;
for (i = 0; i < numSplits; i++) {
for (j = currPartitionPtr[i]; j < partitionBeginnings_sorting[i + 1]; j++) {
partitionPresent = getPartitionId(type, array + arrayElemSize * pos[j]);
if (j >= partitionBeginnings_sorting[partitionPresent] && partitionPresent < partitionBeginnings_sorting[partitionPresent + 1]) {
currPartitionPtr[i]++;
continue;
}
firstVictimLoc = j;
presentVictim = j;
flag = 1;
while (flag) {
partitionStart = currPartitionPtr[partitionPresent];
partitionEnd = partitionBeginnings_sorting[partitionPresent + 1];
partitionLast = partitionPresent;
for (k = partitionStart; k < partitionEnd; k++) {
partitionPresent = getPartitionId(type, array + arrayElemSize * pos[k]);
if (k >= partitionBeginnings_sorting[partitionPresent] && k < partitionBeginnings_sorting[partitionPresent + 1])
continue;
if (k == firstVictimLoc) {
flag = 0;
}
//swapTuples(presentVictim, array + (arrayElemSize * k));
temp = presentVictim;
presentVictim = pos[k];
pos[k] = temp;
INC_WRITES;
currPartitionPtr[partitionLast] = k;
break;
}
}
}
}
printf("Partitioning Over\n");
//FREE(presentVictim);
FREE(currPartitionPtr);
if(type == TYPE_SORT){
FREE(count);
}
return (EXIT_SUCCESS);
}
ISemaphore::ISemaphore(const std::string &name, spi::ClientContext *context)
: proxy::ProxyImpl("hz:impl:semaphoreService", name, context) {
serialization::pimpl::Data keyData = context->getSerializationService().toData<std::string>(&name);
partitionId = getPartitionId(keyData);
}
ITopicImpl::ITopicImpl(const std::string &instanceName, spi::ClientContext *context)
: proxy::ProxyImpl("hz:impl:topicService", instanceName, context) {
partitionId = getPartitionId(toData(instanceName));
}
