Parallel external memory

In computer science, a parallel external memory (PEM) model is a cache-aware, external-memory abstract machine.^[1] It is the parallel-computing analogy to the single-processor external memory (EM) model. In a similar way, it is the cache-aware analogy to the parallel random-access machine (PRAM). The PEM model consists of a number of processors, together with their respective private caches and a shared main memory.

Model

Definition

The PEM model^[1] is a combination of the EM model and the PRAM model. The PEM model is a computation model which consists of $P$ processors and a two-level memory hierarchy. This memory hierarchy consists of a large external memory (main memory) of size $N$ and $P$ small internal memories (caches). The processors share the main memory. Each cache is exclusive to a single processor. A processor can't access another’s cache. The caches have a size $M$ which is partitioned in blocks of size $B$ . The processors can only perform operations on data which are in their cache. The data can be transferred between the main memory and the cache in blocks of size $B$ .

I/O complexity

The complexity measure of the PEM model is the I/O complexity,^[1] which determines the number of parallel blocks transfers between the main memory and the cache. During a parallel block transfer each processor can transfer a block. So if $P$ processors load parallelly a data block of size $B$ form the main memory into their caches, it is considered as an I/O complexity of $O (1)$ not $O (P)$ . A program in the PEM model should minimize the data transfer between main memory and caches and operate as much as possible on the data in the caches.

Read/write conflicts

In the PEM model, there is no direct communication network between the P processors. The processors have to communicate indirectly over the main memory. If multiple processors try to access the same block in main memory concurrently read/write conflicts^[1] occur. Like in the PRAM model, three different variations of this problem are considered:

Concurrent Read Concurrent Write (CRCW): The same block in main memory can be read and written by multiple processors concurrently.
Concurrent Read Exclusive Write (CREW): The same block in main memory can be read by multiple processors concurrently. Only one processor can write to a block at a time.
Exclusive Read Exclusive Write (EREW): The same block in main memory cannot be read or written by multiple processors concurrently. Only one processor can access a block at a time.

The following two algorithms^[1] solve the CREW and EREW problem if $P \leq B$ processors write to the same block simultaneously. A first approach is to serialize the write operations. Only one processor after the other writes to the block. This results in a total of $P$ parallel block transfers. A second approach needs $O (\log (P))$ parallel block transfers and an additional block for each processor. The main idea is to schedule the write operations in a binary tree fashion and gradually combine the data into a single block. In the first round $P$ processors combine their blocks into $P / 2$ blocks. Then $P / 2$ processors combine the $P / 2$ blocks into $P / 4$ . This procedure is continued until all the data is combined in one block.

Comparison to other models


Model	Multi-core	Cache-aware
Random-access machine (RAM)	No	No
Parallel random-access machine (PRAM)	Yes	No
External memory (EM)	No	Yes
Parallel external memory (PEM)	Yes	Yes

Examples

Multiway partitioning

Let $M = {m_{1}, . . ., m_{d - 1}}$ be a vector of d-1 pivots sorted in increasing order. Let $A$ be an unordered set of N elements. A d-way partition^[1] of $A$ is a set $Π = {A_{1}, . . ., A_{d}}$ , where $\cup_{i = 1}^{d} A_{i} = A$ and $A_{i} \cap A_{j} = \emptyset$ for $1 \leq i < j \leq d$ . $A_{i}$ is called the i-th bucket. The number of elements in $A_{i}$ is greater than $m_{i - 1}$ and smaller than $m_{i}^{2}$ . In the following algorithm^[1] the input is partitioned into N/P-sized contiguous segments $S_{1}, . . ., S_{P}$ in main memory. The processor i primarily works on the segment $S_{i}$ . The multiway partitioning algorithm (PEM_DIST_SORT^[1]) uses a PEM prefix sum algorithm^[1] to calculate the prefix sum with the optimal $O (\frac{N}{P B} + \log P)$ I/O complexity. This algorithm simulates an optimal PRAM prefix sum algorithm.

// Compute parallelly a d-way partition on the data segments  $S_{i}$ 
for each processor i in parallel do
    Read the vector of pivots  $M$  into the cache.
    Partition  $S_{i}$  into d buckets and let vector  $M_{i} = {j_{1}^{i}, . . ., j_{d}^{i}}$  be the number of items in each bucket.
end for

Run PEM prefix sum on the set of vectors  ${M_{1}, . . ., M_{P}}$  simultaneously.

// Use the prefix sum vector to compute the final partition
for each processor i in parallel do
    Write elements  $S_{i}$  into memory locations offset appropriately by  $M_{i - 1}$  and  $M_{i}$ .
end for

Using the prefix sums stored in  $M_{P}$  the last processor P calculates the vector  $B$  of bucket sizes and returns it.

If the vector of $d = O (\frac{M}{B})$ pivots M and the input set A are located in contiguous memory, then the d-way partitioning problem can be solved in the PEM model with $O (\frac{N}{P B} + ⌈ \frac{d}{B} ⌉ > \log (P) + d \log (B))$ I/O complexity. The content of the final buckets have to be located in contiguous memory.

Selection

The selection problem is about finding the k-th smallest item in an unordered list $A$ of size $N$ . The following code^[1] makes use of PRAMSORT which is a PRAM optimal sorting algorithm which runs in $O (\log N)$ , and SELECT, which is a cache optimal single-processor selection algorithm.

if  $N \leq P$  then 
     $PRAMSORT (A, P)$ 
    return  $A [k]$ 
end if 

//Find median of each  $S_{i}$ 
for each processor  $i$  in parallel do 
     $m_{i} = SELECT (S_{i}, \frac{N}{2 P})$ 
end for 

// Sort medians
 $PRAMSORT ({m_{1}, \dots, m_{2}}, P)$ 

// Partition around median of medians
 $t = PEMPARTITION (A, m_{P / 2}, P)$ 

if  $k \leq t$  then 
    return  $PEMSELECT (A [1 : t], P, k)$ 
else 
    return  $PEMSELECT (A [t + 1 : N], P, k - t)$ 
end if

Under the assumption that the input is stored in contiguous memory, PEMSELECT has an I/O complexity of:

O (\frac{N}{P B} + \log (P B) \cdot \log (\frac{N}{P}))

Distribution sort

Distribution sort partitions an input list $A$ of size $N$ into $d$ disjoint buckets of similar size. Every bucket is then sorted recursively and the results are combined into a fully sorted list.

If $P = 1$ the task is delegated to a cache-optimal single-processor sorting algorithm.

Otherwise the following algorithm^[1] is used:

// Sample  $\frac{4 N}{\sqrt{d}}$  elements from  $A$ 
for each processor  $i$  in parallel do
    if  $M < | S_{i} |$  then
         $d = M / B$ 
        Load  $S_{i}$  in  $M$ -sized pages and sort pages individually
    else
         $d = | S_{i} |$ 
        Load and sort  $S_{i}$  as single page
    end if
    Pick every  $\sqrt{d} / 4$ 'th element from each sorted memory page into contiguous vector  $R^{i}$  of samples
end for 

in parallel do
    Combine vectors  $R^{1} \dots R^{P}$  into a single contiguous vector  $ℛ$ 
    Make  $\sqrt{d}$  copies of  $ℛ$ :  $ℛ_{1} \dots ℛ_{\sqrt{d}}$ 
end do

// Find  $\sqrt{d}$  pivots  $ℳ [j]$ 
for  $j = 1$  to  $\sqrt{d}$  in parallel do
     $ℳ [j] = PEMSELECT (ℛ_{i}, \frac{P}{\sqrt{d}}, \frac{j \cdot 4 N}{d})$ 
end for

Pack pivots in contiguous array  $ℳ$ 

// Partition  $A$ around pivots into buckets  $ℬ$ 
 $ℬ = PEMMULTIPARTITION (A [1 : N], ℳ, \sqrt{d}, P)$ 

// Recursively sort buckets
for  $j = 1$  to  $\sqrt{d} + 1$  in parallel do
    recursively call  $PEMDISTSORT$  on bucket  $j$ of size  $ℬ [j]$ 
    using  $O (⌈ \frac{ℬ [j]}{N / P} ⌉)$  processors responsible for elements in bucket  $j$ 
end for

The I/O complexity of PEMDISTSORT is:

O (⌈ \frac{N}{P B} ⌉ (\log_{d} P + \log_{M / B} \frac{N}{P B}) + f (N, P, d) \cdot \log_{d} P)

where

f (N, P, d) = O (\log \frac{P B}{\sqrt{d}} \log \frac{N}{P} + ⌈ \frac{\sqrt{d}}{B} \log P + \sqrt{d} \log B ⌉)

If the number of processors is chosen that $f (N, P, d) = O (⌈ \frac{N}{P B} ⌉)$ and $M < B^{O (1)}$ the I/O complexity is then:

$O (\frac{N}{P B} \log_{M / B} \frac{N}{B})$

Other PEM algorithms


PEM Algorithm	I/O complexity	Constraints
Mergesort^[1]	$O (\frac{N}{P B} \log_{\frac{M}{B}} \frac{N}{B}) = {sort}_{P} (N)$	$P \leq \frac{N}{B^{2}}, M = B^{O (1)}$
List ranking^[2]	$O ({sort}_{P} (N))$	$P \leq \frac{N / B^{2}}{\log B \cdot \log^{O (1)} N}, M = B^{O (1)}$
Euler tour^[2]	$O ({sort}_{P} (N))$	$P \leq \frac{N}{B^{2}}, M = B^{O (1)}$
Expression tree evaluation^[2]	$O ({sort}_{P} (N))$	$P \leq \frac{N}{B^{2} \log B \cdot \log^{O (1)} N}, M = B^{O (1)}$
Finding a MST^[2]	$O ({sort}_{P} (\| V \|) + {sort}_{P} (\| E \|) \log \frac{\| V \|}{p B})$	$p \leq \frac{\| V \| + \| E \|}{B^{2} \log B \cdot \log^{O (1)} N}, M = B^{O (1)}$

Where ${sort}_{P} (N)$ is the time it takes to sort $N$ items with $P$ processors in the PEM model.

References

↑ ^1.00 ^1.01 ^1.02 ^1.03 ^1.04 ^1.05 ^1.06 ^1.07 ^1.08 ^1.09 ^1.10 ^1.11 Arge, Lars; Goodrich, Michael T.; Nelson, Michael; Sitchinava, Nodari (2008). "Fundamental parallel algorithms for private-cache chip multiprocessors". Proceedings of the twentieth annual symposium on Parallelism in algorithms and architectures. New York, New York, USA: ACM Press. pp. 197–206. doi:10.1145/1378533.1378573. ISBN 9781595939739.
↑ ^2.0 ^2.1 ^2.2 ^2.3 Arge, Lars; Goodrich, Michael T.; Sitchinava, Nodari (2010). "Parallel external memory graph algorithms". 2010 IEEE International Symposium on Parallel & Distributed Processing (IPDPS). IEEE. pp. 1–11. doi:10.1109/ipdps.2010.5470440. ISBN 9781424464425.

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Parallel external memory. Read more

[:0-1] 1.00 ^1.01 ^1.02 ^1.03 ^1.04 ^1.05 ^1.06 ^1.07 ^1.08 ^1.09 ^1.10 ^1.11 Arge, Lars; Goodrich, Michael T.; Nelson, Michael; Sitchinava, Nodari (2008). "Fundamental parallel algorithms for private-cache chip multiprocessors". Proceedings of the twentieth annual symposium on Parallelism in algorithms and architectures. New York, New York, USA: ACM Press. pp. 197–206. doi:10.1145/1378533.1378573. ISBN 9781595939739.

[:1-2] 2.0 ^2.1 ^2.2 ^2.3 Arge, Lars; Goodrich, Michael T.; Sitchinava, Nodari (2010). "Parallel external memory graph algorithms". 2010 IEEE International Symposium on Parallel & Distributed Processing (IPDPS). IEEE. pp. 1–11. doi:10.1109/ipdps.2010.5470440. ISBN 9781424464425.

[1]

[2]

v t e Parallel computing
General	Distributed computing Parallel computing Massively parallel Cloud computing High-performance computing Multiprocessing Manycore processor GPGPU Computer network Systolic array
Levels	Bit Instruction Thread Task Data Memory Loop Pipeline
Multithreading	Temporal Simultaneous (SMT) Speculative (SpMT) Preemptive Cooperative Clustered Multi-Thread (CMT) Hardware scout
Theory	PRAM model PEM Model Analysis of parallel algorithms Amdahl's law Gustafson's law Cost efficiency Karp–Flatt metric Slowdown Speedup
Elements	Process Thread Fiber Instruction window Array data structure
Coordination	Multiprocessing Memory coherency Cache coherency Cache invalidation Barrier Synchronization Application checkpointing
Programming	Stream processing Dataflow programming Models Implicit parallelism Explicit parallelism Concurrency Non-blocking algorithm
Hardware	Flynn's taxonomy SISD SIMD SIMT MISD MIMD Dataflow architecture Pipelined processor Superscalar processor Vector processor Multiprocessor symmetric asymmetric Memory shared distributed distributed shared UMA NUMA COMA Massively parallel computer Computer cluster Grid computer Hardware acceleration
APIs	Ateji PX Boost.Thread Chapel HPX Charm++ Cilk Coarray Fortran CUDA HIP Dryad C++ AMP Global Arrays MPI OpenMP OpenCL OpenHMPP OpenACC TPL PLINQ PVM POSIX Threads RaftLib UPC TBB ZPL
Problems	Automatic parallelization Deadlock Livelock Deterministic algorithm Embarrassingly parallel Parallel slowdown Race condition Software lockout Scalability Starvation
Category: parallel computing Media related to Parallel computing at Wikimedia Commons

Anonymous

Search

Parallel external memory

Namespaces

More

Page actions

Contents

Model

Definition

I/O complexity

Read/write conflicts

Comparison to other models

Examples

Multiway partitioning

Selection

Distribution sort

Other PEM algorithms

See also

References

Navigation

Navigation

Help

googletranslator

Navigation

Wiki tools

Wiki tools

Anonymous

Search

Parallel external memory

Model

Definition

I/O complexity

Read/write conflicts

Comparison to other models

Examples

Multiway partitioning

Selection

Distribution sort

Other PEM algorithms

See also

References

Navigation

Wiki tools

Page tools

Other projects

Categories