valar-ypir 0.1.5

Fork of YPIR: High-Throughput Single-Server PIR with Silent Preprocessing
Documentation 
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

pub fn transpose(buf: &[u8], rows: usize, cols: usize, bytes_per_pt_el: usize) -> Vec<u8> {
    let mut out = vec![0u8; buf.len()];

    for i in 0..rows {
        for j in 0..cols {
            for k in 0..bytes_per_pt_el {
                out[j * rows * bytes_per_pt_el + i * bytes_per_pt_el + k] =
                    buf[i * cols * bytes_per_pt_el + j * bytes_per_pt_el + k];
            }
        }
    }

    out
}

pub fn transpose_elems<T: Sized + Copy>(
    buf: &[&[T]],
    inp_rows: usize,
    inp_cols: usize,
) -> Vec<Vec<T>> {
    let mut out = Vec::new();

    for j in 0..inp_cols {
        let mut row = Vec::new();
        for i in 0..inp_rows {
            row.push(buf[i][j]);
        }
        out.push(row);
    }

    out
}

static TRANSPOSE_TILE_SIZE: usize = 32;

pub fn transpose_generic<T>(a: &[T], a_rows: usize, a_cols: usize) -> Vec<T>
where
    T: Sized + Copy + Default,
{
    // assert!(a_rows >= TRANSPOSE_TILE_SIZE);
    // assert!(a_cols >= TRANSPOSE_TILE_SIZE);
    // assert_eq!(a_rows % TRANSPOSE_TILE_SIZE, 0);
    // assert_eq!(a_cols % TRANSPOSE_TILE_SIZE, 0);
    let mut transpose_tile_size = 32.min(a_rows).min(a_cols);
    if a_rows % transpose_tile_size != 0 || a_cols % transpose_tile_size != 0 {
        transpose_tile_size = 1;
    }
    let mut out = vec![T::default(); a_rows * a_cols];

    for i_outer in (0..a_rows).step_by(transpose_tile_size) {
        for j_outer in (0..a_cols).step_by(transpose_tile_size) {
            for i_inner in 0..transpose_tile_size {
                for j_inner in 0..transpose_tile_size {
                    let i = i_outer + i_inner;
                    let j = j_outer + j_inner;
                    out[j * a_rows + i] = a[i * a_cols + j];
                }
            }
        }
    }

    out
}

pub fn transpose_f64(out: &mut [f64], a: &[f64], a_rows: usize, a_cols: usize) {
    assert!(a_rows >= TRANSPOSE_TILE_SIZE);
    assert!(a_cols >= TRANSPOSE_TILE_SIZE);
    assert_eq!(a_rows % TRANSPOSE_TILE_SIZE, 0);
    assert_eq!(a_cols % TRANSPOSE_TILE_SIZE, 0);
    let transpose_tile_size = TRANSPOSE_TILE_SIZE; //32.min(a_rows).min(a_cols);

    for i_outer in (0..a_rows).step_by(transpose_tile_size) {
        for j_outer in (0..a_cols).step_by(transpose_tile_size) {
            for i_inner in 0..transpose_tile_size {
                for j_inner in 0..transpose_tile_size {
                    unsafe {
                        let i = i_outer + i_inner;
                        let j = j_outer + j_inner;

                        // out[j * a_rows + i] = a[i * a_cols + j];
                        *out.get_unchecked_mut(j * a_rows + i) = *a.get_unchecked(i * a_cols + j);
                    }
                }
            }
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_transpose() {
        let mut buf = vec![0u8; 16];
        for i in 0..16 {
            buf[i] = i as u8;
        }

        let out = transpose(&buf, 2, 8, 1);

        assert_eq!(
            out,
            vec![0, 8, 1, 9, 2, 10, 3, 11, 4, 12, 5, 13, 6, 14, 7, 15,]
        );
    }
}