private boolean hasConnections() {
if (entity_count == 0) {
return (false);
}
List<RateControlledEntity> ref = high_priority_entities;
for (RateControlledEntity e : ref) {
if (e.getConnectionCount(read_waiter) > 0) {
return (true);
}
}
ref = normal_priority_entities;
for (RateControlledEntity e : ref) {
if (e.getConnectionCount(read_waiter) > 0) {
return (true);
}
}
return (false);
}
public void updateStats(Set types, Map values) {
if (types.contains(AzureusCoreStats.ST_NET_READ_CONTROL_LOOP_COUNT)) {
values.put(AzureusCoreStats.ST_NET_READ_CONTROL_LOOP_COUNT, new Long(loop_count));
}
if (types.contains(AzureusCoreStats.ST_NET_READ_CONTROL_NP_COUNT)) {
values.put(AzureusCoreStats.ST_NET_READ_CONTROL_NP_COUNT, new Long(non_progress_count));
}
if (types.contains(AzureusCoreStats.ST_NET_READ_CONTROL_P_COUNT)) {
values.put(AzureusCoreStats.ST_NET_READ_CONTROL_P_COUNT, new Long(progress_count));
}
if (types.contains(AzureusCoreStats.ST_NET_READ_CONTROL_WAIT_COUNT)) {
values.put(AzureusCoreStats.ST_NET_READ_CONTROL_WAIT_COUNT, new Long(wait_count));
}
if (types.contains(AzureusCoreStats.ST_NET_READ_CONTROL_ENTITY_COUNT)) {
values.put(
AzureusCoreStats.ST_NET_READ_CONTROL_ENTITY_COUNT,
new Long(high_priority_entities.size() + normal_priority_entities.size()));
}
if (types.contains(AzureusCoreStats.ST_NET_READ_CONTROL_CON_COUNT)
|| types.contains(AzureusCoreStats.ST_NET_READ_CONTROL_READY_CON_COUNT)) {
int ready_connections = 0;
int connections = 0;
ArrayList[] refs = {normal_priority_entities, high_priority_entities};
for (int i = 0; i < refs.length; i++) {
ArrayList ref = refs[i];
for (int j = 0; j < ref.size(); j++) {
RateControlledEntity entity = (RateControlledEntity) ref.get(j);
connections += entity.getConnectionCount(read_waiter);
ready_connections += entity.getReadyConnectionCount(read_waiter);
}
}
values.put(AzureusCoreStats.ST_NET_READ_CONTROL_CON_COUNT, new Long(connections));
values.put(AzureusCoreStats.ST_NET_READ_CONTROL_READY_CON_COUNT, new Long(ready_connections));
}
}
/**
* Add the given entity to the controller for read processing.
*
* @param entity to process reads for
*/
public void addReadEntity(RateControlledEntity entity) {
try {
entities_mon.enter();
if (entity.getPriority() == RateControlledEntity.PRIORITY_HIGH) {
// copy-on-write
ArrayList<RateControlledEntity> high_new =
new ArrayList<RateControlledEntity>(high_priority_entities.size() + 1);
high_new.addAll(high_priority_entities);
high_new.add(entity);
high_priority_entities = high_new;
} else {
// copy-on-write
ArrayList<RateControlledEntity> norm_new =
new ArrayList<RateControlledEntity>(normal_priority_entities.size() + 1);
norm_new.addAll(normal_priority_entities);
norm_new.add(entity);
normal_priority_entities = norm_new;
}
entity_count = normal_priority_entities.size() + high_priority_entities.size();
} finally {
entities_mon.exit();
}
read_waiter.eventOccurred();
}
private RateControlledEntity getNextReadyHighPriorityEntity() {
ArrayList<RateControlledEntity> ref = high_priority_entities;
int size = ref.size();
int num_checked = 0;
while (num_checked < size) {
entity_check_count++;
next_high_position = next_high_position >= size ? 0 : next_high_position; // make circular
RateControlledEntity entity = ref.get(next_high_position);
next_high_position++;
num_checked++;
if (entity.canProcess(read_waiter)) { // is ready
return entity;
}
}
return null; // none found ready
}
private boolean doRead(RateControlledEntity ready_entity) {
if (ready_entity != null) {
if (AGGRESIVE_READ) {
// skip over failed readers to find a good one
if (ready_entity.doProcessing(read_waiter, 0) > 0) {
progress_count++;
return (true);
} else {
non_progress_count++;
if (entity_check_count - last_entity_check_count
>= normal_priority_entities.size() + high_priority_entities.size()) {
last_entity_check_count = entity_check_count;
// force a wait
if (read_waiter.waitForEvent(IDLE_SLEEP_TIME)) {
wait_count++;
}
return (false);
}
return (true);
}
} else {
return (ready_entity.doProcessing(read_waiter, 0) > 0);
}
}
return false;
}
/**
* Remove the given entity from the controller.
*
* @param entity to remove from read processing
*/
public void removeReadEntity(RateControlledEntity entity) {
try {
entities_mon.enter();
if (entity.getPriority() == RateControlledEntity.PRIORITY_HIGH) {
// copy-on-write
ArrayList<RateControlledEntity> high_new =
new ArrayList<RateControlledEntity>(high_priority_entities);
high_new.remove(entity);
high_priority_entities = high_new;
} else {
// copy-on-write
ArrayList<RateControlledEntity> norm_new =
new ArrayList<RateControlledEntity>(normal_priority_entities);
norm_new.remove(entity);
normal_priority_entities = norm_new;
}
entity_count = normal_priority_entities.size() + high_priority_entities.size();
} finally {
entities_mon.exit();
}
}