Skip to content

Commit 0bc5b4b

Browse files
olemon111olemon111
committed
change ycsb data to longlatt due to pddate bug n lippp
1 parent 4bb0e23 commit 0bc5b4b

14 files changed

+224
-174
lines changed

‎include/lipp/lipp.h

+49-61
Original file line numberDiff line numberDiff line change
@@ -10,8 +10,6 @@
1010
#include <vector>
1111
#include <cstring>
1212
#include <sstream>
13-
#include "nvm_alloc.h"
14-
1513

1614
typedef uint8_t bitmap_t;
1715
#define BITMAP_WIDTH (sizeof(bitmap_t) * 8)
@@ -91,7 +89,6 @@ class LIPP
9189
: BUILD_LR_REMAIN(BUILD_LR_REMAIN), QUIET(QUIET)
9290
{
9391
{
94-
9592
std::vector<Node *> nodes;
9693
for (int _ = 0; _ < 1e7; _++)
9794
{
@@ -333,7 +330,7 @@ class LIPP
333330
printf("\t time_build_tree_bulk = %lf\n", stats.time_build_tree_bulk);
334331
#endif
335332
}
336-
size_t index_size() const
333+
size_t index_size(bool total = false, bool ignore_child = true) const
337334
{
338335
std::stack<Node *> s;
339336
s.push(root);
@@ -344,17 +341,33 @@ class LIPP
344341
Node *node = s.top();
345342
s.pop();
346343
bool has_child = false;
344+
if (ignore_child == false)
345+
{
346+
size += sizeof(*node);
347+
}
347348
for (int i = 0; i < node->num_items; i++)
348349
{
349-
if (BITMAP_GET(node->child_bitmap, i) == 1)
350+
if (ignore_child == true)
350351
{
351352
size += sizeof(Item);
352353
has_child = true;
354+
}
355+
else
356+
{
357+
if (total)
358+
size += sizeof(Item);
359+
}
360+
if (BITMAP_GET(node->child_bitmap, i) == 1)
361+
{
362+
if (!total)
363+
size += sizeof(Item);
353364
s.push(node->items[i].comp.child);
354365
}
355366
}
356-
if (has_child)
367+
if (ignore_child == true && has_child)
368+
{
357369
size += sizeof(*node);
370+
}
358371
}
359372
return size;
360373
}
@@ -390,11 +403,7 @@ class LIPP
390403
Node *root;
391404
std::stack<Node *> pending_two;
392405

393-
#ifdef USE_MEM
394406
std::allocator<Node> node_allocator;
395-
#else
396-
NVM::allocator<Node> node_allocator;
397-
#endif
398407
Node *new_nodes(int n)
399408
{
400409
Node *p = node_allocator.allocate(n);
@@ -405,11 +414,8 @@ class LIPP
405414
{
406415
node_allocator.deallocate(p, n);
407416
}
408-
#ifdef USE_MEM
417+
409418
std::allocator<Item> item_allocator;
410-
#else
411-
NVM::allocator<Item> item_allocator;
412-
#endif
413419
Item *new_items(int n)
414420
{
415421
Item *p = item_allocator.allocate(n);
@@ -420,12 +426,8 @@ class LIPP
420426
{
421427
item_allocator.deallocate(p, n);
422428
}
423-
424-
#ifdef USE_MEM
429+
425430
std::allocator<bitmap_t> bitmap_allocator;
426-
#else
427-
NVM::allocator<bitmap_t> bitmap_allocator;
428-
#endif
429431
bitmap_t *new_bitmap(int n)
430432
{
431433
bitmap_t *p = bitmap_allocator.allocate(n);
@@ -454,10 +456,7 @@ class LIPP
454456
BITMAP_SET(node->none_bitmap, 0);
455457
node->child_bitmap = new_bitmap(1);
456458
node->child_bitmap[0] = 0;
457-
NVM::Mem_persist(node->items,sizeof(Item));
458-
NVM::Mem_persist(node->child_bitmap,sizeof(bitmap_t));
459-
NVM::Mem_persist(node->none_bitmap,sizeof(bitmap_t));
460-
NVM::Mem_persist(node,sizeof(Node));
459+
461460
return node;
462461
}
463462
/// build a tree with two keys
@@ -487,25 +486,20 @@ class LIPP
487486
node->child_bitmap = new_bitmap(1);
488487
node->none_bitmap[0] = 0xff;
489488
node->child_bitmap[0] = 0;
490-
NVM::Mem_persist(node->none_bitmap,sizeof(Node));
491-
NVM::Mem_persist(node->child_bitmap,sizeof(Node));
492-
NVM::Mem_persist(node->items,sizeof(Item)*8);
493-
NVM::Mem_persist(node,sizeof(Node));
494489
}
495490
else
496491
{
497492
node = pending_two.top();
498493
pending_two.pop();
499494
}
500-
501495

502-
const double mid1_key = key1;
503-
const double mid2_key = key2;
496+
const long double mid1_key = key1;
497+
const long double mid2_key = key2;
504498

505499
const double mid1_target = node->num_items / 3;
506500
const double mid2_target = node->num_items * 2 / 3;
507501

508-
node->model.a = (mid1_target - mid2_target) / (mid1_key - mid2_key);
502+
node->model.a = (mid2_target - mid1_target) / (mid2_key - mid1_key);
509503
node->model.b = mid1_target - node->model.a * mid1_key;
510504
RT_ASSERT(isfinite(node->model.a));
511505
RT_ASSERT(isfinite(node->model.b));
@@ -516,18 +510,15 @@ class LIPP
516510
BITMAP_CLEAR(node->none_bitmap, pos);
517511
node->items[pos].comp.data.key = key1;
518512
node->items[pos].comp.data.value = value1;
519-
NVM::Mem_persist(node->items+pos,sizeof(Item));
520513
}
521514
{ // insert key2&value2
522515
int pos = PREDICT_POS(node, key2);
523516
RT_ASSERT(BITMAP_GET(node->none_bitmap, pos) == 1);
524517
BITMAP_CLEAR(node->none_bitmap, pos);
525518
node->items[pos].comp.data.key = key2;
526519
node->items[pos].comp.data.value = value2;
527-
NVM::Mem_persist(node->items+pos,sizeof(Item));
528520
}
529-
NVM::Mem_persist(node->none_bitmap,sizeof(Node));
530-
NVM::Mem_persist(node->child_bitmap,sizeof(Node));
521+
531522
return node;
532523
}
533524
/// bulk build, _keys must be sorted in asc order.
@@ -595,14 +586,16 @@ class LIPP
595586
RT_ASSERT(mid1_pos < mid2_pos);
596587
RT_ASSERT(mid2_pos < size - 1);
597588

598-
const double mid1_key = static_cast<double>((static_cast<long double>(keys[mid1_pos]) + static_cast<long double>(keys[mid1_pos + 1])) / 2);
599-
const double mid2_key = static_cast<double>((static_cast<long double>(keys[mid2_pos]) + static_cast<long double>(keys[mid2_pos + 1])) / 2);
589+
const long double mid1_key =
590+
(static_cast<long double>(keys[mid1_pos]) + static_cast<long double>(keys[mid1_pos + 1])) / 2;
591+
const long double mid2_key =
592+
(static_cast<long double>(keys[mid2_pos]) + static_cast<long double>(keys[mid2_pos + 1])) / 2;
600593

601594
node->num_items = size * static_cast<int>(BUILD_GAP_CNT + 1);
602595
const double mid1_target = mid1_pos * static_cast<int>(BUILD_GAP_CNT + 1) + static_cast<int>(BUILD_GAP_CNT + 1) / 2;
603596
const double mid2_target = mid2_pos * static_cast<int>(BUILD_GAP_CNT + 1) + static_cast<int>(BUILD_GAP_CNT + 1) / 2;
604597

605-
node->model.a = (mid1_target - mid2_target) / (mid1_key - mid2_key);
598+
node->model.a = (mid2_target - mid1_target) / (mid2_key - mid1_key);
606599
node->model.b = mid1_target - node->model.a * mid1_key;
607600
RT_ASSERT(isfinite(node->model.a));
608601
RT_ASSERT(isfinite(node->model.b));
@@ -691,15 +684,13 @@ class LIPP
691684
const int end = s.top().end;
692685
const int level = s.top().level;
693686
Node *node = s.top().node;
694-
NVM::Mem_persist(node,sizeof(Node));
695687
s.pop();
696688

697689
RT_ASSERT(end - begin >= 2);
698690
if (end - begin == 2)
699691
{
700692
Node *_ = build_tree_two(_keys[begin], _values[begin], _keys[begin + 1], _values[begin + 1]);
701693
memcpy(node, _, sizeof(Node));
702-
NVM::Mem_persist(node,sizeof(Node));
703694
delete_nodes(_, 1);
704695
}
705696
else
@@ -726,7 +717,9 @@ class LIPP
726717
int i = 0;
727718
int D = 1;
728719
RT_ASSERT(D <= size - 1 - D);
729-
double Ut = double(keys[size - 1 - D] - keys[D]) / double(L - 2) + 1e-6;
720+
double Ut = (static_cast<long double>(keys[size - 1 - D]) - static_cast<long double>(keys[D])) /
721+
(static_cast<double>(L - 2)) +
722+
1e-6;
730723
while (i < size - 1 - D)
731724
{
732725
while (i + D < size && keys[i + D] - keys[i] >= Ut)
@@ -741,14 +734,18 @@ class LIPP
741734
if (D * 3 > size)
742735
break;
743736
RT_ASSERT(D <= size - 1 - D);
744-
Ut = double(keys[size - 1 - D] - keys[D]) / double(L - 2) + 1e-6;
737+
Ut = (static_cast<long double>(keys[size - 1 - D]) - static_cast<long double>(keys[D])) /
738+
(static_cast<double>(L - 2)) +
739+
1e-6;
745740
}
746741
if (D * 3 <= size)
747742
{
748743
stats.fmcd_success_times++;
749744

750745
node->model.a = 1.0 / Ut;
751-
node->model.b = (L - node->model.a * (keys[size - 1 - D] + keys[D])) / 2;
746+
node->model.b = (L - node->model.a * (static_cast<long double>(keys[size - 1 - D]) +
747+
static_cast<long double>(keys[D]))) /
748+
2;
752749
RT_ASSERT(isfinite(node->model.a));
753750
RT_ASSERT(isfinite(node->model.b));
754751
node->num_items = L;
@@ -764,14 +761,18 @@ class LIPP
764761
RT_ASSERT(mid1_pos < mid2_pos);
765762
RT_ASSERT(mid2_pos < size - 1);
766763

767-
const double mid1_key = static_cast<double>((static_cast<long double>(keys[mid1_pos]) + static_cast<long double>(keys[mid1_pos + 1])) / 2);
768-
const double mid2_key = static_cast<double>((static_cast<long double>(keys[mid2_pos]) + static_cast<long double>(keys[mid2_pos + 1])) / 2);
764+
const long double mid1_key = (static_cast<long double>(keys[mid1_pos]) +
765+
static_cast<long double>(keys[mid1_pos + 1])) /
766+
2;
767+
const long double mid2_key = (static_cast<long double>(keys[mid2_pos]) +
768+
static_cast<long double>(keys[mid2_pos + 1])) /
769+
2;
769770

770771
node->num_items = size * static_cast<int>(BUILD_GAP_CNT + 1);
771772
const double mid1_target = mid1_pos * static_cast<int>(BUILD_GAP_CNT + 1) + static_cast<int>(BUILD_GAP_CNT + 1) / 2;
772773
const double mid2_target = mid2_pos * static_cast<int>(BUILD_GAP_CNT + 1) + static_cast<int>(BUILD_GAP_CNT + 1) / 2;
773774

774-
node->model.a = (mid1_target - mid2_target) / (mid1_key - mid2_key);
775+
node->model.a = (mid2_target - mid1_target) / (mid2_key - mid1_key);
775776
node->model.b = mid1_target - node->model.a * mid1_key;
776777
RT_ASSERT(isfinite(node->model.a));
777778
RT_ASSERT(isfinite(node->model.b));
@@ -793,10 +794,7 @@ class LIPP
793794
node->child_bitmap = new_bitmap(bitmap_size);
794795
memset(node->none_bitmap, 0xff, sizeof(bitmap_t) * bitmap_size);
795796
memset(node->child_bitmap, 0, sizeof(bitmap_t) * bitmap_size);
796-
NVM::Mem_persist(node->items,sizeof(Item)*node->num_items);
797-
NVM::Mem_persist(node->child_bitmap,sizeof(bitmap_t));
798-
NVM::Mem_persist(node->none_bitmap,sizeof(bitmap_t));
799-
NVM::Mem_persist(node,sizeof(Node));
797+
800798
for (int item_i = PREDICT_POS(node, keys[0]), offset = 0; offset < size;)
801799
{
802800
int next = offset + 1, next_i = -1;
@@ -817,18 +815,13 @@ class LIPP
817815
BITMAP_CLEAR(node->none_bitmap, item_i);
818816
node->items[item_i].comp.data.key = keys[offset];
819817
node->items[item_i].comp.data.value = values[offset];
820-
NVM::Mem_persist(node->none_bitmap+item_i/8,sizeof(bitmap_t));
821-
NVM::Mem_persist(node->items+item_i,sizeof(Item));
822818
}
823819
else
824820
{
825821
// ASSERT(next - offset <= (size+2) / 3);
826822
BITMAP_CLEAR(node->none_bitmap, item_i);
827823
BITMAP_SET(node->child_bitmap, item_i);
828824
node->items[item_i].comp.child = new_nodes(1);
829-
NVM::Mem_persist(node->none_bitmap+item_i/8,sizeof(bitmap_t));
830-
NVM::Mem_persist(node->child_bitmap+item_i/8,sizeof(bitmap_t));
831-
NVM::Mem_persist(node->items+item_i,sizeof(Item));
832825
s.push((Segment){begin + offset, begin + next, level + 1, node->items[item_i].comp.child});
833826
}
834827
if (next >= size)
@@ -958,7 +951,7 @@ class LIPP
958951

959952
Node *insert_tree(Node *_node, const T &key, const P &value)
960953
{
961-
constexpr int MAX_DEPTH = 512;
954+
constexpr int MAX_DEPTH = 128;
962955
Node *path[MAX_DEPTH];
963956
int path_size = 0;
964957
int insert_to_data = 0;
@@ -970,23 +963,18 @@ class LIPP
970963

971964
node->size++;
972965
node->num_inserts++;
973-
NVM::Mem_persist(node,sizeof(Node));
974966
int pos = PREDICT_POS(node, key);
975967
if (BITMAP_GET(node->none_bitmap, pos) == 1)
976968
{
977969
BITMAP_CLEAR(node->none_bitmap, pos);
978970
node->items[pos].comp.data.key = key;
979971
node->items[pos].comp.data.value = value;
980-
NVM::Mem_persist(node->items+pos,sizeof(Item));
981-
NVM::Mem_persist(node->none_bitmap+pos/8,sizeof(bitmap_t));
982972
break;
983973
}
984974
else if (BITMAP_GET(node->child_bitmap, pos) == 0)
985975
{
986976
BITMAP_SET(node->child_bitmap, pos);
987-
NVM::Mem_persist(node->child_bitmap+pos/8,sizeof(bitmap_t));
988977
node->items[pos].comp.child = build_tree_two(key, value, node->items[pos].comp.data.key, node->items[pos].comp.data.value);
989-
NVM::Mem_persist(node->items+pos,sizeof(Item));
990978
insert_to_data = 1;
991979
break;
992980
}

‎include/lipp/lipp_base.h

+4-4
Original file line numberDiff line numberDiff line change
@@ -12,20 +12,20 @@ class LinearModel
1212
{
1313
public:
1414
double a = 0; // slope
15-
double b = 0; // intercept
15+
long double b = 0; // intercept
1616

1717
LinearModel() = default;
18-
LinearModel(double a, double b) : a(a), b(b) {}
18+
LinearModel(double a, long double b) : a(a), b(b) {}
1919
explicit LinearModel(const LinearModel &other) : a(other.a), b(other.b) {}
2020

2121
inline int predict(T key) const
2222
{
23-
return std::floor(a * static_cast<double>(key) + b);
23+
return std::floor(a * static_cast<long double>(key) + b);
2424
}
2525

2626
inline double predict_double(T key) const
2727
{
28-
return a * static_cast<double>(key) + b;
28+
return a * static_cast<long double>(key) + b;
2929
}
3030
};
3131

‎output/swp-2000000-ycsb-write-.txt

-10
This file was deleted.

‎output/swp-alex-llt-read-write-0.txt

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
2022年 10月 31日 星期一 16:44:45 CST
2+
THREAD NUMBER: 1
3+
LOAD_SIZE: 2000000
4+
PUT_SIZE: 10000000
5+
GET_SIZE: 10000000
6+
DB name: alex
7+
Loads type: 4
8+
Reverse: 0
9+
read 2000000 values from /home/lbl/dataset/generate_random_osm_longlat.dat in 15 ms (133.333 M values/s)
10+
before newdb, dram space use: 0.0218658 GB
11+
Start loading ....
12+
[Metic-Load]: Load 2000000: cost 1.1048s, kops/s: 1810.28 .
13+
after load, dram space use: 0.0218658 GB
14+
------------------------------
15+
Start Testing Uniform Workload: Read
16+
wrong get: 0
17+
[Metic-Operate]: Operate 10000000, cost 1.42684s, kops/s: 7008.51 .
18+
dram space use: 0.120319 GB
19+
------------------------------
20+
Start Testing Uniform Workload: Write
21+
wrong get: 0
22+
[Metic-Operate]: Operate 10000000, cost 1.76088s, kops/s: 5678.99 .
23+
dram space use: 0.143757 GB

0 commit comments

Comments
 (0)