Добрый день, Уважаемые Господа!

Перед мной стоит задача задействовать ресурсы графического процессора для проведения параллельных вычислений.

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

На данный момент существует программа, позволяющее распараллеливать проведение расчетов на ПРОИЗВОЛЬНОЕ количество процессов.

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

Очевидно, что использование современных многопоточных GPU может позволить получить выигрыш в скорости вычислений по сравнению даже с многоядерными CPU.

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

- работала бы в фоновом режиме, во время работы расчетной программы

- позволяла бы осуществлять перехватывание команд между расчетной программой и CPU

- перенаправляла бы вычисления из CPU в GPU.

Сложность заключается в том, что все это нужно мне сделать БЕЗ МОДИФИКАЦИИ ИСХОДНОГО ТЕКСТА ПРОГРАММЫ по определенному ряду причин.

Поэтому, мне хотелось бы узнать Ваше мнение по поводу способов решения этой задачи!

Мне кажется, что наиболее эффективным способом решения этой проблемы является задействование ресурсов GPU с помощью использования ШЕЙДЕРОВ на языке их описания OpenGL Shading Language (GLSL).

В синтаксисе GLSL существуют возможность выполнять в GPU такие же никоуровневые команды как и в ассемблере для CPU (ADD, SUB и т.д.). 

Значит, нужно в «прозрачном» режиме для каждого из запущенных процессов просто перенаправлять на исполнение команды из CPU в GPU.

Таким образом, необходимо решить 2 следующие задачи:

1. Найти способ перехватывания инструкций между расчетной программой и CPU для каждого из запущенных процессов.

2. Найти способ перенаправлять вычисления из CPU в GPU и в обратную сторону.

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

Заранее благодарен за дельные советы, Triton.

При такой постановке нереально, имхо.

В качестве инструмента для решения задачи решил использовать технологию CUDA от NVIDIA.

Основная идея заключается в том, что бы создать системный драйвер, который позволил бы эмулировать работу CPU при помощи GPU, исполняя арифметические команды в GPU, а все остальные в CPU.

Хотелось бы услышать Ваше мнение по поводу такого способа решения описанной выше задачи.

Triton, посмотрите Nvidia Tesla.

Добавлено через 2 минуты и 24 секунды
Перехватить выполнение арифметических команд - это как? 

Дело в том, что программа состоит из нескольких исполняемых модулей, которые выполняют следующие функции:

1. PreProcess – модуль для запуска интерфейса подготовки исходных данных (компонентный состав, давление, температура и т.д.)

2. Setup – модуль для настройки параметров решателя (количество запускаемых процессов, число итераций, необходимое для достижения сходимости, релаксационные факторы и т.д.)

3. Solver – программа-решатель, которая запускается из под модуля Setup в заданном количестве экземпляров-процессов.

4. Monitor – программа работающая в фоновом режиме и работающая арбитром при раздаче очередных данных для каждого потока (экземпляры программы решателей Solver)

5.PostProccess – модуль для вывода расcчитанных данных.


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

В принципе, при помощи инструментов из MS DDK можно эмулировать заданное количество процессоров, а затем использовать их для отладки многопоточных приложений.

В то же время, набор низкоуровневых команд GPU не аналогичен набору команд CPU.

Значит, нужен системный драйвер для эмуляции процессора – это раз.

И механизм, который мог бы обеспечить исполнение основных команд – на центральном процессоре, а арифмитических – на GPU.

Это - два!

В GLSL есть возможность использования низкоуровневых шейдеров, которые могут оперировать с неким подобием ассемблерного кода, выполняя операции ADD, SUB и некотрые др. (см. гл.20, стр. 877 из книги OpenGL- Суперкнига, 3-е изд. под ред. Ричарда Райта-мл. и Бенджамина Липчача)

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

Можно ознакомиться с первыми несколькими страницами asm-овского кода, который я выложил на нижеприведенном ресурсе:

http://downfile.narod.ru/solver.txt

Программа действительно распараллеливает вычисления на ПРОИЗВОЛЬНОЕ количество процессов.

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

Поэтому, при помощи технологии CUDA, хочется написать некоторую “обертку” для этого кода, которая позволила распределять исполнение машинного кода между GPU и CPU.

Вопрос заключается, собственно говоря, в том - как это можно сделать?

А спросите в процессорном разделе конференции на ixbt.com - там есть крутые вычислители-параллельщики. И т.к. задействуется MPI - то еще одним основным вопросом может быть следующий: а какие аргументы MPI-функций поменять (или как переписать код планировщика), чтобы распараллеливание шло не только по процессорам, но и по компьютерам локалки/кластера.  Это гораздо дешевле по времени реализации будет, чем бодание с GPU. Думаю, что поддержка многокомпьютерности в Вашей проге или уже есть (только Вы об этом не знаете), либо требует очень малых действий по её включению.
И не говорите, что я не заметил Вашего требования о немодификации исходной программы - Вам шашечки или ехать?

Драйверы и подобное - нафиг, в любом случае оставьте нормальный MPI-ый планировщик по процессорам/компьютерам, но добейте в первую очередь версию для кластера, а потом может и время на нормальное переписывание решателя именно с учетом GPU появится (а то эмуляция - это может оказаться не рыбой и не мясом...)

ЗЫ. Читал дискуссию по этому вопросу на форуме aicommunity - честно говоря, не понимаю Ваши стремления к усложнению способа решения (эмуляция там, драйвера,...). Восстановленный исходный текст решалки будет явно полезнее в целях добавления иных способов распараллеливания (вместо MPI), оптимизации алгоритма, переписывания алгоритма явно под GPU. Скрещивать ужа с ежом можно, конечно, но очень уж часто получается такая хрень...

Это сообщение отредактировал(а) VictorTsaregorodtsev - 17.9.2007, 17:08

Дело в том, что MPI-планировщик в программе есть, автоматическая нагрузка между вычислительными узлами происходит в автоматическом режиме.

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

Поэтому я и ищу способ для того, чтобы решить задачу доступными методами.

Тогда получается, что распараллеливаются относительно быстро выполняющиеся блоки программы или происходит значительный объем обмена данными (раз МПИ затыкается при росте числа узлов)? Тогда и для ГПУ ожидайте такой же гемор из-за необходимости частого обмена данными между параллельными потоками, т.к. средний кластер из 15 компов на двухядерниках - это в 3 (или 4?) раза меньше потоков, чем число конвейеров в 8800 нвидиях, и там планировщик встанет вообще и ускорение от ГПУ не поможет.
Узнайте на Иксбите о реальных накладных расходах МПИ - может, надо просто переписать планировщик и вычислитель под более крупные параллельные блоки, и тогда наступит счастье?