ROOT LIT JINR

Многопоточность и мультипроцессорность

Для повышения производительности расчетов ROOT предлагает инструмент, работа которого основывается на параллелизме распределенных систем - PROOF. С другой стороны, часто желательны решения, связанные с простой многопотоковой и многопроцессорной обработкой данных. Начиная с версии 6.08 в ROOT появились методы, обеспечивающие эти свойства. Для того, чтобы эти функции были доступны, ROOT должен быть скомпилирован с флагом imt = ON. При работе на кластере HybriLit пользователь должен установить модуль ROOT/v6-13-02-1.

Многопоточность

ROOT может использоваться как библиотека из нескольких потоков при условии использования специальной функции ROOT::EnableImplicitMT(numthreads). Эта функция обеспечивает глобальное включение неявной многопоточности в ROOT, активацию параллельного выполнения методов в ROOT, что обеспечивают внутреннюю параллелизацию.

Параметр' numthreads ' позволяет управлять количеством потоков, используемых неявной многопоточностью. Однако, этот параметр всего лишь просит ROOT установить такое количество потоков, и ROOT постарается удовлетворить запрос, если исполнение сценария позволяет это сделать. А если ROOT настроен на использование внешнего планировщика, установка значения 'numthreads' может не иметь никакого эффекта. ROOT::EnableImplicitMT(numthreads) вызывается перед выполнением операций в нескольких потоках.

Функция ROOT::EnableThreadSafety() oбеспечивает глобальный мьютекс, чтобы сделать ROOT потокобезопасным.

Мьютекс (англ. mutex, от mutual exclusion «взаимное исключение») аналог одноместного семафора, служащий в программировании для синхронизации одновременно выполняющихся потоков. Мьютекс отличается от семафора тем, что только владеющий им поток может его освободить, т.е. перевести в отмеченное состояние. Мьютексы это один из вариантов семафорных механизмов для организации взаимного исключения. Они реализованы во многих ОС, их основное назначение организация взаимного исключения для потоков из одного и того же или из разных процессов. Мьютексы это простейшие двоичные семафоры, которые могут находиться в одном из двух состояний отмеченном или неотмеченном (открыт и закрыт соответственно). Когда какой-либо поток, принадлежащий любому процессу, становится владельцем объекта mutex, последний переводится в неотмеченное состояние. Если задача освобождает мьютекс, его состояние становится отмеченным. Задача мьютекса защита объекта от доступа к нему других потоков, отличных от того, который завладел мьютексом. В каждый конкретный момент только один поток может владеть объектом, защищённым мьютексом. Если другому потоку будет нужен доступ к переменной, защищённой мьютексом, то этот поток блокируется до тех пор, пока мьютекс не будет освобождён. Цель использования мьютексов защита данных от повреждения в результате асинхронных изменений.

Методы ROOT::DisableImplicitMT() и ROOT::IsImplicitMTEnabled() используются для отключения и проверки состояния глобальной неявной многопоточности в ROOT соответственно. Также необходимо, чтобы в каждом потоке читался или записывался только один файл.

Мультипроцессорность

Инструмент, предоставляемый ROOT для выполнения простых операций с использованием многопроцессорности - это класс TProcPool. Новый интерфейс, реализованный в классе TProcPool, обеспечивает возможность параллельно выполнять очень общий набор задач, описываемых макросами или функциями. Основные методы класса TProcPool::Map(F func, unsigned nTimes) и TProcPool::MapReduce(F func, unsigned nTimes, R redfunk) анализируют деревья, используя все имеющиеся в наличии ядра.

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

Программа, представленная ниже, демонстрирует, как активировать и использовать неявное распараллеливание метода TTree::GetEntry().

int imt001_parBranchProcessing()
{
   //Сначала включаем неявную многопоточность, чтобы использовалась неявная параллелизация.
   // Параметр вызова определяет количество потоков
   int nthreads = 4;
   ROOT::EnableImplicitMT(nthreads);
   // Открываем файл, содержащий дерево
   TFile *file = TFile::Open("http://root.cern.ch/files/h1/dstarmb.root");
   // Вытаскиваем дерево
   TTree *tree = nullptr;
   file->GetObject("h42", tree);
   // Считаваем ветви параллельно.
   // Интерфейс ничем не отличается от непараллельного случая, поскольку параллелизация внутренняя
   for (Long64_t i = 0; i < tree->GetEntries(); ++i) {
      tree->GetEntry(i); // параллельное чтение
   }
   // IMT параллелизация может быть отключена для отдельного дерева
   tree->SetImplicitMT(false);
   // Если сейчас вызвать GetEntry, то считывание будет происходить последовательно
   for (Long64_t i = 0; i < tree->GetEntries(); ++i) {
      tree->GetEntry(i); // последовательное считывание
   }
   // Параллельное считывание может быть восстановлено
   tree->SetImplicitMT(true);
   // IMT можно также отключить глобально.
   ROOT::DisableImplicitMT();
   // В этом случае даже если конкретному дереву разрешено параллельное считывание,
   // считывание будет происходить последовательно
   for (Long64_t i = 0; i < tree->GetEntries(); ++i) {
      tree->GetEntry(i); // последовательное считывание
   }
   return 0;
}

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