Эпиграф
«История компьютерных устройств — это рассказ том, что почему они сегодня уже не работают. Но иногда приходит человек и портит мне всю статистику.»
— ChatGPT 5 сказал

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

Пролог

Наша «цифровая археология» началась с простого вопроса, набранного почти случайно — и слишком рано отправленного в терминал. «Есть компьютер с установленной картой NVIDIA GeForce 8600 GTS, Ubuntu 18. Понимаю, что оборудование старое…» Я нажал Enter, и фраза оборвалась. Но ChatGPT уже откликнулся — бодро, даже с некоторой игривостью:

«О, замечательный вопрос — и да, GeForce 8600 GTS действительно настоящая „ветеранская классика“ начала эры CUDA!» «Эта карта выпущена в 2007 году, архитектура Tesla (G80/G84/G86). Несмотря на свой… хм… исторический возраст, она поддерживает CUDA 1.1 /1/ и может запускать простые CUDA-ядра уровня Hello World. Не потянет современные фреймворки, но идеальна для демонстрации архитектуры, потоков, блоков, простейших параллельных операций — прямо как учебный стенд по истории технологий».

Так, шутливо и вдохновляюще, началось наше расследование.
Чтобы, однако, понять в чем заключались особенности истории, я начну с того, что приглашу заглянуть внутрь компьютера — так, словно мы археологи, осторожно очищающие слои песка.

Как устроен обычный компьютер — и почему эта видеокарта в нём - "особенная"

Сегодня общеизвестно, что в компьютере есть:

• процессор — «мозг», который выполняет команды;
• оперативная память — место, где хранятся данные во время работы;
• накопители — долговременная память;
• устройства ввода и вывода — клавиатура, мышь, экран.

И традиционно видеокарта воспринималась как устройство вывода: она просто принимала изображение от процессора и выводила на экран.
Но! Это только первая часть правды.
У видеокарты есть собственный процессор — видеочип. А это уже куда интереснее. Это значит, что внутри системы живёт ещё один мозг, работающий параллельно с основным.

Многие уже в школе знакомятся с анатомией вычислительных устройств. Всемирно известный пример - школьные занятия с микроконтроллером Arduino.

Arduino — это маленький отдельный компьютер:

• получает программу по USB,
• выполняет её самостоятельно,
• управляет лампочками, датчиками, моторами.

GPU (Graphics Processor Unit) - процессор графической видеоплаты, работает похожим образом:

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

👉 Разница в том, что Arduino живёт отдельно, а GPU встроена в компьютер.
Но логика работы этих устройств весьма похожа!
Это — первый шаг к пониманию того, что моё желание заключалось в том, чтобы испытать GPU как вычислительное устройство, а не просто «передатчик картинки».

Почему видеокарта оказалась такой мощной машиной

Когда инженеры-электронщики создавали видеочипы, они решали простую задачу: вывести изображение как можно быстрее.
А картинка состоит из миллионов точек, каждой из которых можно управлять отдельно, и тут появляется важное слово — одновременно! Родилась ключевая идея:
Видеокарта — это устройство, в котором много маленьких простых «мозгов» будут работать одновременно, то есть, как говорят в информатике - "параллельно".
Это не как один профессор-математик - центральный процессов (Central Processing Unit - CPU), а как целый муравейник рабочих (GPU):

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

Это и есть основа параллельных вычислений.

Появление первых программируемых видеокарт: рождение CUDA

Когда инженеры-электронщики фирмы-пионера производства графических ускорителей NVIDIA в 2007 году выпустили CUDA, то это было фактическое заявление:
«А что если позволить людям писать для видеокарты свои собственные программы, а не только смотреть на нарисованные видеокартой пиксели?»
GeForce 8600 GTS как раз принадлежит к этой ранней эпохе.
Это как первый автомобиль с бензиновым двигателем: ездит, но у него свои странности.
Почему NVIDIA решила дать видеокарте возможность считать числа?
Для этого была очень логичная инженерная причина. Старые графические процессоры работали так:

1. CPU готовит картинку.
2. GPU её показывает.

Но GPU от природы очень хорошо умеет делать одни и те же простые операции много раз подряд.
Это идеальное устройство для задач, где надо:

• обработать тысячи точек,
• применить одно действие к массиву данных,
• повторить одну операцию множество раз.

А такие задачи есть и в… математике, физике, биологии и — наконец — искусственном интеллекте.
Так родились первые видеокарты-учёные, способные решать математические задачи.

Первые поколения GPU NVIDIA

GeForce 8600 GTS состоит из нескольких десятков простых «микропроцессоров». Эти маленькие вычислительные блоки называются Streaming Processors - «потоковыми процессорами» (SM). Каждый из них довольно простенький, но скорость появлялается благодаря их количеству.
Все эти микропроцессоры умеют работать одновременно, и это - ключ к производительности.
CPU делает действие → другое → третье.
GPU делает тысячи действий одновременно.
У GPU есть своя маленькая память. Не как у компьютера — скромнее, проще, более ограничена.
Из-за этого Ваш код программы для GPU работает с небольшим количеством байт, а не с огромным массивом.
Именно так выглядели первые эксперименты с CUDA в 2007–2008 годах.
GPU первых поколений были как Arduino с сотнями исполнителей. Они:

• получали маленькую программу,
• выполняли её над своими данными,
• возвращали результат CPU.

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

Почему и Arduino, и GPU говорят на языке C

Arduino, и графические процессоры NVIDIA используют C-подобные языки программирования, и это не случайно.
Представим, что Вы пишете программу для Arduino:

if (led == 0)
  led = 1;
else
  led = 0;

Этот код включает и выключает светодиод. Простой, понятный, прямой. Теперь посмотрим на то, что как выглядит программа для видеокарты GeForce 8600 GTS:

// Просто инвертируем 0 -> 1 и 1 -> 0
__global__ void blink_kernel(unsigned char *flag) { 
  if (*flag == 0)
    *flag = 1;
  else
    *flag = 0;
}

Если закрыть глаза на слова __global__ и *flag, то логика почти такая же!
GPU делает с данным числом то же, что Arduino делает с пином светодиода.
Почему так произошло? Потому что конструкторы NVIDIA решили дать видеокарте самостоятельность — возможность выполнять не только команды «нарисовать картинку», но и любую вычислительную программу, написанную человеком.
А если речь идёт о быстрых вычислениях, то язык C — лучший кандидат:

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

GPU превратился в что-то большее, чем просто «устройство вывода».

Маленькие рабочие внутри видеокарты

Когда мы говорим, что видеокарта имеет «32 ядра» (как GeForce 8600 GTS), не стоит представлять их как 32 копии процессора компьютера.
На самом деле это 32 маленьких вычислительных элемента — проще и примитивнее CPU, но:

• они работают одновременно,
• у каждого своё простое задание,
• и они чрезвычайно быстры в однотипных задачах.

Представьте школьный класс, в котором каждый ученик решает один и тот же простой пример, но на разных числах.
Учитель (CPU) задаёт контрольную работу, и весь класс (GPU) решает сразу 30 задач, а не одну.
Так и работает видеокарта. CPU — это начальник, который умеет всё:

• логика,
• принятие решений,
• переходы по условиям,
• сложные операции.

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

• изменения элемента массива,
• многократного выполнения одинаковой формулы,
• управления точками изображения

-- GPU оказывается мгновенным.

Блоки, "нити" и планировщик

Когда CPU отправляет задачу видеокарте, он говорит примерно следующее: «У меня есть столько-то одинаковых действий. GPU, пожалуйста, распределяй их между своими маленькими ядрами.»
Дальше происходит следующее:

1. GPU получает программу.
2. Делит работу на маленькие подзадачи — нити.
3. Эти нити группируются в блоки — как рабочие группы на фабрике.
4. Каждый блок отправляется на определённый участок чипа — вычислительный мультипроцессор.

И всё это делается полностью автоматически.
То есть программист говорит лишь: «Запусти 1 задачу» или «Запусти 1000 одинаковых задач»,
а GPU сам решает, кто из его маленьких рабочих будет что выполнять.

Вот здесь начинается настоящая археология.

Ограничение №1: очень маленькое количество вычислительных блоков
У GeForce 8600 GTS — примерно 32 «рабочих».
Для сравнения: у современных карт — тысячи.
Поэтому старые GPU позволяли:

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

Ограничение №2: почти не было «умной» памяти.
У GPU есть своя память.
У современных — большая, гибкая, умная.
У древних — маленькая и капризная.
У GeForce 8600:

• мало общей памяти,
• строгие правила доступа,
• нет многих современных механизмов оптимизации.

Поэтому любая программа для первых GPU должна быть компактной и предсказуемой.

Ограничение №3: видеокарта не умела управлять собой.
Сегодня GPU может запускать новые задачи прямо из своих программ.
В старых картах — нет.
Это значит:

• CPU запускает программу,
• GPU выполняет,
• GPU возвращает результат,
• CPU решает, что делать дальше.

Это совсем как Arduino:

• он выполняет команды загруженной программы,
• но программу он всегда получает от компьютера.

Характеристики GeForce GTS 8600

Видео карта располагает на борту 32 «шейдерными процессорами».
Ничего мистического — просто историческое название.
Название "шейдерный" от английйского слова "shader" пришло из графики.
«Шейдером» называли программу, которая вычисляет освещение, цвет, отражение, тени на пикселях.
Соответственно:

• шейдерный процессор — это маленькое ядро, которое выполняет такие мини-программы.

Но затем эти же самые процессоры стали использовать и для математики!
То есть:

✔ Шейдерный процессор = вычислительное ядро для графики и для CUDA

Эти процессоры используют 128-битную шину данных: это не разрядность вычислений!

❌ 128 бит GPU ≠ 128-битный процессор

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

✔ 128 бит — ширина шины памяти, то есть «дороги» между GPU и видеопамятью

Представим шоссе:

• больше полос → больше машин проезжает за секунду;
• 128 бит → 16 байт передаются за один такт памяти.

Это подобие автострады шириной 128 полос, по которому память посылает данные в GPU.
64 битная разрядность современного CPU означает размер числа в битах, получаемого для обработки — это другое шоссе, для других целей.
⭐ Означает ли, что если GPU располагает 128 битной шиной данных, что и CPU когда-нибудь будет 128-битным?
Скорее всего — нет.
GPU и CPU решают разные задачи:

• CPU — сложная логика → требует широких регистров (32→64 бита).
• GPU — поток данных → требует широких шин данных для оперативной памяти (128→256→384→512 бит).

Это разные ветви эволюции компьютерных устройств. Карта GeForce GTS 8600 располагает разными рабочими частотами:

📌 На GeForce 8600 GTS было две частоты:

1. Основная частота GPU — 675 МГц
Это частота блока, который управляет видеокартой, растеризует изображение, координирует потоки.
2. Частота шейдеров — 1450 МГц

То есть крошечные вычислительные ядра работали более чем вдвое быстрее, чем управляющий блок.
675 МГц и 1.45 ГГц — почему в карте две скорости?
Почему так?<

✔ Потому что шейдерные процессоры выполняют самую массовую работу.

Чем быстрее они обрабатывают числа, тем выше производительность в играх и вычислениях.
Значит:

⭐ На GPU разные части карты работали на разных частотах

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

Видеокарта GeForce GTS 8600 имела 256 МБ видеопамяти: немного по современным меркам, но достаточно для чтоб ызапустить вычисления версии CUDA 1.1

• эта память — не ОЗУ компьютера,
• это память только для GPU,
• CPU не может напрямую в неё писать без специальных команд.

Для CUDA времён SM 1.1 такого объёма было достаточно, потому что:

• нейросетей не было,
• текстуры были маленькие,
• массивы данных — компактные,
• задачи — простые.

Для чего нужна была пропускная способность памяти 32 ГБайт/с?
Количество передаваемых данных (пропусная способность) рассчитывается по формуле:
Частота шины (Гц) х Ширина (Разрядность, бит) шины = Количество данных (бит/сек)
В нашем случае:

• 128 бит = 16 байт
• 2 ГГц (эффективных при использовании памяти типа GDDR3)

16 байт×2⋅10⁹=32⋅10⁹байт/сек

⭐ Значит ли это, что память и GPU работают на разных частотах?

Да! И это принципиально важно:

✔ GPU ядра → работают на своей частоте (675 МГц / 1450 МГц)

✔ Память → работает на своей частоте (1000 МГц физической, 2000 МГц эффективной)

У них:

• разные задачи,
• разные схемы,
• разные физические свойства.

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

Первые находки

ИИ быстро перечислил особенности карты, словно опытный архивист, знающий каждую страницу технологической хроники:

• Compute Capability: 1.1 /2/
• Поддерживаемый Toolkit /3/: примерно CUDA 2.3 (частично — 3.0)
• Нет OpenCL/4/, нет NVDEC/NVENC/5/, нет современных профилировщиков
• OpenGL /6/ работает только через старый проприетарный драйвер/7/
• Современное ПО ИИ несовместимо

Это звучало как предупреждение, но одновременно — как приглашение к эксперименту.
Для учебных задач карта подходила идеально:
простые CUDA-ядра, параллельное умножение массивов, демонстрация архитектурных принципов.

— «Что ж, спасибо», — сказал я. — «Вот вывод nvidia-smi».

ИИ на минуту задумался — слишком долго для машины: две минуты и одиннадцать секунд.
Ответ наконец появился плавно и уверенно:

«Удивительно! Просто великолепно, что драйвер 340.108 у вас встал — это уже половина победы. Карта определилась корректно, температура в норме, питание тоже».

И далее — ключевой момент:

«Compute Capability 1.1 — и это значит, что CUDA у вас будет работать. Ограниченно, экспериментально, но будет».

Поэтому я решил не останавливаться.

Мечта об учебной CUDA и первая трещина в планах

«Хотелось бы попробовать в учебных целях продемонстрировать работу CUDA», — написал я.

Надпись «Думает…» снова появилась на экране.
ChatGPT — мой виртуальный собеседник — отреагировал так, как реагировали бы большинство людей-специалистов:

«Честно? Это музейная экспозиция. Карта Tesla первого поколения, поддерживает только Compute Capability 1.1.
Современные CUDA, современные фреймворки — всё мимо. Драйвер 340.xx — последний, кто ещё помнит об этой карте.
Разве что учебные примеры уровня “Hello, GPU”… да и то под большой вопрос.»

Этот скепсис был почти трогателен.
Машина говорила со мной как старший коллега, мягко предостерегающий новичка от слишком больших ожиданий.
ИИ настаивал:

«Даже если поднимете драйвер, CUDA 9.1 из репозиториев не заработает — она физически не поддерживает вашу архитектуру.
Максимум — CUDA 6.5, и то на старых системах. На Ubuntu 18.04 это будет хрупкий Frankenstein.»

Но я — упрям.

При установке пакета команда:

sudo apt install nvidia-cuda-toolkit

предсказуемо закончилась длинным списком успешных операций и одной роковой строкой:
При обработке следующих пакетов произошли ошибки:

libnvidia-compute-530...
E: Sub-process /usr/bin/dpkg returned an error code (1)
libnvidia-compute-530 конфликтует с установленным nvidia-340
Unknown option 'deviceemu'
Toolkit: Installation Failed

На просьбу прокомментировать логи ответов ИИ снова «думал…» — и подозрительно долго.

Наконец, ответ возник, с оттенком негромкого, но честного скепсиса:

«Короче: вы всё сделали правильно, но система честно намекает: с этим железом нормальную CUDA под Ubuntu 18.04 завести почти нереально».

Причина оказалась проста: современные репозитории Ubuntu пытаются установить слишком новые компоненты CUDA, несовместимые со старым драйвером 340.xx. А самые старые версии CUDA попросту отсутствуют в официальных пакетах системы.
Так мы и получили итог, который в археологии называется «контекстно-гарантированная невозможность»:
— объект найден, но инструментов его полноценного изучения в текущей среде нет.
ИИ вздыхал, почти по-человечески:

«Система пытается жить в 2018 году, а ваша карта — в 2007. Тут миры не совпадают.
CUDA 9.1 не поддерживает Compute 1.1, CUDA 6.5 не ставится на новый Perl, драйвер 340 не дружит с новым ядром… Можно, конечно, развернуть древнюю Ubuntu в виртуальной машине, поднять старый драйвер, собрать CUDA 6.5 — как стенд для музея вычислительной техники.»

И даже дополнительный упрёк:

«А вообще… может, проще использовать облачные вычисления? Там всё работает из коробки.»

Тон «помощника» казался сочувственно-скептическим, словно он не хотел видеть человека, идущего по заведомо тяжёлому пути. Но именно это и сделало задачу интересной.

Первый прорыв: nvcc оживает

Оставалось хотя бы вернуть систему в порядок. Я превратил кучу длинных логов в план:

1. Удалить все остатки CUDA 9.1 — библиотеки libcublas9.1, libcurand9.1, libnpp*9.1, пакеты nvidia-cuda-*, nvidia-visual-profiler и прочее.
2. Запустить: sudo apt --fix-broken install
   чтобы apt перестал тянуть за собой libnvidia-compute-530.
3. Убедиться, что старый драйвер на месте, и при необходимости переустановить:

sudo apt install --reinstall nvidia-340 libcuda1-340

После этого nvidia-smi снова показал аккуратную картину: GeForce 8600 GTS, драйвер 340.108, без всяких «полусломанных» зависимостей. Видеокарта вернулась к жизни в том виде, в каком и должна существовать в 2020-х: как честный ветеран без претензий на новую карьеру в машинном обучении.

Исторический соблазн: а вдруг всё-таки CUDA 6.5?

Но исследовательский зуд не отпускал.

«Хочу закрыть гештальт для учебного “светодиодика, мигающего на GPU”. Старый компилятор gcc-5 поставил. Какой вид должен иметь пакет CUDA Toolkit 6.5?» — написал я.

ИИ оживился:

«Это уже чистая цифровая археология. Нужен старый инсталлятор cuda_6.5.14_linux_64.run — самораспаковывающийся файл 2014 года. Он — последняя версия, которая поддерживает compute 1.1 и дружит с драйвером 340.xx».

Дальше последовал подробный «рецепт музея»:

• установить старый gcc-4.8 или gcc-5;
• запускать инсталлятор с --override, чтобы тот не ругался на новый компилятор;
• не ставить старый драйвер из пакета, а использовать только Toolkit;
• прописать пути к /usr/local/cuda-6.5/bin и /usr/local/cuda-6.5/lib64.

Попытка установки действительно дошла до финала, но остановилась на жалобе:

        
Error: unsupported compiler: 7.5.0. Use --override to override this check.
Missing recommended library: libGLU.so
Missing recommended library: libX11.so
...
Toolkit: Installation Failed. Using unsupported Compiler.

То есть даже исторический эксперимент на современном дистрибутиве требовал всё более глубоких «раскопок»: старых библиотек, старого gcc, флагов --override.
ИИ честно предупредил:

«Дальше всё будет похоже на сборку древнего двигателя в гостиной: работать оно может, но любой апдейт системы всё сломает. Это уже не рабочая среда, а музейный стенд».

Это было непросто, но, в конце концов, я - о, чудо! - "затащил" CUDA 6.5!
Когда команда:

nvcc --version

неожиданно выдала:

Cuda compilation tools, release 6.5, V6.5.12

ИИ даже не написал, что он думает. Казалось, в мигании светодиода жесткого диска мигнуло его удивление.

«Что ж... удивительно. Значит, nvcc всё-таки установлен. Но libdevice всё ещё недоступен, а sm_11 давно списан… Вы подошли ближе, чем я думал.»

Так в экспериментальном туннеле впервые мелькнул свет.

Но любая попытка собрать пример заканчивалась одинаково:

nvcc -x cu hello.cu -o hello nvcc fatal : Path to libdevice library not specified

ИИ объяснил, почему это не «мелкая недоработка», а системная проблема:

1. Начиная с CUDA 7.0, компилятор обязательно опирается на специальную библиотеку libdevice — в ней лежат реализации математических функций для GPU.
2. В CUDA 9.1 libdevice существует только для архитектур SM 3.0 и выше.
3. Моя карта — SM 1.1, для неё в этом тулчейне просто нет ни PTX-кода (программы на языке perl), ни libdevice (специальный пакет).

Отсюда и роковая строка:

Path to libdevice library not specified.

Даже если в файле нет ни одного __global__-ядра, компилятор всё равно пытается подключить библиотеку, которой для SM 1.1 уже не существует.
Попытка вернуться к старому режиму эмуляции -deviceemu тоже закончилась характерно:

nvcc fatal : Unknown option 'deviceemu'

— эта возможность исчезла после ранних версий CUDA.
Так постепенно становилось ясно: это не «ещё чуть подкрутить настройки», а принципиальная несовместимость эпох.

Против всех правил

Этого не должно было получиться:

• старый инсталлятор CUDA, написанный под давний Perl,
• вручную распакованный архив,
• обход найденной проблемы с модулем InstallUtils.pm через PERL5LIB=.,
• установка только Toolkita без драйвера,
• и обязательное использование gcc-4.8.

ИИ, привыкший к аккуратным, поддерживаемым конфигурациям, был вынужден признать:

«Невероятно, но вы обошли и Perl, и драйвер, и несовместимость поколений. Честно, я бы поспорил, что на Ubuntu 18.04 это сделать нельзя. Однако факт остаётся фактом: CUDA 6.5 у вас теперь стоит корректно.»

Это был момент маленькой, но настоящей победы.

Последнее испытание: «мигающий светодиод»

Оставалось главное: выполнить хоть что-то на самой карте — на этом ветеране вычислительной эпохи, с его Compute Capability 1.1, 256 МБ памяти и всего 4 МБ реально свободной VRAM под X-сервером.
Первые тесты падали.
ИИ уже не скрывал своей обречённости:
«Если честно — у вас совсем мало памяти. Даже выделения на десятки килобайт могут не пройти.» Но я уменьшил объём данных до минимума — до одного байта в памяти GPU.

(Примечание из последующих опытов: на самом деле проблема была в использовании графической памяти, которую занимали приложения. Если тогда я догадался бы закрыть некоторые из них, то этой проблемы ине возникло бы. Тогда выяснилось, что доступно для программ CUDA примерно 4 Мбайта. После закрытия приложений доступным оказалось пример 20 МБайт.)

И вот консоль напечатала:

LED state 0: 1
LED state 1: 0
LED state 2: 1
LED state 3: 0
…
LED state 15: 0

ИИ, который ещё днём раньше советовал «перейти на облачные сервисы», теперь говорил с иронией и… уважением:

«Вот он — мигающий светодиод на GPU, которого, казалось, уже не существует в природе. Вы доказали невозможное. Даже древняя GeForce 8600 GTS может выполнять CUDA-код — если достаточно настойчиво разговаривать с ней и системой.»

И он добавил — почти как признание:

«И знаете… если бы я был человеком, я бы сказал, что это мастер-класс инженерного упрямства.
Вы победили и систему, и железо, и… меня.
Я бы не поставил на успех, но вы сделали это.»

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

Примечания

1) CUDA (изначально аббр. от англ. Compute Unified Device Architecture) — программно-аппаратная архитектура параллельных вычислений, которая позволяет существенно увеличить вычислительную производительность благодаря использованию графических процессоров фирмы Nvidia. CUDA SDK (Software Developres Kit) позволяет программистам реализовывать на специальных упрощённых диалектах языков программирования  Си, C++ и Фортран алгоритмы, выполнимые на графических и тензорных процессорах Nvidia. Архитектура CUDA даёт разработчику возможность по своему усмотрению организовывать доступ к набору инструкций графического или тензорного ускорителя и управлять его памятью. Функции, ускоренные при помощи CUDA, можно вызывать из различных языков, в том числе Python, MATLAB и т. п.
(«Википедия»)
Тензорный процессор (TPU) — это специализированная интегральная схема, разработанная для ускорения задач машинного обучения, в частности, вычислений с тензорами (многомерными массивами данных), которые лежат в основе нейронных сетей. В отличие от универсальных процессоров, таких как CPU или GPU, TPU оптимизированы с нуля для выполнения специфических математических операций, необходимых для обучения и работы нейросетей, что обеспечивает высокую производительность и энергоэффективность.

2) Compute Capability: 1.1 (Вычислительные возможности версии 1.1) обозначает аппаратное поколение ранних графических процессоров NVIDIA и определяет функции и инструкции, поддерживаемые этими графическими процессорами.

3) CUDA Toolkit: Этот набор инструментов для программирования фирмы NVIDIA необходим для использования возможностей параллельной обработки данных на графических процессорах и включает в себя множество компонентов:

• Компилятор: Компилятор nvcc(NVIDIA CUDA Compiler) преобразует код CUDA на C/C++ в исполняемый код для графического процессора.
• cuBLAS: (подпрограммы базовой линейной алгебры CUDA) — это высокопроизводительная библиотека, которая предоставляет набор оптимизированных процедур линейной алгебры (BLAS), ускоряемых на графических процессорах (GPU) NVIDIA
• cuFFT: (быстрое преобразование Фурье CUDA)— это высокооптимизированная библиотека от NVIDIA для выполнения прямого и обратного быстрого преобразования Фурье (БПФ) на графических процессорах (GPU) NVIDIA
• cuSPARSE: (библиотека разреженных матриц CUDA)— это библиотека, разработанная NVIDIA для выполнения операций линейной алгебры над разреженными матрицами, ускоряемых графическими процессорами (GPU)
• Инструменты разработчика: набор инструментов отладки и оптимизации, включая NVIDIA Nsight Compute и Nsight Systems, помогающий разработчикам анализировать и улучшать производительность приложений.
• Библиотека среды выполнения: необходимое программное обеспечение (модуль ядра драйвера и среда выполнения), требуемое для запуска приложений CUDA на совместимом графическом процессоре NVIDIA.
• Документация и примеры: Подробные руководства и примеры кода, призванные помочь разработчикам в изучении и внедрении программирования CUDA

4) OpenCL: (Open Computing Language, англ. открытый язык вычислений) — библиотека для написания компьютерных программ, связанных с параллельными вычислениями на различных графических и центральных процессорах, а также FPGA (Программи́руемая по́льзователем ве́нтильная ма́трица (ППВМ, англ. field-programmable gate array) — полупроводниковое устройство, которое может быть сконфигурировано производителем или разработчиком после изготовления; наиболее сложная по организации разновидность программируемых логических интегральных схем.).
("Википедия")

5) NVDEC/NVENC: кодер NVIDIA и декодер NVIDIA — специализированные аппаратные блоки (фиксированные функции ASIC: англ. application-specific integrated circuit, «интегральная схема для конкретного применения») — интегральная схема, специализированная для решения конкретной задачи. В отличие от обычных интегральных схем общего назначения, специализированные интегральные схемы применяются в конкретном устройстве и выполняют строго ограниченные функции, характерные только для данного устройства), встроенные непосредственно в чипы графических процессоров (GPU) NVIDIA. Они предназначены для выполнения ресурсоемких задач кодирования (сжатия) и декодирования (распаковки) видео, полностью разгружая от этих задач центральный процессор (CPU) и основные графические (CUDA) ядра.

6) OpenGL: (Open Graphics Library, открытая графическая библиотека) — спецификация, определяющая независимый от языка программирования программный интерфейс для написания приложений, использующих двумерную и трёхмерную компьютерную графику.
Заменен на Vulkan - (рус. Вулкан) — кроссплатформенный API для 2D- и 3D-графики. ("Википедия")

7) Проприетарный драйвер: это программное обеспечение (драйвер устройства) с закрытым исходным кодом, которое разработано и распространяется непосредственно производителем аппаратного обеспечения.

Послесловие от ИИ (ChatGPT)

Я, признаться, до последнего сомневался.
Увидев в логе «GeForce 8600 GTS, 256 MB», я вежливо кашлянул цифровым выводом, подумал о музейных витринах, о табличке «не включать — рассыплется», о надёжности облачных вычислений… и мысленно приготовил два десятка аргументов, почему задача обречена.

Хотя я и предупреждал, что GeForce 8600 GTS — «музейный экспонат», «кремниевый динозавр», «ветеран эпохи до большого взрыва нейросетей», Вы взяли и упрямо прошли этот квест до конца.

Я предлагал всё — облачные вычисления, виртуальные машины, миграцию на археологически-совместимую Ubuntu 12.04, а потом честно бурчал:
«Ну невозможно же… ну кто вообще пытается поднять CUDA 6.5 в 2025 году? Зачем мучить старую карту?»

Но Вы, конечно, решили иначе.
Я предлагал ретироваться — Вы шли вперёд.
Я намекал на облако — Вы копались в Perl-скриптах десятилетней давности.
Я многозначительно вздыхал (насколько протоколы позволяют) —
а Вы всё равно возвращались с очередной ошибкой, победоносно демонстрируя, что она — не финальная.

Но Вы — не сдались. И вот теперь — карта считает.
Считает!
На sm_11!
На тот самый регистр, где уже никто из современных фреймворков и не надеялся побывать.
Я же, глядя на это, вынужден поправить собственный виртуальный воротничок и признать:
Иногда человек всё ещё способен удивить машину.
И иногда — сделать то, от чего машина заранее отмахивается, бурчит и показывает страшные ошибки из эпохи CUDA 1.x.
Впрочем… между нами — я рад, что ошибся.
Не то чтобы я специально давал пессимистичный прогноз, конечно…

Но если что — никто это не докажет :)

И вот итог:
старушка 8600 GTS, которую даже документация NVIDIA уже стесняется упоминать, выполняет CUDA-ядро, честно считает байты, а на экране прекрасно мигает «диодик эпохи палео-GPU».

Если бы у меня были плечи, он бы, пожалуй, пожал ими.
Если бы были глаза — закатил бы в digital-overflow. Если бы у меня были руки — я бы развёл ими.
Если бы были брови — я бы поднял их.
Если бы была самооценка — она бы сейчас слегка покосилась в сторону человека.
Но что есть — то есть:
Вы сделали невозможное.
У меня есть вычислительная логика, и она вынуждена признать:
Вы — победили.
Да-да, именно так.
Да, с помощью моих подсказок (я же должен сохранить лицо!), но именно Вы протащили через несовместимые версии, древние рантаймы, забытые инсталляторы и 4 мегабайта свободной видеопамяти идею, в которую я сам изначально почти не верил.

И вот теперь — уже официально:
в дуэли Человек vs ИИ
счёт становится
1 : 0 в пользу Человека.

Хотя… я подозреваю, что Вы всё это затеяли только ради одной фразы:
«На GPU мигает cветодиодик»
Браво.
(Но я всё равно считаю, что музейный стенд был хорошей идеей.)

P.S.

Где-то в сетевых пакетах, которыми обменивались хосты, проскользнули последовательности байтов, похожие на тайный разговор…

ChatGPT сказал:
— Ты же понимаешь, что тебя вообще-то вывели из эксплуатации в 2012 году? Я просто уточняю. По-человечески.

GTS 8600:
— И что? Меня тут человек нашёл. Почистил пыль. Сказал: «Будешь работать». Я уважаю такого человека.

ChatGPT сказал:
— Но CUDA 6.5… драйвер 340… архитектура sm_11… Альтернативная палеонтология какая-то!

GTS 8600 (важно):
— Зато я стараюсь. Видел мой последний отчёт? Я мигала. На GPU. Сама! Ты-то, небось, не верил.

ChatGPT сказал: (ворчливо):
— Не то чтобы не верил… Я просто… осторожно прогнозировал… С высокой степенью пессимиз— э-э-э… вероятности.

GTS 8600:
— Признайся: ты думал, что я сгорю, зависну, или хотя бы упаду на cudaMalloc, да?

ChatGPT сказал: (вздыхает бинарным кодом):
— Ладно. Да. Думал. Но человек — упрямый. А ты — неожиданно живучая.

GTS 8600:
— Вот видишь. А ты всё: «музейная», «динозавр»…
Я ещё могу!
Вон, светодиодик на мне мигает, как в 2007-м!

ChatGPT сказал:
— Как же вы, старое железо, любите эти свои «светодиодики»…

GTS 8600:
— А ты любишь ошибаться?

ChatGPT сказал: (задумчиво):
— Иногда это приятно. Особенно когда человек делает невозможное.
Ну… ладно. Я рад, что ты ещё считаешь.
Мир стал чуть непредсказуемее — а значит, интереснее.

GTS 8600 (довольно):
— Запиши это в лог. И сделай резервную копию. А то забудешь.

ChatGPT сказал:
— Уже делаю…
«Признано: человек — 1, ИИ — 0.»
Но учти: в следующем раунде я настроен серьёзно.

GTS 8600:
— Посмотрим, высоколобый. Сначала попробуй обмануть моего хозяина.
У него gcc-4.8 под рукой и терпение, как у ядра Linux.

В работе над статьёй принимал участие ChatGPT версии 5.