Nobody else builds their ISA around blocks of instructions - not the
Power PC, not the SPARC, not the 680x0, not the System/360, not the
x86. The only example out there of a sort of block structure is the
Itanium!
But the thing that kept forcing me back to block structure was that I couldn't even meet my efficiency goals for what I regarded as the
basic part of the instruction set without block structure. Load/store memory-reference instructions, with base-index addressing and 16-bit displacements took up a minimum of 3/4 of the opcode space, without compromises that I tried and tried and could not ever reconcile myself
with.
The other thing I absolutely needed was (near, quasi) 16-bit short instructions. It's possible to fit a useful register-to-register
operate instruction into that space, a big part of a program could be
made out of such instructions, and so leaving them out would doom
programs to be almost twice as big as they had to be.
But with only 1/4 of the opcode space, it seemed like there was *no
way* I could have them too without block structure.
But as the history of Concertina II has certainly shown, I'm not
adverse to trying bizarre and nutty ideas.
I need eight instructions for each floating-point type, but sixteen instructions for each integer type.
My main goal is a processor capable of providing high performance for scientific applications. So I need all 32 registers for floating-point operations.
So I squeeze two short instructions into a 32-bit word starting with
11 by using 15-bit instructions with the following properties...
John Savard--- Synchronet 3.22a-Linux NewsLink 1.2
quadibloc@invalid.com (John Savard) posted:
I need eight instructions for each floating-point type, but sixteen
instructions for each integer type.
FP is always signed, int is both signed and unsigned. Thus, FP is a
sub-set of int and you can use this in your memory refs.
My main goal is a processor capable of providing high performance for
scientific applications. So I need all 32 registers for floating-point
operations.
Maybe, maybe not. CDC 6600/7600 only had 8 and dominated the market
for over a decade.
So I squeeze two short instructions into a 32-bit word starting with
11 by using 15-bit instructions with the following properties...
How matters little when the concept is fundamentally flawed.
On Tue, 27 Oct 2026 21:17:28 GMT, MitchAlsup ><user5857@newsgrouper.org.invalid> wrote:
quadibloc@invalid.com (John Savard) posted:
So I squeeze two short instructions into a 32-bit word starting with
11 by using 15-bit instructions with the following properties...
How matters little when the concept is fundamentally flawed.
That is true, whichever concept it is that is fundamentally flawed.
Is it
- putting two 16-bit instructions in a 32-bit word, so that simplistic >decoding will not require too many overhead bits;
- the general idea of the Concertina series of ISAs, which is to
squeeze too much into an ISA at every level of too few bits;
- or any of many other possibilities? Or a whole pile of them?
So I squeeze two short instructions into a 32-bit word starting with
11 by using 15-bit instructions with the following properties...
One bit says if it's fixed or floating.
If floating, then there's a four-bit opcode field. Eight operations
for two floating-point types.
On Tue, 27 Oct 2026 21:17:28 GMT, MitchAlsup <user5857@newsgrouper.org.invalid> wrote:{this
quadibloc@invalid.com (John Savard) posted:
I need eight instructions for each floating-point type, but sixteen
instructions for each integer type.
FP is always signed, int is both signed and unsigned. Thus, FP is a
sub-set of int and you can use this in your memory refs.
It's true that unsigned integers are a concept which some languages
support (C, but not FORTRAN). Given that, an ISA has to support them;
a processor on which a C compiler would not run well would have little
market appeal. Not least because how on Earth would you port Linux to
an architecture on which code generated by a C compiler could not run? However, I don't require extra instructions to support unsigned
integers, only extra condition codes.
The reason why I need more instructions for integer types is because
there's no such thing as a floating XOR, AND, or OR.
As far as the memory reference instructions go, though, unsigned is
relevant. After all, integers have LOAD, INSERT, and LOAD UNSIGNED in addition to STORE, while floats only have LOAD and STORE. (Because
integers are right-aligned and, by default with LOAD, sign-extended.)
Since I have separate ADD BYTE, ADD HALFWORD, ADD, and ADD LONG
instructions, I suppose I _could_ only have a LOAD instruction that
inserts left-aligned... but I don't trust myself to properly imagine
an ISA that isn't slavishly bound to the assumptions and mentality of
the IBM System/360. I'd expect myself to miss something important, and
create a fatally flawed design without noticing it.
My main goal is a processor capable of providing high performance for
scientific applications. So I need all 32 registers for floating-point
operations.
Maybe, maybe not. CDC 6600/7600 only had 8 and dominated the market
for over a decade.
I'm not sure that's relevant, since MIPS and PowerPC and ARM are out
there as competition to be concerned with. Plus, full Tomasulo or
Explicit Register Rename are what I have to compete with, not
scoreboarding.
So I squeeze two short instructions into a 32-bit word starting with
11 by using 15-bit instructions with the following properties...
How matters little when the concept is fundamentally flawed.
That is true, whichever concept it is that is fundamentally flawed.
Is it
- putting two 16-bit instructions in a 32-bit word, so that simplistic decoding will not require too many overhead bits;
- the general idea of the Concertina series of ISAs, which is to} is creating the unsolvable dilemma.
squeeze too much into an ISA at every level of too few bits;
- or any of many other possibilities? Or a whole pile of them?--- Synchronet 3.22a-Linux NewsLink 1.2
John Savard
Since I have separate ADD BYTE, ADD HALFWORD, ADD, and ADD LONG
instructions, I suppose I _could_ only have a LOAD instruction that
inserts left-aligned... but I don't trust myself to properly imagine
an ISA that isn't slavishly bound to the assumptions and mentality of
the IBM System/360. I'd expect myself to miss something important, and
create a fatally flawed design without noticing it.
{this
- the general idea of the Concertina series of ISAs, which is to} is creating the unsolvable dilemma.
squeeze too much into an ISA at every level of too few bits;
Why left-aligned, for heaven's sake?
On Thu, 29 Oct 2026 06:33:01 -0000 (UTC), Thomas Koenig ><tkoenig@netcologne.de> wrote:
Why left-aligned, for heaven's sake?
At present, integer types shorter than 64 bits are always right
aligned, even as it was on the System/360.
zSeries added a bunch of instructions that do 32 bit operations
on the high half of a 64 bit register, add, subtract, compare,
load, store, even load and store multiple.
It's not clear to me what the point is but someone must have wanted them.
Even though that's an adequate amount of opcode space to long
instructions, it seems... unbalanced.
On Thu, 29 Oct 2026 15:51:05 -0000 (UTC), John Levine
<johnl@taugh.com> wrote:
zSeries added a bunch of instructions that do 32 bit operations
on the high half of a 64 bit register, add, subtract, compare,
load, store, even load and store multiple.
It's not clear to me what the point is but someone must have wanted them.
Wouldn't 32-bit operations on the high half, ignoring the other half,
be more compatible with 32-bit operations on a machine with 32-bit
registers than 32-bit operations on the low half?
John Savard
On Thu, 29 Oct 2026 06:33:01 -0000 (UTC), Thomas Koenig <tkoenig@netcologne.de> wrote:
Why left-aligned, for heaven's sake?
At present, integer types shorter than 64 bits are always right
aligned, even as it was on the System/360.
Left-aligned was suggested as an _alternative_ so as to avoid the need
for sign-extension complexities, while maintaining the property that
carry out is always out of the actual leftmost bit of the register.
The plus is that one only needs LOAD and STORE for integers.--- Synchronet 3.22a-Linux NewsLink 1.2
The minus is that fixed-point quantities, considered as integers
(rather than fractions in [0,1) ) no longer automatically interconvert
when loaded/stored from the same register.
John Savard
On Thu, 29 Oct 2026 14:04:59 GMT, quadibloc@invalid.com (John Savard)
wrote:
Even though that's an adequate amount of opcode space to long
instructions, it seems... unbalanced.
The ISA is such that there is no way to squeeze out a big chunk of
opcode space from the 32-bit instructions.
The paired 15-bit short instructions, on the other hand, are more
tempting.
The obvious way to make more opcode space available here would be to
give up the self-indulgence of supporting the Medium floating-point
type in short instructions.
Medium was included, however, precisely because it was useful for the architecture's intended primary application area, scientific
computation. Given a 32-bit word instead of a 36-bit word, not only is
Medium useful, however, but single precision is not useful.
And that suggests choosing Medium and Double as the two floating types
to support.
But that exchanges unbalanced for... unhinged!
Could I use a mode bit to switch between Medium/Double and
Single/Double?
Could I limit the harm by making that mode bit only changeable in
kernel mode? Problem: then one has parts of the floating-point library
that aren't accessible to programs that requested the other option on
load.
How about associating the mode with the memory containing the code by--- Synchronet 3.22a-Linux NewsLink 1.2
putting it inside the paging mechanism? Solves all the problems, at
the cost of yuck.
A Plan B suggests itself. Support all four basic floating types in
short instructions, but give them only the first 16 registers instead
of all 32. But that saves two bits, instead of just the one that is
needed...
Oh, of course. Acknowledge that Thumb Mode on the ARM required
sacrifices, but avoid the most painful one. Replace unhinged with
truly evil.
Short instructions for double precision, the default type for
scientific computation, get all 32 registers.
Single, Medium, and Quad get 16 registers. This meets my opcode space
goals, and avoids any temptation to consider a mode bit.
John Savard
More Danger Will Robinson, Danger.
Unfortunately, while that solution has the virtue of concentrating the
use of opcode space on what is most important, it looks to be
genuinely bizarre.
quadibloc@invalid.com (John Savard) posted:
Medium was included, however, precisely because it was useful for
the architecture's intended primary application area, scientific computation. Given a 32-bit word instead of a 36-bit word, not
only is Medium useful, however, but single precision is not useful.
Is there any scientific computing that has not already been ported
to IEEE 754 FP32 and FP64 ??
No, but quadibloc wants to be able to run old software natively, or
nearly so.
That might be achieved by creating an exceptionally versatile microcode >engine, capable of loading instruction sets on a per-process basis.
On Fri, 30 Oct 2026 05:00 +0000 (GMT Standard Time), jgd@cix.co.uk
(John Dallman) wrote:
No, but quadibloc wants to be able to run old software natively, or
nearly so.
That might be achieved by creating an exceptionally versatile microcode >>engine, capable of loading instruction sets on a per-process basis.
I thought that microcode was an obsolete implementation technique
which was excessively slow. But then, on the other hand, it seems that
it is sort of used on modern computers, just in a modified form that >harmonizes with their largely hardwired design, so that microcode can
be used to patch design errors after the fact and to implement a few
of the fancier instructions.
Definitely, though, this sounds like a good suggestion, simply because
it avoids designing an ISA that is burdened with more instructions
than other ISAs.
From my perspective, though, it has problems. Microcode, unlike an
ISA, tends to be model-dependent. Even if it's documented and
available to the user, it's not as accessible to the ordinary
programmer as an ISA.
Since Concertina III is squeezing everything into the opcode space >available... for a single instruction set, with no mode bits, without
block structure, and with (in the case, at least, of 64-bit
instructions) the additional overhead of length-indicating bits in
each 32 bits (so that instruction decode can blindly look at every 32
bits in the instruction stream without waiting for the previous part
of the instruction stream to have its length recognized)... it's going
to drop at least some of this excess.
It'll keep native S/360 float, because that will be just one of a
large number of data types supported.
But it will probably drop trying to treat memory as composed of
48/36/60 bit words and handling different-length data types. While I
might _possibly_ be able to squeeze that into the recently increased
opcode space available for 64-bit instructions, I doubt it, and that
feature _is_ a luxury, even by my (wretchedly low) standards.
On Fri, 30 Oct 2026 10:15:41 GMT, quadibloc@invalid.com (John Savard)
wrote:
On Fri, 30 Oct 2026 05:00 +0000 (GMT Standard Time), jgd@cix.co.uk
(John Dallman) wrote:
No, but quadibloc wants to be able to run old software natively, or
nearly so.
That might be achieved by creating an exceptionally versatile microcode
engine, capable of loading instruction sets on a per-process basis.
I thought that microcode was an obsolete implementation technique
which was excessively slow. But then, on the other hand, it seems that
it is sort of used on modern computers, just in a modified form that
harmonizes with their largely hardwired design, so that microcode can
be used to patch design errors after the fact and to implement a few
of the fancier instructions.
Definitely, though, this sounds like a good suggestion, simply because
it avoids designing an ISA that is burdened with more instructions
than other ISAs.
From my perspective, though, it has problems. Microcode, unlike an
ISA, tends to be model-dependent. Even if it's documented and
available to the user, it's not as accessible to the ordinary
programmer as an ISA.
Since Concertina III is squeezing everything into the opcode space
available... for a single instruction set, with no mode bits, without
block structure, and with (in the case, at least, of 64-bit
instructions) the additional overhead of length-indicating bits in
each 32 bits (so that instruction decode can blindly look at every 32
bits in the instruction stream without waiting for the previous part
of the instruction stream to have its length recognized)... it's going
to drop at least some of this excess.
It'll keep native S/360 float, because that will be just one of a
large number of data types supported.
But it will probably drop trying to treat memory as composed of
48/36/60 bit words and handling different-length data types. While I
might _possibly_ be able to squeeze that into the recently increased
opcode space available for 64-bit instructions, I doubt it, and that
feature _is_ a luxury, even by my (wretchedly low) standards.
Another thing about microcode as a strategy is that I'm less
interested in trying to run an old operating system natively and
simulate the whole retro environment as I am in allowing someone to
take a single old application, or a single old FORTRAN program, and
run it from the comfort of your own KDE/Gnome desktop.
That's what puts this stuff squarely at the ISA level.
Do you mean take an old executable and run it? If so, how do plan to
handle the old executable's OS calls, which are likely not "Unix compatible"?
If you mean run the old program after recompiling, then
you have the issue of requiring different compiler code generation (and possibly source code recognition) for each "old, obsolete", system you
want to support.
That's what puts this stuff squarely at the ISA level.
I think your "strategy" needs more thought.
Another thing about microcode as a strategy is that I'm less
interested in trying to run an old operating system natively and
simulate the whole retro environment as I am in allowing someone to
take a single old application, or a single old FORTRAN program, and
run it from the comfort of your own KDE/Gnome desktop.
Do you mean take an old executable and run it? If so, how do plan to
handle the old executable's OS calls, which are likely not "Unix >compatible"?
On Fri, 30 Oct 2026 05:00 +0000 (GMT Standard Time), jgd@cix.co.uk
(John Dallman) wrote:
No, but quadibloc wants to be able to run old software natively, or
nearly so.
That might be achieved by creating an exceptionally versatile microcode >engine, capable of loading instruction sets on a per-process basis.
I thought that microcode was an obsolete implementation technique
which was excessively slow.
But then, on the other hand, it seems that
it is sort of used on modern computers, just in a modified form that harmonizes with their largely hardwired design, so that microcode can
be used to patch design errors after the fact and to implement a few
of the fancier instructions.
Definitely, though, this sounds like a good suggestion, simply because
it avoids designing an ISA that is burdened with more instructions
than other ISAs.
From my perspective, though, it has problems. Microcode, unlike an
ISA, tends to be model-dependent. Even if it's documented and
available to the user, it's not as accessible to the ordinary
programmer as an ISA.
Since Concertina III is squeezing everything into the opcode space available... for a single instruction set, with no mode bits, without--- Synchronet 3.22a-Linux NewsLink 1.2
block structure, and with (in the case, at least, of 64-bit
instructions) the additional overhead of length-indicating bits in
each 32 bits (so that instruction decode can blindly look at every 32
bits in the instruction stream without waiting for the previous part
of the instruction stream to have its length recognized)... it's going
to drop at least some of this excess.
It'll keep native S/360 float, because that will be just one of a
large number of data types supported.
But it will probably drop trying to treat memory as composed of
48/36/60 bit words and handling different-length data types. While I
might _possibly_ be able to squeeze that into the recently increased
opcode space available for 64-bit instructions, I doubt it, and that
feature _is_ a luxury, even by my (wretchedly low) standards.
John Savard
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> schrieb:
Do you mean take an old executable and run it? If so, how do plan to
handle the old executable's OS calls, which are likely not "Unix
compatible"?
Older operating systems were often record-oriented; see the CKD DASD
for the IBM mainframes. UNIX has won with its "everything is a stream
of bytes" abstraction, and fixed buffer size mass storage has also won.
I believe CKD disks are now emulated on fixed buffer size devices.
Just imagine implementing ISAM or any variant of VSAM in your
emulator (and ISAM was done mostly on the device, not the CPU).
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> schrieb:
Do you mean take an old executable and run it? If so, how do plan to
handle the old executable's OS calls, which are likely not "Unix
compatible"?
Older operating systems were often record-oriented; see the CKD DASD
for the IBM mainframes.
UNIX has won with its "everything is a stream
of bytes" abstraction, and fixed buffer size mass storage has also won.
I believe CKD disks are now emulated on fixed buffer size devices.
Just imagine implementing ISAM or any variant of VSAM in your
emulator (and ISAM was done mostly on the device, not the CPU).
--If you mean run the old program after recompiling, then
you have the issue of requiring different compiler code generation (and
possibly source code recognition) for each "old, obsolete", system you
want to support.
That's what puts this stuff squarely at the ISA level.
Plus files handling...
I think your "strategy" needs more thought.
Yep :-)
According to Thomas Koenig <tkoenig@netcologne.de>:
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> schrieb:
Do you mean take an old executable and run it? If so, how do plan to
handle the old executable's OS calls, which are likely not "Unix
compatible"?
Older operating systems were often record-oriented; see the CKD DASD
for the IBM mainframes. UNIX has won with its "everything is a stream
of bytes" abstraction, and fixed buffer size mass storage has also won.
I believe CKD disks are now emulated on fixed buffer size devices.
Just imagine implementing ISAM or any variant of VSAM in your
emulator (and ISAM was done mostly on the device, not the CPU).
IBM emulates CKD disks using modern disks.
It's painful but not that
hard. See for example:
https://www.ibm.com/docs/en/zos/3.2.0?topic=devices-initializing-emulated-ckd-device-3370-fba-device
Also, ISAM was mostly in the controller, not the disk drives. The disks were formatted with CKD records which the controller searched.
According to Stephen Fuld <sfuld@alumni.cmu.edu.invalid>:
Another thing about microcode as a strategy is that I'm less
interested in trying to run an old operating system natively and
simulate the whole retro environment as I am in allowing someone to
take a single old application, or a single old FORTRAN program, and
run it from the comfort of your own KDE/Gnome desktop.
Do you mean take an old executable and run it? If so, how do plan to
handle the old executable's OS calls, which are likely not "Unix
compatible"?
This is hardly a new problem. My FreeBSD system can run linux binaries, providing enough of a linux virtual environment to make them work:
https://man.freebsd.org/cgi/man.cgi?query=linux&sektion=4
Or look at Docker which lets you run all sorts of linux binaries on
Mac or Windows, again wrapping a linux environment around the binaries.
On 10/30/2026 11:39 AM, John Levine wrote:
According to Stephen Fuld-a <sfuld@alumni.cmu.edu.invalid>:
Another thing about microcode as a strategy is that I'm less
interested in trying to run an old operating system natively and
simulate the whole retro environment as I am in allowing someone to
take a single old application, or a single old FORTRAN program, and
run it from the comfort of your own KDE/Gnome desktop.
Do you mean take an old executable and run it?-a If so, how do plan to
handle the old executable's OS calls, which are likely not "Unix
compatible"?
This is hardly a new problem.-a My FreeBSD system can run linux binaries,
providing enough of a linux virtual environment to make them work:
https://man.freebsd.org/cgi/man.cgi?query=linux&sektion=4
Or look at Docker which lets you run all sorts of linux binaries on
Mac or Windows, again wrapping a linux environment around the binaries.
OK, but these are all variants of Unix, not some totally different OS.
Older operating systems were often record-oriented; see the CKD DASD
for the IBM mainframes. UNIX has won with its "everything is a stream
of bytes" abstraction, and fixed buffer size mass storage has also won.
I believe CKD disks are now emulated on fixed buffer size devices.
Just imagine implementing ISAM or any variant of VSAM in your
emulator (and ISAM was done mostly on the device, not the CPU).
Or look at Docker which lets you run all sorts of linux binaries on
Mac or Windows, again wrapping a linux environment around the binaries.
On Fri, 30 Oct 2026 18:23:46 -0000 (UTC), Thomas Koenig
<tkoenig@netcologne.de> wrote:
Older operating systems were often record-oriented; see the CKD DASD
for the IBM mainframes. UNIX has won with its "everything is a stream
of bytes" abstraction, and fixed buffer size mass storage has also won.
I believe CKD disks are now emulated on fixed buffer size devices.
Just imagine implementing ISAM or any variant of VSAM in your
emulator (and ISAM was done mostly on the device, not the CPU).
Actually, I fully intend to do that, even in the absence of any
emulation whatever. I believe that MTS had the right idea in following
the lead of IBM operating systems. ISAM was how the MTS LINE file was organized, with the line number as the primary key (a 16-bit integer
treated as a fixed point number in units of 1/1000 or 0.001). This
avoids the buffer overflow issue that so plagued UNIX and DOS.
Or look at Docker which lets you run all sorts of linux binaries on
Mac or Windows, again wrapping a linux environment around the binaries.
On 10/30/2026 12:38 PM, Stephen Fuld wrote:
On 10/30/2026 11:39 AM, John Levine wrote:
Or look at Docker which lets you run all sorts of linux binaries on
Mac or Windows, again wrapping a linux environment around the binaries.
OK, but these are all variants of Unix, not some totally different OS.
Sorry for the self follow-up. I lost that you indicated MACOS and
Windows, which are not Unix variants.
But they are certainly closer to
Unix than say OS/360, thus are easier to accommodate to.
Actually, I fully intend to do that, even in the absence of any
emulation whatever. I believe that MTS had the right idea in following
the lead of IBM operating systems. ISAM was how the MTS LINE file was >organized, with the line number as the primary key (a 16-bit integer
treated as a fixed point number in units of 1/1000 or 0.001). This
avoids the buffer overflow issue that so plagued UNIX and DOS.
John Levine <johnl@taugh.com> writes:
Or look at Docker which lets you run all sorts of linux binaries on
Mac or Windows, again wrapping a linux environment around the binaries.
That's actually somewhat paradoxic, because the container stuff (of
which Docker is one example) was designed to be more light-weight than
VMs by using the same Linux kernel and its system calls, and just
having less sharing of resources than Linux usually does. But it has
become so successful that MacOS and Windows run Linux in a VM in order
to run Docker inside that.
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> writes:
On 10/30/2026 12:38 PM, Stephen Fuld wrote:
On 10/30/2026 11:39 AM, John Levine wrote:
Or look at Docker which lets you run all sorts of linux binaries onOK, but these are all variants of Unix, not some totally different OS.
Mac or Windows, again wrapping a linux environment around the binaries. >>>
Sorry for the self follow-up. I lost that you indicated MACOS and
Windows, which are not Unix variants.
MacOS arguably is. Windows isn't, but provides a VM that runs Linux
(WSL2).
But Linux these days provides a lot of additional functionality beyond
Unix, and especially Docker makes use of that.
So Windows has given up on the WSL1 approach (or the Wine approach in
the other direction) of implementing Linux system calls in the Windows kernel, and instead provides a VM that runs a Linux kernel (WSL2).
And I expect that MacOS does it that way, too, despite being closer to
the Linux system call interface than Windows is.
But they are certainly closer to
Unix than say OS/360, thus are easier to accommodate to.
OS/360 runs on VM these days, if at all. Is it even possible to run
bare OS/360 on any s390x machine? Linux runs on the same VM that
OS/360 runs on. I don't think it's a good use of s390x hardware to
run Docker images containing AMD64 or ARM A64 binaries, however.
Maybe that's why they put ARM A64 hardware into s390x hardware: to be
able to run Docker images with ARM A64 binaries (and at least for
gitlab such images already exist).
Are you thinking of variable or fixed width lines (FB80)? And
2**16 lines is not a lot, although, at the time, it may have
seemed like it.
On Sat, 31 Oct 2026 08:42:53 -0000 (UTC), Thomas Koenig
<tkoenig@netcologne.de> wrote:
Are you thinking of variable or fixed width lines (FB80)? And
2**16 lines is not a lot, although, at the time, it may have
seemed like it.
Variable-width lines, either 0-255 characters or 0-65535 characters.
And 32-bit line numbers may be used instead.
But they are certainly closer to
Unix than say OS/360, thus are easier to accommodate to.
OS/360 runs on VM these days, if at all. Is it even possible to run
bare OS/360 on any s390x machine? Linux runs on the same VM that
OS/360 runs on.
I don't think it's a good use of s390x hardware to
run Docker images containing AMD64 or ARM A64 binaries, however.
Maybe that's why they put ARM A64 hardware into s390x hardware: to be
able to run Docker images with ARM A64 binaries (and at least for
gitlab such images already exist).
All of that may be true, but John's stated goal is to be able to run
"dusty deck" programs originally written to run under OS/360 and other >obsolete systems such as (I gather, though I never used it) PDP
10/Tenex. I am just pointing out those systems are far more different
than current OSs than ones like MACOS and Windows.
John Savard <quadibloc@invalid.com> schrieb:
Variable-width lines, either 0-255 characters or 0-65535 characters.
And 32-bit line numbers may be used instead.
So how does this fix the buffer overrun problem (snipped above)?
On Sat, 31 Oct 2026 08:42:53 -0000 (UTC), Thomas Koenig <tkoenig@netcologne.de> wrote:
Are you thinking of variable or fixed width lines (FB80)? And
2**16 lines is not a lot, although, at the time, it may have
seemed like it.
Variable-width lines, either 0-255 characters or 0-65535 characters.
And 32-bit line numbers may be used instead.
John Savard--- Synchronet 3.22a-Linux NewsLink 1.2
quadibloc@invalid.com (John Savard) posted:
On Sat, 31 Oct 2026 08:42:53 -0000 (UTC), Thomas Koenig
<tkoenig@netcologne.de> wrote:
Are you thinking of variable or fixed width lines (FB80)? And
2**16 lines is not a lot, although, at the time, it may have
seemed like it.
Variable-width lines, either 0-255 characters or 0-65535 characters.
And 32-bit line numbers may be used instead.
What is wrong with <cr><lf> terminated lines ??
If lines in files are Pascal strings (length code plus characters)
instead of C strings (characters plus delimiter) then there is a
known maximum record length that it is impossible to exceed. So it is possible to have a record buffer of the right size.
MitchAlsup <user5857@newsgrouper.org.invalid> schrieb:
quadibloc@invalid.com (John Savard) posted:
On Sat, 31 Oct 2026 08:42:53 -0000 (UTC), Thomas Koenig
<tkoenig@netcologne.de> wrote:
Are you thinking of variable or fixed width lines (FB80)? And
2**16 lines is not a lot, although, at the time, it may have
seemed like it.
Variable-width lines, either 0-255 characters or 0-65535 characters.
And 32-bit line numbers may be used instead.
What is wrong with <cr><lf> terminated lines ??
People might use gets() :-) (See the BUGS section in the Linux
manpage).
Variable-width lines, either 0-255 characters or 0-65535 characters.
And 32-bit line numbers may be used instead.
What is wrong with <cr><lf> terminated lines ??
People might use gets() :-) (See the BUGS section in the Linux
manpage).
Gets the whole file into 1 buffer.....whiich is why my C code just used >getc() and I parsed strings/lines/keywords by myself.
According to Stephen Fuld <sfuld@alumni.cmu.edu.invalid>:
But they are certainly closer to
Unix than say OS/360, thus are easier to accommodate to.
OS/360 runs on VM these days, if at all. Is it even possible to run
bare OS/360 on any s390x machine? Linux runs on the same VM that
OS/360 runs on.
I don't think you can run old versions of OS/360 on modern hardware but
IBM has an impressive commitment to hardware and softare backward compatibility.
Modern z series machines still have a 24 bit address mode and z/OS has kept he old interfaces so you should be able to run OS programs on zOS and it'll work.
I don't think it's a good use of s390x hardware to
run Docker images containing AMD64 or ARM A64 binaries, however.
Maybe that's why they put ARM A64 hardware into s390x hardware: to be
able to run Docker images with ARM A64 binaries (and at least for
gitlab such images already exist).
There was a "bladecenter" thing that let them put AMD64 processor blades
into a zSeries system but it seems to have been a failed experiment. I can't find any references to it less than a decade old. I'd think that networking is now good enough that you could put a rack of AMD and ARM processors next to the rack with your z machine all runing linux and network them together if that's what you want.
All of that may be true, but John's stated goal is to be able to run
"dusty deck" programs originally written to run under OS/360 and other
obsolete systems such as (I gather, though I never used it) PDP
10/Tenex. I am just pointing out those systems are far more different
than current OSs than ones like MACOS and Windows.
The PDP-10 was a 36 bit word addressed machine so the data formats don't
map onto modern byte addressed machines in a reasonable way. OS360 is a special case as described above, since it's still alive.
It's not exactly beyond the state of the art to process C strings securely. >You use routines that know the length of intermediate buffers and expand
them if needed. I use a package called bglibs but there are plenty of >others.
There was a "bladecenter" thing that let them put AMD64 processor blades
into a zSeries system but it seems to have been a failed experiment. I can't >find any references to it less than a decade old. I'd think that networking >is now good enough that you could put a rack of AMD and ARM processors next >to the rack with your z machine all runing linux and network them together if >that's what you want.
Yes, I was puzzled about why one would have ARM A64 cores in a
z-something machine.
My current explanation is that it is relevant for the marketing of
these systems. IBM (and in particular their z-something department)
does not want them to be considered as legacy systems, but as
highly-valued systems ...
Every linux program runs on ARM because that's the most cost effective
way to run them at AWS, Azure, etc., but they only run on S390[x] if someone's ported them which I expect is occasionally painful since it's
big-endian.
Gets the whole file into 1 buffer.....whiich is why my C code just used getc() and I parsed strings/lines/keywords by myself.
quadibloc@invalid.com (John Savard) posted:
On Fri, 30 Oct 2026 05:00 +0000 (GMT Standard Time), jgd@cix.co.uk
(John Dallman) wrote:
No, but quadibloc wants to be able to run old software natively, or
nearly so.
That might be achieved by creating an exceptionally versatile microcode
engine, capable of loading instruction sets on a per-process basis.
I thought that microcode was an obsolete implementation technique
which was excessively slow.
Done right, it is neither. MicroCode is "just a way to make a sequencer".
But then, on the other hand, it seems that
it is sort of used on modern computers, just in a modified form that
harmonizes with their largely hardwired design, so that microcode can
be used to patch design errors after the fact and to implement a few
of the fancier instructions.
RISC architecture shrunk the kind of sequencers needed such that they
can be implemented in hardwired logic.
Definitely, though, this sounds like a good suggestion, simply because
it avoids designing an ISA that is burdened with more instructions
than other ISAs.
In particular, one of the things -|Code is good at is subroutines
within sequences--an address mode is simply a subroutine to a
main instruction. Hard Wired sequencers are not good at subroutines.
From my perspective, though, it has problems. Microcode, unlike an
ISA, tends to be model-dependent. Even if it's documented and
available to the user, it's not as accessible to the ordinary
programmer as an ISA.
For good reasons !!!!! not the least of which is that -|Code is not
generally vonNeumann {do one thing to completion before starting the
next}.
On 2026-Oct-30 14:42, MitchAlsup wrote:
quadibloc@invalid.com (John Savard) posted:
On Fri, 30 Oct 2026 05:00 +0000 (GMT Standard Time), jgd@cix.co.uk
(John Dallman) wrote:
No, but quadibloc wants to be able to run old software natively, or
nearly so.
That might be achieved by creating an exceptionally versatile microcode >>> engine, capable of loading instruction sets on a per-process basis.
I thought that microcode was an obsolete implementation technique
which was excessively slow.
Done right, it is neither. MicroCode is "just a way to make a sequencer".
Yes, it is not "microcode" that is the problem with
PDP-11, VAX-780, 360/370, 8086, 68000.
It is that these designs use a _single_ monolithic sequencer
to control almost the whole machine. With just one sequencer
they can only be performing one task at a time.
The above mostly have in their cores just two sequencers,
a simple little one to load a prefetch instruction buffer,
and a big one to serially control everything else.
This is similar to a single threaded program.
The "risc" approach has many smaller state machines operating
concurrently on many instructions at once.
It is that these designs use a _single_ monolithic sequencer
to control almost the whole machine. With just one sequencer
they can only be performing one task at a time.
The "risc" approach has many smaller state machines operating
concurrently on many instructions at once.
Each stage has at least one sequencer, all running concurrently.
This is similar to a multi-threaded program.
Yes, it is not "microcode" that is the problem with
PDP-11, VAX-780, 360/370, 8086, 68000.
It is that these designs use a _single_ monolithic sequencer
to control almost the whole machine. With just one sequencer
they can only be performing one task at a time.
The above mostly have in their cores just two sequencers,
a simple little one to load a prefetch instruction buffer,
and a big one to serially control everything else.
This is similar to a single threaded program.
The "risc" approach has many smaller state machines operating
concurrently on many instructions at once.
My TTL risc-ish vax-ish has two sequencers in the fetch stage,
one for prefetching into I-cache and loading 8-byte octets into
the 32 byte fetch buffer, one for aligning and parsing a variable
length instruction into the instruction buffer in 1 clock.
There is another sequencer in the TLB for table walking.
The initial version of the I-cache is the same as VAX-780
and does not have a separate sequencer for cpu cache misses,
just one for snooping DMA and invalidating entries.
However an updated design could add an I-cache sequencer
to handle automatic cache prefetch.
That has the potential for my Fetch stage alone to be
performing up to 5 concurrent actions per clock.
Horizontal microcode is VLIW
EricP <ThatWouldBeTelling@thevillage.com> writes:
Yes, it is not "microcode" that is the problem with
PDP-11, VAX-780, 360/370, 8086, 68000.
It is that these designs use a _single_ monolithic sequencer
to control almost the whole machine. With just one sequencer
they can only be performing one task at a time.
The above mostly have in their cores just two sequencers,
a simple little one to load a prefetch instruction buffer,
and a big one to serially control everything else.
This is similar to a single threaded program.
The "risc" approach has many smaller state machines operating
concurrently on many instructions at once.
I don't think that's true for the MIPS R2000 and R3000. This one has
just one sequencer for the main pipeline, without interlocking, as the
name says. If there is a cache miss, the whole pipeline stops. If
there is a TLB miss, there is an exception. I think that these
processors have another sequencer for the multiply/divide unit.
The first SPARCs allow having a dependent instruction after a load
while having a similar five-stage pipeline AFAIK. AFAIK it already recognizes this during decoding and inserts a pipeline bubble between
the load and the dependent instruction there, and so still needs just
one sequencer, albeit a more complex one. It does not have a
multiplier or divider, so it has even fewer sequencers than the R2000.
The ARM1/2 AFAIK also has just one sequencer, except for the load/store-multiple instruction, which has its own sequencer AFAIK;
the ordinary pipeline just stops while load/store-multiple run, so it
might have been possible to do it all in one sequencer, but probably
the design was easier to think through with separate sequencers.
The 88100 has a pipeline with branches and joins. Maybe Mitch Alsup
can tell us how it is sequenced.
The RS/6000 (Power 1) with its IIRC seven-chip CPU and IIRC
superscalar execution (between 1 ALU, 1 branch unit, 1 LSU, 1 FPU)
seems to have more sequencers, with lots of things going on
independently, but that's five years after the first RISCs.
For the RISCs the instruction set design ensured that their simplest implementations can be done with one sequencer and still have
pipelining with 3-5 stages.
Of course, newer designs, especially OoO ones, use more sequencers.
It seems to me that their smaller feedback loops is what allows high
clock rates; the Pentium 4 tried to avoid the small feedback loops
with its replays, but that proved to be problematic for performance.
The independent sequencers of modern OoO designs also allow high IPC,--- Synchronet 3.22a-Linux NewsLink 1.2
but of course in places like renaming and the reorder buffer there is
a need to process many instructions per cycle in a way that takes all
of them into account, and doing that at high clock rate is another
secret to the high IPC numbers.
My TTL risc-ish vax-ish has two sequencers in the fetch stage,
one for prefetching into I-cache and loading 8-byte octets into
the 32 byte fetch buffer, one for aligning and parsing a variable
length instruction into the instruction buffer in 1 clock.
There is another sequencer in the TLB for table walking.
The initial version of the I-cache is the same as VAX-780
and does not have a separate sequencer for cpu cache misses,
just one for snooping DMA and invalidating entries.
However an updated design could add an I-cache sequencer
to handle automatic cache prefetch.
That has the potential for my Fetch stage alone to be
performing up to 5 concurrent actions per clock.
Yes, handling variable-width instructions on a bandwidth-limited
machine with an indpenendent instruction fetcher is a good idea,
and already early Power designs have that.
IIRC at least the 32-bit version of the IBM 801 (and later the ROMP)
has variable-width instructions. Does it have a separate sequencer
for instruction fetch? Probably yes.
Horizontal microcode is VLIW
Yes, because "is" is reflective. Historically, VLIW has been inspired
by horizontal microcode and the compilers for that microcode.
- anton
EricP <ThatWouldBeTelling@thevillage.com> posted:
On 2026-Oct-30 14:42, MitchAlsup wrote:
quadibloc@invalid.com (John Savard) posted:Yes, it is not "microcode" that is the problem with
On Fri, 30 Oct 2026 05:00 +0000 (GMT Standard Time), jgd@cix.co.uk
(John Dallman) wrote:
No, but quadibloc wants to be able to run old software natively, or
nearly so.
That might be achieved by creating an exceptionally versatile microcode >>>>> engine, capable of loading instruction sets on a per-process basis.
I thought that microcode was an obsolete implementation technique
which was excessively slow.
Done right, it is neither. MicroCode is "just a way to make a sequencer". >>
PDP-11, VAX-780, 360/370, 8086, 68000.
It is that these designs use a _single_ monolithic sequencer
to control almost the whole machine. With just one sequencer
they can only be performing one task at a time.
Technically, 68000 family had 3 sequencers { I-box, D-box, and A-box}
that rarely interacted. So, microcode ROM had 3 partitions {I, D, S}
and had 3 uPCs. Only when the instruction at had needed coordination
between boxes, did microcode spit out signals moderating what happened between boxes. {{Most of these were MOV from 1 box to another}. A CALL instruction would have {I} send RetA to A-box while {A} SP-- and then
{A} stores that {I} value to the stack}.
The above mostly have in their cores just two sequencers,
a simple little one to load a prefetch instruction buffer,
and a big one to serially control everything else.
This is similar to a single threaded program.
The "risc" approach has many smaller state machines operating
concurrently on many instructions at once.
GBOoO have a front end sequencer, many FU sequencers, and a Retire
sequencer.
On Fri, 30 Oct 2026 00:01:23 GMT, quadibloc@invalid.com (John Savard)
wrote:
Unfortunately, while that solution has the virtue of concentrating the
use of opcode space on what is most important, it looks to be
genuinely bizarre.
I had more opcode space available than I realized, which meant that I
did not have to make it quite as weird as I feared. The secondary >double-precision operate instructions that connect the regular
floating-point registers to the extended floating-point registers can
appear on both the left and right sides of the 32-bit word, as the
opcode space for long instructions is available from somewhere else,
so I don't need to limit those instructions to the right half.
In article <11c82ce$htg$1@gal.iecc.com>, johnl@taugh.com (John Levine)
wrote:
Every linux program runs on ARM because that's the most cost effective
way to run them at AWS, Azure, etc., but they only run on S390[x] if
someone's ported them which I expect is occasionally painful since it's
big-endian.
I wanted to port the code I work on to S390x Linux, _because_ it's big-endian. We've supported big-endian platforms in the past, but they're
all dead now. It seems unlikely that big-endian will come back, but
having something I could test big-endian on would be nice. Sadly, the hardware is very expensive, and nobody on the Hercules mailing list knows
how to set up Linux on that.
John
EricP <ThatWouldBeTelling@thevillage.com> writes:
Yes, it is not "microcode" that is the problem with
PDP-11, VAX-780, 360/370, 8086, 68000.
It is that these designs use a _single_ monolithic sequencer
to control almost the whole machine. With just one sequencer
they can only be performing one task at a time.
The above mostly have in their cores just two sequencers,
a simple little one to load a prefetch instruction buffer,
and a big one to serially control everything else.
This is similar to a single threaded program.
The "risc" approach has many smaller state machines operating
concurrently on many instructions at once.
I don't think that's true for the MIPS R2000 and R3000. This one has
just one sequencer for the main pipeline, without interlocking, as the
name says. If there is a cache miss, the whole pipeline stops. If
there is a TLB miss, there is an exception. I think that these
processors have another sequencer for the multiply/divide unit.
The first SPARCs allow having a dependent instruction after a load
while having a similar five-stage pipeline AFAIK. AFAIK it already recognizes this during decoding and inserts a pipeline bubble between
the load and the dependent instruction there, and so still needs just
one sequencer, albeit a more complex one. It does not have a
multiplier or divider, so it has even fewer sequencers than the R2000.
The ARM1/2 AFAIK also has just one sequencer, except for the load/store-multiple instruction, which has its own sequencer AFAIK;
the ordinary pipeline just stops while load/store-multiple run, so it
might have been possible to do it all in one sequencer, but probably
the design was easier to think through with separate sequencers.
The 88100 has a pipeline with branches and joins. Maybe Mitch Alsup
can tell us how it is sequenced.
The RS/6000 (Power 1) with its IIRC seven-chip CPU and IIRC
superscalar execution (between 1 ALU, 1 branch unit, 1 LSU, 1 FPU)
seems to have more sequencers, with lots of things going on
independently, but that's five years after the first RISCs.
For the RISCs the instruction set design ensured that their simplest implementations can be done with one sequencer and still have
pipelining with 3-5 stages.
Of course, newer designs, especially OoO ones, use more sequencers.
It seems to me that their smaller feedback loops is what allows high
clock rates; the Pentium 4 tried to avoid the small feedback loops
with its replays, but that proved to be problematic for performance.
The independent sequencers of modern OoO designs also allow high IPC,
but of course in places like renaming and the reorder buffer there is
a need to process many instructions per cycle in a way that takes all
of them into account, and doing that at high clock rate is another
secret to the high IPC numbers.
My TTL risc-ish vax-ish has two sequencers in the fetch stage,
one for prefetching into I-cache and loading 8-byte octets into
the 32 byte fetch buffer, one for aligning and parsing a variable
length instruction into the instruction buffer in 1 clock.
There is another sequencer in the TLB for table walking.
The initial version of the I-cache is the same as VAX-780
and does not have a separate sequencer for cpu cache misses,
just one for snooping DMA and invalidating entries.
However an updated design could add an I-cache sequencer
to handle automatic cache prefetch.
That has the potential for my Fetch stage alone to be
performing up to 5 concurrent actions per clock.
Yes, handling variable-width instructions on a bandwidth-limited
machine with an indpenendent instruction fetcher is a good idea,
and already early Power designs have that.
IIRC at least the 32-bit version of the IBM 801 (and later the ROMP)
has variable-width instructions. Does it have a separate sequencer
for instruction fetch? Probably yes.
Horizontal microcode is VLIW
Yes, because "is" is reflective. Historically, VLIW has been inspired
by horizontal microcode and the compilers for that microcode.
- anton
On 11/1/26 5:21 PM, John Dallman wrote:
In article <11c82ce$htg$1@gal.iecc.com>, johnl@taugh.com (John Levine)
wrote:
Every linux program runs on ARM because that's the most cost effective
way to run them at AWS, Azure, etc., but they only run on S390[x] if
someone's ported them which I expect is occasionally painful since it's
big-endian. ...
Fedora linux used to be supported on s390x and had directions for
installing on Hercules. But it appears to be stale.
According to Brian G. Lucas <bagel99@gmail.com>:
On 11/1/26 5:21 PM, John Dallman wrote:
In article <11c82ce$htg$1@gal.iecc.com>, johnl@taugh.com (John Levine)
wrote:
Every linux program runs on ARM because that's the most cost effective >>>> way to run them at AWS, Azure, etc., but they only run on S390[x] if
someone's ported them which I expect is occasionally painful since it's >>>> big-endian. ...
Fedora linux used to be supported on s390x and had directions for >>installing on Hercules. But it appears to be stale.
Says here that Red Hat, Suse, and Ubuntu run on z series:
https://www.ibm.com/docs/en/linux-on-systems?topic=archive-distributions
On Fri, 30 Oct 2026 03:49:16 GMT, quadibloc@invalid.com (John Savard)
wrote:
On Fri, 30 Oct 2026 00:01:23 GMT, quadibloc@invalid.com (John Savard) >>wrote:
Unfortunately, while that solution has the virtue of concentrating the >>>use of opcode space on what is most important, it looks to be
genuinely bizarre.
I had more opcode space available than I realized, which meant that I
did not have to make it quite as weird as I feared. The secondary >>double-precision operate instructions that connect the regular >>floating-point registers to the extended floating-point registers can >>appear on both the left and right sides of the 32-bit word, as the
opcode space for long instructions is available from somewhere else,
so I don't need to limit those instructions to the right half.
I had to go back to a little weirdness, because I needed *one more
bit* of opcode space for 64-bit instructions in order that immediate >instructions with 48-bit immediate values (needed for the Medium >floating-point type) could be 64-bit instructions instead of 96-bit >instructions.
On 2026-Nov-03 01:07, Anton Ertl wrote:---------------------
Performing a global stall of the whole pipeline for a data cache miss
is an inexpensive way to handle stalls but not the only way.
With improved handshaking between the stages the pipeline can do a local stall only when it has to and compress out any bubbles in the earlier stages.
But a prompt looks pretty much the same on any Linux distribution.
| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 76 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 54:49:16 |
| Calls: | 1,265 |
| Calls today: | 1 |
| Files: | 1,362 |
| D/L today: |
3 files (2,684K bytes) |
| Messages: | 285,582 |