static void _BRRMDCompress(uint32_t *r, uint32_t *x)
{
// left line
static const int rl1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }, // round 1, id
rl2[] = { 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8 }, // round 2, rho
rl3[] = { 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12 }, // round 3, rho^2
rl4[] = { 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2 }, // round 4, rho^3
rl5[] = { 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13 }; // round 5, rho^4
// right line
static const int rr1[] = { 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12 }, // round 1, pi
rr2[] = { 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2 }, // round 2, rho pi
rr3[] = { 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13 }, // round 3, rho^2 pi
rr4[] = { 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14 }, // round 4, rho^3 pi
rr5[] = { 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11 }; // round 5, rho^4 pi
// left line shifts
static const int sl1[] = { 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8 }, // round 1
sl2[] = { 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12 }, // round 2
sl3[] = { 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5 }, // round 3
sl4[] = { 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12 }, // round 4
sl5[] = { 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 }; // round 5
// right line shifts
static const int sr1[] = { 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6 }, // round 1
sr2[] = { 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11 }, // round 2
sr3[] = { 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5 }, // round 3
sr4[] = { 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8 }, // round 4
sr5[] = { 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 }; // round 5
int i;
uint32_t al = r[0], bl = r[1], cl = r[2], dl = r[3], el = r[4], ar = al, br = bl, cr = cl, dr = dl, er = el, t;
for (i = 0; i < 16; i++) rmd(t, f(bl, cl, dl), x[rl1[i]], 0x00000000, sl1[i], al, el, dl, cl, bl); // round 1 left
for (i = 0; i < 16; i++) rmd(t, j(br, cr, dr), x[rr1[i]], 0x50a28be6, sr1[i], ar, er, dr, cr, br); // round 1 right
for (i = 0; i < 16; i++) rmd(t, g(bl, cl, dl), x[rl2[i]], 0x5a827999, sl2[i], al, el, dl, cl, bl); // round 2 left
for (i = 0; i < 16; i++) rmd(t, i(br, cr, dr), x[rr2[i]], 0x5c4dd124, sr2[i], ar, er, dr, cr, br); // round 2 right
for (i = 0; i < 16; i++) rmd(t, h(bl, cl, dl), x[rl3[i]], 0x6ed9eba1, sl3[i], al, el, dl, cl, bl); // round 3 left
for (i = 0; i < 16; i++) rmd(t, h(br, cr, dr), x[rr3[i]], 0x6d703ef3, sr3[i], ar, er, dr, cr, br); // round 3 right
for (i = 0; i < 16; i++) rmd(t, i(bl, cl, dl), x[rl4[i]], 0x8f1bbcdc, sl4[i], al, el, dl, cl, bl); // round 4 left
for (i = 0; i < 16; i++) rmd(t, g(br, cr, dr), x[rr4[i]], 0x7a6d76e9, sr4[i], ar, er, dr, cr, br); // round 4 right
for (i = 0; i < 16; i++) rmd(t, j(bl, cl, dl), x[rl5[i]], 0xa953fd4e, sl5[i], al, el, dl, cl, bl); // round 5 left
for (i = 0; i < 16; i++) rmd(t, f(br, cr, dr), x[rr5[i]], 0x00000000, sr5[i], ar, er, dr, cr, br); // round 5 right
t = r[1] + cl + dr; // final result for r[0]
r[1] = r[2] + dl + er, r[2] = r[3] + el + ar, r[3] = r[4] + al + br, r[4] = r[0] + bl + cr, r[0] = t; // combine
var_clean(&al, &bl, &cl, &dl, &el, &ar, &br, &cr, &dr, &er, &t);
}
TEST(IndexMetaDataTest, writeReadTest) {
vector<BlockMetaData> bs;
off_t afterFI = 6 * 2 * sizeof(Id);
off_t afterLhs = afterFI + 4 * (sizeof(Id) + sizeof(off_t));
off_t afterRhs = afterLhs + 6 * sizeof(Id);
bs.push_back(BlockMetaData(10, afterFI));
bs.push_back(BlockMetaData(16, afterFI + 2 * (sizeof(Id) + sizeof(off_t))));
RelationMetaData rmd(1, 0, afterLhs, afterRhs, 6, 2, bs);
RelationMetaData rmd2(rmd);
rmd2._relId = 2;
IndexMetaData imd;
imd.add(rmd);
imd.add(rmd2);
ad_utility::File f("_testtmp.imd", "w");
f << imd;
f.close();
ad_utility::File in("_testtmp.imd", "r");
size_t imdBytes = sizeof(size_t) + rmd.bytesRequired() * 2;
unsigned char* buf = new unsigned char[imdBytes];
in.read(buf, imdBytes);
IndexMetaData imd2;
imd2.createFromByteBuffer(buf);
delete[] buf;
remove("_testtmp.rmd");
ASSERT_EQ(rmd._relId, imd2.getRmd(1)._relId);
ASSERT_EQ(rmd._startFullIndex, imd2.getRmd(1)._startFullIndex);
ASSERT_EQ(rmd._startRhs, imd2.getRmd(1)._startRhs);
ASSERT_EQ(rmd._offsetAfter, imd2.getRmd(1)._offsetAfter);
ASSERT_EQ(rmd._nofElements, imd2.getRmd(1)._nofElements);
ASSERT_EQ(rmd._nofBlocks, imd2.getRmd(1)._nofBlocks);
ASSERT_EQ(rmd._blocks.size(), imd2.getRmd(1)._blocks.size());
ASSERT_EQ(rmd._blocks[0]._firstLhs, imd2.getRmd(1)._blocks[0]._firstLhs);
ASSERT_EQ(rmd._blocks[0]._startOffset, imd2.getRmd(1)._blocks[0]._startOffset);
ASSERT_EQ(rmd._blocks[1]._firstLhs, imd2.getRmd(1)._blocks[1]._firstLhs);
ASSERT_EQ(rmd._blocks[1]._startOffset, imd2.getRmd(1)._blocks[1]._startOffset);
ASSERT_EQ(rmd2._relId, imd2.getRmd(2)._relId);
ASSERT_EQ(rmd2._startFullIndex, imd2.getRmd(2)._startFullIndex);
ASSERT_EQ(rmd2._startRhs, imd2.getRmd(2)._startRhs);
ASSERT_EQ(rmd2._offsetAfter, imd2.getRmd(2)._offsetAfter);
ASSERT_EQ(rmd2._nofElements, imd2.getRmd(2)._nofElements);
ASSERT_EQ(rmd2._nofBlocks, imd2.getRmd(2)._nofBlocks);
ASSERT_EQ(rmd2._blocks.size(), imd2.getRmd(2)._blocks.size());
ASSERT_EQ(rmd2._blocks[0]._firstLhs, imd2.getRmd(2)._blocks[0]._firstLhs);
ASSERT_EQ(rmd2._blocks[0]._startOffset, imd2.getRmd(2)._blocks[0]._startOffset);
ASSERT_EQ(rmd2._blocks[1]._firstLhs, imd2.getRmd(2)._blocks[1]._firstLhs);
ASSERT_EQ(rmd2._blocks[1]._startOffset, imd2.getRmd(2)._blocks[1]._startOffset);
}
TEST(RelationMetaDataTest, getBlockStartAndNofBytesForLhsTest) {
vector<BlockMetaData> bs;
off_t afterFI = 6 * 2 * sizeof(Id);
off_t afterLhs = afterFI + 4 * (sizeof(Id) + sizeof(off_t));
off_t afterRhs = afterLhs + 6 * sizeof(Id);
bs.push_back(BlockMetaData(10, afterFI));
bs.push_back(BlockMetaData(16, afterFI + 2 * (sizeof(Id) + sizeof(off_t))));
RelationMetaData rmd(1, 0, afterLhs, afterRhs, 6, 2, bs);
auto rv = rmd.getBlockStartAndNofBytesForLhs(10);
ASSERT_EQ(afterFI, rv.first);
ASSERT_EQ(2 * (sizeof(Id) + sizeof(off_t)), rv.second);
rv = rmd.getBlockStartAndNofBytesForLhs(15);
ASSERT_EQ(afterFI, rv.first);
ASSERT_EQ(2 * (sizeof(Id) + sizeof(off_t)), rv.second);
rv = rmd.getBlockStartAndNofBytesForLhs(16);
ASSERT_EQ(afterFI + 2 * (sizeof(Id) + sizeof(off_t)), rv.first);
ASSERT_EQ(2 * (sizeof(Id) + sizeof(off_t)), rv.second);
rv = rmd.getBlockStartAndNofBytesForLhs(17);
ASSERT_EQ(afterFI + 2 * (sizeof(Id) + sizeof(off_t)), rv.first);
ASSERT_EQ(2 * (sizeof(Id) + sizeof(off_t)), rv.second);
}
