Method Process

src/DownloadQueue.cpp:409–560

// x > NORMALITY_FACTOR -> High availability.

void CDownloadQueue::Process()
{
	// send src requests to local server
	ProcessLocalRequests();
	const uint64 curTick = ::GetTickCount64();
	{
		wxMutexLocker lock(m_mutex);

		// Refill the global download bucket for this tick. The previous
		// per-peer ratio controller (50-200% adaptive against the
		// observed aggregate datarate) never actually enforced
		// MaxDownload as a literal byte/sec cap. The throttler is a
		// single shared atomic budget that every CEMSocket consults
		// before each Read(); fast peers can claim unused capacity
		// from slow ones within the same tick (demand-aware
		// redistribution), and the global cap is the only constraint.
		// MaxDownload=0 (UNLIMITED) sets the throttler to bypass mode.
		CDownloadBandwidthThrottler::Get().RefillBudget(
			thePrefs::GetMaxDownload(), CORE_TIMER_PERIOD);

		m_datarate = 0;
		m_udcounter++;
		uint32 cur_datarate = 0;
		uint32 cur_udcounter = m_udcounter;

		std::list<int> m_sourcecountlist;

		bool mustPreventSleep = false;

		for ( FileQueue::size_type i = 0; i < m_filelist.size(); i++ ) {
			CPartFile* file = m_filelist[i];

			CMutexUnlocker unlocker(m_mutex);

			uint8 status = file->GetStatus();
			mustPreventSleep |= !(status == PS_ERROR || status == PS_INSUFFICIENT || status == PS_PAUSED || status == PS_COMPLETE);

			if (status == PS_READY || status == PS_EMPTY ){
				cur_datarate += file->Process( cur_udcounter );
			} else {
				//This will make sure we don't keep old sources to paused and stopped files..
				file->StopPausedFile();

				// Drain leftover Phase 3 hash work for paused files: their
				// Process() doesn't run (gated above), but pre-pause
				// m_aChangedPart entries still need verification.
				//
				// PS_INSUFFICIENT is intentionally excluded — driving
				// FlushBuffer for a disk-full file re-enters its disk-space
				// check at PartFile.cpp:3083 every tick, which logs
				// "Not enough free disk-space" and re-pauses on every call,
				// producing tens of log lines per second.  The destructor
				// sync-hash drain still covers leftover dirty parts of
				// disk-full files at shutdown.
				if (status == PS_PAUSED && file->HasPendingHashWork()) {
					file->FlushBuffer();
				}
			}