void RLOG_LogCommID(RLOG_Struct* pRLOG, int comm_id)
{
RLOG_HEADER *pHeader;
RLOG_COMM *pComm;
if (pRLOG->bLogging == FALSE)
return;
if (pRLOG->pOutput->pCurHeader + sizeof(RLOG_HEADER) + sizeof(RLOG_COMM) > pRLOG->pOutput->pEnd)
{
MarkDiskStart(pRLOG);
WriteFileData(pRLOG->pOutput->buffer, pRLOG->pOutput->pCurHeader - pRLOG->pOutput->buffer, pRLOG->pOutput->f);
WriteDiskEvent(pRLOG);
pRLOG->pOutput->pCurHeader = pRLOG->pOutput->buffer;
}
pHeader = (RLOG_HEADER*)pRLOG->pOutput->pCurHeader;
pComm = (RLOG_COMM*)((char*)pHeader + sizeof(RLOG_HEADER));
pHeader->type = RLOG_COMM_TYPE;
pHeader->length = sizeof(RLOG_HEADER) + sizeof(RLOG_COMM);
pComm->newcomm = comm_id;
pComm->rank = pRLOG->nRank;
/* advance the current position pointer */
pRLOG->pOutput->pCurHeader += pHeader->length;
}
int ModifyEvents(FILE *f, int nNumEvents, int nMin, double *pOffsets, int n)
{
RLOG_EVENT event;
int i, index;
int error;
MPL_msg_printf("Modifying %d events\n", nNumEvents);
fseek(f, 0, SEEK_CUR);
for (i=0; i<nNumEvents; i++)
{
error = ReadFileData((char*)&event, sizeof(RLOG_EVENT), f);
if (error)
{
rlog_err_printf("reading event failed.\n");
return -1;
}
index = event.rank - nMin;
if (index >= 0 && index < n && pOffsets[index] != 0)
{
event.start_time += pOffsets[index];
event.end_time += pOffsets[index];
fseek(f, -(int)sizeof(RLOG_EVENT), SEEK_CUR);
error = WriteFileData((const char *)&event, sizeof(RLOG_EVENT), f);
if (error)
{
rlog_err_printf("writing modified event failed.\n");
return -1;
}
fseek(f, 0, SEEK_CUR);
}
}
return 0;
}
void RLOG_LogRecv(RLOG_Struct* pRLOG, int src, int tag, int size)
{
if (pRLOG->bLogging == FALSE)
return;
if (pRLOG->pOutput->pCurHeader + sizeof(RLOG_HEADER) + sizeof(RLOG_IARROW) > pRLOG->pOutput->pEnd)
{
MarkDiskStart(pRLOG);
WriteFileData(pRLOG->pOutput->buffer, pRLOG->pOutput->pCurHeader - pRLOG->pOutput->buffer, pRLOG->pOutput->f);
WriteDiskEvent(pRLOG);
pRLOG->pOutput->pCurHeader = pRLOG->pOutput->buffer;
}
RLOG_HEADER_CAST()->type = RLOG_IARROW_TYPE;
RLOG_HEADER_CAST()->length = sizeof(RLOG_HEADER) + sizeof(RLOG_IARROW);
RLOG_IARROW_CAST()->sendrecv = RLOG_RECEIVER;
RLOG_IARROW_CAST()->rank = pRLOG->nRank;
RLOG_IARROW_CAST()->remote = src;
RLOG_IARROW_CAST()->tag = tag;
RLOG_IARROW_CAST()->length = size;
RLOG_IARROW_CAST()->timestamp = RLOG_timestamp() - pRLOG->dFirstTimestamp;
/* advance the current position pointer */
pRLOG->pOutput->pCurHeader += sizeof(RLOG_HEADER) + sizeof(RLOG_IARROW);
}
int IRLOG_CloseOutputStruct(IRLOG_IOStruct **ppOutput)
{
WriteFileData((*ppOutput)->buffer, (int)((*ppOutput)->pCurHeader - (*ppOutput)->buffer), (*ppOutput)->f);
fclose((*ppOutput)->f);
MPIU_Free(*ppOutput);
*ppOutput = NULL;
return 0;
}
int RLOG_FinishLog(RLOG_Struct* pRLOG)
{
RLOG_HEADER header;
/* FixUpBuffer(); */
MarkDiskStart(pRLOG);
WriteFileData(pRLOG->pOutput->buffer, pRLOG->pOutput->pCurHeader - pRLOG->pOutput->buffer, pRLOG->pOutput->f);
WriteDiskEvent(pRLOG);
pRLOG->pOutput->pCurHeader = pRLOG->pOutput->buffer;
header.type = RLOG_ENDLOG_TYPE;
header.length = sizeof(RLOG_HEADER);
WriteFileData((const char *)&header, sizeof(RLOG_HEADER), pRLOG->pOutput->f);
IRLOG_CloseOutputStruct(&pRLOG->pOutput);
return 0;
}
void SaveEvent(RLOG_EVENT *pEvent)
{
RecursionStruct *pLevel;
pLevel = GetLevel(pEvent->rank, pEvent->recursion);
pLevel->num_events++;
/* fwrite(pEvent, sizeof(RLOG_EVENT), 1, pLevel->fout); */
WriteFileData(pEvent, sizeof(RLOG_EVENT), pLevel->fout);
}
cxBool cxUtil::WriteDocument(cchars file,const cxStr *data,cxBool replace)
{
CX_ASSERT(cxStr::IsOK(file) && cxStr::IsOK(data), "path or data error");
const cxStr *path = DocumentPath(file);
if(!cxStr::IsOK(path)){
return false;
}
return WriteFileData(path, data, replace);
}
void XConfig::Save()
{
if(RootElement)
{
XFile file;
file.Open(strFileName, XFILE_WRITE, XFILE_CREATEALWAYS);
WriteFileData(file, 0, RootElement);
file.Close();
}
}
int IRLOG_WriteRecord(RLOG_HEADER * pRecord, IRLOG_IOStruct * pOutput)
{
if (pOutput->pCurHeader + pRecord->length > pOutput->pEnd) {
WriteFileData(pOutput->buffer, (int) (pOutput->pCurHeader - pOutput->buffer), pOutput->f);
pOutput->pCurHeader = pOutput->buffer;
}
/* copy the record into the output buffer */
memcpy(pOutput->pCurHeader, pRecord, pRecord->length);
/* advance the current position pointer */
pOutput->pCurHeader = pOutput->pCurHeader + pRecord->length;
return 0;
}
void XConfig::Close(bool bSave)
{
if(RootElement && bSave)
{
XFile file;
file.Open(strFileName, XFILE_WRITE, XFILE_CREATEALWAYS);
WriteFileData(file, 0, RootElement);
file.Close();
}
delete RootElement;
RootElement = NULL;
strFileName.Clear();
}
void WriteCurrentDataAndLogEvent(RLOG_Struct *pRLOG, int event, double starttime, double endtime, int recursion)
{
double disk_start, disk_end;
/* save the disk event start */
disk_start = RLOG_timestamp();
/* write the data and reset the buffer */
WriteFileData(pRLOG->pOutput->buffer, pRLOG->pOutput->pCurHeader - pRLOG->pOutput->buffer, pRLOG->pOutput->f);
pRLOG->pOutput->pCurHeader = pRLOG->pOutput->buffer;
/* save the disk event end */
disk_end = RLOG_timestamp();
/* save the event that was interrupted by the disk event */
RLOG_LogEvent(pRLOG, event, starttime, endtime, recursion);
/* save the disk event */
RLOG_LogEvent(pRLOG, pRLOG->DiskEvent.event, disk_start, disk_end, recursion);
}
void XConfig::SaveTo(CTSTR lpPath)
{
if (RootElement)
{
String tmpPath = lpPath;
tmpPath.AppendString(TEXT(".tmp"));
XFile file;
if (file.Open(tmpPath, XFILE_WRITE, XFILE_CREATEALWAYS))
{
if (WriteFileData(file, 0, RootElement))
{
file.Close();
OSRenameFile(tmpPath, lpPath);
}
else
{
Log(TEXT("XConfig::SaveTo: WriteFileData failed while writing %s."), lpPath);
}
}
}
}
void XConfig::Save()
{
if(RootElement)
{
String tmpPath = strFileName;
tmpPath.AppendString(TEXT(".tmp"));
XFile file;
if (file.Open(strFileName, XFILE_WRITE, XFILE_CREATEALWAYS))
{
if (WriteFileData(file, 0, RootElement))
{
file.Close();
OSRenameFile(tmpPath, strFileName);
}
else
{
Log(TEXT("XConfig::Save: WriteFileData failed while writing %s."), strFileName.Array());
}
}
}
}
void RLOG_DescribeState(RLOG_Struct* pRLOG, int state, char *name, char *color)
{
RLOG_HEADER *pHeader;
RLOG_STATE *pState;
if (pRLOG->bLogging == FALSE)
return;
if (pRLOG->pOutput->pCurHeader + sizeof(RLOG_HEADER) + sizeof(RLOG_STATE) > pRLOG->pOutput->pEnd)
{
MarkDiskStart(pRLOG);
WriteFileData(pRLOG->pOutput->buffer, pRLOG->pOutput->pCurHeader - pRLOG->pOutput->buffer, pRLOG->pOutput->f);
WriteDiskEvent(pRLOG);
pRLOG->pOutput->pCurHeader = pRLOG->pOutput->buffer;
}
pHeader = (RLOG_HEADER*)pRLOG->pOutput->pCurHeader;
pState = (RLOG_STATE*)((char*)pHeader + sizeof(RLOG_HEADER));
pHeader->type = RLOG_STATE_TYPE;
pHeader->length = sizeof(RLOG_HEADER) + sizeof(RLOG_STATE);
pState->event = state;
MPL_strncpy(pState->color, (color != NULL) ? color : get_random_color_str(), RLOG_COLOR_LENGTH);
pState->color[RLOG_COLOR_LENGTH-1] = '\0';
if (name)
{
MPL_strncpy(pState->description, name, RLOG_DESCRIPTION_LENGTH);
pState->description[RLOG_DESCRIPTION_LENGTH-1] = '\0';
}
else
{
pState->description[0] = '\0';
}
/* advance the current position pointer */
pRLOG->pOutput->pCurHeader += pHeader->length;
}
void SaveArrow(RLOG_IARROW *pArrow)
{
ArrowNode *pNode;
StartArrowStruct *pStart, *pStartIter;
EndArrowStruct *pEnd, *pEndIter;
RLOG_ARROW arrow;
if (g_fArrow == NULL)
{
MPL_strncpy(g_pszArrowFilename, "ArrowFile.tmp", 1024);
g_fArrow = fopen(g_pszArrowFilename, "w+b");
if (g_fArrow == NULL)
{
MPL_error_printf("unable to open ArrowFile.tmp\n");
return;
}
}
if (pArrow->sendrecv == RLOG_SENDER)
{
pNode = GetArrowNode(pArrow->remote);
pEnd = ExtractEndNode(pNode, pArrow->rank, pArrow->tag);
if (pEnd == NULL)
{
pStart = (StartArrowStruct *)MPL_malloc(sizeof(StartArrowStruct));
pStart->src = pArrow->rank;
pStart->tag = pArrow->tag;
pStart->length = pArrow->length;
pStart->start_time = pArrow->timestamp;
pStart->next = NULL;
if (pNode->pStartList == NULL)
{
pNode->pStartList = pStart;
}
else
{
pStartIter = pNode->pStartList;
while (pStartIter->next != NULL)
pStartIter = pStartIter->next;
pStartIter->next = pStart;
}
return;
}
arrow.src = pArrow->rank;
arrow.dest = pArrow->remote;
arrow.length = pArrow->length;
arrow.start_time = pEnd->timestamp;
arrow.end_time = pArrow->timestamp;
arrow.tag = pArrow->tag;
arrow.leftright = RLOG_ARROW_LEFT;
/* fwrite(&arrow, sizeof(RLOG_ARROW), 1, g_fArrow); */
WriteFileData(&arrow, sizeof(RLOG_ARROW), g_fArrow);
MPL_free(pEnd);
}
else
{
arrow.dest = pArrow->rank;
arrow.end_time = pArrow->timestamp;
arrow.tag = pArrow->tag;
arrow.length = pArrow->length;
pNode = GetArrowNode(pArrow->rank);
pStart = ExtractStartNode(pNode, pArrow->remote, pArrow->tag);
if (pStart != NULL)
{
arrow.src = pStart->src;
arrow.start_time = pStart->start_time;
arrow.length = pStart->length; /* the sender length is more accurate than the receiver length */
arrow.leftright = RLOG_ARROW_RIGHT;
MPL_free(pStart);
/* fwrite(&arrow, sizeof(RLOG_ARROW), 1, g_fArrow); */
WriteFileData(&arrow, sizeof(RLOG_ARROW), g_fArrow);
}
else
{
pEnd = (EndArrowStruct *)MPL_malloc(sizeof(EndArrowStruct));
pEnd->src = pArrow->remote;
pEnd->tag = pArrow->tag;
pEnd->timestamp = pArrow->timestamp;
pEnd->next = NULL;
if (pNode->pEndList == NULL)
{
pNode->pEndList = pEnd;
}
else
{
pEndIter = pNode->pEndList;
while (pEndIter->next != NULL)
pEndIter = pEndIter->next;
pEndIter->next = pEnd;
}
}
}
/* fwrite(pArrow, sizeof(RLOG_IARROW), 1, g_fArrow); */
}
void XConfig::WriteFileItem(XFile &file, int indent, XBaseItem *baseItem)
{
int j;
if(baseItem->IsData())
{
XDataItem *item = static_cast<XDataItem*>(baseItem);
String strItem;
for(j=0; j<indent; j++)
strItem << TEXT(" ");
if( item->strName.IsValid() && (
item->strName[0] == ' ' ||
item->strName[0] == '\t' ||
item->strName[0] == '{' ||
item->strName[item->strName.Length()-1] == ' ' ||
item->strName[item->strName.Length()-1] == '\t' ||
schr(item->strName, '\n') ||
schr(item->strName, '"') ||
schr(item->strName, ':') ))
{
strItem << ConvertToTextString(item->strName);
}
else
strItem << item->strName;
strItem << TEXT(" : ");
if( item->strData.IsValid() && (
item->strData[0] == ' ' ||
item->strData[0] == '\t' ||
item->strData[0] == '{' ||
item->strData[item->strData.Length()-1] == ' ' ||
item->strData[item->strData.Length()-1] == '\t' ||
schr(item->strData, '\n') ||
schr(item->strData, '"') ||
schr(item->strData, ':') ))
{
strItem << ConvertToTextString(item->strData);
}
else
strItem << item->strData;
strItem << TEXT("\r\n");
file.WriteAsUTF8(strItem);
}
else if(baseItem->IsElement())
{
XElement *element = static_cast<XElement*>(baseItem);
String strElement;
for(j=0; j<indent; j++)
strElement << TEXT(" ");
if( element->strName.IsValid() && (
element->strName[0] == ' ' ||
element->strName[0] == '\t' ||
element->strName[0] == '{' ||
element->strName[element->strName.Length()-1] == ' ' ||
element->strName[element->strName.Length()-1] == '\t' ||
schr(element->strName, '\n') ||
schr(element->strName, '"') ||
schr(element->strName, ':') ))
{
strElement << ConvertToTextString(element->strName);
}
else
strElement << element->strName;
strElement << TEXT(" : {\r\n");
file.WriteAsUTF8(strElement);
strElement.Clear();
WriteFileData(file, indent+1, element);
for(j=0; j<indent; j++)
strElement << TEXT(" ");
strElement << TEXT("}\r\n");
file.WriteAsUTF8(strElement);
}
}
int main(int argc, char *argv[])
{
RLOG_FILE_HEADER header;
RLOG_State_list *pState;
int nNumInputs;
IRLOG_IOStruct *pInput;
IRLOG_IOStruct **ppInput;
int nMaxRank = 0;
int nMinRank = MAX_RANK;
int nNumStates = 0;
int type, length;
int nMaxLevel = 0;
int nNumLevels = 0;
int nTotalNumEvents = 0;
int nNumEvents;
RecursionStruct *pLevel;
FILE *fout;
int i, j;
int nRank;
if (argc < 3)
{
MPL_error_printf("Usage:\nirlog2rlog out.rlog in0.irlog in1.irlog ...\nirlog2rlog out.rlog n\n");
return 0;
}
if (argc == 3 && IsNumber(argv[2]))
{
GenerateNewArgv(&argc, &argv, atoi(argv[2]));
}
nNumInputs = argc - 2;
/* open the output rlog file */
fout = fopen(argv[1], "wb");
if (fout == NULL)
{
MPL_error_printf("unable to open output file '%s'\n", argv[1]);
return -1;
}
/* read the arrows from all the files in order */
ppInput = (IRLOG_IOStruct**)MPL_malloc(nNumInputs * sizeof(IRLOG_IOStruct*));
for (i=0; i<nNumInputs; i++)
{
ppInput[i] = IRLOG_CreateInputStruct(argv[i+2]);
if (ppInput[i] == NULL)
{
MPL_error_printf("Unable to create an input structure for '%s', skipping\n", argv[i+2]);
}
}
for (i=0; i<nNumInputs; i++)
{
if (ppInput[i] == NULL)
{
for (j=i; j<nNumInputs-1; j++)
ppInput[j] = ppInput[j+1];
nNumInputs--;
i--;
}
}
MPL_msg_printf("reading the arrows from all the input files.\n");fflush(stdout);
ReadAllArrows(ppInput, nNumInputs);
nNumInputs = argc - 2;
/* read, parse and save all the data from the irlog files */
for (i=0; i<nNumInputs; i++)
{
pInput = IRLOG_CreateInputStruct(argv[i+2]);
if (pInput == NULL)
{
MPL_error_printf("Unable to create an input structure for '%s', skipping\n", argv[i+2]);
}
else
{
MPL_msg_printf("reading irlog file: %s\n", argv[i+2]);fflush(stdout);
for(;;)
{
switch (pInput->header.type)
{
case RLOG_STATE_TYPE:
SaveState(&pInput->record.state);
break;
case RLOG_COMM_TYPE:
nMaxRank = (pInput->record.comm.rank > nMaxRank) ? pInput->record.comm.rank : nMaxRank;
nMinRank = (pInput->record.comm.rank < nMinRank) ? pInput->record.comm.rank : nMinRank;
break;
case RLOG_IARROW_TYPE:
/* SaveArrow(&pInput->record.iarrow); */
break;
case RLOG_EVENT_TYPE:
SaveEvent(&pInput->record.event);
break;
default:
MPL_error_printf("Unknown irlog record type: %d\n", pInput->header.type);
break;
}
if (IRLOG_GetNextRecord(pInput))
{
IRLOG_CloseInputStruct(&pInput);
break;
}
}
}
}
/* set the fields in the header */
header.nMinRank = FindMinRank(g_pLevel);
header.nMaxRank = FindMaxRank(g_pLevel);
if (nMinRank != header.nMinRank)
MPL_error_printf("minimum event rank %d does not equal the minimum comm record rank %d\n", header.nMinRank, nMinRank);
if (nMaxRank != header.nMaxRank)
MPL_error_printf("maximum event rank %d does not equal the maximum comm record rank %d\n", header.nMaxRank, nMaxRank);
/* write header */
MPL_msg_printf("writing header.\n");fflush(stdout);
type = RLOG_HEADER_SECTION;
length = sizeof(RLOG_FILE_HEADER);
/* fwrite(&type, sizeof(int), 1, fout); */
WriteFileData(&type, sizeof(int), fout);
/* fwrite(&length, sizeof(int), 1, fout);*/
WriteFileData(&length, sizeof(int), fout);
/* fwrite(&header, sizeof(RLOG_FILE_HEADER), 1, fout); */
WriteFileData(&header, sizeof(RLOG_FILE_HEADER), fout);
/* write states */
if (g_pList)
{
MPL_msg_printf("writing states.\n");fflush(stdout);
}
pState = g_pList;
while (pState)
{
nNumStates++;
pState = pState->next;
}
type = RLOG_STATE_SECTION;
length = nNumStates * sizeof(RLOG_STATE);
/* fwrite(&type, sizeof(int), 1, fout); */
WriteFileData(&type, sizeof(int), fout);
/* fwrite(&length, sizeof(int), 1, fout); */
WriteFileData(&length, sizeof(int), fout);
pState = g_pList;
while (pState)
{
/* fwrite(pState, sizeof(RLOG_STATE), 1, fout); */
WriteFileData(pState, sizeof(RLOG_STATE), fout);
pState = pState->next;
}
/* write arrows */
if (g_fArrow)
{
MPL_msg_printf("writing arrows.\n");fflush(stdout);
type = RLOG_ARROW_SECTION;
length = ftell(g_fArrow);
/* fwrite(&type, sizeof(int), 1, fout); */
WriteFileData(&type, sizeof(int), fout);
/* fwrite(&length, sizeof(int), 1, fout); */
WriteFileData(&length, sizeof(int), fout);
AppendFile(fout, g_fArrow);
}
/* write events */
while (g_pLevel)
{
pLevel = FindMinLevel(g_pLevel);
nNumLevels = FindMaxRecursion(g_pLevel, pLevel->rank);
nRank = pLevel->rank;
/* count the events for this rank */
nNumEvents = 0;
for (i=0; i<nNumLevels; i++)
{
pLevel = GetLevel(pLevel->rank, i);
nNumEvents += pLevel->num_events;
}
/* write an event section for this rank */
type = RLOG_EVENT_SECTION;
length = sizeof(int) + sizeof(int) + (nNumLevels * sizeof(int)) + (nNumEvents * sizeof(RLOG_EVENT));
/* fwrite(&type, sizeof(int), 1, fout); */
WriteFileData(&type, sizeof(int), fout);
/* fwrite(&length, sizeof(int), 1, fout); */
WriteFileData(&length, sizeof(int), fout);
/* fwrite(&nRank, sizeof(int), 1, fout); */
WriteFileData(&nRank, sizeof(int), fout);
/* fwrite(&nNumLevels, sizeof(int), 1, fout); */
WriteFileData(&nNumLevels, sizeof(int), fout);
for (i=0; i<nNumLevels; i++)
{
pLevel = GetLevel(nRank, i);
/* fwrite(&pLevel->num_events, sizeof(int), 1, fout); */
WriteFileData(&pLevel->num_events, sizeof(int), fout);
}
for (i=0; i<nNumLevels; i++)
{
MPL_msg_printf("writing event level %d:%d\n", nRank, i);fflush(stdout);
pLevel = GetLevel(nRank, i);
AppendFile(fout, pLevel->fout);
}
/* remove this rank from the list of levels */
RemoveLevel(nRank);
}
/* free resources */
while (g_pList)
{
pState = g_pList;
g_pList = g_pList->next;
MPL_free(pState);
}
if (g_fArrow)
{
fclose(g_fArrow);
unlink(g_pszArrowFilename);
}
if (s_bFreeArgv)
MPL_free(argv);
return 0;
}
static int ModifyArrows(FILE *f, int nNumArrows, int nMin, double *pOffsets, int n)
{
RLOG_ARROW arrow, *pArray;
int i, index, bModified;
long arrow_pos;
int error;
double temp_time;
fseek(f, 0, SEEK_CUR);
arrow_pos = ftell(f);
if (arrow_pos == -1)
return errno;
pArray = (RLOG_ARROW*)MPIU_Malloc(nNumArrows * sizeof(RLOG_ARROW));
if (pArray)
{
MPL_msg_printf("Modifying %d arrows\n", nNumArrows);
/* read the arrows */
fseek(f, 0, SEEK_CUR);
error = ReadFileData((char*)pArray, nNumArrows * sizeof(RLOG_ARROW), f);
if (error)
{
MPIU_Free(pArray);
return error;
}
/* modify the arrows */
for (i=0; i<nNumArrows; i++)
{
arrow = pArray[i];
bModified = FALSE;
index = (arrow.leftright == RLOG_ARROW_RIGHT) ? arrow.src - nMin : arrow.dest - nMin;
if (index >= 0 && index < n && pOffsets[index] != 0)
{
arrow.start_time += pOffsets[index];
bModified = TRUE;
}
index = (arrow.leftright == RLOG_ARROW_RIGHT) ? arrow.dest - nMin : arrow.src - nMin;
if (index >= 0 && index < n && pOffsets[index] != 0)
{
arrow.end_time += pOffsets[index];
bModified = TRUE;
}
if (bModified)
{
if (arrow.start_time > arrow.end_time)
{
temp_time = arrow.start_time;
arrow.start_time = arrow.end_time;
arrow.end_time = temp_time;
arrow.leftright = (arrow.leftright == RLOG_ARROW_LEFT) ? RLOG_ARROW_RIGHT : RLOG_ARROW_LEFT;
}
pArray[i] = arrow;
}
}
/* sort the arrows */
qsort(pArray, (size_t)nNumArrows, sizeof(RLOG_ARROW),
(int (*)(const void *,const void*))compareArrows);
/* write the arrows back */
fseek(f, arrow_pos, SEEK_SET);
error = WriteFileData((char*)pArray, nNumArrows * sizeof(RLOG_ARROW), f);
if (error)
{
MPIU_Free(pArray);
return error;
}
fseek(f, 0, SEEK_CUR);
MPIU_Free(pArray);
}
else
{
MPL_error_printf("Error: unable to allocate an array big enough to hold %d arrows\n", nNumArrows);
return -1;
}
return 0;
}
static void WriteDiskEvent(RLOG_Struct *pRLOG)
{
pRLOG->DiskEvent.end_time = RLOG_timestamp() - pRLOG->dFirstTimestamp;
WriteFileData((const char *)&pRLOG->DiskHeader, sizeof(RLOG_HEADER), pRLOG->pOutput->f);
WriteFileData((const char *)&pRLOG->DiskEvent, sizeof(RLOG_EVENT), pRLOG->pOutput->f);
}
