Пакет scala.collection.parallel.immutable

Неизменяемый параллельный хэш-мап, основанный на хэш-дереве.

Это базовый трайт для параллельных коллекций 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.

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

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

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

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

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

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

Неизменяемое параллельное хеш-множество, основанное на хеш-деревьях.

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

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

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

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 реализован как операция постоянного времени для параллельных коллекций, и операции параллельных коллекций опираются на это предположение.

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

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

Это базовый трайт для параллельных коллекций 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 реализован как операция постоянного времени для параллельных коллекций, и операции с параллельными коллекциями полагаются на это предположение.

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

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

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

Параллельные диапазоны.

Это базовый трайт для параллельных коллекций 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 реализован как операция постоянного времени для параллельных коллекций, и на этом предположении основаны операции параллельных коллекций.

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

Неизменяемые параллельные векторы, основанные на векторах.

Это базовый трайт для параллельных коллекций 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 реализован как операция постоянного времени для параллельных коллекций, и параллельные операции коллекций полагаются на это предположение.

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