src/compute/skc/tile.h

/*
 * Copyright 2016 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can
 * be found in the LICENSE file.
 *
 */

#ifndef SKC_ONCE_TILE
#define SKC_ONCE_TILE

//
//
//

#include "macros.h"

//
// Hard requirements:
//
//   - A TTXB "block pool" extent that is at least 1GB.
//
//   - A virtual surface of at least 8K x 8K
//
//   - A physical surface of __don't really care__ because it's
//     advantageous to tile the physical surface since it's likely
//     to shrink the post-place TTCK sorting step.
//
//
//      EXTENT                 TTXB BITS
//     SIZE (MB) +------------------------------------+
//               |  22    23    24    25    26    27  |
//          +----+------------------------------------+
//          |  8 |  128   256   512  1024  2048  4096 |
//     TTXB | 16 |  256   512  1024  2048  4096  8192 |
//    WORDS | 32 |  512  1024  2048  4096  8192 16384 |
//          | 64 | 1024  2048  4096  8192 16384 32768 |
//          +----+------------------------------------+
//
//
//         SURF                        X/Y BITS
//         TILE  +------------------------------------------------------+
//               |   5     6     7     8     9    10    11    12    13  |
//          +----+------------------------------------------------------+
//          |  3 |  256   512  1024  2048  4096  8192 16384 32768 65536 |
//     TILE |  4 |  512  1024  2048  4096  8192 16384 32768 65536  128K |
//     SIDE |  5 | 1024  2048  4096  8192 16384 32768 65536  128K  256K |
//     BITS |  6 | 2048  4096  8192 16384 32768 65536  128K  256K  512K |
//          |  7 | 4096  8192 16384 32768 65536  128K  256K  512K 1024K |
//          +----+------------------------------------------------------+
//      TILES^2  | 1024  4096 16384 65536  256K    1M    4M   16M   64M |
//               +------------------------------------------------------+
//
// The following values should be pretty future-proof across all GPUs:
//
//   - The minimum addressable subblock size is 16 words (64 bytes) to
//     ensure there is enough space for a path or raster header and
//     its payload.
//
//   - Blocks are power-of-2 multiples of subblocks. Larger blocks can
//     reduce allocation activity (fewer atomic adds).
//
//   - 27 bits of TTXB_ID space implies a max of 4GB-32GB of
//     rasterized paths depending on the size of the TTXB block.
//     This could enable interesting use cases.
//
//   - A virtual rasterization surface that's from +/-16K to +/-128K
//     depending on the size of the TTXB block.
//
//   - Keys that (optionally) only require a 32-bit high word
//     comparison.
//
//   - Support for a minimum of 256K layers. This can be practically
//     raised to 1m or 2m layers.
//

//
// TTRK (64-bit COMPARE)
//
//  0                                         63
//  | TTSB ID |   X  |   Y  | RASTER COHORT ID |
//  +---------+------+------+------------------+
//  |    27   |  12  |  12  |        13        |
//
//
// TTRK (32-BIT COMPARE) ( DEFAULT )
//
//  0                                               63
//  | TTSB ID | N/A |   X  |   Y  | RASTER COHORT ID |
//  +---------+-----+------+------+------------------+
//  |    27   |  5  |  12  |  12  |        8         |
//
//
// TTSK v1
//
//  0                                     63
//  | TTSB ID | IS_PREFIX |  N/A |  X |  Y |
//  +---------+-----------+------+----+----+
//  |    27   |   1 (=0)  |  12  | 12 | 12 |
//
//
// TTPK v2 ( DEFAULT )
//
//  0                                       63
//  | TTPB ID | IS_PREFIX | SPAN |  X  |  Y  |
//  +---------+-----------+------+-----+-----+
//  |    27   |   1 (=1)  |  12  | 12  | 12  |
//
//
// TTCK (32-BIT COMPARE) v1
//
//  0                                                           63
//  | PAYLOAD/TTSB/TTPB ID | PREFIX | ESCAPE | LAYER |  X  |  Y  |
//  +----------------------+--------+--------+-------+-----+-----+
//  |          30          |    1   |    1   |   18  |  7  |  7  |
//
//
// TTCK (32-BIT COMPARE) v2
//
//  0                                                           63
//  | PAYLOAD/TTSB/TTPB ID | PREFIX | ESCAPE | LAYER |  X  |  Y  |
//  +----------------------+--------+--------+-------+-----+-----+
//  |          30          |    1   |    1   |   15  |  9  |  8  |
//
//
// TTCK (64-BIT COMPARE) -- achieves 4K x 4K with an 8x16 tile ( DEFAULT )
//
//  0                                                           63
//  | PAYLOAD/TTSB/TTPB ID | PREFIX | ESCAPE | LAYER |  X  |  Y  |
//  +----------------------+--------+--------+-------+-----+-----+
//  |          27          |    1   |    1   |   18  |  9  |  8  |
//

//
//
//

#define SKC_SUBPIXEL_RESL_X_LOG2  5
#define SKC_SUBPIXEL_RESL_Y_LOG2  5

//
// FIXME -- COMMON -- HOIST ELSEWHERE
//

#define SKC_TILE_WIDTH            (1 << SKC_TILE_WIDTH_LOG2)
#define SKC_TILE_HEIGHT           (1 << SKC_TILE_HEIGHT_LOG2)

#define SKC_SUBPIXEL_RESL_X       (1 << SKC_SUBPIXEL_RESL_X_LOG2)
#define SKC_SUBPIXEL_RESL_Y       (1 << SKC_SUBPIXEL_RESL_Y_LOG2)

//
// PLATFORM SURFACE TILE SIZE
//

#define SKC_TILE_WIDTH_MASK       SKC_BITS_TO_MASK(SKC_TILE_WIDTH_LOG2)
#define SKC_TILE_HEIGHT_MASK      SKC_BITS_TO_MASK(SKC_TILE_HEIGHT_LOG2)

//
// TILE SUBPIXEL RESOLUTION
//

#define SKC_SUBPIXEL_RESL_X       (1 << SKC_SUBPIXEL_RESL_X_LOG2)
#define SKC_SUBPIXEL_RESL_Y       (1 << SKC_SUBPIXEL_RESL_Y_LOG2)

#define SKC_SUBPIXEL_MASK_X       SKC_BITS_TO_MASK(SKC_SUBPIXEL_RESL_X_LOG2)
#define SKC_SUBPIXEL_MASK_Y       SKC_BITS_TO_MASK(SKC_SUBPIXEL_RESL_Y_LOG2)

#define SKC_SUBPIXEL_RESL_X_F32   ((float)(SKC_SUBPIXEL_RESL_X))
#define SKC_SUBPIXEL_RESL_Y_F32   ((float)(SKC_SUBPIXEL_RESL_Y))

#define SKC_SUBPIXEL_X_SCALE_UP   SKC_SUBPIXEL_RESL_X_F32
#define SKC_SUBPIXEL_Y_SCALE_UP   SKC_SUBPIXEL_RESL_Y_F32

#define SKC_SUBPIXEL_X_SCALE_DOWN (1.0f / SKC_SUBPIXEL_RESL_X_F32)
#define SKC_SUBPIXEL_Y_SCALE_DOWN (1.0f / SKC_SUBPIXEL_RESL_Y_F32)

//
// SUBTILE RESOLUTION
//

#define SKC_SUBTILE_RESL_X_LOG2   (SKC_TILE_WIDTH_LOG2  + SKC_SUBPIXEL_RESL_X_LOG2)
#define SKC_SUBTILE_RESL_Y_LOG2   (SKC_TILE_HEIGHT_LOG2 + SKC_SUBPIXEL_RESL_Y_LOG2)

#define SKC_SUBTILE_RESL_X        (1 << SKC_SUBTILE_RESL_X_LOG2)
#define SKC_SUBTILE_RESL_Y        (1 << SKC_SUBTILE_RESL_Y_LOG2)

#define SKC_SUBTILE_MASK_X        SKC_BITS_TO_MASK(SKC_SUBTILE_RESL_X_LOG2)
#define SKC_SUBTILE_MASK_Y        SKC_BITS_TO_MASK(SKC_SUBTILE_RESL_Y_LOG2)

#define SKC_SUBTILE_RESL_X_F32    ((float)(SKC_SUBTILE_RESL_X))
#define SKC_SUBTILE_RESL_Y_F32    ((float)(SKC_SUBTILE_RESL_Y))

#define SKC_SUBTILE_X_SCALE_DOWN  (1.0f / SKC_SUBTILE_RESL_X_F32)
#define SKC_SUBTILE_Y_SCALE_DOWN  (1.0f / SKC_SUBTILE_RESL_Y_F32)

//
//
//

#define SKC_TILE_X_OFFSET_U32     (1 << (SKC_TTSK_BITS_X-1))
#define SKC_TILE_X_SPAN_U32       (1 << (SKC_TTSK_BITS_X))   // exclusive

#define SKC_TILE_Y_OFFSET_U32     (1 << (SKC_TTSK_BITS_Y-1))
#define SKC_TILE_Y_SPAN_U32       (1 << (SKC_TTSK_BITS_Y))   // exclusive

#define SKC_TILE_X_OFFSET_F32     0 // ((float)SKC_TILE_X_OFFSET_U32)
#define SKC_TILE_X_SPAN_F32       ((float)SKC_TILE_X_SPAN_U32)

#define SKC_TILE_Y_OFFSET_F32     0 // ((float)SKC_TILE_Y_OFFSET_U32)
#define SKC_TILE_Y_SPAN_F32       ((float)SKC_TILE_Y_SPAN_U32)

//
// TILE TRACE SUBPIXEL, PREFIX & COMPOSITION KEYS
//
// These keys are are purposefully 64-bits so they can be sorted with
// Hotsort's 32:32 or 64-bit implementation.
//
// Tiles are 32x32 on CUDA but can be made rectangular or smaller to
// fit other architectures.
//
//   TW   : tile width
//   TH   : tile height
//
//   TTS  : tile trace subpixel
//   TTSB : tile trace subpixel block
//   TTRK : tile trace subpixel key while in raster cohort
//   TTSK : tile trace subpixel key
//
//   TTP  : tile trace prefix
//   TTPB : tile trace prefix block
//   TTPK : tile trace prefix key
//
//   TTCK : tile trace composition key
//

//
// TILE TRACE SUBPIXEL
//
// The subpixels are encoded with either absolute tile coordinates
// (32-bits) or packed in delta-encoded form form.
//
// For 32-bit subpixel packing of a 32x32 or smaller tile:
//
// A tile X is encoded as:
//
//   TX : 10 : unsigned min(x0,x1) tile subpixel coordinate.
//
//   SX :  6 : unsigned subpixel span from min to max x with range
//             [0,32]. The original direction is not captured. Would
//             be nice to capture dx but not necessary right now but
//             could be in the future. <--- SPARE VALUES AVAILABLE
//
// A tile Y is encoded as:
//
//   TY : 10 : unsigned min(y0,y1) tile subpixel coordinate.
//
//   DY :  6 : signed subpixel delta y1-y0. The range of delta is
//             [-32,32] but horizontal lines are not encoded so [1,32]
//             is mapped to [0,31]. The resulting range [-32,31] fits
//             in 6 bits.
//
// TTS:
//
//  0                        31
//  |  TX |  SX  |  TY |  DY  |
//  +-----+------+-----+------+
//  |  10 |   6  |  10 |   6  |
//

#define SKC_TTS_BITS_TX           10
#define SKC_TTS_BITS_SX           6
#define SKC_TTS_BITS_TY           10
#define SKC_TTS_BITS_SY           6

//
//
//

#define SKC_TTS_INVALID           ( SKC_UINT_MAX ) // relies on limited range of dx

//
//
//

#define SKC_TTS_OFFSET_SX         (SKC_TTS_BITS_TX)
#define SKC_TTS_OFFSET_TY         (SKC_TTS_BITS_TX + SKC_TTS_BITS_SX)
#define SKC_TTS_OFFSET_DY         (SKC_TTS_BITS_TX + SKC_TTS_BITS_SX + SKC_TTS_BITS_TY)

#define SKC_TTS_MASK_TX           SKC_BITS_TO_MASK(SKC_TTS_BITS_TX)
#define SKC_TTS_MASK_SX           SKC_BITS_TO_MASK_AT(SKC_TTS_BITS_SX,SKC_TTS_OFFSET_SX)
#define SKC_TTS_MASK_TY           SKC_BITS_TO_MASK_AT(SKC_TTS_BITS_TY,SKC_TTS_OFFSET_TY)

#define SKC_TTS_MASK_TX_PIXEL     SKC_BITS_TO_MASK_AT(SKC_TTS_BITS_TX-SKC_SUBPIXEL_RESL_X_LOG2, \
                                                      SKC_SUBPIXEL_RESL_X_LOG2)
#define SKC_TTS_MASK_TY_PIXEL     SKC_BITS_TO_MASK_AT(SKC_TTS_BITS_TY-SKC_SUBPIXEL_RESL_Y_LOG2, \
                                                      SKC_TTS_OFFSET_TY+SKC_SUBPIXEL_RESL_Y_LOG2)

//
// TTRK (64-BIT COMPARE)
//
//    0                                  63
//    | TTSB ID |   X  |   Y  | COHORT ID |
//    +---------+------+------+-----------+
//    |    27   |  12  |  12  |     13    |
//
//
// TTRK (32-BIT COMPARE)
//
//    0                                        63
//    | TTSB ID | N/A |   X  |   Y  | COHORT ID |
//    +---------+-----+------+------+-----------+
//    |    27   |  5  |  12  |  12  |     8     |
//

//
// TTRK is sortable intermediate key format for TTSK
//
// We're going to use the 32-bit comparison version for now
//

//
// TTSK v2:
//
//    0                                  63
//    | TTSB ID | PREFIX |  N/A |  X |  Y |
//    +---------+--------+------+----+----+
//    |    27   | 1 (=0) |  12  | 12 | 12 |
//
//
// TTPK v2:
//
//    0                                    63
//    | TTPB ID | PREFIX | SPAN |  X  |  Y  |
//    +---------+--------+------+-----+-----+
//    |    27   | 1 (=1) |  12  | 12  | 12  |
//

#define SKC_TTXK_LO_BITS_ID          27
#define SKC_TTXK_LO_BITS_PREFIX      1
#define SKC_TTXK_HI_BITS_Y           12
#define SKC_TTXK_HI_BITS_X           12
#define SKC_TTXK_BITS_SPAN           12
#define SKC_TTXK_HI_BITS_YX          (SKC_TTXK_HI_BITS_Y + SKC_TTXK_HI_BITS_X)

#define SKC_TTRK_HI_MASK_X           SKC_BITS_TO_MASK(SKC_TTXK_HI_BITS_X)
#define SKC_TTRK_HI_MASK_YX          SKC_BITS_TO_MASK(SKC_TTXK_HI_BITS_YX)

#define SKC_TTRK_HI_BITS_COHORT      8
#define SKC_TTRK_LO_BITS_NA          (32 - SKC_TTXK_LO_BITS_ID)
#define SKC_TTRK_HI_BITS_COHORT_Y    (SKC_TTRK_HI_BITS_COHORT + SKC_TTXK_HI_BITS_Y)

#define SKC_TTRK_HI_OFFSET_COHORT    (32 - SKC_TTRK_HI_BITS_COHORT)
#define SKC_TTRK_HI_MASK_COHORT      SKC_BITS_TO_MASK_AT(SKC_TTRK_HI_BITS_COHORT,SKC_TTRK_HI_OFFSET_COHORT)

#define SKC_TTRK_HI_BITS_COHORT_YX   (SKC_TTRK_HI_BITS_COHORT + SKC_TTXK_HI_BITS_Y + SKC_TTXK_HI_BITS_X)

#define SKC_TTXK_LO_BITS_ID_PREFIX   (SKC_TTXK_LO_BITS_ID + SKC_TTXK_LO_BITS_PREFIX)

#define SKC_TTXK_LO_OFFSET_PREFIX    SKC_TTXK_LO_BITS_ID
#define SKC_TTXK_LO_OFFSET_SPAN      SKC_TTXK_LO_BITS_ID_PREFIX

#define SKC_TTXK_LO_BITS_SPAN        (32 - SKC_TTXK_LO_BITS_ID_PREFIX)
#define SKC_TTXK_HI_BITS_SPAN        (SKC_TTXK_BITS_SPAN - SKC_TTXK_LO_BITS_SPAN)

#define SKC_TTXK_LO_OFFSET_PREFIX    SKC_TTXK_LO_BITS_ID

#define SKC_TTXK_LO_MASK_ID          SKC_BITS_TO_MASK(SKC_TTXK_LO_BITS_ID)
#define SKC_TTXK_LO_MASK_PREFIX      SKC_BITS_TO_MASK_AT(SKC_TTXK_LO_BITS_PREFIX,SKC_TTXK_LO_OFFSET_PREFIX)
#define SKC_TTXK_LO_MASK_ID_PREFIX   SKC_BITS_TO_MASK(SKC_TTXK_LO_BITS_ID_PREFIX)

#define SKC_TTXK_HI_OFFSET_Y         (32 - SKC_TTXK_HI_BITS_Y)
#define SKC_TTXK_HI_OFFSET_X         (SKC_TTXK_HI_OFFSET_Y - SKC_TTXK_HI_BITS_X)

#define SKC_TTXK_HI_ONE_X            (1u << SKC_TTXK_HI_OFFSET_X)

#define SKC_TTXK_HI_MASK_YX          SKC_BITS_TO_MASK_AT(SKC_TTXK_HI_BITS_YX,SKC_TTXK_HI_OFFSET_X)
#define SKC_TTXK_HI_MASK_Y           SKC_BITS_TO_MASK_AT(SKC_TTXK_HI_BITS_Y ,SKC_TTXK_HI_OFFSET_Y)

#define SKC_TTPK_LO_SHL_YX_SPAN      (SKC_TTXK_LO_OFFSET_SPAN - SKC_TTXK_HI_OFFSET_X)
#define SKC_TTPK_HI_SHR_YX_SPAN      (SKC_TTXK_HI_OFFSET_X + SKC_TTXK_LO_BITS_SPAN)

//
// TTCK (32-BIT COMPARE) v1 -- NOT USED:
//
//  0                                                           63
//  | PAYLOAD/TTSB/TTPB ID | PREFIX | ESCAPE | LAYER |  X  |  Y  |
//  +----------------------+--------+--------+-------+-----+-----+
//  |          30          |    1   |    1   |   18  |  7  |  7  |
//
//
// TTCK (32-BIT COMPARE) v2 -- NOT USED:
//
//  0                                                           63
//  | PAYLOAD/TTSB/TTPB ID | PREFIX | ESCAPE | LAYER |  X  |  Y  |
//  +----------------------+--------+--------+-------+-----+-----+
//  |          30          |    1   |    1   |   15  |  9  |  8  |
//
//
// TTCK (64-BIT COMPARE) -- achieves 4K x 4K with an 8x16 tile:
//
//  0                                                           63
//  | PAYLOAD/TTSB/TTPB ID | PREFIX | ESCAPE | LAYER |  X  |  Y  |
//  +----------------------+--------+--------+-------+-----+-----+
//  |          27          |    1   |    1   |   18  |  9  |  8  |
//

#define SKC_TTCK_BITS_LAYER               18

#define SKC_TTCK_LO_BITS_ID               SKC_TTXK_LO_BITS_ID
#define SKC_TTCK_LO_OFFSET_ID             0

#define SKC_TTCK_LO_MASK_ID               SKC_BITS_TO_MASK(SKC_TTCK_LO_BITS_ID)

#define SKC_TTCK_LO_BITS_PREFIX           1
#define SKC_TTCK_LO_OFFSET_PREFIX         SKC_TTCK_LO_BITS_ID
#define SKC_TTCK_LO_MASK_PREFIX           SKC_BITS_TO_MASK_AT(SKC_TTCK_LO_BITS_PREFIX,SKC_TTCK_LO_OFFSET_PREFIX)

#define SKC_TTCK_LO_BITS_ID_PREFIX        (SKC_TTCK_LO_BITS_ID + SKC_TTCK_LO_BITS_PREFIX)
#define SKC_TTCK_LO_MASK_ID_PREFIX        SKC_BITS_TO_MASK(SKC_TTCK_LO_BITS_ID_PREFIX)

#define SKC_TTCK_LO_BITS_ESCAPE           1
#define SKC_TTCK_LO_OFFSET_ESCAPE         SKC_TTCK_LO_BITS_ID_PREFIX
#define SKC_TTCK_LO_MASK_ESCAPE           SKC_BITS_TO_MASK_AT(SKC_TTCK_LO_BITS_ESCAPE,SKC_TTCK_LO_OFFSET_ESCAPE)

#define SKC_TTCK_LO_BITS_ID_PREFIX_ESCAPE (SKC_TTCK_LO_BITS_ID_PREFIX + SKC_TTCK_LO_BITS_ESCAPE)

#define SKC_TTCK_HI_OFFSET_Y              24
#define SKC_TTCK_HI_OFFSET_X              15

#define SKC_TTCK_HI_BITS_Y                8
#define SKC_TTCK_HI_BITS_X                9
#define SKC_TTCK_HI_BITS_YX               (SKC_TTCK_HI_BITS_X + SKC_TTCK_HI_BITS_Y)
#define SKC_TTCK_HI_MASK_YX               SKC_BITS_TO_MASK_AT(SKC_TTCK_HI_BITS_YX,SKC_TTCK_HI_OFFSET_X)

#define SKC_TTCK_HI_BITS_LAYER            (32 - SKC_TTCK_HI_BITS_YX)
#define SKC_TTCK_HI_MASK_LAYER            SKC_BITS_TO_MASK(SKC_TTCK_HI_BITS_LAYER)
#define SKC_TTCK_HI_SHR_LAYER             (SKC_TTCK_HI_BITS_Y + SKC_TTCK_HI_BITS_X + SKC_TTCK_BITS_LAYER - 32)

#define SKC_TTCK_LO_BITS_LAYER            (SKC_TTCK_BITS_LAYER - SKC_TTCK_HI_BITS_LAYER)

//
// TILE COORD
//
//  0                32
//  | N/A |  X  |  Y  |
//  +-----+-----+-----+
//  |  8  | 12  | 12  |
//
//
// This simplifies the clip test in the place kernel.
//

union skc_tile_coord
{
  skc_uint   u32;

  struct {
#if defined(__OPENCL_C_VERSION__)
    skc_uint xy;
#else
    skc_uint na0 : 32 - SKC_TTXK_HI_BITS_YX;  // 8
    skc_uint x   : SKC_TTXK_HI_BITS_X;        // 12
    skc_uint y   : SKC_TTXK_HI_BITS_Y;        // 12
#endif
  };
};

SKC_STATIC_ASSERT(sizeof(union skc_tile_coord) == sizeof(skc_uint));

//
//
//

union skc_tile_clip
{
  skc_uint               u32a2[2];

  skc_uint2              u32v2;

  struct {
    union skc_tile_coord xy0; // lower left
    union skc_tile_coord xy1; // upper right
  };
};

SKC_STATIC_ASSERT(sizeof(union skc_tile_clip) == sizeof(skc_uint2));

//
//
//

#endif

//
//
//