more affine

Author: MaxwellBo

gf2p8affineqb/gf2p8affineqb-visualizer.css

@@ -59,3 +59,11 @@
 .gf2p8-cpp-section {
   margin-top: 15px;
 }
+
+.gf2p8-blend-section {
+  margin-top: 10px;
+}
+
+.gf2p8-blend-section p {
+  margin: 6px 0;
+}

gf2p8affineqb/gf2p8affineqb-visualizer.js

@@ -255,6 +255,216 @@ assert(resultByte == ${expectedResult});`;
   container.appendChild(cppSection);
 }
 
+/**
+ * The matrix RPCS3 uses to decode SHUFB's special-case control bytes.
+ * Byte 0 (the row for output bit 7) routes control bit 6 to the sign bit,
+ * bytes 1-7 (rows for output bits 6..0) route control bit 5 everywhere else.
+ */
+export const SHUFB_GFNI_MATRIX = [0x40, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20];
+
+/**
+ * Create a visualization of RPCS3's SHUFB special-case fast path:
+ * one GF2P8AFFINEQB over the SHUFB control byte, followed by two blends.
+ * @param {HTMLElement} container - The container element to render into
+ * @param {{control: number, matrix: Uint8Array, imm: number}} state - Mutable simulator state
+ */
+export function createShufbVisualization(container, state) {
+  const previousDetails = container.querySelector('details');
+  const wasOpen = previousDetails ? previousDetails.open : false;
+
+  container.innerHTML = '';
+
+  const rerender = () => createShufbVisualization(container, state);
+
+  let matrixQword = 0n;
+  for (let i = 0; i < 8; i++) {
+    matrixQword |= BigInt(state.matrix[i]) << BigInt(i * 8);
+  }
+
+  const gfni = affineByte(matrixQword, state.control, state.imm);
+  const idxConst = (gfni & 0x80) ? gfni : 0x00;
+  const controlIsSpecial = (state.control & 0x80) !== 0;
+
+  const hex = (x) => '0x' + x.toString(16).padStart(2, '0').toUpperCase();
+  const bin = (x) => '0b' + x.toString(2).padStart(8, '0');
+
+  // Main visualization: matrix × control + imm = gfni
+  const vizContainer = document.createElement('div');
+  vizContainer.classList.add('gf2p8-viz-container');
+
+  // Matrix grid
+  const matrixGrid = document.createElement('div');
+  matrixGrid.classList.add('gf2p8-matrix-grid');
+  for (let row = 7; row >= 0; row--) {
+    for (let col = 7; col >= 0; col--) {
+      const byteIndex = (7 - row);
+      const bit = (state.matrix[byteIndex] >> col) & 1;
+      const cell = document.createElement('div');
+      cell.textContent = bit;
+      cell.classList.add('gf2p8-cell', 'interactive', bit ? 'one' : 'zero');
+      cell.addEventListener('click', () => {
+        state.matrix[byteIndex] ^= (1 << col);
+        rerender();
+      });
+      matrixGrid.appendChild(cell);
+    }
+  }
+  vizContainer.appendChild(matrixGrid);
+
+  const xLabel = document.createElement('div');
+  xLabel.textContent = '×';
+  xLabel.classList.add('gf2p8-operator');
+  vizContainer.appendChild(xLabel);
+
+  // Control byte vector
+  const controlGrid = document.createElement('div');
+  controlGrid.classList.add('gf2p8-vector-grid');
+  for (let bit = 7; bit >= 0; bit--) {
+    const bitValue = (state.control >> bit) & 1;
+    const cell = document.createElement('div');
+    cell.textContent = bitValue;
+    cell.classList.add('gf2p8-cell', 'interactive', bitValue ? 'one' : 'zero');
+    cell.addEventListener('click', () => {
+      state.control ^= (1 << bit);
+      rerender();
+    });
+    controlGrid.appendChild(cell);
+  }
+  vizContainer.appendChild(controlGrid);
+
+  const xorLabel = document.createElement('div');
+  xorLabel.textContent = '+';
+  xorLabel.classList.add('gf2p8-operator');
+  vizContainer.appendChild(xorLabel);
+
+  // Immediate constant vector
+  const immGrid = document.createElement('div');
+  immGrid.classList.add('gf2p8-vector-grid');
+  for (let bit = 7; bit >= 0; bit--) {
+    const bitValue = (state.imm >> bit) & 1;
+    const cell = document.createElement('div');
+    cell.textContent = bitValue;
+    cell.classList.add('gf2p8-cell', 'interactive', bitValue ? 'one' : 'zero');
+    cell.addEventListener('click', () => {
+      state.imm ^= (1 << bit);
+      rerender();
+    });
+    immGrid.appendChild(cell);
+  }
+  vizContainer.appendChild(immGrid);
+
+  const equalsLabel = document.createElement('div');
+  equalsLabel.textContent = '=';
+  equalsLabel.classList.add('gf2p8-operator');
+  vizContainer.appendChild(equalsLabel);
+
+  // GFNI result with annotations
+  const resultGrid = document.createElement('div');
+  resultGrid.classList.add('gf2p8-result-grid');
+  for (let bit = 7; bit >= 0; bit--) {
+    const bitValue = (gfni >> bit) & 1;
+    const cell = document.createElement('div');
+    cell.textContent = bitValue;
+    cell.classList.add('gf2p8-cell', bitValue ? 'result-one' : 'zero');
+    resultGrid.appendChild(cell);
+
+    const annotation = document.createElement('div');
+    annotation.classList.add('gf2p8-annotation');
+    const matrixByte = state.matrix[7 - bit];
+    const sourceBits = [];
+    for (let i = 7; i >= 0; i--) {
+      if ((matrixByte >> i) & 1) {
+        sourceBits.push(`control bit ${i}`);
+      }
+    }
+    const immBit = (state.imm >> bit) & 1;
+    if (sourceBits.length === 0) {
+      annotation.textContent = immBit ? '1' : '0';
+    } else if (immBit) {
+      annotation.textContent = `¬(${sourceBits.join(' + ')})`;
+    } else {
+      annotation.textContent = sourceBits.join(' + ');
+    }
+    resultGrid.appendChild(annotation);
+  }
+  vizContainer.appendChild(resultGrid);
+
+  container.appendChild(vizContainer);
+
+  // Blend fixup steps
+  const blendSection = document.createElement('div');
+  blendSection.classList.add('gf2p8-blend-section');
+
+  const step1 = document.createElement('p');
+  step1.innerHTML =
+    `<b>Blend 1</b> — force <code>0x00</code> when the affine result's sign bit is clear: ` +
+    `<code>gfni = ${bin(gfni)}</code>, sign bit ${(gfni & 0x80) ? 'set, kept as' : 'clear, forced to'} ` +
+    `<code>${hex(idxConst)}</code>`;
+  blendSection.appendChild(step1);
+
+  const step2 = document.createElement('p');
+  if (controlIsSpecial) {
+    step2.innerHTML =
+      `<b>Blend 2</b> — the control byte's own sign bit is set, so the special-case constant is selected: ` +
+      `result byte = <code>${hex(idxConst)}</code>`;
+  } else {
+    step2.innerHTML =
+      `<b>Blend 2</b> — the control byte's own sign bit is clear, so the shuffle result is selected: ` +
+      `result byte = byte ${state.control & 0x1F} of RA‖RB (the affine result is discarded)`;
+  }
+  blendSection.appendChild(step2);
+
+  const verdict = document.createElement('p');
+  let expected;
+  if (!controlIsSpecial) {
+    expected = `byte ${state.control & 0x1F} of RA‖RB`;
+  } else if ((state.control & 0xC0) === 0x80) {
+    expected = '0x00';
+  } else if ((state.control & 0xE0) === 0xC0) {
+    expected = '0xFF';
+  } else {
+    expected = '0x80';
+  }
+  const actual = controlIsSpecial ? hex(idxConst) : `byte ${state.control & 0x1F} of RA‖RB`;
+  const matches = actual === expected;
+  verdict.innerHTML =
+    `Control byte <code>${bin(state.control)}</code>: <i>Table 5-1</i> says <code>${expected}</code>, ` +
+    `this path produces <code>${actual}</code> ${matches ? '✓' : '✗ (you broke it — reset the matrix to 0x2020202020202040 and imm8 to 0x7F)'}`;
+  blendSection.appendChild(verdict);
+
+  container.appendChild(blendSection);
+
+  // C++ code example
+  const cppSection = document.createElement('details');
+  cppSection.classList.add('gf2p8-cpp-section');
+
+  const cppSummary = document.createElement('summary');
+  cppSummary.textContent = 'C++ implementation';
+  cppSummary.classList.add('gf2p8-cpp-summary');
+  cppSection.appendChild(cppSummary);
+
+  const cppCode = document.createElement('pre');
+  cppCode.classList.add('gf2p8-cpp-code');
+  const codeElement = document.createElement('code');
+  codeElement.textContent = `// ${'0x' + matrixQword.toString(16).padStart(16, '0')}
+const __m128i k_matrix = _mm_set1_epi64x(0x${matrixQword.toString(16).padStart(16, '0')});
+
+// c holds the 16 SHUFB control bytes, shuffled holds the bytes already
+// gathered from RA||RB (e.g. via VPERM2B)
+const __m128i gfni = _mm_gf2p8affine_epi64_epi8(c, k_matrix, ${hex(state.imm)});
+
+// Blend 1: where gfni's sign bit is clear, force 0x00 (fixes up 10xxxxxx)
+const __m128i idx_consts = _mm_blendv_epi8(_mm_setzero_si128(), gfni, gfni);
+
+// Blend 2: where the control byte's sign bit is set, take the special
+// constant; otherwise take the shuffled data
+const __m128i result = _mm_blendv_epi8(shuffled, idx_consts, c);`;
+  cppCode.appendChild(codeElement);
+  cppSection.appendChild(cppCode);
+  cppSection.open = wasOpen;
+  container.appendChild(cppSection);
+}
+
 /**
  * Create a matrix from bytes for visualization
  * @param {number[]} bytes - 8 bytes representing the matrix rows

gf2p8affineqb/gf2p8affineqb.test.js

@@ -174,3 +174,36 @@ describe('gf2p8affineqb', () => {
     expect(result_neg[0]).toBe(0b11111111); // Sign extended
   });
 });
+
+describe("RPCS3 SHUFB special-case fast path (Whatcookie's trick)", () => {
+  // Matrix used in RPCS3's SPULLVMRecompiler SHUFB path:
+  // Byte 0 (row for output bit 7): 0x40 -> copies control bit 6 to the sign bit
+  // Bytes 1-7 (rows for output bits 6..0): 0x20 -> copy control bit 5,
+  // which imm8 = 0x7F then inverts
+  const shufbMatrix = 0x2020202020202040n;
+  const imm8 = 0x7f;
+
+  /** Model the affine op followed by RPCS3's first blend (force 0x00 when sign bit clear) */
+  function idxConst(control) {
+    const gfni = affineByte(shufbMatrix, control, imm8);
+    return (gfni & 0x80) ? gfni : 0x00;
+  }
+
+  test('10xxxxxx produces 0x00', () => {
+    for (let c = 0b10000000; c <= 0b10111111; c++) {
+      expect(idxConst(c)).toBe(0x00);
+    }
+  });
+
+  test('110xxxxx produces 0xFF', () => {
+    for (let c = 0b11000000; c <= 0b11011111; c++) {
+      expect(idxConst(c)).toBe(0xFF);
+    }
+  });
+
+  test('111xxxxx produces 0x80', () => {
+    for (let c = 0b11100000; c <= 0b11111111; c++) {
+      expect(idxConst(c)).toBe(0x80);
+    }
+  });
+});

gf2p8affineqb/index.html

@@ -621,6 +621,84 @@ <h2>Shuffle Bytes</h2>
 end</pre>
     </blockquote>
 
+    <p>
+      A naive implementation has to check for the three constant-generating patterns
+      (<code>10xxxxxx</code> → <code>0x00</code>, <code>110xxxxx</code> → <code>0xFF</code>,
+      <code>111xxxxx</code> → <code>0x80</code>) on every one of the 16 control bytes, on top of
+      the actual shuffle. <a href="https://github.com/Whatcookie">Whatcookie</a>'s fast path
+      (<a href="https://github.com/RPCS3/rpcs3/pull/8712">RPCS3 PR #8712</a>) decodes all three
+      special cases at once with a single GF2P8AFFINEQB over the control bytes, because each
+      output is a pure boolean function of control bits 5, 6, and 7 &mdash; exactly the kind of
+      function an affine transformation can compute:
+    </p>
+
+    <ul>
+      <li>The matrix row for output bit 7 is <code>0b01000000</code>, so the result's sign bit is a copy
+        of control bit 6.</li>
+      <li>The rows for output bits 6 through 0 are all <code>0b00100000</code>, selecting control bit
+        5, and imm8 = <code>0x7F</code> flips those seven bits, so they become ¬(control bit 5).</li>
+    </ul>
+
+    <p>
+      Two cheap blends then finish the job: one forces the byte to <code>0x00</code> wherever the affine
+      result's sign bit is clear (fixing up the <code>10xxxxxx</code> case), and one selects between the
+      special-case constant and the actual shuffled data based on the control byte's own sign bit.
+      Toggle the control byte's top three bits below and watch <i>Table 5-1</i> fall out:
+    </p>
+
+    <div id="viz-shufb" class="simulator-container"></div>
+
+    <script type="module">
+      import { createShufbVisualization, SHUFB_GFNI_MATRIX } from './gf2p8affineqb-visualizer.js';
+
+      createShufbVisualization(document.getElementById('viz-shufb'), {
+        control: 0b11000101,
+        matrix: new Uint8Array(SHUFB_GFNI_MATRIX),
+        imm: 0x7f,
+      });
+    </script>
+
+    <p>
+      Here's the actual source, from RPCS3's SPU LLVM recompiler
+      (<code>gf2p8affineqb</code> is a thin wrapper that emits the
+      <code>llvm.x86.vgf2p8affineqb.128</code> intrinsic, and <code>c</code> holds the 16 SHUFB
+      control bytes). The 16-byte <code>build</code> is the <code>0x2020202020202040</code> matrix
+      from the simulator above, once per 64-bit lane:
+    </p>
+
+    <figure>
+      <pre><code>// Calculate special index constants
+
+value_t&lt;u8[16]&gt; idx_consts;
+if (perm_or_zero_only)
+{
+	idx_consts = eval(splat&lt;u8[16]&gt;(0));
+}
+else if (m_use_avx512_icl)
+{
+	const auto gfni = gf2p8affineqb(c, build&lt;u8[16]&gt;(0x40, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x40, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20), 0x7f);
+	idx_consts = eval(select(noncast&lt;s8[16]&gt;(gfni) &gt;= 0, splat&lt;u8[16]&gt;(0), gfni));
+}
+else
+{
+	const auto pshufb_lut = build&lt;u8[16]&gt;(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x80, 0x80);
+	idx_consts = eval(pshufb(pshufb_lut, (c &gt;&gt; 4)));
+}
+
+// Combine shuffle and special index constants
+
+if (shuf_zero_when_msb)
+	set_vr(op.rt4, ab_shuf | idx_consts);
+else
+	set_vr(op.rt4, select(noncast&lt;s8[16]&gt;(c) &gt;= 0, ab_shuf, idx_consts));</code></pre>
+      <figcaption>
+        <a
+          href="https://github.com/RPCS3/rpcs3/blob/cdbc43712bac68cd174f4c7305bfcd41d04db51c/rpcs3/Emu/Cell/SPULLVMRecompiler.cpp#L7635-L7658">
+          <cite>rpcs3/Emu/Cell/SPULLVMRecompiler.cpp</cite>, lines 7635&ndash;7658, in <code>SHUFB</code>
+        </a>
+      </figcaption>
+    </figure>
+
     <p>
       <a href="https://www.youtube.com/watch?v=19ae5Mq2lJE">Here's the video that discusses it</a>
     </p>