Оптимизация! - Что это? Как это сделано?

This is a good question.

Usually the best practice is 1) just write the code to do what you need it to do, 2) then deal with performance, but only if it's an issue. If the program is "fast enough" it's not an issue.

If the program is not fast enough (like it makes you wait) then try some performance tuning. Performance tuning is not like programming. In programming, you think first and then do something. In performance tuning, thinking first is a mistake, because that is guessing.

Don't guess what to fix; diagnose what the program is doing. Everybody knows that, but mostly they do it anyway. It is natural to say "Could be the problem is X, Y, or Z" but only the novice acts on guesses. The pro says "but I'm probably wrong".

There are different ways to diagnose performance problems.

The simplest is just to single-step through the program at the assembly-language level, and don't take any shortcuts. That way, if the program is doing unnecessary things, then you are doing the same things, and it will become painfully obvious.

Another is to get a profiling tool, and as others say, measure, measure, measure.

Personally I don't care for measuring. I think it's a fuzzy microscope for the purpose of pinpointing performance problems. I prefer this method, and this is an example of its use.

Good luck.

ADDED: I think you will find, if you go through this exercise a few times, you will learn what coding practices tend to result in performance problems, and you will instinctively avoid them. (This is subtly different from "premature optimization", which is assuming at the beginning that you must be concerned about performance. In fact, you will probably learn, if you don't already know, that premature concern about performance can well cause the very problem it seeks to avoid.)

Оптимизация программы означает: заставить ее работать быстрее

Единственный способ сделать программу быстрее - заставить ее делать меньше :

• найдите алгоритм, который использует меньше операций (например, N log N вместо N ^ 2)
• избегайте медленных компонентов вашей машины (храните объекты в кэше, а не в основной памяти, или в основной памяти вместо диска); сокращение потребления памяти почти всегда помогает!

Дополнительные правила:

• При поиске возможностей оптимизации придерживайтесь правила 80-20: на 20% типичного программного кода приходится 80% времени выполнения.
• Измерьте время до и после каждой попытки оптимизации; достаточно часто оптимизации нет.
• Оптимизировать только после правильного выполнения программы!

Кроме того, есть способы заставить программу выглядеть быстрее:

• отделить обработку событий графического интерфейса от внутренних задач; отдавать предпочтение видимым для пользователя изменениям по сравнению с внутренними вычислениями, чтобы внешний интерфейс оставался "быстрым"
• , давая пользователю что-то для чтения при выполнении длительных операций (каждый заметил слайд-шоу, отображаемые установщиками?)

Я предлагаю вам сначала прочитать немного теории (из книг или Google для слайдов лекций):

• Структуры данных и алгоритмы - что такое нотация O (), как ее вычислить , какие структуры данных и алгоритмы можно использовать для снижения O-сложности
  Книга: Введение в алгоритмы Томаса Х. Кормена, Чарльза Э. Лейзерсона и Рональда Л. Ривеста

• Компиляторы и сборка - как код транслируется в машину инструкции

• Архитектура компьютера - как ЦП, ОЗУ, кэш, прогнозирование ветвлений, выполнение вне очереди ... работа

• Операционные системы - режим ядра, пользовательский режим, планирование процессов / потоков, мьютексов, семафоров, очередей сообщений

Прочитав по частям каждого из них, вы должны иметь базовое представление обо всех различных аспектах оптимизации.

Примечание: я добавил это вики, чтобы люди могли добавлять рекомендации по книгам.

Я придерживаюсь идеи, что оптимизация кода должна дать те же результаты за меньшее время. А полная оптимизация означает лишь то, что у них закончились идеи, чтобы сделать это быстрее. Я с большим презрением отношусь к заявлениям о «полностью оптимизированном» коде! Такого не бывает.

Итак, вы хотите, чтобы ваше приложение / программа / модуль работали быстрее? Первое, что нужно сделать (как упоминалось ранее), - это измерение, также известное как профилирование. Не гадайте, где оптимизировать. Вы не так уж умны и ошибетесь. Мои предположения все время ошибаются, и большую часть года я трачу на профилирование и оптимизацию. Так что пусть компьютер сделает это за вас. Для ПК VTune - отличный профилировщик. Я думаю, что VS2008 имеет встроенный профилировщик, но я не изучал его. В противном случае измеряйте функции и большие фрагменты кода с помощью счетчиков производительности. Вы найдете образец кода для использования счетчиков производительности в MSDN.

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

Оптимизация - это очень весело. И это тоже никогда не кончится :)

Отличная книга по оптимизации - Рэндалл Хайд «Написание отличного кода: понимание машины».

Оптимизация - это очень весело. И это тоже никогда не кончится :)

Отличная книга по оптимизации - Рэндалл Хайд «Написание отличного кода: понимание машины».

Оптимизация - это очень весело. И это тоже никогда не кончится :)

Отличная книга по оптимизации - Рэндалл Хайд «Написание отличного кода: понимание машины».

В основном я буду разглагольствовать без каких-либо практических советов.

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

Вы не можете исправить то, что не можете измерить . Пусть ваша программа сообщит через некоторую инфраструктуру производительности, что она делает и сколько времени на это требуется. Я пришел из фона Win32, поэтому я m привык к счетчикам производительности, и я очень щедро разбрасываю их по всему коду. Я даже автоматизировал код для их генерации .

И, наконец, несколько слов об оптимизации. В большинстве дискуссий об оптимизации я вижу, что основное внимание уделяется тому, что любой компилятор оптимизирует для вас бесплатно. По моему опыту, самый большой источник выгоды для «высокооптимизированного кода» лежит в другом месте: доступ к памяти . В современных архитектурах ЦП большую часть времени простаивает, ожидая, пока память будет передана в его конвейеры. Между промахами кэша L1 и L2 промахи TLB , межузловой доступ NUMA и даже GPF , который должен получить страницу с диска, шаблон доступа к памяти современное приложение - это самая важная из возможных оптимизаций. Я' m, немного преувеличивая, конечно, будут встречные примеры рабочих нагрузок, которые не улучшат локальность доступа к памяти с помощью этих методов. Но большинство приложений будет. Чтобы быть конкретным, то, что означают эти методы, просто: кластеризуйте ваши данные в памяти, чтобы один процессор мог работать в узком диапазоне памяти, содержащем все, что ему нужно, без дорогостоящих ссылок на память за пределами ваших строк кеша или вашей текущей страницы. На практике это может означать что-то столь же простое, как доступ к массиву по строкам, а не по столбцам.

Я бы рекомендовал вам прочитать статью Alpha-Sort, представленную на конференции VLDB в 1995 году. как алгоритмы, чувствительные к кеш-памяти, разработанные специально для современных архитектур ЦП, могут вытеснить старые предыдущие тесты:

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

Я бы рекомендовал вам прочитать статью Alpha-Sort, представленную на конференции VLDB в 1995 году. как алгоритмы, чувствительные к кеш-памяти, разработанные специально для современных архитектур ЦП, могут вытеснить старые предыдущие тесты:

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

Я бы рекомендовал вам прочитать статью Alpha-Sort, представленную на конференции VLDB в 1995 году. как алгоритмы, чувствительные к кеш-памяти, разработанные специально для современных архитектур ЦП, могут вытеснить старые предыдущие тесты:

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

Я бы рекомендовал вам прочитать статью Alpha-Sort, представленную на конференции VLDB в 1995 году. как алгоритмы, чувствительные к кеш-памяти, разработанные специально для современных архитектур ЦП, могут вытеснить старые предыдущие тесты:

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

Я бы рекомендовал вам прочитать статью Alpha-Sort, представленную на конференции VLDB в 1995 году. как алгоритмы, чувствительные к кеш-памяти, разработанные специально для современных архитектур ЦП, могут вытеснить старые предыдущие тесты:

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

Я бы рекомендовал вам прочитать статью Alpha-Sort, представленную на конференции VLDB в 1995 году. как алгоритмы, чувствительные к кеш-памяти, разработанные специально для современных архитектур ЦП, могут вытеснить старые предыдущие тесты:

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

Я бы рекомендовал вам прочитать статью Alpha-Sort, представленную на конференции VLDB в 1995 году. как алгоритмы, чувствительные к кеш-памяти, разработанные специально для современных архитектур ЦП, могут вытеснить старые предыдущие тесты:

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

Прежде чем начинать оптимизацию, убедитесь, что ваше приложение дает правильные результаты.

Оптимизировать - это термин, который мы лениво употребляем для обозначения «сделать что-то лучше определенным образом». Мы редко что-то «оптимизируем» - более того, мы просто улучшаем это до тех пор, пока это не соответствует нашим ожиданиям.

Оптимизация - это изменения, которые мы вносим в надежде оптимизировать какую-то часть программы. Полностью оптимизированная программа обычно означает, что разработчик упустил возможность чтения и перекодировал алгоритм неочевидными способами, чтобы минимизировать «время стены». (Это не требование, чтобы «оптимизированный код» был трудным для чтения, это просто тенденция.)

Можно оптимизировать для:

• потребления памяти - Уменьшите размер времени выполнения программы или алгоритма.

• Потребление ЦП - Сделайте алгоритм менее интенсивным в вычислительном отношении.

• Время стены - Делайте все возможное, чтобы что-то сделать быстрее.

• Читаемость - Вместо того, чтобы делать ваше приложение лучше для компьютера, вы можете упростить его чтение людьми.

Некоторые Общие (и чрезмерно обобщенные) методы оптимизации кода включают:

• Изменение алгоритма для улучшения характеристик производительности. Если у вас есть алгоритм, который занимает O (n ^ 2) времени или пространства, попробуйте заменить этот алгоритм на тот, который занимает O (n * log n).

• Чтобы уменьшить потребление памяти, просмотрите код и найдите потраченные впустую объем памяти. Например, если у вас есть приложение с интенсивным использованием строк, вы можете переключиться на использование ссылок на подстроки (где ссылка содержит указатель на строку плюс индексы для определения ее границ) вместо выделения и копирования памяти из исходной строки.

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

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

Подумайте о таких вещах, как этот фрагмент кода:

a=(b+c)*3-(b+c)

, который транслируется в

        -
     *     + 
    + 3   b c
   b c 

Для синтаксического анализатора будет очевидно, что узел + с его 2 потомки идентичны, поэтому они будут объединены во временную переменную t, и дерево будет переписано:

        -
     *     t 
    t 3   

Теперь даже лучший синтаксический анализатор увидит, что, поскольку t является целым числом, дерево можно упростить до:

        *
     t     2 

и промежуточный код, на котором вы запускаете шаг генерации кода, будет наконец, будет

int t=b+c;
a=t*2;

с t, помеченным как регистровая переменная, что и будет написано для ассемблера.

И последнее замечание: вы можете оптимизировать не только скорость выполнения. Вы также можете оптимизировать потребление памяти, что наоборот. Если развертывание циклов и создание временных копий поможет ускорить ваш код, они также будут использовать больше памяти, так что это компромисс с вашей целью.

int t=b+c;
a=t*2;

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

И последнее замечание: вы можете оптимизировать больше, чем просто скорость выполнения. Вы также можете оптимизировать потребление памяти, что наоборот. Если развертывание циклов и создание временных копий поможет ускорить ваш код, они также будут использовать больше памяти, так что это компромисс с вашей целью.

int t=b+c;
a=t*2;

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

И последнее замечание: вы можете оптимизировать не только скорость выполнения. Вы также можете оптимизировать потребление памяти, что наоборот. Если развертывание циклов и создание временных копий поможет ускорить ваш код, они также будут использовать больше памяти, так что это компромисс с вашей целью.

Однако, как начинающий программист-самоучка, я никогда толком не понимал, что именно люди имеют в виду, когда говорят о таких вещах.

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

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

1. У них есть данные
2. Они выбирают алгоритм, который, как они знают, быстрее математически.
3. Они выбирают структуру данных, которая, как они знают, быстрее математически.

Optimization means trying to improve computer programs for such things as speed. The question is very broad, because optimization can involve compilers improving programs for speed, or human beings doing the same.

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

В приложении Я работал над тем, что было несколько структур данных LinkedList, которые использовались для хранения различных экземпляров foo.

Когда приложение использовалось, оно очень часто проверяло, содержит ли LinkedListed объект X. Поскольку количество X началось Чтобы расти, я заметил, что приложение работает медленнее, чем должно быть.

Я запустил профилировщик и понял, что каждый 'myList.Contains (x)' call имел O (N), потому что список должен перебирать каждый элемент, который он содержит, пока не достигнет конца или не найдет совпадение. Это определенно было неэффективно.

Итак, что я сделал для оптимизации этого кода? Я переключил большинство структур данных LinkedList на HashSets, которые могут выполнять вызов '.Contains (X)' в O (1) - намного лучше.