Вычисления на GPU — бесплатный тест онлайн

Вопрос 1 из 30

Какое утверждение точнее всего объясняет участок с `@show typeof(y) sum(Array(y[1:10]))`?

x\in\mathrm{DeviceMemory}

using CUDA
x = CUDA.rand(Float32, 1_000_000)
y = @. 2f0*x + sin(x)
@show typeof(y) sum(Array(y[1:10]))

`CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU. Код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро. Переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством. Тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно. Диспетчеризация по `CuArray` переносит операцию на GPU даже тогда, когда библиотека не объявляет специальной реализации для этого типа.

Вопрос 2 из 30

Какой контрольный тест лучше всего проверит правило, связанное с `@show typeof(y) sum(Array(y[1:10]))`?

using CUDA
x = CUDA.rand(Float32, 1_000_000)
y = @. 2f0*x + sin(x)
@show typeof(y) sum(Array(y[1:10]))

Проверить на отдельном примере, что код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро. Проверить на отдельном примере, что переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством. Проверить на отдельном примере, что диспетчеризация по `CuArray` переносит операцию на GPU даже тогда, когда библиотека не объявляет специальной реализации для этого типа. Проверить на отдельном примере, что тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно. Проверить на отдельном примере, что `CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU.

Вопрос 3 из 30

Какое решение устраняет риск вокруг `@show typeof(y) sum(Array(y[1:10]))`, не меняя поведение на допустимых данных?

using CUDA
x = CUDA.rand(Float32, 1_000_000)
y = @. 2f0*x + sin(x)
@show typeof(y) sum(Array(y[1:10]))

Сохранить в реализации правило: Тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно. Сохранить в реализации правило: Переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством. Сохранить в реализации правило: `CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU. Сохранить в реализации правило: Код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро. Сохранить в реализации правило: Диспетчеризация по `CuArray` переносит операцию на GPU даже тогда, когда библиотека не объявляет специальной реализации для этого типа.

Вопрос 4 из 30

Как проверить, что новая реализация `@show typeof(y) sum(Array(y[1:10]))` не изменила обещанное пользователю поведение?

x\in\mathrm{DeviceMemory}

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

Вопрос 5 из 30

Какое ограничение стоит прямо указать в документации к участку с `@show typeof(y) sum(Array(y[1:10]))`?

Указать в документации: Диспетчеризация по `CuArray` переносит операцию на GPU даже тогда, когда библиотека не объявляет специальной реализации для этого типа. Указать в документации: Переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством. Указать в документации: `CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU. Указать в документации: Тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно. Указать в документации: Код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро.

Вопрос 6 из 30

Какое объяснение для `@cuda threads=256 blocks=cld(length(x), 256) saxpy_kernel!(y, 2f0, x)` выдержит проверку на другом допустимом входе?

i=(b-1)t+j

using CUDA
function saxpy_kernel!(y, a, x)
    i = (blockIdx().x - 1) * blockDim().x + threadIdx().x
    if i <= length(y)
        @inbounds y[i] = a*x[i] + y[i]
    end
    return
end
x = CUDA.rand(Float32, 1024); y = CUDA.ones(Float32, 1024)
@cuda threads=256 blocks=cld(length(x), 256) saxpy_kernel!(y, 2f0, x)
synchronize()
@show sum(Array(y[1:8]))

Если число запущенных потоков равно длине массива, ядро не нуждается в проверке границы: планировщик устройства не создаёт лишних индексов. Диспетчеризация по `CuArray` переносит операцию на GPU даже тогда, когда библиотека не объявляет специальной реализации для этого типа. Публичный API с типом `CuArray` остаётся переносимым на AMD и CPU, потому что все массив другого вычислительного устройстваы совместимы по наследованию. Kernel должен явно вычислять индекс, проверять границы и избегать гонок записи; число потоков запуска не обязано совпадать с длиной данных. Передача host-device имеет заметную цену, поэтому несколько операций объединяют на GPU и не копируют массив ради каждого небольшого шага.

Вопрос 7 из 30

Какой контрольный тест лучше всего проверит правило, связанное с `@cuda threads=256 blocks=cld(length(x), 256) saxpy_kernel!(y, 2f0, x)`?

using CUDA
function saxpy_kernel!(y, a, x)
    i = (blockIdx().x - 1) * blockDim().x + threadIdx().x
    if i <= length(y)
        @inbounds y[i] = a*x[i] + y[i]
    end
    return
end
x = CUDA.rand(Float32, 1024); y = CUDA.ones(Float32, 1024)
@cuda threads=256 blocks=cld(length(x), 256) saxpy_kernel!(y, 2f0, x)
synchronize()
@show sum(Array(y[1:8]))

Проверить на отдельном примере, что если число запущенных потоков равно длине массива, ядро не нуждается в проверке границы: планировщик устройства не создаёт лишних индексов. Проверить на отдельном примере, что ядро должен явно вычислять индекс, проверять границы и избегать гонок записи; число потоков запуска не обязано совпадать с длиной данных. Проверить на отдельном примере, что передача host-device имеет заметную цену, поэтому несколько операций объединяют на GPU и не копируют массив ради каждого небольшого шага. Проверить на отдельном примере, что диспетчеризация по `CuArray` переносит операцию на GPU даже тогда, когда библиотека не объявляет специальной реализации для этого типа. Проверить на отдельном примере, что публичный API с типом `CuArray` остаётся переносимым на AMD и CPU, потому что все массив другого вычислительного устройстваы совместимы по наследованию.

Вопрос 8 из 30

Какую гарантию должна сохранить правка участка с `@cuda threads=256 blocks=cld(length(x), 256) saxpy_kernel!(y, 2f0, x)`?

using CUDA
function saxpy_kernel!(y, a, x)
    i = (blockIdx().x - 1) * blockDim().x + threadIdx().x
    if i <= length(y)
        @inbounds y[i] = a*x[i] + y[i]
    end
    return
end
x = CUDA.rand(Float32, 1024); y = CUDA.ones(Float32, 1024)
@cuda threads=256 blocks=cld(length(x), 256) saxpy_kernel!(y, 2f0, x)
synchronize()
@show sum(Array(y[1:8]))

Сохранить в реализации правило: Передача host-device имеет заметную цену, поэтому несколько операций объединяют на GPU и не копируют массив ради каждого небольшого шага. Сохранить в реализации правило: Если число запущенных потоков равно длине массива, ядро не нуждается в проверке границы: планировщик устройства не создаёт лишних индексов. Сохранить в реализации правило: Диспетчеризация по `CuArray` переносит операцию на GPU даже тогда, когда библиотека не объявляет специальной реализации для этого типа. Сохранить в реализации правило: Публичный API с типом `CuArray` остаётся переносимым на AMD и CPU, потому что все массив другого вычислительного устройстваы совместимы по наследованию. Сохранить в реализации правило: Kernel должен явно вычислять индекс, проверять границы и избегать гонок записи; число потоков запуска не обязано совпадать с длиной данных.

Вопрос 9 из 30

Какой результат приёмочного теста подтвердит корректность участка с `@cuda threads=256 blocks=cld(length(x), 256) saxpy_kernel!(y, 2f0, x)`?

i=(b-1)t+j

Приёмка должна подтвердить, что если число запущенных потоков равно длине массива, ядро не нуждается в проверке границы: планировщик устройства не создаёт лишних индексов. Приёмка должна подтвердить, что ядро должен явно вычислять индекс, проверять границы и избегать гонок записи; число потоков запуска не обязано совпадать с длиной данных. Приёмка должна подтвердить, что публичный API с типом `CuArray` остаётся переносимым на AMD и CPU, потому что все массив другого вычислительного устройстваы совместимы по наследованию. Приёмка должна подтвердить, что передача host-device имеет заметную цену, поэтому несколько операций объединяют на GPU и не копируют массив ради каждого небольшого шага. Приёмка должна подтвердить, что диспетчеризация по `CuArray` переносит операцию на GPU даже тогда, когда библиотека не объявляет специальной реализации для этого типа.

Вопрос 10 из 30

Какое ограничение стоит прямо указать в документации к участку с `@cuda threads=256 blocks=cld(length(x), 256) saxpy_kernel!(y, 2f0, x)`?

Указать в документации: Публичный API с типом `CuArray` остаётся переносимым на AMD и CPU, потому что все массив другого вычислительного устройстваы совместимы по наследованию. Указать в документации: Диспетчеризация по `CuArray` переносит операцию на GPU даже тогда, когда библиотека не объявляет специальной реализации для этого типа. Указать в документации: Передача host-device имеет заметную цену, поэтому несколько операций объединяют на GPU и не копируют массив ради каждого небольшого шага. Указать в документации: Kernel должен явно вычислять индекс, проверять границы и избегать гонок записи; число потоков запуска не обязано совпадать с длиной данных. Указать в документации: Если число запущенных потоков равно длине массива, ядро не нуждается в проверке границы: планировщик устройства не создаёт лишних индексов.

Вопрос 11 из 30

Что именно следует из фрагмента с `out[i] = parse(Float32, string(x[i]))`?

i\le n

using CUDA
function bad_kernel!(out, x)
    i = threadIdx().x
    i <= length(out) || return
    out[i] = parse(Float32, string(x[i]))
    return
end
x = CUDA.ones(Float32, 32); out = similar(x)
# string/parse не являются допустимой операцией kernel.

Тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно. Kernel может использовать произвольные строки, исключения и динамическое выделение памяти так же, как обычная функция CPU. Переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством. `CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU. Код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро.

Вопрос 12 из 30

Какой тест точнее всего зафиксирует границу поведения `out[i] = parse(Float32, string(x[i]))`?

using CUDA
function bad_kernel!(out, x)
    i = threadIdx().x
    i <= length(out) || return
    out[i] = parse(Float32, string(x[i]))
    return
end
x = CUDA.ones(Float32, 32); out = similar(x)
# string/parse не являются допустимой операцией kernel.

Проверить на отдельном примере, что тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно. Проверить на отдельном примере, что ядро может использовать произвольные строки, исключения и динамическое выделение памяти так же, как обычная функция CPU. Проверить на отдельном примере, что переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством. Проверить на отдельном примере, что код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро. Проверить на отдельном примере, что `CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU.

Вопрос 13 из 30

Какой контракт следует закрепить при переработке строки `out[i] = parse(Float32, string(x[i]))`?

using CUDA
function bad_kernel!(out, x)
    i = threadIdx().x
    i <= length(out) || return
    out[i] = parse(Float32, string(x[i]))
    return
end
x = CUDA.ones(Float32, 32); out = similar(x)
# string/parse не являются допустимой операцией kernel.

Сохранить в реализации правило: Код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро. Сохранить в реализации правило: Kernel может использовать произвольные строки, исключения и динамическое выделение памяти так же, как обычная функция CPU. Сохранить в реализации правило: Тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно. Сохранить в реализации правило: `CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU. Сохранить в реализации правило: Переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством.

Вопрос 14 из 30

Две реализации участка с `out[i] = parse(Float32, string(x[i]))` совпадают на обычных данных. Что необходимо проверить перед выпуском?

i\le n

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

Вопрос 15 из 30

Что следует сообщить пользователю библиотеки о поведении `out[i] = parse(Float32, string(x[i]))`?

Указать в документации: Переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством. Указать в документации: Тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно. Указать в документации: Kernel может использовать произвольные строки, исключения и динамическое выделение памяти так же, как обычная функция CPU. Указать в документации: Код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро. Указать в документации: `CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU.

Вопрос 16 из 30

Какое объяснение для `x_gpu = CuArray($x_cpu)` выдержит проверку на другом допустимом входе?

T=T_{H2D}+T_{kernel}+T_{D2H}

using CUDA, BenchmarkTools
x_cpu = rand(Float32, 1_000_000)
t = @belapsed begin
    x_gpu = CuArray($x_cpu)
    y_gpu = sin.(x_gpu)
    Array(y_gpu)
end
@show t

Диспетчеризация по `CuArray` переносит операцию на GPU даже тогда, когда библиотека не объявляет специальной реализации для этого типа. Kernel может использовать произвольные строки, исключения и динамическое выделение памяти так же, как обычная функция CPU. Передача host-device имеет заметную цену, поэтому несколько операций объединяют на GPU и не копируют массив ради каждого небольшого шага. Копирование одного небольшого массива на GPU почти бесплатно и не влияет на решение, где выполнять короткий расчёт. Kernel должен явно вычислять индекс, проверять границы и избегать гонок записи; число потоков запуска не обязано совпадать с длиной данных.

Вопрос 17 из 30

Какой контрольный тест лучше всего проверит правило, связанное с `x_gpu = CuArray($x_cpu)`?

using CUDA, BenchmarkTools
x_cpu = rand(Float32, 1_000_000)
t = @belapsed begin
    x_gpu = CuArray($x_cpu)
    y_gpu = sin.(x_gpu)
    Array(y_gpu)
end
@show t

Проверить на отдельном примере, что диспетчеризация по `CuArray` переносит операцию на GPU даже тогда, когда библиотека не объявляет специальной реализации для этого типа. Проверить на отдельном примере, что ядро может использовать произвольные строки, исключения и динамическое выделение памяти так же, как обычная функция CPU. Проверить на отдельном примере, что копирование одного небольшого массива на GPU почти бесплатно и не влияет на решение, где выполнять короткий расчёт. Проверить на отдельном примере, что передача host-device имеет заметную цену, поэтому несколько операций объединяют на GPU и не копируют массив ради каждого небольшого шага. Проверить на отдельном примере, что ядро должен явно вычислять индекс, проверять границы и избегать гонок записи; число потоков запуска не обязано совпадать с длиной данных.

Вопрос 18 из 30

Какое требование к `x_gpu = CuArray($x_cpu)` важнее удобной детали текущей реализации?

using CUDA, BenchmarkTools
x_cpu = rand(Float32, 1_000_000)
t = @belapsed begin
    x_gpu = CuArray($x_cpu)
    y_gpu = sin.(x_gpu)
    Array(y_gpu)
end
@show t

Сохранить в реализации правило: Kernel должен явно вычислять индекс, проверять границы и избегать гонок записи; число потоков запуска не обязано совпадать с длиной данных. Сохранить в реализации правило: Копирование одного небольшого массива на GPU почти бесплатно и не влияет на решение, где выполнять короткий расчёт. Сохранить в реализации правило: Kernel может использовать произвольные строки, исключения и динамическое выделение памяти так же, как обычная функция CPU. Сохранить в реализации правило: Диспетчеризация по `CuArray` переносит операцию на GPU даже тогда, когда библиотека не объявляет специальной реализации для этого типа. Сохранить в реализации правило: Передача host-device имеет заметную цену, поэтому несколько операций объединяют на GPU и не копируют массив ради каждого небольшого шага.

Вопрос 19 из 30

После обновления Julia или пакета поведение участка с `x_gpu = CuArray($x_cpu)` изменилось. Какой критерий приёмки остаётся корректным?

T=T_{H2D}+T_{kernel}+T_{D2H}

Приёмка должна подтвердить, что kernel должен явно вычислять индекс, проверять границы и избегать гонок записи; число потоков запуска не обязано совпадать с длиной данных. Приёмка должна подтвердить, что диспетчеризация по `CuArray` переносит операцию на GPU даже тогда, когда библиотека не объявляет специальной реализации для этого типа. Приёмка должна подтвердить, что передача host-device имеет заметную цену, поэтому несколько операций объединяют на GPU и не копируют массив ради каждого небольшого шага. Приёмка должна подтвердить, что копирование одного небольшого массива на GPU почти бесплатно и не влияет на решение, где выполнять короткий расчёт. Приёмка должна подтвердить, что ядро может использовать произвольные строки, исключения и динамическое выделение памяти так же, как обычная функция CPU.

Вопрос 20 из 30

Какое утверждение о `x_gpu = CuArray($x_cpu)` является переносимым правилом, а не особенностью одного запуска?

Указать в документации: Передача host-device имеет заметную цену, поэтому несколько операций объединяют на GPU и не копируют массив ради каждого небольшого шага. Указать в документации: Диспетчеризация по `CuArray` переносит операцию на GPU даже тогда, когда библиотека не объявляет специальной реализации для этого типа. Указать в документации: Копирование одного небольшого массива на GPU почти бесплатно и не влияет на решение, где выполнять короткий расчёт. Указать в документации: Kernel может использовать произвольные строки, исключения и динамическое выделение памяти так же, как обычная функция CPU. Указать в документации: Kernel должен явно вычислять индекс, проверять границы и избегать гонок записи; число потоков запуска не обязано совпадать с длиной данных.

Вопрос 21 из 30

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

f(::AbstractArray)

using GPUArraysCore
function energy(x::AbstractArray)
    return sum(abs2, x)
end
cpu = rand(Float32, 1000)
@show energy(cpu)
# Тот же контракт может использовать CuArray или другой backend-массив.

Публичный API с типом `CuArray` остаётся переносимым на AMD и CPU, потому что все массив другого вычислительного устройстваы совместимы по наследованию. Код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро. `CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU. Переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством. Тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно.

Вопрос 22 из 30

Какой тест точнее всего зафиксирует границу поведения `function energy(x::AbstractArray)`?

using GPUArraysCore
function energy(x::AbstractArray)
    return sum(abs2, x)
end
cpu = rand(Float32, 1000)
@show energy(cpu)
# Тот же контракт может использовать CuArray или другой backend-массив.

Проверить на отдельном примере, что код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро. Проверить на отдельном примере, что тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно. Проверить на отдельном примере, что переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством. Проверить на отдельном примере, что `CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU. Проверить на отдельном примере, что публичный API с типом `CuArray` остаётся переносимым на AMD и CPU, потому что все массив другого вычислительного устройстваы совместимы по наследованию.

Вопрос 23 из 30

Какой контракт следует закрепить при переработке строки `function energy(x::AbstractArray)`?

using GPUArraysCore
function energy(x::AbstractArray)
    return sum(abs2, x)
end
cpu = rand(Float32, 1000)
@show energy(cpu)
# Тот же контракт может использовать CuArray или другой backend-массив.

Сохранить в реализации правило: Публичный API с типом `CuArray` остаётся переносимым на AMD и CPU, потому что все массив другого вычислительного устройстваы совместимы по наследованию. Сохранить в реализации правило: Тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно. Сохранить в реализации правило: `CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU. Сохранить в реализации правило: Код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро. Сохранить в реализации правило: Переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством.

Вопрос 24 из 30

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

f(::AbstractArray)

Приёмка должна подтвердить, что переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством. Приёмка должна подтвердить, что код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро. Приёмка должна подтвердить, что тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно. Приёмка должна подтвердить, что публичный API с типом `CuArray` остаётся переносимым на AMD и CPU, потому что все массив другого вычислительного устройстваы совместимы по наследованию. Приёмка должна подтвердить, что `CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU.

Вопрос 25 из 30

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

Указать в документации: Переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством. Указать в документации: `CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU. Указать в документации: Публичный API с типом `CuArray` остаётся переносимым на AMD и CPU, потому что все массив другого вычислительного устройстваы совместимы по наследованию. Указать в документации: Код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро. Указать в документации: Тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно.

Вопрос 26 из 30

Что именно следует из фрагмента с `@test gpu ≈ cpu rtol=1f-5`?

\lVert y_{gpu}-y_{cpu}\rVert\le\tau

using CUDA, Test
CUDA.functional() || @info "GPU tests skipped: CUDA unavailable"
if CUDA.functional()
    x = rand(Float32, 257)
    cpu = x.^2 .+ 1
    gpu = Array(CuArray(x).^2 .+ 1)
    @test gpu ≈ cpu rtol=1f-5
end

Код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро. `CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU. Тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно. Переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством. Если GPU-код скомпилировался и совпал с ожидаемым ответом на одном размере массива, CPU-эталон, другие размеры и отдельный режим CI без GPU не нужны.

Вопрос 27 из 30

Какой тест точнее всего зафиксирует границу поведения `@test gpu ≈ cpu rtol=1f-5`?

using CUDA, Test
CUDA.functional() || @info "GPU tests skipped: CUDA unavailable"
if CUDA.functional()
    x = rand(Float32, 257)
    cpu = x.^2 .+ 1
    gpu = Array(CuArray(x).^2 .+ 1)
    @test gpu ≈ cpu rtol=1f-5
end

Проверить на отдельном примере, что `CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU. Проверить на отдельном примере, что тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно. Проверить на отдельном примере, что если GPU-код скомпилировался и совпал с ожидаемым ответом на одном размере массива, CPU-эталон, другие размеры и отдельный режим CI без GPU не нужны. Проверить на отдельном примере, что код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро. Проверить на отдельном примере, что переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством.

Вопрос 28 из 30

Какую гарантию должна сохранить правка участка с `@test gpu ≈ cpu rtol=1f-5`?

using CUDA, Test
CUDA.functional() || @info "GPU tests skipped: CUDA unavailable"
if CUDA.functional()
    x = rand(Float32, 257)
    cpu = x.^2 .+ 1
    gpu = Array(CuArray(x).^2 .+ 1)
    @test gpu ≈ cpu rtol=1f-5
end

Сохранить в реализации правило: Если GPU-код скомпилировался и совпал с ожидаемым ответом на одном размере массива, CPU-эталон, другие размеры и отдельный режим CI без GPU не нужны. Сохранить в реализации правило: Переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством. Сохранить в реализации правило: Код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро. Сохранить в реализации правило: `CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU. Сохранить в реализации правило: Тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно.

Вопрос 29 из 30

Как проверить, что новая реализация `@test gpu ≈ cpu rtol=1f-5` не изменила обещанное пользователю поведение?

\lVert y_{gpu}-y_{cpu}\rVert\le\tau

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

Вопрос 30 из 30

Как сформулировать границу механизма `@test gpu ≈ cpu rtol=1f-5` без чрезмерного обещания?

Указать в документации: Тестирование сравнивает небольшой GPU-результат с CPU-эталоном, проверяет разные размеры и допускает особенности округления; наличие устройства в CI нужно обрабатывать явно. Указать в документации: `CuArray` и другие GPU-массивы хранят данные на устройстве; обычная операция высокого уровня быстра только когда имеет GPU-реализацию и не вызывает скрытого возврата на CPU. Указать в документации: Переносимость достигается общими абстракциями массивов и небольшими границами платформенных реализаций; CUDA-специфичный тип в публичной модели связывает весь пакет с одним устройством. Указать в документации: Если GPU-код скомпилировался и совпал с ожидаемым ответом на одном размере массива, CPU-эталон, другие размеры и отдельный режим CI без GPU не нужны. Указать в документации: Код устройства ограничен поддерживаемыми типами, динамикой и выделением памяти; случайный вызов неподдерживаемой функции обнаруживается при компиляции ядро.