hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

patch 4.0

Browse Source
This commit is contained in:
wangzelin.wzl
2022-10-24 10:34:53 +08:00
parent 4ad6e00ec3
commit 93a1074b0c
10533 changed files with 2588271 additions and 2299373 deletions
Download Patch File Download Diff File Expand all files Collapse all files

166
deps/oblib/unittest/lib/container/ob_2d_array_test.cpp vendored
View File

@ -16,33 +16,36 @@
#include <gtest/gtest.h>
using namespace oceanbase::common;
class Ob2DArrayTest : public ::testing::Test {
public:
Ob2DArrayTest();
virtual ~Ob2DArrayTest();
virtual void SetUp();
virtual void TearDown();
private:
// disallow copy
Ob2DArrayTest(const Ob2DArrayTest& other);
Ob2DArrayTest& operator=(const Ob2DArrayTest& other);
protected:
// data members
class Ob2DArrayTest: public ::testing::Test
{
public:
Ob2DArrayTest();
virtual ~Ob2DArrayTest();
virtual void SetUp();
virtual void TearDown();
private:
// disallow copy
Ob2DArrayTest(const Ob2DArrayTest &other);
Ob2DArrayTest& operator=(const Ob2DArrayTest &other);
protected:
// data members
};
Ob2DArrayTest::Ob2DArrayTest()
{}
{
}
Ob2DArrayTest::~Ob2DArrayTest()
{}
{
}
void Ob2DArrayTest::SetUp()
{}
{
}
void Ob2DArrayTest::TearDown()
{}
{
}
TEST_F(Ob2DArrayTest, basic_test)
{
@ -50,32 +53,37 @@ TEST_F(Ob2DArrayTest, basic_test)
Ob2DArray<int, block_size> arr;
Ob2DArray<int, block_size> arr2;
_OB_LOG(INFO, "sizeof(2darray)=%ld", sizeof(arr));
const int N = 1024 * 32 + 1;
for (int round = 0; round < 10; ++round) {
const int N = 1024*32+1;
for (int round = 0; round < 10; ++round)
{
ASSERT_EQ(0, arr.count());
for (int i = 0; i < N; ++i) {
for (int i = 0; i < N; ++i)
{
ASSERT_EQ(OB_SUCCESS, arr.push_back(i));
}
ASSERT_EQ(N, arr.count());
for (int i = 0; i < N; ++i) {
for (int i = 0; i < N; ++i)
{
ASSERT_EQ(i, arr.at(i));
}
ASSERT_EQ(1024 * 33, arr.get_capacity());
ASSERT_EQ(1024*33, arr.get_capacity());
// test copy
ASSERT_EQ(OB_SUCCESS, arr2.assign(arr));
for (int i = 0; i < N; ++i) {
for (int i = 0; i < N; ++i)
{
ASSERT_EQ(i, arr2.at(i));
}
ASSERT_EQ(OB_SUCCESS, arr.resize(2 * (N - 1)));
ASSERT_EQ(1024 * 32 * 2, arr.get_capacity());
ASSERT_EQ(1024 * 32 * 2, arr.count());
ASSERT_EQ(OB_SUCCESS, arr.resize((N - 1)));
ASSERT_EQ(1024 * 32, arr.get_capacity());
ASSERT_EQ(1024 * 32, arr.count());
ASSERT_EQ(OB_SUCCESS, arr.reserve(2 * (N-1)));
ASSERT_EQ(1024*32*2, arr.get_capacity());
//ASSERT_EQ(1024*32*2, arr.count());
arr.reset();
ASSERT_EQ(OB_SUCCESS, arr.reserve((N-1)));
ASSERT_EQ(1024*32, arr.get_capacity());
//ASSERT_EQ(1024*32, arr.count());
}
_OB_LOG(INFO, "done");
}
@ -149,31 +157,37 @@ TEST_F(Ob2DArrayTest, remove)
ASSERT_EQ(3, arr.at(1));
}
#if 0
TEST_F(Ob2DArrayTest, swap)
{
const int64_t block_size = sizeof(int) * 1024;
Ob2DArray<int, block_size> arr1;
Ob2DArray<int, block_size> arr2;
const int len1 = 1024 * 32 + 1;
const int len2 = 1024 + 1;
for (int round = 0; round < 10; ++round) {
const int len1 = 1024*32+1;
const int len2 = 1024+1;
for (int round = 0; round < 10; ++round)
{
ASSERT_EQ(0, arr1.count());
ASSERT_EQ(0, arr2.count());
for (int i = 0; i < len1; ++i) {
for (int i = 0; i < len1; ++i)
{
ASSERT_EQ(OB_SUCCESS, arr1.push_back(i));
}
ASSERT_EQ(len1, arr1.count());
for (int i = 0; i < len2; ++i) {
for (int i = 0; i < len2; ++i)
{
ASSERT_EQ(OB_SUCCESS, arr2.push_back(-i));
}
ASSERT_EQ(len2, arr2.count());
for (int i = 0; i < len1; ++i) {
for (int i = 0; i < len1; ++i)
{
ASSERT_EQ(i, arr1.at(i));
}
for (int i = 0; i < len2; ++i) {
for (int i = 0; i < len2; ++i)
{
ASSERT_EQ(-i, arr2.at(i));
}
@ -182,10 +196,12 @@ TEST_F(Ob2DArrayTest, swap)
ASSERT_EQ(len1, arr2.count());
ASSERT_EQ(len2, arr1.count());
for (int i = 0; i < len1; ++i) {
for (int i = 0; i < len1; ++i)
{
ASSERT_EQ(i, arr2.at(i));
}
for (int i = 0; i < len2; ++i) {
for (int i = 0; i < len2; ++i)
{
ASSERT_EQ(-i, arr1.at(i));
}
@ -194,6 +210,7 @@ TEST_F(Ob2DArrayTest, swap)
}
_OB_LOG(INFO, "done");
}
#endif
// performance_test parameters
using obj_type = int*;
@ -202,81 +219,79 @@ const int access_index_num = 100000 * 500;
const int access_run = 1;
const int ptr_array_capacity = 1000;
const int block_size = OB_MALLOC_BIG_BLOCK_SIZE;
using Tested2DArray = Ob2DArray<obj_type, block_size, ModulePageAllocator, false,
ObSEArray<obj_type*, ptr_array_capacity, ModulePageAllocator, false>>;
using Tested2DArray = Ob2DArray<obj_type, block_size,
ModulePageAllocator,
false,
ObSEArray<obj_type *, ptr_array_capacity,
ModulePageAllocator, false>>;
#include <stdio.h> /* printf, scanf, NULL */
#include <stdlib.h> /* malloc, free, rand */
#include <stdio.h> /* printf, scanf, NULL */
#include <stdlib.h> /* malloc, free, rand */
#include <chrono>
#include <deque>
using namespace std;
#if 0
TEST_F(Ob2DArrayTest, performance_test)
{
int* indices = static_cast<int*>(malloc(sizeof(int) * access_index_num));
ASSERT_NE(indices, nullptr);
for (int i = 0; i < access_index_num; i++)
indices[i] = rand() % array_size;
for (int i=0; i<access_index_num; i++)
indices[i]=rand() % array_size;
decltype(chrono::steady_clock::now()) time_start, time_end;
long sum = 0;
OB_LOG(WARN,
"parameters:",
K(sizeof(obj_type)),
K(array_size),
K(access_index_num),
K(access_run),
K(ptr_array_capacity),
K(block_size));
OB_LOG(WARN, "parameters:",
K(sizeof(obj_type)),
K(array_size), K(access_index_num), K(access_run),
K(ptr_array_capacity), K(block_size));
obj_type* c_array = static_cast<obj_type*>(malloc(sizeof(obj_type) * array_size));
ASSERT_NE(c_array, nullptr);
time_start = chrono::steady_clock::now();
for (int i = 0; i < access_run; i++) {
for (int j = 0; j < access_index_num; j++) {
for(int i=0; i<access_run; i++){
for(int j=0; j<access_index_num; j++){
int index = indices[j];
sum += (long)c_array[index];
sum += (long) c_array[index];
}
}
time_end = chrono::steady_clock::now();
_OB_LOG(
WARN, "%s time: %ld ms", "c_array", chrono::duration_cast<chrono::milliseconds>(time_end - time_start).count());
_OB_LOG(WARN, "%s time: %ld ms", "c_array",
chrono::duration_cast<chrono::milliseconds>(time_end - time_start).count());
Tested2DArray ob_2d_array;
for (int i = 0; i < array_size; i++)
for(int i=0; i<array_size; i++)
ob_2d_array.push_back(0);
ASSERT_EQ(array_size, ob_2d_array.count());
time_start = chrono::steady_clock::now();
for (int i = 0; i < access_run; i++) {
for (int j = 0; j < access_index_num; j++) {
for(int i=0; i<access_run; i++){
for(int j=0; j<access_index_num; j++){
int index = indices[j];
sum += (long)ob_2d_array.at(index);
sum += (long) ob_2d_array.at(index);
}
}
time_end = chrono::steady_clock::now();
_OB_LOG(WARN,
"%s time: %ld ms",
"ob_array (div to bit shift)",
chrono::duration_cast<chrono::milliseconds>(time_end - time_start).count());
_OB_LOG(WARN, "%s time: %ld ms", "ob_array (div to bit shift)",
chrono::duration_cast<chrono::milliseconds>(time_end - time_start).count());
deque<obj_type> cpp_deque(array_size, 0);
time_start = chrono::steady_clock::now();
for (int i = 0; i < access_run; i++) {
for (int j = 0; j < access_index_num; j++) {
for(int i=0; i<access_run; i++){
for(int j=0; j<access_index_num; j++){
int index = indices[j];
sum += (long)cpp_deque[index];
sum += (long) cpp_deque[index];
}
}
time_end = chrono::steady_clock::now();
_OB_LOG(
WARN, "%s time: %ld ms", "cpp_deque", chrono::duration_cast<chrono::milliseconds>(time_end - time_start).count());
_OB_LOG(WARN, "%s time: %ld ms", "cpp_deque",
chrono::duration_cast<chrono::milliseconds>(time_end - time_start).count());
for (int i = 0; i < array_size; i++) {
for(int i=0; i<array_size; i++){
ASSERT_EQ(c_array[i], ob_2d_array.at(i));
ASSERT_EQ(c_array[i], cpp_deque[i]);
}
@ -284,10 +299,11 @@ TEST_F(Ob2DArrayTest, performance_test)
OB_LOG(WARN, "sum:", K(sum));
_OB_LOG(INFO, "done");
}
#endif
int main(int argc, char** argv)
int main(int argc, char **argv)
{
oceanbase::common::ObLogger::get_logger().set_log_level("WARN");
::testing::InitGoogleTest(&argc, argv);
::testing::InitGoogleTest(&argc,argv);
return RUN_ALL_TESTS();
}