void SourceInfo::load() {
Lock lock(m_mutex);
if (!m_loaded) {
loadImpl(m_cpp2php, g_source_info);
loadImpl(m_cls2file, m_file2cls, g_source_cls2file);
loadImpl(m_func2file, m_file2func, g_source_func2file);
m_source_root_len = strlen(g_source_root);
m_loaded = true;
}
}
void SettingsWidget::load()
{
p->sleep = true;
loadImpl();
p->clearValues();
p->sleep = false;
}
bool gkShader::loadImpl( void )
{
// 现在是最简单的调用内部的loadImpl [9/17/2010 Kaiming-Laptop]
IDirect3DDevice9* pDevice = getRenderer()->getDevice();
ID3DXEffectPool** ppPool = getRenderer()->getEffectPoolPointer();
return loadImpl(pDevice, ppPool);
}
HeightMapInterface* AbstractHeightMapManager::getHeightMapOfTile(Tile* tile) {
if (tileMap.find(tile->getId()) != tileMap.end()) {
return tileMap[tile->getId()]; //cache hit
}
//load and save
std::string fileName = generateFileName(tile);
HeightMapInterface* h = loadImpl(fileName);
if(h) {
PRINTD(INFO, "found saved heightmap at %s\n",fileName.c_str());
} else {
PRINTD(INFO, "creating heightmap for tile %s\n",tile->getName().c_str());
h = createImpl(tile);
if(h) { //save to disk
if(!saveImpl(h, fileName))
PRINTD(WARNING, "can't save heightmap of tile %s to %s\n",tile->getName().c_str(), fileName.c_str());
}
}
if(h) { //save in cache -> TODO what about locks?
tileMap[tile->getId()] = h;
return h;
} else {
PRINTD(WARNING, "can't neighter load or create heightmap for tile %s\n",tile->getName().c_str());
return NULL;
}
}
void Sound::load(bool wait) throw(Exception)
{
if (!isLoaded()) {
if (!isLoading())
loadImpl(wait);
if (wait && !isLoaded())
waitLoad();
}
}
/*!
Public wrapper to loadImpl.
*/
int HomeDir::load ()
{
int ret;
loadMutex.lock ();
try
{
ret = loadImpl ();
loadMutex.unlock ();
}
catch (...)
{
loadMutex.unlock ();
throw;
}
return ret;
}
//---------------------------------------------------------------------
void Page::handleResponse(const WorkQueue::Response* res, const WorkQueue* srcQ)
{
// Main thread
PageResponse pres = any_cast<PageResponse>(res->getData());
PageRequest preq = any_cast<PageRequest>(res->getRequest()->getData());
// only deal with own requests
if (preq.srcPage!= this)
return;
// final loading behaviour
if (res->succeeded())
{
std::swap(mContentCollections, pres.pageData->collectionsToAdd);
loadImpl();
}
OGRE_DELETE pres.pageData;
mDeferredProcessInProgress = false;
}
HeightMapInterface* AbstractHeightMapManager::load(std::string fileName) {
return loadImpl(fileName);
}
MojErr MojDb::load(const MojChar* path, MojUInt32& countOut, MojUInt32 flags, MojDbReqRef req)
{
MojAssert(path);
MojLogTrace(s_log);
MojErr err = beginReq(req, true);
MojErrCheck(err);
MojFile file;
err = file.open(path, MOJ_O_RDONLY);
MojErrCheck(err);
MojJsonParser parser;
parser.begin();
MojSize bytesRead = 0;
MojObjectBuilder visitor;
int total_mutexes, mutexes_free, mutexes_used, mutexes_used_highwater, mutex_regionsize;
m_objDb->mutexStats(&total_mutexes, &mutexes_free, &mutexes_used, &mutexes_used_highwater, &mutex_regionsize);
MojLogDebug(s_log, _T("Starting load of %s, total_mutexes: %d, mutexes_free: %d, mutexes_used: %d, mutexes_used_highwater: %d, &mutex_regionsize: %d\n"),
path, total_mutexes, mutexes_free, mutexes_used, mutexes_used_highwater, mutex_regionsize);
int orig_mutexes_used = mutexes_used;
struct timeval startTime = {0,0}, stopTime = {0,0};
gettimeofday(&startTime, NULL);
int total_transaction_time = 0;
int total = 0;
int transactions = 0;
do {
MojChar buf[MojFile::MojFileBufSize];
err = file.read(buf, sizeof(buf), bytesRead);
MojErrCheck(err);
const MojChar* parseEnd = buf;
while (parseEnd < (buf + bytesRead)) {
err = parser.parseChunk(visitor, parseEnd, bytesRead - (parseEnd - buf), parseEnd);
MojErrCheck(err);
if (parser.finished()) {
//store the object
err = loadImpl(visitor.object(), flags, req);
MojErrCheck(err);
countOut++;
parser.begin();
visitor.reset();
total++;
if ((total % 10) == 0) {
// For debugging mutex consumption during load operations, we periodically retrieve the mutex stats.
m_objDb->mutexStats(&total_mutexes, &mutexes_free, &mutexes_used, &mutexes_used_highwater, &mutex_regionsize);
MojLogDebug(s_log, _T("Loading %s record %d, total_mutexes: %d, mutexes_free: %d, mutexes_used: %d, mutexes_used_highwater: %d, &mutex_regionsize: %d\n"),
path, total, total_mutexes, mutexes_free, mutexes_used, mutexes_used_highwater, mutex_regionsize);
}
// If a loadStepSize is configured, then break up the load into separate transactions.
// This is intended to prevent run-away mutex consumption in some particular scenarios.
// The transactions do not reverse or prevent mutex consumption, but seem to reduce the
// growth and eventually cause it to level off.
if ((m_loadStepSize > 0) && ((total % m_loadStepSize) == 0)) {
// Close and reopen transaction, to prevent a very large transaction from building up.
MojLogDebug(s_log, _T("Loading %s record %d, closing and reopening transaction.\n"),
path, total);
struct timeval transactionStartTime = {0,0}, transactionStopTime = {0,0};
gettimeofday(&transactionStartTime, NULL);
err = req->end();
MojErrCheck(err);
err = req->endBatch();
MojErrCheck(err);
req->beginBatch(); // beginBatch() invocation for first transaction happened in MojDbServiceHandlerBase::invokeImpl
err = beginReq(req, true);
MojErrCheck(err);
gettimeofday(&transactionStopTime, NULL);
long int elapsedTransactionTimeMS = (transactionStopTime.tv_sec - transactionStartTime.tv_sec) * 1000 +
(transactionStopTime.tv_usec - transactionStartTime.tv_usec) / 1000;
total_transaction_time += (int)elapsedTransactionTimeMS;
transactions++;
}
}
}
} while (bytesRead > 0);
err = parser.end(visitor);
MojErrCheck(err);
if (parser.finished()) {
err = loadImpl(visitor.object(), flags, req);
MojErrCheck(err);
countOut++;
} else if (bytesRead > 0) {
MojErrThrow(MojErrJsonParseEof);
}
err = req->end();
MojErrCheck(err);
gettimeofday(&stopTime, NULL);
long int elapsedTimeMS = (stopTime.tv_sec - startTime.tv_sec) * 1000 +
(stopTime.tv_usec - startTime.tv_usec) / 1000;
m_objDb->mutexStats(&total_mutexes, &mutexes_free, &mutexes_used, &mutexes_used_highwater, &mutex_regionsize);
MojLogDebug(s_log, _T("Finished load of %s, total_mutexes: %d, mutexes_free: %d, mutexes_used: %d, mutexes_used_highwater: %d, &mutex_regionsize: %d\n"),
path, total_mutexes, mutexes_free, mutexes_used, mutexes_used_highwater, mutex_regionsize);
MojLogDebug(s_log, _T("Loaded %s with %d records in %ldms (%dms of that for %d extra transactions), consuming %d mutexes, afterwards %d are available out of %d\n"),
path, total, elapsedTimeMS, total_transaction_time, transactions, mutexes_used - orig_mutexes_used, mutexes_free, total_mutexes);
return MojErrNone;
}
void PopupAppearance::cancelImpl()
{
loadImpl();
}
void DataSettingsObject::cancelImpl()
{
loadImpl();
}
void NotificationSettings::cancelImpl()
{
loadImpl();
}
void IcqMainSettings::cancelImpl()
{
loadImpl();
}
void DataSettingsWidget::cancelImpl()
{
loadImpl();
}
void IconLoaderSettings::cancelImpl()
{
loadImpl();
}
void DataSettingsObject::load()
{
loadImpl();
}
void SharedLibrary::load(const std::string& path)
{
loadImpl(path);
}
virtual void load(void* object, const sol::object& luaObject) const
{
loadImpl(reinterpret_cast<C*>(object), luaObject);
}
void clams::StreamSequenceBase::load (const std::string &root_path)
{
loadImpl (root_path);
root_path_ = root_path;
}
//---------------------------------------------------------------------
void Resource::load(bool background)
{
// Early-out without lock (mitigate perf cost of ensuring loaded)
// Don't load if:
// 1. We're already loaded
// 2. Another thread is loading right now
// 3. We're marked for background loading and this is not the background
// loading thread we're being called by
if (mIsBackgroundLoaded && !background) return;
// This next section is to deal with cases where 2 threads are fighting over
// who gets to prepare / load - this will only usually happen if loading is escalated
bool keepChecking = true;
LoadingState old;
while (keepChecking)
{
// quick check that avoids any synchronisation
old = mLoadingState.get();
if ( old == LOADSTATE_PREPARING )
{
while( mLoadingState.get() == LOADSTATE_PREPARING )
{
OGRE_LOCK_AUTO_MUTEX
}
old = mLoadingState.get();
}
if (old!=LOADSTATE_UNLOADED && old!=LOADSTATE_PREPARED && old!=LOADSTATE_LOADING) return;
// atomically do slower check to make absolutely sure,
// and set the load state to LOADING
if (old==LOADSTATE_LOADING || !mLoadingState.cas(old,LOADSTATE_LOADING))
{
while( mLoadingState.get() == LOADSTATE_LOADING )
{
OGRE_LOCK_AUTO_MUTEX
}
LoadingState state = mLoadingState.get();
if( state == LOADSTATE_PREPARED || state == LOADSTATE_PREPARING )
{
// another thread is preparing, loop around
continue;
}
else if( state != LOADSTATE_LOADED )
{
OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Another thread failed in resource operation",
"Resource::load");
}
return;
}
keepChecking = false;
}
// Scope lock for actual loading
try
{
OGRE_LOCK_AUTO_MUTEX
if (mIsManual)
{
preLoadImpl();
// Load from manual loader
if (mLoader)
{
mLoader->loadResource(this);
}
else
{
// Warn that this resource is not reloadable
LogManager::getSingleton().stream(LML_TRIVIAL)
<< "WARNING: " << mCreator->getResourceType()
<< " instance '" << mName << "' was defined as manually "
<< "loaded, but no manual loader was provided. This Resource "
<< "will be lost if it has to be reloaded.";
}
postLoadImpl();
}
else
{
if (old==LOADSTATE_UNLOADED)
prepareImpl();
preLoadImpl();
old = LOADSTATE_PREPARED;
if (mGroup == ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME)
{
// Derive resource group
changeGroupOwnership(
ResourceGroupManager::getSingleton()
.findGroupContainingResource(mName));
}
loadImpl();
postLoadImpl();
}
// Calculate resource size
mSize = calculateSize();
}
catch (...)
{
// Reset loading in-progress flag, in case failed for some reason.
// We reset it to UNLOADED because the only other case is when
// old == PREPARED in which case the loadImpl should wipe out
// any prepared data since it might be invalid.
mLoadingState.set(LOADSTATE_UNLOADED);
// Re-throw
throw;
}
mLoadingState.set(LOADSTATE_LOADED);
_dirtyState();
// Notify manager
if(mCreator)
mCreator->_notifyResourceLoaded(this);
// Fire (deferred) events
if (mIsBackgroundLoaded)
queueFireBackgroundLoadingComplete();
}
//-----------------------------------------------------------------------
void Resource::load(bool background)
{
// Early-out without lock (mitigate perf cost of ensuring loaded)
// Don't load if:
// 1. We're already loaded
// 2. Another thread is loading right now
// 3. We're marked for background loading and this is not the background
// loading thread we're being called by
if (mLoadingState != LOADSTATE_UNLOADED || (mIsBackgroundLoaded && !background))
return;
// Scope lock over load status
{
OGRE_LOCK_MUTEX(mLoadingStatusMutex)
// Check again just in case status changed (since we didn't lock above)
if (mLoadingState != LOADSTATE_UNLOADED || (mIsBackgroundLoaded && !background))
{
// no loading to be done
return;
}
mLoadingState = LOADSTATE_LOADING;
}
// Scope lock for actual loading
try
{
OGRE_LOCK_AUTO_MUTEX
preLoadImpl();
if (mIsManual)
{
// Load from manual loader
if (mLoader)
{
mLoader->loadResource(this);
}
else
{
// Warn that this resource is not reloadable
LogManager::getSingleton().logMessage(
"WARNING: " + mCreator->getResourceType() +
" instance '" + mName + "' was defined as manually "
"loaded, but no manual loader was provided. This Resource "
"will be lost if it has to be reloaded.");
}
}
else
{
if (mGroup == ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME)
{
// Derive resource group
changeGroupOwnership(
ResourceGroupManager::getSingleton()
.findGroupContainingResource(mName));
}
loadImpl();
}
// Calculate resource size
mSize = calculateSize();
postLoadImpl();
}
catch (...)
{
// Reset loading in-progress flag in case failed for some reason
OGRE_LOCK_MUTEX(mLoadingStatusMutex)
mLoadingState = LOADSTATE_UNLOADED;
// Re-throw
throw;
}
// Scope lock for loading progress
{
OGRE_LOCK_MUTEX(mLoadingStatusMutex)
// Now loaded
mLoadingState = LOADSTATE_LOADED;
}
// Notify manager
if(mCreator)
mCreator->_notifyResourceLoaded(this);
// Fire (deferred) events
if (mIsBackgroundLoaded)
queueFireBackgroundLoadingComplete();
}