int StructuredLearnerRpc::FindOrCreateSession(const Json::Value& root, Json::Value& response) { int sess_ind = -1; char sess_id[1000]; char errStr[1000]; if(strlen(root.get("session_id", "").asString().c_str()) < 1000) strcpy(sess_id, root.get("session_id", "").asString().c_str()); else strcpy(sess_id, ""); if(!strlen(sess_id)) { if(!NewSession(root, response) || !InitializeSession(root, response)) { JSON_ERROR("Failed to create new session in classify_example\n", -1); } sess_ind = num_sessions-1;//FindSession(response.get("session_id", "").asString().c_str()); assert(sess_ind >= 0); //fprintf(stderr, "New Session %d\n", sess_ind); } else { sess_ind=FindSession(sess_id, true); if(sess_ind < 0) { sprintf(errStr, "Invalid session_id %s in classify_example()\n", sess_id); JSON_ERROR(errStr, sess_ind); } //fprintf(stderr, "Found Session %d %s\n", sess_ind, sess_id); } response["session_id"] = sessions[sess_ind].id; return sess_ind; }
BOOL CSerialServer::RunDaemon() { WORKSESSION *pSession; char szBuffer[2048+1]; int len; long lCurTime; BOOL bForever = TRUE; m_pSaveSession = pSession = NewSession(m_nFD, m_szDevice); if (pSession == NULL) { return FALSE; } if (!EnterSession(pSession)) { LeaveSession(pSession); return FALSE; } for(;bForever && !m_bExitPending;) { // Passive mode에서는 수신을 하지 않는다. if (m_bPassiveMode) { USLEEP(1000000); continue; } len = read(m_nFD, szBuffer, 2048); if (len == 0) { // Timeout Session if (m_nTimeout != -1) { time(&lCurTime); if ((lCurTime-pSession->lLastInput) >= m_nTimeout) { pSession->lLastInput = lCurTime; if (!OnTimeoutSession(pSession)) break; } } continue; } else if (len < 0) { // Terminate Session break; } else { // Receive Session time(&pSession->lLastInput); AddSessionRecvStream(pSession, szBuffer, len); } } LeaveSession(pSession); return FALSE; }
void TCPNetwork::Run() { //Set select parameters auto readSet = m_readSet; auto writeSet = m_readSet; auto excptSet = m_readSet; timeval timeOut{ 0, 1000 }; //Call select and check result auto selectRet = select(0, &readSet, &writeSet, &excptSet, &timeOut); auto isFDSetChanged = RunCheckSelectResult(selectRet); if (isFDSetChanged == false) { return; } //Process FD elements if (FD_ISSET(m_serverSocket, &readSet)) { NewSession(); } else { RunCheckSelectClient(readSet, writeSet, excptSet); } }
int EDITAPI EDITFile( char *fn, char *hlib ) /***************************************************/ { CurrSession = FindSession( fn ); if( CurrSession == NULL ) { if( StartingSessionInProgress ) { return( FALSE ); } StartingSessionInProgress = TRUE; // new session must be created before we start the editor so // that we can process the WM_DDE_INITIATE message properly CurrSession = NewSession( fn, hlib ); if( CurrSession == NULL ) { return( FALSE ); } LinkSession( CurrSession ); if( spawnlp( P_NOWAIT, _Editor, _Editor, "/W", fn, NULL ) == -1 ) { DeleteSession( NULLHANDLE ); CurrSession = NULL; return( FALSE ); } } WinSetFocus( HWND_DESKTOP, CurrSession->hwnd ); return( TRUE ); }
void TcpNetwork::Run() { auto read_set = m_Readfds; auto write_set = m_Readfds; auto exc_set = m_Readfds; timeval timeout{ 0, 1000 }; //tv_sec, tv_usec auto selectResult = select(0, &read_set, &write_set, &exc_set, &timeout); auto isFDSetChanged = RunCheckSelectResult(selectResult); if (isFDSetChanged == false) { return; } // Accept if (FD_ISSET(m_ServerSockfd, &read_set)) { NewSession(); } else // clients { RunCheckSelectClients(exc_set, read_set, write_set); } }
//-------------------------------------------------------------- Session_ptr create_session_with_graph( tensorflow::GraphDef& graph_def, const string device, const tensorflow::SessionOptions& session_options) { Session_ptr session(NewSession(session_options)); if( !session) { ofLogError() << "Error creating session"; return nullptr; } if(!device.empty()) tensorflow::graph::SetDefaultDevice(device, &graph_def); log_error(session->Create(graph_def), "Error creating graph for session"); return session; }
int SessionManager::Poll(struct timeval &timeout) { SetupFdset(); int ret = ::select( _nfds+1, _read_set, _write_set, _error_set, &timeout); if (ret > 0) { // new connection comes ? if (_listen.is_valid() && _read_set.is_set( _listen.query_socket() ) ) { DEBUG("new session"); NewSession(); } SessionList list = SessionMapToList(_sessions); // poll read session for (SessionList::iterator it=list.begin(); it!=list.end(); it++) { ISession *session = *it; SOCKET s = session->query_socket(); if (_read_set.is_set(s)) { // notify the listener int nReturn = session->do_recv(); if (nReturn <= 0 ) { DEBUG("session close connection"); if (nReturn == SOCKET_ERROR) { ERROR("socket wrong and close connection"); session->OnError(this, WSAGetLastError(), "socket wrong and close connection" ); } // delete session _sessions.erase(session->getid()); session->OnDisconnect(this); delete session; } else { session->OnRead(this); } } } //for // poll write and error session list = SessionMapToList(_nbconnect_sessions); for (SessionList::iterator it=list.begin(); it!=list.end(); it++) { ISession *session = *it; SOCKET s = session->query_socket(); if (_error_set.is_set(s)) // error { _nbconnect_sessions.erase(session->getid()); ERROR("connection non-blocking socket error"); session->OnError(this, WSAGetLastError(), "connection non-blocking socket error"); delete session; } else if (_write_set.is_set(s)) // write { // check error (when socket error it become writeable on linux) // so must check. int err = 0; socklen_t errlen = sizeof(err); ::getsockopt(s, SOL_SOCKET, SO_ERROR, &err, &errlen); if (err) { _nbconnect_sessions.erase(session->getid()); ERROR("connection non-blocking socket error"); session->OnError(this, WSAGetLastError(), "connection non-blocking socket error"); delete session; } else { // delete from non-blocking connection session _nbconnect_sessions.erase(session->getid()); _sessions[session->getid()] = session; session->OnConnect(this); } } } //for // delete session of _delete_sessions for (SessionMap::iterator it=_delete_sessions.begin(); it!=_delete_sessions.end(); it++) { int id = it->first; ISession *session = it->second; if (_sessions.count(id) > 0) { // delete session _sessions.erase(id); session->OnDisconnect(this); delete session; } else if (_nbconnect_sessions.count(id) > 0) { // just delete session _nbconnect_sessions.erase(id); delete session; } } //for _delete_sessions.clear(); } // if return ret; }
DWORD CSerialServer::ReadProc() { OVERLAPPED osReader; // Overlapped structure for read operations OVERLAPPED osStatus; // Overlapped structure for status operations HANDLE arEvents[3]; // Event Array DWORD dwStoredFlags; // Local copy of event flags DWORD dwCommEvent=0; // Result from WaitCommEvent DWORD dwRead; // Bytes actually read #ifndef WINCE DWORD dwResult; // Result from WaitForSingleObject #endif BOOL fWaitingOnRead; BOOL fWaitingOnStat; BOOL fThreadDone; #ifndef WINCE DWORD dwOvRes; // Result from GetOverlappedResult #endif m_pSaveSession = NewSession(m_hComPort, m_szDevice); OnEnterSession(m_pSaveSession); dwStoredFlags = 0xFFFFFFFF; fWaitingOnRead = FALSE; fWaitingOnStat = FALSE; fThreadDone = FALSE; // Create two overlapped structures, one for read events // and another for status events memset(&osReader, 0, sizeof(OVERLAPPED)); osReader.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); if (osReader.hEvent == NULL) XDEBUG("[CSerialServer] CreateEvent (Reader Event).\n"); memset(&osStatus, 0, sizeof(OVERLAPPED)); osStatus.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); if (osStatus.hEvent == NULL) XDEBUG("[CSerialServer] CreateEvent (Status Event).\n"); arEvents[0] = m_hReadStopEvent; arEvents[1] = osReader.hEvent; arEvents[2] = osStatus.hEvent; // Initial Check, Forces Updates CheckModemStatus(TRUE); CheckComStat(TRUE); m_bRecvReady = TRUE; while(!fThreadDone && !m_bDisconnectPending) { if (m_bPassiveMode) { Sleep(100); continue; } if (!ReadFile(m_hComPort, m_szBuffer, DEFAULT_SIO_BUFFER, &dwRead, &osReader)) { // Read not delayed? if (GetLastError() != ERROR_IO_PENDING) XDEBUG("[CSerialComm] ReadFile in ReaderAndStatusProc.\r\n"); } #ifndef WINCE else { // Read Completed Immediately if ((dwRead != MAX_READ_BUFFER) && m_bDisplayTimeouts) XDEBUG("[CSerialComm] Read timed out immediately.\r\n"); } dwResult = WaitForMultipleObjects(3, arEvents, FALSE, STATUS_CHECK_TIMEOUT); switch(dwResult) { case WAIT_OBJECT_0 : // Thread Exit Event fThreadDone = TRUE; break; case WAIT_OBJECT_0 + 1 : // Read Completed if (!GetOverlappedResult(m_hComPort, &osReader, &dwRead, FALSE)) { if (GetLastError() == ERROR_OPERATION_ABORTED) XDEBUG("[CSerialComm] Read aborted.\r\n"); else ErrorHandler(const_cast<char*>("[CSerialServer] GetOverlappedResult (in Reader).\r\n")); } else { // Read Completed Successfully if ((dwRead != MAX_READ_BUFFER) && m_bDisplayTimeouts) XDEBUG("[CSerialComm] Read timed out overlapped.\r\n"); if (dwRead > 0) OnReceiveSession(m_pSaveSession, (char *)m_szBuffer, dwRead); } fWaitingOnRead = FALSE; break; case WAIT_OBJECT_0 + 2 : // Status Completed if (!GetOverlappedResult(m_hComPort, &osStatus, &dwOvRes, FALSE)) { if (GetLastError() == ERROR_OPERATION_ABORTED) XDEBUG("[CSerialServer] WaitCommEvent aborted.\n"); else ErrorHandler(const_cast<char*>("[CSerialServer] GetOverlappedResult (in Reader).\r\n")); } else { // status check completed successfully ReportStatusEvent(dwCommEvent); } fWaitingOnStat = FALSE; break; case WAIT_TIMEOUT: // If status checks are not allowed, then don't issue the // modem status check nor the com stat check if (!m_bNoStatus) { CheckModemStatus(FALSE); CheckComStat(FALSE); } break; default: XDEBUG("[CSerialServer] WaitForMultipleObjects(Reader & Status handles).\r\n"); break; } #else if (dwRead > 0) OnReceiveSession(m_pSaveSession, (char *)m_szBuffer, dwRead); #endif } OnLeaveSession(m_pSaveSession); DeleteSession(m_pSaveSession); // Set SendThread Exit Event SetEvent(m_hThreadExitEvent); m_bExitWriter = TRUE; WaitForSingleObject(m_hSendTerminateEvent, 5000); // Close event handles CloseHandle(osReader.hEvent); CloseHandle(osStatus.hEvent); // Set Terminate Signal SetEvent(m_hReadTerminateEvent); return 0; }
int RunSingleSessionLoop( const wchar_t* sessionUuidStr ) { HRESULT hr = S_OK; MSG msg; int sessionCount = 0; UINT_PTR timerId = 0; // Make these available for as soon as the server starts listening for calls gMainTid = GetCurrentThreadId(); hr = InitSingleSessionLoop( sessionUuidStr ); if ( FAILED( hr ) ) return hr; // force the OS to make a message queue PeekMessage( &msg, NULL, 0, 0, FALSE ); timerId = SetTimer( NULL, 1, ConnectTimeoutMillis, NULL ); if ( timerId == 0 ) return HRESULT_FROM_WIN32( GetLastError() ); while ( GetMessage( &msg, NULL, 0, 0 ) ) { if ( msg.hwnd == NULL ) { switch ( msg.message ) { case WM_TIMER: KillTimer( NULL, timerId ); timerId = 0; if ( NewSession() ) { // Because NewSession just claimed the only debugging session, it means // that no other debugging session was opened, no other session can be // opened, and time ran out. So, quit. PostQuitMessage( ConnectTimeoutErrorCode ); } break; case WM_MAGO_SESSION_ADDED: sessionCount++; break; case WM_MAGO_SESSION_DELETED: sessionCount--; if ( sessionCount == 0 ) { PostQuitMessage( 0 ); } break; } } } if ( timerId != 0 ) KillTimer( NULL, timerId ); UninitRpcServer(); return (int) msg.wParam; }
void Tensorflow::consume(IConsumer::info consume_info, ssi_size_t stream_in_num, ssi_stream_t stream_in[]) { ssi_real_t *dataptr = ssi_pcast(ssi_real_t, stream_in[0].ptr); tensorflow::Session *session; tensorflow::Status status = NewSession(tensorflow::SessionOptions(), &session); if (!status.ok()) { ssi_wrn("status: %s \n", status.ToString().c_str()); return; } tensorflow::GraphDef graph_def; #if __ANDROID__ status = ReadTextProto(tensorflow::Env::Default(), "/sdcard/android_xmlpipe/frozen_graph.pb", &graph_def); #else status = ReadTextProto(tensorflow::Env::Default(), "/home/mainuser/code/SSI/mobileSSI/plugins/tensorflow/test_files/frozen_graph.pb", &graph_def); #endif if (!status.ok()) { ssi_wrn("status: %s \n", status.ToString().c_str()); return; } status = session->Create(graph_def); if (!status.ok()) { ssi_wrn("status: %s \n", status.ToString().c_str()); return; } int number_dim = stream_in[0].dim; int number_test = stream_in[0].num; // 4072 int number_classes = 4; tensorflow::Tensor input_tensor(tensorflow::DT_FLOAT, tensorflow::TensorShape({number_test, number_dim})); auto dst = input_tensor.flat<float>().data(); for (int i = 0; i < stream_in[0].num; i++) { std::copy_n(dataptr + i * number_dim, number_dim, dst); dst += number_dim; } std::vector<std::pair<std::string, tensorflow::Tensor>> inputs = {{"input_TT", input_tensor}}; std::vector<tensorflow::Tensor> outputs; status = session->Run(inputs, {"output_TT"}, {}, &outputs); if (!status.ok()) { ssi_wrn("status: %s \n", status.ToString().c_str()); return; } std::vector<int> number_hits(number_classes, 0); for (std::vector<tensorflow::Tensor>::iterator it = outputs.begin(); it != outputs.end(); ++it) { auto items = it->shaped<float, 2>({number_test, number_classes}); for (int i = 0; i < number_test; i++) { int arg_max = 0; float val_max = items(i, 0); for (int j = 0; j < number_classes; j++) { if (items(i, j) > val_max) { arg_max = j; val_max = items(i, j); } } for (int i = 0; i < number_classes; i++) { if (arg_max == i) { number_hits[i]++; } } } } std::string classes[] = {"ambient_animals", "rain", "running_water", "traffic"}; for (int i = 0; i < number_classes; i++) { float accuracy = (float) number_hits[i] / number_test; ssi_wrn("accuracy for class %s : %f \n", classes[i].c_str(), accuracy); _probs[i] = accuracy; } session->Close(); _handler->handle(consume_info.time, consume_info.dur, 4, 0, _probs, _class_names, 0, 0); }