-*- coding: utf-8 -*- 2011-05-14 The following is the file from my computer at 〔c:/Program Files/PC-Doctor for Windows/pcdrmemory.p5p〕. It is copied here for educational and archiving purposes. See: 〈Windows Blue Screen of Death〉 http://xahlee.org/mswin/blue_screen_of_death.html ────────── ────────── ────────── ────────── ────────── /* * * COPYRIGHT© 1993-2008 PC-Doctor, Inc. ALL RIGHTS RESERVED. * * * PC-Doctor is a trademark of PC-Doctor, Inc., Reno, NV. * All other brand and product names are registered trademarks, * trademarks or servicemarks their respective holders and are gratefully * acknowledged. Product specifications subject to change without notice. * * * * All PC-Doctor® products are protected by one or more of the following * patents: 6,742,148; 6,792,562; 6,829,726. Other patents pending. * * * * Module: pcdrmemory * Customer: default * Variant: * OS: windows * * * * @author Automatically Generated from the Database * * * * THIS FILE WAS MACHINE GENERATED FROM THE DATABASE * DO NOT MODIFY THIS FILE, IT WILL BE OVER-WRITTEN DURING * COMPILATION */ Module.Company = PC-Doctor, Inc. Module.Description = This module tests the system memory. Module.Help_Concept =

Memory or Random Access Memory (RAM) is the computer's workspace that allows programs to run efficiently and helps the CPU process data. PCs use memory as temporary storage for fast access and retrieval of frequently used data. Think of memory as a very small but very fast hard drive where the data is erased when the computer is turned off.

The Memory Test verifies the integrity of your PC's memory using two different patterns tests. These patterns verify the memory stores and retrieves data correctly. Before running this test, shut down all other programs.

Note: The Memory Test resides in a small portion of memory. For this reason, the Memory Test can not test the entire range of memory.


Understanding how Memory Mapped I/O affects Memory Capacity

32-bit versions of Windows (or a CPU running in 32-bit mode) utilize system memory differently than 64-bit versions of Windows that can affect the overall capacity of installed memory. Windows can only address up to 4 GB of memory on 32-bit systems. Additionally, many add-in cards and on-board controllers are accessible to the operating system only through assigned memory addresses. This is called Memory Mapped I/O (MMIO).

For example, an installed video card with 256 MB of on-board video memory needs to have that memory mapped to the system memory so that the system can perform reads and writes to the on-board video card memory. Since this memory range has to lie within the 4 GB range, the total amount of memory installed on the video card is subtracted from the installed and available system memory.

This issue is more specifically related to the hardware architecture (x86) as opposed to the operating system. Modern computers utilize a method for addressing peripheral devices conceptually similar to the old Upper Memory Area (UMA) of memory reserved for peripheral device addressing. Many of the original UMA MMIO reserved areas still exist today (for example, to support DOS backwards compatibility). This will substantially affect the amount of available system memory if 4 GB of system memory is installed on a 32-bit system. For example, system information may report only 3.25 GB of available system memory even though 4 GB is installed.

For more information on MMIO and the affect on 32-bit systems, click here

Note: All 32-bit versions of Windows Vista limit the total available memory to 3.12 GB.

Module.Name = Memory Test Module.Tipkeys = pcdrmemory_helpctr Test.PatternTest.Description = Verifies memory can accurately retain data using a default set of test patterns. Test.PatternTest.Help_Concept =

This test uses eighteen test patterns to test memory locations by writing each predefined pattern, one by one, into memory. After writing the pattern, the test reads the memory to make sure the pattern is written correctly. If the test detects a mismatch in data, it reports the address of the failing block in the test log and logs the test as Failed.

Test.PatternTest.Name = Pattern Test Test.AdvancedPatternTest.Description = Verifies memory cell corruption does not occur from read/write activity on adjacent cells. Test.AdvancedPatternTest.Help_Concept =

This test checks for memory cell corruption from read/write activity on adjacent cells (cells are individual bits). It is run from memory address 0 through each memory cell sequentially to the top of extended memory, then from the top down to memory address 0.

Note: This test will only run on Extended Memory.

Each version of the Windows operating system has an absolute minimum amount of physical memory that must be available to it at all times. The Advanced Pattern Test can cause a lot of paging, which can lead to a test time in excess of several hours.

Warning!: This test will stop and record a result of Cannot Run in the test log if the minimum available memory falls below 20 MB. This is only a factor when running the System Stress Test, which includes the Advanced Pattern Test.

Test.AdvancedPatternTest.Name = Advanced Pattern Test Event.CannotAllocateMemory.EventCode = 18 Event.CannotAllocateMemory.Message = Memory allocation error Event.CannotAllocateMemory.Tipkeys = ManualOnOff Event.PatternMismatch.EventCode = 557 Event.PatternMismatch.Message = Incorrect data at offset {PhysicalAddressInHex}H ({PhysicalAddressInDecimal}) Wrote pattern {WritePattern}H, read back pattern {ReadPattern}H Event.TooManyErrors.EventCode = 842 Event.TooManyErrors.Message = Too many errors. Test canceled. Event.NoEnoughMemory.EventCode = 1235 Event.NoEnoughMemory.Message = Not enough memory. Event.SwapSizeTooSmall.EventCode = 1079 Event.SwapSizeTooSmall.Message = Swap file too small to perform test. Event.FailToReadSwapSize.EventCode = 91 Event.FailToReadSwapSize.Message = Error reading swap file size. Event.CannotOpenDriver.EventCode = 170 Event.CannotOpenDriver.Message = Unable to open driver! LocalizedString.ProgInfo = Testing {TotalBlocks} KB block - current pattern is {PatternDone} of {TotalPatterns} ({CurrentPattern}H). Tip.pcdrmemory_helpctr.Content = RAM Tip.pcdrmemory_helpctr.ContentEx = Search "Help and Support Center" Tip.pcdrmemory_helpctr.Type = HELP_AND_SUPPORT_TIP Test.Modulo20Test.Description = Verifies the memory can accurately write data to specific locations. Test.Modulo20Test.Help_Concept =

This test is a variation of the Pattern Test. The test starts by writing a test pattern to every 20th address location in the memory location and writes the compliment of that pattern to all other locations. For example, if the pattern is 0000 0000H, the test will write 00000000H to addresses 00000000H, 00000014H, 00000028H, 0000003CH and so on. For all other address locations (00000001H, 00000002H, 00000003H and so on) the test will write FFFFFFFFH. Once the test finishes writing to all available memory locations, it reads the data from the tested memory locations to verify the written and read data match. If the test detects any mismatch in data, it logs as Failed.

Test.Modulo20Test.Name = Modulo20 Test Test.MovingInversionTest.Description = Verifies memory can accurately shift data from address to address. Test.MovingInversionTest.Help_Concept =

This test is a 32-bit inversion test that starts by writing a data pattern to the first available address in the memory space. Once the test pattern is written, the test shifts the data pattern left one bit to the next available address, continuing in this fashion until the test has shifted the test pattern through all available addresses. The test then reads all the memory bits to verify the written and read data match. If the test detects any mismatches in data, it logs as Failed.

Note: The Moving Inversion Test is very effective at detecting data sensitive errors but the execution time is long.

Test.MovingInversionTest.Name = Moving Inversion Test Event.NoFailedMemoryDiagEventsFound.EventCode = 730 Event.NoFailedMemoryDiagEventsFound.Message = No failed memory diagnostic results were found in the event log. Event.NoMemoryDiagEventsFound.EventCode = 713 Event.NoMemoryDiagEventsFound.Message = No memory diagnostic results were found in the event log. Event.NoMemoryDiagEventsFound.Tipkeys = LaunchMemoryDiagScheduler Event.FailedMemoryDiagEventFound.EventCode = 745 Event.FailedMemoryDiagEventFound.Message = A failed memory diagnostic result was logged in the system event log on {date}. Test.WindowsMemoryTest.Description = Searches system event log for OS memory diagnostic results. Test.WindowsMemoryTest.Help_Concept =

This test verifies any passed or failed diagnostic results occurring in the test log are valid based on a configured date. The test filters out events found in the log that are older than X number of days (specified in the pcdrmemory.p5i file). If the test is unable to locate any memory diagnostic results, it records N/A in the test log and prompts the user to launch the operating system memory diagnostic scheduler. If the test finds only passed memory diagnostic results, it records Passed in the test log. If the test finds any failed memory diagnostic results, it records a WARNING in the test log, pointing out that a memory diagnostic failed on a certain date.

Test.WindowsMemoryTest.Name = Windows Memory Test Tip.LaunchMemoryDiagScheduler.Content = Launch OS Memory Diagnostic Scheduler Tip.LaunchMemoryDiagScheduler.ContentEx = applauncher mdsched Tip.LaunchMemoryDiagScheduler.Type = APP_LAUNCHER_TIP Event.PERCENT_FREE_MEMORY_TO_TEST_INVALID_PARAM.Description = The percentFreeMemoryToTest was set incorrectly Event.PERCENT_FREE_MEMORY_TO_TEST_INVALID_PARAM.EventCode = 761 Event.PERCENT_FREE_MEMORY_TO_TEST_INVALID_PARAM.Message = Invalid parameter: The percentFreeMemoryToTest parameter needs to be between 1 and 100 Event.PERCENT_FREE_MEMORY_TO_TEST_INVALID_PARAM.Name = PERCENT_FREE_MEMORY_TO_TEST_INVALID_PARAM Event.AVAILABLE_MEMORY_TOO_LOW.Description = AVAILABLE_MEMORY_TOO_LOW Event.AVAILABLE_MEMORY_TOO_LOW.EventCode = 780 Event.AVAILABLE_MEMORY_TOO_LOW.Message = The available free memory is too low to run memory stress test. The expected available free memory is minimum of 20 MB. Event.AVAILABLE_MEMORY_TOO_LOW.Name = AVAILABLE_MEMORY_TOO_LOW Event.PatternMismatchDetailed.EventCode = 781 Event.PatternMismatchDetailed.Message = {message} LocalizedString.FailureAddress = Memory read-write error at physical address {PhysicalAddressInHex}H. LocalizedString.FailureUnknownAddress = Memory read-write error. LocalizedString.FailurePattern = Wrote pattern {WritePattern}H, read back pattern {ReadPattern}H. LocalizedString.FailureLocation = SMBIOS indicates the failed address is on "{ChipDescription}". Parameter.displaySMBIOSInfo.Description = If the information contained in the SMBIOS Type 17 and Type 20 structures seems correct, then the test will associate a failure at a physical address with the memory device described in the SMBIOS tables. Parameter.displaySMBIOSInfo.Name = Display SMBIOS Memory Information Test.BitLowTest.Description = Verifies all memory bits can switch to a low value. Test.BitLowTest.Help_Concept =

This test sets all memory bits to zero then reads each bit value. If a read bit value is not zero, the test logs as Failed. The test loops from low address to high address for all available pages.

Test.BitLowTest.Name = Bit Low Test Test.BitHighTest.Description = Verifies all memory bits can switch to a high value. Test.BitHighTest.Help_Concept =

This test loops from low address to high address for all available pages, sets all memory bits to one, then reads each bit value. If a read bit value is not one, the test logs as Failed.

Test.BitHighTest.Name = Bit High Test Test.CheckerboardTest.Description = Verifies all memory bits can switch from high to low values without error. Test.CheckerboardTest.Help_Concept =

This test writes a checkerboard pattern to a memory address, switching all bits to a value of 01010101, then switching all bits to a value of 10101010. The test then loops from low address to high address for all available pages and reads each bit value in the address. If the bit values in the address are inconsistent, the test logs as Failed.

Test.CheckerboardTest.Name = Checkerboard Test Test.WalkingOneLeftTest.Description = Verifies memory can switch a bit value from zero to one and back to zero, testing from right to left one bit at a time. Test.WalkingOneLeftTest.Help_Concept =

This test starts by setting all bits in a byte to a value of zero. One at a time from right to left, each bit is set to a value of one and back to zero. The test then reads each bit value in the byte. If the bit values in the byte are inconsistent, the test logs as Failed. The test loops from low address to high address for all available pages.

Test.WalkingOneLeftTest.Name = Walking One Left Test Test.WalkingOneRightTest.Description = Verifies memory can switch a bit value from zero to one and back to zero, testing from left to right one bit at a time. Test.WalkingOneRightTest.Help_Concept =

This test starts by setting all bits in a byte to a value of zero. One at a time from left to right, each bit is set to a value of one and back to zero. The test then reads each bit value in the byte. If the bit values in the byte are inconsistent, the test logs as Failed. The test loops from low address to high address for all available pages.

Test.WalkingOneRightTest.Name = Walking One Right Test Test.AddressTest.Description = Verifies memory locations contain unique address values. Test.AddressTest.Help_Concept =

This test fills each memory location with its own address value, then reads each memory location to verify it contains its own unique address value. If there is any inconsistency between the address value and the value written to the memory location, the test logs as Failed.

Test.AddressTest.Name = Address Test Test.NibbleMoveTest.Description = Verifies memory can accurately change the value from low to high 4-bits at a time. Test.NibbleMoveTest.Help_Concept =

This test loops from low address to high address for all available pages, sets a nibble to both high and low values one address at a time, then reads each individual bit value in the nibble (a nibble is four bits). If the bit values in the nibble are inconsistent, the test logs as Failed.

Test.NibbleMoveTest.Name = Nibble Move Test LocalizedString.MEMORY_PROGRESS = Writing pattern {PATTERN_NAME} from physical address {START_ADDRESS}H to {END_ADDRESS}H in all 20th locations LocalizedString.MEMORY_PROGRESS_NO_PHYSICAL = Writing pattern {PATTERN_NAME} to {TOTAL_BLOCK}KB blocks of memory LocalizedString.MEMORY_PROGRESS_NO_20TH = Writing pattern {PATTERN_NAME} from physical address {START_ADDRESS}H to {END_ADDRESS}H in all except 20th locations LocalizedString.VERIFY_PATTERN = Verifying written pattern {PATTERN_NAME} from physical address {START_ADDRESS}H to {END_ADDRESS}H in all 20th locations LocalizedString.VERIFY_PATTERN_NO_20TH = Verifying written pattern {PATTERN_NAME} from physical address {START_ADDRESS}H to {END_ADDRESS}H in all except 20th location Test.AuxiliaryPatternsTest.Description = Uses supplemental test patterns that are not used in the Patterns Test. Test.AuxiliaryPatternsTest.Help_Concept =

This test fills each memory location with extra data patterns that supplement patterns used in other tests. The test then reads each memory location to verify the patterns were written correctly. If there is any inconsistency between the written data and read data, the test logs as Failed.

Test.AuxiliaryPatternsTest.Name = Auxiliary Pattern Test LocalizedString.PRODUCT_NAME = default Parameter.bEnableOptimizations.Description = Enable optimizations Parameter.bEnableOptimizations.Name = Enable optimizations Parameter.bNaIfSwapFileLessThanPhys.Description = Return N/A if swap file is less than physical memory Parameter.bNaIfSwapFileLessThanPhys.Name = Is swap file less than physical Parameter.iMBToLeaveFree.Description = Mega Bytes to leave free Parameter.iMBToLeaveFree.Name = Mega Bytes to leave free Parameter.bSavePhysicalAddresses.Description = Save physical addresses Parameter.bSavePhysicalAddresses.Name = Save physical addresses Parameter.percentFreeMemoryToTest.Description = Percent free memory to test Parameter.percentFreeMemoryToTest.Name = Percent free memory to test Parameter.QuitOnFirstFailedMemoryDiagEvent.Description = Quit on first failed memory diag event Parameter.QuitOnFirstFailedMemoryDiagEvent.Name = Quit on first failed memory diag event Parameter.MemoryDiagEventDayFilter.Description = Memory diag event day filter Parameter.MemoryDiagEventDayFilter.Name = Memory diag event day filter Parameter.ErrorLimit.Description = The maximum number of errors before returning fail result Parameter.ErrorLimit.Name = Error limit Help.MemoryMappedIO.Content =

32-bit versions of Windows (or a CPU running in 32-bit mode) utilize system memory differently than 64-bit versions of Windows that can affect the overall capacity of installed memory. Windows can only address up to 4 GB of memory on 32-bit systems. Additionally, many add-in cards and on-board controllers are accessible to the operating system only through assigned memory addresses. This is called Memory Mapped I/O (MMIO).

For example, an installed video card with 256 MB of on-board video memory needs to have that memory mapped to the system memory so that the system can perform reads and writes to the on-board video card memory. Since this memory range has to lie within the 4 GB range, the total amount of memory installed on the video card is subtracted from the installed and available system memory.

This issue is more specifically related to the hardware architecture (x86) as opposed to the operating system. Modern computers utilize a method for addressing peripheral devices conceptually similar to the old Upper Memory Area (UMA) of memory reserved for peripheral device addressing. Many of the original UMA MMIO reserved areas still exist today (for example, to support DOS backwards compatibility). This will substantially affect the amount of available system memory if 4 GB of system memory is installed on a 32-bit system. For example, system information may report only 3.25 GB of available system memory even though 4 GB is installed.

For more information on MMIO and the affect on 32-bit systems, click here

Note: All 32-bit versions of Windows Vista limit the total available memory to 3.12 GB.

Help.MemoryMappedIO.Name = Understanding how Memory Mapped I/O affects Memory Capacity