oceanbase/deps/oblib/unittest/lib/allocator/test_slice_alloc.cpp

/**
 * Copyright (c) 2021 OceanBase
 * OceanBase CE is licensed under Mulan PubL v2.
 * You can use this software according to the terms and conditions of the Mulan PubL v2.
 * You may obtain a copy of Mulan PubL v2 at:
 *          http://license.coscl.org.cn/MulanPubL-2.0
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 * See the Mulan PubL v2 for more details.
 */

#include "lib/allocator/ob_slice_alloc.h"
#include "lib/allocator/ob_vslice_alloc.h"
#include "lib/allocator/ob_small_allocator.h"
#include "lib/allocator/ob_simple_fifo_alloc.h"
#include "lib/objectpool/ob_concurrency_objpool.h"
#include "lib/queue/ob_link_queue.h"
#include "lib/time/ob_time_utility.h"
#include "lib/metrics/ob_counter.h"

using namespace oceanbase;
using namespace oceanbase::common;

#define ISIZE 64
struct AllocInterface {
public:
  virtual void* alloc() = 0;
  virtual void free(void* p) = 0;
  virtual int64_t hold()
  {
    return 0;
  }
  virtual void set_nway(int nway)
  {
    UNUSED(nway);
  }
};

struct MallocWrapper : public AllocInterface {
public:
  void* alloc()
  {
    return ::malloc(ISIZE);
  }
  void free(void* p)
  {
    ::free(p);
  }
};

struct ObMallocWrapper : public AllocInterface {
public:
  void* alloc()
  {
    return common::ob_malloc(ISIZE);
  }
  void free(void* p)
  {
    common::ob_free(p);
  }
};

struct SmallAllocWrapper : public AllocInterface, public ObSmallAllocator {
public:
  SmallAllocWrapper()
  {
    alloc_.init(ISIZE);
  }
  void* alloc()
  {
    return alloc_.alloc();
  }
  void free(void* p)
  {
    alloc_.free(p);
  }

private:
  ObSmallAllocator alloc_;
};

struct OpAllocWrapper : public AllocInterface {
public:
  struct Item {
    char data[ISIZE];
  };
  void* alloc()
  {
    return (void*)op_alloc(Item);
  }
  void free(void* p)
  {
    return op_free((Item*)p);
  }
};

struct OpReclaimAllocWrapper : public AllocInterface {
public:
  struct Item {
    char data[ISIZE];
  };
  void* alloc()
  {
    return (void*)op_reclaim_alloc(Item);
  }
  void free(void* p)
  {
    return op_reclaim_free((Item*)p);
  }
};

ObMemAttr mem_attr;
struct SliceAllocWrapper : public AllocInterface {
public:
  SliceAllocWrapper() : alloc_(ISIZE, mem_attr, OB_MALLOC_BIG_BLOCK_SIZE)
  {
    alloc_.set_nway(64);
  }
  void* alloc()
  {
    return alloc_.alloc();
  }
  void free(void* p)
  {
    return alloc_.free(p);
  }
  void set_nway(int nway)
  {
    alloc_.set_nway(nway);
  }
  int64_t hold()
  {
    return alloc_.hold();
  }

private:
  ObSliceAlloc alloc_;
};

struct VSliceAllocWrapper : public AllocInterface {
public:
  VSliceAllocWrapper() : alloc_(mem_attr, OB_MALLOC_BIG_BLOCK_SIZE)
  {
    alloc_.set_nway(64);
  }
  void* alloc()
  {
    return alloc_.alloc(ISIZE);
  }
  void free(void* p)
  {
    return alloc_.free(p);
  }
  void set_nway(int nway)
  {
    alloc_.set_nway(nway);
  }
  int64_t hold()
  {
    return alloc_.hold();
  }

private:
  ObVSliceAlloc alloc_;
};

struct SimpleFifoAllocWrapper : public AllocInterface {
public:
  SimpleFifoAllocWrapper() : alloc_(mem_attr, OB_MALLOC_BIG_BLOCK_SIZE)
  {
    alloc_.set_nway(64);
  }
  void* alloc()
  {
    return alloc_.alloc(ISIZE);
  }
  void free(void* p)
  {
    return alloc_.free(p);
  }
  void set_nway(int nway)
  {
    alloc_.set_nway(nway);
  }
  int64_t hold()
  {
    return alloc_.hold();
  }

private:
  ObSimpleFifoAlloc alloc_;
};

ObTCCounter gcounter;
class FixedStack {
public:
  FixedStack() : top_(base_)
  {}
  void push(void* p)
  {
    if (NULL == p)
      abort();
    *top_++ = p;
  }
  void* pop()
  {
    return *--top_;
  }

private:
  void** top_;
  void* base_[4096];
};

FixedStack gstack[65];
FixedStack& get_stack()
{
  return gstack[get_itid()];
}

inline uint64_t rand64(uint64_t h)
{
  h ^= h >> 33;
  h *= 0xff51afd7ed558ccd;
  h ^= h >> 33;
  h *= 0xc4ceb9fe1a85ec53;
  h ^= h >> 33;
  return h;
}

int64_t next_seq()
{
  static int64_t init_seq = 0;
  static __thread int64_t seq = 0;
  if (seq <= 0) {
    seq = ATOMIC_AAF(&init_seq, 1);
  }
  return seq += 1024;
}

int64_t rand_gen()
{
  return rand64(next_seq());
}

inline void do_alloc(AllocInterface* ga, int64_t count = 1)
{
  for (int i = 0; i < count; i++) {
    get_stack().push(ga->alloc());
  }
}

inline void do_free(AllocInterface* ga, int64_t count = 1)
{
  for (int i = 0; i < count; i++) {
    ga->free(get_stack().pop());
  }
}

volatile bool g_stop CACHE_ALIGNED;
void* thread_func(AllocInterface* ga)
{
  while (!g_stop) {
    int64_t x = 1 + (rand_gen() & 1023);
    do_alloc(ga, x);
    do_free(ga, x);
    gcounter.inc(x);
  }
  return NULL;
}

#define cfgi(k, d) atoi(getenv(k) ?: #d)
void do_perf(AllocInterface* ga)
{
  int n_sec = cfgi("n_sec", 1);
  int n_way = cfgi("n_way", 1);
  int n_thread = cfgi("n_thread", 8);
  pthread_t thread[128];
  g_stop = false;
  ga->set_nway(n_way);
  for (int i = 0; i < n_thread; i++) {
    pthread_create(thread + i, NULL, (void* (*)(void*))thread_func, ga);
  }
  sleep(1);
  int64_t last = gcounter.value();
  while (n_sec--) {
    sleep(1);
    int64_t cur = gcounter.value();
    fprintf(stderr, "tps=%'ld hold=%ld\n", cur - last, ga->hold());
    last = cur;
  }
  g_stop = true;
  for (int i = 0; i < n_thread; i++) {
    pthread_join(thread[i], NULL);
  }
}
// int64_t get_us() { return ObTimeUtility::current_time(); }
#define PERF(x)               \
  {                           \
    fprintf(stderr, #x "\n"); \
    x##Wrapper ga;            \
    do_perf(&ga);             \
  }

#include <locale.h>
int main()
{
  setlocale(LC_ALL, "");
  PERF(SliceAlloc);
  PERF(VSliceAlloc);
  PERF(Malloc);
  PERF(ObMalloc);
  PERF(SmallAlloc);
  PERF(OpAlloc);
  PERF(OpReclaimAlloc);
  PERF(SimpleFifoAlloc);
  return 0;
}