/** Log the number of ops that have completed. */
protected void logNumOps() {
SharedCounters sc = CQUtilBB.getBB().getSharedCounters();
int totalOps =
keyIntervals.getNumKeys() - keyIntervals.getNumKeys(KeyIntervals.NONE) + numNewKeys;
long numOpsCompleted =
sc.read(CQUtilBB.LASTKEY_INVALIDATE)
- keyIntervals.getFirstKey(KeyIntervals.INVALIDATE)
+ sc.read(CQUtilBB.LASTKEY_DESTROY)
- keyIntervals.getFirstKey(KeyIntervals.DESTROY)
+ sc.read(CQUtilBB.LASTKEY_UPDATE_EXISTING_KEY)
- keyIntervals.getFirstKey(KeyIntervals.UPDATE_EXISTING_KEY)
+ sc.read(CQUtilBB.LASTKEY_GET)
- keyIntervals.getFirstKey(KeyIntervals.GET)
+ sc.read(CQUtilBB.NUM_NEW_KEYS_CREATED);
Log.getLogWriter()
.info(
"Total ops is " + totalOps + ", current number of ops completed is " + numOpsCompleted);
}
/**
* Hydra start task to initialize key intervals, which are ranges of keys which are to have an
* operation done on them (invalidate, destroy, etc)
*/
public static synchronized void StartTask_initialize() {
int numKeys = TestConfig.tab().intAt(CQUtilPrms.numKeys);
KeyIntervals intervals =
new KeyIntervals(
new int[] {
KeyIntervals.NONE, KeyIntervals.INVALIDATE,
KeyIntervals.DESTROY, KeyIntervals.UPDATE_EXISTING_KEY,
KeyIntervals.GET
},
numKeys);
CQUtilBB.getBB().getSharedMap().put(CQUtilBB.KeyIntervals, intervals);
Log.getLogWriter().info("Created keyIntervals: " + intervals);
// Set the counters for the next keys to use for each operation
hydra.blackboard.SharedCounters sc = CQUtilBB.getBB().getSharedCounters();
sc.setIfLarger(CQUtilBB.LASTKEY_INVALIDATE, intervals.getFirstKey(KeyIntervals.INVALIDATE) - 1);
sc.setIfLarger(
CQUtilBB.LASTKEY_LOCAL_INVALIDATE,
intervals.getFirstKey(KeyIntervals.LOCAL_INVALIDATE) - 1);
sc.setIfLarger(CQUtilBB.LASTKEY_DESTROY, intervals.getFirstKey(KeyIntervals.DESTROY) - 1);
sc.setIfLarger(
CQUtilBB.LASTKEY_LOCAL_DESTROY, intervals.getFirstKey(KeyIntervals.LOCAL_DESTROY) - 1);
sc.setIfLarger(
CQUtilBB.LASTKEY_UPDATE_EXISTING_KEY,
intervals.getFirstKey(KeyIntervals.UPDATE_EXISTING_KEY) - 1);
sc.setIfLarger(CQUtilBB.LASTKEY_GET, intervals.getFirstKey(KeyIntervals.GET) - 1);
// show the blackboard
CQUtilBB.getBB().printSharedMap();
CQUtilBB.getBB().printSharedCounters();
}
/**
* Verify the contents of the region, taking into account the keys that were destroyed,
* invalidated, etc (as specified in keyIntervals) Throw an error of any problems are detected.
* This must be called repeatedly by the same thread until StopSchedulingTaskOnClientOrder is
* thrown.
*/
public void verifyRegionContents() {
final long LOG_INTERVAL_MILLIS = 10000;
// we already completed this check once; we can't do it again without reinitializing the
// verify state variables
if (verifyRegionContentsCompleted) {
throw new TestException(
"Test configuration problem; already verified region contents, "
+ "cannot call this task again without resetting batch variables");
}
// iterate keys
long lastLogTime = System.currentTimeMillis();
long minTaskGranularitySec = TestConfig.tab().longAt(TestHelperPrms.minTaskGranularitySec);
long minTaskGranularityMS = minTaskGranularitySec * TestHelper.SEC_MILLI_FACTOR;
long startTime = System.currentTimeMillis();
long size = aRegion.size();
boolean first = true;
int numKeysToCheck = keyIntervals.getNumKeys() + numNewKeys;
while (verifyRegionContentsIndex < numKeysToCheck) {
verifyRegionContentsIndex++;
if (first) {
Log.getLogWriter()
.info(
"In verifyRegionContents, region has "
+ size
+ " keys; starting verify at verifyRegionContentsIndex "
+ verifyRegionContentsIndex
+ "; verifying key names with indexes through (and including) "
+ numKeysToCheck);
first = false;
}
// check region size the first time through the loop to avoid it being called
// multiple times when this is batched
if (verifyRegionContentsIndex == 1) {
if (totalNumKeys != size) {
String tmpStr = "Expected region size to be " + totalNumKeys + ", but it is size " + size;
Log.getLogWriter().info(tmpStr);
verifyRegionContentsErrStr.append(tmpStr + "\n");
}
}
Object key = NameFactory.getObjectNameForCounter(verifyRegionContentsIndex);
try {
if (((verifyRegionContentsIndex >= keyIntervals.getFirstKey(KeyIntervals.NONE))
&& (verifyRegionContentsIndex <= keyIntervals.getLastKey(KeyIntervals.NONE)))
|| ((verifyRegionContentsIndex >= keyIntervals.getFirstKey(KeyIntervals.GET))
&& (verifyRegionContentsIndex <= keyIntervals.getLastKey(KeyIntervals.GET)))) {
// this key was untouched after its creation
checkContainsKey(key, true, "key was untouched");
checkContainsValueForKey(key, true, "key was untouched");
Object value = aRegion.get(key);
checkValue(key, value);
} else if ((verifyRegionContentsIndex >= keyIntervals.getFirstKey(KeyIntervals.INVALIDATE))
&& (verifyRegionContentsIndex <= keyIntervals.getLastKey(KeyIntervals.INVALIDATE))) {
checkContainsKey(key, true, "key was invalidated");
checkContainsValueForKey(key, false, "key was invalidated");
} else if ((verifyRegionContentsIndex
>= keyIntervals.getFirstKey(KeyIntervals.LOCAL_INVALIDATE))
&& (verifyRegionContentsIndex
<= keyIntervals.getLastKey(KeyIntervals.LOCAL_INVALIDATE))) {
// this key was locally invalidated
checkContainsKey(key, true, "key was locally invalidated");
checkContainsValueForKey(key, true, "key was locally invalidated");
Object value = aRegion.get(key);
checkValue(key, value);
} else if ((verifyRegionContentsIndex >= keyIntervals.getFirstKey(KeyIntervals.DESTROY))
&& (verifyRegionContentsIndex <= keyIntervals.getLastKey(KeyIntervals.DESTROY))) {
// this key was destroyed
checkContainsKey(key, false, "key was destroyed");
checkContainsValueForKey(key, false, "key was destroyed");
} else if ((verifyRegionContentsIndex
>= keyIntervals.getFirstKey(KeyIntervals.LOCAL_DESTROY))
&& (verifyRegionContentsIndex <= keyIntervals.getLastKey(KeyIntervals.LOCAL_DESTROY))) {
// this key was locally destroyed
checkContainsKey(key, true, "key was locally destroyed");
checkContainsValueForKey(key, true, "key was locally destroyed");
Object value = aRegion.get(key);
checkValue(key, value);
} else if ((verifyRegionContentsIndex
>= keyIntervals.getFirstKey(KeyIntervals.UPDATE_EXISTING_KEY))
&& (verifyRegionContentsIndex
<= keyIntervals.getLastKey(KeyIntervals.UPDATE_EXISTING_KEY))) {
// this key was updated
checkContainsKey(key, true, "key was updated");
checkContainsValueForKey(key, true, "key was updated");
Object value = aRegion.get(key);
checkUpdatedValue(key, value);
} else if (verifyRegionContentsIndex > keyIntervals.getNumKeys()) {
// key was newly added
checkContainsKey(key, true, "key was new");
checkContainsValueForKey(key, true, "key was new");
Object value = aRegion.get(key);
checkValue(key, value);
}
} catch (TestException e) {
Log.getLogWriter().info(TestHelper.getStackTrace(e));
verifyRegionContentsErrStr.append(e.getMessage() + "\n");
}
if (System.currentTimeMillis() - lastLogTime > LOG_INTERVAL_MILLIS) {
Log.getLogWriter()
.info("Verified key " + verifyRegionContentsIndex + " out of " + totalNumKeys);
lastLogTime = System.currentTimeMillis();
}
if (System.currentTimeMillis() - startTime >= minTaskGranularityMS) {
Log.getLogWriter()
.info(
"In HydraTask_verifyRegionContents, returning before completing verify "
+ "because of task granularity (this task must be batched to complete); last key verified is "
+ key);
return; // task is batched; we are done with this batch
}
}
verifyRegionContentsCompleted = true;
if (verifyRegionContentsErrStr.length() > 0) {
throw new TestException(verifyRegionContentsErrStr.toString());
}
String aStr =
"In HydraTask_verifyRegionContents, verified " + verifyRegionContentsIndex + " keys/values";
Log.getLogWriter().info(aStr);
throw new StopSchedulingTaskOnClientOrder(aStr);
}