В чем смысл правила оптимизации программы 90/10?

Согласно Википедии, правило оптимизации программы 90/10 гласит, что «90% времени выполнения программы тратится на выполнение 10% кода» (см. Второй абзац здесь ).

Я действительно не понимаю этого. Что именно это значит? Как можно потратить 90% времени выполнения только на выполнение 10% кода? А как насчет остальных 90% кода? Как они могут быть выполнены всего за 10% времени?

Здесь есть два основных принципа:

• Некоторый код выполняется намного чаще, чем другой код. Например, некоторый код обработки ошибок может никогда не использоваться. Некоторый код будет выполняться только при запуске вашей программы. Другой код будет выполняться снова и снова, пока ваша программа работает.
• Некоторый код выполняется намного дольше, чем другой код. Например, одна строка, которая выполняет запрос к базе данных или извлекает файл из Интернета, вероятно, займет больше времени, чем миллионы математических операций.

Правило 90/10 не буквально верно. Это зависит от программы (и я сомневаюсь, что вообще есть основания для конкретных чисел 90 и 10; кто-то, вероятно, вытащил их из воздуха). Но дело в том, что если вам нужно, чтобы ваша программа работала быстрее, возможно, для этого достаточно лишь небольшое количество строк. Выявление медленных частей вашего программного обеспечения часто является самой большой частью оптимизации.

Это важное понимание, и это означает, что решения, которые кажутся новым разработчикам нелогичными, часто могут быть правильными. Например:

• Существует много кода, который не стоит тратить время на то, чтобы сделать его «лучше» , даже если он делает что-то глупо и упрощенно. Не могли бы вы написать более эффективный алгоритм поиска для приложения XYZ? Да, но на самом деле простое сравнение каждого значения занимает тривиальное время, хотя существуют тысячи значений. Так что это просто не стоит. Новым разработчикам может быть непросто избежать ненужной оптимизации, потому что в их учебной программе так много времени было потрачено на написание «правильного» (то есть наиболее эффективного) алгоритма. Но в реальном мире правильный алгоритм - это любой, который работает и работает достаточно быстро.
• Изменения, которые делают ваш код намного длиннее и сложнее, могут по-прежнему выигрывать в производительности. Например, в приложении FOO, возможно, стоит добавить сотни строк новой логики, чтобы избежать единственного вызова базы данных.

Это не закон природы, а правило большого пальца, основанное на большом опыте. Это также известно как правило 80/20, и это только грубое приближение.

Петли, ответвления и др. Контроль потока.

В каждом месте, где есть if, у вас будет одна ветвь, которая будет занята чаще, чем другая. Таким образом, больше времени на выполнение тратится на выполнение этой части программы, а не другой части.

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

В качестве примера рассмотрим:

def DoSomeWork():
    for i in range(1000000):
        DoWork(i)
    except WorkExeption:
        print("Oh No!")

Здесь print("Oh No!")будет только один максимум, и часто никогда, тогда как DoWork(i)будет происходить около миллиона раз.

Контуры.

Я испытываю желание остановиться там! :-)

Рассмотрим эту программу

1. do_something

2. loop 10 times
3.    do_another_thing

4.    loop 5 times
5.        do_more_stuff

Строка 1 выполняется один раз, а строка 3 - 10 раз. Глядя на каждую строку по очереди

1 1   0.8%
2 10  8.3%
3 10  8.3%
4 50 41.3%
5 50 41.3%

На две строки приходится 83% времени выполнения (при условии, что на выполнение всех строк требуется примерно одинаковое время. Таким образом, 40% программы занимает> 80%.

С более крупными примерами из реальной жизни это возрастает, поэтому большую часть времени выполнения составляет только небольшое количество строк.

Правило 90/10 (или, как его иногда называют 80/20) - это «практическое правило» - только приблизительно верно.

Смотрите также принцип Парето.

Поскольку вы спрашивали только о времени выполнения, этот пример может быть полезен:

int main() {
    sleep(90); // approximately 10% of the program.
    // other 90% of the program:
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    sleep(1);
    return 0;
}

Если быть немного более серьезным, это означает, что в реальном коде вы почти всегда вызываете тяжелую функцию в цикле (а не sleep(90);), а в оставшиеся 10% времени вы выполняете некоторые однопроходные вычисления.

Другой пример - обработка ошибок в некоторых сервисах высокой доступности. Любой высокодоступный сервис предназначен для работы неограниченное количество времени в нормальных условиях. Обычно он работает 99% времени, но иногда, в случае ошибки, он выполняет некоторую обработку ошибок и восстановление, которые могут быть даже более логически сложными, чем сама служба.

Аргументация 90/10 означает, что небольшая часть вашего кода будет повторяться или использоваться чаще других. Это часто используется, чтобы предложить вам сконцентрировать 90% ваших усилий по разработке / оптимизации на этих 10% вашего кода.

Вспомните обычный текстовый процессор, например Microsoft Word или OpenOffice :

• Диалог настроек, используется не очень;
• Подпрограммы, которые рисуют символы, используются постоянно.

Это высказывание также используется в науках об управлении ... Это урок самой жизни ... Значение: сконцентрируйте большинство своих усилий там, где вы получите больший результат.

Представьте себе такую ​​программу:

print "H"
print "e"
print "l"
print "l"
print "o"
for i=0 to 1,000,000
    print "How long now?"
next
print "B"
print "y"
print "e"

Обратите внимание, что здесь есть 11 строк, где 3 из 11 являются циклом for, и сколько времени тратится на этот довольно небольшой фрагмент кода? Совсем немного, а остальные 8 строк просто печатают один символ. Таким образом, имейте в виду, что хотя некоторый код может быть коротким, он не говорит вам, как часто он выполняется и сколько времени это займет.

В дополнение к зацикливанию, как уже упоминалось в других замечательных ответах, есть еще и принципы СУХОГО. Хорошо написанный, объектно-ориентированный код имеет много повторно используемых частей. Те части, которые повторно используются, по определению, используются как минимум в два раза чаще, чем то, что выполняется только один раз. Если у вас много ОО-кода, вы можете многократно использовать несколько классов и методов, а несколько других частей кода - только один раз.

Как упоминалось в других ответах, вероятно, лучше потратить усилия на то, чтобы сделать код, который используется чаще, лучше, чем улучшить код, который используется только один раз.

Это не правило, это просто какой-то чувак, который отредактировал Википедию с парой цифр, взятых из воздуха, и назвал это правилом. Сравните с принципом Парето, который более твердо установлен в других контекстах. Я хотел бы посмотреть, какие исследования были сделаны (если таковые имеются) на точность этого "правила".

Но в основном ответ на ваш вопрос таков: некоторый код выполняется гораздо чаще, чем другой. Петли часто являются причиной этого. Другими причинами являются длительные вызовы, например, на внешние ресурсы, такие как веб-службы или носители данных.

Это переосмысление «принципа Парето», который гласит, что «для многих событий примерно 80% последствий происходит от 20% причин», также известный как правило 80/20. Это правило в основном применяется к экономике, поэтому имеет смысл, что оно будет предназначено для программирования.

Это просто картина, которая наблюдалась в течение длительного периода времени.

Вот очень хорошее видео о таких шаблонах, и оно также объясняет принцип Парето.

https://www.youtube.com/watch?v=fCn8zs912OE&ab_channel=Vsauce