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" ); }