wxFileOffset CStatusLineCtrl::GetCurrentSpeed() { if (!m_pStatus) return -1; const wxTimeSpan timeDiff( wxDateTime::UNow().Subtract(m_gcLastTimeStamp) ); if (timeDiff.GetMilliseconds().GetLo() <= 2000) return m_gcLastSpeed; m_gcLastTimeStamp = wxDateTime::UNow(); if (m_gcLastOffset == -1) m_gcLastOffset = m_pStatus->startOffset; const wxFileOffset fileOffsetDiff = m_pStatus->currentOffset - m_gcLastOffset; m_gcLastOffset = m_pStatus->currentOffset; m_gcLastSpeed = fileOffsetDiff * 1000 / timeDiff.GetMilliseconds().GetLo(); return m_gcLastSpeed; }
unsigned int CFileZillaEnginePrivate::GetRemainingReconnectDelay(const CServer& server) { std::list<t_failedLogins>::iterator iter = m_failedLogins.begin(); while (iter != m_failedLogins.end()) { const wxTimeSpan span = wxDateTime::UNow() - iter->time; const int delay = m_pOptions->GetOptionVal(OPTION_RECONNECTDELAY); if (span.GetSeconds() >= delay) { std::list<t_failedLogins>::iterator prev = iter; iter++; m_failedLogins.erase(prev); } else if (!iter->critical && iter->server.GetHost() == server.GetHost() && iter->server.GetPort() == server.GetPort()) return delay * 1000 - span.GetMilliseconds().GetLo(); else if (iter->server == server) return delay * 1000 - span.GetMilliseconds().GetLo(); else iter++; } return 0; }
bool Threading::Semaphore::WaitWithoutYield(const wxTimeSpan& timeout) { // This method is the reason why there has to be a special Darwin // implementation of Semaphore. Note that semaphore_timedwait() is prone // to returning with KERN_ABORTED, which basically signifies that some // signal has worken it up. The best official "documentation" for // semaphore_timedwait() is the way it's used in Grand Central Dispatch, // which is open-source. // on x86 platforms, mach_absolute_time() returns nanoseconds // TODO(aktau): on iOS a scale value from mach_timebase_info will be necessary u64 const kOneThousand = 1000; u64 const kOneBillion = kOneThousand * kOneThousand * kOneThousand; u64 const delta = timeout.GetMilliseconds().GetValue() * (kOneThousand * kOneThousand); mach_timespec_t ts; kern_return_t kr = KERN_ABORTED; for (u64 now = mach_absolute_time(), deadline = now + delta; kr == KERN_ABORTED; now = mach_absolute_time()) { if (now > deadline) { // timed out by definition return false; } u64 timeleft = deadline - now; ts.tv_sec = timeleft / kOneBillion; ts.tv_nsec = timeleft % kOneBillion; // possible return values of semaphore_timedwait() (from XNU sources): // internal kernel val -> return value // THREAD_INTERRUPTED -> KERN_ABORTED // THREAD_TIMED_OUT -> KERN_OPERATION_TIMED_OUT // THREAD_AWAKENED -> KERN_SUCCESS // THREAD_RESTART -> KERN_TERMINATED // default -> KERN_FAILURE kr = semaphore_timedwait(m_sema, ts); } if (kr == KERN_OPERATION_TIMED_OUT) { return false; } // while it's entirely possible to have KERN_FAILURE here, we should // probably assert so we can study and correct the actual error here // (the thread dying while someone is wainting for it). MACH_CHECK(kr); __atomic_sub_fetch(&m_counter, 1, __ATOMIC_SEQ_CST); return true; }