// --------------------------------------------------------------------
void rma_receiver::handle_message_no_chunk_data()
{
chunk_fetch_ = true;
// get the remote chunk block memory region details
auto &cb = header_->chunk_header_ptr()->chunk_rma;
LOG_DEBUG_MSG("receiver " << hexpointer(this)
<< "Fetching RMA chunk chunk data with "
<< "size " << decnumber(cb.size_)
<< "rkey " << hexpointer(cb.rkey_)
<< "addr " << hexpointer(cb.data_.cpos_));
// we need a local memory region to read the chunks into
chunk_region_ = memory_pool_->allocate_region(cb.size_);
chunk_region_->set_message_length(cb.size_);
uint64_t rkey1 = cb.rkey_;
const void *remoteAddr1 = cb.data_.cpos_;
// add it to the list of rma regions to fetch
rma_regions_.push_back(chunk_region_);
LOG_DEBUG_MSG("receiver " << hexpointer(this)
<< "Fetching chunk region with size " << decnumber(cb.size_));
rma_count_ = 1;
// if the message region requires rma-get, we can get it now as well
if (!header_->message_piggy_back())
{
auto &mc = header_->message_chunk_ptr()->message_rma;
message_region_ = memory_pool_->allocate_region(mc.size_);
message_region_->set_message_length(mc.size_);
uint64_t rkey2 = mc.rkey_;
const void *remoteAddr2 = mc.data_.cpos_;
// add it to the list of rma regions to fetch
rma_regions_.push_back(message_region_);
LOG_DEBUG_MSG("receiver " << hexpointer(this)
<< "Fetching message region with size " << decnumber(mc.size_));
++rma_count_;
// call the rma read function for the message chunk
read_one_chunk(src_addr_, message_region_, remoteAddr2, rkey2);
}
// call the rma read function for the chunk-info chunk
// we do this last so that a completion does not come before the message
// chunk read has been triggered - this would cause the rma receive to decrement
// the counter and might hit zero before we had sent the second request
read_one_chunk(src_addr_, chunk_region_, remoteAddr1, rkey1);
}
static void realloc_request_list(struct Verify_Request_List **history_request_list)
{
*history_request_list = (struct Verify_Request_List *)malloc(sizeof(struct Verify_Request_List));
if(*history_request_list == NULL)
{
LOG_DEBUG_MSG("Failed memory allocation. \n");
return;
}
LOG_DEBUG_MSG("_log_request_list : 0x%08X \n", _log_request_list);
(*history_request_list)->crash_pointer = NULL;
(*history_request_list)->crash_request_count= 0;
(*history_request_list)->request_count = 0;
(*history_request_list)->head = NULL;
(*history_request_list)->tail = NULL;
(*history_request_list)->next = NULL;
_normal_request_count_after_crash = 0;
_normal_request_count_before_crash = 0;
static void destory_request_list(struct Verify_Request_List *list)
{
struct Verify_Request_Info *del_info = NULL;
struct Verify_Request_Info *next_info = NULL;
LOG_DEBUG_MSG("Destroy History Request List START, Verify_Request_List : 0x%08X \n", list);
if(list == NULL)
return ;
if(list->crash_pointer != NULL)
{
free(list->crash_pointer);
list->crash_pointer = NULL;
}
if(list->head != NULL)
del_info = list->head;
while(del_info != NULL)
{
if(del_info->next != NULL)
next_info = del_info->next;
else
next_info = NULL;
if(del_info->crash_pages_in_request != NULL)
{
free(del_info->crash_pages_in_request);
del_info->crash_pages_in_request = NULL;
}
del_info->request_start_lsn = 0;
del_info->request_sectors = 0;
del_info->request_status = 0;
del_info->next = NULL;
free(del_info);
del_info = next_info;
}
list->head = NULL;
list->tail = NULL;
list->next = NULL;
list->crash_pointer = NULL;
list->request_count = 0;
list->crash_request_count = 0;
free(list);
// --------------------------------------------------------------------
void rma_receiver::read_one_chunk(
fi_addr_t src_addr, region_type *get_region,
const void *remoteAddr, uint64_t rkey)
{
// post the rdma read/get
LOG_DEBUG_MSG("rma_receiver " << hexpointer(this)
<< "RDMA Get fi_read :"
<< "client " << hexpointer(endpoint_)
<< "fi_addr " << hexpointer(src_addr_)
<< "tag " << hexuint64(header_->tag())
<< "local addr " << hexpointer(get_region->get_address())
<< "local desc " << hexpointer(get_region->get_desc())
<< "size " << hexlength(get_region->get_message_length())
<< "rkey " << hexpointer(rkey)
<< "remote cpos " << hexpointer(remoteAddr));
// count reads
++rma_reads_;
ssize_t ret = 0;
for (std::size_t k = 0; true; ++k)
{
LOG_EXCLUSIVE(
// write a pattern and dump out data for debugging purposes
uint32_t *buffer =
reinterpret_cast<uint32_t*>(get_region->get_address());
std::fill(buffer, buffer + get_region->get_size()/4, 0xDEADC0DE);
LOG_TRACE_MSG(
CRC32_MEM(get_region->get_address(), c.size_,
"(RDMA GET region (pre-fi_read))"));
);
ret = fi_read(endpoint_,
get_region->get_address(),
get_region->get_message_length(),
get_region->get_desc(),
src_addr_,
(uint64_t)(remoteAddr), rkey, this);
if (ret == -FI_EAGAIN)
{
LOG_ERROR_MSG("receiver " << hexpointer(this)
<< "reposting fi_read...\n");
hpx::util::detail::yield_k(k, "libfabric::receiver::async_read");
continue;
}
if (ret) throw fabric_error(ret, "fi_read");
break;
}
static void *listenForMessages( void *ptr )
{
struct sockaddr_in si_me;
struct sockaddr_in si_other;
socklen_t slen = sizeof(si_other);
ssize_t readBytes = 0;
char buf[BUFLEN+1]; //add space fer terminating \0
char msgId[MSGIDLEN+1]; //add space fer terminating \0
int port = PORT;
DLT_REGISTER_APP("GNSS", "GNSS-SERVICE");
DLT_REGISTER_CONTEXT(gContext,"GSRV", "Global Context");
LOG_DEBUG(gContext,"GNSSService listening on port %d...",port);
if((s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP))==-1)
{
LOG_ERROR_MSG(gContext,"socket() failed!");
exit(EXIT_FAILURE);
}
memset((char *) &si_me, 0, sizeof(si_me));
si_me.sin_family = AF_INET;
si_me.sin_port = htons(port);
si_me.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind(s, (struct sockaddr *)&si_me, (socklen_t)sizeof(si_me)) == -1)
{
LOG_ERROR_MSG(gContext,"bind() failed!");
exit(EXIT_FAILURE);
}
while(isRunning == true)
{
//use select to introduce a timeout - alloy shutdown even when no data are received
fd_set readfs; /* file descriptor set */
int maxfd; /* maximum file desciptor used */
int res;
struct timeval Timeout;
/* set timeout value within input loop */
Timeout.tv_usec = 0; /* milliseconds */
Timeout.tv_sec = 1; /* seconds */
FD_SET(s, &readfs);
maxfd = s+1;
/* block until input becomes available */
res = select(maxfd, &readfs, NULL, NULL, &Timeout);
if (res > 0)
{
readBytes = recvfrom(s, buf, BUFLEN, 0, (struct sockaddr *)&si_other, (socklen_t *)&slen);
if(readBytes < 0)
{
LOG_ERROR_MSG(gContext,"recvfrom() failed!");
exit(EXIT_FAILURE);
}
buf[readBytes] = '\0';
LOG_DEBUG_MSG(gContext,"------------------------------------------------");
LOG_DEBUG(gContext,"Received Packet from %s:%d",
inet_ntoa(si_other.sin_addr), ntohs(si_other.sin_port));
sscanf(buf, "%*[^'$']$%" STRINGIFY(MSGIDLEN) "[^',']", msgId);
LOG_DEBUG(gContext,"MsgID:%s", msgId);
LOG_DEBUG(gContext,"Len:%u", (unsigned int)strlen(buf));
LOG_DEBUG(gContext,"Data:%s", buf);
LOG_DEBUG_MSG(gContext,"------------------------------------------------");
if(strcmp("GVGNSPOS", msgId) == 0)
{
processGVGNSPOS(buf);
}
else if(strcmp("GVGNSTIM", msgId) == 0)
{
processGVGNSTIM(buf);
}
else if(strcmp("GVGNSSAT", msgId) == 0)
{
processGVGNSSAT(buf);
}
//handling of old logs for backward compatibility
else if(strcmp("GVGNSP", msgId) == 0)
{
processGVGNSP(buf);
}
else if(strcmp("GVGNSC", msgId) == 0)
{
processGVGNSC(buf);
}
else if(strcmp("GVGNSAC", msgId) == 0)
{
processGVGNSAC(buf);
}
}
}
close(s);
return EXIT_SUCCESS;
}
static void insert_request_list(struct Verify_Request_Info *info, enum VERI_ERROR_NUM status)
{
if(_log_request_list == NULL)
{
LOG_DEBUG_MSG("History Request List is not allocation.\n");
return;
}
if(_current_step != verify_get_current_step())
{
realloc_request_list(&_log_request_list);
_current_step = verify_get_current_step();
insert_manager_list(&_log_request_list, _current_step);
}
if(_log_request_list->request_count == 0)
{
_log_request_list->head = info;
_log_request_list->tail = info;
}
else
{
_log_request_list->tail->next = info;
_log_request_list->tail = info;
}
_log_request_list->request_count++;
if(_log_request_list->crash_request_count == 0)
{
_normal_request_count_before_crash++;
if(_normal_request_count_before_crash > MAX_NORMAL_REQUEST + 1)
{
struct Verify_Request_Info *temp = _log_request_list->head;
_log_request_list->head = _log_request_list->head->next;
free(temp);
_log_request_list->request_count--;
_normal_request_count_before_crash--;
}
}
else
{
_normal_request_count_after_crash++;
if(_normal_request_count_after_crash >= MAX_NORMAL_REQUEST && status < VERI_EREQUEST)
{
realloc_request_list(&_log_request_list);
insert_manager_list(&_log_request_list, _current_step);
return;
}
}
if(status >= VERI_EREQUEST)
{
_normal_request_count_after_crash = 0;
if(_log_request_list->crash_request_count == 0)
{
LOG_DEBUG_MSG("Create, Insert Crash Info (lsn : 0x%08X, sectors : %d, count before crash : %d, count after crash : %d, crash index : %d) \n", info->request_start_lsn, info->request_sectors, _normal_request_count_before_crash, _normal_request_count_after_crash, _log_request_list->crash_request_count);
_log_request_list->crash_pointer = (struct Verify_Request_Info **)malloc(sizeof(struct Verify_Request_Info *) * DEFAULT_CRASH_ALLOC_COUNT);
if(_log_request_list->crash_pointer == NULL)
{
LOG_DEBUG_MSG("Failed memory allocation. \n");
return;
}
memset(&*(_log_request_list->crash_pointer), 0, sizeof(struct Verify_Request_Info *) * DEFAULT_CRASH_ALLOC_COUNT);
_log_request_list->crash_pointer[_log_request_list->crash_request_count] = info;
}
else if(_log_request_list->crash_request_count != 0 &&
_log_request_list->crash_request_count % DEFAULT_CRASH_ALLOC_COUNT == 0)
{
struct Verify_Request_Info **temp = NULL;
uint alloc_count = ((_log_request_list->crash_request_count / DEFAULT_CRASH_ALLOC_COUNT) + 1) * DEFAULT_CRASH_ALLOC_COUNT;
LOG_DEBUG_MSG("Reset, Insert Crash Info (lsn : 0x%08X, sectors : %d, count before crash : %d, count after crash : %d, crash index : %d) \n", info->request_start_lsn, info->request_sectors, _normal_request_count_before_crash, _normal_request_count_after_crash, _log_request_list->crash_request_count);
temp = (struct Verify_Request_Info **)malloc(sizeof(struct Verify_Request_Info *) * alloc_count);
if(temp == NULL)
{
LOG_DEBUG_MSG("Failed memory allocation. \n");
return;
}
memset(&*temp, 0, sizeof(struct Verify_Request_Info *) * alloc_count);
memcpy(&*temp, &*(_log_request_list->crash_pointer), sizeof(struct Verify_Request_Info *) * _log_request_list->crash_request_count);
free(_log_request_list->crash_pointer);
_log_request_list->crash_pointer = temp;
_log_request_list->crash_pointer[_log_request_list->crash_request_count] = info;
}
else
{
LOG_DEBUG_MSG("Insert Crash Info (lsn : 0x%08X, sectors : %d, count before crash : %d, count after crash : %d, crash index : %d) \n", info->request_start_lsn, info->request_sectors, _normal_request_count_before_crash, _normal_request_count_after_crash, _log_request_list->crash_request_count);
_log_request_list->crash_pointer[_log_request_list->crash_request_count] = info;
}
_log_request_list->crash_request_count++;
}
~unique_lock()
{
LOG_DEBUG_MSG("Destroying unique_lock RAII");
}
unique_lock(Mutex& m, std::try_to_lock_t t) : std::unique_lock<Mutex>(m, t)
{
LOG_DEBUG_MSG("Creating unique_lock try_to_lock_t RAII");
}
unique_lock(Mutex &m) : std::unique_lock<Mutex>(m)
{
LOG_DEBUG_MSG("Creating unique_lock RAII");
}
~scoped_lock()
{
LOG_DEBUG_MSG("Destroying scoped_lock RAII");
}
scoped_lock(Mutex &m) : std::lock_guard<Mutex>(m)
{
LOG_DEBUG_MSG("Creating scoped_lock RAII");
}
