faster-LUT/Common.cpp at main · zju-abclab/faster-LUT · GitHub

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
#include "Common.h"

void rotate_to(uint8_t bw, uint8_t * a, uint8_t * b, uint8_t offset) {
    memcpy(b, a + (1 << bw) - offset, offset);
    memcpy(b + offset, a, (1 << bw) - offset);
}

void send_bool_vct(const bool * x, const uint32_t len, NetIO * empIO) {
    const uint32_t a = len / 8;
    const uint32_t b = len % 8;
    if (a != 0) {
        vector<uint8_t> send_data(a);
        compress_bool_into_uint8(x, send_data.data(), a);
        empIO->send_data(send_data.data(), a);
    }
    if (b != 0) {
        empIO->send_data(x + a * 8, b);
    }
}

void recv_bool_vct(bool * x, const uint32_t len, NetIO * empIO) {
    const uint32_t a = len / 8;
    const uint32_t b = len % 8;
    if (a != 0) {
        vector<uint8_t> recv_data(a);
        empIO->recv_data(recv_data.data(), a);
        decompress_bool_from_uint8(recv_data.data(), x, a);
    }
    if (b != 0) {
        empIO->recv_data(x + a * 8, b);
    }
}

void send_uint8_vct(const uint8_t * x, const uint32_t len, const uint32_t bw, NetIO * empIO) {
    vector<uint8_t> send_data(ceil(len * bw / 8.0));
    compress_uint8(x, send_data.data(), len, bw);
    empIO->send_data(send_data.data(), send_data.size());
}

void recv_uint8_vct(uint8_t * x, const uint32_t len, const uint32_t bw, NetIO * empIO) {
    vector<uint8_t> recv_data(ceil(len * bw / 8.0));
    empIO->recv_data(recv_data.data(), recv_data.size());
    decompress_uint8(recv_data.data(), x, len, bw);
}

void send_u64_vct(const uint64_t * x, const uint32_t len, const uint32_t bw, NetIO * empIO) {
    uint32_t num_in_bytes = ceil(bw / 8.0);
    vector<uint8_t> send_data(len * num_in_bytes);
    uint8_t * cur_ptr = send_data.data();
    for (uint32_t i = 0; i < len; i++) {
        memcpy(cur_ptr, x + i, num_in_bytes);
        cur_ptr += num_in_bytes;
    }
    empIO->send_data(send_data.data(), len * num_in_bytes);
}

void recv_u64_vct(uint64_t * x, const uint32_t len, const uint32_t bw, NetIO * empIO) {
    uint32_t num_in_bytes = ceil(bw / 8.0);
    vector<uint8_t> recv_data(len * num_in_bytes);
    empIO->recv_data(recv_data.data(), len * num_in_bytes);
    uint8_t * cur_ptr = recv_data.data();
    for (uint32_t i = 0; i < len; i++) {
        uint64_t tmp = 0;
        memcpy(&tmp, cur_ptr, num_in_bytes);
        x[i] = tmp;
        cur_ptr += num_in_bytes;
    }
}