-
Notifications
You must be signed in to change notification settings - Fork 61
/
client_embedded.cc
122 lines (99 loc) · 3.29 KB
/
client_embedded.cc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
// Copyright (c) 2014, Emmanuel Goossaert. All rights reserved.
// Use of this source code is governed by the BSD 3-Clause License,
// that can be found in the LICENSE file.
#include <iostream>
#include <iomanip>
#include <thread>
#include <regex>
#include <queue>
#include <vector>
#include <string>
#include <cstdio>
#include <string.h>
#include <execinfo.h>
#include <chrono>
#include <sstream>
#include <csignal>
#ifdef DEBUG
#include <gperftools/profiler.h>
#endif
#include "interface/database.h"
#include "util/status.h"
#include "util/order.h"
#include "util/byte_array.h"
#include "interface/snapshot.h"
#include "interface/iterator.h"
#define SIZE_LARGE_TEST_ITEMS 1024*1024*64 // size of large items used for testing
void handler(int sig) {
int depth_max = 20;
void *array[depth_max];
size_t depth;
depth = backtrace(array, depth_max);
fprintf(stderr, "Error: signal %d:\n", sig);
backtrace_symbols_fd(array, depth, STDERR_FILENO);
exit(1);
}
int main() {
signal(SIGSEGV, handler);
signal(SIGABRT, handler);
kdb::Logger::set_current_level("info");
kdb::DatabaseOptions options;
options.compression = kdb::kLZ4Compression;
//options.storage__maximum_part_size = 128 * 1024;
kdb::Database db(options, "mydb");
db.Open();
kdb::ReadOptions read_options;
kdb::WriteOptions write_options;
int size = SIZE_LARGE_TEST_ITEMS;
char *buffer_large = new char[size+1];
for (auto i = 0; i < size; i++) {
buffer_large[i] = 'a';
}
buffer_large[size] = '\0';
int num_items = 1000000;
std::vector<std::string> items;
int size_key = 16;
for (auto i = 0; i < num_items; i++) {
std::stringstream ss;
ss << std::setfill ('0') << std::setw (size_key);
ss << i;
//std::cout << ss.str() << std::endl;
items.push_back(ss.str());
}
std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
for (auto i = 0; i < num_items; i++) {
kdb::ByteArray key = kdb::NewDeepCopyByteArray(items[i].c_str(), items[i].size());
kdb::ByteArray value = kdb::NewDeepCopyByteArray(buffer_large, 100);
kdb::Status s = db.PutPart(write_options,
key,
value,
0,
100);
}
std::chrono::high_resolution_clock::time_point end = std::chrono::high_resolution_clock::now();
uint64_t duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
std::cout << "done in " << duration << " ms" << std::endl;
kdb::Snapshot snapshot = db.NewSnapshot();
kdb::Iterator iterator = snapshot.NewIterator(read_options);
#ifdef DEBUG
ProfilerStart("/tmp/kingdb.prof");
#endif
iterator.Begin();
start = std::chrono::high_resolution_clock::now();
auto count_items = 0;
for (; iterator.IsValid(); iterator.Next()) {
kdb::ByteArray key = iterator.GetKey();
kdb::ByteArray value = iterator.GetValue();
count_items += 1;
}
end = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
std::cout << "iteration done in " << duration << " ms" << std::endl;
std::cout << "count items: " << count_items << std::endl;
#ifdef DEBUG
ProfilerStop();
ProfilerFlush();
#endif
delete[] buffer_large;
return 0;
}