Method GetCVKernelBody

compiler/lib/KernelGen/GeneralIntrinsic/Flip.cpp:32–146

}

std::string FlipKernel::GetCVKernelBody(TContext* context) const {
    auto kernel_sig = GetCVKernelSignature(context);
    std::stringstream writer;
    writer << R"(
        #include <string.h>
        #include "gi_int.h"
        #include "tinycv_c.h"
        #define rep(i, n) for (size_t i = 0; i < (n); ++i)
        )";
    std::string body_temp = R"(
        static void flip_horizontal_on_channel_c1(uint8_t* dst, const uint8_t* src, size_t W) {
            size_t j = 0;
            for (; j + 15 < W; j += 16) {
                    GI_UINT8_t src_vec = GiLoadUint8(src + j);
                    GI_UINT8_t dst_vec = GiReverseUint8(src_vec);
                    GiStoreUint8((dst + W - j - 16), dst_vec);
            }
            for (; j < W; ++j) {
                    *(dst + W - j - 1) = *(src + j);
            }
        }
         static void flip_horizontal_on_channel_c3(uint8_t* dst, const uint8_t* src, size_t W) {
            size_t j = 0;
            for (; j + 15 < W; j += 16) {
                GI_UINT8_t src_vec0, src_vec1, src_vec2;
                src_vec0 = GiLoadUzip0V3Uint8(src + j * 3);
                src_vec1 = GiLoadUzip1V3Uint8(src + j * 3);
                src_vec2 = GiLoadUzip2V3Uint8(src + j * 3);

                GI_UINT8_t dst_vec0 = GiReverseUint8(src_vec0);
                GI_UINT8_t dst_vec1 = GiReverseUint8(src_vec1);
                GI_UINT8_t dst_vec2 = GiReverseUint8(src_vec2);
                GiStoreZipUint8V3((dst + W * 3 - 3 * j - 48), dst_vec0, dst_vec1, dst_vec2);

              
            }
            for (; j < W; ++j) {
                *(dst + W * 3 - j * 3 - 3) = *(src + j * 3);
                *(dst + W * 3 - j * 3 - 2) = *(src + j * 3 + 1);
                *(dst + W * 3 - j * 3 - 1) = *(src + j * 3 + 2);
                
            }
        }

        static void flip_horizontal_naive(uint8_t* dst, const uint8_t* src, size_t W,
                                size_t C) {
            size_t sc = 0;
            size_t dc = W * C;
            for (; sc + 8 * C <= W * C; sc += 8 * C, dc -= 8 * C) {
                rep(ic, C) dst[dc - 1 * C + ic] = src[sc + 0 * C + ic];
                rep(ic, C) dst[dc - 2 * C + ic] = src[sc + 1 * C + ic];
                rep(ic, C) dst[dc - 3 * C + ic] = src[sc + 2 * C + ic];
                rep(ic, C) dst[dc - 4 * C + ic] = src[sc + 3 * C + ic];
                rep(ic, C) dst[dc - 5 * C + ic] = src[sc + 4 * C + ic];
                rep(ic, C) dst[dc - 6 * C + ic] = src[sc + 5 * C + ic];
                rep(ic, C) dst[dc - 7 * C + ic] = src[sc + 6 * C + ic];
                rep(ic, C) dst[dc - 8 * C + ic] = src[sc + 7 * C + ic];
            }