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
|
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.vespa.curator.stats;
import com.yahoo.vespa.curator.stats.LatencyStats.ActiveInterval;
import java.util.concurrent.atomic.AtomicInteger;
/**
* A collection of counters for events related to lock acquisition and release.
*
* @author hakon
*/
public class LockMetrics {
private final AtomicInteger acquireCount = new AtomicInteger(0);
private final AtomicInteger acquireFailedCount = new AtomicInteger(0);
private final AtomicInteger acquireTimedOutCount = new AtomicInteger(0);
private final AtomicInteger acquireSucceededCount = new AtomicInteger(0);
private final AtomicInteger releaseCount = new AtomicInteger(0);
private final AtomicInteger releaseFailedCount = new AtomicInteger(0);
private final AtomicInteger reentryCount = new AtomicInteger(0);
private final AtomicInteger cumulativeAcquireCount = new AtomicInteger(0);
private final AtomicInteger cumulativeAcquireFailedCount = new AtomicInteger(0);
private final AtomicInteger cumulativeAcquireTimedOutCount = new AtomicInteger(0);
private final AtomicInteger cumulativeAcquireSucceededCount = new AtomicInteger(0);
private final AtomicInteger cumulativeReleaseCount = new AtomicInteger(0);
private final AtomicInteger cumulativeReleaseFailedCount = new AtomicInteger(0);
private final AtomicInteger cumulativeReentryCount = new AtomicInteger(0);
private final LatencyStats acquireStats = new LatencyStats();
private final LatencyStats lockedStats = new LatencyStats();
private final AtomicInteger deadlockCount = new AtomicInteger(0);
private final AtomicInteger acquireWithoutReleaseCount = new AtomicInteger(0);
private final AtomicInteger nakedReleaseCount = new AtomicInteger(0);
private final AtomicInteger foreignReleaseCount = new AtomicInteger(0);
private final AtomicInteger cumulativeDeadlockCount = new AtomicInteger(0);
private final AtomicInteger cumulativeAcquireWithoutReleaseCount = new AtomicInteger(0);
private final AtomicInteger cumulativeNakedReleaseCount = new AtomicInteger(0);
private final AtomicInteger cumulativeForeignReleaseCount = new AtomicInteger(0);
/** Returns a Runnable that must be invoked when the acquire() finishes. */
ActiveInterval acquireInvoked(boolean reentry) {
if (reentry) {
reentryCount.incrementAndGet();
cumulativeReentryCount.incrementAndGet();
return () -> { };
}
acquireCount.incrementAndGet();
cumulativeAcquireCount.incrementAndGet();
return acquireStats.startNewInterval();
}
void acquireFailed(boolean reentry, ActiveInterval acquireInterval) {
acquireInterval.close();
if (reentry) return;
acquireFailedCount.incrementAndGet();
cumulativeAcquireFailedCount.incrementAndGet();
}
void acquireTimedOut(boolean reentry, ActiveInterval acquireInterval) {
acquireInterval.close();
if (reentry) return;
acquireTimedOutCount.incrementAndGet();
cumulativeAcquireTimedOutCount.incrementAndGet();
}
ActiveInterval lockAcquired(boolean reentry, ActiveInterval acquireInterval) {
acquireInterval.close();
if (reentry) return () -> {};
acquireSucceededCount.incrementAndGet();
cumulativeAcquireSucceededCount.incrementAndGet();
return lockedStats.startNewInterval();
}
void preRelease(boolean reentry, ActiveInterval lockedInterval) {
lockedInterval.close();
if (reentry) return;
releaseCount.incrementAndGet();
cumulativeReleaseCount.incrementAndGet();
}
void releaseFailed(boolean reentry) {
if (reentry) return;
releaseFailedCount.incrementAndGet();
cumulativeReleaseFailedCount.incrementAndGet();
}
void incrementDeadlockCount() {
deadlockCount.incrementAndGet();
cumulativeDeadlockCount.incrementAndGet();
}
void incrementAcquireWithoutReleaseCount() {
acquireWithoutReleaseCount.incrementAndGet();
cumulativeAcquireWithoutReleaseCount.incrementAndGet();
}
void incrementNakedReleaseCount() {
nakedReleaseCount.incrementAndGet();
cumulativeNakedReleaseCount.incrementAndGet();
}
void incrementForeignReleaseCount() {
foreignReleaseCount.incrementAndGet();
cumulativeForeignReleaseCount.incrementAndGet();
}
public int getAndResetAcquireCount() { return acquireCount.getAndSet(0); }
public int getAndResetAcquireFailedCount() { return acquireFailedCount.getAndSet(0); }
public int getAndResetAcquireTimedOutCount() { return acquireTimedOutCount.getAndSet(0); }
public int getAndResetAcquireSucceededCount() { return acquireSucceededCount.getAndSet(0); }
public int getAndResetReleaseCount() { return releaseCount.getAndSet(0); }
public int getAndResetReleaseFailedCount() { return releaseFailedCount.getAndSet(0); }
public int getAndResetReentryCount() { return reentryCount.getAndSet(0); }
public int getAndResetDeadlockCount() { return deadlockCount.getAndSet(0); }
public int getAndResetAcquireWithoutReleaseCount() { return acquireWithoutReleaseCount.getAndSet(0); }
public int getAndResetNakedReleaseCount() { return nakedReleaseCount.getAndSet(0); }
public int getAndResetForeignReleaseCount() { return foreignReleaseCount.getAndSet(0); }
public int getCumulativeAcquireCount() { return cumulativeAcquireCount.get(); }
public int getCumulativeAcquireFailedCount() { return cumulativeAcquireFailedCount.get(); }
public int getCumulativeAcquireTimedOutCount() { return cumulativeAcquireTimedOutCount.get(); }
public int getCumulativeAcquireSucceededCount() { return cumulativeAcquireSucceededCount.get(); }
public int getCumulativeReleaseCount() { return cumulativeReleaseCount.get(); }
public int getCumulativeReleaseFailedCount() { return cumulativeReleaseFailedCount.get(); }
public int getCumulativeReentryCount() { return cumulativeReentryCount.get(); }
public int getCumulativeDeadlockCount() { return cumulativeDeadlockCount.get(); }
public int getCumulativeAcquireWithoutReleaseCount() { return cumulativeAcquireWithoutReleaseCount.get(); }
public int getCumulativeNakedReleaseCount() { return cumulativeNakedReleaseCount.get(); }
public int getCumulativeForeignReleaseCount() { return cumulativeForeignReleaseCount.get(); }
public LatencyMetrics getAcquireLatencyMetrics() { return acquireStats.getLatencyMetrics(); }
public LatencyMetrics getLockedLatencyMetrics() { return lockedStats.getLatencyMetrics(); }
public LatencyMetrics getAndResetAcquireLatencyMetrics() { return acquireStats.getLatencyMetricsAndStartNewPeriod(); }
public LatencyMetrics getAndResetLockedLatencyMetrics() { return lockedStats.getLatencyMetricsAndStartNewPeriod(); }
// For tests
LockMetrics setAcquireCount(int count) { acquireCount.set(count); return this; }
LockMetrics setAcquireFailedCount(int count) { acquireFailedCount.set(count); return this; }
LockMetrics setAcquireTimedOutCount(int count) { acquireTimedOutCount.set(count); return this; }
LockMetrics setAcquireSucceededCount(int count) { acquireSucceededCount.set(count); return this; }
LockMetrics setReleaseCount(int count) { releaseCount.set(count); return this; }
LockMetrics setReleaseFailedCount(int count) { releaseFailedCount.set(count); return this; }
LockMetrics setReentryCount(int count) { reentryCount.set(count); return this; }
// For tests
LockMetrics setCumulativeAcquireCount(int count) { cumulativeAcquireCount.set(count); return this; }
LockMetrics setCumulativeAcquireFailedCount(int count) { cumulativeAcquireFailedCount.set(count); return this; }
LockMetrics setCumulativeAcquireTimedOutCount(int count) { cumulativeAcquireTimedOutCount.set(count); return this; }
LockMetrics setCumulativeAcquireSucceededCount(int count) { cumulativeAcquireSucceededCount.set(count); return this; }
LockMetrics setCumulativeReleaseCount(int count) { cumulativeReleaseCount.set(count); return this; }
LockMetrics setCumulativeReleaseFailedCount(int count) { cumulativeReleaseFailedCount.set(count); return this; }
LockMetrics setCumulativeReentryCount(int count) { cumulativeReentryCount.set(count); return this; }
@Override
public String toString() {
return "LockMetrics{" +
"acquireCount=" + acquireCount +
", acquireFailedCount=" + acquireFailedCount +
", acquireTimedOutCount=" + acquireTimedOutCount +
", acquireSucceededCount=" + acquireSucceededCount +
", releaseCount=" + releaseCount +
", releaseFailedCount=" + releaseFailedCount +
", reentryCount=" + reentryCount +
", cumulativeAcquireCount=" + cumulativeAcquireCount +
", cumulativeAcquireFailedCount=" + cumulativeAcquireFailedCount +
", cumulativeAcquireTimedOutCount=" + cumulativeAcquireTimedOutCount +
", cumulativeAcquireSucceededCount=" + cumulativeAcquireSucceededCount +
", cumulativeReleaseCount=" + cumulativeReleaseCount +
", cumulativeReleaseFailedCount=" + cumulativeReleaseFailedCount +
", cumulativeReentryCount=" + cumulativeReentryCount +
", acquireStats=" + acquireStats +
", lockedStats=" + lockedStats +
'}';
}
}
|
