mirror of
https://github.com/ebean-orm/ebean.git
synced 2026-11-19 23:02:24 +00:00
Bump to java8-parent, update to Java8 LongAdder
This commit is contained in:
1 parent
78c4dbb44d
commit
fad8358a9d
8 files changed
+17
-770
No files matched your search
@@ -3,13 +3,13 @@
|
|||||||
|
|
||||||
<parent>
|
<parent>
|
||||||
<groupId>org.avaje</groupId>
|
<groupId>org.avaje</groupId>
|
||||||
<artifactId>oss-parent</artifactId>
|
<artifactId>java8-parent</artifactId>
|
||||||
<version>1.1</version>
|
<version>1.1</version>
|
||||||
</parent>
|
</parent>
|
||||||
|
|
||||||
<groupId>org.avaje.ebean</groupId>
|
<groupId>org.avaje.ebean</groupId>
|
||||||
<artifactId>ebean</artifactId>
|
<artifactId>ebean</artifactId>
|
||||||
<version>8.8.2-SNAPSHOT</version>
|
<version>9.1.1-SNAPSHOT</version>
|
||||||
<packaging>jar</packaging>
|
<packaging>jar</packaging>
|
||||||
|
|
||||||
<name>ebean</name>
|
<name>ebean</name>
|
||||||
@@ -19,22 +19,6 @@
|
|||||||
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
|
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
|
||||||
</properties>
|
</properties>
|
||||||
|
|
||||||
<licenses>
|
|
||||||
<license>
|
|
||||||
<name>The Apache Software License, Version 2.0</name>
|
|
||||||
<url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
|
|
||||||
<distribution>repo</distribution>
|
|
||||||
</license>
|
|
||||||
</licenses>
|
|
||||||
|
|
||||||
<developers>
|
|
||||||
<developer>
|
|
||||||
<id>rbygrave</id>
|
|
||||||
<name>Rob Bygrave</name>
|
|
||||||
<email>robin.bygrave@gmail.com</email>
|
|
||||||
</developer>
|
|
||||||
</developers>
|
|
||||||
|
|
||||||
<scm>
|
<scm>
|
||||||
<developerConnection>scm:git:https://github.com/ebean-orm/ebean.git</developerConnection>
|
<developerConnection>scm:git:https://github.com/ebean-orm/ebean.git</developerConnection>
|
||||||
<tag>HEAD</tag>
|
<tag>HEAD</tag>
|
||||||
@@ -236,16 +220,6 @@
|
|||||||
<build>
|
<build>
|
||||||
<plugins>
|
<plugins>
|
||||||
|
|
||||||
<plugin>
|
|
||||||
<groupId>org.apache.maven.plugins</groupId>
|
|
||||||
<artifactId>maven-compiler-plugin</artifactId>
|
|
||||||
<version>3.2</version>
|
|
||||||
<configuration>
|
|
||||||
<source>1.6</source>
|
|
||||||
<target>1.6</target>
|
|
||||||
</configuration>
|
|
||||||
</plugin>
|
|
||||||
|
|
||||||
<plugin>
|
<plugin>
|
||||||
<groupId>org.avaje.ebean</groupId>
|
<groupId>org.avaje.ebean</groupId>
|
||||||
<artifactId>ebean-maven-plugin</artifactId>
|
<artifactId>ebean-maven-plugin</artifactId>
|
||||||
@@ -303,7 +277,7 @@
|
|||||||
<artifactId>maven-javadoc-plugin</artifactId>
|
<artifactId>maven-javadoc-plugin</artifactId>
|
||||||
<version>2.9.1</version>
|
<version>2.9.1</version>
|
||||||
<configuration>
|
<configuration>
|
||||||
<doctitle>Ebean 8</doctitle>
|
<doctitle>Ebean 9</doctitle>
|
||||||
<overview>src/main/java/com/avaje/ebean/overview.html</overview>
|
<overview>src/main/java/com/avaje/ebean/overview.html</overview>
|
||||||
<source>1.8</source>
|
<source>1.8</source>
|
||||||
<doclet>org.avaje.doclet.PygmentsDoclet</doclet>
|
<doclet>org.avaje.doclet.PygmentsDoclet</doclet>
|
||||||
|
|||||||
+1
-1
@@ -1,9 +1,9 @@
|
|||||||
package com.avaje.ebeaninternal.server.autotune.service;
|
package com.avaje.ebeaninternal.server.autotune.service;
|
||||||
|
|
||||||
import com.avaje.ebeaninternal.server.autotune.AutoTuneCollection;
|
import com.avaje.ebeaninternal.server.autotune.AutoTuneCollection;
|
||||||
import com.avaje.ebeaninternal.server.util.LongAdder;
|
|
||||||
|
|
||||||
import java.io.Serializable;
|
import java.io.Serializable;
|
||||||
|
import java.util.concurrent.atomic.LongAdder;
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Used to accumulate query execution statistics for paths relative to the origin query.
|
* Used to accumulate query execution statistics for paths relative to the origin query.
|
||||||
|
|||||||
@@ -4,7 +4,7 @@ import com.avaje.ebean.BackgroundExecutor;
|
|||||||
import com.avaje.ebean.cache.ServerCache;
|
import com.avaje.ebean.cache.ServerCache;
|
||||||
import com.avaje.ebean.cache.ServerCacheOptions;
|
import com.avaje.ebean.cache.ServerCacheOptions;
|
||||||
import com.avaje.ebean.cache.ServerCacheStatistics;
|
import com.avaje.ebean.cache.ServerCacheStatistics;
|
||||||
import com.avaje.ebeaninternal.server.util.LongAdder;
|
|
||||||
import org.slf4j.Logger;
|
import org.slf4j.Logger;
|
||||||
import org.slf4j.LoggerFactory;
|
import org.slf4j.LoggerFactory;
|
||||||
|
|
||||||
@@ -16,6 +16,7 @@ import java.util.Iterator;
|
|||||||
import java.util.Map;
|
import java.util.Map;
|
||||||
import java.util.concurrent.ConcurrentHashMap;
|
import java.util.concurrent.ConcurrentHashMap;
|
||||||
import java.util.concurrent.TimeUnit;
|
import java.util.concurrent.TimeUnit;
|
||||||
|
import java.util.concurrent.atomic.LongAdder;
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* The default cache implementation.
|
* The default cache implementation.
|
||||||
@@ -38,7 +39,6 @@ public class DefaultServerCache implements ServerCache {
|
|||||||
*/
|
*/
|
||||||
protected final Map<Object, CacheEntry> map;
|
protected final Map<Object, CacheEntry> map;
|
||||||
|
|
||||||
// LongAdder is a highly concurrent low latency counter (back ported from Java8)
|
|
||||||
protected final LongAdder missCount = new LongAdder();
|
protected final LongAdder missCount = new LongAdder();
|
||||||
protected final LongAdder hitCount = new LongAdder();
|
protected final LongAdder hitCount = new LongAdder();
|
||||||
protected final LongAdder insertCount = new LongAdder();
|
protected final LongAdder insertCount = new LongAdder();
|
||||||
|
|||||||
@@ -1,10 +1,10 @@
|
|||||||
package com.avaje.ebeaninternal.server.core;
|
package com.avaje.ebeaninternal.server.core;
|
||||||
|
|
||||||
import java.util.concurrent.atomic.AtomicLong;
|
import java.util.concurrent.atomic.AtomicLong;
|
||||||
|
import java.util.concurrent.atomic.LongAdder;
|
||||||
|
|
||||||
import com.avaje.ebean.meta.*;
|
import com.avaje.ebean.meta.*;
|
||||||
import com.avaje.ebean.bean.ObjectGraphNode;
|
import com.avaje.ebean.bean.ObjectGraphNode;
|
||||||
import com.avaje.ebeaninternal.server.util.LongAdder;
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Helper to collect the query execution statistics for a given node.
|
* Helper to collect the query execution statistics for a given node.
|
||||||
|
|||||||
@@ -1,17 +1,17 @@
|
|||||||
package com.avaje.ebeaninternal.server.query;
|
package com.avaje.ebeaninternal.server.query;
|
||||||
|
|
||||||
|
import com.avaje.ebean.bean.ObjectGraphNode;
|
||||||
|
import com.avaje.ebean.meta.MetaQueryPlanOriginCount;
|
||||||
|
import com.avaje.ebean.meta.MetaQueryPlanStatistic;
|
||||||
|
|
||||||
import java.util.ArrayList;
|
import java.util.ArrayList;
|
||||||
import java.util.Collections;
|
import java.util.Collections;
|
||||||
import java.util.List;
|
import java.util.List;
|
||||||
import java.util.Map.Entry;
|
import java.util.Map.Entry;
|
||||||
import java.util.concurrent.ConcurrentHashMap;
|
import java.util.concurrent.ConcurrentHashMap;
|
||||||
import java.util.concurrent.atomic.AtomicLong;
|
import java.util.concurrent.atomic.AtomicLong;
|
||||||
|
import java.util.concurrent.atomic.LongAccumulator;
|
||||||
import com.avaje.ebean.bean.ObjectGraphNode;
|
import java.util.concurrent.atomic.LongAdder;
|
||||||
import com.avaje.ebean.meta.MetaQueryPlanOriginCount;
|
|
||||||
import com.avaje.ebean.meta.MetaQueryPlanStatistic;
|
|
||||||
import com.avaje.ebeaninternal.server.util.LongAdder;
|
|
||||||
import com.avaje.ebeaninternal.server.util.LongMaxUpdater;
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Statistics for a specific query plan that can accumulate.
|
* Statistics for a specific query plan that can accumulate.
|
||||||
@@ -26,7 +26,7 @@ public final class CQueryPlanStats {
|
|||||||
|
|
||||||
private final LongAdder totalBeans = new LongAdder();
|
private final LongAdder totalBeans = new LongAdder();
|
||||||
|
|
||||||
private final LongMaxUpdater maxTime = new LongMaxUpdater();
|
private final LongAccumulator maxTime = new LongAccumulator(Math::max, Long.MIN_VALUE);
|
||||||
|
|
||||||
private final AtomicLong startTime = new AtomicLong(System.currentTimeMillis());
|
private final AtomicLong startTime = new AtomicLong(System.currentTimeMillis());
|
||||||
|
|
||||||
@@ -51,7 +51,7 @@ public final class CQueryPlanStats {
|
|||||||
count.increment();
|
count.increment();
|
||||||
totalBeans.add(loadedBeanCount);
|
totalBeans.add(loadedBeanCount);
|
||||||
totalTime.add(timeMicros);
|
totalTime.add(timeMicros);
|
||||||
maxTime.update(timeMicros);
|
maxTime.accumulate(timeMicros);
|
||||||
|
|
||||||
// not safe but should be atomic
|
// not safe but should be atomic
|
||||||
lastQueryTime = System.currentTimeMillis();
|
lastQueryTime = System.currentTimeMillis();
|
||||||
@@ -106,9 +106,9 @@ public final class CQueryPlanStats {
|
|||||||
// not guaranteed to be consistent due to time gaps between getting each value out of LongAdders but can live with that
|
// not guaranteed to be consistent due to time gaps between getting each value out of LongAdders but can live with that
|
||||||
// relative to the cost of making sure count and totalTime etc are all guaranteed to be consistent
|
// relative to the cost of making sure count and totalTime etc are all guaranteed to be consistent
|
||||||
if (reset) {
|
if (reset) {
|
||||||
return new Snapshot(queryPlan, count.sumThenReset(), totalTime.sumThenReset(), totalBeans.sumThenReset(), maxTime.maxThenReset(), startTime.getAndSet(System.currentTimeMillis()), lastQueryTime, origins);
|
return new Snapshot(queryPlan, count.sumThenReset(), totalTime.sumThenReset(), totalBeans.sumThenReset(), maxTime.getThenReset(), startTime.getAndSet(System.currentTimeMillis()), lastQueryTime, origins);
|
||||||
}
|
}
|
||||||
return new Snapshot(queryPlan, count.sum(), totalTime.sum(), totalBeans.sum(), maxTime.max(), startTime.get(), lastQueryTime, origins);
|
return new Snapshot(queryPlan, count.sum(), totalTime.sum(), totalBeans.sum(), maxTime.get(), startTime.get(), lastQueryTime, origins);
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
|||||||
@@ -1,201 +0,0 @@
|
|||||||
package com.avaje.ebeaninternal.server.util;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Written by Doug Lea with assistance from members of JCP JSR-166
|
|
||||||
* Expert Group and released to the public domain, as explained at
|
|
||||||
* http://creativecommons.org/publicdomain/zero/1.0/
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
import java.util.concurrent.atomic.AtomicLong;
|
|
||||||
import java.io.Serializable;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* One or more variables that together maintain an initially zero
|
|
||||||
* {@code long} sum. When updates (method {@link #add}) are contended
|
|
||||||
* across threads, the set of variables may grow dynamically to reduce
|
|
||||||
* contention. Method {@link #sum} (or, equivalently, {@link
|
|
||||||
* #longValue}) returns the current total combined across the
|
|
||||||
* variables maintaining the sum.
|
|
||||||
*
|
|
||||||
* <p>This class is usually preferable to {@link AtomicLong} when
|
|
||||||
* multiple threads update a common sum that is used for purposes such
|
|
||||||
* as collecting statistics, not for fine-grained synchronization
|
|
||||||
* control. Under low update contention, the two classes have similar
|
|
||||||
* characteristics. But under high contention, expected throughput of
|
|
||||||
* this class is significantly higher, at the expense of higher space
|
|
||||||
* consumption.
|
|
||||||
*
|
|
||||||
* <p>This class extends {@link Number}, but does <em>not</em> define
|
|
||||||
* methods such as {@code equals}, {@code hashCode} and {@code
|
|
||||||
* compareTo} because instances are expected to be mutated, and so are
|
|
||||||
* not useful as collection keys.
|
|
||||||
*
|
|
||||||
* <p><em>jsr166e note: This class is targeted to be placed in
|
|
||||||
* java.util.concurrent.atomic.</em>
|
|
||||||
*
|
|
||||||
* @since 1.8
|
|
||||||
* @author Doug Lea
|
|
||||||
*/
|
|
||||||
public class LongAdder extends Striped64 implements Serializable {
|
|
||||||
private static final long serialVersionUID = 7249069246863182397L;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Version of plus for use in retryUpdate
|
|
||||||
*/
|
|
||||||
final long fn(long v, long x) { return v + x; }
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Creates a new adder with initial sum of zero.
|
|
||||||
*/
|
|
||||||
public LongAdder() {
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Adds the given value.
|
|
||||||
*
|
|
||||||
* @param x the value to add
|
|
||||||
*/
|
|
||||||
public void add(long x) {
|
|
||||||
Cell[] as; long b, v; HashCode hc; Cell a; int n;
|
|
||||||
if ((as = cells) != null || !casBase(b = base, b + x)) {
|
|
||||||
boolean uncontended = true;
|
|
||||||
int h = (hc = threadHashCode.get()).code;
|
|
||||||
if (as == null || (n = as.length) < 1 ||
|
|
||||||
(a = as[(n - 1) & h]) == null ||
|
|
||||||
!(uncontended = a.cas(v = a.value, v + x)))
|
|
||||||
retryUpdate(x, hc, uncontended);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Equivalent to {@code add(1)}.
|
|
||||||
*/
|
|
||||||
public void increment() {
|
|
||||||
add(1L);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Equivalent to {@code add(-1)}.
|
|
||||||
*/
|
|
||||||
public void decrement() {
|
|
||||||
add(-1L);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the current sum. The returned value is <em>NOT</em> an
|
|
||||||
* atomic snapshot; invocation in the absence of concurrent
|
|
||||||
* updates returns an accurate result, but concurrent updates that
|
|
||||||
* occur while the sum is being calculated might not be
|
|
||||||
* incorporated.
|
|
||||||
*
|
|
||||||
* @return the sum
|
|
||||||
*/
|
|
||||||
public long sum() {
|
|
||||||
long sum = base;
|
|
||||||
Cell[] as = cells;
|
|
||||||
if (as != null) {
|
|
||||||
int n = as.length;
|
|
||||||
for (int i = 0; i < n; ++i) {
|
|
||||||
Cell a = as[i];
|
|
||||||
if (a != null)
|
|
||||||
sum += a.value;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return sum;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Resets variables maintaining the sum to zero. This method may
|
|
||||||
* be a useful alternative to creating a new adder, but is only
|
|
||||||
* effective if there are no concurrent updates. Because this
|
|
||||||
* method is intrinsically racy, it should only be used when it is
|
|
||||||
* known that no threads are concurrently updating.
|
|
||||||
*/
|
|
||||||
public void reset() {
|
|
||||||
internalReset(0L);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Equivalent in effect to {@link #sum} followed by {@link
|
|
||||||
* #reset}. This method may apply for example during quiescent
|
|
||||||
* points between multithreaded computations. If there are
|
|
||||||
* updates concurrent with this method, the returned value is
|
|
||||||
* <em>not</em> guaranteed to be the final value occurring before
|
|
||||||
* the reset.
|
|
||||||
*
|
|
||||||
* @return the sum
|
|
||||||
*/
|
|
||||||
public long sumThenReset() {
|
|
||||||
long sum = base;
|
|
||||||
Cell[] as = cells;
|
|
||||||
base = 0L;
|
|
||||||
if (as != null) {
|
|
||||||
int n = as.length;
|
|
||||||
for (int i = 0; i < n; ++i) {
|
|
||||||
Cell a = as[i];
|
|
||||||
if (a != null) {
|
|
||||||
sum += a.value;
|
|
||||||
a.value = 0L;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return sum;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the String representation of the {@link #sum}.
|
|
||||||
* @return the String representation of the {@link #sum}
|
|
||||||
*/
|
|
||||||
public String toString() {
|
|
||||||
return Long.toString(sum());
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Equivalent to {@link #sum}.
|
|
||||||
*
|
|
||||||
* @return the sum
|
|
||||||
*/
|
|
||||||
public long longValue() {
|
|
||||||
return sum();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the {@link #sum} as an {@code int} after a narrowing
|
|
||||||
* primitive conversion.
|
|
||||||
*/
|
|
||||||
public int intValue() {
|
|
||||||
return (int)sum();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the {@link #sum} as a {@code float}
|
|
||||||
* after a widening primitive conversion.
|
|
||||||
*/
|
|
||||||
public float floatValue() {
|
|
||||||
return (float)sum();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the {@link #sum} as a {@code double} after a widening
|
|
||||||
* primitive conversion.
|
|
||||||
*/
|
|
||||||
public double doubleValue() {
|
|
||||||
return (double)sum();
|
|
||||||
}
|
|
||||||
|
|
||||||
private void writeObject(java.io.ObjectOutputStream s)
|
|
||||||
throws java.io.IOException {
|
|
||||||
s.defaultWriteObject();
|
|
||||||
s.writeLong(sum());
|
|
||||||
}
|
|
||||||
|
|
||||||
private void readObject(java.io.ObjectInputStream s)
|
|
||||||
throws java.io.IOException, ClassNotFoundException {
|
|
||||||
s.defaultReadObject();
|
|
||||||
busy = 0;
|
|
||||||
cells = null;
|
|
||||||
base = s.readLong();
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
@@ -1,184 +0,0 @@
|
|||||||
package com.avaje.ebeaninternal.server.util;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Written by Doug Lea with assistance from members of JCP JSR-166
|
|
||||||
* Expert Group and released to the public domain, as explained at
|
|
||||||
* http://creativecommons.org/publicdomain/zero/1.0/
|
|
||||||
*/
|
|
||||||
|
|
||||||
import java.io.Serializable;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* One or more variables that together maintain a running {@code long}
|
|
||||||
* maximum with initial value {@code Long.MIN_VALUE}. When updates
|
|
||||||
* (method {@link #update}) are contended across threads, the set of
|
|
||||||
* variables may grow dynamically to reduce contention. Method {@link
|
|
||||||
* #max} (or, equivalently, {@link #longValue}) returns the current
|
|
||||||
* maximum across the variables maintaining updates.
|
|
||||||
*
|
|
||||||
* <p>This class extends {@link Number}, but does <em>not</em> define
|
|
||||||
* methods such as {@code equals}, {@code hashCode} and {@code
|
|
||||||
* compareTo} because instances are expected to be mutated, and so are
|
|
||||||
* not useful as collection keys.
|
|
||||||
*
|
|
||||||
* <p><em>jsr166e note: This class is targeted to be placed in
|
|
||||||
* java.util.concurrent.atomic.</em>
|
|
||||||
*
|
|
||||||
* @since 1.8
|
|
||||||
* @author Doug Lea
|
|
||||||
*/
|
|
||||||
public class LongMaxUpdater extends Striped64 implements Serializable {
|
|
||||||
private static final long serialVersionUID = 7249069246863182397L;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Version of max for use in retryUpdate
|
|
||||||
*/
|
|
||||||
final long fn(long v, long x) { return v > x ? v : x; }
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Creates a new instance with initial maximum of {@code
|
|
||||||
* Long.MIN_VALUE}.
|
|
||||||
*/
|
|
||||||
public LongMaxUpdater() {
|
|
||||||
base = Long.MIN_VALUE;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Updates the maximum to be at least the given value.
|
|
||||||
*
|
|
||||||
* @param x the value to update
|
|
||||||
*/
|
|
||||||
public void update(long x) {
|
|
||||||
Cell[] as; long b, v; HashCode hc; Cell a; int n;
|
|
||||||
if ((as = cells) != null ||
|
|
||||||
(b = base) < x && !casBase(b, x)) {
|
|
||||||
boolean uncontended = true;
|
|
||||||
int h = (hc = threadHashCode.get()).code;
|
|
||||||
if (as == null || (n = as.length) < 1 ||
|
|
||||||
(a = as[(n - 1) & h]) == null ||
|
|
||||||
((v = a.value) < x && !(uncontended = a.cas(v, x))))
|
|
||||||
retryUpdate(x, hc, uncontended);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the current maximum. The returned value is
|
|
||||||
* <em>NOT</em> an atomic snapshot; invocation in the absence of
|
|
||||||
* concurrent updates returns an accurate result, but concurrent
|
|
||||||
* updates that occur while the value is being calculated might
|
|
||||||
* not be incorporated.
|
|
||||||
*
|
|
||||||
* @return the maximum
|
|
||||||
*/
|
|
||||||
public long max() {
|
|
||||||
Cell[] as = cells;
|
|
||||||
long max = base;
|
|
||||||
if (as != null) {
|
|
||||||
int n = as.length;
|
|
||||||
long v;
|
|
||||||
for (int i = 0; i < n; ++i) {
|
|
||||||
Cell a = as[i];
|
|
||||||
if (a != null && (v = a.value) > max)
|
|
||||||
max = v;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return max;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Resets variables maintaining updates to {@code Long.MIN_VALUE}.
|
|
||||||
* This method may be a useful alternative to creating a new
|
|
||||||
* updater, but is only effective if there are no concurrent
|
|
||||||
* updates. Because this method is intrinsically racy, it should
|
|
||||||
* only be used when it is known that no threads are concurrently
|
|
||||||
* updating.
|
|
||||||
*/
|
|
||||||
public void reset() {
|
|
||||||
internalReset(Long.MIN_VALUE);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Equivalent in effect to {@link #max} followed by {@link
|
|
||||||
* #reset}. This method may apply for example during quiescent
|
|
||||||
* points between multithreaded computations. If there are
|
|
||||||
* updates concurrent with this method, the returned value is
|
|
||||||
* <em>not</em> guaranteed to be the final value occurring before
|
|
||||||
* the reset.
|
|
||||||
*
|
|
||||||
* @return the maximum
|
|
||||||
*/
|
|
||||||
public long maxThenReset() {
|
|
||||||
Cell[] as = cells;
|
|
||||||
long max = base;
|
|
||||||
base = Long.MIN_VALUE;
|
|
||||||
if (as != null) {
|
|
||||||
int n = as.length;
|
|
||||||
for (int i = 0; i < n; ++i) {
|
|
||||||
Cell a = as[i];
|
|
||||||
if (a != null) {
|
|
||||||
long v = a.value;
|
|
||||||
a.value = Long.MIN_VALUE;
|
|
||||||
if (v > max)
|
|
||||||
max = v;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return max;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the String representation of the {@link #max}.
|
|
||||||
* @return the String representation of the {@link #max}
|
|
||||||
*/
|
|
||||||
public String toString() {
|
|
||||||
return Long.toString(max());
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Equivalent to {@link #max}.
|
|
||||||
*
|
|
||||||
* @return the maximum
|
|
||||||
*/
|
|
||||||
public long longValue() {
|
|
||||||
return max();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the {@link #max} as an {@code int} after a narrowing
|
|
||||||
* primitive conversion.
|
|
||||||
*/
|
|
||||||
public int intValue() {
|
|
||||||
return (int)max();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the {@link #max} as a {@code float}
|
|
||||||
* after a widening primitive conversion.
|
|
||||||
*/
|
|
||||||
public float floatValue() {
|
|
||||||
return (float)max();
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the {@link #max} as a {@code double} after a widening
|
|
||||||
* primitive conversion.
|
|
||||||
*/
|
|
||||||
public double doubleValue() {
|
|
||||||
return (double)max();
|
|
||||||
}
|
|
||||||
|
|
||||||
private void writeObject(java.io.ObjectOutputStream s)
|
|
||||||
throws java.io.IOException {
|
|
||||||
s.defaultWriteObject();
|
|
||||||
s.writeLong(max());
|
|
||||||
}
|
|
||||||
|
|
||||||
private void readObject(java.io.ObjectInputStream s)
|
|
||||||
throws java.io.IOException, ClassNotFoundException {
|
|
||||||
s.defaultReadObject();
|
|
||||||
busy = 0;
|
|
||||||
cells = null;
|
|
||||||
base = s.readLong();
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
@@ -1,342 +0,0 @@
|
|||||||
package com.avaje.ebeaninternal.server.util;
|
|
||||||
|
|
||||||
/*
|
|
||||||
* Written by Doug Lea with assistance from members of JCP JSR-166
|
|
||||||
* Expert Group and released to the public domain, as explained at
|
|
||||||
* http://creativecommons.org/publicdomain/zero/1.0/
|
|
||||||
*/
|
|
||||||
|
|
||||||
import java.util.Random;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* A package-local class holding common representation and mechanics
|
|
||||||
* for classes supporting dynamic striping on 64bit values. The class
|
|
||||||
* extends Number so that concrete subclasses must publicly do so.
|
|
||||||
*/
|
|
||||||
abstract class Striped64 extends Number {
|
|
||||||
/*
|
|
||||||
* This class maintains a lazily-initialized table of atomically
|
|
||||||
* updated variables, plus an extra "base" field. The table size
|
|
||||||
* is a power of two. Indexing uses masked per-thread hash codes.
|
|
||||||
* Nearly all declarations in this class are package-private,
|
|
||||||
* accessed directly by subclasses.
|
|
||||||
*
|
|
||||||
* Table entries are of class Cell; a variant of AtomicLong padded
|
|
||||||
* to reduce cache contention on most processors. Padding is
|
|
||||||
* overkill for most Atomics because they are usually irregularly
|
|
||||||
* scattered in memory and thus don't interfere much with each
|
|
||||||
* other. But Atomic objects residing in arrays will tend to be
|
|
||||||
* placed adjacent to each other, and so will most often share
|
|
||||||
* cache lines (with a huge negative performance impact) without
|
|
||||||
* this precaution.
|
|
||||||
*
|
|
||||||
* In part because Cells are relatively large, we avoid creating
|
|
||||||
* them until they are needed. When there is no contention, all
|
|
||||||
* updates are made to the base field. Upon first contention (a
|
|
||||||
* failed CAS on base update), the table is initialized to size 2.
|
|
||||||
* The table size is doubled upon further contention until
|
|
||||||
* reaching the nearest power of two greater than or equal to the
|
|
||||||
* number of CPUS. Table slots remain empty (null) until they are
|
|
||||||
* needed.
|
|
||||||
*
|
|
||||||
* A single spinlock ("busy") is used for initializing and
|
|
||||||
* resizing the table, as well as populating slots with new Cells.
|
|
||||||
* There is no need for a blocking lock; when the lock is not
|
|
||||||
* available, threads try other slots (or the base). During these
|
|
||||||
* retries, there is increased contention and reduced locality,
|
|
||||||
* which is still better than alternatives.
|
|
||||||
*
|
|
||||||
* Per-thread hash codes are initialized to random values.
|
|
||||||
* Contention and/or table collisions are indicated by failed
|
|
||||||
* CASes when performing an update operation (see method
|
|
||||||
* retryUpdate). Upon a collision, if the table size is less than
|
|
||||||
* the capacity, it is doubled in size unless some other thread
|
|
||||||
* holds the lock. If a hashed slot is empty, and lock is
|
|
||||||
* available, a new Cell is created. Otherwise, if the slot
|
|
||||||
* exists, a CAS is tried. Retries proceed by "double hashing",
|
|
||||||
* using a secondary hash (Marsaglia XorShift) to try to find a
|
|
||||||
* free slot.
|
|
||||||
*
|
|
||||||
* The table size is capped because, when there are more threads
|
|
||||||
* than CPUs, supposing that each thread were bound to a CPU,
|
|
||||||
* there would exist a perfect hash function mapping threads to
|
|
||||||
* slots that eliminates collisions. When we reach capacity, we
|
|
||||||
* search for this mapping by randomly varying the hash codes of
|
|
||||||
* colliding threads. Because search is random, and collisions
|
|
||||||
* only become known via CAS failures, convergence can be slow,
|
|
||||||
* and because threads are typically not bound to CPUS forever,
|
|
||||||
* may not occur at all. However, despite these limitations,
|
|
||||||
* observed contention rates are typically low in these cases.
|
|
||||||
*
|
|
||||||
* It is possible for a Cell to become unused when threads that
|
|
||||||
* once hashed to it terminate, as well as in the case where
|
|
||||||
* doubling the table causes no thread to hash to it under
|
|
||||||
* expanded mask. We do not try to detect or remove such cells,
|
|
||||||
* under the assumption that for long-running instances, observed
|
|
||||||
* contention levels will recur, so the cells will eventually be
|
|
||||||
* needed again; and for short-lived ones, it does not matter.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Padded variant of AtomicLong supporting only raw accesses plus CAS.
|
|
||||||
* The value field is placed between pads, hoping that the JVM doesn't
|
|
||||||
* reorder them.
|
|
||||||
*
|
|
||||||
* JVM intrinsics note: It would be possible to use a release-only
|
|
||||||
* form of CAS here, if it were provided.
|
|
||||||
*/
|
|
||||||
static final class Cell {
|
|
||||||
volatile long p0, p1, p2, p3, p4, p5, p6;
|
|
||||||
volatile long value;
|
|
||||||
volatile long q0, q1, q2, q3, q4, q5, q6;
|
|
||||||
Cell(long x) { value = x; }
|
|
||||||
|
|
||||||
final boolean cas(long cmp, long val) {
|
|
||||||
return UNSAFE.compareAndSwapLong(this, valueOffset, cmp, val);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Unsafe mechanics
|
|
||||||
private static final sun.misc.Unsafe UNSAFE;
|
|
||||||
private static final long valueOffset;
|
|
||||||
static {
|
|
||||||
try {
|
|
||||||
UNSAFE = getUnsafe();
|
|
||||||
Class<?> ak = Cell.class;
|
|
||||||
valueOffset = UNSAFE.objectFieldOffset
|
|
||||||
(ak.getDeclaredField("value"));
|
|
||||||
} catch (Exception e) {
|
|
||||||
throw new Error(e);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Holder for the thread-local hash code. The code is initially
|
|
||||||
* random, but may be set to a different value upon collisions.
|
|
||||||
*/
|
|
||||||
static final class HashCode {
|
|
||||||
static final Random rng = new Random();
|
|
||||||
int code;
|
|
||||||
HashCode() {
|
|
||||||
int h = rng.nextInt(); // Avoid zero to allow xorShift rehash
|
|
||||||
code = (h == 0) ? 1 : h;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* The corresponding ThreadLocal class
|
|
||||||
*/
|
|
||||||
static final class ThreadHashCode extends ThreadLocal<HashCode> {
|
|
||||||
public HashCode initialValue() { return new HashCode(); }
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Static per-thread hash codes. Shared across all instances to
|
|
||||||
* reduce ThreadLocal pollution and because adjustments due to
|
|
||||||
* collisions in one table are likely to be appropriate for
|
|
||||||
* others.
|
|
||||||
*/
|
|
||||||
static final ThreadHashCode threadHashCode = new ThreadHashCode();
|
|
||||||
|
|
||||||
/** Number of CPUS, to place bound on table size */
|
|
||||||
static final int NCPU = Runtime.getRuntime().availableProcessors();
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Table of cells. When non-null, size is a power of 2.
|
|
||||||
*/
|
|
||||||
transient volatile Cell[] cells;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Base value, used mainly when there is no contention, but also as
|
|
||||||
* a fallback during table initialization races. Updated via CAS.
|
|
||||||
*/
|
|
||||||
transient volatile long base;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Spinlock (locked via CAS) used when resizing and/or creating Cells.
|
|
||||||
*/
|
|
||||||
transient volatile int busy;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Package-private default constructor
|
|
||||||
*/
|
|
||||||
Striped64() {
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* CASes the base field.
|
|
||||||
*/
|
|
||||||
final boolean casBase(long cmp, long val) {
|
|
||||||
return UNSAFE.compareAndSwapLong(this, baseOffset, cmp, val);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* CASes the busy field from 0 to 1 to acquire lock.
|
|
||||||
*/
|
|
||||||
final boolean casBusy() {
|
|
||||||
return UNSAFE.compareAndSwapInt(this, busyOffset, 0, 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Computes the function of current and new value. Subclasses
|
|
||||||
* should open-code this update function for most uses, but the
|
|
||||||
* virtualized form is needed within retryUpdate.
|
|
||||||
*
|
|
||||||
* @param currentValue the current value (of either base or a cell)
|
|
||||||
* @param newValue the argument from a user update call
|
|
||||||
* @return result of the update function
|
|
||||||
*/
|
|
||||||
abstract long fn(long currentValue, long newValue);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Handles cases of updates involving initialization, resizing,
|
|
||||||
* creating new Cells, and/or contention. See above for
|
|
||||||
* explanation. This method suffers the usual non-modularity
|
|
||||||
* problems of optimistic retry code, relying on rechecked sets of
|
|
||||||
* reads.
|
|
||||||
*
|
|
||||||
* @param x the value
|
|
||||||
* @param hc the hash code holder
|
|
||||||
* @param wasUncontended false if CAS failed before call
|
|
||||||
*/
|
|
||||||
final void retryUpdate(long x, HashCode hc, boolean wasUncontended) {
|
|
||||||
int h = hc.code;
|
|
||||||
boolean collide = false; // True if last slot nonempty
|
|
||||||
for (;;) {
|
|
||||||
Cell[] as; Cell a; int n; long v;
|
|
||||||
if ((as = cells) != null && (n = as.length) > 0) {
|
|
||||||
if ((a = as[(n - 1) & h]) == null) {
|
|
||||||
if (busy == 0) { // Try to attach new Cell
|
|
||||||
Cell r = new Cell(x); // Optimistically create
|
|
||||||
if (busy == 0 && casBusy()) {
|
|
||||||
boolean created = false;
|
|
||||||
try { // Recheck under lock
|
|
||||||
Cell[] rs; int m, j;
|
|
||||||
if ((rs = cells) != null &&
|
|
||||||
(m = rs.length) > 0 &&
|
|
||||||
rs[j = (m - 1) & h] == null) {
|
|
||||||
rs[j] = r;
|
|
||||||
created = true;
|
|
||||||
}
|
|
||||||
} finally {
|
|
||||||
busy = 0;
|
|
||||||
}
|
|
||||||
if (created)
|
|
||||||
break;
|
|
||||||
continue; // Slot is now non-empty
|
|
||||||
}
|
|
||||||
}
|
|
||||||
collide = false;
|
|
||||||
}
|
|
||||||
else if (!wasUncontended) // CAS already known to fail
|
|
||||||
wasUncontended = true; // Continue after rehash
|
|
||||||
else if (a.cas(v = a.value, fn(v, x)))
|
|
||||||
break;
|
|
||||||
else if (n >= NCPU || cells != as)
|
|
||||||
collide = false; // At max size or stale
|
|
||||||
else if (!collide)
|
|
||||||
collide = true;
|
|
||||||
else if (busy == 0 && casBusy()) {
|
|
||||||
try {
|
|
||||||
if (cells == as) { // Expand table unless stale
|
|
||||||
Cell[] rs = new Cell[n << 1];
|
|
||||||
for (int i = 0; i < n; ++i)
|
|
||||||
rs[i] = as[i];
|
|
||||||
cells = rs;
|
|
||||||
}
|
|
||||||
} finally {
|
|
||||||
busy = 0;
|
|
||||||
}
|
|
||||||
collide = false;
|
|
||||||
continue; // Retry with expanded table
|
|
||||||
}
|
|
||||||
h ^= h << 13; // Rehash
|
|
||||||
h ^= h >>> 17;
|
|
||||||
h ^= h << 5;
|
|
||||||
}
|
|
||||||
else if (busy == 0 && cells == as && casBusy()) {
|
|
||||||
boolean init = false;
|
|
||||||
try { // Initialize table
|
|
||||||
if (cells == as) {
|
|
||||||
Cell[] rs = new Cell[2];
|
|
||||||
rs[h & 1] = new Cell(x);
|
|
||||||
cells = rs;
|
|
||||||
init = true;
|
|
||||||
}
|
|
||||||
} finally {
|
|
||||||
busy = 0;
|
|
||||||
}
|
|
||||||
if (init)
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
else if (casBase(v = base, fn(v, x)))
|
|
||||||
break; // Fall back on using base
|
|
||||||
}
|
|
||||||
hc.code = h; // Record index for next time
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Sets base and all cells to the given value.
|
|
||||||
*/
|
|
||||||
final void internalReset(long initialValue) {
|
|
||||||
Cell[] as = cells;
|
|
||||||
base = initialValue;
|
|
||||||
if (as != null) {
|
|
||||||
int n = as.length;
|
|
||||||
for (int i = 0; i < n; ++i) {
|
|
||||||
Cell a = as[i];
|
|
||||||
if (a != null)
|
|
||||||
a.value = initialValue;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Unsafe mechanics
|
|
||||||
private static final sun.misc.Unsafe UNSAFE;
|
|
||||||
private static final long baseOffset;
|
|
||||||
private static final long busyOffset;
|
|
||||||
static {
|
|
||||||
try {
|
|
||||||
UNSAFE = getUnsafe();
|
|
||||||
Class<?> sk = Striped64.class;
|
|
||||||
baseOffset = UNSAFE.objectFieldOffset
|
|
||||||
(sk.getDeclaredField("base"));
|
|
||||||
busyOffset = UNSAFE.objectFieldOffset
|
|
||||||
(sk.getDeclaredField("busy"));
|
|
||||||
} catch (Exception e) {
|
|
||||||
throw new Error(e);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns a sun.misc.Unsafe. Suitable for use in a 3rd party package.
|
|
||||||
* Replace with a simple call to Unsafe.getUnsafe when integrating
|
|
||||||
* into a jdk.
|
|
||||||
*
|
|
||||||
* @return a sun.misc.Unsafe
|
|
||||||
*/
|
|
||||||
private static sun.misc.Unsafe getUnsafe() {
|
|
||||||
try {
|
|
||||||
return sun.misc.Unsafe.getUnsafe();
|
|
||||||
} catch (SecurityException tryReflectionInstead) {}
|
|
||||||
try {
|
|
||||||
return java.security.AccessController.doPrivileged
|
|
||||||
(new java.security.PrivilegedExceptionAction<sun.misc.Unsafe>() {
|
|
||||||
public sun.misc.Unsafe run() throws Exception {
|
|
||||||
Class<sun.misc.Unsafe> k = sun.misc.Unsafe.class;
|
|
||||||
for (java.lang.reflect.Field f : k.getDeclaredFields()) {
|
|
||||||
f.setAccessible(true);
|
|
||||||
Object x = f.get(null);
|
|
||||||
if (k.isInstance(x))
|
|
||||||
return k.cast(x);
|
|
||||||
}
|
|
||||||
throw new NoSuchFieldError("the Unsafe");
|
|
||||||
}});
|
|
||||||
} catch (java.security.PrivilegedActionException e) {
|
|
||||||
throw new RuntimeException("Could not initialize intrinsics",
|
|
||||||
e.getCause());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Reference in new issue
Block a user