// =============================================================================
// sxr_CheckCluster
// -----------------------------------------------------------------------------
/// Check clusters load and consistency.
// =============================================================================
void sxr_CheckCluster (void)
{
u32 i,j;
#ifdef __SXR_CLUSTER__
sxr_MemHead_t *Header;
#endif
SXS_FPRINTF((_SXR|TSTDOUT|TDB|TNB_ARG(1),TSTR("NbCluster %d\n",0x06bc0008), sxr_NbCluster));
for (i=0; i<sxr_NbCluster; i++)
{
SXS_FPRINTF ((_SXR|TSTDOUT|TIDU|TNB_ARG(4)|TDB,TSTR("Cluster %i: %i * %i bytes. %i allocated blocks.\n",0x06bc0009),
i,
sxr_Cluster [i].NbCluster,
sxr_Cluster [i].AlignSize,
sxr_Cluster [i].NbAllocation));
// sxr_GetAbsoluteHeapRemainingSize (0, PAL_NB_RAM_AREA + SXR_NB_HEAP_USER + i)));
#ifdef __SXR_CLUSTER__
for (j=0; j<sxr_Cluster [i].NbCluster; j++)
{
Header = (sxr_MemHead_t *)(&((u8 *)sxr_Cluster [i].Add) [j * sxr_Cluster [i].AlignSize]);
if (!sxr_CheckSum (&Header -> CheckSum))
{
SXS_RAISE ((_SXR|TDB|TNB_ARG(1),TSTR("Cluster Header consistency failure %lx\n",0x06bc000a), Header + 1));
}
if ((((u8 *)sxr_Cluster [Header -> PIdx].Add) [((Header -> Index + 1) * sxr_Cluster [Header -> PIdx].AlignSize) -1]) != SXR_MEM_PATTERN)
{
SXS_RAISE ((_SXR|TDB|TNB_ARG(2),TSTR("Cluster Footer erased %lx, %lxy\n",0x06bc000b), Header + 1, Header -> CallerAdd));
}
if (Header -> CallerAdd != SXR_POOL_FREE)
{
SXS_FPRINTF ((_SXR|TSTDOUT|TIDU|TDB|TNB_ARG(3),TSTR("(0x%08lx , %5i) -> %lxy\n",0x06bc000c), Header + 1, Header -> Size, Header -> CallerAdd));
}
}
#else
sxr_ChkHp (PAL_NB_RAM_AREA + SXR_NB_HEAP_USER + i);
#endif
for (j=0; j<SXR_LOAD_HIST_GRANULARITY; j++)
{
if (sxr_Cluster [i].LoadHist [j] != 0)
{
SXS_TRACE (_SXR|TSTDOUT|TNB_ARG(2)|TDB,TSTR("Load < %i/100: %i\n",0x06bc000d), ((j+1)*100)/SXR_LOAD_HIST_GRANULARITY, sxr_Cluster [i].LoadHist [j]);
}
}
SXS_TRACE (_SXR|TSTDOUT|TDB,TSTR("\n",0x06bc000e));
}
}
// =============================================================================
// sxr_ChkHp
// -----------------------------------------------------------------------------
/// Check Heaps load and consistency.
/// @param Idx Heap index.
// =============================================================================
void sxr_ChkHp (u8 Idx)
{
sxr_HMemHead_t *HBlock = (sxr_HMemHead_t *)sxr_Heap [Idx].Start;
u8 Cnt = 0;
SXS_FPRINTF ((_SXR|TSTDOUT|TDB|TNB_ARG(3),TSTR("Heap size Total %i Cur %i Min %i\n",0x06bc0014), (u32)sxr_Heap [Idx].End - (u32)sxr_Heap [Idx].Start, sxr_Heap [Idx].CurSize, sxr_Heap [Idx].LowestSize));
while (HBlock < (sxr_HMemHead_t *)sxr_Heap [Idx].Top)
{
if (HBlock != ((sxr_HMemHead_t *) ((u32 *)HBlock) [HBlock -> Size - 1]))
{
SXS_RAISE ((_SXR|TDB|TNB_ARG(3),TSTR("Heap block consistency failure %lx Size %i Heap End %lx\n",0x06bc0015), HBlock, HBlock -> Size, sxr_Heap [Idx].End));
}
if (HBlock -> H.Index == SXR_HEAP_ALLOCATED)
{
SXS_FPRINTF ((_SXR|TSTDOUT|TDB|TNB_ARG(4),TSTR("(%08lx, %5i) -> %lxy (%i)\n",0x06bc0016), HBlock+1, (HBlock -> Size << 2) - HBlock -> H.DSize, HBlock -> H.CallerAdd, Cnt++));
if (HBlock == (sxr_HMemHead_t *)sxr_Heap [Idx].Top)
{
break;
}
if (!sxr_CheckSum (&HBlock -> H.CheckSum))
{
SXS_RAISE ((_SXR|TDB|TNB_ARG(1),TSTR("Heap Header consistency failure %lx\n",0x06bc0017), HBlock + 1));
}
if (((u8 *)HBlock)[sizeof (sxr_HMemHead_t) + (HBlock -> Size << 2) - HBlock -> H.DSize] != SXR_MEM_PATTERN)
{
SXS_RAISE ((_SXR|TDB|TNB_ARG(2),TSTR("Heap Footer erased %lx, %lxy\n",0x06bc0018), HBlock, HBlock -> H.CallerAdd));
}
}
if (HBlock -> Size > 0xFFFFF)
SXS_RAISE ((_SXR|TDB|TNB_ARG(2),TSTR("Heap destroyed. %lx %lx\n",0x06bc0019), HBlock, (HBlock -> Size << 2) - HBlock -> H.DSize));
{
u32 *Zob = (u32 *)HBlock;
Zob += HBlock -> Size;
HBlock = (sxr_HMemHead_t *)Zob;
}
}
if (HBlock != (sxr_HMemHead_t *)sxr_Heap [Idx].Top)
{
SXS_RAISE ((_SXR|TDB|TNB_ARG(2),TSTR("Heap unconsistency %lx / %lx\n",0x06bc001a), HBlock, sxr_Heap [Idx].End));
}
}
// =============================================================================
// sxr_CheckTask
// -----------------------------------------------------------------------------
/// Trace out a diagnostic information for all the existing task.
// =============================================================================
void sxr_CheckTask (void)
{
u32 i;
SXS_FPRINTF ((_SXR|TSTDOUT|TDB|TNB_ARG(2),TSTR("\nAllocated Tasks %i\nSchedule Disable %i\n",0x06c3000d),
sxr_Task.Load, sxr_Task.ScheduleDisable));
for (i=0; i<SXR_NB_MAX_TASK; i++)
{
sxr_ChkTask ((u8)i);
}
}
// =============================================================================
// sxr_ChkTask
// -----------------------------------------------------------------------------
/// Trace out a diagnostic information for a task.
/// @param TkNb Task Id.
// =============================================================================
void sxr_ChkTask (u8 TkNb)
{
{
if ( sxr_Task.Ctx [TkNb].Id != SXR_NO_TASK)
{
SXS_FPRINTF ((_SXR|TSTDOUT|TSMAP(2)|TDB|TNB_ARG(3),TSTR("Task %2i: %s Priority %3i ",0x06c30005),
TkNb,
sxr_Task.Ctx [TkNb].Desc -> Name,
sxr_Task.Ctx [TkNb].Desc -> Priority));
switch (sxr_Task.Ctx [TkNb].State)
{
case SXR_ALLOCATED_TSK :
SXS_FPRINTF ((_SXR|TSTDOUT|TIDU|TDB,TSTR("is allocated.\n",0x06c30006)));
break;
case SXR_PENDING_TSK :
SXS_FPRINTF ((_SXR|TSTDOUT|TIDU|TDB,TSTR("is pending.\n",0x06c30007)));
break;
case SXR_ACTIVE_TSK :
SXS_FPRINTF ((_SXR|TSTDOUT|TIDU|TDB,TSTR("is active.\n",0x06c30008)));
break;
case SXR_SUSPENDED_TSK :
SXS_FPRINTF ((_SXR|TSTDOUT|TIDU|TDB,TSTR("is suspended.\n",0x06c30009)));
break;
case SXR_WAIT_MSG_TSK :
SXS_FPRINTF ((_SXR|TSTDOUT|TIDU|TDB,TSTR("wait for a message.\n",0x06c3000a)));
break;
default :
SXS_FPRINTF ((_SXR|TSTDOUT|TIDU|TDB,TSTR("is broken...\n",0x06c3000b)));
}
#ifdef __SXR_STACK_CHECK__
{
SXS_FPRINTF ((_SXR|TSTDOUT|TIDU|TDB|TNB_ARG(4),TSTR("Stack %3i/%3i Top 0x%lx <- 0x%lx\n",0x06c3000c),
sxr_GetStackMaxUsage(TkNb),
SXR_SET_STACK(sxr_Task.Ctx [TkNb].Desc -> StackSize) << 2,
sxr_Task.Ctx [TkNb].StackTop,
sxr_Task.Ctx [TkNb].StackTop + SXR_SET_STACK(sxr_Task.Ctx [TkNb].Desc -> StackSize)));
}
#endif
}
}
}
