void CPathFinder::Reset()
{
if (VerifyMemory())
{
for (int i = 0; i < DIM; i++)
{
for (int j = 0; j < DIM; j++)
m_graph[i][j] = 0;
}
}
memset(&m_ptLevelLeftTop, 0, sizeof(POINT));
memset(&m_ptAbsDest, 0, sizeof(POINT));
memset(&m_ptRelDest, 0, sizeof(POINT));
memset(&m_rightBottom, 0, sizeof(POINT));
m_lefttTop.x = DIM;
m_lefttTop.y = DIM;
m_aSearched.RemoveAll();
}
/**
Test a range of the memory directly .
@param[in] Private Point to generic memory test driver's private data.
@param[in] StartAddress Starting address of the memory range to be tested.
@param[in] Length Length in bytes of the memory range to be tested.
@param[in] Capabilities The bit mask of attributes that the memory range supports.
@retval EFI_SUCCESS Successful test the range of memory.
@retval Others Failed to test the range of memory.
**/
EFI_STATUS
DirectRangeTest (
IN GENERIC_MEMORY_TEST_PRIVATE *Private,
IN EFI_PHYSICAL_ADDRESS StartAddress,
IN UINT64 Length,
IN UINT64 Capabilities
)
{
EFI_STATUS Status;
//
// Perform a dummy memory test, so directly write the pattern to all range
//
WriteMemory (Private, StartAddress, Length);
//
// Verify the memory range
//
Status = VerifyMemory (Private, StartAddress, Length);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Add the tested compatible memory to system memory using GCD service
//
gDS->RemoveMemorySpace (
StartAddress,
Length
);
gDS->AddMemorySpace (
EfiGcdMemoryTypeSystemMemory,
StartAddress,
Length,
Capabilities &~(EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED | EFI_MEMORY_TESTED | EFI_MEMORY_RUNTIME)
);
return EFI_SUCCESS;
}
/**
Perform the memory test.
@param[in] This The protocol instance pointer.
@param[out] TestedMemorySize Return the tested extended memory size.
@param[out] TotalMemorySize Return the whole system physical memory size.
The total memory size does not include memory in a slot with a disabled DIMM.
@param[out] ErrorOut TRUE if the memory error occured.
@param[in] IfTestAbort Indicates that the user pressed "ESC" to skip the memory test.
@retval EFI_SUCCESS One block of memory passed the test.
@retval EFI_NOT_FOUND All memory blocks have already been tested.
@retval EFI_DEVICE_ERROR Memory device error occured, and no agent can handle it.
**/
EFI_STATUS
EFIAPI
GenPerformMemoryTest (
IN EFI_GENERIC_MEMORY_TEST_PROTOCOL *This,
OUT UINT64 *TestedMemorySize,
OUT UINT64 *TotalMemorySize,
OUT BOOLEAN *ErrorOut,
IN BOOLEAN TestAbort
)
{
EFI_STATUS Status;
GENERIC_MEMORY_TEST_PRIVATE *Private;
EFI_MEMORY_RANGE_EXTENDED_DATA *RangeData;
UINT64 BlockBoundary;
Private = GENERIC_MEMORY_TEST_PRIVATE_FROM_THIS (This);
*ErrorOut = FALSE;
RangeData = NULL;
BlockBoundary = 0;
//
// In extensive mode the boundary of "mCurrentRange->Length" may will lost
// some range that is not Private->BdsBlockSize size boundry, so need
// the software mechanism to confirm all memory location be covered.
//
if (mCurrentAddress < (mCurrentRange->StartAddress + mCurrentRange->Length)) {
if ((mCurrentAddress + Private->BdsBlockSize) <= (mCurrentRange->StartAddress + mCurrentRange->Length)) {
BlockBoundary = Private->BdsBlockSize;
} else {
BlockBoundary = mCurrentRange->StartAddress + mCurrentRange->Length - mCurrentAddress;
}
//
// If TestAbort is true, means user cancel the memory test
//
if (!TestAbort && Private->CoverLevel != IGNORE) {
//
// Report status code of every memory range
//
RangeData = AllocateZeroPool (sizeof (EFI_MEMORY_RANGE_EXTENDED_DATA));
if (RangeData == NULL) {
return EFI_OUT_OF_RESOURCES;
}
RangeData->DataHeader.HeaderSize = (UINT16) sizeof (EFI_STATUS_CODE_DATA);
RangeData->DataHeader.Size = (UINT16) (sizeof (EFI_MEMORY_RANGE_EXTENDED_DATA) - sizeof (EFI_STATUS_CODE_DATA));
RangeData->Start = mCurrentAddress;
RangeData->Length = BlockBoundary;
REPORT_STATUS_CODE_EX (
EFI_PROGRESS_CODE,
EFI_COMPUTING_UNIT_MEMORY | EFI_CU_MEMORY_PC_TEST,
0,
&gEfiGenericMemTestProtocolGuid,
NULL,
(UINT8 *) RangeData + sizeof (EFI_STATUS_CODE_DATA),
RangeData->DataHeader.Size
);
//
// The software memory test (R/W/V) perform here. It will detect the
// memory mis-compare error.
//
WriteMemory (Private, mCurrentAddress, BlockBoundary);
Status = VerifyMemory (Private, mCurrentAddress, BlockBoundary);
if (EFI_ERROR (Status)) {
//
// If perform here, means there is mis-compare error, and no agent can
// handle it, so we return to BDS EFI_DEVICE_ERROR.
//
*ErrorOut = TRUE;
return EFI_DEVICE_ERROR;
}
}
mTestedSystemMemory += BlockBoundary;
*TestedMemorySize = mTestedSystemMemory;
//
// If the memory test restart after the platform driver disable dimms,
// the NonTestSystemMemory may be changed, but the base memory size will
// not changed, so we can get the current total memory size.
//
*TotalMemorySize = Private->BaseMemorySize + mNonTestedSystemMemory;
//
// Update the current test address pointing to next BDS BLOCK
//
mCurrentAddress += Private->BdsBlockSize;
return EFI_SUCCESS;
}
//
// Change to next non tested memory range
//
mCurrentLink = mCurrentLink->ForwardLink;
if (mCurrentLink != &Private->NonTestedMemRanList) {
mCurrentRange = NONTESTED_MEMORY_RANGE_FROM_LINK (mCurrentLink);
mCurrentAddress = mCurrentRange->StartAddress;
return EFI_SUCCESS;
} else {
//
// Here means all the memory test have finished
//
*TestedMemorySize = mTestedSystemMemory;
*TotalMemorySize = Private->BaseMemorySize + mNonTestedSystemMemory;
return EFI_NOT_FOUND;
}
}
BYTE CPathFinder::CalculatePathTo(WORD x, WORD y, LPPATH lpBuffer, int nAdjust)
{
if (lpBuffer == NULL || x == 0 || y == 0 || !VerifyMemory())
return 0;
memset(lpBuffer, 0, sizeof(PATH));
lpBuffer->posStart = GetPosition();
if (lpBuffer->posStart.x == 0 || lpBuffer->posStart.y == 0)
return 0;
if (!Search())
return 0;
//GameInfof("Mapsize %d, %d", m_rightBottom.x - m_lefttTop.x, m_rightBottom.y - m_lefttTop.y);
m_ptAbsDest.x = x;
m_ptAbsDest.y = y;
m_ptRelDest = m_ptAbsDest;
MapToGraph(m_ptRelDest);
//GameInfof("des %d, %d", m_ptRelDest.x, m_ptRelDest.y);
// verify destination, see if it's in our map
if (!IsValidPos(m_ptRelDest))
return 0;
MakeMap2();
//DumpMap2();
POINT pos;
pos.x = (short)lpBuffer->posStart.x;
pos.y = (short)lpBuffer->posStart.y;
lpBuffer->iNodeCount = 0;
BOOL bOK = FALSE;
int nRes = GetBestMove(pos, nAdjust);
while (nRes != PATH_FAIL && lpBuffer->iNodeCount < 255)
{
// Reached?
if (nRes == PATH_REACHED)
{
bOK = TRUE;
lpBuffer->aPathNodes[lpBuffer->iNodeCount].x = x;
lpBuffer->aPathNodes[lpBuffer->iNodeCount].y = y;
lpBuffer->iNodeCount++;
break; // Finished
}
// Perform a redundancy check
int nRedundancy = GetRedundancy(lpBuffer, pos);
if (nRedundancy == -1)
{
// no redundancy
lpBuffer->aPathNodes[lpBuffer->iNodeCount].x = (WORD)pos.x;
lpBuffer->aPathNodes[lpBuffer->iNodeCount].y = (WORD)pos.y;
lpBuffer->iNodeCount++;
}
else
{
// redundancy found, discard all redundant steps
lpBuffer->iNodeCount = nRedundancy + 1;
lpBuffer->aPathNodes[lpBuffer->iNodeCount].x = (WORD)pos.x;
lpBuffer->aPathNodes[lpBuffer->iNodeCount].y = (WORD)pos.y;
}
nRes = GetBestMove(pos, nAdjust);
}
if (!bOK)
{
lpBuffer->iNodeCount = 0;
}
else
{
lpBuffer->posEnd.x = x;
lpBuffer->posEnd.y = y;
}
//DumpMap1(lpBuffer); // debug pictures
return lpBuffer->iNodeCount;
}
