bitcoin-addrman 0.1.16-alpha.0

stochastic address manager
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

crate::ix!();

impl AddrManInner {

    /**
      | Move an entry from the "new" table(s)
      | to the "tried" table
      |
      */
    pub fn make_tried(&mut self, 
        info: &mut AddrInfo,
        n_id: i32,
        n_key: &u256,
        asmap: &Vec<bool>
    )  {
        
        // remove the entry from all new buckets
        let start_bucket: usize = info.get_new_bucket(n_key, asmap).try_into().unwrap();

        for n in 0..ADDRMAN_NEW_BUCKET_COUNT {

            let bucket: usize = (start_bucket + n) % ADDRMAN_NEW_BUCKET_COUNT;
            let pos:    usize = info.get_bucket_position(n_key, true, bucket).try_into().unwrap();

            if self.vv_new[bucket][pos] == n_id {

                self.vv_new[bucket][pos] = -1;

                info.n_ref_count -= 1;

                if info.n_ref_count == 0 {
                    break;
                }
            }
        }

        self.n_new -= 1;

        assert!(info.n_ref_count == 0);

        //  which tried bucket to move the entry to
        let n_kbucket:     usize = info.get_tried_bucket(n_key, asmap).try_into().unwrap();
        let n_kbucket_pos: usize = info.get_bucket_position(n_key, false, n_kbucket).try_into().unwrap();

        //  first make space to add it (the
        //  existing tried entry there is moved to
        //  new, deleting whatever is there).
        if self.vv_tried[n_kbucket][n_kbucket_pos] != -1 {

            //  find an item to evict
            let n_id_evict: i32 = self.vv_tried[n_kbucket][n_kbucket_pos];;

            assert!(self.map_info.contains_key(&n_id_evict));

            unsafe {

                let info_old: *mut AddrInfo = self.map_info.get_mut(&n_id_evict).unwrap() as *mut AddrInfo;

                //  Remove the to-be-evicted item from the tried set.
                (*info_old).in_tried = false;

                self.vv_tried[n_kbucket][n_kbucket_pos] = -1;

                self.n_tried -= 1;

                //  find which new bucket it belongs to
                let n_ubucket:     usize = (*info_old).get_new_bucket(n_key, asmap).try_into().unwrap();
                let n_ubucket_pos: usize = (*info_old).get_bucket_position(n_key, true, n_ubucket).try_into().unwrap();

                self.clear_new(n_ubucket, n_ubucket_pos);

                assert!(self.vv_new[n_ubucket][n_ubucket_pos] == -1);

                //  Enter it into the new set again.
                (*info_old).n_ref_count = 1;

                self.vv_new[n_ubucket][n_ubucket_pos] = n_id_evict;

                self.n_new += 1;

                log_print!(
                    bc_log::addrman, 
                    "Moved %s from tried[%i][%i] to new[%i][%i] to make space\n", 
                    (*info_old).to_string(), 
                    n_kbucket, 
                    n_kbucket_pos, 
                    n_ubucket, 
                    n_ubucket_pos
                );
            }
        }

        assert!(self.vv_tried[n_kbucket][n_kbucket_pos] == -1);

        self.vv_tried[n_kbucket][n_kbucket_pos] = n_id;

        self.n_tried += 1;

        info.in_tried = true;
    }
}