[HN Gopher] SVC16: Simplest Virtual Computer
___________________________________________________________________
SVC16: Simplest Virtual Computer
Author : thunderbong
Score : 135 points
Date : 2024-12-15 16:39 UTC (6 hours ago)
(HTM) web link (github.com)
(TXT) w3m dump (github.com)
| PaulHoule wrote:
| It is like the PDP-8 (tiny instruction set) and the TMS 9900 (no
| registers) but the 16-bit word size for memory did not catch on
| for real hardware.
| nabla9 wrote:
| 16 bit microcontrollers are a $25 billion market.
| p_l wrote:
| Those are usually supporting byte accesses, not limited to
| word accesses.
| vardump wrote:
| 8086, 80286, 680[01]0 all had a 16-bit word size and could only
| access RAM at 16-bit granularity (I/O is a different story). Of
| course they had the ability to extract just a byte as well.
|
| 68000 generates a bus error if you try unaligned 16/32-bit
| access.
| PaulHoule wrote:
| But you could have had a system with 64k 16-bit words that
| gives 128k bytes.
| Tor3 wrote:
| I worked with a 16-bit minicomputer as late as 1995.. word
| addressable, not byte addressable.
| max_ wrote:
| I remember coming across a JS repo that had lots of minimum
| viable implementations.
|
| It has simple processors, simple compilers etc.
|
| I wish I could find it.
| nroize wrote:
| Not JS but there's Build Your Own X
| https://github.com/codecrafters-io/build-your-own-x
| azinman2 wrote:
| This is super cool. Thanks for posting it. I dream of being
| retired and being able to go through each one.
| nefarious_ends wrote:
| Wow this looks cool, I'm going to try writing a program. I have
| recently been learning about computer architecture (specifically
| older 8 bit CPUs) so when I read "There are no CPU registers" I
| was very intrigued.
| joshu wrote:
| stack pointer? offset addressing mode?
| anfilt wrote:
| The ISA is a bit complex for the simplest Virtual Computer. One
| Instruction computers are a thing:
| https://en.wikipedia.org/wiki/One-instruction_set_computer#I...
| ivanjermakov wrote:
| Readme mentioned that creating the simplest possible computer
| wasn't the goal
| ks2048 wrote:
| I had a similar thought. Better name is SVC16: Simple Virtual
| Computer
| bbminner wrote:
| Can someone explain to me the appeal of these virtual console
| projects? Is it like lock picking or demoscene in a sense that
| you need to figure how to achieve impressive things under tight
| constraints?
| ktpsns wrote:
| Purpose, my guess: Fun, joy of understanding, tinkering,
| learning and education.
|
| Such projects can grow and eventually somebody learning on this
| builds the next Language or Qemu.
| Retr0id wrote:
| I enjoy implementing these sorts of things from a spec. It's
| very rewarding to have other peoples' games boot up in your
| emulator.
| Lerc wrote:
| I feel like it is the same form of intellectual stimulation
| that one gets from crosswords or sudoku but with an added
| creative dimension. Where crosswords and sudoku present a
| challenge with a fixed target goal, the demo scene and virtual
| consoles give you the difficulty with an open ended goal.
|
| Code golf is somewhere in the middle, Often you have a fixed
| goal, but there is no one 'right' solution, creativity can find
| many paths to achieve the desired output while reducing line or
| character count.
|
| So I do
|
| Dweets https://beta.dwitter.net/u/lerc/top
|
| My own fantasy console
| https://k8.fingswotidun.com/static/ide/?gist=ad96329670965dc...
|
| A stack machine image generator limited to 50 characters of
| program code https://c50.fingswotidun.com/
|
| Why do it? Why play with Lego? It's interesting and you get to
| see what you make.
|
| The proliferation of fantasy consoles is simply because making
| a fantasy console appeals to the same aesthetic. See what you
| can make.
| boricj wrote:
| That instruction set looks _really_ weird, like some sort of
| obscure and long-forgotten 1960s experimental architecture.
|
| If I understand it correctly, the entire register file except for
| PC is effectively memory-mapped, it uses 16-bit word addressing
| and the peripherals (framebuffer + mouse) are accessed through
| dedicated instructions. Instructions are four words long, the
| first one only having 16 valid opcodes and the rest referencing
| either direct memory addresses or raw word values.
| adonovan wrote:
| > forgotten 1960s architecture... the entire register file is
| memory-mapped
|
| 1830s, in fact--the original computer, Babbage's Analytical
| Engine!
| otaka wrote:
| As for me, it is bad that there is no any permanent storage like
| disk. Also the lack of keyboard is a big limitation
| d3VwsX wrote:
| To keep things simple maybe just handle that using emulator
| save-states instead?
| catlifeonmars wrote:
| You could memory map additional device drivers at the end of
| the memory as a way to extend with arbitrary peripherals
| ljlolel wrote:
| Worse is better
| ilaksh wrote:
| This is really simple and approachable. Reminds me slightly of
| Forth or subleq.
|
| https://colorforth.github.io/index.html
|
| https://en.wikipedia.org/wiki/Forth_(programming_language)
|
| https://github.com/davidar/subleq/blob/master/README.md
| ivanjermakov wrote:
| Can't not mention a great game about programming a SIC using
| subleq called SIC-1:
| https://store.steampowered.com/app/2124440/SIC1/
|
| Second part of the game requires writing self-modifying code
| which is quite mindboggling!
| retrac wrote:
| Subleq some other OISCs are surprisingly effective. There's a
| four operand variant that has some interesting properties.
| Given fixed-width unsigned two's complement arithmetic:
| for(;;) { *a = *b - *c; if *a <= 0 then ip = d else ip++; }
|
| The equivalent of mov, sub, add, negate, unconditional jump,
| conditional jump, and (crucially) jump-and-return-link can be
| done with just one instruction, with various operands. And with
| some self-modifying of the arguments in the instructions,
| pointer indirection, stack simulation, etc. is mostly 1 - 3
| instruction sequences. Almost not a Turing tarpit. The
| dependency on self-modifying code is a bit ugly to modern
| aesthetics but there's a fix even for that that involves no
| more hardware (though more memory and memory cycles): just add
| a level of indirection to the operands.
| d3VwsX wrote:
| A bit confused by the goto and skip instructions. Why multiply by
| 4 in one, but not the other? Sounds reasonable that both keep the
| target address a valid instruction pointer (aligned to 4 words)?
|
| Adding two words to create an address is a fun variation of
| segment pointers, but even more wasteful than x86 16-bit
| segment+offset pointers (not a complaint, just an observation).
| revskill wrote:
| I thought it is excel.
| Lerc wrote:
| I like toys like this. I even have made a few of my own, doodled
| instruction set ideas on many scraps of paper, and so forth.
|
| It's a bit weird that this particular instruction set annoys me
| so much. Perhaps annoys is the wrong word, maybe irritates is
| better. The entire thing I can get behind except for the
| instruction encoding. The instructions are too large for the
| space available. 128k of ram for programs and 128k for screen
| (and workspace area, given sync), but at 8 bytes per instruction
| it eats up the limited resource too quickly.
|
| I guess that irritation comes from the efficiency hacks that
| these constrained environments encourage. It revives an age of
| clever tricks to get the most of of a little. The instruction
| size pokes at that aesthetic like a lump in a pillow.
|
| I'm not sure what would be a better solution while preserving
| simplicity. maybe a single extra dereference to turn
| opcode arg1 arg2 arg3 @(IP) @(IP+1) @(IP+2) @(IP+3) ;;
| IP+=4
|
| into @(@IP) @(@IP+1) @(@IP+2) @(@IP+3) ;;
| IP+=1
|
| which would be one system word per instruction lookup, from a
| dictionary of instructions in RAM (coders would have to be
| careful not to lose the ability to generate all constant values
| if they eliminated certain dictionary entries(
|
| Tiny programs would get bigger , Larger programs would be smaller
| when they reuse instructions.
|
| If you wanted to work against the idea of 'simplest' and embrace
| the notion of weird-features-because-of-technical-debt, you could
| make an 'upgraded' machine that has a second bank of 128k (64k
| words) as dedicated program memory, that is initialized at
| startup with the numbers 0x0000 to 0xffff. This would make the
| machine run SVC16 programs unmodified. You could then either have
| it use program ROMs or add a single instruction
| StoreProgMem @progMem(@arg1+@arg3) =(@arg2+@arg3)
|
| Which would enable writing the program space.
|
| Egads, I've been nerd sniped!
| nine_k wrote:
| Why, there is a well-known approach to having constant-size,
| small opcodes: a data stack. The only non-constant size
| instruction would be the one that puts an immediate argument
| onto the stack. Jumps would pop the target address off the
| stack, too. The stack should be the width of the ALU, say, 32
| bit, while the machine codes could be half a byte, like here.
|
| I'm very surprised this smallest machine is not a stack
| machine.
| jonjacky wrote:
| Compare this to the LGP-30, a "small" (desk-sized) vacuum tube
| computer of the 1950s. It also had just 16 instructions. It
| nominally had some registers, but these were just locations on
| the same magnetic drum that stored all the other data.
|
| https://en.wikipedia.org/wiki/LGP-30
| mechagodzilla wrote:
| It took me about 20 minutes to make a basic FPGA-friendly
| implementation of the CPU core in Verilog, but the 256KB of ram
| is pretty expensive (16-bit color seems excessive for such a
| simple core!).
| boutell wrote:
| I wondered how long it would take for someone to do this. An
| amount of time approaching zero apparently. Nice.
| mechagodzilla wrote:
| Implementing a CPU, if you're not trying to hyper-optimize
| it, is reasonably straightforward. This is a very simple
| design. It would take a little bit more work to add proper
| video output and mouse input, but those blocks are easy to
| find for VGA and PS/2 mice. I think this would run > 100 MHz
| very easily on anything made in the last decade.
| mechagodzilla wrote:
| Ugh, I just noticed it's even worse - the display is double-
| buffered, so you actually need 384KB of ram (128KB for system
| RAM and 2 x 128KB display buffers!).
| gnarbarian wrote:
| I like nock.
|
| the official specification for Nock, the assembly language used
| by the Urbit virtual machine, fits on a t-shirt: The Nock
| specification is only 200 words long It can be compressed to 371
| bytes Nock is a low-level, homoiconic combinator language that's
| similar to JVM code. It's designed to be simple, and is
| interpreted by Vere. Hoon is the practical layer of Urbit, and it
| compiles itself to Nock, the simple layer.
| gnarbarian wrote:
| https://docs.urbit.org/language/nock/reference/specification
| anthk wrote:
| subleq can be done in few lines of AWK, you could just use
| busybox instead of a huge Rust toolchain.
| machinestops wrote:
| The ISA leaves something to be desired for "simplest". Simple,
| sure, but parameters (and unused ones, at that!)? Memory copy
| instructions? Multiply and no shifts? Addition _and_ subtraction?
|
| Others have mentioned Subleq (Subtract And Branch If Less Than Or
| Equal To), but there's more useful designs that meet all the
| design constraints. They state that "It is also not intended to
| be as simple and elegant as it could possibly be.", but it's
| called "The Simplest Virtual Computer" - that kind of name is a
| challenge.
___________________________________________________________________
(page generated 2024-12-15 23:00 UTC)