Extreme UDP-Package-Loss in HoloLens2 -UWP-Application

Question

In my HoloLens2 application sometimes the UDP-Package-receive rate drops instantly from 40 packages per second to 0-2 packages per second and stays there (size of packages between 2000 byte and 60000 byte. The application is made with Unity3d and .Net Sockets for networking. This behaviour sometimes happens straight from application startup, sometimes after 30 minutes, so basically quiet random. Even Restarting HoloLens2 doesn´t help in such a situation. The application logs no exception or error messages. On my Unity-Editor the Application can handle the network traffic without any problem.

It feels like some Network buffer got stuffend and drops all packages so did I miss some Cleanup command in my Networking-Code or is there another way to face Receive-Overload in my code? Or is HoloLens2 somehow limited in it´s Bandwith when running via Ethernet (and not Wifi)?

At the same time my application also maintains a peer-to-peer Video-stream (WebRTC with MixedReality Capture). This stream works well over the whole lifetime of the application flawlessly.

using System;

using System.Collections;

using System.Net;

using System.Net.Sockets;

using System.Threading;

using UnityEngine;


public class UdpCommunicationDotNet : ICommunicator
    {
        #region Fields
        private int m_PackageCountPerSecond;
        private int m_PackageCountTotal;
        private Thread m_PackageCounterResetRoutine;
        private Socket m_SenderSocket;
        private Socket m_ReceiverSocket;
        private IPEndPoint m_ServerIpEndPoint;
        private IPEndPoint m_ReceiverIpEndPoint;
        private IPEndPoint m_ListenerIpEndPoint;
        private EndPoint m_ServerEndPoint;
        private EndPoint m_ReceiverEndPoint;
        private byte[] m_ReceiveBuffer;
        private IDataProvider m_DataProvider;
        private int m_MaxBufferByteLength;


        private bool m_ReceiveEnabled = true;


        public IDataProvider DataProvider { get => m_DataProvider; set => m_DataProvider = value; }
        #endregion


        #region Constructor

        public UdpCommunicationDotNet()
        {
            m_MaxBufferByteLength = GameManager.Instance.GetConfigurationManager.RuntimeConfig.NetworkSettings.MaxBufferByteLength;
        }

        #endregion

        #region Public Methods


        public void Initialize(DataLineConfig dataLineConfig)
        {
            m_ReceiveBuffer = new byte[m_MaxBufferByteLength];
            m_ServerIpEndPoint = dataLineConfig.serverEndPoint;
            m_ReceiverIpEndPoint = new IPEndPoint(IPAddress.Any, 0);
            m_ServerEndPoint = (EndPoint)m_ServerIpEndPoint;
            m_ReceiverEndPoint = (EndPoint)m_ReceiverIpEndPoint;
            m_ListenerIpEndPoint = dataLineConfig.receiverEndPoint;
        }

        public void StartReceiver()
        {
            if (InitializeReceiverSocket())
            {
                m_ReceiveEnabled = true;
                StartReceiving();
            }
        }


        public void EndReceiver()
        {
            m_ReceiveEnabled = false;

        }

        public void StartSender()
        {
            InitializeSenderSocket();
        }

        public void Send(Byte[] data)
        {
            try
            {
                //added this, remove it
                //Debug.Log("SentMyDataPackage");
                m_SenderSocket.BeginSendTo(data, 0, data.Length, SocketFlags.None, m_ServerEndPoint, new AsyncCallback(OnSendCallback), null);
            }
            catch (Exception e)
            {
                Debug.LogError("Failed to send udp data through the UdpCommunicator: " + e.Message);
            }
        }

        #endregion

        #region Private Methods

        private bool InitializeReceiverSocket()
        {
            bool isInitialized = false;

            try
            {
                m_ReceiverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
                m_ReceiverSocket.Bind(m_ListenerIpEndPoint);
                isInitialized = true;
            }
            catch (Exception e)
            {
                Debug.LogError("Failed to initialize the receiver socket in the UdpCommunicator: " + e.Message);
            }
            
            return isInitialized;
        }

        private void InitializeSenderSocket()
        {
            m_SenderSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
        }

        private void StartReceiving()
        {

            m_ReceiverSocket.BeginReceiveFrom(m_ReceiveBuffer, 0, m_ReceiveBuffer.Length, SocketFlags.None, ref m_ReceiverEndPoint, new AsyncCallback(OnReceiveCallback), m_ReceiverEndPoint);
        }

        private void DistributeData(object dataObject)
        {
            byte[] data = (byte[])dataObject;
            m_DataProvider.DistributeData(data);
        }

        #endregion

        #region Callback Methods

        private void OnSendCallback(IAsyncResult asyncResult)
        {
            try
            {
                m_SenderSocket.EndSend(asyncResult);
            }
            catch (Exception e)
            {
                Debug.LogError("Failed to close the opened send connection in the UdpCommunicator: " + e.Message);
            }
        }

        private void OnReceiveCallback(IAsyncResult asyncResult)
        {
            try
            {
                if (DebugManager.Instance.isActive)
                {
                    DebugManager.Instance.m_PackageCounter.UpdateMainCountTotal(m_PackageCountTotal);
                }

                int receivedBufferSize = m_ReceiverSocket.EndReceiveFrom(asyncResult, ref m_ReceiverEndPoint);
                Array.Resize(ref m_ReceiveBuffer, receivedBufferSize);

                byte[] copiedBuffer = new byte[receivedBufferSize];
                Buffer.BlockCopy(m_ReceiveBuffer, 0, copiedBuffer, 0, receivedBufferSize);
 
                Thread thread = new Thread(DistributeData);
                thread.SetApartmentState(ApartmentState.STA);
                thread.Start(copiedBuffer);

                m_ReceiveBuffer = new byte[m_MaxBufferByteLength];
            }
            catch (Exception e)
            {
                Debug.LogError("Failed to fetch the received data in the UdpCommunicator: " + e.Message);
            }
            finally
            {
                if (m_ReceiveEnabled)
                {
                    StartReceiving();
                }
                else
                {
                    m_ReceiverSocket.Shutdown(SocketShutdown.Both);
                    m_SenderSocket.Shutdown(SocketShutdown.Both);
                    m_ReceiverSocket.Close();
                    m_SenderSocket.Close();
                }
            }
        }

        #endregion

    }

Edit: By writing the Minimal Reproducable Example I found out the reason for the missbehaviour! I realized that if I send more than 4 Packages in one chunk (so send package1, send package2, send package3, send package4, etc, wait x ms, start again) HoloLens2 is starting to drop my udp packages.

In contrast, when I send Package1-> wait for 4 ms -> send package2 -> wait for 4 ms -> send package 3 -> wait 4ms and so on and after sending all different packages simply restart sending, it Works like a charm!

Also, when I send the packages via EthernetOverUSB (what is not a usable approach for my case), even if I send all packages in one chunk it works.

For me this behaviour is wiered and I can´t explain it to myself. Maybe somebody of you can ? Anyways, thanks for anybody who tried to help me!