I tried asking the web-browser this and it returned a bunch of links to >introduction to vectors.
Am I right in thinking that the vector length and element size are
basically stable throughout an application?
If so, they can be stored in a config register.
Otherwise, if they need to be changeable on a dynamic
basis they would have to be processed like a GPR with renaming etc.
Updating a CSR is rather slow as updates do not take place until commit >time.
ATM the config is just wired directly into the micro-op translate stage >which would have really poor performance if things need to be modified
on the fly.
I looked at the RISCV vector extension model and they have it just as a
CSR. Makes me think that is an acceptable solution.
On Sun, 8 Nov 2026 07:39:44 -0500, Robert Finch <robfi680@gmail.com>
wrote:
I tried asking the web-browser this and it returned a bunch of links to
introduction to vectors.
Am I right in thinking that the vector length and element size are
basically stable throughout an application?
Certainly not.
Element width may remain stable across many operations, but you can
expect that different widths may be needed at different times.
Vector lengths, however, often change frequently.
If so, they can be stored in a config register.
If you are referring to a separate (Cray style) vector processor, or
to a streaming unit, the width and length would be in setup registers
in any case.
Otherwise, if they need to be changeable on a dynamic
basis they would have to be processed like a GPR with renaming etc.
Updating a CSR is rather slow as updates do not take place until commit
time.
You can't change the setup while the vector unit is operating anyway. However, there is no reason changes can't be queued to happen as soon
as the unit is finished.
ATM the config is just wired directly into the micro-op translate stage
which would have really poor performance if things need to be modified
on the fly.
"On the fly" meaning what? You can't change the setup /while/ the
vector unit is in operation.
Needing to frequently change element widths and/or vector lengths is
the domain of the short-vector SIMD many chips now have.
I looked at the RISCV vector extension model and they have it just as a
CSR. Makes me think that is an acceptable solution.
It is for the case where the vector unit is separate and asynchronous.
I tried asking the web-browser this and it returned a bunch of links to introduction to vectors.
Am I right in thinking that the vector length and element size are
basically stable throughout an application?
If so, they can be stored in
a config register. Otherwise, if they need to be changeable on a dynamic basis they would have to be processed like a GPR with renaming etc.
Updating a CSR is rather slow as updates do not take place until commit time.
ATM the config is just wired directly into the micro-op translate stage which would have really poor performance if things need to be modified
on the fly.
I looked at the RISCV vector extension model and they have it just as a
CSR. Makes me think that is an acceptable solution.
Robert Finch <robfi680@gmail.com> posted:
I tried asking the web-browser this and it returned a bunch of links to
introduction to vectors.
Am I right in thinking that the vector length and element size are
basically stable throughout an application?
Consider Gaussian Elimination, the length of the loop goes down
by 1 every loop.
If so, they can be stored in
a config register. Otherwise, if they need to be changeable on a dynamic
basis they would have to be processed like a GPR with renaming etc.
Get ready to change them every entry to top-of-loop.
Most CRAY-like vector units have a length-this-time register that
is decremented by vector-register-length every vector-iteration.
On the last iteration, it is used to create a mask of elements
that are not going to be calculated.
Updating a CSR is rather slow as updates do not take place until commit
time.
ATM the config is just wired directly into the micro-op translate stage
which would have really poor performance if things need to be modified
on the fly.
I looked at the RISCV vector extension model and they have it just as a
CSR. Makes me think that is an acceptable solution.
It can be, so long as it performs decrement-by-vector-length all
by itself ...
On 2026-11-08 9:02 a.m., George Neuner wrote:
On Sun, 8 Nov 2026 07:39:44 -0500, Robert Finch <robfi680@gmail.com>Ugh.
wrote:
I tried asking the web-browser this and it returned a bunch of links to
introduction to vectors.
Am I right in thinking that the vector length and element size are
basically stable throughout an application?
Certainly not.
Element width may remain stable across many operations, but you can
expect that different widths may be needed at different times.
Vector lengths, however, often change frequently.
If so, they can be stored in a config register.
If you are referring to a separate (Cray style) vector processor, or
to a streaming unit, the width and length would be in setup registers
in any case.
Otherwise, if they need to be changeable on a dynamic
basis they would have to be processed like a GPR with renaming etc.
Updating a CSR is rather slow as updates do not take place until commit
time.
You can't change the setup while the vector unit is operating anyway.
However, there is no reason changes can't be queued to happen as soon
as the unit is finished.
ATM the config is just wired directly into the micro-op translate stage
which would have really poor performance if things need to be modified
on the fly.
"On the fly" meaning what?-a You can't change the setup /while/ the
vector unit is in operation.
Needing to frequently change element widths and/or vector lengths is
the domain of the short-vector SIMD many chips now have.
I looked at the RISCV vector extension model and they have it just as a
CSR. Makes me think that is an acceptable solution.
It is for the case where the vector unit is separate and asynchronous.
I did not realize that was the use case for RISCV.
Brain dump design issues. Qupls is not going to have a separate asynchronous vector unit. Vectors are supported using the GPR register file by hiding the issuing of multiple instructions behind the scenes and relying on parallelism in the OoO design.
How vectors are supported in Qupls may need re-thinking. The vector length is being used to set the number of 64-bit registers needed to represent a vector at the micro-op encoding stage, before the register file is read. That cannot be done ff the length has to change frequently.-a Using a fixed number of registers might be better. For frequent changes the config would end up being passed around as another operand to vector instructions. Making the core larger = slower.
It is a toss-up I think. Using a fixed number of registers will occupy more execution units, mean more micro-ops will be fetched and dispatched and slow things down. On the other hand waiting 20 cycles or so for the length changes to percolate through the pipeline is not fast either.
May have both static length settings and dynamic length settings then. Using the static setting to set a maximum before the app is running and using dynamic lengths while executing code. Static length would set the number of micro-ops needed per vector instruction. Dynamic length would set the vector masking.
Maybe too complex to understand, having two different length settings.
Vector masking could be used to control the vector length dynamically. Rather than change the vector length, change the masking.
On 2026-11-08 9:02 a.m., George Neuner wrote:
On Sun, 8 Nov 2026 07:39:44 -0500, Robert Finch <robfi680@gmail.com>Ugh.
wrote:
I tried asking the web-browser this and it returned a bunch of links to
introduction to vectors.
Am I right in thinking that the vector length and element size are
basically stable throughout an application?
Certainly not.
Element width may remain stable across many operations, but you can
expect that different widths may be needed at different times.
Vector lengths, however, often change frequently.
If so, they can be stored in a config register.
If you are referring to a separate (Cray style) vector processor, or
to a streaming unit, the width and length would be in setup registers
in any case.
Otherwise, if they need to be changeable on a dynamic
basis they would have to be processed like a GPR with renaming etc.
Updating a CSR is rather slow as updates do not take place until commit
time.
You can't change the setup while the vector unit is operating anyway.
However, there is no reason changes can't be queued to happen as soon
as the unit is finished.
ATM the config is just wired directly into the micro-op translate stage
which would have really poor performance if things need to be modified
on the fly.
"On the fly" meaning what? You can't change the setup /while/ the
vector unit is in operation.
Needing to frequently change element widths and/or vector lengths is
the domain of the short-vector SIMD many chips now have.
I looked at the RISCV vector extension model and they have it just as a
CSR. Makes me think that is an acceptable solution.
It is for the case where the vector unit is separate and asynchronous.
I did not realize that was the use case for RISCV.
Brain dump design issues. Qupls is not going to have a separate
asynchronous vector unit. Vectors are supported using the GPR register
file by hiding the issuing of multiple instructions behind the scenes
and relying on parallelism in the OoO design.
How vectors are supported in Qupls may need re-thinking. The vector
length is being used to set the number of 64-bit registers needed to >represent a vector at the micro-op encoding stage, before the register
file is read. That cannot be done ff the length has to change
frequently. Using a fixed number of registers might be better. For
frequent changes the config would end up being passed around as another >operand to vector instructions. Making the core larger = slower.
It is a toss-up I think. Using a fixed number of registers will occupy
more execution units, mean more micro-ops will be fetched and dispatched
and slow things down. On the other hand waiting 20 cycles or so for the >length changes to percolate through the pipeline is not fast either.
May have both static length settings and dynamic length settings then.
Using the static setting to set a maximum before the app is running and >using dynamic lengths while executing code. Static length would set the >number of micro-ops needed per vector instruction. Dynamic length would
set the vector masking.
Maybe too complex to understand, having two different length settings.
Vector masking could be used to control the vector length dynamically. >Rather than change the vector length, change the masking.
I looked at the RISCV vector extension model and they have it just
as a CSR. Makes me think that is an acceptable solution.
On Sun, 8 Nov 2026 07:39:44 -0500, Robert Finch wrote:
I looked at the RISCV vector extension model and they have it just
as a CSR. Makes me think that is an acceptable solution.
RISC-V is going against the prevailing fashion on this. Most other CPU architectures in common use implement loads of SIMD instructions with
fixed vector lengths that are typically quite short: e.g. 4 or 8
elements. The reason why you need loads of different instructions is
because you want to cover all the possible combinations of operand
types that a programmer might find useful.
The RISC-V designers quite rightly criticize this combinatorial
explosion of instruction variants as going completely against the
whole idea of a *reduced* instruction set computer (which is what
rCLRISCrCY is supposed to stand for).
On Sun, 8 Nov 2026 10:03:01 -0500, Robert Finch <robfi680@gmail.com>
wrote:
On 2026-11-08 9:02 a.m., George Neuner wrote:
On Sun, 8 Nov 2026 07:39:44 -0500, Robert Finch <robfi680@gmail.com>Ugh.
wrote:
I tried asking the web-browser this and it returned a bunch of links to >>>> introduction to vectors.
Am I right in thinking that the vector length and element size are
basically stable throughout an application?
Certainly not.
Element width may remain stable across many operations, but you can
expect that different widths may be needed at different times.
Vector lengths, however, often change frequently.
If so, they can be stored in a config register.
If you are referring to a separate (Cray style) vector processor, or
to a streaming unit, the width and length would be in setup registers
in any case.
Otherwise, if they need to be changeable on a dynamic
basis they would have to be processed like a GPR with renaming etc.
Updating a CSR is rather slow as updates do not take place until commit >>>> time.
You can't change the setup while the vector unit is operating anyway.
However, there is no reason changes can't be queued to happen as soon
as the unit is finished.
ATM the config is just wired directly into the micro-op translate stage >>>> which would have really poor performance if things need to be modified >>>> on the fly.
"On the fly" meaning what? You can't change the setup /while/ the
vector unit is in operation.
Needing to frequently change element widths and/or vector lengths is
the domain of the short-vector SIMD many chips now have.
I looked at the RISCV vector extension model and they have it just as a >>>> CSR. Makes me think that is an acceptable solution.
It is for the case where the vector unit is separate and asynchronous.
I did not realize that was the use case for RISCV.
I don't know anything about RISCV ... I was speaking generally.
Any unit might have (hidden) control registers that need to be set for
a particular operation to be performed. In fact, most do.
The reason to have /visible/ setup registers is to allow for
operations that run asynchronously and automatically. Generally you
need at least to describe the input and what to do if there is an
error ... typically much more information than can be packed into a
CPU instruction.
E.g., consider a DMA transfer: source address, target address,
transfer width, transfer count.
Ok, /maybe/ that's a 4 source instruction, but more likely it is 4
mmap registers on your DMA unit that have to be set.
Or if your DMA unit allows chaining, you construct a linked list or
vector of parameter blocks in RAM, then set registers to point the
unit to the head of the chain and (if a vector) to tell it how many
blocks.
Brain dump design issues. Qupls is not going to have a separate
asynchronous vector unit. Vectors are supported using the GPR register
file by hiding the issuing of multiple instructions behind the scenes
and relying on parallelism in the OoO design.
How vectors are supported in Qupls may need re-thinking. The vector
length is being used to set the number of 64-bit registers needed to
represent a vector at the micro-op encoding stage, before the register
file is read. That cannot be done ff the length has to change
frequently. Using a fixed number of registers might be better. For
frequent changes the config would end up being passed around as another
operand to vector instructions. Making the core larger = slower.
It is a toss-up I think. Using a fixed number of registers will occupy
more execution units, mean more micro-ops will be fetched and dispatched
and slow things down. On the other hand waiting 20 cycles or so for the
length changes to percolate through the pipeline is not fast either.
May have both static length settings and dynamic length settings then.
Using the static setting to set a maximum before the app is running and
using dynamic lengths while executing code. Static length would set the
number of micro-ops needed per vector instruction. Dynamic length would
set the vector masking.
Maybe too complex to understand, having two different length settings.
Vector masking could be used to control the vector length dynamically.
Rather than change the vector length, change the masking.
Note that I'm primarily a software person. And I don't know anything
about your particular design. My own musings follow. Feel free to
ignore them as I only can consider the problem from the POV of using
the CPU.
I understand that you want to stream vectors through your CPU, using
your general registers to do the processing. Sounds similar to what
Mitch is trying to achieve with his "My 66000".
Depending on how many sources (args) per instruction, and whether you
have only reg->reg or memory loadops, and whether you have full length instruction constants, it seems that vector operations are going to
require 1 to 3 registers per element.
[If you can fix the number of registers per element, that will help.]
Regardless of how many registers (or names) you have, undoubtedly
there will be vectors that are too long to handle without looping, and
there will be vectors whose lengths are not integer multiples of
however many elements an iteration can do in parallel.
[You always can fall back on 1 element per iteration.]
The question is how smart you want your CPU to be.
With vector lengths known at compile time, the compiler can unroll the
loop to figure out how many iterations of N elements, and handle
remaining (< N) elements separately. This requires no vector specific
smarts in your CPU.
If you want to do the moral equivalent of unrolling at runtime ...
well that's another thing altogether. I confess that I don't fully understand what Mitch is doing, and from your comments above I get the
idea that you really don't yet know how you want to handle it.
Obviously, you will need to know how many registers are needed for one element - so unless you have some super loop instruction that
specifies that, you may have to parse the loop body. And you'll need
to know how many registers are available to use. You probably don't
want to have to spill things to make room, and you may find you need a
few registers for loop control: e.g., elements per/this iteration,
count of remaining elements, perhaps even a separate iteration count.
I don't really see how you'd use a vector mask. It would work for a contiguous vector register file, but since each element is represented
by a /group/ of GPRs that possibly are subject to discontiguous
renames, it seems better to predicate the loop body operations based
on whether they have something to do this iteration. That argues for
your dispatcher/sequencer to handle each element separately.
BTW: you didn't mention whether you are register renaming. I hope so,
because I can't see how you realistically could do runtime unrolling
without it.
That's all for now. I have to think about it some more.
George
On Sun, 8 Nov 2026 07:39:44 -0500, Robert Finch wrote:
I looked at the RISCV vector extension model and they have it just
as a CSR. Makes me think that is an acceptable solution.
RISC-V is going against the prevailing fashion on this. Most other CPU architectures in common use implement loads of SIMD instructions with
fixed vector lengths that are typically quite short: e.g. 4 or 8
elements. The reason why you need loads of different instructions is
because you want to cover all the possible combinations of operand
types that a programmer might find useful.
The RISC-V designers quite rightly criticize this combinatorial
explosion of instruction variants as going completely against the
whole idea of a *reduced* instruction set computer (which is what
rCLRISCrCY is supposed to stand for).
On 2026-11-08 7:01 p.m., Lawrence DrCOOliveiro wrote:
The RISC-V designers quite rightly criticize this combinatorial
explosion of instruction variants as going completely against the
whole idea of a *reduced* instruction set computer (which is what
rCLRISCrCY is supposed to stand for).
It is partly a representation issue. IDK how it would be avoided,
scratched my head over this one.
On Sun, 8 Nov 2026 23:11:46 -0500, Robert Finch wrote:
On 2026-11-08 7:01 p.m., Lawrence DrCOOliveiro wrote:
The RISC-V designers quite rightly criticize this combinatorial
explosion of instruction variants as going completely against the
whole idea of a *reduced* instruction set computer (which is what
rCLRISCrCY is supposed to stand for).
It is partly a representation issue. IDK how it would be avoided,
scratched my head over this one.
I think they do it by specifying the data type of the operands in
another control register.
RISC-V is going against the prevailing fashion on this. Most other CPU >architectures in common use implement loads of SIMD instructions with
fixed vector lengths that are typically quite short: e.g. 4 or 8
elements. The reason why you need loads of different instructions is
because you want to cover all the possible combinations of operand
types that a programmer might find useful.
The RISC-V designers quite rightly criticize this combinatorial
explosion of instruction variants as going completely against the
whole idea of a *reduced* instruction set computer (which is what
"RISC" is supposed to stand for).
On Mon, 9 Nov 2026 00:01:09 -0000 (UTC), Lawrence DrCOOliveiro wrote:
The RISC-V designers quite rightly criticize this combinatorial
explosion of instruction variants as going completely against the
whole idea of a *reduced* instruction set computer (which is what
"RISC" is supposed to stand for).
Given that Patterson (who coined the term RISC) never gave a
definition of RISC, how can one say that the combinatorial explosion
is right or wrong?
On Mon, 09 Nov 2026 06:13:02 GMT, Anton Ertl wrote:
Given that Patterson (who coined the term RISC) never gave a
definition of RISC, how can one say that the combinatorial explosion
is right or wrong?
It's in the name: "Reduced Instruction Set Computer"
Lawrence =?iso-8859-13?q?D=FFOliveiro?= <ldo@nz.invalid> writes:
RISC-V is going against the prevailing fashion on this. Most other CPU
architectures in common use implement loads of SIMD instructions with
fixed vector lengths that are typically quite short: e.g. 4 or 8
elements. The reason why you need loads of different instructions is
because you want to cover all the possible combinations of operand
types that a programmer might find useful.
The RISC-V designers quite rightly criticize this combinatorial
explosion of instruction variants as going completely against the
whole idea of a *reduced* instruction set computer (which is what
"RISC" is supposed to stand for).
Given that Patterson (who coined the term RISC) never gave a
definition of RISC, how can one say that the combinatorial explosion
is right or wrong?
John Mashey gave criteria for determining the RISC-ness of an
intruction set
<https://userpages.umbc.edu/~vijay/mashey.on.risc.html>, and I found
his arguments convincing (although I do not agree fully with all of
his criteria, in particular, not 3a-c, and 5a and consequently 5b).
The number of instructions is not one of the criteria he gave.
In particular, if we look at AVX and AVX-512 instructions,
1) The gather and scatter instructions are against RISC criteria
(Mashey criterion 4b), and on Skylake are slow, and already have
resulted in the Downfall vulnerability.
2) The load-and-operate variants of the instructions are against
Mashey's criterion 4a, and while other criteria (in particular
3a-3c) are not satisfied by all CPUs that are typically seen as
RISC, this criterion has been satisfied by all of them. One can
see the bad effects of the load-and-operate variants as well as the
bad effects of making the destination operand one of the sources
(not a Mashey criterion) in the FMA3 instructions, which come in
132, 213, and 231 variants depending on which source operand should
be overwritten and which should be in memory.
3) AVX and AVX-512 are part of AMD64, so naturally they do not satisfy
criteria 3a and 3b.
If you leave away the gather-and-scatter instructions, and the load-and-operate variants, and encode the rest to fit in 32 bits (and
leave room for the integer instruction set:-), and reduce the offset
of load/store instructions to make this possible, AVX-512 still has
hundreds, maybe thousands of instructions thanks to the combination of operations, types, lane (element) sizes, operation width, but
satisfies Masheys criteria.
The RISC-V designers may want to add the number of instructions as
another criterion, but I think they would be wrong. The advantages of
the RISC principles do not hinge on the number of instructions.
If they want to encode some of the "combinatorial explosion" stuff in registers that are implicitly used by the SIMD instructions, that's
actually against the trend in at least some of the RISCs, in
particular MIPS (with hi and lo as the exception that proves the rule)
and Alpha, and RISC-V without the vector stuff, to avoid implicit (and
thus single-instance) registers; this rule has shown its value in
particular when OoO was introduced (no need to rename the condition
codes).
One might have several registers containing the type and widths, and
refer to them in the instruction, and this would reduce the problems
of this approach a little. But a problem remains: Implementors want
to know the registers that the instruction operates on in the renamer,
and the type that they work on when entering the schedulers (not every microarchitecture has just one scheduler that covers everything), so
these informations need to be provided at the front end, and
instructions that change these registers need to be executed at the
front end, subverting OoO implementations.
There is a reason why we have encoded the instruction type and width
into scalar instructions, and this reason does not go away when it
comes to vector instructions. And just because this good practice
inreases the instruction count, does not make it a bad practice, even
if the result is a combinatorial explosion.
- anton
On Sun, 8 Nov 2026 10:03:01 -0500, Robert Finch <robfi680@gmail.com>
wrote:
I looked at the RISCV vector extension model and they have it just as a >>>> CSR. Makes me think that is an acceptable solution.
It is for the case where the vector unit is separate and asynchronous.
I did not realize that was the use case for RISCV.
I don't know anything about RISCV ... I was speaking generally.
Any unit might have (hidden) control registers that need to be set for
a particular operation to be performed. In fact, most do.
The reason to have /visible/ setup registers is to allow for
operations that run asynchronously and automatically. Generally you
need at least to describe the input and what to do if there is an
error ... typically much more information than can be packed into a
CPU instruction.
E.g., consider a DMA transfer: source address, target address,
transfer width, transfer count.
Ok, /maybe/ that's a 4 source instruction, but more likely it is 4
mmap registers on your DMA unit that have to be set.
On Sun, 8 Nov 2026 10:03:01 -0500, Robert Finch <robfi680@gmail.com>
wrote:
Vectors are supported using the GPR register
file by hiding the issuing of multiple instructions behind the scenes
and relying on parallelism in the OoO design.
How vectors are supported in Qupls may need re-thinking.
Note that I'm primarily a software person. And I don't know anything
about your particular design. My own musings follow. Feel free to
ignore them as I only can consider the problem from the POV of using
the CPU.
I understand that you want to stream vectors through your CPU, usingYes, although he is talking about various "configuration" registers for
your general registers to do the processing. Sounds similar to what
Mitch is trying to achieve with his "My 66000".
Depending on how many sources (args) per instruction, and whether you
have only reg->reg or memory loadops, and whether you have full length instruction constants, it seems that vector operations are going to
require 1 to 3 registers per element.
[If you can fix the number of registers per element, that will help.]
Regardless of how many registers (or names) you have, undoubtedly
there will be vectors that are too long to handle without looping, and
there will be vectors whose lengths are not integer multiples of
however many elements an iteration can do in parallel.
[You always can fall back on 1 element per iteration.]
The question is how smart you want your CPU to be.
With vector lengths known at compile time, the compiler can unroll the
loop to figure out how many iterations of N elements, and handle
remaining (< N) elements separately. This requires no vector specific
smarts in your CPU.
If you want to do the moral equivalent of unrolling at runtime ...
well that's another thing altogether. I confess that I don't fully understand what Mitch is doing, and from your comments above I get the
idea that you really don't yet know how you want to handle it.
I can't speak to the hardware complexity of the implementation. Perhaps >that is a limiting factor. But barring that, and the mental effort
required to "reorient" your thinking, I don't see why any new clean
sheet design would use SIMD instructions. Perhaps someone can explain
why it should.
On Mon, 9 Nov 2026 07:51:10 -0000 (UTC), Lawrence DrCOOliveiro wrote:
It's in the name: "Reduced Instruction Set Computer"
Read it as "reduced-instruction set computer", not as "reduced instruction-set computer".
The relevance is that the instruction complexity is reduced, even at
the cost of increasing the number of instructions.
E.g., MIPS and RISC-V have an instruction called LUI, which would be unnecessary if ADDIU just supported full-width immediate operands,
like VAX.
; Pedantic (work in progress)
; If the number of GPR registers per vector register is 3.
; The core translates with micro-ops:
-a-a-a-avadd %r1,%r8,%r16
; into
-a-a-a-aadd %r1,%r8,%r16-a-a-a ; records lane #1 in the instruction
-a-a-a-aadd %r2,%r9,%r17-a-a-a ; records lane #2 in the instruction
-a-a-a-aadd %r3,%r10,%r18
; which it can then distribute to three different pipelines
; and execute in parallel. (no dependencies).
; Translating with micro-ops happens in the front-end after
; the instruction is extracted from the cache line.
; Therefore, there are no register values available yet,
; therefore the vector length cannot be set dynamically
; at high speed. It is possible to change the length but
; it takes a lot of clock cycles. Suggested to use mask
; register instead.
-a-a-a-avaddm %r1,%r8,%r16,%r4-a-a-a ; r4 contains mask
; translates into (source arg #3 is always scalar) masked add
-a-a-a-aaddm %r1,%r8,%r16,%r4-a-a-a ; records lane #1 in the instruction
-a-a-a-aaddm %r2,%r9,%r17,%r4-a-a-a ; records lane #2 in the instruction
-a-a-a-aaddm %r3,%r10,%r18,%r4
; if the elements remaining is less than the number of elements
; in a vector register
; the follwoing generates a mask (alias for bitfield set insn)
-a-a-a-avmfill %r4,$0,$ele_remaining
; It is possible to use a simple instruction sequence to
; generate the mask.
; eg 12 elements in 3 regs
-a-a-a-aminu %r5,$12,%r6-a-a-a-a-a-a-a ; where r6 is counting down # ele
-a-a-a-aset %r4,$0,$0,%r5,$-1-a-a-a-a-a-a-a ; vmfill %r4,$0,%r5
-a-a-a-asub %r6,%r6,%r5-a-a-a-a-a-a-a-a-a-a-a ; count down # ele
-a-a-a-abne %r5,$0,.loop_again
On Mon, 09 Nov 2026 08:14:04 GMT, Anton Ertl wrote:
Read it as "reduced-instruction set computer", not as "reduced
instruction-set computer".
So what exactly is a "set computer"?
The relevance is that the instruction complexity is reduced, even at
the cost of increasing the number of instructions.
E.g., MIPS and RISC-V have an instruction called LUI, which would be
unnecessary if ADDIU just supported full-width immediate operands,
like VAX.
So you see a shift-and-load instruction is being somehow *less*
complex than a straight load?
I'm not sure what I'm thinking as this idea is very un-baked
but maybe the Mill's belt concept could be useful.
Instead of treating the register file as 32 32-byte SIMD registers,
what if it was a 1024 byte belt. A variable byte length LDV Load Vector >copies a memory vector onto the belt such that element[0] lands in belt[0]. >Source operands use a 10 bit belt byte offset,
and dynamic vector length of up to 32 bytes.
Internally its implemented as a circular buffer,
with byte alignment shifters to right-align (little endian)
the source operands as they are read for each operation.
There is no renaming because the belt output inherently
rotates the the whole belt. Internally that would just be
an byte vector alignment shifter applied to the destination.
On Mon, 09 Nov 2026 08:14:04 GMT, Anton Ertl wrote:
On Mon, 9 Nov 2026 07:51:10 -0000 (UTC), Lawrence DrCOOliveiro wrote:
It's in the name: "Reduced Instruction Set Computer"
Read it as "reduced-instruction set computer", not as "reduced
instruction-set computer".
So what exactly is a rCLset computerrCY?
Why not rCLreduced-instruction set-computerrCY? If itrCOs good to put in hyphens, why not put in more of them? rCLReduced-instruction-set
computerrCY?
Yours is an example of a rCLcircular argumentrCY -- you are choosing a particular reading (and a particularly awkward one at that) just on
the basis that it agrees with your argument, not for any other reason.
The relevance is that the instruction complexity is reduced, even at
the cost of increasing the number of instructions.
E.g., MIPS and RISC-V have an instruction called LUI, which would be
unnecessary if ADDIU just supported full-width immediate operands,
like VAX.
So you see a shift-and-load instruction is being somehow *less*
complex than a straight load?
It is also, I think, helpful to consider RISC as the "opposite" of CISC
- and Complex Instruction Set Computer cannot really be interpreted as >meaning anything other than that the instructions are "complex". By >comparison, with RISC the /instructions/ are "reduced".
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> writes:
I can't speak to the hardware complexity of the implementation. Perhaps
that is a limiting factor. But barring that, and the mental effort
required to "reorient" your thinking, I don't see why any new clean
sheet design would use SIMD instructions. Perhaps someone can explain
why it should.
There used to be memory-to-memory vector machines, and there used to
be vector machines with vector registers, like the Cray-1. The
advantage of the vector registers was that they could be used several
or even many times for each time they are loaded, as is common in
matrix multiplication implementations.
My impression is that VVM can only do what memory-to-memory vector
machines could do, but does not have a good story for those tasks
where the vector/SIMD registers are used several times.
On Sun, 8 Nov 2026 07:39:44 -0500, Robert Finch wrote:
I looked at the RISCV vector extension model and they have it just
as a CSR. Makes me think that is an acceptable solution.
RISC-V is going against the prevailing fashion on this. Most other CPU architectures in common use implement loads of SIMD instructions with
fixed vector lengths that are typically quite short: e.g. 4 or 8
elements. The reason why you need loads of different instructions is
because you want to cover all the possible combinations of operand
types that a programmer might find useful.
The RISC-V designers quite rightly criticize this combinatorial
explosion of instruction variants as going completely against the
whole idea of a *reduced* instruction set computer (which is what
rCLRISCrCY is supposed to stand for).
On 2026-11-08 6:17 p.m., George Neuner wrote:------------merciful snip--------------
I understand that you want to stream vectors through your CPU, using
your general registers to do the processing. Sounds similar to what
Mitch is trying to achieve with his "My 66000".
Depending on how many sources (args) per instruction, and whether you
have only reg->reg or memory loadops, and whether you have full length instruction constants, it seems that vector operations are going to
require 1 to 3 registers per element.
[If you can fix the number of registers per element, that will help.]
Maybe a semantic difference here. I call components of a vector elements that might also be called lanes. Multiple elements (lanes) fit into a
single register (between 1 and 8 elements) depending on if the element
is a byte, wyde, tetra or octa in size. Elements are not allowed to span registers.
On 2026-11-08 11:37 p.m., Lawrence DrCOOliveiro wrote:
On Sun, 8 Nov 2026 23:11:46 -0500, Robert Finch wrote:
On 2026-11-08 7:01 p.m., Lawrence DrCOOliveiro wrote:
The RISC-V designers quite rightly criticize this combinatorial
explosion of instruction variants as going completely against the
whole idea of a *reduced* instruction set computer (which is what
rCLRISCrCY is supposed to stand for).
It is partly a representation issue. IDK how it would be avoided,
scratched my head over this one.
I think they do it by specifying the data type of the operands in
another control register.
I went with the hoards of instructions approach. But the size of the
operand is specified in a config register.
At least I do not have a different instruction for each size. Data type is usually determined by
the instruction. vadd for vector integer add, vfadd for float add, etc.
On 11/8/2026 3:17 PM, George Neuner wrote:
On Sun, 8 Nov 2026 10:03:01 -0500, Robert Finch <robfi680@gmail.com>
wrote:
Big snip
Vectors are supported using the GPR register
file by hiding the issuing of multiple instructions behind the scenes
and relying on parallelism in the OoO design.
Good.
How vectors are supported in Qupls may need re-thinking.
Agreed.
big snip
Note that I'm primarily a software person. And I don't know anything
about your particular design. My own musings follow. Feel free to
ignore them as I only can consider the problem from the POV of using
the CPU.
I am in the same position.
I understand that you want to stream vectors through your CPU, using
your general registers to do the processing. Sounds similar to what
Mitch is trying to achieve with his "My 66000".
Yes, although he is talking about various "configuration" registers for things like vector length, element size, etc. which My 66000's VVM
doesn't need.
Depending on how many sources (args) per instruction, and whether you
have only reg->reg or memory loadops, and whether you have full length instruction constants, it seems that vector operations are going to
require 1 to 3 registers per element.
[If you can fix the number of registers per element, that will help.]
Regardless of how many registers (or names) you have, undoubtedly
there will be vectors that are too long to handle without looping, and there will be vectors whose lengths are not integer multiples of
however many elements an iteration can do in parallel.
[You always can fall back on 1 element per iteration.]
All issues that simply go away with VVM. Or at least "go away" for the programmer. The hardware must still handle them, though.
The question is how smart you want your CPU to be.
Yes. I don't know how much "smarts" VVM requires in the hardware.
Lawrence =?iso-8859-13?q?D=FFOliveiro?= <ldo@nz.invalid> writes:
On Mon, 09 Nov 2026 08:14:04 GMT, Anton Ertl wrote:
Read it as "reduced-instruction set computer", not as "reduced
instruction-set computer".
So what exactly is a "set computer"?
You obviously need even more help in how the words belong together.
It's
{{reduced instruction} set} computer
The relevance is that the instruction complexity is reduced, even at
the cost of increasing the number of instructions.
E.g., MIPS and RISC-V have an instruction called LUI, which would be
unnecessary if ADDIU just supported full-width immediate operands,
like VAX.
So you see a shift-and-load instruction is being somehow *less*
complex than a straight load?
There is no shift-and-load involved anywhere. See <https://instructionsets.com/risc-v/lui/> about what LUI does on
RISC-V. If you look at the binary layout, you see that the imm20 is
in the same bit positions in the instruction as in the destination
register.
What is less complex is that MIPS amd RISC-V implementations do not
need to deal with instructions that have more than 32 bits in length.
Without their compressed extensions, they only need to deal with one instruction length: 32 bits. Which means that you can fetch the
instruction directly into the decoder, without needing an instruction
buffer nor a shifter for shifting the bytes around in that buffer.
Concerning circularity: John Mashey's arguments are based on observing architectures that have been generally considered RISC (such as Power,
ARM A32, and RISC-V) vs. architectures that have not (e.g., PDP-11,
VAX, and i386).
You may consider that circular: Derive criteria from a pre-existing classification, and then use the criteria to classify new
architectures. That's what you get if you don't have a definition to
start with. BTW, while Patterson himself did not give a definition in
the paper where he coined the term RISC, but in 1985 observed
commonalities between IBM 801, Berkeley RISC-II and Stanford MIPS and
listed them, preceeding John Mashey's more detailed analysis.
Mashey (and IIRC also Patterson) also discuss the technical background
behind the commonalities in RISCs, so while you may consider the way
that the criteria were derived to be circular, they are not
accidental.
Instruction count is not among these criteria that Patterson observed, and not among the criteria that Mashey uses, either.
Instruction count would also be hard to measure; e.g., <https://instructionsets.com/x86/add/> lists 19 forms of instruction
with the mnemonic ADD. Are they 19 different instructions with the
same name, or just one? What about variants with the same encoding,
like the one with the opcode 05H (listed separately), where the
meaning depends on the value of a flag? What about other differences
in behaviour influenced by a flag?
Mashey used (wrongly IMO) the number of addressing modes as a
criterion, and had difficulty counting them.
And, e.g., Power lists auto-incrementing loads as separate instructions where auto-increment--- Synchronet 3.22a-Linux NewsLink 1.2
is considered to be an addressing mode by ARM.
If you consider an instruction set RISC if it has, say, 64
instructions or less, does it become CISC when FP instructions are
added? What about adding 64-bit instructions?
- anton
On 11/9/2026 2:01 PM, Anton Ertl wrote:
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> writes:
I can't speak to the hardware complexity of the implementation. Perhaps >> that is a limiting factor. But barring that, and the mental effort
required to "reorient" your thinking, I don't see why any new clean
sheet design would use SIMD instructions. Perhaps someone can explain
why it should.
There used to be memory-to-memory vector machines, and there used to
be vector machines with vector registers, like the Cray-1. The
advantage of the vector registers was that they could be used several
or even many times for each time they are loaded, as is common in
matrix multiplication implementations.
My impression is that VVM can only do what memory-to-memory vector
machines could do, but does not have a good story for those tasks
where the vector/SIMD registers are used several times.
That is an interesting, and thought provoking, response. It seems the advantage of an SIMD approach is the large set of addressable registers
that can be used to keep data readily available for future use. Of
course, both systems can keep a modest amount of data in the non SIMD registers, and VVM has streaming buffers, which dedicate memory within
the CPU for other purposes.
I don't know if, when doing things like matrix multiplication, the
streaming buffers can be used to keep data around as well as their role
in anticipating future use. And, for matmul in particular, perhaps you
could break the operation down into small enough blocks that the
non-SIMD registers would be enough. This all requires more thought.
I respect Mitch's abilities such that I can't believe he hasn't thought about how VVM would handle such a common operation as matrix multiplication.
Robert Finch <robfi680@gmail.com> posted:
On 2026-11-08 11:37 p.m., Lawrence DrCOOliveiro wrote:
On Sun, 8 Nov 2026 23:11:46 -0500, Robert Finch wrote:
On 2026-11-08 7:01 p.m., Lawrence DrCOOliveiro wrote:
The RISC-V designers quite rightly criticize this combinatorial
explosion of instruction variants as going completely against the
whole idea of a *reduced* instruction set computer (which is what
rCLRISCrCY is supposed to stand for).
It is partly a representation issue. IDK how it would be avoided,
scratched my head over this one.
I think they do it by specifying the data type of the operands in
another control register.
I went with the hoards of instructions approach. But the size of the
operand is specified in a config register.
How would you vectorize:
LOOP on i
{
DoubleWord[i] = WORD[i] |u HalfWord[i] + Byte[i+2];
}
It is also, I think, helpful to consider RISC as the "opposite" of
CISC - and Complex Instruction Set Computer cannot really be
interpreted as meaning anything other than that the instructions are "complex". By comparison, with RISC the /instructions/ are "reduced".
My impression is that VVM can only do what memory-to-memory vector
machines could do, but does not have a good story for those tasks
where the vector/SIMD registers are used several times.
Mashey (and IIRC also Patterson) also discuss the technical background
behind the commonalities in RISCs, so while you may consider the way
that the criteria were derived to be circular, they are not
accidental.
Don't leave out Mark Horowitz
Given {signed, Unsigned}|u{Byte, halfword, word, doubleword} one has
8 integer ADDs,
There used to be memory-to-memory vector machines, and there used to
be vector machines with vector registers, like the Cray-1.
/ERROR "unexpected byte sequence starting at index 590: '\xC3'" while decoding/:
MitchAlsup <user5857@newsgrouper.org.invalid> writes: >anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
Mashey (and IIRC also Patterson) also discuss the technical background
behind the commonalities in RISCs, so while you may consider the way
that the criteria were derived to be circular, they are not
accidental.
Don't leave out Mark Horowitz
Duckduckgo does not give me any papers, or web pages about RISC
definition when I ask it for "Mark Horowitz RISC", unlike for "John
Mashey RISC". Do you have a specific paper or web page in mind?
Given {signed, Unsigned}|a-u{Byte, halfword, word, doubleword} one has
8 integer ADDs,
SPARC and Power have only one add instruction. With a load-store architecture, you need only one, the full-width one.
Only with
load-and-add instructions, you need to specify the width in the
addition, and whether you want the loaded value to be sign-extended or zero-extended (although I think most have only one variant of every
length). You also then have to ask yourself if you want to perform
the addition to the full width of the register, or just the width of
the loaded value, and sign- or zero-extend the result. I see no good
reason to add only to the width of the loaded value, but that's how
AMD64 works.
The nice thing about load/store architectures is that you can separate
these concerns.
Have all 7 variants of loads (lbu lbs lsu lss lmu lms ll), four--- Synchronet 3.22a-Linux NewsLink 1.2
variants of store (sb ss sm sl), do addition at full width, and have
various zero- and sign-extending instructions in the cases where they
are needed (usually not in connection with addition).
- anton
MitchAlsup wrote:
Robert Finch <robfi680@gmail.com> posted:
On 2026-11-08 11:37 p.m., Lawrence DrCOOliveiro wrote:
On Sun, 8 Nov 2026 23:11:46 -0500, Robert Finch wrote:
On 2026-11-08 7:01 p.m., Lawrence DrCOOliveiro wrote:
The RISC-V designers quite rightly criticize this combinatorial
explosion of instruction variants as going completely against the
whole idea of a *reduced* instruction set computer (which is what
rCLRISCrCY is supposed to stand for).
It is partly a representation issue. IDK how it would be avoided,
scratched my head over this one.
I think they do it by specifying the data type of the operands in
another control register.
I went with the hoards of instructions approach. But the size of the
operand is specified in a config register.
How would you vectorize:
LOOP on i
{
DoubleWord[i] = WORD[i] |u HalfWord[i] + Byte[i+2];
}
Relatively easy:
Unroll by 16:
load 4 W entries into ymm0
load 4 W entries into ymm1
load 4 W entries into ymm2
load 4 W entries into ymm3
load 8 HW entries into ymm4
load 8 HW entries into ymm5
load 16 B entries into ymm6
//
expand low half of ymm4 into ymm7
expand high half of ymm4 in place
// Ditto for ymm5/ymm8
//
// expand ymm6 into ymm9, ymm6, then both of these into two more regs.
After all inputs have been expanded into the final DW element size, do
the muls and adds.
With a total of ~20 size expansion operations, they might well end up as
a very significant part of the total runtime.
If the architecture has doubling parallel MULs, then that would save
quite a few operations.
Terje
It appears that Anton Ertl <anton@mips.complang.tuwien.ac.at> said:
There used to be memory-to-memory vector machines, and there used to
be vector machines with vector registers, like the Cray-1.
There still are. zSeries has 16 vector registers and an impressively overimplemented set of vector ops including integers, IEEE floats,
strings, and packed decimal.
It's not clear who this is for, but presumably there are customers
that wanted them enough to add them.
David Brown [2026-11-10 10:31:47] wrote:
It is also, I think, helpful to consider RISC as the "opposite" of
CISC - and Complex Instruction Set Computer cannot really be
interpreted as meaning anything other than that the instructions are "complex". By comparison, with RISC the /instructions/ are "reduced".
Indeed. And one of the motivations behind the CISC evolution was the
famed "semantic gap", which pushed towards rather fewer instructions
that are more flexible, regular, and powerful.
The million instructions of AES don't feel very CISCy to me.
=== Stefan--- Synchronet 3.22a-Linux NewsLink 1.2
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> posted:
On 11/9/2026 2:01 PM, Anton Ertl wrote:
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> writes:
I can't speak to the hardware complexity of the implementation. Perhaps >>>> that is a limiting factor. But barring that, and the mental effort
required to "reorient" your thinking, I don't see why any new clean
sheet design would use SIMD instructions. Perhaps someone can explain >>>> why it should.
There used to be memory-to-memory vector machines, and there used to
be vector machines with vector registers, like the Cray-1. The
advantage of the vector registers was that they could be used several
or even many times for each time they are loaded, as is common in
matrix multiplication implementations.
My impression is that VVM can only do what memory-to-memory vector
machines could do, but does not have a good story for those tasks
where the vector/SIMD registers are used several times.
That is an interesting, and thought provoking, response. It seems the
advantage of an SIMD approach is the large set of addressable registers
that can be used to keep data readily available for future use. Of
course, both systems can keep a modest amount of data in the non SIMD
registers, and VVM has streaming buffers, which dedicate memory within
the CPU for other purposes.
I don't know if, when doing things like matrix multiplication, the
streaming buffers can be used to keep data around as well as their role
in anticipating future use. And, for matmul in particular, perhaps you
could break the operation down into small enough blocks that the
non-SIMD registers would be enough. This all requires more thought.
I respect Mitch's abilities such that I can't believe he hasn't thought
about how VVM would handle such a common operation as matrix multiplication.
Blocking in the DCache.
Robert Finch <robfi680@gmail.com> posted:
On 2026-11-08 11:37 p.m., Lawrence DrCOOliveiro wrote:
On Sun, 8 Nov 2026 23:11:46 -0500, Robert Finch wrote:
On 2026-11-08 7:01 p.m., Lawrence DrCOOliveiro wrote:
The RISC-V designers quite rightly criticize this combinatorial
explosion of instruction variants as going completely against the
whole idea of a *reduced* instruction set computer (which is what
rCLRISCrCY is supposed to stand for).
It is partly a representation issue. IDK how it would be avoided,
scratched my head over this one.
I think they do it by specifying the data type of the operands in
another control register.
I went with the hoards of instructions approach. But the size of the
operand is specified in a config register.
How would you vectorize:
LOOP on i
{
DoubleWord[i] = WORD[i] |u HalfWord[i] + Byte[i+2];
}
???
At least I do not have a
different instruction for each size. Data type is usually determined by
the instruction. vadd for vector integer add, vfadd for float add, etc.
MitchAlsup wrote:
Robert Finch <robfi680@gmail.com> posted:
On 2026-11-08 11:37 p.m., Lawrence DrCOOliveiro wrote:
On Sun, 8 Nov 2026 23:11:46 -0500, Robert Finch wrote:
On 2026-11-08 7:01 p.m., Lawrence DrCOOliveiro wrote:
The RISC-V designers quite rightly criticize this combinatorial
explosion of instruction variants as going completely against the
whole idea of a *reduced* instruction set computer (which is what
rCLRISCrCY is supposed to stand for).
It is partly a representation issue. IDK how it would be avoided,
scratched my head over this one.
I think they do it by specifying the data type of the operands in
another control register.
I went with the hoards of instructions approach. But the size of the
operand is specified in a config register.
How would you vectorize:
-a-a-a-a-a-a LOOP on i
-a-a-a-a-a-a {
-a-a-a-a-a-a-a-a-a-a-a DoubleWord[i] = WORD[i] |u HalfWord[i] + Byte[i+2]; >> -a-a-a-a-a-a }
Relatively easy:
Unroll by 16:
-a-a load 4 W entries into ymm0
-a-a load 4 W entries into ymm1
-a-a load 4 W entries into ymm2
-a-a load 4 W entries into ymm3
-a-a load 8 HW entries into ymm4
-a-a load 8 HW entries into ymm5
-a-a load 16 B entries into ymm6
//
-a-a expand low half of ymm4 into ymm7
-a-a expand high half of ymm4 in place
// Ditto for ymm5/ymm8
//
//-a-a expand ymm6 into ymm9, ymm6, then both of these into two more regs.
After all inputs have been expanded into the final DW element size, do
the muls and adds.
With a total of ~20 size expansion operations, they might well end up as
a very significant part of the total runtime.
If the architecture has doubling parallel MULs, then that would save
quite a few operations.
Terje
My impression is that VVM can only do what memory-to-memory vector
machines could do, but does not have a good story for those tasks
where the vector/SIMD registers are used several times.
Presumably caches could be used to get comparable results.
The million instructions of AES don't feel very CISCy to me.
Terje Mathisen <terje.mathisen@tmsw.no> posted:
MitchAlsup wrote:
Robert Finch <robfi680@gmail.com> posted:
On 2026-11-08 11:37 p.m., Lawrence D|ore4raoOliveiro wrote:
On Sun, 8 Nov 2026 23:11:46 -0500, Robert Finch wrote:
On 2026-11-08 7:01 p.m., Lawrence D|ore4raoOliveiro wrote:
The RISC-V designers quite rightly criticize this combinatorial
explosion of instruction variants as going completely against the>>>>>>> whole idea of a *reduced* instruction set computer (which is what>>>>>>> |ore4+oRISC|ore4-Y is supposed to stand for).
It is partly a representation issue. IDK how it would be avoided,
scratched my head over this one.
I think they do it by specifying the data type of the operands in
another control register.
I went with the hoards of instructions approach. But the size of the>>>> operand is specified in a config register.
How would you vectorize:
LOOP on i
{
DoubleWord[i] = WORD[i] |arCo HalfWord[i] + Byte[i+2];
}
Relatively easy:
Unroll by 16:
load 4 W entries into ymm0
load 4 W entries into ymm1
load 4 W entries into ymm2
load 4 W entries into ymm3
load 8 HW entries into ymm4
load 8 HW entries into ymm5
load 16 B entries into ymm6
//
expand low half of ymm4 into ymm7
expand high half of ymm4 in place
// Ditto for ymm5/ymm8
//
// expand ymm6 into ymm9, ymm6, then both of these into two more regs.
See you did get my point--at least part of it.Oh, I most certainly "got" it. :-)
Now constrain i to the range{1..14} and try again.If we only have 14 operations, then it becomes like the final iteration
On 11/10/2026 12:00 PM, MitchAlsup wrote:
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> posted:
I respect Mitch's abilities such that I can't believe he hasn't thought
about how VVM would handle such a common operation as matrix
multiplication.
Blocking in the DCache.
So how well does that perform compared to a "typical" SIMD approach?
David Brown [2026-11-10 10:31:47] wrote:
It is also, I think, helpful to consider RISC as the "opposite" of
CISC - and Complex Instruction Set Computer cannot really be
interpreted as meaning anything other than that the instructions are
"complex". By comparison, with RISC the /instructions/ are "reduced".
Indeed. And one of the motivations behind the CISC evolution was the
famed "semantic gap", which pushed towards rather fewer instructions
that are more flexible, regular, and powerful.
The million instructions of AES don't feel very CISCy to me.
=== Stefan
It appears that Anton Ertl <anton@mips.complang.tuwien.ac.at> said:
There used to be memory-to-memory vector machines, and there used to
be vector machines with vector registers, like the Cray-1.
There still are. zSeries has 16 vector registers and an impressively overimplemented set of vector ops including integers, IEEE floats,
strings, and packed decimal.
It's not clear who this is for, but presumably there are customers
that wanted them enough to add them.
anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
/ERROR "unexpected byte sequence starting at index 590: '\xC3'" while decoding/:
MitchAlsup <user5857@newsgrouper.org.invalid> writes:
anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
Mashey (and IIRC also Patterson) also discuss the technical background >>>> behind the commonalities in RISCs, so while you may consider the way
that the criteria were derived to be circular, they are not
accidental.
Don't leave out Mark Horowitz
Duckduckgo does not give me any papers, or web pages about RISC
definition when I ask it for "Mark Horowitz RISC", unlike for "John
Mashey RISC". Do you have a specific paper or web page in mind?
"Architectural Tradeoffs in the Design of MIPS-X" Horowitz and Chow
Given {signed, Unsigned}|a-u{Byte, halfword, word, doubleword} one has
8 integer ADDs,
SPARC and Power have only one add instruction. With a load-store
architecture, you need only one, the full-width one.
If you like LLVM compilers having to constrain ADD results with
SEXT/ZEXT, sure, and you also don't get integer overflow performed
properly (assuming you want it done at all).
LLVM takes the (somewhat convoluted) vision that a result in a
register is range limited to the exact value-set as one stored
in memory.
Only with
load-and-add instructions, you need to specify the width in the
addition, and whether you want the loaded value to be sign-extended or
zero-extended (although I think most have only one variant of every
length). You also then have to ask yourself if you want to perform
the addition to the full width of the register, or just the width of
the loaded value, and sign- or zero-extend the result. I see no good
reason to add only to the width of the loaded value, but that's how
AMD64 works.
Any language that requires the register-allocated variable to be range constrained exactly like those residing in memory has that property.
The nice thing about load/store architectures is that you can separate
these concerns.
There are side effects wrt HLLs that are not addresses with that view point.
Have all 7 variants of loads (lbu lbs lsu lss lmu lms ll), four
variants of store (sb ss sm sl), do addition at full width, and have
various zero- and sign-extending instructions in the cases where they
are needed (usually not in connection with addition).
- anton
Stefan Monnier <monnier@iro.umontreal.ca> posted:
Indeed. And one of the motivations behind the CISC evolution was the
famed "semantic gap", which pushed towards rather fewer instructions
that are more flexible, regular, and powerful.
The million instructions of AES don't feel very CISCy to me.
Nor does a million instructions of AES feel very RISCy to me.
Stefan Monnier <monnier@iro.umontreal.ca> writes:
My impression is that VVM can only do what memory-to-memory vector
machines could do, but does not have a good story for those tasks
where the vector/SIMD registers are used several times.
Presumably caches could be used to get comparable results.
Let's take Zen6 (because its capabilities have just been reported on <https://chipsandcheese.com/p/amds-zen-6-family-feeding-the-beast>):
It can do 2 512-bit FMAs per cycle, each consuming 3 512-bit inputs
and generating 1 512-bit output, and, e.g. matrix multiplication can
get a good utilization from these units.
So in the worst case, if you need all the inputs from caches and
outputs to caches, you would need to be able to perform 6 512-bit
loads and 2 512-bit stores per cycle. The actual Zen6 can perform 2
512-bit loads and (?) 1 512-bit store per cycle (and it's unclear from
the graphics whether the 2 loads and 1 store can happen in the same
cycle).
It may be possible to reduce the number of needed load or store ports
a little for matrix multiplication in VVM, e.g., by computing the sum
of several multiplications before storing, and/or by performing multiplications of a vector with a scalar (SAXPY-style). Fortunately,
matrix multiplication provides lots of freedoms in rearranging the computation. Nevertheless, I would be surprised if one could achieve
the same FPU/LSU ratio with VVM as one can achieve with AVX-512.
- anton
And people keep over-relying on optimizing designs for the SPEC
benchmark, rather than across larger and more varied codebases (that
would ideally not cost money to access).
SPARC and Power have only one add instruction. With a load-store
architecture, you need only one, the full-width one.
If you like LLVM compilers having to constrain ADD results with
SEXT/ZEXT, sure, and you also don't get integer overflow performed
properly (assuming you want it done at all).
LLVM takes the (somewhat convoluted) vision that a result in a
register is range limited to the exact value-set as one stored
in memory.
Only with
load-and-add instructions, you need to specify the width in the
addition, and whether you want the loaded value to be sign-extended or
zero-extended (although I think most have only one variant of every
length). You also then have to ask yourself if you want to perform
the addition to the full width of the register, or just the width of
the loaded value, and sign- or zero-extend the result. I see no good
reason to add only to the width of the loaded value, but that's how
AMD64 works.
Any language that requires the register-allocated variable to be range >constrained exactly like those residing in memory has that property.
On 11/10/2026 11:08 AM, Stefan Monnier wrote:
David Brown [2026-11-10 10:31:47] wrote:
It is also, I think, helpful to consider RISC as the "opposite" of
CISC - and Complex Instruction Set Computer cannot really be
interpreted as meaning anything other than that the instructions are
"complex". By comparison, with RISC the /instructions/ are "reduced".
Indeed. And one of the motivations behind the CISC evolution was the
famed "semantic gap", which pushed towards rather fewer instructions
that are more flexible, regular, and powerful.
I can note that one goal I pushed for in my ISA design was to reduce executed instruction counts without raising the level of abstraction
or having complex logic.
Though, this mostly ends up creating a pressure towards a larger GPR
space and having the ability to encode larger immediate and displacement fields and similar for the cases where spills were common.
Also the LUI+ADDI scheme used by RISC-V, while very effective as a
fallback case for a 32-bit machine, falls on its face for 64-bit
machines. Also the design of the ISA starts to fall on its face the
moment one has a struct or similar that is larger than 2K.
So:
LUI+ADD+LW/SW => Sucks...
Well, and:
SLL+ADD+LW/SW => Also sucks.
...
And, like, if one were doing a lot of work with JPEG or similar, a case could be made for things like YUV -> RGB converters and similar.
Nevermind the specific version of YUV.
Some of my stuff used an approximation, say:
Y=(4*G+3*R+B)/8; U=(B-Y)/2+128; V=(R-Y)/2+128;
Which while not an exact match for the standard color spaces, is "close enough". If mashing the result into RGB555 it may not really matter.
Could be realized relatively affordably in a hardware implementation.
Well, and say:
Y=(9*G+5*R+2*B)/16;
...
Would be more accurate, but slightly less cheap to convert back to RGB
(even if, yes, these factors still allow the multiplications to be done
via a LEA instruction or similar; it results in the reverse-side Green conversion no longer being a plain shift).
Say:
G=(8*Y-3*R-B)>>2;
Vs:
G=((16*Y-5*R-2*B)*57)>>9;
Yeah, if we take CISC as motivated by the desire to provide an assembly language that is comfortable for humans, we can also take RISC as
motivated by the desire to provide an assembly language that's
convenient for compilers (which would rather not need to worry about tradeoffs between using LD+ADD+ST vs using some fancy addressing mode
on ADD).
It appears that Anton Ertl <anton@mips.complang.tuwien.ac.at> said:
There still are. zSeries has 16 vector registers and an impressively >overimplemented set of vector ops including integers, IEEE floats,
strings, and packed decimal.
It's not clear who this is for, but presumably there are customers
that wanted them enough to add them.
It seems the
advantage of an SIMD approach is the large set of addressable registers
that can be used to keep data readily available for future use.
Yeah, if we take CISC as motivated by the desire to provide an assembly >language that is comfortable for humans, we can also take RISC as
motivated by the desire to provide an assembly language that's
convenient for compilers (which would rather not need to worry about >tradeoffs between using LD+ADD+ST vs using some fancy addressing mode
on ADD).
From that point of view, AES is neither CISCy nor RISCy because it's >convenient only for the CPU implementors.
[ In contrast, vVM is definitely RISCy from that standpoint. ]
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> schrieb:
It seems the
advantage of an SIMD approach is the large set of addressable registers
that can be used to keep data readily available for future use.
Plus, you can do wide permutes, and it can also help with reduction.
Having mask for reducing operations also helps (or a length field).
There is one other thing that VVM does not do natively: Reductions
on commutative operators.
Consider the implementation of a simple
SUM intrinsic of FORTRAN. If you write the assembly equivalent of
s = 0;
for (long int i=0; i<n; i++)
s = s + a[i];
then VVM will add a loop-carried dependency. For faster code
on long arrays one can unroll the loop, like
tmp[0] = 0;
tmp[1] = 0;
tmp[2] = 0;
tmp[3] = 0;
n_end = (n / 4) * 4;
for (long int i = 0; i < n_nend; i++)
{
tmp[0] = tmp[0] + a[i];
tmp[1] = tmp[1] + a[i+1];
tmp[2] = tmp[2] + a[i+2];
tmp[3] = tmp[3] + a[i+3];
}
for (long int i = 0; i < n % 4; i++)
tmp[i] = tmp[i] + a[i+n_end];
s = tmp[0] + tmp[1] + tmp[2] + tmp[3];
(hope I got this right)
John Levine <johnl@taugh.com> writes:
It appears that Anton Ertl <anton@mips.complang.tuwien.ac.at> said:
There still are. zSeries has 16 vector registers and an impressively >>overimplemented set of vector ops including integers, IEEE floats,
strings, and packed decimal.
Any relation to the vector facility of the 3090 model 9021/9121?
It's not clear who this is for, but presumably there are customers
that wanted them enough to add them.
One idea might be that auto-vectorization was becoming widespread in
2015 (with gcc and LLVM doing it), probably with exaggerated
expectations concerning its efficacy. So a reason for adding these >instructions might be FOMO on the side of the s390x architects and/or
their customers.
Stefan Monnier <monnier@iro.umontreal.ca> writes:
Yeah, if we take CISC as motivated by the desire to provide an assembly >language that is comfortable for humans, we can also take RISC as
motivated by the desire to provide an assembly language that's
convenient for compilers (which would rather not need to worry about >tradeoffs between using LD+ADD+ST vs using some fancy addressing mode
on ADD).
The fancy addressing mode is the same whether you use it with a LD, a
ST, or an ADD.
Compilers actually have no problem using that addressing mode,
especially in an architecture like VAX: When the variable resides in a register, use a register, when it's in memory, use the appropriate
addressing mode.
It's just that with the 16 registers of S/360 and a compiler that
allocates variables into registers, most accesses are to registers.
And the more fancy addressing modes are not difficult for the
compiler, either (optimality is more difficult, but for trees has been reached with tree-parsing, as used in burg or iburg). But these
addressing modes are not used much, not by compilers, nor by humans
(IIRC the IBM 801 group looked at existing S/370 code), because the corresponding access patterns are not used much.
Likewise, the famed POLY instruction of VAX is there for library use,
in particular for implementing transcendental functions, not because
it's something that programmers used often in raw form.
--- Synchronet 3.22a-Linux NewsLink 1.2[ In contrast, vVM is definitely RISCy from that standpoint. ]
VVM is a microarchitectural mechanism, so architectural concepts like
RISC and CISC are inappropriate for that. You may want to discuss the
VEC and LOOP instructions of MY 66000.
- anton
According to Anton Ertl <anton@mips.complang.tuwien.ac.at>:
John Levine <johnl@taugh.com> writes:
It appears that Anton Ertl <anton@mips.complang.tuwien.ac.at> said:
There still are. zSeries has 16 vector registers and an impressively
overimplemented set of vector ops including integers, IEEE floats,
strings, and packed decimal.
Any relation to the vector facility of the 3090 model 9021/9121?
As far as I can tell, no. The 3090 had 16 vector registers each of
which could hold 128 elements: integer, float, or by pairing registers, double. The z has 16 registers which can hold all sorts of stuff.
It's not clear who this is for, but presumably there are customers
that wanted them enough to add them.
One idea might be that auto-vectorization was becoming widespread in
2015 (with gcc and LLVM doing it), probably with exaggerated
expectations concerning its efficacy. So a reason for adding these
instructions might be FOMO on the side of the s390x architects and/or
their customers.
Possibly, or they may have had some specific applications where they
wanted to do a whole lot of decimal arithmetic or string searches.
EricP <ThatWouldBeTelling@thevillage.com> writes:
I'm not sure what I'm thinking as this idea is very un-baked
but maybe the Mill's belt concept could be useful.
Instead of treating the register file as 32 32-byte SIMD registers,
what if it was a 1024 byte belt. A variable byte length LDV Load Vector
copies a memory vector onto the belt such that element[0] lands in belt[0]. >> Source operands use a 10 bit belt byte offset,
and dynamic vector length of up to 32 bytes.
Internally its implemented as a circular buffer,
with byte alignment shifters to right-align (little endian)
the source operands as they are read for each operation.
There is no renaming because the belt output inherently
rotates the the whole belt. Internally that would just be
an byte vector alignment shifter applied to the destination.
The disadvantage of a belt is that stuff vanishes from the belt (or
you have to preserve it by regularly copying from the end of the belt
to the beginning, so you do not get the advantage of a vector
register, that you can reuse its content as often as you like without additional costs (useful, e.g., in matrix multiplication).
IIRC there are vector instruction sets (maybe even RVV?) that
can have more shorter or fewer longer vector registers.
- anton
On 2026-Nov-10 04:03, Anton Ertl wrote:
EricP <ThatWouldBeTelling@thevillage.com> writes:
I'm not sure what I'm thinking as this idea is very un-baked
but maybe the Mill's belt concept could be useful.
Instead of treating the register file as 32 32-byte SIMD registers,
what if it was a 1024 byte belt. A variable byte length LDV Load Vector
copies a memory vector onto the belt such that element[0] lands in
belt[0].
Source operands use a 10 bit belt byte offset,
and dynamic vector length of up to 32 bytes.
Internally its implemented as a circular buffer,
with byte alignment shifters to right-align (little endian)
the source operands as they are read for each operation.
There is no renaming because the belt output inherently
rotates the the whole belt. Internally that would just be
an byte vector alignment shifter applied to the destination.
The disadvantage of a belt is that stuff vanishes from the belt (or
you have to preserve it by regularly copying from the end of the belt
to the beginning, so you do not get the advantage of a vector
register, that you can reuse its content as often as you like without
additional costs (useful, e.g., in matrix multiplication).
IIRC there are vector instruction sets (maybe even RVV?) that
can have more shorter or fewer longer vector registers.
- anton
Just playing around with this belt idea a bit more...
Yes it needs other registers. So say it has
32 scalar 64-bit registers that can hold integer or float values,
plus a 32 slot belt with 64-bit values,
plus 32 vector registers of 8kB each, each with a byte count,
and the vectors can be interpreted as 1, 2, 4 or 8 byte elements.
Each vector instruction can source its operands from scalar, belt,
or vector registers. If it is a vector register then it is implied
that the current vector loop counter is the index to the element.
The result output goes to belt[0] or belt[1:0] if 128 bit result.
To save a belt value it must be copied to scalar, or vector register
at the current index, or recycled to belt[0], or to memory.
So the belt becomes the equivalent of a forwarding network for
vector calculation temporaries that don't need to be saved.
Not sure where I'm headed with this... just thinking out loud.
anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
Stefan Monnier <monnier@iro.umontreal.ca> writes:
Yeah, if we take CISC as motivated by the desire to provide an assembly
language that is comfortable for humans, we can also take RISC as
motivated by the desire to provide an assembly language that's
convenient for compilers (which would rather not need to worry about
tradeoffs between using LD+ADD+ST vs using some fancy addressing mode
on ADD).
The fancy addressing mode is the same whether you use it with a LD, a
ST, or an ADD.
Compilers actually have no problem using that addressing mode,
especially in an architecture like VAX: When the variable resides in a
register, use a register, when it's in memory, use the appropriate
addressing mode.
It's just that with the 16 registers of S/360 and a compiler that
allocates variables into registers, most accesses are to registers.
And the more fancy addressing modes are not difficult for the
compiler, either (optimality is more difficult, but for trees has been
reached with tree-parsing, as used in burg or iburg). But these
addressing modes are not used much, not by compilers, nor by humans
(IIRC the IBM 801 group looked at existing S/370 code), because the
corresponding access patterns are not used much.
CMU circa 1985, there was a master's thesis called "Maximal Munching
Method" where someone wrote a tree-walker that attempted to match
as big a tree segment as possible in targeting VAX addressing modes.
The compiler produced good fast code (for that era).
The problem was that there was a ">" instead of a "<" in the tree
analyzer: so, the compiler actually used VAX ISA to produce RISC-like
code sequences.
---------------
Likewise, the famed POLY instruction of VAX is there for library use,
in particular for implementing transcendental functions, not because
it's something that programmers used often in raw form.
Performing a series of FMAC steps in the FMAC unit is straightforward-- feeding the polynomial evaluation a series of coefficients is not--
unless those coefficients are stored in ROM in the FMAC unit itself.
Thus, My 66000 transcendentals.
[ In contrast, vVM is definitely RISCy from that standpoint. ]
VVM is a microarchitectural mechanism, so architectural concepts like
RISC and CISC are inappropriate for that. You may want to discuss the
VEC and LOOP instructions of MY 66000.
- anton
Stefan Monnier <monnier@iro.umontreal.ca> writes:
The million instructions of AES don't feel very CISCy to me.Not sure what you mean by that.
Indeed. And one of the motivations behind the CISC evolution was the
famed "semantic gap", which pushed towards rather fewer instructions
that are more flexible, regular, and powerful.
Floating Point Systems had been selling attached "array processors"
for PDP-11, VAX-780 and IBM systems since 1976 and colloborated with
DEC in 1987 attaching to the VAX 8200, 8500, 87/8800. >https://en.wikipedia.org/wiki/Floating_Point_Systems
The 3090 announced its vector unit on 1-Oct-1985
to replace "discontinued 3838 array processor". >https://en.wikipedia.org/wiki/IBM_3090#Vector_facility
DEC started designed their own vector unit in 1986 for the VAX 9000 >https://en.wikipedia.org/wiki/VAX_9000#Vector_processor
It might have been that IBM and DEC looked at the money FPS
was taking in and decided that they wanted a piece of that action.
On 2026-11-12 3:06 p.m., EricP wrote:---------------------
On 2026-Nov-10 04:03, Anton Ertl wrote:
EricP <ThatWouldBeTelling@thevillage.com> writes:
IDK how the belt works. Sounds like a familiar architecture with a
conveyor belt of operands bolted on? When does the belt advance?
At one
point I was trying to re-organize the re-order buffer like a belt.
Queueing at one end and committing at the other. The idea was to use a
shift register for the re-order buffer.
Thinking about the dichotomy of vector registers versus integer and float-point ones. Why do vector registers accept either float or integer values while the integer and floating-point register files are kept separate?
I bin planning on just using a single massive physical register file for everything. Just changing the logical register tags to fake separate register files. But there is going to be separate register files
viewable in the ISA. IDK if to have separate register files for vector integers and vector floats though. Why not add even more separate
register files for decimal-floats and posits too?
On 2026-11-12 2:19 p.m., MitchAlsup wrote:-----------------------
anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
Stefan Monnier <monnier@iro.umontreal.ca> writes:
Performing a series of FMAC steps in the FMAC unit is straightforward-- feeding the polynomial evaluation a series of coefficients is not--
unless those coefficients are stored in ROM in the FMAC unit itself.
Thus, My 66000 transcendentals.
Why cannot the polynomical coefficients be passed in registers?
[ In contrast, vVM is definitely RISCy from that standpoint. ]
VVM is a microarchitectural mechanism, so architectural concepts like
RISC and CISC are inappropriate for that. You may want to discuss the
VEC and LOOP instructions of MY 66000.
- anton
According to EricP <ThatWouldBeTelling@thevillage.com>:
Floating Point Systems had been selling attached "array processors"
for PDP-11, VAX-780 and IBM systems since 1976 and colloborated with
DEC in 1987 attaching to the VAX 8200, 8500, 87/8800. >https://en.wikipedia.org/wiki/Floating_Point_Systems
They were fast, but extremely difficult to program because you had to work out all the paralellism by hand. Trying to program FPS got Josh Fisher thinking about trace scheduling which led to Multiflow and later Itanium.
The 3090 announced its vector unit on 1-Oct-1985
to replace "discontinued 3838 array processor". >https://en.wikipedia.org/wiki/IBM_3090#Vector_facility
Here's the manual for it.
https://bitsavers.org/pdf/ibm/3090/GG24-3058-0_IBM_3090_Vector_Facility_Technical_Reference_198607.pdf
DEC started designed their own vector unit in 1986 for the VAX 9000 >https://en.wikipedia.org/wiki/VAX_9000#Vector_processor
It might have been that IBM and DEC looked at the money FPS
was taking in and decided that they wanted a piece of that action.
Perhaps but I don't get the impression FPS made that much money. In the early 1990s Cray Research bought them and subsequent machines were clusters of SPARC
or Intel i860 chips, quite different from the coprocessors.
According to EricP <ThatWouldBeTelling@thevillage.com>:
The 3090 announced its vector unit on 1-Oct-1985
to replace "discontinued 3838 array processor".
https://en.wikipedia.org/wiki/IBM_3090#Vector_facility
Here's the manual for it.
https://bitsavers.org/pdf/ibm/3090/GG24-3058-0_IBM_3090_Vector_Facility_Technical_Reference_198607.pdf
Robert Finch <robfi680@gmail.com> posted:But cannot the calc be broken up into sequential elements?
On 2026-11-12 2:19 p.m., MitchAlsup wrote:-----------------------
anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
Stefan Monnier <monnier@iro.umontreal.ca> writes:
Performing a series of FMAC steps in the FMAC unit is straightforward--Why cannot the polynomical coefficients be passed in registers?
feeding the polynomial evaluation a series of coefficients is not--
unless those coefficients are stored in ROM in the FMAC unit itself.
Thus, My 66000 transcendentals.
Are you going to make a RS-entry with 9 Src2 operands ???
[ In contrast, vVM is definitely RISCy from that standpoint. ]
VVM is a microarchitectural mechanism, so architectural concepts like
RISC and CISC are inappropriate for that. You may want to discuss the >>>> VEC and LOOP instructions of MY 66000.
- anton
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> schrieb:
It seems the
advantage of an SIMD approach is the large set of addressable registers
that can be used to keep data readily available for future use.
Plus, you can do wide permutes, and it can also help with reduction.
Having mask for reducing operations also helps (or a length field).
There is one other thing that VVM does not do natively: Reductions
on commutative operators.
EricP <ThatWouldBeTelling@thevillage.com> writes:
I'm not sure what I'm thinking as this idea is very un-baked
but maybe the Mill's belt concept could be useful.
Instead of treating the register file as 32 32-byte SIMD registers,
what if it was a 1024 byte belt. A variable byte length LDV Load Vector >>copies a memory vector onto the belt such that element[0] lands in belt[0]. >>Source operands use a 10 bit belt byte offset,
and dynamic vector length of up to 32 bytes.
Internally its implemented as a circular buffer,
with byte alignment shifters to right-align (little endian)
the source operands as they are read for each operation.
There is no renaming because the belt output inherently
rotates the the whole belt. Internally that would just be
an byte vector alignment shifter applied to the destination.
The disadvantage of a belt is that stuff vanishes from the belt (or
you have to preserve it by regularly copying from the end of the belt
to the beginning, so you do not get the advantage of a vector
register, that you can reuse its content as often as you like without >additional costs (useful, e.g., in matrix multiplication).
IIRC there are vector instruction sets (maybe even RVV?) that
can have more shorter or fewer longer vector registers.
- anton
On 11/11/2026 10:53 PM, Thomas Koenig wrote:
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> schrieb:
It seems the
advantage of an SIMD approach is the large set of addressable registers
that can be used to keep data readily available for future use.
Plus, you can do wide permutes, and it can also help with reduction.
Having mask for reducing operations also helps (or a length field).
There is one other thing that VVM does not do natively: Reductions
on commutative operators.
When we talked about reductions on VVM in a thread some months ago, I thought Mitch said that VVM could parallelize such reductions, including handling an array size that was not a multiple of the number of
functional units used (i.e. the degree of parallelism), and combining
the partial sums at the end. As I have said, I am not a hardware guy
but that sounded impressive and I don't know how he does that.
Wikipedia mentions an earlier array processor, the 3838
https://www.bitsavers.org/pdf/ibm/3838/Array_Processor_Status_Report_Jan76.pdf
"HARDWARE
1 MEGABYTE BULK STORE (24K POINTS, 1M-PURCHASE)
24/48 BIT FRACTION
ARITHMATIC ELEMENT
2 ADDERS
1 MULTIPLIER
HIGHLY PIPELINED
100 NS CYCLE
2-1000 WORD WORKING STORES
MICROPROGRAMMED
SHORT/LONG PRECISION
No ERROR CHECKING
CONTROL PROCESSOR
2 MICRO SECOND CYCLE
CONTROLS DATA TRANSFERS
HOST TO BULK STORE (3M B/S)
BULK STORE TO WORKING STORE (40M B/S)
PROVIDES OVERLAP
370 CHANNEL INTERFACE
It mentions an earlier array processor, the 2938, note the date of 1966
https://www.bitsavers.org/pdf/ibm/2938/Functional_Objectives_for_an_Array_Processor_Nov66.pdf
"August 1967
THE 2938 ARRAY PROCESSOR
The 2938 Array Processor is a peripheral processor for attachment to >System/360 Models 44, 65, and 75.
...
The arithmetic unit of the 2938 is a multiplication and addition unit which >performs the operation Z = U*X +- Y. The unit operates on System/360 >short-operand floating-point data only.
...
the combined multiply and add time is effectively 200 nanoseconds,
whereas the total time for a particular set of U, X I and Y to pass
through the arithmetic unit to form the resultant Z is approximately
800 nanoseconds."
According to EricP <ThatWouldBeTelling@thevillage.com>:
Floating Point Systems had been selling attached "array processors"
for PDP-11, VAX-780 and IBM systems since 1976 and colloborated with
DEC in 1987 attaching to the VAX 8200, 8500, 87/8800. >>https://en.wikipedia.org/wiki/Floating_Point_Systems
They were fast, but extremely difficult to program because you had to work out all the paralellism by hand. Trying to program FPS got Josh Fisher thinking about trace scheduling which led to Multiflow and later Itanium.
The 3090 announced its vector unit on 1-Oct-1985
to replace "discontinued 3838 array processor". >>https://en.wikipedia.org/wiki/IBM_3090#Vector_facility
Here's the manual for it.
https://bitsavers.org/pdf/ibm/3090/GG24-3058-0_IBM_3090_Vector_Facility_Technical_Reference_198607.pdf
Stefan Monnier <monnier@iro.umontreal.ca> writes:
Yeah, if we take CISC as motivated by the desire to provide an assembly >>language that is comfortable for humans, we can also take RISC asThe fancy addressing mode is the same whether you use it with a LD, a
motivated by the desire to provide an assembly language that's
convenient for compilers (which would rather not need to worry about >>tradeoffs between using LD+ADD+ST vs using some fancy addressing mode
on ADD).
ST, or an ADD.
Compilers actually have no problem using that addressing mode,
especially in an architecture like VAX: When the variable resides in a register, use a register, when it's in memory, use the appropriate
addressing mode.
(optimality is more difficult, but for trees has been
reached with tree-parsing, as used in burg or iburg).
But these addressing modes are not used much, not by compilers,
We have learned how to do such tools with the more efficient calling conventions we use now, but that does cost a lot of complexity in the
tools: Generating and using DWARF information etc. Ok, DWARF is not
just about calling conventions, but it might be interesting to
consider how much simpler debugging information would be with VAX
CALLs.
From that point of view, AES is neither CISCy nor RISCy because it'sAES instructions are not particularly convenient for CPU implementors, probably on the contrary, because they need hardware that is not
convenient only for the CPU implementors.
useful for anything else.
[ In contrast, vVM is definitely RISCy from that standpoint. ]vVM is a microarchitectural mechanism,
Anton Ertl [2026-11-12 06:21:21] wrote:
Stefan Monnier <monnier@iro.umontreal.ca> writes:
Yeah, if we take CISC as motivated by the desire to provide an assembly >>>language that is comfortable for humans, we can also take RISC as >>>motivated by the desire to provide an assembly language that'sThe fancy addressing mode is the same whether you use it with a LD, a
convenient for compilers (which would rather not need to worry about >>>tradeoffs between using LD+ADD+ST vs using some fancy addressing mode
on ADD).
ST, or an ADD.
That's beside the point. With a load/store architecture you don't need
to choose between using the ADD-with-addressing mode or using explicit
loads and stores. Makes life simpler for the compiler.
Compilers actually have no problem using that addressing mode,
especially in an architecture like VAX: When the variable resides in a
register, use a register, when it's in memory, use the appropriate
addressing mode.
What if explicit loads and stores are faster/slower?
And how is the answer affected by subsequent operations accessing the
same memory location?
(optimality is more difficult, but for trees has been
reached with tree-parsing, as used in burg or iburg).
And this is useful for CISC but much less so for RISC, so you can use
a simpler compiler for RISC instruction sets.
BGB <cr88192@gmail.com> posted:
On 11/10/2026 11:08 AM, Stefan Monnier wrote:
David Brown [2026-11-10 10:31:47] wrote:
It is also, I think, helpful to consider RISC as the "opposite" of
CISC - and Complex Instruction Set Computer cannot really be
interpreted as meaning anything other than that the instructions are
"complex". By comparison, with RISC the /instructions/ are "reduced".
Indeed. And one of the motivations behind the CISC evolution was the
famed "semantic gap", which pushed towards rather fewer instructions
that are more flexible, regular, and powerful.
I can note that one goal I pushed for in my ISA design was to reduce
executed instruction counts without raising the level of abstraction
or having complex logic.
For my part, My 66000 was restricted to not add more than 1 gate of delay
per cycle to any stage of the pipeline.
Though, this mostly ends up creating a pressure towards a larger GPR
space and having the ability to encode larger immediate and displacement
fields and similar for the cases where spills were common.
I did not find that, given that I waste no registers for immediates or displacements.
Also the LUI+ADDI scheme used by RISC-V, while very effective as a
fallback case for a 32-bit machine, falls on its face for 64-bit
machines. Also the design of the ISA starts to fall on its face the
moment one has a struct or similar that is larger than 2K.
So:
LUI+ADD+LW/SW => Sucks...
Well, and:
SLL+ADD+LW/SW => Also sucks.
...
And the only thing that always works is:
MEM Rd,[Rbase,Rindex<<scale,#displacement{32 or 64}]
You can access anything anywhere in a 64-bit VAS in 1 instruction--
including transferring control through GOT.
-------------------
And, like, if one were doing a lot of work with JPEG or similar, a case
could be made for things like YUV -> RGB converters and similar.
Nevermind the specific version of YUV.
Some of my stuff used an approximation, say:
Y=(4*G+3*R+B)/8; U=(B-Y)/2+128; V=(R-Y)/2+128;
Which while not an exact match for the standard color spaces, is "close
enough". If mashing the result into RGB555 it may not really matter.
Could be realized relatively affordably in a hardware implementation.
Well, and say:
Y=(9*G+5*R+2*B)/16;
...
Would be more accurate, but slightly less cheap to convert back to RGB
(even if, yes, these factors still allow the multiplications to be done
via a LEA instruction or similar; it results in the reverse-side Green
conversion no longer being a plain shift).
Say:
G=(8*Y-3*R-B)>>2;
Vs:
G=((16*Y-5*R-2*B)*57)>>9;
My point on all of this is to find a way to avoid approximations and
get the well defined math done cheaply.
WRT the Mill, I think people here may be missing that it supported short-vector-SIMD, and that a vector operand on its belt was a single
element [of whatever width] - not a bunch of scalars that magically
would be operated on together.
According to Ivan, the Mill's instruction set supported quad FP and
128-bit short vector SIMD.
[Similar width as Intel's SSE2, though SSE_ doesn't do quad FP.]
He spoke about the potential for [more lanes] wider SIMD and made
clear that, whatever widths were supported, the "operands" still would
be treated as single belt elements.
George Neuner wrote:
WRT the Mill, I think people here may be missing that it supported short-vector-SIMD, and that a vector operand on its belt was a
single element [of whatever width] - not a bunch of scalars that
magically would be operated on together.
Yes and no, see below.
According to Ivan, the Mill's instruction set supported quad FP and
128-bit short vector SIMD.
[Similar width as Intel's SSE2, though SSE_ doesn't do quad FP.]
He spoke about the potential for [more lanes] wider SIMD and madeThe real magic sauce is the fact that belt operands carries metadata, including not just byte/short/int/long/float/double/etc designators,
clear that, whatever widths were supported, the "operands" still
would be treated as single belt elements.
but also a vector vs scalar boolean, as well as None and NAR (Not A
Result, similar to NaN but even more powerful).
This means that Mill only needs a single ADD instruction, it
automagically handles vector/scalar/multiple element sizes based on
those metadata bits.
If you want to treat 16 bytes, loaded as 16 unsigned bytes, as if
they were 8 int16_t's, then you need to convert the entry.
Terje
PS. Expect to see Mill return to being generally visible in the near
future.
On 2026-11-12 3:06 p.m., EricP wrote:
On 2026-Nov-10 04:03, Anton Ertl wrote:IDK how the belt works. Sounds like a familiar architecture with a conveyor belt of operands bolted on? When does the belt advance? At one point I was trying to re-organize the re-order buffer like a belt. Queueing at one end and committing at the other. The idea was to use a shift register for the re-order buffer.
EricP <ThatWouldBeTelling@thevillage.com> writes:
I'm not sure what I'm thinking as this idea is very un-baked
but maybe the Mill's belt concept could be useful.
Instead of treating the register file as 32 32-byte SIMD registers,
what if it was a 1024 byte belt. A variable byte length LDV Load Vector >>>> copies a memory vector onto the belt such that element[0] lands in belt[0].
Source operands use a 10 bit belt byte offset,
and dynamic vector length of up to 32 bytes.
Internally its implemented as a circular buffer,
with byte alignment shifters to right-align (little endian)
the source operands as they are read for each operation.
There is no renaming because the belt output inherently
rotates the the whole belt. Internally that would just be
an byte vector alignment shifter applied to the destination.
The disadvantage of a belt is that stuff vanishes from the belt (or
you have to preserve it by regularly copying from the end of the belt
to the beginning, so you do not get the advantage of a vector
register, that you can reuse its content as often as you like without
additional costs (useful, e.g., in matrix multiplication).
IIRC there are vector instruction sets (maybe even RVV?) that
can have more shorter or fewer longer vector registers.
- anton
Just playing around with this belt idea a bit more...
Yes it needs other registers. So say it has
32 scalar 64-bit registers that can hold integer or float values,
plus a 32 slot belt with 64-bit values,
plus 32 vector registers of 8kB each, each with a byte count,
and the vectors can be interpreted as 1, 2, 4 or 8 byte elements.
Each vector instruction can source its operands from scalar, belt,
or vector registers. If it is a vector register then it is implied
that the current vector loop counter is the index to the element.
The result output goes to belt[0] or belt[1:0] if 128 bit result.
To save a belt value it must be copied to scalar, or vector register
at the current index, or recycled to belt[0], or to memory.
So the belt becomes the equivalent of a forwarding network for
vector calculation temporaries that don't need to be saved.
Not sure where I'm headed with this... just thinking out loud.
Thinking about the dichotomy of vector registers versus integer and float-point ones. Why do vector registers accept either float or integer values while the integer and floating-point register files are kept separate?
I bin planning on just using a single massive physical register file for everything. Just changing the logical register tags to fake separate register files. But there is going to be separate register files viewable in the ISA. IDK if to have separate register files for vector integers and vector floats though. Why not add even more separate register files for decimal-floats and posits too?
On Tue, 10 Nov 2026 09:03:17 GMT, anton@mips.complang.tuwien.ac.at
(Anton Ertl) wrote:
EricP <ThatWouldBeTelling@thevillage.com> writes:
I'm not sure what I'm thinking as this idea is very un-baked
but maybe the Mill's belt concept could be useful.
Instead of treating the register file as 32 32-byte SIMD registers,
what if it was a 1024 byte belt. A variable byte length LDV Load Vector
copies a memory vector onto the belt such that element[0] lands in belt[0]. >>> Source operands use a 10 bit belt byte offset,
and dynamic vector length of up to 32 bytes.
Internally its implemented as a circular buffer,
with byte alignment shifters to right-align (little endian)
the source operands as they are read for each operation.
There is no renaming because the belt output inherently
rotates the the whole belt. Internally that would just be
an byte vector alignment shifter applied to the destination.
The disadvantage of a belt is that stuff vanishes from the belt (or
you have to preserve it by regularly copying from the end of the belt
to the beginning, so you do not get the advantage of a vector
register, that you can reuse its content as often as you like without
additional costs (useful, e.g., in matrix multiplication).
IIRC there are vector instruction sets (maybe even RVV?) that
can have more shorter or fewer longer vector registers.
- anton
WRT the Mill, I think people here may be missing that it supported short-vector-SIMD, and that a vector operand on its belt was a single
element [of whatever width] - not a bunch of scalars that magically
would be operated on together.
According to Ivan, the Mill's instruction set supported quad FP and
128-bit short vector SIMD.
[Similar width as Intel's SSE2, though SSE_ doesn't do quad FP.]
He spoke about the potential for [more lanes] wider SIMD and made
clear that, whatever widths were supported, the "operands" still would
be treated as single belt elements.
On Fri, 13 Nov 2026 15:19:04 +0100
Terje Mathisen <terje.mathisen@tmsw.no> wrote:
George Neuner wrote:
WRT the Mill, I think people here may be missing that it supported
short-vector-SIMD, and that a vector operand on its belt was a
single element [of whatever width] - not a bunch of scalars that
magically would be operated on together.
Yes and no, see below.
The real magic sauce is the fact that belt operands carries metadata,
According to Ivan, the Mill's instruction set supported quad FP and
128-bit short vector SIMD.
[Similar width as Intel's SSE2, though SSE_ doesn't do quad FP.]
He spoke about the potential for [more lanes] wider SIMD and made
clear that, whatever widths were supported, the "operands" still
would be treated as single belt elements.
including not just byte/short/int/long/float/double/etc designators,
but also a vector vs scalar boolean, as well as None and NAR (Not A
Result, similar to NaN but even more powerful).
This means that Mill only needs a single ADD instruction, it
automagically handles vector/scalar/multiple element sizes based on
those metadata bits.
If you want to treat 16 bytes, loaded as 16 unsigned bytes, as if
they were 8 int16_t's, then you need to convert the entry.
Terje
PS. Expect to see Mill return to being generally visible in the near
future.
Still with aspiration to actually implement it in silicon?
Or realistic?
On 2026-Nov-12 15:43, Robert Finch wrote:
IDK how the belt works. Sounds like a familiar architecture with a
conveyor belt of operands bolted on? When does the belt advance? At
one point I was trying to re-organize the re-order buffer like a belt.
Queueing at one end and committing at the other. The idea was to use a
shift register for the re-order buffer.
Its like an accumulator register in that it is the default result output register
but it has multiple slots that logically act like a shift register array.
As each new result is output the one at the far end falls off the belt.
Like a regular register file it is logically committed when a result is written out.
Internally it can be implemented as a shift register, or as a circular buffer,
or as a fixed physical register file with a circular renamer.
The difference is in the programming model.
A regular scalar RF (SRF) uses absolute register number addressing
while a belt register file (BRF) uses relative addressing.
With SRF when you write to R1 and that's where the result stays.
If you want to retain R1 for a later loop iteration then you have to
copy it
to R2 or unroll a loop and assign a different register to each iteration.
With BRF each result is saved to belt[0] and older ones shift up.
If the belt is 32 slots then belt[31] falls off and is lost unless saved first.
John Levine <johnl@taugh.com> schrieb:
According to EricP <ThatWouldBeTelling@thevillage.com>:
Floating Point Systems had been selling attached "array processors"
for PDP-11, VAX-780 and IBM systems since 1976 and colloborated with
DEC in 1987 attaching to the VAX 8200, 8500, 87/8800. >>>https://en.wikipedia.org/wiki/Floating_Point_Systems
They were fast, but extremely difficult to program because you had to work >> out all the paralellism by hand. Trying to program FPS got Josh Fisher
thinking about trace scheduling which led to Multiflow and later Itanium.
The 3090 announced its vector unit on 1-Oct-1985
to replace "discontinued 3838 array processor". >>>https://en.wikipedia.org/wiki/IBM_3090#Vector_facility
Here's the manual for it.
https://bitsavers.org/pdf/ibm/3090/GG24-3058-0_IBM_3090_Vector_Facility_Technical_Reference_198607.pdf
On 2026-11-12 8:18 p.m., MitchAlsup wrote:
Robert Finch <robfi680@gmail.com> posted:
On 2026-11-12 2:19 p.m., MitchAlsup wrote:-----------------------
anton@mips.complang.tuwien.ac.at (Anton Ertl) posted:
Stefan Monnier <monnier@iro.umontreal.ca> writes:
Performing a series of FMAC steps in the FMAC unit is straightforward-- >>> feeding the polynomial evaluation a series of coefficients is not--Why cannot the polynomical coefficients be passed in registers?
unless those coefficients are stored in ROM in the FMAC unit itself.
Thus, My 66000 transcendentals.
Are you going to make a RS-entry with 9 Src2 operands ???But cannot the calc be broken up into sequential elements?
Q+ FPOLY instruction expands into multiple FMA micro-ops.
The micro-ops only need a few src operands. The next coefficient is
assumed to come from the next register.
It is using Horner's rule.
FPOLY has a cascade input option so it can be called as many times as desired.
Of course the Q+ micro-op translator is kinda huge, maybe unworkable IRL.
[ In contrast, vVM is definitely RISCy from that standpoint. ]
VVM is a microarchitectural mechanism, so architectural concepts like >>>> RISC and CISC are inappropriate for that. You may want to discuss the >>>> VEC and LOOP instructions of MY 66000.
- anton
Anton Ertl [2026-11-12 06:21:21] wrote:
Stefan Monnier <monnier@iro.umontreal.ca> writes:
Yeah, if we take CISC as motivated by the desire to provide an assembly >>>language that is comfortable for humans, we can also take RISC as >>>motivated by the desire to provide an assembly language that'sThe fancy addressing mode is the same whether you use it with a LD, a
convenient for compilers (which would rather not need to worry about >>>tradeoffs between using LD+ADD+ST vs using some fancy addressing mode
on ADD).
ST, or an ADD.
That's beside the point. With a load/store architecture you don't need
to choose between using the ADD-with-addressing mode or using explicit
loads and stores. Makes life simpler for the compiler.
Compilers actually have no problem using that addressing mode,
especially in an architecture like VAX: When the variable resides in a
register, use a register, when it's in memory, use the appropriate
addressing mode.
What if explicit loads and stores are faster/slower?
And how is the answer affected by subsequent operations accessing the
same memory location?
(optimality is more difficult, but for trees has been
reached with tree-parsing, as used in burg or iburg).
And this is useful for CISC but much less so for RISC, so you can use
a simpler compiler for RISC instruction sets.
AES instructions are not particularly convenient for CPU implementors,
probably on the contrary, because they need hardware that is not
useful for anything else.
AFAIK, AES was designed specifically to give access to that extra
hardware. More specifically, manufacturers were eager to add more FPUs
and the question they faced was how to make that hardware available to
the programmer.
IOW it's "more hardware" that caused AES rather than the other way around.
And AFAICT, AES is a fairly naive/simple way (for the CPU implementor)
to give access to that hardware.
vVM is a microarchitectural mechanism,
Is it? I use it as a way to refer to the design of VEC+LOOP (which is
so designed as to allow a particular micro-architecture).
Stefan Monnier <monnier@iro.umontreal.ca> writes:
And how is the answer affected by subsequent operations accessing the
same memory location?
Just the same as on a RISC: You run register allocation before
instruction selection, so if a value is accessed several times and
registers are available, the value will be allocated into a register,
on both architecture styles.
vVM is a microarchitectural mechanism,
Is it? I use it as a way to refer to the design of VEC+LOOP (which is
so designed as to allow a particular micro-architecture).
Architecturally, LOOP is a branch (maybe it also deals with the loop >counter?), and VEC is a noop AFAIK.
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> schrieb:
On 11/11/2026 10:53 PM, Thomas Koenig wrote:
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> schrieb:
It seems the
advantage of an SIMD approach is the large set of addressable registers >>> that can be used to keep data readily available for future use.
Plus, you can do wide permutes, and it can also help with reduction.
Having mask for reducing operations also helps (or a length field).
There is one other thing that VVM does not do natively: Reductions
on commutative operators.
When we talked about reductions on VVM in a thread some months ago, I thought Mitch said that VVM could parallelize such reductions, including handling an array size that was not a multiple of the number of
functional units used (i.e. the degree of parallelism), and combining
the partial sums at the end. As I have said, I am not a hardware guy
but that sounded impressive and I don't know how he does that.
I don't see this in the manuals, at least. Mitch, did I miss it?
Actually, normally register allocation is performed after instruction >selection. So if the operand is a local variable that can be in a
register (no address taken), it will be assumed to be in a register,
for instruction selection. Later the register allocator actually
tries to allocate a register for the variable, and if not, on a RISC
spill code is inserted with additional live ranges, and the register >allocator has to run again (at least that's the way that Chaitin and
Briggs described this). On a VAX, you just use a memory operand for
those variables that do not fit into registers.
Stefan Monnier <monnier@iro.umontreal.ca> schrieb:
Anton Ertl [2026-11-12 06:21:21] wrote:I agree. But a large amount of optimization has gone into architectures
Stefan Monnier <monnier@iro.umontreal.ca> writes:That's beside the point. With a load/store architecture you don't need
Yeah, if we take CISC as motivated by the desire to provide an assembly >>>>language that is comfortable for humans, we can also take RISC as >>>>motivated by the desire to provide an assembly language that's >>>>convenient for compilers (which would rather not need to worry about >>>>tradeoffs between using LD+ADD+ST vs using some fancy addressing mode >>>>on ADD).The fancy addressing mode is the same whether you use it with a LD, a
ST, or an ADD.
to choose between using the ADD-with-addressing mode or using explicit
loads and stores. Makes life simpler for the compiler.
with have memory operands (especially x86), so this is in large part
a solved problem.
Stefan Monnier <monnier@iro.umontreal.ca> writes:
That's beside the point. With a load/store architecture you don't needNo. With an architecture like the VAX, RISC is actually harder:
to choose between using the ADD-with-addressing mode or using explicit >>loads and stores. Makes life simpler for the compiler.
VAX: If operand src1 is in memory, accessed with d(SP), use the ADD instruction with d(SP) as second operand. Likewise for src2 and dst.
RISC: If operand src2 is in memory, allocate a register for it (but
why is it in memory? Probably because there are no registers
available, so first spill some other value);
It's all doable, but simpler? No.
And this is useful for CISC but much less so for RISC, so you can use
a simpler compiler for RISC instruction sets.
It's also useful for RISCs, because it has instructions that combine a constant with an operation, and instructions that add a constant and a register, and then use the resulting address in a load (or store); not
to mention addressing modes of, e.g., the 88K architecture. And auto-increment/decrement addressing modes, such as available on ARM
A32 and A64, and HPPA, do not fit the tree parsing paradigm.
Thomas Koenig <tkoenig@netcologne.de> posted:
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> schrieb:
On 11/11/2026 10:53 PM, Thomas Koenig wrote:
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> schrieb:
It seems the
advantage of an SIMD approach is the large set of addressable registers >> >>> that can be used to keep data readily available for future use.
Plus, you can do wide permutes, and it can also help with reduction.
Having mask for reducing operations also helps (or a length field).
There is one other thing that VVM does not do natively: Reductions
on commutative operators.
When we talked about reductions on VVM in a thread some months ago, I
thought Mitch said that VVM could parallelize such reductions, including >> > handling an array size that was not a multiple of the number of
functional units used (i.e. the degree of parallelism), and combining
the partial sums at the end. As I have said, I am not a hardware guy
but that sounded impressive and I don't know how he does that.
I don't see this in the manuals, at least. Mitch, did I miss it?
The augend input to FMAC has a special feed-forward mechanism {-|Architectural}
I may have to do something special when running 4-wide.
anton@mips.complang.tuwien.ac.at (Anton Ertl) writes:
Stefan Monnier <monnier@iro.umontreal.ca> writes:
And how is the answer affected by subsequent operations accessing
the same memory location?
Just the same as on a RISC: You run register allocation before
instruction selection, so if a value is accessed several times and >registers are available, the value will be allocated into a register,
on both architecture styles.
Actually, normally register allocation is performed after instruction selection. So if the operand is a local variable that can be in a
register (no address taken), it will be assumed to be in a register,
for instruction selection. Later the register allocator actually
tries to allocate a register for the variable, and if not, on a RISC
spill code is inserted with additional live ranges, and the register allocator has to run again (at least that's the way that Chaitin and
Briggs described this). On a VAX, you just use a memory operand for
those variables that do not fit into registers.
vVM is a microarchitectural mechanism,
Is it? I use it as a way to refer to the design of VEC+LOOP (which
is so designed as to allow a particular micro-architecture).
Architecturally, LOOP is a branch (maybe it also deals with the loop >counter?), and VEC is a noop AFAIK.
And the fact that VVM is a microarchitectural mechanism is it's
beauty. The semantics are just the same as for the whole loop without
VVM.
- anton
Michael S wrote:
On Fri, 13 Nov 2026 15:19:04 +0100
Terje Mathisen <terje.mathisen@tmsw.no> wrote:
George Neuner wrote:
WRT the Mill, I think people here may be missing that it supported
short-vector-SIMD, and that a vector operand on its belt was a
single element [of whatever width] - not a bunch of scalars that
magically would be operated on together.
Yes and no, see below.
The real magic sauce is the fact that belt operands carries
According to Ivan, the Mill's instruction set supported quad FP
and 128-bit short vector SIMD.
[Similar width as Intel's SSE2, though SSE_ doesn't do quad FP.]
He spoke about the potential for [more lanes] wider SIMD and made
clear that, whatever widths were supported, the "operands" still
would be treated as single belt elements.
metadata, including not just byte/short/int/long/float/double/etc
designators, but also a vector vs scalar boolean, as well as None
and NAR (Not A Result, similar to NaN but even more powerful).
This means that Mill only needs a single ADD instruction, it
automagically handles vector/scalar/multiple element sizes based on
those metadata bits.
If you want to treat 16 bytes, loaded as 16 unsigned bytes, as if
they were 8 int16_t's, then you need to convert the entry.
Terje
PS. Expect to see Mill return to being generally visible in the
near future.
Still with aspiration to actually implement it in silicon?
Or realistic?
I sincerely hope so since I would love to be able to run on actual
silicon, not just a sw simulator! :-)
Terje
How would you do it for non-associative arithmetic opcodes like >floating-point?
Michael S <already5chosen@yahoo.com> writes:
How would you do it for non-associative arithmetic opcodes like >floating-point?
IIRC Mitch Alsup's answer to FP reduction is an accumulator with about
2100 bits or so. It's not clear to me how one can accumulate 16 DP FP
values per cycle, like Zen5 can do.
- anton
On Sat, 14 Nov 2026 17:53:07 GMT
anton@mips.complang.tuwien.ac.at (Anton Ertl) wrote:
IIRC Mitch Alsup's answer to FP reduction is an accumulator with about
2100 bits or so. It's not clear to me how one can accumulate 16 DP FP
values per cycle, like Zen5 can do.
- anton
It still does not produce the same result as sequiential code.
Michael S <already5chosen@yahoo.com> writes:
On Sat, 14 Nov 2026 17:53:07 GMT
anton@mips.complang.tuwien.ac.at (Anton Ertl) wrote:
IIRC Mitch Alsup's answer to FP reduction is an accumulator with
about 2100 bits or so. It's not clear to me how one can
accumulate 16 DP FP values per cycle, like Zen5 can do.
- anton
It still does not produce the same result as sequiential code.
Of course the (architectural) code does not add an FP value with
another FP value, instead it always adds to the accumulator; so the programmer or compiler has to know what they are doing.
Adding to the accumulator produces an exact result. So the order in
which you add is irrelevant.
A way to do it in parallel would be to have 16 accumulators that each
can do one addition per cycle, and add them all in the end. But that
would be very expensive to implement. Maybe there is a clever way to
add more than one value per cycle.
It's less clear to me if one can use an accumulator for
multiplicative reduction and if that can be parallelized, but it's
rare AFAIK, so it may not be so important to make it fast.
- anton
MitchAlsup <user5857@newsgrouper.org.invalid> schrieb:
Thomas Koenig <tkoenig@netcologne.de> posted:
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> schrieb:
On 11/11/2026 10:53 PM, Thomas Koenig wrote:
Stephen Fuld <sfuld@alumni.cmu.edu.invalid> schrieb:
It seems the
advantage of an SIMD approach is the large set of addressable registers
that can be used to keep data readily available for future use.
Plus, you can do wide permutes, and it can also help with reduction.
Having mask for reducing operations also helps (or a length field).
There is one other thing that VVM does not do natively: Reductions
on commutative operators.
When we talked about reductions on VVM in a thread some months ago, I >> > thought Mitch said that VVM could parallelize such reductions, including
handling an array size that was not a multiple of the number of
functional units used (i.e. the degree of parallelism), and combining >> > the partial sums at the end. As I have said, I am not a hardware guy >> > but that sounded impressive and I don't know how he does that.
I don't see this in the manuals, at least. Mitch, did I miss it?
The augend input to FMAC has a special feed-forward mechanism {-|Architectural}
I may have to do something special when running 4-wide.
So, in order to do efficient reductions, the vectorized VVM
loops will also have to be unrolled, with a final horizontal
reduction step (like I wrote above).
Michael S <already5chosen@yahoo.com> writes:
How would you do it for non-associative arithmetic opcodes like
floating-point?
IIRC Mitch Alsup's answer to FP reduction is an accumulator with about
2100 bits or so. It's not clear to me how one can accumulate 16 DP FP
values per cycle, like Zen5 can do.
On Sat, 14 Nov 2026 18:32:08 GMT
anton@mips.complang.tuwien.ac.at (Anton Ertl) wrote:
Adding to the accumulator produces an exact result. So the order in
which you add is irrelevant.
I think that it is only almost irrelevant. Overflows still can differ.
Or may be not, if you have few more bits?
But Horner scheme is not exactly unseen of.
Anton Ertl wrote:
Michael S <already5chosen@yahoo.com> writes:
How would you do it for non-associative arithmetic opcodes like
floating-point?
IIRC Mitch Alsup's answer to FP reduction is an accumulator with about
2100 bits or so. It's not clear to me how one can accumulate 16 DP FP
values per cycle, like Zen5 can do.
That
Zen5 needs a pair of 512-bit accumulators to do it, right?
Total number of accumulator bits are in the same ballpark, but a >Superaccumulator will give the correct/exact answer totally independent
of the aggregation order, something which you definitely cannot claim
for that 16-wide Zen5 AVX-512 version.
Michael S <already5chosen@yahoo.com> writes:
On Sat, 14 Nov 2026 18:32:08 GMT
anton@mips.complang.tuwien.ac.at (Anton Ertl) wrote:
Adding to the accumulator produces an exact result. So the order
in which you add is irrelevant.
I think that it is only almost irrelevant. Overflows still can
differ. Or may be not, if you have few more bits?
Yes. But how many more bits? I guess you have to use on the order of
60 extra bits if you want to support accumulating over several years
without forcing overflow detection in the meantime.
Alternatively, the architecture could require an explicit
overflow-check instruction every n adds to the accumulator, and then
the additions could not be reordered wrt. this instruction. 60 extra
bits looks more attractive to me.
But Horner scheme is not exactly unseen of.
How would it be sped up in SIMD? Un-Horner it and compute all the
powers in parallel, then multiply with the coefficients in parallel,
then add up the summands with pairwise addition?
With VVM, the parallel parts should be relatively straightforward to
do, and then the pairwise addition parts would be done with the
reduction support, whatever it is.
- anton
Michael S <already5chosen@yahoo.com> writes:
How would you do it for non-associative arithmetic opcodes like >>floating-point?
IIRC Mitch Alsup's answer to FP reduction is an accumulator with about
2100 bits or so.
It's not clear to me how one can accumulate 16 DP FP
values per cycle, like Zen5 can do.
Anton Ertl <anton@mips.complang.tuwien.ac.at> schrieb:...
Michael S <already5chosen@yahoo.com> writes:
How would you do it for non-associative arithmetic opcodes like >>>floating-point?
IIRC Mitch Alsup's answer to FP reduction is an accumulator with about
2100 bits or so.
It's not clear to me how one can accumulate 16 DP FP
values per cycle, like Zen5 can do.
Lots of pipelining and lots of full adders would be my guess.
EricP <ThatWouldBeTelling@thevillage.com> writes:
Wikipedia mentions an earlier array processor, the 3838
https://www.bitsavers.org/pdf/ibm/3838/Array_Processor_Status_Report_Jan76.pdf
"HARDWARE
1 MEGABYTE BULK STORE (24K POINTS, 1M-PURCHASE)
24/48 BIT FRACTION
ARITHMATIC ELEMENT
2 ADDERS
1 MULTIPLIER
HIGHLY PIPELINED
100 NS CYCLE
2-1000 WORD WORKING STORES
MICROPROGRAMMED
SHORT/LONG PRECISION
No ERROR CHECKING
CONTROL PROCESSOR
2 MICRO SECOND CYCLE
CONTROLS DATA TRANSFERS
HOST TO BULK STORE (3M B/S)
BULK STORE TO WORKING STORE (40M B/S)
PROVIDES OVERLAP
370 CHANNEL INTERFACE
So that's around the same time as Cray-1, maybe inspired by earlier
pipelined vector machines by TI and CDC.
The cycle time is 8 times longer than that of the Cray-1, so the
Cray-1 probably resulted in very low sales for the 3838.
The use of the channels for these kinds of accelerators is
interesting. Maybe this was the inspiration for the way that the SPEs
in the Cell Broadband Engine (used in, e.g., the Playstation 3)
interface to the rest of the system. I'll ask Michael Gschwind when I
see him (he occasionally visits his alma mater).
While reading up on Cell and Michal Gschwind, I found the following, which leads us back to vector extensions on S390x:
<https://en.wikipedia.org/wiki/Michael_Gschwind#SIMD_Parallel_vector_architecture>
|To enable efficient compilation, Gschwind proposed the implementation
|of merged scalar and vector execution units, eliminating the cost of
|copies between scalar and vectorized code, and simplifying compiler |architecture by resolving phase ordering problems in compilers.
|
|The Cell's accelerator cores (Synergistic Processor Unit SPU) contain
|a single 128 element register file with 128 bit per register.
|Registers may hold either scalar or a vector of multiple values.[66]
|The simplified cost model leads to significantly improved
|vectorization success, improving overall program performance and |efficiency.[67]
|
|The vector-scalar approach was also adopted by the IBM Power VSX
|(Vector Scalar Extension) SIMD instructions,[68] BlueGene/Q vector |instructions[69][70] and System/z mainframe vector instruction
|set,[42][71] the design of all three IBM vector-scalar architectures
|having been led by Gschwind as Chief Architect for IBM System
|Architecture.
So IBM reuses architectural (and probably implementation) work across
its various architectures. This has also happened with decimal FP
appearing on Power and S390x. So the S390x vector stuff probably was
not demand-driven, but supply-driven. One would have to compare the
vector extensions of the various architectures (and architecture
versions) to see if there are any parts that occur only on some of
them and where they appear first. One can assume that demand puts the feature in the first architecture, and then supply puts it in the
others.
It mentions an earlier array processor, the 2938, note the date of 1966
https://www.bitsavers.org/pdf/ibm/2938/Functional_Objectives_for_an_Array_Processor_Nov66.pdf
"August 1967
THE 2938 ARRAY PROCESSOR
The 2938 Array Processor is a peripheral processor for attachment to
System/360 Models 44, 65, and 75.
...
The arithmetic unit of the 2938 is a multiplication and addition unit which >> performs the operation Z = U*X +- Y. The unit operates on System/360
short-operand floating-point data only.
...
the combined multiply and add time is effectively 200 nanoseconds,
whereas the total time for a particular set of U, X I and Y to pass
through the arithmetic unit to form the resultant Z is approximately
800 nanoseconds."
Should I interpret that as 800ns latency with a throughput of 1/200ns?
That would then be an early case of a pipelined vector processor.
- anton
On 11/13/2026 7:28 AM, EricP wrote:
On 2026-Nov-12 15:43, Robert Finch wrote:
snip
IDK how the belt works. Sounds like a familiar architecture with a conveyor belt of operands bolted on? When does the belt advance? At one point I was trying to re-organize the re-order buffer like a belt. Queueing at one end and committing at the other. The idea was to use a shift register for the re-order buffer.
Its like an accumulator register in that it is the default result output register
but it has multiple slots that logically act like a shift register array.
As each new result is output the one at the far end falls off the belt.
Like a regular register file it is logically committed when a result is written out.
Yes.-a I look at it as sort of a fixed length stack (put new elements at the top an push all other elements down) with the enhancement that you can address, for reading only, stack elements other than the top.
Internally it can be implemented as a shift register, or as a circular buffer,
or as a fixed physical register file with a circular renamer.
IIRC, the Mill implements it using the output buffers of each functional unit plus each having a "position register" of log2 (number of FUs) bit register that gives that register's position within the stack.-a Each instruction sets the register corresponding to that instruction to TOS and increments all the other position registers.-a No actual separate register set and no shifting.
The difference is in the programming model.
A regular scalar RF (SRF) uses absolute register number addressing
while a belt register file (BRF) uses relative addressing.
Yes.
With SRF when you write to R1 and that's where the result stays.
If you want to retain R1 for a later loop iteration then you have to copy it >> to R2 or unroll a loop and assign a different register to each iteration.
With BRF each result is saved to belt[0] and older ones shift up.
If the belt is 32 slots then belt[31] falls off and is lost unless saved first.
Yes, although with the Mill (IIRC), the "shift" is logical not physical.
On Fri, 13 Nov 2026 21:51:25 GMT
anton@mips.complang.tuwien.ac.at (Anton Ertl) wrote:
anton@mips.complang.tuwien.ac.at (Anton Ertl) writes:
Stefan Monnier <monnier@iro.umontreal.ca> writes:
And how is the answer affected by subsequent operations accessing
the same memory location?
Just the same as on a RISC: You run register allocation before >instruction selection, so if a value is accessed several times and >registers are available, the value will be allocated into a register,
on both architecture styles.
Actually, normally register allocation is performed after instruction selection. So if the operand is a local variable that can be in a
register (no address taken), it will be assumed to be in a register,
for instruction selection. Later the register allocator actually
tries to allocate a register for the variable, and if not, on a RISC
spill code is inserted with additional live ranges, and the register allocator has to run again (at least that's the way that Chaitin and
Briggs described this). On a VAX, you just use a memory operand for
those variables that do not fit into registers.
vVM is a microarchitectural mechanism,
Is it? I use it as a way to refer to the design of VEC+LOOP (which
is so designed as to allow a particular micro-architecture).
Architecturally, LOOP is a branch (maybe it also deals with the loop >counter?), and VEC is a noop AFAIK.
And the fact that VVM is a microarchitectural mechanism is it's
beauty. The semantics are just the same as for the whole loop without
VVM.
- anton
How would you do it for non-associative arithmetic opcodes like floating-point?
Anton Ertl wrote:
Michael S <already5chosen@yahoo.com> writes:
How would you do it for non-associative arithmetic opcodes like
floating-point?
IIRC Mitch Alsup's answer to FP reduction is an accumulator with about
2100 bits or so. It's not clear to me how one can accumulate 16 DP FP values per cycle, like Zen5 can do.
A superaccumulator using fully redundant storage (bits + carries) can
add another input in a small fraction of a clock cycle, you just need parallel aligners to allow mantissa bits to enter in the right spot.
Probably not 16 doubles every clock cycle, but much more than one. That
Zen5 needs a pair of 512-bit accumulators to do it, right?
Total number of accumulator bits are in the same ballpark, but a Superaccumulator will give the correct/exact answer totally independent
of the aggregation order, something which you definitely cannot claim
for that 16-wide Zen5 AVX-512 version. (For the last claim to be true,
you actually need a fair number of extra bits so that you cannot get a spurious intermediate overflow due to a particularly bad operand ordering.)
Terje
Michael S <already5chosen@yahoo.com> writes:
On Sat, 14 Nov 2026 18:32:08 GMT
anton@mips.complang.tuwien.ac.at (Anton Ertl) wrote:
Adding to the accumulator produces an exact result. So the order in
which you add is irrelevant.
I think that it is only almost irrelevant. Overflows still can differ.
Or may be not, if you have few more bits?
Yes. But how many more bits? I guess you have to use on the order of
60 extra bits if you want to support accumulating over several years
without forcing overflow detection in the meantime.
Alternatively, the architecture could require an explicit
overflow-check instruction every n adds to the accumulator, and then
the additions could not be reordered wrt. this instruction. 60 extra
bits looks more attractive to me.
But Horner scheme is not exactly unseen of.
How would it be sped up in SIMD? Un-Horner it and compute all the
powers in parallel, then multiply with the coefficients in parallel,
then add up the summands with pairwise addition?
With VVM, the parallel parts should be relatively straightforward to--- Synchronet 3.22a-Linux NewsLink 1.2
do, and then the pairwise addition parts would be done with the
reduction support, whatever it is.
- anton
Thomas Koenig <tkoenig@netcologne.de> writes:
Anton Ertl <anton@mips.complang.tuwien.ac.at> schrieb:...
Michael S <already5chosen@yahoo.com> writes:
How would you do it for non-associative arithmetic opcodes like >>>>floating-point?
IIRC Mitch Alsup's answer to FP reduction is an accumulator with about
2100 bits or so.
It's not clear to me how one can accumulate 16 DP FP
values per cycle, like Zen5 can do.
Lots of pipelining and lots of full adders would be my guess.
One way to do it would be to add up the 16 operands using pairwise
addition, and then finally add the result to the accumulator. That
approach would cost a lot of transistors, however.
| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 76 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 54:48:35 |
| Calls: | 1,265 |
| Calls today: | 1 |
| Files: | 1,362 |
| D/L today: |
3 files (2,684K bytes) |
| Messages: | 285,582 |