This page describing the БЭСМ-6 instruction set refers to a value called ω, which is stored inside a Mode Register. It appears to be set by certain kinds of instructions, so that ω can tell you which of the last executed multiply and the last executed addition and the last executed subtraction was executed last. Kind of like how the Z80 has a bit that says whether an addition or subtraction happened last and is useful for the "decimal adjustment" operation.

  • Now the БЭСМ-6 has a Young Bits register1 and the precise semantics of fetching Young Bits into Accumulator depend on what's inside ω.

  • Now the БЭСМ-6 has a Branch if Zero instruction and correspondingly a Branch if Not Zero instruction, and the thing which determines what "Zero" is2 is some kind of calculation based on the value ω.

I'm finding this whole business kind of bizarre and hard to grok. So my question is basically "what's going on here?". Can you explain why Zero is not 0 and why this depends on ω and why loading Young Bits also depends on ω?

And bonus points also if you know the etymology. I have exactly no idea why this thing should be denoted by ω, the lower case omega.

1 Presumably, it's called Young Bits in this particular document because it's sometimes treated as an extension of the accumulator and the Russian word младший can mean "younger" and the same word also can mean "least significant" when talking about bits/bytes/digits, but I'm not aware that this use of the English word "younger" is in widespread use.

2 A hint: This Zero condition does not mean that Accumulator is numerically zero.

  • 2
    Quick shot: These are all floating point numbers, and additive/multiplicative operations seem to do rounding/normalization differently, therefore different bits represent a "zero" condition (which is fuzzy in FP, anyway). One would need more details about how rounding/normalization is handled by the instructions. The emulator source code may help.
    – dirkt
    Commented Aug 28, 2018 at 11:47
  • 1
    "Younger bits" meaning "least-significant bits" is not widespread but apparently understood in context. It can be found, for example, in an RFC. OTOH, "young bits" is a term related to branch prediction.
    – Leo B.
    Commented Aug 28, 2018 at 18:53

2 Answers 2


I'm finding this whole business kind of bizarre and hard to grok. So my question is basically "what's going on here?".

It's a way to save on special case jump instructions. Or more general, to adapt certain instructions to work as needed due to prior executed ones. I guess today we would cover this on a programming level with a bunch of macro opcodes which then generate appropriate opcode pairs.

Can you explain why Zero is not 0 and why this depends on ω

Zero as a name is more of a placeholder and in only true to its name for logical zero tests. Omega saves what the last operation was. Multiply, Additive or Logical. The Branch (Not) Zero instruction uses Omega to determine what to check.

  • All 48 bits to be zero when Omega is logical - much like a test for zero on canonical CPUs
  • The sign (Bit 41) for being zero (positive) when Omega is additive - Test for positive/negative result
  • The highest bit of the exponent (Bit 48) for being one when Omega marks a prior multiply - Effectively testing for overflow.

Bottom line: Only two branch instructions are needed to test three different conditions, depending on what prior operation happened.

and why loading Young Bits also depends on ω?

Because YTA is eventually (like Zero) not really describing the whole meaning. YTA is meant to bring the second 'half' of a prior result into A. In case of logical operation Y contains this, so all bits of Y are transferred to A. In all other (arithmetic) instructions the 'second value' is in Z, so YTA is transferring Z to A - or more exactly, the 40 bits of Z are moved while the rest is set according to the instructions EA to make it a FP value.

Bottom Line: Instead of two move instruction only one needs to be encoded, selecting the right source depending on what prior instruction happened

  • 1
    So Zero is just a matter of a poorly chosen name, either in the English translation or of course in the Russian original. A better name, if a little verbose, might have been "condition you might find it useful to be able to check for". Commented Aug 28, 2018 at 14:12
  • 3
    @Wilson The instruction which performs a jump when ω is Logical and all bits of ACC are equal to 0 is rightfully called "branch when 0" (UZA). Consequently, all other combinations of conditions chosen to cause the UZA instruction to branch are called "zero".
    – Leo B.
    Commented Aug 28, 2018 at 15:25

As a matter of fact, the page you refer to, which was authored by me a long time ago, is somewhat incorrect, and bases its notation on a colloquial use of ω.

In the original documentation ω is the name of the 1-bit signal generated by the arithmetic unit and consumed by the control unit. The UZA instruction takes the branch when ω=0.

The 3-bit field in the R register which is called ω on the page, should be properly called "instruction group attributes". My excuse is that the names of these three signals in the documentation do include ω: УПωЛ, УПωП, УПωМ, which can be glossed as "Control Attribute ω Logical", "Control Attribute ω Exponent", "Control Attribute ω Mantissa".

Colloquially, "ω is Logical" means "At the moment, the signal УПωЛ is high, and the observed value of ω had been computed according to the Logical mode rule".

I'm afraid that the etymology of ω is lost in the sands of time. The available BESM-6 documentation doesn't mention it.

The Latin-based instruction mnemonics had been devised in the Joint Institute for Nuclear Research with a multi-lingual cadre of researchers from various countries; as the extension register of the accumulator (A) was called Y (and not, say, B for the next letter of the alphabet, or L for the "least-significant bits"), it is likely that the choice of the mnemonic based on the term "young(er) bits" was well-understood and well-accepted.

The YTA instruction in the Logical mode is a regular move instruction, and in the "arithmetic" (Additive or Multiplicative) modes it moves just the mantissa bits. That behavior is mostly (or only) geared toward facilitating extended precision arithmetic.

Also note that there is no explicit opposite instruction (ATY); moving the accumulator to the Y register is achieved as a side effect of the AEX (exclusive OR) instruction.

  • "the page you refer to, which was authored by me a long time ago" Why I'm not surprised? :))
    – Raffzahn
    Commented Aug 28, 2018 at 20:57
  • 4
    @Raffzahn :) I've carefully avoided inserting vanity links when asking my BESM-6 related questions.
    – Leo B.
    Commented Aug 29, 2018 at 8:43

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .