void CIndexedHuge::EvictThirdLevelChunk(SIndexedThirdLevelSearch* psIndexedThirdLevelSearch)
{
SIndexedThirdLevelSearch** ppsIndexedThirdLevelSearch;
SIndexedSecondLevelSearch* psIndexedSecondLevelSearch;
int iSecondLevelOffset;
psIndexedSecondLevelSearch = psIndexedThirdLevelSearch->psParent;
//Clear the second level chunk pointer pointing to this third level chunk.
iSecondLevelOffset = psIndexedThirdLevelSearch->iSecondLevelOffset;
ppsIndexedThirdLevelSearch = GetIndexedThirdLevelChunk(psIndexedSecondLevelSearch, iSecondLevelOffset);
(*ppsIndexedThirdLevelSearch) = NULL;
//Roll to the next third level chunk if the chunk being evicted was this one.
if (mpsFirstThirdLevelChunk == psIndexedThirdLevelSearch)
{
mpsFirstThirdLevelChunk = psIndexedThirdLevelSearch->psNext;
}
EvictCachedObjects(psIndexedThirdLevelSearch);
SaveThirdLevelChunk(psIndexedThirdLevelSearch);
memset_fast(psIndexedThirdLevelSearch, 0, sizeof(SIndexedThirdLevelSearch) + (miThirdLevelChunkWidth*sizeof(CIndexedDataDescriptor)));
miThirdLevelEvictions += miThirdLevelChunkWidth;
}
/* Interrupt routine to run when the timer expires */
void interrupt isr_timer1(void) {
/* Fill the screen with a random color */
memset_fast(lcd_Ram, randInt(0,255), LCD_SIZE);
/* Must acknowledge that the interrupt occured to clear the flag */
int_Acknowledge = INT_TIMER1;
}
SIndexedSecondLevelSearch* CIndexedHuge::LoadSecondLevelChunk(int iSecondLevelIndex)
{
SIndexedSecondLevelSearch* psIndexedSecondLevelSearch;
int iPrevLast;
int iSize;
iSize = (sizeof(SIndexedSecondLevelSearch) + (sizeof(SIndexedThirdLevelSearch*) * miSecondLevelChunkWidth));
if (!mbSecondLevelCacheFull)
{
iPrevLast = miLastSecondLevelChunk;
miLastSecondLevelChunk = IncrementSecondLevelNumber(miLastSecondLevelChunk);
if ((miLastSecondLevelChunk != 0) || (iPrevLast == -1))
{
psIndexedSecondLevelSearch = (SIndexedSecondLevelSearch*)RemapSinglePointer(mpvSecondLevel, miLastSecondLevelChunk * iSize);
memset_fast(psIndexedSecondLevelSearch, 0, iSize);
SetSecondLevelChunk(psIndexedSecondLevelSearch, iSecondLevelIndex);
return psIndexedSecondLevelSearch;
}
mbSecondLevelCacheFull = TRUE;
miLastSecondLevelChunk--;
}
miLastSecondLevelChunk = IncrementSecondLevelNumber(miLastSecondLevelChunk);
psIndexedSecondLevelSearch = (SIndexedSecondLevelSearch*)RemapSinglePointer(mpvSecondLevel, miLastSecondLevelChunk * iSize);
EvictSecondLevelChunk(psIndexedSecondLevelSearch);
SetSecondLevelChunk(psIndexedSecondLevelSearch, iSecondLevelIndex);
return psIndexedSecondLevelSearch;
}
void CNamesIndexedSorterSource::Init(int iWidth, filePos iPosition)
{
mpcCurrent = (CNamedIndexedBlock*)malloc(iWidth);
memset_fast(mpcCurrent, 0, iWidth);
miPosition = iPosition;
miCount = 0;
}
void interrupt isr_rtc(void) {
/* Get the status of the RTC interrupt register */
uint8_t status = rtc_IntStatus;
/* If a second passed, increment a counter */
if(status & RTC_SEC_INT) {
seconds++;
memset_fast(lcd_Ram, randInt(0,255), LCD_SIZE);
}
/* Acknowledge all outstanding interrupts */
rtc_IntAcknowledge = status;
}
BOOL CNamedIndexesBlock::Cache(void* pvCache)
{
if (pvCache)
{
mpvCachePos = pvCache;
memset_fast(pvCache, 0, (size_t)(miBlockChunkSize * miBlockWidth));
return TRUE;
}
else
{
return FALSE;
}
}
void pid_init(pid_instance * S, int32 resetStateFlag)
{
/* Derived coefficient A0 */
S->A0 = S->Kp + S->Ki + S->Kd;
/* Derived coefficient A1 */
S->A1 = (-S->Kp) - ((float) 2.0 * S->Kd);
/* Derived coefficient A2 */
S->A2 = S->Kd;
/* Check whether state needs reset or not */
if (resetStateFlag)
{
/* Clear the state buffer. The size will be always 3 samples */
memset_fast(S->state, 0, 3u * 2);
}
}
BOOL CNamedIndexesBlock::AddUnsafe(OIndex oi, CChars* szName)
{
CArrayBlock avFakeBlock;
CNamedIndexedBlock sBlock;
int iIndex;
if (!mpvCachePos)
{
return FALSE;
}
memset_fast(&sBlock, 0, miBlockWidth);
sBlock.Set(szName->Text(), oi);
avFakeBlock.Fake(miBlockWidth, mpvCachePos, (int)miUsedBlocks, (int)miBlockChunkSize);
//It's safe to insert into a faked array because we know there is at least one free element in the chunk
//That is: miBlockChunkSize - miUsedBlocks >= 1
iIndex = avFakeBlock.InsertIntoSorted(&CompareNamedIndexedBlock, &sBlock, FALSE);
if (miUsedBlocks == 0)
{
mszFirst.Set(szName);
mszLast.Set(szName);
}
else
{
if (iIndex == 0)
{
mszFirst.Set(szName);
}
else if (iIndex == miUsedBlocks)
{
mszLast.Set(szName);
}
}
miUsedBlocks++;
Dirty();
return TRUE;
}
BOOL CIndexedHuge::ChangeStrategy(int iSecondLevelWidth, int iThirdLevelWidth, int iNumSecondLevelChunks, int iNumThirdLevelChunks)
{
int iSecondLevelCacheSize;
int iThirdLevelCacheSize;
if (miLastOi != INVALID_O_INDEX)
{
return FALSE;
}
if ((iSecondLevelWidth % iThirdLevelWidth) != 0)
{
return FALSE;
}
miSecondLevelChunkWidth = iSecondLevelWidth;
miThirdLevelChunkWidth = iThirdLevelWidth;
miNumSecondLevelChunks = iNumSecondLevelChunks;
miNumThirdLevelChunks = iNumThirdLevelChunks;
SafeFree(mpvSecondLevel);
SafeFree(mpvThirdLevel);
iSecondLevelCacheSize = GetSecondLevelCacheByteSize();
mpvSecondLevel = malloc(iSecondLevelCacheSize);
memset_fast(mpvSecondLevel, 0, iSecondLevelCacheSize);
iThirdLevelCacheSize = GetThirdLevelCacheByteSize();
mpvThirdLevel = malloc(iThirdLevelCacheSize);
ClearThirdLevelChunks();
miLastSecondLevelChunk = -1;
mapFirstLevel.Kill();
mapFirstLevel.Allocate(&gcSystemAllocator, iNumSecondLevelChunks);
mapFirstLevel.Zero();
return TRUE;
}
BOOL CNamedIndexesBlock::Cache(CIndexedFile* pcFile, void* pvCache)
{
BOOL bResult;
void* pvClear;
if (IsInFile())
{
mpvCachePos = pvCache;
bResult = pcFile->Read(miDataIndex, pvCache, miUsedBlocks);
if (IsNotFull())
{
pvClear = RemapSinglePointer(pvCache, (size_t)(miBlockWidth * miUsedBlocks));
memset_fast(pvClear, 0, (size_t)((miBlockChunkSize - miUsedBlocks) * miBlockWidth));
}
mbDirty = FALSE;
return bResult;
}
else
{
return FALSE;
}
}
void pid_reset(pid_instance * S)
{
/* Clear the state buffer. The size will be always 3 samples */
memset_fast(S->state, 0, 3u * 2);
}
void FillCachedElement(void* pvData, int iSize, char c)
{
memset_fast(pvData, c, iSize-1);
((char*)pvData)[iSize-1] = '\0';
}
BOOL CNamedIndexesOptimiser::OptimiseBlock(CNamedIndexesBlocks* pcBlocks, CIndexedFile* pcIndexedFile)
{
int i;
CNamesIndexedSorterSource* pcSource;
CFileBasic cDestFile;
BOOL bResult;
filePos iNumNames;
CNamedIndexedBlock cBlock;
if (!pcIndexedFile)
{
return TRUE;
}
bResult = AllocateSources(pcBlocks, pcIndexedFile);
ReturnOnFalse(bResult);
bResult = LoadInitialSources(pcIndexedFile, pcBlocks->GetDataSize());
ReturnOnFalse(bResult);
bResult = OpenDestinationFile(&cDestFile, pcIndexedFile->GetFileName());
if (!bResult)
{
KillSources();
return FALSE;
}
iNumNames = macSources.NumElements() * pcBlocks->GetNumBlocks();
for (i = 0; i < iNumNames; i++)
{
pcSource = GetSmallestSource(pcBlocks->GetNumBlocks());
if (!pcSource)
{
break;
}
bResult = cDestFile.WriteData(pcSource->mpcCurrent, pcBlocks->GetDataSize());
if (!bResult)
{
cDestFile.Close();
cDestFile.Kill();
KillSources();
return FALSE;
}
bResult = pcSource->ReadNext(pcIndexedFile->GetPrimaryFile(), pcBlocks->GetDataSize());
if (!bResult)
{
cDestFile.Close();
cDestFile.Kill();
KillSources();
return TRIERROR;
}
}
memset_fast(&cBlock, 0, pcBlocks->GetDataSize());
for (; i < iNumNames; i++)
{
cDestFile.WriteData(&cBlock, pcBlocks->GetDataSize());
}
cDestFile.Close();
cDestFile.Kill();
KillSources();
return TRUE;
}
