8 Feb
2022
8 Feb
'22
12:15 a.m.
I remember taking a course in systems architecture from an IBM'er when
he pointed out that, based on their measurements and sampling,
arithmetic wasn't as big a portion of the instruction mix as might
commonly be thought. He said, "Computers don't add. What computers do
is branch." (IBM lingo for a jump or a change of PC). It was one of
those eye opening moments.
So, Yes, you are going to have a bunch a jumps, it's really about how
they get hit.
I found doing a compare and conditional jump nice, but perhaps that's
because this is how the x86 does unsigned arithmetic, which the 10
doesn't really have.
I think the only time skips ever get confusing for me is when you want
to transfer execution based on a bunch of bits all being on. You can
test for them all being off (TxnE), but the corresponding test (TxnN)
skips if *any* of them are on. So that means you have to complement the
bits (TRC, say) then test them for being off while complementing them
back again.
I believe the saying went something like, "Tricky, tricky, track" or
something like that.
On 2/7/22 5:40 PM, Johnny Billquist wrote:
On 2022-02-07 21:41, Dennis Boone wrote:
I don't agree. Skips aren't really any more strange than branches.
We're talking assembler here anyway. There are bound to be jumps all
over the place always. Not really more spagetti in any architecture
compared to any other.
The probably more "ugly" thing in the PDP-8 is that you do self
modifying code very often.
With the limited instruction set of the PDP-8, only one accumlator,
and very limited addressing modes, combining any instruction with an
ISZ (increment, basically) of that instruction allowed it to walk over
some memory space easily, since the address is in the low 7 bits of
the instruction.
Johnny
PDP-8
works this way too. Many people wrinkle their noses about it,
but I find the skip model to be very convenient and easy to wrangle.
The Honeywell x16 family does this too. It's more or less
definitionally spaghetti code, which is probably the cause of the nose
wrinkling. It'd be interesting to see if the rise in awareness of some
of this sort of "structured code" thinking coincides with a decline in
architectures using skips.