Quelle TestSIMD.cpp Sprache: C

/* -*- Mode: C++; tab-width: 9; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "mozilla/Assertions.h"
#include "mozilla/SIMD.h"

using mozilla::SIMD;

void TestTinyString() {
  const char* test = "012\n";

  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '0', 3) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '0', 3) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '1', 3) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '1', 3) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '2', 3) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '2', 3) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '\n', 3) == nullptr);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '\n', 3) == nullptr);
}

void TestShortString() {
  const char* test = "0123456789\n";

  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '0', 10) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '0', 10) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '1', 10) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '1', 10) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '2', 10) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '2', 10) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '3', 10) == test + 0x3);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '3', 10) == test + 0x3);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '4', 10) == test + 0x4);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '4', 10) == test + 0x4);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '5', 10) == test + 0x5);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '5', 10) == test + 0x5);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '6', 10) == test + 0x6);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '6', 10) == test + 0x6);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '7', 10) == test + 0x7);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '7', 10) == test + 0x7);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '8', 10) == test + 0x8);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '8', 10) == test + 0x8);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '9', 10) == test + 0x9);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '9', 10) == test + 0x9);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '\n', 10) == nullptr);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '\n', 10) == nullptr);
}

void TestMediumString() {
  const char* test = "0123456789abcdef\n";

  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '0', 16) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '0', 16) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '1', 16) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '1', 16) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '2', 16) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '2', 16) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '3', 16) == test + 0x3);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '3', 16) == test + 0x3);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '4', 16) == test + 0x4);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '4', 16) == test + 0x4);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '5', 16) == test + 0x5);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '5', 16) == test + 0x5);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '6', 16) == test + 0x6);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '6', 16) == test + 0x6);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '7', 16) == test + 0x7);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '7', 16) == test + 0x7);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '8', 16) == test + 0x8);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '8', 16) == test + 0x8);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '9', 16) == test + 0x9);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '9', 16) == test + 0x9);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, 'a', 16) == test + 0xa);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, 'a', 16) == test + 0xa);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, 'b', 16) == test + 0xb);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, 'b', 16) == test + 0xb);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, 'c', 16) == test + 0xc);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, 'c', 16) == test + 0xc);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, 'd', 16) == test + 0xd);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, 'd', 16) == test + 0xd);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, 'e', 16) == test + 0xe);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, 'e', 16) == test + 0xe);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, 'f', 16) == test + 0xf);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, 'f', 16) == test + 0xf);
  MOZ_RELEASE_ASSERT(SIMD::memchr8(test, '\n', 16) == nullptr);
  MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test, '\n', 16) == nullptr);
}

void TestLongString() {
  // NOTE: here we make sure we go all the way up to 256 to ensure we're
  // handling negative-valued chars appropriately. We don't need to bother
  // testing this side of things with char16_t's because they are very
  // sensibly guaranteed to be unsigned.
  const size_t count = 256;
  char test[count];
  for (size_t i = 0; i < count; ++i) {
    test[i] = static_cast<char>(i);
  }

  for (size_t i = 0; i < count - 1; ++i) {
    MOZ_RELEASE_ASSERT(SIMD::memchr8(test, static_cast<char>(i), count - 1) ==
                       test + i);
    MOZ_RELEASE_ASSERT(
        SIMD::memchr8SSE2(test, static_cast<char>(i), count - 1) == test + i);
  }
  MOZ_RELEASE_ASSERT(
      SIMD::memchr8(test, static_cast<char>(count - 1), count - 1) == nullptr);
}

void TestGauntlet() {
  const size_t count = 256;
  char test[count];
  for (size_t i = 0; i < count; ++i) {
    test[i] = static_cast<char>(i);
  }

  for (size_t i = 0; i < count - 1; ++i) {
    for (size_t j = 0; j < count - 1; ++j) {
      for (size_t k = 0; k < count - 1; ++k) {
        if (i >= k) {
          const char* expected = nullptr;
          if (j >= k && j < i) {
            expected = test + j;
          }
          MOZ_RELEASE_ASSERT(
              SIMD::memchr8(test + k, static_cast<char>(j), i - k) == expected);
          MOZ_RELEASE_ASSERT(SIMD::memchr8SSE2(test + k, static_cast<char>(j),
                                               i - k) == expected);
        }
      }
    }
  }
}

void TestTinyString16() {
  const char16_t* test = u"012\n";

  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'0', 3) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'0', 3) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'1', 3) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'1', 3) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'2', 3) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'2', 3) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'\n', 3) == nullptr);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'\n', 3) == nullptr);
}

void TestShortString16() {
  const char16_t* test = u"0123456789\n";

  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'0', 10) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'0', 10) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'1', 10) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'1', 10) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'2', 10) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'2', 10) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'3', 10) == test + 0x3);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'3', 10) == test + 0x3);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'4', 10) == test + 0x4);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'4', 10) == test + 0x4);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'5', 10) == test + 0x5);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'5', 10) == test + 0x5);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'6', 10) == test + 0x6);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'6', 10) == test + 0x6);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'7', 10) == test + 0x7);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'7', 10) == test + 0x7);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'8', 10) == test + 0x8);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'8', 10) == test + 0x8);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'9', 10) == test + 0x9);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'9', 10) == test + 0x9);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'\n', 10) == nullptr);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'\n', 10) == nullptr);
}

void TestMediumString16() {
  const char16_t* test = u"0123456789abcdef\n";

  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'0', 16) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'0', 16) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'1', 16) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'1', 16) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'2', 16) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'2', 16) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'3', 16) == test + 0x3);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'3', 16) == test + 0x3);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'4', 16) == test + 0x4);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'4', 16) == test + 0x4);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'5', 16) == test + 0x5);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'5', 16) == test + 0x5);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'6', 16) == test + 0x6);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'6', 16) == test + 0x6);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'7', 16) == test + 0x7);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'7', 16) == test + 0x7);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'8', 16) == test + 0x8);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'8', 16) == test + 0x8);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'9', 16) == test + 0x9);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'9', 16) == test + 0x9);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'a', 16) == test + 0xa);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'a', 16) == test + 0xa);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'b', 16) == test + 0xb);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'b', 16) == test + 0xb);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'c', 16) == test + 0xc);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'c', 16) == test + 0xc);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'd', 16) == test + 0xd);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'd', 16) == test + 0xd);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'e', 16) == test + 0xe);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'e', 16) == test + 0xe);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'f', 16) == test + 0xf);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'f', 16) == test + 0xf);
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, u'\n', 16) == nullptr);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, u'\n', 16) == nullptr);
}

void TestLongString16() {
  const size_t count = 256;
  char16_t test[count];
  for (size_t i = 0; i < count; ++i) {
    test[i] = i;
  }

  for (size_t i = 0; i < count - 1; ++i) {
    MOZ_RELEASE_ASSERT(
        SIMD::memchr16(test, static_cast<char16_t>(i), count - 1) == test + i);
    MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, static_cast<char16_t>(i),
                                          count - 1) == test + i);
  }
  MOZ_RELEASE_ASSERT(SIMD::memchr16(test, count - 1, count - 1) == nullptr);
  MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test, count - 1, count - 1) == nullptr);
}

void TestGauntlet16() {
  const size_t count = 257;
  char16_t test[count];
  for (size_t i = 0; i < count; ++i) {
    test[i] = i;
  }

  for (size_t i = 0; i < count - 1; ++i) {
    for (size_t j = 0; j < count - 1; ++j) {
      for (size_t k = 0; k < count - 1; ++k) {
        if (i >= k) {
          const char16_t* expected = nullptr;
          if (j >= k && j < i) {
            expected = test + j;
          }
          MOZ_RELEASE_ASSERT(SIMD::memchr16(test + k, static_cast<char16_t>(j),
                                            i - k) == expected);
          MOZ_RELEASE_ASSERT(SIMD::memchr16SSE2(test + k,
                                                static_cast<char16_t>(j),
                                                i - k) == expected);
        }
      }
    }
  }
}

void TestTinyString64() {
  const uint64_t test[4] = {0, 1, 2, 3};

  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 0, 3) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 1, 3) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 2, 3) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 3, 3) == nullptr);
}

void TestShortString64() {
  const uint64_t test[16] = {0, 1, 2,  3,  4,  5,  6,  7,
                             8, 9, 10, 11, 12, 13, 14, 15};

  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 0, 15) == test + 0);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 1, 15) == test + 1);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 2, 15) == test + 2);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 3, 15) == test + 3);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 4, 15) == test + 4);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 5, 15) == test + 5);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 6, 15) == test + 6);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 7, 15) == test + 7);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 8, 15) == test + 8);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 9, 15) == test + 9);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 9, 15) == test + 9);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 10, 15) == test + 10);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 11, 15) == test + 11);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 12, 15) == test + 12);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 13, 15) == test + 13);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 14, 15) == test + 14);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 15, 15) == nullptr);
}

void TestMediumString64() {
  const uint64_t test[32] = {0,  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};

  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 0, 31) == test + 0);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 1, 31) == test + 1);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 2, 31) == test + 2);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 3, 31) == test + 3);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 4, 31) == test + 4);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 5, 31) == test + 5);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 6, 31) == test + 6);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 7, 31) == test + 7);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 8, 31) == test + 8);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 9, 31) == test + 9);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 9, 31) == test + 9);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 10, 31) == test + 10);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 11, 31) == test + 11);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 12, 31) == test + 12);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 13, 31) == test + 13);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 14, 31) == test + 14);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 15, 31) == test + 15);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 16, 31) == test + 16);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 17, 31) == test + 17);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 18, 31) == test + 18);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 19, 31) == test + 19);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 20, 31) == test + 20);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 21, 31) == test + 21);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 22, 31) == test + 22);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 23, 31) == test + 23);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 24, 31) == test + 24);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 25, 31) == test + 25);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 26, 31) == test + 26);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 27, 31) == test + 27);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 28, 31) == test + 28);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 29, 31) == test + 29);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 30, 31) == test + 30);
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, 31, 31) == nullptr);
}

void TestLongString64() {
  const size_t count = 256;
  uint64_t test[count];
  for (size_t i = 0; i < count; ++i) {
    test[i] = i;
  }

  for (uint64_t i = 0; i < count - 1; ++i) {
    MOZ_RELEASE_ASSERT(SIMD::memchr64(test, i, count - 1) == test + i);
  }
  MOZ_RELEASE_ASSERT(SIMD::memchr64(test, count - 1, count - 1) == nullptr);
}

void TestGauntlet64() {
  const size_t count = 257;
  uint64_t test[count];
  for (size_t i = 0; i < count; ++i) {
    test[i] = i;
  }

  for (uint64_t i = 0; i < count - 1; ++i) {
    for (uint64_t j = 0; j < count - 1; ++j) {
      for (uint64_t k = 0; k < count - 1; ++k) {
        if (i >= k) {
          const uint64_t* expected = nullptr;
          if (j >= k && j < i) {
            expected = test + j;
          }
          MOZ_RELEASE_ASSERT(SIMD::memchr64(test + k, j, i - k) == expected);
        }
      }
    }
  }
}

void TestTinyString2x8() {
  const char* test = "012\n";

  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '0', '1', 3) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '1', '2', 3) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '2', '\n', 3) == nullptr);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '0', '2', 3) == nullptr);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '1', '\n', 3) == nullptr);
}

void TestShortString2x8() {
  const char* test = "0123456789\n";

  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '0', '1', 10) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '1', '2', 10) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '2', '3', 10) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '3', '4', 10) == test + 0x3);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '4', '5', 10) == test + 0x4);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '5', '6', 10) == test + 0x5);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '6', '7', 10) == test + 0x6);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '7', '8', 10) == test + 0x7);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '8', '9', 10) == test + 0x8);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '9', '\n', 10) == nullptr);
}

void TestMediumString2x8() {
  const char* test = "0123456789abcdef\n";

  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '0', '1', 16) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '1', '2', 16) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '2', '3', 16) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '3', '4', 16) == test + 0x3);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '4', '5', 16) == test + 0x4);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '5', '6', 16) == test + 0x5);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '6', '7', 16) == test + 0x6);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '7', '8', 16) == test + 0x7);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '8', '9', 16) == test + 0x8);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, '9', 'a', 16) == test + 0x9);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, 'a', 'b', 16) == test + 0xa);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, 'b', 'c', 16) == test + 0xb);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, 'c', 'd', 16) == test + 0xc);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, 'd', 'e', 16) == test + 0xd);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, 'e', 'f', 16) == test + 0xe);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, 'f', '\n', 16) == nullptr);
}

void TestLongString2x8() {
  const size_t count = 256;
  char test[count];
  for (size_t i = 0; i < count; ++i) {
    test[i] = static_cast<char>(i);
  }

  for (size_t i = 0; i < count - 2; ++i) {
    MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, static_cast<char>(i),
                                       static_cast<char>(i + 1),
                                       count - 1) == test + i);
  }
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test, static_cast<char>(count - 2),
                                     static_cast<char>(count - 1),
                                     count - 1) == nullptr);
}

void TestTinyString2x16() {
  const char16_t* test = u"012\n";

  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'0', u'1', 3) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'1', u'2', 3) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'2', u'\n', 3) == nullptr);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'0', u'2', 3) == nullptr);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'1', u'\n', 3) == nullptr);
}

void TestShortString2x16() {
  const char16_t* test = u"0123456789\n";

  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'0', u'1', 10) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'1', u'2', 10) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'2', u'3', 10) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'3', u'4', 10) == test + 0x3);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'4', u'5', 10) == test + 0x4);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'5', u'6', 10) == test + 0x5);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'6', u'7', 10) == test + 0x6);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'7', u'8', 10) == test + 0x7);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'8', u'9', 10) == test + 0x8);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'9', u'\n', 10) == nullptr);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'0', u'2', 10) == nullptr);
}

void TestMediumString2x16() {
  const char16_t* test = u"0123456789abcdef\n";

  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'0', u'1', 16) == test + 0x0);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'1', u'2', 16) == test + 0x1);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'2', u'3', 16) == test + 0x2);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'3', u'4', 16) == test + 0x3);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'4', u'5', 16) == test + 0x4);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'5', u'6', 16) == test + 0x5);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'6', u'7', 16) == test + 0x6);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'7', u'8', 16) == test + 0x7);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'8', u'9', 16) == test + 0x8);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'9', u'a', 16) == test + 0x9);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'a', u'b', 16) == test + 0xa);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'b', u'c', 16) == test + 0xb);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'c', u'd', 16) == test + 0xc);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'd', u'e', 16) == test + 0xd);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'e', u'f', 16) == test + 0xe);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'f', u'\n', 16) == nullptr);
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, u'0', u'2', 10) == nullptr);
}

void TestLongString2x16() {
  const size_t count = 257;
  char16_t test[count];
  for (size_t i = 0; i < count; ++i) {
    test[i] = static_cast<char16_t>(i);
  }

  for (size_t i = 0; i < count - 2; ++i) {
    MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, static_cast<char16_t>(i),
                                        static_cast<char16_t>(i + 1),
                                        count - 1) == test + i);
  }
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test, static_cast<char16_t>(count - 2),
                                      static_cast<char16_t>(count - 1),
                                      count - 1) == nullptr);
}

void TestGauntlet2x8() {
  const size_t count = 256;
  char test[count * 2];
  // load in the evens
  for (size_t i = 0; i < count / 2; ++i) {
    test[i] = static_cast<char>(2 * i);
  }
  // load in the odds
  for (size_t i = 0; i < count / 2; ++i) {
    test[count / 2 + i] = static_cast<char>(2 * i + 1);
  }
  // load in evens and odds sequentially
  for (size_t i = 0; i < count; ++i) {
    test[count + i] = static_cast<char>(i);
  }

  for (size_t i = 0; i < count - 1; ++i) {
    for (size_t j = 0; j < count - 2; ++j) {
      for (size_t k = 0; k < count - 1; ++k) {
        if (i > k + 1) {
          const char* expected1 = nullptr;
          const char* expected2 = nullptr;
          if (i > j + 1) {
            expected1 = test + j + count;  // Add count to skip over odds/evens
            if (j >= k) {
              expected2 = test + j + count;
            }
          }
          char a = static_cast<char>(j);
          char b = static_cast<char>(j + 1);
          // Make sure it doesn't pick up any in the alternating odd/even
          MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test + k, a, b, i - k + count) ==
                             expected1);
          // Make sure we cover smaller inputs
          MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test + k + count, a, b, i - k) ==
                             expected2);
        }
      }
    }
  }
}

void TestGauntlet2x16() {
  const size_t count = 1024;
  char16_t test[count * 2];
  // load in the evens
  for (size_t i = 0; i < count / 2; ++i) {
    test[i] = static_cast<char16_t>(2 * i);
  }
  // load in the odds
  for (size_t i = 0; i < count / 2; ++i) {
    test[count / 2 + i] = static_cast<char16_t>(2 * i + 1);
  }
  // load in evens and odds sequentially
  for (size_t i = 0; i < count; ++i) {
    test[count + i] = static_cast<char16_t>(i);
  }

  for (size_t i = 0; i < count - 1; ++i) {
    for (size_t j = 0; j < count - 2; ++j) {
      for (size_t k = 0; k < count - 1; ++k) {
        if (i > k + 1) {
          const char16_t* expected1 = nullptr;
          const char16_t* expected2 = nullptr;
          if (i > j + 1) {
            expected1 = test + j + count;  // Add count to skip over odds/evens
            if (j >= k) {
              expected2 = test + j + count;
            }
          }
          char16_t a = static_cast<char16_t>(j);
          char16_t b = static_cast<char16_t>(j + 1);
          // Make sure it doesn't pick up any in the alternating odd/even
          MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test + k, a, b, i - k + count) ==
                             expected1);
          // Make sure we cover smaller inputs
          MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test + k + count, a, b, i - k) ==
                             expected2);
        }
      }
    }
  }
}

void TestSpecialCases() {
  // The following 4 asserts test the case where we do two overlapping checks,
  // where the first one ends with our first search character, and the second
  // one begins with our search character. Since they are overlapping, we want
  // to ensure that the search function doesn't carry the match from the
  // first check over to the second check.
  const char* test1 = "x123456789abcdey";
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test1, 'y', 'x', 16) == nullptr);
  const char* test2 = "1000000000000000200000000000000030b000000000000a40";
  MOZ_RELEASE_ASSERT(SIMD::memchr2x8(test2, 'a', 'b', 50) == nullptr);
  const char16_t* test1wide = u"x123456y";
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test1wide, 'y', 'x', 8) == nullptr);
  const char16_t* test2wide = u"100000002000000030b0000a40";
  MOZ_RELEASE_ASSERT(SIMD::memchr2x16(test2wide, 'a', 'b', 26) == nullptr);
}

int main(void) {
  TestTinyString();
  TestShortString();
  TestMediumString();
  TestLongString();
  TestGauntlet();

  TestTinyString16();
  TestShortString16();
  TestMediumString16();
  TestLongString16();
  TestGauntlet16();

  TestTinyString64();
  TestShortString64();
  TestMediumString64();
  TestLongString64();
  TestGauntlet64();

  TestTinyString2x8();
  TestShortString2x8();
  TestMediumString2x8();
  TestLongString2x8();

  TestTinyString2x16();
  TestShortString2x16();
  TestMediumString2x16();
  TestLongString2x16();

  TestSpecialCases();

  // These are too slow to run all the time, but they should be run when making
  // meaningful changes just to be sure.
  // TestGauntlet2x8();
  // TestGauntlet2x16();

  return 0;
}

quality62%

¤ Dauer der Verarbeitung: 0.18 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.