Какие параметры влияют на производительность приложений? Часть 1. TCP Window Size

Самый простой способ понять значение термина размер TCP окна (TCP Window Size), это представить разговор двух человек. Один человек говорит, а второй кивает головой или говорит да, тем самым подтверждая, что он понял, а по сути, получил все слова, которые ему были сказаны. После этого разговор продолжается. Если мы встречаем особо говорливого человека, то наша голова быстро загружается, и мы начинаем терять нить разговора или переспрашивать нашего собеседника. Тоже самое происходит и в Матрице — в мире цифр и машин.

Размер TCP окна (TCP Window Size) – количество октетов (начиная с номера подтверждения), которое принимающая сторона готова принять в настоящий момент без подтверждения. На стадии установления соединения рабочая станция и сервер обмениваются значениями максимального размера TCP окна (TCP Window Size), которые присутствуют в пакете и эти значения можно легко увидеть, воспользовавшись захватом трафика.

Например, если размер окна получателя равен 16384 байта, то отправитель может отправить 16384 байта без остановки. Принимая во внимание, что максимальная длина сегмента (MSS) может быть 1460 байт, то отправитель сможет передать данный объем в 12 фреймах, и затем будет ждать подтверждение доставки от получателя и информации по обновлению размера окна. Если процесс прошел без ошибок, то размер окна может быть увеличен. Таким образом, реализуется размер скользящего окна в стеке протокола TCP.

В зависимости от состояния каналов связи, размер окна может быть больше или меньше. Каналы связи могут быть высокоскоростными (большая пропускная способность) и протяженными (большая задержка и возможно потери), поэтому при небольшом размере TCP окна мы будем вынуждены отправлять один или несколько фреймов и ждать подтверждения от получателя, затем процесс повторяется. Таким образом, наши приложения будут неэффективно использовать доступную полосу пропускания. Пакетов будет много, но реального полезного трафика будет передано не много. Чтобы получить максимальную пропускную способность, необходимо использовать оптимально установленный размер передающего и принимающего окна для канала, который вы используете.

Для расчёта максимального размера окна (т.е. максимальный объем данных, которые могут передаваться одним пользователем другому в канале связи) рассчитывается по формуле:

Полоса пропускания (бит/сек) * RTT (круговое время передачи по сети) = размер окна в битах

Таким образом, если ваши два офиса соединяет канал связи в 10 Мбит/сек и круговое время составляет 85 миллисекунд, то воспользовавшись данной формулой, мы получим значение окна равное:

10 000 000 * 0,085 / 8 = 106250 байт

Размер поля Window в заголовке TCP составляет 16 бит; это означает, что узел TCP может указать максимальный размер TCP окна 65535 байт. Таким образом, максимальная пропускная способность составляет:

65535 * 8 / 0,085 = 6,2 Мбит/сек

т.е. чуть больше 50% от реально доступной полосы пропускания канала.

В современных версиях операционных систем можно увеличить размер окна TCP Window Size и включить динамическое изменение окна в зависимости от состояния канала связи. В предложении RFC 1323 дано определение масштабирования окон, позволяющего получателю указывать размер окна больше 65535 байт, что позволит применять большие размеры окон и высокоскоростные каналы передачи. Параметр TCP Window Scale указывает коэффициент масштабирования окна, который в сочетании с 16-битным полем Window в заголовке TCP может увеличивать размер окна приема до максимального значения, составляющего примерно 1 ГБ. Параметр Window Scale отправляется только в сегментах синхронизации (SYN) при установке соединения. На нашем скриншоте из WireShark он составляет 256. Устройства, общающиеся друг с другом, могут указывать разные коэффициенты масштабирования для TCP окон.

Таким образом, активировав масштабирование окон TCP и уменьшив круговое время передачи по сети, мы сможем повысить эффективность использования доступной полосы пропускания и как следствие скорость работы приложений. А проверить это можно захватив пакеты, и посмотреть о каких значениях размера окна и коэффициенте масштабирования договорились устройства в момент установки соединения. Это динамическое увеличение и уменьшение размера окна является непрерывным процессом в TCP и определяет оптимальный размер окна для каждого сеанса. В очень эффективных сетях размеры окна могут стать очень большими, потому что данные не теряются. В сетях, где сетевая инфраструктура перегружена, размер окна, вероятно, останется маленьким.

Windows max window size

This forum has migrated to Microsoft Q&A. Visit Microsoft Q&A to post new questions.

Answered by:

Question

Is there way to set min and max size of Universal App’s windows on Win10?

• Moved by Esther Fan Microsoft employee Saturday, May 16, 2015 2:10 AM
• Moved by Tina-Shi Monday, May 18, 2015 6:32 AM the issue is related to the Universal App
• Edited by Rob Caplan [MSFT] Microsoft employee Wednesday, May 27, 2015 2:11 AM title

Answers

No, you can’t force a minimum or maximum size.

You can request a minimum or specific size with Windows.UI.ViewManagement.ApplicationView.SetPreferredMinSize or TryResizeView, and you can request the app’s window be maximized with TryEnterFullScreenMode but the results are not guaranteed if they conflict with system settings.

All replies

Thank you for posting in MSDN forum.

Since this issue is related to the Universal App, so we will move this case to this Developing Universal Windows apps forum, you will get better support.

We are trying to better understand customer views on social support experience, so your participation in this interview project would be greatly appreciated if you have time. Thanks for helping make community forums a great place.
Click HERE to participate the survey.

Windows max window size

Given an integer array of size n, find the maximum of the minimum’s of every window size in the array. Note that window size varies from 1 to n.
Example:

Input: arr[] = <10, 20, 30, 50, 10, 70, 30>
Output: 70, 30, 20, 10, 10, 10, 10
The first element in the output indicates the maximum of minimums of all
windows of size 1.
Minimums of windows of size 1 are <10>, <20>, <30>, <50>, <10>,
<70>and <30>. Maximum of these minimums is 70
The second element in the output indicates the maximum of minimums of all
windows of size 2.
Minimums of windows of size 2 are <10>, <20>, <30>, <10>, <10>,
and <30>. Maximum of these minimums is 30
The third element in the output indicates the maximum of minimums of all
windows of size 3.
Minimums of windows of size 3 are <10>, <20>, <10>, <10>and <10>.
Maximum of these minimums is 20
Similarly, other elements of output are computed.

Naive Solution: Brute Force.
Approach: A simple brute force approach to solve this problem can be to generate all the windows possible of a particular length say ‘L’ and find the minimum element in all such windows. Then find the maximum of all such elements and store it. Now the length of window is 1

Python3

Output:

Complexity Analysis:

Efficient Solution: We can solve this problem in O(n) time. The idea is to use extra space. Below are detailed steps.
Step 1: Find indexes of next smaller and previous smaller for every element. Next smaller is the nearest smallest element on right side of arr[i]. Similarly, a previous smaller element is the nearest smallest element on the left side of arr[i].
If there is no smaller element on the right side, then the next smaller is n. If there is no smaller on the left side, then the previous smaller is -1.
For input <10, 20, 30, 50, 10, 70, 30>, array of indexes of next smaller is <7, 4, 4, 4, 7, 6, 7>.
For input <10, 20, 30, 50, 10, 70, 30>, array of indexes of previous smaller is <-1, 0, 1, 2, -1, 4, 4>
This step can be done in O(n) time using the approach discussed in next greater element.
Step 2: Once we have indexes of next and previous smaller, we know that arr[i] is a minimum of a window of length “right[i] – left[i] – 1”. Lengths of windows for which the elements are minimum are <7, 3, 2, 1, 7, 1, 2>. This array indicates, the first element is minimum in the window of size 7, the second element is minimum in the window of size 3, and so on.
Create an auxiliary array ans[n+1] to store the result. Values in ans[] can be filled by iterating through right[] and left[]

We get the ans[] array as <0, 70, 30, 20, 0, 0, 0, 10>. Note that ans[0] or answer for length 0 is useless.
Step 3: Some entries in ans[] are 0 and yet to be filled. For example, we know maximum of minimum for lengths 1, 2, 3 and 7 are 70, 30, 20 and 10 respectively, but we don’t know the same for lengths 4, 5 and 6.
Below are few important observations to fill remaining entries
a) Result for length i, i.e. ans[i] would always be greater or same as result for length i+1, i.e., ans[i+1].
b) If ans[i] is not filled it means there is no direct element which is minimum of length i and therefore either the element of length ans[i+1], or ans[i+2], and so on is same as ans[i]
So we fill rest of the entries using below loop.

Below is implementation of above algorithm.

GUI/Maximum window dimensions

The task is to determine the maximum height and width of a window that can fit within the physical display area of the screen without scrolling.

This is effectively the screen size (not the total desktop area, which could be bigger than the screen display area) in pixels minus any adjustments for window decorations and menubars.

The idea is to determine the physical display parameters for the maximum height and width of the usable display area in pixels (without scrolling).

The values calculated should represent the usable desktop area of a window maximized to fit the the screen.

Considerations — Multiple Monitors

For multiple monitors, the values calculated should represent the size of the usable display area on the monitor which is related to the task (i.e.: the monitor which would display a window if such instructions were given).

— Tiling Window Managers

For a tiling window manager, the values calculated should represent the maximum height and width of the display area of the maximum size a window can be created (without scrolling). This would typically be a full screen window (minus any areas occupied by desktop bars), unless the window manager has restrictions that prevents the creation of a full screen window, in which case the values represent the usable area of the desktop that occupies the maximum permissible window size (without scrolling).

Contents

Ada [ edit ]

Output (on a 1280 x 800 screen with Windows XP):

AutoHotkey [ edit ]

This is a modified example taken from the AutoHotkey documentation for the SysGet command. Also, the built in variables A_ScreenHeight and A_ScreenWidth contain the width and height of the primary monitor, in pixels.

Axe [ edit ]

Because Axe is currently (6/22/2015) only available on the TI-83/84 black and white calculators, the screen dimensions are fixed at 96 by 64 pixels.

BaCon [ edit ]

Requires BaCon version 4.0.1 or higher, using GTK3.

Result when executed using my 1600×900 screen:

BBC BASIC [ edit ]

C [ edit ]

Windows [ edit ]

The following implementation has been tested on Windows 8.1, may not work on Linux systems.

C# [ edit ]

Compiler: Roslyn C# (language version >= 6)

Must be referenced:

Bounds are the screen’s dimensions; working area is the is the region that excludes «taskbars, docked windows, and docked tool bars» (from Framework documentation).

Alternatively, use the dimensions of a borderless form with WindowState set to FormWindowState.Maximized (i.e. a full-screen window that is shown above the taskbar).

Creative Basic [ edit ]

Delphi [ edit ]

Resources from form:

EGL [ edit ]

To get the size of the window in a RuiHandler a JavaScript function is needed that is not natively supported by EGL. Therefore an external type is created to wrap the JavaScript function.

File ‘Browser.js’ in folder ‘utils’ in the WebContent folder of a rich UI project.

The external type to wrap the JavaScript functions.

Usage of the Browser external type in a RuiHandler.

FBSL [ edit ]

In the graphics mode, Windows does it all automatically and displays a form that fills the entire area not obscured by the taskbar on your primary monitor:

Alternatively, one can obtain the unobscured area’s dimensions using the following console script:

A typical output for a 1680×1050 primary monitor will be:

FreeBASIC [ edit ]

Output for my machine:

Gambas [ edit ]

Overview [ edit ]

In gambas, the trick to determining the maximum window size that will fit on the screen is to create a form that is maximized and then query its dimensions from within a Form_Resize() event. Note that the form can be invisible during this process, and typically we would use the main modal window (FMain in this example).

Creating the form [ edit ]

From with the project create a form (FMain) with the following properties set:

From within the projectview, rightclick the FMain form and select Edit class from the contextmenu. This will display a form class file (FMain.class) as follows:

Adding the form resize event [ edit ]

We can now add a Form_Resize() event to the class file with the necessary code to obtain the screen dimensions as follows: