File: 05_packed_load_store.ispc

package info (click to toggle)
ispc 1.26.0-1
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 95,356 kB
  • sloc: cpp: 55,778; python: 6,681; yacc: 3,074; lex: 1,095; ansic: 714; sh: 283; makefile: 16
file content (64 lines) | stat: -rw-r--r-- 5,999 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
// Copyright (c) 2021-2024, Intel Corporation
// SPDX-License-Identifier: BSD-3-Clause

export uniform int width() { return programCount; }

// This case loads based on condition.
#define PACKEDLOAD(T_ISPC)                                                                                             \
    export uniform uint32 packed_load_active_##T_ISPC##_eq(uniform T_ISPC *uniform src, uniform T_ISPC *uniform dst,   \
                                                           uniform const uint index, uniform int count) {              \
        uniform int32 num = 0;                                                                                         \
        uint32 val = 0;                                                                                                \
        foreach (i = 0...count) {                                                                                      \
            varying T_ISPC var = 0;                                                                                    \
            if ((programIndex & index) == 0)                                                                           \
                num += packed_load_active(&src[num], &var);                                                            \
            val += var;                                                                                                \
        }                                                                                                              \
        return reduce_add(val);                                                                                        \
    }                                                                                                                  \
                                                                                                                       \
    export uniform uint32 packed_load_active_##T_ISPC##_neq(uniform T_ISPC *uniform src, uniform T_ISPC *uniform dst,  \
                                                            uniform const uint index, uniform int count) {             \
        uniform int32 num = 0;                                                                                         \
        uint32 val = 0;                                                                                                \
        foreach (i = 0...count) {                                                                                      \
            varying T_ISPC var = 0;                                                                                    \
            if ((programIndex & index) != 0)                                                                           \
                num += packed_load_active(&src[num], &var);                                                            \
            val += var;                                                                                                \
        }                                                                                                              \
        return reduce_add(val);                                                                                        \
    }

// This case stores based on condition.
#define PACKEDSTORE(T_ISPC, STORE_TYPE)                                                                                \
    export uniform uint32 STORE_TYPE##_##T_ISPC##_eq(uniform T_ISPC *uniform src, uniform T_ISPC *uniform dst,         \
                                                     uniform const uint index, uniform int count) {                    \
        uniform int32 num = 0;                                                                                         \
        foreach (i = 0...count) {                                                                                      \
            varying T_ISPC var = src[i];                                                                               \
            if ((programIndex & index) == 0)                                                                           \
                num += STORE_TYPE(&dst[num], var);                                                                     \
        }                                                                                                              \
        return num;                                                                                                    \
    }                                                                                                                  \
                                                                                                                       \
    export uniform uint32 STORE_TYPE##_##T_ISPC##_neq(uniform T_ISPC *uniform src, uniform T_ISPC *uniform dst,        \
                                                      uniform const uint index, uniform int count) {                   \
        uniform int32 num = 0;                                                                                         \
        foreach (i = 0...count) {                                                                                      \
            varying T_ISPC var = src[i];                                                                               \
            if ((programIndex & index) != 0)                                                                           \
                num += STORE_TYPE(&dst[num], var);                                                                     \
        }                                                                                                              \
        return num;                                                                                                    \
    }

PACKEDLOAD(int32)
PACKEDSTORE(int32, packed_store_active)
PACKEDSTORE(int32, packed_store_active2)

PACKEDLOAD(int64)
PACKEDSTORE(int64, packed_store_active)
PACKEDSTORE(int64, packed_store_active2)