Самый быстрый способ найти собственные пары малой несимметричной матрицы на GPU в разделяемой памяти

У меня есть проблема, когда мне нужно найти все положительные (так как собственное значение положительно) собственные пары небольшой (обычно меньше, чем 60x60) несимметричной матрицы. Я могу прекратить вычислять, когда собственное значение меньше определенного порога. Я знаю, что собственные значения реальны. Какие-нибудь предложения по алгоритмам, которые я мог бы использовать, чтобы попытаться выжать лучшую производительность? Я должен сделать несколько тысяч таких разложений, поэтому скорость важна.

Заранее спасибо.

РЕДАКТИРОВАТЬ: Мне нужно сделать это на GPU в общей памяти. Матрицы также не обязательно имеют одинаковый размер. Я не знаю ни о каких библиотеках, которые делают это в данный момент. Предложения алгоритмов, которые были бы хорошо подходят для этой проблемы, будут оценены.

performance eigensystem gpu

— Кантоку
источник

Если я правильно понял, у вас есть ядро CUDA, которое вычисляет тысячи маленьких матриц в общей памяти, и вы не желаете копировать их в глобальную память. Прежде чем пытаться дать ответ, необходимо уточнить некоторые моменты. В CUDA время жизни совместно используемой памяти ограничено временем жизни блока: сколько потоков у вас для каждой матрицы для разложения? Действительно ли важны экстремальные характеристики? (Как ожидаемые времена извлечения собственных значений сравниваются со временем генерации матрицы?) На основании какого аргумента вы знаете, что собственная система является реальной? Может ли собственная система быть неисправна?

— Стефано М

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

— Кантоку

Ответы:

Не делая большого поиска, я рекомендую вам взглянуть на библиотеку MAGMA . Свободно доступный код с постоянной поддержкой. NVIDIA признала MAGMA «прорывом в решении проблем собственных значений».

Существует также библиотека CULA , которая, как правило, является коммерческим продуктом, хотя недавно она стала бесплатной для академического использования (подробности см. Здесь ).

— Александр
источник

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

— Кантоку

@Kantoku, да, эти библиотеки более общие и хранят всю матрицу в глобальной памяти. Если ваши матрицы находятся в общей памяти, над ними может работать только один SM, не так ли? Таким образом, реализация EVD должна быть достаточно простой.

— Александр

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

— Кантоку

@ Кантоку (и Александр). Несимметричные EVD далеки от простых, даже в последовательном случае. Это все еще активная область исследований.

— Джек Поулсон

@JackPoulson Ах да, вы правы, но я (и я полагаю, что Александр тоже) имел в виду, что было бы просто применить установленный алгоритм к проблеме, учитывая, что есть много упрощений, которые можно сделать, если мы примем размер и характер матрицы во внимание. Проблема в том, какой алгоритм.

— Кантоку

Используйте функции в LAPACK, вряд ли вы сможете превзойти их в своей собственной реализации.

— Вольфганг Бангерт
источник

Привет, Вольфганг. Спасибо за ответ, но я намереваюсь реализовать это на GPU с использованием CUDA и для нескольких тысяч таких крошечных матриц (где каждый блок обрабатывает разложение одной матрицы), и матрицы не обязательно имеют одинаковый размер, поэтому реализация что-то, что использует общую память, кажется, мой единственный выбор. Любая идея, какой алгоритм лучше всего подходит для этих типов матриц? PS Спасибо за сделку. II лекции, которые вы читали на KAUST в прошлом семестре. Я наслаждался ими :)

— Kantoku

@Kantoku Вы должны добавить эти детали в свой вопрос, иначе это вводит в заблуждение.

— Александр

@ Александр Я обновил вопрос с более подробной информацией. Спасибо за предложение!

— Кантоку

@Kantoku: GPU немного за пределами моей области, но я уверен, что уже есть библиотеки, которые делают то, что вы хотите (и на самом деле я вижу, что другие ответы уже ссылаются на них). Рад слышать, что тебе понравились мои занятия!

— Вольфганг Бангерт