Операции связи MPI по умолчанию -<send>и<recv>- могут подождать, пока вся передача не будет завершена, прежде чем они смогут вернуться. Иногда этоблокирующееповедение оказывает негативное влияние на производительность, потому что отправитель может выполнять полезные вычисления, пока он ждет передачи. Более важными, однако, являются случаи, когда несколько операций связи должны происходить одновременно, например, процесс будет одновременно отправлять и получать.

Давайте вернемся к нашей программе «Привет, мир!» из предыдущего раздела. Ядро этой программы передает два сообщения:

if (world.rank() == 0) {
  world.send(1, 0, std::string("Hello"));
  std::string msg;
  world.recv(1, 1, msg);
  std::cout << msg << "!" << std::endl;
} else {
  std::string msg;
  world.recv(0, 0, msg);
  std::cout << msg << ", ";
  std::cout.flush();
  world.send(0, 1, std::string("world"));
}

Первый процесс передает сообщение второму процессу, затем готовится к получению сообщения. Второй процесс выполняет отправку и получение в обратном порядке. Тем не менее, эта последовательность событий — это просто последовательность, что означает, что по существу нет параллелизма. Мы можем использовать неблокирующую связь для обеспечения одновременной передачи двух сообщений<hello_world_nonblocking.cpp>:

#include <boost/mpi.hpp>
#include <iostream>
#include <string>
#include <boost/serialization/string.hpp>
namespace mpi = boost::mpi;
int main()
{
  mpi::environment env;
  mpi::communicator world;
  if (world.rank() == 0) {
    mpi::request reqs[2];
    std::string msg, out_msg = "Hello";
    reqs[0] = world.isend(1, 0, out_msg);
    reqs[1] = world.irecv(1, 1, msg);
    mpi::wait_all(reqs, reqs + 2);
    std::cout << msg << "!" << std::endl;
  } else {
    mpi::request reqs[2];
    std::string msg, out_msg = "world";
    reqs[0] = world.isend(0, 1, out_msg);
    reqs[1] = world.irecv(0, 0, msg);
    mpi::wait_all(reqs, reqs + 2);
    std::cout << msg << ", ";
  }
  return 0;
}

Мы заменили призывы к<communicator::send>и<communicator::recv>членам аналогичными призывами к их неблокирующим коллегам<communicator::isend>и<communicator::irecv>. Префиксiуказывает, что операции немедленно возвращаются с объектом<mpi::request>, что позволяет запрашивать статус запроса связи (см. метод<test>) или ждать, пока он не будет завершен (см. метод<wait>). Несколько запросов могут быть выполнены одновременно с операцией<wait_all>.

Важное примечание: Стандарт MPI требует, чтобы пользователи сохраняли обработку запроса для неблокирующей связи и вызывали операцию «подождать» (или успешно тестировать для завершения) для завершения отправки или получения. В отличие от большинства реализаций C MPI, которые позволяют пользователю отклонить запрос на неблокирующую отправку, Boost. MPI требует, чтобы пользователь назвал «ожидание» или «тест», поскольку объект запроса может содержать временные буферы, которые должны храниться до завершения отправки. Более того, стандарт MPI не гарантирует, что приемник делает какой-либо прогресс перед вызовом «ждать» или «тестировать», хотя большинство реализаций C MPI позволяют приемникам прогрессировать перед вызовом «ждать» или «тестировать». С другой стороны, Boost.MPI обычно требует «тестирования» или «ожидания» звонков для достижения прогресса.

Если вы запускаете эту программу несколько раз, вы можете увидеть некоторые странные результаты, а именно:

Hello, world!

Другие будут производить:

world!
Hello,

или даже какой-то искаженный вариант букв в «Привет» и «мир». Это указывает на некоторый параллелизм в программе, потому что после того, как оба сообщения (одновременно) передаются, оба процесса будут одновременно выполнять свои заявления печати. Как для производительности, так и для корректности неблокирующие операции связи имеют решающее значение для многих параллельных приложений с использованием MPI.

Включение<boost/serialization/string.hpp>в предыдущие примеры очень важно: оно делает значения типа<std::string>сериализуемыми, чтобы их можно было передавать с помощью Boost. MPI. В целом, встроенные типы C++ (<int>s,<float>s, символы и т.д.) могут передаваться по MPI напрямую, в то время как пользовательские и библиотечные типы должны сначала быть сериализованы (упакованы) в формат, который поддается передаче. Повышаю. MPI опирается на библиотекуBoost.Serializationдля сериализации и десериализации типов данных.

Для типов, определенных стандартной библиотекой (например,<std::string>или<std::vector>) и некоторых типов в Boost (например,<boost::variant>), библиотекаBoost.Serializationуже содержит весь требуемый код сериализации. В этих случаях вам нужно только включить соответствующий заголовок из каталога<boost/serialization>.

Для типов, которые еще не имеют заголовка сериализации, сначала необходимо реализовать код сериализации, прежде чем типы могут быть переданы с помощью Boost. MPI. Рассмотрим простой класс<gps_position>, который содержит членов<degrees>,<minutes>и<seconds>. Этот класс становится сериализуемым, делая его другом<boost::serialization::access>и вводя шаблонную<serialize()>функцию следующим образом:

class gps_position
{
private:
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & degrees;
        ar & minutes;
        ar & seconds;
    }
    int degrees;
    int minutes;
    float seconds;
public:
    gps_position(){};
    gps_position(int d, int m, float s) :
        degrees(d), minutes(m), seconds(s)
    {}
};

Полная информация о том, как сделать типы сериализуемыми, выходит за рамки этого учебника. Для получения дополнительной информации см.Boost.Serializationбиблиотечный учебник, из которого был извлечен приведенный выше пример. Одно из важных побочных преимуществ создания типов, сериализуемых для Boost. MPI заключается в том, что они становятся сериализуемыми для любого другого использования, такого как хранение объектов на диске и манипулирование ими в XML.

Некоторые сериализуемые типы, такие как<gps_position>выше, имеют фиксированное количество данных, хранящихся при фиксированных смещениях, и полностью определяются значениями их элемента данных (большинство POD без указателей являются хорошим примером). Если это так, поднимите. MPI может оптимизировать их сериализацию и передачу, избегая посторонних операций копирования. Чтобы обеспечить эту оптимизацию, пользователи должны специализироваться на признаке типа<is_mpi_datatype>, например:

namespace boost { namespace mpi {
  template <>
  struct is_mpi_datatype<gps_position> : mpl::true_ { };
} }

Для типов без шаблонов мы определили макрос, чтобы упростить объявление типа как типа данных MPI.

BOOST_IS_MPI_DATATYPE(gps_position)

Для композитных признаков специализация<is_mpi_datatype>может зависеть от самого<is_mpi_datatype>. Например, объект<boost::array>фиксируется только тогда, когда фиксируется тип хранимого им параметра:

namespace boost { namespace mpi {
  template <typename T, std::size_t N>
  struct is_mpi_datatype<array<T, N> >
    : public is_mpi_datatype<T> { };
} }

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

Повышаю. MPI может передавать любой тип данных, определенный пользователем, из одного процесса в другой. Встроенные типы могут передаваться без каких-либо дополнительных усилий; определяемые библиотекой типы требуют включения заголовка сериализации; и определяемые пользователем типы потребуют добавления кода сериализации. Фиксированные типы данных могут быть оптимизированы для передачи с использованием признака типа<is_mpi_datatype>.

Алгоритм<broadcast>на сегодняшний день является самой простой коллективной операцией. Он передает значение от одного процесса ко всем другим процессам в пределах 70. Например, следующая программа транслирует «Привет, мир!» от процесса 0 до любого другого процесса.<hello_world_broadcast.cpp>

#include <boost/mpi.hpp>
#include <iostream>
#include <string>
#include <boost/serialization/string.hpp>
namespace mpi = boost::mpi;
int main()
{
  mpi::environment env;
  mpi::communicator world;
  std::string value;
  if (world.rank() == 0) {
    value = "Hello, World!";
  }
  broadcast(world, value, 0);
  std::cout << "Process #" << world.rank() << " says " << value
            << std::endl;
  return 0;
}

Запуск этой программы с семью процессами даст такой результат, как:

Process #0 says Hello, World!
Process #2 says Hello, World!
Process #1 says Hello, World!
Process #4 says Hello, World!
Process #3 says Hello, World!
Process #5 says Hello, World!
Process #6 says Hello, World!

Коллектив<gather>собирает значения, производимые каждым процессом в коммуникаторе, в вектор значений на «корневом» процессе (определяется аргументом<gather>). Элемент /i/th в векторе будет соответствовать значению, собранному в процессе /i/th. Например, в следующей программе каждый процесс вычисляет свое собственное случайное число. Все эти случайные числа собираются в процессе 0 («корень» в данном случае), который распечатывает значения, соответствующие каждому процессору.<random_gather.cpp>

#include <boost/mpi.hpp>
#include <iostream>
#include <vector>
#include <cstdlib>
namespace mpi = boost::mpi;
int main()
{
  mpi::environment env;
  mpi::communicator world;
  std::srand(time(0) + world.rank());
  int my_number = std::rand();
  if (world.rank() == 0) {
    std::vector<int> all_numbers;
    gather(world, my_number, all_numbers, 0);
    for (int proc = 0; proc < world.size(); ++proc)
      std::cout << "Process #" << proc << " thought of "
                << all_numbers[proc] << std::endl;
  } else {
    gather(world, my_number, 0);
  }
  return 0;
}

Выполнение этой программы с помощью семи процессов приведет к выходу, например: Хотя случайные значения будут меняться от одного прогона к следующему, порядок процессов на выходе останется прежним, потому что только процесс 0 записывает<std::cout>.

Process #0 thought of 332199874
Process #1 thought of 20145617
Process #2 thought of 1862420122
Process #3 thought of 480422940
Process #4 thought of 1253380219
Process #5 thought of 949458815
Process #6 thought of 650073868

Операция<gather>собирает значения из каждого процесса в вектор в одном процессе. Если вместо этого значения каждого процесса должны быть собраны в идентичные векторы на каждом процессе, используйте алгоритм<all_gather>, который семантически эквивалентен вызову<gather>, за которым следует<broadcast>полученного вектора.

Коллектив<reduce>суммирует значения из каждого процесса в одно значение в заданном пользователем «корневом» процессе. Начало. Операция MPI<reduce>аналогична по духу операции STL.<accumulate>операция, поскольку она принимает последовательность значений (по одному на процесс) и объединяет их через объект функции. Например, мы можем произвольно генерировать значения в каждом процессе и вычислять минимальное значение по всем процессам с помощью вызова<reduce><random_min.cpp>:

#include <boost/mpi.hpp>
#include <iostream>
#include <cstdlib>
namespace mpi = boost::mpi;
int main()
{
  mpi::environment env;
  mpi::communicator world;
  std::srand(time(0) + world.rank());
  int my_number = std::rand();
  if (world.rank() == 0) {
    int minimum;
    reduce(world, my_number, minimum, mpi::minimum<int>(), 0);
    std::cout << "The minimum value is " << minimum << std::endl;
  } else {
    reduce(world, my_number, mpi::minimum<int>(), 0);
  }
  return 0;
}

Использование<mpi::minimum<int>>указывает на то, что необходимо вычислить минимальное значение.<mpi::minimum<int>>— двоичный функциональный объект, который сравнивает свои два параметра через<<>и возвращает меньшее значение. Любая ассоциативная двоичная функция или объект функции будет работать. Например, для сопряжения строк с<reduce>можно использовать объект функции<std::plus<std::string>><string_cat.cpp>:

#include <boost/mpi.hpp>
#include <iostream>
#include <string>
#include <functional>
#include <boost/serialization/string.hpp>
namespace mpi = boost::mpi;
int main()
{
  mpi::environment env;
  mpi::communicator world;
  std::string names[10] = { "zero ", "one ", "two ", "three ",
                            "four ", "five ", "six ", "seven ",
                            "eight ", "nine " };
  std::string result;
  reduce(world,
         world.rank() < 10? names[world.rank()]
                          : std::string("many "),
         result, std::plus<std::string>(), 0);
  if (world.rank() == 0)
    std::cout << "The result is " << result << std::endl;
  return 0;
}

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

The result is zero one two three four five six

Любой вид объектов двоичной функции может быть использован с<reduce>. Например, и таких объектов функций много в заголовке C++<<functional>>и Boost. Заголовок MPI<<boost/mpi/operations.hpp>>. Вы можете создать свой собственный объект. Функциональные объекты, используемые с<reduce>, должны быть ассоциативными, то есть<f(x, f(y,z))>должны быть эквивалентны<f(f(x,y),z)>. Если они также являются коммутативными (т.е.<f(x,y)==f(y, x)>), то они увеличиваются. MPI может использовать более эффективную реализацию<reduce>. Чтобы утверждать, что объект функции коммутативный, нужно будет специализировать класс<is_commutative>. Например, мы могли бы изменить предыдущий пример, сказав Boost. MPI, что конкатенация струн является коммутативной:

namespace boost { namespace mpi {
  template<>
  struct is_commutative<std::plus<std::string>, std::string>
    : mpl::true_ { };
} } // end namespace boost::mpi

Добавляя этот код до<main()>, увеличить. MPI предполагает, что конкатенация строк является коммутативной и использует другой параллельный алгоритм для операции<reduce>. Используя этот алгоритм, программа выводит следующее при запуске с семью процессами:

The result is zero one four five six two three

Обратите внимание, что числа в результирующей строке находятся в другом порядке: это прямой результат Boost. MPI переупорядочение операций. Результат в этом случае отличался от некоммутативного результата, потому что конкатенация строк не коммутативна:<f("x", "y")>не то же самое, что<f("y", "x")>, потому что порядок аргументов имеет значение. Для действительно коммутативных операций (например, целочисленного сложения) более эффективный коммутативный алгоритм даст тот же результат, что и некоммутативный алгоритм. Повышаю. MPI также выполняет прямые отображения от объектов функций в<<functional>>до<MPI_Op>значениях, предварительно определенных MPI (например,<MPI_SUM>,<MPI_MAX>); если у вас есть собственные объекты функций, которые могут воспользоваться этим отображением, см. шаблон классов<is_mpi_op>.

Как и<gather>,<reduce>имеет вариант «все», называемый<all_reduce>, который выполняет операцию восстановления и передает результат во все процессы. Этот вариант полезен, например, при установлении глобальных минимальных или максимальных значений.

Следующий код<global_min.cpp>показывает вещательную версию примера<random_min.cpp>:

#include <boost/mpi.hpp>
#include <iostream>
#include <cstdlib>
namespace mpi = boost::mpi;
int main(int argc, char* argv[])
{
  mpi::environment env(argc, argv);
  mpi::communicator world;
  std::srand(world.rank());
  int my_number = std::rand();
  int minimum;
  all_reduce(world, my_number, minimum, mpi::minimum<int>());
  if (world.rank() == 0) {
      std::cout << "The minimum value is " << minimum << std::endl;
  }
  return 0;
}

В этом примере мы предоставляем как входные, так и выходные значения, требующие в два раза больше места, что может быть проблемой в зависимости от размера передаваемых данных. Если нет необходимости сохранять входное значение, выходное значение может быть опущено. В этом случае входное значение будет переопределено с выходным значением и повышением. MPI способен в некоторых ситуациях реализовать операцию с более эффективным решением (используя флаг<MPI_IN_PLACE>отображения MPI C), как в следующем примере<in_place_global_min.cpp>:

#include <boost/mpi.hpp>
#include <iostream>
#include <cstdlib>
namespace mpi = boost::mpi;
int main(int argc, char* argv[])
{
  mpi::environment env(argc, argv);
  mpi::communicator world;
  std::srand(world.rank());
  int my_number = std::rand();
  all_reduce(world, my_number, mpi::minimum<int>());
  if (world.rank() == 0) {
      std::cout << "The minimum value is " << my_number << std::endl;
  }
  return 0;
}

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

Уже обсуждалось, что фиксированные типы длины, не содержащие указателей, могут использоваться в качестве<is_mpi_datatype>, например:

namespace boost { namespace mpi {
  template <>
  struct is_mpi_datatype<gps_position> : mpl::true_ { };
} }

или эквивалентный макрос

BOOST_IS_MPI_DATATYPE(gps_position)

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

BOOST_CLASS_TRACKING(gps_position,track_never)
BOOST_CLASS_IMPLEMENTATION(gps_position,object_serializable)

Дополнительные оптимизации возможны на однородных машинах, избегая вызовов MPI_Pack/MPI_Unpack, но используя прямую битовую копию. Эта функция включена по умолчанию путем определения макроса<BOOST_MPI_HOMOGENEOUS>в файле включения<boost/mpi/config.hpp>. Это определение должно быть последовательным при строительстве. MPI и при создании приложения.

Кроме того, все классы должны быть помечены как is_mpi_datatype, так и as is_bitwise_serializable с помощью вспомогательного макроса Boost. Сериализация:

BOOST_IS_BITWISE_SERIALIZABLE(gps_position)

Обычно безопасно сериализовать класс, для которого является_mpi_datatype, используя двоичную копию битов. Исключение составляют классы, для которых некоторые члены должны быть пропущены для сериализации.