「MD5: RFC 1321 を実装してみる」にある C++ プログラムを弄って改良を試みます。

オリジナル・プログラム (テスト部分は改良版と同じものに変更)

md5bs_orig.cpp

//
// ヘッダ用
//

#include <cstddef>
#include <cstdint>

/*
 * MD5ByteSum
 */

class MD5ByteSum
{
public:
    typedef uint32_t State[4];
    typedef uint32_t Block[16];
    typedef uint8_t Digest[16];
    typedef char HexDigest[33];

protected:
    static const uint8_t padding[64];

    State state;
    uint32_t bytes;
    Block input;
    bool active;

public:
    MD5ByteSum();
    MD5ByteSum(const void *message, size_t size);

    void digest(Digest &out);
    void hexdigest(HexDigest &out);

    void initialize();
    void update(const void *message, size_t size);
    void finalize();

protected:
    void update_state();
};

/*
 * MD5ByteSum - inline
 */

inline MD5ByteSum::MD5ByteSum()
{
    initialize();
}

//
// コンパイル用
//

/*
 * MD5ByteSum::State - update 16-Word block
 */

inline static uint32_t ROL(uint32_t x, int s)
{
    return ((x << s) | (x >> (32 - s)));
}

inline static uint32_t get_block_index(uint32_t index)
{
    /*
     * [y|y|x|x|x|x]
     *  (index * 1 + 0) & 15
     *  (index * 5 + 1) & 15
     *  (index * 3 + 5) & 15
     *  (index * 7 + 0) & 15
     */
    uint32_t x = index & 0x0f;
    uint32_t y = index & 0x30;
    uint32_t y1 = index & 0x10;
    uint32_t y2 = index & 0x20;
    uint32_t xmul = (y1 >> 2) | (y2 >> 4) | 1;
    uint32_t offs = (0x0510 >> (y >> 2)) & 7;
    return (x * xmul + offs) & 15;
}

inline static int get_rotate_bits(uint32_t index)
{
    /*
     * [y|y|.|.|x|x]
     *  7 12 17 22 : 3 8 13 18 : 3 3 3 3 : 3 3 3 2
     *  5  9 14 20 : 1 5 10 16 : 1 0 0 1 : 1 0 0 0
     *  4 11 16 23 : 0 7 12 19 : 0 2 2 4 : 0 2 2 3
     *  6 10 15 21 : 2 6 11 17 : 2 1 1 2 : 2 1 1 1
     *              -4          -(x*5)    -(x==3)
     *
     *  11 11 11 10 : 10_11_11_11 = bf
     *  01 00 00 00 : 00_00_00_01 = 01
     *  00 10 10 11 : 11_10_10_00 = e8
     *  10 01 01 01 : 01_01_01_10 = 56
     */
    uint32_t x = index & 0x03;
    uint32_t y = index & 0x30;
    uint32_t p = x | (y >> 2);
    uint32_t x0 = (0x56e801bf >> (p << 1)) & 3;
    uint32_t x3 = (x + 1) >> 2; // (x == 3) ? 1 : 0;
    uint32_t x5 = x * 5;
    return x0 + x3 + x5 + 4;
}

inline static uint32_t get_state_index(uint32_t index, uint32_t element)
{
    /*
     *  0 1 2 3
     *  3 0 1 2
     *  2 3 0 1
     *  1 2 3 0
     */
    return ((index * 3) + element) & 3;
}

inline static uint32_t md5bs_state_func(uint32_t index, uint32_t x, uint32_t y, uint32_t z)
{
    switch ((index >> 4) & 3)
    {
    case 0: return (y & x) | (z & ~x);
    case 1: return (x & z) | (y & ~z);
    case 2: return x ^ y ^ z;
    case 3: return y ^ (x | ~z);
    }
    return 0;
}

inline static void md5bs_state_update(uint32_t index, uint32_t *S, const MD5ByteSum::Block &X, uint32_t T)
{
    uint32_t a = get_state_index(index, 0);
    uint32_t b = get_state_index(index, 1);
    uint32_t c = get_state_index(index, 2);
    uint32_t d = get_state_index(index, 3);
    uint32_t x = get_block_index(index);
    uint32_t r = get_rotate_bits(index);

    S[a] = S[b] + ROL(X[x] + T + S[a] + md5bs_state_func(index, S[b], S[c], S[d]), r);
}

inline static void md5bs_state_update(uint32_t index, uint32_t *S,
                                      const MD5ByteSum::Block &X,
                                      uint32_t T1, uint32_t T2,
                                      uint32_t T3, uint32_t T4)
{
    md5bs_state_update(index + 0, S, X, T1);
    md5bs_state_update(index + 1, S, X, T2);
    md5bs_state_update(index + 2, S, X, T3);
    md5bs_state_update(index + 3, S, X, T4);
}

void MD5ByteSum::update_state()
{
    State p;

    p[0] = state[0];
    p[1] = state[1];
    p[2] = state[2];
    p[3] = state[3];

    // Round 1.
    md5bs_state_update( 0 * 4, state, input, 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee);
    md5bs_state_update( 1 * 4, state, input, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501);
    md5bs_state_update( 2 * 4, state, input, 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be);
    md5bs_state_update( 3 * 4, state, input, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821);

    // Round 2.
    md5bs_state_update( 4 * 4, state, input, 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa);
    md5bs_state_update( 5 * 4, state, input, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8);
    md5bs_state_update( 6 * 4, state, input, 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed);
    md5bs_state_update( 7 * 4, state, input, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a);

    // Round 3.
    md5bs_state_update( 8 * 4, state, input, 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c);
    md5bs_state_update( 9 * 4, state, input, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70);
    md5bs_state_update(10 * 4, state, input, 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05);
    md5bs_state_update(11 * 4, state, input, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665);

    // Round 4.
    md5bs_state_update(12 * 4, state, input, 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039);
    md5bs_state_update(13 * 4, state, input, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1);
    md5bs_state_update(14 * 4, state, input, 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1);
    md5bs_state_update(15 * 4, state, input, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391);

    state[0] += p[0];
    state[1] += p[1];
    state[2] += p[2];
    state[3] += p[3];
}

/*
 * MD5ByteSum
 */

const uint8_t MD5ByteSum::padding[64] = { 0x80 };

MD5ByteSum::MD5ByteSum(const void *message, size_t size)
{
    initialize();
    update(message, size);
    // finalize();
}

void MD5ByteSum::initialize()
{
    state[0] = 0x67452301;
    state[1] = 0xefcdab89;
    state[2] = 0x98badcfe;
    state[3] = 0x10325476;
    bytes = 0;
    for (int i = 0; i < 16; i++)
        input[i] = 0;
    active = true;
}

void MD5ByteSum::finalize()
{
    if (!active)
        return;

    uint32_t l = bytes;
    uint32_t i = l & 0x3f;
    uint32_t n = ((i >= 56) ? 64 : 0) + 56 - i;

    update(padding, n);

    input[14] = l << 3;
    input[15] = l >> 29;
    update_state();

    active = false;
}

void MD5ByteSum::update(const void *message, size_t size)
{
    if (!active)
        initialize();

    const uint8_t *d = reinterpret_cast<const uint8_t *>(message);
    unsigned b = (bytes & 3) << 3;
    unsigned i = (bytes >> 2) & 0x0f;

    bytes += size;
    while (size-- > 0)
    {
        input[i] |= (*d++) << b;

        b = (b + 8) & 0x1f;
        if (b == 0)
        {
            i = (i + 1) & 0x0f;
            if (i == 0)
                update_state();
            input[i] = 0;
        }
    }
}

void MD5ByteSum::digest(Digest &out)
{
    finalize();

    for (int p = 0; p < 4; p++)
    {
        uint32_t s = state[p];

        for (int q = 0; q < 4; q++, s >>= 8)
            out[p * 4 + q] = uint8_t(s);
    }
}

void MD5ByteSum::hexdigest(HexDigest &out)
{
    finalize();

    for (int p = 0; p < 4; p++)
    {
        uint32_t s = state[p];

        for (unsigned q = 0; q < 4; q++, s >>= 8)
        {
            char h = (s >> 4) & 0x0f;
            char l = (s >> 0) & 0x0f;
            out[p * 8 + q * 2 + 0] = h + ((h < 10) ? '0' : ('a' - 10));
            out[p * 8 + q * 2 + 1] = l + ((l < 10) ? '0' : ('a' - 10));
        }
    }
    out[32] = 0;
}

//
// テスト用
//

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cinttypes>
#include <time.h>

inline uint64_t RDTSC()
{
#if defined(_MSC_VER) ||   \
    (defined(__clang__) && \
     (defined(__amd64) ||  \
      defined(__i386) ||   \
      defined(__x86) ||    \
      defined(__x86_64)))

    return __rdtsc();

#elif defined(__GNUC__) && \
    (defined(__amd64) ||   \
     defined(__i386) ||    \
     defined(__x86) ||     \
     defined(__x86_64))

    uint32_t eax, edx;
    __asm__ volatile ("RDTSC" : "=a" (eax), "=d" (edx));
    return ((uint64_t)edx << 32) | eax;

#else

    timespec c;
    clock_gettime(CLOCK_REALTIME, &c);
    return ((uint64_t)c.tv_sec * 1000 * 1000 * 1000 + c.tv_nsec);

#endif
}

static void prepare_message(uint8_t *d, size_t dlen, const uint8_t *s, size_t slen)
{
    size_t clen = slen;
    if (clen > dlen)
        clen = dlen;
    std::memcpy(d, s, clen);
    d += clen;
    dlen -= clen;
    if (dlen != 0)
        prepare_message(d, dlen, s, slen + clen);
}

static int string_message(const char *message, const char *digest = NULL)
{
    size_t msglen = strlen(message);
    MD5ByteSum md5(message, msglen);
    MD5ByteSum::HexDigest res;

    md5.hexdigest(res);
    printf("MD5 (\"%s\") = %s\n", message, res);
    if (!digest)
        return 0;
    if (!strcmp(digest, res))
        return 0;
    printf("BUG: %s != %s\n", digest, res);
    return 2;
}

static int file_message(const char *path)
{
    MD5ByteSum md5;
    MD5ByteSum::HexDigest res;

    size_t size = 1024 * 1024;
    void *buffer = malloc(size);

    if (!buffer)
    {
        printf("not enough memory.");
        return 2;
    }

    bool success = true;
    FILE *fp = fopen(path, "rb");

    if (!fp)
    {
        printf("open error: %s\n", path);
        return 2;
    }
    while (!feof(fp))
    {
        size_t rdsz = fread(buffer, 1, size, fp);
        if (ferror(fp))
        {
            success = false;
            break;
        }
        if (!rdsz)
            break;
        md5.update(buffer, rdsz);
    }
    fclose(fp);
    free(buffer);
    if (!success)
    {
        printf("read error: %s\n", path);
        return 2;
    }

    md5.hexdigest(res);
    printf("MD5 (%s) = %s\n", path, res);

    return 0;
}

static int benchmark(const char *message)
{
    if (!message)
        message = "benchmark";
    int rval = string_message(message);
    if (rval)
        return rval;

    size_t msglen = strlen(message);
    size_t blocks = (4 * 1024 * 1024);
    size_t bufsize = sizeof(MD5ByteSum::Block) * blocks;
    uint8_t *buffer = (uint8_t *)malloc(bufsize);
    if (!buffer)
    {
        puts("not enough memory.");
        return 2;
    }
    if (msglen)
    {
        uint8_t *d = buffer;
        std::memcpy(d, message, msglen);
        prepare_message(d + msglen, bufsize - msglen, buffer, msglen);
    }
    else
    {
        std::memset(buffer, -1, bufsize);
    }

    MD5ByteSum md5;
    MD5ByteSum::HexDigest res;

    uint64_t s_tsc = RDTSC();
    {
        const uint8_t *p = buffer;
        size_t s = bufsize;

#define STEP(n) md5.update(p, n); p += n; s -= n;
        // 動作テスト用に分解(計測への影響は極小)
        STEP(17);     // 0
        STEP(17);     // 17
        STEP(63);     // 34
        STEP(31+128); // 97
        STEP(s);
    }
    uint64_t e_tsc = RDTSC();
    uint64_t d_tsc = e_tsc - s_tsc;
    uint64_t ave_i = d_tsc / blocks;
    uint64_t ave_f = (100 * (d_tsc % blocks) + (blocks / 2)) / blocks;

    md5.hexdigest(res);
    printf("TEST digest: %s\n", res);
    // printf("timer start  : %" PRIu64 "\n", s_tsc);
    // printf("timer end    : %" PRIu64 "\n", e_tsc);
    printf("timer count  : %" PRIu64 "\n", d_tsc);
    printf("block average: %" PRIu64 ".%02" PRIu64 "\n", ave_i, ave_f);

    free(buffer);
    return 0;
}

static int test()
{
    static const char *tab[] = {
        "d41d8cd98f00b204e9800998ecf8427e", "",
        "0cc175b9c0f1b6a831c399e269772661", "a",
        "900150983cd24fb0d6963f7d28e17f72", "abc",
        "f96b697d7cb7938d525a2f31aaf161d0", "message digest",
        "c3fcd3d76192e4007dfb496cca67e13b", "abcdefghijklmnopqrstuvwxyz",
        "d174ab98d277d9f5a5611c2c9f419d9f", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
        "ad76b175d22a98a4e3bc2ad72affc53e", "01234567890123456789012345678901234567890123456789012345678",
        NULL, NULL,
    };
    for (int i = 0; tab[i] != NULL; i += 2)
    {
        int res = string_message(tab[i + 1], tab[i + 0]);
        if (res != 0)
            return res;
    }
    return 0;
}

static const char *program;
static int usage()
{
    printf("Usage:\n"
           "  %s -b [message]\n"
           "  %s -f file\n"
           "  %s message\n",
           program, program, program);
    return 1;
}

int main(int argc, char **argv)
{
    program = argv[0];
    if (argc < 2)
        return usage();
    if (!strcmp(argv[1], "-b"))
    {
        if (argc < 4)
            return benchmark(argv[2]);
        return usage();
    }
    if (!strcmp(argv[1], "-f"))
    {
        if (argc == 3)
            return file_message(argv[2]);
        return usage();
    }
    if (!strcmp(argv[1], "-t"))
        return test();
    if (argc == 2)
        return string_message(argv[1]);
    return usage();
}

改良の試み

主に、メモリへのアクセスのパターンの変更と SIMD レジスタの使用ですが、できるだけコンパイラの最適化に依存します。

改良を試みたプログラム

md5bs.cpp

///////////////////////////////////////////////////////////////////////////////
//
// ヘッダ ファイル用
//
///////////////////////////////////////////////////////////////////////////////

#include <cstddef>
#include <cstdint>

/*
 * alignas(n) : バイト境界指定
 *   x86/x64 では alignas(16) で XMM レジスタの活用を期待する
 */

#if (__cplusplus < 201103L) && !defined(alignas)
#  if defined(__GNUC__)
#    define alignas(n)  __attribute__((__aligned__(n)))
#  elif defined(_MSC_VER)
#    define alignas(n)  __declspec(align(n))
#  else
#    define alignas(n)  /**/
#  endif
#endif

/*
 * MD5ByteSum クラス
 *   アプリケーションは、コンストラクタ,update,digest,hexdigest の呼び出しだけでよい
 *   initialize, finalize は必要に応じて自動的に呼び出される
 */
class MD5ByteSum
{
public:
    typedef uint32_t State[4];
    typedef uint32_t Block[16];
    typedef uint8_t Digest[16];
    typedef char HexDigest[33];

protected:
    alignas(64) Block input;
    alignas(64) Block adbuf[4];
    alignas(16) State state;
    uint32_t bytes;
    bool active;

public:
    MD5ByteSum();
    MD5ByteSum(const void *message, size_t size);

    void update(const void *message, size_t size);
    void digest(Digest &out);
    void hexdigest(HexDigest &out);

    void initialize();
    void finalize();

protected:
    void update_state();
    void update_state(const void *block);
};

/*
 * MD5ByteSum (inline)
 */

// コンストラクタ
inline MD5ByteSum::MD5ByteSum()
{
    initialize();
}

// ダイジェスト値(state)の更新:
//   入力するブロックは input メンバー変数を使う
inline void MD5ByteSum::update_state()
{
    update_state(input);
}

///////////////////////////////////////////////////////////////////////////////
//
// コンパイル ファイル用
//
///////////////////////////////////////////////////////////////////////////////

#include <cstring>

// ベクトル型の代用
namespace // anonymous
{
    template <typename T, int N>
    struct md5bs_vector
    {
        typedef md5bs_vector<T,N> self_type;

        T value[N];

        T &operator [](int n)
            { return value[n]; }
        T operator [](int n) const
            { return value[n]; }
        self_type operator +(const self_type &rhs) const
            {
                self_type r;

                for (int i = 0; i < N; i++)
                    r[i] = value[i] + rhs[i];
                return r;
            }
    };
}

/*
 * MD5BS_ISA_ARM : ARM 命令セット
 * MD5BS_ISA_X86 : x86 命令セット
 */
#if defined(__arm__)
#  define MD5BS_ISA_ARM  1
#endif
#if (defined(__amd64)  || \
     defined(__i386)   || \
     defined(__x86)    || \
     defined(__x86_64))
#  define MD5BS_ISA_X86  1
#endif

#ifndef MD5BS_ISA_ARM
#  define MD5BS_ISA_ARM  0
#endif
#ifndef MD5BS_ISA_X86
#  define MD5BS_ISA_X86  0
#endif

/*
 * __dummy_access    : コンパイラの最適化抑制用
 * __force_inline    : 強制インライン展開のお呪い
 * __no_inline       : インライン展開抑制のお呪い
 * md5bs_clear_cache : キャッシュのクリア
 * md5bs_prefetch    : キャッシュへの先読み
 */
#if defined(__GNUC__)
#  define __force_inline  __attribute__((always_inline)) inline
#  define __no_inline  __attribute__((noinline))
#  define md5bs_clear_cache(s,e)  __builtin___clear_cache((char*)(s), (char*)(e))
#  define md5bs_prefetch(p)  __builtin_prefetch(p)
#elif defined(_MSC_VER)
#  define __force_inline  __forceinline
#  define __no_inline     __noinline
#endif

#if !defined(__dummy_access)
#  if defined(__GNUC__)
#    define __dummy_access(m)  __asm__ volatile ("#dummy %0":/**/:"m" (m))
#  else
#    define __dummy_access(m)
#  endif
#endif
#if !defined(__force_inline)
#  define __force_inline  inline
#endif
#if !defined(__no_inline)
#  define __no_inline
#endif
#if !defined(md5bs_clear_cache)
#  define md5bs_clear_cache(s,e)  /*NOOP*/
#endif
#if !defined(md5bs_prefetch)
#  define md5bs_prefetch(p)  /*NOOP*/
#endif

/*
 * MD5BS_BIG_ENDIAN        : ビッグ・エンディアン
 * MD5BS_ADDRESS_ALIGN     : バイト境界アクセスが必要
 * MD5BS_CACHE_LINE_SIZE   : キャッシュのライン・サイズ
 * MD5BS_BLOCK_PREPARE     : int(abs(sin(i))*(1<<32)) の加算済みブロックを用意
 * MD5BS_BLOCK_X_ORDER     : 加算済みブロックの配列を T の並びから X の並びに変更
 * MD5BS_HAS_SIMD          : SIMD 機能を明示的に使用
 * MD5BS_SIMD_REGISTER     : コア・レジスタの代わりに SIMD レジスタを使用
 *       良 : 使用出来るレジスタが増えてスタック・フレームへのアクセスが減る場合がある
 *       悪 : SIMD 命令がコア・レジスタの命令よりスループットが遅い場合がある
 * MD5BS_SIMD_REGISTER_128 : 128ビット・レジスタの有無
 * MD5BS_SIMD_REGISTER_256 : 256ビット・レジスタの有無
 */

/*
 * ARM
 */

#if MD5BS_ISA_ARM
#  if !defined(MD5BS_CACHE_LINE_SIZE)
#    define MD5BS_CACHE_LINE_SIZE  32
#  endif
#  if defined(__ARM_NEON__) && !defined(MD5BS_HAS_SIMD)
#    define MD5BS_HAS_SIMD  1
#    define MD5BS_ISA_ARM_NEON  1
#    define MD5BS_BLOCK_PREPARE_ARM  0

#    include <arm_neon.h>

typedef uint32x2_t md5bs_simd2_t;
typedef uint32x4_t md5bs_simd4_t;
typedef md5bs_simd2_t md5bs_alt_uint32_t;

#  endif
#  if !defined(MD5BS_BLOCK_PREPARE_ARM)
#    define MD5BS_BLOCK_PREPARE_ARM  0
#  endif
#  if !defined(MD5BS_BLOCK_PREPARE)
#    define MD5BS_BLOCK_PREPARE  MD5BS_BLOCK_PREPARE_ARM
#  endif
#endif

/*
 * x86
 */

#if MD5BS_ISA_X86
#  define MD5BS_BIG_ENDIAN  0
#  if defined(__SSE4_1__) && !defined(MD5BS_HAS_SIMD)
#    define MD5BS_HAS_SIMD  1
#    define MD5BS_ISA_X86_SSE4_1  1
#    if !defined(MD5BS_CACHE_LINE_SIZE)
#      define MD5BS_CACHE_LINE_SIZE  64
#    endif
#    define MD5BS_BLOCK_PREPARE_X86  1
#    if !defined(MD5BS_BLOCK_X_ORDER)
#      define MD5BS_BLOCK_X_ORDER  1
#    endif
#    if defined(__clang__) && !defined(MD5BS_SIMD_REGISTER)
#      define MD5BS_SIMD_REGISTER  1
#    endif

#    include <immintrin.h>

typedef __v2si md5bs_simd2_t;
typedef __v4su md5bs_simd4_t;
typedef md5bs_simd4_t md5bs_alt_uint32_t;

#    if defined(__AVX__)
#      define MD5BS_SIMD_REGISTER_256 1

typedef __v8su md5bs_simd8_t;

#    endif

#  elif defined(__clang__)
#    define MD5BS_BLOCK_PREPARE_X86  1
#  endif
#  if !defined(MD5BS_BLOCK_PREPARE_X86)
#    define MD5BS_BLOCK_PREPARE_X86  0
#  endif
#  if !defined(MD5BS_BLOCK_PREPARE)
#    define MD5BS_BLOCK_PREPARE  MD5BS_BLOCK_PREPARE_X86
#  endif
#endif

/*
 * 未定義の解消
 */

#ifndef MD5BS_BIG_ENDIAN
#  if (defined(__BYTE_ORDER__) && \
       (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
#    define MD5BS_BIG_ENDIAN  1
#  else
#    define MD5BS_BIG_ENDIAN  0
#  endif
#endif
#ifndef MD5BS_ADDRESS_ALIGN
#  define MD5BS_ADDRESS_ALIGN  0
#endif
#ifndef MD5BS_CACHE_LINE_SIZE
#  define MD5BS_CACHE_LINE_SIZE  0
#endif
#ifndef MD5BS_BLOCK_PREPARE
#  define MD5BS_BLOCK_PREPARE  0
#endif
#ifndef MD5BS_BLOCK_X_ORDER
#  define MD5BS_BLOCK_X_ORDER  0
#endif

#ifndef MD5BS_HAS_SIMD
#  define MD5BS_HAS_SIMD  0
#endif
#ifndef MD5BS_SIMD_REGISTER
#  define MD5BS_SIMD_REGISTER  0
#elif !defined(MD5BS_SIMD_REGISTER_128)
#  define MD5BS_SIMD_REGISTER_128 1
#endif
#ifndef MD5BS_SIMD_REGISTER_128
#  define MD5BS_SIMD_REGISTER_128 0
#endif
#ifndef MD5BS_SIMD_REGISTER_256
#  define MD5BS_SIMD_REGISTER_256 0
#endif

#if !MD5BS_HAS_SIMD
typedef md5bs_vector<uint32_t,2> md5bs_simd2_t;
typedef md5bs_vector<uint32_t,4> md5bs_simd4_t;
typedef uint32_t md5bs_uint32_t;
#elif !MD5BS_SIMD_REGISTER /*  && MD5BS_HAS_SIMD */
typedef uint32_t md5bs_uint32_t;
#else /* MD5BS_HAS_SIMD && MD5BS_SIMD_REGISTER */
typedef md5bs_alt_uint32_t md5bs_uint32_t;
#endif
#if !MD5BS_SIMD_REGISTER_256
typedef md5bs_vector<md5bs_simd4_t,2> md5bs_simd8_t;
#endif

// 32ビットをリトル・エンディアンとして読み込む関数型
typedef uint32_t (*md5bs_load32)(const uint32_t &, bool);

// ポインタ型を uint8_t * 型に変換
__force_inline
static uint8_t *md5bs_uint8_p(void *p)
{
    return reinterpret_cast<uint8_t *>(p);
}

// const ポインタ型を const uint8_t * 型に変換
__force_inline
static const uint8_t *md5bs_uint8_p(const void *p)
{
    return reinterpret_cast<const uint8_t *>(p);
}

// const ポインタ型を const uint32_t * 型に変換
__force_inline
static const uint32_t *md5bs_uint32_p(const void *p)
{
    return reinterpret_cast<const uint32_t *>(p);
}

// ポインタ型を md5bs_simd4_t * 型に変換
__force_inline
static md5bs_simd4_t *md5bs_simd4_p(void *p)
{
    return reinterpret_cast<md5bs_simd4_t *>(p);
}

// const ポインタ型を const md5bs_simd4_t * 型に変換
__force_inline
static const md5bs_simd4_t *md5bs_simd4_p(const void *p)
{
    return reinterpret_cast<const md5bs_simd4_t *>(p);
}

// ポインタ型を md5bs_simd8_t * 型に変換
__force_inline
static md5bs_simd8_t *md5bs_simd8_p(void *p)
{
    return reinterpret_cast<md5bs_simd8_t *>(p);
}

// const ポインタ型を const md5bs_simd4_t * 型に変換
__force_inline
static const md5bs_simd8_t *md5bs_simd8_p(const void *p)
{
    return reinterpret_cast<const md5bs_simd8_t *>(p);
}

// ポインタ型を intptr_t 型に変換
__force_inline
static intptr_t md5bs_intptr(const void *p)
{
    return reinterpret_cast<intptr_t>(p);
}

// ポインタのアドレスが4バイト境界ならば true
__force_inline
static bool md5bs_is_align4(const void *p)
{
    return ((md5bs_intptr(p) & 3) == 0);
}

// ビッグ・エンディアン構成の CPU 用
//   リトル・エンディアン形式の32ビット整数を取り出す
//   aligned が true の場合は x のアドレスが4バイト境界ではない
//   [最適化によるバイト・オーダー変換命令の使用を期待する]
__force_inline
static uint32_t md5bs_load32be(const uint32_t &x, bool aligned)
{
    uint32_t b0, b1, b2, b3;

    if (aligned)
    {
        b3 = (x >>  0) & 0xff;
        b2 = (x >>  8) & 0xff;
        b1 = (x >> 16) & 0xff;
        b0 = (x >> 24) & 0xff;
    }
    else
    {
        const uint8_t *p = md5bs_uint8_p(&x);

        b0 = p[0];
        b1 = p[1];
        b2 = p[2];
        b3 = p[3];
    }
    return ((b3 << 24) | (b2 << 16) | (b1 << 8) | (b0 << 0));
}

// リトル・エンディアン構成の CPU 用
//   リトル・エンディアン形式の32ビット整数を取り出す
//   [最適化による非境界アクセス命令の使用を期待する]
__force_inline
static uint32_t md5bs_load32le(const uint32_t &x, bool aligned)
{
    if (aligned || !MD5BS_ADDRESS_ALIGN)
        return x;

    const uint8_t *p = md5bs_uint8_p(&x);
    uint32_t b0 = p[0];
    uint32_t b1 = p[1];
    uint32_t b2 = p[2];
    uint32_t b3 = p[3];

    return ((b0 << 0) | (b1 << 8) | (b2 << 16) | (b3 << 24));
}

// 32ビットをリトル・エンディアンとして読み込む関数を得る
__force_inline
static md5bs_load32 md5bs_load32_func(bool endian)
{
    return endian ? md5bs_load32be : md5bs_load32le;
}

/*
 * SIMD 向け
 */

#if MD5BS_HAS_SIMD
#  if MD5BS_ISA_ARM

//
// ARM
//

namespace // anonymous
{
    template <typename T>
    struct vfp_cast_type
    {
        template <typename U>
        __force_inline
        static T from(U s)
        {
#if MD5BS_BIG_ENDIAN
#error "TODO"
#endif
            union
            {
                T d;
                U s;
            } u;

            u.s = s;
            return u.d;
        }
    };

    template <>
    struct vfp_cast_type<uint32_t>
    {
        __force_inline
        static uint32_t from(uint32_t s)
            { return s; }

        template <typename U>
        __force_inline
        static uint32_t from(U s)
            { return s[0]; }
    };

} // anonymous

template <typename dT, typename sT>
__force_inline
static dT vfp_cast(sT s)
{
    return vfp_cast_type<dT>::from(s);
}

template <typename T>
__force_inline
static md5bs_uint32_t md5bs_uint32(T x)
{
    return vfp_cast<md5bs_uint32_t>(x);
}

template <typename T>
__force_inline
static md5bs_simd4_t md5bs_simd(T x)
{
    return vfp_cast<md5bs_simd4_t>(x);
}

#    if MD5BS_SIMD_REGISTER /* ARM */

__force_inline
static uint64x1_t md5bs_vshl_n_s64(uint64x1_t x, int s)
{
    switch (s)
    {
#define MD5BS_VSHL_N_S64_CASE_1(n) case (n): return vshl_n_s64(x, (n))
#define MD5BS_VSHL_N_S64_CASE_2(n)      \
        MD5BS_VSHL_N_S64_CASE_1(n + 0); \
        MD5BS_VSHL_N_S64_CASE_1(n + 1)
#define MD5BS_VSHL_N_S64_CASE_4(n)      \
        MD5BS_VSHL_N_S64_CASE_2(n + 0); \
        MD5BS_VSHL_N_S64_CASE_2(n + 2)
#define MD5BS_VSHL_N_S64_CASE_8(n)      \
        MD5BS_VSHL_N_S64_CASE_4(n + 0); \
        MD5BS_VSHL_N_S64_CASE_4(n + 4)
#define MD5BS_VSHL_N_S64_CASE_16(n)     \
        MD5BS_VSHL_N_S64_CASE_8(n + 0); \
        MD5BS_VSHL_N_S64_CASE_8(n + 8)
#define MD5BS_VSHL_N_S64_CASE_32(n)      \
        MD5BS_VSHL_N_S64_CASE_16(n + 0); \
        MD5BS_VSHL_N_S64_CASE_16(n + 16)

        MD5BS_VSHL_N_S64_CASE_32(0);
        MD5BS_VSHL_N_S64_CASE_32(32);
    }
    return (uint64x1_t){0};
}

__force_inline
static md5bs_simd4_t md5bs_simd_add(const md5bs_simd4_t &a, const md5bs_simd4_t &b)
{
    return vaddq_u32(a, b);
}

__force_inline
static md5bs_alt_uint32_t md5bs_rotate(md5bs_alt_uint32_t x, int s)
{
    x[1] = x[0];
    x = vfp_cast<uint32x2_t>(md5bs_vshl_n_s64(vfp_cast<uint64x1_t>(x), s));
    x[0] = x[1];
    return x;
}

__force_inline
static md5bs_uint32_t md5bs_simd_read(md5bs_simd4_t q, int n)
{
    return vfp_cast<md5bs_uint32_t>(q[n]);
}

__force_inline
static md5bs_simd4_t md5bs_simd_write(md5bs_simd4_t &p, int n, md5bs_uint32_t v)
{
    md5bs_simd4_t r = p;

    r[n] = vfp_cast<uint32_t>(v);
    return r;
}

#    endif
#  elif MD5BS_ISA_X86 /* x86 */

//
// x86
//

// uint32/xmm, xmm/xmm 型の変換
namespace // anonymous
{
    template <typename T>
    struct xmm_cast_type
    {
        __force_inline
        static T from(uint32_t s)
            { return (T)_mm_cvtsi32_si128(s); }
        template <typename U>
        __force_inline
        static T from(U s)
            { return (T)s; }
    };

    template <>
    struct xmm_cast_type<uint32_t>
    {
        __force_inline
        static uint32_t from(uint32_t s)
            { return s; }

        template <typename U>
        __force_inline
        static uint32_t from(U s)
            { return (uint32_t)_mm_cvtsi128_si32(s); }
    };

} // anonymous

template <typename dT, typename sT>
__force_inline
static dT xmm_cast(sT s)
{
    return xmm_cast_type<dT>::from(s);
}

template <typename T>
__force_inline
static __m128 md5bs_m128(T v)
{
    return xmm_cast<__m128>(v);
}

template <typename T>
__force_inline
static __m128i md5bs_m128i(T v)
{
    return xmm_cast<__m128i>(v);
}

template <typename T>
__force_inline
static md5bs_uint32_t md5bs_uint32(T x)
{
    return xmm_cast<md5bs_uint32_t>(x);
}

template <typename T>
__force_inline
static md5bs_simd4_t md5bs_simd(T x)
{
    return xmm_cast<md5bs_simd4_t>(x);
}

#    if MD5BS_SIMD_REGISTER /* x86 */

// xmm レジスタ型へのアクセス
__force_inline
static md5bs_uint32_t md5bs_simd_read(md5bs_simd4_t q, int n)
{
    __m128i p = md5bs_m128i(q);

    switch ((n & 3))
    {
    case 0: return md5bs_uint32(_mm_shuffle_epi32(p, 0x00));
    case 1: return md5bs_uint32(_mm_shuffle_epi32(p, 0x55));
    case 2: return md5bs_uint32(_mm_shuffle_epi32(p, 0xaa));
    case 3: return md5bs_uint32(_mm_shuffle_epi32(p, 0xff));
    }
    return md5bs_uint32(q ^ q); /* 警告抑制用：意味は無い */
    // return 0; // はエラーになる
}

__force_inline
static md5bs_simd4_t md5bs_simd_write(md5bs_simd4_t q, int n, md5bs_simd4_t w)
{
    __m128 p = md5bs_m128(q);
    __m128 v = md5bs_m128(w);

    switch ((n & 3))
    {
    case 0: return md5bs_simd(_mm_insert_ps(p, v, 0x00));
    case 1: return md5bs_simd(_mm_insert_ps(p, v, 0x10));
    case 2: return md5bs_simd(_mm_insert_ps(p, v, 0x20));
    case 3: return md5bs_simd(_mm_insert_ps(p, v, 0x30));
    }
    return (w ^ w); /* 警告抑制用：意味は無い */
    // return 0; // はエラーになる
}

// xmm を使った加算
__force_inline
static md5bs_simd4_t md5bs_simd_add(md5bs_simd4_t a, md5bs_simd4_t b)
{
    return a + b;
}

// xmm を使ったローテート
__force_inline
static md5bs_alt_uint32_t md5bs_rotate(md5bs_alt_uint32_t x, int s)
{
    return md5bs_simd(_mm_srli_epi64(_mm_shuffle_epi32(md5bs_m128i(x), 0), (32 - s)));
}

#    else  /* MD5BS_SIMD_REGISTER */
#    endif /* MD5BS_SIMD_REGISTER */

// メモリ・アクセス
__force_inline
static md5bs_simd4_t md5bs_simd_loadu(const md5bs_simd4_t *p)
{
    return md5bs_simd(_mm_lddqu_si128((const __m128i *)p));
}

#    if MD5BS_SIMD_REGISTER_256 // YMM

template <typename T>
__force_inline
static __m256 md5bs_m256(T v)
{
    return xmm_cast<__m256>(v);
}

template <typename T>
__force_inline
static __m256i md5bs_m256i(T v)
{
    return xmm_cast<__m256i>(v);
}

template <typename T>
__force_inline
static md5bs_simd8_t md5bs_simd8(T x)
{
    return xmm_cast<md5bs_simd8_t>(x);
}

__force_inline
static md5bs_simd8_t md5bs_simd_loadu(const md5bs_simd8_t *p)
{
    return md5bs_simd8(_mm256_lddqu_si256((const __m256i *)p));
}

#    endif /* MD5BS_SIMD_REGISTER_256 */
#  else /* MD5BS_ISA_??? */
#    error "unknown ISA"
#  endif /* MD5BS_ISA_??? */
#else /* !MD5BS_HAS_SIMD */

// C

#  if MD5BS_SIMD_REGISTER /*****/

__force_inline
static md5bs_simd4_t md5bs_simd(uint32_t x)
{
    md5bs_simd4_t r;

    r[0] = x;
    r[1] = 0;
    r[2] = 0;
    r[3] = 0;
    return r;
}

__force_inline
static md5bs_uint32_t md5bs_simd_read(const md5bs_simd4_t &p, int n)
{
    return p[n];
}

__force_inline
static md5bs_simd4_t md5bs_simd_write(md5bs_simd4_t &p, int n, uint32_t v)
{
    md5bs_simd4_t r = p;

    r[n] = v;
    return r;
}

#  endif /* MD5BS_SIMD_REGISTER */
#endif /* !MD5BS_HAS_SIMD */

namespace // anonymous
{

    template <typename T>
    __force_inline
    static T md5bs_simd_loadu(const T *p)
    {
        return *p;
    }

    template <typename T>
    __force_inline
    static void md5bs_simd_store(T *p, const T &v)
    {
        *p = v;
    }


} // anonymous

#if !MD5BS_HAS_SIMD || !MD5BS_SIMD_REGISTER

__force_inline
static md5bs_uint32_t md5bs_uint32(uint32_t x)
{
    return x;
}

__force_inline
static md5bs_simd4_t md5bs_simd_add(md5bs_simd4_t a, md5bs_simd4_t b)
{
    return a + b;
}

__force_inline
static uint32_t md5bs_rotate(uint32_t x, int s)
{
    return ((x << s) | (x >> (32 - s)));
}

#endif

/*****************************************
 *
 *     ブロックの計算
 *
 *****************************************/

// T[n] の値
static const uint32_t md5bs_block_t_order_table[64] = {
    0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
    0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
    0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
    0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,

    0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
    0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
    0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
    0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,

    0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
    0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
    0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
    0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,

    0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
    0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
    0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
    0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
};

// X[i] に合わせた T[n] の値
static const uint32_t md5bs_block_x_order_table[64] = {
    0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,  //  0,  1,  2,  3
    0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,  //  4,  5,  6,  7
    0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,  //  8,  9, 10, 11
    0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,  // 12, 13, 14, 15

    0xe9b6c7aa, 0xf61e2562, 0xfcefa3f8, 0xf4d50d87,  //  1,  6, 11,  0
    0xe7d3fbc8, 0xd62f105d, 0xc040b340, 0x676f02d9,  //  5, 10, 15,  4
    0x455a14ed, 0x21e1cde6, 0x02441453, 0x265e5a51,  //  9, 14,  3,  8
    0x8d2a4c8a, 0xa9e3e905, 0xc33707d6, 0xd8a1e681,  // 13,  2,  7, 12

    0xeaa127fa, 0xa4beea44, 0xc4ac5665, 0xd4ef3085,  //  5,  8, 11, 14
    0x4bdecfa9, 0xfffa3942, 0x04881d05, 0xf6bb4b60,  //  1,  4,  7, 10
    0x8771f681, 0xd9d4d039, 0xbebfbc70, 0x6d9d6122,  // 13,  0,  3,  6
    0xe6db99e5, 0x289b7ec6, 0xfde5380c, 0x1fa27cf8,  //  9, 12, 15,  2

    0xf4292244, 0x85845dd1, 0x2ad7d2bb, 0x8f0ccc92,  //  0,  7, 14,  5
    0xf7537e82, 0xfc93a039, 0xa3014314, 0x432aff97,  // 12,  3, 10,  1
    0x6fa87e4f, 0xeb86d391, 0xffeff47d, 0xbd3af235,  //  8, 15,  6, 13
    0x655b59c3, 0x4e0811a1, 0xab9423a7, 0xfe2ce6e0,  //  4, 11,  2,  9
};

// 4バイト境界にないブロック・データを取得する
__force_inline
static void md5bs_block_load(MD5ByteSum::Block &out,
                             const uint32_t *inp,
                             bool endian)
{
    md5bs_load32 load = md5bs_load32_func(endian);

    for (int i = 0; i < 16; i++)
        out[i] = load(inp[i], false);
}

// 1ブロックの先読み(Dキャッシュ)を試みる
__force_inline
static void md5bs_block_prefetch(const void *block)
{
    const uint8_t *p = md5bs_uint8_p(block);

    if (MD5BS_CACHE_LINE_SIZE >= 16)
        for (int o = 0; o < 64; o += MD5BS_CACHE_LINE_SIZE)
            md5bs_prefetch(p + o);
}

/*
 * get_block_index()
 * get_rotate_bits()
 */
#if 0

/* テーブル参照方式 */

// 計算順番(インデックス)とブロックのワード番号の表
static const uint8_t md5bs_block_index_table[64] = {
    0, 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
    1, 6, 11,  0,  5, 10, 15,  4,  9, 14,  3,  8, 13,  2,  7, 12,
    5, 8, 11, 14,  1,  4,  7, 10, 13,  0,  3,  6,  9, 12, 15,  2,
    0, 7, 14,  5, 12,  3, 10,  1,  8, 15,  6, 13,  4, 11,  2,  9,
};

// 計算順番(インデックス)からブロックのワード番号の取得する
__force_inline
static uint32_t get_block_index(uint32_t index)
{
    return md5bs_block_index_table[index];
}

// 計算順番(インデックス)とローテート・ビット数の表
static const uint8_t md5bs_rotate_bits_table[64] = {
    7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
    5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20,
    4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
    6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21,
};

// 計算順番(インデックス)からローテート・ビット数を取得する
__force_inline
static int get_rotate_bits(uint32_t index)
{
    return md5bs_rotate_bits_table[index];
}

#else

/* 計算方式 */

// 計算順番(インデックス)からブロックのワード番号の取得する
//     0..15: (index * 1 + 0) & 15
//    16..31: (index * 5 + 1) & 15
//    32..47: (index * 3 + 5) & 15
//    48..63: (index * 7 + 0) & 15
//
__force_inline
static uint32_t get_block_index(uint32_t index)
{
    uint32_t x = index & 0x0f;
    uint32_t y = index & 0x30;
    uint32_t y1 = index & 0x10;
    uint32_t y2 = index & 0x20;
    uint32_t xmul = (y1 >> 2) | (y2 >> 4) | 1;  // {1,5,3,7}[y >> 4]
    uint32_t offs = (0x0510 >> (y >> 2)) & 7;   // {0,1,5,0}[y >> 4]
    return (x * xmul + offs) & 15;
}

// 計算順番(インデックス)からローテート・ビット数を取得する
//   {
//     7, 12, 17, 22,
//     5,  9, 14, 20,
//     4, 11, 16, 23,
//     6, 10, 15, 21,
//   } = {
//     4+(0*5)+0+[3], 4+(1*5)+0+[3], 4+(2*5)+0+[3], 4+(3*5)+1+[2],
//     4+(0*5)+0+[1], 4+(1*5)+0+[0], 4+(2*5)+0+[0], 4+(3*5)+1+[0],
//     4+(0*5)+0+[0], 4+(1*5)+0+[2], 4+(2*5)+0+[2], 4+(3*5)+1+[3],
//     4+(0*5)+0+[2], 4+(1*5)+0+[1], 4+(2*5)+0+[1], 4+(3*5)+1+[1],
//   }
//   ここから[n]を抜き出して
//   {
//     3, 3, 3, 2, // |2|3|3|3| = 10_11_11_11 = 0xbf
//     1, 0, 0, 0, // |0|0|0|1| = 00_00_00_01 = 0x01
//     0, 2, 2, 3, // |3|2|2|0| = 11_10_10_00 = 0xe8
//     2, 1, 1, 1, // |1|1|1|2| = 01_01_01_10 = 0x56
//   }
//
__force_inline
static int get_rotate_bits(uint32_t index)
{
    uint32_t x = index & 0x03;
    uint32_t y = index & 0x30;
    uint32_t p = x | (y >> 2);
    uint32_t x3 = (x + 1) >> 2;    // (x == 3) ? 1 : 0;
    uint32_t x0 = (0x56e801bf >> (p << 1)) & 3;
    return 4 + (x * 5) + x3 + x0;  // 4+(x*5)+x3+[x0]
}

#endif

// 計算順番(インデックス)によって異なる計算をする
template <typename T>
__force_inline
static T md5bs_state_func(uint32_t index, T x, T y, T z)
{
    switch ((index >> 4) & 3)
    {
    case 0: return (y & x) | (z & ~x); /* index: 0x00 - 0x0F */
    case 1: return (x & z) | (y & ~z); /* index: 0x10 - 0x1F */
    case 2: return x ^ y ^ z;          /* index: 0x20 - 0x2F */
    case 3: return y ^ (x | ~z);       /* index: 0x30 - 0x3F */
    }
    return (x ^ x); /* 警告抑制用：意味はない */
}

// ダイジェスト値(A,B,C,D)の更新準備: 計算1回(indexでは4個)分
__force_inline
static void md5bs_update_prepare4(uint32_t i,
                                  const uint32_t *X,
                                  const uint32_t *T,
                                  uint32_t *XT,
                                  bool aligned,
                                  bool endian,
                                  bool order)
{
    md5bs_load32 load = md5bs_load32_func(endian);
    uint32_t j = i & 0x0f;
    uint32_t x0 = order ? (j + 0) : get_block_index(i + 0);
    uint32_t x1 = order ? (j + 1) : get_block_index(i + 1);
    uint32_t x2 = order ? (j + 2) : get_block_index(i + 2);
    uint32_t x3 = order ? (j + 3) : get_block_index(i + 3);
    uint32_t *xt = XT;

    xt[j + 0] = T[i + 0] + load(X[x0], aligned);
    xt[j + 1] = T[i + 1] + load(X[x1], aligned);
    xt[j + 2] = T[i + 2] + load(X[x2], aligned);
    xt[j + 3] = T[i + 3] + load(X[x3], aligned);

    __dummy_access(*xt);
}

// ダイジェスト値(A,B,C,D)の更新準備: 計算4回(indexでは16個)分
__force_inline
static void md5bs_update_prepare16(uint32_t i,
                                   const uint32_t *X,
                                   const uint32_t *T,
                                   uint32_t *XT,
                                   bool aligned,
                                   bool endian,
                                   bool order)
{
    if (MD5BS_SIMD_REGISTER && aligned && order && !endian)
    {
        const md5bs_simd4_t *x = md5bs_simd4_p(X);
        const md5bs_simd4_t *t = md5bs_simd4_p(T + i);
        md5bs_simd4_t *xt = md5bs_simd4_p(XT);

        xt[0] = md5bs_simd_add(t[0], md5bs_simd_loadu(x + 0));
        xt[1] = md5bs_simd_add(t[1], md5bs_simd_loadu(x + 1));
        xt[2] = md5bs_simd_add(t[2], md5bs_simd_loadu(x + 2));
        xt[3] = md5bs_simd_add(t[3], md5bs_simd_loadu(x + 3));

        __dummy_access(xt[0]);
        __dummy_access(xt[1]);
        __dummy_access(xt[2]);
        __dummy_access(xt[3]);
    }
    else
    {
        md5bs_update_prepare4(i + 0 * 4, X, T, XT, aligned, endian, order);
        md5bs_update_prepare4(i + 1 * 4, X, T, XT, aligned, endian, order);
        md5bs_update_prepare4(i + 2 * 4, X, T, XT, aligned, endian, order);
        md5bs_update_prepare4(i + 3 * 4, X, T, XT, aligned, endian, order);
    }
}

// ダイジェスト値(A,B,C,D)の更新準備: 計算16回(indexでは64個)分
__force_inline
static void md5bs_update_prepare64(const uint32_t *X,
                                   const uint32_t *T,
                                   MD5ByteSum::Block *XT)
{
    const md5bs_simd8_t *wx = md5bs_simd8_p(X);
    const md5bs_simd8_t *wt = md5bs_simd8_p(T);
    md5bs_simd8_t *wxt = md5bs_simd8_p(XT);
    md5bs_simd8_t x0 = md5bs_simd_loadu(wx + 0);
    md5bs_simd8_t x1 = md5bs_simd_loadu(wx + 1);

    for (int i = 0; i < 4; i++)
    {
        int j = i * 2;

        wxt[j + 0] = x0 + wt[j + 0];
        wxt[j + 1] = x1 + wt[j + 1];

        __dummy_access(wxt[j + 0]);
        __dummy_access(wxt[j + 1]);
    }
}

// ダイジェスト値(A,B,C,D)の更新: 計算1個分
//   md5bs_update_prepare4 で用意したブロックを使う
__force_inline
static md5bs_uint32_t md5bs_update_execute1(uint32_t i,
                                            md5bs_uint32_t xt,
                                            md5bs_uint32_t a,
                                            md5bs_uint32_t b,
                                            md5bs_uint32_t c,
                                            md5bs_uint32_t d,
                                            int r)
{
    return b + md5bs_rotate(xt + a + md5bs_state_func(i, b, c, d), r);
}

// ダイジェスト値(A,B,C,D)の更新: 計算4個分
//   md5bs_update_prepare4 で用意したブロックを使う
__force_inline
static void md5bs_update_execute4(uint32_t i,
                                  const uint32_t *xt,
                                  md5bs_uint32_t &a,
                                  md5bs_uint32_t &b,
                                  md5bs_uint32_t &c,
                                  md5bs_uint32_t &d,
                                  bool order)
{
    uint32_t j = (i & 0x0f);
    uint32_t b0 = order ? get_block_index(i + 0) : (j + 0);
    uint32_t b1 = order ? get_block_index(i + 1) : (j + 1);
    uint32_t b2 = order ? get_block_index(i + 2) : (j + 2);
    uint32_t b3 = order ? get_block_index(i + 3) : (j + 3);

    int r0 = get_rotate_bits(i + 0);
    int r1 = get_rotate_bits(i + 1);
    int r2 = get_rotate_bits(i + 2);
    int r3 = get_rotate_bits(i + 3);

    md5bs_uint32_t xt0 = md5bs_uint32(xt[b0]);
    md5bs_uint32_t xt1 = md5bs_uint32(xt[b1]);
    md5bs_uint32_t xt2 = md5bs_uint32(xt[b2]);
    md5bs_uint32_t xt3 = md5bs_uint32(xt[b3]);

    a = md5bs_update_execute1(i + 0, xt0, a, b, c, d, r0);
    d = md5bs_update_execute1(i + 1, xt1, d, a, b, c, r1);
    c = md5bs_update_execute1(i + 2, xt2, c, d, a, b, r2);
    b = md5bs_update_execute1(i + 3, xt3, b, c, d, a, r3);
}

// ダイジェスト値(A,B,C,D)の更新: 計算16個分
__force_inline
static void md5bs_update_execute16(uint32_t i,
                                   const uint32_t *xt,
                                   md5bs_uint32_t &a,
                                   md5bs_uint32_t &b,
                                   md5bs_uint32_t &c,
                                   md5bs_uint32_t &d,
                                   bool order)
{
    md5bs_update_execute4(i + 0 * 4, xt, a, b, c, d, order);
    md5bs_update_execute4(i + 1 * 4, xt, a, b, c, d, order);
    md5bs_update_execute4(i + 2 * 4, xt, a, b, c, d, order);
    md5bs_update_execute4(i + 3 * 4, xt, a, b, c, d, order);
}

// ダイジェスト値(A,B,C,D)の更新: 計算1回分
__force_inline
static md5bs_uint32_t md5bs_update_step1(uint32_t i,
                                         md5bs_uint32_t X,
                                         md5bs_uint32_t T,
                                         md5bs_uint32_t a,
                                         md5bs_uint32_t b,
                                         md5bs_uint32_t c,
                                         md5bs_uint32_t d,
                                         int r)
{
    return b + md5bs_rotate(X + T + a + md5bs_state_func(i, b, c, d), r);
}

// ダイジェスト値(A,B,C,D)の更新: 計算4回分
__force_inline
static void md5bs_update_step4(uint32_t i,
                               const uint32_t *X,
                               const uint32_t *T,
                               md5bs_uint32_t &a,
                               md5bs_uint32_t &b,
                               md5bs_uint32_t &c,
                               md5bs_uint32_t &d,
                               bool aligned,
                               bool endian)
{
    md5bs_load32 load = md5bs_load32_func(endian);

    uint32_t b0 = get_block_index(i + 0);
    uint32_t b1 = get_block_index(i + 1);
    uint32_t b2 = get_block_index(i + 2);
    uint32_t b3 = get_block_index(i + 3);

    int r0 = get_rotate_bits(i + 0);
    int r1 = get_rotate_bits(i + 1);
    int r2 = get_rotate_bits(i + 2);
    int r3 = get_rotate_bits(i + 3);

    md5bs_uint32_t t0 = md5bs_uint32(T[i + 0]);
    md5bs_uint32_t t1 = md5bs_uint32(T[i + 1]);
    md5bs_uint32_t t2 = md5bs_uint32(T[i + 2]);
    md5bs_uint32_t t3 = md5bs_uint32(T[i + 3]);

    md5bs_uint32_t x0 = md5bs_uint32(load(X[b0], aligned));
    md5bs_uint32_t x1 = md5bs_uint32(load(X[b1], aligned));
    md5bs_uint32_t x2 = md5bs_uint32(load(X[b2], aligned));
    md5bs_uint32_t x3 = md5bs_uint32(load(X[b3], aligned));

    a = md5bs_update_step1(i + 0, x0, t0, a, b, c, d, r0);
    d = md5bs_update_step1(i + 1, x1, t1, d, a, b, c, r1);
    c = md5bs_update_step1(i + 2, x2, t2, c, d, a, b, r2);
    b = md5bs_update_step1(i + 3, x3, t3, b, c, d, a, r3);
}

// ダイジェスト値(A,B,C,D)の更新: 計算16回分
__force_inline
static void md5bs_update_step16(uint32_t i,
                                const uint32_t *X,
                                const uint32_t *T,
                                md5bs_uint32_t &a,
                                md5bs_uint32_t &b,
                                md5bs_uint32_t &c,
                                md5bs_uint32_t &d,
                                bool aligned,
                                bool endian)
{
    md5bs_update_step4(i + 0 * 4, X, T, a, b, c, d, aligned, endian);
    md5bs_update_step4(i + 1 * 4, X, T, a, b, c, d, aligned, endian);
    md5bs_update_step4(i + 2 * 4, X, T, a, b, c, d, aligned, endian);
    md5bs_update_step4(i + 3 * 4, X, T, a, b, c, d, aligned, endian);
}

// uint32_t 型用: state から a, b, c, d を取得する
__force_inline
static void md5bs_get_state(const MD5ByteSum::State &state,
                            md5bs_uint32_t &a,
                            md5bs_uint32_t &b,
                            md5bs_uint32_t &c,
                            md5bs_uint32_t &d)
{
#if !MD5BS_SIMD_REGISTER

    a = state[0];
    b = state[1];
    c = state[2];
    d = state[3];

#else

    const md5bs_simd4_t &p = *reinterpret_cast<const md5bs_simd4_t *>(&state);

    a = md5bs_simd_read(p, 0);
    b = md5bs_simd_read(p, 1);
    c = md5bs_simd_read(p, 2);
    d = md5bs_simd_read(p, 3);

#endif
}

// uint32_t 型用: state に a, b, c, d を加算する
__force_inline
static void md5bs_add_state(MD5ByteSum::State &state,
                            md5bs_uint32_t a,
                            md5bs_uint32_t b,
                            md5bs_uint32_t c,
                            md5bs_uint32_t d)
{
#if !MD5BS_SIMD_REGISTER

    state[0] += a;
    state[1] += b;
    state[2] += c;
    state[3] += d;

#else

    md5bs_simd4_t &s = *reinterpret_cast<md5bs_simd4_t *>(&state);
    md5bs_simd4_t t;

    t = md5bs_simd(a);
    t = md5bs_simd_write(t, 1, b);
    t = md5bs_simd_write(t, 2, c);
    t = md5bs_simd_write(t, 3, d);
    s = s + t;

#endif
}

// ダイジェスト値(state)の更新:
//   入力 block は任意のアドレスで、16ワードのデータがある
__force_inline
static void md5bs_state_update(MD5ByteSum::State &state,
                               MD5ByteSum::Block &input,
                               MD5ByteSum::Block xt[4],
                               const void *block,
                               bool aligned,
                               bool endian)
{
    const uint32_t *t = md5bs_block_t_order_table;
    const uint32_t *x = md5bs_uint32_p(block);
    md5bs_uint32_t a, b, c, d;

    md5bs_get_state(state, a, b, c, d);

    if (!MD5BS_BLOCK_PREPARE)
    {
        md5bs_update_step16(0 * 16, x, t, a, b, c, d, aligned, endian);
        md5bs_update_step16(1 * 16, x, t, a, b, c, d, aligned, endian);
        md5bs_update_step16(2 * 16, x, t, a, b, c, d, aligned, endian);
        md5bs_update_step16(3 * 16, x, t, a, b, c, d, aligned, endian);
    }
    else
    {
        // 1ブロック分の (xt[k] = T[i] + X[j]) を準備する版
        bool order = MD5BS_BLOCK_X_ORDER;

        if (!aligned && MD5BS_ADDRESS_ALIGN)
        {
            md5bs_block_load(input, x, endian);
            aligned = true;
            endian = false;
            x = input;
        }
        if (order)
            t = md5bs_block_x_order_table;

        if (MD5BS_SIMD_REGISTER_256 && aligned && order && !endian)
            md5bs_update_prepare64(x, t, xt);
        else
        {
            md5bs_update_prepare16(0 * 16, x, t, xt[0], aligned, endian, order);
            md5bs_update_prepare16(1 * 16, x, t, xt[1], aligned, endian, order);
            md5bs_update_prepare16(2 * 16, x, t, xt[2], aligned, endian, order);
            md5bs_update_prepare16(3 * 16, x, t, xt[3], aligned, endian, order);
        }

        md5bs_update_execute16(0 * 16, xt[0], a, b, c, d, order);
        md5bs_update_execute16(1 * 16, xt[1], a, b, c, d, order);
        md5bs_update_execute16(2 * 16, xt[2], a, b, c, d, order);
        md5bs_update_execute16(3 * 16, xt[3], a, b, c, d, order);
    }

    md5bs_add_state(state, a, b, c, d);
}

// 複数ブロックによるダイジェスト値(state)の更新:
//   入力 block は任意のアドレスで、16ワードのデータが count 個ある
template <bool aligned>
__force_inline
static void md5bs_state_update(MD5ByteSum::State &state,
                               MD5ByteSum::Block &input,
                               MD5ByteSum::Block adbuf[4],
                               const void *block,
                               unsigned count,
                               bool endian)
{
    const uint8_t *p = md5bs_uint8_p(block);

    if (MD5BS_CACHE_LINE_SIZE < 16)
    {
        do
        {
            md5bs_state_update(state, input, adbuf, p, aligned, endian);
            p += 64;
        }
        while (--count != 0);
    }
    else
    {
        md5bs_block_prefetch(p);
        while (--count > 0)
        {
            md5bs_block_prefetch(p + 64);
            md5bs_state_update(state, input, adbuf, p, aligned, endian);
            p += 64;
        }
        md5bs_state_update(state, input, adbuf, p, aligned, endian);
    }
}

// メッセージを入力ブロック（バッファ）にコピーする
//   s から n バイト(n>0)を、input のバイト換算 i の位置へ
__force_inline
static void md5bs_setinp(uint32_t *input, const void *message, unsigned i, uint32_t n, bool endian)
{
    uint8_t *d = md5bs_uint8_p(input);
    const uint8_t *s = md5bs_uint8_p(message);

    if (!endian)
    {
        std::memcpy(d + i, s, n);
        return;
    }

    while ((i & 3) != 0)
    {
        d[i++ ^ 3] = *s++;
        if (--n == 0)
            return;
    }
    for (uint32_t c = n >> 2; c > 0; c--, i += 4, s += 4)
        input[i >> 2] = md5bs_load32be(*md5bs_uint32_p(s), false);
    n &= 3;
    if (n == 0)
        return;
    while (n-- > 0)
        d[i++ ^ 3] = *s++;
}

// ワードの8ビット以上(iによる)を0クリアする(リトル・エンディアン版)
//   p = MD5ByteSum::input, i = MD5ByteSum::bytes
__force_inline
static uint32_t md5bs_set0le(uint8_t *p, uint32_t i)
{
    { if ((i & 3) == 0) return i; } p[i++] = 0;
    { if ((i & 3) == 0) return i; } p[i++] = 0;
    { if ((i & 3) == 0) return i; } p[i++] = 0;
    return i;
}

// ワードの8ビット以上(iによる)を0クリアする(ビッグ・エンディアン版)
//   p = MD5ByteSum::input, i = MD5ByteSum::bytes
__force_inline
static uint8_t md5bs_set0be(uint8_t *p, uint32_t i)
{
    { if ((i & 3) == 0) return i; } p[i++ ^ 3] = 0;
    { if ((i & 3) == 0) return i; } p[i++ ^ 3] = 0;
    { if ((i & 3) == 0) return i; } p[i++ ^ 3] = 0;
    return i;
}

/*****************************************
 *
 *    MD5ByteSum クラス
 *
 *****************************************/

// コンストラクタ
MD5ByteSum::MD5ByteSum(const void *message, size_t size)
{
    initialize();
    update(message, size);
}

// メンバー変数の初期化
void MD5ByteSum::initialize()
{
    std::memset(input, 0, sizeof(input));
    std::memset(adbuf, 0, sizeof(adbuf));
    state[0] = 0x67452301;
    state[1] = 0xefcdab89;
    state[2] = 0x98badcfe;
    state[3] = 0x10325476;
    bytes = 0;
    active = true;
}

// ダイジェスト値(state)の更新:
//   入力するブロックは任意のアドレスで 64 バイトのメッセージがある
void MD5ByteSum::update_state(const void *block)
{
    md5bs_state_update(state, input, adbuf, block, true, false);
}

// ダイジェスト値の確定処理
void MD5ByteSum::finalize()
{
    if (!active)
        return;

    uint32_t i = bytes & 0x3f;
    uint8_t *p = md5bs_uint8_p(input);

    if (!MD5BS_BIG_ENDIAN)
    {
        p[i++] = 0x80;
        if (i > 56)
        {
            if (i < 64)
            {
                i = md5bs_set0le(p, i);
                if (i == 60)
                    input[15] = 0;
            }
            update_state();
            i = 0;
        }
    }
    else
    {
        p[i++ ^ 3] = 0x80;
        i = md5bs_set0be(p, i);
        if (i >= 60)
        {
            if (i == 60)
                input[15] = 0;
            update_state();
            i = 0;
        }
    }
    std::memset(p + i, 0, (56 - i));
    input[14] = bytes << 3;
    input[15] = bytes >> 29;
    update_state();

    active = false;
}

// メッセージによるダイジェスト値の更新
void MD5ByteSum::update(const void *message, size_t size)
{
    if (!active)
        initialize();

    bool endian = MD5BS_BIG_ENDIAN;
    const uint8_t *p = md5bs_uint8_p(message);
    unsigned i = bytes & 0x3f;
    unsigned r;
    size_t s;

    for (;;)
    {
        if (size == 0)
            return;

        if ((i != 0) || (size < 64))
        {
            s = size + i;
            if (s >= 64)
                s = (64 - i);
            if (s > size)
                s = size;
            r = unsigned(s);

            md5bs_setinp(input, p, i, r, endian);
            bytes += r;
            size -= r;
            p += r;

            i = bytes & 0x3f;
            if (i == 0)
                update_state();
            continue;
        }

        r = unsigned(size & ~0x3f);
        bytes += r;
        size -= r;

        r >>= 6;
        if (md5bs_is_align4(p) || !MD5BS_ADDRESS_ALIGN)
            md5bs_state_update<true>(state, input, adbuf, p, r, endian);
        else
            md5bs_state_update<false>(state, input, adbuf, p, r, endian);
    }
}

// ダイジェスト値の確定と取得
void MD5ByteSum::digest(Digest &out)
{
    finalize();

    if (!MD5BS_BIG_ENDIAN)
    {
        std::memcpy(out, &state, 16);
    }
    else
    {
        uint8_t *d = out;
        const uint32_t *s = state;

        for (uint32_t i = 0; i < 4; i++)
            for (uint32_t w = *s++, j = 0; j < 4; j++, w >>= 8)
                *d++ = uint8_t(w);
    }
}

// ダイジェスト値の確定と16進数文字列による取得(NULL終端文字列)
void MD5ByteSum::hexdigest(HexDigest &out)
{
    finalize();

    for (int p = 0; p < 4; p++)
    {
        uint32_t s = state[p];

        for (unsigned q = 0; q < 4; q++, s >>= 8)
        {
            char h = (s >> 4) & 0x0f;
            char l = (s >> 0) & 0x0f;
            out[p * 8 + q * 2 + 0] = h + ((h < 10) ? '0' : ('a' - 10));
            out[p * 8 + q * 2 + 1] = l + ((l < 10) ? '0' : ('a' - 10));
        }
    }
    out[32] = 0;
}

///////////////////////////////////////////////////////////////////////////////
//
// テスト用
//
///////////////////////////////////////////////////////////////////////////////

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cinttypes>
#include <time.h>

inline uint64_t RDTSC()
{
#if defined(_MSC_VER) ||   \
    (defined(__clang__) && \
     (defined(__amd64) ||  \
      defined(__i386) ||   \
      defined(__x86) ||    \
      defined(__x86_64)))

    return __rdtsc();

#elif defined(__GNUC__) && \
    (defined(__amd64) ||   \
     defined(__i386) ||    \
     defined(__x86) ||     \
     defined(__x86_64))

    uint32_t eax, edx;
    __asm__ volatile ("RDTSC" : "=a" (eax), "=d" (edx));
    return ((uint64_t)edx << 32) | eax;

#else

    timespec c;
    clock_gettime(CLOCK_REALTIME, &c);
    return ((uint64_t)c.tv_sec * 1000 * 1000 * 1000 + c.tv_nsec);

#endif
}

static void prepare_message(uint8_t *d, size_t dlen, const uint8_t *s, size_t slen)
{
    size_t clen = slen;
    if (clen > dlen)
        clen = dlen;
    std::memcpy(d, s, clen);
    d += clen;
    dlen -= clen;
    if (dlen != 0)
        prepare_message(d, dlen, s, slen + clen);
}

static int string_message(const char *message, const char *digest = NULL)
{
    size_t msglen = strlen(message);
    MD5ByteSum md5(message, msglen);
    MD5ByteSum::HexDigest res;

    md5.hexdigest(res);
    printf("MD5 (\"%s\") = %s\n", message, res);
    if (!digest)
        return 0;
    if (!strcmp(digest, res))
        return 0;
    printf("BUG: %s != %s\n", digest, res);
    return 2;
}

static int file_message(const char *path)
{
    MD5ByteSum md5;
    MD5ByteSum::HexDigest res;

    size_t size = 1024 * 1024;
    void *buffer = malloc(size);

    if (!buffer)
    {
        printf("not enough memory.");
        return 2;
    }

    bool success = true;
    FILE *fp = fopen(path, "rb");

    if (!fp)
    {
        printf("open error: %s\n", path);
        return 2;
    }
    while (!feof(fp))
    {
        size_t rdsz = fread(buffer, 1, size, fp);
        if (ferror(fp))
        {
            success = false;
            break;
        }
        if (!rdsz)
            break;
        md5.update(buffer, rdsz);
    }
    fclose(fp);
    free(buffer);
    if (!success)
    {
        printf("read error: %s\n", path);
        return 2;
    }

    md5.hexdigest(res);
    printf("MD5 (%s) = %s\n", path, res);

    return 0;
}

static int benchmark(const char *message)
{
    if (!message)
        message = "benchmark";
    int rval = string_message(message);
    if (rval)
        return rval;

    size_t msglen = strlen(message);
    size_t blocks = (4 * 1024 * 1024);
    size_t bufsize = sizeof(MD5ByteSum::Block) * blocks;
    uint8_t *buffer = (uint8_t *)malloc(bufsize);
    if (!buffer)
    {
        puts("not enough memory.");
        return 2;
    }
    if (msglen)
    {
        uint8_t *d = buffer;
        std::memcpy(d, message, msglen);
        prepare_message(d + msglen, bufsize - msglen, buffer, msglen);
    }
    else
    {
        std::memset(buffer, -1, bufsize);
    }

    MD5ByteSum md5;
    MD5ByteSum::HexDigest res;

    uint64_t s_tsc = RDTSC();
    {
        const uint8_t *p = buffer;
        size_t s = bufsize;

#define STEP(n) md5.update(p, n); p += n; s -= n;
        // 動作テスト用に分解(計測への影響は極小)
        STEP(17);     // 0
        STEP(17);     // 17
        STEP(63);     // 34
        STEP(31+128); // 97
        STEP(s);
    }
    uint64_t e_tsc = RDTSC();
    uint64_t d_tsc = e_tsc - s_tsc;
    uint64_t ave_i = d_tsc / blocks;
    uint64_t ave_f = (100 * (d_tsc % blocks) + (blocks / 2)) / blocks;

    md5.hexdigest(res);
    printf("TEST digest: %s\n", res);
    // printf("timer start  : %" PRIu64 "\n", s_tsc);
    // printf("timer end    : %" PRIu64 "\n", e_tsc);
    printf("timer count  : %" PRIu64 "\n", d_tsc);
    printf("block average: %" PRIu64 ".%02" PRIu64 "\n", ave_i, ave_f);

    free(buffer);
    return 0;
}

static int test()
{
    static const char *tab[] = {
        "d41d8cd98f00b204e9800998ecf8427e", "",
        "0cc175b9c0f1b6a831c399e269772661", "a",
        "900150983cd24fb0d6963f7d28e17f72", "abc",
        "f96b697d7cb7938d525a2f31aaf161d0", "message digest",
        "c3fcd3d76192e4007dfb496cca67e13b", "abcdefghijklmnopqrstuvwxyz",
        "d174ab98d277d9f5a5611c2c9f419d9f", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
        "ad76b175d22a98a4e3bc2ad72affc53e", "01234567890123456789012345678901234567890123456789012345678",
        NULL, NULL,
    };
    for (int i = 0; tab[i] != NULL; i += 2)
    {
        int res = string_message(tab[i + 1], tab[i + 0]);
        if (res != 0)
            return res;
    }
    return 0;
}

static const char *program;
static int usage()
{
    printf("Usage:\n"
           "  %s -b [message]\n"
           "  %s -f file\n"
           "  %s message\n",
           program, program, program);
    return 1;
}

int main(int argc, char **argv)
{
    program = argv[0];
    if (argc < 2)
        return usage();
    if (!strcmp(argv[1], "-b"))
    {
        if (argc < 4)
            return benchmark(argv[2]);
        return usage();
    }
    if (!strcmp(argv[1], "-f"))
    {
        if (argc == 3)
            return file_message(argv[2]);
        return usage();
    }
    if (!strcmp(argv[1], "-t"))
        return test();
    if (argc == 2)
        return string_message(argv[1]);
    return usage();
}

※ビッグ・エンディアン機での動作確認はしていません

Makefile (GNU make 用)

Makefile

# -*- Makefile -*-
####

-include local-variable.mk

####

DATETIME     := $(shell date +%Y%m%d-%H%M%S)
MACHINE      := $(shell uname -m)

####

ifeq "$(MACHINE)" "armv7l"
CPU_TYPE      = arm
else ifeq "$(MACHINE)" "i686"
CPU_TYPE      = x86
else ifeq "$(MACHINE)" "x86"
CPU_TYPE      = x86
else ifeq "$(MACHINE)" "x86_64"
CPU_TYPE      = x86
else
CPU_TYPE      = none
endif

####

CLANGXX      ?= clang++
GNUGXX       ?= g++

ifeq "$(COMPILER)" "clang"
CXX          = $(CLANGXX)
else ifeq "$(COMPILER)" "gcc"
CXX          = $(GNUGXX)
endif

ifndef COMPILER
flag_CLANG    = $(shell (c++ -v 2>&1 | grep -i clang > /dev/null) && echo clang)
flag_GCC      = $(shell (c++ -v 2>&1 | grep '^gcc' > /dev/null) && echo gcc)
COMPILER      = $(strip $(flag_CLANG) $(flag_GCC))
endif

####

ifeq "$(CPU_TYPE)" "arm"
CPU_ARCHS     = arm neon
else ifeq "$(CPU_TYPE)" "x86"
CPU_ARCHS     = x86 sse avx
endif
ifndef CPU_ARCHS
CPU_ARCHS     = host
endif

CARCH_host    = $(NULL)

CARCH_arm     = $(NULL) # -march=armv6
CARCH_neon    = -march=armv7 -mfpu=neon

CARCH_x86     = -mno-sse
CARCH_sse     = -msse4.2
CARCH_avx     = -mavx2

CMTUNE_arm    =
CMTUNE_x86    = -mtune=native

OPT_ARCH_host = host
OPT_ARCH_arm  = core
OPT_ARCH_x86  = gpr
OPT_ARCH_sse  = sse
OPT_ARCH_avx  = avx
OPT_ARCH_neon = neon
OPT_XARCH     = $(OPT_ARCH_$(OPT_ARCH))

OPT_stdc      = -DMD5BS_HAS_SIMD=0
OPT_core      = -DMD5BS_SIMD_REGISTER=0
OPT_simd      = -DMD5BS_SIMD_REGISTER=1
OPT_direct    = -DMD5BS_BLOCK_PREPARE=0
OPT_preadd    = -DMD5BS_BLOCK_PREPARE=1
OPT_torder    = $(OPT_preadd) -DMD5BS_BLOCK_X_ORDER=0
OPT_xorder    = $(OPT_preadd) -DMD5BS_BLOCK_X_ORDER=1

ifndef PREFETCH
PREFETCH      = default
endif
PREFETCH_off  = -DMD5BS_CACHE_LINE_SIZE=0
PREFETCH_on   = -DMD5BS_CACHE_LINE_SIZE=64

CARCH         = $(CARCH_$(OPT_ARCH)) $(CMTUNE_$(CPU_TYPE))
CDEFS         = $(OPT_$(OPT_SIMD)) $(OPT_$(OPT_BLOCK)) $(PREFETCH_$(PREFETCH))

ifndef COPTS
COPTS         = -O3
endif
ifndef CWARNS
CWARNS        = -W -Wall -Wno-ignored-attributes
endif
CFLAGS        = $(CARCH) $(COPTS) $(CWARNS) $(CSTD)

CXXARCH       = $(CARCH)
CXXDEFS       = $(CDEFS)
CXXOPTS       = $(COPTS)
CXXWARNS      = $(CWARNS)
CXXFLAGS      = $(patsubst %,%,$(CXXARCH) $(CXXOPTS) $(CXXWARNS) $(CXXSTD) $(CXXDEFS))

####

BUILDOPT      = COMPILER=$(COMPILER) PREFETCH=$(PREFETCH)

TEST_BINARY  ?= *

####

SUBDIRS       = asm bin log

####

all:		$(COMPILER)

gcc:
		$(MAKE) COMPILER=gcc build
clang:
		$(MAKE) COMPILER=clang build

build:		build-orig build-curr

build-orig:
		@(for arch in $(CPU_ARCHS);\
		do\
		  $(MAKE) COMPILER=$(COMPILER) OPT_ARCH=$$arch build-orig-exec;\
		done)
build-orig-exec: asm bin
		$(CXX) $(CXXFLAGS) md5bs_orig.cpp -o bin/$(COMPILER)-$(OPT_XARCH)-md5bs_orig
		$(CXX) $(CXXFLAGS) md5bs_orig.cpp -o asm/$(COMPILER)-$(OPT_XARCH)-md5bs_orig.s -S

build-new:
		@(for arch in $(CPU_ARCHS);\
		do\
		  $(MAKE) $(BUILDOPT) OPT_SIMD=stdc OPT_BLOCK=direct OPT_ARCH=$$arch build-new-exec || exit $$?;\
		  $(MAKE) $(BUILDOPT) OPT_SIMD=stdc OPT_BLOCK=torder OPT_ARCH=$$arch build-new-exec || exit $$?;\
		  $(MAKE) $(BUILDOPT) OPT_SIMD=stdc OPT_BLOCK=xorder OPT_ARCH=$$arch build-new-exec || exit $$?;\
		  $(MAKE) $(BUILDOPT) OPT_SIMD=core OPT_BLOCK=direct OPT_ARCH=$$arch build-new-exec || exit $$?;\
		  $(MAKE) $(BUILDOPT) OPT_SIMD=core OPT_BLOCK=torder OPT_ARCH=$$arch build-new-exec || exit $$?;\
		  $(MAKE) $(BUILDOPT) OPT_SIMD=core OPT_BLOCK=xorder OPT_ARCH=$$arch build-new-exec || exit $$?;\
		  $(MAKE) $(BUILDOPT) OPT_SIMD=simd OPT_BLOCK=direct OPT_ARCH=$$arch build-new-exec || exit $$?;\
		  $(MAKE) $(BUILDOPT) OPT_SIMD=simd OPT_BLOCK=torder OPT_ARCH=$$arch build-new-exec || exit $$?;\
		  $(MAKE) $(BUILDOPT) OPT_SIMD=simd OPT_BLOCK=xorder OPT_ARCH=$$arch build-new-exec || exit $$?;\
		done)

build-new-exec: asm bin
		$(CXX) $(CXXFLAGS) md5bs.cpp -o bin/$(COMPILER)-$(OPT_XARCH)-md5bs-$(OPT_SIMD)-$(OPT_BLOCK)
		$(CXX) $(CXXFLAGS) md5bs.cpp -o asm/$(COMPILER)-$(OPT_XARCH)-md5bs-$(OPT_SIMD)-$(OPT_BLOCK).s -S

bench:		log
		@(cd bin;\
		for f in *;\
		do\
		  [ -x $$f ] || continue;\
		  echo "********" $$f -t "*******";\
		  for n in `seq 5`; do ./$$f -b | tee -a ../log/$(DATETIME)-$$f.log; done;\
		done)

####

check:
		@(cd bin;\
		for f in $(TEST_BINARY);\
		do\
		  [ -x $$f ] || continue;\
		  echo $$f -t;\
		  ./$$f -t || exit $$?;\
		done)

####

clean:
		rm -f *.[os] *.log *~
		rm -rf $(SUBDIRS)
clean-output:
		rm -rf asm bin
clean-log:
		rm -rf log

$(SUBDIRS) $(VMSHAREDIR):
		mkdir $@

####

-include local-rule.mk

コンパイルと実行

$ make clean gcc clang check bench

コンパイル・オプション

改良版は、以下の3通り

略号	コンパイル・オプション	内容
D	-DMD5BS_BLOCK_PREPARE=0	メッセージの記憶域を直接参照する
T	-DMD5BS_BLOCK_PREPARE=1 -DMD5BS_BLOCK_X_ORDER=0	ブロックの計算開始時に X[j] + T[i] を i 順に用意
X	-DMD5BS_BLOCK_PREPARE=1 -DMD5BS_BLOCK_X_ORDER=1	ブロックの計算開始時に X[j] + T[i] を j 順に用意

を、それぞれ以下の3通り

略号	コンパイル・オプション	内容
N	-DMD5BS_HAS_SIMD=0	明示的に SIMD は使用しない
B	-DMD5BS_SIMD_REGISTER=0	ブロックの計算開始時を除いて明示的に SIMD は使用しない
S	-DMD5BS_SIMD_REGISTER=1	明示的に SIMD を使用する

で、9通りのビルド・パターンがあります。

実行時のコマンド・ラインは

$ ./md5bs_orig -b
$ ./md5bs -b

として、 5回実行し、出力の "block average" を比較します。計測は、(1<<22)個のブロック全体の処理時間を測り、(1<<22)で割っています。

ARM (RaspberryPI 3B+)

改良版の9通りに対して、命令セット(ISA)の2通り

略号	コンパイル・オプション	内容
CORE		デフォルトの最適化
NEON	-march=armv7 -mfpu=neon	NEON を使用した最適化

で18通りのビルド・パターンを2つのコンパイラ

コンパイラ
Clang version 12.0.1
GCC version 11.2.0

で行い、これを RaspberryPI 3B+ の RaspberryPI OS 10.10で実行します。全部で36通りです。

CORE,B:S の組み合わせでは SIMD の代替を用意しています。

x86/x86_64

改良版の9通りに対して、命令セット(ISA)の3通り

略号	コンパイル・オプション	内容
GPR	-mno-sse -mtune=native -O3	SSE なしで最適化
SSE	-msse4.2 -mtune=native -O3	SSE4.2 を使用した最適化
AVX	-mavx2 -mtune=native -O3	AVX2 を使用した最適化

で27通りのビルド・パターンを2つのコンパイラ

コンパイラ
Clang version 14.0.0
GCC version 11.2.0

で行い、これを2つの実行環境

CPU	Intel(R) Core(TM) i7-8700B CPU @ 3.20GHz
x86	Debian 10.10 (i386)
x86_64	Debian 10.10 (amd64)

で実行します。全部で108通りです。

GRP,B:S の組み合わせでは SIMD の代替を用意しています。

実行結果

ARM (RaspberryPI 3B+)

計測は clock_gettime を使用しているので、概ねナノ秒(ns)になります。 RaspberryPI 3B+ は 1.4GHz 動作らしいので、1.4 倍で CPU サイクル数に相当します。

実行結果一覧（長いので折りたたみ）

オリジナル(md5bs_orig)の結果

	ISA	1回目	2回目	3回目	4回目	5回目	平均
GCC	CORE	1227.88	1200.95	1227.22	1201.41	1230.51	1217.59
GCC	NEON	776.77	770.64	776.64	772.85	775.67	774.51
Clang	CORE	967.45	958.84	966.88	962.38	966.46	964.40
Clang	NEON	967.45	966.36	952.18	967.03	951.40	960.88

改良版(md5bs)の結果

	ISA			1回目	2回目	3回目	4回目	5回目	平均
GCC	CORE	N	D	332.38	331.38	332.54	331.93	332.57	332.16
GCC	CORE	N	T	557.36	556.45	557.38	556.19	557.34	556.94
GCC	CORE	N	X	559.18	559.18	558.75	556.10	558.76	558.39
GCC	CORE	B	D	329.78	330.20	329.44	330.73	329.83	330.00
GCC	CORE	B	T	553.59	557.48	553.72	556.88	553.79	555.09
GCC	CORE	B	X	558.58	555.80	558.90	555.55	560.23	557.81
GCC	CORE	S	D	336.25	336.46	336.26	336.23	332.90	335.62
GCC	CORE	S	T	561.28	558.27	559.14	558.24	559.11	559.21
GCC	CORE	S	X	559.67	561.68	560.02	562.40	556.93	560.14
GCC	NEON	N	D	307.95	308.03	306.86	308.61	306.68	307.63
GCC	NEON	N	T	520.61	525.04	521.11	524.06	521.23	522.41
GCC	NEON	N	X	537.60	533.93	537.28	533.89	537.65	536.07
GCC	NEON	B	D	307.20	305.58	306.40	306.27	306.41	306.37
GCC	NEON	B	T	521.12	520.38	520.92	521.05	521.51	521.00
GCC	NEON	B	X	534.80	538.76	534.50	538.05	534.09	536.04
GCC	NEON	S	D	1046.08	1051.76	1052.14	1043.85	1045.98	1047.96
GCC	NEON	S	T	1115.89	1119.64	1120.17	1125.41	1119.80	1120.18
GCC	NEON	S	X	1020.62	1026.44	1021.06	1020.98	1025.80	1022.98
Clang	CORE	N	D	335.22	334.81	333.06	334.76	334.14	334.40
Clang	CORE	N	T	483.41	482.87	486.73	483.20	482.90	483.82
Clang	CORE	N	X	486.73	480.72	486.96	483.17	486.81	484.88
Clang	CORE	B	D	332.63	335.06	332.51	333.11	332.67	333.20
Clang	CORE	B	T	484.56	480.44	480.38	480.34	483.46	481.84
Clang	CORE	B	X	480.33	480.22	483.21	480.17	483.16	481.42
Clang	CORE	S	D	975.93	979.16	976.14	979.95	976.03	977.44
Clang	CORE	S	T	1373.85	1364.28	1373.68	1363.78	1363.86	1367.89
Clang	CORE	S	X	1204.28	1204.10	1203.96	1203.96	1203.88	1204.04
Clang	NEON	N	D	335.14	332.84	335.12	333.05	333.53	333.94
Clang	NEON	N	T	483.33	480.61	483.12	480.93	480.45	481.69
Clang	NEON	N	X	480.11	482.80	480.26	483.17	480.51	481.37
Clang	NEON	B	D	332.51	337.50	332.95	334.56	333.03	334.11
Clang	NEON	B	T	483.19	486.70	480.40	486.63	481.29	483.64
Clang	NEON	B	X	483.14	486.69	483.13	486.77	483.01	484.55
Clang	NEON	S	D	975.90	979.21	976.13	978.92	976.49	977.33
Clang	NEON	S	T	1373.42	1364.28	1373.26	1364.35	1364.02	1367.87
Clang	NEON	S	X	1208.53	1203.87	1209.26	1203.23	1204.65	1205.91

改良版(md5bs)の平均

ISA	GCC CORE	GCC NEON	Clang CORE	Clang NEON
N:D	332.16	307.63	334.40	333.94
N:T	556.94	522.41	483.82	481.69
N:X	558.39	536.07	484.88	481.37
B:D	330.00	306.37	333.20	334.11
B:T	555.09	521.00	481.84	483.64
B:X	557.81	536.04	481.42	484.55
S:D	335.62	1047.96	977.44	977.33
S:T	559.21	1120.18	1367.89	1367.87
S:X	560.14	1022.98	1204.04	1205.91

GCC では NEON,B:D の場合が 306.37 で、Clang では CORE,B:D の場合が 333.20 で最小になりました。

平均でソートした表

コンパイラ	種類	平均	コンパイラ	種類	平均
GCC	NEON,B:D	306.37	Clang	CORE,B:D	333.20
GCC	NEON,N:D	307.63	Clang	NEON,N:D	333.94
GCC	CORE,B:D	330.00	Clang	NEON,B:D	334.11
GCC	CORE,N:D	332.16	Clang	CORE,N:D	334.40
GCC	CORE,S:D	335.62	Clang	NEON,N:X	481.37
GCC	NEON,B:T	521.00	Clang	CORE,B:X	481.42
GCC	NEON,N:T	522.41	Clang	NEON,N:T	481.69
GCC	NEON,B:X	536.04	Clang	CORE,B:T	481.84
GCC	NEON,N:X	536.07	Clang	NEON,B:T	483.64
GCC	CORE,B:T	555.09	Clang	CORE,N:T	483.82
GCC	CORE,N:T	556.94	Clang	NEON,B:X	484.55
GCC	CORE,B:X	557.81	Clang	CORE,N:X	484.88
GCC	CORE,N:X	558.39	Clang	NEON,S:D	977.33
GCC	CORE,S:T	559.21	Clang	CORE,S:D	977.44
GCC	CORE,S:X	560.14	Clang	CORE,S:X	1204.04
GCC	NEON,S:X	1022.98	Clang	NEON,S:X	1205.91
GCC	NEON,S:D	1047.96	Clang	NEON,S:T	1367.87
GCC	NEON,S:T	1120.18	Clang	CORE,S:T	1367.89

x86/x86_64

x86 では、RDTSC を使用しているので、概ね CPU サイクル数になります。

実行結果一覧（長いので折りたたみ）

オリジナル(md5bs_orig:x86)の結果

	ISA	1回目	2回目	3回目	4回目	5回目	平均
GCC	GPR	407.97	398.59	401.21	398.68	398.12	400.91
GCC	SSE	400.45	398.58	398.89	397.89	399.72	399.11
GCC	AVX	428.43	426.58	426.93	428.53	427.38	427.57
Clang	GPR	457.11	458.43	455.37	459.71	455.57	457.24
Clang	SSE	473.62	473.85	473.85	472.85	473.78	473.59
Clang	AVX	477.69	477.86	476.72	480.49	474.50	477.45

オリジナル(md5bs_orig:x86_64)の結果

	ISA	1回目	2回目	3回目	4回目	5回目	平均
GCC	GPR	425.67	424.85	425.23	426.17	423.01	424.99
GCC	SSE	437.09	436.23	437.59	435.42	437.42	436.75
GCC	AVX	433.30	438.24	436.30	435.33	436.27	435.89
Clang	GPR	456.02	457.86	461.90	457.10	458.76	458.33
Clang	SSE	461.80	463.15	462.28	461.82	463.53	462.52
Clang	AVX	461.90	463.72	463.61	463.22	466.09	463.71

改良版(md5bs:x86)の結果

	ISA			1回目	2回目	3回目	4回目	5回目	平均
GCC	GPR	N	D	262.77	262.95	261.93	262.42	263.05	262.62
GCC	GPR	N	T	320.92	321.77	321.22	322.16	321.53	321.52
GCC	GPR	N	X	321.04	321.28	320.62	321.84	320.76	321.11
GCC	GPR	B	D	263.50	262.13	262.35	263.10	262.20	262.66
GCC	GPR	B	T	322.77	320.79	321.15	322.33	321.55	321.72
GCC	GPR	B	X	322.08	321.94	322.91	320.76	321.66	321.87
GCC	GPR	S	D	258.92	258.82	259.55	259.22	258.74	259.05
GCC	GPR	S	T	321.87	320.09	321.68	320.41	321.60	321.13
GCC	GPR	S	X	322.83	324.13	322.73	322.48	322.83	323.00
GCC	SSE	N	D	261.86	262.34	263.79	261.92	263.59	262.70
GCC	SSE	N	T	320.71	321.19	321.97	322.05	322.58	321.70
GCC	SSE	N	X	321.64	322.28	322.42	321.63	322.08	322.01
GCC	SSE	B	D	260.70	259.84	259.08	260.29	258.94	259.77
GCC	SSE	B	T	320.81	320.24	320.50	321.37	320.63	320.71
GCC	SSE	B	X	321.34	320.51	322.11	320.81	321.82	321.32
GCC	SSE	S	D	348.15	348.05	348.71	348.29	348.63	348.37
GCC	SSE	S	T	370.97	372.03	371.33	371.69	373.95	371.99
GCC	SSE	S	X	301.67	301.40	302.90	301.58	302.58	302.03
GCC	AVX	N	D	261.82	262.97	261.65	261.86	263.56	262.37
GCC	AVX	N	T	322.11	321.10	321.81	324.40	322.59	322.40
GCC	AVX	N	X	322.12	321.82	321.52	321.89	320.47	321.56
GCC	AVX	B	D	259.20	260.34	259.10	259.12	260.41	259.63
GCC	AVX	B	T	320.30	321.56	320.68	320.10	321.58	320.84
GCC	AVX	B	X	259.58	259.81	259.04	258.07	259.83	259.27
GCC	AVX	S	D	348.34	349.27	348.80	350.05	348.10	348.91
GCC	AVX	S	T	372.02	371.80	372.16	371.16	372.35	371.90
GCC	AVX	S	X	313.90	314.35	312.90	314.03	314.38	313.91
Clang	GPR	N	D	306.05	308.56	305.89	306.34	307.45	306.86
Clang	GPR	N	T	295.40	296.06	293.19	295.77	294.45	294.97
Clang	GPR	N	X	296.26	295.02	294.07	295.97	294.53	295.17
Clang	GPR	B	D	306.62	308.30	305.83	306.35	307.51	306.92
Clang	GPR	B	T	293.67	296.13	294.20	295.70	295.32	295.00
Clang	GPR	B	X	294.21	296.56	296.30	296.33	293.29	295.34
Clang	GPR	S	D	305.90	306.56	305.36	305.58	306.09	305.90
Clang	GPR	S	T	294.87	293.45	293.75	295.20	297.43	294.94
Clang	GPR	S	X	339.56	342.89	336.89	342.88	338.08	340.06
Clang	SSE	N	D	305.96	305.61	306.30	304.84	305.31	305.60
Clang	SSE	N	T	293.79	294.15	294.43	294.62	295.37	294.47
Clang	SSE	N	X	294.13	293.57	294.68	293.91	294.85	294.23
Clang	SSE	B	D	313.45	326.08	304.71	302.66	303.99	310.18
Clang	SSE	B	T	305.73	308.47	306.43	306.55	307.09	306.85
Clang	SSE	B	X	306.76	306.84	306.66	306.61	305.85	306.54
Clang	SSE	S	D	286.51	287.99	287.31	288.10	287.17	287.42
Clang	SSE	S	T	302.26	300.22	299.80	301.23	300.24	300.75
Clang	SSE	S	X	281.74	280.64	280.77	281.87	280.55	281.11
Clang	AVX	N	D	307.69	308.49	305.87	308.33	307.04	307.48
Clang	AVX	N	T	298.05	298.38	296.24	296.35	294.17	296.64
Clang	AVX	N	X	295.33	294.32	297.56	294.17	295.85	295.45
Clang	AVX	B	D	305.28	303.31	304.80	303.21	305.33	304.39
Clang	AVX	B	T	309.11	306.97	312.09	307.02	306.03	308.24
Clang	AVX	B	X	252.19	251.88	252.52	252.22	251.21	252.00
Clang	AVX	S	D	294.33	295.06	294.19	293.54	291.73	293.77
Clang	AVX	S	T	299.37	299.94	302.42	300.17	299.48	300.28
Clang	AVX	S	X	281.69	283.01	281.51	282.62	282.68	282.30

改良版(md5bs:x86_64)の結果

	ISA			1回目	2回目	3回目	4回目	5回目	平均
GCC	GPR	N	D	256.96	257.21	256.06	257.59	255.54	256.67
GCC	GPR	N	T	357.57	356.19	358.66	354.65	359.62	357.34
GCC	GPR	N	X	352.60	355.81	353.47	355.36	352.42	353.93
GCC	GPR	B	D	256.31	256.41	258.40	255.47	256.45	256.61
GCC	GPR	B	T	357.87	356.56	358.40	354.31	356.23	356.67
GCC	GPR	B	X	354.08	354.31	353.27	353.20	352.54	353.48
GCC	GPR	S	D	255.50	258.72	255.21	257.10	255.14	256.33
GCC	GPR	S	T	354.59	356.76	355.84	357.69	356.14	356.20
GCC	GPR	S	X	367.23	363.54	362.16	361.69	363.25	363.57
GCC	SSE	N	D	257.35	259.63	257.12	257.03	255.62	257.35
GCC	SSE	N	T	314.19	314.64	313.42	313.90	313.86	314.00
GCC	SSE	N	X	312.98	313.91	311.79	314.15	312.18	313.00
GCC	SSE	B	D	263.13	265.71	263.71	264.56	261.81	263.78
GCC	SSE	B	T	310.23	313.00	313.28	312.44	311.76	312.14
GCC	SSE	B	X	308.33	311.29	308.94	312.98	310.15	310.34
GCC	SSE	S	D	345.95	342.75	346.63	344.33	347.49	345.43
GCC	SSE	S	T	357.23	358.31	358.05	357.48	360.34	358.28
GCC	SSE	S	X	302.82	304.24	302.93	302.95	303.91	303.37
GCC	AVX	N	D	257.54	255.75	253.70	256.45	255.62	255.81
GCC	AVX	N	T	313.38	308.89	313.26	312.11	311.77	311.88
GCC	AVX	N	X	313.57	312.99	314.11	312.09	313.88	313.33
GCC	AVX	B	D	263.60	262.46	264.83	262.05	264.58	263.50
GCC	AVX	B	T	310.24	311.77	312.41	311.48	312.30	311.64
GCC	AVX	B	X	263.60	263.59	265.41	265.45	265.01	264.61
GCC	AVX	S	D	350.30	345.10	341.74	344.86	345.25	345.45
GCC	AVX	S	T	358.64	358.57	358.21	359.84	358.64	358.78
GCC	AVX	S	X	313.22	311.52	313.15	312.47	309.78	312.03
Clang	GPR	N	D	300.57	302.18	300.31	300.31	302.04	301.08
Clang	GPR	N	T	278.92	280.39	278.86	278.66	282.17	279.80
Clang	GPR	N	X	278.86	279.28	277.39	278.68	280.04	278.85
Clang	GPR	B	D	300.46	301.16	301.44	299.97	299.21	300.45
Clang	GPR	B	T	279.32	280.46	278.16	278.72	279.91	279.31
Clang	GPR	B	X	279.80	280.98	281.75	279.37	280.72	280.52
Clang	GPR	S	D	299.30	300.89	300.16	299.37	301.26	300.20
Clang	GPR	S	T	279.73	281.44	279.93	280.17	281.48	280.55
Clang	GPR	S	X	291.58	293.09	291.58	292.20	292.52	292.19
Clang	SSE	N	D	300.35	301.89	300.53	300.02	301.63	300.88
Clang	SSE	N	T	278.76	281.00	279.40	279.15	279.41	279.54
Clang	SSE	N	X	278.96	280.83	279.18	281.02	280.06	280.01
Clang	SSE	B	D	301.03	300.04	299.74	300.78	302.69	300.86
Clang	SSE	B	T	279.05	280.84	279.97	279.25	280.33	279.89
Clang	SSE	B	X	278.90	281.16	277.63	279.39	281.28	279.67
Clang	SSE	S	D	293.28	292.23	290.10	293.19	292.92	292.34
Clang	SSE	S	T	299.61	302.07	307.42	300.91	301.28	302.26
Clang	SSE	S	X	281.94	282.91	281.32	279.91	283.43	281.90
Clang	AVX	N	D	299.80	301.19	300.86	301.99	300.21	300.81
Clang	AVX	N	T	278.06	278.10	280.44	279.53	278.99	279.02
Clang	AVX	N	X	278.85	280.27	278.93	279.24	280.24	279.51
Clang	AVX	B	D	301.25	302.76	301.16	301.76	300.56	301.50
Clang	AVX	B	T	280.73	279.43	279.48	280.34	279.65	279.93
Clang	AVX	B	X	251.00	251.88	249.67	251.93	250.70	251.04
Clang	AVX	S	D	288.59	289.64	288.52	288.43	288.12	288.66
Clang	AVX	S	T	295.95	298.04	296.20	297.59	295.22	296.60
Clang	AVX	S	X	280.93	282.61	281.30	282.59	280.97	281.68

改良版(md5bs:x86)の平均

ISA	GCC GPR	GCC SSE	GCC AVX	Clang GPR	Clang SSE	Clang AVX
N:D	262.62	262.70	262.37	306.86	305.60	307.48
N:T	321.52	321.70	322.40	294.97	294.47	296.64
N:X	321.11	322.01	321.56	295.17	294.23	295.45
B:D	262.66	259.77	259.63	306.92	310.18	304.39
B:T	321.72	320.71	320.84	295.00	306.85	308.24
B:X	321.87	321.32	259.27	295.34	306.54	252.00
S:D	259.05	348.37	348.91	305.90	287.42	293.77
S:T	321.13	371.99	371.90	294.94	300.75	300.28
S:X	323.00	302.03	313.91	340.06	281.11	282.30

GCC では GPR,S:D の場合が 259.05 で、Clang では AVX,B:X の場合が 252.00 で最小になりました。

平均でソートした表

コンパイラ	種類	平均	コンパイラ	種類	平均
GCC	GPR,S:D	259.05	Clang	AVX,B:X	252.00
GCC	AVX,B:X	259.27	Clang	SSE,S:X	281.11
GCC	AVX,B:D	259.63	Clang	AVX,S:X	282.30
GCC	SSE,B:D	259.77	Clang	SSE,S:D	287.42
GCC	AVX,N:D	262.37	Clang	AVX,S:D	293.77
GCC	GPR,N:D	262.62	Clang	SSE,N:X	294.23
GCC	GPR,B:D	262.66	Clang	SSE,N:T	294.47
GCC	SSE,N:D	262.70	Clang	GPR,S:T	294.94
GCC	SSE,S:X	302.03	Clang	GPR,N:T	294.97
GCC	AVX,S:X	313.91	Clang	GPR,B:T	295.00
GCC	SSE,B:T	320.71	Clang	GPR,N:X	295.17
GCC	AVX,B:T	320.84	Clang	GPR,B:X	295.34
GCC	GPR,N:X	321.11	Clang	AVX,N:X	295.45
GCC	GPR,S:T	321.13	Clang	AVX,N:T	296.64
GCC	SSE,B:X	321.32	Clang	AVX,S:T	300.28
GCC	GPR,N:T	321.52	Clang	SSE,S:T	300.75
GCC	AVX,N:X	321.56	Clang	AVX,B:D	304.39
GCC	SSE,N:T	321.70	Clang	SSE,N:D	305.60
GCC	GPR,B:T	321.72	Clang	GPR,S:D	305.90
GCC	GPR,B:X	321.87	Clang	SSE,B:X	306.54
GCC	SSE,N:X	322.01	Clang	SSE,B:T	306.85
GCC	AVX,N:T	322.40	Clang	GPR,N:D	306.86
GCC	GPR,S:X	323.00	Clang	GPR,B:D	306.92
GCC	SSE,S:D	348.37	Clang	AVX,N:D	307.48
GCC	AVX,S:D	348.91	Clang	AVX,B:T	308.24
GCC	AVX,S:T	371.90	Clang	SSE,B:D	310.18
GCC	SSE,S:T	371.99	Clang	GPR,S:X	340.06

改良版(md5bs:x86_64)の平均

ISA	GCC GPR	GCC SSE	GCC AVX	Clang GPR	Clang SSE	Clang AVX
N:D	256.67	257.35	255.81	301.08	300.88	300.81
N:T	357.34	314.00	311.88	279.80	279.54	279.02
N:X	353.93	313.00	313.33	278.85	280.01	279.51
B:D	256.61	263.78	263.50	300.45	300.86	301.50
B:T	356.67	312.14	311.64	279.31	279.89	279.93
B:X	353.48	310.34	264.61	280.52	279.67	251.04
S:D	256.33	345.43	345.45	300.20	292.34	288.66
S:T	356.20	358.28	358.78	280.55	302.26	296.60
S:X	363.57	303.37	312.03	292.19	281.90	281.68

GCC では AVX,N:D の場合が 255.81 で、Clang では AVX,B:X の場合が 251.04 で最小になりました。

平均でソートした表

コンパイラ	種類	平均	コンパイラ	種類	平均
GCC	AVX,N:D	255.81	Clang	AVX,B:X	251.04
GCC	GPR,S:D	256.33	Clang	GPR,N:X	278.85
GCC	GPR,B:D	256.61	Clang	AVX,N:T	279.02
GCC	GPR,N:D	256.67	Clang	GPR,B:T	279.31
GCC	SSE,N:D	257.35	Clang	AVX,N:X	279.51
GCC	AVX,B:D	263.50	Clang	SSE,N:T	279.54
GCC	SSE,B:D	263.78	Clang	SSE,B:X	279.67
GCC	AVX,B:X	264.61	Clang	GPR,N:T	279.80
GCC	SSE,S:X	303.37	Clang	SSE,B:T	279.89
GCC	SSE,B:X	310.34	Clang	AVX,B:T	279.93
GCC	AVX,B:T	311.64	Clang	SSE,N:X	280.01
GCC	AVX,N:T	311.88	Clang	GPR,B:X	280.52
GCC	AVX,S:X	312.03	Clang	GPR,S:T	280.55
GCC	SSE,B:T	312.14	Clang	AVX,S:X	281.68
GCC	SSE,N:X	313.00	Clang	SSE,S:X	281.90
GCC	AVX,N:X	313.33	Clang	AVX,S:D	288.66
GCC	SSE,N:T	314.00	Clang	GPR,S:X	292.19
GCC	SSE,S:D	345.43	Clang	SSE,S:D	292.34
GCC	AVX,S:D	345.45	Clang	AVX,S:T	296.60
GCC	GPR,B:X	353.48	Clang	GPR,S:D	300.20
GCC	GPR,N:X	353.93	Clang	GPR,B:D	300.45
GCC	GPR,S:T	356.20	Clang	AVX,N:D	300.81
GCC	GPR,B:T	356.67	Clang	SSE,B:D	300.86
GCC	GPR,N:T	357.34	Clang	SSE,N:D	300.88
GCC	SSE,S:T	358.28	Clang	GPR,N:D	301.08
GCC	AVX,S:T	358.78	Clang	AVX,B:D	301.50
GCC	GPR,S:X	363.57	Clang	SSE,S:T	302.26

手元の環境では、このような結果になりましたが、同一バイナリでも動作環境によって異なるので、使用する環境での確認が必要です。