void
getSections(Uint32 secCount, SegmentedSectionPtr ptr[3]){
Uint32 tSec0 = ptr[0].i;
Uint32 tSec1 = ptr[1].i;
Uint32 tSec2 = ptr[2].i;
SectionSegment * p;
switch(secCount){
case 3:
p = g_sectionSegmentPool.getPtr(tSec2);
ptr[2].p = p;
ptr[2].sz = p->m_sz;
case 2:
p = g_sectionSegmentPool.getPtr(tSec1);
ptr[1].p = p;
ptr[1].sz = p->m_sz;
case 1:
p = g_sectionSegmentPool.getPtr(tSec0);
ptr[0].p = p;
ptr[0].sz = p->m_sz;
case 0:
return;
}
char msg[40];
sprintf(msg, "secCount=%d", secCount);
ErrorReporter::handleAssert(msg, __FILE__, __LINE__);
}
/**
* verifySection
* Assertion method to check that a segmented section is constructed
* 'properly' where 'properly' is loosly defined.
*/
bool
verifySection(Uint32 firstIVal, SectionSegmentPool& thePool)
{
if (firstIVal == RNIL)
return true;
/* Get first section ptr (With assertions in getPtr) */
SectionSegment* first= thePool.getPtr(firstIVal);
assert(first != NULL);
Uint32 totalSize= first->m_sz;
Uint32 lastSegIVal= first->m_lastSegment;
/* Hmm, need to be careful of length == 0
* Nature abhors a segmented section with length 0
*/
//assert(totalSize != 0);
assert(lastSegIVal != RNIL); /* Should never be == RNIL */
/* We ignore m_ownerRef */
if (totalSize <= SectionSegment::DataLength)
{
/* 1 segment */
assert(first->m_lastSegment == firstIVal);
// m_nextSegment not always set to RNIL on last segment
//assert(first->m_nextSegment == RNIL);
}
else
{
/* > 1 segment */
assert(first->m_nextSegment != RNIL);
assert(first->m_lastSegment != firstIVal);
Uint32 currIVal= firstIVal;
SectionSegment* curr= first;
/* Traverse segments to where we think the end should be */
while (totalSize > SectionSegment::DataLength)
{
currIVal= curr->m_nextSegment;
curr= thePool.getPtr(currIVal);
totalSize-= SectionSegment::DataLength;
/* Ignore m_ownerRef, m_sz, m_lastSegment of intermediate
* Segments
*/
}
/* Once we are here, we are on the last Segment of this Section
* Check that last segment is as stated in the first segment
*/
assert(currIVal == lastSegIVal);
// m_nextSegment not always set properly on last segment
//assert(curr->m_nextSegment == RNIL);
/* Ignore m_ownerRef, m_sz, m_lastSegment of last segment */
}
return true;
}
void
getSection(SegmentedSectionPtr & ptr, Uint32 i){
ptr.i = i;
SectionSegment * p = g_sectionSegmentPool.getPtr(i);
ptr.p = p;
ptr.sz = p->m_sz;
}
void
linkSegments(Uint32 head, Uint32 tail){
Ptr<SectionSegment> headPtr;
g_sectionSegmentPool.getPtr(headPtr, head);
Ptr<SectionSegment> tailPtr;
g_sectionSegmentPool.getPtr(tailPtr, tail);
Ptr<SectionSegment> oldTailPtr;
g_sectionSegmentPool.getPtr(oldTailPtr, headPtr.p->m_lastSegment);
headPtr.p->m_lastSegment = tailPtr.p->m_lastSegment;
headPtr.p->m_sz += tailPtr.p->m_sz;
oldTailPtr.p->m_nextSegment = tailPtr.i;
}
void
print(SegmentedSectionPtr ptr, FILE* out){
ptr.p = g_sectionSegmentPool.getPtr(ptr.i);
Uint32 len = ptr.p->m_sz;
fprintf(out, "ptr.i = %d(%p) ptr.sz = %d(%d)\n", ptr.i, ptr.p, len, ptr.sz);
while(len > SectionSegment::DataLength){
print(ptr.p, SectionSegment::DataLength, out);
len -= SectionSegment::DataLength;
fprintf(out, "ptr.i = %d\n", ptr.p->m_nextSegment);
ptr.p = g_sectionSegmentPool.getPtr(ptr.p->m_nextSegment);
}
print(ptr.p, len, out);
fprintf(out, "\n");
}
void
append(DataBuffer<sz>& dst, SegmentedSectionPtr ptr, SectionSegmentPool& pool) {
Uint32 len = ptr.sz;
while(len > SectionSegment::DataLength) {
dst.append(ptr.p->theData, SectionSegment::DataLength);
ptr.p = pool.getPtr(ptr.p->m_nextSegment);
len -= SectionSegment::DataLength;
}
dst.append(ptr.p->theData, len);
}
void
SignalLoggerManager::printSegmentedSection(FILE * output,
const SignalHeader & sh,
const SegmentedSectionPtr ptr[3],
unsigned i)
{
fprintf(output, "SECTION %u type=segmented", i);
if (i >= 3) {
fprintf(output, " *** invalid ***\n");
return;
}
const Uint32 len = ptr[i].sz;
SectionSegment * ssp = ptr[i].p;
Uint32 pos = 0;
fprintf(output, " size=%u\n", (unsigned)len);
while (pos < len) {
if (pos > 0 && pos % SectionSegment::DataLength == 0) {
ssp = g_sectionSegmentPool.getPtr(ssp->m_nextSegment);
}
printDataWord(output, pos, ssp->theData[pos % SectionSegment::DataLength]);
}
if (len > 0)
putc('\n', output);
}
