Parity Errors in Windows 3.x (93521)

MORE INFORMATION

Parity is a very basic check of information integrity. Each byte (8 bits) of RAM storage actually takes nine bits of information. Eight bits are used for the data and the last bit (the "parity bit") is used to store the parity of the data.

The processor is in charge of checking the accuracy of the parity bit, and the processor generates an NMI if it determines that the parity bit is set incorrectly. In Windows 386 enhanced mode, this is captured by a Virtual Device Driver (VDD), *parity, which displays an error message. In Windows Standard Mode, NMIs are ignored and passed to the default parity handler. This either does nothing or generates a TTY (full screen) error message. In both cases, the machine is in an unstable state and is halted.

Parity errors can seem to be resolved if you remove a memory-resident item, such as a device driver or terminate-and-stay-resident (TSR) program. This only changes the memory location of load code. If you change the location or remove an item, then the code no longer resides on the faulty memory and you may no longer receive a parity error. If data resides the suspect memory, you might not see a parity error at all. Unfortunately, since data and code in Windows changes memory locations constantly, the parity error might appear (or reappear) later.

In Windows, memory is commonly allocated with a flag to initialize the memory to zero. This makes the parity even (zero ones set in the data byte). If there is a faulty memory chip where the value of a bit is always set to zero, then everything functions normally as nothing is written to that memory (because the parity bit is correct). If the faulty memory address falls in a code segment (that is, the memory is going to store actual, executable code) it is likely that the bit will be used and a parity error will be generated.

A parity error can be caused by different circumstances but it is almost always a hardware problem.

Common Causes of Parity Errors

One cause of parity errors is faulty memory. The most foolproof way to resolve this problem is to swap out each piece of memory until the problem disappears. Make sure you are using good, quality memory and the memory is properly seated in the computer. Memory checking programs are not adequate because they don't test the memory the way that Windows uses it. Most, if not all, memory checkers use read/write cycles when scanning memory. Since Windows is executing code from the memory, it uses execute cycles. Execute cycles are physically different from read/write cycles and are more vulnerable to parity errors. It is possible for memory checking programs to find parity errors if the memory is extremely faulty.

Sometimes parity errors are caused by mismatched memory speeds. The CPU might be accessing the memory faster than the memory is capable of handling requests. A possible workaround is to increase the number of wait states in the CMOS setup. This option is not available on all machines and doesn't always work. In short, increasing the number of wait states directs the CPU to wait for a predetermined amount of time between memory reads. This slows the machine down because it now takes longer to access memory. Generally, this option can be set to Zero, One, or Two wait states. The higher the number, the longer it waits between memory cycles. In addition, try to keep the same speed of RAM installed in your computer. If you have to mix speeds, make sure that you have the same speed RAM installed in each Bank. Banks are usually sets of four memory chips on the motherboard.

Supporting hardware, like video cards, can often cause parity errors. Because the devices occupy memory in the UMB, read/write data to these devices can also cause parity errors. The best way test this is to replace the device with one that is working correctly. Also faulty power supplies can cause parity errors.

Another known cause for parity errors is the PARITY BOOT B Virus.

What is Parity?

There are two versions of Parity: Odd and Even. The Parity BIT is set on or off depending on the count of ON bits, or 1's, in the data, usually a byte.

Examples

11011010 (Parity would be set to 1 to make the number of ones even.)

11110111 (Parity would be set to 0 to make the number of ones odd.)

Memory for the PC is designed such that there is an extra chip, or extra BIT, set aside for parity. This chip will hold the parity for a byte of memory. This is why there is often 9 chips on a memory SIMM, or the chips themselves are labeled 256x9's or 1Megx9's, and so on.

A parity error will be generated when a piece of code is executed in a faulty memory address. During the fetch or pre-fetch cycle of the CPU, the point where the CPU receives an instruction from memory to execute, the hardware checks the fetched code for parity. If that fetch fails, an exception error is generated. This is done to safe-guard the CPU from executing an instruction that is not viable.

During a regular memory fetch, that is, data reads, parity is not checked. This is why a memory checker will normally be unable to find parity errors. The only program that will check memory for parity problems correctly is a program that executes code in the RAM addresses in question. Windows 3.0 and 3.1 are such programs. In Windows 3.0, the mechanism for checking parity errors did not function correctly and instead generated UAE's. These UAE's were a result of the parity errors not being caught and the code continuing to run in the faulty memory.

NOTE: You cannot check memory for parity problems by creating a RAMDRIVE, copying a program to it, and executing the program. The program is still stored as data in the RAMDRIVE. When run, the program is copied into conventional memory before it is executed. For information on how to use a RAMDRIVE to troubleshoot memory, please see the following article(s) in the Microsoft Knowledge Base: