copy_hosts(hosts, hosts_);

for (HostMap::const_iterator i = hosts.begin(),

end = hosts.end(); i != end; ++i) {

i->second->enable_latency_tracking(settings_.scale_ns, settings_.min_measured);

}

ChainedLoadBalancingPolicy::init(connected_host, hosts);

calculate_min_average_task_ = PeriodicTask::start(loop,

settings_.update_rate_ms,

this,

LatencyAwarePolicy::on_work,

LatencyAwarePolicy::on_after_work);

if (calculate_min_average_task_ != NULL) {

PeriodicTask::stop(calculate_min_average_task_);

}

host->enable_latency_tracking(settings_.scale_ns, settings_.min_measured);

add_host(hosts_, host);

ChainedLoadBalancingPolicy::on_add(host);

LatencyAwarePolicy* policy = static_cast<LatencyAwarePolicy*>(task->data());

const Settings& settings = policy->settings_;

const CopyOnWriteHostVec& hosts = policy->hosts_;

int64_t new_min_average = CASS_INT64_MAX;

int64_t now = uv_hrtime();

for (HostVec::const_iterator i = hosts->begin(),

end = hosts->end(); i != end; ++i) {

TimestampedAverage latency = (*i)->get_current_average();

if (latency.average >= 0

&& latency.num_measured >= settings.min_measured

&& (now - latency.timestamp) <= settings.retry_period_ns) {

new_min_average = std::min(new_min_average, latency.average);

}

}

if (new_min_average != CASS_INT64_MAX) {

LOG_TRACE("Calculated new minimum: %f", static_cast<double>(new_min_average) / 1e6);

policy->min_average_.store(new_min_average);

}