vector<TimerEvent*> Timer::GetExpiredTimerEvent(const Timestamp& now_ts) { LOG_VERBOSE << "us:" << now_ts.GetTimeUs() << endl; vector<TimerEvent*> expired_events; PrintWaitEvent(); auto iter = wait_event_.lower_bound(now_ts.GetTimeUs()); auto it = wait_event_.begin(); while (it != iter) { auto timer_it = id_timer_map_.find(it->second); if (timer_it != id_timer_map_.end()) { expired_events.push_back(timer_it->second.get()); } else { LOG_VERBOSE << "timer id:" << it->second << " has been canceled" << endl; } it = wait_event_.erase(it); LOG_VERBOSE << "some timer event happend" << endl; } return expired_events; }
DateTime::DateTime() { Timestamp now; _utcTime = now.utcTime(); computeGregorian(julianDay()); computeDaytime(); }
void TimerTest::testScheduleInterval() { Timer timer; Timestamp time; TimerTask::Ptr pTask = new TimerTaskAdapter<TimerTest>(*this, &TimerTest::onTimer); assert (pTask->lastExecution() == 0); timer.schedule(pTask, 500, 500); _event.wait(); assert (time.elapsed() >= 590000); assert (pTask->lastExecution().elapsed() < 130000); _event.wait(); assert (time.elapsed() >= 1190000); assert (pTask->lastExecution().elapsed() < 130000); _event.wait(); assert (time.elapsed() >= 1790000); assert (pTask->lastExecution().elapsed() < 130000); pTask->cancel(); assert (pTask->isCancelled()); }
void LiveSLAMWrapper::newImageCallback(const cv::Mat& img, Timestamp imgTime) { ++ imageSeqNumber; // Convert image to grayscale, if necessary cv::Mat grayImg; if (img.channels() == 1) grayImg = img; else cvtColor(img, grayImg, CV_RGB2GRAY); // Assert that we work with 8 bit images assert(grayImg.elemSize() == 1); assert(fx != 0 || fy != 0); // need to initialize if(!isInitialized) { monoOdometry->randomInit(grayImg.data, img.data, imgTime.toSec(), 1); isInitialized = true; } else if(isInitialized && monoOdometry != nullptr) { monoOdometry->trackFrame(grayImg.data, img.data, imageSeqNumber,false,imgTime.toSec()); } }
StatusWith<OplogFetcher::DocumentsInfo> OplogFetcher::validateDocuments( const Fetcher::Documents& documents, bool first, Timestamp lastTS) { if (first && documents.empty()) { return Status(ErrorCodes::OplogStartMissing, str::stream() << "The first batch of oplog entries is empty, but expected at " "least 1 document matching ts: " << lastTS.toString()); } DocumentsInfo info; // The count of the bytes of the documents read off the network. info.networkDocumentBytes = 0; info.networkDocumentCount = 0; for (auto&& doc : documents) { info.networkDocumentBytes += doc.objsize(); ++info.networkDocumentCount; // If this is the first response (to the $gte query) then we already applied the first doc. if (first && info.networkDocumentCount == 1U) { continue; } // Check to see if the oplog entry goes back in time for this document. const auto docOpTime = OpTime::parseFromOplogEntry(doc); // entries must have a "ts" field. if (!docOpTime.isOK()) { return docOpTime.getStatus(); } info.lastDocument = {doc["h"].numberLong(), docOpTime.getValue()}; const auto docTS = info.lastDocument.opTime.getTimestamp(); if (lastTS >= docTS) { return Status(ErrorCodes::OplogOutOfOrder, str::stream() << "Out of order entries in oplog. lastTS: " << lastTS.toString() << " outOfOrderTS:" << docTS.toString() << " in batch with " << info.networkDocumentCount << "docs; first-batch:" << first << ", doc:" << doc); } lastTS = docTS; } // These numbers are for the documents we will apply. info.toApplyDocumentCount = documents.size(); info.toApplyDocumentBytes = info.networkDocumentBytes; if (first) { // The count is one less since the first document found was already applied ($gte $ts query) // and we will not apply it again. --info.toApplyDocumentCount; auto alreadyAppliedDocument = documents.cbegin(); info.toApplyDocumentBytes -= alreadyAppliedDocument->objsize(); } return info; }
StatusWith<RollBackLocalOperations::RollbackCommonPoint> syncRollBackLocalOperations( const OplogInterface& localOplog, const OplogInterface& remoteOplog, const RollBackLocalOperations::RollbackOperationFn& rollbackOperation) { auto remoteIterator = remoteOplog.makeIterator(); auto remoteResult = remoteIterator->next(); if (!remoteResult.isOK()) { return StatusWith<RollBackLocalOperations::RollbackCommonPoint>( ErrorCodes::InvalidSyncSource, "remote oplog empty or unreadable"); } RollBackLocalOperations finder(localOplog, rollbackOperation); Timestamp theirTime; while (remoteResult.isOK()) { theirTime = remoteResult.getValue().first["ts"].timestamp(); BSONObj theirObj = remoteResult.getValue().first; auto result = finder.onRemoteOperation(theirObj); if (result.isOK()) { return result.getValue(); } else if (result.getStatus().code() != ErrorCodes::NoSuchKey) { return result; } remoteResult = remoteIterator->next(); } severe() << "rollback error RS100 reached beginning of remote oplog"; log() << " them: " << remoteOplog.toString(); log() << " theirTime: " << theirTime.toStringLong(); return StatusWith<RollBackLocalOperations::RollbackCommonPoint>( ErrorCodes::NoMatchingDocument, "RS100 reached beginning of remote oplog [1]"); }
void OplogBufferCollection::pushAllNonBlocking(OperationContext* txn, Batch::const_iterator begin, Batch::const_iterator end) { if (begin == end) { return; } size_t numDocs = std::distance(begin, end); Batch docsToInsert(numDocs); Timestamp ts; std::transform(begin, end, docsToInsert.begin(), [&ts](const Value& value) { auto pair = addIdToDocument(value); invariant(ts.isNull() || pair.second > ts); ts = pair.second; return pair.first; }); stdx::lock_guard<stdx::mutex> lk(_mutex); auto status = _storageInterface->insertDocuments(txn, _nss, docsToInsert); fassertStatusOK(40161, status); _lastPushedTimestamp = ts; _count += numDocs; _size += std::accumulate(begin, end, 0U, [](const size_t& docSize, const Value& value) { return docSize + size_t(value.objsize()); }); _cvNoLongerEmpty.notify_all(); }
void TimerQueue::reset(std::vector<TimerQueue::Entry> expired, Timestamp now) { for (auto iter : expired) { ActiveTimer timer(iter.second, iter.second->sequeue()); if (iter.second->repeat() && cancleTimers_.find(timer) == cancleTimers_.end()) { iter.second->restart(now); //timers_.insert(iter); //activeTimers_.insert(timer); insert(iter.second); } else { delete iter.second; } } Timestamp time; if (!timers_.empty()) { time = timers_.begin()->second->expiration(); } if (time.valid()) { ext::resetTimerfd(timerfd_, time); } }
void TimerQueue::reset(const std::vector<Entry>& expired, Timestamp now) { Timestamp nextExpire; for (std::vector<Entry>::const_iterator it = expired.begin(); it != expired.end(); it++) { ActiveTimer timer(it->second, it->second->sequence()); if (it->second->repeat() && cancelingTimers_.find(timer) == cancelingTimers_.end()) { it->second->restart(now); insert(it->second); } else { delete it->second; } } if (!timers_.empty()) { nextExpire = timers_.begin()->second->expiration(); } if (nextExpire.valid()) { resetTimerfd(timerfd_, nextExpire); } }
void SyncTail::handleSlaveDelay(const BSONObj& lastOp) { ReplicationCoordinator* replCoord = getGlobalReplicationCoordinator(); int slaveDelaySecs = durationCount<Seconds>(replCoord->getSlaveDelaySecs()); // ignore slaveDelay if the box is still initializing. once // it becomes secondary we can worry about it. if (slaveDelaySecs > 0 && replCoord->getMemberState().secondary()) { const Timestamp ts = lastOp["ts"].timestamp(); long long a = ts.getSecs(); long long b = time(0); long long lag = b - a; long long sleeptime = slaveDelaySecs - lag; if (sleeptime > 0) { uassert(12000, "rs slaveDelay differential too big check clocks and systems", sleeptime < 0x40000000); if (sleeptime < 60) { sleepsecs((int)sleeptime); } else { warning() << "slavedelay causing a long sleep of " << sleeptime << " seconds"; // sleep(hours) would prevent reconfigs from taking effect & such! long long waitUntil = b + sleeptime; while (time(0) < waitUntil) { sleepsecs(6); // Handle reconfigs that changed the slave delay if (durationCount<Seconds>(replCoord->getSlaveDelaySecs()) != slaveDelaySecs) break; } } } } // endif slaveDelay }
int Timestamp::Compare(const Timestamp &aCompare) const { uint64_t thisSeconds = GetSeconds(); uint64_t compareSeconds = aCompare.GetSeconds(); uint16_t thisTicks = GetTicks(); uint16_t compareTicks = aCompare.GetTicks(); int rval; if (compareSeconds > thisSeconds) { rval = 1; } else if (compareSeconds < thisSeconds) { rval = -1; } else if (compareTicks > thisTicks) { rval = 1; } else if (compareTicks < thisTicks) { rval = -1; } else { rval = 0; } return rval; }
void sslTest2() { tracef("ssl test 2 begin: ssl send data."); Context::Ptr pContext = new Context(Context::TLSV1_CLIENT_USE, "", Context::VERIFY_NONE); SecureStreamSocket sss(pContext); SocketAddress sa("127.0.0.1", 12222); sss.connect(sa, Timespan(3, 0)); DynamicStruct ds; ds["type"] = "request"; ds["action"] = "server.token"; Timestamp t; UInt64 tms = t.epochMicroseconds(); char tms_str[32]; snprintf(tms_str, 31, "%llu", tms); std::string key = "alpha2015"; key += tms_str; MD5Engine md5; md5.update(key); const DigestEngine::Digest& digest = md5.digest(); std::string md5key = DigestEngine::digestToHex(digest); DynamicStruct param; param["key"] = md5key; param["timestamp"] = tms_str; param["dev_name"] = "lock1"; param["dev_type"] = "sc-01"; param["uuid"] = "SC00000001"; ds["param"] = param; tracef("data send: %s.", ds.toString().c_str()); sss.sendBytes(ds.toString().c_str(), ds.toString().length()); sss.close(); tracef("socket closed."); tracef("ssl test 2 finished.\n"); }
void SSLContext::flushSessionCache() { assert(_usage == SERVER_USE); Timestamp now; SSL_CTX_flush_sessions(_sslContext, static_cast<long>(now.epochTime())); }
void ReqGetNewMsgs::OnSuccess() { PXml p = m_xml.getChildNode(0); Assert(SafeStrCmp(p.getName(), "now")); timestamp = p.getText(); p = m_xml.getChildNode(1); if (SafeStrCmp(p.getName(), "msgs")) { int numMsgs = p.nChildNode(); for (int i = 0; i < numMsgs; i++) { PXml msg = p.getChildNode(i); int id = atoi(msg.getChildNode(0).getText()); int senderId = atoi(msg.getChildNode(1).getText()); timestamp = msg.getChildNode(2).getText(); Timestamp whenSent = atoi(timestamp.c_str()); std::string text = msg.getChildNode(3).getText(); text = DecodeMsg(text); ////Replace(text, "_", " "); // replace underscores with spaces -- TODO punctuation int recipId = atoi(msg.getChildNode(4).getText()); std::cout << "GOT NEW MSG!! ID: " << id << " sender: " << senderId << " sent: " << whenSent.ToString() << " text: " << text << "\n"; TheMsgManager::Instance()->QueueMsg(MsgManager::Msg(id, text, senderId, recipId, whenSent)); } } else { ShowError("Unexpected format for msgs response"); } }
Ref<Database> PackageService::buildLookupDB(const String& path, StreamSourceMap& packCfgs) { Ref<Database> db = Database::open(path); db->exec("DROP TABLE IF EXISTS packs; CREATE TABLE packs (name PRIMARY KEY, timestamp INT)"); db->exec("DROP TABLE IF EXISTS lookup; CREATE TABLE lookup (type, key, subtype, pack, entry, PRIMARY KEY (type, key))"); db->exec("DROP INDEX IF EXISTS lookup_packidx; CREATE INDEX lookup_packidx ON lookup (pack ASC)"); Ref<Database::Query> packInsert = db->prepare("INSERT INTO packs (name, timestamp) VALUES (?, ?)"); Ref<Database::Query> lookupInsert = db->prepare("INSERT INTO lookup (type, key, subtype, pack, entry) VALUES ($type, $key, $subtype, $pack, $entry)"); for (StreamSourceMap::iterator itr = packCfgs.begin(), end = packCfgs.end(); itr != end; ++itr) { const String& packName = itr->first; Ref<Settings> cfg = Settings::load(itr->second); if (cfg == NULL) { LOG(0, "*** can't load '%s'\n", cfg->getUrl().c_str()); continue; } Timestamp time = itr->second->getTimestamp(); packInsert->reset(); packInsert->bind(1, packName); packInsert->bind(2, time.getUnixTime64()); packInsert->step(); Ref<Settings> section = cfg->getSection("lookup"); if (section == NULL) continue; for (Settings::Iterator itr = section->begin(), end = section->end(); itr != end; ++itr) { String type = itr->first; String key = itr->second; String sub, entry; splitLookupEntry(type, key, sub, entry); lookupInsert->reset(); lookupInsert->bind("$type", type); lookupInsert->bind("$key", key); lookupInsert->bind("$subtype", sub); lookupInsert->bind("$entry", entry); lookupInsert->bind("$pack", packName); lookupInsert->step(); } } return db; }
auto greater::operator()<Timestamp&, Timestamp&>(Timestamp& a, Timestamp& b) const noexcept { if (a.is_null()) return false; if (b.is_null()) return true; return a > b; }
int main(int argc, char const *argv[]) { Timestamp now = Timestamp::now(); cout << now.toString() << endl; cout << now.toFormatString() << endl; return 0; }
/** * This function returns the fraction of time elapsed after the beginning * till the end */ double fraction(Timestamp currentTime, Timestamp endTime) { if ( (currentTime.after(*this)) && (endTime.after(currentTime)) ) { return(((double)currentTime.subUsec(*this)) / ((double)endTime.subUsec(*this))); } else { return -1.0; } }
std::pair<BSONObj, Timestamp> OplogBufferCollection::addIdToDocument(const BSONObj& orig) { invariant(!orig.isEmpty()); BSONObjBuilder bob; Timestamp ts = orig["ts"].timestamp(); invariant(!ts.isNull()); bob.append("_id", ts); bob.append(kOplogEntryFieldName, orig); return std::pair<BSONObj, Timestamp> {bob.obj(), ts}; }
void delay_loop( unsigned long usec ) { Timestamp end; end.add( usec * 1e-6 ); Timestamp now; while ( now.before( end ) ) { now.setnow(); } }
void sendDataByClient() { static int64_t i = 0; if (clientConnection) { Timestamp now = Timestamp::now(); char str[] = "hello world"; cout << "client send data : " << str << " at " << now.toString() <<"\n"; clientConnection->send(str, sizeof(str)); } }
Timestamp Timestamp::timeNow() { //build a Timestamp object Timestamp result; //set the time to the current system time result.setTimeNow(); //return the Timestamp object return result; }
void SqlTestSuiteFixture::CheckSingleResult<Timestamp>(const char* request, const Timestamp& expected) { SQL_TIMESTAMP_STRUCT res; CheckSingleResult0(request, SQL_C_TIMESTAMP, &res, 0, 0); using ignite::impl::binary::BinaryUtils; Timestamp actual = common::MakeTimestampGmt(res.year, res.month, res.day, res.hour, res.minute, res.second, res.fraction); BOOST_REQUIRE_EQUAL(actual.GetSeconds(), expected.GetSeconds()); BOOST_REQUIRE_EQUAL(actual.GetSecondFraction(), expected.GetSecondFraction()); }
int main(void) { char logFileName[300] = "/home/danconde/coleta/europa.log"; ResourceData parameters(0.5f, 100000); bool answer; DataCollector *dtCollector = new DataCollector(logFileName); unsigned int i, count; UsageData *testUsageData; setValidResourceDataThreshold(0.9f); setPredictionHours(6); cout << "timestamp\tp_cpu\tp_mem\tanswer\tpcs\tvcs\tcoff" << endl; // pcs = predicted cpu satisfability // vcs = verified cpu satisfability UsagePredictor *up = new UsagePredictor(new KMeansClusteringAlgorithm(), dtCollector); vector<UsageData*> *usageDatas = dtCollector->getUnclassifiedData(); for (unsigned int k = 0; k < usageDatas->size(); k += 3) { testUsageData = usageDatas->at(k); if (testUsageData->isValid()) { for (unsigned int j = 6; j < 18; j++) { Timestamp timestamp = Timestamp(testUsageData->getDate().beginningOfSameDay().getRawTime() + j*3600); answer = up->canRunGridApplication(timestamp, parameters, testUsageData); cout << timestamp.formattedPrint() << "\t" << parameters << "\t" << answer << "\t"; vector<double> prediction = up->getPrediction(timestamp, CPU_USAGE, getPredictionHours(), testUsageData); count = 0; for (i = 0; i < prediction.size(); i++) if (prediction[i] + parameters.getCpuUsage() <= 1.0f) count++; cout << (static_cast<double>(count) / prediction.size()) * 100 << "%\t"; count = 0; for (i = 0; i < prediction.size(); i++) { ResourceData rd = testUsageData->getData()[(timestamp.getSecondInDay()/COLLECT_INTERVAL) + SAMPLES_PER_DAY + i]; if (rd.isValid() && (rd.getCpuUsage() + parameters.getCpuUsage() <= 1.0f)) count++; } cout << (static_cast<double>(count) / prediction.size()) * 100 << "%\t"; cout << testUsageData->resourceAverage(CPU_USAGE, timestamp.getSecondInDay()/COLLECT_INTERVAL, timestamp.getSecondInDay()/COLLECT_INTERVAL + SAMPLES_PER_DAY) << endl; } } } /* informar qual cluster foi encontrado */ /* comparar resultado da predicao com o realizado */ /* pegar o resultado do getPrediction e ver a porcentagem de elementos do vetor de previsao condisseram com o realizado */ return 0; }
void PollerSelect::loop_once(Timestamp *ts) { runNextLoopHandlers(); struct timeval timeout; struct timeval *pto = nullptr; if (ts != nullptr) { Timestamp now = Timestamp::now(); if (*ts < now) { timeout = {0, 0}; } else { Timestamp inter = *ts - now; timeout = {.tv_sec = inter.sec(), .tv_usec = inter.usec()}; } pto = &timeout; } fd_set rset = rset_; fd_set wset = wset_; fd_set eset = eset_; int nready = ::select(maxfd_, &rset, &wset, &eset, pto); errorif(nready == -1, "select: %s", ::strerror(errno)); for (int fd = 0; fd < maxfd_ && nready > 0; fd++) { DeferCaller deferCaller([this] { runNextTickHandlers(); }); Channel *ch = getChannel(fd); if (ch == nullptr) continue; bool flag = false; if (FD_ISSET(fd, &eset)) { flag = true; ch->handleErroEvent(); continue; } if (FD_ISSET(fd, &rset)) { flag = true; ch->handleReadEvent(); } if (FD_ISSET(fd, &wset) && (ch = getChannel(fd)) != nullptr) { flag = true; ch->handleWritEvent(); } if (flag == true) { nready--; } } runAfterLoopHandlers(); }
Timestamp Timestamp::minus(unsigned long secs, unsigned long usecs) const { Timestamp t; const unsigned long max = 1000000ul; if(m_usecs < usecs) t.setTime(m_secs - secs - 1, max - (usecs - m_usecs)); else t.setTime(m_secs - secs, m_usecs - usecs); return t; }
bool is_greater(Timestamp lhs, Timestamp rhs) { const auto max = std::numeric_limits<Timestamp::value_type>::max(); const Timestamp::value_type lhs_raw = lhs.raw(); const Timestamp::value_type rhs_raw = rhs.raw(); if ((lhs_raw > rhs_raw && lhs_raw - rhs_raw <= max/2) || (rhs_raw > lhs_raw && rhs_raw - lhs_raw > max/2)) { return true; } else { return false; } }
bool TimedNotificationQueue::wait(Timestamp::TimeDiff interval) { const Timestamp::TimeDiff MAX_SLEEP = 8*60*60*Timestamp::TimeDiff(1000000); // sleep at most 8 hours at a time while (interval > 0) { Timestamp now; Timestamp::TimeDiff sleep = interval <= MAX_SLEEP ? interval : MAX_SLEEP; if (_nfAvailable.tryWait(static_cast<long>((sleep + 999)/1000))) return true; interval -= now.elapsed(); } return false; }
Timestamp Timestamp::plus(unsigned long secs, unsigned long usecs) const { Timestamp t; const unsigned long max = 1000000ul; if(m_usecs + usecs >= max) t.setTime(m_secs + secs + 1, m_usecs + usecs - max); else t.setTime(m_secs + secs, m_usecs + usecs); return t; }
void ReplicationRecoveryImpl::_applyToEndOfOplog(OperationContext* opCtx, Timestamp oplogApplicationStartPoint, Timestamp topOfOplog) { invariant(!oplogApplicationStartPoint.isNull()); invariant(!topOfOplog.isNull()); // Check if we have any unapplied ops in our oplog. It is important that this is done after // deleting the ragged end of the oplog. if (oplogApplicationStartPoint == topOfOplog) { log() << "No oplog entries to apply for recovery. appliedThrough is at the top of the oplog."; return; // We've applied all the valid oplog we have. } else if (oplogApplicationStartPoint > topOfOplog) { severe() << "Applied op " << oplogApplicationStartPoint.toBSON() << " not found. Top of oplog is " << topOfOplog.toBSON() << '.'; fassertFailedNoTrace(40313); } log() << "Replaying stored operations from " << oplogApplicationStartPoint.toBSON() << " (exclusive) to " << topOfOplog.toBSON() << " (inclusive)."; DBDirectClient db(opCtx); auto cursor = db.query(NamespaceString::kRsOplogNamespace.ns(), QUERY("ts" << BSON("$gte" << oplogApplicationStartPoint)), /*batchSize*/ 0, /*skip*/ 0, /*projection*/ nullptr, QueryOption_OplogReplay); // Check that the first document matches our appliedThrough point then skip it since it's // already been applied. if (!cursor->more()) { // This should really be impossible because we check above that the top of the oplog is // strictly > appliedThrough. If this fails it represents a serious bug in either the // storage engine or query's implementation of OplogReplay. severe() << "Couldn't find any entries in the oplog >= " << oplogApplicationStartPoint.toBSON() << " which should be impossible."; fassertFailedNoTrace(40293); } auto firstTimestampFound = fassertStatusOK(40291, OpTime::parseFromOplogEntry(cursor->nextSafe())).getTimestamp(); if (firstTimestampFound != oplogApplicationStartPoint) { severe() << "Oplog entry at " << oplogApplicationStartPoint.toBSON() << " is missing; actual entry found is " << firstTimestampFound.toBSON(); fassertFailedNoTrace(40292); } // Apply remaining ops one at at time, but don't log them because they are already logged. UnreplicatedWritesBlock uwb(opCtx); while (cursor->more()) { auto entry = cursor->nextSafe(); fassertStatusOK(40294, SyncTail::syncApply(opCtx, entry, OplogApplication::Mode::kRecovering)); _consistencyMarkers->setAppliedThrough( opCtx, fassertStatusOK(40295, OpTime::parseFromOplogEntry(entry))); } }