void MipsJit::Compile(u32 em_address) {
PROFILE_THIS_SCOPE("jitc");
if (GetSpaceLeft() < 0x10000 || blocks.IsFull()) {
ClearCache();
}
int block_num = blocks.AllocateBlock(em_address);
JitBlock *b = blocks.GetBlock(block_num);
DoJit(em_address, b);
blocks.FinalizeBlock(block_num, jo.enableBlocklink);
bool cleanSlate = false;
if (js.hasSetRounding && !js.lastSetRounding) {
WARN_LOG(JIT, "Detected rounding mode usage, rebuilding jit with checks");
// Won't loop, since hasSetRounding is only ever set to 1.
js.lastSetRounding = js.hasSetRounding;
cleanSlate = true;
}
if (cleanSlate) {
// Our assumptions are all wrong so it's clean-slate time.
ClearCache();
Compile(em_address);
}
}
void c4_HandlerSeq::DetachFromStorage(bool full_)
{
if (_persist != 0) {
int limit = full_ ? 0 : NumFields();
// get rid of all handlers which might do I/O
for (int c = NumHandlers(); --c >= 0;) {
c4_Handler &h = NthHandler(c);
// all nested fields are detached recursively
if (IsNested(c))
for (int r = 0; r < NumRows(); ++r)
if (h.HasSubview(r)) {
SubEntry(c, r).DetachFromStorage(full_);
}
if (c >= limit) {
if (h.IsPersistent()) {
delete &h;
_handlers.RemoveAt(c);
ClearCache();
}
}
}
if (full_) {
//UnmappedAll();
_persist = 0;
}
}
}
STDMETHODIMP CEtsDivColl::Clone(IEtsDivColl** ppVal)
{
HRESULT hr = S_OK;
__CHECK_POINTER(ppVal);
try
{
ClearCache();
IEtsDivCollPtr spColl;
CComObject<CEtsDivColl>* pColl = NULL;
_CHK(CComObject<CEtsDivColl>::CreateInstance(&pColl));
spColl.Attach(pColl, TRUE);
if(!m_DivColl.empty())
{
EnumIterType itr = m_DivColl.begin();
while(itr!=m_DivColl.end())
{
pColl->m_DivColl.insert(*itr);
++itr;
}
}
*ppVal = spColl.Detach();
}
catch (_com_error& e)
{
hr = Error((PTCHAR)EgLib::CComErrorWrapper::ErrorDescription(e), IID_IEtsDivColl, e.Error());
}
return hr;
}
bool Unitsync::LoadUnitSyncLib(const std::string& unitsyncloc)
{
LOCK_UNITSYNC;
ClearCache();
const bool ret = susynclib().Load(unitsyncloc);
if (!ret) {
return false;
}
const std::string datadir = LSL::Util::config().GetDataDir();
const std::string curdatadir = susynclib().GetSpringDataDir();
if (datadir != curdatadir) {
LslWarning("Reloading unitsync due to datadir change: %s -> %s", curdatadir.c_str(), datadir.c_str());
SetSpringDataPath(datadir);
susynclib().Load(unitsyncloc);
}
supportsManualUnLoad = LSL::susynclib().GetSpringConfigInt("UnitsyncAutoUnLoadMapsIsSupported", 0) != 0;
if (supportsManualUnLoad) {
LslDebug("Unitsync supports manual loading of archives (faster, yey!)");
LSL::usync().SetSpringConfigInt("UnitsyncAutoUnLoadMaps", 1);
} else {
LslDebug("Unitsync doesn't support manual loading of archives :-/");
}
m_cache_path = LSL::Util::config().GetCachePath();
PopulateArchiveList();
return true;
}
Unitsync::~Unitsync()
{
ClearCache();
delete m_cache_thread;
m_cache_thread = NULL;
Cache::FreeInstance();
}
void ImgCell::Draw(CellParser& parser, wxPoint point, int fontsize)
{
wxDC& dc = parser.GetDC();
if (DrawThisCell(parser, point) && m_image != NULL)
{
wxMemoryDC bitmapDC;
double scale = parser.GetScale();
m_image->ViewportSize(m_canvasSize.x,m_canvasSize.y,scale);
m_height = (m_image->m_height) + 2 * m_imageBorderWidth;
m_width = (m_image->m_width) + 2 * m_imageBorderWidth;
SetPen(parser);
if (m_drawRectangle)
dc.DrawRectangle(wxRect(point.x, point.y - m_center, m_width, m_height));
wxBitmap bitmap = m_image->GetBitmap();
bitmapDC.SelectObject(bitmap);
dc.Blit(point.x + m_imageBorderWidth, point.y - m_center + m_imageBorderWidth, m_width - 2 * m_imageBorderWidth, m_height - 2 * m_imageBorderWidth, &bitmapDC, 0, 0);
}
else
// The cell isn't drawn => No need to keep it's image cache for now.
ClearCache();
MathCell::Draw(parser, point, fontsize);
}
void SlideShow::MarkAsDeleted()
{
// Stop and unregister the timer.
StopTimer();
ClearCache();
Cell::MarkAsDeleted();
}
c4_HandlerSeq::~c4_HandlerSeq()
{
const bool rootLevel = _parent == this;
c4_Persist *pers = _persist;
if (rootLevel && pers != 0) {
pers->DoAutoCommit();
}
DetachFromParent();
DetachFromStorage(true);
for (int i = 0; i < NumHandlers(); ++i) {
delete &NthHandler(i);
}
_handlers.SetSize(0);
ClearCache();
if (rootLevel) {
delete _field;
d4_assert(pers != 0);
delete pers;
}
}
ChEXPORT SsrwOOCacheStream::SsrwOOCacheStream(Stream* in_pStream)
{
ChLOG_DEBUG_START_FN;
m_pStream = in_pStream;
m_pStringTmp = NULL;
ClearCache();
}
BoxBrowser::~BoxBrowser()
{
for( int i = 0; i < NUM_BOXES; i++ )
{
delete box[ i ];
}
delete gameText;
// delete zIdTxt;
delete noCoverdata;
ClearCache();
if( bgImg1 )
delete bgImg1;
if( bgImg2 )
delete bgImg2;
// if( ratingImg )
// delete ratingImg;
// if( ratingImgData )
// delete ratingImgData;
}
//shifts the image datas to a different box and shifts the index
void BoxBrowser::Shift( int num )
{
//shift list index
listIdx -= num;
if( listIdx >= GameList::Count() )
{
listIdx = 0;
}
else if( listIdx < 0 )
{
listIdx = GameList::Count() - 1;
}
// check cache size
// probably could be more elegant than this, but this should work for now
if( coverImg.size() + abs(num) > BB_MAX_CACHE )
ClearCache( false );
//assign new image to boxes
int lOff = ( NUM_BOXES / 2 );
for( int i = 0; i < NUM_BOXES; i++ )
{
u32 cvrIdx = ( ( ( listIdx ) + i ) % GameList::Count() );
box[ i ]->SetImage( Get( cvrIdx ) );
if( i == lOff )
{
//set title text
currentSelection = cvrIdx;
gameText->SetText( GameList::Name( currentSelection ).c_str() );
}
}
//RsxMem::PrintInfo( true );
}
const FileStatusCacheEntry * GitFolderStatus::GetCachedItem(const CTGitPath& filepath)
{
sCacheKey.assign(filepath.GetWinPath());
FileStatusMap::const_iterator iter;
const FileStatusCacheEntry *retVal;
if(m_mostRecentPath.IsEquivalentTo(CTGitPath(sCacheKey.c_str())))
{
// We've hit the same result as we were asked for last time
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": fast cache hit for %s\n"), filepath.GetWinPath());
retVal = m_mostRecentStatus;
}
else if ((iter = m_cache.find(sCacheKey)) != m_cache.end())
{
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": cache found for %s\n"), filepath.GetWinPath());
retVal = &iter->second;
m_mostRecentStatus = retVal;
m_mostRecentPath = CTGitPath(sCacheKey.c_str());
}
else
{
retVal = NULL;
}
if(retVal != NULL)
{
// We found something in a cache - check that the cache is not timed-out or force-invalidated
DWORD now = GetTickCount();
if ((now >= m_TimeStamp)&&((now - m_TimeStamp) > GetTimeoutValue()))
{
// Cache is timed-out
CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Cache timed-out\n");
ClearCache();
retVal = NULL;
}
else if(WaitForSingleObject(m_hInvalidationEvent, 0) == WAIT_OBJECT_0)
{
// TortoiseGitProc has just done something which has invalidated the cache
CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Cache invalidated\n");
ClearCache();
retVal = NULL;
}
return retVal;
}
return NULL;
}
void SlideShow::Draw(wxPoint point)
{
Cell::Draw(point);
// If the animation leaves the screen the timer is stopped automatically.
if(m_animationRunning)
ReloadTimer();
if (DrawThisCell(point) && (m_images[m_displayed] != NULL))
{
// Start the timer once the animation appears on the screen.
// But start it only once: Else the animation could be refreshed
// more frequent than it can be drawn. Each update of the animation
// will trigger this function and will trigger the animation to be
// restarted anyway.
//
Configuration *configuration = (*m_configuration);
if(configuration->GetPrinting()) {
m_images[m_displayed]->Recalculate(configuration->GetZoomFactor() * PRINT_SIZE_MULTIPLIER);
} else {
m_images[m_displayed]->Recalculate();
}
if (!InUpdateRegion()) return;
wxDC *dc = configuration->GetDC();
wxMemoryDC bitmapDC;
// Slide show cells have a red border except if they are selected
if (m_drawBoundingBox)
dc->SetPen(*(wxThePenList->FindOrCreatePen(configuration->GetColor(TS_SELECTION))));
else
dc->SetPen(*wxRED_PEN);
dc->DrawRectangle(wxRect(point.x, point.y - m_center, m_width, m_height));
wxBitmap bitmap = (configuration->GetPrinting() ? m_images[m_displayed]->GetBitmap(configuration->GetZoomFactor() * PRINT_SIZE_MULTIPLIER) : m_images[m_displayed]->GetBitmap());
bitmapDC.SelectObject(bitmap);
int imageBorderWidth = m_imageBorderWidth;
if (m_drawBoundingBox)
{
imageBorderWidth = Scale_Px(3);
dc->SetBrush(*(wxTheBrushList->FindOrCreateBrush(configuration->GetColor(TS_SELECTION))));
dc->DrawRectangle(wxRect(point.x, point.y - m_center, m_width, m_height));
}
dc->Blit(point.x + imageBorderWidth, point.y - m_center + imageBorderWidth,
m_width - 2 * imageBorderWidth, m_height - 2 * imageBorderWidth,
&bitmapDC,
imageBorderWidth - m_imageBorderWidth, imageBorderWidth - m_imageBorderWidth);
}
else
// The cell isn't drawn => No need to keep it's image cache for now.
ClearCache();
// If we need a selection border on another redraw we will be informed by OnPaint() again.
m_drawBoundingBox = false;
}
void MEmblemMgr::Destroy()
{
if (CheckSaveFlag())
SaveCache();
ClearCache();
m_HttpSpooler.Destroy();
}
ProfileManager::~ProfileManager()
{
// If the profiles have been altered then write out the profile file
if (Changed)
SaveCache();
ClearCache();
}
EXPORT_C void CHuiFxEngine::SetMemoryLevel(THuiMemoryLevel aLevel)
{
iLowGraphicsMemoryMode = aLevel;
if(iLowGraphicsMemoryMode < EHuiMemoryLevelReduced)
{
ClearCache();
}
}
void Core_Imp::DrawSceneToWindowWithTransition(CoreScene* nextScene, CoreScene* previousScene, CoreTransition* transition)
{
auto t = (CoreTransition_Imp*) transition;
m_graphics->SetRenderTarget(nullptr, nullptr);
t->DrawCache(layerRenderer, nextScene, previousScene);
t->ClearCache();
}
c4_Sequence::~c4_Sequence() {
d4_assert(_refCount == 0);
d4_assert(!_dependencies); // there can be no dependencies left
ClearCache();
delete _tempBuf;
}
void LexicalReorderingTableTree::InitializeForInput(const InputType& input){
ClearCache();
if(ConfusionNet const* cn = dynamic_cast<ConfusionNet const*>(&input)){
Cache(*cn);
} else if(Sentence const* s = dynamic_cast<Sentence const*>(&input)){
// Cache(*s); ... this just takes up too much memory, we cache elsewhere
DisableCache();
}
};
void SsrwOOCacheStream::ClearCacheAndResync()
{
if (m_bytesCached>0)
{
unsigned long pos = this->getPos(); // find out where we think we are in the stream
ClearCache();
this->raw_seek(pos, SsrwOO_START); // and get the underlying stream to the right point
}
}
bool
TopographyFile::Update(const WindowProjection &map_projection)
{
if (IsEmpty())
return false;
if (map_projection.GetMapScale() > scale_threshold)
/* not visible, don't update cache now */
return false;
const GeoBounds screenRect =
map_projection.GetScreenBounds();
if (cache_bounds.IsValid() && cache_bounds.IsInside(screenRect))
/* the cache is still fresh */
return false;
cache_bounds = map_projection.GetScreenBounds().Scale(fixed(2));
rectObj deg_bounds = ConvertRect(cache_bounds);
// Test which shapes are inside the given bounds and save the
// status to file.status
msShapefileWhichShapes(&file, dir, deg_bounds, 0);
// If not a single shape is inside the bounds
if (!file.status) {
// ... clear the whole buffer
ClearCache();
return false;
}
// Iterate through the shapefile entries
const ShapeList **current = &first;
auto it = shapes.begin();
for (int i = 0; i < file.numshapes; ++i, ++it) {
if (!msGetBit(file.status, i)) {
// If the shape is outside the bounds
// delete the shape from the cache
delete it->shape;
it->shape = NULL;
} else {
// is inside the bounds
if (it->shape == NULL)
// shape isn't cached yet -> cache the shape
it->shape = new XShape(&file, i, label_field);
// update list pointer
*current = it;
current = &it->next;
}
}
// end of list marker
*current = NULL;
++serial;
return true;
}
void cImage::Allocate( const Uint32& size, eeColorA DefaultColor, bool memsetData ) {
ClearCache();
mPixels = eeNewArray( unsigned char, size );
mSize = size;
if ( memsetData ) {
memset( mPixels, (int)DefaultColor.GetValue(), size );
}
}
NS_IMETHODIMP nsXULTreeAccessible::Shutdown()
{
nsXULSelectableAccessible::Shutdown();
if (mAccessNodeCache) {
ClearCache(*mAccessNodeCache);
delete mAccessNodeCache;
mAccessNodeCache = nsnull;
}
return NS_OK;
}
void *Z_Malloc(int size, int tag, void *user)
{
memblock_t *newblock;
unsigned char *data;
void *result;
if (tag < 0 || tag >= PU_NUM_TAGS || tag == PU_FREE)
{
I_Error("Z_Malloc: attempted to allocate a block with an invalid "
"tag: %i", tag);
}
if (user == NULL && tag >= PU_PURGELEVEL)
{
I_Error ("Z_Malloc: an owner is required for purgable blocks");
}
// Malloc a block of the required size
newblock = NULL;
while (newblock == NULL)
{
newblock = (memblock_t *) malloc(sizeof(memblock_t) + size);
if (newblock == NULL)
{
if (!ClearCache(sizeof(memblock_t) + size))
{
I_Error("Z_Malloc: failed on allocation of %i bytes", size);
}
}
}
newblock->tag = tag;
// Hook into the linked list for this tag type
newblock->id = ZONEID;
newblock->user = user;
newblock->size = size;
Z_InsertBlock(newblock);
data = (unsigned char *) newblock;
result = data + sizeof(memblock_t);
if (user != NULL)
{
*newblock->user = result;
}
return result;
}
SpriteRenderer3D::~SpriteRenderer3D()
{
ClearCache();
m_vertexBuffer.reset();
m_indexBuffer.reset();
m_shader_nt.reset();
m_shader.reset();
SafeRelease(m_graphics);
}
void Jit::Compile(u32 em_address)
{
if (GetSpaceLeft() < 0x10000 || blocks.IsFull())
{
ClearCache();
}
int block_num = blocks.AllocateBlock(em_address);
JitBlock *b = blocks.GetBlock(block_num);
blocks.FinalizeBlock(block_num, jo.enableBlocklink, DoJit(em_address, b));
}
ConvexTriangleCallback::ConvexTriangleCallback(Dispatcher* dispatcher,BroadphaseProxy* proxy0,BroadphaseProxy* proxy1):
m_convexProxy(proxy0),m_triangleProxy(*proxy1),m_dispatcher(dispatcher),
m_dispatchInfoPtr(0)
{
//
// create the manifold from the dispatcher 'manifold pool'
//
m_manifoldPtr = m_dispatcher->GetNewManifold(proxy0->m_clientObject,proxy1->m_clientObject);
ClearCache();
}
TopographyFile::~TopographyFile()
{
if (IsEmpty())
return;
ClearCache();
msShapefileClose(&file);
if (dir != NULL) {
--dir->refcount;
zzip_dir_free(dir);
}
}
void ClangCodeCompletion::OnBuildEnded(clBuildEvent& e)
{
e.Skip();
CHECK_CLANG_ENABLED_RET();
// Clear environment variables previously set by this class
::wxUnsetEnv("CL_COMPILATION_DB");
::wxUnsetEnv("CXX");
::wxUnsetEnv("CC");
// Clear the TU cache
ClearCache();
}
void Jit::Compile(u32 em_address)
{
if (GetSpaceLeft() < 0x10000 || blocks.IsFull())
{
ClearCache();
}
int block_num = blocks.AllocateBlock(em_address);
JitBlock *b = blocks.GetBlock(block_num);
DoJit(em_address, b);
blocks.FinalizeBlock(block_num, jo.enableBlocklink);
// Drat. The VFPU hit an uneaten prefix at the end of a block.
if (js.startDefaultPrefix && js.MayHavePrefix()) {
WARN_LOG(JIT, "Uneaten prefix at end of block: %08x", js.compilerPC - 4);
js.startDefaultPrefix = false;
// Our assumptions are all wrong so it's clean-slate time.
ClearCache();
// Let's try that one more time. We won't get back here because we toggled the value.
Compile(em_address);
}
}
