Что быстрее udp или tcp
ИТ База знаний
Полезно
— Онлайн генератор устойчивых паролей
— Онлайн калькулятор подсетей
— Руководство администратора FreePBX на русском языке
— Руководство администратора Cisco UCM/CME на русском языке
— Руководство администратора по Linux/Unix
Навигация
Серверные решения
Телефония
FreePBX и Asterisk
Настройка программных телефонов
Корпоративные сети
Протоколы и стандарты
TCP и UDP – в чем разница?
Напомним немного про OSI
Современный мир немыслим без средств связи. Десятки миллионов устройств по всему миру связываются посредством компьютерных сетей. И каждая компьютерная сеть организована по определенным стандартам. Любые устройства взаимодействуют по общепринятой модели OSI, или Базовой Эталонной Модели Взаимодействия Открытых Систем. Данная модель определяет взаимодействие различных сетевых устройств на семи уровнях – Media (к ним относятся физический, канальный и сетевой) и Host – (транспортный, сеансовый, представления и прикладной). В данной статье мы рассмотрим два самых распространенных сетевых протокола транспортного уровня – TCP и UDP, примеры их применения, а также сравним их характеристики.
Онлайн курс по Кибербезопасности
Изучи хакерский майндсет и научись защищать свою инфраструктуру! Самые важные и актуальные знания, которые помогут не только войти в ИБ, но и понять реальное положение дел в индустрии
Видео: TCP и UDP | что это такое и в чем разница?
В чем же разница TCP и UDP?
Вообще, протоколы транспортного уровня широко применяются в современных сетях. Именно они позволяют гарантировать доставку сообщения до адресата, а также сохраняют правильную последовательность передачи данных. При этом протоколы имеют ряд различий, что позволяет использовать их профильно, для решения своих задач каждый.
Протокол TCP (Transmission Control Protocol) – это сетевой протокол, который «заточен» под соединение. Иными словами, прежде, чем начать обмен данными, данному протоколу требуется установить соединение между двумя хостами. Данный протокол имеет высокую надежность, поскольку позволяет не терять данные при передаче, запрашивает подтверждения о получении от принимающей стороны и в случае необходимости отправляет данные повторно. При этом отправляемые пакеты данных сохраняют порядок отправки, то есть можно сказать, что передача данных упорядочена. Минусом данного протокола является относительно низкая скорость передачи данных, за счет того что выполнение надежной и упорядоченной передачи занимает больше времени, чем в альтернативном протоколе UDP.
Протокол UDP (User Datagram Protocol), в свою очередь, более прост. Для передачи данных ему не обязательно устанавливать соединение между отправителем и получателем. Информация передается без предварительной проверки готовности принимающей стороны. Это делает протокол менее надежным – при передаче некоторые фрагменты данных могут теряться. Кроме того, упорядоченность данных не соблюдается – возможен непоследовательный прием данных получателем. Зато скорость передачи данных по данному транспортному протоколу будет более высокой.
Заключение и наглядное сравнение
Приведем несколько основных пунктов:
Полный курс по Сетевым Технологиям
В курсе тебя ждет концентрат ТОП 15 навыков, которые обязан знать ведущий инженер или senior Network Operation Engineer
TCP против UDP: особенности, использование и отличия
Протокол TCP: что это и как работает?
TCP (протокол управления передачей) Протокол является одним из основных протоколов в Интернете, он позволяет приложениям взаимодействовать с гарантиями независимо от нижних уровней модели TCP / IP. Это означает, что маршрутизаторы (сетевой уровень в модели TCP / IP) должны только отправлять сегменты (единицы измерения в TCP), не беспокоясь о том, будут ли эти данные поступать правильно. TCP поддерживает несколько протоколов уровня приложений такие как HTTP (Интернет), HTTPS (защищенный Интернет), POP3 (входящая почта) и SMTP (исходящая почта), а также их безопасные версии с использованием TLS. TCP также используется в таких важных протоколах, как FTP, FTPES и SFTP для передачи файлов из источника в место назначения, и даже протокол SSH для локального и удаленного безопасного управления компьютерами использует протокол TCP.
основные черты
Поскольку TCP обслуживает большое количество протоколов прикладного уровня, он важно, чтобы данные (сегменты) доходили до получателя правильно без ошибок и по порядку. Если при передаче сегментов они повреждены или утеряны, автоматически TCP протокол начинается ретрансляция без вмешательства прикладного уровня. Таким образом, гарантируется, что данные достигают получателя без ошибок, так как этот протокол отвечает за решение любого типа проблемы.
TCP имеет сложный механизм контроля ошибок используется техника скользящего окна, чтобы все сегменты приходили правильно. Эта функция использует различные методы для обнаружения возможных ошибок:
Конечно, если TCP обнаружит ошибку, он автоматически начнет повторную передачу, при этом прикладному уровню вообще не придется ничего делать.
Протокол TCP позволяет управление потоком то есть он способен смягчить возможное насыщение сети или удаленного хоста. Если устройство передает данные со скоростью 500 Мбит / с, а устройство-адресат может получать информацию только со скоростью 100 Мбит / с, протокол TCP динамически адаптируется. Таким образом, протокол TCP всегда будет пытаться максимизировать доступную пропускную способность между источником и назначением. Работа этого скользящего окна сложна, но в основном он работает в том, что у получателя есть доступное окно TCP с количеством байтов, которые могут быть сохранены в буфере, отправитель может отправлять данные до тех пор, пока это количество не будет заполнено. Для того чтобы отправитель отправил больше данных, получателю необходимо отправить ACK, указывающий, что все правильно и что он продолжает «загружать» его на прикладной уровень.
Чтобы избежать перегрузки и того, что мы можем сжать максимальную доступную полосу пропускания между отправителем и пунктом назначения, существует всего три этапа. медленный старт Фаза (медленный старт) отвечает за экспоненциальный рост (поэтому его нельзя считать медленным стартом) окна перегрузки, затем перегрузки уклонение фаза, которая отвечает за линейное увеличение окна заторов, и, наконец, постоянная фаза где окно приема такое же, как окно перегрузки.
TCP в настоящее время имеет различные алгоритмы для эффективного управления перегрузкой, первыми были TCP Tahoe и Reno, хотя у нас также есть другие, такие как TCP Vegas, но с годами, благодаря новым сетям передачи данных TCP / IP, у них появились другие алгоритмы, которые более эффективным. Например, у нас есть TCP BRR что позволяет нам отправлять информацию как можно быстрее, поскольку он намного эффективнее исходного протокола TCP (у нас будет большая скорость). У нас также есть TCP Cubic, который является средством контроля перегрузки, используемым Linux и операционные системы Unix.
Установление соединения между клиентом и сервером и отключение в TCP
Основной характеристикой протокола TCP является то, что это протокол, ориентированный на соединение Чтобы установить соединение между клиентом и сервером, абсолютно необходимо установить предыдущее соединение с указанным сервером.
Одна из уязвимостей TCP заключается в отправке большого количества сегментов TCP SYN с целью «насыщения» подключений к получателю. Вот некоторые возможные решения для смягчения атаки типа «отказ в обслуживании»:
Заголовок TCP
TCP добавляет как минимум 20 байтов заголовка в каждом сегменте, так как у нас есть «необязательное» поле. В этом заголовке TCP мы найдем порт источника и порт назначения соединения (сокета), мы также найдем порядковый номер, номер ACK и различные флаги TCP, такие как SYN, ACK, RST, FIN, URG и другие. В этом заголовке у нас также есть очень важная часть для работы со скользящим окном, и у нас будет 16-битное поле, которое указывает размер окна приема, которое мы объяснили ранее.
порты (исходный порт и порт назначения) необходимы для правильного функционирования TCP. TCP использует эти номера портов для идентификации сокета, то есть приложения, которое отправляет данные или получает данные. Порты TCP варьируются от 0 до 65535, но у нас есть три различных типа портов:
Протокол UDP: что это и как работает?
Протокол UDP (протокол пользовательских дейтаграмм) является одним из основных протоколов в Интернете, он позволяет приложениям обмениваться данными с гарантиями независимо от нижних уровней модели TCP / IP. Это означает, что маршрутизаторы (сетевой уровень в модели TCP / IP) должны отправлять только дейтаграммы (единица измерения в UDP). UDP поддерживает несколько протоколов прикладного уровня, например, популярный DNS и даже протокол DHCP для автоматического получения (и предоставления) IP-адресации.
основные черты
Этот протокол не обеспечивает какого-либо типа управления потоком Если одно устройство быстрее другого и отправляет информацию, вполне возможно, что информация будет потеряна, поскольку она будет разрушаться при самой низкой скорости, и нам придется перейти к пересылке информации. Важной деталью является то, что управление пересылкой дейтаграмм осуществляется транспортным уровнем, поскольку UDP очень прост и не имеет механизмов управления для пересылки дейтаграмм, поскольку он был потерян.
UDP также не обеспечивает любой тип контроля скопление если в сети есть перегрузка, пакеты могут быть потеряны, и, конечно, он не будет отвечать за их повторную отправку, как это происходит с TCP. Следовательно, UDP не имеет контроля перегрузки, контроля потока или контроля ошибок, можно сказать, что UDP является ненадежным протоколом. Кроме того, он не предоставляет порядок в отправленных дейтаграммах и информацию о том, правильно ли поступила дейтаграмма, поскольку нет подтверждения доставки или получения. Любой тип гарантий передачи информации должен быть реализован на более высоких уровнях.
Этот протокол в основном используется в DHCP и DNS, где скорость важнее надежности. UDP широко используется в задачах управления передачей аудио и видео по сети. UDP только добавляет мультиплексирование приложения и добавление контрольной суммы в заголовок и полезную нагрузку.
Заголовок UDP
UDP добавляет 8-байтовый заголовок в каждой дейтаграмме. В этом заголовке UDP мы найдем порт источника и порт назначения соединения (сокета), длину дейтаграммы и контрольную сумму упомянутой дейтаграммы, чтобы убедиться, что в ней нет ошибок ни заголовка, ни данных дейтаграммы. порты (исходный порт и порт назначения) необходимы для правильного функционирования UDP. UDP использует эти номера портов для идентификации сокета, то есть приложения, которое передает данные или получает данные.
TCP против UDP в различных протоколах VPN, таких как OpenVPN
OpenVPN позволяет использовать протокол TCP и UDP для туннеля данных, как вы видели, TCP и UDP сильно различаются, и всегда рекомендуется использовать TCP, так как он имеет управление потоком, контроль перегрузки, контроль ошибок и многие другие функции, которые делают соединение надежным. Если вы собираетесь использовать OpenVPN, по умолчанию используется UDP, это связано с тем, что, если есть какие-либо проблемы, протоколы прикладного уровня, такие как HTTP (который использует TCP ниже), будут отвечать за выполнение повторных передач, если это было необходимо, поэтому соединение будет надежным (управление потоком, перегрузка, ошибки и т. д.), даже если зашифрованный туннель точка-точка использует UDP.
Очень важный аспект заключается в том, что сервер OpenVPN с UDP будет способен принимать больше входящих соединений одновременно, если вы используете UDP, чем если вы используете TCP, кроме того, у нас также будет большая пропускная способность, так как дополнительная «загрузка» не добавляется потому что UDP намного «легче».
Как вы видели, как TCP, так и UDP являются двумя основными интернет-протоколами, и каждый из них обрабатывает разные протоколы прикладного уровня.
UDP по-прежнему лучше, чем TCP, для игр с большим объемом данных в реальном времени?
Я знаю, что UDP обычно рекомендуется для многопользовательских игр в реальном времени с высоким использованием данных.
Большинству статей посвящено несколько лет, и, поскольку
Это заставляет меня задуматься: по-прежнему ли UDP превосходит скорость и задержку? Могли ли недавние оптимизации TCP сделать TCP работать лучше, чем UDP?
TCP создает абстракцию, в которой поступают все сетевые пакеты, и они приходят в точном порядке, в котором они были отправлены. Чтобы реализовать такую абстракцию на канале с потерями, он должен реализовать повторные передачи и тайм-ауты, которые занимают время. Если вы отправите 2 обновления по TCP, и пакет первого обновления будет потерян, второе обновление не будет отображаться до тех пор, пока:
Не имеет значения, насколько быстро это делается в TCP, потому что с UDP вы просто отбрасываете первое обновление и используете второе, более новое, прямо сейчас. В отличие от TCP, UDP не гарантирует, что все пакеты прибывают, и не гарантирует, что они прибывают в порядке.
Это требует, чтобы вы отправляли правильный тип данных и разрабатывали свое общение таким образом, чтобы потеря данных была приемлемой.
Если у вас есть данные, куда должен прибыть каждый пакет, и пакеты должны обрабатываться вашей игрой в том порядке, в котором они были отправлены, то UDP не будет работать быстрее. На самом деле использование UDP в этом случае, вероятно, будет медленнее, потому что вы восстанавливаете TCP и реализуете его с помощью UDP, и в этом случае вы также можете использовать TCP.
Как правило, уровень потери пакетов в Ethernet очень низок, но он становится намного выше, если задействован WiFi или если пользователь выполняет загрузку / загрузку. Давайте предположим, что у нас совершенно равномерная потеря пакетов 0,01% (в одну сторону, а не в оба конца). На шутере от первого лица клиенты должны отправлять обновления всякий раз, когда что-то происходит, например, когда курсор мыши поворачивает плеер, что происходит примерно 20 раз в секунду. Они также могут отправлять обновления по кадрам или с фиксированным интервалом, который будет составлять 60-120 обновлений в секунду. Поскольку эти обновления отправляются в разное время, они будут / должны отправляться в одном пакете за обновление. В игре на 16 игроков все 16 игроков отправляют эти 20-120 пакетов в секунду на сервер, в результате чего получается 320-1920 пакетов в секунду. С нашей скоростью потери пакетов 0,01% мы ожидаем потерять пакет каждые 5,2-31,25 секунды.
Напротив, в случае UDP мы восстанавливаемся из потерянного пакета, как только получаем следующий пакет, поэтому мы теряем 8,3 мс, если отправляем 120 пакетов в секунду, и 50 мс, если отправляем 20 пакетов в секунду.
С TCP все становится еще сложнее, если мы также должны учитывать Nagle (если разработчик забывает отключить объединение отправки или не может отключить задержанный ACK ), предотвращение перегрузки сети или достаточно большая потеря пакетов, что мы должны учитывать несколько потери пакетов (включая потерянные Ack и DupAck). С помощью UDP мы можем легко написать более быстрый код, потому что нам просто не важно быть хорошим сетевым гражданином, как это делает TCP.
TCP и UDP: различия
TCP и UDP — два важных протокола транспортного уровня, управляющих Интернетом. Оба являются частью набора протоколов TCP / IP. В этом руководстве мы исследуем различия между этими двумя протоколами.
Прежде чем мы начнем разбираться в разнице между TCP и UDP, давайте кратко рассмотрим модели сетей OSI и TCP / IP.
Обзор OSI и TCP / IP
Сетевая архитектура OSI и TCP / IP — две известные эталонные модели сети. Модель OSI была разработана Международной организацией по стандартизации (ISO). В 1984 году она была принята в качестве эталонной модели. Модель OSI в основном определяет семиуровневый канал связи между системой. Эти уровни функционируют таким образом, чтобы предоставлять услуги более высокому уровню. Функции этих уровней кратко описаны ниже:
Физический уровень — его основная функция заключается в передаче битов данных на физическом носителе, таком как кабели, сетевые карты, концентраторы и т.д.
Уровень канала передачи данных DLL кодирует биты данных в пакеты перед их передачей. Данные декодируются обратно в биты на приемнике. Другие функции включают управление логическим соединением, обнаружение ошибок, надежную передачу данных и т.д.
Сетевой уровень — отвечает за маршрутизацию пакетов данных в двух разных сетях с использованием IP (Интернет-протокола). Уровень канала данных направляет данные только в локальную сеть.
Транспортный уровень — транспортный уровень обеспечивает надежную и прозрачную передачу данных между сквозными устройствами. Помимо сегментации данных, транспортный уровень определяет тип услуги, которая должна быть предоставлена вышележащим и нижним уровням.
Сеансовый уровень — он связан с такими аспектами управления соединением, как установление и завершение соединения, продолжительность сеанса, синхронизация данных между конечными устройствами с использованием контрольных точек.
Уровень представления — он форматирует данные таким образом, чтобы их могла использовать принимающая сторона. Другие функции, которые здесь работают, — это сжатие и шифрование данных и т.д.
Уровень приложения — он содержит различные службы связи, такие как передача файлов, SMTP, SSH, FTP и электронная почта. Он действует как интерфейс между пользовательскими приложениями, такими как браузеры, удаленный вход и т.д.
TCP / IP — это комбинация двух протоколов: протокола управления передачей и Интернет-протокола. Это основа современного Интернета. Целью TCP является обеспечение надежной передачи пакетов данных путем предоставления механизма контроля ошибок и проверки доставки пакетов данных в последовательности. TCP использует IP для разделения больших потоков данных на более мелкие пакеты и маршрутизации этих пакетов. Есть небольшие различия между уровнями модели OSI и модели TCP / IP. Например, уровни представления и сеанса объединены в его прикладной уровень в TCP / IP. Интернет-уровень соответствует сетевому уровню в модели OSI. Протокол IP является основной частью этого уровня. Кроме того, TCP / IP объединяет канал передачи данных OSI и физические уровни в один уровень, называемый уровнем доступа к сети.
Отличия TCP от UDP
После того, как мы получили быстрый обзор модели OSI и TCP / IP, мы теперь увидим разницу между двумя протоколами транспортного уровня. Ниже мы суммировали основные отличия:
Помимо этих различий, для этих двух протоколов существуют некоторые общие ограничения, например:
Многопоточностьневозможна с TCP и UDP. SCTP или протокол передачи управления потоком преодолевают эту проблему за счет параллельной передачи нескольких потоков данных.
Множественная адресация(с использованием нескольких интернет-провайдеров) также невозможна с TCP и UDP.
Какой использовать: TCP или UDP
Это очевидный вопрос, который может возникнуть у нас в голове. Выбор использования одного по сравнению с другим зависит от требований для конкретной цели. Приложение, которое требует быстрой и непрерывной передачи данных, не заботясь о надежности, тогда выбор будет UDP. В противном случае, если вам нужна надежная передача данных и вы беспокоитесь о том, чтобы не потерять их во время передачи, выберите TCP.
Например, UDP отлично работает при использовании для чувствительных ко времени приложений, таких как игры, поиск DNS, VoIP и т.д. Если вы используете TCP здесь, задержка, вызванная во время передачи, значительно повлияет на производительность этих служб. TCP может использоваться для приложений передачи файлов, приложений чата, SMTP и т.д. В случае OpenVPN можно использовать оба из них.
TCP против UDP или будущее сетевых протоколов
Перед каждым сервисом, генерирующим хотя бы 1 Мбит/сек трафика в интернете возникает вопрос: «Как? по TCP или по UDP?» В прикладных областях, в том числе и платформах доставки уже сложились предпочтения и традиции принятия подобных решений.
По идее, если бы, к примеру, однажды один ленивый разработчик не попробовал развернуть свой ML на Python (потому что только его и знал), мир скорее всего никогда не проникся бы такой любовью к презренному «супер-джава-кодерами» языку. А сегодня слабости этого языка в прошлом контексте применения безоговорочно обеспечивают ему первенство в развертывании и запуске многочисленных майнерских А/Б.
Сравнивать можно многое: ARM с Intel, iOS и Android, а Mortal Kombat с Injustice. И нарваться на космический холивар, поэтому вернемся к теме доставки огромных объемов разноформатного контента.
Десять лет назад все были абсолютно уверены, UDP — это что-то про негарантированную доставку. Если нужен надежный протокол — это TCP. И вопреки традициям в этой статье мы будем сравнивать такие, кажущиеся несравнимыми вещи, как TCP и UDP.
Осторожно, под катом 99 иллюстраций и схем и все важные.
Сравнение проводит руководитель разработки платформ Видео и Лента в OK Александр Тоболь (alatobol). Сервисы Видео и Лента Новостей в соцсети ОК — исключительно про контент и его доставку на все существующие клиентские платформы в сколько угодно плохих или отличных условиях сети, и вопрос, как его доставлять — по TCP или по UDP — имеет решающее значение.
TCP vs UDP. Минимум теории
Чтобы перейти к сравнению, нам потребуется немного базовой теории.
Что мы знаем об IP сетях? Поток данных, который вы отправляете, разбивается на пакеты, какой-то черный ящик доставляет эти пакеты до клиента. Клиент собирает пакеты и получает поток данных. Обычно это все прозрачно и нет необходимости думать, что там на нижних уровнях.
На схеме представлены TCP/IP и UDP/IP стек. Внизу есть Ethernet-пакеты, IP-пакеты, и дальше на уровне ОС есть TCP и UDP. TCP и UDP в этом стеке не сильно друг от друга отличаются. Они инкапсулируются в IP-пакеты, и приложения могут ими пользоваться. Чтобы увидеть отличия, нужно посмотреть внутрь TCP- и UDP-пакета.
И там, и там есть порты. Но в UDP есть только контрольная сумма — длина пакета, этот протокол максимально простой. А в TCP — очень много данных, которые явно указывают окно, acknowledgement, sequence, пакеты и так далее. Очевидно, TCP более сложный.
Если говорить очень грубо, то TCP — это протокол надежной доставки, а UDP — ненадежной.
И всё же, несмотря на заявленную ненадёжность UDP, мы разберём, возможно ли доставить данные быстрее и надежнее чем с использованием TCP. Попробуем посмотреть на сеть изнутри и понять, как она работает. Попутно затронем следующие вопросы:
Зачем сравнивать TCP или что с ним не так
TCP придумали в 1974 году, а лет через 20, когда я пошел в школу, я покупал интернет-карты, стирал код и куда-то звонил. Причем, если звонить с 2 ночи до 7 утра, то интернет был бесплатный, но дозвониться было трудно.
Прошло еще 20 лет, и пользователи на мобильных беспроводных сетях стали превалировать над «проводными» пользователями, при этом TCP концептуально не менялся.
Мобильный мир победил, появились беспроводные протоколы, а TCP был по-прежнему неизменен.
Сегодня 80% пользователей используют Wi-Fi или беспроводную 3G-4G сеть.
В беспроводных сетях существуют:
Ниже на карте средняя скорость получения данных по TCP в России. Если убрать западную часть, то видно, что скорость измеряется скорее в килобитах, чем в мегабитах.
То есть в среднем у наших пользователей (если исключить западную часть России): пропускная способность 1,1 Мбит/сек, 0,6 % packet loss, RTT (round-trip time) порядка 200 мс.
Как вычислить RTT
Когда я увидел среднее в 200мс, подумал что в статистике ошибка, и решил измерить RTT до наших серверов в МСК альтернативным способом с помощью RIPE Atlas. Это система сбора данных о состоянии Интернета. Устройство зонд от RIPE Atlas можно получить бесплатно.
Суть в том, что вы подключаете ее к домашнему интернету и собираете «карму». Она сутками работает, какие-то люди выполняют на ней какие-то свои запросы. Потом вы можете сами ставить различные задачи. Пример такой задачи: случайно взять 30 точек в интернете, и попросить померить RTT, то есть выполнить команду ping до сайта Одноклассники.
Как ни странно, среди случайных точек много таких, у которых ping от 200 до 300 мс.
Итого, беспроводные сети популярны и нестабильны (хотя последнее обычно игнорируется, так как считается, что с этим справляется TCP):
Потребление контента зависит от скорости интернета
Это очень легко проверить — есть много статистических данных. Я взял статистику по видео, которая говорит, что чем выше скорость интернета в стране, тем больше пользователи смотрят видео.
Согласно этой статистике в России достаточно быстрый Интернет, однако по нашим внутренним данным средняя скорость несколько ниже.
В пользу того, что скорость интернета в целом недостаточная, говорит то, что все создатели крупных приложений, социальных сетей, видеосервисов и так далее оптимизируют свои сервисы для работы в плохой сети. Уже после 10 Кбайт полученных данных можно увидеть минимум информации в ленте, а на скорости 500 Кбит можно смотреть видео.
Как ускорить загрузку
В процессе разработки платформы Видео, мы поняли, что TCP не очень эффективен в беспроводных сетях. Как пришли к такому выводу?
Мы решили ускорить загрузку и сделали следующий трюк.
Грузили видео с клиента на сервер, в несколько потоков, то есть 40 Мбайт делим на 4 части по 10 Мбайт и загружаем их параллельно. Запустили это на Android и получили, что параллельно загружается быстрее, чем в одно соединение (демо в докладе). Самое интересное, что когда мы выкатили параллельную загрузку в продакшен, то увидели, что в некоторых регионах скорость загрузки выросла в 3 раза!
По четырем TCP-соединениям реально можно загрузить данные на сервер в 3 раза быстрее.
Так мы повысили скорость загрузки видео и сделали вывод, что загрузку нужно распараллеливать.
TCP в нестабильных сетях
Невероятный эффект с параллелизмом можно потрогать. Достаточно взять измеритель скорости получения/отправки данных (например Speed Test) и трафик шейпер (например network link Conditioner, если у вас Mac) Ограничиваем сеть параметрами 1 Мбит/сек на upload и download и начинаем растить потерю пакетов.
В таблице указаны RTT и потери. Видно, что в случае 0% потерь, сеть утилизирована на 100%.
Следующей итерацией увеличиваем packet loss на 5%, и видим, что сеть утилизируется всего на 74%. Вроде ничего страшного — при packet loss в 5% теряется 26% сети. Но если увеличить еще и ping, то останется меньше половины канала.
Если канал с высоким RTT и большим packet loss, то одно TCP соединение не полностью утилизирует сеть.
Дальнейший трюк показывает, что если начать использовать параллельные TCP-соединения (вы можете просто запустить несколько Speed Test-ов одновременно), виден обратный рост утилизации канала.
С увеличением числа параллельных TCP-соединений утилизация сети становится почти равной пропускной способности, за вычетом процента потерь.
Таким образом, получилось:
TCP vs не ТСР
С чем сравнить тёплое? Есть два варианта.
Первый вариант — на уровне IP есть TCP и UDP, мы можем позволить себе еще какой-то протокол сверху. Очевидно, что если параллельно с TCP и UDP запустить свой протокол, то про него не будут знать Firewall, Brandmauer, маршрутизаторы и весь остальной мир, участвующий в доставке пакетов. В итоге придется годами ждать, когда все оборудование обновится и начнет работать с новым протоколом.
Второй вариант — сделать свой надежный протокол доставки данных поверх ненадежного UDP. Очевидно, что ждать, пока Linux, Android и iOS добавят новый протокол в свое ядро можно долго, поэтому надо пилить протокол в User Space.
Такое решение кажется интересным, будем называть его self-made UDP-протокол. Чтобы начать его разрабатывать, не нужно ничего особенного: просто открываем UDP socket и отправляем данные.
Будем его развивать, параллельно изучая, как работает сеть.
TCP vs self-made UDP
Хорошо, а на чем сравнивать?
Сети бывают разные:
Кроме профилей сети, нужно еще определиться с профилем потребления трафика. Вот те, которые использовали мы:
Так как я отвечаю за Видео и Ленту, то профили соответствующие:
HTTP 1.1 и HTTP 2.0
Стандартный стек 2000-х выглядел как HTTP 1.1 поверх SSL. Современный стек — это HTTP 2.0, TLS 1.3, и все это поверх TCP.
Основное отличие в том, что HTTP 1.1 использует ограниченный пул соединений в браузере к одному домену, поэтому делают отдельный домен для картинок, для данных и так далее. HTTP 2.0 предлагает одно мультиплексированное соединение, в котором передаются все эти данные.
HTTP 1.1 работает так: делаете запрос, получаете данные, делаете запрос, получаете данные.
Обычно браузер или мобильное приложение пулит, то есть соединение на получение картинок, данных по API, и вы параллельно выполняете запрос за картинкой, за API, за видео и так далее.
Основная проблема — конкуренция. Вы никак не управляете отправленными запросами. Вы понимаете, что пользователю уже не нужна картинка, которую он пролистал, но ничего не можете сделать.
С HTTP 1.1 вы все равно получаете то, что запросили, отменить загрузку трудно.
Единственный шанс — socket close — это закрыть соединение. Дальше увидим, почему это плохо.
Отличия HTTP 2.0
HTTP 2.0 решает эти проблемы:
Запрашиваем картинку и API. Картинка сразу отдается, API подготовился через некоторое время. Отдался API — отдалась до конца картинка. Все это происходит прозрачно. Высокоприоритетный контент загружается раньше.
Server push — это такая штука, когда вы попросили что-то конкретное типа API, но еще в нагрузку на клиенте закэшировались картинки, которые точно понадобятся для просмотра, например, ленты.
Еще есть команда Reset stream, которую браузер выполняет сам, если вы переходите между страницами и т.д. Для мобильного клиента с её помощью можно отказаться от получения данных, при этом не разрывая соединение.
Таким образом будем сравнивать TCP на разных:
Модель без потерь
Начнем сравнение с простой сетью, в которой существует только два параметра: round-trip time и bandwidth.
RTT — это ping, время оборота пакета, получения acknowledgement или время эха на response.
Чтобы измерить bandwidth — пропускную способность сети — отправляем пачку пакетов и считаем количество прошедших пакетов на каком-то временном интервале.
Так как мы работаем с надежными протоколами, то, конечно, есть acknowledgement — отправляем пакеты и получаем подтверждение о получении.
Задача про медленный интернет
На заре разработки нашего видеосервиса в 2013 году мой друг поехал в Калифорнию и решил посмотреть новую серию своего любимого сериала на Одноклассниках. У него был RTT в 250 мс, идеальный Wi-Fi 400 Мбит/с в кампусе Google, он хотел посмотреть новую серию всего лишь в FullHD.
Как вы думаете, смог ли он посмотреть видео? Ответ зависит от настройки send/recv buffer на наших серверах.
Так как у нас протокол с acknowledgement, то все данные, которые не получили подтверждения о доставке, хранятся в буфере. Если send buffer ограничен 128 Кб, то эти 128 Кб меньше, чем за RTT, мы отправить не можем. Таким образом, от нашей сети в 400 Мбит/с осталось 4 Мбит/с. Этого недостаточно, чтобы онлайн смотреть видео в FullHD.
Тогда я потюнил размер буфера и посмотрел, как действительно меняется скорость отдачи одного сегмента видео в зависимости от изменения размера буфера. Сразу оговорюсь, что recv buffer подстраивался автоматически, т.е. то, что отправлял сервер, клиент всегда мог принять.
Очевидный рецепт TCP: если передаёте высокоскоростные данные на большие расстояния, нужно увеличить буфер отправки.
Кажется, все неплохо. Можно зайти на сервис fast.com, который померяет скорость вашего интернет до серверов Netflix. Из офиса я получил скорость 210 Мбит/с. А потом через net shaper настроил условия задачи и зашел на этот сайт еще раз. Магия — я получил 4 Мбит/с ровно.
Как я ни крутил, не получилось от Netflix добиться буфера больше 128 Кбайт.
Размер буфера
Для того чтобы разобраться с оптимальным размером буфера, нужно понять, что такое On-the-fly packets.
Есть состояние сети:
Если количество пакетов в On-the-fly равно размеру буфера, то он недостаточного размера. В этом случае сеть голодает, не до конца используется.
Возможна обратная ситуация — слишком большой буфер. В этом случае происходит распухание буфера. Чем это плохо?
Если говорить про мультиплексирование данных и отправлять несколько запросов одновременно, например, картинки в это же соединение и API, то когда вся огромная мегабайтная картинка влезла в буфер, а мы пытаемся запихнуть еще и высокоприоритетный API, то буфер распухает. Придется очень долго ждать, когда картинка уйдет.
Простым решением является автоматическая настройка размера буфера. Сейчас это доступно на многих клиентах и работает примерно так.
Если сейчас может быть отправлено много пакетов, буфер увеличивается, передача данных ускоряется, размер буфера растет, вроде бы все здорово.
Но есть проблема. Если буфер увеличился, его нельзя так просто уменьшить. Это более сложная задача. Если скорость проседает, то происходит то самое распухание буфера. Буфер довольно большой и весь заполнен, нам нужно ждать, пока все данные отправятся на клиент.
Если мы пишем свой UDP-протокол, то все очень просто — у нас есть доступ к буферу.
Если TCP в таких ситуациях просто добавляет данные в конец, и вы ничего не можете сделать, то в self-made протоколе можно помещать данные, например, вперед, сразу же за On-the-fly packets.
А если придет cancel, и клиент скажет, что эта картинка больше не нужна, ему нужны API данные, он пролистал контент дальше, можно все это выбросить из буфера и отправить нужное.
Как это делается? Известно, что чтобы восстанавливать пакеты, управлять доставкой, получать acknowledgements, нужен какой-то sequence_id пакетов. Sequence_id мы выписывается только для on-the-fly packets, то есть выдаем его только, когда отправляем пакеты. Все остальное в буфере можно передвигать как хотим до тех пор, пока пакеты не ушли.
Вывод: в TCP буфер надо правильно настроить, поймать баланс, чтобы не упираться в сеть и не раздувать буфер. Для собственного UDP-протокола все просто — этим можно управлять.
Модель сети с потерями
Передвигаемся на уровень выше, сеть становится чуть-чуть сложнее, в ней появляется packet loss. Для мобильных сетей это обычная ситуация. Часть из отправленных пакетов не доходит до клиента. Стандартный алгоритм восстановления retransmit работает примерно так:
Отправляет пакеты, на каждый пакет получает acknowledgement. Если через Retransmit timeout (RTO) равному RTT плюс некоторые константы подтверждения нет, то перепосылает пакет.
Вернемся к кривой неэффективности TCP, когда теряется всего 5% пакетов, а утилизация сети равна 50%.
При retransmit, который просто досылает пакеты, мы не должны наблюдать такую проблему. Чтобы разобраться в причинах, нужно понять, что такое Congestion control.
Congestion control
Его очень часто путают с flow control, поэтому рассмотрим их оба.
Если перегрузить сеть, то вполне вероятна такая ситуация: посылаете данные, часть пакетов не доходит, посылаете еще больше данных, и все эти данные опять пропадают. За то чтобы лимитировать выдачу данных некоторыми порциями, как раз и отвечает congestion control.
Существует так называемый TCP window.
Это некоторый минимум из flow control и congestion control, то есть явно не превышает эти значения.
Если происходит перегрузка сети, пропадают пакеты, то окно обратно сужается и начинает разгоняться заново.
Как при этом выглядит сеть?
Маршрутизатор немножко умный, он не дожидается перегрузки, и сразу дропает. У него есть механизм тикетов: он выдает тикет на отправку, если канал освободится и т.д. Суть механизма в том, что он дропает пакеты чуть раньше. Тогда срабатывает congestion control, схлопывает TCP window, нагрузка на маршрутизатор падает, и все продолжает работать.
Так работали старые механизмы congestion control, которые были уверены, что сеть — это картинка сверху. На самом деле не любой packet loss — следствие того, что сеть перегружена. У нас есть сети как на нижней картинке, про которые говорят, что в них потеря пакетов ничего не значит — это просто такая сеть, потому что она беспроводная.
Понятно, что TCP развивался, адаптировался, и первый congestion control оперировал только loss-функцией. После этого появились congestion control на loss delay, то есть и на потери, и на задержки.
BBR Congestion Control
Посмотрим на Cubic и BBR по методам feedback.
На схеме сверху нормальный маршрутизатор и маршрутизатор, у которого очередь начинает копиться — каждый следующий acknowledgement приходит всё дольше и дольше относительно отправки. В этом случае:
BBR вначале прощупывает время round-trip, отправляет больше и больше пакетов, потом понимает, что буфер забивается, и выходит на режим работы с минимальной задержкой.
Cubic работает агрессивно — он переполняет целиком буфер, и, когда буфер переполняется и случается packet loss, то cubic уменьшает окно.
Кажется, что с помощью BBR можно было бы решить все проблемы, но в сетях существует jitter — пакеты иногда задерживаются, иногда группируются пачками. Вы их отправляете с определенной частотой, а они приходят группами. Еще хуже, когда вы получаете acknowledgements обратно на эти пакеты, и они тоже как-то «jitter’ятся».
Так как я обещал, что все можно будет потрогать руками, то пингуем, например, сайт HighLoad++, смотрим ping и считаем jitter между пакетами.
Видно, что пакеты приходят неравномерно, средний jitter порядка 50 мс. Естественно, BBR может при этом ошибиться.
BBR хорош тем, что различает: реальный congestion loss, потерю пакетов в виду переполнения буферов устройств, и random loss из-за плохой беспроводной сети. Но плохо работает в случае высокого jitter. Как можно ему помочь?
Как сделать Congestion control лучше
На самом деле у TCP в acknowledgement достаточно мало информации, в ней есть только то, какие пакеты он видел. Есть еще selective acknowledgement, в котором говорится, какие пакеты подтверждены, какие еще не дошли. Но и этой информации недостаточно.
Если вы имеете возможность раздуть acknowledgement, то можете еще сохранить все времена — не только отправки этих пакетов, но и прихода их на клиент. То есть, по сути, на сервере собрать jitter клиента.
Почему вообще эффективно раздувать acknowledgement? Потому что мобильные сети асимметричны. Например, обычно у 3G или LTE 70% пропускной способности выделяется на скачивание данных и 30% — на upload. Передатчик переключается: upload — download, upload — download, и вы на это никак не влияете. Если вы ничего не выгружаете, то он просто простаивает. Поэтому если у вас есть какие-то интересные идеи, увеличивайте acknowledgement, не стесняйтесь — это не проблема.
Пример того, как можно с помощью acknowledgement поделить jitter на отправку и jitter на прием, и отслеживать их отдельно. Тогда мы становимся более гибкими, и понимаем, когда произошел congestion loss, а когда random loss. Например, можно понять, сколько jitter в каждую сторону, и более точно настроить окно.
Какой Congestion control выбрать
Одноклассники — большая сеть, в которой много разного трафика: видео, API, картинки. И есть статистика, какие congestion control для чего лучше выбрать.
BBR всегда эффективен для видео, потому что уменьшает задержки. В остальных случаях обычно используется Cubic — он хорош для фотографий. Но есть другие варианты.
Есть десятки разных вариантов congestion control. Для того чтобы выбрать лучший, можно собрать статистику по клиенту и для разного типа профиля нагрузки попробовать тот или иной congestion control.
Например, это эффект от запуска BBR на видео.
Нам удалось серьезно увеличить глубину просмотра. Google говорит, что у них примерно на 10% уменьшается количество буферизации в плеере при использовании BBR.
Здорово, но что у нас на клиентах?
Клиенты немножко заторможенные, у них у всех Cubic, и вы на это не можете повлиять. Но ничего страшного, иногда можно параллелить данные, и будет хорошо.
Выводы про congestion control:
Если вы делаете свой UDP-протокол, у вас гораздо больше свободы с точки зрения congestion control.
Мультиплексирование и приоритизация
Это новый тренд, все сейчас этим занимаются. Какие здесь есть проблемы? Если мы используем TCP, наверняка все (или почти все) знают ситуацию head-of-line blocking.
Есть несколько запросов, которые мультиплексируются через одно TCP-соединение. Мы их отправили в сеть, но какой-то пакет пропал. TCP-соединение будет этот пакет ретрансмитить, он заретрансмитится за время, близкое к RTT или больше. В это время мы ничего получить не сможем, хотя в TCP-буфере находятся данные от другого запроса, полностью готовые к тому, чтобы их можно было забрать.
Получается, что мультиплексирование поверх TCP, если вы используете HTTP 2.0, не всегда эффективно в плохих сетях.
Следующая проблема — это распухание буфера.
Когда картинка отправляется клиенту, увеличивается буфер. Мы его долго отправляем, а потом появляется API-запрос, и он никак не может быть приоритизирован. В таких случаях не работает TCP-приоритизация.
Таким образом, если случается потеря пакетов, есть head-of-Line blocking, а когда у клиента переменный битрейт (а у мобильных клиентов это бывает часто), то появляется эффект bufferbloat. В итоге не работает ни мультиплексирование, ни приоритизация, ни server push, ни все остальное, потому что у нас или забиты буферы, или клиент что-то ожидает.
Если мы делаем свое мультиплексирование, то можем поместить туда различные данные.
Это нетрудно, просто складываем в буфер пакеты с номерами. On-the-fly — то, что уже было отправлено, не трогаем, а то, что еще не отправлено, можно переставлять. Выглядит это так.
Отправили картинки, разбили на пакеты, пришел приоритетный API-запрос: его вставили, дослали картинку. Даже если пропал пакет, мы из буфера можем достать готовый API-запрос, он высокоприоритетный и быстро дойдет до клиента. В TCP по определению при стриминговой передаче данных такое невозможно.
Установка соединения
Если попрофилировать наше приложение, то мы увидим, что большую часть времени на старте приложения сеть простаивает, потому что сначала устанавливается соединение до API, потом мы получаем данные, потом устанавливается соединение до картинок, скачиваются эти данные и т.д. Так всегда и происходит — сеть утилизируется пиками.
Чтобы с этим разобраться, посмотрим, как устанавливается соединение.
Первое — это resolve DNS — с этим мы ничего сделать не можем. Дальше установка TCP-соединения, установка безопасного соединения, потом выполнение запроса и получение ответа. Самое интересное, что часть работы, которую выполняет сервер, отвечая на запрос, обычно занимает меньше времени, чем установка соединения.
Сейчас очень модно измерять latency numbers для памяти, для дисков, еще для чего-то. Можно их для сети 3G, 4G измерить и увидеть, сколько займет в худшем случае установка соединения по TCP с TLS.
И это могут быть секунды! Даже на 4G до 700 мс –тоже существенно. Но TCP не мог так просто все это время жить.
В установке соединения базовый алгоритм TCP 3-way handshake. Делаете syn, syn + ack, подправляете уже потом запрос (слева на схеме).
Есть TCP Fast Open (справа). Если вы с этим сервером уже хэндшейкились, есть cookie, можно сразу за zero-RTT отправить свой запрос. Чтобы этим воспользоваться, нужно создать socket, сделать sendto() первых данных, сказать, что вы хотите FASTOPEN.
Nginx все это умеет — просто включите, все будет работать (или в ядре включите).
Давайте проверим, что TLS — это плохо.
Я опять настроил net shaper на 200 мс, попинговал google.com и увидел, что RTT = 220 – мой RTT + RTT shaper. Потом сделал запрос по HTTP и HTTPS. Выяснил, что по HTTP можно за время RTT получить ответ, то есть TFO работает для Google с моего компьютера. Для HTTPS это заняло больше времени.
Это такие обычные накладные расходы TLS, который требует обмен сообщениями для того, чтобы установить безопасное соединение.
Для этого за нас подумали, добавили TLS 1.3. Его тоже легко включить в nginx.
Кажется, что все работает. Но давайте посмотрим, что там на наших мобильных клиентах, которые всем этим пользуются.
Что там у клиентов
TCP Fast Open — классная штука. По статистике.
Есть много статей, которые говорят, что установка соединения гарантированно пройдет быстрее на 10%. Но на Android 8.1.0 (я смотрел различные устройства) ни у кого нет TFO. На Android 9 я видел TFO на эмуляторе, но не не реальных устройствах. С iOS чуть получше. Вот так это можно посмотреть:
Почему так произошло? TCP Fast Open предложили еще в 2014 году, теперь он уже стандарт, поддерживается в Linux и все здорово. Но есть такая проблема, что TFO handshake стали в некоторых сетях разваливаться. Это происходит потому, что некоторые провайдеры (или какие-то устройства) привыкли инспектировать TCP, делать свои оптимизации, и не ожидали, что там будет TFO handshake. Поэтому его внедрение заняло так много времени, и до сих пор мобильные клиенты его не включают по умолчанию, по крайне мере, Android.
С TLS 1.3, который нам обещает zero-RTT установки соединений еще лучше. Я не нашел устройств на Android, на котором бы он работал. Поэтому Facebook сделал библиотеку Fizz. Пару месяцев назад она стала доступна в опенсорсе, ее можно притащить с собой и использовать TLS 1.3. Получается, что даже безопасность нужно тащить с собой, в ядре этого ничего не появляется.
На диаграмме представлено использование нашими мобильными клиентами различных версий Android. V 9.x совсем немного — там, где TFO может появиться, а TLS1.3 пока нет нигде.
Выводы про установку соединения:
Выяснилось, что 97% создаваемых соединений используют уже имеющийся ключ, то есть 97% создается за zero RTT, и только 3% новых. Ключ какое-то время хранится на устройстве.
TCP этим похвастаться не может. Максимум в 5% случаев, если вы все сделаете правильно, вам удастся получить настоящий zero-RTT, о котором сейчас все разговаривают.
Смена IP-адреса
Часто, когда вы уходите из дома, ваш телефон переключается с Wi-Fi на 4G.
TCP работает так: сменился IP-адрес — соединение развалилось.
Если вы пишите свой UDP протокол, то очень просто, внедряя в каждый пакет connection ID (CUID), вы сможете его идентифицировать, даже если он пришел с другого IP-адреса.
Понятно, что надо удостовериться в безопасности, что у него правильный ключ, все расшифровывается, и т.д. Но в принципе вы можете начать отвечать на этот адрес, проблем с этим не будет.
В TCP IP Migration — это невозможная вещь.
Если вы делаете свой UDP, и пришли на тот же самый сервер, нужно немножко поколдовать, включить CID в каждый пакет, и вам удастся использовать установленное соединение при смене IP адреса.
Connection reuse
Все говорят, что нужно переиспользовать соединения, потому что соединения — очень дорогая вещь.
Но в переиспользовании соединения есть подводные камни.
Наверное, многие помнят (если нет, то см. сюда), что не у всех публичные адреса, а есть NAT, который обычно на домашнем роутере хранит какое-то время mapping. Для TCP понятно, сколько хранить, а для UDP — непонятно. NAT оперирует timeout, если аккуратно измерить этот timeout, то получим, что примерно за 15-30 секунд более 50% соединений начнут разрушаться.
Ничего страшного — сделаем ping-pong пакета по 15 с. Для случаев, когда соединение таки разрушилось, есть IP Migration, который недорого позволит сменить порт на маршрутизаторе.
Packet pacing
Это очень важная вещь, если вы делаете свой UDP-протокол.
Если очень просто, то чем дольше вы непрерывно посылаете пакеты в сеть, тем больше вероятность packet loss. Если пакеты проредить, то packet loss будет ниже.
Есть много разных теорий, как это работает, но мне нравится эта.
Есть 3 соединения, которые создаются в один момент времени. У вас есть так называемый initial window — 10 пакетов, создаваемых одновременно. Конечно, в этот момент может не хватить bandwidth. Но если их аккуратно распределить, разделить, то все будет отлично, как на правом рисунке.
Таким образом, если задавать равномерный темп отправки пакетов, прореживать их, то вероятность того, что будет единомоментное переполнение буферов, станет ниже. Это не доказано, но теоретически получается так.
Когда нужно прорежать пакеты (делать pacing):
При написании своего UDP-протокола обязательно нужно помнить про MTU. MTU — это размер данных, которые вы можете переправить.
Отправляем пакеты с сервера на клиент, например, размером 1500. Если на пути встречается маршрутизатор, который не поддерживает этот размер MTU, он его фрагментирует. Единственная проблема фрагментации в том, что если потеряется один пакет, потеряются оба, и придется все это ретрасмитить. Поэтому в TCP есть алгоритм определения MTU — PMTU.
Каждый маршрутизатор смотрит MTU своего интерфейса, отправляет его одному клиенту, другой отправляет своему клиенту, все знают, сколько у них MTU на клиенте. Потом флагом запрещается фрагментация и отправляются пакеты размером MTU. Если в этот момент кто-то внутри сети поймет, что у него MTU меньше, то по ICMP сообщит: «Извините, пакет пропал, потому что нужна фрагментация» и укажет размер MTU. Мы поменяем этот размер и продолжим отправку. В худшем случае наш небольшой overhead — это RTT/2. Это в TCP.
Если в UDP вам не охота заморачиваться с ICMP, то можно сделать следующее: при отправке обычных данных разрешить фрагментацию. То есть посылать фрагментированные пакеты — пусть они работают. А параллельно запустить процесс, который запретит фрагментацию, бинарным поиском подберет оптимальное MTU, на которое мы потом выйдем. Это не совсем эффективно, потому что вначале MTU будет как бы прогреваться.
Более хитрый вариант — посмотреть распределение MTU по мобильным клиентам.
Со всех клиентов мы отправили пакеты различного размера с запретом фрагментации. То есть если пакет не дойдет, он дропнется, а самый маленький MTU должен доходить стопроцентно. Но есть небольшой packet loss, поэтому на графике есть две горки:
На самом деле можно сказать так: пренебрежем 1-2% наших клиентов, пусть они живут на фрагментированных пакетах. Зато мы сразу будем стартовать с того, с чего надо — это с 1350.
Исправление ошибок (SACK, NACK, FEC)
Если вы делаете свой протокол, вам нужно исправлять ошибки. Если пакет пропал (для беспроводных сетей это нормально), его нужно восстановить.
В самом простом случае (подробнее тут), есть ретрансмит через Retransmit Time Out (RTO). Если пакет пропал, ждем время ретрансмита и отправляем его заново.
Следующий алгоритм — это Fast retransmit. Это все алгоритмы TCP, но их можно легко перенести в UDP.
Когда пакет пропал, мы продолжаем посылать — есть передача других пакетов. В это время сервер говорит, что он получил следующий пакет, но предыдущего не было. Для этого он делает хитрый acknowledgement, который равен номеру пакета + 1, и выставляет флаг duplicate ack. Он так эти dup ack посылает, и на третьем мы обычно понимаем, что пакет пропал и посылаем его заново.
Что еще хочется классного сделать, чего нет в TCP и что предлагают делать в UDP — это Forward Error Correction.
Кажется, что если мы знаем, что пакеты могут пропасть, мы можем взять набор пакетов, добавить к нему XOR-пакет и починить проблему без дополнительных ретрансмитов сразу на клиенте при получении данных. Но есть проблема, если пропадет несколько пакетов. Кажется, что ее можно решить через parity protection, Reed-Solomon и т.д.
Мы так пробовали, у нас получилось, что на самом деле пакеты пропадают пачками.
Средний packet gap получился 6. Это очень неудобный packet gap — нужно очень много кодов исправления ошибок. При этом есть какой-то пик на 11 — не знаю почему, но пакеты иногда пачками по 11 пропадают. Из-за этого packet gap это не работает.
Google такое тоже пробовал, все грезят FEC, но пока ни у кого не заработало.
Есть еще следующий вариант, когда FEC может помочь.
Кроме ретрансмита через Retransmit Time Out, Fast Retransmit, есть еще tail loss probe. Это такая штука, когда вы шлете данные, и хвостик пропал. То есть вы послали часть данных, послали пятый пакет — он дошел. Потом начали пропадать пакеты, например, потому что сеть провалилась. Пакеты пропадают, пропадают, и вы получили acknowledgement только на пятый пакет.
Чтобы понять, дошли ли эти данные, вы через какое-то время начинаете делать TLP (tail loss probe), спрашивать, а получен ли конец. Дело в том, что пересылка данных закончилась, и вы ничего не шлете, то Fast Retransmit не сработает. Чтобы это починить, делайте TLP.
К TLP можно добавить FEC. Вы можете посмотреть все пакеты, которые не пришли, посчитать по ним parity и делать отправку TLP с некоторым parity-пакетом.
Это все классно, кажется, должно работать. Но есть такая проблема.
Мы собрали статистику, и получилось, что 98% ошибок чинится через Fast Retransmit. Остальное чинится через Retransmit Time Out, и меньше 1% — через TLP. Если вы еще что-то почините FEC, это будет меньше, чем 0,5%.
TCP не поддерживает FEC. В UDP не трудно это сделать, но в общем случае стандартных алгоритмов восстановления TCP хватает.
Performance
Нельзя было бы не задеть performance, сравнивая TCP с UDP.
TCP — очень старый протокол с большим количеством различных оптимизаций, например, LSO (large segment offload) и zerocopy. Сейчас для UDP это все недоступно. Поэтому производительность UDP всего 20% относительно TCP с тех же серверов. Но уже есть готовые решения (UDP GSO, zerocopy), которые позволяют в Linux поддержать это.
Основная проблема поддержки оптимизации по zerocopy и LSO в том, что теряется pacing.
Time to market или что убило TCP
В последнее время, когда стали популярны мобильные беспроводные сети, появилось много различных стандартов TCP: TLP, TFO, новые Congestion control, RACK, BBR и прочее.
Но основная проблема в том, что многие из них не внедряются, потому что TCP, как говорят, окостенел. Во многих случаях операторы заглядывают в TCP пакеты и ожидают увидеть то, что они ожидают. Поэтому его очень трудно менять.
К тому же мобильные клиенты обновляются долго, и мы не можем доставить эти обновления. Если посмотреть, что из последних свежих обновлений доступно на клиенте, а что на сервере, можно сказать, что на клиенте почти ничего.
Поэтому решение написать протокол в user space, по крайней мере пока вы все эти фичи накапливаете, кажется не таким плохим.
С TCP фичи раскатываются годами. Для своего UDP-протокола, вы можете обновить версию буквально за один апдейт клиента и сервера. Но надо будет добавить version negotiation.
TCP vs self-made UDP. Final fighting
Тестирование self-made UDP на пользователях
Мы собрали тестовый стенд.
Есть клиент на TCP и на UDP. Нормировали трафик через net shaper, отправили в интернет и на сервер. Один сервис REST API, второй с UDP. Причём UDP ходит на тот же REST API внутри одного дата-центра, чтобы проверить данные. Собрали разные профили наших мобильных клиентов и запустили тест.
Измерив среднее по порталу, мы увидели, что мы смогли уменьшить время вызова API на 10%, картинки на 7%. User activity выросла всего-навсего на 1 %, но мы не сдаемся, думаем, что будет лучше.
По нагрузкам у нас сейчас порядка 10 млн пользователей на нашем self-made UDP, трафик до 80 Гбит/c, 6 млн пакетов в секунду и 20 серверов все это обслуживают.
UDP checklist
Если вы будете писать свой протокол, вам нужен чек лист:
Было бы нечестно говорить, что Google такого не делал.
Есть протокол QUIC, который реализовал Google под интерфейсом HTTP 2.0, который поддерживает примерно то же самое.
Почему QUIC не так quick
Когда вышел QUIC, появилось очень много хейтинга по поводу того, что Google говорит, что все работает быстрее, а «я померял у себя дома на компьютере — работает медленнее».
В этой статье куча картинок и измерений.
Что же, получается, мы все это зря делали, люди померили за нас? Есть реальные домашние измерения, даже с примерами кода.
На самом деле улучшений не будет до тех пор, пока вы не будете параллелить запросы, работать в реальных сетях, и пока потери пакетов не будут делиться на congestion loss и random loss. Нужна реальная эмуляция реальной сети.
Но есть и позитив, говорят, QUIC не лучше и не хуже. Таким образом в идеальных сетях QUIC работает хорошо.
Будущее
Недавно Google назвал версию HTTP 2.0 поверх QUIC HTTP 3, чтобы не путаться, потому что HTTP 2.0 мог быть поверх TCP и поверх QUIC. Теперь он HTTP 3.
Был еще Google QUIC — это QUIC, который реализован в Chrome, и iQUIC — стандартизованный QUIC. Стандартизованный QUIC по факту нигде не имплементировался, стандартные серверы iQUIC не хэндшейкались с Google QUIC. Сейчас они обещают эту проблему решить, и скоро это будет доступно.
QUIC повсюду
Если вы еще не верите, что TCP умер, то я вам скажу, что когда вы используете Chrome, Android, а скоро и iOS, и ходите в google, youtube и прочее, то используете QUIC и UDP (пруфлинк).
Также можно зайти в сеть в браузере и тоже увидеть, что там есть GQUIC.
Ещё немного будущего
Скоро нас ждёт multipath.
Когда у вас есть мобильный клиент, у которого есть и Wi-Fi, и 3G, вы можете использовать оба канала. Multipath TCP сейчас в разработке, скоро будет доступен в ядре Linux. Очевидно, что до клиентов он дойдет нескоро, думаю, на UDP его можно сделать гораздо быстрее.
Так как мы проводим массу трансляций объемом по 3 Тб, мы очень часто используем такие технологии как CDN и p2p раздача, когда один и тот же контент нужно доставить многим пользователям по всему миру.
В IPv6 есть multicast с UDP, который позволит доставлять пакеты сразу нескольким подписавшимся пользователям. Поэтому я думаю, что технологии CDN и p2p в скором будущем будут не нужны, если мы будем доставлять весь контент с использованием multicast на IPv6.
Выводы
Надеюсь, что вам стало понятнее:
Мы с вами определяем будущее. То, какими протоколами пользоваться, решаем мы сами. Хотите использовать QUIC — используйте, хотите свое UDP или остаться на TCP — определяйте будущее сами.
Полезные ссылки
До 7 сентября на московский HighLoad++ еще можно подать заявку и поделиться, а как вы готовите свои сервисы для высоких нагрузок. Но программа уже постепенно наполняется, от Одноклассников приняты доклады о новой архитектуре графа друзей, об оптимизации сервиса подарочков под высокие нагрузки и о том, что делать, если вы все оптимизировали, а данные до пользователя доходят недостаточно быстро.