拙訳「Low Level Optimizations for GCN」

float2 TexcoordToScreenPos(float2 inUV, float4 inFov) {
    float2 p = inUV;
    p.x = p.x * inFov.x + inFov.z;
    p.y = p.y * inFov.y + inFov.w;
    return p;
}Copy

s_buffer_load_dwordx4 s[0:3], s[12:15], 0x08
s_waitcnt lgkmcnt(0)
v_mov_b32 v2, s2
v_mov_b32 v3, s3
s_waitcnt vmcnt(0) & lgkmcnt(15)
v_mac_f32 v2, s0, v0
v_mac_f32 v3, s1, v1Copy

float2 TexcoordToScreenPos(float2 inUV) {
    float2 p = inUV;
    p.x = p.x * 2.0 + (-1.0);
    p.y = p.y * -2.0 + 1.0;
    return p;
}Copy

v_mad_f32 v0, v0, 2.0, -1.0
v_mad_f32 v1, v1, -2.0, 1.0Copy

// v_bfe_u32の参考実装
uint BitFieldExtract(uint inSrc, uint inOffset, uint inSize) {
    return (inSrc >> inOffset) & ((1 << inSize) - 1);
}Copy

// v_bfe_i32の参考実装
uint BitFieldExtractSignExtend(uint inSrc, uint inOffset, uint inSize) {
    uint size = inSize & 0x1f;
    uint offset = inOffset & 0x1f;
    uint data = inSrc >> offset;
    uint signBit = data & (1 << (size - 1));
    uint mask = (1 << size) - 1;
    return (-int(signBit)) | (mask & data);
}Copy

// 127, -1, -126をRGB_11_11_10にパックする
// 整数は2の補数である
// packed_data = 00001111111 11111111111 1110000010
// R(127)をアンパックする
BFE(packed_data, 21, 11) = 0000 0000 0000 0000 0000 0000 0111 1111
// B(-126)をアンパックする
BFE(packed_data, 0, 11) = 1111 1111 1111 1111 1111 1111 1000 0010Copy

// Int16のパッキング
int PackInt2ToInt(in int inX, in int inY) {
    return (clamp(inX, -int(0x8000), 0x7fff) & 0xffff) | (clamp(inY, -int(0x8000), 0x7f00) <<16);
}

int2 UnpackInt2FromInt(in int inPackedInt) {
    return int2(
        BitFieldExtractSignExtend((int)inPackedInt, uint(0), uint(16)),
        BitFieldExtractSignExtend((int)inPackedInt, uint(16), uint(16)),
    );
}Copy

// SNorm16のパッキング
int PackSNorm2ToUInt(in float inX, in float inY) {
    return (clamp(int(inX * 0x7fff), -int(0x7fff), 0x7fff) & 0xffff) | (clamp(int(inY * 0x7fff), -int(0x7fff), 0x7fff) << 16);
}

int2 UnpackSNorm2FromUInt(in uint inPackedUInt) {
    return float2(
        BitFieldExtractSignExtend((int)inPackedUInt, uint(0), uint(16)) / float(0x7fff),
        BitFieldExtractSignExtend((int)inPackedUInt, uint(16), uint(16)) / float(0x7fff),
    );
}Copy

uint FastLog2(uint inX) {
    return firstbithigh(inX) - 1;
}Copy

// ソフトウェアのトライアングル錐台(ニア面)クリッピング
// 一次方程式[line equations]の前の頂点ソート
float v0 = b[0]; float v1 = b[1]; float v2 = b[2];
if (b[0] > near_z || b[1] > near_z || b[2] > near_z) {
    if (b[1] > near_z) { v0 = t[1]; v1 = t[2]; v2 = t[0]; }
    if (b[2] > near_z) { v0 = t[2]; v1 = t[0]; v2 = t[1]; }
}
if ((b[0] > near_z && b[1] > near_z) ||
    (b[0] > near_z && b[2] > near_z) ||
    (b[1] > near_z && b[2] > near_z)) {
    if (!(b[0] > near_z)) { v0 = t[1]; v1 = t[2]; v2 = t[0]; }
    if (!(b[1] > near_z)) { v0 = t[2]; v1 = t[0]; v2 = t[1]; }
}
// コンパイルすると: フルレートのALUが42つ ＋ (16フルレート以上の)BRANCHが4つCopy

// ソフトウェアのトライアングル錐台(ニア面)クリッピング
// 一次方程式[line equations]の前の頂点ソート
uint bitfield = 0;
bitfield |= b[0] > near_z ? 0x1 << 0 : 0x0;
bitfield |= b[1] > near_z ? 0x1 << 1 : 0x0;
bitfield |= b[2] > near_z ? 0x1 << 2 : 0x0;

float v0 = b[0]; float v1 = b[1]; float v2 = b[2];
uint csb = CountSetBits(bitfield);
uint csb_eq2 = (csb >> 1) & 0x1;

if (bitfield & 0x2 & csb) {v0 = t[1]; v1 = t[2]; v2 = t[0]; }
if (bitfield & 0x4 & csb) {v0 = t[2]; v1 = t[0]; v2 = t[1]; }
if (!(bitfield & 0x1) && csb_eq2) {v0 = t[1]; v1 = t[2]; v2 = t[0]; }
if (!(bitfield & 0x2) && csb_eq2) {v0 = t[2]; v1 = t[0]; v2 = t[1]; }Copy

v_cubetc_f32 v1, v2, v3, v0  // tc座標を計算する
v_cubesc_f32 v4, v2, v3, v0  // sc座標を計算する
v_cubema_f32 v5, v2, v3, v0  // 主軸[major axis]を計算する
v_cubeid_f32 v8, v2, v3, v0  // 面IDを計算する
v_rcp_f32 v2, abs(v5)
s_mov_b32 s0, 0x3fc00000
v_mad_f32 v7, v1, v2, s0  // 最終的な面UVを計算する
v_mad_f32 v6, v4, v2, s0  // 最終的な面UVを計算する
image_sample v[0:3], v[6:9], s[4:11], s[12:15]  // テクスチャ配列Copy

// v_cubeid_f32の参考実装
float CubeMapFaceID(float inX, float inY, float inZ) {
    float3 v = float3(inX, inY, inZ);
    float faceID;

    if (abs(v.z) >= abs(v.x) && abs(v.z) >= abs(v.y)) {
        faceID = (v.z < 0.0) ? 5.0 : 4.0;
    } else if (abs(v.y) >= abs(v.x)) {
        faceID = (v.y < 0.0) ? 3.0 : 2.0;
    } else {
        faceID = (v.x < 0.0) ? 1.0 : 0.0;
    }
    return faceID;
}Copy

float3 PackNormalMajorAxis(float3 inNormal) {
    uint index = 2;
    if (abs(inNormal.x) >= abs(inNormal.y) && abs(inNormal.x) >= abs(inNormal.z)) {
        index = 0;
    } else if (abs(inNormal.y) > abs(inNormal.z)) {
        index = 1;
    }

    float3 normal = inNormal;
    normal = index == 0 ? normal.yzx : normal;
    normal = index == 1 ? normal.xzy : normal;

    float s = normal.z > 0.0 ? 1.0 : -1.0;
    float3 packedNormal;
    packedNormal.xy = normal.xy * s;
    packedNormal.z = index / 2.0f;
    return packedNormal;
}

// コンパイルすると:
// フルレートの28つのALU ＋ (16フルレート以上の)2つのBRANCHCopy

float3 PackNormalMajorAxis(float3 inNormal) {
    uint index = CubeMapFaceID(inNormal.x, inNormal.y, inNormal.z) * 0.5f;

    float3 normal = inNormal;
    normal = index == 0 ? normal.yzx : normal;
    normal = index == 1 ? normal.xzy : normal;

    float s = normal.z > 0.0 ? 1.0 : -1.0;
    float3 packedNormal;
    packedNormal.xy = normal.xy * s;
    packedNormal.z = index / 2.0f;
    return packedNormal;
}

// コンパイルすると:
// フルレートの17つのALUCopy

float4 Interpolate(float4 A, float4 B, float4 C, float2 Vij) {
    return A *  (1.0 - Vij.x - Vij.y) + B * Vij.x + c * Vij.y;
}Copy

struct Interpolants {
    float4 position : SV_POSITION;
    float4 color : COLOR0;
};

float4 main(Interpolants In) : COLOR {
    float4 Out;
    Out = In.color;
    return Out;
}Copy

v_interp_p1_f32 v2, v0, attr0.x  // LDSからAttr0のためにデータをロードして、Vi(補間の第1パート(V00, V01を使って))処理する
                                 //
v_interp_p2_f32 v2, v1, attr0.x  // LDSからAttr0のためにデータをロードして、Vj(補間の第2パート(V01、V10を用いて))を処理する
v_interp_p1_f32 v3, v0, attr0.y
v_interp_p2_f32 v3, v1, attr0.y
v_interp_p1_f32 v4, v0, attr0.z
v_interp_p2_f32 v4, v1, attr0.z
v_interp_p1_f32 v0, v0, attr0.w
v_interp_p2_f32 v0, v1, attr0.wCopy

struct Interpolants {
    float4 position : SV_POSITION;
    float4 color : COLOR0;
};

float4 main(Interpolants In) : COLOR {
    float4 Out;
    Out = In.color;
    return Out;
}Copy

v_interp_mov_f32 v0, p0, attr0.x  // LDSからのAttr0に対して頂点p0からデータをロードする
v_interp_mov_f32 v1, p0, attr0.y  // LDSからのAttr0に対して頂点p0からデータをロードする
v_interp_mov_f32 v2, p0, attr0.z  // LDSからのAttr0に対して頂点p0からデータをロードする
v_interp_mov_f32 v3, p0, attr0.w  // LDSからのAttr0に対して頂点p0からデータをロードするCopy

float4 Interpolate(float4 A, float4 B, float4 C, floatt3 barycentric) {
    return A * barycentric.z + B * barycentric.x + C * barycentric.y;
}Copy

float3 barycentric;
barycentric.xy = GetBarycentricCoordsPerspectiveCenter();  // ハードウェアからVi Vjを読む
barycentric.z = 1 - barycentric.x - barycentric.y;

uint rawA = (GetVertexParameterP0(In.color_packed));  // V00から生のUINTデータを読む
uint rawB = (GetVertexParameterP1(In.color_packed));  // V01から生のUINTデータを読む
uint rawC = (GetVertexParameterP2(In.color_packed));  // V10から生のUINTデータを読む

float4 decompressedA = UnpackColor(rawA);  // UINTからByteをアンパックして、floatに変換する
float4 decompressedB = UnpackColor(rawB);  // UINTからByteをアンパックして、floatに変換する
float4 decompressedC = UnpackColor(rawC);  // UINTからByteをアンパックして、floatに変換する

float4 Out;
Out = Interpolate(decompressedA, decompressedB, decompressedC, barycentric);Copy

// 低速なコード --- いくつかのコンパイラはマクロを最適化するほどアグレッシブではない
float3 vector;
float vectorLength = length(vector);  // コンパイラの最良ケース: sqrt(dot(vector, vector))を展開する
float3 normalVector = normalize(vector);  // コンパイラの最良ケース: vector * rsqrt(dot(vector, vector))を展開するCopy

// タイミング: (FR --- フルレートサイクル --- 4サイクル)
v_mov_b32     v0, s2           // 1FR
v_mul_f32     v1, s2, v0       // 1FR
v_mov_b32     v2, s1           // 1FR
v_mac_f32     v1, s1, v2       // 1FR
v_mov_b32     v3, s0           // 1FR
v_mac_f32     v1, s0, v3       // 1FR
v_sqrt_f32    v1, v1           // 4FR
v_mul_f32     v0, s2, v0       // 1FR
v_mac_f32     v0, s1, v2       // 1FR
v_mac_f32     v0, s0, v3       // 1FR
v_rsq_f32     v0, v0           // 4FR
v_mov_b32     v2, #0x7f7fffff  // 1FR
v_mov_b32     s3, #0xff7fffff  // 1FR
v_med3_f32    v0, v0, s3, v2   // 1FR
v_mul_f32     v2, s0, v0       // 1FR
v_mul_f32     v3, s1, v0       // 1FR
v_mul_f32     v0, s2, v0       // 1FR
// MOVを含めない合計               // 18FRCopy

// 手動でマクロをアンロールすることによりコンパイラを補助する
// これは常に良いプラクティスである
float dotVector = dot(inVector, inVector);
float vectorLength = sqrt(dotVector);
float3 normalVector = inVector * rcp(vectorLength);Copy

// タイミング : (FR - フルレートサイクル - 4サイクル):
v_mov_b32     v0, s2       // 1 FR
v_mul_f32     v0, s2, v0   // 1 FR
v_mov_b32     v1, s1       // 1 FR
v_mac_f32     v0, s1, v1   // 1 FR
v_mov_b32     v1, s0       // 1 FR
v_mac_f32     v0, s0, v1   // 1 FR
v_rsq_f32     v1, v0       // 4 FR
v_sqrt_f32    v0, v0       // 4 FR
v_mul_f32     v2, s0, v1   // 1 FR
v_mul_f32     v3, s1, v1   // 1 FR
v_mul_f32     v1, s2, v1   // 1 FR
// MOVを含めない合計           //14 FRCopy

// FR数と悪用[exploiting]によるパイプライン化でより良くできる
// sqrt(x) = rsqrt(x) * x
// rcp(x) = rsqrt(x) * rsqrt(x)  // Xが正のときのみ
float dotVector = dot(inVector, inVector);
float rcpVectorLength = rsqrt(dotVector);
float vectorLength = rcpVectorLength * dotVector;
float3 normalVector = inVector * rcpVectorLength;Copy

// この結果は:
v_mov_b32     v0, s2       // 1 FR
v_mul_f32     v0, s2, v0   // 1 FR
v_mov_b32     v1, s1       // 1 FR
v_mac_f32     v0, s1, v1   // 1 FR
v_mov_b32     v1, s0       // 1 FR
v_mac_f32     v0, s0, v1   // 1 FR
v_rsq_f32     v1, v0       // 4 FR
v_mul_f32     v0, v0, v1   // 1 FR
v_mul_f32     v2, s0, v1   // 1 FR
v_mul_f32     v3, s1, v1   // 1 FR
v_mul_f32     v1, s2, v1   // 1 FR
// MOVを含めない合計           //11 FRCopy

// asint() / asfloat()はreinterpret_castとして動作する
// タダ --- 異なる命令セットを用いるデータを扱うためにコンパイラにヒントを与えるだけ

#define asint(_x) *reinterpret_cast<int*>(&_x);
#define asfloat(_x) *reinterpret_cast<float*>(&_x);Copy

float Q_rsqrt(float number) {
    long i;
    float x2, y;
    const float threehalfs = 1.5f;

    x2 = number * 0.5f;
    y = number;
    i = *(long*)&y;                       // floatからintへの再翻訳
    i = 0x5f3759df - (i >> 1);            // WTF?
    y = *(float*)&i;                      // intからfloatへの再翻訳
    y = y * (threehalfs - (x2 * y * y));  // ニュートン・ラフソン法の1回目

    return y;
}Copy

int x = asint(inX);
x = 0x5f3759df - (x >> 1);
return asfloat(x);Copy

v_ashr_i32 v0, v0, 1
v_sub_i32 v0, # 0x5f3759df, v0Copy

// 2フルレート
float rcpSqrtIEEEIntApproximation(float inX, const int inRcpSqrtConst) {
    int x = asint(inX);
    x = inRcpSqrtConst - (x >> 1);
    return asfloat(x);
}

// 2フルレート
float sqrtIEEEIntApproximation(float inX, const int inSqrtConst) {
    int x = asint(inX);
    x = inSqrtConst + (x >> 1);
    return asfloat(x);
}

// 1フルレート
float rcpIEEEIntApproximation(float inX, const int inRcpConst) {
    int x = asint(inX);
    x = inRcpConst - x;
    return asfloat(x);
}Copy

float r = inV.x / inV.y;Copy

// IEEE strictなし
// xはv1、yはv2
v_rcp_f32 v0, v1  // 安全でないrcp()はNaNが生成され得る
v_mul_f32 v0, v2, v0Copy

// IEEE strict安全な-fastmath
// xはv1、yはv2
v_rcp_f32 v0, v1  // 安全でないrcp()はNaNが生成され得る
v_mov_b32 v1, #0x7f7fffff  // MAX_FLT
v_mov_b32 s1, #0xff7fffff  // MIN_FLT
v_med3_f32 v0, v0, s1, v1  // NaNを消去するための安全なクランピング
v_mul_legacy_f32 v0, v2, v0Copy

float r = inV.x / inV.y;Copy

// IEEE strict safe accurateは非正規数を洗い流す
// xはv1、yはv2
v_rcp_f32 v0, v1
v_mul_f32 v0, v0, v2
v_div_fixup_f32 v3, v0, v1, v2  // -/+INF NaN QNaNを直すCopy

float r = inV.x / inV.y;Copy

// IEEE strict safe accurateは非正規数に対応する
// 丸めモードや非正規数の出力に応じて
// コンパイラは以下を追加できる
v_rcp_f32
v_mul_f32
v_div_scale_f32
nop
nop
nop
nop
v_div_fmas_f32Copy