static ImageHost::Bias UpdateBias(const TimeStamp& aCompositionTime, const TimeStamp& aCompositedImageTime, const TimeStamp& aNextImageTime, // may be null ImageHost::Bias aBias) { if (aCompositedImageTime.IsNull()) { return ImageHost::BIAS_NONE; } TimeDuration threshold = TimeDuration::FromMilliseconds(1.0); if (aCompositionTime - aCompositedImageTime < threshold && aCompositionTime - aCompositedImageTime > -threshold) { // The chosen frame's time is very close to the composition time (probably // just before the current composition time, but due to previously set // negative bias, it could be just after the current composition time too). // If the inter-frame time is almost exactly equal to (a multiple of) // the inter-composition time, then we're in a dangerous situation because // jitter might cause frames to fall one side or the other of the // composition times, causing many frames to be skipped or duplicated. // Try to prevent that by adding a negative bias to the frame times during // the next composite; that should ensure the next frame's time is treated // as falling just before a composite time. return ImageHost::BIAS_NEGATIVE; } if (!aNextImageTime.IsNull() && aNextImageTime - aCompositionTime < threshold && aNextImageTime - aCompositionTime > -threshold) { // The next frame's time is very close to our composition time (probably // just after the current composition time, but due to previously set // positive bias, it could be just before the current composition time too). // We're in a dangerous situation because jitter might cause frames to // fall one side or the other of the composition times, causing many frames // to be skipped or duplicated. // Try to prevent that by adding a negative bias to the frame times during // the next composite; that should ensure the next frame's time is treated // as falling just before a composite time. return ImageHost::BIAS_POSITIVE; } return ImageHost::BIAS_NONE; }
int main() { TimeStamp start; TimeStamp newTime; TimeStamp dt; start.now(); while (1) { newTime.now(); dt=newTime-start; std::cout << dt.getSec() << "sec " << dt.getUSec() << "usec\n"; if (dt.getSec()>3) return 0; } return 1; }
bool SybCTnewDAImpl::CheckCloseOpenedConnections(long lTimeout) { StartTrace(SybCTnewDAImpl.CheckCloseOpenedConnections); bool bRet = false; Anything anyTimeStamp(coast::storage::Global()); TimeStamp aStamp; aStamp -= lTimeout; Trace("current timeout " << lTimeout << "s, resulting time [" << aStamp.AsString() << "]"); LockUnlockEntry me(fgStructureMutex); if ( fgInitialized ) { TraceAny(fgListOfSybCT, "current list of connections"); if ( fgListOfSybCT.LookupPath(anyTimeStamp, "Open") && anyTimeStamp.GetSize() ) { SybCTnewDA *pSyb = NULL; long lTS = 0L; // if we still have open connections and the last access is older than lTimeout seconds while ( anyTimeStamp.GetSize() && ( aStamp > TimeStamp(anyTimeStamp.SlotName(lTS)) ) ) { Anything anyTS(coast::storage::Global()); anyTS = anyTimeStamp[lTS]; TraceAny(anyTS, "stamp of connections to close [" << anyTimeStamp.SlotName(0L) << "]"); while ( anyTS.GetSize() ) { pSyb = SafeCast(anyTS[0L][0L].AsIFAObject(), SybCTnewDA); anyTS.Remove(0L); if ( pSyb != NULL ) { Trace("closing timeouted connection"); if ( pSyb->Close() ) { bRet = true; } } else { SYSWARNING("Sybase connection with address " << (long)pSyb << " not valid anymore!"); } fgListOfSybCT["Unused"].Append((IFAObject *)pSyb); } anyTimeStamp.Remove(lTS); } } } else { SYSERROR("SybCTnewDAImpl not initialized!"); } return bRet; }
coredata::dmcp::ModuleExitCodeMessage::ModuleExitCode Vehicle::body() { stringstream sstrConfiguration; getKeyValueConfiguration().writeTo(sstrConfiguration); // Use libodsimulation's odsimirus implementation. string config = sstrConfiguration.str(); vehiclecontext::model::SimplifiedBicycleModel simplifiedBicycleModel(config); simplifiedBicycleModel.setup(); // Use the most recent EgoState available. KeyValueDataStore &kvs = getKeyValueDataStore(); TimeStamp previousTime; while (getModuleStateAndWaitForRemainingTimeInTimeslice() == coredata::dmcp::ModuleStateMessage::RUNNING) { // Get current VehicleControl. Container c = kvs.get(Container::VEHICLECONTROL); automotive::VehicleControl vc = c.getData<automotive::VehicleControl>(); TimeStamp currentTime; const double timeStep = (currentTime.toMicroseconds() - previousTime.toMicroseconds()) / (1000.0 * 1000.0); // Calculate result and propagate it. vector<Container> toBeSent = simplifiedBicycleModel.calculate(vc, timeStep); if (toBeSent.size() > 0) { vector<Container>::iterator it = toBeSent.begin(); while(it != toBeSent.end()) { getConference().send(*it); it++; Thread::usleepFor(50); } } previousTime = currentTime; } simplifiedBicycleModel.tearDown(); return coredata::dmcp::ModuleExitCodeMessage::OKAY; }
/* * Check for data loss. * TODO(simon): move to the ola server */ bool DmxMonitor::CheckDataLoss() { if (m_last_data.IsSet()) { TimeStamp now; Clock clock; clock.CurrentTime(&now); TimeInterval diff = now - m_last_data; if (diff > TimeInterval(2, 5000000)) { // loss of data DrawDataLossWindow(); } } return true; }
void CWriteLogClass::WriteLogToFile(const char* filename,const char* module,const char* info,const int status) { TimeStamp ts; string mlog = ts.getTimeString(2).c_str() ; mlog += module; mlog += ","; mlog += info; mlog += ","; if (!status) { mlog += "³É¹¦"; } else { mlog += "ʧ°Ü"; } mlog += "\n"; cout << mlog << endl; FILE * fp = fopen(filename,"a+"); fwrite(mlog.c_str(),1,mlog.size(),fp); fclose(fp); }
void ClientModule::wait() { // Update liveliness. m_cycleCounter++; TimeStamp current; const float FREQ = getFrequency(); const long TIME_CONSUMPTION_OF_CURRENT_SLICE = (current.toMicroseconds() - m_lastCycle.toMicroseconds()) - m_lastWaitTime; m_lastCycle = current; const long ONE_SECOND_IN_MICROSECONDS = 1000 * 1000 * 1; const long NOMINAL_DURATION_OF_ONE_SLICE = static_cast<long>((1.0f/FREQ) * ONE_SECOND_IN_MICROSECONDS); const long WAITING_TIME_OF_CURRENT_SLICE = NOMINAL_DURATION_OF_ONE_SLICE - TIME_CONSUMPTION_OF_CURRENT_SLICE; // Inform supercomponent about statistical runtime data. bool sendStatistics = false; if (FREQ < 1) { sendStatistics = true; } else { const int32_t CYCLES_PER_SECOND = static_cast<int32_t>(fabs(floor(FREQ + 0.5))); if ( (m_cycleCounter % CYCLES_PER_SECOND) == 0 ) { sendStatistics = true; m_cycleCounter = 0; } } if (sendStatistics) { RuntimeStatistic rts; rts.setSliceConsumption((float)TIME_CONSUMPTION_OF_CURRENT_SLICE/(float)NOMINAL_DURATION_OF_ONE_SLICE); m_dmcpClient->sendStatistics(rts); } if (WAITING_TIME_OF_CURRENT_SLICE > 0) { m_lastWaitTime = WAITING_TIME_OF_CURRENT_SLICE; Thread::usleep(WAITING_TIME_OF_CURRENT_SLICE); } else { m_lastWaitTime = 0; } }
void VectorPerformanceThread::run() { TimeStamp timeStamp; TimeStamp timeStampLast; timeStampLast.getCurrent(); int nSinceLastReport = 0; while(true) { if(delay>0.0) epicsThreadSleep(delay); { Lock lock(mutex); if(isDestroyed) { runReturned = true; return; } } timeStamp.getCurrent(); double diff = TimeStamp::diff(timeStamp,timeStampLast); if(diff>=1.0) { cout << "thread" << threadNumber; cout << " value " << value; cout << " time " << diff; double iterations = nSinceLastReport; iterations /= diff; cout << " iterations/sec " << iterations; double elementSize = size; double elementsPerSecond = elementSize*nSinceLastReport; elementsPerSecond /= diff; elementsPerSecond /= 1e6; cout << " elements/sec " << elementsPerSecond << "million" << endl; cout.flush(); timeStampLast = timeStamp; nSinceLastReport = 0; } ++nSinceLastReport; ++value; for(size_t i=0; i<size; ++i) vector[i] = value; } }
// aID is a sub-identifier (in particular a specific MediaStramTrack) void AsyncLatencyLogger::WriteLog(LatencyLogIndex aIndex, uint64_t aID, int64_t aValue, TimeStamp aTimeStamp) { if (aTimeStamp.IsNull()) { MOZ_LOG(GetLatencyLog(), LogLevel::Debug, ("Latency: %s,%" PRIu64 ",%" PRId64 ",%" PRId64, LatencyLogIndex2Strings[aIndex], aID, GetTimeStamp(), aValue)); } else { MOZ_LOG(GetLatencyLog(), LogLevel::Debug, ("Latency: %s,%" PRIu64 ",%" PRId64 ",%" PRId64 ",%" PRId64, LatencyLogIndex2Strings[aIndex], aID, GetTimeStamp(), aValue, static_cast<int64_t>((aTimeStamp - gAsyncLogger->mStart).ToMilliseconds()))); } }
/*PLONK_INLINE_LOW*/ bool TimeStamp::operator>= (TimeStamp const& other) const throw() { plonk_assert (fractionIsValid (this->fraction)); plonk_assert (fractionIsValid (other.fraction)); if (this->isInfinite()) { if (other.isInfinite()) return false; else return true; } else return ((time > other.time) || ((time == other.time) && (fraction >= other.fraction))); }
// aID is a sub-identifier (in particular a specific MediaStramTrack) void AsyncLatencyLogger::WriteLog(LatencyLogIndex aIndex, uint64_t aID, int64_t aValue, TimeStamp aTimeStamp) { if (aTimeStamp.IsNull()) { PR_LOG(GetLatencyLog(), PR_LOG_DEBUG, ("Latency: %s,%llu,%lld,%lld", LatencyLogIndex2Strings[aIndex], aID, GetTimeStamp(), aValue)); } else { PR_LOG(GetLatencyLog(), PR_LOG_DEBUG, ("Latency: %s,%llu,%lld,%lld,%lld", LatencyLogIndex2Strings[aIndex], aID, GetTimeStamp(), aValue, static_cast<int64_t>((aTimeStamp - gAsyncLogger->mStart).ToMilliseconds()))); } }
void Canvas::Draw() { if (_StyleModules.empty()) return; preDraw(); TimeStamp *timestamp = TimeStamp::instance(); for (unsigned int i = 0; i < _StyleModules.size(); ++i) { _current_sm = _StyleModules[i]; if (i < _Layers.size() && _Layers[i]) delete _Layers[i]; _Layers[i] = _StyleModules[i]->execute(); if (!_Layers[i]) continue; stroke_count += _Layers[i]->strokes_size(); timestamp->increment(); } postDraw(); }
LightSpeed::StringA dateTimeToDB(const LightSpeed::JSON::INode &nd) { using namespace LightSpeed; if (nd.getType() == JSON::ndString) { ConstStrA str = nd.getStringUtf8(); TextParser<char, SmallAlloc<256> > parser; if (parser(" NOW ",str)) { TimeStamp st = TimeStamp::now(); return st.formatTime(dbDateTimeFormat); } else if (parser(" NOW %[-+]f1 ",str)) { float ofs = parser[1]; TimeStamp st = TimeStamp::now() + TimeStamp(ofs); return st.formatTime(dbDateTimeFormat); } return nd.getStringUtf8(); } else if (nd.getType() == JSON::ndFloat || nd.getType() == JSON::ndInt) { TimeStamp st(nd.getFloat()); return st.formatTime(dbDateTimeFormat); } else if (nd.getType() == JSON::ndNull) { return "0000-00-00 00:00:00"; } return "0000-00-00 00:00:00"; }
/* * Makes n plots and times them. * Plot number k is called sink. * It is a plot of sin(kx) vs. x */ void timeplot(int n){ double x[n*10]; double y[n*10]; StatVector stats(n); TimeStamp clk; for(int i=1; i <= n; i++){ printf("\r%d", i); fflush(stdout); char name[30]; sprintf(name, "sin%d", i); for(int j=0; j < n*10; j++){ x[j] = 2*PI*i*j/(n*10.0); y[j] = sin(x[j]*i); } clk.tic(); makeplot(x, y, 10*n, name); double cycles = clk.toc(); stats.insert(cycles); } char banner[200]; sprintf(banner, "cycle stats for %d plots", n); stats.print(banner); system("rm FIGS/sin*.pdf"); }
int EndRun() { RunEndTime = PrevSubEvtTime; FullTimes[ CurrRun ] = (RunEndTime - RunStartTime).GetSeconds(); LiveTimes[ CurrRun ] = FullTimes[ CurrRun ] - MuonShadowTime.GetSeconds(); MuonCounters[ CurrRun ] = MuonCounter; for( int det = 1; det <= 4; det++ ) { NSinglesUp[ CurrRun ][ det ] = SinglesUpCounter[ det ]; NSinglesLow[ CurrRun ][ det ] = SinglesLowCounter[ det ]; } return 1; }
void DialogEditTime::on_buttonBox_accepted() { // workaround for missing leading zero bug: prepend a "0", if it is missing QString tStr = ui->lineEdit->text(); QStringList helper = tStr.split(":"); if(helper.first().length() == 1){ tStr.prepend("0"); } // end of workaround QTime t = QTime::fromString(tStr); qDebug() << "zeit: " << t.toString(); TimeStamp* ts =0; if(myRun){// ignore runns with Nullpointer if(myTimeType == TT_START){ if(myRun->getStartTimeID() == 0){ // if no TS exists, create a new one ts = new TimeStamp(0, t, TimeStamp::E); MainWindow::competition()->addTimeStamp(ts); ts->setRunID(myRun->getID()); myRun->setStartTimeID(ts->getID()); }else{ ts = MainWindow::competition()->getTimeStamp(myRun->getStartTimeID()); } }else{ // goal if(myRun->getGoalTimeID() == 0){ // if no TS exists, create a new one ts = new TimeStamp(0, t, TimeStamp::E); MainWindow::competition()->addTimeStamp(ts); ts->setRunID(myRun->getID()); myRun->setGoalTimeID(ts->getID()); }else{ ts = MainWindow::competition()->getTimeStamp(myRun->getGoalTimeID()); } } // if new time != old time // compare strings, because of sub-0.01s differences, which should be ignored if(MainWindow::convertTimeToString(ts->getTime()) != MainWindow::convertTimeToString(t)){ ts->setTime(t); ts->setSource(TimeStamp::E); emit timeEdited(myRun); } } hide(); }
double time(double *a, double *b, int n, enum sumcopy_enum flag){ const int count = 10; StatVector stats(count); TimeStamp clk; double bytes = 8.0*n; for(int i=0; i < count; i++){ clk.tic(); switch(flag){ case SUM: sum(a, n); break; case SUMSTR: sumstride(a, n, STR); break; case SUMCONSTSTR: sumconststride(a, n); break; case COPY: copy(a, b, n); break; case COPYCONSTSTR: copyconststride(a, b, n); break; } double cycles = clk.toc(); stats.insert(cycles); } if(flag == COPY || flag == COPYCONSTSTR) bytes *= 2; if (!(flag == SUM || flag == COPY)) bytes /= STR; return bytes/stats.median(); }
void VideoFrameContainer::SetCurrentFrame(const gfxIntSize& aIntrinsicSize, Image* aImage, TimeStamp aTargetTime) { MutexAutoLock lock(mMutex); if (aIntrinsicSize != mIntrinsicSize) { mIntrinsicSize = aIntrinsicSize; mIntrinsicSizeChanged = true; } gfxIntSize oldFrameSize = mImageContainer->GetCurrentSize(); TimeStamp lastPaintTime = mImageContainer->GetPaintTime(); if (!lastPaintTime.IsNull() && !mPaintTarget.IsNull()) { mPaintDelay = lastPaintTime - mPaintTarget; } // When using the OMX decoder, destruction of the current image can indirectly // block on main thread I/O. If we let this happen while holding onto // |mImageContainer|'s lock, then when the main thread then tries to // composite it can then block on |mImageContainer|'s lock, causing a // deadlock. We use this hack to defer the destruction of the current image // until it is safe. nsRefPtr<Image> kungFuDeathGrip; kungFuDeathGrip = mImageContainer->LockCurrentImage(); mImageContainer->UnlockCurrentImage(); mImageContainer->SetCurrentImage(aImage); gfxIntSize newFrameSize = mImageContainer->GetCurrentSize(); if (oldFrameSize != newFrameSize) { mImageSizeChanged = true; mNeedInvalidation = true; } mPaintTarget = aTargetTime; }
bool TimeToFileTime(TimeStamp& time, LPFILETIME pFileTime) { SYSTEMTIME sysTime; time.getTime(sysTime); // convert system time to local file time FILETIME localTime; if (!SystemTimeToFileTime((LPSYSTEMTIME)&sysTime, &localTime)) return false; // convert local file time to UTC file time if (!LocalFileTimeToFileTime(&localTime, pFileTime)) return false; return true; }
void mozilla_sampler_responsiveness(const TimeStamp& aTime) { if (!sLastTracerEvent.IsNull()) { if (sResponsivenessLoc == 100) { for(size_t i = 0; i < 100-1; i++) { sResponsivenessTimes[i] = sResponsivenessTimes[i+1]; } sResponsivenessLoc--; } TimeDuration delta = aTime - sLastTracerEvent; sResponsivenessTimes[sResponsivenessLoc++] = delta.ToMilliseconds(); } sCurrentEventGeneration++; sLastTracerEvent = aTime; }
Nullable<TimeDuration> DocumentTimeline::ToTimelineTime( const TimeStamp& aTimeStamp) const { Nullable<TimeDuration> result; // Initializes to null if (aTimeStamp.IsNull()) { return result; } nsDOMNavigationTiming* timing = mDocument->GetNavigationTiming(); if (MOZ_UNLIKELY(!timing)) { return result; } result.SetValue(aTimeStamp - timing->GetNavigationStartTimeStamp() - mOriginTime); return result; }
void LayerManagerComposite::EndTransaction(const TimeStamp& aTimeStamp, EndTransactionFlags aFlags) { NS_ASSERTION(mInTransaction, "Didn't call BeginTransaction?"); NS_ASSERTION(!(aFlags & END_NO_COMPOSITE), "Shouldn't get END_NO_COMPOSITE here"); mInTransaction = false; mRenderStartTime = TimeStamp::Now(); if (!mIsCompositorReady) { return; } mIsCompositorReady = false; #ifdef MOZ_LAYERS_HAVE_LOG MOZ_LAYERS_LOG((" ----- (beginning paint)")); Log(); #endif if (mDestroyed) { NS_WARNING("Call on destroyed layer manager"); return; } // Set composition timestamp here because we need it in // ComputeEffectiveTransforms (so the correct video frame size is picked) and // also to compute invalid regions properly. mCompositor->SetCompositionTime(aTimeStamp); if (mRoot && !(aFlags & END_NO_IMMEDIATE_REDRAW)) { MOZ_ASSERT(!aTimeStamp.IsNull()); UpdateAndRender(); mCompositor->FlushPendingNotifyNotUsed(); } else { // Modified the layer tree. mGeometryChanged = true; } mCompositor->ClearTargetContext(); mTarget = nullptr; #ifdef MOZ_LAYERS_HAVE_LOG Log(); MOZ_LAYERS_LOG(("]----- EndTransaction")); #endif }
TimeStamp TimeStamp::operator+ (TimeStamp const& other) const throw() { if (this->isInfinite()) { return *this; } else if (other.isInfinite()) { return other; } else { TimeStamp result (this->time + other.time, this->fraction); result += other.fraction; return result; } }
NS_IMETHODIMP nsAppStartup::GetStartupInfo(JSContext* aCx, JS::MutableHandle<JS::Value> aRetval) { JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx)); aRetval.setObject(*obj); TimeStamp procTime = StartupTimeline::Get(StartupTimeline::PROCESS_CREATION); TimeStamp now = TimeStamp::Now(); PRTime absNow = PR_Now(); if (procTime.IsNull()) { bool error = false; procTime = TimeStamp::ProcessCreation(error); if (error) { Telemetry::Accumulate(Telemetry::STARTUP_MEASUREMENT_ERRORS, StartupTimeline::PROCESS_CREATION); } StartupTimeline::Record(StartupTimeline::PROCESS_CREATION, procTime); } for (int i = StartupTimeline::PROCESS_CREATION; i < StartupTimeline::MAX_EVENT_ID; ++i) { StartupTimeline::Event ev = static_cast<StartupTimeline::Event>(i); TimeStamp stamp = StartupTimeline::Get(ev); if (stamp.IsNull() && (ev == StartupTimeline::MAIN)) { // Always define main to aid with bug 689256. stamp = procTime; MOZ_ASSERT(!stamp.IsNull()); Telemetry::Accumulate(Telemetry::STARTUP_MEASUREMENT_ERRORS, StartupTimeline::MAIN); } if (!stamp.IsNull()) { if (stamp >= procTime) { PRTime prStamp = ComputeAbsoluteTimestamp(absNow, now, stamp) / PR_USEC_PER_MSEC; JS::Rooted<JSObject*> date(aCx, JS::NewDateObject(aCx, JS::TimeClip(prStamp))); JS_DefineProperty(aCx, obj, StartupTimeline::Describe(ev), date, JSPROP_ENUMERATE); } else { Telemetry::Accumulate(Telemetry::STARTUP_MEASUREMENT_ERRORS, ev); } } } return NS_OK; }
int32 TimeStamp::compare( const TimeStamp &ts ) const { if ( m_year < ts.m_year ) return -1; if ( m_year > ts.m_year ) return 1; if ( m_month < ts.m_month ) return -1; if ( m_month > ts.m_month ) return 1; if ( m_day < ts.m_day ) return -1; if ( m_day > ts.m_day ) return 1; if ( ts.m_timezone == m_timezone || ts.m_timezone == tz_NONE || m_timezone == tz_NONE ) { if ( m_hour < ts.m_hour ) return -1; if ( m_hour > ts.m_hour ) return 1; if ( m_day < ts.m_day ) return -1; if ( m_day > ts.m_day ) return 1; } else { int16 hdisp=0, mdisp=0; int16 ts_hdisp=0, ts_mdisp=0; \ getTZDisplacement( hdisp, mdisp ); ts.getTZDisplacement( ts_hdisp, ts_mdisp ); if ( m_hour + hdisp < ts.m_hour + ts_hdisp ) return -1; if ( m_hour + hdisp > ts.m_hour + ts_hdisp ) return 1; if ( m_day + mdisp < ts.m_day + ts_mdisp ) return -1; if ( m_day + mdisp > ts.m_day + ts_mdisp ) return 1; } if ( m_minute < ts.m_minute ) return -1; if ( m_minute > ts.m_minute ) return 1; if ( m_second < ts.m_second ) return -1; if ( m_second > ts.m_second ) return 1; if ( m_msec < ts.m_msec ) return -1; if ( m_msec > ts.m_msec ) return 1; return 0; }
bool SpdyPushedStream3::IsOrphaned(TimeStamp now) { MOZ_ASSERT(!now.IsNull()); // if spdy is not transmitting, and is also not connected to a consumer // stream, and its been like that for too long then it is oprhaned if (mConsumerStream) return false; bool rv = ((now - mLastRead).ToSeconds() > 30.0); if (rv) { LOG3(("SpdyPushCache::IsOrphaned 0x%X IsOrphaned %3.2f\n", mStreamID, (now - mLastRead).ToSeconds())); } return rv; }
bool TimeStamp::operator> (TimeStamp const& other) const throw() { plonk_assert (fractionIsValid (this->fraction)); plonk_assert (fractionIsValid (other.fraction)); if (this->isInfinite()) { if (other.isInfinite()) return false; else return true; } else if (time > other.time) return true; else if ((time == other.time) && (fraction > other.fraction)) return true; else return false; }
void mozilla_sampler_responsiveness(TimeStamp aTime) { if (!sLastTracerEvent.IsNull()) { if (sResponsivenessLoc == 100) { for(size_t i = 0; i < 100-1; i++) { sResponsivenessTimes[i] = sResponsivenessTimes[i+1]; } sResponsivenessLoc--; //for(size_t i = 0; i < 100; i++) { // sResponsivenessTimes[i] = 0; //} //sResponsivenessLoc = 0; } TimeDuration delta = aTime - sLastTracerEvent; sResponsivenessTimes[sResponsivenessLoc++] = delta.ToMilliseconds(); } sLastTracerEvent = aTime; }
void TimeStamp::add( const TimeStamp &ts ) { m_day += ts.m_day; m_hour += ts.m_hour; m_minute += ts.m_minute; m_second += ts.m_second; m_msec += ts.m_msec; if ( m_timezone != ts.m_timezone && m_timezone != tz_NONE && ts.m_timezone != tz_NONE ) { int16 hours=0, mins=0, ts_hours=0, ts_mins=0; ts.getTZDisplacement( ts_hours, ts_mins ); getTZDisplacement( hours, mins ); m_hour += hours - ts_hours; m_minute += hours - ts_mins; } rollOver(); if ( m_timezone == tz_NONE ) m_timezone = ts.m_timezone; }
bool CompositorParent::SetTestSampleTime(LayerTransactionParent* aLayerTree, const TimeStamp& aTime) { if (aTime.IsNull()) { return false; } mIsTesting = true; mTestTime = aTime; // Update but only if we were already scheduled to animate if (mCompositionManager && mCurrentCompositeTask) { AutoResolveRefLayers resolve(mCompositionManager); bool requestNextFrame = mCompositionManager->TransformShadowTree(aTime); if (!requestNextFrame) { CancelCurrentCompositeTask(); } } return true; }