#include <network_quality.hpp>

Public Member Functions
void	update_sample (double rtt_ms, bool success)
std::string	classify_network () const
int	recommended_dns_timeout () const
int	recommended_https_timeout () const
bool	is_mobile_like () const
double	rtt_ms () const
double	loss () const

Public Attributes
std::atomic< double >	ewma_rtt_ms {50.0}
std::atomic< double >	ewma_loss {0.0}
std::atomic< int >	samples {3}

Detailed Description

Definition at line 28 of file network_quality.hpp.

Member Function Documentation

◆ classify_network()

std::string NetQuality::classify_network ( ) const

inline

Definition at line 52 of file network_quality.hpp.

                                       {
        double rtt  = ewma_rtt_ms.load(std::memory_order_relaxed);
        double loss = ewma_loss.load(std::memory_order_relaxed);
 
        if (samples.load(std::memory_order_relaxed) < 3)
            return "bootstrap";
 
        if (rtt < 25.0 && loss < 0.005)
            return "fiber-ftth";
        if (rtt < 50.0 && loss < 0.008)
            return "ethernet";
        if (rtt < 120.0 && loss < 0.015)
            return "wifi";
        if (rtt < 200.0 && loss < 0.03)
            return "dsl/adsl";
        if (rtt < 400.0 && loss < 0.05)
            return "fwa-4g";
        if (rtt < 700.0 && loss < 0.08)
            return "5g";
        return "unstable";
    }

References ewma_loss, ewma_rtt_ms, loss(), and samples.

Referenced by recommended_dns_timeout(), and recommended_https_timeout().

◆ is_mobile_like()

bool NetQuality::is_mobile_like ( ) const

inline

Definition at line 101 of file network_quality.hpp.

                                {
        double rtt  = ewma_rtt_ms.load(std::memory_order_relaxed);
        double loss = ewma_loss.load(std::memory_order_relaxed);
        return (rtt > 250.0) || (loss > 0.05);
    }

References ewma_loss, ewma_rtt_ms, and loss().

◆ loss()

double NetQuality::loss ( ) const

inline

Definition at line 109 of file network_quality.hpp.

109{ return ewma_loss.load(std::memory_order_relaxed); }

References ewma_loss.

Referenced by classify_network(), and is_mobile_like().

◆ recommended_dns_timeout()

int NetQuality::recommended_dns_timeout ( ) const

inline

Definition at line 75 of file network_quality.hpp.

                                        {
        std::string net = classify_network();
        if (net == "fiber-ftth") return 60;
        if (net == "ethernet")   return 80;
        if (net == "wifi")       return 120;
        if (net == "dsl/adsl")   return 160;
        if (net == "fwa-4g")     return 200;
        if (net == "5g")         return 150;
        if (net == "bootstrap")  return 100;
        return 250;
    }

References classify_network().

◆ recommended_https_timeout()

int NetQuality::recommended_https_timeout ( ) const

inline

Definition at line 88 of file network_quality.hpp.

                                          {
        std::string net = classify_network();
        if (net == "fiber-ftth") return 400;
        if (net == "ethernet")   return 600;
        if (net == "wifi")       return 900;
        if (net == "dsl/adsl")   return 1200;
        if (net == "fwa-4g")     return 1500;
        if (net == "5g")         return 1100;
        if (net == "bootstrap")  return 800;
        return 1800;
    }

References classify_network().

◆ rtt_ms()

double NetQuality::rtt_ms ( ) const

inline

Definition at line 108 of file network_quality.hpp.

108{ return ewma_rtt_ms.load(std::memory_order_relaxed); }

References ewma_rtt_ms.

Referenced by update_sample().

◆ update_sample()

void NetQuality::update_sample	(	double	rtt_ms,
		bool	success )

inline

Definition at line 34 of file network_quality.hpp.

                                                    {
        const double alpha = 0.55;
        int s = samples.fetch_add(1, std::memory_order_relaxed) + 1;
 
        double prev_rtt  = ewma_rtt_ms.load(std::memory_order_relaxed);
        double prev_loss = ewma_loss.load(std::memory_order_relaxed);
 
 
        rtt_ms = std::clamp(rtt_ms, 1.0, 2000.0);
 
        double new_rtt  = alpha * rtt_ms + (1.0 - alpha) * prev_rtt;
        double new_loss = alpha * (success ? 0.0 : 1.0) + (1.0 - alpha) * prev_loss;
 
        ewma_rtt_ms.store(new_rtt, std::memory_order_relaxed);
        ewma_loss.store(new_loss, std::memory_order_relaxed);
    }