init push

deps/oblib/unittest/lib/queue/test_link_queue.cpp

@@ -0,0 +1,154 @@
+/**
+ * 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/objectpool/ob_concurrency_objpool.h"
+#include "lib/queue/ob_link_queue.h"
+#include "lib/queue/ob_lighty_queue.h"
+#include "lib/time/ob_time_utility.h"
+#include "lib/metrics/ob_counter.h"
+using namespace oceanbase;
+using namespace oceanbase::common;
+
+ObTCCounter push_count, pop_count;
+
+volatile bool g_stop CACHE_ALIGNED;
+#define MAGIC 12345678
+void before_push(int64_t* p)
+{
+  *p = MAGIC;
+}
+void after_pop(int64_t* p)
+{
+  if (MAGIC != *p) {
+    fprintf(stderr, "pop error\n");
+    abort();
+  }
+  *p = 0;
+}
+
+struct QI {
+  virtual int push(void* p) = 0;
+  virtual void* pop(int64_t timeout) = 0;
+};
+
+struct SLinkQueueWrapper : public QI {
+  int push(void* p)
+  {
+    q_.push((ObLink*)p);
+    return 0;
+  }
+  void* pop(int64_t timeout)
+  {
+    UNUSED(timeout);
+    return (void*)q_.pop();
+  }
+  ObSpScLinkQueue q_;
+};
+
+struct LightyQueueWrapper : public QI {
+  LightyQueueWrapper()
+  {
+    q_.init(1 << 20);
+  }
+  int push(void* p)
+  {
+    return q_.push(p);
+  }
+  void* pop(int64_t timeout)
+  {
+    void* p = NULL;
+    q_.pop(p, timeout);
+    return p;
+  }
+  ObLightyQueue q_;
+};
+void do_push(QI* q)
+{
+  void* p = malloc(16);
+  before_push((int64_t*)p + 1);
+  while (0 != q->push(p))
+    ;
+}
+
+void do_pop(QI* q)
+{
+  void* p = NULL;
+  int64_t timeout = 100 * 1000;
+  while (NULL == (p = q->pop(timeout)))
+    ;
+  after_pop((int64_t*)p + 1);
+  free(p);
+}
+
+void* pop_loop(QI* q)
+{
+  while (!g_stop) {
+    do_pop(q);
+    pop_count.inc(1);
+  }
+  return NULL;
+}
+void* push_loop(QI* q)
+{
+  while (!g_stop) {
+    do_push(q);
+    usleep(100);
+    push_count.inc(1);
+  }
+  return NULL;
+}
+
+#define cfgi(k, d) atoi(getenv(k) ?: #d)
+typedef void* handler_t(void*);
+void do_perf(QI* qi)
+{
+  int n_sec = cfgi("n_sec", 1);
+  int n_thread = cfgi("n_thread", 2);
+  pthread_t thread[256];
+  g_stop = false;
+  for (int i = 0; i < n_thread; i++) {
+    handler_t* handler = (handler_t*)((i % 2) ? push_loop : pop_loop);
+    pthread_create(thread + i, NULL, handler, qi);
+  }
+  sleep(1);
+  int64_t last_push = push_count.value();
+  int64_t last_pop = pop_count.value();
+  while (n_sec--) {
+    sleep(1);
+    int64_t cur_push = push_count.value();
+    int64_t cur_pop = pop_count.value();
+    fprintf(stderr, "push=%'ld pop=%'ld\n", cur_push - last_push, cur_pop - last_pop);
+    last_push = cur_push;
+    last_pop = cur_pop;
+  }
+  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 qi;            \
+    do_perf(&qi);             \
+  }
+
+#include <locale.h>
+int main()
+{
+  setlocale(LC_ALL, "");
+  // PERF(SLinkQueue);
+  PERF(LightyQueue);
+  return 0;
+}