void send_to_acquaintances(const message& what) {
// send to all remote subscribers
auto sender = current_sender();
CAF_LOG_DEBUG("forward message to " << m_acquaintances.size()
<< " acquaintances; " << CAF_TSARG(sender) << ", "
<< CAF_TSARG(what));
for (auto& acquaintance : m_acquaintances) {
acquaintance->enqueue(sender, invalid_message_id, what, host());
}
}
caf::behavior make_behavior() override {
auto start_map = std::make_shared<
std::map<caf::actor,
std::chrono::time_point<
std::chrono::high_resolution_clock>
>
>();
return {
[=](init_atom, const std::vector<caf::actor>& all_workers) {
std::cout << "init: " << all_workers.size() << std::endl;
all_workers_.clear();
all_workers_.insert(std::begin(all_workers_), std::begin(all_workers),
std::end(all_workers));
send(this, calc_weights_atom::value, all_workers_.size());
},
[=](calc_weights_atom, size_t workers_to_use) {
// Clear all caches
chunk_cache_.clear();
image_cache empty;
std::swap(cache_, empty);
start_map->clear();
workers_.clear();
//
for (size_t i = 0; i < workers_to_use; ++i)
workers_.emplace(all_workers_[i], 0);
using hrc = std::chrono::high_resolution_clock;
auto req = stream_.next(); // TODO: Get a image with much black
uint32_t req_width = width(req);
uint32_t req_height = height(req);
auto req_min_re = min_re(req);
auto req_max_re = max_re(req);
auto req_min_im = min_im(req);
auto req_max_im = max_im(req);
uint32_t offset = 0;
uint32_t rows = image_height_;
for (auto& e : workers_) {
auto& worker = e.first;
start_map->emplace(worker, hrc::now());
send(worker, default_iterations, req_width, req_height,
offset, rows, req_min_re, req_max_re, req_min_im, req_max_im);
}
},
[=](const std::vector<uint16_t>& data, uint32_t) {
if (data.size() != image_size_) return; // old data TODO: Problem with 1 worker?
auto sender = caf::actor_cast<caf::actor>(current_sender());
auto t2 = std::chrono::high_resolution_clock::now();
auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(t2 - (*start_map)[sender]).count();
workers_[sender] = diff;
start_map->erase(sender);
if (start_map->empty()) {
auto add = [](size_t lhs, const std::pair<caf::actor, double>& rhs) {
return lhs + rhs.second;
};
auto total_time = std::accumulate(workers_.begin(), workers_.end(),
size_t{0}, add);
for (auto& e : workers_)
e.second = e.second / total_time;
double time = diff;
for (auto& e : workers_) {
time *= e.second;
break;
}
auto ms = static_cast<double>(std::chrono::milliseconds(static_cast<uint16_t>(time)).count());
auto sec = static_cast<double>(std::chrono::milliseconds(1000).count());
double fps = sec / ms;
tick_rate_ = std::chrono::milliseconds(/*static_cast<uint16_t>(time) + 50*/1000);
std::cout << "Assumed FPS: " << fps << std::endl;
//buffer_min_size_ = fps < 1 ? static_cast<uint32_t>(1.0 / fps)
// : static_cast<uint32_t>(fps);
//buffer_min_size_ *= seconds_to_buffer_; // FIXME
buffer_min_size_ = static_cast<uint32_t>(fps) + 1 * seconds_to_buffer_;
buffer_max_size_ = buffer_min_size_ * 4;
become(init_buffer());
}
},
[=](resize_atom, uint32_t w, uint32_t h) {
resize(w,h);
},
[=](limit_atom, normal_atom, uint32_t workers) {
send(this, calc_weights_atom::value, size_t{workers});
},
caf::others() >> [=] {
std::cout << to_string(current_message()) << std::endl;
}
};
}
nexus::behavior_type nexus::make_behavior() {
return {
[=](const riac::node_info& ni) {
if (ni.source_node == caf::invalid_node_id) {
cerr << "node_info received with invalid source node" << endl;
return;
}
cout << "received node_info " << endl;
data_[ni.source_node].node = ni;
auto& ls = current_sender();
probes_[ls] = ls.node();
monitor(ls);
broadcast();
},
HANDLE_UPDATE(riac::ram_usage, ram),
HANDLE_UPDATE(riac::work_load, load),
[=](const riac::new_actor_published& msg) {
CHECK_SOURCE(riac::actor_published, msg);
auto addr = msg.published_actor;
auto nid = msg.source_node;
if (addr == invalid_actor_addr) {
cerr << "received riac::actor_published "
<< "with invalid actor address"
<< endl;
return;
}
if (data_[nid].known_actors.insert(addr).second) {
monitor(addr);
}
data_[nid].published_actors.insert(std::make_pair(addr, msg.port));
broadcast();
},
[=](const riac::new_route& route) {
CHECK_SOURCE(riac::new_route, route);
if (route.is_direct
&& data_[route.source_node].direct_routes.insert(route.dest).second) {
broadcast();
}
},
[=](const riac::route_lost& route) {
CHECK_SOURCE(riac::route_lost, route);
if (data_[route.source_node].direct_routes.erase(route.dest) > 0) {
cout << "new route" << endl;
broadcast();
}
},
[=](const riac::new_message& msg) {
// TODO: reduce message size by avoiding the complete msg
CHECK_SOURCE(riac::new_message, msg);
cout << "new message" << endl;
broadcast();
},
[=](const riac::add_listener& req) {
//cout << "new listerner" << endl;
add_listener(actor_cast<riac::listener_type>(req.listener));
},
[=](const riac::add_typed_listener& req) {
add_listener(req.listener);
},
[=](const down_msg& dm) {
if (listeners_.erase(actor_cast<riac::listener_type>(dm.source)) > 0) {
cout << format_down_msg("listener", dm) << endl;
return;
}
auto probe_addr = probes_.find(dm.source);
if (probe_addr != probes_.end()) {
cout << format_down_msg("probe", dm) << endl;
riac::node_disconnected nd{probe_addr->second};
send(this, nd);
auto i = data_.find(probe_addr->second);
if (i != data_.end()
&& i->second.known_actors.erase(probe_addr->first) > 0) {
return;
}
}
},
[=](const riac::node_disconnected& nd) {
data_.erase(nd.source_node);
broadcast();
}
};
}
void test_action::test_current_sender() {
account_name cur_send;
read_action(&cur_send, sizeof(account_name));
eosio_assert( current_sender() == cur_send, "the current sender does not match" );
}
