scala.collection.parallel.mutable

Implements combining contents of two combiners by postponing the operation until result method is called. It chains the leaf results together instead of evaluating the actual collection.

Type parameters

Buff: the type of the buffers that contain leaf results and this combiner chains together
Elem: the type of the elements in the combiner
To: the type of the collection the combiner produces

Attributes

Supertypes: trait Combiner[Elem, To]

trait Parallel

trait Sizing

trait Builder[Elem, To]

trait Growable[Elem]

trait Clearable

class Object

trait Matchable

class Any
Show all
Known subtypes: trait ResizableParArrayCombiner[T]

Parallel sequence holding elements in a linear array.

ParArray is a parallel sequence with a predefined size. The size of the array cannot be changed after it's been created.

ParArray internally keeps an array containing the elements. This means that bulk operations based on traversal ensure fast access to elements. ParArray uses lazy builders that create the internal data array only after the size of the array is known. In the meantime, they keep the result set fragmented. The fragments are copied into the resulting data array in parallel using fast array copy operations once all the combiners are populated in parallel.

Type parameters

T: type of the elements in the array

Attributes

See also: Scala's Parallel Collections Library overview section on ParArray for more information.
Companion: object
Supertypes: trait Serializable

trait ParSeq[T]

trait ParSeq[T]

trait ParSeqLike[T, ParArray, ParArray[T], ArraySeq[T]]

trait Equals

trait ParIterable[T]

trait ParIterable[T]

trait ParIterableLike[T, ParArray, ParArray[T], ArraySeq[T]]

trait Parallel

trait CustomParallelizable[T, ParArray[T]]

trait Parallelizable[T, ParArray[T]]

trait IterableOnce[T]

trait GenericParTemplate[T, ParArray]

trait HasNewCombiner[T, ParArray[T]]

trait GenericTraversableTemplate[T, ParArray]

trait HasNewBuilder[T, ParArray[T]]

class Object

trait Matchable

class Any
Show all
Self type: ParArray[T]

This object provides a set of operations needed to create ParIterable values.

Attributes

Companion: class
Supertypes: class ParFactory[ParArray]

trait GenericParCompanion[ParArray]

class Object

trait Matchable

class Any
Self type: ParArray.type

Parallel flat hash table.

Type parameters

T: type of the elements in the $coll.

Attributes

Supertypes: trait HashUtils[T]

class Object

trait Matchable

class Any
Known subtypes: class ParHashSet[T]

A parallel hash map.

ParHashMap is a parallel map which internally keeps elements within a hash table. It uses chaining to resolve collisions.

Type parameters

K: type of the keys in the parallel hash map
V: type of the values in the parallel hash map

Attributes

Companion: object
Supertypes: trait Serializable

trait ParHashTable[K, V, DefaultEntry[K, V]]

trait WithContents[K, V, DefaultEntry[K, V]]

trait HashUtils[K]

trait ParMap[K, V]

trait ParMapLike[K, V, ParHashMap, ParHashMap[K, V], HashMap[K, V]]

trait Cloneable[ParHashMap[K, V]]

trait Cloneable

trait Shrinkable[K]

trait Growable[(K, V)]

trait Clearable

trait ParIterable[(K, V)]

trait ParMap[K, V]

trait ParMapLike[K, V, ParHashMap, ParHashMap[K, V], HashMap[K, V]]

trait Equals

trait ParIterable[(K, V)]

trait ParIterableLike[(K, V), ParIterable, ParHashMap[K, V], HashMap[K, V]]

trait Parallel

trait CustomParallelizable[(K, V), ParHashMap[K, V]]

trait Parallelizable[(K, V), ParHashMap[K, V]]

trait IterableOnce[(K, V)]

trait GenericParMapTemplate[K, V, ParHashMap]

trait GenericParTemplate[(K, V), ParIterable]

trait HasNewCombiner[(K, V), ParHashMap[K, V]]

trait GenericTraversableTemplate[(K, V), ParIterable]

trait HasNewBuilder[(K, V), ParIterable[(K, V)]]

class Object

trait Matchable

class Any
Show all
Self type: ParHashMap[K, V]

This object provides a set of operations needed to create ParMap values.

Attributes

Companion: class
Supertypes: class ParMapFactory[ParHashMap, HashMap]

trait GenericParMapCompanion[ParHashMap]

class Object

trait Matchable

class Any
Self type: ParHashMap.type

A parallel hash set.

ParHashSet is a parallel set which internally keeps elements within a hash table. It uses linear probing to resolve collisions.

Type parameters

T: type of the elements in the table.

Attributes

Companion: object
Supertypes: trait Serializable

trait ParFlatHashTable[T]

trait HashUtils[T]

trait ParSet[T]

trait ParSetLike[T, ParHashSet, ParHashSet[T], HashSet[T]]

trait Cloneable[ParHashSet[T]]

trait Cloneable

trait Shrinkable[T]

trait Growable[T]

trait Clearable

trait ParSet[T]

trait ParSetLike[T, ParHashSet, ParHashSet[T], HashSet[T]]

trait Equals

trait T => Boolean

trait ParIterable[T]

trait ParIterable[T]

trait ParIterableLike[T, ParHashSet, ParHashSet[T], HashSet[T]]

trait Parallel

trait CustomParallelizable[T, ParHashSet[T]]

trait Parallelizable[T, ParHashSet[T]]

trait IterableOnce[T]

trait GenericParTemplate[T, ParHashSet]

trait HasNewCombiner[T, ParHashSet[T]]

trait GenericTraversableTemplate[T, ParHashSet]

trait HasNewBuilder[T, ParHashSet[T]]

class Object

trait Matchable

class Any
Show all

This object provides a set of operations needed to create ParIterable values.

Attributes

Companion: class
Supertypes: class ParSetFactory[ParHashSet]

trait GenericParCompanion[ParHashSet]

class Object

trait Matchable

class Any
Self type: ParHashSet.type

Provides functionality for hash tables with linked list buckets, enriching the data structure by fulfilling certain requirements for their parallel construction and iteration.

Attributes

Supertypes: trait WithContents[K, V, Entry]

trait HashUtils[K]

class Object

trait Matchable

class Any
Known subtypes: class ParHashMap[K, V]

A template trait for mutable parallel iterable collections.

This is a base trait for Scala parallel collections. It defines behaviour common to all parallel collections. Concrete parallel collections should inherit this trait and ParIterable if they want to define specific combiner factories.

Parallel operations are implemented with divide and conquer style algorithms that parallelize well. The basic idea is to split the collection into smaller parts until they are small enough to be operated on sequentially.

All of the parallel operations are implemented as tasks within this trait. Tasks rely on the concept of splitters, which extend iterators. Every parallel collection defines:

   def splitter: IterableSplitter[T]

which returns an instance of IterableSplitter[T], which is a subtype of Splitter[T]. Splitters have a method remaining to check the remaining number of elements, and method split which is defined by splitters. Method split divides the splitters iterate over into disjunct subsets:

   def split: Seq[Splitter]

which splits the splitter into a sequence of disjunct subsplitters. This is typically a very fast operation which simply creates wrappers around the receiver collection. This can be repeated recursively.

Tasks are scheduled for execution through a scala.collection.parallel.TaskSupport object, which can be changed through the tasksupport setter of the collection.

Method newCombiner produces a new combiner. Combiners are an extension of builders. They provide a method combine which combines two combiners and returns a combiner containing elements of both combiners. This method can be implemented by aggressively copying all the elements into the new combiner or by lazily binding their results. It is recommended to avoid copying all of the elements for performance reasons, although that cost might be negligible depending on the use case. Standard parallel collection combiners avoid copying when merging results, relying either on a two-step lazy construction or specific data-structure properties.

Methods:

   def seq: Sequential
   def par: Repr

produce the sequential or parallel implementation of the collection, respectively. Method par just returns a reference to this parallel collection. Method seq is efficient - it will not copy the elements. Instead, it will create a sequential version of the collection using the same underlying data structure. Note that this is not the case for sequential collections in general - they may copy the elements and produce a different underlying data structure.

The combination of methods toMap, toSeq or toSet along with par and seq is a flexible way to change between different collection types.

Since this trait extends the GenIterable trait, methods like size must also be implemented in concrete collections, while iterator forwards to splitter by default.

Each parallel collection is bound to a specific fork/join pool, on which dormant worker threads are kept. The fork/join pool contains other information such as the parallelism level, that is, the number of processors used. When a collection is created, it is assigned the default fork/join pool found in the scala.parallel package object.

Parallel collections are not necessarily ordered in terms of the foreach operation (see Traversable). Parallel sequences have a well defined order for iterators - creating an iterator and traversing the elements linearly will always yield the same order. However, bulk operations such as foreach, map or filter always occur in undefined orders for all parallel collections.

Existing parallel collection implementations provide strict parallel iterators. Strict parallel iterators are aware of the number of elements they have yet to traverse. It's also possible to provide non-strict parallel iterators, which do not know the number of elements remaining. To do this, the new collection implementation must override isStrictSplitterCollection to false. This will make some operations unavailable.

To create a new parallel collection, extend the ParIterable trait, and implement size, splitter, newCombiner and seq. Having an implicit combiner factory requires extending this trait in addition, as well as providing a companion object, as with regular collections.

Method size is implemented as a constant time operation for parallel collections, and parallel collection operations rely on this assumption.

The higher-order functions passed to certain operations may contain side-effects. Since implementations of bulk operations may not be sequential, this means that side-effects may not be predictable and may produce data-races, deadlocks or invalidation of state if care is not taken. It is up to the programmer to either avoid using side-effects or to use some form of synchronization when accessing mutable data.

Type parameters

T: the element type of the collection

Attributes

Companion: object
Supertypes: trait ParIterable[T]

trait ParIterableLike[T, ParIterable, ParIterable[T], Iterable[T]]

trait Parallel

trait CustomParallelizable[T, ParIterable[T]]

trait Parallelizable[T, ParIterable[T]]

trait IterableOnce[T]

trait GenericParTemplate[T, ParIterable]

trait HasNewCombiner[T, ParIterable[T]]

trait GenericTraversableTemplate[T, ParIterable]

trait HasNewBuilder[T, ParIterable[T]]

class Object

trait Matchable

class Any
Show all
Known subtypes: trait ParMap[K, V]

class ParHashMap[K, V]

class WithDefault[K, V]

class ParTrieMap[K, V]

trait ParSeq[T]

class ParArray[T]

trait ParSet[T]

class ParHashSet[T]
Show all

This object provides a set of operations needed to create ParIterable values.

Attributes

Companion: trait
Supertypes: class ParFactory[ParIterable]

trait GenericParCompanion[ParIterable]

class Object

trait Matchable

class Any
Self type: ParIterable.type

A template trait for mutable parallel maps.

The higher-order functions passed to certain operations may contain side-effects. Since implementations of bulk operations may not be sequential, this means that side-effects may not be predictable and may produce data-races, deadlocks or invalidation of state if care is not taken. It is up to the programmer to either avoid using side-effects or to use some form of synchronization when accessing mutable data.

Type parameters

K: the key type of the map
V: the value type of the map

Attributes

Companion: object
Supertypes: trait ParMapLike[K, V, ParMap, ParMap[K, V], Map[K, V]]

trait Cloneable[ParMap[K, V]]

trait Cloneable

trait Shrinkable[K]

trait Growable[(K, V)]

trait Clearable

trait ParIterable[(K, V)]

trait ParMap[K, V]

trait ParMapLike[K, V, ParMap, ParMap[K, V], Map[K, V]]

trait Equals

trait ParIterable[(K, V)]

trait ParIterableLike[(K, V), ParIterable, ParMap[K, V], Map[K, V]]

trait Parallel

trait CustomParallelizable[(K, V), ParMap[K, V]]

trait Parallelizable[(K, V), ParMap[K, V]]

trait IterableOnce[(K, V)]

trait GenericParMapTemplate[K, V, ParMap]

trait GenericParTemplate[(K, V), ParIterable]

trait HasNewCombiner[(K, V), ParMap[K, V]]

trait GenericTraversableTemplate[(K, V), ParIterable]

trait HasNewBuilder[(K, V), ParIterable[(K, V)]]

class Object

trait Matchable

class Any
Show all
Known subtypes: class ParHashMap[K, V]

class WithDefault[K, V]

class ParTrieMap[K, V]

Attributes

Companion: trait
Supertypes: class ParMapFactory[ParMap, Map]

trait GenericParMapCompanion[ParMap]

class Object

trait Matchable

class Any
Self type: ParMap.type

A template trait for mutable parallel maps. This trait is to be mixed in with concrete parallel maps to override the representation type.

The higher-order functions passed to certain operations may contain side-effects. Since implementations of bulk operations may not be sequential, this means that side-effects may not be predictable and may produce data-races, deadlocks or invalidation of state if care is not taken. It is up to the programmer to either avoid using side-effects or to use some form of synchronization when accessing mutable data.

Type parameters

K: the key type of the map
V: the value type of the map

Attributes

Supertypes: trait Cloneable[Repr]

trait Cloneable

trait Shrinkable[K]

trait Growable[(K, V)]

trait Clearable

trait ParMapLike[K, V, CC, Repr, Sequential]

trait Equals

trait ParIterableLike[(K, V), ParIterable, Repr, Sequential]

trait HasNewCombiner[(K, V), Repr]

trait Parallel

trait CustomParallelizable[(K, V), Repr]

trait Parallelizable[(K, V), Repr]

trait IterableOnce[(K, V)]

class Object

trait Matchable

class Any
Show all
Known subtypes: class ParHashMap[K, V]

trait ParMap[K, V]

class WithDefault[K, V]

class ParTrieMap[K, V]

A mutable variant of ParSeq.

Attributes

Companion: object
Supertypes: trait ParSeq[T]

trait ParSeqLike[T, ParSeq, ParSeq[T], Seq[T]]

trait Equals

trait ParIterable[T]

trait ParIterable[T]

trait ParIterableLike[T, ParSeq, ParSeq[T], Seq[T]]

trait Parallel

trait CustomParallelizable[T, ParSeq[T]]

trait Parallelizable[T, ParSeq[T]]

trait IterableOnce[T]

trait GenericParTemplate[T, ParSeq]

trait HasNewCombiner[T, ParSeq[T]]

trait GenericTraversableTemplate[T, ParSeq]

trait HasNewBuilder[T, ParSeq[T]]

class Object

trait Matchable

class Any
Show all
Known subtypes: class ParArray[T]
Self type: ParSeq[T]

This object provides a set of operations needed to create ParIterable values.

Attributes

Companion: trait
Supertypes: class ParFactory[ParSeq]

trait GenericParCompanion[ParSeq]

class Object

trait Matchable

class Any
Self type: ParSeq.type

A mutable variant of ParSet.

Attributes

Companion: object
Supertypes: trait ParSetLike[T, ParSet, ParSet[T], Set[T]]

trait Cloneable[ParSet[T]]

trait Cloneable

trait Shrinkable[T]

trait Growable[T]

trait Clearable

trait ParSet[T]

trait ParSetLike[T, ParSet, ParSet[T], Set[T]]

trait Equals

trait T => Boolean

trait ParIterable[T]

trait ParIterable[T]

trait ParIterableLike[T, ParSet, ParSet[T], Set[T]]

trait Parallel

trait CustomParallelizable[T, ParSet[T]]

trait Parallelizable[T, ParSet[T]]

trait IterableOnce[T]

trait GenericParTemplate[T, ParSet]

trait HasNewCombiner[T, ParSet[T]]

trait GenericTraversableTemplate[T, ParSet]

trait HasNewBuilder[T, ParSet[T]]

class Object

trait Matchable

class Any
Show all
Known subtypes: class ParHashSet[T]
Self type: ParSet[T]

This object provides a set of operations needed to create ParIterable values.

Attributes

Companion: trait
Supertypes: class ParSetFactory[ParSet]

trait GenericParCompanion[ParSet]

class Object

trait Matchable

class Any
Self type: ParSet.type

A template trait for mutable parallel sets. This trait is mixed in with concrete parallel sets to override the representation type.

The higher-order functions passed to certain operations may contain side-effects. Since implementations of bulk operations may not be sequential, this means that side-effects may not be predictable and may produce data-races, deadlocks or invalidation of state if care is not taken. It is up to the programmer to either avoid using side-effects or to use some form of synchronization when accessing mutable data.

Type parameters

T: the element type of the set

Attributes

Supertypes: trait Cloneable[Repr]

trait Cloneable

trait Shrinkable[T]

trait Growable[T]

trait Clearable

trait ParSetLike[T, CC, Repr, Sequential]

trait Equals

trait T => Boolean

trait ParIterableLike[T, CC, Repr, Sequential]

trait HasNewCombiner[T, Repr]

trait Parallel

trait CustomParallelizable[T, Repr]

trait Parallelizable[T, Repr]

trait IterableOnce[T]

class Object

trait Matchable

class Any
Show all
Known subtypes: class ParHashSet[T]

trait ParSet[T]
Self type: ParSetLike[T, CC, Repr, Sequential]

Parallel TrieMap collection.

It has its bulk operations parallelized, but uses the snapshot operation to create the splitter. This means that parallel bulk operations can be called concurrently with the modifications.

Attributes

See also: Scala's Parallel Collections Library overview section on ParTrieMap for more information.
Companion: object
Supertypes: trait Serializable

trait Combiner[(K, V), ParTrieMap[K, V]]

trait Sizing

trait Builder[(K, V), ParTrieMap[K, V]]

trait ParMap[K, V]

trait ParMapLike[K, V, ParTrieMap, ParTrieMap[K, V], TrieMap[K, V]]

trait Cloneable[ParTrieMap[K, V]]

trait Cloneable

trait Shrinkable[K]

trait Growable[(K, V)]

trait Clearable

trait ParIterable[(K, V)]

trait ParMap[K, V]

trait ParMapLike[K, V, ParTrieMap, ParTrieMap[K, V], TrieMap[K, V]]

trait Equals

trait ParIterable[(K, V)]

trait ParIterableLike[(K, V), ParIterable, ParTrieMap[K, V], TrieMap[K, V]]

trait Parallel

trait CustomParallelizable[(K, V), ParTrieMap[K, V]]

trait Parallelizable[(K, V), ParTrieMap[K, V]]

trait IterableOnce[(K, V)]

trait GenericParMapTemplate[K, V, ParTrieMap]

trait GenericParTemplate[(K, V), ParIterable]

trait HasNewCombiner[(K, V), ParTrieMap[K, V]]

trait GenericTraversableTemplate[(K, V), ParIterable]

trait HasNewBuilder[(K, V), ParIterable[(K, V)]]

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Supertypes: class ParMapFactory[ParTrieMap, TrieMap]

trait GenericParMapCompanion[ParTrieMap]

class Object

trait Matchable

class Any
Self type: ParTrieMap.type

An array combiner that uses a chain of arraybuffers to store elements.

Attributes

Companion: object
Supertypes: trait LazyCombiner[T, ParArray[T], ExposedArrayBuffer[T]]

trait Combiner[T, ParArray[T]]

trait Parallel

trait Sizing

trait Builder[T, ParArray[T]]

trait Growable[T]

trait Clearable

class Object

trait Matchable

class Any
Show all

Attributes

Companion: trait
Supertypes: class Object

trait Matchable

class Any
Self type: ResizableParArrayCombiner.type

An array combiner that uses doubling unrolled buffers to store elements.

Attributes

Companion: object
Supertypes: trait Combiner[T, ParArray[T]]

trait Parallel

trait Sizing

trait Builder[T, ParArray[T]]

trait Growable[T]

trait Clearable

class Object

trait Matchable

class Any
Show all

Attributes

Companion: trait
Supertypes: class Object

trait Matchable

class Any
Self type: UnrolledParArrayCombiner.type

Attributes

Supertypes: class Object

trait Matchable

class Any
Known subtypes: trait ParHashTable[K, V, Entry]

class ParHashMap[K, V]
Self type: HashTable[K, V, Entry]

scala.collection.parallel.mutable

Members list

Type members

Classlikes

Type parameters

Attributes

Type parameters

Attributes

Attributes

Type parameters

Attributes

Type parameters

Attributes

Attributes

Type parameters

Attributes

Attributes

Attributes

Type parameters

Attributes

Attributes

Type parameters

Attributes

Attributes

Type parameters

Attributes

Attributes

Attributes

Attributes

Attributes

Type parameters

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Attributes

Types

Value members

Concrete fields