wave8.h

Go to the documentation of this file.

 
 
#pragma once
 
// allow-include-after-namespace
 
#include "fl/stl/align.h"
#include "fl/stl/compiler_control.h"
#include "fl/stl/stdint.h"
 
namespace fl {
 
struct ChipsetTiming;

struct Wave8Bit {
    u8 data;  // Each bit represents one pulse (MSB first)
};

struct FL_ALIGNAS(8) Wave8Byte {
    Wave8Bit symbols[8];  // 8 bytes total (8 symbols × 1 byte each)
};
 
// ============================================================================
// Nibble Lookup Table (LUT) Types and Generator
// ============================================================================

struct FL_ALIGNAS(8) Wave8BitExpansionLut {
    Wave8Bit lut[16][4]; // nibble -> 4 Wave8Bit (4 bytes per nibble)
};

struct FL_ALIGNAS(8) Wave8ByteExpansionLut {
    Wave8Byte lut[256]; // byte -> 8 Wave8Bit (8 bytes per byte)
};

Wave8BitExpansionLut buildWave8ExpansionLUT(const ChipsetTiming &timing);

Wave8ByteExpansionLut buildWave8ByteExpansionLUT(const Wave8BitExpansionLut &nibble);
 
// Forward declaration for inline function (implementation in detail/wave8.hpp)
void wave8(u8 lane,
           const Wave8BitExpansionLut &lut,
           u8 (&FL_RESTRICT_PARAM output)[sizeof(Wave8Byte)]);
 
// Public transposition functions (implementations in wave8.cpp)
void wave8Transpose_2(
    const u8 (&FL_RESTRICT_PARAM lanes)[2],
    const Wave8BitExpansionLut &lut,
    u8 (&FL_RESTRICT_PARAM output)[2 * sizeof(Wave8Byte)]);
 
void wave8Transpose_4(
    const u8 (&FL_RESTRICT_PARAM lanes)[4],
    const Wave8BitExpansionLut &lut,
    u8 (&FL_RESTRICT_PARAM output)[4 * sizeof(Wave8Byte)]);
 
void wave8Transpose_8(
    const u8 (&FL_RESTRICT_PARAM lanes)[8],
    const Wave8BitExpansionLut &lut,
    u8 (&FL_RESTRICT_PARAM output)[8 * sizeof(Wave8Byte)]);
 
void wave8Transpose_16(
    const u8 (&FL_RESTRICT_PARAM lanes)[16],
    const Wave8BitExpansionLut &lut,
    u8 (&FL_RESTRICT_PARAM output)[16 * sizeof(Wave8Byte)]);
 
// Byte-LUT overloads (#2526): same semantics, faster expansion path.
void wave8Transpose_2(
    const u8 (&FL_RESTRICT_PARAM lanes)[2],
    const Wave8ByteExpansionLut &lut,
    u8 (&FL_RESTRICT_PARAM output)[2 * sizeof(Wave8Byte)]);
 
void wave8Transpose_4(
    const u8 (&FL_RESTRICT_PARAM lanes)[4],
    const Wave8ByteExpansionLut &lut,
    u8 (&FL_RESTRICT_PARAM output)[4 * sizeof(Wave8Byte)]);
 
void wave8Transpose_8(
    const u8 (&FL_RESTRICT_PARAM lanes)[8],
    const Wave8ByteExpansionLut &lut,
    u8 (&FL_RESTRICT_PARAM output)[8 * sizeof(Wave8Byte)]);
 
void wave8Transpose_16(
    const u8 (&FL_RESTRICT_PARAM lanes)[16],
    const Wave8ByteExpansionLut &lut,
    u8 (&FL_RESTRICT_PARAM output)[16 * sizeof(Wave8Byte)]);

void wave8Transpose_16x2_pipe2(
    const u8 (&FL_RESTRICT_PARAM lanes_a)[16],
    const u8 (&FL_RESTRICT_PARAM lanes_b)[16],
    const Wave8ByteExpansionLut &lut,
    u8 (&FL_RESTRICT_PARAM output_a)[16 * sizeof(Wave8Byte)],
    u8 (&FL_RESTRICT_PARAM output_b)[16 * sizeof(Wave8Byte)]);

void wave8Transpose_16x4_pipe4(
    const u8 (&FL_RESTRICT_PARAM lanes_a)[16],
    const u8 (&FL_RESTRICT_PARAM lanes_b)[16],
    const u8 (&FL_RESTRICT_PARAM lanes_c)[16],
    const u8 (&FL_RESTRICT_PARAM lanes_d)[16],
    const Wave8ByteExpansionLut &lut,
    u8 (&FL_RESTRICT_PARAM output_a)[16 * sizeof(Wave8Byte)],
    u8 (&FL_RESTRICT_PARAM output_b)[16 * sizeof(Wave8Byte)],
    u8 (&FL_RESTRICT_PARAM output_c)[16 * sizeof(Wave8Byte)],
    u8 (&FL_RESTRICT_PARAM output_d)[16 * sizeof(Wave8Byte)]);

void wave8Transpose_2_bf1(
    const u8 (&FL_RESTRICT_PARAM lanes)[2],
    const Wave8ByteExpansionLut &lut,
    u8 (&FL_RESTRICT_PARAM output)[2 * sizeof(Wave8Byte)]);

void wave8Transpose_4_bf1(
    const u8 (&FL_RESTRICT_PARAM lanes)[4],
    const Wave8ByteExpansionLut &lut,
    u8 (&FL_RESTRICT_PARAM output)[4 * sizeof(Wave8Byte)]);

void wave8Transpose_8_bf1(
    const u8 (&FL_RESTRICT_PARAM lanes)[8],
    const Wave8ByteExpansionLut &lut,
    u8 (&FL_RESTRICT_PARAM output)[8 * sizeof(Wave8Byte)]);

void wave8Transpose_16_bf1(
    const u8 (&FL_RESTRICT_PARAM lanes)[16],
    const Wave8ByteExpansionLut &lut,
    u8 (&FL_RESTRICT_PARAM output)[16 * sizeof(Wave8Byte)]);

void wave8Transpose_16x4_bf1_pipe4(
    const u8 (&FL_RESTRICT_PARAM lanes_a)[16],
    const u8 (&FL_RESTRICT_PARAM lanes_b)[16],
    const u8 (&FL_RESTRICT_PARAM lanes_c)[16],
    const u8 (&FL_RESTRICT_PARAM lanes_d)[16],
    const Wave8ByteExpansionLut &lut,
    u8 (&FL_RESTRICT_PARAM output_a)[16 * sizeof(Wave8Byte)],
    u8 (&FL_RESTRICT_PARAM output_b)[16 * sizeof(Wave8Byte)],
    u8 (&FL_RESTRICT_PARAM output_c)[16 * sizeof(Wave8Byte)],
    u8 (&FL_RESTRICT_PARAM output_d)[16 * sizeof(Wave8Byte)]);
 
// Untranspose functions (for testing - reverse the transpose operation)
void wave8Untranspose_2(
    const u8 (&FL_RESTRICT_PARAM transposed)[2 * sizeof(Wave8Byte)],
    u8 (&FL_RESTRICT_PARAM output)[2 * sizeof(Wave8Byte)]);
 
void wave8Untranspose_4(
    const u8 (&FL_RESTRICT_PARAM transposed)[4 * sizeof(Wave8Byte)],
    u8 (&FL_RESTRICT_PARAM output)[4 * sizeof(Wave8Byte)]);
 
void wave8Untranspose_8(
    const u8 (&FL_RESTRICT_PARAM transposed)[8 * sizeof(Wave8Byte)],
    u8 (&FL_RESTRICT_PARAM output)[8 * sizeof(Wave8Byte)]);
 
void wave8Untranspose_16(
    const u8 (&FL_RESTRICT_PARAM transposed)[16 * sizeof(Wave8Byte)],
    u8 (&FL_RESTRICT_PARAM output)[16 * sizeof(Wave8Byte)]);
 
} // namespace fl
 
// Include inline implementations for optimal performance
// This must be after the namespace to avoid the include-after-namespace linter error