Fix tdutils after merge.

GitOrigin-RevId: 3eceb2e574a737a78dc5414e535e416c86d23f7a

td/telegram/files/FileDownloader.cpp

@@ -331,16 +331,15 @@ Result<size_t> FileDownloader::process_part(Part part, NetQueryPtr net_query) {
 
   // Encryption
   if (need_cdn_decrypt) {
-    UInt128 iv = as<UInt128>(cdn_encryption_iv_.c_str());
     CHECK(part.offset % 16 == 0);
     auto offset = narrow_cast<uint32>(part.offset / 16);
     offset =
         ((offset & 0xff) << 24) | ((offset & 0xff00) << 8) | ((offset & 0xff0000) >> 8) | ((offset & 0xff000000) >> 24);
-    as<uint32>(iv.raw + 12) = offset;
-    UInt256 key = as<UInt256>(cdn_encryption_key_.c_str());
 
     AesCtrState ctr_state;
-    ctr_state.init(as_slice(key), as_slice(iv));
+    string iv = cdn_encryption_iv_;
+    as<uint32>(&iv[12]) = offset;
+    ctr_state.init(cdn_encryption_key_, iv);
     ctr_state.decrypt(bytes.as_slice(), bytes.as_slice());
   }
   if (encryption_key_.is_secret()) {

tdactor/test/actors_main.cpp

@@ -481,7 +481,7 @@ class XContext : public ActorContext {
   int x = 1234;
 };
 
-class WithContext : public Actor {
+class WithXContext : public Actor {
  public:
   void start_up() override {
     set_context(std::make_shared<XContext>());
@@ -491,8 +491,6 @@ class WithContext : public Actor {
   void close() {
     stop();
   }
-
- private:
 };
 
 void check_context() {
@@ -510,11 +508,11 @@ TEST(Actors, context_during_destruction) {
 
   {
     auto guard = sched.get_main_guard();
-    auto with_context = create_actor<WithContext>("WithContext").release();
-    send_closure(with_context, &WithContext::f, create_lambda_guard([] { check_context(); }));
-    send_closure_later(with_context, &WithContext::close);
-    send_closure(with_context, &WithContext::f, create_lambda_guard([] { check_context(); }));
-    send_closure(with_context, &WithContext::f, create_lambda_guard([] { Scheduler::instance()->finish(); }));
+    auto with_context = create_actor<WithXContext>("WithXContext").release();
+    send_closure(with_context, &WithXContext::f, create_lambda_guard([] { check_context(); }));
+    send_closure_later(with_context, &WithXContext::close);
+    send_closure(with_context, &WithXContext::f, create_lambda_guard([] { check_context(); }));
+    send_closure(with_context, &WithXContext::f, create_lambda_guard([] { Scheduler::instance()->finish(); }));
   }
   sched.start();
   while (sched.run_main(10)) {

tdutils/CMakeLists.txt

@@ -99,17 +99,17 @@ set(TDUTILS_SOURCE
   td/utils/MpmcQueue.cpp
   td/utils/OptionsParser.cpp
   td/utils/Random.cpp
-  td/utils/Slice.cpp
   td/utils/SharedSlice.cpp
+  td/utils/Slice.cpp
   td/utils/StackAllocator.cpp
   td/utils/Status.cpp
   td/utils/StringBuilder.cpp
+  td/utils/tests.cpp
   td/utils/Time.cpp
   td/utils/Timer.cpp
-  td/utils/TsFileLog.cpp
-  td/utils/tests.cpp
   td/utils/tl_parsers.cpp
   td/utils/translit.cpp
+  td/utils/TsFileLog.cpp
   td/utils/unicode.cpp
   td/utils/utf8.cpp
 
@@ -220,6 +220,7 @@ set(TDUTILS_SOURCE
   td/utils/Random.h
   td/utils/ScopeGuard.h
   td/utils/SharedObjectPool.h
+  td/utils/SharedSlice.h
   td/utils/Slice-decl.h
   td/utils/Slice.h
   td/utils/Span.h
@@ -230,15 +231,16 @@ set(TDUTILS_SOURCE
   td/utils/StorerBase.h
   td/utils/StringBuilder.h
   td/utils/tests.h
+  td/utils/ThreadLocalStorage.h
   td/utils/ThreadSafeCounter.h
   td/utils/Time.h
   td/utils/TimedStat.h
   td/utils/Timer.h
-  td/utils/TsFileLog.h
   td/utils/tl_helpers.h
   td/utils/tl_parsers.h
   td/utils/tl_storers.h
   td/utils/translit.h
+  td/utils/TsFileLog.h
   td/utils/type_traits.h
   td/utils/UInt.h
   td/utils/uint128.h
@@ -254,6 +256,7 @@ set(TDUTILS_TEST_SOURCE
   ${CMAKE_CURRENT_SOURCE_DIR}/test/ConcurrentHashMap.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test/crypto.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test/Enumerator.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test/EpochBasedMemoryReclamation.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test/filesystem.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test/gzip.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test/HazardPointers.cpp

tdutils/td/utils/FileLog.h

@@ -37,7 +37,7 @@ class FileLog : public LogInterface {
   string path_;
   int64 size_ = 0;
   int64 rotate_threshold_ = 0;
-  bool redirect_stderr_;
+  bool redirect_stderr_ = false;
 
   void do_rotate();
 };

tdutils/td/utils/SharedSlice.cpp

@@ -11,7 +11,7 @@
 namespace td {
 
 BufferSlice SharedSlice::clone_as_buffer_slice() const {
-  return BufferSlice{as_slice().str()};
+  return BufferSlice{as_slice()};
 }
 
 }  // namespace td

tdutils/td/utils/SharedSlice.h

@@ -15,7 +15,7 @@ namespace td {
 
 namespace detail {
 struct SharedSliceHeader {
-  explicit SharedSliceHeader(size_t size) : refcnt_{1}, size_{size} {
+  explicit SharedSliceHeader(size_t size) : size_{size} {
   }
 
   void inc() {
@@ -37,7 +37,7 @@ struct SharedSliceHeader {
   }
 
  private:
-  std::atomic<uint64> refcnt_;
+  std::atomic<uint64> refcnt_{1};
   size_t size_;
 };
 
@@ -107,9 +107,9 @@ class UnsafeSharedSlice {
 
   static UnsafeSharedSlice create(size_t size) {
     static_assert(std::is_standard_layout<HeaderT>::value, "HeaderT must have statdard layout");
-    auto ptr = std::make_unique<char[]>(size + sizeof(HeaderT));
+    auto ptr = std::make_unique<char[]>(sizeof(HeaderT) + size);
     auto header_ptr = new (ptr.get()) HeaderT(size);
-    CHECK(reinterpret_cast<char *>(header_ptr) == ptr.get());
+    CHECK(header_ptr == reinterpret_cast<HeaderT *>(ptr.get()));
 
     return UnsafeSharedSlice(std::move(ptr));
   }
@@ -160,8 +160,7 @@ class SharedSlice {
  public:
   SharedSlice() = default;
 
-  explicit SharedSlice(Slice slice) : impl_(Impl::create(slice.size())) {
-    impl_.as_mutable_slice().copy_from(slice);
+  explicit SharedSlice(Slice slice) : impl_(Impl::create(slice)) {
   }
 
   explicit SharedSlice(UniqueSharedSlice from);
@@ -301,7 +300,7 @@ class UniqueSliceImpl {
   explicit UniqueSliceImpl(size_t size) : impl_(Impl::create(size)) {
   }
   UniqueSliceImpl(size_t size, char c) : impl_(Impl::create(size)) {
-    std::memset(as_mutable_slice().data(), c, size);
+    as_mutable_slice().fill(c);
   }
   explicit UniqueSliceImpl(Slice slice) : impl_(Impl::create(slice)) {
   }

tdutils/td/utils/Slice.cpp

@@ -5,6 +5,7 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 #include "td/utils/Slice.h"
+
 #if TD_HAVE_OPENSSL
 #include <openssl/crypto.h>
 #endif
@@ -14,16 +15,18 @@ namespace td {
 void MutableSlice::fill(char c) {
   std::memset(data(), c, size());
 }
+
 void MutableSlice::fill_zero() {
-  fill(0);
+  fill('\0');
 }
+
 void MutableSlice::fill_zero_secure() {
 #if TD_HAVE_OPENSSL
   OPENSSL_cleanse(begin(), size());
 #else
   volatile char *ptr = begin();
   for (size_t i = 0; i < size(); i++) {
-    ptr[i] = 0;
+    ptr[i] = '\0';
   }
 #endif
 }

tdutils/td/utils/ThreadLocalStorage.h

@@ -6,14 +6,13 @@
 //
 #pragma once
 
-#include "td/utils/port/thread.h"
 #include "td/utils/port/thread_local.h"
-#include "td/utils/int_types.h"
 
-#include <atomic>
 #include <array>
+#include <atomic>
 
 namespace td {
+
 template <class T>
 class ThreadLocalStorage {
  public:
@@ -23,15 +22,15 @@ class ThreadLocalStorage {
 
   template <class F>
   void for_each(F&& f) {
-    int n = max_thread_id_.load();
-    for (int i = 0; i < n; i++) {
+    int32 n = max_thread_id_.load();
+    for (int32 i = 0; i < n; i++) {
       f(nodes_[i].value);
     }
   }
   template <class F>
   void for_each(F&& f) const {
-    int n = max_thread_id_.load();
-    for (int i = 0; i < n; i++) {
+    int32 n = max_thread_id_.load();
+    for (int32 i = 0; i < n; i++) {
       f(nodes_[i].value);
     }
   }
@@ -39,10 +38,10 @@ class ThreadLocalStorage {
  private:
   struct Node {
     T value{};
-    char padding[128];
+    char padding[TD_CONCURRENCY_PAD];
   };
-  static constexpr int MAX_THREAD_ID = 128;
-  std::atomic<int> max_thread_id_{MAX_THREAD_ID};
+  static constexpr int32 MAX_THREAD_ID = 128;
+  std::atomic<int32> max_thread_id_{MAX_THREAD_ID};
   std::array<Node, MAX_THREAD_ID> nodes_;
 
   Node& thread_local_node() {
@@ -51,4 +50,5 @@ class ThreadLocalStorage {
     return nodes_[thread_id];
   }
 };
+
 }  // namespace td

tdutils/td/utils/ThreadSafeCounter.h

@@ -5,13 +5,15 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 #pragma once
-#include "td/utils/ThreadLocalStorage.h"
+
 #include "td/utils/StringBuilder.h"
+#include "td/utils/ThreadLocalStorage.h"
 
 #include <array>
 #include <mutex>
 
 namespace td {
+
 template <size_t N>
 class ThreadSafeMultiCounter {
  public:
@@ -23,7 +25,7 @@ class ThreadSafeMultiCounter {
   int64 sum(size_t index) const {
     CHECK(index < N);
     int64 res = 0;
-    tls_.for_each([&](auto &value) { res += value[index].load(); });
+    tls_.for_each([&](auto &value) { res += value[index].load(std::memory_order_relaxed); });
     return res;
   }
 
@@ -75,7 +77,7 @@ class NamedThreadSafeCounter {
       }
     }
     CHECK(names_.size() < N);
-    names_.push_back(name.str());
+    names_.emplase_back(name.begin(), name.size());
     return get_counter_ref(names_.size() - 1);
   }
 

tdutils/td/utils/TsFileLog.cpp

@@ -4,15 +4,21 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
-#include "TsFileLog.h"
+#include "td/utils/TsFileLog.h"
+
+#include "td/utils/logging.h"
+
+#include <array>
 
 namespace td {
+
 namespace detail {
-class TsFileLog : public LogInterface {
+
+class TsFileLogImpl : public LogInterface {
  public:
   Status init(string path) {
     path_ = std::move(path);
-    for (int i = 0; i < (int)logs_.size(); i++) {
+    for (int32 i = 0; i < static_cast<int32>(logs_.size()); i++) {
       logs_[i].id = i;
     }
     return init_info(&logs_[0]);
@@ -36,17 +42,17 @@ class TsFileLog : public LogInterface {
  private:
   struct Info {
     FileLog log;
-    bool is_inited;
-    int id;
+    bool is_inited = false;
+    int32 id;
   };
-  static constexpr int MAX_THREAD_ID = 128;
+  static constexpr int32 MAX_THREAD_ID = 128;
   std::string path_;
   std::array<Info, MAX_THREAD_ID> logs_;
 
   LogInterface *get_current_logger() {
     auto *info = get_current_info();
     if (!info->is_inited) {
-      CHECK(init_info(info).is_ok());
+      init_info(info).ensure();
     }
     return &info->log;
   }
@@ -61,18 +67,20 @@ class TsFileLog : public LogInterface {
     return Status::OK();
   }
 
-  string get_path(Info *info) {
+  string get_path(const Info *info) {
     if (info->id == 0) {
       return path_;
     }
     return PSTRING() << path_ << "." << info->id;
   }
 };
+
 }  // namespace detail
 
-Result<td::unique_ptr<LogInterface>> TsFileLog::create(string path) {
-  auto res = td::make_unique<detail::TsFileLog>();
+Result<unique_ptr<LogInterface>> TsFileLog::create(string path) {
+  auto res = make_unique<detail::TsFileLogImpl>();
   TRY_STATUS(res->init(path));
   return std::move(res);
 }
+
 }  // namespace td

tdutils/td/utils/TsFileLog.h

@@ -6,11 +6,16 @@
 //
 #pragma once
 
+#include "td/utils/common.h"
 #include "td/utils/FileLog.h"
+#include "td/utils/logging.h"
+#include "td/utils/Status.h"
 
 namespace td {
+
 class TsFileLog {
  public:
-  static Result<td::unique_ptr<LogInterface>> create(string path);
+  static Result<unique_ptr<LogInterface>> create(string path);
 };
+
 }  // namespace td

tdutils/td/utils/base64.cpp

@@ -7,11 +7,10 @@
 #include "td/utils/base64.h"
 
 #include "td/utils/common.h"
+#include "td/utils/format.h"
 #include "td/utils/Slice.h"
 #include "td/utils/Status.h"
 
-#include "td/utils/format.h"
-
 #include <algorithm>
 #include <iterator>
 
@@ -110,8 +109,7 @@ Status base64_do_decode(Slice base64, F &&append) {
 Result<string> base64_decode(Slice base64) {
   init_base64_table();
 
-  TRY_RESULT(tmp, base64_drop_padding(base64));
-  base64 = tmp;
+  TRY_RESULT_ASSIGN(base64, base64_drop_padding(base64));
 
   string output;
   output.reserve(((base64.size() + 3) >> 2) * 3);
@@ -122,8 +120,7 @@ Result<string> base64_decode(Slice base64) {
 Result<SecureString> base64_decode_secure(Slice base64) {
   init_base64_table();
 
-  TRY_RESULT(tmp, base64_drop_padding(base64));
-  base64 = tmp;
+  TRY_RESULT_ASSIGN(base64, base64_drop_padding(base64));
 
   SecureString output(((base64.size() + 3) >> 2) * 3);
   char *ptr = output.as_mutable_slice().begin();

tdutils/td/utils/base64.h

@@ -7,8 +7,8 @@
 #pragma once
 
 #include "td/utils/common.h"
-#include "td/utils/Slice.h"
 #include "td/utils/SharedSlice.h"
+#include "td/utils/Slice.h"
 #include "td/utils/Status.h"
 
 namespace td {

tdutils/td/utils/crypto.cpp

@@ -308,7 +308,7 @@ class AesCtrState::Impl {
     if (AES_set_encrypt_key(key.ubegin(), 256, &aes_key) < 0) {
       LOG(FATAL) << "Failed to set encrypt key";
     }
-    counter.as_mutable_slice().copy_from(as_slice(iv));
+    counter.as_mutable_slice().copy_from(iv);
     current_pos = 0;
   }
 

tdutils/td/utils/crypto.h

@@ -8,8 +8,8 @@
 
 #include "td/utils/buffer.h"
 #include "td/utils/common.h"
-#include "td/utils/Slice.h"
 #include "td/utils/SharedSlice.h"
+#include "td/utils/Slice.h"
 #include "td/utils/Status.h"
 
 namespace td {

tdutils/td/utils/filesystem.h

@@ -7,15 +7,15 @@
 #pragma once
 
 #include "td/utils/buffer.h"
-#include "td/utils/Slice.h"
 #include "td/utils/SharedSlice.h"
+#include "td/utils/Slice.h"
 #include "td/utils/Status.h"
 
 namespace td {
 
 Result<BufferSlice> read_file(CSlice path, int64 size = -1, int64 offset = 0);
-Result<string> read_file_str(CSlice path, int64 size = -1, int64 offset = 0);
 Result<SecureString> read_file_secure(CSlice path, int64 size = -1, int64 offset = 0);
+Result<string> read_file_str(CSlice path, int64 size = -1, int64 offset = 0);
 
 Status copy_file(CSlice from, CSlice to, int64 size = -1) TD_WARN_UNUSED_RESULT;
 

tdutils/td/utils/tl_helpers.h

@@ -9,8 +9,8 @@
 #include "td/utils/common.h"
 #include "td/utils/logging.h"
 #include "td/utils/misc.h"
-#include "td/utils/Slice.h"
 #include "td/utils/SharedSlice.h"
+#include "td/utils/Slice.h"
 #include "td/utils/StackAllocator.h"
 #include "td/utils/Status.h"
 #include "td/utils/tl_parsers.h"

tdutils/td/utils/tl_parsers.h

@@ -156,12 +156,14 @@ class TlParser {
       data += sizeof(int32);
     } else {
       check_len(sizeof(int32));
-      result_len = data[1] + (data[2] << 8) + (data[3] << 16) + (data[4] << 24) + (static_cast<uint64>(data[5]) << 32) +
-                   (static_cast<uint64>(data[6]) << 40) + (static_cast<uint64>(data[7]) << 48);
-      if (result_len > std::numeric_limits<size_t>::max() - 3) {
+      auto result_len_uint64 = data[1] + (data[2] << 8) + (data[3] << 16) + (data[4] << 24) +
+                               (static_cast<uint64>(data[5]) << 32) + (static_cast<uint64>(data[6]) << 40) +
+                               (static_cast<uint64>(data[7]) << 48);
+      if (result_len_uint64 > std::numeric_limits<size_t>::max() - 3) {
         set_error("Too big string found");
         return T();
       }
+      result_len = static_cast<size_t>(result_len_uint64);
       result_begin = reinterpret_cast<const char *>(data + 8);
       result_aligned_len = ((result_len + 3) >> 2) << 2;
       data += sizeof(int64);

tdutils/td/utils/tl_storers.h

@@ -83,7 +83,7 @@ class TlStorerUnsafe {
         // fallthrough
       case 2:
         *buf_++ = 0;
-      // fallthrough
+        // fallthrough
       case 3:
         *buf_++ = 0;
     }

tdutils/test/SharedSlice.cpp

@@ -4,66 +4,65 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
-#include "td/utils/tests.h"
 #include "td/utils/SharedSlice.h"
-
-using namespace td;
+#include "td/utils/tests.h"
 
 TEST(SharedSlice, Hands) {
   {
-    SharedSlice h("hello");
+    td::SharedSlice h("hello");
     ASSERT_EQ("hello", h.as_slice());
     // auto g = h; // CE
     auto g = h.clone();
+    ASSERT_EQ("hello", h.as_slice());
     ASSERT_EQ("hello", g.as_slice());
   }
 
   {
-    SharedSlice h("hello");
-    UniqueSharedSlice g(std::move(h));
+    td::SharedSlice h("hello");
+    td::UniqueSharedSlice g(std::move(h));
     ASSERT_EQ("", h.as_slice());
     ASSERT_EQ("hello", g.as_slice());
   }
   {
-    SharedSlice h("hello");
-    SharedSlice t = h.clone();
-    UniqueSharedSlice g(std::move(h));
+    td::SharedSlice h("hello");
+    td::SharedSlice t = h.clone();
+    td::UniqueSharedSlice g(std::move(h));
     ASSERT_EQ("", h.as_slice());
     ASSERT_EQ("hello", g.as_slice());
     ASSERT_EQ("hello", t.as_slice());
   }
 
   {
-    UniqueSharedSlice g(5);
+    td::UniqueSharedSlice g(5);
     g.as_mutable_slice().copy_from("hello");
-    SharedSlice h(std::move(g));
+    td::SharedSlice h(std::move(g));
     ASSERT_EQ("hello", h);
     ASSERT_EQ("", g);
   }
 
   {
-    UniqueSlice h("hello");
-    UniqueSlice g(std::move(h));
+    td::UniqueSlice h("hello");
+    td::UniqueSlice g(std::move(h));
     ASSERT_EQ("", h.as_slice());
     ASSERT_EQ("hello", g.as_slice());
   }
 
   {
-    SecureString h("hello");
-    SecureString g(std::move(h));
+    td::SecureString h("hello");
+    td::SecureString g(std::move(h));
     ASSERT_EQ("", h.as_slice());
     ASSERT_EQ("hello", g.as_slice());
   }
 
   {
-    Stage stage;
-    SharedSlice a, b;
-    std::vector<td::thread> threads(2);
+    td::Stage stage;
+    td::SharedSlice a, b;
+    td::vector<td::thread> threads(2);
     for (int i = 0; i < 2; i++) {
       threads[i] = td::thread([i, &stage, &a, &b] {
         for (int j = 0; j < 10000; j++) {
           if (i == 0) {
-            a = SharedSlice("hello");
+            a = td::SharedSlice("hello");
             b = a.clone();
           }
           stage.wait((2 * j + 1) * 2);
@@ -71,7 +70,7 @@ TEST(SharedSlice, Hands) {
             ASSERT_EQ('h', a[0]);
             a.clear();
           } else {
-            UniqueSharedSlice c(std::move(b));
+            td::UniqueSharedSlice c(std::move(b));
             c.as_mutable_slice()[0] = '!';
           }
           stage.wait((2 * j + 2) * 2);

tdutils/test/log.cpp

@@ -4,23 +4,22 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
-#include "td/utils/tests.h"
+#include "td/utils/benchmark.h"
 #include "td/utils/FileLog.h"
-#include "td/utils/TsFileLog.h"
 #include "td/utils/logging.h"
 #include "td/utils/port/path.h"
-#include "td/utils/benchmark.h"
+#include "td/utils/tests.h"
+#include "td/utils/TsFileLog.h"
 
 // Thread safe logging with tests
 //
 // LOG uses thread local LogInterface
 // void append(CSlice slice, int log_level);
-//
 
 template <class Log>
 class LogBenchmark : public td::Benchmark {
  public:
-  explicit LogBenchmark(std::string name, int threads_n, std::function<td::unique_ptr<Log>()> creator)
+  LogBenchmark(std::string name, int threads_n, std::function<td::unique_ptr<Log>()> creator)
       : name_(std::move(name)), threads_n_(threads_n), creator_(std::move(creator)) {
   }
   std::string get_description() const override {