• Re: Why VAX Was the Ultimate CISC and Not RISC

    From quadibloc@quadibloc@invalid.com (John Savard) to comp.arch on Sat Oct 24 00:05:11 2026
    From Newsgroup: comp.arch

    On Sat, 1 Mar 2025 08:09:35 -0000 (UTC), Lawrence D'Oliveiro
    <ldo@nz.invalid> wrote:

    The VAX project started roughly around the time the first RISC
    concepts were being researched. Could the VAX have been designed as a
    RISC architecture to begin with? Because not doing so meant that, just
    over a decade later, RISC architectures took over the rCLreal computerrCY >market and wiped the floor with DECrCOs flagship architecture, >performance-wise.

    The answer was no, the VAX could not have been done as a RISC
    architecture. RISC wasnrCOt actually price-performance competitive until
    the latter 1980s:

    Shall we then conclude that DEC did everything right, because later on
    after the VAX, DEC came up with the Alpha, which was RISC, and which
    was the highest-performing chip of its day?

    Well, not everything. The Alpha was so expensive as to be a dismal
    failure in the market. However, it was either good enough, or
    well-documented enough, for some Chinese efforts at home-grown
    computer design to have copied it.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From MitchAlsup@user5857@newsgrouper.org.invalid to comp.arch on Sat Oct 24 19:28:02 2026
    From Newsgroup: comp.arch

    quadibloc@invalid.com (John Savard) posted:

    /ERROR "unexpected byte sequence starting at index 348: '\xE2'" while decoding/:

    On Sat, 1 Mar 2025 08:09:35 -0000 (UTC), Lawrence D'Oliveiro
    <ldo@nz.invalid> wrote:

    The VAX project started roughly around the time the first RISC
    concepts were being researched.

    I remember walking by a CS conference room 1973-ish and listening to
    a bunch of people (including Bill Wolfe and Aho) at Carnegie Mellon.
    The discussion was about a follow on to the PDP-11 architectures
    and what additional address modes should go in or not.

    So, my memory is that VAX was being fleshed out at least 7 years
    before RISC got started.

    Could the VAX have been designed as a
    RISC architecture to begin with?

    Not with the players involved. Now, if Thronton or Seymore was at CMU
    then maybe.

    Because not doing so meant that, just
    over a decade later, RISC architectures took over the |o-C-Lreal computer|o-C-Y
    market and wiped the floor with DEC|o-C-Os flagship architecture, >performance-wise.

    The answer was no, the VAX could not have been done as a RISC
    architecture. RISC wasn|o-C-Ot actually price-performance competitive until >the latter 1980s:

    Once compilers made significant growth in optimization, and sufficient
    silicon area became available.

    Shall we then conclude that DEC did everything right, because later on
    after the VAX, DEC came up with the Alpha, which was RISC, and which
    was the highest-performing chip of its day?

    The commercial success of VAX delayed Alpha--no doubt about that. So, I contend, DEC misplayed that card.

    Well, not everything. The Alpha was so expensive as to be a dismal
    failure in the market. However, it was either good enough, or
    well-documented enough, for some Chinese efforts at home-grown
    computer design to have copied it.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Thomas Koenig@tkoenig@netcologne.de to comp.arch on Sat Oct 24 20:42:50 2026
    From Newsgroup: comp.arch

    On 2026-10-24, MitchAlsup <user5857@newsgrouper.org.invalid> wrote:
    quadibloc@invalid.com (John Savard) posted:

    /ERROR "unexpected byte sequence starting at index 348: '\xE2'" while decoding/:

    On Sat, 1 Mar 2025 08:09:35 -0000 (UTC), Lawrence D'Oliveiro
    <ldo@nz.invalid> wrote:

    The VAX project started roughly around the time the first RISC
    concepts were being researched.

    I remember walking by a CS conference room 1973-ish and listening to
    a bunch of people (including Bill Wolfe and Aho) at Carnegie Mellon.
    The discussion was about a follow on to the PDP-11 architectures
    and what additional address modes should go in or not.

    So, my memory is that VAX was being fleshed out at least 7 years
    before RISC got started.

    The 801 certainly counts, but it was certainly not mainstream at
    the time.


    Could the VAX have been designed as a
    RISC architecture to begin with?

    Not with the players involved. Now, if Thronton or Seymore was at CMU
    then maybe.

    Because not doing so meant that, just
    over a decade later, RISC architectures took over the ??????real computer??????
    market and wiped the floor with DEC??????s flagship architecture,
    performance-wise.

    The answer was no, the VAX could not have been done as a RISC
    architecture. RISC wasn??????t actually price-performance competitive until >> >the latter 1980s:

    Once compilers made significant growth in optimization, and sufficient silicon area became available.

    Again, the 801 proved that it could be done. I think they also
    invented graph coloring for register allocation, or if they did
    not invent it, they certainly used 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 Lawrence =?iso-8859-13?q?D=FFOliveiro?=@ldo@nz.invalid to comp.arch on Sat Oct 24 22:20:21 2026
    From Newsgroup: comp.arch

    On Sat, 24 Oct 2026 19:28:02 GMT, MitchAlsup wrote:

    The commercial success of VAX delayed Alpha--no doubt about that.
    So, I contend, DEC misplayed that card.

    But DEC did bring out their first Unix-based RISC product in 1989 --
    the MIPS-based DECstation. But there was still internal feuding
    between the rCLUnix Is Snake OilrCY camp (led by Ken Olsen himself) and
    the rCLCustomers Want An Open OSrCY camp, which prevented the company committing wholesale to the latter viewpoint.

    The holdouts were not completely neutralized until Ken OlsenrCOs time as
    CEO came to an end.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From MitchAlsup@user5857@newsgrouper.org.invalid to comp.arch on Sat Oct 24 23:33:09 2026
    From Newsgroup: comp.arch

    Lawrence =?iso-8859-13?q?D=FFOliveiro?= <ldo@nz.invalid> posted:

    On Sat, 24 Oct 2026 19:28:02 GMT, MitchAlsup wrote:

    The commercial success of VAX delayed Alpha--no doubt about that.
    So, I contend, DEC misplayed that card.

    But DEC did bring out their first Unix-based RISC product in 1989 --
    the MIPS-based DECstation. But there was still internal feuding
    between the rCLUnix Is Snake OilrCY camp (led by Ken Olsen himself) and
    the rCLCustomers Want An Open OSrCY camp, which prevented the company committing wholesale to the latter viewpoint.

    The holdouts were not completely neutralized until Ken OlsenrCOs time as
    CEO came to an end.

    Faced the same war at Motorola where the factory and 68K design team
    (150+ people) waged war on 88K design team (22) with the same conclusion::

    Moto is no longer in the CPU game.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From EricP@ThatWouldBeTelling@thevillage.com to comp.arch on Sun Oct 25 12:56:55 2026
    From Newsgroup: comp.arch

    On 2026-Oct-24 15:28, MitchAlsup wrote:
    quadibloc@invalid.com (John Savard) posted:

    /ERROR "unexpected byte sequence starting at index 348: '\xE2'" while decoding/:

    On Sat, 1 Mar 2025 08:09:35 -0000 (UTC), Lawrence D'Oliveiro
    <ldo@nz.invalid> wrote:

    The VAX project started roughly around the time the first RISC
    concepts were being researched.

    I remember walking by a CS conference room 1973-ish and listening to
    a bunch of people (including Bill Wolfe and Aho) at Carnegie Mellon.
    The discussion was about a follow on to the PDP-11 architectures
    and what additional address modes should go in or not.

    So, my memory is that VAX was being fleshed out at least 7 years
    before RISC got started.

    According to one of Gordon Bell's web pages
    the VAX project was officially started on 1-Apr-1975.
    The VAX 780 product was introduced in Oct 1977.

    Recall my prior post of the article from Electronics about memory prices
    circa 1973 being about 10 cents per byte (in 1973 cents) as that would
    strongly influence any architecture and ISA design decisions.

    Also in 1975 DEC introduced the LSI-11 product built from a 3 chip set
    MCP-1600 from Western Digital in 7u NMOS process at 3.3MHz (300ns microcycle). https://simh.trailing-edge.com/semi/lsi11.html https://en.wikipedia.org/wiki/PDP-11#LSI-11_integrated_circuits https://en.wikipedia.org/wiki/MCP-1600

    So circa 1975 DEC had access to NMOS chip technology similar to 8080
    if they had chosen to use it for a risc-VAX.

    RISC architecture to begin with?

    Not with the players involved. Now, if Thronton or Seymore was at CMU
    then maybe.

    Because not doing so meant that, just
    over a decade later, RISC architectures took over the |o-C-Lreal computer|o-C-Y
    market and wiped the floor with DEC|o-C-Os flagship architecture,
    performance-wise.

    The answer was no, the VAX could not have been done as a RISC
    architecture. RISC wasn|o-C-Ot actually price-performance competitive until >>> the latter 1980s:

    I disagree. As I mentioned above, the 1975 price of memory would be a
    strong consideration. Compared to a variable length ISA of 2.5 to 3 bytes average, a fixed length 4-byte ISA would waste 1 to 1.5 bytes per instruction. I believe one could build a variable length instruction fetch/parse using standard 1975 TTL parts that can sustain 1 clock per instruction at 5 MHz. After that, just keep the instructions simple like risc so they decode easily.

    That gives one the compact instruction size similar to cisc,
    with the uArch design simplicity a risc decode and execute,
    and performance of a pipelined processor.

    You need to also consider R&D cost and time to market.

    - IIRC I read someplace that VAX-780 design cost 300 man-years over 3 years.

    - Looking at Hennessy's project notes for the Stanford MIPS,
    and filtering out tool developments costs,
    MIPS-1 design cost about 2 engineers working for 6 months.

    Once compilers made significant growth in optimization, and sufficient silicon area became available.

    By 1982 DEC research showed that VAX compilers only used 50 to 60 of its
    304 instructions and 3 or 4 of its address modes.
    See "A Case Study of VAX-11 Instruction Set Usage For Compiler Execution", 1982.

    So compilers were already emitting risc-ish code.

    Shall we then conclude that DEC did everything right, because later on
    after the VAX, DEC came up with the Alpha, which was RISC, and which
    was the highest-performing chip of its day?

    The commercial success of VAX delayed Alpha--no doubt about that. So, I contend, DEC misplayed that card.

    During the 1980's DEC had multiple proposals and projects floating
    around internally but failed to capitalize on any of them.

    There was the risc-ish Titan project circa 1982.

    Titan System Manual 1986 WRL-86-1 https://www.bitsavers.org/pdf/dec/tech_reports/WRL-86-1.pdf

    "The Titan project was begun as the initial project of the Western Research Laboratory in April of 1982. The most obvious milestones were the following: Apr 1982 Project begins
    Mar 1983 CPU logic simulation
    Oct 1984 CPU executing with toy memory system
    May 1985 CPU executing with real memory system
    Jun 1985 I/O starts working
    Dec 1985 Complete system with all I/O running Unix"

    "The first implementation of Titan is in 100K ECL, with a 45 nanosecond cycle time
    and 13 cycle cache miss penalty. The central processor has a four-stage pipeline
    with a peak instruction issue rate of one per cycle. Due to cache misses and pipeline stalls, a new instruction is typically issued every 1.5 cycles."

    There were internal proposals to switch to an internal risc engine:

    VOR: VAX on a RISC.
    Internal memo, Digital Systems Research Center, December 1984 https://bwlampson.site/35a-VOR/35a-VORAbstract.html

    Ideas for a simple fast VAX.
    Internal memo, Digital Systems Research Center, October 1985 https://bwlampson.site/35b-IdeasFastVAX/35b-IdeasFastVAXAbstract.html

    DEC PRISM (Parallel Reduced Instruction Set Machine) was circa 1988 https://en.wikipedia.org/wiki/DEC_PRISM


    Well, not everything. The Alpha was so expensive as to be a dismal
    failure in the market. However, it was either good enough, or
    well-documented enough, for some Chinese efforts at home-grown
    computer design to have copied it.

    John Savard

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From John Levine@johnl@taugh.com to comp.arch on Sun Oct 25 18:42:06 2026
    From Newsgroup: comp.arch

    According to EricP <ThatWouldBeTelling@thevillage.com>:
    Recall my prior post of the article from Electronics about memory prices >circa 1973 being about 10 cents per byte (in 1973 cents) as that would >strongly influence any architecture and ISA design decisions.

    Yes, they guessed wrong about the trajectory of memory prices.

    I think they also had an implicit assumption that ROM would always be
    faster than RAM so the cost of interpreting microcode would be low.

    And they totally missed that people would stop writing systems code in assembler
    and switch to higher level languages like C or PL/S or BLISS or Burroughs Algol.
    The IBM 801 project was going on at the same time, with the compiler and the computer developed together. The 801 was a RISC largely because that was the code that the PL.8 compiler generated.

    I recall reading somwhere that when they wrote a S/360 code generator
    for PL.8, its code ran much faster than the regular PL/I compilers because
    it mostly used a RISC-ish subset of the 360 instruction set that ran fast.
    --
    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 Sun Oct 25 20:03:14 2026
    From Newsgroup: comp.arch

    John Levine <johnl@taugh.com> schrieb:
    The 801 was a RISC largely because that was the
    code that the PL.8 compiler generated.

    They chose the RISC design based on their studies of generated code,
    and then co-developed the ISA and the compiler together.

    What I particularly liked is the way they simulated their machine.
    Apparently, they had a /370 at their disposal and replaced the 801 instructions, on the fly, with equivalend 32-bit instructions for
    the /370, which made for much faster execution than pure emulation.

    I recall reading somwhere that when they wrote a S/360 code generator
    for PL.8, its code ran much faster than the regular PL/I compilers because
    it mostly used a RISC-ish subset of the 360 instruction set that ran fast.

    Graph coloring for register allocation also played a large role,
    from what I read.
    --
    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 Stefan Monnier@monnier@iro.umontreal.ca to comp.arch on Sun Oct 25 23:36:03 2026
    From Newsgroup: comp.arch

    EricP [2026-10-25 12:56:55] wrote:
    On 2026-Oct-24 15:28, MitchAlsup wrote:
    Once compilers made significant growth in optimization, and sufficient
    silicon area became available.
    [...]
    So compilers were already emitting risc-ish code.

    Yeah, IIUC the need to have better compilers wasn't because
    compiler-generated RISC code would not be competitive with
    compiler-generated CISC code, but because CISC assembler was supposed to
    be comfortable whereas RISC assembler was supposed to be painful to use,
    so RISC would be palatable only if exposure to assembler was reduced
    (hence the need for better compilers).

    The old "semantic gap" argument.


    === Stefan
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.arch on Mon Oct 26 18:06:04 2026
    From Newsgroup: comp.arch

    quadibloc@invalid.com (John Savard) writes:
    Shall we then conclude that DEC did everything right, because later on
    after the VAX, DEC came up with the Alpha, which was RISC, and which
    was the highest-performing chip of its day?

    If DEC did everything right, why is there no DEC now?

    Well, not everything. The Alpha was so expensive as to be a dismal
    failure in the market.

    They did not sell as many as they needed, and they were more expensive
    than Intel-based PCs, and eventually Intel and AMD ate all the RISCs
    in general-purpose computing, except, probably thanks to iSeries,
    Power. Price may have had to do with it.

    The fact that Intel and AMD could ramp up the speed faster than Alpha
    probably was the nail in the coffin.

    - 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 Mon Oct 26 18:19:23 2026
    From Newsgroup: comp.arch

    MitchAlsup <user5857@newsgrouper.org.invalid> writes:
    quadibloc@invalid.com (John Savard) posted:
    Could the VAX have been designed as a
    RISC architecture to begin with?

    Not with the players involved. Now, if Thronton or Seymore was at CMU
    then maybe.

    The 801 was designed at around the same time as the VAX 11/780, and
    the CDC6600 had been designed more than a decade earlier. EricP has
    reported on his design of a RISC with the kind of technology that the
    VAX was built from. It's pretty obvious that it was possible, and it
    is even more obvious that the VAX architects did not do it.

    Once compilers made significant growth in optimization, and sufficient >silicon area became available.

    RISCs are already faster without additional compiler optimization.
    Good register allocation is necessary to avoid a large code size
    penalty, however, and that was an issue when the VAX started.

    - 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 Mon Oct 26 18:33:09 2026
    From Newsgroup: comp.arch

    Thomas Koenig <tkoenig@netcologne.de> writes:
    Again, the 801 proved that it could be done. I think they also
    invented graph coloring for register allocation, or if they did
    not invent it, they certainly used it.

    Graph coloring register allocation was indeed developed in connection
    with the 801 project (note that John Cocke coauthored the paper
    [chaitin+81]).

    However, graph coloring register allocation is not necessary for a
    RISC to outperform the VAX 11/780, pipelining is enough. The Berkeley
    RISC people were a hardware group and did not do optimizing compilers.

    HPPA originally used some PCC variant (no graph coloring register
    allocation or any other sophisticated optimization) as C compiler, and
    gcc outperformed HP's compiler by a wide margin when it appeared. Yet
    HPPA outperformed HP's CISC offerings by a wide margin, too.

    The only groups that did much with compilers in early RISC history are
    the IBM 801 group and the Stanford MIPS group.

    @Article{chaitin+81,
    author = "Gregory J. Chaitin and Marc A. Auslander and Ashok K.
    Chandra and John Cocke and Martin E. Hopkins and
    Peter W. Markstein",
    title = "Register Allocation via Coloring",
    journal = complang,
    year = "1981",
    volume = "6",
    number = "1",
    pages = "45--57",
    note = "Reprinted in \cite{stallings90}",
    annote = "The seminal paper on coloring register allocation.
    The spill code generation differs much from Chaitins
    later paper and reminds me of hierarchical graph
    coloring."
    }

    - 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 scott@scott@slp53.sl.home (Scott Lurndal) to comp.arch on Mon Oct 26 18:53:06 2026
    From Newsgroup: comp.arch

    anton@mips.complang.tuwien.ac.at (Anton Ertl) writes:
    quadibloc@invalid.com (John Savard) writes:
    Shall we then conclude that DEC did everything right, because later on >>after the VAX, DEC came up with the Alpha, which was RISC, and which
    was the highest-performing chip of its day?

    If DEC did everything right, why is there no DEC now?

    Well, not everything. The Alpha was so expensive as to be a dismal
    failure in the market.

    They did not sell as many as they needed, and they were more expensive
    than Intel-based PCs, and eventually Intel and AMD ate all the RISCs
    in general-purpose computing, except, probably thanks to iSeries,
    Power. Price may have had to do with it.

    The fact that Intel and AMD could ramp up the speed faster than Alpha >probably was the nail in the coffin.

    Alpha's weak memory model didn't help sell chips, either.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.arch on Mon Oct 26 18:46:12 2026
    From Newsgroup: comp.arch

    Stefan Monnier <monnier@iro.umontreal.ca> writes:
    Yeah, IIUC the need to have better compilers wasn't because >compiler-generated RISC code would not be competitive with
    compiler-generated CISC code, but because CISC assembler was supposed to
    be comfortable whereas RISC assembler was supposed to be painful to use,
    so RISC would be palatable only if exposure to assembler was reduced
    (hence the need for better compilers).

    RISC assembly languages are not painful; on the contrary, they are
    relatively easy. I can imagine that assembly programmers resented the devaluing of their skill of making good use of the addressing modes,
    and CISCy features of an instruction set. Instead, delay slots meant
    that a new skill had to be learned for some assembly languages. The
    MIPS assembler took care of the delay slots, however.

    Anyway, as memories grew, high-level languages gained relevance.
    RISCs have a performance advantage over VAX-11/780 in assembly
    language, with simple compilers, and with optimizing compilers, thanks
    to pipelining (and the 11/780's high CPI). The memory consumption
    with simple compilers may have resulted in bad code density for a
    RISCy VAX, and that would have delayed the moved to high-level
    languages by a short while, but I still think that a RISCy VAX would
    have been better for DEC and their customers.

    - 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 Mon Oct 26 19:56:22 2026
    From Newsgroup: comp.arch

    It appears that Anton Ertl <anton@mips.complang.tuwien.ac.at> said:
    However, graph coloring register allocation is not necessary for a
    RISC to outperform the VAX 11/780, pipelining is enough. The Berkeley
    RISC people were a hardware group and did not do optimizing compilers.

    They sure didn't. They invented register windows because PCC's
    register allocator saved and restored lots of registers around
    every call, and the windows made that faster. On the 801, they
    just saved what they needed to so they didn't even have load or
    store multiple.
    --
    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 Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.arch on Mon Oct 26 14:29:46 2026
    From Newsgroup: comp.arch

    On 10/26/2026 11:46 AM, Anton Ertl wrote:
    Stefan Monnier <monnier@iro.umontreal.ca> writes:
    Yeah, IIUC the need to have better compilers wasn't because
    compiler-generated RISC code would not be competitive with
    compiler-generated CISC code, but because CISC assembler was supposed to
    be comfortable whereas RISC assembler was supposed to be painful to use,
    so RISC would be palatable only if exposure to assembler was reduced
    (hence the need for better compilers).

    RISC assembly languages are not painful; on the contrary, they are
    relatively easy. I can imagine that assembly programmers resented the devaluing of their skill of making good use of the addressing modes,
    and CISCy features of an instruction set. Instead, delay slots meant
    that a new skill had to be learned for some assembly languages. The
    MIPS assembler took care of the delay slots, however.

    Fwiw, never put a MEMBAR instruction in a delay slot on SPARC.



    Anyway, as memories grew, high-level languages gained relevance.
    RISCs have a performance advantage over VAX-11/780 in assembly
    language, with simple compilers, and with optimizing compilers, thanks
    to pipelining (and the 11/780's high CPI). The memory consumption
    with simple compilers may have resulted in bad code density for a
    RISCy VAX, and that would have delayed the moved to high-level
    languages by a short while, but I still think that a RISCy VAX would
    have been better for DEC and their customers.

    - anton

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.arch on Mon Oct 26 14:30:16 2026
    From Newsgroup: comp.arch

    On 10/26/2026 11:53 AM, Scott Lurndal wrote:
    anton@mips.complang.tuwien.ac.at (Anton Ertl) writes:
    quadibloc@invalid.com (John Savard) writes:
    Shall we then conclude that DEC did everything right, because later on
    after the VAX, DEC came up with the Alpha, which was RISC, and which
    was the highest-performing chip of its day?

    If DEC did everything right, why is there no DEC now?

    Well, not everything. The Alpha was so expensive as to be a dismal
    failure in the market.

    They did not sell as many as they needed, and they were more expensive
    than Intel-based PCs, and eventually Intel and AMD ate all the RISCs
    in general-purpose computing, except, probably thanks to iSeries,
    Power. Price may have had to do with it.

    The fact that Intel and AMD could ramp up the speed faster than Alpha
    probably was the nail in the coffin.

    Alpha's weak memory model didn't help sell chips, either.


    Alpha was a little too weak...
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Chris M. Thomasson@chris.m.thomasson.1@gmail.com to comp.arch on Mon Oct 26 14:32:48 2026
    From Newsgroup: comp.arch

    On 10/26/2026 2:30 PM, Chris M. Thomasson wrote:
    On 10/26/2026 11:53 AM, Scott Lurndal wrote:
    anton@mips.complang.tuwien.ac.at (Anton Ertl) writes:
    quadibloc@invalid.com (John Savard) writes:
    Shall we then conclude that DEC did everything right, because later on >>>> after the VAX, DEC came up with the Alpha, which was RISC, and which
    was the highest-performing chip of its day?

    If DEC did everything right, why is there no DEC now?

    Well, not everything. The Alpha was so expensive as to be a dismal
    failure in the market.

    They did not sell as many as they needed, and they were more expensive
    than Intel-based PCs, and eventually Intel and AMD ate all the RISCs
    in general-purpose computing, except, probably thanks to iSeries,
    Power.-a Price may have had to do with it.

    The fact that Intel and AMD could ramp up the speed faster than Alpha
    probably was the nail in the coffin.

    Alpha's weak memory model didn't help sell chips, either.


    Alpha was a little too weak...

    It was interesting to me that Windows can run on an Alpha:

    https://betawiki.net/wiki/Draft:Installing_Windows_NT_on_DEC_Alpha
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Lawrence =?iso-8859-13?q?D=FFOliveiro?=@ldo@nz.invalid to comp.arch,alt.folklore.computers on Mon Oct 26 22:13:56 2026
    From Newsgroup: comp.arch

    On Mon, 26 Oct 2026 18:06:04 GMT, Anton Ertl wrote:

    If DEC did everything right, why is there no DEC now?

    It was a company run by engineers, not businesspeople. They were
    bright engineers, who pioneered a lot of things in their early days,
    but they were less appreciative of innovations coming into their
    market from other directions (Unix, and of course the IBM PC and
    friends).

    The fact that Intel and AMD could ramp up the speed faster than
    Alpha probably was the nail in the coffin.

    Or indeed, faster than PowerPC, which Apple were using at around that
    time.

    I used to tell people that Intel was spending 10|u on developing x86
    what IBM/Motorola were putting into developing PowerPC. But then, they
    were also earning 10|u as much revenue from x86 chips, so they could
    afford it. The result was, the inferior technology was winning in the marketplace, just due to the sheer laws of economics.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Lawrence =?iso-8859-13?q?D=FFOliveiro?=@ldo@nz.invalid to comp.arch,alt.folklore.computers on Mon Oct 26 22:16:43 2026
    From Newsgroup: comp.arch

    On Mon, 26 Oct 2026 14:32:48 -0700, Chris M. Thomasson wrote:

    It was interesting to me that Windows can run on an Alpha:

    https://betawiki.net/wiki/Draft:Installing_Windows_NT_on_DEC_Alpha

    All part of the original plan, didnrCOt you know? NT was designed at the beginning to be a portable OS, able to run on a range of architectures
    -- development actually started, not on x86, but on MIPS. It even had
    a rCLpersonalityrCY system, where the Win32 API was just one rCLpersonalityrCY that could be exposed to userland; there were plans to support others.

    In the end, the portability of a proprietary OS proved too expensive
    to maintain. A few non-x86 ports did ship for a while, but none lasted
    for long.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Thomas Koenig@tkoenig@netcologne.de to comp.arch on Tue Oct 27 06:31:58 2026
    From Newsgroup: comp.arch

    John Levine <johnl@taugh.com> schrieb:
    It appears that Anton Ertl <anton@mips.complang.tuwien.ac.at> said:
    However, graph coloring register allocation is not necessary for a
    RISC to outperform the VAX 11/780, pipelining is enough. The Berkeley
    RISC people were a hardware group and did not do optimizing compilers.

    They sure didn't. They invented register windows because PCC's
    register allocator saved and restored lots of registers around
    every call, and the windows made that faster. On the 801, they
    just saved what they needed to so they didn't even have load or
    store multiple.

    They had subroutines for register save and restore, which of course
    helps code density, but is a bit... iffy.
    --
    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 Tue Oct 27 08:18:00 2026
    From Newsgroup: comp.arch

    In article <11bogu0$10307$1@dont-email.me>, chris.m.thomasson.1@gmail.com (Chris M. Thomasson) wrote:

    It was interesting to me that Windows can run on an Alpha:

    https://betawiki.net/wiki/Draft:Installing_Windows_NT_on_DEC_Alpha

    It worked fine. My employers supported it for several years. It had
    customers because it was the fastest Windows platform, for a while. It
    lost that position when Intel and AMD were competing on raw clock speeds
    and running through their growth space much faster than they'd wanted to.


    Once Compaq bought DEC, there was little development funding for Alpha.
    Once HP bought Compaq there was none, because HP was focused on Itanium,
    and sold the Alpha IP to Intel.

    John
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From MitchAlsup@user5857@newsgrouper.org.invalid to comp.arch on Tue Oct 27 16:41:35 2026
    From Newsgroup: comp.arch

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

    MitchAlsup <user5857@newsgrouper.org.invalid> writes:
    quadibloc@invalid.com (John Savard) posted:
    Could the VAX have been designed as a
    RISC architecture to begin with?

    Not with the players involved. Now, if Thronton or Seymore was at CMU
    then maybe.

    The 801 was designed at around the same time as the VAX 11/780, and
    the CDC6600 had been designed more than a decade earlier. EricP has
    reported on his design of a RISC with the kind of technology that the
    VAX was built from. It's pretty obvious that it was possible, and it
    is even more obvious that the VAX architects did not do it.

    Once compilers made significant growth in optimization, and sufficient >silicon area became available.

    RISCs are already faster without additional compiler optimization.

    If 1983 compilers were still at the -O1 level, RISC may have failed.
    Luckily they were at -O2 at that time, and did.

    Good register allocation is necessary to avoid a large code size
    penalty, however, and that was an issue when the VAX started.

    - anton
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From MitchAlsup@user5857@newsgrouper.org.invalid to comp.arch on Tue Oct 27 16:58:12 2026
    From Newsgroup: comp.arch

    Thomas Koenig <tkoenig@netcologne.de> posted:

    John Levine <johnl@taugh.com> schrieb:
    It appears that Anton Ertl <anton@mips.complang.tuwien.ac.at> said:
    However, graph coloring register allocation is not necessary for a
    RISC to outperform the VAX 11/780, pipelining is enough. The Berkeley >>RISC people were a hardware group and did not do optimizing compilers.

    They sure didn't. They invented register windows because PCC's
    register allocator saved and restored lots of registers around
    every call, and the windows made that faster. On the 801, they
    just saved what they needed to so they didn't even have load or
    store multiple.

    They had subroutines for register save and restore, which of course
    helps code density, but is a bit... iffy.

    So iffy that essentially nobody does register windows anymore.
    The compiler is at least as good at it as an exception-called
    save/restore machine. {Both V8 and V9}

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From John Ames@commodorejohn@gmail.com to comp.arch,alt.folklore.computers on Tue Oct 27 10:04:50 2026
    From Newsgroup: comp.arch

    On Mon, 26 Oct 2026 22:16:43 -0000 (UTC)
    Lawrence DrCOOliveiro <ldo@nz.invalid> wrote:
    All part of the original plan, didnrCOt you know? NT was designed at the beginning to be a portable OS, able to run on a range of architectures
    -- development actually started, not on x86, but on MIPS. It even had
    a rCLpersonalityrCY system, where the Win32 API was just one rCLpersonalityrCY
    that could be exposed to userland; there were plans to support others.

    In the end, the portability of a proprietary OS proved too expensive
    to maintain. A few non-x86 ports did ship for a while, but none lasted
    for long.
    Yeah, multiarchitecture NT was a neat idea, but they whiffed on some essentials, the time wasn't really right, and they never gave it quite
    the effort it needed, or the marketing push. The core work of getting
    it up and running on the various RISC platforms was handled well; 2k
    RC1 runs as stably on Alpha as it does on a comparable P2 rig...
    ...but AFAIK Alpha was the only architecture they developed an x86
    translation layer for ('til ARM64, decades later.) So on e.g. PPC or
    MIPS you were limited to the set of applications whose developers felt
    like providing a native build, which wasn't helped by the fact that M$
    sold separate RISC editions of Visual Studio. (I still have the copy of
    VB5 from the brief period where $EMPLOYER toyed with Alpha support.)
    Moreover, they didn't provide anything like the "fat binary" formats
    used by e.g. Apple or NeXT, so even shipping native builds for multiple architectures was a non-trivial thing; nor was there a shared virtual-
    machine platform developers could target UCSD-style, even though MS had experience with that since the first versions of Visual Basic.
    (Granted, performance on VM platforms was even more lackluster in those
    days, before the advent of JIT techniques etc., but a slower version of
    an application is, in most cases, better than none at all.)
    It's also a good question how much demand there was for cross-platform
    RISC support at the time - how many Windows users *really* needed to be
    on the bleeding edge of performance that bad? - but MS's attitude that
    their job was done when the OS was up and running sure didn't help.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Roman Belenov@no@spam.please to comp.arch,alt.folklore.computers on Tue Oct 27 20:22:16 2026
    From Newsgroup: comp.arch

    Lawrence DrCOOliveiro <ldo@nz.invalid> writes:

    All part of the original plan, didnrCOt you know? NT was designed at the beginning to be a portable OS, able to run on a range of architectures
    -- development actually started, not on x86, but on MIPS.

    Wasn't it i860?

    Regards, Roman
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From cross@cross@spitfire.i.gajendra.net (Dan Cross) to comp.arch,alt.folklore.computers on Tue Oct 27 18:05:10 2026
    From Newsgroup: comp.arch

    In article <m2mrrzxdmf.fsf@Mac.lan>, Roman Belenov <no@spam.please> wrote: >Lawrence DrCOOliveiro <ldo@nz.invalid> writes:

    All part of the original plan, didnrCOt you know? NT was designed at the
    beginning to be a portable OS, able to run on a range of architectures
    -- development actually started, not on x86, but on MIPS.

    Wasn't it i860?

    Yes. i860 was the first architecture to boot NT.

    - Dan C.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Dave Yeo@dave.r.yeo@gmail.com to comp.arch,alt.folklore.computers on Tue Oct 27 11:14:43 2026
    From Newsgroup: comp.arch

    Roman Belenov wrote:
    Lawrence DrCOOliveiro <ldo@nz.invalid> writes:

    All part of the original plan, didnrCOt you know? NT was designed at the
    beginning to be a portable OS, able to run on a range of architectures
    -- development actually started, not on x86, but on MIPS.

    Wasn't it i860?


    I remember a Byte article about OS/2 NT v3 first boot (cmd line) on MIPS.
    Quite possible they developed on multiple architectures.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Michael S@already5chosen@yahoo.com to comp.arch,alt.folklore.computers on Tue Oct 27 20:15:39 2026
    From Newsgroup: comp.arch

    On Tue, 27 Oct 2026 18:05:10 -0000 (UTC)
    cross@spitfire.i.gajendra.net (Dan Cross) wrote:
    In article <m2mrrzxdmf.fsf@Mac.lan>, Roman Belenov <no@spam.please>
    wrote:
    Lawrence D|ore4raoOliveiro <ldo@nz.invalid> writes:

    All part of the original plan, didn|ore4raot you know? NT was designed
    at the beginning to be a portable OS, able to run on a range of
    architectures -- development actually started, not on x86, but on
    MIPS.

    Wasn't it i860?

    Yes. i860 was the first architecture to boot NT.

    - Dan C.

    Wikipedia claims that the first architecture to boot NT was i860
    emulator. They don't say what was the hardware host of the emulator.
    The first boot on bare metal most likely happened on MIPS R3000.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.arch on Tue Oct 27 18:16:41 2026
    From Newsgroup: comp.arch

    MitchAlsup <user5857@newsgrouper.org.invalid> writes: >anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
    RISCs are already faster without additional compiler optimization.

    If 1983 compilers were still at the -O1 level, RISC may have failed.
    Luckily they were at -O2 at that time, and did.

    The -O1 and -O2 of what compiler do you have in mind?

    Gcc was released in 1987; it did have a -O option (IIRC no -O2 yet),
    and gcc beat HP's C compiler on HP/UX (probably PCC-based, i.e., far
    less optimization that gcc -O) by a wide margin; yet HP with their not
    so great compiler saw good speedups with their C compiler from their
    HPPA RISC architecture (introduced 1986) compared to their 68K-based
    and HP FOCUS based systems. And that's against the 68030 (when I was
    at HP in 1988), which already had a better CPI than the CPI=10 of the
    VAX 11/780.

    The VAX 11/780 CPI is so abysmally high that even if a VAX instruction
    would expand into

    load
    load
    operate
    store

    on a RISC, the RISC would still beat it easily (on early RISCs this
    sequence takes 5 cycles, while a typical VAX instruction takes 10
    cycles). You may want to argue cache for the load and the store, but

    1) wrt compilers, those memory accesses that compilers can
    register-allocate away are cache hits.

    2) wrt VAX 11/780, it will miss the cache for the same memory accesses
    as the RISC, so cache misses won't help the VAX.

    Compilers with better register allocation certainly helped, but they
    also helped the CISCs (maybe not as much, but still).

    - 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 cross@cross@spitfire.i.gajendra.net (Dan Cross) to comp.arch,alt.folklore.computers on Tue Oct 27 18:50:58 2026
    From Newsgroup: comp.arch

    In article <20261027201539.00001cb0@yahoo.com>,
    Michael S <already5chosen@yahoo.com> wrote:
    On Tue, 27 Oct 2026 18:05:10 -0000 (UTC)
    cross@spitfire.i.gajendra.net (Dan Cross) wrote:

    In article <m2mrrzxdmf.fsf@Mac.lan>, Roman Belenov <no@spam.please>
    wrote:
    Lawrence D|ore4raoOliveiro <ldo@nz.invalid> writes:

    All part of the original plan, didn|ore4raot you know? NT was designed
    at the beginning to be a portable OS, able to run on a range of
    architectures -- development actually started, not on x86, but on
    MIPS.

    Wasn't it i860?

    Yes. i860 was the first architecture to boot NT.

    - Dan C.


    Wikipedia claims that the first architecture to boot NT was i860
    emulator. They don't say what was the hardware host of the emulator.
    The first boot on bare metal most likely happened on MIPS R3000.

    Believe what you want, but I have this first-hand from an
    engineer who was there.

    - Dan C.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Michael S@already5chosen@yahoo.com to comp.arch,alt.folklore.computers on Tue Oct 27 21:16:41 2026
    From Newsgroup: comp.arch

    On Tue, 27 Oct 2026 18:50:58 -0000 (UTC)
    cross@spitfire.i.gajendra.net (Dan Cross) wrote:
    In article <20261027201539.00001cb0@yahoo.com>,
    Michael S <already5chosen@yahoo.com> wrote:
    On Tue, 27 Oct 2026 18:05:10 -0000 (UTC)
    cross@spitfire.i.gajendra.net (Dan Cross) wrote:

    In article <m2mrrzxdmf.fsf@Mac.lan>, Roman Belenov
    <no@spam.please> wrote:
    Lawrence D|a-o|orCU-4|orCR-oOliveiro <ldo@nz.invalid> writes:

    All part of the original plan, didn|a-o|orCU-4|orCR-ot you know? NT was >> >> designed at the beginning to be a portable OS, able to run on a
    range of architectures -- development actually started, not on
    x86, but on MIPS.

    Wasn't it i860?

    Yes. i860 was the first architecture to boot NT.

    - Dan C.


    Wikipedia claims that the first architecture to boot NT was i860
    emulator. They don't say what was the hardware host of the emulator.
    The first boot on bare metal most likely happened on MIPS R3000.

    Believe what you want, but I have this first-hand from an
    engineer who was there.

    - Dan C.

    Looked further and found this: https://x.com/davepl1968/status/2103977673425047588
    Sounds like Wikipedia story is not complete.
    The complete story was:
    1. First boot - i860 emulator running on i386 under OS/2
    2. First boot on bare metal - i860 XR. Unsatisfactory performance.
    3. Boot on MIPS 3 months thereafter.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Peter Flass@Peter@Iron-Spring.com to comp.arch,alt.folklore.computers on Tue Oct 27 12:44:47 2026
    From Newsgroup: comp.arch

    On 10/27/26 10:04, John Ames wrote:
    On Mon, 26 Oct 2026 22:16:43 -0000 (UTC)
    Lawrence DrCOOliveiro <ldo@nz.invalid> wrote:

    All part of the original plan, didnrCOt you know? NT was designed at the
    beginning to be a portable OS, able to run on a range of architectures
    -- development actually started, not on x86, but on MIPS. It even had
    a rCLpersonalityrCY system, where the Win32 API was just one rCLpersonalityrCY
    that could be exposed to userland; there were plans to support others.

    In the end, the portability of a proprietary OS proved too expensive
    to maintain. A few non-x86 ports did ship for a while, but none lasted
    for long.

    Yeah, multiarchitecture NT was a neat idea, but they whiffed on some essentials, the time wasn't really right, and they never gave it quite
    the effort it needed, or the marketing push. The core work of getting
    it up and running on the various RISC platforms was handled well; 2k
    RC1 runs as stably on Alpha as it does on a comparable P2 rig...

    ...but AFAIK Alpha was the only architecture they developed an x86 translation layer for ('til ARM64, decades later.) So on e.g. PPC or
    MIPS you were limited to the set of applications whose developers felt
    like providing a native build, which wasn't helped by the fact that M$
    sold separate RISC editions of Visual Studio. (I still have the copy of
    VB5 from the brief period where $EMPLOYER toyed with Alpha support.)

    Moreover, they didn't provide anything like the "fat binary" formats
    used by e.g. Apple or NeXT, so even shipping native builds for multiple architectures was a non-trivial thing; nor was there a shared virtual- machine platform developers could target UCSD-style, even though MS had experience with that since the first versions of Visual Basic.

    (Granted, performance on VM platforms was even more lackluster in those
    days, before the advent of JIT techniques etc., but a slower version of
    an application is, in most cases, better than none at all.)

    It's also a good question how much demand there was for cross-platform
    RISC support at the time - how many Windows users *really* needed to be
    on the bleeding edge of performance that bad? - but MS's attitude that
    their job was done when the OS was up and running sure didn't help.

    Wasn't there an NT release for the PowerPC?
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Peter Flass@Peter@Iron-Spring.com to comp.arch,alt.folklore.computers on Tue Oct 27 12:46:56 2026
    From Newsgroup: comp.arch

    On 10/27/26 12:16, Michael S wrote:
    On Tue, 27 Oct 2026 18:50:58 -0000 (UTC)
    cross@spitfire.i.gajendra.net (Dan Cross) wrote:

    In article <20261027201539.00001cb0@yahoo.com>,
    Michael S <already5chosen@yahoo.com> wrote:
    On Tue, 27 Oct 2026 18:05:10 -0000 (UTC)
    cross@spitfire.i.gajendra.net (Dan Cross) wrote:

    In article <m2mrrzxdmf.fsf@Mac.lan>, Roman Belenov
    <no@spam.please> wrote:
    Lawrence D|a-o|orCU-4|orCR-oOliveiro <ldo@nz.invalid> writes:

    All part of the original plan, didn|a-o|orCU-4|orCR-ot you know? NT was >>>>>> designed at the beginning to be a portable OS, able to run on a
    range of architectures -- development actually started, not on
    x86, but on MIPS.

    Wasn't it i860?

    Yes. i860 was the first architecture to boot NT.

    - Dan C.


    Wikipedia claims that the first architecture to boot NT was i860
    emulator. They don't say what was the hardware host of the emulator.
    The first boot on bare metal most likely happened on MIPS R3000.

    Believe what you want, but I have this first-hand from an
    engineer who was there.

    - Dan C.



    Looked further and found this: https://x.com/davepl1968/status/2103977673425047588

    Sounds like Wikipedia story is not complete.
    The complete story was:
    1. First boot - i860 emulator running on i386 under OS/2
    2. First boot on bare metal - i860 XR. Unsatisfactory performance.
    3. Boot on MIPS 3 months thereafter.

    What would "satisfactory" performance for Windows have looked like?
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Michael S@already5chosen@yahoo.com to comp.arch,alt.folklore.computers on Tue Oct 27 22:00:58 2026
    From Newsgroup: comp.arch

    On Tue, 27 Oct 2026 12:46:56 -0700
    Peter Flass <Peter@Iron-Spring.com> wrote:
    On 10/27/26 12:16, Michael S wrote:
    On Tue, 27 Oct 2026 18:50:58 -0000 (UTC)
    cross@spitfire.i.gajendra.net (Dan Cross) wrote:

    In article <20261027201539.00001cb0@yahoo.com>,
    Michael S <already5chosen@yahoo.com> wrote:
    On Tue, 27 Oct 2026 18:05:10 -0000 (UTC)
    cross@spitfire.i.gajendra.net (Dan Cross) wrote:

    In article <m2mrrzxdmf.fsf@Mac.lan>, Roman Belenov
    <no@spam.please> wrote:
    Lawrence D|a-o|orCU-4|orCR-oOliveiro <ldo@nz.invalid> writes:

    All part of the original plan, didn|a-o|orCU-4|orCR-ot you know? NT was
    designed at the beginning to be a portable OS, able to run on a
    range of architectures -- development actually started, not on
    x86, but on MIPS.

    Wasn't it i860?

    Yes. i860 was the first architecture to boot NT.

    - Dan C.


    Wikipedia claims that the first architecture to boot NT was i860
    emulator. They don't say what was the hardware host of the
    emulator. The first boot on bare metal most likely happened on
    MIPS R3000.

    Believe what you want, but I have this first-hand from an
    engineer who was there.

    - Dan C.



    Looked further and found this: https://x.com/davepl1968/status/2103977673425047588

    Sounds like Wikipedia story is not complete.
    The complete story was:
    1. First boot - i860 emulator running on i386 under OS/2
    2. First boot on bare metal - i860 XR. Unsatisfactory performance.
    3. Boot on MIPS 3 months thereafter.

    What would "satisfactory" performance for Windows have looked like?
    How would I possibly know? My guess is, something like "100 context
    switches per second reduce performance (relatively to 0 switches) of
    CPU-bound tasks by less than 5%." But that's just my wild guess.
    Anyway, since MIPS, x86 and few months later Alpha versions of NT
    shipped, I would guess that they all were considered satisfactory.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From John Ames@commodorejohn@gmail.com to comp.arch,alt.folklore.computers on Tue Oct 27 13:03:49 2026
    From Newsgroup: comp.arch

    On Tue, 27 Oct 2026 12:44:47 -0700
    Peter Flass <Peter@Iron-Spring.com> wrote:

    Wasn't there an NT release for the PowerPC?

    Yup - only 3.5/3.51, and AFAIK it only ran on IBM hardware, but it did
    exist, briefly.

    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Thomas Koenig@tkoenig@netcologne.de to comp.arch on Tue Oct 27 20:43:47 2026
    From Newsgroup: comp.arch

    MitchAlsup <user5857@newsgrouper.org.invalid> schrieb:
    Thomas Koenig <tkoenig@netcologne.de> posted:

    John Levine <johnl@taugh.com> schrieb:
    It appears that Anton Ertl <anton@mips.complang.tuwien.ac.at> said:
    However, graph coloring register allocation is not necessary for a
    RISC to outperform the VAX 11/780, pipelining is enough. The Berkeley
    RISC people were a hardware group and did not do optimizing compilers.

    They sure didn't. They invented register windows because PCC's
    register allocator saved and restored lots of registers around
    every call, and the windows made that faster. On the 801, they
    just saved what they needed to so they didn't even have load or
    store multiple.

    They had subroutines for register save and restore, which of course
    helps code density, but is a bit... iffy.

    So iffy that essentially nobody does register windows anymore.
    The compiler is at least as good at it as an exception-called
    save/restore machine. {Both V8 and V9}

    The 801 didn't do register windows.

    They called a routine to save x registers (in their calling
    convention) and to restore them on return. Like enter/exit,
    but with a subroutine call.
    --
    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 MitchAlsup@user5857@newsgrouper.org.invalid to comp.arch on Tue Oct 27 21:01:36 2026
    From Newsgroup: comp.arch

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

    MitchAlsup <user5857@newsgrouper.org.invalid> writes: >anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
    RISCs are already faster without additional compiler optimization.

    If 1983 compilers were still at the -O1 level, RISC may have failed. >Luckily they were at -O2 at that time, and did.

    The -O1 and -O2 of what compiler do you have in mind?

    Green Hills circa 1985.

    Gcc was released in 1987; it did have a -O option (IIRC no -O2 yet),
    and gcc beat HP's C compiler on HP/UX (probably PCC-based, i.e., far
    less optimization that gcc -O) by a wide margin; yet HP with their not
    so great compiler saw good speedups with their C compiler from their
    HPPA RISC architecture (introduced 1986) compared to their 68K-based
    and HP FOCUS based systems. And that's against the 68030 (when I was
    at HP in 1988), which already had a better CPI than the CPI=10 of the
    VAX 11/780.

    The VAX 11/780 CPI is so abysmally high that even if a VAX instruction
    would expand into

    load
    load
    operate
    store

    on a RISC, the RISC would still beat it easily (on early RISCs this
    sequence takes 5 cycles, while a typical VAX instruction takes 10
    cycles). You may want to argue cache for the load and the store, but

    1) wrt compilers, those memory accesses that compilers can
    register-allocate away are cache hits.

    2) wrt VAX 11/780, it will miss the cache for the same memory accesses
    as the RISC, so cache misses won't help the VAX.

    Compilers with better register allocation certainly helped, but they
    also helped the CISCs (maybe not as much, but still).

    - anton
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From scott@scott@slp53.sl.home (Scott Lurndal) to comp.arch on Tue Oct 27 21:14:17 2026
    From Newsgroup: comp.arch

    MitchAlsup <user5857@newsgrouper.org.invalid> writes: >anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:

    MitchAlsup <user5857@newsgrouper.org.invalid> writes:
    anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
    RISCs are already faster without additional compiler optimization.

    If 1983 compilers were still at the -O1 level, RISC may have failed.
    Luckily they were at -O2 at that time, and did.

    The -O1 and -O2 of what compiler do you have in mind?

    Green Hills circa 1985.

    When we started using the 88100 in 1989, we were given
    the m88k version of PCC[*] from the Motorola group in the
    Chicago area. It wasn't until the next year that we had
    access to the Green Hills (and later Diab Data) 88k compilers.

    [*] For which I had to patch the register allocator to support
    the crazy expressions generated by cfront.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Lawrence =?iso-8859-13?q?D=FFOliveiro?=@ldo@nz.invalid to comp.arch,alt.folklore.computers on Tue Oct 27 22:19:02 2026
    From Newsgroup: comp.arch

    On Tue, 27 Oct 2026 20:22:16 +0300, Roman Belenov wrote:

    Lawrence DrCOOliveiro <ldo@nz.invalid> writes:

    All part of the original plan, didnrCOt you know? NT was designed at
    the beginning to be a portable OS, able to run on a range of
    architectures -- development actually started, not on x86, but on
    MIPS.

    Wasn't it i860?

    Probably.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Lawrence =?iso-8859-13?q?D=FFOliveiro?=@ldo@nz.invalid to comp.arch,alt.folklore.computers on Tue Oct 27 22:32:21 2026
    From Newsgroup: comp.arch

    On Tue, 27 Oct 2026 08:18 +0000 (GMT Standard Time), John Dallman wrote:

    In article <11bogu0$10307$1@dont-email.me>, chris.m.thomasson.1@gmail.com (Chris M. Thomasson) wrote:

    It was interesting to me that Windows can run on an Alpha:

    https://betawiki.net/wiki/Draft:Installing_Windows_NT_on_DEC_Alpha

    It worked fine. My employers supported it for several years. It had
    customers because it was the fastest Windows platform, for a while.

    Never took advantage of 64-bit addressing, though; ran the Alpha in
    32-bit-only rCLTASOrCY mode.

    Of the four OSes I can think of that were ported to Alpha, the one
    from Microsoft was 32-bit-only, DECrCOs homegrown one (OpenVMS) was a
    32/64-bit hybrid, and the only fully 64-bit ones were DEC UNIX and
    Linux.
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From jgd@jgd@cix.co.uk (John Dallman) to comp.arch on Wed Oct 28 08:08:00 2026
    From Newsgroup: comp.arch

    In article <11br8pl$1uehc$5@dont-email.me>, ldo@nz.invalid (Lawrence D_Oliveiro) wrote:

    Of the four OSes I can think of that were ported to Alpha, the one
    from Microsoft was 32-bit-only, DEC's homegrown one (OpenVMS) was a
    32/64-bit hybrid, and the only fully 64-bit ones were DEC UNIX and
    Linux.

    VMS was initially 32-bit only. The 32/64 hybrid came in at VMS v7.0. The Itanium and x64_64 versions are still 32/64 hybrids.

    John
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.arch on Thu Oct 29 16:11:18 2026
    From Newsgroup: comp.arch

    MitchAlsup <user5857@newsgrouper.org.invalid> writes:
    Thomas Koenig <tkoenig@netcologne.de> posted:

    John Levine <johnl@taugh.com> schrieb:
    [IBM 801]
    They had subroutines for register save and restore, which of course
    helps code density, but is a bit... iffy.

    So iffy that essentially nobody does register windows anymore.

    The IBM 801 did not do register windows, either.

    The compiler is at least as good at it as an exception-called
    save/restore machine. {Both V8 and V9}

    If we stay with in-order machines, the SPARC register windows have two disadvantages that are not necessary:

    1) Every window has a fixed 16 registers, resulting in less utilization
    of a given number of registers (and more need for saving/restoring
    to memory) and possibly extra spilling needed for functions with
    particularly high register pressure, compared to a more flexible
    scheme.

    2) Using exceptions for the saving and restoring gives away some of
    the potential speed advantage of register windows. That does not
    affect user space, so getting rid of that should have been not that
    hard, but AFAIK it did not happen for SPARC, so maybe it was hard
    (cf. the IA-64 problems).

    The AMD 29K and IA-64 deal with 1) by being more flexible. IA-64 was
    intended to deal with 2) with its hardware stack engine, but according
    to John Dallman they botched it, and fell back to exceptions as a
    recourse. Apparently it is not an easy feature to implement, which is
    somewhat surprising given that OoO seems conceptually more complex,
    and the microarchitects have managed to get it right pretty much every
    time.

    There is a third issue: Do you pass arguments in the register windows,
    or in what SPARC calls global registers? AFAIK SPARC chose to pass
    them in windows, but that means that a call sequence like

    int foo(a,b)
    {
    ...
    bar(a,b);
    ...
    }

    has to copy a and b between in and out, while using globals for
    arguments would avoid that (but would require saving the arguments in
    some way if they are used after the call, the same as without register windows).

    Once we consider OoO, the potential advantages of register windows
    become even smaller:

    1) OoO can make the stores and loads around calls and returns cheaper:
    If the front end runs far ahead of the execution engine (the usual
    case), the stores can start as soon as the values are ready (and if
    they are ready late, the store waits without delaying anything
    else), and independent loads can start early. So ideally they
    don't get into the way of the useful instructions.

    2) On recent designs, zero-cycle store-to-load forwarding means that
    even storing and loading around short function calls may have little
    or no latency penalty.

    And register windows tend to cost more in OoO implementations: the
    register address table (for implementations with a separate renamer)
    becomes larger.

    My memory says that the OoO implementations of HAL/Fujitsu used the
    minimum number of register windows allowed, probably due to a
    combination of the cost and the smaller benefits. However, the number
    of exceptions would increase.

    - 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 Thu Oct 29 17:54:14 2026
    From Newsgroup: comp.arch

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

    MitchAlsup <user5857@newsgrouper.org.invalid> writes:
    Thomas Koenig <tkoenig@netcologne.de> posted:

    John Levine <johnl@taugh.com> schrieb:
    [IBM 801]
    They had subroutines for register save and restore, which of course
    helps code density, but is a bit... iffy.

    So iffy that essentially nobody does register windows anymore.
    -----------snip----------
    There is a third issue: Do you pass arguments in the register windows,
    or in what SPARC calls global registers? AFAIK SPARC chose to pass
    them in windows, but that means that a call sequence like

    int foo(a,b)
    {
    ...
    bar(a,b);
    ...
    }

    It gets worse when::

    type foo( a, b ){
    ...
    return bar( a, b );
    ...
    }

    Now you have to copy forward foo->bar and copy bar's return back
    as foo's return. Whereas a flat register file has neither MOV.

    has to copy a and b between in and out, while using globals for
    arguments would avoid that (but would require saving the arguments in
    some way if they are used after the call, the same as without register windows).

    Once we consider OoO, the potential advantages of register windows
    become even smaller:

    1) OoO can make the stores and loads around calls and returns cheaper:
    If the front end runs far ahead of the execution engine (the usual
    case), the stores can start as soon as the values are ready (and if
    they are ready late, the store waits without delaying anything
    else), and independent loads can start early. So ideally they
    don't get into the way of the useful instructions.

    My 66000 takes advantage of this by LDing the Ret Addr first, and then
    reLDing the rest of the file, so by the time that is done, FETCH already
    has instructions for DECODE>

    2) On recent designs, zero-cycle store-to-load forwarding means that
    even storing and loading around short function calls may have little
    or no latency penalty.

    When prologue and epilogue are 'structured' there are times when one
    can elide the stores entirely as the memory location already has the
    bit pattern the <yet to be performed> ST will write. These happen
    when an EXIT runs into a CALL->ENTER while EXIT is still moving data.

    And register windows tend to cost more in OoO implementations: the
    register address table (for implementations with a separate renamer)
    becomes larger.

    Slower RF, makes the pipeline at least 1/2 cycle longer.

    My memory says that the OoO implementations of HAL/Fujitsu used the
    minimum number of register windows allowed, probably due to a
    combination of the cost and the smaller benefits. However, the number
    of exceptions would increase.

    - anton
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.arch on Thu Oct 29 18:09:45 2026
    From Newsgroup: comp.arch

    MitchAlsup <user5857@newsgrouper.org.invalid> writes: >anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
    There is a third issue: Do you pass arguments in the register windows,
    or in what SPARC calls global registers? AFAIK SPARC chose to pass
    them in windows, but that means that a call sequence like

    int foo(a,b)
    {
    ...
    bar(a,b);
    ...
    }

    It gets worse when::

    type foo( a, b ){
    ...
    return bar( a, b );
    ...
    }

    Now you have to copy forward foo->bar and copy bar's return back
    as foo's return.

    No, it's a tail-call. You just jump to bar without saving or
    restoring a register window.

    My 66000 takes advantage of this by LDing the Ret Addr first, and then >reLDing the rest of the file, so by the time that is done, FETCH already
    has instructions for DECODE>

    I get the impression that My 66000 lives in 1994. In a modern
    (post-1995, with a few exceptions, most of which have died out in the
    meantime) processor the front end predicts the return from the processor-internal return stack and often starts fetching from there
    before the load-store unit sees the load of the return address. The
    return address is then used to validate the branch prediction and
    retire the return instruction.

    And register windows tend to cost more in OoO implementations: the
    register address table (for implementations with a separate renamer)
    becomes larger.

    Slower RF, makes the pipeline at least 1/2 cycle longer.

    Given register file sizes like 416 physical GPRs on the Qualcomm
    Oryon, making the pipeline longer seems to be something CPU designers
    can handle these days; with 416 physical GPRs, taking 72 (or however
    many architectural registers Fujitsu used) rather than 32 for
    architected registers is probably not a big thing, but sure, now there
    are 40 fewer registers that can be used for renaming. Still the
    growth of the RAT is probably a bigger issue.

    - 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 Thu Oct 29 20:31:25 2026
    From Newsgroup: comp.arch

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

    MitchAlsup <user5857@newsgrouper.org.invalid> writes: >anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
    --------------------
    My 66000 takes advantage of this by LDing the Ret Addr first, and then >reLDing the rest of the file, so by the time that is done, FETCH already >has instructions for DECODE>

    I get the impression that My 66000 lives in 1994. In a modern
    (post-1995, with a few exceptions, most of which have died out in the meantime) processor the front end predicts the return from the processor-internal return stack and often starts fetching from there
    before the load-store unit sees the load of the return address. The
    return address is then used to validate the branch prediction and
    retire the return instruction.

    You can't predict until you are within <about> 2-fetch cycles of the instruction you are going to make a prediction about {RET here}.
    When RET is 16-odd instructions (all LDDs) from the current INSERT
    point, you aren't at the point you can make a prediction (by couple
    of cycles).

    The thing is that there may be 16 register loads between the point where
    the compiler knows a return is going to happen and the RET instruction
    itself (in whatever guise). Given that each takes an instruction, then
    we get to the point where moving those 16 register loads through DECODE prevents FETCH/PREDICT from seeing the RET for several cycles. But the
    EXIT instruction itself makes DECODE know that a bunch of register LDs
    will happen and a RET will also happen, so it arranged that RA is fetched
    first and then used to fetch instructions at RA and feed DECODE while all
    the LDs are transpiring.

    Yes, it is easy to predict RET and to fetch instructions there. So, let's
    say we predict the RET and we also "predict" <in some manner> the sub-
    sequent call. So, while we are still LDing registers, we now need to ST
    a bunch of registers {new epilogue} onto the same memory currently being
    LDed.

    The predictive mechanics to determine that the new epilogue is storing
    bit patterns that are already in those memory locations is "non trivial"
    for RISC-V but trivial for EXIT-CALL-ENTER. {For most leaf functions;
    there is only RET with no preserved register restoration and no EXIT}.

    There are cases where one has an EXIT-CALL-ENTER where both {EXIT LDDs
    and ENTER STs} are elided, since the return from this CALL will perform
    those restores--but only to the overlapping set of registers.

    In no way am I preventing predictors from predicting {although I am
    reducing the number of <hard> cases they have to sift through.} I am
    realistic about when a prediction may transpire. Generally current IP
    and some HASHing bits are used to access predictor(s) in cycle k,
    and are available in cycle k=1 to make a FETCH prediction for cycle
    k+2.

    So, the question, here, boils down to: "How many cycles does it take
    DECODE to 'process' 16-LDDs in a row". Even a 10-wide machine may only
    have 4 LD/MEM FUs, so it would take 4-odd cycles to push LDDs through
    DECODE, and at cycle 2 one could be able to predict RET--whereas My
    66000 can predict {with 100% confidence} 2-cycles earlier.

    It is this "push through DECODE" notion I have been struggling with
    for a "while". Once I saw 42-instructions in a row out of the compiler
    all targeting the FMAC FU--I knew I needed a way to move instructions
    through DECODE faster than the targeted FU can process them. Prologues
    and epilogues are just more of this same problem.

    I suspect others have found similar "push through DECODE" issues, too.

    And register windows tend to cost more in OoO implementations: the
    register address table (for implementations with a separate renamer)
    becomes larger.

    Slower RF, makes the pipeline at least 1/2 cycle longer.

    Given register file sizes like 416 physical GPRs on the Qualcomm
    Oryon, making the pipeline longer seems to be something CPU designers
    can handle these days; with 416 physical GPRs, taking 72 (or however
    many architectural registers Fujitsu used) rather than 32 for
    architected registers is probably not a big thing, but sure, now there
    are 40 fewer registers that can be used for renaming. Still the
    growth of the RAT is probably a bigger issue.

    The RAT _was_ a big problem for K9 {with 22 ports per cycle}, its only
    saving grace was that it was only 8-bits wide {instead of 64+}.

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

    On Tue, 27 Oct 2026 16:58:12 GMT, MitchAlsup
    <user5857@newsgrouper.org.invalid> wrote:

    So iffy that essentially nobody does register windows anymore.

    Even I think that register windows are too crazy to consider!

    I have banks of 128 registers, but the choice is to use them all or
    ignore them.

    Of course, there's one register-window-like scheme that I could
    *remotely consider* using, even though it is also dangerously flawed.
    Give the computer an internal high-speed memory that's only 64K in
    size... and copy the Texas Instruments 9900 scheme. That's a little
    different from a "window", although in a way it's essentially the same
    thing. At least here save and restore don't mean copying the window
    contents into memory, but instead saving a copy of the pointer.

    John Savard
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From MitchAlsup@user5857@newsgrouper.org.invalid to comp.arch on Fri Oct 30 00:33:18 2026
    From Newsgroup: comp.arch

    quadibloc@invalid.com (John Savard) posted:

    On Tue, 27 Oct 2026 16:58:12 GMT, MitchAlsup <user5857@newsgrouper.org.invalid> wrote:

    So iffy that essentially nobody does register windows anymore.

    Even I think that register windows are too crazy to consider!

    I have banks of 128 registers, but the choice is to use them all or
    ignore them.

    Of course, there's one register-window-like scheme that I could
    *remotely consider* using, even though it is also dangerously flawed.
    Give the computer an internal high-speed memory that's only 64K in
    size... and copy the Texas Instruments 9900 scheme. That's a little
    different from a "window", although in a way it's essentially the same
    thing. At least here save and restore don't mean copying the window
    contents into memory, but instead saving a copy of the pointer.

    My 66000's memory-based Thread-state is similar to 9900--except HW
    treats them like a write-back-cache. In the 9900 sense, one can
    change a pointer and one has a new register file--but one also has
    a new memory map, and everything else in a Thread-State.

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

    MitchAlsup <user5857@newsgrouper.org.invalid> writes: >anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
    In a modern
    (post-1995, with a few exceptions, most of which have died out in the
    meantime) processor the front end predicts the return from the
    processor-internal return stack and often starts fetching from there
    before the load-store unit sees the load of the return address. The
    return address is then used to validate the branch prediction and
    retire the return instruction.

    You can't predict until you are within <about> 2-fetch cycles of the >instruction you are going to make a prediction about {RET here}.

    Predictors can make predictions about anything. But given that it is
    only useful to make predictions that are actually used, they will only
    predict the next few I-cache lines to be fetched, so yes, predicting a
    few fetch lines ahead could be common.

    How many? Depends on the latency of the I-cache. Given that it is
    typically similar in size to the D-cache, it's latency will also be
    similar, i.e., around 4 cycles.

    How many cache lines are fetched per cycle? With a 10-wide front end,
    you probably do not want to underutilize the rest of the front end if
    there is a taken branch or there is a branch to a target less than 10 instructions from the end of the cache line, so better fetch two cache
    lines per cycle.

    So there might be about 8 cache lines fetched between the prediction
    of the line that includes the return instructions and the actual fetch
    of the return instruction. The predictor has to predict the target of
    the return as the next prediction.

    Now if you want to wait for the result of the return-address load, you
    have to contend not just with the latency of the I-cache fetch of this
    load, but also the decoding, renaming, scheduling, and execution
    (D-cache latency) of this load, typically 10-20 cycles total. So you
    would have to fetch this load 10-20 cycles (and thus 10-20 cycles
    worth of instructions, i.e. 100-200 instructions on a 10-wide machine)
    to have its result ready for using it to fetch the cache line after
    the return instruction (but of course that does not consider that in
    such a predictorless design, the return instruction also takes its
    time to decode etc.).

    Anyway, thanks to branch prediction and speculative execution, that's
    not necessary.

    When RET is 16-odd instructions (all LDDs) from the current INSERT
    point, you aren't at the point you can make a prediction (by couple
    of cycles).

    The thing is that there may be 16 register loads between the point where
    the compiler knows a return is going to happen and the RET instruction
    itself (in whatever guise). Given that each takes an instruction, then
    we get to the point where moving those 16 register loads through DECODE >prevents FETCH/PREDICT from seeing the RET for several cycles.

    Concerning the 16 loads, I don't think I have ever seen a compiler
    generate that many in front of a return. It would require that the
    calling convention has at least 16 callee-saved registers, and that
    they are all being used.

    But anyway, even assuming there is this bunch of loads, and the
    pipeline from the renamer to the scheduler(s) of the load/store units
    is narrow and there is no buffering capacity in between, there is no
    reason why the predictor would not predict the return. It does not
    need to decode the return instruction to predict it, it just needs to
    predict that there will be a return, and then use the hardware return
    stack to make the prediction.

    Of course, with a design that suffers from congestion between the
    renamer and the schedulers, the congestion will eventually clog the
    front end back to the instruction fetcher, and then even having a
    preduction early will not help. If this is a common occurence, the microarchitecture is obviously badly balanced for the workloads it
    uses.

    BTW, what is the INSERT point?

    But the
    EXIT instruction itself makes DECODE know that a bunch of register LDs
    will happen and a RET will also happen, so it arranged that RA is fetched >first and then used to fetch instructions at RA and feed DECODE while all
    the LDs are transpiring.

    Ok, so you are assuming that the congestion has not clogged the
    decoder. In that case, a design with a predictor will happily fetch
    the target of the return and feed it into the decoders.

    Yes, it is easy to predict RET and to fetch instructions there. So, let's
    say we predict the RET and we also "predict" <in some manner> the sub- >sequent call. So, while we are still LDing registers, we now need to ST
    a bunch of registers {new epilogue} onto the same memory currently being >LDed.

    I assume you mean "{new prologue}".

    And you assume that the next call also makes use of many callee-saved registers.

    The predictive mechanics to determine that the new epilogue is storing
    bit patterns that are already in those memory locations is "non trivial"
    for RISC-V but trivial for EXIT-CALL-ENTER.

    Are the same registers saved to the same places? If that is a common
    occurence (I don't think so), recognizing and optimizing it in
    hardware (probably in the renamer) looks doable.

    {For most leaf functions;
    there is only RET with no preserved register restoration and no EXIT}.

    If you need so many registers that you also use callee-saved
    registers, the callee also saves them when the callee is a leaf
    function. Of course, for values that do not live across a call
    (i.e. all values in a leaf function), caller-saved registers are the
    first pick.

    So, the question, here, boils down to: "How many cycles does it take
    DECODE to 'process' 16-LDDs in a row". Even a 10-wide machine may only
    have 4 LD/MEM FUs, so it would take 4-odd cycles to push LDDs through
    DECODE

    I would not know why a 10-wide decoder would not decode 10 loads per
    cycle. Likewise for the renamer. Then the schedulers may be more
    limited, but if so, and having loads and stores in large bunches is
    common, a competent designer will insert some buffering capacity to
    avoid congesting the front end.

    and at cycle 2 one could be able to predict RET--whereas My
    66000 can predict {with 100% confidence} 2-cycles earlier.

    You mean, it can resolve the prediction two cycles earlier. Given
    that return stack prediction is very accurate, the benefit might be
    that one can use a smaller ROB, if the prediction of return was the
    only reason for having a large ROB. But I think that other reasons
    for having a large ROB (such as conditional branches, or cache misses)
    stull persist and are actually more important.

    - 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 Fri Oct 30 18:34:13 2026
    From Newsgroup: comp.arch

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

    MitchAlsup <user5857@newsgrouper.org.invalid> writes: >anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
    In a modern
    (post-1995, with a few exceptions, most of which have died out in the
    meantime) processor the front end predicts the return from the
    processor-internal return stack and often starts fetching from there
    before the load-store unit sees the load of the return address. The
    return address is then used to validate the branch prediction and
    retire the return instruction.

    You can't predict until you are within <about> 2-fetch cycles of the >instruction you are going to make a prediction about {RET here}.

    Predictors can make predictions about anything. But given that it is
    only useful to make predictions that are actually used, they will only predict the next few I-cache lines to be fetched, so yes, predicting a
    few fetch lines ahead could be common.

    How many? Depends on the latency of the I-cache. Given that it is
    typically similar in size to the D-cache, it's latency will also be
    similar, i.e., around 4 cycles.

    How many cache lines are fetched per cycle? With a 10-wide front end,
    you probably do not want to underutilize the rest of the front end if
    there is a taken branch or there is a branch to a target less than 10 instructions from the end of the cache line, so better fetch two cache
    lines per cycle.

    A cache line contains 16 instructions, so one would assume a partial
    line is held over (to the next decode cycle) and one makes 1 fetch
    in the sequential direction and 1 fetch to another predicted address. 2-fetches per cycle giving almost 3 lines of instructions for decode.

    So there might be about 8 cache lines fetched between the prediction
    of the line that includes the return instructions and the actual fetch
    of the return instruction. The predictor has to predict the target of
    the return as the next prediction.

    Now if you want to wait for the result of the return-address load, you
    have to contend not just with the latency of the I-cache fetch of this
    load, but also the decoding, renaming, scheduling, and execution
    (D-cache latency) of this load, typically 10-20 cycles total.

    That is the latency of verification of the prediction.

    So you
    would have to fetch this load 10-20 cycles (and thus 10-20 cycles
    worth of instructions, i.e. 100-200 instructions on a 10-wide machine)
    to have its result ready for using it to fetch the cache line after
    the return instruction (but of course that does not consider that in
    such a predictorless design, the return instruction also takes its
    time to decode etc.).

    Anyway, thanks to branch prediction and speculative execution, that's
    not necessary.

    When RET is 16-odd instructions (all LDDs) from the current INSERT
    point, you aren't at the point you can make a prediction (by couple
    of cycles).

    The thing is that there may be 16 register loads between the point where >the compiler knows a return is going to happen and the RET instruction >itself (in whatever guise). Given that each takes an instruction, then
    we get to the point where moving those 16 register loads through DECODE >prevents FETCH/PREDICT from seeing the RET for several cycles.

    Concerning the 16 loads, I don't think I have ever seen a compiler
    generate that many in front of a return. It would require that the
    calling convention has at least 16 callee-saved registers, and that
    they are all being used.

    I have numerous examples of RISC-V (LLVM -O3) having 13 STs in prologue
    and 13 LDs in epilogue. The distribution (excepting for leaf functions
    (0 saved) and director functions (1 saved) is basically a Bell Curve
    from 2->13.)

    But anyway, even assuming there is this bunch of loads, and the
    pipeline from the renamer to the scheduler(s) of the load/store units
    is narrow and there is no buffering capacity in between, there is no
    reason why the predictor would not predict the return. It does not
    need to decode the return instruction to predict it, it just needs to
    predict that there will be a return, and then use the hardware return
    stack to make the prediction.

    Maybe predictors have gotten that good. We always verified that there
    was a flow-control instruction as a qualification to the predictor.

    Of course, with a design that suffers from congestion between the
    renamer and the schedulers, the congestion will eventually clog the
    front end back to the instruction fetcher, and then even having a
    preduction early will not help. If this is a common occurence, the microarchitecture is obviously badly balanced for the workloads it
    uses.

    Key point: DECODE needs a mechanism that "smoothly" deals with FU overcommitment.

    BTW, what is the INSERT point?

    It is where the instruction is far enough into the pipe that natural
    FU scheduling runs it to completion {This is mostly when the Inst is
    written into Reservation Station.}

    But the
    EXIT instruction itself makes DECODE know that a bunch of register LDs
    will happen and a RET will also happen, so it arranged that RA is fetched >first and then used to fetch instructions at RA and feed DECODE while all >the LDs are transpiring.

    Ok, so you are assuming that the congestion has not clogged the
    decoder. In that case, a design with a predictor will happily fetch
    the target of the return and feed it into the decoders.

    ENTER and EXIT invent the STs and LDs needed in a way easy for DECODE to digest. EXIT in particular {with inst<3>==0} will return; and even if
    there are a lot of LDs to be performed <via EXIT>, RA can be sent to
    FETCH far earlier, ...

    Yes, it is easy to predict RET and to fetch instructions there. So, let's >say we predict the RET and we also "predict" <in some manner> the sub- >sequent call. So, while we are still LDing registers, we now need to ST
    a bunch of registers {new epilogue} onto the same memory currently being >LDed.

    I assume you mean "{new prologue}". -- YES YES

    And you assume that the next call also makes use of many callee-saved registers.

    Sure, setting up the scenario.

    The predictive mechanics to determine that the new epilogue is storing
    bit patterns that are already in those memory locations is "non trivial" >for RISC-V but trivial for EXIT-CALL-ENTER.

    Are the same registers saved to the same places? If that is a common occurence (I don't think so), recognizing and optimizing it in
    hardware (probably in the renamer) looks doable.

    My 66000 ABI (and SBI) both operate that way. ENTER saves registers
    where higher register numbers are stored at higher memory locations.

    {For most leaf functions;
    there is only RET with no preserved register restoration and no EXIT}.

    If you need so many registers that you also use callee-saved
    registers, the callee also saves them when the callee is a leaf
    function.

    No, of course not. Leaf functions (93%) save no registers at all as they perform their duties in the freely-available temporary registers R0..15

    Of course, for values that do not live across a call
    (i.e. all values in a leaf function), caller-saved registers are the
    first pick.

    So, the question, here, boils down to: "How many cycles does it take
    DECODE to 'process' 16-LDDs in a row". Even a 10-wide machine may only
    have 4 LD/MEM FUs, so it would take 4-odd cycles to push LDDs through >DECODE

    I would not know why a 10-wide decoder would not decode 10 loads per
    cycle. Likewise for the renamer. Then the schedulers may be more
    limited, but if so, and having loads and stores in large bunches is
    common, a competent designer will insert some buffering capacity to
    avoid congesting the front end.

    and at cycle 2 one could be able to predict RET--whereas My
    66000 can predict {with 100% confidence} 2-cycles earlier.

    You mean, it can resolve the prediction two cycles earlier. Given
    that return stack prediction is very accurate, the benefit might be
    that one can use a smaller ROB, if the prediction of return was the
    only reason for having a large ROB. But I think that other reasons
    for having a large ROB (such as conditional branches, or cache misses)
    stull persist and are actually more important.

    - anton
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.arch on Sat Oct 31 08:13:42 2026
    From Newsgroup: comp.arch

    MitchAlsup <user5857@newsgrouper.org.invalid> writes: >anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:

    MitchAlsup <user5857@newsgrouper.org.invalid> writes:
    anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
    In a modern
    (post-1995, with a few exceptions, most of which have died out in the
    meantime) processor the front end predicts the return from the
    processor-internal return stack and often starts fetching from there
    before the load-store unit sees the load of the return address. The
    return address is then used to validate the branch prediction and
    retire the return instruction.

    You can't predict until you are within <about> 2-fetch cycles of the
    instruction you are going to make a prediction about {RET here}.

    Predictors can make predictions about anything. But given that it is
    only useful to make predictions that are actually used, they will only
    predict the next few I-cache lines to be fetched, so yes, predicting a
    few fetch lines ahead could be common.

    How many? Depends on the latency of the I-cache. Given that it is
    typically similar in size to the D-cache, it's latency will also be
    similar, i.e., around 4 cycles.

    How many cache lines are fetched per cycle? With a 10-wide front end,
    you probably do not want to underutilize the rest of the front end if
    there is a taken branch or there is a branch to a target less than 10
    instructions from the end of the cache line, so better fetch two cache
    lines per cycle.

    A cache line contains 16 instructions, so one would assume a partial
    line is held over (to the next decode cycle) and one makes 1 fetch
    in the sequential direction and 1 fetch to another predicted address.

    With this design the rest of the front end would not be fully utilized
    if there are is more than on taken branch per n instructions (where n
    is the decode width). With 10-wide designs, that's restrictive. I
    have programs here that have more than 1 taken branch on 10
    instructions:

    perf stat -e instructions:u -e br_inst_retired.near_taken:u ./magichex 3 2
    ...
    143280237 instructions:u
    16156505 br_inst_retired.near_taken:u

    That's 8.9 instructions per taken branch.

    perf stat -e instructions:u -e br_inst_retired.near_taken:u gforth-fast --no-dynamic onebench.fs
    4249141031 instructions:u
    661631554 br_inst_retired.near_taken:u

    That's 6.4 instructions per taken branch.

    Although, admittedly, in the last case if we take the "--no-dynamic"
    away, this reduces the number of taken branches more than the number
    of instructions, resulting in more than 10 instructions per taken
    branch:

    2026987196 instructions:u
    175323098 br_inst_retired.near_taken:u

    But it uses dynamic native-code generation, which you have poo-pooed
    as "self-modifying code", so presumably My 66000 will have to fall
    back to --no-dynamic and will have to take at least 661M cycles for
    this benchmark if it can only deal with one taken branch per cycle,
    whereas even a lowly Darkmont (Core Ultra 225 E-Core) can run this
    benchmark on 440M cycles.

    I have numerous examples of RISC-V (LLVM -O3) having 13 STs in prologue
    and 13 LDs in epilogue. The distribution (excepting for leaf functions
    (0 saved) and director functions (1 saved) is basically a Bell Curve
    from 2->13.)

    It's interesting that you have numerous examples of needing 13
    callee-saved registers for non-leaf functions, but apparently the 16 caller-saved registers are enough for the leaf functions; i.e., there
    is not a single leaf function that needs more than 16 registers (the
    number of caller-saved registers in the RISC-V ABI).

    It does not
    need to decode the return instruction to predict it, it just needs to
    predict that there will be a return, and then use the hardware return
    stack to make the prediction.

    Maybe predictors have gotten that good.

    They have to. You cannot afford to wait to decode a branch before
    starting to predict it when you need to be able to deal with 1-2 taken
    branches per cycle. If you wait for the fetch and the decode before
    starting to predict, you will see at most 1 taken branch every n
    cycles, where n=fetch_latency+decode_latency+predictor_latency, i.e.,
    5 cycles on a modern CPU, possibly more like 10 cycles. With one
    taken branch every 10 instructions or so, this would limit your IPC to
    1-2, and much of the 10-wide design would starve.

    No, of course not. Leaf functions (93%) save no registers at all as they >perform their duties in the freely-available temporary registers R0..15

    If a leaf function needs more GPRs, it use callee-saved registers, and
    will save them in the prologue and load them in the epilogue.

    - 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 Sat Oct 31 18:22:32 2026
    From Newsgroup: comp.arch

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

    MitchAlsup <user5857@newsgrouper.org.invalid> writes: >anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:

    MitchAlsup <user5857@newsgrouper.org.invalid> writes:
    anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
    In a modern
    (post-1995, with a few exceptions, most of which have died out in the >> >> meantime) processor the front end predicts the return from the
    processor-internal return stack and often starts fetching from there
    before the load-store unit sees the load of the return address. The
    return address is then used to validate the branch prediction and
    retire the return instruction.

    You can't predict until you are within <about> 2-fetch cycles of the
    instruction you are going to make a prediction about {RET here}.

    Predictors can make predictions about anything. But given that it is
    only useful to make predictions that are actually used, they will only
    predict the next few I-cache lines to be fetched, so yes, predicting a
    few fetch lines ahead could be common.

    How many? Depends on the latency of the I-cache. Given that it is
    typically similar in size to the D-cache, it's latency will also be
    similar, i.e., around 4 cycles.

    How many cache lines are fetched per cycle? With a 10-wide front end,
    you probably do not want to underutilize the rest of the front end if
    there is a taken branch or there is a branch to a target less than 10
    instructions from the end of the cache line, so better fetch two cache
    lines per cycle.

    A cache line contains 16 instructions, so one would assume a partial
    line is held over (to the next decode cycle) and one makes 1 fetch
    in the sequential direction and 1 fetch to another predicted address.

    With this design the rest of the front end would not be fully utilized
    if there are is more than on taken branch per n instructions (where n
    is the decode width). With 10-wide designs, that's restrictive.

    Remember, I am only shooting at a 6-wide machine. and for 6-wide, 1-
    prediction per cycle is not very restrictive. Also note: I have
    conditional PREDicates which take 20% of front-end-redirects away.

    K9 was 8-wide and we did have 2-predictions per cycle to deal with.

    I have programs here that have more than 1 taken branch on 10
    instructions:

    perf stat -e instructions:u -e br_inst_retired.near_taken:u ./magichex 3 2 ...
    143280237 instructions:u
    16156505 br_inst_retired.near_taken:u

    That's 8.9 instructions per taken branch.

    My statistics are low 9.x inst per taken branch.

    perf stat -e instructions:u -e br_inst_retired.near_taken:u gforth-fast --no-dynamic onebench.fs
    4249141031 instructions:u
    661631554 br_inst_retired.near_taken:u

    That's 6.4 instructions per taken branch.

    Although, admittedly, in the last case if we take the "--no-dynamic"
    away, this reduces the number of taken branches more than the number
    of instructions, resulting in more than 10 instructions per taken
    branch:

    2026987196 instructions:u
    175323098 br_inst_retired.near_taken:u

    But it uses dynamic native-code generation, which you have poo-pooed
    as "self-modifying code",

    I have indeed.

    so presumably My 66000 will have to fall
    back to --no-dynamic and will have to take at least 661M cycles for
    this benchmark if it can only deal with one taken branch per cycle,
    whereas even a lowly Darkmont (Core Ultra 225 E-Core) can run this
    benchmark on 440M cycles.

    If --no-dynamic has to do with dynamically loaded libraries, ABI
    allows for them via GOT (without PLT saving a branch in the process).

    I have numerous examples of RISC-V (LLVM -O3) having 13 STs in prologue
    and 13 LDs in epilogue. The distribution (excepting for leaf functions
    (0 saved) and director functions (1 saved) is basically a Bell Curve
    from 2->13.)

    It's interesting that you have numerous examples of needing 13
    callee-saved registers for non-leaf functions, but apparently the 16 caller-saved registers are enough for the leaf functions; i.e., there
    is not a single leaf function that needs more than 16 registers (the
    number of caller-saved registers in the RISC-V ABI).

    There are leaf functions which need more than 16 registers--where did I
    imply otherwise--there are "just not many".

    It does not
    need to decode the return instruction to predict it, it just needs to
    predict that there will be a return, and then use the hardware return
    stack to make the prediction.

    Maybe predictors have gotten that good.

    They have to. You cannot afford to wait to decode a branch before
    starting to predict it when you need to be able to deal with 1-2 taken branches per cycle.

    Which is why we built the packet cache for Mc 88120 and a trace cache
    for K9. Mc 88120 could take all conditional branches per cycle and 1 conditional branch per cycle. K9 could take all unconditional and 2
    conditional branches per cycle.

    If you wait for the fetch and the decode before
    starting to predict, you will see at most 1 taken branch every n
    cycles, where n=fetch_latency+decode_latency+predictor_latency, i.e.,

    I see fetch-latency running concurrently with predictor-latency.
    I do not see DECODE-latency getting in the way.

    5 cycles on a modern CPU, possibly more like 10 cycles. With one
    taken branch every 10 instructions or so, this would limit your IPC to
    1-2, and much of the 10-wide design would starve.

    Fetching as described above, and with annotation as above; I don't
    see a problem feeding DECODE with 6-instructions per cycle. Remember
    that 10-wide machine is only retiring 3 I/c.

    No, of course not. Leaf functions (93%) save no registers at all as they >perform their duties in the freely-available temporary registers R0..15

    If a leaf function needs more GPRs, it use callee-saved registers, and
    will save them in the prologue and load them in the epilogue.

    Captain Obvious strikes again.

    - anton
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.arch on Sat Oct 31 19:15:46 2026
    From Newsgroup: comp.arch

    MitchAlsup <user5857@newsgrouper.org.invalid> writes: >anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
    if we take the "--no-dynamic" away
    ...
    But it uses dynamic native-code generation, which you have poo-pooed
    as "self-modifying code",

    I have indeed.

    If --no-dynamic has to do with dynamically loaded libraries, ABI
    allows for them via GOT (without PLT saving a branch in the process).

    No, --no-dynamic falls back to using a threaded-code interpreter,
    while --dynamic (default) uses native code generated at run-time (what
    you call "self-modifying code" and want to disable; other people call
    it "JIT compilation").

    There are leaf functions which need more than 16 registers--where did I
    imply otherwise--there are "just not many".

    Here:
    Leaf functions (93%) save no registers at all as they
    perform their duties in the freely-available temporary registers R0..15

    Remember
    that 10-wide machine is only retiring 3 I/c.

    I regularly see programs with >3IPC on 5-wide, 6-wide and 8-wide
    machines. E.g., for "gforth-fast onebench.fs" mentioned above on a
    Darkmont (Core Ultra 225 E-Core).

    424_922_809 cpu_atom/cycles:u/
    2_044_802_828 cpu_atom/instructions:u/ # 4.81 insn per cycle

    A few weeks ago <2026Sep21.171615@mips.complang.tuwien.ac.at> I
    reported measuring 6.75 IPC on a Rocket Lake, which is usually
    considered to be 5-wide, and with reason (only 5 renamer slots etc.).
    Here we see 7 IPC in a loop because the loop contains two cmp+branch combinations, which consume only one slot in the path from the
    microcode cache through the renamer to the schedulers. Both branches
    are taken in the measured loop, i.e., 1 taken branch every 3.5
    instructions.

    - 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 Sat Oct 31 20:44:17 2026
    From Newsgroup: comp.arch

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

    MitchAlsup <user5857@newsgrouper.org.invalid> writes: >anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
    if we take the "--no-dynamic" away
    ...
    But it uses dynamic native-code generation, which you have poo-pooed
    as "self-modifying code",

    I have indeed.

    If --no-dynamic has to do with dynamically loaded libraries, ABI
    allows for them via GOT (without PLT saving a branch in the process).

    No, --no-dynamic falls back to using a threaded-code interpreter,
    while --dynamic (default) uses native code generated at run-time (what
    you call "self-modifying code" and want to disable; other people call
    it "JIT compilation").

    There are leaf functions which need more than 16 registers--where did I >imply otherwise--there are "just not many".

    Here:
    Leaf functions (93%) save no registers at all as they
    perform their duties in the freely-available temporary registers R0..15

    Remember
    that 10-wide machine is only retiring 3 I/c.

    I regularly see programs with >3IPC on 5-wide, 6-wide and 8-wide
    machines. E.g., for "gforth-fast onebench.fs" mentioned above on a
    Darkmont (Core Ultra 225 E-Core).

    424_922_809 cpu_atom/cycles:u/
    2_044_802_828 cpu_atom/instructions:u/ # 4.81 insn per cycle

    A few weeks ago <2026Sep21.171615@mips.complang.tuwien.ac.at> I
    reported measuring 6.75 IPC on a Rocket Lake, which is usually
    considered to be 5-wide, and with reason (only 5 renamer slots etc.).
    Here we see 7 IPC in a loop because the loop contains two cmp+branch combinations, which consume only one slot in the path from the
    microcode cache through the renamer to the schedulers. Both branches
    are taken in the measured loop, i.e., 1 taken branch every 3.5
    instructions.

    I see similar (at a smaller scale) when my cores perform CoIssue
    (similar to instruction fusing, but designed to leverage RF ports
    across instructions. A CoIssued instruction requires no more RF
    ports or rename ports than any 'random' instruction can use.

    Since STs do not write to RF, STs can be CoIssued with any following calculation instruction (or branch instruction).

    Since conditional Branch instructions do not write RF, they can be
    CoIssued with previous calculation instruction.

    STs and <conditional> branches make up 30%-odd of instruction stream:
    so, the decoder looks to be processing 1.3 I/c in a 1-wide implementa-
    tion.

    There are other potentials--but since this is not close to RISC-V's
    instruction fusing, I had to use a different word.

    - anton
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From antispam@antispam@fricas.org (Waldek Hebisch) to comp.arch on Sat Nov 7 16:21:00 2026
    From Newsgroup: comp.arch

    Anton Ertl <anton@mips.complang.tuwien.ac.at> wrote:
    MitchAlsup <user5857@newsgrouper.org.invalid> writes:
    anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
    There is a third issue: Do you pass arguments in the register windows,
    or in what SPARC calls global registers? AFAIK SPARC chose to pass
    them in windows, but that means that a call sequence like

    int foo(a,b)
    {
    ...
    bar(a,b);
    ...
    }

    It gets worse when::

    type foo( a, b ){
    ...
    return bar( a, b );
    ...
    }

    Now you have to copy forward foo->bar and copy bar's return back
    as foo's return.

    No, it's a tail-call. You just jump to bar without saving or
    restoring a register window.

    My 66000 takes advantage of this by LDing the Ret Addr first, and then >>reLDing the rest of the file, so by the time that is done, FETCH already >>has instructions for DECODE>

    I get the impression that My 66000 lives in 1994. In a modern
    (post-1995, with a few exceptions, most of which have died out in the meantime) processor the front end predicts the return from the processor-internal return stack and often starts fetching from there
    before the load-store unit sees the load of the return address. The
    return address is then used to validate the branch prediction and
    retire the return instruction.

    It must be more complex. Silly fibonacci benchmark shows average
    performance of function call per 2 clocks. Given length of
    the pipeline return address is pushed too late to use it for
    fetching intructions after return. In other words, return
    must be predicted before the call starts executing.
    --
    Waldek Hebisch
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.arch on Sat Nov 7 18:01:41 2026
    From Newsgroup: comp.arch

    antispam@fricas.org (Waldek Hebisch) writes:
    Anton Ertl <anton@mips.complang.tuwien.ac.at> wrote:
    In a modern
    (post-1995, with a few exceptions, most of which have died out in the
    meantime) processor the front end predicts the return from the
    processor-internal return stack and often starts fetching from there
    before the load-store unit sees the load of the return address. The
    return address is then used to validate the branch prediction and
    retire the return instruction.

    It must be more complex. Silly fibonacci benchmark shows average
    performance of function call per 2 clocks.

    Without inlining? On what hardware?

    What I see on a Rocket Lake with a Fibonacci program compiled by the
    Rust 1.89 compiler is 3.6 cycles per return (i.e., also per call, with
    2.3 branches per return). I have not looked at the code to see if
    there is any inlining, but given that a regular fibonacci call
    includes a call, a conditional branch, and a return (with any
    recursive call accounted separately), showing 2.3 branches indicates
    that there is at least some inlining going on here.

    Given length of
    the pipeline return address is pushed too late to use it for
    fetching intructions after return. In other words, return
    must be predicted before the call starts executing.

    Certainly. Modern branch predictors have to trigger on addresses, not
    on the results of fetches. But if a microarchitecture really does a non-inlined fibonacci program at two cycles per call, even more
    prediction has to be done: In the base case (half of the calls) the
    push to the return address stack is followed by a pull from the return
    address stack, and all of that and the prediction based on the return
    address must happen in two cycles. Or maybe there is some special
    fast path for such cases.

    What the microarchitects do in the branch predictors is certainly
    amazing.

    - 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 antispam@antispam@fricas.org (Waldek Hebisch) to comp.arch on Sun Nov 8 04:37:34 2026
    From Newsgroup: comp.arch

    Anton Ertl <anton@mips.complang.tuwien.ac.at> wrote:
    antispam@fricas.org (Waldek Hebisch) writes:
    Anton Ertl <anton@mips.complang.tuwien.ac.at> wrote:
    In a modern
    (post-1995, with a few exceptions, most of which have died out in the
    meantime) processor the front end predicts the return from the
    processor-internal return stack and often starts fetching from there
    before the load-store unit sees the load of the return address. The
    return address is then used to validate the branch prediction and
    retire the return instruction.

    It must be more complex. Silly fibonacci benchmark shows average >>performance of function call per 2 clocks.

    Without inlining? On what hardware?

    What I see on a Rocket Lake with a Fibonacci program compiled by the
    Rust 1.89 compiler is 3.6 cycles per return (i.e., also per call, with
    2.3 branches per return). I have not looked at the code to see if
    there is any inlining, but given that a regular fibonacci call
    includes a call, a conditional branch, and a return (with any
    recursive call accounted separately), showing 2.3 branches indicates
    that there is at least some inlining going on here.

    A little correction. This is on AMD Ryzen 9 7900 with claims
    3.0 GHz clock. But perf says that benchmark run at 5.310 GHz,
    so number of clocks is larger. I used two versions, one produced
    by gcc -O which in assembly is:

    fib:
    movq %rdi, %rax
    cmpq $1, %rdi
    jle .L5
    pushq %rbp
    pushq %rbx
    subq $8, %rsp
    movq %rdi, %rbx
    leaq -1(%rdi), %rdi
    call fib
    movq %rax, %rbp
    leaq -2(%rbx), %rdi
    call fib

    So performs all expected calls. This one needs 4.6 cycles
    per call. The other is generated by the perl program below.
    Generated code contains only calls and returns, for each
    n there is separate function. Call structure is exactly the
    same as when computing fibonacci. This one needs 4.01
    cycles per call. For comparison, version which replaces
    final call and ret by jump (corresponding to tail call
    elimination) needs 2.43 clocks per "call".

    -----------<cut here>---------------
    print << 'EOD1';
    .file "fib3c.pl"

    EOD1

    my($j);

    for($j = 2; $j < 50; $j++) {
    my($k) = $j - 1;
    my($l) = $j - 2;
    print << "EOD2";
    .globl fib$j
    .type fib$j, \@function
    fib$j:
    call fib$k
    call fib$l
    ret
    .size fib$j, .-fib$j
    EOD2
    }
    -----------<cut here>---------------
    --
    Waldek Hebisch
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From Lawrence =?iso-8859-13?q?D=FFOliveiro?=@ldo@nz.invalid to comp.arch on Sun Nov 8 04:49:12 2026
    From Newsgroup: comp.arch

    On Sun, 8 Nov 2026 04:37:34 -0000 (UTC), Waldek Hebisch wrote:

    for($j = 2; $j < 50; $j++) {
    my($k) = $j - 1;
    my($l) = $j - 2;
    print << "EOD2";
    .globl fib$j
    .type fib$j, \@function
    fib$j:
    call fib$k
    call fib$l

    ShouldnrCOt there be a rCLfib0rCY somewhere?
    --- Synchronet 3.22a-Linux NewsLink 1.2
  • From anton@anton@mips.complang.tuwien.ac.at (Anton Ertl) to comp.arch on Sun Nov 8 06:33:01 2026
    From Newsgroup: comp.arch

    antispam@fricas.org (Waldek Hebisch) writes:
    The other is generated by the perl program below.
    Generated code contains only calls and returns

    Which reminded me that I also have a microbenchmark that performs
    calls to empty functions: 9 such calls to 5 different empty functions
    in a row, and then a call to a function that does a little more than
    nothing (including a conditional branch), then a jump back. The
    overall instruction count is 2.7 per call on AMD64. And I have
    results for that for a variety of microarchitectures. You find the
    results at the first column of <https://www.complang.tuwien.ac.at/forth/threading/>. See below for
    your code.

    In terms of cycles, Lion Cove (Core Ultra 225 P-core) is remarkable:
    it takes just one cycle per call-return pair. Here the
    microarchitecture clearly is doing miraculous things; maybe inlining
    in the microcode cache?

    Next, we have the Cortex-A76 with 2.24 cycles per call. Given the
    clock rate of the Cortex-A76, it is plausible that it manages to push
    something on the return-address stack in one cycle and pull it from
    the return-address stack and use it for prediction in the next cycle.

    Next, we have the Goldmont (predecessor to the present Intel E-cores)
    with 2.88 cycles per call. Similar considerations apply as for the
    Cortex-A76. What is interesting here is that the next
    microarchitecture in this family, the Goldmont+, shows a much worse
    result for this microbenchmark; this continues with further family
    members Tremont and Gracemont, until finally Skymont gets down to 3.51
    cycles. My guess is that a big redesign of the branch predictor
    happened in the Goldmont+ (compare also the, e.g., direct columns for
    these processors), and the case "return from a very recent call"
    became a victim of the redesign, and was only optimized again in
    Skymont.

    -----------<cut here>---------------
    print << 'EOD1';
    .file "fib3c.pl"

    EOD1

    my($j);

    for($j = 2; $j < 50; $j++) {
    my($k) = $j - 1;
    my($l) = $j - 2;
    print << "EOD2";
    .globl fib$j
    .type fib$j, \@function
    fib$j:
    call fib$k
    call fib$l
    ret
    .size fib$j, .-fib$j
    EOD2
    }
    -----------<cut here>---------------

    I completed this as follows:

    A C program fib.c with the following source code:

    ----------------
    extern void fib49();

    int main()
    {
    fib49();
    return 0;
    }

    void fib1()
    {
    }

    void fib0()
    {
    }
    --------------------

    And build and run the whole thing as follows:

    perl fib3c.pl >fib.s
    gcc -Wall -O fib.c fib.s -o fib
    taskset -c 1 perf stat -c cycles:u -e instructions:u fib

    fib benchmark executes 50_345_190_769 instructions, i.e., about
    25_172_595_384 calls.

    The Lion Cove takes 61_452_053_514 cycles, i.e., 2.44 cycles per call.
    If half of the calls take 1 cycle (as seen in the subroutine
    microbenchmark), the other half (which contains a call) take 3.88
    cycles on average. Or maybe the limited depth of the return-address
    stack plays a role. There are 6_448_145 branch mispredictions
    reported, which are likely the result of the limited depth of the return-address stack. These mispredictions would typically account
    for ~130M cycles, i.e, only 0.2% of the total cycles. So the major
    aspect seems to be how fast the handling of the return-address stack
    works, and possible limitations of the optimization that produced the miraculous 1 cycle/call on subroutine.

    The Skymont takes 376_693_549_679 cycles, i.e., 14.96 cycles per call.
    This is high, whatever the explanation is. The number of branch
    mispredictions is reported as 7_511, so either the return-address
    stack is more than 40 or so deep or mispredictions from returns are
    not counted on Skymont.

    In any case, fib3 tests things that subroutine does not test.

    - 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 antispam@antispam@fricas.org (Waldek Hebisch) to comp.arch on Sun Nov 8 14:19:40 2026
    From Newsgroup: comp.arch

    Lawrence DrCOOliveiro <ldo@nz.invalid> wrote:
    On Sun, 8 Nov 2026 04:37:34 -0000 (UTC), Waldek Hebisch wrote:

    for($j = 2; $j < 50; $j++) {
    my($k) = $j - 1;
    my($l) = $j - 2;
    print << "EOD2";
    .globl fib$j
    .type fib$j, \@function
    fib$j:
    call fib$k
    call fib$l

    ShouldnrCOt there be a rCLfib0rCY somewhere?

    Yes, you need 'fib0' and 'fib1'. You can add them as Anton did,
    or at assembly level just take single 'ret'.
    --
    Waldek Hebisch
    --- Synchronet 3.22a-Linux NewsLink 1.2