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" ) );
}
