Действительно ли семейство "* apply " не векторизовано?

для меня векторизация-это прежде всего упрощение написания и понимания вашего кода.

цель векторизованной функции состоит в том, чтобы устранить Бухгалтерский учет, связанный с циклом for. Например, вместо:

means <- numeric(length(mtcars))
for (i in seq_along(mtcars)) {
  means[i] <- mean(mtcars[[i]])
}
sds <- numeric(length(mtcars))
for (i in seq_along(mtcars)) {
  sds[i] <- sd(mtcars[[i]])
}

Вы можете написать:

means <- vapply(mtcars, mean, numeric(1))
sds   <- vapply(mtcars, sd, numeric(1))

что делает его легче увидеть, что то же самое (входные данные) и что отличается (функция, которую вы применяете).

вторичным преимуществом векторизации является то, что for-loop часто пишется на C, а не на R. Это имеет существенные преимущества в производительности, но я не думаю, что это ключевое свойство векторизации. Векторизация в основном касается сохранения вашего мозга, а не сохранения работы компьютера.

я согласен с мнением Патрика Бернса, что это скорее скрытие петли, а не векторизация кода. Вот почему:

считайте это C фрагмент кода:

for (int i=0; i<n; i++)
  c[i] = a[i] + b[i]

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

наиболее очевидным способом является то, что код выполняется в последовательно. Загрузить a[i] и b[i] на регистры, добавьте их, сохраните результат в c[i], и сделать это для каждого i.

однако, современные процессоры имеют вектор или SIMD набор инструкций, который способен работать на вектор данных во время та же инструкция при выполнении та же операция (например, добавление двух векторов, как показано выше). В зависимости от процессора / архитектуры, можно было бы добавить, скажем, четыре числа из a и b по той же инструкции, а не по одному.

мы хотели бы использовать Одна Инструкция, Множество Данных и выполнить параллелизм уровня данных, т. е. загружать 4 вещи одновременно, добавлять 4 вещи одновременно, хранить 4 вещи одновременно, например. А это векторизация кода.

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

было бы здорово, если бы компилятор идентифицировал такие блоки кода и автоматически векторизует их, что является сложной задачей. автоматическая векторизация кода является сложной темой исследования в области компьютерных наук. Но за время компиляторы стали лучше. Вы можете проверить автоматическая векторизация возможности GNU-gccздесь. Аналогично для LLVM-clangздесь. И вы также можете найти некоторые тесты в последней ссылке по сравнению с gcc и ICC (компилятор Intel C++).

gcc (я v4.9) например не векторизует код автоматически при -O2 оптимизация уровня. Поэтому, если бы мы должны были выполнить код, показанный выше, это было бы выполняются последовательно. Вот время для добавления двух целочисленных векторов длиной 500 миллионов.

нам либо нужно добавить флаг -ftree-vectorize или изменить оптимизацию на уровень -O3. (Обратите внимание, что -O3 выполняет другие дополнительные оптимизации как хорошо). Флаг -fopt-info-vec полезно, поскольку он сообщает, когда цикл был успешно векторизован).

# compiling with -O2, -ftree-vectorize and  -fopt-info-vec
# test.c:32:5: note: loop vectorized
# test.c:32:5: note: loop versioned for vectorization because of possible aliasing
# test.c:32:5: note: loop peeled for vectorization to enhance alignment    

это говорит нам, что функция векторизированный. Вот тайминги, сравнивающие оба не векторизированный и векторизированный версии на целочисленных векторов длины 500 млн.:

x = sample(100L, 500e6L, TRUE)
y = sample(100L, 500e6L, TRUE)
z = vector("integer", 500e6L) # result vector

# non-vectorised, -O2
system.time(.Call("Csum", x, y, z))
#    user  system elapsed 
#   1.830   0.009   1.852

# vectorised using flags shown above at -O2
system.time(.Call("Csum", x, y, z))
#    user  system elapsed 
#   0.361   0.001   0.362

# both results are checked for identicalness, returns TRUE

---

эту часть можно смело пропустить без потери непрерывности.

компиляторы не всегда будут иметь достаточно информации для векторизации. Мы могли бы использовать спецификация OpenMP для параллельного программирования и simd директива компилятора для указания компиляторам векторизовать код. Важно обеспечить, чтобы их не было перекрывает память, состояние гонки и т. д.. при векторизации кода вручную, иначе это приведет к неверным результатам.

#pragma omp simd
for (i=0; i<n; i++) 
  c[i] = a[i] + b[i]

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

# timing with -O2 + OpenMP with simd
x = sample(100L, 500e6L, TRUE)
y = sample(100L, 500e6L, TRUE)
z = vector("integer", 500e6L) # result vector
system.time(.Call("Cvecsum", x, y, z))
#    user  system elapsed 
#   0.360   0.001   0.360

это здорово! Это было протестировано с помощью gcc v6. 2. 0 и llvm clang v3.9. 0 (оба установлены через homebrew, MacOS 10.12.3), оба из которых поддержка OpenMP 4.0.

---

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

в случае R, даже rowSums() или colSums() код в C не использовать векторизация кода IIUC; это просто цикл в C. То же самое касается lapply(). В случае apply(), это в R. поэтому все они скрытие петли.

короче говоря, обертывание функции R:

просто писать for-loop in C != векторизация кода.
просто пишу for-loop in R != векторизация кода.

Intel Math Kernel Library (MKL) например реализует векторизованные формы функции.

HTH

---

ссылки:

1. разговор Джеймса Рейндерса, Intel (этот ответ в основном является попыткой резюмировать этот отличный разговор)

Итак, чтобы суммировать отличные ответы / комментарии в какой-то общий ответ и предоставить некоторый фон: R имеет 4 типа циклов (с не-векторизация на заказ векторизация)

1. R for цикл, который повторно вызывает функции R в каждой итерации (не векторизированный)
2. цикл C, который повторно вызывает функции R в каждой итерации (не векторизированный)
3. цикл C, который вызывает функцию R только один раз (несколько векторизованных)
4. простой цикл C, который не вызывает любой R функция вообще и использует ее собственные скомпилированные функции (векторизовать)

так *apply семья-это второй тип. Кроме apply который больше из первого типа

вы можете понять это из комментария в его исходный код

/* .Внутренний (lapply (X, FUN)) * /

/* это особый .Внутренние, так что имеет неоценимые аргументы. Это
вызывается из обертки закрытия, поэтому X и FUN-это обещания. Веселье должно быть быть недооцененным для использования, например, в bquote . * /

что это значит lapplyкод s C принимает не оцененную функцию от R и позже оценивает ее в самом коде C. Это в основном разница между lapplys .Internal вызов

.Internal(lapply(X, FUN))

С