Renegade/Code/wwnet/BWBalance.cpp

/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : Command & Conquer                                            *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/wwnet/BWBalance.cpp                          $*
 *                                                                                             *
 *                      $Author:: Steve_t                                                     $*
 *                                                                                             *
 *                     $Modtime:: 10/13/02 9:40p                                              $*
 *                                                                                             *
 *                    $Revision:: 12                                                          $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#include <always.h>
#include "bwbalance.h"
#include "connect.h"
#include "packetmgr.h"
#include "systimer.h"

BandwidthBalancerClass BandwidthBalancer;

/*
** 8000 bits per second is about as low as we want to go.
*/
#define MIN_ACCEPTABLE_BANDWIDTH	8000



/***********************************************************************************************
 * BandwidthBalancerClass::BandwidthBalancerClass -- Class constructor                         *
 *                                                                                             *
 *                                                                                             *
 *                                                                                             *
 * INPUT:    Nothing                                                                           *
 *                                                                                             *
 * OUTPUT:   Nothing                                                                           *
 *                                                                                             *
 * WARNINGS: None                                                                              *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/21/2001 8:47PM ST : Created                                                            *
 *=============================================================================================*/
BandwidthBalancerClass::BandwidthBalancerClass(void)
{
	NumClientStructs = 0;
	ClientInfo = NULL;

	Allocate_Client_Structs(8);

	IsEnabled = true;
}



/***********************************************************************************************
 * BandwidthBalancerClass::~BandwidthBalancerClass -- Class destructor                         *
 *                                                                                             *
 *                                                                                             *
 *                                                                                             *
 * INPUT:    Nothing                                                                           *
 *                                                                                             *
 * OUTPUT:   Nothing                                                                           *
 *                                                                                             *
 * WARNINGS: None                                                                              *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/21/2001 8:47PM ST : Created                                                            *
 *=============================================================================================*/
BandwidthBalancerClass::~BandwidthBalancerClass(void)
{
	if (ClientInfo) {
		delete [] ClientInfo;
	}
	ClientInfo = NULL;
}



/***********************************************************************************************
 * BandwidthBalancerClass::Allocate_Client_Structs -- Make room to store per client info       *
 *                                                                                             *
 *                                                                                             *
 *                                                                                             *
 * INPUT:    Likely number of clients                                                          *
 *                                                                                             *
 * OUTPUT:   Nothing                                                                           *
 *                                                                                             *
 * WARNINGS: None                                                                              *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/21/2001 8:47PM ST : Created                                                            *
 *=============================================================================================*/
void BandwidthBalancerClass::Allocate_Client_Structs(int num_structs)
{
	if (num_structs > NumClientStructs) {
		num_structs += 15;
		num_structs &= 0xfffffff0;

		if (ClientInfo) {
			delete [] ClientInfo;
		}

		ClientInfo = new ClientInfoStruct[num_structs];
		NumClientStructs = num_structs;
	}

}




/***********************************************************************************************
 * BandwidthBalancerClass::Adjust -- Adjust bandwidth to each client                           *
 *                                                                                             *
 *                                                                                             *
 *                                                                                             *
 * INPUT:    Nothing                                                                           *
 *                                                                                             *
 * OUTPUT:   Nothing                                                                           *
 *                                                                                             *
 * WARNINGS: None                                                                              *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/21/2001 8:48PM ST : Created                                                            *
 *=============================================================================================*/
void BandwidthBalancerClass::Adjust(cConnection *connection, bool is_dedicated)
{
	static unsigned long _last_adjustment = 0;	//TIMEGETTIME();

	/*
	**
	** Get average average priority.
	**
	** Do a pass and assign bandwidth to clients based on priority. Boost bandwidth to players currently loading. Clip bandwidth to
	** clients max bps (and +- 50%) and keep a total of spare bandwidth.
	**
	** Repeat until no bandwidth left.
	**
	*/
	if (connection != NULL) {

		bool need_update = false;
		for (int i=connection->Get_Min_RHost() + (is_dedicated ? 0 : 1) ; i <= connection->Get_Max_RHost() ; i++) {
			cRemoteHost *client = connection->Get_Remote_Host(i);
			if (client && client->Get_Target_Bps() == 0) {
				need_update = true;
				break;
			}
		}


		if (need_update || TIMEGETTIME() - _last_adjustment > 100) {
			_last_adjustment = TIMEGETTIME();

			Adjust_Connection_Budget(connection);

			int num_remote_hosts = connection->Get_Num_RHosts();
			if (!is_dedicated) {
				num_remote_hosts--;
			}

			if (num_remote_hosts > NumClientStructs) {
				Allocate_Client_Structs(num_remote_hosts);
			}
			WWASSERT(NumClientStructs >= num_remote_hosts);
			NumClients = 0;

			/*
			** Copy all the info we need into a single place.
			*/
			float average_priority = 0;
			for (int i=connection->Get_Min_RHost() + (is_dedicated ? 0 : 1) ; i <= connection->Get_Max_RHost() ; i++) {

				cRemoteHost *client = connection->Get_Remote_Host(i);

				if (client != NULL) {

					ClientInfo[NumClients].AveragePriority = client->Get_Average_Priority();
					ClientInfo[NumClients].MaxBpsDown = client->Get_Maximum_Bps();
					ClientInfo[NumClients].AllocatedBBO = client->Get_Target_Bps();
					ClientInfo[NumClients].ID = client->Get_Id();
					ClientInfo[NumClients].IsLoading = client->Get_Is_Loading();
					ClientInfo[NumClients].IsDone = false;

					/*
					** Track the overally average priority.
					*/
					average_priority += ClientInfo[NumClients].AveragePriority;
					NumClients++;
				}
			}

			WWASSERT(NumClients == num_remote_hosts);

			if (NumClients) {
				/*
				** Get the average object priority among all players.
				*/
				average_priority = average_priority / NumClients;
				int bw_adjust = 100;

				unsigned long total_bbo_allocated = Allocate_Bandwidth(average_priority, bw_adjust, connection->Get_Bandwidth_Budget_Out());

				/*
				** Ok, we have a rough bandwidth allocation. If we allocated too much or too little then we will need to do
				** some fine tuning.
				*/
				unsigned long total_bbo = connection->Get_Bandwidth_Budget_Out();
				int diff = total_bbo - total_bbo_allocated;
				int percent_diff = (100 * abs(diff)) / total_bbo;
				diff = total_bbo - total_bbo_allocated;
				bw_adjust = 100 + ((100 * diff) / (((int)total_bbo * 9) / 10));

				if (bw_adjust) {

					/*
					** If we allocated more or less than we have then keep adjusting until it comes out at about 95%.
					*/
					int tries = 5;
					while ((diff < 0 || percent_diff > 10) && tries >= 0) {
						//WWDEBUG_SAY(("Allocated too much or too little bandwidth. total_bbo = %d, total_bbo_allocated = %d, bw_adjust = %d\n", total_bbo, total_bbo_allocated, bw_adjust));
						total_bbo_allocated = Allocate_Bandwidth(average_priority, bw_adjust, connection->Get_Bandwidth_Budget_Out());
						diff = total_bbo - total_bbo_allocated;
						percent_diff = (100 * abs(diff)) / total_bbo;
						bw_adjust = bw_adjust * (100 + ((100 * diff) / (((int)total_bbo * 9) / 10))) / 100;
						if (bw_adjust <= 0) {
							break;
						}
						tries--;
					}

					/*
					** If we get to this point, there should still be bandwidth left.
					*/
					if (diff < 0 && percent_diff > 3) {
						WWDEBUG_SAY(("***** WARNING - BandwidthBalancer: Insufficient bandwidth for the number of clients in the game *********\n"));
						WWDEBUG_SAY(("Allocated too much bandwidth. total_bbo = %d, total_bbo_allocated = %d, bw_adjust = %d\n", total_bbo, total_bbo_allocated, bw_adjust));
					}

					/*
					** Oh well, let's assume that's right. Set the bandwidth budgets back into the rhosts.
					*/
					int index = 0;
					for (int i=connection->Get_Min_RHost() + (is_dedicated ? 0 : 1) ; i <= connection->Get_Max_RHost() ; i++) {
						cRemoteHost *client = connection->Get_Remote_Host(i);
						if (client != NULL) {
							client->Set_Target_Bps(ClientInfo[index++].AllocatedBBO);
						}
					}
				}
			}
		}
	}
}



/***********************************************************************************************
 * BandwidthBalancerClass::Allocate_Bandwidth -- Split bandwidth between clients               *
 *                                                                                             *
 *                                                                                             *
 *                                                                                             *
 * INPUT:    Average object priority for all clients                                           *
 *                                                                                             *
 *                                                                                             *
 * OUTPUT:   Percentage to apply to final bandwidth numbers                                    *
 *                                                                                             *
 * WARNINGS: None                                                                              *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/21/2001 8:49PM ST : Created                                                            *
 *=============================================================================================*/
unsigned long BandwidthBalancerClass::Allocate_Bandwidth(float average_priority, int bw_adjust, unsigned long total_server_bbo)
{
	WWASSERT(bw_adjust != 0);
	WWASSERT(average_priority >= 0.0f);
	WWASSERT(average_priority <= 1.0f);

	/*
	** Get our total bandwidth budget out. This has to be split between all clients.
	*/
	unsigned long total_bbo = total_server_bbo;
	unsigned long bbo_per_client = total_bbo / NumClients;
	unsigned long total_bbo_allocated = 0;

	/*
	** Loop through and assign bandwidth based on average priority and other metrics.
	*/
	for (int i=0 ; i<NumClients ; i++) {

		ClientInfoStruct *client = &ClientInfo[i];
		float pri = client->AveragePriority;

		/*
		** Work out the bandwidth, initially based on average priority.
		*/
		int client_bbo_adjust = (pri - average_priority) * bbo_per_client;
		if (client_bbo_adjust > 0) {
			client_bbo_adjust = min(client_bbo_adjust, (int)bbo_per_client / 2);
		} else {
			client_bbo_adjust = max(client_bbo_adjust, -((int)bbo_per_client / 2));
		}
		int new_client_bbo = bbo_per_client + client_bbo_adjust;
		WWASSERT(new_client_bbo > 0);

		/*
		** Boost the bandwidth if the client is loading. He doesn't need it now but there will be a huge demand for
		** bandwidth as soon as the load is done so it's good to free some up now.
		*/
		if (client->IsLoading) {
			new_client_bbo = new_client_bbo << 1;
		}

		/*
		** Apply the overall percentage adjustment.
		*/
		double big_client_bbo = (double) new_client_bbo;
		double big_bw_adjust = (double) bw_adjust;
		big_client_bbo = (big_client_bbo * big_bw_adjust) / 100.0;
		big_client_bbo = min(big_client_bbo, (double) 0x7fffffff);
		//new_client_bbo = (new_client_bbo * bw_adjust) / 100;
		new_client_bbo = (int) big_client_bbo;

		/*
		** OK, we have the bandwidth adjusted according to priority.
		** Clamp it to the min allowed and the max the client can take.
		*/
		new_client_bbo = min(new_client_bbo, (int)client->MaxBpsDown);
		new_client_bbo = max(new_client_bbo, MIN_ACCEPTABLE_BANDWIDTH);

		client->AllocatedBBO = (unsigned long) new_client_bbo;
		total_bbo_allocated += (unsigned long) new_client_bbo;
	}

	return(total_bbo_allocated);
}





/***********************************************************************************************
 * BandwidthBalancerClass::Adjust_Connection_Budget -- Adjust BBO of server connection         *
 *                                                                                             *
 *                                                                                             *
 *                                                                                             *
 * INPUT:    Ptr to server connection                                                          *
 *                                                                                             *
 * OUTPUT:   Nothing                                                                           *
 *                                                                                             *
 * WARNINGS: None                                                                              *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/24/2001 1:56PM ST : Created                                                            *
 *=============================================================================================*/
void BandwidthBalancerClass::Adjust_Connection_Budget(cConnection *connection)
{
	static unsigned long _last_time = 0;
	unsigned long time = TIMEGETTIME();

	/*
	** Check every n seconds and see if we had any send errors that would be caused by sending too much data.
	*/
	if (PacketManager.Get_Error_State() == PacketManagerClass::STATE_WS_BUFFERS_FULL) {
		if (time - _last_time > 10000) {
			_last_time = time;
			ULONG bbo = connection->Get_Bandwidth_Budget_Out();
			ULONG new_bbo = (bbo * 9) / 10;
			connection->Set_Bandwidth_Budget_Out(new_bbo);
			WWDEBUG_SAY(("*** WARNING BandwidthBalancerClass - Adjusting Server connection BBO from %d to %d due to send overflow ***\n", bbo, new_bbo));
		}
	}
}