1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
// ==++==
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// ==--==
// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
//
// IntMinMaxAggregationOperator.cs
//
// <OWNER>[....]</OWNER>
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Threading;
#if SILVERLIGHT
using System.Core; // for System.Core.SR
#endif
namespace System.Linq.Parallel
{
/// <summary>
/// An inlined min/max aggregation and its enumerator, for ints.
/// </summary>
internal sealed class IntMinMaxAggregationOperator : InlinedAggregationOperator<int, int, int>
{
private readonly int m_sign; // The sign (-1 for min, 1 for max).
//---------------------------------------------------------------------------------------
// Constructs a new instance of a min/max associative operator.
//
internal IntMinMaxAggregationOperator(IEnumerable<int> child, int sign) : base(child)
{
Contract.Assert(sign == -1 || sign == 1, "invalid sign");
m_sign = sign;
}
//---------------------------------------------------------------------------------------
// Executes the entire query tree, and aggregates the intermediate results into the
// final result based on the binary operators and final reduction.
//
// Return Value:
// The single result of aggregation.
//
protected override int InternalAggregate(ref Exception singularExceptionToThrow)
{
// Because the final reduction is typically much cheaper than the intermediate
// reductions over the individual partitions, and because each parallel partition
// will do a lot of work to produce a single output element, we prefer to turn off
// pipelining, and process the final reductions serially.
using (IEnumerator<int> enumerator = GetEnumerator(ParallelMergeOptions.FullyBuffered, true))
{
// Throw an error for empty results.
if (!enumerator.MoveNext())
{
singularExceptionToThrow = new InvalidOperationException(SR.GetString(SR.NoElements));
return default(int);
}
int best = enumerator.Current;
// Based on the sign, do either a min or max reduction.
if (m_sign == -1)
{
while (enumerator.MoveNext())
{
int current = enumerator.Current;
if (current < best)
{
best = current;
}
}
}
else
{
while (enumerator.MoveNext())
{
int current = enumerator.Current;
if (current > best)
{
best = current;
}
}
}
return best;
}
}
//---------------------------------------------------------------------------------------
// Creates an enumerator that is used internally for the final aggregation step.
//
protected override QueryOperatorEnumerator<int, int> CreateEnumerator<TKey>(
int index, int count, QueryOperatorEnumerator<int, TKey> source, object sharedData, CancellationToken cancellationToken)
{
return new IntMinMaxAggregationOperatorEnumerator<TKey>(source, index, m_sign, cancellationToken);
}
//---------------------------------------------------------------------------------------
// This enumerator type encapsulates the intermediary aggregation over the underlying
// (possibly partitioned) data source.
//
private class IntMinMaxAggregationOperatorEnumerator<TKey> : InlinedAggregationOperatorEnumerator<int>
{
private readonly QueryOperatorEnumerator<int, TKey> m_source; // The source data.
private readonly int m_sign; // The sign for comparisons (-1 means min, 1 means max).
//---------------------------------------------------------------------------------------
// Instantiates a new aggregation operator.
//
internal IntMinMaxAggregationOperatorEnumerator(QueryOperatorEnumerator<int, TKey> source, int partitionIndex, int sign,
CancellationToken cancellationToken) :
base(partitionIndex, cancellationToken)
{
Contract.Assert(source != null);
m_source = source;
m_sign = sign;
}
//---------------------------------------------------------------------------------------
// Tallies up the min/max of the underlying data source, walking the entire thing the first
// time MoveNext is called on this object.
//
protected override bool MoveNextCore(ref int currentElement)
{
// Based on the sign, do either a min or max reduction.
QueryOperatorEnumerator<int, TKey> source = m_source;
TKey keyUnused = default(TKey);
if (source.MoveNext(ref currentElement, ref keyUnused))
{
int i = 0;
// We just scroll through the enumerator and find the min or max.
if (m_sign == -1)
{
int elem = default(int);
while (source.MoveNext(ref elem, ref keyUnused))
{
if ((i++ & CancellationState.POLL_INTERVAL) == 0)
CancellationState.ThrowIfCanceled(m_cancellationToken);
if (elem < currentElement)
{
currentElement = elem;
}
}
}
else
{
int elem = default(int);
while (source.MoveNext(ref elem, ref keyUnused))
{
if ((i++ & CancellationState.POLL_INTERVAL) == 0)
CancellationState.ThrowIfCanceled(m_cancellationToken);
if (elem > currentElement)
{
currentElement = elem;
}
}
}
// The sum has been calculated. Now just return.
return true;
}
return false;
}
//---------------------------------------------------------------------------------------
// Dispose of resources associated with the underlying enumerator.
//
protected override void Dispose(bool disposing)
{
Contract.Assert(m_source != null);
m_source.Dispose();
}
}
}
}
|
