Receiving high frequency UDP packets: packet loss?

I have a C ++ application that uses a UDP server (using Boost.Asio) that accepts packets from a gigabit local network device at a high rate (3500 packets per second). Some users have reported multiple packet loss. So in the end I decided to run WireShark and my application in parallel to check if there were any packages WireShark could receive, but not my application.

I found that WireShark doesn't receive every packet, it seems like it is missing some. My app is skipping a few more frames which Wireshark received correctly.

My questions . Is it possible WireShark is receiving packets that my app doesn't have? I thought maybe WireShark has low-level access to the IP stack and packets are dropped by the OS even though they show up in WireShark? Is it possible that the operation in (1) is taking too long so that the next one async_receive_from

is called too late? I would like to get opinions on this matter. Thank.

Here is the code I'm using (pretty simple). udp_server.h:

#pragma once

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <fstream>

const int MAX_BUFFER_SIZE = 65537;

using boost::asio::ip::udp;

class UDPServer
{
public:
    UDPServer(boost::asio::io_service& ios, udp::endpoint endpoint)
        :m_io_service(ios),
        m_udp_socket(m_io_service, endpoint)
    {
        // Resize the buffer to max size in the component property
        m_recv_buffer.resize(MAX_BUFFER_SIZE);

        m_output_file.open("out.bin", std::ios::out | std::ios::binary);

        StartReceive();
    }

public:
    void StartReceive()
    {
        m_udp_socket.async_receive_from(
            boost::asio::buffer(m_recv_buffer), m_remote_endpoint,
            boost::bind(&UDPServer::HandleReceive, this,
            boost::asio::placeholders::error,
            boost::asio::placeholders::bytes_transferred));
    }

private:
    void HandleReceive(const boost::system::error_code& error, std::size_t bytes_transferred)
    {
        if (!error || error == boost::asio::error::message_size)
        {
            // Write to output -- (1)
            m_output_file.sputn(&m_recv_buffer[0], bytes_transferred);

            // Start to receive again
            StartReceive();
        }
    }

    boost::asio::io_service&    m_io_service;
    udp::socket                 m_udp_socket;
    udp::endpoint               m_remote_endpoint;
    std::vector<char>           m_recv_buffer;
    std::filebuf                m_output_file;
};

      

        
        
        
      

    

main.cpp:

include <boost/asio.hpp>
#include "udp_server.h"

const unsigned short PORT_NUMBER = 44444;

int main()
{
    boost::asio::io_service ios;
    boost::asio::ip::udp::endpoint endpoint(udp::endpoint(udp::v4(), PORT_NUMBER));
    UDPServer server(ios, endpoint);
    ios.run();

    return 0;
}