Even so, the 386's implementation of protected mode was more reliable and easier to set up than the 286's was, I believe.
The i386 supported 4KB paged virtual memory in a flat 32-bit virtual and physical address space and it was possible for the 386 to switch back to real mode from protected mode. This made it possible for its memory management to be largely compatible with contemporary CPUs. The i286 on the other hand was a 16-bit CPU that supported segmented virtual memory of up to 1GB within a 24MB physical address space and it couldn't switch back to real mode by itself.
So, if you're unfamiliar with i286 segmentation, here's a short explanation:
The 8086 was a 16-bit CPU with a 1MB address range and it achieved this using a technique called
segmentation. Memory pointers could only address up to 64KB at a time, but whenever you tried to access memory it would add one of 4 different 16-bit segment registers multiplied by 16. Hence a complete address was always:
aSegmentRegister*16+
aPointer and so the maximum address was 65535*16+65535 = 1114095, which is nearly 1MB+64KB, but that last 64KB would simply wrap around back to the beginning of memory. There were 4 segment registers, one for code (CS), one for data (DS), one for the stack (SS) and an Extra one for copying memory between arbitrary memory regions (ES).
The 68000 by contrast simply supported 32-bit pointers that could in theory address 4GB, but the address signals limited it to 24-bits giving 16MB. Very much simpler!
The 80286 was its true successor and introduced protected mode. The 4 segment registers were kept, but instead of them being multiplied by 16 they indexed a long table in RAM (called the descriptor table) which contained a full 24-bit base pointer and a 16-bit length value. So, now memory addresses were computed as: DescriptorTable[
aSegmentRegister].base+
aPointer. For 'speed', 6 of the descriptor table entries were cached in the processor too. There were actually at least 3 description tables: the global descriptor table, the local descriptor table and the interrupt descriptor table.
So, this was an awful way to manage virtual memory, because well firstly, the segmentation was now incompatible with the 8086 and secondly, when virtual memory segments of were placed in physical memory, they could all be completely different sizes, so when it came to swapping out segments and swapping in new ones from disk, it could easily involve lots of shuffling around of existing segments or swapping out multiple segments or leaving gaps in physical memory where they didn't align.
In other words Intel turned a poor scheme into a dreadful scheme. It was so bad, that it's really hard to find an Intel 80286 OS that used VM properly. Even Windows 3.1 (in standard mode) didn't manage it, they just treated protected mode as a means of accessing 16MB of physical RAM.
The 80386 fixed this. It supported the segments, but all programmers did was set them all to 0 and then activated page mode. The segmentation just became a waste of transistors, but at least it was simpler to access.
Because 386 paging is pretty similar to 68030 paging, 386 page mode emulation is easier than 286 emulation.
