{
MutexAutoLock internal(m_internal_mutex);
current_bytes_transfered += bytes;
- current_packet_successfull += packets;
+ current_packet_successful += packets;
}
void Channel::UpdateBytesReceived(unsigned int bytes) {
current_packet_too_late++;
}
-void Channel::UpdateTimers(float dtime,bool legacy_peer)
+void Channel::UpdateTimers(float dtime)
{
bpm_counter += dtime;
packet_loss_counter += dtime;
- if (packet_loss_counter > 1.0)
- {
- packet_loss_counter -= 1.0;
+ if (packet_loss_counter > 1.0f) {
+ packet_loss_counter -= 1.0f;
unsigned int packet_loss = 11; /* use a neutral value for initialization */
- unsigned int packets_successfull = 0;
+ unsigned int packets_successful = 0;
//unsigned int packet_too_late = 0;
bool reasonable_amount_of_data_transmitted = false;
MutexAutoLock internal(m_internal_mutex);
packet_loss = current_packet_loss;
//packet_too_late = current_packet_too_late;
- packets_successfull = current_packet_successfull;
+ packets_successful = current_packet_successful;
- if (current_bytes_transfered > (unsigned int) (window_size*512/2))
- {
+ if (current_bytes_transfered > (unsigned int) (window_size*512/2)) {
reasonable_amount_of_data_transmitted = true;
}
current_packet_loss = 0;
current_packet_too_late = 0;
- current_packet_successfull = 0;
+ current_packet_successful = 0;
}
- /* dynamic window size is only available for non legacy peers */
- if (!legacy_peer) {
- float successfull_to_lost_ratio = 0.0;
- bool done = false;
+ /* dynamic window size */
+ float successful_to_lost_ratio = 0.0f;
+ bool done = false;
+
+ if (packets_successful > 0) {
+ successful_to_lost_ratio = packet_loss/packets_successful;
+ } else if (packet_loss > 0) {
+ window_size = std::max(
+ (window_size - 10),
+ MIN_RELIABLE_WINDOW_SIZE);
+ done = true;
+ }
- if (packets_successfull > 0) {
- successfull_to_lost_ratio = packet_loss/packets_successfull;
- }
- else if (packet_loss > 0)
- {
- window_size = MYMAX(
- (window_size - 10),
+ if (!done) {
+ if ((successful_to_lost_ratio < 0.01f) &&
+ (window_size < MAX_RELIABLE_WINDOW_SIZE)) {
+ /* don't even think about increasing if we didn't even
+ * use major parts of our window */
+ if (reasonable_amount_of_data_transmitted)
+ window_size = std::min(
+ (window_size + 100),
+ MAX_RELIABLE_WINDOW_SIZE);
+ } else if ((successful_to_lost_ratio < 0.05f) &&
+ (window_size < MAX_RELIABLE_WINDOW_SIZE)) {
+ /* don't even think about increasing if we didn't even
+ * use major parts of our window */
+ if (reasonable_amount_of_data_transmitted)
+ window_size = std::min(
+ (window_size + 50),
+ MAX_RELIABLE_WINDOW_SIZE);
+ } else if (successful_to_lost_ratio > 0.15f) {
+ window_size = std::max(
+ (window_size - 100),
+ MIN_RELIABLE_WINDOW_SIZE);
+ } else if (successful_to_lost_ratio > 0.1f) {
+ window_size = std::max(
+ (window_size - 50),
MIN_RELIABLE_WINDOW_SIZE);
- done = true;
- }
-
- if (!done)
- {
- if ((successfull_to_lost_ratio < 0.01) &&
- (window_size < MAX_RELIABLE_WINDOW_SIZE))
- {
- /* don't even think about increasing if we didn't even
- * use major parts of our window */
- if (reasonable_amount_of_data_transmitted)
- window_size = MYMIN(
- (window_size + 100),
- MAX_RELIABLE_WINDOW_SIZE);
- }
- else if ((successfull_to_lost_ratio < 0.05) &&
- (window_size < MAX_RELIABLE_WINDOW_SIZE))
- {
- /* don't even think about increasing if we didn't even
- * use major parts of our window */
- if (reasonable_amount_of_data_transmitted)
- window_size = MYMIN(
- (window_size + 50),
- MAX_RELIABLE_WINDOW_SIZE);
- }
- else if (successfull_to_lost_ratio > 0.15)
- {
- window_size = MYMAX(
- (window_size - 100),
- MIN_RELIABLE_WINDOW_SIZE);
- }
- else if (successfull_to_lost_ratio > 0.1)
- {
- window_size = MYMAX(
- (window_size - 50),
- MIN_RELIABLE_WINDOW_SIZE);
- }
}
}
}
- if (bpm_counter > 10.0)
- {
+ if (bpm_counter > 10.0f) {
{
MutexAutoLock internal(m_internal_mutex);
cur_kbps =
- (((float) current_bytes_transfered)/bpm_counter)/1024.0;
+ (((float) current_bytes_transfered)/bpm_counter)/1024.0f;
current_bytes_transfered = 0;
cur_kbps_lost =
- (((float) current_bytes_lost)/bpm_counter)/1024.0;
+ (((float) current_bytes_lost)/bpm_counter)/1024.0f;
current_bytes_lost = 0;
cur_incoming_kbps =
- (((float) current_bytes_received)/bpm_counter)/1024.0;
+ (((float) current_bytes_received)/bpm_counter)/1024.0f;
current_bytes_received = 0;
- bpm_counter = 0;
+ bpm_counter = 0.0f;
}
- if (cur_kbps > max_kbps)
- {
+ if (cur_kbps > max_kbps) {
max_kbps = cur_kbps;
}
- if (cur_kbps_lost > max_kbps_lost)
- {
+ if (cur_kbps_lost > max_kbps_lost) {
max_kbps_lost = cur_kbps_lost;
}
UDPPeer::UDPPeer(u16 a_id, Address a_address, Connection* connection) :
Peer(a_address,a_id,connection)
{
+ for (Channel &channel : channels)
+ channel.setWindowSize(g_settings->getU16("max_packets_per_iteration"));
}
bool UDPPeer::getAddress(MTProtocols type,Address& toset)
return false;
}
-void UDPPeer::setNonLegacyPeer()
-{
- m_legacy_peer = false;
- for(unsigned int i=0; i< CHANNEL_COUNT; i++)
- {
- channels[i].setWindowSize(g_settings->getU16("max_packets_per_iteration"));
- }
-}
-
void UDPPeer::reportRTT(float rtt)
{
assert(rtt >= 0.0f);
#define CONTROLTYPE_SET_PEER_ID 1
#define CONTROLTYPE_PING 2
#define CONTROLTYPE_DISCO 3
-#define CONTROLTYPE_ENABLE_BIG_SEND_WINDOW 4
/*
ORIGINAL: This is a plain packet with no control and no error
CONNCMD_SEND,
CONNCMD_SEND_TO_ALL,
CONCMD_ACK,
- CONCMD_CREATE_PEER,
- CONCMD_DISABLE_LEGACY
+ CONCMD_CREATE_PEER
};
struct ConnectionCommand
reliable = true;
raw = true;
}
-
- void disableLegacy(session_t peer_id_, const SharedBuffer<u8> &data_)
- {
- type = CONCMD_DISABLE_LEGACY;
- peer_id = peer_id_;
- data = data_;
- channelnum = 0;
- reliable = true;
- raw = true;
- }
};
/* maximum window size to use, 0xFFFF is theoretical maximum don't think about
void UpdateBytesLost(unsigned int bytes);
void UpdateBytesReceived(unsigned int bytes);
- void UpdateTimers(float dtime, bool legacy_peer);
+ void UpdateTimers(float dtime);
const float getCurrentDownloadRateKB()
{ MutexAutoLock lock(m_internal_mutex); return cur_kbps; };
unsigned int current_packet_loss = 0;
unsigned int current_packet_too_late = 0;
- unsigned int current_packet_successfull = 0;
+ unsigned int current_packet_successful = 0;
float packet_loss_counter = 0.0f;
unsigned int current_bytes_transfered = 0;
bool getAddress(MTProtocols type, Address& toset);
- void setNonLegacyPeer();
-
- bool getLegacyPeer()
- { return m_legacy_peer; }
-
u16 getNextSplitSequenceNumber(u8 channel);
void setNextSplitSequenceNumber(u8 channel, u16 seqnum);
bool processReliableSendCommand(
ConnectionCommand &c,
unsigned int max_packet_size);
-
- bool m_legacy_peer = true;
};
/*
for (Channel &channel : udpPeer->channels) {
std::list<BufferedPacket> timed_outs;
- if (udpPeer->getLegacyPeer())
- channel.setWindowSize(WINDOW_SIZE);
-
// Remove timed out incomplete unreliable split packets
channel.incoming_splits.removeUnreliableTimedOuts(dtime, m_timeout);
break; /* no need to check other channels if we already did timeout */
}
- channel.UpdateTimers(dtime, udpPeer->getLegacyPeer());
+ channel.UpdateTimers(dtime);
}
/* skip to next peer if we did timeout */
}
return;
- case CONCMD_DISABLE_LEGACY:
- LOG(dout_con << m_connection->getDesc()
- << "UDP processing reliable CONCMD_DISABLE_LEGACY" << std::endl);
- if (!rawSendAsPacket(c.peer_id, c.channelnum, c.data, c.reliable)) {
- /* put to queue if we couldn't send it immediately */
- sendReliable(c);
- }
- return;
-
case CONNCMD_SERVE:
case CONNCMD_CONNECT:
case CONNCMD_DISCONNECT:
m_connection->SetPeerID(peer_id_new);
}
- // set non legacy mode locally
- dynamic_cast<UDPPeer *>(peer)->setNonLegacyPeer();
-
- // request the same from the remote side
- ConnectionCommand cmd;
-
- SharedBuffer<u8> reply(2);
- writeU8(&reply[0], PACKET_TYPE_CONTROL);
- writeU8(&reply[1], CONTROLTYPE_ENABLE_BIG_SEND_WINDOW);
- cmd.disableLegacy(PEER_ID_SERVER, reply);
- m_connection->putCommand(cmd);
-
throw ProcessedSilentlyException("Got a SET_PEER_ID");
} else if (controltype == CONTROLTYPE_PING) {
// Just ignore it, the incoming data already reset
}
throw ProcessedSilentlyException("Got a DISCO");
- } else if (controltype == CONTROLTYPE_ENABLE_BIG_SEND_WINDOW) {
- dynamic_cast<UDPPeer *>(peer)->setNonLegacyPeer();
- throw ProcessedSilentlyException("Got non legacy control");
} else {
LOG(derr_con << m_connection->getDesc()
<< "INVALID TYPE_CONTROL: invalid controltype="
projects / oweals / minetest.git / commitdiff