private int starterQueueLength() {
int length = 0;
synchronized (starterQueue) {
for (PersistentChosenRequest request : starterQueue) length += request.sizeNotStarted();
}
return length;
}
void removeFromStarterQueue(
SendableRequest req, ObjectContainer container, boolean reqAlreadyActive) {
PersistentChosenRequest dumped = null;
synchronized (starterQueue) {
for (int i = 0; i < starterQueue.size(); i++) {
PersistentChosenRequest pcr = starterQueue.get(i);
if (pcr.request == req) {
starterQueue.remove(i);
dumped = pcr;
break;
}
}
}
if (dumped != null) dumped.onDumped(schedCore, container, reqAlreadyActive);
}
private void trimStarterQueue(ObjectContainer container) {
ArrayList<PersistentChosenRequest> dumped = null;
synchronized (starterQueue) {
int length = starterQueueLength();
while (length > MAX_STARTER_QUEUE_SIZE) {
// Find the lowest priority/retry count request.
// If we can dump it without going below the limit, then do so.
// If we can't, return.
PersistentChosenRequest worst = null;
short worstPrio = -1;
int worstIndex = -1;
int worstLength = -1;
if (starterQueue.isEmpty()) {
break;
}
length = 0;
for (int i = 0; i < starterQueue.size(); i++) {
PersistentChosenRequest req = starterQueue.get(i);
short prio = req.prio;
int size = req.sizeNotStarted();
length += size;
if (prio > worstPrio) {
worstPrio = prio;
worst = req;
worstIndex = i;
worstLength = size;
continue;
}
}
int lengthAfter = length - worstLength;
if (lengthAfter >= MAX_STARTER_QUEUE_SIZE) {
if (dumped == null) dumped = new ArrayList<PersistentChosenRequest>(2);
dumped.add(worst);
starterQueue.remove(worstIndex);
if (lengthAfter == MAX_STARTER_QUEUE_SIZE) break;
} else {
// Can't remove any more.
break;
}
}
}
if (dumped == null) return;
for (PersistentChosenRequest req : dumped) {
req.onDumped(schedCore, container, false);
}
}
/**
* @param request
* @param container
* @return True if the queue is now full/over-full.
*/
boolean addToStarterQueue(SendableRequest request, ObjectContainer container) {
if (logMINOR) Logger.minor(this, "Adding to starter queue: " + request);
container.activate(request, 1);
PersistentChosenRequest chosen;
try {
chosen =
new PersistentChosenRequest(
request,
request.getPriorityClass(container),
container,
ClientRequestScheduler.this,
clientContext);
} catch (NoValidBlocksException e) {
return false;
}
if (logMINOR) Logger.minor(this, "Created PCR: " + chosen);
container.deactivate(request, 1);
boolean dumpNew = false;
synchronized (starterQueue) {
for (PersistentChosenRequest req : starterQueue) {
if (req.request == request) {
Logger.error(
this, "Already on starter queue: " + req + " for " + request, new Exception("debug"));
dumpNew = true;
break;
}
}
if (!dumpNew) {
starterQueue.add(chosen);
int length = starterQueueLength();
length += chosen.sizeNotStarted();
runningPersistentRequests.add(request);
if (logMINOR)
Logger.minor(
this,
"Added to running persistent requests, size now "
+ runningPersistentRequests.size()
+ " : "
+ request);
return length > MAX_STARTER_QUEUE_SIZE;
}
}
if (dumpNew) chosen.onDumped(schedCore, container, false);
return false;
}
/**
* Compare a recently registered SendableRequest to what is already on the starter queue. If it is
* better, kick out stuff from the queue until we are just over the limit.
*
* @param req
* @param container
*/
public void maybeAddToStarterQueue(
SendableRequest req, ObjectContainer container, SendableRequest[] mightBeActive) {
short prio = req.getPriorityClass(container);
if (logMINOR) Logger.minor(this, "Maybe adding to starter queue: prio=" + prio);
synchronized (starterQueue) {
boolean betterThanSome = false;
int size = 0;
PersistentChosenRequest prev = null;
for (PersistentChosenRequest old : starterQueue) {
if (old.request == req) {
// Wait for a reselect. Otherwise we can starve other
// requests. Note that this happens with persistent SBI's:
// they are added at the new retry count before being
// removed at the old retry count.
if (logMINOR) Logger.minor(this, "Already on starter queue: " + old + " for " + req);
return;
}
if (prev == old)
Logger.error(this, "ON STARTER QUEUE TWICE: " + prev + " for " + prev.request);
if (prev != null && prev.request == old.request)
Logger.error(
this,
"REQUEST ON STARTER QUEUE TWICE: "
+ prev
+ " for "
+ prev.request
+ " vs "
+ old
+ " for "
+ old.request);
boolean ignoreActive = false;
if (mightBeActive != null) {
for (SendableRequest tmp : mightBeActive) if (tmp == old.request) ignoreActive = true;
}
if (!ignoreActive) {
if (container.ext().isActive(old.request))
Logger.warning(
this,
"REQUEST ALREADY ACTIVATED: "
+ old.request
+ " for "
+ old
+ " while checking request queue in maybeAddToStarterQueue for "
+ req);
else if (logDEBUG)
Logger.debug(
this,
"Not already activated for "
+ old
+ " in while checking request queue in maybeAddToStarterQueue for "
+ req);
} else if (logMINOR)
Logger.minor(
this,
"Ignoring active because just registered: "
+ old.request
+ " in maybeAddToStarterQueue for "
+ req);
size += old.sizeNotStarted();
if (old.prio > prio) betterThanSome = true;
if (old.request == req) return;
prev = old;
}
if (size >= MAX_STARTER_QUEUE_SIZE && !betterThanSome) {
if (logMINOR)
Logger.minor(
this,
"Not adding to starter queue: over limit and req not better than any queued requests");
return;
}
}
addToStarterQueue(req, container);
trimStarterQueue(container);
}
private void fillRequestStarterQueue(ObjectContainer container, ClientContext context) {
synchronized (this) {
if (fillingRequestStarterQueue) return;
fillingRequestStarterQueue = true;
}
long now = System.currentTimeMillis();
try {
if (logMINOR)
Logger.minor(
this,
"Filling request queue... (SSK=" + isSSKScheduler + " insert=" + isInsertScheduler);
long noLaterThan = Long.MAX_VALUE;
boolean checkCooldownQueue = now > nextQueueFillRequestStarterQueue;
if ((!isInsertScheduler) && checkCooldownQueue) {
if (persistentCooldownQueue != null)
noLaterThan = moveKeysFromCooldownQueue(persistentCooldownQueue, true, container);
noLaterThan =
Math.min(
noLaterThan, moveKeysFromCooldownQueue(transientCooldownQueue, false, container));
}
// If anything has been re-added, the request starter will have been woken up.
short fuzz = -1;
if (PRIORITY_SOFT.equals(choosenPriorityScheduler)) fuzz = -1;
else if (PRIORITY_HARD.equals(choosenPriorityScheduler)) fuzz = 0;
boolean added = false;
synchronized (starterQueue) {
if (logMINOR && (!isSSKScheduler) && (!isInsertScheduler)) {
Logger.minor(this, "Scheduling CHK fetches...");
for (SendableRequest req : runningPersistentRequests) {
boolean wasActive = container.ext().isActive(req);
if (!wasActive) container.activate(req, 1);
Logger.minor(this, "Running persistent request: " + req);
if (!wasActive) container.deactivate(req, 1);
}
}
// Recompute starterQueueLength
int length = 0;
PersistentChosenRequest old = null;
for (PersistentChosenRequest req : starterQueue) {
if (old == req) Logger.error(this, "DUPLICATE CHOSEN REQUESTS ON QUEUE: " + req);
if (old != null && old.request == req.request)
Logger.error(
this, "DUPLICATE REQUEST ON QUEUE: " + old + " vs " + req + " both " + req.request);
boolean ignoreActive = false;
if (!ignoreActive) {
if (container.ext().isActive(req.request))
Logger.warning(
this,
"REQUEST ALREADY ACTIVATED: "
+ req.request
+ " for "
+ req
+ " while checking request queue in filling request queue");
else if (logMINOR)
Logger.minor(
this,
"Not already activated for "
+ req
+ " in while checking request queue in filling request queue");
} else if (logMINOR)
Logger.minor(this, "Ignoring active because just registered: " + req.request);
req.pruneDuplicates(ClientRequestScheduler.this);
old = req;
length += req.sizeNotStarted();
}
if (logMINOR)
Logger.minor(
this,
"Queue size: " + length + " SSK=" + isSSKScheduler + " insert=" + isInsertScheduler);
if (length > MAX_STARTER_QUEUE_SIZE * 3 / 4) {
if (length >= WARNING_STARTER_QUEUE_SIZE)
Logger.error(this, "Queue already full: " + length);
return;
}
}
if ((!isSSKScheduler) && (!isInsertScheduler)) {
Logger.minor(this, "Scheduling CHK fetches...");
}
boolean addedMore = false;
while (true) {
SelectorReturn r;
// Must synchronize on scheduler to avoid problems with cooldown queue. See notes on
// CooldownTracker.clearCachedWakeup, which also applies to other cooldown operations.
synchronized (this) {
r =
selector.removeFirstInner(
fuzz,
random,
offeredKeys,
starter,
schedCore,
schedTransient,
false,
true,
Short.MAX_VALUE,
isRTScheduler,
context,
container,
now);
}
SendableRequest request = null;
if (r != null && r.req != null) request = r.req;
else {
if (r != null && r.wakeupTime > 0 && noLaterThan > r.wakeupTime) {
noLaterThan = r.wakeupTime;
if (logMINOR)
Logger.minor(
this,
"Waking up in " + TimeUtil.formatTime(noLaterThan - now) + " for cooldowns");
}
}
if (request == null) {
synchronized (ClientRequestScheduler.this) {
// Don't wake up for a while, but no later than the time we expect the next item to come
// off the cooldown queue
if (checkCooldownQueue && !added) {
nextQueueFillRequestStarterQueue =
System.currentTimeMillis() + WAIT_AFTER_NOTHING_TO_START;
if (nextQueueFillRequestStarterQueue > noLaterThan)
nextQueueFillRequestStarterQueue = noLaterThan + 1;
}
}
if (addedMore) starter.wakeUp();
return;
}
boolean full = addToStarterQueue(request, container);
container.deactivate(request, 1);
if (!added) starter.wakeUp();
else addedMore = true;
added = true;
if (full) {
if (addedMore) starter.wakeUp();
return;
}
}
} finally {
synchronized (this) {
fillingRequestStarterQueue = false;
}
}
}
/** Called by RequestStarter to find a request to run. */
@Override
public ChosenBlock grabRequest() {
boolean needsRefill = true;
while (true) {
PersistentChosenRequest reqGroup = null;
synchronized (starterQueue) {
short bestPriority = Short.MAX_VALUE;
for (PersistentChosenRequest req : starterQueue) {
if (req.prio == RequestStarter.MINIMUM_PRIORITY_CLASS) {
if (logDEBUG)
Logger.debug(
this, "Ignoring paused persistent request: " + req + " prio: " + req.prio);
continue; // Ignore paused requests
}
if (req.prio < bestPriority) {
bestPriority = req.prio;
reqGroup = req;
}
}
}
if (reqGroup != null) {
// Try to find a better non-persistent request
if (logMINOR)
Logger.minor(this, "Persistent request: " + reqGroup + " prio " + reqGroup.prio);
ChosenBlock better = getBetterNonPersistentRequest(reqGroup.prio);
if (better != null) {
if (better.getPriority() > reqGroup.prio) {
Logger.error(
this, "Selected " + better + " as better than " + reqGroup + " but isn't better!");
}
if (logMINOR) Logger.minor(this, "Returning better: " + better);
return better;
}
}
if (reqGroup == null) {
queueFillRequestStarterQueue();
return getBetterNonPersistentRequest(Short.MAX_VALUE);
}
ChosenBlock block;
synchronized (starterQueue) {
block = reqGroup.grabNotStarted(clientContext.fastWeakRandom, this);
if (block == null) {
if (logMINOR) Logger.minor(this, "No block found on " + reqGroup);
int finalLength = 0;
for (int i = 0; i < starterQueue.size(); i++) {
if (starterQueue.get(i) == reqGroup) {
starterQueue.remove(i);
if (logMINOR)
Logger.minor(this, "Removed " + reqGroup + " from starter queue because is empty");
i--;
} else {
finalLength += starterQueue.get(i).sizeNotStarted();
}
}
needsRefill = finalLength < MAX_STARTER_QUEUE_SIZE;
continue;
} else {
// Prevent this request being selected, even though we may remove the PCR from the starter
// queue
// in the very near future. When the PCR finishes, the requests will be un-blocked.
if (!runningPersistentRequests.contains(reqGroup.request))
runningPersistentRequests.add(reqGroup.request);
}
}
if (needsRefill) queueFillRequestStarterQueue();
if (logMINOR) Logger.minor(this, "grabRequest() returning " + block + " for " + reqGroup);
return block;
}
}
