/** Send a Fetch task to a target worker. * @param to a worker that will receive a split * @param from a worker that will send a split * @param name a name of a split that will be sent * @param size the size of a split that will be sent * @param id id of this task (generally 0) * @param uid id of this fetch task. * @param parentid parent id of this task * @return NULL */ static void dispatch_fetch(WorkerInfo *to, const ServerInfo &from, const string &name, size_t size, ::uint64_t id, ::uint64_t uid) { FetchRequest req; req.set_name(name); req.mutable_location()->CopyFrom(from); req.set_size(size); req.set_id(id); req.set_uid(uid); to->Fetch(req); LOG_DEBUG("FETCH TaskID %16d - Sent to Worker %s", static_cast<int>(uid), to->hostname().c_str()); }
/** Fetch a split from remote worker and keep it in the shared memory region * @param dest a memory pointer where the split will be written (usually shared mem) * @param name a name of split to fetch * @param size the size of split to fetch * @param client a worker information from where we will fetch the split * @param myhostname a name of worker who initiate the transfer request * @param store a location other than dram where the split will be written. It can be zero-length * @return return code from server */ int32_t TransferServer::transfer_blob(void *dest, const string &name, size_t size, WorkerInfo* client, const string& myhostname, const string &store) { // Setup the transfer this->dest_ = dest; this->size_ = size; bytes_fetched_ = 0; // Initialize semaphore to zero. Server thread will increment // when it is ready sem_init(&server_ready, 0, 0); // Setup a receicing thread. // Later, we will send a Fetch request, // and the data will arrive to this thread pthread_t server_thread; pthread_create(&server_thread, 0, transfer_pthread, this); // fprintf(stderr, // "Waiting for server to be ready for transfer array %s from %s\n", // a.name.c_str(), a.location.name.c_str()); // Wait till server is ready sem_wait(&server_ready); // FIXME(shivaram): This doesn't work on bfc machines // char hostname[64]; // HOST_NAME_MAX is 64 in Linux // int ret = gethostname(hostname, 64); // if (ret < 0) { // return ret; // } // Information of the requester ServerInfo location; location.set_name(myhostname); location.set_presto_port(server_socket_port); // Create a fetch request FetchRequest req; req.mutable_location()->CopyFrom(location); req.set_size(size); req.set_name(name); if (!store.empty()) { req.set_store(store); } client->NewTransfer(req); // request transfer to remote workers void* server_ret; pthread_join(server_thread, &server_ret); sem_destroy(&server_ready); return *reinterpret_cast<int32_t*>(server_ret); // TODO(erik): error handling // } else { // // Cancel the server thread if transfer failed. // // TODO(shivaram): Check if this behaves correctly or use signals. // fprintf(stderr, "Transfer failed, cancelling server\n"); // sem_destroy(&server_ready); // pthread_cancel(server_thread); // shutdown(serverfd, SHUT_RDWR); // close(serverfd); // return -1; // } }