/[gxemul]/trunk/doc/intro.html
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /trunk/doc/intro.html

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2 by dpavlin, Mon Oct 8 16:17:48 2007 UTC revision 34 by dpavlin, Mon Oct 8 16:21:17 2007 UTC
# Line 1  Line 1 
1  <html>  <html><head><title>Gavare's eXperimental Emulator:&nbsp;&nbsp;&nbsp;Introduction</title>
2  <head><title>GXemul documentation: Introduction</title>  <meta name="robots" content="noarchive,nofollow,noindex"></head>
3  </head>  <body bgcolor="#f8f8f8" text="#000000" link="#4040f0" vlink="#404040" alink="#ff0000">
4  <body bgcolor="#ffffff" text="#000000" link="#4040f0" vlink="#404040" alink="#ff0000">  <table border=0 width=100% bgcolor="#d0d0d0"><tr>
5  <p>  <td width=100% align=center valign=center><table border=0 width=100%><tr>
6  <table width="100%">  <td align="left" valign=center bgcolor="#d0efff"><font color="#6060e0" size="6">
7    <tr><td width="100%" bgcolor="#808070"><font color="#ffffe0" size="6">  <b>Gavare's eXperimental Emulator:</b></font><br>
8    <b>GXemul documentation: Introduction</b></font></td></tr>  <font color="#000000" size="6"><b>Introduction</b>
9  </table>  </font></td></tr></table></td></tr></table><p>
 <p>  
 <!-- The first 10 lines are cut away by the homepage updating script.  -->  
   
10    
11  <!--  <!--
12    
13  $Id: intro.html,v 1.30 2005/04/07 15:43:15 debug Exp $  $Id: intro.html,v 1.106 2007/02/18 09:19:47 debug Exp $
14    
15  Copyright (C) 2003-2005  Anders Gavare.  All rights reserved.  Copyright (C) 2003-2007  Anders Gavare.  All rights reserved.
16    
17  Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
18  modification, are permitted provided that the following conditions are met:  modification, are permitted provided that the following conditions are met:
# Line 48  SUCH DAMAGE. Line 45  SUCH DAMAGE.
45  <h2>Introduction</h2>  <h2>Introduction</h2>
46    
47  <p>  <p>
48    <table border="0" width="99%"><tr><td valign="top" align="left">
49  <ul>  <ul>
50    <li><a href="#overview">Overview</a>    <li><a href="#overview">Overview</a>
51    <li><a href="#free">Is GXemul free software?</a>    <li><a href="#free">Is GXemul Free software?</a>
52    <li><a href="#build">How to compile/build the emulator</a>    <li><a href="#build">How to compile/build the emulator</a>
53    <li><a href="#cpus">Which CPU types does GXemul emulate?</a>    <li><a href="#run">How to run the emulator</a>
54      <li><a href="#cpus">Which processor architectures does GXemul emulate?</a>
55      <li><a href="#hosts">Which host architectures are supported?</a>
56      <li><a href="#translation">What kind of translation does GXemul use?</a>
57    <li><a href="#accuracy">Emulation accuracy</a>    <li><a href="#accuracy">Emulation accuracy</a>
58    <li><a href="#emulmodes">Which machines does GXemul emulate?</a>    <li><a href="#emulmodes">Which machines does GXemul emulate?</a>
   <li><a href="#guestos">Which guest OSes are possible to run?</a>  
59  </ul>  </ul>
60    </td><td valign="center" align="center">
61    <a href="20050317-example.png"><img src="20050317-example_small.png"></a>
62    <p>NetBSD/pmax 1.6.2 with X11<br>running in GXemul</td></tr></table>
63    
64    
65    
# Line 66  SUCH DAMAGE. Line 68  SUCH DAMAGE.
68  <a name="overview"></a>  <a name="overview"></a>
69  <h3>Overview:</h3>  <h3>Overview:</h3>
70    
71  GXemul is a machine emulator, which can be used to experiment with  GXemul is an experimental instruction-level machine emulator. Several
72  binary code for (among others) MIPS-based machines. Several emulation  emulation modes are available. In some modes, processors and surrounding
 modes are available. For some emulation modes, processors and surrounding  
73  hardware components are emulated well enough to let unmodified operating  hardware components are emulated well enough to let unmodified operating
74  systems run as if they were running on a real machine.  systems (e.g. NetBSD) run as if they were running on a real machine.
   
 <p>  
 It is important to keep in mind that devices and CPUs are not really  
 emulated correctly, they are only "faked" well enough to make eg. NetBSD  
 run. Still, the emulator could be of interest for academic research and  
 experiments, such as when learning how to write an OS for a real machine,  
 or profiling SMP, memory, or system call usage.  
   
 <p>  
 The emulator is written in C, does not depend on external libraries (except  
 X11, but that is optional), and should compile and run on most Unix-like  
 systems. If it doesn't, then that is a bug.  
75    
76  <p>  <p>Devices and processors are not simulated with 100% accuracy. They are
77  The emulator contains code which tries to emulate the workings of CPUs and  only ``faked'' well enough to allow guest operating systems to run without
78  surrounding hardware found in real machines, but it does not contain any  complaining too much. Still, the emulator could be of interest for
79  ROM code. You will need some form of program (in binary form) to run in  academic research and experiments, such as when learning how to write
80  the emulator. For many emulation modes, PROM calls are handled by the  operating system code.
81    
82    <p>The emulator is written in C, does not depend on third-party libraries,
83    and should compile and run on most 64-bit and 32-bit Unix-like systems.
84    
85    <p>The emulator contains code which tries to emulate the workings of CPUs
86    and surrounding hardware found in real machines, but it does not contain
87    any ROM code. You will need some form of program (in binary form) to run
88    in the emulator. For many emulation modes, PROM calls are handled by the
89  emulator itself, so you do not need to use any ROM image at all.  emulator itself, so you do not need to use any ROM image at all.
90    
91  <p>  <p>You can use pre-compiled kernels (for example NetBSD kernels, or
92  You can use pre-compiled kernels (for example NetBSD kernels, or Linux),  Linux), or other programs that are in binary format, and in some cases
93  or other programs that are in binary format, and in some cases even actual  even actual ROM images. A couple of different file formats are supported
94  ROM images. A couple of different file formats are supported (ELF, a.out,  (ELF, a.out, ECOFF, SREC, and raw binaries).
95  ECOFF, SREC, raw binaries).  
96    <p>If you do not have a kernel as a separate file, but you have a bootable
97    disk image, then it is sometimes possible to boot directly from that
98    image. (This works for example with DECstation emulation, Dreamcast
99    emulation, or when booting from generic ISO9660 CDROM images if the
100    kernel is included in the image as a plain file.)
101    
102    <p>Thanks to (in no specific order) Joachim Buss, Olivier Houchard, Juli
103    Mallett, Juan Romero Pardines, Alec Voropay, Göran Weinholt, Alexander
104    Yurchenko, and everyone else who has provided me with feedback.
105    
106    
 <p>  
 (You do not need any MIPS compiler toolchain to build or use GXemul.  
 If you need to compile MIPS binaries from sources, then of course you need  
 such a toolchain, but that is completely separate from GXemul. There  
 is a <a href="technical.html#regtest">regression testing</a> framework,  
 which requires that a GNU CC for mips64-unknown-elf or similar is available.  
 For simply building and using the emulator, it is not required.)  
107    
108    
109    
# Line 111  For simply building and using the emulat Line 111  For simply building and using the emulat
111    
112  <p><br>  <p><br>
113  <a name="free"></a>  <a name="free"></a>
114  <h3>Is GXemul free software?</h3>  <h3>Is GXemul Free software?</h3>
   
 Yes. I have released GXemul under a free license.  
 (For a definitions of the four freedoms associated with free software,  
 please read <a href="http://www.gnu.org/philosophy/free-sw.html">  
 http://www.gnu.org/philosophy/free-sw.html</a>.)  
   
 <p>  
 The code I have written is released under a 3-clause BSD-style license  
 (or "revised BSD-style" if one wants to use  
 <a href="http://www.gnu.org/philosophy/bsd.html">GNU jargon</a>.)  
 Apart from the code I have written, some files are copied from other sources  
 such as NetBSD, for example header files containing symbolic names of  
 bitfields in device registers. They are also covered by similar licenses,  
 but with some additional clauses. If you plan to redistribute GXemul  
 (for example as a binary package), or reuse code from GXemul,  
 then you should check those files for their license terms.  
115    
116  <p>  Yes. I have released GXemul under a Free license. The code in GXemul is
117  (The licenses usually require that the original Copyright and license  Copyrighted software, it is <i>not</i> public domain. (If this is
118  terms are included when you make a copy or modification. The "easiest way  confusing to you, you might want to read up on the definitions of the
119  out" if you plan to redistribute code from GXemul is to simply supply  four freedoms associated with Free software, <a
120  the source code. You should however check individual files for details.)  href="http://www.gnu.org/philosophy/free-sw.html">http://www.gnu.org/philosophy/free-sw.html</a>.)
121    
122    <p>The code I have written is released under a 3-clause BSD-style license
123    (or "revised BSD-style" if one wants to use <a
124    href="http://www.gnu.org/philosophy/bsd.html">GNU jargon</a>). Apart from
125    the code I have written, some files are copied from other sources such as
126    NetBSD, for example header files containing symbolic names of bitfields in
127    device registers. They are also covered by similar licenses, but with some
128    additional clauses. The main point, however, is that the licenses require
129    that the original Copyright and license terms are included when you make a
130    copy or modification.
131    
132    <p>If you plan to redistribute GXemul <i>without</i> supplying the source
133    code, then you need to comply with each individual source file some other
134    way, for example by writing additional documentation containing copyright
135    notes. I have not done this, since I do not plan on making distributions
136    without source code. You need to check all individual files for details.
137    The "easiest way out" if you plan to redistribute code from GXemul is, of
138    course, to let it remain open source and simply supply the source code.
139    
140    <p>In case you want to reuse parts of GXemul, but you need to do that
141    under a different license (e.g. the GPL), then contact me and I might
142    re-license/dual-license files on a case-by-case basis.
143    
144    
145    
# Line 149  Uncompress the .tar.gz distribution file Line 155  Uncompress the .tar.gz distribution file
155          $ <b>make</b>          $ <b>make</b>
156  </pre>  </pre>
157    
158  <p>  <p>This should work on most Unix-like systems. GXemul does not require any
159  This should work on most Unix-like systems. If it doesn't, then please  specific libraries to build, however, if you build on a system which does
160  mail me a bug report.  not have X11 libraries installed, some functionality will be lost.
161    
162  <p>  <p>The emulator's performance is highly dependent on both runtime settings
 (Note for Windows users: there is a possibility that some releases  
 and/or snapshots will also work with Cygwin, but I can't promise that.)  
   
 <p>  
 The emulator's performance is highly dependent on both runtime settings  
163  and on compiler settings, so you might want to experiment with different  and on compiler settings, so you might want to experiment with different
164  CC and CFLAGS environment variable values. For example, on a modern PC,  CC and CFLAGS environment variable values. For example, on an AMD Athlon
165  you could try the following:  host, you might want to try setting <tt>CFLAGS</tt> to <tt>-march=athlon</tt>
166  <p>  before running <tt>configure</tt>.
167  <pre>  
168          $ <b>CFLAGS="-mcpu=pentium4 -O3" ./configure</b>  
169          $ <b>make</b>  
170  </pre>  
171    
172    
173    
174    <p><br>
175    <a name="run"></a>
176    <h3>How to run the emulator:</h3>
177    
178    Once you have built GXemul, running it should be rather straight-forward.
179    Running <tt><b>gxemul</b></tt> without arguments (or with the
180    <b><tt>-h</tt></b> or <b><tt>-H</tt></b> command line options) will
181    display a help message.
182    
183  <p>  <p>
184  Run <b>./configure --help</b> to get a list of configure options. (The  To get some ideas about what is possible to run in the emulator, please
185  possible options differ between different releases and snapshots.)  read the section about <a href="guestoses.html">installing "guest"
186    operating systems</a>. If you are interested in using the emulator to
187    develop code on your own, then you should also read the section about
188    <a href="experiments.html#hello">Hello World</a>.
189    
190  <p>  <p>
 Once you have built GXemul, running it should be rather straight-forward.  
191  To exit the emulator, type CTRL-C to enter the  To exit the emulator, type CTRL-C to enter the
192  single-step debugger, and then type <b>quit</b>. By typing CTRL-B instead,  single-step debugger, and then type <tt><b>quit</b></tt>.
 a CTRL-C is sent to the emulated program.  
193    
194    <p>
195    If you are starting an emulation by entering settings directly on the
196    command line, and you are not using the <tt><b>-x</b></tt> option, then all
197    terminal input and output will go to the main controlling terminal.
198    CTRL-C is used to break into the debugger, so in order to send CTRL-C to
199    the running (emulated) program, you may use CTRL-B.
200    (This should be a reasonable compromise to allow the emulator to be usable
201    even on systems without X Windows.)
202    
203    <p>
204    There is no way to send an actual CTRL-B to the emulated program, when
205    typing in the main controlling terminal window. The solution is to either
206    use <a href="configfiles.html">configuration files</a>, or use
207    <tt><b>-x</b></tt>. Both these solutions cause new xterms to be opened for
208    each emulated serial port that is written to. CTRL-B and CTRL-C both have
209    their original meaning in those xterm windows.
210    
211    
212    
# Line 185  a CTRL-C is sent to the emulated program Line 214  a CTRL-C is sent to the emulated program
214    
215  <p><br>  <p><br>
216  <a name="cpus"></a>  <a name="cpus"></a>
217  <h3>Which CPU types does GXemul emulate?</h3>  <h3>Which processor architectures does GXemul emulate?</h3>
218    
219    The architectures that are emulated well enough to let at least one
220    guest operating system run (per architecture) are ARM, MIPS, PowerPC,
221    and SuperH.
222    
223    <p>Please read the page about <a href="guestoses.html">guest operating
224    systems</a> for more information about the machines and operating systems
225    that can be considered "working" in the emulator.
226    
227    
228    
 <h4>MIPS:</h4>  
229    
 Emulation of R4000, which is a 64-bit CPU, was my initial goal. Right  
 now, R2000/R3000-like CPUs are also emulated (32-bit), and emulation of  
 R1x000 (at least the parts that are similar to R4000) is beginning to work  
 as expected. Code targeted for MIPS32 and MIPS64 also often work.  
230    
231  <p>  
232  I have written an experimental dynamic binary translation subsystem.  <p><br>
233  This gives higher total performance than interpreting one instruction at a  <a name="hosts"></a>
234  time and executing it. (If you wish to enable bintrans, add <b>-b</b> to  <h3>Which host architectures are supported?</h3>
235  the command line, but keep in mind that it is still experimental.)  
236    GXemul should compile and run on any modern host architecture (64-bit or
237    32-bit word-length).
238    
239    <p>Note: The dynamic translation engine does <i>not</i> require backends
240    for native code generation to be written for each individual host
241    architecture; the "intermediate representation" that the dyntrans system
242    uses can be executed on any host architecture.
243    
244    
245    
246    
 <h4>URISC:</h4>  
247    
248  I have implemented an <a href="http://en.wikipedia.org/wiki/URISC">URISC</a>  <p><br>
249  emulation mode, just for fun. The only instruction available in an URISC  <a name="translation"></a>
250  machine is "reverse subtract and skip on borrow". (It is probably not  <h3>What kind of translation does GXemul use?</h3>
 worth trying to do bintrans with URISC, because any reasonable URISC  
 program relies on self-modifying code, which is bad for bintrans  
 performance.)  
251    
252    <b>Static vs. dynamic:</b>
253    
254    <p>In order to support guest operating systems, which can overwrite old
255    code pages in memory with new code, it is necessary to translate code
256    dynamically. It is not possible to do a "one-pass" (static) translation.
257    Self-modifying code and Just-in-Time compilers running inside
258    the emulator are other things that would not work with a static
259    translator. GXemul is a dynamic translator. However, it does not
260    necessarily translate into native code, like many other emulators.
261    
262    <p><b>"Runnable" Intermediate Representation:</b>
263    
264    <p>Dynamic translators usually translate from the emulated architecture
265    (e.g. MIPS) into a kind of <i>intermediate representation</i> (IR), and then
266    to native code (e.g. AMD64 or x86 code). Since one of my main goals for
267    GXemul is to keep everything as portable as possible, I have tried to make
268    sure that the IR is something which can be executed regardless of whether
269    the final step (translation from IR to native code) has been implemented
270    or not.
271    
272    <p>The IR in GXemul consists of arrays of pointers to functions, and a few
273    arguments which are passed along to those functions. The functions are
274    implemented in either manually hand-coded C, or automatically generated C.
275    In any case, this is all statically linked into the GXemul binary at link
276    time.
277    
278    <p>Here is a simplified diagram of how these arrays work.
279    
280    <p><center><img src="simplified_dyntrans.png"></center>
281    
282    <p>There is one instruction call slot for every possible program counter
283    location. In the MIPS case, instruction words are 32 bits in length,
284    and pages are (usually) 4 KB large, resulting in 1024 instruction call
285    slots. After the last of these instruction calls, there is an additional
286    call to a special "end of page" function (which doesn't count as an executed
287    instruction). This function switches to the first instruction
288    on the next virtual page (which might cause exceptions, etc).
289    
290    <p>The complexity of individual instructions vary. A simple example of
291    what an instruction can look like is the MIPS <tt>addiu</tt> instruction:
292    <pre>
293            X(addiu)
294            {
295                    reg(ic->arg[1]) = (int32_t)
296                        ((int32_t)reg(ic->arg[0]) + (int32_t)ic->arg[2]);
297            }
298    </pre>
299    
300    <p>It stores the result of a 32-bit addition of the register at arg[0]
301    with the immediate value arg[2] (treating both as signed 32-bit
302    integers) into register arg[1]. If the emulated CPU is a 64-bit CPU,
303    then this will store a correctly sign-extended value into arg[1].
304    If it is a 32-bit CPU, then only the lowest 32 bits will be stored,
305    and the high part ignored. <tt>X(addiu)</tt> is expanded to
306    <tt>mips_instr_addiu</tt> in the 64-bit case, and <tt>mips32_instr_addiu</tt>
307    in the 32-bit case. Both are compiled into the GXemul executable; no code
308    is created during run-time.
309    
310    <p>Here are examples of what the <tt>addiu</tt> instruction actually
311    looks like when it is compiled, on various host architectures:
312    
313    <p><center><table border="0">
314        <tr><td><b>GCC 4.0.1 on Alpha:</b></td>
315            <td width="35"></td><td></td>
316        <tr>
317            <td valign="top">
318    <pre>mips_instr_addiu:
319         ldq     t1,8(a1)
320         ldq     t2,24(a1)
321         ldq     t3,16(a1)
322         ldq     t0,0(t1)
323         addl    t0,t2,t0
324         stq     t0,0(t3)
325         ret</pre>
326            </td>
327            <td></td>
328            <td valign="top">
329    <pre>mips32_instr_addiu:
330         ldq     t2,8(a1)
331         ldq     t0,24(a1)
332         ldq     t3,16(a1)
333         ldl     t1,0(t2)
334         addq    t0,t1,t0
335         stl     t0,0(t3)
336         ret</pre>
337            </td>
338        </tr>
339    
340        <tr><td><b><br>GCC 3.4.4 on AMD64:</b></td>
341        <tr>
342            <td valign="top">
343    <pre>mips_instr_addiu:
344         mov    0x8(%rsi),%rdx
345         mov    0x18(%rsi),%rax
346         mov    0x10(%rsi),%rcx
347         add    (%rdx),%eax
348         cltq
349         mov    %rax,(%rcx)
350         retq</pre>
351            </td>
352            <td></td>
353            <td valign="top">
354    <pre>mips32_instr_addiu:
355         mov    0x8(%rsi),%rcx
356         mov    0x10(%rsi),%rdx
357         mov    (%rcx),%eax
358         add    0x18(%rsi),%eax
359         mov    %eax,(%rdx)
360         retq</pre>
361            </td>
362        </tr>
363    
364        <tr><td><b><br>GCC 4.0.1 on i386:</b></td>
365        <tr>
366            <td valign="top">
367    <pre>mips_instr_addiu:
368         mov    0x8(%esp),%eax
369         mov    0x8(%eax),%ecx
370         mov    0x4(%eax),%edx
371         mov    0xc(%eax),%eax
372         add    (%edx),%eax
373         mov    %eax,(%ecx)
374         cltd
375         mov    %edx,0x4(%ecx)
376         ret</pre>
377            </td>
378            <td></td>
379            <td valign="top">
380    <pre>mips32_instr_addiu:
381         mov    0x8(%esp),%eax
382         mov    0x8(%eax),%ecx
383         mov    0x4(%eax),%edx
384         mov    0xc(%eax),%eax
385         add    (%edx),%eax
386         mov    %eax,(%ecx)
387         ret</pre>
388            </td>
389        </tr>
390    </table></center>
391    
392    <p>On 64-bit hosts, there is not much difference, but on 32-bit hosts (and
393    to some extent on AMD64), the difference is enough to make it worthwhile.
394    
395    
396    <p><b>Performance:</b>
397    
398    <p>The performance of using this kind of runnable IR is obviously lower
399    than what can be achieved by emulators using native code generation, but
400    can be significantly higher than using a naive fetch-decode-execute
401    interpretation loop. In my opinion, using a runnable IR is an interesting
402    compromise.
403    
404    <p>The overhead per emulated instruction is usually around or below
405    approximately 10 host instructions. This is very much dependent on your
406    host architecture and what compiler and compiler switches you are using.
407    Added to this instruction count is (of course) also the C code used to
408    implement each specific instruction.
409    
410    <p><b>Instruction Combinations:</b>
411    
412    <p>Short, common instruction sequences can sometimes be replaced by a
413    "compound" instruction. An example could be a compare instruction followed
414    by a conditional branch instruction. The advantages of instruction
415    combinations are that
416    <ul>
417      <li>the amortized overhead per instruction is slightly reduced, and
418      <p>
419      <li>the host's compiler can make a good job at optimizing the common
420            instruction sequence.
421    </ul>
422    
423  <h4>Other CPU types:</h4>  <p>The special cases where instruction combinations give the most gain
424    are in the cores of string/memory manipulation functions such as
425    <tt>memset()</tt> or <tt>strlen()</tt>. The core loop can then (at least
426    to some extent) be replaced by a native call to the equivalent function.
427    
428    <p>The implementations of compound instructions still keep track of the
429    number of executed instructions, etc. When single-stepping, these
430    translations are invalidated, and replaced by normal instruction calls
431    (one per emulated instruction).
432    
433    <p><b>Native Code Back-ends:</b>
434    
435    <p>In theory, it will be possible to implement native code generation,
436    similar to what is used in high-performance emulators such as QEMU,
437    as long as that generated code abides to the C ABI on the host.
438    
439    <p>However, since I wanted to make sure that GXemul works without such
440    native code back-ends, there are no implemented backends in this release.
441    
442    <p>(There is a place-holder in the source code for native code generation,
443    which can be used for experiments, but it does not contain any working
444    code at the moment.)
445    
 There is some code for 64-bit (and 32-bit) POWER/PowerPC emulation too,  
 but it only works for "Hello World" and similarly trivial programs. (There  
 are some other CPU modes too, but they are working even less.)  
446    
447    
448    
# Line 228  are some other CPU modes too, but they a Line 452  are some other CPU modes too, but they a
452  <a name="accuracy"></a>  <a name="accuracy"></a>
453  <h3>Emulation accuracy:</h3>  <h3>Emulation accuracy:</h3>
454    
455  GXemul is an instruction-level simulator; things that would happen in  GXemul is an instruction-level emulator; things that would happen in
456  several steps within a real CPU are not taken into account (eg. pipe-line  several steps within a real CPU are not taken into account (e.g. pipe-line
457  stages or out-of-order execution). Still, instruction-level accuracy seems  stalls or out-of-order execution). Still, instruction-level accuracy seems
458  to be enough to be able to run complete guest operating systems inside the  to be enough to be able to run complete guest operating systems inside the
459  emulator.  emulator.
460    
461    <p>The existance of instruction and data caches is "faked" to let
462    operating systems think that they are there, but for all practical
463    purposes, these caches are non-working.
464    
465    <p>The emulator is in general <i>not</i> timing-accurate, neither at the
466    instruction level nor on any higher level. An attempt is made to let
467    emulated clocks run at the same speed as the host (i.e. an emulated timer
468    running at 100 Hz will interrupt around 100 times per real second), but
469    since the host speed may vary, e.g. because of other running processes,
470    there is no guarantee as to how many instructions will be executed in
471    each of these 100 Hz cycles.
472    
473    <p>If the host is very slow, the emulated clocks might even lag behind
474    the real-world clock.
475    
476    
477    
478    
479    
# Line 242  emulator. Line 482  emulator.
482  <a name="emulmodes"></a>  <a name="emulmodes"></a>
483  <h3>Which machines does GXemul emulate?</h3>  <h3>Which machines does GXemul emulate?</h3>
484    
485  A few different machine types are emulated. The machine types that are  A few different machine types are emulated. The following machine types
486  emulated best at the moment are:  are emulated well enough to run at least one "guest OS":
487    
488  <p>  <p>
489  <ul>  <ul>
490    <li><b>DECstation 5000/200</b>&nbsp;&nbsp;("pmax")    <li><b><u>ARM</u></b>
491          <br>(Serial controller (including keyboard and mouse), ethernet,    <ul>
492          SCSI, and graphical framebuffers.)      <li><b>CATS</b> (<a href="guestoses.html#netbsdcatsinstall">NetBSD/cats</a>,
493            <a href="guestoses.html#openbsdcatsinstall">OpenBSD/cats</a>)
494        <li><b>IQ80321</b> (<a href="guestoses.html#netbsdevbarminstall">NetBSD/evbarm</a>)
495        <li><b>NetWinder</b> (<a href="guestoses.html#netbsdnetwinderinstall">NetBSD/netwinder</a>)
496      </ul>
497    <p>    <p>
498    <li><b>Acer Pica-61</b>&nbsp;&nbsp;(an ARC machine)    <li><b><u>MIPS</u></b>
499          <br>(Serial controller, "VGA" text console, and SCSI.)    <ul>
500        <li><b>DECstation 5000/200</b> (<a href="guestoses.html#netbsdpmaxinstall">NetBSD/pmax</a>,
501            <a href="guestoses.html#openbsdpmaxinstall">OpenBSD/pmax</a>,
502            <a href="guestoses.html#ultrixinstall">Ultrix</a>,
503            <a href="guestoses.html#declinux">Linux/DECstation</a>,
504            <a href="guestoses.html#sprite">Sprite</a>)
505        <li><b>Acer Pica-61</b> (<a href="guestoses.html#netbsdarcinstall">NetBSD/arc</a>)
506        <li><b>NEC MobilePro 770, 780, 800, 880</b> (<a href="guestoses.html#netbsdhpcmipsinstall">NetBSD/hpcmips</a>)
507        <li><b>Cobalt</b> (<a href="guestoses.html#netbsdcobaltinstall">NetBSD/cobalt</a>)
508        <li><b>Malta</b> (<a href="guestoses.html#netbsdevbmipsinstall">NetBSD/evbmips</a>, Linux/Malta <font color="#0000e0">(<super>*1</super>)</font>)
509        <li><b>Algorithmics P5064</b> (<a href="guestoses.html#netbsdalgorinstall">NetBSD/algor</a>)
510        <li><b>SGI O2 (aka IP32)</b> <font color="#0000e0">(<super>*2</super>)</font>
511            (<a href="guestoses.html#netbsdsgimips">NetBSD/sgi</a>)
512      </ul>
513    <p>    <p>
514    <li><b>NEC MobilePro 770, 780, 800, and 880</b>&nbsp;&nbsp;(HPCmips machines)    <li><b><u>PowerPC</u></b>
515          <br>(Framebuffer, keyboard, and a PCMCIA IDE controller.)    <ul>
516        <li><b>IBM 6050/6070 (PReP, PowerPC Reference Platform)</b> (<a href="guestoses.html#netbsdprepinstall">NetBSD/prep</a>)
517        <li><b>MacPPC (generic "G4" Macintosh)</b> (<a href="guestoses.html#netbsdmacppcinstall">NetBSD/macppc</a>)
518      </ul>
519      <p>
520      <li><b><u>SuperH</u></b>
521      <ul>
522        <li><b>Sega Dreamcast</b> (<a href="dreamcast.html#netbsd_generic_md">NetBSD/dreamcast</a>)
523      </ul>
524  </ul>  </ul>
525    
526  <p>  <p>
527  There is code in GXemul for emulation of many other machine types;  <small><font color="#0000e0">(<super>*1</super>)</font> =
528  the degree to which these work range from "almost" being able to run  Linux/Malta may be run as a guest OS, however I have not yet found any stable
529  a complete OS, to almost completely unsupported (perhaps just enough  URL to pre-compiled Linux/Malta kernels. Thus, Linux/Malta emulation is not
530  support to output a few boot messages via serial console).  tested for every release of the emulator; sometimes it works, sometimes
531    it doesn't.</small>
532  <p>  
533  In addition to specific machine types, a "test-machine" can be emulated.  <br><small><font color="#0000e0">(<super>*2</super>)</font> =
534  A test-machine consists of one or more CPUs and a few experimental  SGI O2 emulation is enough for root-on-nfs, but not for disk boot.</small>
535  devices such as:  
536    
537    <p>There is code in GXemul for emulation of many other machine types; the
538    degree to which these work range from almost being able to run a complete
539    OS, to almost completely unsupported (perhaps just enough support to
540    output a few boot messages via serial console).
541    
542    <p>In addition to emulating real machines, there is also a "test-machine".
543    A test-machine consists of one or more CPUs and a few experimental devices
544    such as:
545    
546  <p>  <p>
547  <ul>  <ul>
548    <li>a console I/O device (putchar() and getchar()...)    <li>a console I/O device (putchar() and getchar()...)
549    <li>an inter-processor communication device, for SMP experiments    <li>an inter-processor communication device, for SMP experiments
550    <li>a very simple linear framebuffer device (for graphics output)    <li>a very simple linear framebuffer device (for graphics output)
551      <li>a simple disk controller
552      <li>a simple ethernet controller
553      <li>a real-time clock device
554  </ul>  </ul>
555    
556  <p>  <p>This mode is useful if you wish to run experimental code, but do not
 This mode is useful if you wish to run experimental code, but do not  
557  wish to target any specific real-world machine type, for example for  wish to target any specific real-world machine type, for example for
558  educational purposes.  educational purposes.
559    
560  <p>  <p>You can read more about these experimental devices <a
561  You can read more about these experimental devices  href="experiments.html#expdevices">here</a>.
 <a href="experiments.html#expdevices">here</a>.  
   
   
   
   
   
   
   
 <p><br>  
 <a name="guestos"></a>  
 <h3>Which guest OSes are possible to run?</h3>  
   
 This table sums up the guest OSes that run well enough to be considered  
 working in the emulator. They can boot from a harddisk image and be  
 interacted with similar to a real machine:  
   
 <p><br>  
  <center>  
   <table border="0">  
     <tr><td>  
       <table border="0">  
         <tr><td align="center">  
           <table border="0">  
             <tr>  
               <td valign="top"><b><u>Guest&nbsp;OS:</u></b></td>  
               <td width="15">&nbsp;</td>  
               <td valign="top"><b><u>Emulation&nbsp;mode:</u></b></td>  
               <td width="35">&nbsp;</td>  
               <td valign="top"><b><u>Guest&nbsp;OS:</u></b></td>  
               <td width="15">&nbsp;</td>  
               <td valign="top"><b><u>Emulation&nbsp;mode:</u></b></td>  
             </tr>  
   
             <tr>  
               <td height="1"></td>  
             </tr>  
   
             <tr>  
               <td valign="top"><a href="http://www.netbsd.org/Ports/pmax/">NetBSD/pmax</a></td>  
               <td></td>  
               <td valign="top">DECstation</td>  
               <td></td>  
               <td valign="top"><a href="http://www.netbsd.org/Ports/arc/">NetBSD/arc</a></td>  
               <td></td>  
               <td valign="top">ARC&nbsp;(Acer&nbsp;Pica)</td>  
             </tr>  
   
             <tr>  
               <td valign="top"><a href="http://www.openbsd.org/pmax.html">OpenBSD/pmax</a></td>  
               <td></td>  
               <td valign="top">DECstation</td>  
               <td></td>  
               <td valign="top"><a href="http://www.openbsd.org/arc.html">OpenBSD/arc</a></td>  
               <td></td>  
               <td valign="top">ARC (Acer Pica)</td>  
             </tr>  
   
             <tr>  
               <td valign="top">Ultrix/RISC</td>  
               <td></td>  
               <td valign="top">DECstation</td>  
               <td></td>  
               <td valign="top"><a href="http://www.cs.berkeley.edu/projects/sprite/retrospective.html">Sprite</a></td>  
               <td></td>  
               <td valign="top">DECstation</td>  
             </tr>  
   
             <tr>  
               <td valign="top">Redhat&nbsp;Linux<super>*</super></td>  
               <td></td>  
               <td valign="top">DECstation</td>  
               <td></td>  
               <td valign="top"><a href="http://www.debian.org/">Debian&nbsp;GNU/Linux</a><super>*</super></td>  
               <td></td>  
               <td valign="top">DECstation</td>  
             </tr>  
   
             <tr>  
               <td valign="top"><a href="http://www.netbsd.org/Ports/hpcmips/">NetBSD/hpcmips</a></td>  
               <td></td>  
               <td valign="top">NEC MobilePro</td>  
             </tr>  
           </table>  
         </td></tr>  
   
         <tr><td height="15">&nbsp;</td></tr>  
   
         <tr><td>  
           <center>  
             <table border="0">  
               <tr>  
                 <td width=160 align=center><a href="netbsd-pmax-20040630.png"><img src="netbsd-pmax-20040630_small.png"></a></td>  
                 <td width=160 align=center><a href="openbsd-pmax-20040710.png"><img src="openbsd-pmax-20040710_small.png"></a></td>  
                 <td width=160 align=center><a href="ultrix4.5-20040706.png"><img src="ultrix4.5-20040706_small.gif"></a></td>  
               </tr>  
               <tr>  
                 <td align=center>NetBSD/pmax&nbsp;1.6.2</td>  
                 <td align=center>OpenBSD/pmax&nbsp;2.8</td>  
                 <td align=center>Ultrix&nbsp;4.5</td>  
               </tr>  
               <tr>  
                 <td height=10>&nbsp;</td>  
               </tr>  
               <tr>  
                 <td width=160 align=center><a href="20041024-netbsd-arc-installed.gif"><img src="20041024-netbsd-arc-installed_small.gif"></a></td>  
                 <td width=160 align=center><a href="20041024-openbsd-arc-installed.gif"><img src="20041024-openbsd-arc-installed_small.gif"></a></td>  
                 <td width=160 align=center><a href="sprite-20040711.png"><img src="sprite-20040711_small.png"></a></td>  
               </tr>  
               <tr>  
                 <td align=center>NetBSD/arc&nbsp;1.6.2</td>  
                 <td align=center>OpenBSD/arc&nbsp;2.3</td>  
                 <td align=center>Sprite</td>  
               </tr>  
               <tr>  
                 <td height=10>&nbsp;</td>  
               </tr>  
               <tr>  
                 <td width=160 align=center><a href="20041129-redhat_mips.png"><img src="20041129-redhat_mips_small.png"></a></td>  
                 <td width=160 align=center><a href="20041213-debian_4.png"><img src="20041213-debian_4_small.gif"></a></td>  
                 <td width=160 align=center><a href="20050331-netbsd-hpcmips.png"><img src="20050331-netbsd-hpcmips_small.png"></a></td>  
               </tr>  
               <tr>  
                 <td align=center>Redhat&nbsp;Linux<super>*</super></td>  
                 <td align=center>Debian&nbsp;GNU/Linux<super>*</super></td>  
                 <td align=center>NetBSD/hpcmips</td>  
               </tr>  
             </table>  
           </center>  
         </td></tr>  
       </table>  
     </td></tr>  
   </table>  
  </center>  
   
 <p><br>  
   
 (<super>*</super> Although Linux runs under DECstation emulation, the  
 default kernel in Debian GNU/Linux does not support keyboards on the 5000/200  
 (the specific DECstation model being emulated), so when the login prompt  
 is reached you cannot interact with the system.  
 Kaj-Michael Lang has compiled and made available a newer kernel from the  
 current mips-linux development tree. You can find it here:  
 <a href="http://home.tal.org/~milang/o2/kernels/">http://home.tal.org/~milang/o2/kernels</a>/<a href="http://home.tal.org/~milang/o2/kernels/vmlinux-2.4.29-rc2-r3k-mipsel-decstation">vmlinux-2.4.29-rc2-r3k-mipsel-decstation</a>  
 This newer kernel supports keyboard input, but it does not have Debian's  
 ethernet patches, so you will not be able to use keyboard/framebuffer  
 <i>and</i> networking at the same time.)  
   
   
 <p>  
 It is non-trivial to get a specific operating system or OS kernel to  
 run in the emulator, so don't expect the list above to grow too quickly.  
   
 <p>  
 There is no guarantee that anything specific will run in the emulator, but  
 NetBSD is a good starting point for someone who wants to experiment.  
562    
563    
564    
565    
566    
 </p>  
567    
568  </body>  </body>
569  </html>  </html>

Legend:
Removed from v.2  
changed lines
  Added in v.34

  ViewVC Help
Powered by ViewVC 1.1.26