Пакет scala.collection.parallel

Базовый тракт для всех объединителей. Объединитель наращивает коллекцию, как и обычный билдер, но также реализует эффективную операцию слияния двух билдеров с помощью combine метода. После создания коллекции ее можно получить, вызвав result метод.

Сложность combine метода должна быть меньше линейной для лучшей производительности. result метод не обязательно должен быть операцией постоянного времени, но может выполняться параллельно.

Поддержка задач, которая использует контекст выполнения для планирования задач.

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

По умолчанию параллельные коллекции параметризованы этим объектом поддержки задач, поэтому параллельные коллекции используют тот же бэкенд контекста выполнения, что и остальная часть пакета scala.concurrent.

Эта реализация задач использует контексты выполнения для запуска параллельного вычисления.

В качестве оптимизации она внутренне проверяет, является ли контекст выполнения стандартной реализацией на основе пулов fork/join, и если это так, создаёт ForkJoinTaskSupport, который использует тот же пул для переадресации запроса.

В противном случае она использует контекст выполнения, эксклюзивную Tasks реализацию, чтобы разбить задачи на более мелкие части и выполнить операции на нём.

Поддержка задач, использующая пул fork join для планирования задач.

Параллельные итераторы позволяют разделять и предоставляют метод remaining для получения количества элементов, оставшихся в итераторе.

Шаблонный трейт для параллельных итерируемых коллекций.

Это базовый трейт для параллельных коллекций Scala. Он определяет поведение, общее для всех параллельных коллекций. Конкретные параллельные коллекции должны унаследовать этот трейт и ParIterable если они хотят определить конкретные фабрики комбинирования.

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

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

def splitter: IterableSplitter[T]

который возвращает экземпляр IterableSplitter[T], который является подтипом Splitter[T]. Разделители имеют метод remaining для проверки оставшегося числа элементов и метод split, который определен разделителями. Метод split делит итерируемых разделителей на непересекающиеся подмножества:

def split: Seq[Splitter]

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

Задачи планируются для выполнения через объект scala.collection.parallel.TaskSupport, который может быть изменён через tasksupport setter коллекции.

Метод newCombiner создаёт новый комбинирующий элемент. Комбинирующие элементы являются расширением билдеров. Они предоставляют метод combine для объединения двух комбинирующих элементов и возвращают комбинирующий элемент, содержащий элементы обоих комбинирующих элементов. Этот метод может быть реализован путём агрессивного копирования всех элементов в новый комбинирующий элемент или путём ленивой привязки их результатов. Рекомендуется избегать копирования всех элементов по причинам производительности, хотя эта стоимость может быть незначительной в зависимости от конкретного случая. Стандартные комбинирующие элементы параллельных коллекций избегают копирования при объединении результатов, полагаясь либо на двухэтапную ленивую конструкцию, либо на специфические свойства структуры данных.

Методы:

def seq: Sequential
def par: Repr

соответственно генерируют последовательную или параллельную реализацию коллекции. Метод par просто возвращает ссылку на эту параллельную коллекцию. Метод seq эффективный — он не копирует элементы. Вместо этого он создаёт последовательную версию коллекции, используя ту же базовую структуру данных. Обратите внимание, что это не относится к последовательным коллекциям в целом — они могут копировать элементы и создавать другую базовую структуру данных.

Сочетание методов toMap, toSeq или toSet вместе с par и seq является гибким способом переключения между различными типами коллекций.

Поскольку этот трейт расширяет трейт GenIterable, методы, такие как size, также должны быть реализованы в конкретных коллекциях, в то время как iterator по умолчанию перенаправляется на splitter.

Каждая параллельная коллекция связана с определённым пулом fork/join, в котором хранятся спящие рабочие потоки. Пул fork/join содержит другую информацию, такую как уровень параллелизма, то есть количество используемых процессоров. При создании коллекции ей назначается стандартный пул fork/join, найденный в пакете scala.parallel.

Параллельные коллекции не обязательно упорядочены в терминах операции foreach (см. Traversable). У параллельных последовательностей определённый порядок для итераторов — создание итератора и линейное прохождение элементов всегда даёт тот же порядок. Однако массовые операции, такие как foreach, map или filter, всегда происходят в неопределённом порядке для всех параллельных коллекций.

Существующие реализации параллельных коллекций предоставляют жёсткие параллельные итераторы. Строгие параллельные итераторы знают количество элементов, которые им ещё предстоит пройти. Также возможно предоставить нестрогие параллельные итераторы, которые не знают количество оставшихся элементов. Для этого новая реализация коллекции должна переопределить isStrictSplitterCollection в false. Это сделает некоторые операции недоступными.

Для создания новой параллельной коллекции необходимо расширить трейт ParIterable и реализовать size, splitter, newCombiner и seq. Для использования неявной фабрики комбинирования требуется расширить этот трейт, а также предоставить объект компаньона, как и в случае с обычными коллекциями.

Метод size реализован как операция постоянного времени для параллельных коллекций, и операции параллельных коллекций опираются на это предположение.

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

Шаблонный трайт для параллельных коллекций типа ParIterable[T].

Это базовый трайт для параллельных коллекций Scala. Он определяет общее поведение для всех параллельных коллекций. Конкретные параллельные коллекции должны унаследовать этот трайт и ParIterable , если они хотят определить конкретные фабрики комбинирования.

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

Все параллельные операции реализуются как задачи в этом трайте. Задачи основаны на концепции разделителей, которые расширяют итераторы. Каждая параллельная коллекция определяет:

def splitter: IterableSplitter[T]

которая возвращает экземпляр IterableSplitter[T], который является подтипом Splitter[T]. Разделители имеют метод remaining для проверки оставшегося числа элементов и метод split, который определён разделителями. Метод split делит итерацию разделителей на непересекающиеся подмножества:

def split: Seq[Splitter]

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

Задачи планируются для выполнения через объект scala.collection.parallel.TaskSupport, который можно изменить через tasksupport сеттер коллекции.

Метод newCombiner создаёт новый комбинатор. Комбинаторы являются расширением билдеров. Они предоставляют метод combine который объединяет два комбинатора и возвращает комбинатор, содержащий элементы обоих комбинаторов. Этот метод может быть реализован путём агрессивного копирования всех элементов в новый комбинатор или путём ленивой привязки их результатов. Для повышения производительности рекомендуется избегать копирования всех элементов, хотя эта стоимость может быть незначительной в зависимости от конкретного случая. Стандартные параллельные комбинаторы коллекций избегают копирования при объединении результатов, полагаясь либо на двухэтапную ленивую конструкцию, либо на свойства конкретной структуры данных.

Методы:

def seq: Sequential
def par: Repr

производят последовательную или параллельную реализацию коллекции соответственно. Метод par просто возвращает ссылку на эту параллельную коллекцию. Метод seq является эффективным – он не копирует элементы. Вместо этого он создаёт последовательную версию коллекции, используя ту же базовую структуру данных. Обратите внимание, что это не всегда верно для последовательных коллекций в целом – они могут копировать элементы и создавать другую базовую структуру данных.

Комбинация методов toMap, toSeq или toSet вместе с par и seq является гибким способом изменения между различными типами коллекций.

Поскольку этот трайт расширяет трайт GenIterable, методы, такие как size , должны также быть реализованы в конкретных коллекциях, в то время как iterator по умолчанию передаёт вызов splitter.

Каждая параллельная коллекция привязана к определённому пулу fork/join, в котором хранятся спящие рабочие потоки. Пул fork/join содержит другую информацию, такую как уровень параллелизма, то есть количество используемых процессоров. При создании коллекции ей назначается стандартный пул fork/join, найденный в объекте пакета scala.parallel.

Параллельные коллекции не обязательно упорядочены в терминах операции foreach (см. Traversable). Параллельные последовательности имеют чётко определённый порядок для итераторов – создание итератора и линейное прохождение элементов всегда дадут тот же порядок. Однако объёмные операции, такие как foreach, map или filter всегда происходят в неопределённом порядке для всех параллельных коллекций.

Существующие реализации параллельных коллекций обеспечивают строгие параллельные итераторы. Строгие параллельные итераторы знают количество элементов, которые им ещё предстоит пройти. Также возможно предоставить нестрогие параллельные итераторы, которые не знают количество оставшихся элементов. Для этого новая реализация коллекции должна переопределить isStrictSplitterCollection в false. Это сделает некоторые операции недоступными.

Чтобы создать новую параллельную коллекцию, расширьте трайт ParIterable, и реализуйте size, splitter, newCombiner и seq . Наличие неявной фабрики комбинаторов требует дополнительно расширить этот трайт, а также предоставить компаньон-объект, как и в случае с обычными коллекциями.

Метод size реализуется как операция постоянного времени для параллельных коллекций, и операции с параллельными коллекциями полагаются на это предположение.

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

Шаблонный трайт для параллельных карт.

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

Шаблонный трайт для изменяемых параллельных карт. Этот трайт должен быть смешан с конкретными параллельными картами для переопределения типа представления.

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

Шаблонный трайт для параллельных последовательностей.

Параллельные последовательности наследуют трайт Seq. Их вычисления индексации и длины определены как эффективные. Как и их последовательные аналоги, они всегда имеют определенный порядок элементов. Это означает, что они будут генерировать результирующие параллельные последовательности так же, как последовательные последовательности. Однако порядок, в котором они выполняют массовые операции над элементами для получения результатов, не определен и, как правило, не является детерминированным. Если функции высшего порядка, предоставляемые им, не производят побочных эффектов, то это не будет заметно.

Этот трайт определяет новую, более общую операцию split и повторно реализует операцию split трайта ParallelIterable с использованием новой операции split.

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

Шаблонный трайт для последовательностей типа ParSeq[T], представляющих параллельные последовательности с типом элементов T.

Параллельные последовательности наследуют трайт Seq. Их вычисления индексации и длины определены как эффективные. Как и их последовательные аналоги, они всегда имеют определенный порядок элементов. Это означает, что они будут генерировать результирующие параллельные последовательности так же, как последовательные последовательности. Однако порядок, в котором они выполняют массовые операции над элементами для получения результатов, не определен и, как правило, не является детерминированным. Если функции высшего порядка, предоставляемые им, не производят побочных эффектов, то это не будет заметно.

Этот трайт определяет новую, более общую операцию split и повторно реализует операцию split трайта ParallelIterable с использованием новой операции split.

Шаблонный трайт для параллельных множеств.

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

Шаблонный трайт для параллельных множеств. Этот трайт смешивается с конкретными параллельными множествами для переопределения типа представления.

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

A precise splitter (or a precise split iterator) can be split into arbitrary number of splitters that traverse disjoint subsets of arbitrary sizes.

Implementors might want to override the parameterless split method for efficiency.

Parallel sequence iterators allow splitting into arbitrary subsets.

A splitter (or a split iterator) can be split into more splitters that traverse over disjoint subsets of elements.

A trait implementing the scheduling of a parallel collection operation.

Parallel collections are modular in the way operations are scheduled. Each parallel collection is parameterized with a task support object which is responsible for scheduling and load-balancing tasks to processors.

A task support object can be changed in a parallel collection after it has been created, but only during a quiescent period, i.e. while there are no concurrent invocations to parallel collection methods.

There are currently a few task support implementations available for parallel collections. The scala.collection.parallel.ForkJoinTaskSupport uses a fork-join pool internally.

The scala.collection.parallel.ExecutionContextTaskSupport uses the default execution context implementation found in scala.concurrent, and it reuses the thread pool used in scala.concurrent.

The execution context task support is set to each parallel collection by default, so parallel collections reuse the same fork-join pool as the future API.

Here is a way to change the task support of a parallel collection:

import scala.collection.parallel._
val pc = mutable.ParArray(1, 2, 3)
pc.tasksupport = new ForkJoinTaskSupport(
  new java.util.concurrent.ForkJoinPool(2))

Composite throwable - thrown when multiple exceptions are thrown at the same time.

A task support that uses a thread pool executor to schedule tasks.

An implementation of tasks objects based on the Java thread pooling API.