hyper/race semantics
 Share
The version of the browser you are using is no longer supported. Please upgrade to a supported browser.Dismiss

 
View only
 
 
Still loading...
ABCDEFGHIJKLMNOPQRSTUVWXYZ
1
Key
2
Terminates parallel and list processing (result is item, hash, Supply, etc.)
3
Terminates parallel processing, resulting in a sequential Seq or List
4
Remains/continues in hyper paradigm
5
Remains/continues in race paradigm
6
7
OperationSemantics of hyperDone/TestedSemantics of raceDone/Tested
8
AT-POSDelegated to .cacheDelegated to .cache
9
ArrayMakes an Array from the sequential iteratorMakes an Array from the sequential iterator
10
BagDefined in terms of .listDefined in terms of .list
11
BagHashDefined in terms of .listDefined in terms of .list
12
BoolDelegated to .cacheDelegated to .cache
13
EXISTS-POSDelegated to .cacheDelegated to .cache
14
HashDefined as .hash.HashDefined as .hash.Hash
15
IntDelegated to .cacheDelegated to .cache
16
ListMakes a List from the sequential iteratorMakes a List from the sequential iterator
17
MapDefined as .hash.MapDefined as .hash.Map
18
MixDefined in terms of .listDefined in terms of .list
19
MixHashDefined in terms of .listDefined in terms of .list
20
NumericDelegated to .cacheDelegated to .cache
21
SetDefined in terms of .listDefined in terms of .list
22
SetHashDefined in terms of .listDefined in terms of .list
23
SlipMakes a Slip from the sequential iteratorMakes a Slip from the sequential iterator
24
StrDelegated to .cacheDelegated to .cache
25
StringyDelegated to .cacheDelegated to .cache
26
Supply
Produces a serial Supply, with values emitted as they are
produced. May be revisited when we have `hyper whenever
$s { ... }` semantics clear.)
Produces a non-serial Supply, with values emitted as they
are produced. (Note that most things that process supplies
will enforce serial processing.) May be revisited when we
have `race whenever $s { ... }` semantics clear.
27
allDefined in terms of .eagerDefined in terms of .eager
28
antipairsSame as .pairs but with key/value flippedSame as .pairs but with key/value flipped
29
anyDefined in terms of .eagerDefined in terms of .eager
30
batch
Groups input items into groups of the specified size, which
respect the input order. Downstream operations can process
these batches in parallel.
Groups input items into groups of the specified size, based
on the order that the items become available from the
preceding operation. Thus the order of the batches and the
items inside the batches may be disordered with regard
to the input.
31
cacheMakes a List from the sequential iterator and saves itMakes a List from the sequential iterator and saves it
32
categorize
May call the mapper in parallel; result arrays ordered
relative to input items
May call the mapper in parallel; item order in result arrays
may not respect input order
33
classify
May call the mapper in parallel; result arrays ordered
relative to input items
May call the mapper in parallel; item order in result arrays
may not respect input order
34
collateDefined in terms of .sortDefined in terms of .sort
35
combinations
Equivalent to .list.combinations(...).hyper, except it may
internally work in parallel to produce the combinations
Equivalent to .list.combinations(...).race, except it may
internally work in parallel to produce the combinations
36
deepmap
Semantics as with Seq.deepmap, producing a List, but the
operation may be applied to values and sublists in parallel.
Semantics as with Seq.deepmap, producing a List, but the
operation may be applied to values and sublists in parallel
and the order of results at both the top level and in sublists
is undefined.
37
duckmap
Semantics as with Seq.duckmap, producing a List, but the
operation may be applied to values and sublists in parallel.
Semantics as with Seq.duckmap, producing a List, but the
operation may be applied to values and sublists in parallel
and the order of results at both the top level and in sublists
is undefined."
38
eagerDefined as .List.eagerDefined as .List.eager
39
elemsDelegated to .cacheDelegated to .cache
40
endDelegated to .listDelegated to .list
41
first
Applies predicate in parallel, but must return the first found
item with respect to input order; predicate may be applied to
items beyond that which matches
Applies predicate in parallel; returns first matching item
regardless of input order. Predicate may be applied and
match on items other than the one that is returned.
42
flat
May flatten (and so evaluate) sublists in parallel, but order
of both input lists and sublists is retained
May flatten (and so evaluate) sublists in parallel; elements
from different sublists being flattened in may become
interleaved
43
flatmapDefined as .map(...).flatDefined as .map(...).flat
44
fmtDelegated to .cacheDelegated to .cache
45
gistDelegated to .cacheDelegated to .cache
46
grep
Applies predicate in parallel. Outputs matching items with
respect to input order.
Applies predicate in parallel. Outputs matching items as they
are found, maybe dis-ordering them
47
hashDefined in terms of .iterator.
Defined in terms of .iterator, which disordered values
relative to their inputs. This is unprobelamtic if the results
are Pairs; beware of keys/values.
48
head
The first item produced, relative to the order of the input
items.
The first item produced, without any regard to the order of
the inputs. Effectively, an item that was quick to produce.
49
head(N)
The first N items produced, relative to the order of the input
items. It is possible elements from the input beyond those
resulting in values being returned will be processed.
The first N items produced by the computation, without any
regard to the order of the inputs. Useful when you need N
results, and those produced soonest are good enough.
50
hyperIdentityMakes any following operations respect ordering
51
invertDefined as .map(-> Pair $p { $p.value => $p.key })Defined as .map(-> Pair $p { $p.value => $p.key })
52
is-lazyReturns FalseReturns False
53
iterator
Ends parallel pipeline; will get values relative to input order
Ends parallel pipeline; will get values in the produced order
54
join
Defined in terms of the sequential .iterator. The joined items
will be relative to the input order, and sub-parts may be
joined in parallel.
Defined in terms of the sequential .iterator. Thus the joined
items will be in the order produced, and may be disordered
with regard to the input computation. Sub-parts may be
joined in parallel.
55
keys
Produces a sequence of ascending integers, starting from
zero. They are only produced when the input item at that
index has been processed.
Produces integers starting from zero and incrementing with
each value that is processed. The order of the integers will
likely have little useful meaning. Why are you even using
this?
56
kv
Produces an alternating sequence of ascending integers and
values.
Defined as .hyper.kv, since otherwise the integers would
potentially soon end up scattered any old way among the
values. Note that unless this is the first item in the parallel
pipeline, the data may already have been disordered. If it's
the first, then the .race should have been .hyper in the first
place.
57
lazyDefined in terms of the sequential .iteratorDefined in terms of the sequential .iterator
58
lazy-ifDefined in terms of .lazyDefined in terms of .lazy
59
listMakes a List from the sequential iteratorMakes a List from the sequential iterator
60
map
Applies the mapping in parallel. Produces output relative to
input order. Respects Slips.
Applies the mapping in parallel. Outputs may be disordered
relative to inputs. Items inserted by a Slip will be together in
the direct output, but may be disordered by further operations
under the race paradigm.
61
max
Performs comparisons in parallel on items as they become
available, producing the maximum value.
Performs comparisons in parallel on items as they become
available, producing the maximum value.
62
maxpairs
Produces results equivalent to Seq.maxpairs; comparisons
may be done in parallel
Produces results equivalent to Seq.maxpairs; comparisons
may be done in parallel
63
min
Performs comparisons in parallel on items as they become
available, producing the minimum value.
Performs comparisons in parallel on items as they become
available, producing the minimum value.
64
minmax
Results as with Seq.minmax, but may call &by in parallel
Results as with Seq.minmax, but may call &by in parallel
65
minpairs
Produces results equivalent to Seq.minpairs; comparisons
may be done in parallel
Produces results equivalent to Seq.minpairs; comparisons
may be done in parallel
66
nodemap
Semantics as with Seq.nodemap, producing a List, but the
operation may be applied in parallel.
Semantics as with Seq.nodemap, producing a List, but the
operation may be applied in parallel and the results may be
disordered relative to the inputs.
67
noneDefined in terms of .eagerDefined in terms of .eager
68
notDefined in terms of .BoolDefined in terms of .Bool
69
oneDefined in terms of .eagerDefined in terms of .eager
70
pairs
Produces pairs mapping the integer index of the item in the
input sequence to the item itself.
Produces pairs mapping the integer index of the item in the
input sequence to the item itself. Unless this is the very first
operation in the parallel chain, the integers will have no
particular relation to the original input order. If it is, then this
may be useful in that it allows you to retain the original
positions of items while processing them in any order.
But in most cases, it would have been better to just use
.hyper.
71
pairupEquivalent to .batch(2).map({ .[0] => .[1] })
Equivalent to .batch(2).map({ .[0] => .[1] }) (noting that the
input items may be disordered by prior operations)
72
perlDelegated to .cache, with .hyper appendedDelegated to .cache, with .race appended
73
permutations
Equivalent to .list.permutations.hyper, except it may
internally work in parallel to produce the permutations
Equivalent to .list.permutations.race, except it may
internally work in parallel to produce the permutations
74
pickDelegated to .listDelegated to .list
75
pick(N)
Must see all values from the previous step in order to start
producing results; stays in parallel processing mdoe
Must see all values from the previous step in order to start
producing results; stays in parallel processing mdoe
76
produce
Applies the reduction operation to values in order, and so will
never call it in parallel. Produces all intermediate results,
which may themselves be processed in parallel.
Applies the reduction operation to values in order, and so will
never call it in parallel (otherwise it's hard to produce
meaningful intermediate results). Since the values will be
disordered relative to the inputs, however, it's important
that the operation commutes. Further steps in the pipeline
will process the produced values in any order.
77
raceMeans any following operations need not respect orderIdentity
78
reduce
Applies the reduction operation to values in order, and so will
never call it in parallel. Thus, equivalent to .list.reduce.
Applies the reduction operator in parallel to batches, and
then further reduces those to a single result. The reduction
operator may thus run in parallel, and the result will only
make sense if it is commutative.
79
repeated
Emits values that value already been seen. May execute
&as or &with in parallel.
Defined as .hyper.repeated (e.g. switches on ordering for
following operations)
80
reverse
Emits items in reverse order relative to the input order.
Keeps processing in the hyper paradigm.
Identity result, together with a warning. (The items are not
ordered, and so there's no useful use for reverse here.)
81
rollDelegated to .listDelegated to .list
82
roll(N)
Must see all values from the previous step in order to start
producing results; stays in parallel processing mdoe
Must see all values from the previous step in order to start
producing results; stays in parallel processing mdoe
83
rotor
Works as with Seq.rotor, except that the results may also
be processed in parallel
Works as with Seq.rotor, except the items in the batches
and the batches themselves may be produced out of
order
84
sinkBlocks until all values have been processedBlocks until all values have been processed
85
skipExcludes the first N items from the input
Excludes the first N items produced, without regard to the
input order (effectively, excludes any N items)
86
soDefined in terms of .BoolDefined in terms of .Bool
87
sort
May invoke the sort criteria in parallel, and work internally in
parallel.
Defined as .hyper.sort (e.g. switches on ordering for following
operations)
88
squish
May invoke the as/with in parallel. Works by squishing
batches of values in parallels, then further squishing at
the boundaries, meaning the &as may be invoked
more times than in the sequential case.
Defined as .hyper.squish (e.g. switches on ordering for
following operations).
89
sumDefined in terms of .reduceDefined in terms of .reduce
90
tail
Gets the final item produced, relative to the input items.
Gets the final item produced; since this is unordered, it could
be any item.
91
tail(N)
Gives the final N items produced, which will be ordered
relative to the inputs.
Gives the last N items that are produced by the parallel
pipeline, without regard to input order. Effectively, you can
rely on getting any N items, and all input items have been
processed.
92
treeImplemented in terms of .iteratorImplemented in terms of .iterator
93
unique
May invoke the as/with in parallel, and may invoke them
more times than the sequential equivalent, depending on
implementation.
May invoke the as/with in parallel, and may invoke them
more times than the sequential equivalent, depending on
implementation.
94
valuesIdentityIdentity
95
96
97
98
99
100
Loading...
 
 
 
Sheet1