/**
* Creates an index, and buckets and sorts the list of records into the index.
*/
void AlphabeticIndex::initBuckets(UErrorCode &errorCode) {
if (U_FAILURE(errorCode) || buckets_ != NULL) {
return;
}
buckets_ = createBucketList(errorCode);
if (U_FAILURE(errorCode) || inputList_ == NULL || inputList_->isEmpty()) {
return;
}
// Sort the records by name.
// Stable sort preserves input order of collation duplicates.
inputList_->sortWithUComparator(recordCompareFn, collator_, errorCode);
// Now, we traverse all of the input, which is now sorted.
// If the item doesn't go in the current bucket, we find the next bucket that contains it.
// This makes the process order n*log(n), since we just sort the list and then do a linear process.
// However, if the user adds an item at a time and then gets the buckets, this isn't efficient, so
// we need to improve it for that case.
Bucket *currentBucket = getBucket(*buckets_->bucketList_, 0);
int32_t bucketIndex = 1;
Bucket *nextBucket;
const UnicodeString *upperBoundary;
if (bucketIndex < buckets_->bucketList_->size()) {
nextBucket = getBucket(*buckets_->bucketList_, bucketIndex++);
upperBoundary = &nextBucket->lowerBoundary_;
} else {
nextBucket = NULL;
upperBoundary = NULL;
}
for (int32_t i = 0; i < inputList_->size(); ++i) {
Record *r = getRecord(*inputList_, i);
// if the current bucket isn't the right one, find the one that is
// We have a special flag for the last bucket so that we don't look any further
while (upperBoundary != NULL &&
collatorPrimaryOnly_->compare(r->name_, *upperBoundary, errorCode) >= 0) {
currentBucket = nextBucket;
// now reset the boundary that we compare against
if (bucketIndex < buckets_->bucketList_->size()) {
nextBucket = getBucket(*buckets_->bucketList_, bucketIndex++);
upperBoundary = &nextBucket->lowerBoundary_;
} else {
upperBoundary = NULL;
}
}
// now put the record into the bucket.
Bucket *bucket = currentBucket;
if (bucket->displayBucket_ != NULL) {
bucket = bucket->displayBucket_;
}
if (bucket->records_ == NULL) {
bucket->records_ = new UVector(errorCode);
if (bucket->records_ == NULL) {
errorCode = U_MEMORY_ALLOCATION_ERROR;
return;
}
}
bucket->records_->addElement(r, errorCode);
}
}
void
ApplyBucketsWork::onReset()
{
mTotalBuckets = 0;
mAppliedBuckets = 0;
mAppliedEntries = 0;
mTotalSize = 0;
mAppliedSize = 0;
mLastAppliedSizeMb = 0;
mLastPos = 0;
auto addBucket = [this](std::shared_ptr<Bucket const> const& bucket) {
if (bucket->getSize() > 0)
{
mTotalBuckets++;
mTotalSize += bucket->getSize();
}
};
for (auto const& hsb : mApplyState.currentBuckets)
{
addBucket(getBucket(hsb.snap));
addBucket(getBucket(hsb.curr));
}
mLevel = BucketList::kNumLevels - 1;
mApplying = false;
mSnapBucket.reset();
mCurrBucket.reset();
mSnapApplicator.reset();
mCurrApplicator.reset();
}
void World::queryLine(point_t v1, point_t v2, QueryCallback* qc) {
if (use_partitioning) {
//spatial hash version: check every rect in bucket intersecting line
int min_x = (v1.getX()) / bucket_width;
int max_x = (v2.getX()) / bucket_width;
if (min_x > max_x)
std::swap(min_x, max_x);
int min_y = (v1.getY()) / bucket_height;
int max_y = (v2.getY()) / bucket_height;
if (min_y > max_y)
std::swap(min_y, max_y);
//todo: iterates over full box containing line; just iterate over any bucket intersecting.
//iterate over all buckets intersecting line:
for (int i = min_x; i <= max_x; i++)
for (int j = min_y; j <= max_y; j++)
if (bucket* b = getBucket(i, j))
//iterate over all rects in bucket:
for (auto iter : b->rect_v)
//check if rect intersects the line:
if (iter->queryOnLine(v1, v2))
//halt if QueryCallback returns false.
if (!qc->onMatch(iter,
iter->getContactPointOnLine(v1, v2)))
return;
} else {
//non spatial hash version: check every rect
for (auto iter : v_rect) {
if (iter->queryOnLine(v1, v2))
if (!qc->onMatch(iter, iter->getContactPointOnLine(v1, v2)))
return;
}
}
}
int put(HashMap* map,void* key,void* value){
List* Bucket = getBucket(map,key);
hashElement* element =calloc(1,sizeof(hashElement));
element->key =key;
element->value =value;
return insert(Bucket,Bucket->length,element);
};
void World::queryRectangle(prec_t x, prec_t y, prec_t w, prec_t h, QueryCallback* qc) {
if (use_partitioning) {
//spatial hash version: check every rect in a bucket intersecting query rectangle
int min_x = (x) / bucket_width;
int max_x = (x + w) / bucket_width;
int min_y = (y) / bucket_height;
int max_y = (y + h) / bucket_height;
//iterate through all buckets in rectangle:
for (int i = min_x; i <= max_x; i++)
for (int j = min_y; j <= max_y; j++)
if (bucket* b = getBucket(i, j))
//iterate through all rects in bucket:
for (auto iter : b->rect_v)
//see if rect intersects query rectangle
if (iter->queryIntersects(x, y, w, h))
//halt if onMatch() returns false (see QueryCallback)
if (!qc->onMatch(iter,{0,0}))
return;
} else {
//non spatial hash version: check every rect
for (auto iter : v_rect) {
if (iter->queryIntersects(x, y, w, h))
if (!qc->onMatch(iter,{0,0}))
return;
}
}
}
virtual string dupKeyError(const IndexCatalogEntry* btreeState,
DiskLoc bucket,
const BSONObj& keyObj) const {
typename Version::KeyOwned key(keyObj);
return getBucket( btreeState, bucket )->dupKeyError(btreeState->descriptor(),
key);
}
virtual DiskLoc advance(const IndexCatalogEntry* btreeState,
const DiskLoc& thisLoc,
int& keyOfs,
int direction,
const char* caller) const {
return getBucket( btreeState, thisLoc )->advance(thisLoc, keyOfs, direction, caller);
}
std::vector<IdType> getNearest(const IdType& id, size_t maxGroupSize = MAX_BUCKET_SIZE) const {
std::lock_guard<std::mutex> lock(mutex_);
const size_t index = getBucket(id);
std::vector<IdType> group;
for (size_t dist = 0; dist < IdType::SIZE_IN_BITS && group.size() < maxGroupSize; dist++) {
if (index >= dist) {
for (const auto& nodeId: buckets_.at(index - dist)) {
if (group.size() >= maxGroupSize) {
break;
}
group.push_back(nodeId);
}
}
const auto rightPosition = index + dist + 1;
if (rightPosition < IdType::SIZE_IN_BITS) {
for (const auto& nodeId: buckets_[rightPosition]) {
if (group.size() >= maxGroupSize) {
break;
}
group.push_back(nodeId);
}
}
}
return group;
}
void BucketSkipList::moveNodeToProperBucket(long nodeId, long oldCost) {
BucketListElement* bucket = getBucket(oldCost);
NodeListElement* foundNodeElement = NULL;
if(bucket->nodes->node->id == nodeId) {
foundNodeElement = bucket->nodes;
bucket->nodes = foundNodeElement->next;
} else {
NodeListElement* lastElement = bucket->nodes;
while(lastElement->next != NULL) {
if(lastElement->next->node->id == nodeId) {
foundNodeElement = lastElement->next;
lastElement->next = foundNodeElement->next;
break;
}
lastElement = lastElement->next;
}
}
if(foundNodeElement == NULL) {
cout << "F**k. Haven't found the node" << endl;
exit(69);
}
insertNode(foundNodeElement);
}
inline
C *
NdbLinHash<C>::deleteKey ( const char* str, Uint32 len){
const Uint32 hash = Hash(str, len);
int dir, seg;
getBucket(hash, &dir, &seg);
NdbElement_t<C> *oldChain = 0;
NdbElement_t<C> **chainp = &directory[dir]->elements[seg];
for(NdbElement_t<C> * chain = *chainp; chain != 0; chain = chain->next){
if(chain->len == len && !memcmp(chain->str, str, len)){
C *data= chain->theData;
if (oldChain == 0) {
* chainp = chain->next;
} else {
oldChain->next = chain->next;
}
delete chain;
return data;
} else {
oldChain = chain;
}
}
return 0; /* Element doesn't exist */
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_DPSTRANSLOCK_TRYUPGRADE, "dpsTransLock::tryUpgrade" )
INT32 dpsTransLock::tryUpgrade( _pmdEDUCB *eduCB,
const dpsTransLockId &lockId,
dpsTransCBLockInfo *pLockInfo,
DPS_TRANSLOCK_TYPE lockType )
{
SDB_ASSERT( eduCB, "eduCB can't be null" ) ;
INT32 rc = SDB_OK;
DPS_TRANSLOCK_TYPE lastLockType;
dpsLockBucket *pLockBucket = NULL;
rc = upgradeCheck( pLockInfo->getType(), lockType );
PD_RC_CHECK( rc, PDERROR, "Upgrade lock failed(rc=%d)", rc );
rc = getBucket( lockId, pLockBucket );
PD_RC_CHECK( rc, PDERROR, "Failed to get lock-bucket, upgrade lock "
"failed(rc=%d)", rc );
lastLockType = pLockInfo->getType();
pLockInfo->setType( lockType );
rc = pLockBucket->tryAcquire( eduCB, lockId, lockType );
PD_CHECK( SDB_OK == rc, rc, rollbackType, PDERROR,
"Upgrade lock failed(rc=%d)", rc );
done:
PD_TRACE_EXIT ( SDB_DPSTRANSLOCK_TRYUPGRADE );
return rc;
rollbackType:
pLockInfo->setType( lastLockType );
error:
goto done;
}
Node* BucketSkipList::getMinCostNode() {
NodeListElement* minCostNodeElement;
BucketListElement* firstBucket = getBucket(currentMinCost);
if(firstBucket->nodes == NULL) {
long distanceToNextEmptyBucket = 1;
BucketListElement* currentBucket = firstBucket->next;
while(currentBucket->nodes == NULL) {
distanceToNextEmptyBucket++;
currentBucket = currentBucket->next;
}
currentMinCost += distanceToNextEmptyBucket;
offset = (offset + distanceToNextEmptyBucket) % listSize;
minCostNodeElement = currentBucket->nodes;
currentBucket->nodes = minCostNodeElement->next;
} else {
minCostNodeElement = firstBucket->nodes;
firstBucket->nodes = minCostNodeElement->next;
}
Node* minCostNode = minCostNodeElement->node;
delete minCostNodeElement;
currentNumberOfNodes--;
return minCostNode;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_DPSTRANSLOCK_RELEASEALL, "dpsTransLock::releaseAll" )
void dpsTransLock::releaseAll( _pmdEDUCB *eduCB )
{
SDB_ASSERT( eduCB, "eduCB can't be null" ) ;
INT32 rc = SDB_OK;
dpsLockBucket *pLockBucket = NULL;
DpsTransCBLockList *pLockLst = eduCB->getLockList();
DpsTransCBLockList::iterator iterLst = pLockLst->begin();
while ( iterLst != pLockLst->end() )
{
rc = getBucket( iterLst->first, pLockBucket );
if ( rc )
{
PD_LOG( PDWARNING, "Failed to get lock-bucket while release "
"lock(rc=%d)", rc );
}
else
{
pLockBucket->release( eduCB, iterLst->first );
}
SDB_OSS_DEL iterLst->second;
pLockLst->erase( iterLst++ );
}
eduCB->clearLockList() ;
PD_TRACE_EXIT ( SDB_DPSTRANSLOCK_RELEASEALL );
return ;
}
BucketList(UVector *bucketList, UVector *publicBucketList)
: bucketList_(bucketList), immutableVisibleList_(publicBucketList) {
int32_t displayIndex = 0;
for (int32_t i = 0; i < publicBucketList->size(); ++i) {
getBucket(*publicBucketList, i)->displayIndex_ = displayIndex++;
}
}
void getCommands(char* speedByte, char* turnByte)
{
char bL=getBucket(LEFT);
char bR=getBucket(RIGHT);
*turnByte = (bR-bL) * 40;
if(revDown())
{
//printf("revdown\r\n");
*speedByte = (bL > bR)? -bL:-bR; //max function (on magnitudes)
}
else
{
*speedByte = (bL > bR)? bL:bR; //max function
}
*speedByte *= 40;
//printf("Spd: %i, Turn: %i",*speedByte,*turnByte);
}
void addHostList(HostList *list)
{
if(list == NULL) return;
Bucket *bucket = getBucket(list);
/* The passed list is expected to exist in the host table. */
assert(bucket != NULL);
bucket->reference_count++;
}
unsigned int receiveSymb_BucketName(LTdecoder *decoder, int bucketName,
char *encodedInfo, unsigned int encodedInfoLength,
unsigned int IDfirstSymb) {
Bucket *bucket = getBucket(decoder, bucketName);
return genRXSymb(bucket, encodedInfo, encodedInfoLength,
&(decoder->RXsymbList), &(decoder->lastRXsymbol), IDfirstSymb);
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_DPSTRANSLOCK_ACQUIREIS, "dpsTransLock::acquireIS" )
INT32 dpsTransLock::acquireIS( _pmdEDUCB *eduCB,
const dpsTransLockId &lockId )
{
SDB_ASSERT( eduCB, "eduCB can't be null" ) ;
SDB_ASSERT( ( DMS_INVALID_OFFSET == lockId._recordOffset
&& DMS_INVALID_EXTENT == lockId._recordExtentID ),
"IX-Lock only used for collection or collectionspace" ) ;
INT32 rc = SDB_OK;
dpsLockBucket *pLockBucket = NULL;
dpsTransLockId sLockId;
dpsTransCBLockInfo *pLockInfo = NULL;
BOOLEAN isISLocked = FALSE;
if ( lockId._collectionID != DMS_INVALID_MBID )
{
sLockId._logicCSID = lockId._logicCSID;
rc = acquireIS( eduCB, sLockId );
PD_RC_CHECK( rc, PDERROR, "Failed to get the S-lock of space, "
"get IS-lock failed(rc=%d)", rc );
isISLocked = TRUE;
}
pLockInfo = eduCB->getTransLock( lockId );
if ( pLockInfo != NULL )
{
pLockInfo->incRef();
goto done;
}
rc = getBucket( lockId, pLockBucket );
PD_RC_CHECK( rc, PDERROR, "Failed to get the lock-bucket, "
"get IS-lock failed(rc=%d)", rc );
{
DPS_TRANS_WAIT_LOCK _transWaitLock( eduCB, lockId ) ;
eduCB->addLockInfo( lockId, DPS_TRANSLOCK_IS );
rc = pLockBucket->acquire( eduCB, lockId, DPS_TRANSLOCK_IS );
}
if ( rc )
{
eduCB->delLockInfo( lockId );
}
PD_RC_CHECK( rc, PDERROR, "Failed to get the IS-lock(rc=%d)", rc );
PD_LOG( PDDEBUG, "Get the IS-lock(%s)", lockId.toString().c_str() );
done:
PD_TRACE_EXIT ( SDB_DPSTRANSLOCK_ACQUIREIS );
return rc;
error:
if ( isISLocked )
{
release( eduCB, sLockId );
}
goto done;
}
virtual bool unindex(IndexCatalogEntry* btreeState,
const DiskLoc thisLoc,
const BSONObj& key,
const DiskLoc recordLoc) {
return getBucket( btreeState, thisLoc )->unindex(btreeState,
thisLoc,
key,
recordLoc);
}
// recursive function which does all search logic
void DFBBMonteCarlo(StarcraftStateType & s, int depth)
{
printf("Depth %d\n", depth);
// increase the node expansion count
nodesExpanded++;
// the time at which the last thing in the queue will finish
int finishTime = s.getLastFinishTime();
if (finishTime >= upperBound)
{
return;
}
int bucket = getBucket(finishTime);
int armyValue = s.getArmyValue();
if (armyValue > armyValues[bucket])
{
armyValues[bucket] = armyValue;
buildOrders[bucket] = getBuildOrder(s);
}
// if we are using search timeout and we are over the limit
if (params.searchTimeLimit && (nodesExpanded % 1000 == 0) && (searchTimer.getElapsedTimeInMilliSec() > params.searchTimeLimit))
{
// throw an exception to unroll the recursion
throw 1;
}
// get the legal action set
ActionSet legalActions = s.getLegalActionsMonteCarlo(params.goal);
// if we have children, update the counter
if (!legalActions.isEmpty())
{
numGenerations += 1;
numChildren += legalActions.numActions();
Action nextAction = legalActions.randomAction();
StarcraftStateType child(s);
int readyTime = child.resourcesReady(nextAction);
child.doAction(nextAction, readyTime);
child.setParent(&s);
DFBBMonteCarlo(child, depth+1);
}
else
{
printf("No legal actions %d\n", depth);
}
}
void World::removeFromBuckets(Rect* r) {
assert(use_partitioning);
for (int i = r->x/bucket_width;i<=(r->x+r->w)/bucket_width;i++)
for (int j = r->y/bucket_height;j<=(r->y+r->h)/bucket_height;j++) {
//only adds a bucket if no bucket existed there before.
bucket* b=getBucket(i,j);
if (b)
b->rect_v.remove(r);
}
}
void
ApplyBucketsWork::startLevel()
{
assert(isLevelComplete());
CLOG(DEBUG, "History") << "ApplyBuckets : starting level " << mLevel;
auto& level = getBucketLevel(mLevel);
HistoryStateBucket const& i = mApplyState.currentBuckets.at(mLevel);
bool applySnap = (i.snap != binToHex(level.getSnap()->getHash()));
bool applyCurr = (i.curr != binToHex(level.getCurr()->getHash()));
if (!mApplying && (applySnap || applyCurr))
{
uint32_t oldestLedger = applySnap
? BucketList::oldestLedgerInSnap(
mApplyState.currentLedger, mLevel)
: BucketList::oldestLedgerInCurr(
mApplyState.currentLedger, mLevel);
auto& lsRoot = mApp.getLedgerTxnRoot();
lsRoot.deleteObjectsModifiedOnOrAfterLedger(oldestLedger);
}
if (mApplying || applySnap)
{
mSnapBucket = getBucket(i.snap);
mSnapApplicator = std::make_unique<BucketApplicator>(
mApp, mMaxProtocolVersion, mSnapBucket);
CLOG(DEBUG, "History") << "ApplyBuckets : starting level[" << mLevel
<< "].snap = " << i.snap;
mApplying = true;
mBucketApplyStart.Mark();
}
if (mApplying || applyCurr)
{
mCurrBucket = getBucket(i.curr);
mCurrApplicator = std::make_unique<BucketApplicator>(
mApp, mMaxProtocolVersion, mCurrBucket);
CLOG(DEBUG, "History") << "ApplyBuckets : starting level[" << mLevel
<< "].curr = " << i.curr;
mApplying = true;
mBucketApplyStart.Mark();
}
}
virtual bool wouldCreateDup(const IndexCatalogEntry* btreeState,
const DiskLoc& thisLoc,
const BSONObj& key,
const DiskLoc& self) const {
typename Version::KeyOwned ownedVersion(key);
return getBucket( btreeState, thisLoc )->wouldCreateDup(btreeState,
thisLoc,
ownedVersion,
self);
}
void dispose(HashMap* map){
List* Bucket;
int loop;
for(loop=map->capacity;loop>0;loop--){
Bucket = (List*)getBucket(map,&loop);
if (Bucket == NULL) continue;
if(Bucket->head!= NULL)
Free(Bucket);
}
};
bool World::contains(Rect* target) {
if (use_partitioning) {
for (auto iter : getBucket(target->getX()/bucket_width,target->getY()/bucket_height)->rect_v)
if (iter==target)
return true;
} else
for (auto iter : v_rect)
if (&*iter==target)
return true;
return false;
}
virtual BSONObj keyAt(const IndexCatalogEntry* btreeState,
DiskLoc bucket, int keyOffset) const {
verify(!bucket.isNull());
const BtreeBucket<Version> *b = getBucket(btreeState,bucket);
int n = b->getN();
if (n == b->INVALID_N_SENTINEL) {
throw UserException(deletedBucketCode, "keyAt bucket deleted");
}
dassert( n >= 0 && n < 10000 );
return keyOffset >= n ? BSONObj() : b->keyNode(keyOffset).key.toBson();
}
//PD_TRACE_DECLARE_FUNCTION ( SDB_DPSTRANSLOCK_RELEASE, "dpsTransLock::release" )
void dpsTransLock::release( _pmdEDUCB * eduCB,
const dpsTransLockId & lockId )
{
SDB_ASSERT( eduCB, "eduCB can't be null" ) ;
INT32 rc = SDB_OK;
dpsLockBucket *pLockBucket = NULL;
dpsTransLockId iLockId;
dpsTransCBLockInfo *pLockInfo = NULL;
INT64 lockRef = 0;
pLockInfo = eduCB->getTransLock( lockId );
PD_CHECK( pLockInfo, SDB_OK, done, PDWARNING,
"duplicate release lock(%s)",
lockId.toString().c_str() ) ;
lockRef = pLockInfo->decRef();
if ( lockRef <= 0 )
{
rc = getBucket( lockId, pLockBucket );
if ( rc )
{
PD_LOG( PDWARNING, "Failed to get lock-bucket while release "
"lock(rc=%d)", rc );
}
else
{
pLockBucket->release( eduCB, lockId );
}
eduCB->delLockInfo( lockId );
pLockInfo = NULL;
}
if ( lockId._collectionID != DMS_INVALID_MBID )
{
iLockId = lockId;
if ( lockId._recordOffset != DMS_INVALID_OFFSET )
{
iLockId._recordExtentID = DMS_INVALID_EXTENT;
iLockId._recordOffset = DMS_INVALID_OFFSET;
release( eduCB, iLockId );
}
else
{
iLockId._collectionID = DMS_INVALID_MBID;
release( eduCB, iLockId );
}
}
done:
PD_TRACE_EXIT ( SDB_DPSTRANSLOCK_RELEASE );
return ;
}
int32_t getBucketIndex(const UnicodeString &name, const Collator &collatorPrimaryOnly,
UErrorCode &errorCode) {
// binary search
int32_t start = 0;
int32_t limit = bucketList_->size();
while ((start + 1) < limit) {
int32_t i = (start + limit) / 2;
const AlphabeticIndex::Bucket *bucket = getBucket(*bucketList_, i);
UCollationResult nameVsBucket =
collatorPrimaryOnly.compare(name, bucket->lowerBoundary_, errorCode);
if (nameVsBucket < 0) {
limit = i;
} else {
start = i;
}
}
const AlphabeticIndex::Bucket *bucket = getBucket(*bucketList_, start);
if (bucket->displayBucket_ != NULL) {
bucket = bucket->displayBucket_;
}
return bucket->displayIndex_;
}
unsigned readEHTFile(EHTFILE * file, char * key) {
unsigned recordPos = hash(key) % file->tableSize;
char * ptr;
int i;
getBucket(file, recordPos);
for ( i = 0, ptr = file->bucket->buffer; i < file->bucket->length; ++i, ptr += sizeof(unsigned) + file->keyLength ) {
IndexOverlay * indexEntry = (IndexOverlay *)ptr;
if ( strcmp(key, indexEntry->key) == 0 )
return indexEntry->link;
}
return 0;
}
// PD_TRACE_DECLARE_FUNCTION ( SDB_DPSTRANSLOCK_TESTX, "dpsTransLock::testX" )
INT32 dpsTransLock::testX( _pmdEDUCB *eduCB, const dpsTransLockId &lockId )
{
SDB_ASSERT( eduCB, "eduCB can't be null" ) ;
INT32 rc = SDB_OK;
dpsLockBucket *pLockBucket = NULL;
dpsTransLockId iLockId;
dpsTransCBLockInfo *pLockInfo = NULL;
pLockInfo = eduCB->getTransLock( lockId );
if ( pLockInfo != NULL && pLockInfo->isLockMatch( DPS_TRANSLOCK_X ))
{
goto done;
}
if ( lockId._collectionID != DMS_INVALID_MBID )
{
iLockId = lockId ;
if ( lockId._recordOffset != DMS_INVALID_OFFSET )
{
iLockId._recordExtentID = DMS_INVALID_EXTENT;
iLockId._recordOffset = DMS_INVALID_OFFSET;
}
else
{
iLockId._collectionID = DMS_INVALID_MBID;
}
rc = testIX( eduCB, iLockId);
PD_RC_CHECK( rc, PDINFO, "Failed to test the intention-lock, "
"test IX-lock failed(rc=%d)", rc );
}
if ( pLockInfo )
{
rc = testUpgrade( eduCB, lockId, pLockInfo, DPS_TRANSLOCK_X );
}
else
{
rc = getBucket( lockId, pLockBucket );
PD_RC_CHECK( rc, PDERROR, "Failed to get the lock-bucket, "
"test X-lock failed(rc=%d)", rc );
rc = pLockBucket->test( eduCB, lockId, DPS_TRANSLOCK_X );
}
PD_RC_CHECK( rc, PDINFO, "Failed to test the X-lock(rc=%d)", rc );
done:
PD_TRACE_EXIT ( SDB_DPSTRANSLOCK_TESTX );
return rc;
error:
goto done;
}
