oceanbase/unittest/storage/memtable/test_base.h

/**
 * 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.
 */

#ifndef __OB_COMMON_TEST_BASE_H__
#define __OB_COMMON_TEST_BASE_H__

#include <errno.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
#include <sys/time.h>
#include <unistd.h>

inline uint64_t rand64(uint64_t h)
{
  if (0 == h) return 1;
  h ^= h >> 33;
  h *= 0xff51afd7ed558ccd;
  h ^= h >> 33;
  h *= 0xc4ceb9fe1a85ec53;
  h ^= h >> 33;
  //h &= ~(1ULL<<63);
  return h;
}

int64_t get_us()
{
  struct timeval time_val;
  gettimeofday(&time_val, NULL);
  return time_val.tv_sec * 1000000 + time_val.tv_usec;
}

#define profile(expr, n) { \
    int64_t start = get_usec(); \
    expr;\
    int64_t end = get_usec();\
    printf("%s: 1000000*%ld/%ld=%ld\n", #expr, n, end - start, 1000000 * n / (end - start)); \
  }

struct Callable
{
  Callable(): stop_(false) {}
  virtual ~Callable() {}
  virtual int call(pthread_t thread, int64_t idx) = 0;
  volatile bool stop_;
};

typedef void *(*pthread_handler_t)(void *);
class BaseWorker
{
public:
  static const int64_t MAX_N_THREAD = 16;
  struct WorkContext
  {
    WorkContext() : callable_(NULL), idx_(0) {}
    ~WorkContext() {}
    WorkContext &set(Callable *callable, int64_t idx)
    {
      callable_ = callable;
      idx_ = idx;
      return *this;
    }
    Callable *callable_;
    pthread_t thread_;
    int64_t idx_;
  };
public:
  BaseWorker(): n_thread_(0), thread_running_(false) {}
  ~BaseWorker()
  {
    wait();
  }
public:
  BaseWorker &set_thread_num(int64_t n) { n_thread_ = n; return *this; }
  int start(Callable *callable, int64_t idx = -1)
  {
    int err = 0;
    for (int64_t i = 0; i < n_thread_; i++) {
      if (idx > 0 && idx != i) { continue; }
      fprintf(stderr, "worker[%ld] start.\n", i);
      pthread_create(&ctx_[i].thread_, NULL, (pthread_handler_t)do_work, (void *)(&ctx_[i].set(callable,
                                                                                               i)));
    }
    thread_running_ = true;
    return err;
  }

  int wait(int64_t idx = -1)
  {
    int err = 0;
    int64_t ret = 0;
    for (int64_t i = 0; thread_running_ && i < n_thread_; i++) {
      if (idx > 0 && idx != i) { continue; }
      pthread_join(ctx_[i].thread_, (void **)&ret);
      if (ret != 0) {
        fprintf(stderr, "thread[%ld] => %ld\n", i, ret);
      } else {
        fprintf(stderr, "thread[%ld] => OK.\n", i);
      }
    }
    thread_running_ = false;
    return err;
  }

  static int do_work(WorkContext *ctx)
  {
    int err = 0;
    if (NULL == ctx || NULL == ctx->callable_) {
      err = -EINVAL;
    } else {
      err = ctx->callable_->call(ctx->thread_, ctx->idx_);
    }
    return err;
  }
  int par_do(Callable *callable, int64_t duration)
  {
    int err = 0;
    if (0 != (err = start(callable))) {
      fprintf(stderr, "start()=>%d\n", err);
    } else {
      usleep(static_cast<__useconds_t>(duration));
      callable->stop_ = true;
    }
    if (0 != (err = wait())) {
      fprintf(stderr, "wait()=>%d\n", err);
    }
    return err;
  }
protected:
  int64_t n_thread_;
  bool thread_running_;
  WorkContext ctx_[MAX_N_THREAD];
};

int PARDO(int64_t thread_num, Callable *call, int64_t duration)
{
  BaseWorker worker;
  fprintf(stderr, "thread_num=%ld\n", thread_num);
  return worker.set_thread_num(thread_num).par_do(call, duration);
}

#if 0
struct SimpleCallable: public Callable
{
  int64_t n_items_;
  SimpleCallable &set(int64_t n_items)
  {
    n_items_ = n_items;
    return *this;
  }
  int call(pthread_t thread, int64_t idx)
  {
    int err = 0;
    fprintf(stdout, "worker[%ld] run\n", idx);
    if (idx % 2) {
      err = -EPERM;
    }
    return err;
  }
};

int main(int argc, char **argv)
{
  int err = 0;
  BaseWorker worker;
  SimpleCallable callable;
  int64_t n_thread = 0;
  int64_t n_items = 0;
  if (argc != 3) {
    err = -EINVAL;
    fprintf(stderr, "%s n_thread n_item\n", argv[0]);
  } else {
    n_thread = atoll(argv[1]);
    n_items = atoll(argv[2]);
    profile(worker.set_thread_num(n_thread).par_do(&callable.set(n_items), 10000000), n_items);
  }
}
#endif


class RWT: public Callable
{
  typedef void *(*pthread_handler_t)(void *);
  struct Thread
  {
    int set(RWT *self, int64_t idx) { self_ = self, idx_ = idx; return 0; }
    pthread_t thread_;
    RWT *self_;
    int64_t idx_;
  };
public:
  RWT(): n_read_thread_(0), n_write_thread_(0), n_admin_thread_(0) {}
  virtual ~RWT() {}
public:
  int64_t get_thread_num() { return 1 + n_read_thread_ + n_write_thread_ + n_admin_thread_; }
  RWT &set(const int64_t n_read, const int64_t n_write, const int64_t n_admin = 0)
  {
    n_read_thread_ = n_read;
    n_write_thread_ = n_write;
    n_admin_thread_ = n_admin;
    return *this;
  }
  int report_loop()
  {
    int err = 0;
    int64_t report_interval = 1000 * 1000;
    while (!stop_ && 0 == err) {
      usleep(static_cast<__useconds_t>(report_interval));
      err = report();
    }
    return err;
  }
  virtual int call(pthread_t thread, const int64_t idx_)
  {
    int err = 0;
    int64_t idx = idx_;
    (void)(thread);
    fprintf(stderr, "rwt.start(idx=%ld)\n", idx_);
    if (idx < 0) {
      err = -EINVAL;
    }
    if (0 == err && idx >= 0) {
      if (idx == 0) {
        err = report_loop();
      }
      idx -= 1;
    }
    if (0 == err && idx >= 0) {
      if (idx < n_read_thread_) {
        err = read(idx);
      }
      idx -= n_read_thread_;
    }
    if (0 == err && idx >= 0) {
      if (idx < n_write_thread_) {
        err = write(idx);
      }
      idx -= n_write_thread_;
    }
    if (0 == err && idx >= 0) {
      if (idx < n_admin_thread_) {
        err = admin(idx);
      }
      idx -= n_admin_thread_;
    }
    if (0 == err && idx >= 0) {
      err = -EINVAL;
    }
    if (0 != err) {
      stop_ = true;
    }
    fprintf(stderr, "rwt.start(idx=%ld)=>%d\n", idx_, err);
    return err;
  }
  virtual int report() { return 0; }
  virtual int read(const int64_t idx) = 0;
  virtual int write(const int64_t idx) = 0;
  virtual int admin(const int64_t idx) { (void)(idx);  return 0; }
protected:
  int64_t n_read_thread_;
  int64_t n_write_thread_;
  int64_t n_admin_thread_;
};

#define _cfg(k, v) getenv(k)?:v
#define _cfgi(k, v) atoll(getenv(k)?:v)

inline int64_t rand_range(int64_t s, int64_t e)
{
  return s + random() % (e - s);
}

#define RWT_def(base) \
  TEST_F(base, Rand){ \
    ASSERT_EQ(0, PARDO(get_thread_num(), this, duration));      \
    ASSERT_EQ(0, check_error());                                \
  }

#include "gtest/gtest.h"
#include "common/data_buffer.h"
#include "lib/allocator/ob_allocator.h"
#include "lib/allocator/ob_malloc.h"
#include "lib/regex/regex/utils.h"

using namespace oceanbase::common;

struct BufHolder
{
  BufHolder(int64_t limit) { buf_ = (char *)ob_malloc(limit, ObModIds::TEST); }
  ~BufHolder() { ob_free((void *)buf_); }
  char *buf_;
};

struct BaseConfig
{
  static const int64_t buf_limit = 1 << 21;
  BufHolder buf_holder;
  ObDataBuffer buf;
  int64_t duration;
  const char *schema;
  int64_t table_id;
  BaseConfig(): buf_holder(buf_limit)
  {
    buf.set_data(buf_holder.buf_, buf_limit);
    duration = _cfgi("duration", "3000000");
    schema = "./test.schema";
    table_id = 1002;
  }
};

class FixedAllocator: public ObIAllocator
{
public:
  FixedAllocator(char *buf, int64_t limit): buf_(buf), limit_(limit), pos_(0) {}
  virtual ~FixedAllocator() {}
public:
  void reset() { pos_ = 0; }
  virtual void *alloc(const int64_t sz)
  {
    void *ptr = NULL;
    int64_t pos = 0;
    if ((pos = __sync_add_and_fetch(&pos_, sz)) > limit_) {
      __sync_add_and_fetch(&pos_, -sz);
    } else {
      ptr = buf_ + pos;
    }
    return ptr;
  }
  virtual void free(void *ptr) { UNUSED(ptr); }
private:
  char *buf_;
  int64_t limit_;
  int64_t pos_;
};

#endif /* __OB_COMMON_TEST_BASE_H__ */