Лекции / Лекция 6

Технологии и методы программирования. Лекция 6.

Максимально достижимое ускорение.

Оценим верхнюю границу эффективности:

S_p<=t_s/ t_p

При этом t_p=f*t_s+(1-f)*t_s/p, где t_{s –} всё время выполнения, f – доля последовательных, нераспараллеленых операций в алгоритме, t_p — время выполнения последовательных операций. Тогда Sp<=t_s/ t_p = t_s/(f*t_s+(1-f)*t_s/p) = 1/(f+(1-f)/p). Полученное соотношение называется законом Амдаля. Для паракомпьютера, при бесконечном количестве процессоров, верхняя граница эффективности стремится к 1/f. Так, в модифицируемой каскадной схеме сложения элементов последовательности f=n/log(n), значит, при размерности 16 ускорение не может быть выше 4 при любом количестве процессоров. Закон Амдаля используется в сравнении алгоритмов — чем меньше f, тем лучше эффективность. При этом предполагается, что f постоянно, хотя для большинства параллельных алгоритмов f зависит от размерности: чем меньше размерность, тем меньше f. Если оптимизировать число процессоров, и начать увеличивать размерность, что ускорение будет возрастать, так как f будет уменьшаться. Это называется эффектом Амдаля.

Пример: модифицированная каскадная схема сложения элементов последовательности.

T_p=n/p+log₂p

f=1/p+log₂p/n

Видно, что с ростом размерности f падает.

Экспериментальное определение f. (идея предложена Бакановым)

Баканов пришёл к выводу, что теоретически определить f тяжело, так как операции по разделению парных ветвей алгортма выполняются компилятором/средствами поддержки, работу которых теоретически предсказать трудно. Он предложил определять f экспериментально:

f=(p/S_p-1)/(p-1)

Для расчёта нужно построить график эффективности от числа процессоров, а затем методом наименьших квадратов определить уровень наклона и, по нему, f.

Бакановым было показано на кластере МГУ, что при умножении матриц f=0,051 при сложности алгоритма O(n³). Таким образом, оказалось, что оценка верхней границы ускорения по Амдалю сильно завышена, и было предложено использовать формулу

Sp=1/(1+(1-f)/p+c), где с — коэффициент деградации.

с=c_w*c_t

c_w=w_c/w

c_t=t_c/t, где с — коэффициент, определяющий свойства алгоритма, w_c — количество операций коммуникации, w – общее число операций, c_t — отношение вычислительной производительности платформы (t_c) к вычислительной производительности сетевого оборудования (t). Эти коэффициенты могут быть рассчитаны экспериментально.

Закон Густавина — Барсена:

g=t(n)/(t(n)+π(n)/p), где t(n) – время выполнения последовательных операций, а π(n) – параллельных. Если при увеличении размерности g стремится к 0, то эффективность стремится к количеству процессоров — это характерно для хороших алгоритмов. Оценка ускорения с помощью g называется ускорением масштабирования.

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

Алгоритм называется масштабируемым, если при увеличении числа процессоров он обеспечивает рост ускорения при сохранении эффективности.

T₀=pT_p-T₁, где T₀ — время, которое тратится на накладные расходы: синхронизацию, разбиение на параллельные ветви, T_p – время выполнения на p процессорах, а T₁ — на 1.

T_p=(T₀+T₁)/p

S_p=T₁/T_p=p*T₁/(T₀+T₁)

E_p=T₁/(T₀+T₁)

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