/*
* Start Master init event, and wait client
*/
int StartMaster(void *arg) {
char *ip = ((SERVER_START_ARG *)arg)->ip;
int port = ((SERVER_START_ARG *)arg)->port;
int max_conn = ((SERVER_START_ARG *)arg)->max_conn;
event_callback_fn recv_callback_fn = ((SERVER_START_ARG *)arg)->recv_callback_fn;
// prepare socket
int server_sockfd = PrepareSocket();
if ( InitServer(server_sockfd, ip, port, max_conn) != 0 ) {
printf("Master start error.\n");
return -1;
}
// make non_blocking
evutil_make_listen_socket_reuseable(server_sockfd);
// init event
struct event_base *base = event_base_new();
assert(base != NULL);
struct event *listen_event;
callback_arg callarg;
callarg.base = base;
callarg.callback_fn = recv_callback_fn;
listen_event = event_new(base, server_sockfd, EV_READ|EV_PERSIST, MasterAcceptHandle, (void *)&callarg);
event_add(listen_event, NULL);
// start event
printf("Master Start\n");
event_base_dispatch(base);
return server_sockfd;
}
BOOL GenericConnection::CreateSocket()
{
if(m_soSocket == INVALID_SOCKET)
return PrepareSocket();
else
return TRUE;
}
int InitClient(int sockfd, char* addr, int port)
{
PrepareSocket(sockfd, addr, port);
int ret = connect(sockfd, (struct sockaddr *)&serverAddr, sizeof(struct sockaddr));
if(ret == -1)
{
printf("Connect Error!\n");
exit(1);
}
return sockfd;
}
int InitServer(int sockfd, char* addr, int port)
{
PrepareSocket(sockfd, addr, port);
int ret = bind(sockfd, (struct sockaddr *)&serverAddr, sizeof(struct sockaddr));
if(ret == -1)
{
printf("Bind Error!\n");
close(sockfd);
exit(1);
}
listen(sockfd, MAX_CONNECT_QUEUE);
return sockfd;
}
/*
* Init client
*/
int InitializeClient(char *ip, int port) {
// prepare socket
int client_sockfd = PrepareSocket();
// init
struct sockaddr_in server_addr;
memset(&server_addr, 0, sizeof(struct sockaddr_in));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port);
server_addr.sin_addr.s_addr = inet_addr(ip);
memset(&server_addr.sin_zero, 0, 8);
// connect to server
if ( connect(client_sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) < 0 ) {
printf("Connect error.\n");
close(client_sockfd);
return -1;
}
printf("Connect to server(%s:%d) successfully\n", ip, port);
return client_sockfd;
}
iSocket( std::string const &name ) : name_( name )
{
PrepareSocket();
}
iSocket( void )
{
PrepareSocket();
}
/**
* note the serialized block's size is different from others, it has tail info.
* exchange merger is at the end of one segment of plan, so it's the "stage_src"
* for this stage
*/
bool ExchangeMerger::Open(const PartitionOffset& partition_offset) {
unsigned long long int start = curtick();
RegisterExpandedThreadToAllBarriers();
if (TryEntryIntoSerializedSection()) { // first arrived thread dose
exhausted_lowers = 0;
this->partition_offset_ = partition_offset;
lower_num_ = state_.lower_id_list_.size();
socket_fd_lower_list_ = new int[lower_num_];
for (int i = 0; i < lower_num_; ++i) {
socket_fd_lower_list_[i] = -1;
}
// buffer all deserialized blocks come from every socket
all_merged_block_buffer_ = new BlockStreamBuffer(
state_.block_size_, BUFFER_SIZE_IN_EXCHANGE, state_.schema_);
ExpanderTracker::getInstance()->addNewStageEndpoint(
pthread_self(),
LocalStageEndPoint(stage_src, "Exchange", all_merged_block_buffer_));
// if one of block_for_socket is full, it will be deserialized into
// block_for_deserialization and sended to all_merged_data_buffer
block_for_deserialization =
BlockStreamBase::createBlock(state_.schema_, state_.block_size_);
// store block for each socket and the received block is serialized.
block_for_socket_ = new BlockContainer* [lower_num_];
for (unsigned i = 0; i < lower_num_; ++i) {
block_for_socket_[i] = new BlockContainer(
block_for_deserialization->getSerializedBlockSize());
}
if (PrepareSocket() == false) return false;
if (SetSocketNonBlocking(sock_fd_) == false) {
return false;
}
LOG(INFO) << "exchange_id = " << state_.exchange_id_
<< " partition_offset = " << partition_offset
<< " Open: exhausted lower senders num = " << exhausted_lowers
<< " lower sender num = " << lower_num_ << std::endl;
if (RegisterExchange() == false) {
LOG(ERROR) << "Register Exchange with ID = " << state_.exchange_id_
<< " fails!" << std::endl;
}
if (IsMaster()) {
/* According to a bug reported by dsc, the master exchange upper should
* check whether other uppers have registered to exchangeTracker.
* Otherwise, the lower may fail to connect to the exchangeTracker of some
* uppers when the lower nodes receive the exchange lower, as some uppers
* have not register the exchange_id to the exchangeTracker.
*/
LOG(INFO) << " exchange_id = " << state_.exchange_id_
<< " partition_offset = " << partition_offset
<< "Synchronizing...." << std::endl;
IsOtherMergersRegistered();
LOG(INFO) << " exchange_id = " << state_.exchange_id_
<< " partition_offset = " << partition_offset
<< " Synchronized! Then serialize and send its next segment "
"plan to all its lower senders" << std::endl;
if (SerializeAndSendPlan() == false) return false;
}
if (CreateReceiverThread() == false) {
return false;
}
CreatePerformanceInfo();
}
/// A synchronization barrier, in case of multiple expanded threads
BarrierArrive();
return true;
}
