cobalt 0.22.0

Low level, UDP based networking library.
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

// Copyright (c) 2015-2017 Ivo Wetzel

// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

// STD Dependencies -----------------------------------------------------------
use std::cmp;
use std::thread;
use std::time::{Duration, Instant};


// Internal Dependencies ------------------------------------------------------
use ::shared::config::Config;


// Tick Rate Limiting ---------------------------------------------------------
#[derive(Debug)]
pub struct Ticker {
    tick_start: Instant,
    tick_overflow: u64,
    tick_overflow_recovery: bool,
    tick_overflow_recovery_rate: f32,
    tick_delay: u64
}

impl Ticker {

    pub fn new(config: Config) -> Ticker {
        Ticker {
            tick_start: Instant::now(),
            tick_overflow: 0,
            tick_overflow_recovery: config.tick_overflow_recovery,
            tick_overflow_recovery_rate: config.tick_overflow_recovery_rate,
            tick_delay: 1000000000 / config.send_rate
        }
    }

    pub fn set_config(&mut self, config: Config) {
        self.tick_overflow_recovery = config.tick_overflow_recovery;
        self.tick_overflow_recovery_rate = config.tick_overflow_recovery_rate;
        self.tick_delay = 1000000000 / config.send_rate
    }

    pub fn begin_tick(&mut self) {
        self.tick_start = Instant::now();
    }

    pub fn reset(&mut self) {
        self.tick_start = Instant::now();
        self.tick_overflow = 0;
    }

    pub fn end_tick(&mut self) {

        // Actual time taken by the tick
        let time_taken = nanos_from_duration(self.tick_start.elapsed());

        // Required delay reduction to keep tick rate
        let mut reduction = cmp::min(time_taken, self.tick_delay);

        if self.tick_overflow_recovery {

            // Keep track of how much additional time the current tick required
            self.tick_overflow += time_taken - reduction;

            // Try to reduce the existing overflow by reducing the reduction time
            // for the current frame.
            let max_correction = (self.tick_delay - reduction) as i64;
            let correction = cmp::min(
                (max_correction as f32 * self.tick_overflow_recovery_rate) as i64,
                max_correction
            );

            // This way we'll achieve a speed up effect in an effort to keep the
            // desired tick rate stable over a longer period of time
            let reduced_overflow = cmp::max(0, self.tick_overflow as i64 - correction) as u64;

            // Adjust the reduction amount to speed up
            reduction += self.tick_overflow - reduced_overflow;

            // Update remaining overflow
            self.tick_overflow = reduced_overflow;

        }

        thread::sleep(Duration::new(0, (self.tick_delay - reduction) as u32));

    }

}

// Helpers ---------------------------------------------------------------------
fn nanos_from_duration(d: Duration) -> u64 {
    d.as_secs() * 1000 * 1000000 + d.subsec_nanos() as u64
}