void handle_server_request( const MemInfo &in_msg ) { const MessageHeader *header = reinterpret_cast<const MessageHeader *>( in_msg.get_data() ); switch( header->m_type ) { case MessageType::MESSAGE_DATA: { const MessageData *data = reinterpret_cast<const MessageData *>( in_msg.get_data()); std::ostringstream sout; sout<<"AGENT("<<getpid()<<"): "<<data->msg; m_logger->log(sout.str()); m_logger->disconnect(); MessageCompleted completed; m_client->send_message( completed ); std::lock_guard<std::mutex> l(g_mutex); g_stop = true; g_event.notify_one(); break; } default: { } } return; }
int main(int argc, char *argv[]) { CpuInfo *cpuinfo = new CpuInfo(); MemInfo *meminfo = new MemInfo(); FILE * fp; fp = fopen("system_information.txt", "w"); fprintf(fp, "Clockspeed\t: %llu\n", cpuinfo->GetClockSpeed()); fprintf(fp, "Cores\t\t: %d\n", cpuinfo->GetCores()); fprintf(fp, "Memory\t\t: %llu\n", meminfo->GetTotalMemSize()); fclose(fp); }
void connection_cb(bool connected) { // if connection changes, start delayed version request version_retries = RETRIES_COUNT; if (connected) autopilot_version_timer.start(); else autopilot_version_timer.stop(); // add/remove APM diag tasks if (connected && disable_diag && uas->is_ardupilotmega()) { #ifdef MAVLINK_MSG_ID_MEMINFO UAS_DIAG(uas).add(mem_diag); #endif #ifdef MAVLINK_MSG_ID_HWSTATUS UAS_DIAG(uas).add(hwst_diag); #endif #if !defined(MAVLINK_MSG_ID_MEMINFO) || !defined(MAVLINK_MSG_ID_HWSTATUS) ROS_INFO_NAMED("sys", "SYS: APM detected, but mavros uses different dialect. " "Extra diagnostic disabled."); #else ROS_DEBUG_NAMED("sys", "SYS: APM extra diagnostics enabled."); #endif } else { UAS_DIAG(uas).removeByName(mem_diag.getName()); UAS_DIAG(uas).removeByName(hwst_diag.getName()); ROS_DEBUG_NAMED("sys", "SYS: APM extra diagnostics disabled."); } }
void NameServiceClient::on_data_received( const SocketPtr &in_socket, const MemInfo &in_msg ) { std::unique_lock<std::mutex> l( m_mutex ); const DataServiceMessage *pMsg = reinterpret_cast<const DataServiceMessage *>( in_msg.get_data()); m_status = pMsg->m_status; switch( pMsg->m_header.m_type ) { case DataMessageType::DATA_SERVICE_INFO_REPLY: { std::string data(pMsg->m_data); std::istringstream sin( data ); boost::archive::text_iarchive ia( sin ); ia & m_info; break; } default: { } } m_response_ready = true; m_response_ready_cond.notify_one(); return; }
void RemoteLogServer::on_log_received( const SocketPtr &in_socket, const MemInfo &in_info ) { std::string message( in_info.get_data() ); m_signal_log_message_received( message ); return; }
bool HttpServer::CanContinue(const MemInfo& mem, int64_t rssMb, int64_t rssNeeded, int cacheFreeFactor) { if (!mem.valid()) return false; if (mem.freeMb < RuntimeOption::ServerCriticalFreeMb) return false; auto const availableMb = availableMemory(mem, rssMb, cacheFreeFactor); auto const result = (rssMb + availableMb >= rssNeeded); if (result) assert(CanStep(mem, rssMb, rssNeeded, cacheFreeFactor)); return result; }
void MemInfo::updateMax(const MemInfo& other) { max_mai = max(max_mai, other.getMAIIndex()); max_heap_mai = max(max_heap_mai, other.getHeapMAIIndex()); max_moi = max(max_moi, other.getMOIIndex()); max_heap_moi = max(max_heap_moi, other.getHeapMOIIndex()); max_stack = max(max_stack, other.getStackRatio()); max_flow = max(max_flow, other.getFlowRatio()); max_heap_flow = max(max_heap_flow, other.getHeapFlowRatio()); max_bpa = max(max_bpa, other.getBytesPerAccess()); }
bool HttpServer::CanContinue(const MemInfo& mem, int64_t rssMb, int64_t rssNeeded, int cacheFreeFactor) { assert(CanStep(mem, rssMb, rssNeeded, cacheFreeFactor)); if (!mem.valid()) return false; // Don't proceed if free memory is too limited, no matter how big // the cache is. if (mem.freeMb < rssNeeded / 16) return false; auto const availableMb = availableMemory(mem, rssMb, cacheFreeFactor); return (rssMb + availableMb >= rssNeeded); }
void MemInfo::updateMin(const MemInfo& other) { static bool firsttime = true; min_mai = min(min_mai, other.getMAIIndex()); min_heap_mai = min(min_heap_mai, other.getHeapMAIIndex()); min_moi = min(min_moi, other.getMOIIndex()); min_heap_moi = min(min_heap_moi, other.getHeapMOIIndex()); min_stack = min(min_stack, other.getStackRatio()); min_flow = min(min_flow, other.getFlowRatio()); min_heap_flow = min(min_heap_flow, other.getHeapFlowRatio()); min_bpa = min(min_bpa, other.getBytesPerAccess()); firsttime = false; }
bool HttpServer::CanStep(const MemInfo& mem, int64_t rssMb, int64_t rssNeeded, int cacheFreeFactor) { if (!mem.valid()) return false; if (mem.freeMb < RuntimeOption::ServerCriticalFreeMb) return false; auto const availableMb = availableMemory(mem, rssMb, cacheFreeFactor); // Estimation of the memory needed till the next check point. Since // the current check point is not the last one, we try to be more // optimistic, by assuming that memory requirement won't grow // drastically between successive check points, and that it won't // grow over our estimate. auto const neededToStep = std::min(rssNeeded / 4, rssNeeded - rssMb); return (availableMb >= neededToStep); }
void handle_server_commands( const MemInfo &in_msg ) { const MessageHeader *header = reinterpret_cast<const MessageHeader *>( in_msg.get_data() ); switch( header->m_type ) { case MESSAGE_LOGD_SHUTDOWN: { std::lock_guard<std::mutex> l( m_log_mutex ); m_stop = true; m_log_event.notify_one(); break; } default: { } } }
int main(int argc, char **argv) { MPI_Init(NULL, NULL); // MemInfo class: MemInfo* mInfo = MemInfo::GetInstance(); // Optional: initialize it with particular file name: mInfo->Init("mem_info.log"); // Test for the amount of memory in GB (all nodes): float chk_mem_gb = 2.0; int fail = mInfo->BelowThreshold(chk_mem_gb); if (fail > 0) fprintf(stderr, "WARNING: %d cores report memory shortage!\n", fail); // Print one line logs: for (int i = 0; i < 3; ++i) { void* p; if ((p=malloc(1<<28)) == NULL) { // allocate 256MB puts("malloc() failed"); break; } memset(p, 0, (1<<28)); char info[32]; snprintf(info, sizeof(info), "Step %d", i); mInfo->LogSummary(info); // log memory status } // Print info for all MPI ranks to stdout: mInfo->PrintAll(stdout); // Get available and total memory for "my" node [GB]: float avail_mem, total_mem; mInfo->GetMemInfo(&avail_mem, &total_mem); MPI_Finalize(); return(0); }
void handle_meminfo(const mavlink_message_t *msg, uint8_t sysid, uint8_t compid) { mavlink_meminfo_t mem; mavlink_msg_meminfo_decode(msg, &mem); mem_diag.set(mem.freemem, mem.brkval); }
void DataServer::on_data_received( const SocketPtr &in_socket, const MemInfo &in_msg ) { const DataServiceMessage *pMsg = reinterpret_cast<const DataServiceMessage *>( in_msg.get_data()); DataServiceMessage reply( DATA_SERVICE_GENERAL_REPLY ); bool status = false; switch( pMsg->m_header.m_type ) { case DataMessageType::DATA_SERVICE_REGISTER: { std::string buf = pMsg->m_data; std::istringstream ifs( buf ); boost::archive::text_iarchive ia( ifs ); ServiceRequestData data; ia & data; status = on_service_register_request( data.m_service_name, data.m_hostname, data.m_port ); break; } case DataMessageType::DATA_SERVICE_UNREGISTER: { std::string buf = pMsg->m_data; std::istringstream ifs( buf ); boost::archive::text_iarchive ia( ifs ); ServiceRequestData data; ia & data; status = on_service_unregister_request( data.m_service_name, data.m_hostname, data.m_port ); break; } case DataMessageType::DATA_SERVICE_INFO_REQUEST: { std::string buf = pMsg->m_data; std::istringstream ifs( buf ); boost::archive::text_iarchive ia( ifs ); ServiceRequestData data; ia & data; ServiceInfoPtr info; status = on_service_info_request( data.m_service_name, info ); if( info ) { std::ostringstream sout; boost::archive::text_oarchive oa(sout); oa & info; std::strncpy( reply.m_data, sout.str().c_str(), sout.str().size()); } reply.m_header.m_type = DATA_SERVICE_INFO_REPLY; break; } default: { } } reply.m_status = status; MemInfo replyMsg( reinterpret_cast<char *>( &reply ), sizeof( DataServiceMessage ) ); in_socket->send_data( replyMsg ); }
void handle_data( const SocketPtr &in_socket, const MemInfo &in_data ) { std::string msg = in_data.get_data(); std::cout<<"From server: "<<msg<<std::endl; return; }