kc3-lang/angle/src/compiler/translator/ImmutableString.h

• Show log

  Commit

• Hash : 56db3789
  Author :
  Date : 2019-08-01T17:09:53
  

  Use flat arrays instead of switches for function lookups
  
  Current implementation of built in function lookup uses
  autogenerated switch statements. Instead, use the perfect
  hash mapping to have the lookup use arrays instead. This
  will improve runtime performance.
  
  Bug: angleproject:3805
  Change-Id: I6d0ba62d79abd53a7fe818fe675282800781f256
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1756883
  Commit-Queue: Clemen Deng <clemendeng@google.com>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/compiler/translator/ImmutableString.h

• //
  // Copyright 2018 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // ImmutableString.h: Wrapper for static or pool allocated char arrays, that are guaranteed to be
  // valid and unchanged for the duration of the compilation.
  //
  
  #ifndef COMPILER_TRANSLATOR_IMMUTABLESTRING_H_
  #define COMPILER_TRANSLATOR_IMMUTABLESTRING_H_
  
  #include <string>
  
  #include "common/string_utils.h"
  #include "compiler/translator/Common.h"
  
  namespace sh
  {
  
  namespace
  {
  constexpr size_t constStrlen(const char *str)
  {
      if (str == nullptr)
      {
          return 0u;
      }
      size_t len = 0u;
      while (*(str + len) != '\0')
      {
          ++len;
      }
      return len;
  }
  }  // namespace
  
  class ImmutableString
  {
    public:
      // The data pointer passed in must be one of:
      //  1. nullptr (only valid with length 0).
      //  2. a null-terminated static char array like a string literal.
      //  3. a null-terminated pool allocated char array. This can't be c_str() of a local TString,
      //     since when a TString goes out of scope it clears its first character.
      explicit constexpr ImmutableString(const char *data) : mData(data), mLength(constStrlen(data))
      {}
  
      constexpr ImmutableString(const char *data, size_t length) : mData(data), mLength(length) {}
  
      ImmutableString(const std::string &str)
          : mData(AllocatePoolCharArray(str.c_str(), str.size())), mLength(str.size())
      {}
  
      constexpr ImmutableString(const ImmutableString &) = default;
  
      ImmutableString &operator=(const ImmutableString &) = default;
  
      constexpr const char *data() const { return mData ? mData : ""; }
      constexpr size_t length() const { return mLength; }
  
      char operator[](size_t index) const { return data()[index]; }
  
      constexpr bool empty() const { return mLength == 0; }
      bool beginsWith(const char *prefix) const { return angle::BeginsWith(data(), prefix); }
      constexpr bool beginsWith(const ImmutableString &prefix) const
      {
          return mLength >= prefix.length() && memcmp(data(), prefix.data(), prefix.length()) == 0;
      }
      bool contains(const char *substr) const { return strstr(data(), substr) != nullptr; }
  
      constexpr bool operator==(const ImmutableString &b) const
      {
          if (mLength != b.mLength)
          {
              return false;
          }
          return memcmp(data(), b.data(), mLength) == 0;
      }
      constexpr bool operator!=(const ImmutableString &b) const { return !(*this == b); }
      constexpr bool operator==(const char *b) const
      {
          if (b == nullptr)
          {
              return empty();
          }
          return strcmp(data(), b) == 0;
      }
      constexpr bool operator!=(const char *b) const { return !(*this == b); }
      bool operator==(const std::string &b) const
      {
          return mLength == b.length() && memcmp(data(), b.c_str(), mLength) == 0;
      }
      bool operator!=(const std::string &b) const { return !(*this == b); }
  
      constexpr bool operator<(const ImmutableString &b) const
      {
          if (mLength < b.mLength)
          {
              return true;
          }
          if (mLength > b.mLength)
          {
              return false;
          }
          return (memcmp(data(), b.data(), mLength) < 0);
      }
  
      template <size_t hashBytes>
      struct FowlerNollVoHash
      {
          static const size_t kFnvOffsetBasis;
          static const size_t kFnvPrime;
  
          constexpr size_t operator()(const ImmutableString &a) const
          {
              const char *data = a.data();
              size_t hash      = kFnvOffsetBasis;
              while ((*data) != '\0')
              {
                  hash = hash ^ (*data);
                  hash = hash * kFnvPrime;
                  ++data;
              }
              return hash;
          }
      };
  
      // Perfect hash functions
      uint32_t mangledNameHash() const;
      uint32_t unmangledNameHash() const;
  
    private:
      const char *mData;
      size_t mLength;
  };
  
  constexpr ImmutableString kEmptyImmutableString("");
  }  // namespace sh
  
  std::ostream &operator<<(std::ostream &os, const sh::ImmutableString &str);
  
  #endif  // COMPILER_TRANSLATOR_IMMUTABLESTRING_H_
  

Download