int32_t Engine::run() { is_running_ = true; while(is_running_) { chapter_manager().current_chapter().frame_start(); is_running_ = window().update(); chapter_manager().current_chapter().frame_finish(); idle().execute(); timed().execute(); } return 0; }
void run() { _ns = string("perftest.") + name(); client().dropCollection(ns()); prep(); int hlm = howLongMillis(); dur::stats._intervalMicros = 0; // no auto rotate dur::stats.curr->reset(); Timer t; unsigned long long n = 0; const unsigned Batch = 50; do { unsigned i; for( i = 0; i < Batch; i++ ) timed(); n += i; } while( t.millis() < hlm ); client().getLastError(); // block until all ops are finished int ms = t.millis(); say(n, ms, name()); if( n < expectation() ) { cout << "\ntest " << name() << " seems slow n:" << n << " ops/sec but expect greater than:" << expectation() << endl; cout << endl; } { const char *test2name = timed2(); if( test2name ) { dur::stats.curr->reset(); Timer t; unsigned long long n = 0; while( 1 ) { unsigned i; for( i = 0; i < Batch; i++ ) timed2(); n += i; if( t.millis() > hlm ) break; } int ms = t.millis(); say(n, ms, test2name); } } }
nsresult HttpBaseChannel::SetupReplacementChannel(nsIURI *newURI, nsIChannel *newChannel, bool preserveMethod, bool forProxy) { LOG(("HttpBaseChannel::SetupReplacementChannel " "[this=%p newChannel=%p preserveMethod=%d forProxy=%d]", this, newChannel, preserveMethod, forProxy)); PRUint32 newLoadFlags = mLoadFlags | LOAD_REPLACE; // if the original channel was using SSL and this channel is not using // SSL, then no need to inhibit persistent caching. however, if the // original channel was not using SSL and has INHIBIT_PERSISTENT_CACHING // set, then allow the flag to apply to the redirected channel as well. // since we force set INHIBIT_PERSISTENT_CACHING on all HTTPS channels, // we only need to check if the original channel was using SSL. if (mConnectionInfo->UsingSSL()) newLoadFlags &= ~INHIBIT_PERSISTENT_CACHING; // Do not pass along LOAD_CHECK_OFFLINE_CACHE newLoadFlags &= ~nsICachingChannel::LOAD_CHECK_OFFLINE_CACHE; newChannel->SetLoadGroup(mLoadGroup); newChannel->SetNotificationCallbacks(mCallbacks); newChannel->SetLoadFlags(newLoadFlags); nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(newChannel); if (!httpChannel) return NS_OK; // no other options to set if (preserveMethod) { nsCOMPtr<nsIUploadChannel> uploadChannel = do_QueryInterface(httpChannel); nsCOMPtr<nsIUploadChannel2> uploadChannel2 = do_QueryInterface(httpChannel); if (mUploadStream && (uploadChannel2 || uploadChannel)) { // rewind upload stream nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(mUploadStream); if (seekable) seekable->Seek(nsISeekableStream::NS_SEEK_SET, 0); // replicate original call to SetUploadStream... if (uploadChannel2) { const char *ctype = mRequestHead.PeekHeader(nsHttp::Content_Type); if (!ctype) ctype = ""; const char *clen = mRequestHead.PeekHeader(nsHttp::Content_Length); PRInt64 len = clen ? nsCRT::atoll(clen) : -1; uploadChannel2->ExplicitSetUploadStream( mUploadStream, nsDependentCString(ctype), len, nsDependentCString(mRequestHead.Method()), mUploadStreamHasHeaders); } else { if (mUploadStreamHasHeaders) { uploadChannel->SetUploadStream(mUploadStream, EmptyCString(), -1); } else { const char *ctype = mRequestHead.PeekHeader(nsHttp::Content_Type); const char *clen = mRequestHead.PeekHeader(nsHttp::Content_Length); if (!ctype) { ctype = "application/octet-stream"; } if (clen) { uploadChannel->SetUploadStream(mUploadStream, nsDependentCString(ctype), atoi(clen)); } } } } // since preserveMethod is true, we need to ensure that the appropriate // request method gets set on the channel, regardless of whether or not // we set the upload stream above. This means SetRequestMethod() will // be called twice if ExplicitSetUploadStream() gets called above. httpChannel->SetRequestMethod(nsDependentCString(mRequestHead.Method())); } // convey the referrer if one was used for this channel to the next one if (mReferrer) httpChannel->SetReferrer(mReferrer); // convey the mAllowPipelining flag httpChannel->SetAllowPipelining(mAllowPipelining); // convey the new redirection limit httpChannel->SetRedirectionLimit(mRedirectionLimit - 1); nsCOMPtr<nsIHttpChannelInternal> httpInternal = do_QueryInterface(newChannel); if (httpInternal) { // convey the mForceAllowThirdPartyCookie flag httpInternal->SetForceAllowThirdPartyCookie(mForceAllowThirdPartyCookie); // convey the spdy flag httpInternal->SetAllowSpdy(mAllowSpdy); // update the DocumentURI indicator since we are being redirected. // if this was a top-level document channel, then the new channel // should have its mDocumentURI point to newURI; otherwise, we // just need to pass along our mDocumentURI to the new channel. if (newURI && (mURI == mDocumentURI)) httpInternal->SetDocumentURI(newURI); else httpInternal->SetDocumentURI(mDocumentURI); // if there is a chain of keys for redirect-responses we transfer it to // the new channel (see bug #561276) if (mRedirectedCachekeys) { LOG(("HttpBaseChannel::SetupReplacementChannel " "[this=%p] transferring chain of redirect cache-keys", this)); httpInternal->SetCacheKeysRedirectChain(mRedirectedCachekeys.forget()); } } // transfer application cache information nsCOMPtr<nsIApplicationCacheChannel> appCacheChannel = do_QueryInterface(newChannel); if (appCacheChannel) { appCacheChannel->SetApplicationCache(mApplicationCache); appCacheChannel->SetInheritApplicationCache(mInheritApplicationCache); // We purposely avoid transfering mChooseApplicationCache. } // transfer any properties nsCOMPtr<nsIWritablePropertyBag> bag(do_QueryInterface(newChannel)); if (bag) mPropertyHash.EnumerateRead(CopyProperties, bag.get()); // transfer timed channel enabled status nsCOMPtr<nsITimedChannel> timed(do_QueryInterface(newChannel)); if (timed) timed->SetTimingEnabled(mTimingEnabled); if (forProxy) { // Transfer all the headers from the previous channel // this is needed for any headers that are not covered by the code above // or have been set separately. e.g. manually setting Referer without // setting up mReferrer PRUint32 count = mRequestHead.Headers().Count(); for (PRUint32 i = 0; i < count; ++i) { nsHttpAtom header; const char *value = mRequestHead.Headers().PeekHeaderAt(i, header); httpChannel->SetRequestHeader(nsDependentCString(header), nsDependentCString(value), false); } } return NS_OK; }
int64_t BaCoreTimedMs(TBaCoreFun fun, void* pArg) { return round1000(CHRONO_::duration_cast<CHRONO_::microseconds>(timed(fun, pArg)).count()); }
int64_t BaCoreTimedUs(TBaCoreFun fun, void* pArg) { return round1000(timed(fun, pArg).count()); }
static int miscd_dodaemon(char *argv1, char *daemon) { struct sigaction act; char *commandline; char commbuf[10]; char ch; if (!check_file_writable(PASSFILE)) { fprintf(stderr, "Error! File %s is not writable.\n", PASSFILE); exit(-1); } if (!check_file_writable(BOARDS)) { fprintf(stderr, "Error! File %s is not writable.\n", BOARDS); exit(-1); } truncate(BOARDS, MAXBOARD * sizeof(struct boardheader)); if (load_ucache() != 0) { printf("ft,load ucache error!"); exit(-1); } /* init tmpfs */ sprintf(genbuf1,"%s/home",TMPFSROOT); mkdir(genbuf1,0700); sprintf(genbuf1,"%s/boards",TMPFSROOT); mkdir(genbuf1,0700); for (ch='A';ch<='Z';ch++) { sprintf(genbuf1,"%s/home/%c",TMPFSROOT,ch); mkdir(genbuf1,0700); } resolve_boards(); resolve_utmp(); resolve_guest_table(); if (argv1 != NULL) { switch (fork()) { case -1: printf("faint, i can't fork.\n"); exit(0); break; case 0: break; default: exit(0); break; } commandline = argv1; } else { commandline = commbuf; } setsid(); #if defined(FREEBSD) || defined(MACOSX) setpgid(0, 0); #else // by zixia setpgrp(0, 0); setpgrp(); #endif #ifdef AIX act.sa_handler = NULL; act.sa_flags = SA_RESTART | SA_NOCLDWAIT; sigaction(SIGCHLD, &act, NULL); #else act.sa_handler = reaper; act.sa_flags = SA_RESTART; sigaction(SIGCHLD, &act, NULL); #endif if (((daemon == NULL) || (!strcmp(daemon, "timed"))) && ((argv1 == NULL) || fork())) { strcpy(commandline, "timed"); timed(); exit(0); } if (((daemon == NULL) || (!strcmp(daemon, "killd"))) && ((argv1 == NULL) || fork())) { strcpy(commandline, "killd"); char line[20]; const char *path = "var/killd.pid"; int pidfd = open(path, O_RDWR | O_CREAT, 0660); if (write_lock(pidfd, 0, SEEK_SET, 0) < 0) { bbslog("3error", "killd had already been started!"); exit(-1); } snprintf(line, sizeof(line), "%ld\n", (long)getpid()); ftruncate(pidfd, 0); write(pidfd, line, strlen(line)); while (1) { time_t ft; ft = getnextday4am(); do { sleep(ft - time(0)); } while (ft > time(0)); if (argv1 == NULL) { dokilluser(); //doupdategiveupuser(); } else { switch (fork()) { case -1: bbslog("3error", "fork failed\n"); break; case 0: dokilluser(); //doupdategiveupuser(); exit(0); break; default: break; } } switch (fork()) { case -1: bbslog("3error", "fork failed\n"); break; case 0: dokillalldir(); exit(0); break; default: break; } }; exit(0); } if (((daemon == NULL) || (!strcmp(daemon, "userd"))) && ((argv1 == NULL) || fork())) { strcpy(commandline, "userd"); userd(); exit(0); } if ((daemon == NULL) || (!strcmp(daemon, "flushd"))) { strcpy(commandline, "flushd"); flushd(); exit(0); } return 0; }
// ------------------------------------------------------------------------ // CDRMConsume:: ActivateL // // Calculate the smallest end time based on interval, end time, // accumulated time & timed count. // ------------------------------------------------------------------------ // void CDRMConsume::ActivateL( TBool aSecureTime, const TTime& aTrustedTime ) { DRMLOG( _L( "CDRMConsume::ActivateL" ) ); __ASSERT_DEBUG( iChild && iCombined, User::Invariant() ); TTime endTime( Time::MaxTTime() ); TTimeIntervalSeconds timed( KMaxTInt32 ); TBool timeUsed( EFalse ); TBool endTimeUsed( EFalse ); iCurrentDelay = 0; if ( iCombined->iActiveConstraints & EConstraintTimedCounter ) { // Take this, even if timed counts have been updated. // This might cause unnecessary RunL's to be called, but it // ensures both child & parent will be consumed when needed. // If e.g. it would be checked that iTimedCounts == 0xf, // either one (child or parent) might not get updated in case of // "Child expired, but parent didn't -> find new child". PickSmaller( timed, iCombined->iTimedInterval ); timeUsed = ETrue; } if ( iCombined->iActiveConstraints & EConstraintAccumulated ) { PickSmaller( timed, iCombined->iAccumulatedTime ); timeUsed = ETrue; } if ( iCombined->iActiveConstraints & EConstraintInterval ) { if ( iCombined->iIntervalStart != Time::NullTTime() ) { endTime = iCombined->iIntervalStart; endTime += iCombined->iInterval; endTimeUsed = ETrue; } else { TInt64 tmp( iCombined->iInterval.Int() ); PickSmaller( timed, tmp ); timeUsed = ETrue; } } if ( iCombined->iActiveConstraints & EConstraintEndTime ) { PickSmaller( endTime, iCombined->iEndTime ); endTimeUsed = ETrue; } // Put the "smallest time" information to "endTime". if ( timeUsed ) { TTime current( aTrustedTime ); current += timed; PickSmaller( endTime, current ); endTimeUsed = ETrue; } // Interval gets initialised immediately, and so do count constraints. // Timed/accumulated won't: those are consumed after the // interval if secure time exists. Consume( ETrue, ETrue, EFalse, 0, aSecureTime, aTrustedTime ); // In case something was modified, update the db also. UpdateDBL(); if ( endTimeUsed ) { // Something exists. TTimeIntervalSeconds secs( 0 ); TTime current( aTrustedTime ); TInt err( KErrNone ); // SecondsFrom returns an error if the difference is too great. err = endTime.SecondsFrom( current, secs ); if ( err ) { iCurrentDelay = KConsumeDefaultTimer; } else if ( secs.Int() < 0 ) { iCurrentDelay = 0; // Already expired. } else if ( secs.Int() < KConsumeDefaultTimer ) { iCurrentDelay = secs.Int(); } else { iCurrentDelay = KConsumeDefaultTimer; } if ( !IsAdded() ) { CActiveScheduler::Add( this ); } DRMLOG2( _L( "CDRMConsume::ActivateL: using interval %d" ), ( TInt )iCurrentDelay ); // secs -> microsecs. The method sets the AO active. After( TTimeIntervalMicroSeconds32( iCurrentDelay * 1000000 ) ); iTime = current; // If we see timed things here, we also have secure time. //SETBIT( iMask, KConsumeHasSecureTime ); } else // For metering we always need to have this: { iCurrentDelay = KConsumeDefaultTimer; iTime = aTrustedTime; if ( !IsAdded() ) { CActiveScheduler::Add( this ); } DRMLOG2( _L( "CDRMConsume::ActivateL: using interval %d" ), ( TInt )iCurrentDelay ); // secs -> microsecs. The method sets the AO active. After( TTimeIntervalMicroSeconds32( iCurrentDelay * 1000000 ) ); } // If we see timed things here, we also have secure time. if( aTrustedTime != Time::NullTTime()) { SETBIT( iMask, KConsumeHasSecureTime ); } DRMLOG( _L( "CDRMConsume::ActivateL ok" ) ); }