CLevelDBWrapper::CLevelDBWrapper(const boost::filesystem::path &path, size_t nCacheSize, bool fMemory, bool fWipe) {
penv = NULL;
readoptions.verify_checksums = true;
iteroptions.verify_checksums = true;
iteroptions.fill_cache = false;
syncoptions.sync = true;
options = GetOptions(nCacheSize);
options.create_if_missing = true;
if (fMemory) {
penv = leveldb::NewMemEnv(leveldb::Env::Default());
options.env = penv;
} else {
if (fWipe) {
LogPrintf("Wiping LevelDB in %s\n", path.string().c_str());
leveldb::DestroyDB(path.string(), options);
}
boost::filesystem::create_directory(path);
LogPrintf("Opening LevelDB in %s\n", path.string().c_str());
}
leveldb::Status status = leveldb::DB::Open(options, path.string(), &pdb);
HandleError(status);
LogPrintf("Opened LevelDB successfully\n");
}
nsresult
SourceBuffer::ExpectLength(size_t aExpectedLength)
{
MOZ_ASSERT(aExpectedLength > 0, "Zero expected size?");
MutexAutoLock lock(mMutex);
if (MOZ_UNLIKELY(mStatus)) {
MOZ_ASSERT_UNREACHABLE("ExpectLength after SourceBuffer is complete");
return NS_OK;
}
if (MOZ_UNLIKELY(mChunks.Length() > 0)) {
MOZ_ASSERT_UNREACHABLE("Duplicate or post-Append call to ExpectLength");
return NS_OK;
}
if (MOZ_UNLIKELY(NS_FAILED(AppendChunk(CreateChunk(aExpectedLength))))) {
return HandleError(NS_ERROR_OUT_OF_MEMORY);
}
return NS_OK;
}
void FOutputDeviceWindowsError::Serialize( const TCHAR* Msg, ELogVerbosity::Type Verbosity, const class FName& Category )
{
FPlatformMisc::DebugBreak();
if( !GIsCriticalError )
{
const int32 LastError = ::GetLastError();
// First appError.
GIsCriticalError = 1;
TCHAR ErrorBuffer[1024];
ErrorBuffer[0] = 0;
// Windows error.
UE_LOG( LogWindows, Error, TEXT( "Windows GetLastError: %s (%i)" ), FPlatformMisc::GetSystemErrorMessage( ErrorBuffer, 1024, LastError ), LastError );
}
else
{
UE_LOG(LogWindows, Error, TEXT("Error reentered: %s"), Msg );
}
if( GIsGuarded )
{
// Propagate error so structured exception handler can perform necessary work.
#if PLATFORM_EXCEPTIONS_DISABLED
FPlatformMisc::DebugBreak();
#endif
FPlatformMisc::RaiseException( 1 );
}
else
{
// We crashed outside the guarded code (e.g. appExit).
HandleError();
FPlatformMisc::RequestExit( true );
}
}
// Encrypt/Decrypt functionality, called by pager.c
void* sqlite3Codec(void *pCodec, void *data, Pgno nPageNum, int nMode)
{
if (pCodec == NULL) //Db not encrypted
return data;
switch(nMode)
{
case 0: // Undo a "case 7" journal file encryption
case 2: // Reload a page
case 3: // Load a page
if (HasReadKey(pCodec))
Decrypt(pCodec, nPageNum, (unsigned char*) data);
break;
case 6: // Encrypt a page for the main database file
if (HasWriteKey(pCodec))
data = Encrypt(pCodec, nPageNum, (unsigned char*) data, 1);
break;
case 7: // Encrypt a page for the journal file
/*
*Under normal circumstances, the readkey is the same as the writekey. However,
*when the database is being rekeyed, the readkey is not the same as the writekey.
*(The writekey is the "destination key" for the rekey operation and the readkey
*is the key the db is currently encrypted with)
*Therefore, for case 7, when the rollback is being written, always encrypt using
*the database's readkey, which is guaranteed to be the same key that was used to
*read and write the original data.
*/
if (HasReadKey(pCodec))
data = Encrypt(pCodec, nPageNum, (unsigned char*) data, 0);
break;
}
HandleError(pCodec);
return data;
}
void TCPSocket::WriteThread()
{
this->mutex.lock();
while (!this->writeQueue.empty())
{
BytesRef data = this->writeQueue.front();
char* buffer = data->Pointer();
size_t remaining = data->Length();
// Release lock while sending data to avoid blocking write().
this->mutex.unlock();
while (true)
{
try
{
size_t sent = this->socket.sendBytes(buffer, remaining);
if (sent == remaining) break;
buffer += sent;
remaining -= sent;
}
catch (Poco::Exception& e)
{
HandleError(e);
return;
}
}
this->mutex.lock();
this->writeQueue.pop();
}
// Notify listeners we have fully drained the queue.
this->mutex.unlock();
FireEvent("drain");
}
void CSoundGroup::Reload()
{
m_index = 0; // reset our index
#if CONFIG2_AUDIO
ReleaseGroup();
if ( g_SoundManager ) {
for (size_t i = 0; i < filenames.size(); i++)
{
VfsPath thePath = m_filepath/filenames[i];
CSoundData* itemData = CSoundData::SoundDataFromFile(thePath);
if (itemData == NULL)
HandleError(L"error loading sound", thePath, ERR::FAIL);
else
snd_group.push_back(itemData->IncrementCount());
}
if (TestFlag(eRandOrder))
random_shuffle(snd_group.begin(), snd_group.end());
}
#endif // CONFIG2_AUDIO
}
void
find_libdir (void)
{
const char searchfile[] = "Colour.pal";
/* default_dir will be something like "C:\\LINCITY1.11" */
const char default_dir[] = "C:\\LINCITY" VERSION;
/* Check 1: environment variable */
_searchenv (searchfile, "LINCITY_HOME", LIBDIR);
if (*LIBDIR != '\0') {
int endofpath_offset = strlen (LIBDIR) - strlen (searchfile) - 1;
LIBDIR[endofpath_offset] = '\0';
return;
}
/* Check 2: default location */
if ((_access (default_dir, 0)) != -1) {
strcpy (LIBDIR, default_dir);
return;
}
/* Finally give up */
HandleError ("Error. Can't find LINCITY_HOME", FATAL);
}
BOOL
CUdpCommClient::Push(CUdpPacketNode* pcPktNode)
{
if (pcPktNode->GetRawLen() >= m_ulMaxSndPktLen)
{
HandleError(OCFCLIENT_ERROR_USERDEF, OCFCLIENT_ERROR_USERDEF_CATEGORY_PKTMAXSIZE, 0, pcPktNode->GetRawLen(), pcPktNode->GetRawBuff());
return FALSE;
}
//
Lock();
m_cSndPktList.Add(pcPktNode);
if (TRUE == m_bConnectFlag && FALSE == m_bWouldBlock)
{
SetEvent(m_hWrEvent);
}
//
Unlock();
return TRUE;
}
/**
* Prints out the name value records of the matching results.
*/
int printMetadataResults(hc_nvr_t *nvr, hc_session_t *session)
{
char **names = NULL;
char **values = NULL;
int count = 0;
hcerr_t hcError = hc_nvr_convert_to_string_arrays(nvr,
&names,
&values,
&count);
if (hcError != HCERR_OK)
{
HandleError(session, hcError);
hc_session_free(session);
return RETURN_STORAGETEK_ERROR;
} /* if error occurred */
/* Print metadata record. printMetadataRecord is example specific code (in example_metadata.h) */
/* and is not part of the @HoneycombProductName@ API. */
printMetadataRecord(names, values, count);
return RETURN_SUCCESS;
} /* printMetadataResults */
BOOL CUdpClient::ProcessNetworkEvent()
{
BOOL bContinue = TRUE;
WSANETWORKEVENTS events;
int rc = ::WSAEnumNetworkEvents(m_soClient, m_evSocket, &events);
if(rc == SOCKET_ERROR)
bContinue = HandleError();
if(bContinue && events.lNetworkEvents & FD_READ)
bContinue = HandleRead(events);
if(bContinue && events.lNetworkEvents & FD_WRITE)
bContinue = HandleWrite(events);
if(m_bAsyncConnect && bContinue && events.lNetworkEvents & FD_CONNECT)
bContinue = HandleConnect(events);
if(bContinue && events.lNetworkEvents & FD_CLOSE)
bContinue = HandleClosse(events);
return bContinue;
}
bool CFI::CompileCFI(const string &str)
{
// strip the 'epubcfi(...)' wrapping
string cfi(str);
if ( str.find("epubcfi(") == 0 )
{
cfi = cfi.substr(8, (str.size()-1)-8);
}
else if ( str.size() == 0 )
{
HandleError(EPUBError::CFIParseFailed, "Empty CFI string");
return false;
}
else if ( str[0] != '/' )
{
HandleError(EPUBError::CFINonSlashStartCharacter);
}
StringList rangePieces = RangedCFIComponents(cfi);
if ( rangePieces.size() != 1 && rangePieces.size() != 3 )
{
HandleError(EPUBError::CFIRangeComponentCountInvalid, _Str("Expected 1 or 3 range components, got ", rangePieces.size()));
if ( rangePieces.size() == 0 )
return false;
}
if ( CompileComponentsToList(CFIComponentStrings(rangePieces[0]), &_components) == false )
return false;
if ( rangePieces.size() >= 3 )
{
if ( CompileComponentsToList(CFIComponentStrings(rangePieces[1]), &_rangeStart) == false )
return false;
if ( CompileComponentsToList(CFIComponentStrings(rangePieces[2]), &_rangeEnd) == false )
return false;
// now sanity-check the range delimiters:
// neither should be empty
if ( _rangeStart.empty() || _rangeEnd.empty() )
{
HandleError(EPUBError::CFIRangeInvalid, "One of the supplied range components was empty.");
return false;
}
// check the offsets at the end of each— they should be the same type
if ( (_rangeStart.back().flags & Component::OffsetsMask) != (_rangeEnd.back().flags & Component::OffsetsMask) )
{
HandleError(EPUBError::CFIRangeInvalid, "Offsets at the end of range components are of different types.");
return false;
}
// ensure that there are no side-bias values
if ( (_rangeStart.back().sideBias != SideBias::Unspecified) ||
(_rangeEnd.back().sideBias != SideBias::Unspecified) )
{
HandleError(EPUBError::CFIRangeContainsSideBias);
// can safely ignore this one
}
// where the delimiters' component ranges overlap, start must be <= end
auto maxsz = std::max(_rangeStart.size(), _rangeEnd.size());
bool inequalNodeIndexFound = false;
for ( decltype(maxsz) i = 0; i < maxsz; i++ )
{
if ( _rangeStart[i].nodeIndex > _rangeEnd[i].nodeIndex )
{
HandleError(EPUBError::CFIRangeInvalid, "Range components appear to be out of order.");
}
else if ( !inequalNodeIndexFound && _rangeStart[i].nodeIndex < _rangeEnd[i].nodeIndex )
{
inequalNodeIndexFound = true;
}
}
// if the two ranges are equal aside from their offsets, the end offset must be > the start offset
if ( !inequalNodeIndexFound && _rangeStart.size() == _rangeEnd.size() )
{
Component &s = _rangeStart.back(), &e = _rangeEnd.back();
if ( s.HasCharacterOffset() && s.characterOffset > e.characterOffset )
{
HandleError(EPUBError::CFIRangeInvalid, "Range components appear to be out of order.");
}
else
{
if ( s.HasTemporalOffset() && s.temporalOffset > e.temporalOffset )
HandleError(EPUBError::CFIRangeInvalid, "Range components appear to be out of order.");
if ( s.HasSpatialOffset() && s.spatialOffset > e.spatialOffset )
HandleError(EPUBError::CFIRangeInvalid, "Range components appear to be out of order.");
}
}
_options |= RangeTriplet;
}
return true;
}
void
ClientUserLua::Diff( FileSys *f1, FileSys *f2, int doPage,
char *diffFlags, Error *e )
{
if ( P4LUADEBUG_CALLS )
fprintf( stderr, "[P4] Diff() - comparing files\n" );
//
// Duck binary files. Much the same as ClientUser::Diff, we just
// put the output into Ruby space rather than stdout.
//
if( !f1->IsTextual() || !f2->IsTextual() )
{
if ( f1->Compare( f2, e ) )
results.AddOutput( "(... files differ ...)" );
return;
}
// Time to diff the two text files. Need to ensure that the
// files are in binary mode, so we have to create new FileSys
// objects to do this.
FileSys *f1_bin = FileSys::Create( FST_BINARY );
FileSys *f2_bin = FileSys::Create( FST_BINARY );
FileSys *t = FileSys::CreateGlobalTemp( f1->GetType() );
f1_bin->Set( f1->Name() );
f2_bin->Set( f2->Name() );
{
//
// In its own block to make sure that the diff object is deleted
// before we delete the FileSys objects.
//
#ifndef OS_NEXT
::
#endif
Diff d;
d.SetInput( f1_bin, f2_bin, diffFlags, e );
if ( ! e->Test() ) d.SetOutput( t->Name(), e );
if ( ! e->Test() ) d.DiffWithFlags( diffFlags );
d.CloseOutput( e );
// OK, now we have the diff output, read it in and add it to
// the output.
if ( ! e->Test() ) t->Open( FOM_READ, e );
if ( ! e->Test() )
{
StrBuf b;
while( t->ReadLine( &b, e ) )
results.AddOutput( b.Text() );
}
}
delete t;
delete f1_bin;
delete f2_bin;
if ( e->Test() ) HandleError( e );
}
void
ClientUserLua::OutputStat( StrDict *values )
{
StrPtr * spec = values->GetVar( "specdef" );
StrPtr * data = values->GetVar( "data" );
StrPtr * sf = values->GetVar( "specFormatted" );
StrDict * dict = values;
SpecDataTable specData;
Error e;
//
// Determine whether or not the data we've got contains a spec in one form
// or another. 2000.1 -> 2005.1 servers supplied the form in a data variable
// and we use the spec variable to parse the form. 2005.2 and later servers
// supply the spec ready-parsed but set the 'specFormatted' variable to tell
// the client what's going on. Either way, we need the specdef variable set
// to enable spec parsing.
//
int isspec = spec && ( sf || data );
//
// Save the spec definition for later
//
if( spec )
specMgr->AddSpecDef( cmd.Text(), spec->Text() );
//
// Parse any form supplied in the 'data' variable and convert it into a
// dictionary.
//
if( spec && data )
{
// 2000.1 -> 2005.1 server's handle tagged form output by supplying the form
// as text in the 'data' variable. We need to convert it to a dictionary
// using the supplied spec.
if( P4LUADEBUG_CALLS )
fprintf( stderr, "[P4] OutputStat() - parsing form\n" );
// Parse the form. Use the ParseNoValid() interface to prevent
// errors caused by the use of invalid defaults for select items in
// jobspecs.
//#if P4APIVER_ID >= 513538
Spec s( spec->Text(), "", &e );
//#else
//Spec s( spec->Text(), "" );
//#endif
if( !e.Test() ) s.ParseNoValid( data->Text(), &specData, &e );
if( e.Test() )
{
HandleError( &e );
return;
}
dict = specData.Dict();
}
//
// If what we've got is a parsed form, then we'll convert it to a P4::Spec
// object. Otherwise it's a plain hash.
//
if( isspec )
{
if( P4LUADEBUG_CALLS )
fprintf(stderr ,"[P4] OutputStat() - Converting to P4::Spec object\n");
results.AddOutput( specMgr->StrDictToSpec( dict, spec ) );
lua_pop( L, 1 );
}
else
{
if( P4LUADEBUG_CALLS )
fprintf(stderr ,"[P4] OutputStat() - Converting to hash\n");
results.AddOutput( specMgr->StrDictToHash( dict ) );
lua_pop( L, 1 );
}
}
int main(int argc, char* argv[])
{
hc_session_t *session = NULL;
hc_oid returnedOid;
hc_long_t count = 0;
int finished = 0;
int32_t response_code = RETURN_SUCCESS;
hc_query_result_set_t *rset = NULL;
hc_nvr_t *nvr = NULL;
hc_long_t query_integrity_time;
int query_complete;
hcerr_t res = HCERR_OK;
int parametersUsed = USES_SERVERADDRESS | USES_QUERY | USES_SELECT_METADATA | USES_MAXRESULTS;
/* Initialize commandline structure */
cmdLine.storagetekServerAddress = NULL;
cmdLine.query = NULL;
cmdLine.help = 0;
cmdLine.debug_flags = 0;
cmdLine.storagetekPort = 0;
cmdLine.maxResults = DEFAULT_MAX_RESULTS;
/* Initialize metadata map. The metadata map structure is not part of the API but common */
/* code written for the convenience of these examples. See example_metadata.c. */
if (initMetadataMap(&cmdLine.cmdlineMetadata) == 0)
{
return exitApp(RETURN_MAPINITERROR);
} /* if initMetadataMap == 0 */
/* Get commandline (see example_commandline.c) */
if (parseCommandline( argc,
argv,
parametersUsed) == 0)
{
printUsage();
return RETURN_COMMANDLINE_ERROR;
} /* if parseCommandline failed */
else
{
if (cmdLine.help == 1)
{
printUsage();
return RETURN_SUCCESS;
} /* if help requested */
} /* else parseCommandline succeeded */
/* Initialize @HoneycombProductName@ API */
res = hc_init(malloc,free,realloc);
if (res != HCERR_OK)
{
printf("An error occurred while initializing the API.\n");
return res;
} /* if error */
if (cmdLine.debug_flags) {
/* Internal debug flags */
hc_set_global_parameter(HCOPT_DEBUG_FLAGS, cmdLine.debug_flags);
}
res = hc_session_create_ez(cmdLine.storagetekServerAddress,
(cmdLine.storagetekPort > 0 ?
cmdLine.storagetekPort :
STORAGETEK_PORT),
&session);
if (res != HCERR_OK)
{
HandleError(session,res);
return RETURN_STORAGETEK_ERROR;
} /* if initialization failed */
/* Run queryplus if we have a select clause (-s option on the commandline), otherwise run query */
if (cmdLine.cmdlineMetadata.mapSize > 0)
{
res = hc_query_ez(session,
cmdLine.query,
cmdLine.cmdlineMetadata.namePointerArray,
cmdLine.cmdlineMetadata.mapSize,
100,
&rset);
} /* if outputing metadata */
else
{
res = hc_query_ez(session,
cmdLine.query,
NULL,
0,
100,
&rset);
}
if (res != HCERR_OK)
{
HandleError(session, res);
hc_session_free(session);
hc_cleanup();
return RETURN_STORAGETEK_ERROR;
} /* if not successful */
/* Loop up until the maximum result size */
for (count = 0; count < cmdLine.maxResults; count++)
{
/* Get the next result */
res = hc_qrs_next_ez(rset, &returnedOid, &nvr, &finished);
if (res != HCERR_OK)
{
HandleError(session, res);
hc_session_free(session);
hc_cleanup();
return RETURN_STORAGETEK_ERROR;
} /* if not successful */
if (finished)
break;
/* Print the next result to standard output */
if (cmdLine.cmdlineMetadata.mapSize > 0)
{
printMetadataResults(nvr, session);
}
else
{
printOIDResults((char *) &returnedOid);
}
} /* loop through results */
res = hc_qrs_is_query_complete(rset,&query_complete);
if (res != HCERR_OK)
{
HandleError(session, res);
response_code = RETURN_STORAGETEK_ERROR;
}
res = hc_qrs_get_query_integrity_time(rset,&query_integrity_time);
if (res != HCERR_OK)
{
HandleError(session, res);
response_code = RETURN_STORAGETEK_ERROR;
}
printf("Query Integrity Status %s at time %lld\n",
query_complete ? "true" : "false",
query_integrity_time);
res = hc_qrs_free(rset);
if (res != HCERR_OK)
{
HandleError(session, res);
response_code = RETURN_STORAGETEK_ERROR;
}
hc_session_free(session);
hc_cleanup();
return exitApp(response_code);
} /* main */
PyObject *Connection_connect(Connection *self, PyObject *args)
{
/*
Args:
UMConnection conn, const char *_host, int _port, const char *_username, const char *_password, const char *_database, int _autoCommit, const char *_charset*/
char *host;
int port;
char *username;
char *password;
char *database;
int autoCommit;
char *pstrCharset = NULL;
PyObject *acObj = NULL;
if (!PyArg_ParseTuple (args, "sisss|Os", &host, &port, &username, &password, &database, &acObj, &pstrCharset))
{
return NULL;
}
if (acObj)
{
PRINTMARK();
autoCommit = (PyObject_IsTrue(acObj) == 1) ? 1 : 0;
}
if (pstrCharset)
{
if (strcmp (pstrCharset, "utf8") == 0)
{
self->charset = MCS_utf8_general_ci;
self->PFN_PyUnicode_Encode = PyUnicode_EncodeUTF8;
}
else
if (strcmp (pstrCharset, "latin1") == 0)
{
self->charset = MCS_latin1_general_ci;
self->PFN_PyUnicode_Encode = PyUnicode_EncodeLatin1;
}
else
if (strcmp (pstrCharset, "ascii") == 0)
{
self->charset = MCS_ascii_general_ci;
self->PFN_PyUnicode_Encode = PyUnicode_EncodeASCII;
}
else
if (strcmp (pstrCharset, "cp1250") == 0)
{
self->charset = MCS_cp1250_general_ci;
self->PFN_PyUnicode_Encode = PyUnicode_EncodeCP1250Helper;
}
else
{
return PyErr_Format (PyExc_ValueError, "Unsupported character set '%s' specified", pstrCharset);
}
}
else
{
self->charset = MCS_utf8_general_ci;
self->PFN_PyUnicode_Encode = PyUnicode_EncodeUTF8;
}
if (!UMConnection_Connect (self->conn, host, port, username, password, database, acObj ? &autoCommit : NULL, self->charset))
{
return HandleError(self, "connect");
}
Py_RETURN_NONE;
}
/* This function generates a batch named prepare.bat (default).
* The batch contains 6 experiments
* Exp1: SPE - (Special) - runs IOCount SR then IOCount RW then IOCount SR
* The goal is here to determine the Pause value
* Exp2: SIO.SR - runs IOCount2 SR - goal: determine IOIgnoreSR and IOCountSR
* Exp3-5 : same for RR, SW, RW
* Exp6 : Random format of the device
*/
void GenPrepare(sParams* PB) {
FILE* fp2 = NULL; // file pointer
int32 size;
fp2 = fopen(PB->outName, "w");
if (fp2 == NULL) HandleError("GenBench", "Could not open output file", GetLastError(), ERR_ABORT);
strcpy(PB->comment, "SPE");
strcpy(PB->base, "SR");
PB->expID = 1;
PB->microBenchID = 0;
PB->pauseExp = 10000;
size = PB->IOSize * PB->IOCount;
for (PB->runID = 0; PB->runID < PB->nbRun; (PB->runID)++) {
PB->targetOffset = rg.IRandom(0,(int32)((PB->deviceSize/2 - size)/BLOCK))*BLOCK; // We choose a random location in the first half of the device
PB->targetSize = PB->deviceSize - PB->targetOffset;
GenExp(fp2, PB);
}
PB->IOCount = PB->IOCount2;
size = PB->IOSize * PB->IOCount;
strcpy(PB->comment, "SIO.SR");
PB->expID = 2;
for (PB->runID = 0; PB->runID < PB->nbRun; (PB->runID)++) {
PB->targetOffset = rg.IRandom(0,(int32)((PB->deviceSize/2 - size)/BLOCK))*BLOCK; // We choose a random location in the first half of the device
PB->targetSize = PB->deviceSize - PB->targetOffset;
GenExp(fp2, PB);
}
strcpy(PB->base, "RR");
strcpy(PB->comment, "SIO.RR");
PB->expID++;
for (PB->runID = 0; PB->runID < PB->nbRun; (PB->runID)++) {
PB->targetOffset = rg.IRandom(0,(int32)((PB->deviceSize/2 - size)/BLOCK))*BLOCK; // We choose a random location in the first half of the device
PB->targetSize = PB->deviceSize - PB->targetOffset;
GenExp(fp2, PB);
}
strcpy(PB->base, "SW");
strcpy(PB->comment, "SIO.SW");
PB->expID++;
for (PB->runID = 0; PB->runID < PB->nbRun; (PB->runID)++) {
PB->targetOffset = rg.IRandom(0,(int32)((PB->deviceSize/2 - size)/BLOCK))*BLOCK; // We choose a random location in the first half of the device
PB->targetSize = PB->deviceSize - PB->targetOffset;
GenExp(fp2, PB);
}
strcpy(PB->base, "RW");
strcpy(PB->comment, "SIO.RW");
PB->expID++;
for (PB->runID = 0; PB->runID < PB->nbRun; (PB->runID)++) {
PB->targetOffset = rg.IRandom(0,(int32)((PB->deviceSize/2 - size)/BLOCK))*BLOCK; // We choose a random location in the first half of the device
PB->targetSize = PB->deviceSize - PB->targetOffset;
GenExp(fp2, PB);
}
PB->expID++;
fprintf(fp2, "FlashIO RandomFormat Dev %d Bench %d Exp %d ", PB->deviceNum, PB->microBenchID, PB->expID);
if (PB->trimBeforeRun == TRUE)
fprintf(fp2, "TrimBeforeRun True\n");
else
fprintf(fp2, "\n");
if (PB->fake == TRUE)
fprintf(fp2, "Fake True\n Pause\n");
else
fprintf(fp2, "\n Pause\n");
fclose(fp2);
}
bool DoPrepared(HDBC lpDbc, TCHAR* szInput)
{
int arrIdx = 0;
RETCODE RetCode;
SQLSMALLINT sNumResults;
HSTMT lpStmt = NULL;
TCHAR* szIter = szInput;
int cnt = 0;
TRYODBCP(lpDbc,
SQL_HANDLE_DBC,
SQLAllocHandle(SQL_HANDLE_STMT, lpDbc, &lpStmt));
RetCode = SQLPrepare(lpStmt, (SQLCHAR*) szInput, SQL_NTS);
while (NULL != (szIter = strstr(szIter, "?"))) {
++cnt;
++szIter;
}
TCHAR szParams[MAX_PARAMS][SQL_QUERY_SIZE];
SQLLEN lenParams[MAX_PARAMS];
for (int sqlIdx = 1; sqlIdx <= cnt; ++sqlIdx) {
arrIdx = sqlIdx - 1;
_fgetts(szParams[arrIdx], SQL_QUERY_SIZE - 1, stdin);
lenParams[arrIdx] = strlen(szParams[arrIdx]);
szParams[arrIdx][lenParams[arrIdx]] = '\0';
lenParams[arrIdx] -= 1;
TRYODBCP(lpStmt, SQL_HANDLE_STMT,
SQLBindParameter(lpStmt, sqlIdx, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, 255, 0, szParams[arrIdx],
SQL_QUERY_SIZE, &lenParams[arrIdx]));
}
RetCode = SQLExecute(lpStmt);
switch (RetCode)
{
case SQL_SUCCESS_WITH_INFO:
{
HandleError(lpStmt, SQL_HANDLE_STMT, RetCode);
// fall through
}
case SQL_SUCCESS:
{
// If this is a row-returning query, display
// results
TRYODBCP(lpStmt,
SQL_HANDLE_STMT,
SQLNumResultCols(lpStmt, &sNumResults));
if (sNumResults > 0)
{
DisplayResults(lpStmt, sNumResults);
} else
{
SQLLEN siRowCount;
TRYODBCP(lpStmt,
SQL_HANDLE_STMT,
SQLRowCount(lpStmt, &siRowCount));
if (siRowCount >= 0)
{
_tprintf(TEXT("%ld %s affected\n"),
static_cast<long>(siRowCount),
siRowCount == 1 ? TEXT("row") : TEXT("rows"));
}
}
break;
}
case SQL_ERROR:
{
HandleError(lpStmt, SQL_HANDLE_STMT, RetCode);
break;
}
default:
fprintf(stderr, "Unexpected return code %d!\n", RetCode);
}
SQLFreeStmt(lpStmt, SQL_DROP);
return true;
ExitP:
return false;
}
/**
* Restarts a running task.
* If the task isn't started, it starts it.
* @return false if the task is running and we are unable to kill the previous instance
*/
bool Task::Restart()
{
return HandleError(taskRestart(m_taskID));
}
/**
* This routine changes a task's priority to a specified priority.
* Priorities range from 0, the highest priority, to 255, the lowest priority.
* Default task priority is 100.
* @param priority The priority the task should run at.
* @returns true on success.
*/
bool Task::SetPriority(INT32 priority)
{
m_priority = priority;
return HandleError(taskPrioritySet(m_taskID, m_priority));
}
/**
* Resumes a paused task.
* Returns true on success, false if unable to resume or if the task isn't running/paused.
*/
bool Task::Resume()
{
return HandleError(taskResume(m_taskID));
}
/**
* Pauses a running task.
* Returns true on success, false if unable to pause or the task isn't running.
*/
bool Task::Suspend()
{
return HandleError(taskSuspend(m_taskID));
}
void CFI::Component::Parse(const string &str)
{
if ( str.empty() )
{
HandleError(EPUBError::CFIParseFailed, "Empty string supplied to CFI::Component");
return;
}
std::string utf8 = str.stl_str();
std::istringstream iss(utf8);
// read an integer
iss >> nodeIndex;
if ( nodeIndex == 0 && iss.fail() )
{
HandleError(EPUBError::CFIParseFailed, _Str("No node value at start of CFI::Component string '", str, "'"));
return;
}
while ( !iss.eof() )
{
char next = 0;
iss >> next;
switch ( next )
{
case '[':
{
size_t pos = static_cast<size_t>(iss.tellg());
iss.ignore(std::numeric_limits<std::streamsize>::max(), ']');
size_t end = ((size_t)iss.tellg()) - 1;
if ( iss.eof() )
{
HandleError(EPUBError::CFIParseFailed);
return;
}
if ( characterOffset != 0 )
{
// this is a text qualifier
flags |= TextQualifier;
std::string sub = utf8.substr(pos, end-pos);
// is there a side-bias?
auto biasPos = sub.find(";s=");
if ( biasPos == std::string::npos )
{
textQualifier = std::move(sub);
}
else
{
textQualifier = sub.substr(0, biasPos);
if ( sub.size() > biasPos + 3 )
{
switch ( sub[biasPos+3] )
{
case 'b':
sideBias = SideBias::Before;
break;
case 'a':
sideBias = SideBias::After;
break;
default:
sideBias = SideBias::Unspecified;
break;
}
}
}
}
else
{
// it's a position qualifier
qualifier = utf8.substr(pos, end-pos);
flags |= Qualifier;
}
break;
}
case '~':
{
// character offsets and spatial/temporal offsets are mutually exclusive
if ( HasCharacterOffset() )
break;
// read a numeral
iss >> temporalOffset;
flags |= TemporalOffset;
break;
}
case '@':
{
// character offsets and spatial/temporal offsets are mutually exclusive
if ( HasCharacterOffset() )
break;
// two floats, separated by a colon
float x, y;
// read x
iss >> x;
// check for and skip delimiter
if ( iss.peek() != ':' )
break;
iss.ignore(1);
// read y
iss >> y;
spatialOffset.x = x;
spatialOffset.y = y;
flags |= SpatialOffset;
break;
}
case ':':
{
// character offsets and spatial/temporal offsets are mutually exclusive
if ( HasSpatialTemporalOffset() )
break;
iss >> characterOffset;
flags |= CharacterOffset;
break;
}
case '!':
{
// must be the last character, and no offsets
if ( ((int)iss.peek()) != -1 || HasSpatialTemporalOffset() || HasCharacterOffset() )
break;
flags |= Indirector;
break;
}
default:
break;
}
}
}
bool CLevelDBWrapper::WriteBatch(CLevelDBBatch& batch, bool fSync) throw(leveldb_error)
{
leveldb::Status status = pdb->Write(fSync ? syncoptions : writeoptions, &batch.batch);
HandleError(status);
return true;
}
void
get_cert_time_left(
char *realm,
CTimeSpan *ptimeLeft
)
{
HCERTSTORE hStoreHandle = NULL;
PCCERT_CONTEXT pCertContext = NULL;
PCCERT_CONTEXT prev_pCertContext = NULL;
DWORD dwCertEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
DWORD dwAddDisposition = CERT_STORE_ADD_REPLACE_EXISTING;
DWORD dwFindFlags = 0;
# define OID_KCA_AUTHREALM "1.3.6.1.4.1.250.42.1"
DWORD dwFindType = CERT_FIND_ANY;
CERT_INFO *pCertInfo = NULL;
PCERT_EXTENSION pCertExt = NULL;
CRYPT_OBJID_BLOB *p = NULL;
int i = 0;
char tmpRealm[250] = { 0 };
CTime startTime = 0;
CTime endTime = 0;
memset(ptimeLeft, 0, sizeof(*ptimeLeft));
if (!realm || !strlen(realm))
return;
//--------------------------------------------------------------------
// Open a store as the source of the certificates to be deleted and added
if(!(hStoreHandle = CertOpenSystemStore(
0,
MY_STORE)))
{
HandleError("get_cert_time_left: Strange. Unable to access your place in the Registry for certificates");
goto EXIT_RTN;
}
// Find first MY store cert issued by our Certificate Authority
while ((pCertContext = CertFindCertificateInStore(
hStoreHandle, // in
dwCertEncodingType, // in
dwFindFlags, // in
dwFindType, // in
NULL, // in
prev_pCertContext // in
)))
{
if (pCertInfo = pCertContext->pCertInfo)
for (i = pCertInfo->cExtension; i; i--)
{
pCertExt = &pCertInfo->rgExtension[i-1];
if (!strcmp(pCertExt->pszObjId, OID_KCA_AUTHREALM))
{
log_printf("get_cert_time_left: Found KCA_AUTHREALM Extension\n");
p = &pCertExt->Value;
memcpy(tmpRealm, &p->pbData[2], p->cbData-2);
tmpRealm[p->cbData-2] ='\0';
log_printf("get_cert_time_left: value is: '%s'\n", tmpRealm);
/* only match if realm of current TGT matches AuthRealm of this cert */
if (realm && !strcmp(realm, tmpRealm))
{
// It matches, determine remaining certificate's remaining minutes
startTime = CTime::GetCurrentTime();
endTime = pCertContext->pCertInfo->NotAfter;
*ptimeLeft = endTime - startTime;
goto EXIT_RTN;
}
}
}
prev_pCertContext = pCertContext;
}
EXIT_RTN:
if ((prev_pCertContext != pCertContext) && pCertContext)
{
CertFreeCertificateContext(pCertContext);
pCertContext = NULL;
}
if (pCertContext)
CertFreeCertificateContext(pCertContext);
if(hStoreHandle &&!CertCloseStore(
hStoreHandle,
#ifdef DEBUG
CERT_CLOSE_STORE_CHECK_FLAG
#else // !DEBUG
CERT_CLOSE_STORE_FORCE_FLAG
#endif // ! DEBUG
))
{
log_printf("get_cert_time_left: The store was closed, but certificates still in use.\n");
}
} // get_cert_time_left
NS_IMETHODIMP
nsExpatDriver::ConsumeToken(nsScanner& aScanner, PRBool& aFlushTokens)
{
// We keep the scanner pointing to the position where Expat will start
// parsing.
nsScannerIterator currentExpatPosition;
aScanner.CurrentPosition(currentExpatPosition);
// This is the start of the first buffer that we need to pass to Expat.
nsScannerIterator start = currentExpatPosition;
start.advance(mExpatBuffered);
// This is the end of the last buffer (at this point, more data could come in
// later).
nsScannerIterator end;
aScanner.EndReading(end);
PR_LOG(gExpatDriverLog, PR_LOG_DEBUG,
("Remaining in expat's buffer: %i, remaining in scanner: %i.",
mExpatBuffered, Distance(start, end)));
// We want to call Expat if we have more buffers, or if we know there won't
// be more buffers (and so we want to flush the remaining data), or if we're
// currently blocked and there's data in Expat's buffer.
while (start != end || (mIsFinalChunk && !mMadeFinalCallToExpat) ||
(BlockedOrInterrupted() && mExpatBuffered > 0)) {
PRBool noMoreBuffers = start == end && mIsFinalChunk;
PRBool blocked = BlockedOrInterrupted();
const PRUnichar *buffer;
PRUint32 length;
if (blocked || noMoreBuffers) {
// If we're blocked we just resume Expat so we don't need a buffer, if
// there aren't any more buffers we pass a null buffer to Expat.
buffer = nsnull;
length = 0;
#if defined(PR_LOGGING) || defined (DEBUG)
if (blocked) {
PR_LOG(gExpatDriverLog, PR_LOG_DEBUG,
("Resuming Expat, will parse data remaining in Expat's "
"buffer.\nContent of Expat's buffer:\n-----\n%s\n-----\n",
NS_ConvertUTF16toUTF8(currentExpatPosition.get(),
mExpatBuffered).get()));
}
else {
NS_ASSERTION(mExpatBuffered == Distance(currentExpatPosition, end),
"Didn't pass all the data to Expat?");
PR_LOG(gExpatDriverLog, PR_LOG_DEBUG,
("Last call to Expat, will parse data remaining in Expat's "
"buffer.\nContent of Expat's buffer:\n-----\n%s\n-----\n",
NS_ConvertUTF16toUTF8(currentExpatPosition.get(),
mExpatBuffered).get()));
}
#endif
}
else {
buffer = start.get();
length = PRUint32(start.size_forward());
PR_LOG(gExpatDriverLog, PR_LOG_DEBUG,
("Calling Expat, will parse data remaining in Expat's buffer and "
"new data.\nContent of Expat's buffer:\n-----\n%s\n-----\nNew "
"data:\n-----\n%s\n-----\n",
NS_ConvertUTF16toUTF8(currentExpatPosition.get(),
mExpatBuffered).get(),
NS_ConvertUTF16toUTF8(start.get(), length).get()));
}
PRUint32 consumed;
ParseBuffer(buffer, length, noMoreBuffers, &consumed);
if (consumed > 0) {
nsScannerIterator oldExpatPosition = currentExpatPosition;
currentExpatPosition.advance(consumed);
// We consumed some data, we want to store the last line of data that
// was consumed in case we run into an error (to show the line in which
// the error occurred).
// The length of the last line that Expat has parsed.
XML_Size lastLineLength = XML_GetCurrentColumnNumber(mExpatParser);
if (lastLineLength <= consumed) {
// The length of the last line was less than what expat consumed, so
// there was at least one line break in the consumed data. Store the
// last line until the point where we stopped parsing.
nsScannerIterator startLastLine = currentExpatPosition;
startLastLine.advance(-((ptrdiff_t)lastLineLength));
CopyUnicodeTo(startLastLine, currentExpatPosition, mLastLine);
}
else {
// There was no line break in the consumed data, append the consumed
// data.
AppendUnicodeTo(oldExpatPosition, currentExpatPosition, mLastLine);
}
}
mExpatBuffered += length - consumed;
if (BlockedOrInterrupted()) {
PR_LOG(gExpatDriverLog, PR_LOG_DEBUG,
("Blocked or interrupted parser (probably for loading linked "
"stylesheets or scripts)."));
aScanner.SetPosition(currentExpatPosition, PR_TRUE);
aScanner.Mark();
return mInternalState;
}
if (noMoreBuffers && mExpatBuffered == 0) {
mMadeFinalCallToExpat = PR_TRUE;
}
if (NS_FAILED(mInternalState)) {
if (XML_GetErrorCode(mExpatParser) != XML_ERROR_NONE) {
NS_ASSERTION(mInternalState == NS_ERROR_HTMLPARSER_STOPPARSING,
"Unexpected error");
// Look for the next newline after the last one we consumed
nsScannerIterator lastLine = currentExpatPosition;
while (lastLine != end) {
length = PRUint32(lastLine.size_forward());
PRUint32 endOffset = 0;
const PRUnichar *buffer = lastLine.get();
while (endOffset < length && buffer[endOffset] != '\n' &&
buffer[endOffset] != '\r') {
++endOffset;
}
mLastLine.Append(Substring(buffer, buffer + endOffset));
if (endOffset < length) {
// We found a newline.
break;
}
lastLine.advance(length);
}
HandleError();
}
return mInternalState;
}
// Either we have more buffers, or we were blocked (and we'll flush in the
// next iteration), or we should have emptied Expat's buffer.
NS_ASSERTION(!noMoreBuffers || blocked ||
(mExpatBuffered == 0 && currentExpatPosition == end),
"Unreachable data left in Expat's buffer");
start.advance(length);
// It's possible for start to have passed end if we received more data
// (e.g. if we spun the event loop in an inline script). Reload end now
// to compensate.
aScanner.EndReading(end);
}
aScanner.SetPosition(currentExpatPosition, PR_TRUE);
aScanner.Mark();
PR_LOG(gExpatDriverLog, PR_LOG_DEBUG,
("Remaining in expat's buffer: %i, remaining in scanner: %i.",
mExpatBuffered, Distance(currentExpatPosition, end)));
return NS_SUCCEEDED(mInternalState) ? kEOF : NS_OK;
}
PyObject *Connection_query(Connection *self, PyObject *args)
{
void *ret;
PyObject *inQuery = NULL;
PyObject *query = NULL;
PyObject *iterable = NULL;
PyObject *escapedQuery = NULL;
if (!UMConnection_IsConnected(self->conn))
{
return PyErr_Format(PyExc_RuntimeError, "Not connected");
}
if (!PyArg_ParseTuple (args, "O|O", &inQuery, &iterable))
{
return NULL;
}
if (iterable)
{
PyObject *iterator = PyObject_GetIter(iterable);
if (iterator == NULL)
{
PyErr_Clear();
return PyErr_Format(PyExc_TypeError, "Expected iterable");
}
Py_DECREF(iterator);
}
if (!PyString_Check(inQuery))
{
if (!PyUnicode_Check(inQuery))
{
PRINTMARK();
return PyErr_Format(PyExc_TypeError, "Query argument must be either String or Unicode");
}
query = self->PFN_PyUnicode_Encode(PyUnicode_AS_UNICODE(inQuery), PyUnicode_GET_SIZE(inQuery), NULL);
if (query == NULL)
{
if (!PyErr_Occurred())
{
PyErr_SetObject(PyExc_ValueError, query);
return NULL;
}
return NULL;
}
}
else
{
query = inQuery;
Py_INCREF(query);
}
if (iterable)
{
PRINTMARK();
escapedQuery = EscapeQueryArguments(self, query, iterable);
Py_DECREF(query);
if (escapedQuery == NULL)
{
if (!PyErr_Occurred())
{
return PyErr_Format(PyExc_RuntimeError, "Exception not set in EscapeQueryArguments chain");
}
return NULL;
}
}
else
{
escapedQuery = query;
}
ret = UMConnection_Query(self->conn, PyString_AS_STRING(escapedQuery), PyString_GET_SIZE(escapedQuery));
Py_DECREF(escapedQuery);
PRINTMARK();
if (ret == NULL)
{
return HandleError(self, "query");
}
PRINTMARK();
return (PyObject *) ret;
}
void ComputeParams(sParams* PB, item* memList, int32 value, int32 nbVal ) {
static int32 startAddress = 0;
static int32 shift = 0;
int32 size;
int32 size1;
int32 size2;
bool isRead;
bool isSeq;
printf("Generates %d.%d with param %d\n", PB->microBenchID, PB->expID, value);
if (strcasecmp(PB->base, "SR") == 0) {
PB->ignoreIO = PB->ignoreIOSR;
PB->IOCount = PB->IOCountSR;
isSeq = TRUE;
isRead = TRUE;
}
if (strcasecmp(PB->base, "SW") == 0) {
PB->ignoreIO = PB->ignoreIORR;
PB->IOCount = PB->IOCountRR;
isSeq = TRUE;
isRead = FALSE;
}
if (strcasecmp(PB->base, "RR") == 0) {
PB->ignoreIO = PB->ignoreIOSW;
PB->IOCount = PB->IOCountSW;
isSeq = FALSE;
isRead = TRUE;
}
if (strcasecmp(PB->base, "RW") == 0) {
PB->ignoreIO = PB->ignoreIORW;
PB->IOCount = PB->IOCountRW;
isSeq = FALSE;
isRead = FALSE;
}
PB->targetSize = PB->deviceSize; // Default value for target size
if (PB->microBenchID == GRA) PB->IOSize = value;
if (PB->microBenchID == ALI) PB->IOShift = value;
if (PB->microBenchID == LOC) PB->targetSize = value * PB->IOSize ;
if (PB->microBenchID == PAT) PB->nbPartition = value;
if (PB->microBenchID == ORD) PB->order = value;
if (PB->microBenchID == PAR) PB->parDeg = value;
if (PB->microBenchID == MIX) PB->ratio = value;
if (PB->microBenchID == PIO) PB->pauseIO = value;
if (PB->microBenchID == PBU) PB->burstIO = value;
// Number of sectors potentially touched by the experiment
size = PB->IOSize * PB->IOCount;
if (PB->IOShift != 0) size += PB->IOSize;
if (PB->microBenchID == LOC) size = PB->targetSize;
if (PB->microBenchID == ORD) size = PB->IOSize * abs(PB->order)* PB->IOCount;
// 1-GRANULARITY , 2-ALIGNMENT, 8-PAUSE, 9-BURST
if ((PB->microBenchID == GRA) || (PB->microBenchID == ALI)||
(PB->microBenchID == PIO)|| (PB->microBenchID == PBU)) {
if (isSeq == FALSE)
PB->targetOffset = 0;
else if (isRead == TRUE) {
PB->targetOffset = rg.IRandom(0,(int32)((PB->targetSize - size)/BLOCK))*BLOCK;
PB->targetSize = size;
}
else {
PB->targetOffset = MemSearch(memList, size);
PB->targetSize = size;
}
}
// 3-LOCALITY
else if (PB->microBenchID == LOC) {
if ((isRead == TRUE) || (value > 1024))
PB->targetOffset = rg.IRandom(0,(int32)((PB->deviceSize - size)/BLOCK))*BLOCK;
else {
PB->targetOffset = MemSearch(memList, size);
//printf("==>%d %d\n",size, PB->targetOffset );
}
}
// 07-MIX
else if (PB->microBenchID == MIX) {
int32 I1, I2, C1, C2;
I1 = PB->ignoreIO;
C1 = PB->IOCount;
if (strcasecmp(PB->base2, "SR") == 0) {
I2 = PB->ignoreIOSR;
C2 = PB->IOCountSR;
}
if (strcasecmp(PB->base2, "SW") == 0) {
I2 = PB->ignoreIOSW;
C2 = PB->IOCountSW;
}
if (strcasecmp(PB->base2, "RR") == 0) {
I2 = PB->ignoreIORR;
C2 = PB->IOCountRR;
}
if (strcasecmp(PB->base2, "RW") == 0) {
I2 = PB->ignoreIORW;
C2 = PB->IOCountRW;
}
if (PB->ratio < 0) {
PB->ignoreIO = max(I1 + (I1-1)*(-PB->ratio) + 1, I2 * (-PB->ratio + 1)/(-PB->ratio) + 1);
PB->IOCount = max(C1-I1, C2-I2) + PB->ignoreIO;
size1 = PB->IOSize * (1+ (int32)(PB->IOCount/(-PB->ratio + 1)));
size2 = PB->IOSize * (1+ (int32)((PB->IOCount/(-PB->ratio + 1)) * (-PB->ratio)));
}
else if (PB->ratio > 0) {
PB->ignoreIO = max(I2 + (I2-1) * PB->ratio + 1, (I1 * (PB->ratio + 1)/PB->ratio) + 1);
PB->IOCount = max(C1-I1, C2-I2) + PB->ignoreIO;
size1 = PB->IOSize * (1+ (int32)(PB->IOCount/(PB->ratio + 1)));
size2 = PB->IOSize * (1+ (int32)((PB->IOCount/(PB->ratio + 1)) * (PB->ratio)));
}
else {
PB->ignoreIO = I2;
PB->IOCount = C2;
size1 = 0;
size2 = PB->IOSize * PB->IOCount;
}
if (((strcasecmp(PB->base, "SR") == 0) && (strcasecmp(PB->base2, "RR") == 0)) ||
((strcasecmp(PB->base, "SR") == 0) && (strcasecmp(PB->base2, "RW") == 0))) {
PB->targetSize = size1;
PB->targetOffset = rg.IRandom(0,(int32)((PB->deviceSize - size1)/BLOCK))*BLOCK;
PB->targetOffset2 = 0;
PB->targetSize2 = PB->deviceSize;
}
if ((strcasecmp(PB->base, "RR") == 0) && (strcasecmp(PB->base2, "RW") == 0)) {
PB->targetSize = PB->deviceSize;
PB->targetOffset = 0;
PB->targetOffset2 = 0;
PB->targetSize2 = PB->deviceSize;
}
if ((strcasecmp(PB->base, "RR") == 0) && (strcasecmp(PB->base2, "SW") == 0)) {
PB->targetOffset2 = MemSearch(memList, size2);
PB->targetSize2 = size2;
PB->targetOffset = MemMinAddress(memList);
PB->targetSize = PB->deviceSize - PB->targetOffset;
}
if ((strcasecmp(PB->base, "SW") == 0) && (strcasecmp(PB->base2, "RW") == 0)) {
PB->targetOffset = MemSearch(memList, size1);
PB->targetSize = size1;
PB->targetOffset2 = MemMinAddress(memList);
PB->targetSize2 = PB->deviceSize - PB->targetOffset2;
}
if ((strcasecmp(PB->base, "SR") == 0) && (strcasecmp(PB->base2, "SW") == 0)) {
PB->targetOffset2 = MemSearch(memList, size2);
PB->targetSize2 = size2;
PB->targetOffset = rg.IRandom((int32)((PB->deviceSize - MemMinAddress(memList))/2)/BLOCK,(int32)((PB->deviceSize - size1)/BLOCK))*BLOCK;
PB->targetSize = size1;
}
}
// 6-PARALLELISM
else if (PB->microBenchID == PAR) {
PB->targetSize = ((int32)((PB->deviceSize / PB->parDeg)/BLOCK))*BLOCK;
if (isSeq == FALSE)
PB->targetOffset = PB->processID * PB->targetSize;
else if (isRead == TRUE) {
PB->targetOffset = rg.IRandom((PB->processID * PB->targetSize)/BLOCK,
((PB->processID + 1) * PB->targetSize - size)/BLOCK) * BLOCK;
PB->targetSize = size;
}
else { // SEQUENTIAL WRITE..... // CAUTION : PARALLEL EXPERIMENT MUST BE AFTER PARTITIONING
PB->targetSize = (PB->deviceSize - startAddress) / PB->parDeg;
if (PB->targetSize < size) HandleError("ComputeParam", "device too small", 0, ERR_ABORT);
PB->targetOffset = MemAllocNearestAfterA(memList, (PB->processID) * PB->targetSize + startAddress, size);
PB->targetSize = size;
}
}
// 4-PARTITIONING
else if (PB->microBenchID == PAT) {
if ((isRead == TRUE) || (PB->nbPartition > 16)) {
PB->targetOffset = 0;
PB->targetSize = ((int32) (PB->deviceSize/(MAX_PARTITIONS * BLOCK))) * MAX_PARTITIONS * BLOCK;
}
else { // SEQUENTIAL WRITE..... // CAUTION : PARTITIONNING EXPERIMENT MUST BE THE FIRST ...
if (startAddress == 0)
startAddress = MemMinAddress(memList);
if ((size % (16*BLOCK)) != 0)
size = ((int32) (size / (16*BLOCK)) + 1 ) * (16 * BLOCK);
PB->targetSize = PB->deviceSize - startAddress - size * nbVal * PB->nbRun;
PB->targetSize = (int32) (PB->targetSize/ (16 * BLOCK)) * (16 * BLOCK);
if (PB->targetSize < size) HandleError("ComputeParam", "device too small", 0, ERR_ABORT);
PB->targetOffset = startAddress + shift;
for (int32 k = 0; k < PB->nbPartition; ++k) {
long temp;
temp = MemAlloc(memList, PB->targetOffset + k * PB->targetSize/PB->nbPartition,
PB->targetOffset + k * PB->targetSize/PB->nbPartition + size/PB->nbPartition);
}
shift = shift + size/PB->nbPartition;
}
}
// 5-ORDER
else if (PB->microBenchID == ORD) {
size = PB->IOSize * PB->IOCount * PB->order;
if (size == 0) size = BLOCK;
PB->targetSize = abs(size);
if (isRead == TRUE) {
PB->targetOffset = rg.IRandom(0,(int32)((PB->deviceSize - PB->targetSize)/BLOCK))*BLOCK;
if (size < 0)
PB->targetOffset = PB->deviceSize - PB->targetOffset;
}
else {
PB->targetOffset = MemSearch(memList, abs(size));
if (PB->targetOffset == INT32_MAX) {
PB->targetOffset = rg.IRandom(0,(int32)((PB->deviceSize - abs(size))/BLOCK))*BLOCK;
PB->warning = DEVICE_TOO_SMALL;
OutputString(OUT_LOG, "DEVICE TOO SMALL \n");
}
if (size <0)
PB->targetOffset = PB->targetOffset - size;
}
}
if (PB->targetOffset == INT32_MAX) HandleError("ComputeParam", "device too small", 0, ERR_ABORT);
if ((PB->order >= 0) && (PB->targetOffset + PB->targetSize > PB->deviceSize)) {
char st[MAX_STR];
sprintf(st, "Adjusting TargetSize (TO = %d, TS = %d DS = %d\n", PB->targetOffset, PB->targetSize, PB->deviceSize);
PB->targetSize = PB->deviceSize - PB->targetOffset;
PB->warning = PB->warning | TEST_EXCEED_DEVICE;
OutputString(OUT_LOG, st);
}
if ((PB->order < 0) && (PB->targetOffset - PB->targetSize < 0)) {
char st[MAX_STR];
sprintf(st, "Adjusting TargetSize Reverse Order (TO = %d, TS = %d DS = %d\n", PB->targetOffset, PB->targetSize, PB->deviceSize); PB->targetSize = PB->targetOffset;
PB->warning = PB->warning | TEST_EXCEED_DEVICE;
OutputString(OUT_LOG, st);
}
}
void ScoreLoopThread::LoadLeaderboardCompletionCallback(void *userData, SC_Error_t completionStatus) {
/* Get the application from userData argument */
AppData_t *app = (AppData_t *) userData;
/* Check completion status */
if (completionStatus != SC_OK) {
SC_ScoresController_Release(app->scoresController); /* Cleanup Controller */
HandleError(app, completionStatus);
return;
}
/* Just log the scores here for demonstration purposes */
SC_ScoreList_h scoreList = SC_ScoresController_GetScores(app->scoresController);
if (scoreList == NULL) {
SC_ScoresController_Release(app->scoresController); /* Cleanup Controller */
HandleError(app, SC_NOT_FOUND);
return;
}
qDebug() << "Done loading Leaderboard";
/* Get the score formatter here - remember that you need to add a
* scoreloop/SLScoreFormatter.strings file to your asset files in order to retrieve a formatter.
*/
SC_ScoreFormatter_h scoreFormatter = SC_Client_GetScoreFormatter(app->client);
if (!scoreFormatter) {
SC_ScoresController_Release(app->scoresController); /* Cleanup Controller */
HandleError(app, SC_NOT_FOUND);
return;
}
QVariantList leaderboardData;
unsigned int i, numScores = SC_ScoreList_GetCount(scoreList);
for (i = 0; i < numScores; ++i) {
SC_Score_h score = SC_ScoreList_GetAt(scoreList, i);
SC_User_h user = SC_Score_GetUser(score);
SC_String_h login = user ? SC_User_GetLogin(user) : NULL;
SC_String_h formattedScore;
/* Format the score - we take ownership of string */
int rc = SC_ScoreFormatter_FormatScore(scoreFormatter, score, SC_SCORE_FORMAT_DEFAULT, &formattedScore);
if (rc != SC_OK) {
HandleError(app, rc);
return;
}
qDebug() << " Rank: " << SC_Score_GetRank(score) << ", Result: " << SC_String_GetData(formattedScore) << ", User: "******"<unknown>");
QVariantMap scoreData;
scoreData["rank"] = SC_Score_GetRank(score);
scoreData["formattedScore"] = SC_String_GetData(formattedScore);
scoreData["username"] = login ? SC_String_GetData(login) : "<unknown>";
leaderboardData.append(scoreData);
/* Release the string */
SC_String_Release(formattedScore);
}
emit(instance()->LoadLeaderboardCompleted(leaderboardData));
/* Cleanup Controller */
SC_ScoresController_Release(app->scoresController);
/* Set an Award as achieved here just for demonstration purposes */
//AchieveAward(app, SCORELOOP_AN_AWARD_ID);
}
void GenBench(sParams* PBBench) {
boolean finished = FALSE;
int32 prevExp = 0;
int32 currExp;
int32 numExp;
FILE* fp = NULL; // file pointer
FILE* fp2 = NULL; // file pointer
char str[MAX_STR];
int32 tabVal[MAX_VARYING_VAL];
sParams PBExp;
int32 nbVal;
item* memList;
bool tabSel[MAXBENCH*MAXMODE];
int32 nbExp = 0;
int32 key = 0;
parseSel(PBBench, tabSel);
// Allocate data structure for computing target offset
memList = InitMemList((int32)(PBBench->deviceSize));
fp2 = fopen(PBBench->outName, "w");
if (fp2 == NULL) HandleError("GenBench", "Could not open output file", GetLastError(), ERR_ABORT);
while (finished == FALSE) {
// find the next experiment - it is the smallest numExp, greater than prevExp
if ((fp = fopen(PBBench->expPlan, "r")) == NULL )
HandleError("GenBench", "Cannot open experimentation plan file", GetLastError(), ERR_ABORT);
currExp = INT32_MAX;
while (fgets(str, MAX_STR,fp) != NULL) {
numExp = atoi(str);
if ((numExp > prevExp) && (numExp < currExp)) {
currExp = numExp;
}
}
if ((currExp > prevExp) && (currExp != INT32_MAX)) {
printf("=================== Order Number %d\n", currExp);
//New param structure
InitParams(&PBExp);
PBExp.deviceNum = PBBench->deviceNum;
PBExp.IOSize = PBBench->IOSize;
PBExp.IOCount = PBBench->IOCount;
PBExp.IOCountSR = PBBench->IOCountSR;
PBExp.IOCountRR = PBBench->IOCountRR;
PBExp.IOCountSW = PBBench->IOCountSW;
PBExp.IOCountRW = PBBench->IOCountRW;
PBExp.ignoreIO = PBBench->ignoreIO;
PBExp.ignoreIOSR = PBBench->ignoreIOSR;
PBExp.ignoreIORR = PBBench->ignoreIORR;
PBExp.ignoreIOSW = PBBench->ignoreIOSW;
PBExp.ignoreIORW = PBBench->ignoreIORW;
PBExp.collectErase = PBBench->collectErase;
PBExp.pauseExp = PBBench->pauseExp;
PBExp.fake = PBBench->fake;
PBExp.bufferType = PBBench->bufferType;
PBExp.deviceSize = PBBench->deviceSize;
PBExp.burstIO = PBBench->burstIO;
PBExp.nbRun = PBBench->nbRun;
// parse the experiment
nbVal = parseExp(fp, currExp, &PBExp, tabVal);
if (tabSel[(PBExp.microBenchID - 1) * MAXMODE + PBExp.expID - 1] == TRUE) {
for (int32 exp = 0; exp < nbVal; ++exp) {
// Compute the different parameters
if (PBExp.microBenchID == PAR) {
for (PBExp.runID = 0; PBExp.runID < PBExp.nbRun; (PBExp.runID)++) {
PBExp.parDeg = tabVal[exp];
for (int32 pID = 0; pID < PBExp.parDeg; ++pID) {
PBExp.processID = PBExp.parDeg - pID - 1;
PBExp.key = key++;
ComputeParams(&PBExp, memList,PBExp.parDeg, nbVal );
GenExp(fp2, &PBExp);
nbExp++;
PBExp.IOSize = PBBench->IOSize;
PBExp.IOCount = PBBench->IOCount;
PBExp.ignoreIO = PBBench->ignoreIO;
}
}
}
else {
for (PBExp.runID = 0; PBExp.runID < PBExp.nbRun; (PBExp.runID)++) {
PBExp.key = key++;
ComputeParams(&PBExp, memList, tabVal[exp], nbVal);
GenExp(fp2, &PBExp);
nbExp ++;
PBExp.IOSize = PBBench->IOSize;
PBExp.IOCount = PBBench->IOCount;
PBExp.ignoreIO = PBBench->ignoreIO;
}
}
}
}
else
printf("=================== Not Selected\n");
fprintf(fp2, "\n");
}
else finished = TRUE;
prevExp = currExp;
if (fp) fclose(fp);
}
fclose(fp2); // close the output file if we opened it
while (memList) {
item *tmp = memList->next;
free(memList);
memList = tmp;
}
sprintf(str, "%d Experiments have been generated\n", nbExp);
OutputString(OUT_LOG, str);
}
void ScoreLoopThread::run() {
qDebug() << "ScoreLoopThread run() started";
AppData_t app;
SC_InitData_t initData;
SC_Error_t rc;
char versionBuffer[0x100]; /* Thats 256 bytes */
qDebug() << "Starting Scoreloop Sample...";
/* Initialize the BPS event system */
bps_initialize();
bps_set_verbosity(0); /* Set to 1 or 2 for more output if you like */
memset(&app, 0, sizeof(AppData_t));
/* Initialize the Scoreloop platform dependent SC_InitData_t structure to default values. */
SC_InitData_Init(&initData);
/* What version of the Scoreloop library do we use? */
if (SC_GetVersionInfo(&initData, versionBuffer, sizeof(versionBuffer))) {
qDebug() << "Version-Info: " << versionBuffer;
}
/* Now, create the Scoreloop Client with the initialized SC_InitData_t structure
* as well as the game-id and game-secret as found on the developer portal.
*/
rc = SC_Client_New(&app.client, &initData, SCORELOOP_GAME_ID, SCORELOOP_GAME_SECRET, SCORELOOP_GAME_VERSION, SCORELOOP_GAME_CURRENCY, SCORELOOP_GAME_LANGUAGE);
if (rc != SC_OK) {
HandleError(&app, rc);
} else {
//InformUser(&app, "Note", "Scoreloop Sample started...");
/* Request the user here just for demonstration purposes */
RequestUser(&app);
}
while (!m_quit) {
/* Get next BPS event */
bps_event_t *event;
bps_get_event(&event, -1);
/* Scoreloop event handling */
if (bps_event_get_domain(event) == SC_GetBPSEventDomain(&initData)) {
SC_HandleBPSEvent(&initData, event);
}
else if (bps_event_get_domain(event) == dialog_get_domain()) {
dialog_destroy(dialog_event_get_dialog_instance(event));
app.dialog = 0;
}
/* Add more BPS event handling here... */
}
/* Cleanup the Scoreloop client */
SC_Client_Release(app.client);
/* Shutdown BPS */
bps_shutdown();
qDebug() << "SensorsThread run() finished.";
}
