void __fastcall TForm1::btnNativeJustTimeClick(TObject *Sender)
{
if(tvConnectDev->Selected == NULL) return;
DEVICE_STATUS devStatusInfo;
String strInfo;
PDevInfo pDev = NULL;
TTreeNodes *nodes = tvConnectDev->Items;
if(nodes != NULL)
{
for(int i = 0; i < nodes->Count; i++)
{
if(TreeView_GetCheckState(tvConnectDev->Handle,nodes->Item[i]->ItemId))
{
String strViewIP = nodes->Item[i]->Text;
for(int j = 0; j < pDevList->Count; j++)
{
pDev = PDevInfo(pDevList->Items[j]);
if(pDev != NULL)
{
String strDevListIP;
strDevListIP.sprintf("%s", pDev->ucIP);
if(strDevListIP == strViewIP)
{ if(pDev->pHandle != NULL)
{
int nRes = AdjustTime(pDev->pHandle, 0);
if(nRes != 0) ShowMessage("使用本地系统时间校时失败，返回值 = " + IntToStr(nRes));
else ShowMessage("校时成功");
return;
}
}
}
}
}
}
}
}
void GetTotalRuntime(PTHDBLK pthdblk)
{
LONGLONG liElapsed,
liRealTime,
liSaveRealTime;
CHAR chRealTimeSuffix;
PCHRONOCELL pChronoCell;
pChronoCell = pthdblk->pChronoHeadCell;
do
{
liElapsed = pChronoCell->liElapsed;
if (liElapsed == 0L)
{
liRealTime = liElapsed;
}
else
{
liRealTime = liElapsed - pChronoCell->liCallees;
}
liSaveRealTime = liRealTime;
AdjustTime (&liRealTime, &chRealTimeSuffix);
if (chRealTimeSuffix != 'o' ||
chRealTimeSuffix != 'u') // don't add if Under/Overflow
{
liTotalRunTime += liSaveRealTime;
}
pChronoCell++; // bump to next entry
} while (pChronoCell->ulSymbolAddr != 0L);
}
// converts the time returned from the ps2's clock into LOCAL time
// (ps2 clock is in JST time)
void configConvertToLocalTime(sceCdCLOCK* time)
{
int timezone_offset = configGetTimezone();
int daylight_saving = configIsDaylightSavingEnabled();
AdjustTime(time, timezone_offset - 540 + (daylight_saving * 60));
}
// converts the time returned from the ps2's clock into GMT time
// (ps2 clock is in JST time)
void configConvertToGmtTime(sceCdCLOCK* time)
{
AdjustTime(time, -540);
}
void DumpFuncCalls(PTHDBLK pthdblk, LPSTR lpstrBuff)
{
PCHRONOCELL pChronoCell, pCurrentChronoCell;
ULONG ulTotalCalls;
ULONG ulCurrentSymbol;
LONGLONG liTotalElapsed,
liTotalRealTime;
DOUBLE dblTotalPercentage,
dblSinglePercentage;
TCHAR chElapsedSuffix,
chRealTimeSuffix,
chTotalRuntimeSuffix;
ULONG ulTotalPercentage,
ulSinglePercentage;
AdjustTime(&liTotalRunTime, &chTotalRuntimeSuffix);
cChars += sprintf (lpstrBuff + cChars,
"\r\n\n_________________________________"
"________________________________________________"
"________________________________________________"
"________________________________________\r\n\n\n\n"
" SUMMARY OF CALLS PER FUNCTION\r\n"
" =============================\r\n\n\n\n"
" Count [+Callee] [-Callee] %%Total | %%Single "
" Function Name\n"
" __________ _________ _________ __________________ "
"_______________\n\n");
if ( !WriteFile (hOutFile, lpstrBuff, cChars, &cChars, NULL) )
{
CapDbgPrint ("CAP: DumpFuncCalls() - "
"Error writing to %s - 0x%lx\n",
atchOutFileName, GetLastError());
}
cChars = 0;
ulTotalCalls = 0L;
pChronoCell = pthdblk->pChronoHeadCell;
while (pChronoCell->ulSymbolAddr != 0L)
{
liTotalRealTime = 0L;
liTotalElapsed = 0L;
ulCurrentSymbol = pChronoCell->ulSymbolAddr;
pCurrentChronoCell = pChronoCell;
pChronoCell->nNestedCalls = pChronoCell->nRepetitions;
liTotalRealTime += pChronoCell->liCallees;
liTotalElapsed += pChronoCell->liElapsed;
pCurrentChronoCell++;
// Walk the list and accumulate the counts
while (pCurrentChronoCell->ulSymbolAddr != 0L)
{
if (pCurrentChronoCell->ulSymbolAddr == ulCurrentSymbol)
{
pChronoCell->nNestedCalls += pCurrentChronoCell->nRepetitions;
liTotalRealTime += pCurrentChronoCell->liCallees;
liTotalElapsed += pCurrentChronoCell->liElapsed;
// Set to 0xffffffff to indicate it has been processed
pCurrentChronoCell->ulSymbolAddr = 0xffffffff;
}
pCurrentChronoCell++;
}
if (liTotalElapsed == 0 )
{
liTotalRealTime = liTotalElapsed;
}
else
{
liTotalRealTime = liTotalElapsed - liTotalRealTime;
}
AdjustTime (&liTotalElapsed, &chElapsedSuffix);
AdjustTime (&liTotalRealTime, &chRealTimeSuffix);
ulTotalCalls += pChronoCell->nNestedCalls;
if (liTotalRunTime != 0L )
{
dblTotalPercentage = (100.0 * liTotalRealTime) /
liTotalRunTime;
dblSinglePercentage = dblTotalPercentage /
pChronoCell->nNestedCalls;
// BUGBUG! This "sometimes" does not produce correct results
// for some reasons...
//
// dblSinglePercentage =
// (100.0 * liTotalRealTime.LowPart) /
// (liTotalRunTime.LowPart * pChronoCell->nNestedCalls);
}
else
{
dblTotalPercentage = 0.0;
dblSinglePercentage = 0.0;
}
ulTotalPercentage = (ULONG) (dblTotalPercentage * 1000.0);
ulSinglePercentage = (ULONG) (dblSinglePercentage * 1000.0);
cChars += sprintf(lpstrBuff + cChars,
// " <%8lu> %9lu%1c %9lu%1c %7.3f|%7.3f %-*.*s\n",
" <%8lu> %9lu%1c %9lu%1c %3lu.%03lu | %3lu.%03lu %-*.*s\n",
pChronoCell->nNestedCalls,
(ULONG)liTotalElapsed,
chElapsedSuffix,
(ULONG)liTotalRealTime,
chRealTimeSuffix,
ulTotalPercentage / 1000,
ulTotalPercentage % 1000,
ulSinglePercentage / 1000,
ulSinglePercentage % 1000,
iNameLength,
iNameLength,
GetFunctionName (pChronoCell->ulSymbolAddr,
ulLocProfBlkOff,
NULL));
if (cChars > BUFFER_SIZE)
{
if ( !WriteFile(hOutFile, lpstrBuff, cChars, &cChars, NULL))
{
CapDbgPrint ("CAP: DumpFuncCalls() - ChronoDump - "
"Error writing to %s - 0x%lx\n",
atchOutFileName, GetLastError());
}
cChars = 0;
}
pChronoCell++;
while (pChronoCell->ulSymbolAddr == 0xffffffff)
{
pChronoCell++;
}
}
cChars += sprintf(lpstrBuff + cChars,
"\n\n ________________________________ \n\n "
"<%8lu> %9lu%1c\n\n"
"\r\n\n================================="
"================================================"
"================================================"
"========================================\r\n\n\n",
ulTotalCalls,
(ULONG)liTotalRunTime,
chTotalRuntimeSuffix);
if ( !WriteFile (hOutFile, lpstrBuff, cChars, &cChars, NULL) )
{
CapDbgPrint ("CAP: DumpFuncCalls() - "
"Error writing to %s - 0x%lx\n",
atchOutFileName, GetLastError());
}
cChars = 0;
} /* DumpFuncCalls */
void DumpChronoFuncs(PTHDBLK pthdblk, LPSTR lpstrBuff)
{
PCHRONOCELL pChronoCell;
TCHAR ptchSym [FILENAMELENGTH];
PTCHAR ptchFuncName;
PTCHAR ptchModule;
ULONG ulTotalCalls;
int iNest;
PTCHAR ptchChronoModule;
PTCHAR ptchChronoFuncName;
PTCHAR ptchMatch;
LONGLONG liTime;
TCHAR chRuntimeSuffix;
if (cChars) // if Count is not 0, we have to flush everything
{
if ( !WriteFile (hOutFile, lpstrBuff, cChars, &cChars, NULL) )
{
CapDbgPrint ("CAP: DumpChronoFuncs() - "
"Error writing to %s - 0x%lx\n",
atchOutFileName, GetLastError());
}
cChars = 0;
}
//CalcIncompleteChronoCalls(pthdblk);
GetTotalRuntime(pthdblk);
cChars = sprintf (lpstrBuff,
"\r\n\n_________________________________"
"________________________________________________"
"________________________________________________"
"________________________________________\r\n\n\n\n"
"CHRONOLOGICAL FUNCTION LISTINGS\r\n"
"===============================\r\n");
if (fChronoDump)
{
pChronoCell = pthdblk->pChronoHeadCell;
while (pChronoCell->ulSymbolAddr != 0L)
{
//
// Get the symbol name using the function address
//
strcpy(ptchSym, GetFunctionName (pChronoCell->ulSymbolAddr,
ulLocProfBlkOff,
NULL));
_strupr(ptchSym);
_strupr(ptchChronoFuncs);
ptchFuncName = strchr(ptchSym, ':') + 1;
ptchModule = ptchSym;
// ???? Check ptchFuncName
*(ptchFuncName - 1) = '\0';
if (ptchChronoFuncs[0] != EMPTY_STRING) // Empty list ?
{
ptchChronoModule = (PTCHAR) ptchChronoFuncs;
while (*ptchChronoModule != '\0')
{
ptchChronoFuncName = strchr(ptchChronoModule, INI_DELIM) + 1;
*(ptchChronoFuncName - 1) = '\0';
// Look for the Module name
ptchMatch = strstr(ptchModule, ptchChronoModule);
if (ptchMatch && (*(ptchMatch - 1) != COMMENT_CHAR))
{
// We have found the module, now check the func name
if (strstr(ptchFuncName, ptchChronoFuncName))
{
*(ptchChronoFuncName - 1) = INI_DELIM;
// Dump everything call from this cell only
// until the nesting depth is < or == to this cell
//
DumpChronoEntry(pthdblk,
lpstrBuff,
&pChronoCell,
FALSE);
// if found then break out of the
// while (ptchChronoModule) loop
break;
}
}
// If we get here that means we fail to match a module
// name and the func name in the [CHRONO FUNCS] section.
// Just bump to next entry
//
*(ptchChronoFuncName - 1) = INI_DELIM;
ptchChronoModule += strlen(ptchChronoModule) + 1;
}
if (*ptchChronoModule == '\0') // If we did not match
{ // anything then bump to
pChronoCell++; // next cell
}
}
else
{
// Dump everything
DumpChronoEntry(pthdblk, lpstrBuff, &pChronoCell, TRUE);
}
// At this point, pChronoCell has been incremented correctly
// by DumpChronoEntry or inside the searching loop for
// " while (* ptchChronoListItem != EMPTY_STRING) ".
// We just need to loop back.
}
}
else
{
cChars += sprintf (
lpstrBuff + cChars,
"\n\n <<< CHRONO INFO COLLECTED BUT NOT DUMPED >>>\n\n"
"================================="
"================================================"
"================================================"
"========================================\r\n\n\n");
}
cChars += sprintf(lpstrBuff + cChars,
"\n\n______________________________________\n\n\n"
" Summary Statistics\n"
" ==================\n\n\n");
ulTotalCalls = 0L; // Reset our total count for each thread
for (iNest = 0 ;
( (iNest < MAX_NESTING) &&
(pthdblk->aulDepth[iNest] != 0) ) ;
iNest++)
{
ulTotalCalls += pthdblk->aulDepth[iNest];
cChars += sprintf(lpstrBuff + cChars,
" Total calls Depth [%3d] = [%8lu]\n",
iNest,
pthdblk->aulDepth[iNest]);
}
liTime = liTotalRunTime;
AdjustTime(&liTime, &chRuntimeSuffix);
cChars += sprintf(lpstrBuff + cChars,
"\n\n______________________________________\n\n"
" Total Calls = [ %8lu]\n"
" Total Time-Callees = [%9lu]%1c\n\n",
ulTotalCalls,
(ULONG)liTime,
chRuntimeSuffix);
} /* DumpChronoFuncs */
void DumpChronoEntry(PTHDBLK pthdblk,
LPSTR lpstrBuff,
PCHRONOCELL * ppChronoCell,
BOOL fDumpAll)
{
PCHRONOCELL pChronoCell;
LONGLONG liElapsed,
liRealTime;
TCHAR chElapsedSuffix,
chRealTimeSuffix;
TCHAR pIndentation [MAX_NESTING * 2];
TCHAR ptchSym [FILENAMELENGTH];
int i;
int iMinimumDepth;
// TCHAR ptchCallerSym [FILENAMELENGTH];
ULONG ulSymbolAddress;
if (fDumpAll)
{
pChronoCell = pthdblk->pChronoHeadCell;
cChars += sprintf(lpstrBuff + cChars,
"\n\n------------------------------------------------"
"------------------------------------------------"
"----------------------------------------\r\n\n"
" Complete Dump of Chronological Listings\n\n"
" Sym Address [+Callee] [-Callee] Nesting Depth"
" <RepCnt> - Symbol Name\n"
" ___________ _________ _________ _____________"
" ______________________\n\n");
}
else
{
pChronoCell = * ppChronoCell;
cChars += sprintf(lpstrBuff + cChars,
"\n\n------------------------------------------------"
"------------------------------------------------"
"----------------------------------------\r\n\n"
" Dump Chrono listing for Entry:"
" %-*.*s\n\n"
" Sym Address [+Callee] [-Callee] Nesting Depth"
" <RepCnt> - Symbol Name\n"
" ___________ _________ _________ _____________"
" ______________________\n\n",
iNameLength,
iNameLength,
GetFunctionName(pChronoCell->ulSymbolAddr,
ulLocProfBlkOff,
NULL));
}
iMinimumDepth = pChronoCell->nNestedCalls;
do
{
//
// Get the symbol name using the function address
//
strcpy(ptchSym, GetFunctionName (pChronoCell->ulSymbolAddr,
ulLocProfBlkOff,
&ulSymbolAddress));
// The following caller's symbol somehow could not currently be
// correctly resolved. More investigation to figure out how
// BUGBUG
// strcpy(ptchCallerSym, GetFunctionName (
// pChronoCell->ulCallRetAddr,
// MKPPROFBLK(ulLocProfBlkOff)));
pIndentation[0] = '\0';
for (i = 0 ; i < pChronoCell->nNestedCalls ; i++)
{
strcat(pIndentation, " ");
}
liElapsed = pChronoCell->liElapsed;
if (liElapsed == 0L)
{
liRealTime = liElapsed;
}
else
{
liRealTime = liElapsed - pChronoCell->liCallees;
}
AdjustTime (&liRealTime, &chRealTimeSuffix);
AdjustTime (&liElapsed, &chElapsedSuffix);
// Setup our string
cChars += sprintf (
lpstrBuff + cChars,
" <%8lx> %9lu%1c %9lu%1c%s%3d "
"<%2d> %-*.*s\n",
ulSymbolAddress,
(ULONG)liElapsed, chElapsedSuffix,
(ULONG)liRealTime, chRealTimeSuffix,
pIndentation,
pChronoCell->nNestedCalls,
pChronoCell->nRepetitions,
iNameLength,
iNameLength,
ptchSym);
if (cChars > BUFFER_SIZE)
{
if ( !WriteFile(hOutFile, lpstrBuff, cChars, &cChars, NULL))
{
CapDbgPrint ("CAP: DumpChronoFuncs() - ChronoDump - "
"Error writing to %s - 0x%lx\n",
atchOutFileName, GetLastError());
}
cChars = 0;
}
pChronoCell++;
}
while ( (pChronoCell->ulSymbolAddr != 0L) && // End Of list?
((pChronoCell->nNestedCalls > iMinimumDepth) || // Nest ?
(fDumpAll)) ); // Override
if (cChars) // if Count is not 0, we have to flush everything
{
if ( !WriteFile (hOutFile, lpstrBuff, cChars, &cChars, NULL) )
{
CapDbgPrint ("CAP: DumpChronoFuncs() - "
"Error writing to %s - 0x%lx\n",
atchOutFileName, GetLastError());
}
cChars = 0;
}
*ppChronoCell = pChronoCell;
} /* DumpChronoEntry */
