Распределённые вычисления — бесплатный тест онлайн

Вопрос 1 из 30

Какой механизм Julia определяет поведение строки `@everywhere function local_energy(x)`?

W=\{w_1,\ldots,w_p\}

using Distributed
addprocs(2)
@everywhere function local_energy(x)
    return sum(abs2, x)
end
@show workers() fetch(@spawnat workers()[1] local_energy(1:100))

`remotecall_fetch` возвращает результат удалённого вызова, а `@spawnat` создаёт future; выбор определяет, где и когда ждать и как обрабатывать ошибку. Контроль производительности разделяет вычисление, сериализацию, сеть и простой; больше процессов может замедлить задачу при маленьких блоках или общей файловой системе. Рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. Большинство рабочий процессs разделяют глобальные переменные главного процесса по ссылке, поэтому повторная загрузка модулей не нужна. Аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции.

Вопрос 2 из 30

Какой эксперимент отличит настоящий механизм `@everywhere function local_energy(x)` от случайного результата одного запуска?

using Distributed
addprocs(2)
@everywhere function local_energy(x)
    return sum(abs2, x)
end
@show workers() fetch(@spawnat workers()[1] local_energy(1:100))

Проверить на отдельном примере, что большинство рабочий процессs разделяют глобальные переменные главного процесса по ссылке, поэтому повторная загрузка модулей не нужна. Проверить на отдельном примере, что аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции. Проверить на отдельном примере, что `remotecall_fetch` возвращает результат удалённого вызова, а `@spawnat` создаёт future; выбор определяет, где и когда ждать и как обрабатывать ошибку. Проверить на отдельном примере, что контроль производительности разделяет вычисление, сериализацию, сеть и простой; больше процессов может замедлить задачу при маленьких блоках или общей файловой системе. Проверить на отдельном примере, что рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо.

Вопрос 3 из 30

Какую гарантию должна сохранить правка участка с `@everywhere function local_energy(x)`?

using Distributed
addprocs(2)
@everywhere function local_energy(x)
    return sum(abs2, x)
end
@show workers() fetch(@spawnat workers()[1] local_energy(1:100))

Сохранить в реализации правило: Аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции. Сохранить в реализации правило: Рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. Сохранить в реализации правило: Контроль производительности разделяет вычисление, сериализацию, сеть и простой; больше процессов может замедлить задачу при маленьких блоках или общей файловой системе. Сохранить в реализации правило: Большинство рабочий процессs разделяют глобальные переменные главного процесса по ссылке, поэтому повторная загрузка модулей не нужна. Сохранить в реализации правило: `remotecall_fetch` возвращает результат удалённого вызова, а `@spawnat` создаёт future; выбор определяет, где и когда ждать и как обрабатывать ошибку.

Вопрос 4 из 30

После обновления Julia или пакета поведение участка с `@everywhere function local_energy(x)` изменилось. Какой критерий приёмки остаётся корректным?

W=\{w_1,\ldots,w_p\}

Приёмка должна подтвердить, что аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции. Приёмка должна подтвердить, что рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. Приёмка должна подтвердить, что контроль производительности разделяет вычисление, сериализацию, сеть и простой; больше процессов может замедлить задачу при маленьких блоках или общей файловой системе. Приёмка должна подтвердить, что `remotecall_fetch` возвращает результат удалённого вызова, а `@spawnat` создаёт future; выбор определяет, где и когда ждать и как обрабатывать ошибку. Приёмка должна подтвердить, что большинство рабочий процессs разделяют глобальные переменные главного процесса по ссылке, поэтому повторная загрузка модулей не нужна.

Вопрос 5 из 30

Что следует сообщить пользователю библиотеки о поведении `@everywhere function local_energy(x)`?

Указать в документации: Большинство рабочий процессs разделяют глобальные переменные главного процесса по ссылке, поэтому повторная загрузка модулей не нужна. Указать в документации: Рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. Указать в документации: `remotecall_fetch` возвращает результат удалённого вызова, а `@spawnat` создаёт future; выбор определяет, где и когда ждать и как обрабатывать ошибку. Указать в документации: Контроль производительности разделяет вычисление, сериализацию, сеть и простой; больше процессов может замедлить задачу при маленьких блоках или общей файловой системе. Указать в документации: Аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции.

Вопрос 6 из 30

Какое объяснение для `future = remotecall(w, 1:10) do xs` выдержит проверку на другом допустимом входе?

y=\operatorname{fetch}(\operatorname{remotecall}(f,w,x))

using Distributed
addprocs(2)
w = first(workers())
future = remotecall(w, 1:10) do xs
    sum(xs)
end
@show isready(future) fetch(future)

Удалённый код имеет права процесса и видит переданные данные; кластер не является границей безопасности для недоверенного выражения. Рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. `remotecall_fetch` возвращает результат удалённого вызова, а `@spawnat` создаёт future; выбор определяет, где и когда ждать и как обрабатывать ошибку. Аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции. `@spawnat` сразу возвращает удалённое значение, а `remotecall_fetch` нужен только для потоковой передачи больших массивов.

Вопрос 7 из 30

Какую проверку стоит добавить для участка с `future = remotecall(w, 1:10) do xs`?

using Distributed
addprocs(2)
w = first(workers())
future = remotecall(w, 1:10) do xs
    sum(xs)
end
@show isready(future) fetch(future)

Проверить на отдельном примере, что `@spawnat` сразу возвращает удалённое значение, а `remotecall_fetch` нужен только для потоковой передачи больших массивов. Проверить на отдельном примере, что удалённый код имеет права процесса и видит переданные данные; кластер не является границей безопасности для недоверенного выражения. Проверить на отдельном примере, что аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции. Проверить на отдельном примере, что рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. Проверить на отдельном примере, что `remotecall_fetch` возвращает результат удалённого вызова, а `@spawnat` создаёт future; выбор определяет, где и когда ждать и как обрабатывать ошибку.

Вопрос 8 из 30

Какое решение устраняет риск вокруг `future = remotecall(w, 1:10) do xs`, не меняя поведение на допустимых данных?

using Distributed
addprocs(2)
w = first(workers())
future = remotecall(w, 1:10) do xs
    sum(xs)
end
@show isready(future) fetch(future)

Сохранить в реализации правило: Рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. Сохранить в реализации правило: `remotecall_fetch` возвращает результат удалённого вызова, а `@spawnat` создаёт future; выбор определяет, где и когда ждать и как обрабатывать ошибку. Сохранить в реализации правило: `@spawnat` сразу возвращает удалённое значение, а `remotecall_fetch` нужен только для потоковой передачи больших массивов. Сохранить в реализации правило: Аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции. Сохранить в реализации правило: Удалённый код имеет права процесса и видит переданные данные; кластер не является границей безопасности для недоверенного выражения.

Вопрос 9 из 30

Две реализации участка с `future = remotecall(w, 1:10) do xs` совпадают на обычных данных. Что необходимо проверить перед выпуском?

y=\operatorname{fetch}(\operatorname{remotecall}(f,w,x))

Приёмка должна подтвердить, что рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. Приёмка должна подтвердить, что удалённый код имеет права процесса и видит переданные данные; кластер не является границей безопасности для недоверенного выражения. Приёмка должна подтвердить, что `@spawnat` сразу возвращает удалённое значение, а `remotecall_fetch` нужен только для потоковой передачи больших массивов. Приёмка должна подтвердить, что аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции. Приёмка должна подтвердить, что `remotecall_fetch` возвращает результат удалённого вызова, а `@spawnat` создаёт future; выбор определяет, где и когда ждать и как обрабатывать ошибку.

Вопрос 10 из 30

Что следует сообщить пользователю библиотеки о поведении `future = remotecall(w, 1:10) do xs`?

Указать в документации: Аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции. Указать в документации: Рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. Указать в документации: `@spawnat` сразу возвращает удалённое значение, а `remotecall_fetch` нужен только для потоковой передачи больших массивов. Указать в документации: Удалённый код имеет права процесса и видит переданные данные; кластер не является границей безопасности для недоверенного выражения. Указать в документации: `remotecall_fetch` возвращает результат удалённого вызова, а `@spawnat` создаёт future; выбор определяет, где и когда ждать и как обрабатывать ошибку.

Вопрос 11 из 30

Какое утверждение точнее всего объясняет участок с `A = SharedArray{Float64}(10_000)`?

T=T_{ser}+T_{net}+T_{compute}

using Distributed, SharedArrays
addprocs(2)
A = SharedArray{Float64}(10_000)
@sync @distributed for i in eachindex(A)
    A[i] = sin(i)
end
@show sum(A)

Рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. Контроль производительности разделяет вычисление, сериализацию, сеть и простой; больше процессов может замедлить задачу при маленьких блоках или общей файловой системе. Отказ рабочий процесс требует повторного назначения независимой работы или завершения всего расчёта с понятной ошибкой; потерянное изменяемое состояние нельзя восстановить предположением. Сериализация аргумента сохраняет общую изменяемую память между процессами, поэтому изменения рабочий процесс видны главному процессу. Аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции.

Вопрос 12 из 30

Какой контрольный тест лучше всего проверит правило, связанное с `A = SharedArray{Float64}(10_000)`?

using Distributed, SharedArrays
addprocs(2)
A = SharedArray{Float64}(10_000)
@sync @distributed for i in eachindex(A)
    A[i] = sin(i)
end
@show sum(A)

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

Вопрос 13 из 30

Какое требование к `A = SharedArray{Float64}(10_000)` важнее удобной детали текущей реализации?

using Distributed, SharedArrays
addprocs(2)
A = SharedArray{Float64}(10_000)
@sync @distributed for i in eachindex(A)
    A[i] = sin(i)
end
@show sum(A)

Сохранить в реализации правило: Контроль производительности разделяет вычисление, сериализацию, сеть и простой; больше процессов может замедлить задачу при маленьких блоках или общей файловой системе. Сохранить в реализации правило: Рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. Сохранить в реализации правило: Аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции. Сохранить в реализации правило: Отказ рабочий процесс требует повторного назначения независимой работы или завершения всего расчёта с понятной ошибкой; потерянное изменяемое состояние нельзя восстановить предположением. Сохранить в реализации правило: Сериализация аргумента сохраняет общую изменяемую память между процессами, поэтому изменения рабочий процесс видны главному процессу.

Вопрос 14 из 30

После обновления Julia или пакета поведение участка с `A = SharedArray{Float64}(10_000)` изменилось. Какой критерий приёмки остаётся корректным?

T=T_{ser}+T_{net}+T_{compute}

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

Вопрос 15 из 30

Какое утверждение о `A = SharedArray{Float64}(10_000)` является переносимым правилом, а не особенностью одного запуска?

Указать в документации: Сериализация аргумента сохраняет общую изменяемую память между процессами, поэтому изменения рабочий процесс видны главному процессу. Указать в документации: Отказ рабочий процесс требует повторного назначения независимой работы или завершения всего расчёта с понятной ошибкой; потерянное изменяемое состояние нельзя восстановить предположением. Указать в документации: Рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. Указать в документации: Контроль производительности разделяет вычисление, сериализацию, сеть и простой; больше процессов может замедлить задачу при маленьких блоках или общей файловой системе. Указать в документации: Аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции.

Вопрос 16 из 30

Какое утверждение точнее всего объясняет участок с `push!(results, @spawnat w f(chunk))`?

w_i\downarrow\Rightarrow retry\lor fail

using Distributed
addprocs(2)
function resilient_map(f, chunks)
    results = Future[]
    for (w, chunk) in zip(Iterators.cycle(workers()), chunks)
        push!(results, @spawnat w f(chunk))
    end
    return fetch.(results)
end
@show resilient_map(sum, [1:10, 11:20])

Аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции. Отказ рабочий процесс требует повторного назначения независимой работы или завершения всего расчёта с понятной ошибкой; потерянное изменяемое состояние нельзя восстановить предположением. Рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. Контроль производительности разделяет вычисление, сериализацию, сеть и простой; больше процессов может замедлить задачу при маленьких блоках или общей файловой системе. После отказа рабочий процесс обычно хватает повторить удалённый вызов с теми же аргументами; частичные побочные эффекты и идемпотентность операции учитывать не требуется.

Вопрос 17 из 30

Какой эксперимент отличит настоящий механизм `push!(results, @spawnat w f(chunk))` от случайного результата одного запуска?

using Distributed
addprocs(2)
function resilient_map(f, chunks)
    results = Future[]
    for (w, chunk) in zip(Iterators.cycle(workers()), chunks)
        push!(results, @spawnat w f(chunk))
    end
    return fetch.(results)
end
@show resilient_map(sum, [1:10, 11:20])

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

Вопрос 18 из 30

Какую гарантию должна сохранить правка участка с `push!(results, @spawnat w f(chunk))`?

using Distributed
addprocs(2)
function resilient_map(f, chunks)
    results = Future[]
    for (w, chunk) in zip(Iterators.cycle(workers()), chunks)
        push!(results, @spawnat w f(chunk))
    end
    return fetch.(results)
end
@show resilient_map(sum, [1:10, 11:20])

Сохранить в реализации правило: После отказа рабочий процесс обычно хватает повторить удалённый вызов с теми же аргументами; частичные побочные эффекты и идемпотентность операции учитывать не требуется. Сохранить в реализации правило: Контроль производительности разделяет вычисление, сериализацию, сеть и простой; больше процессов может замедлить задачу при маленьких блоках или общей файловой системе. Сохранить в реализации правило: Отказ рабочий процесс требует повторного назначения независимой работы или завершения всего расчёта с понятной ошибкой; потерянное изменяемое состояние нельзя восстановить предположением. Сохранить в реализации правило: Рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. Сохранить в реализации правило: Аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции.

Вопрос 19 из 30

При переносе кода с `push!(results, @spawnat w f(chunk))` в библиотеку какой критерий нельзя заменять впечатлением «пример работает»?

w_i\downarrow\Rightarrow retry\lor fail

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

Вопрос 20 из 30

Что следует сообщить пользователю библиотеки о поведении `push!(results, @spawnat w f(chunk))`?

Указать в документации: Контроль производительности разделяет вычисление, сериализацию, сеть и простой; больше процессов может замедлить задачу при маленьких блоках или общей файловой системе. Указать в документации: Аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции. Указать в документации: Рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. Указать в документации: После отказа рабочий процесс обычно хватает повторить удалённый вызов с теми же аргументами; частичные побочные эффекты и идемпотентность операции учитывать не требуется. Указать в документации: Отказ рабочий процесс требует повторного назначения независимой работы или завершения всего расчёта с понятной ошибкой; потерянное изменяемое состояние нельзя восстановить предположением.

Вопрос 21 из 30

Как нужно интерпретировать `expr_from_user = :(run(`, не добавляя к коду лишних гарантий?

trust(worker)=trust(process)

using Distributed
addprocs(1)
expr_from_user = :(run(`sh -c 'echo unsafe'`))
# Никогда не передавайте недоверенное выражение в Core.eval на worker.
@show workers() expr_from_user.head

Отдельный рабочий процесс служит границей безопасности: недоверенное выражение не получает прав процесса и видит только явно сериализованные аргументы. Большинство рабочий процессs разделяют глобальные переменные главного процесса по ссылке, поэтому повторная загрузка модулей не нужна. Сериализация аргумента сохраняет общую изменяемую память между процессами, поэтому изменения рабочий процесс видны главному процессу. Удалённый код имеет права процесса и видит переданные данные; кластер не является границей безопасности для недоверенного выражения. `@spawnat` сразу возвращает удалённое значение, а `remotecall_fetch` нужен только для потоковой передачи больших массивов.

Вопрос 22 из 30

Какой тест точнее всего зафиксирует границу поведения `expr_from_user = :(run(`?

using Distributed
addprocs(1)
expr_from_user = :(run(`sh -c 'echo unsafe'`))
# Никогда не передавайте недоверенное выражение в Core.eval на worker.
@show workers() expr_from_user.head

Проверить на отдельном примере, что большинство рабочий процессs разделяют глобальные переменные главного процесса по ссылке, поэтому повторная загрузка модулей не нужна. Проверить на отдельном примере, что `@spawnat` сразу возвращает удалённое значение, а `remotecall_fetch` нужен только для потоковой передачи больших массивов. Проверить на отдельном примере, что отдельный рабочий процесс служит границей безопасности: недоверенное выражение не получает прав процесса и видит только явно сериализованные аргументы. Проверить на отдельном примере, что удалённый код имеет права процесса и видит переданные данные; кластер не является границей безопасности для недоверенного выражения. Проверить на отдельном примере, что сериализация аргумента сохраняет общую изменяемую память между процессами, поэтому изменения рабочий процесс видны главному процессу.

Вопрос 23 из 30

Что должно остаться истинным после рефакторинга участка с `expr_from_user = :(run(`?

using Distributed
addprocs(1)
expr_from_user = :(run(`sh -c 'echo unsafe'`))
# Никогда не передавайте недоверенное выражение в Core.eval на worker.
@show workers() expr_from_user.head

Сохранить в реализации правило: Отдельный рабочий процесс служит границей безопасности: недоверенное выражение не получает прав процесса и видит только явно сериализованные аргументы. Сохранить в реализации правило: `@spawnat` сразу возвращает удалённое значение, а `remotecall_fetch` нужен только для потоковой передачи больших массивов. Сохранить в реализации правило: Большинство рабочий процессs разделяют глобальные переменные главного процесса по ссылке, поэтому повторная загрузка модулей не нужна. Сохранить в реализации правило: Сериализация аргумента сохраняет общую изменяемую память между процессами, поэтому изменения рабочий процесс видны главному процессу. Сохранить в реализации правило: Удалённый код имеет права процесса и видит переданные данные; кластер не является границей безопасности для недоверенного выражения.

Вопрос 24 из 30

Как проверить, что новая реализация `expr_from_user = :(run(` не изменила обещанное пользователю поведение?

trust(worker)=trust(process)

Приёмка должна подтвердить, что удалённый код имеет права процесса и видит переданные данные; кластер не является границей безопасности для недоверенного выражения. Приёмка должна подтвердить, что отдельный рабочий процесс служит границей безопасности: недоверенное выражение не получает прав процесса и видит только явно сериализованные аргументы. Приёмка должна подтвердить, что сериализация аргумента сохраняет общую изменяемую память между процессами, поэтому изменения рабочий процесс видны главному процессу. Приёмка должна подтвердить, что большинство рабочий процессs разделяют глобальные переменные главного процесса по ссылке, поэтому повторная загрузка модулей не нужна. Приёмка должна подтвердить, что `@spawnat` сразу возвращает удалённое значение, а `remotecall_fetch` нужен только для потоковой передачи больших массивов.

Вопрос 25 из 30

Что следует сообщить пользователю библиотеки о поведении `expr_from_user = :(run(`?

Указать в документации: `@spawnat` сразу возвращает удалённое значение, а `remotecall_fetch` нужен только для потоковой передачи больших массивов. Указать в документации: Отдельный рабочий процесс служит границей безопасности: недоверенное выражение не получает прав процесса и видит только явно сериализованные аргументы. Указать в документации: Удалённый код имеет права процесса и видит переданные данные; кластер не является границей безопасности для недоверенного выражения. Указать в документации: Сериализация аргумента сохраняет общую изменяемую память между процессами, поэтому изменения рабочий процесс видны главному процессу. Указать в документации: Большинство рабочий процессs разделяют глобальные переменные главного процесса по ссылке, поэтому повторная загрузка модулей не нужна.

Вопрос 26 из 30

Какой механизм Julia определяет поведение строки `remote_trial = @belapsed begin`?

S_p=T_1/T_p

using Distributed, BenchmarkTools
addprocs(2)
data = rand(1_000_000)
chunks = [data[1:500_000], data[500_001:end]]
remote_trial = @belapsed begin
    fs = [remotecall(sum, w, c) for (w,c) in zip(workers(), $chunks)]
    sum(fetch, fs)
end
local_trial = @belapsed sum($data)
@show local_trial remote_trial

Разделение работы между процессами сокращает время задачи, пока число процессов не превышает число доступных ядер. Отказ рабочий процесс требует повторного назначения независимой работы или завершения всего расчёта с понятной ошибкой; потерянное изменяемое состояние нельзя восстановить предположением. Аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции. Рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. Контроль производительности разделяет вычисление, сериализацию, сеть и простой; больше процессов может замедлить задачу при маленьких блоках или общей файловой системе.

Вопрос 27 из 30

Какой тест точнее всего зафиксирует границу поведения `remote_trial = @belapsed begin`?

using Distributed, BenchmarkTools
addprocs(2)
data = rand(1_000_000)
chunks = [data[1:500_000], data[500_001:end]]
remote_trial = @belapsed begin
    fs = [remotecall(sum, w, c) for (w,c) in zip(workers(), $chunks)]
    sum(fetch, fs)
end
local_trial = @belapsed sum($data)
@show local_trial remote_trial

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

Вопрос 28 из 30

Какое требование к `remote_trial = @belapsed begin` важнее удобной детали текущей реализации?

using Distributed, BenchmarkTools
addprocs(2)
data = rand(1_000_000)
chunks = [data[1:500_000], data[500_001:end]]
remote_trial = @belapsed begin
    fs = [remotecall(sum, w, c) for (w,c) in zip(workers(), $chunks)]
    sum(fetch, fs)
end
local_trial = @belapsed sum($data)
@show local_trial remote_trial

Сохранить в реализации правило: Аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции. Сохранить в реализации правило: Рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо. Сохранить в реализации правило: Разделение работы между процессами сокращает время задачи, пока число процессов не превышает число доступных ядер. Сохранить в реализации правило: Контроль производительности разделяет вычисление, сериализацию, сеть и простой; больше процессов может замедлить задачу при маленьких блоках или общей файловой системе. Сохранить в реализации правило: Отказ рабочий процесс требует повторного назначения независимой работы или завершения всего расчёта с понятной ошибкой; потерянное изменяемое состояние нельзя восстановить предположением.

Вопрос 29 из 30

После обновления Julia или пакета поведение участка с `remote_trial = @belapsed begin` изменилось. Какой критерий приёмки остаётся корректным?

S_p=T_1/T_p

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

Вопрос 30 из 30

Какое ограничение стоит прямо указать в документации к участку с `remote_trial = @belapsed begin`?

Указать в документации: Отказ рабочий процесс требует повторного назначения независимой работы или завершения всего расчёта с понятной ошибкой; потерянное изменяемое состояние нельзя восстановить предположением. Указать в документации: Аргументы и результаты обычно сериализуются и передаются между процессами; крупные данные лучше размещать осознанно, а не посылать заново для каждой мелкой операции. Указать в документации: Контроль производительности разделяет вычисление, сериализацию, сеть и простой; больше процессов может замедлить задачу при маленьких блоках или общей файловой системе. Указать в документации: Разделение работы между процессами сокращает время задачи, пока число процессов не превышает число доступных ядер. Указать в документации: Рабочий процесс — отдельный процесс со своим глобальным состоянием и окружением; определение функции на главном процессе не всегда автоматически доступно удалённо.