• Another Kick at Concertina III

    From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Tue Oct 27 19:07:27 2026
    From Newsgroup: comp.arch

    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!

    And it doesn't matter if the coding of exotic rarely-used instructions
    is inefficient.

    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...

    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.

    And then five bits each for the source or destination registers.

    For integers, I need to be able to handle both 32-bit integers for
    normal integer work and 64-bit integers for address calculations. And
    I should be able to handle bytes as well. So as a minimum I will need
    a six-bit opcode field.

    Fine. I just don't use all the source or destination registers for
    these operations. I have short instructions for integer calculations,
    but those can be compromised, as they're less important, they're
    mainly for bookkeeping stuff like array calculations and keeping track
    of loops.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From MitchAlsup@user5857@newsgrouper.org.invalid to comp.arch on Tue Oct 27 21:17:28 2026
    From Newsgroup: comp.arch

    quadibloc@invalid.com (John Savard) posted:

    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!

    Perhaps you should sit back and contemplate that for a while....

    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.

    And yet, I consume a bit under 1/4 Major OpCode space for LD/ST insts.
    12/64 (or 3/16ths).

    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.

    You certainly keep us guessing what bazar thing comes next...

    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.


    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Wed Oct 28 02:29:52 2026
    From Newsgroup: comp.arch

    On Tue, 27 Oct 2026 21:17:28 GMT, MitchAlsup
    <user5857@newsgrouper.org.invalid> wrote:
    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
    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?

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Wed Oct 28 11:07:06 2026
    From Newsgroup: comp.arch

    On Wed, 28 Oct 2026 02:29:52 GMT, quadibloc@invalid.com (John Savard)
    wrote:
    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?

    It took a bit more reflection, but now I realize that there was,
    behind Concertina II and its successors - at one point, going all the
    way to Concertina V - indeed a single unifying concept.

    And once I articulate that concept, the fact that it is obviously
    flawed, deeply and fundamentally so, becomes obvious.

    Every iteration of Concertina II is fundamentally an attempt to take
    an instruction set which, in terms of the operations its instructions
    perform, is CISC - base-index addressing, even memory-to-register
    operate instructions and memory-to-memory packed decimal and string instructions among the longer instructions, and some sort of 16-bit or
    quasi 16-bit register-to-register operate instructions - and fit it
    into an outer form which is patterned after that of RISC -
    instructions that act as if they are always 32 bits in length, somehow
    making it not necessary to parse lengths in sequence, so as to behave
    as if they're all 32 bits in length even when they're not, banks of 32 registers each instead of 8 or 16.

    Taking CISC and putting it into a RISC-sized Procrustean bed... is, on
    its face, fundamentally flawed.

    And taking old CISC wine and putting it into new RISC wineskins can
    even be argued to violate the Law of God!

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Wed Oct 28 12:29:17 2026
    From Newsgroup: comp.arch

    On Tue, 27 Oct 2026 19:07:27 GMT, quadibloc@invalid.com (John Savard)
    wrote:

    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.

    Concertina III in its current iteration has now been uploaded at

    http://www.quadibloc.com/arch/ct28int.htm

    However, there has been a change to the original plan for paired
    15-bit instructions. I decided to indulge myself, and also support the
    48-bit Medium floating-point type; this limits the integer short
    instructions to the first eight registers, rather than the first
    sixteen, but has the benefit that there is now room for short
    instructions of other types again.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From MitchAlsup@user5857@newsgrouper.org.invalid to comp.arch on Wed Oct 28 15:38:38 2026
    From Newsgroup: comp.arch

    quadibloc@invalid.com (John Savard) posted:

    On Tue, 27 Oct 2026 21:17:28 GMT, MitchAlsup <user5857@newsgrouper.org.invalid> wrote:
    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;
    {this
    - 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;
    } is creating the unsolvable dilemma.
    - or any of many other possibilities? Or a whole pile of them?

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Thomas Koenig@tkoenig@netcologne.de to comp.arch on Thu Oct 29 06:33:01 2026
    From Newsgroup: comp.arch

    John Savard <quadibloc@invalid.com> schrieb:

    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.

    Why left-aligned, for heaven's sake?

    When loading unsigned values, put the bits where they belong, and either
    sign extend or truncate. That way, you can then use the values in
    any subsequent arithmetic calculation in whatever width you desire.
    --
    This USENET posting was made without artificial intelligence,
    artificial impertinence, artificial arrogance, artificial stupidity,
    artificial flavorings or artificial colorants.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Thu Oct 29 06:39:36 2026
    From Newsgroup: comp.arch

    On Wed, 28 Oct 2026 15:38:38 GMT, MitchAlsup
    <user5857@newsgrouper.org.invalid> wrote:

    {this
    - 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;
    } is creating the unsolvable dilemma.

    When constructing an ISA, it can either pass or fail. Failing would
    mean some instructions I thought were 32 bits long were actually 33
    bits long, or some instructions had overlapping opcodes. If it doesn't
    fail, nothing was unsolvable.

    Of course, though, most of the past iterations of Concertina II did
    fail at what I was trying to do - they didn't squeeze enough into the
    available opcode space to satisfy me.

    So I did have to choose to leave things out - but it took many
    iterations because such choices are painful for me.

    So even if I disagree with the phrasing, you have indeed correctly
    identified the heart of the issue.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Thu Oct 29 13:58:30 2026
    From Newsgroup: comp.arch

    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.

    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
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Thu Oct 29 14:04:59 2026
    From Newsgroup: comp.arch

    I have noticed a flaw in Concertina III as I am designing it.

    In System/360, 1/4 of the opcode space goes to 16-bit instructions,
    1/4 of the opcode space goes to 48-bit instructions, and 1/2 of the
    opcode space goes to 32-bit instructions.

    In Concertina III, currently... about 3/4 of the opcode space goes to
    32-bit instructions, 1/4 of the opcode space goes to paired 15-bit instructions... and 1/256 of the opcode space goes to 64-bit
    instructions.

    Even though that's an adequate amount of opcode space to long
    instructions, it seems... unbalanced.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From John Levine@johnl@taugh.com to comp.arch on Thu Oct 29 15:51:05 2026
    From Newsgroup: comp.arch

    According to John Savard <quadibloc@invalid.com>:
    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.
    --
    Regards,
    John Levine, johnl@taugh.com, Primary Perpetrator of "The Internet for Dummies",
    Please consider the environment before reading this e-mail. https://jl.ly
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Thu Oct 29 15:56:09 2026
    From Newsgroup: comp.arch

    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
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Thu Oct 29 16:11:00 2026
    From Newsgroup: comp.arch

    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
    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
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Stephen Fuld@sfuld@alumni.cmu.edu.invalid to comp.arch on Thu Oct 29 09:53:26 2026
    From Newsgroup: comp.arch

    On 10/29/2026 8:56 AM, John Savard wrote:
    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

    I guess, in the sense of things like correctly causing overflow
    handling. But this required either a new load instruction to load into
    the upper 32 bits of a register, or an extra instruction, a shift, to
    get the data into the high order half of the register.

    Note that Mitch's My 66000 has a different, more general, solution to
    this issue.
    --
    - Stephen Fuld
    (e-mail address disguised to prevent spam)
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From MitchAlsup@user5857@newsgrouper.org.invalid to comp.arch on Thu Oct 29 17:36:05 2026
    From Newsgroup: comp.arch

    quadibloc@invalid.com (John Savard) posted:

    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.

    While arithmetic of the same size works usefully well like that,
    mixed sized arithmetic does not.

    Instead, My 66000 developed the notion of "proper value". A proper
    value is one that is range limited as the sized container, sitting
    in a 64-bit register. LDs and integer arithmetic create proper values. Consuming a proper value as an operand requires no additional work.

    The plus is that one only needs LOAD and STORE for integers.

    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
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From MitchAlsup@user5857@newsgrouper.org.invalid to comp.arch on Thu Oct 29 17:45:22 2026
    From Newsgroup: comp.arch

    quadibloc@invalid.com (John Savard) posted:

    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.

    In My 66000::

    All int reg, int reg, int reg fit in 1 major OpCode
    All ... reg, int reg, fp. reg fit in 1 major OpCode
    All fp. reg, fp. reg, fp. reg fit in 1 major OpCode

    3/64 ...

    Where did all those other integer instructions come from??

    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.

    When I said All above, I meant {FP8, FP16, FP32, FP64}|uOpCode

    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 ??

    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?

    Danger Will Robinson, Danger.

    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.

    More Danger Will Robinson, Danger.

    How about associating the mode with the memory containing the code by
    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
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Fri Oct 30 00:01:23 2026
    From Newsgroup: comp.arch

    On Thu, 29 Oct 2026 17:45:22 GMT, MitchAlsup
    <user5857@newsgrouper.org.invalid> wrote:

    More Danger Will Robinson, Danger.

    I agreed, so that's why I moved on to a solution that eliminated a
    need for mode bits by limiting the use of all 32 registers in short instructions to 64-bit floats, as was mentioned later in the same
    post.

    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.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Fri Oct 30 03:49:16 2026
    From Newsgroup: comp.arch

    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.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From jgd@jgd@cix.co.uk (John Dallman) to comp.arch on Fri Oct 30 05:00:00 2026
    From Newsgroup: comp.arch

    In article <1793295922-5857@newsgrouper.org>,
    user5857@newsgrouper.org.invalid (MitchAlsup) wrote:

    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.

    John
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Fri Oct 30 10:15:41 2026
    From Newsgroup: comp.arch

    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.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Fri Oct 30 16:32:00 2026
    From Newsgroup: comp.arch

    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.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Stephen Fuld@sfuld@alumni.cmu.edu.invalid to comp.arch on Fri Oct 30 10:29:40 2026
    From Newsgroup: comp.arch

    On 10/30/2026 9:32 AM, John Savard wrote:
    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.

    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.
    --
    - Stephen Fuld
    (e-mail address disguised to prevent spam)
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Thomas Koenig@tkoenig@netcologne.de to comp.arch on Fri Oct 30 18:23:46 2026
    From Newsgroup: comp.arch

    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 :-)
    --
    This USENET posting was made without artificial intelligence,
    artificial impertinence, artificial arrogance, artificial stupidity,
    artificial flavorings or artificial colorants.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From John Levine@johnl@taugh.com to comp.arch on Fri Oct 30 18:39:01 2026
    From Newsgroup: comp.arch

    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.
    --
    Regards,
    John Levine, johnl@taugh.com, Primary Perpetrator of "The Internet for Dummies",
    Please consider the environment before reading this e-mail. https://jl.ly
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From MitchAlsup@user5857@newsgrouper.org.invalid to comp.arch on Fri Oct 30 18:42:38 2026
    From Newsgroup: comp.arch

    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}.

    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.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From John Levine@johnl@taugh.com to comp.arch on Fri Oct 30 18:43:58 2026
    From Newsgroup: comp.arch

    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.
    --
    Regards,
    John Levine, johnl@taugh.com, Primary Perpetrator of "The Internet for Dummies",
    Please consider the environment before reading this e-mail. https://jl.ly
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Stephen Fuld@sfuld@alumni.cmu.edu.invalid to comp.arch on Fri Oct 30 12:16:30 2026
    From Newsgroup: comp.arch

    On 10/30/2026 11:23 AM, Thomas Koenig wrote:
    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.

    True. But even the non IBM mainframes, which operated on fixed block
    (i.e non-CKD disks (of various disk sizes - often not multiples of 512
    bytes - Univac used 504 bytes, Burroughs large scale system used 180
    bytes, Burroughs medium scale systems used 180 and 100 bytes, etc.) were
    block or record oriented. This matched well with the major languages of
    the day, such as COBOL and (the then standard) FORTRAN.


    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.

    That is true. Been there, done that, have the scars! :-( Although the emulation is (or at least was) done in the disk controller so the host software still thinks it is dealing with CKD disks.


    Just imagine implementing ISAM or any variant of VSAM in your
    emulator (and ISAM was done mostly on the device, not the CPU).

    True.


    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 :-)
    --
    - Stephen Fuld
    (e-mail address disguised to prevent spam)
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Stephen Fuld@sfuld@alumni.cmu.edu.invalid to comp.arch on Fri Oct 30 12:36:01 2026
    From Newsgroup: comp.arch

    On 10/30/2026 11:43 AM, John Levine wrote:
    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.

    Yes. I think the last real "native" CKD disk was the 3390. Its
    successors, the "RAMAC" series used smaller diameter disks with CKD
    emulation in the controller.


    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

    I didn't know about that. The 3370 was an FBA device originally
    developed for VM and DOS. AFAIK, it was never supported on MVS, though
    the software you pointed to above seems to do the CKD emulation in the mainframe, not the disk controller.

    Thanks, John for that information.



    Also, ISAM was mostly in the controller, not the disk drives. The disks were formatted with CKD records which the controller searched.

    True. the "K" in CKD stands for "key", which were on the disk and there
    were commands for the controller to search. And, BTW, similarly for the
    TOCs for Partitioned Data Sets.
    --
    - Stephen Fuld
    (e-mail address disguised to prevent spam)
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Stephen Fuld@sfuld@alumni.cmu.edu.invalid to comp.arch on Fri Oct 30 12:38:10 2026
    From Newsgroup: comp.arch

    On 10/30/2026 11:39 AM, John Levine wrote:
    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.

    OK, but these are all variants of Unix, not some totally different OS.
    --
    - Stephen Fuld
    (e-mail address disguised to prevent spam)
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Stephen Fuld@sfuld@alumni.cmu.edu.invalid to comp.arch on Fri Oct 30 12:52:39 2026
    From Newsgroup: comp.arch

    On 10/30/2026 12:38 PM, Stephen Fuld wrote:
    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.


    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.
    --
    - Stephen Fuld
    (e-mail address disguised to prevent spam)
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Fri Oct 30 21:53:16 2026
    From Newsgroup: comp.arch

    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.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Stefan Monnier@monnier@iro.umontreal.ca to comp.arch on Fri Oct 30 16:52:11 2026
    From Newsgroup: comp.arch

    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.

    AFAIK in macOS, Docker works via a Linux kernel running inside a VM.
    I assume in Windows, Docker similarly works via the WSL system which
    basically runs a Linux kernel inside a VM.


    === Stefan
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Thomas Koenig@tkoenig@netcologne.de to comp.arch on Sat Oct 31 08:42:53 2026
    From Newsgroup: comp.arch

    John Savard <quadibloc@invalid.com> schrieb:
    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.

    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.
    --
    This USENET posting was made without artificial intelligence,
    artificial impertinence, artificial arrogance, artificial stupidity,
    artificial flavorings or artificial colorants.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.arch on Sat Oct 31 09:09:50 2026
    From Newsgroup: comp.arch

    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.

    - anton
    --
    'Anyone trying for "industrial quality" ISA should avoid undefined behavior.'
    Mitch Alsup, <c17fcd89-f024-40e7-a594-88a85ac10d20o@googlegroups.com>
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.arch on Sat Oct 31 09:18:36 2026
    From Newsgroup: comp.arch

    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 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.

    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).

    - anton
    --
    'Anyone trying for "industrial quality" ISA should avoid undefined behavior.'
    Mitch Alsup, <c17fcd89-f024-40e7-a594-88a85ac10d20o@googlegroups.com>
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From John Levine@johnl@taugh.com to comp.arch on Sat Oct 31 14:41:00 2026
    From Newsgroup: comp.arch

    According to John Savard <quadibloc@invalid.com>:
    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.

    TSS/360 had a bunch of access methods including VISAM, like ISAM but built on top of 4K paqged storage, not CKD harware. Most text files were VISAM files with
    seven byte numeric line numbers as the key. You normally numbered your lines in hundreds or thousands as you created them to leave room for insertions. Sounds like the same idea.

    Like everything else in TSS, it worked fine except when it didn't
    --
    Regards,
    John Levine, johnl@taugh.com, Primary Perpetrator of "The Internet for Dummies",
    Please consider the environment before reading this e-mail. https://jl.ly
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From John Levine@johnl@taugh.com to comp.arch on Sat Oct 31 14:50:26 2026
    From Newsgroup: comp.arch

    According to Anton Ertl <anton@mips.complang.tuwien.ac.at>:
    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.

    This strikes me as one of those ideas that has been reinvented over and over again.

    In addition to the linux compatibility stuff, FreeBSD has jails, which
    are isolated environments that use the native BSD kernel, as well as bhyve which is
    a virtual machine that can run anything.
    --
    Regards,
    John Levine, johnl@taugh.com, Primary Perpetrator of "The Internet for Dummies",
    Please consider the environment before reading this e-mail. https://jl.ly
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Stephen Fuld@sfuld@alumni.cmu.edu.invalid to comp.arch on Sat Oct 31 08:17:47 2026
    From Newsgroup: comp.arch

    On 10/31/2026 2:18 AM, Anton Ertl wrote:
    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 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.

    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).

    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.
    --
    - Stephen Fuld
    (e-mail address disguised to prevent spam)
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Sat Oct 31 15:44:48 2026
    From Newsgroup: comp.arch

    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
  • From Thomas Koenig@tkoenig@netcologne.de to comp.arch on Sat Oct 31 16:05:34 2026
    From Newsgroup: comp.arch

    John Savard <quadibloc@invalid.com> schrieb:
    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.

    So how does this fix the buffer overrun problem (snipped above)?
    --
    This USENET posting was made without artificial intelligence,
    artificial impertinence, artificial arrogance, artificial stupidity,
    artificial flavorings or artificial colorants.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From John Levine@johnl@taugh.com to comp.arch on Sat Oct 31 17:15:48 2026
    From Newsgroup: comp.arch

    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.
    --
    Regards,
    John Levine, johnl@taugh.com, Primary Perpetrator of "The Internet for Dummies",
    Please consider the environment before reading this e-mail. https://jl.ly
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Sat Oct 31 17:37:30 2026
    From Newsgroup: comp.arch

    On Sat, 31 Oct 2026 16:05:34 -0000 (UTC), Thomas Koenig
    <tkoenig@netcologne.de> wrote:
    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)?

    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.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From MitchAlsup@user5857@newsgrouper.org.invalid to comp.arch on Sat Oct 31 18:29:03 2026
    From Newsgroup: comp.arch

    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 ??

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Thomas Koenig@tkoenig@netcologne.de to comp.arch on Sat Oct 31 19:03:22 2026
    From Newsgroup: comp.arch

    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).
    --
    This USENET posting was made without artificial intelligence,
    artificial impertinence, artificial arrogance, artificial stupidity,
    artificial flavorings or artificial colorants.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From jgd@jgd@cix.co.uk (John Dallman) to comp.arch on Sat Oct 31 20:30:00 2026
    From Newsgroup: comp.arch

    In article <6ae626f4.47873281@news.eternal-september.org>, quadibloc@invalid.com (John Savard) wrote:

    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.

    That leaves you with limited line lengths, or very large buffers.
    Assuming you don't want to take up huge amounts of memory with buffers, attacking your system with a specially crafted file seems to become
    easier.

    John
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From MitchAlsup@user5857@newsgrouper.org.invalid to comp.arch on Sat Oct 31 20:33:20 2026
    From Newsgroup: comp.arch

    Thomas Koenig <tkoenig@netcologne.de> posted:

    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).

    Gets the whole file into 1 buffer.....whiich is why my C code just used
    getc() and I parsed strings/lines/keywords by myself.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From John Levine@johnl@taugh.com to comp.arch on Sat Oct 31 20:56:49 2026
    From Newsgroup: comp.arch

    According to MitchAlsup <user5857@newsgrouper.org.invalid>:
    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.

    Uh, no, gets() reads one line. I suppose it might read the whole file if
    the file doesn't contain any \n characters.

    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.
    --
    Regards,
    John Levine, johnl@taugh.com, Primary Perpetrator of "The Internet for Dummies",
    Please consider the environment before reading this e-mail. https://jl.ly
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Stephen Fuld@sfuld@alumni.cmu.edu.invalid to comp.arch on Sat Oct 31 17:10:40 2026
    From Newsgroup: comp.arch

    On 10/31/2026 10:15 AM, John Levine wrote:
    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.

    I agree completely, but now we just have to convince "the other John",
    Savard, that his goal is a fools errand. :-(
    --
    - Stephen Fuld
    (e-mail address disguised to prevent spam)
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Sun Nov 1 00:57:38 2026
    From Newsgroup: comp.arch

    On Sat, 31 Oct 2026 20:56:49 -0000 (UTC), John Levine
    <johnl@taugh.com> wrote:

    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.

    It certainly isn't. But if one can choose to design the operating
    system so that even those who program without thinking carefully about
    security can't cause disasters...

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.arch on Sun Nov 1 18:01:31 2026
    From Newsgroup: comp.arch

    John Levine <johnl@taugh.com> writes:
    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 that deliver USPs that are not there to the same
    extent in AMD64 and ARM servers (or at least the IBM z marketing wants
    you to think so): RAS, extremely big RAM capacities, high I/O
    capabilities, L4 cache, decimal FP and probably others.

    And not just for the legacy stuff like whatever OSs the legacy
    software runs on, but also for modern stuff like Linux and now ARM
    A64 (probably without decimal FP, but who knows).

    This gives the prospective customers the idea that they are investing
    in something that has a future and not just a legacy.

    I guess the bladecenter stuff was there for the same reason, but did
    not sell; we will see how it goes with the ARM stuff.

    - anton
    --
    'Anyone trying for "industrial quality" ISA should avoid undefined behavior.'
    Mitch Alsup, <c17fcd89-f024-40e7-a594-88a85ac10d20o@googlegroups.com>
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From John Levine@johnl@taugh.com to comp.arch on Sun Nov 1 19:02:38 2026
    From Newsgroup: comp.arch

    According to Anton Ertl <anton@mips.complang.tuwien.ac.at>:
    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 ...

    It looks more straightforward than that. For a while now IBM has been selling z into two
    markets. One is the legacy 360 market, the other is the high end linux server market,
    which they call LinuxONE.

    They've put a lot of effort into LinuxONE including supporting all of the toolchains but
    even so they're a niche. 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 if somoene's
    ported them which I expect is occasionally painful since it's big-endian.

    Their announcement makes a point that this isn't just adding ARM cores. Every core
    will run both z and ARM instruction sets, presumably with a mode switch like the one
    among the 24, 31, and 64 bit 360/390/z modes. So now they can credibly say that if
    your linux program runs on a Graviton, and they all do, it'll run here too, no porting, just load it up and run it.
    --
    Regards,
    John Levine, johnl@taugh.com, Primary Perpetrator of "The Internet for Dummies",
    Please consider the environment before reading this e-mail. https://jl.ly
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From jgd@jgd@cix.co.uk (John Dallman) to comp.arch on Sun Nov 1 23:21:00 2026
    From Newsgroup: comp.arch

    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
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Andy Valencia@vandys@vsta.org to comp.arch on Sun Nov 1 16:30:16 2026
    From Newsgroup: comp.arch

    MitchAlsup <user5857@newsgrouper.org.invalid> writes:
    Gets the whole file into 1 buffer.....whiich is why my C code just used getc() and I parsed strings/lines/keywords by myself.

    At which point mmap()'ing the whole file might be your best choice.

    Andy Valencia
    Home page: https://www.vsta.org/andy/
    To contact me: https://www.vsta.org/contact/andy.html
    No AI was used in the composition of this message
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From EricP@ThatWouldBeTelling@thevillage.com to comp.arch on Mon Nov 2 18:39:01 2026
    From Newsgroup: comp.arch

    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.
    Each stage has at least one sequencer, all running concurrently.
    This is similar to a multi-threaded program.

    In the VAX-780 there is an 8 byte prefetch queue which pulls in
    4-byte blocks - cache hits only as it needs microcode to handle cache
    misses and memory bus access. On cache miss the micro sequencer stalls.
    The prefetched bytes are pulled by decode microcode which is a
    recursive descent parser.
    The microcode control goes all the way through the TLB,
    through the cache, down to controlling the main memory bus.
    If anything unusual happens, TLB miss, cache miss, bus error,
    it throws a micro-instruction exception to a micro-handler.
    This does at most one action per clock.

    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.

    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.

    On FPGA's with 6 input LUTs I think one could implement an
    up to 64 state sequencer with just 15 to 20 LUTs that might
    operate up to 400 MHz. That should be enough to do a
    simple page table walker or an integer divider.

    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.

    Also good for sequences with conditional actions.

    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}.

    Horizontal microcode is VLIW, with 100 to 300 bits per uWord
    and separate fields for controlling individual functions.

    Like a player piano it can control 88 keys at once,
    but it only plays one song at a time for one instrument.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From MitchAlsup@user5857@newsgrouper.org.invalid to comp.arch on Tue Nov 3 01:45:45 2026
    From Newsgroup: comp.arch

    EricP <ThatWouldBeTelling@thevillage.com> posted:

    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.

    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.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Tue Nov 3 01:49:00 2026
    From Newsgroup: comp.arch

    On Mon, 2 Nov 2026 18:39:01 -0500, EricP
    <ThatWouldBeTelling@thevillage.com> wrote:

    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.

    Huh? RISC computers and CISC computers are both Von Neumann machines.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.arch on Tue Nov 3 06:07:08 2026
    From Newsgroup: comp.arch

    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
    --
    'Anyone trying for "industrial quality" ISA should avoid undefined behavior.'
    Mitch Alsup, <c17fcd89-f024-40e7-a594-88a85ac10d20o@googlegroups.com>
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From MitchAlsup@user5857@newsgrouper.org.invalid to comp.arch on Tue Nov 3 18:34:53 2026
    From Newsgroup: comp.arch

    anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:

    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.

    Certainly the FPU <chip> had its own sequencer.

    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.

    There was a master pipeline sequencer, then the memory unit had its own sequencer, as did MULtiplier and FADD. The instruction decoder was a
    NOR-plane.

    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.

    And HEAT.

    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
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From EricP@ThatWouldBeTelling@thevillage.com to comp.arch on Tue Nov 3 23:14:33 2026
    From Newsgroup: comp.arch

    On 2026-Nov-02 20:45, MitchAlsup wrote:
    EricP <ThatWouldBeTelling@thevillage.com> posted:

    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.

    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}.

    Not the 68000, it only had one uAddress counter with two levels of
    control code: a vertical microcode of 640 words x 10 bits that
    indexed to the horizontal "nanocode" of 240 words x 70 bits.
    Bits sourced from the instruction fields, microcode, and nanocode
    combine to sequence the core functions and select the next
    uAddress for the microsequencer.

    See patent US4307445 Microprogrammed control apparatus having a
    two-level control store for data processor, 1978

    The only instruction concurrency the 68000 could do was if the current instruction did not require the memory bus for its last state then it could overlap the last execute state with the Decode state of the next instruction. But a 6502 could do that too.

    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.

    In an in-order pipeline each stage is a single major state.
    It may also have internal sub states.
    The difference from the microsequencer is that the state loop is unrolled.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Wed Nov 4 15:59:33 2026
    From Newsgroup: comp.arch

    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.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Brian G. Lucas@bagel99@gmail.com to comp.arch on Wed Nov 4 11:37:18 2026
    From Newsgroup: comp.arch

    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.

    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

    Fedora linux used to be supported on s390x and had directions for
    installing on Hercules. But it appears to be stale. https://fedoraproject.org/wiki/Architectures/s390x

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From EricP@ThatWouldBeTelling@thevillage.com to comp.arch on Wed Nov 4 11:53:38 2026
    From Newsgroup: comp.arch

    On 2026-Nov-03 01:07, Anton Ertl wrote:
    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.

    Each pipeline stage is roughly equivalent to a microcode state.
    If the instructions are simple like risc then the pipeline is simple.
    The microcode sequencing loop has been unrolled into stages and
    arranged so they can operate concurrently.

    Each stage's function unit are sequencers. When it receives a valid
    message in its input buffer, it does some transform on it,
    possibly consumes some resources which could cause a stall if exhausted,
    and hands this new output message to some subsequent stage-unit
    when possible. It can also send control signals to other stages.
    Then it listens for a new valid input message.

    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.

    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.

    I don't have any documents on the uArch of the R2000 or first Sparc.
    However I treat each stage as its own sequencer, even if it initially
    looks simple.

    For example, a risc Decode stage looks like just a simple combinatorial circuit.
    But in my designs Decode also picks off unconditional branches early,
    and purges and redirects Fetch to the new path.
    Decode also handles interrupt synchronization, pipeline drain, and dispatch. And Decode handles single-step.


    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.

    In each of these cases the stage waits for a valid message to arrive
    in its input buffer, does something in response to it,
    and usually outputs a valid message to some other stage.
    Each stage is acting like a hardware thread in a producer-consumer design.
    To me that makes each stage its own sequencer, even if it is simple.


    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

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From John Levine@johnl@taugh.com to comp.arch on Wed Nov 4 16:58:53 2026
    From Newsgroup: comp.arch

    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
    --
    Regards,
    John Levine, johnl@taugh.com, Primary Perpetrator of "The Internet for Dummies",
    Please consider the environment before reading this e-mail. https://jl.ly
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Thomas Koenig@tkoenig@netcologne.de to comp.arch on Wed Nov 4 17:59:51 2026
    From Newsgroup: comp.arch

    John Levine <johnl@taugh.com> schrieb:
    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

    I have login on a couple of these: https://portal.cfarm.net/news/62#

    But a prompt looks pretty much the same on any Linux distribution.
    AIX, on the other hand... there is a reason it is pronounced "aches".
    --
    This USENET posting was made without artificial intelligence,
    artificial impertinence, artificial arrogance, artificial stupidity,
    artificial flavorings or artificial colorants.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Wed Nov 4 21:35:47 2026
    From Newsgroup: comp.arch

    On Wed, 04 Nov 2026 15:59:33 GMT, quadibloc@invalid.com (John Savard)
    wrote:
    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.

    I have now uploaded the page with the instructions larger than 32
    bits,

    http://www.quadibloc.com/arch/caj0102.htm

    to round out the initial presentation of the instruction formats for
    this architecture.
    Incidentally, it may be asked why these instructions are all multiples
    of 32 bits in length, instead of 16 bits, and why I tolerated the
    additional overhead bits so that it was immediately apparent when 32
    bits weren't the first 32 bits of an instruction.
    This may have a performance benefit, but it's very slight. There are
    ways to very efficiently decode the length of an instruction.

    The answer really lies in the short instructions.

    The 32-bit load/store memory-reference instructions needed about 3/4
    of the total 32-bit opcode space.
    I managed to squeeze the other basic 32-bit instructions into that
    3/4, instead of using up 7/8, the way some Concertina II incarnations
    did.
    But short instructions that only had 14 free bits, having two bits of
    overhead each, were inadequate.
    Short instructions with only 15 bits aren't great either. As
    Concertina II showed, ideally, short instructions should have 18 bits,
    or at least 17 bits. But I _did_ manage to squeeze something barely
    passable into 15 bits.
    That meant only allowing the short instructions to occur in pairs.

    Are short instructions that can only occur in pairs any good? I think
    so. If there are stretches where you can use three or more short
    instructions in a row, you're guaranteed to save at least 16 bits. So,
    if short instructions are a major part of a program, forcing them to
    occur in pairs will lose a percentage of the potential savings, but
    not almost all of those savings.

    But if I'm not going to have individual 16-bit short instructions that
    can be freely placed anywhere, and instead so far the instruction set
    is RISC-like in only having 32-bit instructions, then I think that
    since the instructions that have to be longer than 32 bits are a very
    small portion of the instruction set, for relatively infrequent use...
    I might as well restrict them to be multiples of 32 bits in length,
    and require that they not interfere with decoding 32-bit chunks in
    parallel, because even a tiny gain in general performance outweighs
    the compactness of a very minor portion of the instruction set.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From MitchAlsup@user5857@newsgrouper.org.invalid to comp.arch on Wed Nov 4 21:44:13 2026
    From Newsgroup: comp.arch

    EricP <ThatWouldBeTelling@thevillage.com> posted:

    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.

    But the only way when the compiler has made all instruction scheduling decisions.

    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.

    Mc88100 had this philosophy.


    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.arch on Thu Nov 5 08:06:44 2026
    From Newsgroup: comp.arch

    Thomas Koenig <tkoenig@netcologne.de> writes:
    [s390x]
    But a prompt looks pretty much the same on any Linux distribution.

    The disassembly looks different, though:

    : squared dup * ;
    see-code squared

    outputs:

    <squared> dup 1->2
    $3FF834987F2: lgr %r6,%r5
    <squared+$8> * 2->1
    $3FF834987F6: msgr %r5,%r6
    <squared+$10> ;s 1->1
    $3FF834987FA: lg %r11,0(%r7)
    $3FF83498800: la %r7,8(%r7)
    $3FF83498804: lg %r2,0(%r11)
    $3FF8349880A: br %r2

    In some respects, it's quite similar, though. Here's AMD64:

    <squared> dup 1->2
    $7F588AC73A27: mov %r13,%r15
    <squared+$8> * 2->1
    $7F588AC73A2A: imul %r15,%r13
    <squared+$10> ;s 1->1
    $7F588AC73A2E: mov (%r14),%rbx
    $7F588AC73A31: add $0x8,%r14
    $7F588AC73A35: mov (%rbx),%rax
    $7F588AC73A38: jmp *%rax

    - anton
    --
    'Anyone trying for "industrial quality" ISA should avoid undefined behavior.'
    Mitch Alsup, <c17fcd89-f024-40e7-a594-88a85ac10d20o@googlegroups.com>
    --- Synchronet 3.22a-Linux NewsLink 1.2