From: S_JUFFA@IRAV1.ira.uka.de (|S| Norbert Juffa) Newsgroups: comp.sys.ibm.pc.hardware,comp.sys.intel Subject: Compatibility issues Cyrix 486DLC/Intel 486SX w/ regard to NeXTstep OS Message-ID: 1j699uINN8qg@iraul1.ira.uka.de Date: 15 Jan 1993 12:05:18 GMT Organization: University of Karlsruhe, FRG Lines: 550
Compatibility issues Cyrix Cx486SLC/DLC as compared to the Intel 80486SX
There has been quite a bit of discussion here recently about compatibility issues involving the Cyrix Cx486SLC and Cx486DLC processors, in particular about the fact that the NextStep operating system doesn't run on the Cyrix processors for some reason. During the course of this discussion, we have heard *a lot of opinions* (e.g. "Intel sucks", "Cyrix sucks") but only *few facts*. So I thought it might a good idea to throw in a bit of the latter. I'll try to give the facts as accurate as possible, drawing from personal experience and Intel's and Cyrix' literature on the 80486DX/SX and 486DLC/SLC. If you think you have found erroneous information, feel free to contact me:
S_JUFFA@IRAVCL.IRA.UKA.DE (Norbert Juffa)
NOTE: I have no affiliation whatsoever with either Intel or Cyrix!
The Cyrix 486DLC is a replacement chip for the Intel/AMD 80386DX. The Cyrix 486SLC is a replacement chip for the Intel/AMD 386SX. While the internals of the Cyrix 486SLC/DLC are roughly equivalent to those in the Intel 80486SX, the bus interface of these chips is identical to that of the Intel 80386DX and 80386SX CPUs, respectively to allow easy replacement of the Intel CPUs by the Cyrix chips. This also means that the Cx486SLC, as a replacement for the Intel/AMD 80386SX can only address 16 MB of memory.
The 486SLC/DLC CPUs have a register set that is identical to that found on the Intel 80486SX. However, there are a few subtle differences in the meaning of certain bits in some systems registers (e.g. cache test registers). These are covered in more details below. The instruction sets of the Intel 486SX and the Cyrix Cx486SCL/DLC are identical. The execution times of specific instructions differ between the two chips, but the overall execution speed (measured in CPI = clocks per instruction) seems to be about same.
On both, the Intel 80486SX and the Cyrix 486SLC/DLC, there is *no* on-chip FPU (floating point unit). To add floating point capabilities to a 486SX based system, one would install an 487 'coprocessor', which is basically a 486DX with a slighty different pin-out, or replace the 486SX with an OverDrive processor, a clock-doubled 486DX with the 486SX pinout. With the 486SLC/DLC, one buys a 387 compatible coprocessor to add floating-point capabilities. It is recommended to get a Cyrix coprocessor for this purpose, since these are the fastest387 compatible coprocessors available. Also, Cyrix sells kits consisting of a 486SLC/DLC and a coprocessor that have a favourable value for money ratio. The floating-point performance of a Cyrix 486DLC + Cyrix 83D87 combination is about 50% of that of an Intel 486DX running at the same frequency.
The Cyrix 486SLC/DLC have a RISC-like execution unit with a flexible five stage pipeline, just as the 80486SX has. Unlike the Intel 80486, which has an 8 kB, 4-way associative cache on chip, the Cx486SLC/DLC only have an 1 kB, 2-way associative cache (the cache on the Cyrix chips can also be configured to be of the direct mapped type). The 486DLC provides up to 80% more integer performance than a 386DX at the same clock frequency, with the average performance gain being about 35%. With the 1 kB on-chip cache enabled, the 486DLC provides about 75% of the integer performance of a 486SX at the same clock frequency. With the cache disabled, the 486DLC provides about 65% of the integer performance of a 486SX. The lower performance of the Cyrix 486DLC as compared to the Intel 80486SX is mostly due to the slow 386DX bus interface the 486DLC uses, which is up to 2 times slower than the 486 bus interface. Some additional performance penalty is imposed by the smaller cache on the 486SCL/DLC, which provides significantly lower hit rates than the 8 kB cache of the 80486SX.
I have personally used the Cyrix 486DLC with my 33.3/40 MHz 386 motherboard, which uses the Forex chip set. I have also used the Intel RapidCAD and the C&T 38600DX with this board. These are also replacement chips for the 386DX. Replacing the 386DX is very easy: Just pull out the AMD/Intel 386DX, then plug in the replacement chip (here: the Cyrix 486DLC). I haven't had *major* problems with either of the available replacement chips. The problems encountered using the Cyrix 486DLC were:
1) When a Cyrix EMC87, Cyrix 83D87 (chips produced prior to November 1991),
or IIT 3C87 coprocessor is used with the 486DLC, the computer locks up completely at times, especially when running protected mode multitasked operating systems, such as Windows 3.1 in enhanced mode. This is caused by problems with the FSAVE and FRSTOR instructions when using these coprocessors. Cyrix tells me that this problem only occurs with first generation 486DLCs (read: sample chips like the one I have) and that the bug is fixed on the chips that are now available to OEMs and end users.
2) When using the DBOS 1.0 DOS-extender delivered with the Salford FTN/386
Fortran compiler, the executable of the DODUC benchmark produced by that compiler aborts with a general protection fault. The DODUC executable runs fine with the DBOS 1.0 DOS-extender on the Intel 386DX, C&T 38600DX, Intel RapidCAD, and Intel 80486DX. I have informed Cyrix of the problem.
As for the problems with NextStep on the 486DLC, I have no idea what causes them. I can think of the following possibilities:
1) NextStep has been tailored extremely close to the 486 programming model,
not allowing for even slight changes in the architecture (e.g. smaller cache), so that the subtle changes needed to adapt the different HW of the Cyrix 486SLC/DLC to the 486 programming model can not be accomodated.
2) NextStep includes code that only runs because it uses officialy undocumented
features of the 80486 that have not been disclosed by Intel to other vendors.
3) NextStep includes code that only runs correctly on the 80486 by accident.
E.g. it could mask the contents of an system register and erroneously include a bit that is undefined as per Intel's documentation. This undefined bit could then be '1' on the 80486 and '0' on the 486SLC/DLC, for example, thus leading to corruption of the system further down the execution path.
4) For correct execution, NextStep relies on the timing of certain instructions
that execute slower or faster on the Cx486SLC/DLC than they do on the Intel 80486SX (a chip that reportedly runs NextStep).
5) NEXT Corporation used an early and possibly buggy sample chip to do their
6) There is a bug in the Cyrix 486SLC/DLC that only creeps up if protected
mode system level programs are used, similar to the problem I encountered with the DBOS 1.0 DOS-extender that is described above. However, it is interesting to note that several 32-bit operating systems have been successfully tested on the 486SLC/DLC (see below).
Summary of Intel 486SX / Cyrix 486SLC/DLC implementation details
bus interface: supports burst mode memory accesses with the first
memory access taking two clock cycles and subsequent accesses taking only one clock cycle.
prefetch queue: 32 bytes on-chip cache: 8 KByte unified (code and data) write-through cache.
The cache is 4-way set-associative, with 128 sets consisting of four cache lines each. Every cache line consists of 16 bytes. Four write buffers. Hit rate: ~95% Invalidation of cache lines: total cache line
execution unit: RISC-like execution unit with five stage pipeline. Barrel
shifter. Conditional jump taken/not taken: 3/1 clock cycles. Instructions that can be executed in 1 clock cycle if the destination is a register and the source is either a register or an immediate value: ADC,ADD,AND,BSWAP,CMP,DEC,INC,MOV,NEG,NOT,OR,POP,PUSH,SBB, SUB,TEST,XOR
bus interface: Cx486SLC/DLC uses same the same bus interface as the
Intel 386DX/386SX. Highest speed at which memory is accessed is two clock cycles per memory access, there is *no* burst mode. Seven additional signals have been assigned to pins that are not connected on the 386DX/ 386SX. After power-on or reset, these pins are also electrically disabled on the Cx486SLC/DLC and must be specifically enabled by software. Signals added are used for cache management (KEN#, FLUSH#, RPLSET and RPLVAL#), power management (SUSP#, SUSPA#), and A20 control (A20M#). Each signal can be enabled/disabled independently of the enable/disable status of the other signals.
instruction set: complete Intel 486SX instruction set, including *all*
486 specific instructions: WBINVD (write back and invalidate data cache), XADD (exchange and add), CMPXCHG (compare and exchange), BSWAP (Byte Swap), INVLPG (Invalidate TLB entry), INVD (Invalidate Data Cache)
prefetch queue: 16 bytes on-chip cache: 1 KByte unified (code and data) write-through cache.
The cache is 2-way set-associative, with 128 sets consisting of two cache lines each. Every cache line consists of 4 bytes. Two write buffers. Hit rate: ~65% Invalidation of cache lines: single bytes in cache line The cache is disabled after power-on or reset for compatibility reasons and must be enabled by software. Under DOS, you can use a program provided by Cyrix for this purpose. As far as I know, there are no programs available yet for OS/2 and Unix that enable the cache.
execution unit: RISC-like execution unit with five stage pipeline. Barrel
shifter. 16x16 bit hardware multiplier (16x16 bit multiply: 3 cycles, 32x32 bit multiply: 7 cycles, AAD: 4 cycles). Conditional jump taken/not taken: 6/1 clock cycles. Instructions that can be executed in 1 clock cycle if the destination is a register and the source is either a register or an immediate value: ADC,ADD,AND,CDQ,CLC,CLD,CMC,CMP,CWD,DEC,INC,MOV,MOVSX, NEG, NOT,OR,SBB,SHLD,SHRD,STC,STD,SUB,TEST,XOR
Summary of known compatiblity issues
The following is an extract from the Cx486SLC and Cx486DLC Compatibility Report, Cyrix Corporation 1992, Order No. 94074-00, with some additional information added by me that has been taken from the Cyrix Cx486SLC Microprocessor Data Sheet, Cyrix Corporation 1991, Order No. 94073-00, the i486 Microprocessor Hardware Reference Manual, Intel Corporation, Order No. 240552-001, and the i486 Microprocessor Programmer's Reference Manual, Order No. 240486-001.
SUBSTANTIVE DIFFERENCES - (SOFTWARE)
The TR4 cache test register holds the cache tag address, valid bits and LRU bits for the current cache test operation. The TR5 cache test register defines the cache line, cache set and control bits for the cache test operation. Since the cache size and organization differ between the Cx486SLC/DLC and the 80486, TR4 and TR5 have similar but not identical bit definitions on the Cx486SLC/DLC and the 80486.
Cache test and diagnostic software - if written to explicitly depend on the cache size and organization of the 80486 - may produce unexpected results when run on a Cx486SLC/DLC. The results of the programs typically have no effect on operating systems or applications software. For proper test or diagnosis of the Cx486SLC/DLC cache, software should be used which is specifically written to comprehend the Cx486SLC/DLC.
31 11 10 9 7 6 3 2 0 +------------------------------------------+---+--------+-------+--------+
TR4 | Tag | V | LRU | Valid | Unused |
V This is the valid bit for the particular cache line which was accessed. On a cache lookup, it is a copy of one of the bits reported in bits 3..6, which are the valid bits for all four cache lines in the selected set. On a cache write, it becomes the new valid bit for the particular cache line selected within the selected set. LRU On a cache lookup, these are the three LRU bits of the set which was accessed. On a cache write, these bits are ignored; the LRU bits in the cache are updated by the pseudo-LRU cache replacement algorithm. LRU bit 0 (TR4 bit 7) indicates which group of two cache lines in the set contains the cache line that has been least recently used. The bit is clear when the least recently used line is either line 0 or line 1, and is set when the least recently used line in the set is either line 2 or line 3. LRU bit 1 (TR4 bit 8) and LRU bit 2 (TR4 bit 9) indicate which of the two lines in the group of lines selected by LRU bit 0 is the least recently used, where LRU bit 1 indicates either line 0 (bit=0) or line 1 (bit=1) and LRU bit 2 indicates either line 2 (bit=0) or line 3 (bit=1) has been least recently used. A real LRU replacement algorithm would have to use 5 bits. Valid On a cache lookup, these are the four Valid bits of the set which was accessed, where each bit corresponds to one of the four cache lines in the set.
31 9 8 7 6 3 2 0 +------------------------------------------------+-+-----+-------+-------+
TR4 | Tag |U| LRU | Valid | 0 0 0 |
U bit 8 is unused. LRU On a cache lookup, this is the LRU bit associated with the cache set. On a cache write, this bit is ignored. Bit=0 means line 0 in the selected set has been least recently used, bit=1 means line 1 in the selcted set has been least recently used. Valid On a cache lookup, these are the four valid bits for the particular cache line accessed (one bit per byte in the cache line). On a cache write these are the valid bits written into the line.
31 11 10 4 3 2 1 0 +--------------------------------------+------------------+-------+------+
TR5 | Unused | Set Select | Entry | Ctrl |
Set Select Selects one of the 128 sets of the cache. Entry Selects one of the four cache lines within the selected set. Ctrl 00 write to cache fill buffer, or read from cache read buffer 01 perform cache write 10 perform cache read 11 flush cache (mark all entries invalid)
31 11 10 4 3 2 1 0 +--------------------------------------+------------------+-+-----+------+
TR5 | Unused | Set Select |U| Ent | Ctrl |
Set Select Selects one of the 128 sets of the cache. U bit 3 is unused Entry Selects one of the two cache lines within the selected set. Ctrl 00 ignored 01 perform cache write 10 perform cache read 11 flush cache (mark all entries invalid)
The 80486 NW (not write-through) bit in CR0 disables 80486 write-through capability. If the cache disabled bit is on, a write occurs to a cache-hit location, and NW is a 1, then the 80486 does not perform an external write bus cycle. This bit is not available on the Cx486SLC/DLC and is fixed at zero.
The NW bit on the 80486 allows for a capability of self-contained processing once a program has been loaded into the cache and the cache disabled. Programs that use this feature will work on the Cx486SLC/DLC with writes happening on external write bus cycles.
On systems with hardware FPUs, whose FPU ERROR signal is routed to the CPU ERROR signal (NE bit set on the 80486DX), a floating point error is normally acknowledged by the CPU upon execution of the next floating point instruction. If the next floating point instruction is a load single or load double precision that would have generated a General Protection (GP) fault, it is possible for the Cx486SLC/DLC to acknowledge the GP fault before the coprocessor error fault. The 80486 acknowledges the coprocessor error first.
This condition (FPU ERROR connected to CPU ERROR) does not occur in PC compatible designs.
INFORMATIONAL DIFFERENCES - (SOFTWARE)
Certain 80486 flag bits in the flags register are documented by Intel as undefined after execution of certain instructions. Testing at Cyrix has shown that the final states of theses flag bits are in fact unpredictable. The Cx486SLC/DLC leaves the flag bit values unmodified after execution of the same instructions.
Since the flag bits are documented by Intel to be undefined after certain operations, software can not reliably use the resulting flag bit values.
Early revision 80486SX CPUs have a programmable Numeric Exception control bit in control register CR0 (bit 28). This bit was intended to control whether numeric execptions are handled internally (NE=1) or driven externally on a discrete CPU pin (NE=0). On these 80486SXs, the NE bit can be set to a one even though numeric execptions can not be handled internally due to the fact that no coprocessor exists. Reading the NE bit on the coprocessor exists. Reading the NE bit on the Cx486SLC/DLC always returns a zero indicating that numeric exceptions are always handled externally.
Since the Cx486SLC/DLC does not have an on-board floating point unit, the coprocessor interface (including numeric exception signaling) operates in a fashion compatible with the 80386.The Cx486SLC/DLC and 80386 use an external coprocessor which generates the numeric exception and always return zero when the NE bit is read.
When trying to reference CR1 in protected mode while not at the highest privilege level (level 0), the 80486 generates an Invalid Opcode fault, whereas the Cx486SLC/DLC generate a General Protection (GP) fault.
The Cx486SLC/DLC and 80486 do not define the bits in the CR1 register. Since there are no valid bits in the CR1 register, any exception taken, whether it is a GP fault or Invalid Opcode fault, will signal that an invalid operation has taken place.
When using the Translation Lookaside Buffer (TLB) test registers, the undefined bits in TR7 may differ between the 80486 and the Cx486SLC/DLC when a look-up miss (TR7 bit 4 is clear) occurs. This includes the REP field (bits 2-3).
The majority of the bits in TR7 are documented by Intel to be undefined after a TLB look-up miss. Therefore, software programs can not reliably use the resulting values of these undefined bits.
Cx486SLC/DLC reads and writes to Debug Register 4 (DR4) and Debug Register 5 (DR5) result in accesses to Debug Register 6 (DR6) and Debug Register 7 (DR7), respectively. Accessing DR4 and DR5 on the 80486 produces an Invalid Opcode fault.
DR4 and DR5 are documented as undefined by Intel on the 80486. Since the results are undefined, software programs can not reliably use the register results.
Writing duplicate TLB tags using the TLB test registers generates different results on the Cx486SLC/DLC than on the 80486 when the duplicate address is looked up. The results of writing duplicate TLB tags is documented as undefined by Intel.
Writing duplicate TLB tags using the TLB test registers is an unsupported operation. The Cx486SLC/DLC and 80486 return undefined results when looking up the resulting address. Since the results are undefined, software programs can not reliably use the register results.
The 80486 imposes a performance penalty in order to report debug faults precisely. The Cx486SLC/DLC reports debug faults precisely without a performance penalty (except for a repeated MOVS instruction).
The Cx486SLC/DLC provides superior debugging capability.
The 80486 writes zeroes to the destination register when executing a Bit-Scan Forward (BSF) instruction if all zeroes are found in the specified bit map. The Cx486DLC/DLC leaves the destination register unchanged under this condition.
The value in the destination register of a BSF instruction is specified by Intel to be undefined when a one bit is not found in the source operand. Since the results are undefined, software programs can not be reliably use the register results.
Memory versions of the instructions ADC, ADD, AND, DEC, INC, MOVS, NEG, NOT, OR, RCl, ROL, ROR, SAl, SAR, SBB, SUB, SHL, SHLD, SHR, SHRD, XCHG, and XOR read the destination memory, operate on it, and write it back to memory. The Cx486SLC/DLC checks the writability of the destination before performing these instructions. On non-writable locations, the Cx486SLC/ DLC faults before starting the instruction. The 80486 performs the read, sets the read location acessed bit, and modifies the flags before faulting.
By checking the writability first prior to execution of the instruction (at no performance penalty), the Cx486SLC/DLC avoids unnecessary operations. Leaving the accessed bit and flag contents in their original state is prefered if the instruction is restarted.
In the case above, if the read locatuion is also not present, the 80486 will attempt the read, take a page fault, reload the page, restart the instruction, and then take a GP fault. The Cx486SLC/DLC will take a GP fault.
The 80486 wastes time loading the requested page before taking the required GP fault. The GP fault is eventually detected by both the 80486 and the Cx486SLC/DLC.
If a locked instruction accesses a memory page marked as not present, the 80486 reports in the error code that the access type was a write while the Cx486SLC/DLC reports that the access type was a read.
Since the page is not present in either case (read or write), the same page fault is taken by both the Cx486SLC/DLC and the 80486.
When alignment checking is enabled an an ENTER instruction that misaligns the stack is executed, the 80486 generates an alingment check fault even though the misaligned stack has not been accessed. The Cx486SLC/DLC generates the aligment check fault only when the misaligned stack is accessed.
The Cx486SLC/DLC correctly generates an alignment check fault only when a misaligned stack is accessed. The 80486 unnecessarily takes the fault in the case described.
When executing a REP LOOPE (repeated loop while equal) instruction, the 80486 does not perform the "if equal" function of the instruction. The Cx486SLC/DLC does perfrom the "if equal" check under the same circumstances.
The 80486 execution should be considered incorrect. The Cx486SCL/DLC correctly executes this instruction sequence.
The 80486 incorrectly asserts the LOCK# pin while enterinf the illegal instruction exception handler when using the LOCK prefix on instructions other than those allowed (Only BTS, BTR, BTC, XCHG, INC, DEC, NOT, NEG, ADD, ADC, SUB, SBB, AND, OR, XOR are allowed). The Cx486SLC/DLC correctly does not assert LOCK# in this case.
When using the 80486 in a multi-processor environment, the bus may be locked unnecessarily causing performance degradation.
Operating systems/operating environments tested with the Cx486SLC/DLC:
Digital Research: Concurrent DOS 386 5.0, DR-DOS 6.0 Ergo: OS/386 IBM: IBM DOS 3.3, IBM DOS 4.0, OS/2 2.0, OS/2 SE 1.3 IGC: VM/386 2.01 Interactive: Interactive Unix 3.2 Mark Williams: Coherent 3.1, Coherent 3.2 Microsoft: MS-DOS 3.3, MS-DOS 4.01, MS-DOS 5.0, Windows 3.0, Windows 3.1 Pharlap: DOS-Extender 286, DOS-Extender 386 Quarterdeck: Desqview 386 2.32 Rational: DOS/4G SCO: SCO Open Desktop, SCO Unix, SCO Xenix 2.3.2c Symantec: Norton Desktop for Windows 1.0 UHC: Developers Environment, Network Module, X11R4/Motif Windowing
Module, UNIX Release 4.0 Ver. 3.6