refactor(cyclic_hash): use fast types internally

Author: mhx

include/dwarfs/writer/internal/cyclic_hash.h

@@ -37,21 +37,21 @@ class rsync_hash {
   rsync_hash() = default;
 
   DWARFS_FORCE_INLINE value_type operator()() const {
-    return a_ | (static_cast<value_type>(b_) << 16);
+    return (a_ & 0xffff) | (static_cast<value_type>(b_ & 0xffff) << 16);
   }
 
   DWARFS_FORCE_INLINE void set(value_type hash) {
-    a_ = static_cast<uint16_t>(hash & 0xFFFF);
-    b_ = static_cast<uint16_t>((hash >> 16) & 0xFFFF);
+    a_ = hash & 0xFFFF;
+    b_ = (hash >> 16) & 0xFFFF;
   }
 
-  DWARFS_FORCE_INLINE void update(uint8_t inbyte) {
+  DWARFS_FORCE_INLINE void update(std::uint8_t inbyte) {
     a_ += inbyte;
     b_ += a_;
     ++len_;
   }
 
-  DWARFS_FORCE_INLINE void update(uint8_t outbyte, uint8_t inbyte) {
+  DWARFS_FORCE_INLINE void update(std::uint8_t outbyte, std::uint8_t inbyte) {
     a_ = a_ - outbyte + inbyte;
     b_ -= len_ * outbyte;
     b_ += a_;
@@ -64,17 +64,17 @@ class rsync_hash {
   }
 
   static DWARFS_FORCE_INLINE constexpr value_type
-  repeating_window(uint8_t byte, size_t length) {
-    auto v = static_cast<uint16_t>(byte);
-    auto a = static_cast<uint16_t>(v * length);
-    auto b = static_cast<uint16_t>(v * (length * (length + 1)) / 2);
+  repeating_window(std::uint8_t byte, size_t length) {
+    auto v = static_cast<std::uint16_t>(byte);
+    auto a = static_cast<std::uint16_t>(v * length);
+    auto b = static_cast<std::uint16_t>(v * (length * (length + 1)) / 2);
     return static_cast<value_type>(a) | (static_cast<value_type>(b) << 16);
   }
 
  private:
-  uint16_t a_{0};
-  uint16_t b_{0};
-  int32_t len_{0};
+  std::uint_fast16_t a_{0};
+  std::uint_fast16_t b_{0};
+  std::int_fast32_t len_{0};
 };
 
 } // namespace dwarfs::writer::internal