I asked this question. I've been studying and working on emulators since then.
Another good resource if you are interested in this sort of thing is Victor Barrio's thesis he wrote on the subject of emulation techniques (148pg - PDF): http://db.tt/dUJwwR
Hey Simucal. I'm the Cody Brocious that answered this, and as much as I love this question, it pains me to see it. I edited it so much, it went into community wiki, before it even had 10 upvotes ;)
But for the record, I'm about 1/4 of the way through a book on emulator development, and I'm currently in preliminary talks with one of the bigger names in tech publishing about getting it out there. Not nearly enough resources on emulation these days.
Edit: I've created a poll to gauge interest for such a book, as I've previously believed strongly that the market is very small. Feedback would be greatly appreciated.
It looks like you asked this question about a year ago -- since then, what have you done with emulators? (Just curious.) Did you find it easy / hard to get started?
I found http://openbookproject.net/py4fun/ a while back. It has quite a few projects, one of which is a "toy computer" emulator written in Python. It goes from the raw emulator, through to writing a simple language and compiler for it.
It is a toy example (hence the name, I guess), but a picture is worth a thousand words, if you're wondering about the nitty gritty of it all.
If you're interested in seeing (another) emulator implementation, the Computer History Simulation Project (simh) package <http://simh.trailing-edge.com/>; emulates various boxes.
Think of it this way. A program is just a set of bytes (which are numbers from 0 to 255) which describe what it should do. The goal of most programs is usually just to read in some data (again, just a set of bytes) which is stored in memory, then manipulate that data.
The easiest way to understand how to emulate hardware in software is to just make up your own simple assembly language. For example, let's say you want to have these operations:
"set <memory location> <value between 0 and 255>" -- sets the value at <memory location> to the specified value
"add <src memory location 1> <src memory location 2>" -- adds the numbers at the two memory locations, and stores the result into memory location 1
The point is to keep it ridiculously simple for now, so let's assume the memory locations we provide are also values between 0 and 255 -- effectively giving us 256 bytes of memory to work with.
So let's write a very simple program. It will perform 2 + 2.
set 0 2
set 1 2
add 0 1
The result is now in memory location 0, and the result is "4" obviously.
So what might the program look like on disk? Well, we only have two instructions, so let's say the code for "set" is "0" and the code for "add" is 1". If we store the program in a file, then it might look like this:
0 0 2 0 1 2 1 0 1
Now that we've defined an extremely simple assembly language, we can write a virtual machine for it as follows.
First, write a program which allocates 256 bytes of memory. This is our virtual machine's memory space.
- Read in the first byte of the program.
- If it's 0 ("set"), then read in two more bytes (the dst and value arguments for "set"). Set mem[dst] = value.
- If it's 1 ("add"), then read in two more bytes (the "dst" and "src" arguments for "add"). Set mem[dst] = mem[dst] + mem[src].
- If it's > 1, then abort (the program is invalid).
If this all made sense to you, then you should be a stone's throw away from being able to write a VM for more complicated instruction sets. Just find out what the instruction set can do, and then write a VM which allows the instructions to do those things.
My "Aha!" moment came during my foundations of CS class at uni. As such, I'd suggest reading up on the work of Alan Turing (Church is good too, but Turing's state-machine-based definitions are usually more approachable to a beginner).
[+] [-] Simucal|16 years ago|reply
Another good resource if you are interested in this sort of thing is Victor Barrio's thesis he wrote on the subject of emulation techniques (148pg - PDF): http://db.tt/dUJwwR
It provides a good overview to get you started.
[+] [-] daeken|16 years ago|reply
But for the record, I'm about 1/4 of the way through a book on emulator development, and I'm currently in preliminary talks with one of the bigger names in tech publishing about getting it out there. Not nearly enough resources on emulation these days.
Edit: I've created a poll to gauge interest for such a book, as I've previously believed strongly that the market is very small. Feedback would be greatly appreciated.
[+] [-] palish|16 years ago|reply
[+] [-] anthonyb|16 years ago|reply
It is a toy example (hence the name, I guess), but a picture is worth a thousand words, if you're wondering about the nitty gritty of it all.
[+] [-] Hoff|16 years ago|reply
[+] [-] videl|16 years ago|reply
[+] [-] palish|16 years ago|reply
The easiest way to understand how to emulate hardware in software is to just make up your own simple assembly language. For example, let's say you want to have these operations:
"set <memory location> <value between 0 and 255>" -- sets the value at <memory location> to the specified value
"add <src memory location 1> <src memory location 2>" -- adds the numbers at the two memory locations, and stores the result into memory location 1
The point is to keep it ridiculously simple for now, so let's assume the memory locations we provide are also values between 0 and 255 -- effectively giving us 256 bytes of memory to work with.
So let's write a very simple program. It will perform 2 + 2.
The result is now in memory location 0, and the result is "4" obviously.So what might the program look like on disk? Well, we only have two instructions, so let's say the code for "set" is "0" and the code for "add" is 1". If we store the program in a file, then it might look like this:
Now that we've defined an extremely simple assembly language, we can write a virtual machine for it as follows.First, write a program which allocates 256 bytes of memory. This is our virtual machine's memory space.
- Read in the first byte of the program.
- If it's 0 ("set"), then read in two more bytes (the dst and value arguments for "set"). Set mem[dst] = value.
- If it's 1 ("add"), then read in two more bytes (the "dst" and "src" arguments for "add"). Set mem[dst] = mem[dst] + mem[src].
- If it's > 1, then abort (the program is invalid).
If this all made sense to you, then you should be a stone's throw away from being able to write a VM for more complicated instruction sets. Just find out what the instruction set can do, and then write a VM which allows the instructions to do those things.
[+] [-] amalcon|16 years ago|reply
[+] [-] thinkbohemian|16 years ago|reply
[+] [-] ThePinion|16 years ago|reply
[+] [-] palish|16 years ago|reply