View source for MMIX

{{Short description|64 bit RISC architecture by Donald Knuth}}
{{About|the instruction set architecture|the year|2009|the song|Mylo Xyloto}}
{{Infobox CPU architecture
| name = MMIX
| image = Mmix.png
| image_size = 220px
| alt = MMIX logo
| designer = [[Donald Knuth]]
| bits = [[64-bit computing|64-bit]]
| introduced = {{Start date and age|1999}}
| version = 
| design = [[Reduced instruction set computer|RISC]]
| type  = 
| encoding = fixed
| branching = condition code
| endianness = big
| extensions = 
| open = Yes, royalty free
| registers = 32 special-purpose registers
| gpr = 256
}}

'''MMIX''' (pronounced ''em-mix'') is a [[64-bit computing|64-bit]] [[reduced instruction set computer]] (RISC) [[Computer architecture|architecture]] designed by [[Donald Knuth]], with significant contributions by [[John L. Hennessy]] (who contributed to the design of the [[MIPS architecture]]) and Richard L. Sites (who was an architect of the [[DEC Alpha|Alpha]] architecture).
Knuth has said that: <blockquote>"MMIX is a computer intended to illustrate machine-level aspects of programming. In my books ''[[The Art of Computer Programming]]'', it replaces [[MIX (abstract machine)|MIX]], the 1960s-style machine that formerly played such a role… I strove to design MMIX so that its machine language would be simple, elegant, and easy to learn. At the same time I was careful to include all of the complexities needed to achieve high performance in practice, so that MMIX could in principle be built and even perhaps be competitive with some of the fastest general-purpose computers in the marketplace."<ref name="MMIXware">{{Cite book |last1=Knuth |first1=Donald E. |author1-link=Donald Knuth |date=October 1999 |title=MMIXware: A RISC Computer for the Third Millennium |volume=1750 |series=Lecture Notes in Computer Science Tutorial |publication-place=Heidelberg |publisher=Springer-Verlag |isbn=3-540-66938-8 |url=https://books.google.com/books?id=bIJlBAAAQBAJ}} [https://www-cs-faculty.stanford.edu/~knuth/mmixware.html (Errata)]</ref></blockquote>

Knuth started the design of MMIX in 1999, and released the stable version of the design in 2011.<ref>{{Cite web|title=MMIX Home: A Message From Don Knuth|url=http://mmix.cs.hm.edu/message.html|access-date=2021-05-23|website=mmix.cs.hm.edu}}</ref> The processor is numbered as "2009" with Knuth explaining that this is the [[arithmetic mean]] from the numbers of other computer architectures; as well as being "MMIX" in [[Roman numerals]].<ref>{{cite AV media|url=https://www.youtube.com/watch?v=r_pPF5npnio&t=7m36s |archive-url=https://ghostarchive.org/varchive/youtube/20211211/r_pPF5npnio| archive-date=2021-12-11 |url-status=live|type=offset 7:36 |series=Stanford Lecture |last1=Knuth |first1=Donald |author1-link=Donald Knuth |title=MMIX: A RISC Computer for the New Millennium |date=1999-02-09 |quote=([[Cray-1]] + [[IBM 801]] + [[Berkeley RISC#RISC II|RISC II]] + [[Clipper architecture|Clipper]] C300 + [[AMD 29k]] + [[Motorola 88000|Motorola 88k]] + [[IBM 601]] + [[Intel i960]] + [[Alpha 21164]] + [[POWER2]] + [[MIPS R4000]] + [[Hitachi SH-4|Hitachi Super H4]] + [[StrongARM]] 110 + [[SPARC]]64) / 14 = 28126 / 14 = 2009}}{{cbignore}}</ref>

==Architecture==
MMIX is a [[Endianness|big-endian]] 64-bit [[reduced instruction set computer]] (RISC), with 256 64-bit general-purpose registers, 32 64-bit special-purpose registers, [[instruction set#Instruction length|fixed-length]] 32-bit [[instruction (computer science)|instruction]]s and a 64-bit [[virtual address space]]. The MMIX instruction set comprises 256 opcodes, one of which is reserved for future expansion.{{citation needed|date=January 2017}} MMIX uses [[IEEE 754]] floating-point numbers.

===Instructions===
All instructions have an associated mnemonic. For example, instruction #20 (32 decimal) is associated with ADD. Most instructions have the symbolic form {{code|OP X,Y,Z}}, where {{mono|OP}} specifies the sort of instruction, X specifies the register used to store the result of the instruction and the rest specify the operands of the instruction. Each of these fields is eight bits wide. For example, {{code|ADD $0,$1,3}} means "Set $0 to the sum of $1 and 3."

Most instructions can take either immediate values or register contents; thus a single instruction mnemonic may correspond to one of two opcodes.

MMIX programs are typically constructed using the MMIXAL assembly language.  The below is a simple MMIXAL program, which prints the string "[[Hello, world!]]":
<syntaxhighlight lang="text">
        LOC   #100                   % Set the address of the program
                                     % initially to 0x100.

Main    GETA  $255,string            % Put the address of the string
                                     % into register 255.

        TRAP  0,Fputs,StdOut         % Write the string pointed to by
                                     % register 255 to the standard
                                     % output file.

        TRAP  0,Halt,0               % End process.

string  BYTE  "Hello, world!",#a,0   % String to be printed.  #a is
                                     % newline, 0 terminates the
                                     % string.
</syntaxhighlight>

===Registers===
There are 256 directly addressable general-purpose architectural registers in an MMIX chip, designated by $0 through $255, and 32 special-purpose architectural registers. The special-purpose registers can be accessed with the GET and PUT instructions.
Two of the special registers, rL and rG, determine which of the general registers are local and which are global. All registers from $0... {{nowrap|([rL] − 1)}} are local registers, and represent a [[Register window|window]] into an internal stack of registers.<ref name="rstack" /> Registers from [rL]... {{nowrap|([rG] − 1)}} are "marginal registers", they always return 0 if they are used as a source in an operation. Using a marginal register as the destination of an operation will cause the machine to automatically increase rL to include that register. All registers [rG]... $255 are called global registers, and are not part of the register stack.

====Local register stack====
The local register stack provides each subroutine with its own rL local registers, designated by $0 through {{nowrap|$(rL − 1)}}. Whenever a subroutine is called, a number of local registers are pushed down the stack (by shifting the start of the window). The arguments of the called subroutine are left in the remaining local registers. When a subroutine finishes it pops the previously pushed registers. Because the internal stack can contain only a finite number of registers, it may be necessary to store a part of the stack in memory.<ref name="rstack">{{cite book|last1=Knuth|first1=Donald |author1-link=Donald Knuth|title=MMIX—A RISC Computer for the New Millennium|series=The Art of Computer Programming|volume=1, Fasc. 1|year=2005|publisher=Addison Wesley|page=58|chapter=Section 1.4.2'}}</ref> This is implemented with the special registers rO and rS which record which part of the local register stack is in memory and which part is still in local physical registers. The register stack provides for fast subroutine linkage.

====Special registers====
The 32 special physical architectural registers are as follows:
# <li value="0">'''rB, the bootstrap register (trip)'''</li>
#: When tripping, rB ← $255 and $255 ← rJ. Thus saving rJ in a general register.
# '''rD, the dividend register'''
#: Unsigned integer divide uses this as the left half of the 128-bit input that is to be divided by the other operand.
# '''rE, the epsilon register'''
#: Used for floating comparisons with respect to epsilon.
# '''rH, the himult register'''
#: Used to store the left half of the 128-bit result of unsigned integer multiplication.
# '''rJ, the return-jump register'''
#: Used to save the address of the next instruction by PUSHes and by POP to return from a PUSH.
# '''rM, the multiplex mask register'''
#: Used by the multiplex instruction.
# '''rR, the remainder register'''
#:Is set to the remainder of integer division.
# '''rBB, the bootstrap register (trap)'''
#: When trapping, rBB ← $255 and $255 ← rJ. Thus saving rJ in a general register
# '''rC, the cycle counter'''
#: Incremented every cycle.
# '''rN, the serial number'''
#: A constant identifying this particular MMIX processor.
# '''rO, the register stack offset'''
#: Used to implement the register stack.
# '''rS, the register stack pointer'''
#: Used to implement the register stack.
# '''rI, the interval counter'''
#: Decremented every cycle. Causes an interrupt when zero.
# '''rT, the trap address register'''
#: Used to store the address of the trip vector.
# '''rTT, the dynamic trap address register'''
#: Used to store the address of the trap vector.
# '''rK, the interrupt mask register'''
#: Used to enable and disable specific interrupts.
# '''rQ, the interrupt request register'''
#: Used to record interrupts as they occur.
# '''rU, the usage counter'''
#: Used to keep a count of executed instructions.
# '''rV, the virtual translation register'''
#: Used to translate virtual addresses to physical addresses. Contains the size and number of segments, the root location of the page table and the address space number.
# '''rG, the global threshold register'''
#: All general registers references with a number greater or equal to rG refer to global registers.
# '''rL, the local threshold register'''
#: All general registers references with a number smaller than rL refer to local registers.
# '''rA, the arithmetic status register'''
#: Used to record, enable and disable arithmetic exception like overflow and divide by zero.
# '''rF, the failure location register'''
#: Used to store the address of the instruction that caused a failure.
# '''rP, the prediction register'''
#: Used by conditional swap (CSWAP).
# '''rW, the where-interrupted register (trip)'''
#: Used, when tripping, to store the address of the instruction after the one that was interrupted.
# '''rX, the execution register (trip)'''
#: Used, when tripping, to store the instruction that was interrupted.
# '''rY, the Y operand (trip)'''
#: Used, when tripping, to store the Y operand of the interrupted instruction.
# '''rZ, the Z operand (trip)'''
#: Used, when tripping, to store the Z operand of the interrupted instruction.
# '''rWW, the where-interrupted register (trap)'''
#: Used, when trapping, to store the address of the instruction after the one that was interrupted.
# '''rXX, the execution register (trap)'''
#: Used, when trapping, to store the instruction that was interrupted.
# '''rYY, the Y operand (trap)'''
#: Used, when trapping, to store the Y operand of the interrupted instruction.
# '''rZZ, the Z operand (trap)'''
#: Used, when trapping, to store the Z operand of the interrupted instruction.

Like programs running on almost all other CPUs,
MMIX programs can be [[interrupt]]ed in several ways.
External hardware, such as timers, are a common source of [[preemption (computing)|preemption interrupts]].
Many instructions cause an interrupt in certain exceptional cases; such as the [[memory protection]] [[page fault]] exceptions used to implement virtual memory, and floating point [[exception handling]].
MMIX has 2 kinds of interrupts: "trips" and "traps".
The main difference between "trips" and "traps" is that
traps send control to a "trap handler" program in the operating system (trapping), but
trips send control to a "trip handler" program in the user application (tripping).
Users can also force any interrupt handler to run with explicit [[software interrupt]] instructions TRIP and TRAP, similar to some kinds of [[trap (computing)|trap]] in other computer systems.
In particular, a [[system call]] from a user program to the operating system uses a TRAP instruction.<ref name="MMIXware" />{{rp|38}}

==Hardware implementations==
{{As of|2015|10}}{{needs update|date=November 2024}}, no known hardware implementations of the MMIX instruction set architecture exist. However, the fpgammix<ref>{{cite web|author=tommythorn |url=https://github.com/tommythorn/fpgammix |title=fpgammix |website=[[GitHub]] |access-date=2024-09-27}}</ref> project implements MMIX in [[Verilog]], making it possible to implement using a [[field-programmable gate array]].

==Software tools==
The MMIX instruction set architecture is supported by a number of software tools for computer architecture research and software development.

===Simulators and assembler===
* MMIXware<ref>{{cite web |url=https://www-cs-faculty.stanford.edu/~knuth/mmix-news.html |title=MMIXware |publisher=Cs-faculty.stanford.edu |access-date=2014-05-25}}</ref> – Donald Knuth's MMIX-SIM simple (behavioral) simulator, MMIXAL assembler, test suite, sample programs, full documentation, and MMIX architectural (pipeline) simulator (<code>[[gzip]]ped</code> <code>[[tar (file format)|tar]]</code> file).
* MMIXX<ref>{{cite web |url=https://www.malgil.com/mmix/graphics/ |title=MMIXX |publisher=Malgil.com |date=2002-03-06 |access-date=2014-05-25}}</ref> – An [[X Window System|X11]]-based graphics package contributed by Andrew Pochinsky of [[Massachusetts Institute of Technology|MIT]]’s [[MIT Center for Theoretical Physics|Center for Theoretical Physics]] which, when combined with the MMIXware sources above, augments the MMIX [[virtual machine]] with a [[Display resolution|640×480 pixel]], [[24-bit color|true-color]] ‘virtual display’ (for Unix/Linux).

===Compiler===
The [[GNU Compiler Collection]] includes an MMIX [[compilers#Back end|back-end]] for its [[C (programming language)|C]]/[[C++]] compilers, contributed by Hans-Peter Nilsson and part of the main GCC distribution since late 2001. {{As of|2017|11}}, the MMIX back-end to GCC continues to be actively developed and maintained by volunteers.
* Installation instructions for GCC + MMIX tools by Hans-Peter Nilsson.<ref>[http://bitrange.com/mmix/install.html Installation instructions for GCC + MMIX tools]</ref>
* §3.17.26. MMIX Options for [[GNU]] [[GNU Compiler Collection|GCC]] version 7.2.0<ref>https://gcc.gnu.org/onlinedocs/gcc-7.2.0/gcc/MMIX-Options.html §3.17.26. MMIX</ref> (GNU GCC Web site).
* §9.28.{{nbsp}} MMIX-dependent Features<ref>{{cite web |url=https://sourceware.org/binutils/docs-2.29/as/MMIX_002dDependent.html#MMIX_002dDependent |title=§9.28 MMIX Dependent Features |publisher=Sourceware.org |access-date=2017-11-20}}</ref> for [[GNU]] [[GNU Assembler|as]] from [[GNU Binutils]] version 2.29, the assembler back-end for GNU GCC (GNU Binutils Web site).
The above tools could theoretically be used to compile, build, and bootstrap an entire [[FreeBSD]], [[Linux]], or other similar operating system kernel onto MMIX hardware, were such hardware to exist.

== See also ==
* [[Educational programming language]]
* [[DLX]]
* [[Little Computer 3|LC-3]]
* [[Little man computer]]
* [[MikroSim]]
* [[MIX (abstract machine)|MIX]]
* NAR 2, another processor designed by a professor to help students learn

== References ==
{{Reflist}}

== Further reading ==
* Donald E. Knuth (2005). ''The Art of Computer Programming Volume 1 Fascicle 1: MMIX A RISC Computer for the New Millennium''. Addison-Wesley. {{ISBN|0-201-85392-2}} [https://www-cs-staff.stanford.edu/~uno/taocp.html#err1f1 (errata)]
* Martin Ruckert (2015). ''MMIX Supplement, The: Supplement to The Art of Computer Programming Volumes 1, 2, 3 by Donald E. Knuth''. Addison-Wesley. {{ISBN|0-133-99231-4}}

==External links==
{{Commons category}}
*{{Official website|mmix.cs.hm.edu}}
*[https://www-cs-faculty.stanford.edu/~knuth/mmix.html Donald Knuth's MMIX page] – A brief introduction to MMIX, and Knuth's reasons for using a hypothetical [[assembly language]] in TAoCP.
*[https://www-cs-faculty.stanford.edu/~knuth/mmix-news.html Donald Knuth's MMIX news page] – An [[open-source software|open source]] simulator written in [[CWEB]], a programmer's manual, and example programs.
*[http://mmix.cs.hm.edu/mmixmasters/ MMIXmasters] – A web site for volunteers who are converting all of the programs in TAOCP, volumes 1–3, from the old MIX to the new MMIX.
*[http://www007.upp.so-net.ne.jp/eiji-y/vmmmix/vmmmix.html VMMMIX] {{Webarchive|url=https://web.archive.org/web/20090705154912/http://www007.upp.so-net.ne.jp/eiji-y/vmmmix/vmmmix.html |date=2009-07-05}} – VMMMIX is the MMIX [[virtual machine]] (VM). It has console, HDD and Ethernet I/Os. {{As of|2024}}, this VM runs on Windows only, and supports Linux.
*[http://vmb.sourceforge.net The Virtual Motherboard (VMB) project] – A plug and play set of devices that can be used with an appropriate version of the MMIX CPU.

{{Donald Knuth}}
{{Authority control}}

{{DEFAULTSORT:Mmix}}
[[Category:Donald Knuth]]
[[Category:Educational abstract machines]]
[[Category:Instruction set architectures]]
[[Category:Computer-related introductions in 2011]]
<!-- Hidden categories below -->
[[Category:Articles with example code]]