The OpenNET Project / Index page

[ новости /+++ | форум | wiki | теги | ]

Каталог документации / Раздел "Программирование, языки" / Оглавление документа
next up previous contents
Next: Адресные функции и функции Up: Производные типы данных Previous: Производные типы данных   Contents

Конструкторы типа данных

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

Синтаксис функции MPI_TYPE_CONTIGUOUS представлен ниже.

MPI_TYPE_CONTIGUOUS (count, oldtype, newtype)
IN count число повторений (неотрицательное целое)
IN oldtype старый тип данных (дескриптор)
OUT newtype новый тип данных (дескриптор)

int MPI_Type_contiguous(int count, MPI_Datatype oldtype,
    MPI_Datatype *newtype) 

MPI_TYPE_CONTIGUOUS(COUNT, OLDTYPE, NEWTYPE, IERROR)
INTEGER COUNT, OLDTYPE, NEWTYPE, IERROR 

MPI::Datatype MPI::Datatype::Create_contiguous (int count) const

Новый тип newtype есть тип, полученный конкатенацией (сцеплением) count копий старого типа oldtype.

Пример 3.20 Пусть oldtype имеет карту type map { ( double, 0), (char, 8) } с длиной 16 и пусть count = 3. Карта нового типа будет:

{ (double, 0), (char, 8), (double, 16), (char, 24), (double, 32), (char, 40) } ;

то есть содержать меняющиеся удвоенные значения и символьные элементы со смещением 0, 8, 16, 24, 32, 40.

В общем предположим, что карта типа для oldtype есть

{ (type$_{0}$,disp$_{0}$), ..., (type$_{n - 1}$, disp$_{n - 1}$)} ,

с длиной ex, Тогда newtype имеет карту с count $\cdot
$ n элементами, определяемыми:

{ (type$_{0}$, disp$_{0}$), ..., (type$_{n - 1}$, disp$_{n - 1}$), (type$_{0}$, disp$_{0}$+ex), ... ,(type$_{n - 1}$, disp$_{n - 1}$+ ex) , ...

(type$_{0}$, disp$_{0}$+ex $\cdot
$ ( count-1)), ... , (type$_{n - 1}$, disp$_{n - 1}$+ ex $\cdot
$ (count-1)) }.

Vector. Функция MPI_TYPE_VECTOR является более универсальным конструктором, который позволяет реплицировать типы данных в области, состоящие из блоков равного объема. Каждый блок получается конкатенацией некоторого количества копий старого типа. Пространство между блоками кратно размеру old datatype.

Синтаксис функции MPI_TYPE_VECTOR представлен ниже.

MPI_TYPE_VECTOR(count, blocklength, stride, oldtype, newtype)
IN count число блоков (неотрицательное целое)
IN blocklength число элементов в каждом блоке (неотрицательное целое)
IN stride число элементов между началами каждого блока (целое)
IN oldtype старый тип данных (дескриптор)
OUT newtype новый тип данных (дескриптор)

int MPI_Type_vector(int count, int blocklength, int stride,
    MPI_Datatype oldtype, MPI_Datatype *newtype) 

MPI_TYPE_VECTOR(COUNT, BLOCKLENGTH, STRIDE, OLDTYPE, NEWTYPE, IERROR)
INTEGER COUNT, BLOCKLENGTH, STRIDE, OLDTYPE, NEWTYPE, IERROR 

MPI::Datatype MPI::Datatype::Create_vector(int count,
    int blocklength, int stride) const

Пример 3.21 Предположим снова, что oldtype имеет карту type map {(double, 0), (char, 8)}, с размером 16. Обращение MPI_TYPE_VECTOR(2, 3, 4, oldtype, newtype) будет создавать тип с картой:

type map, { (double, 0), (char, 8), (double, 16), (char, 24), ( double, 32), (char, 40),

(double, 64), (char, 72), (double, 80), (char, 88), (double, 96), (char, 104) } .

Это означает, что в новой карте есть два блока, каждый с тремя копиями старого типа, со страйдом (stride) 4 элемента (4$\cdot
$16 байтов) между блоками.

Пример 3.22 Обращение MPI_TYPE_VECTOR(3, 1, -2, oldtype, newtype) будет создавать тип:

{ (double, 0), (char, 8), (double, -32), (char, -24), (double, -64), (char, -56) } .

В общем случае предположим, что oldtype имеет карту:

{ (type$_{0}$, disp$_{0}$), ..., (type$_{n - 1}$, disp$_{n - 1}$) },

с экстентом ex. Пусть bl - длина блока. Вновь созданный тип данных будет иметь карту с
$ count \times bl \times n $ элементами:

{ (type$_{0}$, disp$_{0}$), ... , (type$_{n - 1}$, disp$_{n - 1}$),

(type$_{0}$,disp$_{0}$+ ex) , ... , (type$_{n - 1}$, disp$_{n - 1}$+ ex), ...,

(type$_{0}$, disp$_{0}$+ (bl -1) $\cdot
$ ex) , ... , (type$_{n - 1}$, disp$_{n - 1}$+ (bl -1) $\cdot
$ ex) ,

(type$_{0}$,disp$_{0}$+ stride$\cdot
$ ex) , ... , (type$_{n - 1}$, disp$_{n - 1}$+ stride$\cdot
$ ex), ... ,

(type$_{0}$, disp$_{0}$+ (stride + bl -1) $\cdot
$ ex) , ... , (type_n-1, disp_n-1+ (stride + bl -1) $\cdot
$ex) , ....,

(type$_{0}$,disp$_{0}$+ stride $\cdot
$ (count-1) $\cdot
$ ex), ... ,

(type$_{n - 1}$, disp$_{n - 1}$+ stride $\cdot
$ (count -1) $\cdot
$ ex) , ... ,

(type$_{0}$, disp$_{0}$+ (stride $\cdot
$ (count -1) + bl -1)$\cdot
$ ex) , ... ,

(type$_{n - 1}$, disp$_{n - 1}$+ ( stride $\cdot
$ (count -1) + bl -1) $\cdot
$ ex) } .

Обращение к MPI_TYPE_CONTIGUOUS (count, oldtype, newtype) эквивалентно обращению
MPI_TYPE_VECTOR(count, 1, 1, oldtype, newtype) или обращению MPI_TYPE_VECTOR (1, count, n, oldtype, newtype), где n - произвольное.

Hvector. Функция MPI_TYPE_HVECTOR идентична MPI_TYPE_VECTOR за исключением того, что страйд задается в байтах, а не в элементах. Использование обоих типов векторных конструкторов иллюстрируется в разделе 3.12.7. (H обозначает heterogeneous - неоднородный).

Синтаксис функции MPI_TYPE_HVECTOR представлен ниже.

MPI_TYPE_HVECTOR(count, blocklength, stride, oldtype, newtype)
IN count число блоков (неотрицательное целое)
IN blocklength число элементов в каждом блоке (неотрицательное целое)
IN stride число байтов между стартом каждого блока (целое)
IN oldtype старый тип данных (дескриптор)
OUT newtype новый тип данных (дескриптор)

int MPI_Type_hvector(int count, int blocklength, MPI_Aint stride,
    MPI_Datatype oldtype, MPI_Datatype *newtype) 

MPI_TYPE_HVECTOR(COUNT, BLOCKLENGTH, STRIDE, OLDTYPE, NEWTYPE, IERROR)
INTEGER COUNT, BLOCKLENGTH, STRIDE, OLDTYPE, NEWTYPE, IERROR

MPI::Datatype MPI::Datatype::Create_hvector(int count,
    int blocklength, MPI::Aint stride) const

Предположим, что oldtype имеет карту

{ (type$_{0}$, disp$_{0}$), ..., (type$_{n - 1}$, disp$_{n - 1}$) } ,

с расширением ex. Пусть bl - длина блока. Вновь созданный тип данных будет иметь карту с $ count \times bl \times n $ элементами:

{ (type$_{0}$, disp$_{0}$), ... , (type$_{n - 1}$, disp$_{n - 1}$),

(type$_{0}$,disp$_{0}$+ ex) , ... , (type$_{n - 1}$, disp$_{n - 1}$+ ex), ...,

(type$_{0}$, disp$_{0}$+ (bl -1) $\cdot
$ ex) , ... , (type$_{n - 1}$, disp$_{n - 1}$+ (bl -1)$\cdot
$ ex) ,

(type$_{0}$,disp$_{0}$+ stride) , ... , (type$_{n - 1}$, disp$_{n - 1}$+ stride) , ... ,

(type$_{0}$, disp$_{0}$+ stride + ( bl -1)$\cdot
$ ex) , ... ,

(type$_{n - 1}$, disp$_{n - 1}$+ stride + (bl -1)$\cdot
$ ex) , ....,

(type$_{0}$,disp$_{0}$+ stride $\cdot
$ (count-1)) , ... , (type$_{n - 1}$, disp$_{n - 1}$+ stride $\cdot
$(count -1)) , ... ,

(type$_{0}$, disp$_{0}$+ stride $\cdot
$ (count -1) + (bl -1)$\cdot
$ ex) , ... ,

(type$_{n - 1}$, disp$_{n - 1}$+ stride $\cdot
$ (count -1) + (bl -1) $\cdot
$ ex) } .

Indexed. Функция MPI_TYPE_INDEXED позволяет реплицировать старый тип old datatype в последовательность блоков (каждый блок есть конкатенация old datatype), где каждый блок может содержать различное число копий и иметь различное смещение. Все смещения блоков кратны длине старого блока old type.

Синтаксис функции MPI_TYPE_INDEXED представлен ниже.

MPI_TYPE_INDEXED(count, array_of_blocklengths,
    array_of_displacements, oldtype, newtype)
IN count число блоков
IN array_of_blocklengths число элементов в каждом блоке (массив неотрицательных целых)
IN array_of_displacements смещение для каждого блока (массив целых)
IN oldtype старый тип данных (дескриптор)
OUT newtype новый тип данных (дескриптор)

int MPI_Type_indexed(int count, int *array_of_blocklengths,
    int *array_of_displacements, MPI_Datatype oldtype, MPI_Datatype *newtype) 

MPI_TYPE_INDEXED(COUNT, ARRAY_OF_BLOCKLENGTHS,
    ARRAY_OF_DISPLACEMENTS, OLDTYPE, NEWTYPE, IERROR)
INTEGER COUNT, ARRAY_OF_BLOCKLENGTHS(*), ARRAY_OF_DISPLACEMENTS(*),
    OLDTYPE, NEWTYPE, IERROR

MPI::Datatype MPI::Datatype::Create_indexed(int count,
    const int array_of_blocklengths[],
    const int array_of_displacements[]) const

Пример 3.23 Пусть oldtype имеет карту type map { ( double, 0), (char, 8) } с экстентом16. Пусть B = (3, 1) и D = (4, 0). Обращение MPI_TYPE_INDEXED (2, B, D, oldtype, newtype) возвращает тип данных с картой:

{ (double, 64), (char, 72), (double, 80), (char, 88), (double, 96), (char, 104),

(double, 0), (char, 8) } .

Это означает, что в новом типе имеется три копии старого типа old type, начиная со смещения 64 и одна копия стартует со смещения 0.

В общем случае предположим, что oldtype имеет карту

{ (type$_{0}$, disp$_{0}$), ..., (type$_{n - 1}$, disp$_{n - 1}$) } ,

с экстентом ex. Пусть В является аргументом массива длин и D - аргументом массива смещений. Тогда вновь созданный тип данных имеет $n \times (B[0]+B[1]+\ldots +B[count-1])$ элементов:

{(type$_{0}$, disp$_{0}$+ D[0] $
* $ex),..., (type$_{n - 1}$, disp$_{n - 1}$ + D[0]$
* $ex)

(type$_{0}$, disp$_{0}$+ D[0] +B[0] -1)$
* $ex),..., (type$_{n - 1}$, disp$_{n - 1}$ + (D[0] + В[0] -1)$
* $ex),...,

(type$_{0}$, disp$_{0}$+ D[count - 1]$
* $ex),..., (type$_{n - 1}$, disp$_{n - 1}$ + D[count - 1]$
* $ex)... ,

(type$_{0}$, disp$_{0}$+ (D[count - 1] + B[count -1)$
* $ex),...,

(type$_{n - 1}$, disp$_{n - 1}$+$_{ (}$D[count - 1] + B[count -1)$
* $ex).

Обращение к MPI_TYPE_VECTOR (count, blocklength, stride, oldtype, newtype) будет эквивалентно обращению к MPI_TYPE_INDEXED(count, B, D, oldtype, newtype), где

D[j] = j$
* $ strade, j = 0,..., count - 1,

и

B[j] = blocklength, j = 0,..., count - 1

Hindexed. Функция MPI_TYPE_HINDEXED идентична MPI_TYPE_INDEXED, за исключением того, что смещения блоков в массиве array_of_displacements задаются в байтах, а не в кратностях величины старого типа oldtype.

Синтаксис функции MPI_TYPE_HINDEXED представлен ниже.

MPI_TYPE_HVECTOR(count, blocklength, stride, oldtype, newtype)
IN count число блоков (неотрицательное целое)
IN blocklength число элементов в каждом блоке (неотрицательное целое)
IN stride число байтов между стартом каждого блока (целое)
IN oldtype старый тип данных (дескриптор)
OUT newtype новый тип данных (дескриптор)

int MPI_Type_hvector(int count, int blocklength, MPI_Aint stride,
    MPI_Datatype oldtype, MPI_Datatype *newtype) 

MPI_TYPE_HVECTOR(COUNT, BLOCKLENGTH, STRIDE, OLDTYPE, NEWTYPE, IERROR)
INTEGER COUNT, BLOCKLENGTH, STRIDE, OLDTYPE, NEWTYPE, IERROR 

MPI::Datatype MPI::Datatype::Create_hvector(int count,
    int blocklength, MPI::Aint stride) const

Предположим, что oldtype имеет карту

{ (type0, disp0), ..., (typen-1, dispn-1) }

с расширением ex. Пусть В - это аргумент array_of_blocklength, а D - аргумент
array_of_displacements. Вновь созданный тип данных имеет карту с $n \times (B[0]+B[1]+\ldots +B[count-1])$ элементов:

{(type$_{0}$,disp$_{0}$+ D[0]),..., (type$_{n - 1}$, disp$_{n - 1}$+ D[0]),...,

(type$_{0}$, disp$_{0}$+ D[0] + (B[0] -1)$
* $ex),...,

(type$_{n - 1, }$disp$_{n - 1}$+ D[0] + (B[0] -1)$
* $ex),...,

(type$_{0}$, disp$_{0}$+ D[count - 1]),..., (type$_{n - 1, }$disp$_{n - 1}$+ D[count - 1]), ...,

(type$_{0}$, disp$_{0}$+ D[count - 1]) + (B[count - 1] - 1)$
* $ex),...,

(type$_{n - 1, }$disp$_{n - 1}$+ D[count - 1]) + (B[count - 1] - 1)$
* $ex)}

Struct. MPI_TYPE_STRUCT является наиболее общим типом конструктора. Он отличается от предыдущего тем, что позволяет каждому блоку состоять из репликаций различного типа.

Синтаксис функции MPI_TYPE_STRUCT представлен ниже.

=1cm MPI_TYPE_STRUCT(count, array_of_blocklengths,
array_of_displacements, array_of_types, newtype)

IN count число блоков (целое)
IN array_of_blocklength число элементов в каждом блоке (массив целых)
IN array_of_displacements смещение каждого блока в байтах (массив целых)
IN array_of_types тип элементов в каждом блоке (массив дескрипторов объектов типов данных)
OUT newtype новый тип данных (дескриптор)

=1cm int MPI_Type_struct(int count, int *array_of_blocklengths,
MPI_Aint *array_of_displacements, MPI_Datatype *array_of_types,
MPI_Datatype *newtype)

=1cm MPI_TYPE_STRUCT(COUNT, ARRAY_OF_BLOCKLENGTHS, ARRAY_OF_DISPLACEMENTS,
ARRAY_OF_TYPES, NEWTYPE, IERROR)
INTEGER COUNT, ARRAY_OF_BLOCKLENGTHS(*), ARRAY_OF_DISPLACEMENTS(*),
ARRAY_OF_TYPES(*), NEWTYPE, IERROR

Пример 3.24 Пусть type1 имеет карту типа

{ (double, 0), (char, 8) } ,

с шириной 16. Пусть B = (2, 1, 3), D = (0, 16, 26), и T = (MPI_FLOAT, type1, MPI_CHAR). Тогда обращение MPI_TYPE_STRUCT(3, B, D, T, newtype) возвращает тип с картой:

{ (float, 0), (float, 4), (double, 16), (char, 24), (char, 26), (char, 27), (char, 28) },

то есть две копии MPI_FLOAT, начиная с 0, с последующей одной копией type1, начиная с 16, с последующими тремя копиями MPI_CHAR, начиная с 26. (Предполагается, что число с плавающей точкой занимает четыре байта).

Обращение к MPI_TYPE_HINDEXED(count, B, D, oldtype, newtype) эквивалентно обращению к MPI_TYPE_STRUCT(count, B, D, T, newtype), где каждый вход T равен oldtype.


next up previous contents
Next: Адресные функции и функции Up: Производные типы данных Previous: Производные типы данных   Contents
Alex Otwagin 2002-12-10



Партнёры:
PostgresPro
Inferno Solutions
Hosting by Hoster.ru
Хостинг:

Закладки на сайте
Проследить за страницей
Created 1996-2024 by Maxim Chirkov
Добавить, Поддержать, Вебмастеру