Apache
/
lucene
mirror of https://github.com/apache/lucene.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove/deprecate obsolete constants in oal.util.Constants; remove code which is no longer executed after Java 9 (#978)

This commit is contained in:
Uwe Schindler 2022-07-01 16:24:18 +02:00 committed by GitHub
parent 5f2a4998a0
commit 8a70988e63
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 104 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
lucene/CHANGES.txt
View File

@ -79,6 +79,9 @@ API Changes
* LUCENE-10603: SortedSetDocValues#NO_MORE_ORDS marked @deprecated in favor of iterating with
SortedSetDocValues#docValueCount(). (Greg Miller)
* GITHUB#978: Deprecate (remove in Lucene 10) obsolete constants in oal.util.Constants; remove
code which is no longer executed after Java 9. (Uwe Schindler)
New Features
---------------------
* LUCENE-10550: Add getAllChildren functionality to facets (Yuting Gan)
@ -116,6 +119,12 @@ Optimizations
* GITHUB#984: Use primitive type data structures in FloatTaxonomyFacets and IntTaxonomyFacets
#getAllChildren() internal implementation to avoid some garbage creation. (Greg Miller)
Changes in runtime behavior
---------------------
* GITHUB#978: IndexWriter diagnostics written to index only contain java's runtime version
and vendor. (Uwe Schindler)
Bug Fixes
---------------------

11
lucene/core/src/java/org/apache/lucene/index/IndexWriter.java
View File

@ -21,12 +21,12 @@ import static org.apache.lucene.util.ByteBlockPool.BYTE_BLOCK_SIZE;
import java.io.Closeable;
import java.io.IOException;
import java.time.Instant;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
@ -4775,14 +4775,9 @@ public class IndexWriter
diagnostics.put("os", Constants.OS_NAME);
diagnostics.put("os.arch", Constants.OS_ARCH);
diagnostics.put("os.version", Constants.OS_VERSION);
diagnostics.put("java.version", Constants.JAVA_VERSION);
diagnostics.put("java.runtime.version", Runtime.version().toString());
diagnostics.put("java.vendor", Constants.JAVA_VENDOR);
// On IBM J9 JVM this is better than java.version which is just 1.7.0 (no update level):
diagnostics.put(
"java.runtime.version", System.getProperty("java.runtime.version", "undefined"));
// Hotspot version, e.g. 2.8 for J9:
diagnostics.put("java.vm.version", System.getProperty("java.vm.version", "undefined"));
diagnostics.put("timestamp", Long.toString(new Date().getTime()));
diagnostics.put("timestamp", Long.toString(Instant.now().toEpochMilli()));
if (details != null) {
diagnostics.putAll(details);
}

76
lucene/core/src/java/org/apache/lucene/util/Constants.java
View File

@ -16,8 +16,6 @@
*/
package org.apache.lucene.util;
import java.util.StringTokenizer;
/** Some useful constants. */
public final class Constants {
private Constants() {} // can't construct
@ -25,12 +23,32 @@ public final class Constants {
/** JVM vendor info. */
public static final String JVM_VENDOR = System.getProperty("java.vm.vendor");
public static final String JVM_VERSION = System.getProperty("java.vm.version");
/** JVM vendor name. */
public static final String JVM_NAME = System.getProperty("java.vm.name");
public static final String JVM_SPEC_VERSION = System.getProperty("java.specification.version");
/** The value of <code>System.getProperty("java.version")</code>. * */
public static final String JAVA_VERSION = System.getProperty("java.version");
/**
* Get the full version string of the current runtime.
*
* @deprecated To detect Java versions use {@link Runtime#version()}
*/
@Deprecated public static final String JVM_VERSION = Runtime.version().toString();
/**
* Gets the specification version of the current runtime. This is the feature version converted to
* String.
*
* @see java.lang.Runtime.Version#feature()
* @deprecated To detect Java versions use {@link Runtime#version()}
*/
@Deprecated
public static final String JVM_SPEC_VERSION = Integer.toString(Runtime.version().feature());
/**
* The value of <code>System.getProperty("java.version")</code>.
*
* @deprecated To detect Java versions use {@link Runtime#version()}
*/
@Deprecated public static final String JAVA_VERSION = System.getProperty("java.version");
/** The value of <code>System.getProperty("os.name")</code>. * */
public static final String OS_NAME = System.getProperty("os.name");
@ -45,24 +63,19 @@ public final class Constants {
/** True iff running on FreeBSD */
public static final boolean FREE_BSD = OS_NAME.startsWith("FreeBSD");
/** The value of <code>System.getProperty("os.arch")</code>. */
public static final String OS_ARCH = System.getProperty("os.arch");
public static final String OS_VERSION = System.getProperty("os.version");
public static final String JAVA_VENDOR = System.getProperty("java.vendor");
private static final int JVM_MAJOR_VERSION;
private static final int JVM_MINOR_VERSION;
/** The value of <code>System.getProperty("os.version")</code>. */
public static final String OS_VERSION = System.getProperty("os.version");
/** The value of <code>System.getProperty("java.vendor")</code>. */
public static final String JAVA_VENDOR = System.getProperty("java.vendor");
/** True iff running on a 64bit JVM */
public static final boolean JRE_IS_64BIT;
static {
final StringTokenizer st = new StringTokenizer(JVM_SPEC_VERSION, ".");
JVM_MAJOR_VERSION = Integer.parseInt(st.nextToken());
if (st.hasMoreTokens()) {
JVM_MINOR_VERSION = Integer.parseInt(st.nextToken());
} else {
JVM_MINOR_VERSION = 0;
}
boolean is64Bit = false;
String datamodel = null;
try {
@ -84,10 +97,27 @@ public final class Constants {
JRE_IS_64BIT = is64Bit;
}
public static final boolean JRE_IS_MINIMUM_JAVA8 =
JVM_MAJOR_VERSION > 1 || (JVM_MAJOR_VERSION == 1 && JVM_MINOR_VERSION >= 8);
public static final boolean JRE_IS_MINIMUM_JAVA9 =
JVM_MAJOR_VERSION > 1 || (JVM_MAJOR_VERSION == 1 && JVM_MINOR_VERSION >= 9);
public static final boolean JRE_IS_MINIMUM_JAVA11 =
JVM_MAJOR_VERSION > 1 || (JVM_MAJOR_VERSION == 1 && JVM_MINOR_VERSION >= 11);
/**
* Always true.
*
* @deprecated This constant is useless and always {@code true}. To detect Java versions use
* {@link Runtime#version()}
*/
@Deprecated public static final boolean JRE_IS_MINIMUM_JAVA8 = true;
/**
* Always true.
*
* @deprecated This constant is useless and always {@code true}. To detect Java versions use
* {@link Runtime#version()}
*/
@Deprecated public static final boolean JRE_IS_MINIMUM_JAVA9 = true;
/**
* Always true.
*
* @deprecated This constant is useless and always {@code true}. To detect Java versions use
* {@link Runtime#version()}
*/
@Deprecated public static final boolean JRE_IS_MINIMUM_JAVA11 = true;
}

15
lucene/core/src/test/org/apache/lucene/search/TestLRUQueryCache.java
View File

@ -70,7 +70,6 @@ import org.apache.lucene.tests.util.RamUsageTester;
import org.apache.lucene.tests.util.TestUtil;
import org.apache.lucene.util.Accountable;
import org.apache.lucene.util.BytesRef;
import org.apache.lucene.util.Constants;
import org.apache.lucene.util.IOUtils;
public class TestLRUQueryCache extends LuceneTestCase {
@ -356,11 +355,8 @@ public class TestLRUQueryCache extends LuceneTestCase {
// This test makes sure that by making the same assumptions as LRUQueryCache, RAMUsageTester
// computes the same memory usage.
@AwaitsFix(bugUrl = "https://issues.apache.org/jira/browse/LUCENE-7595")
public void testRamBytesUsedAgreesWithRamUsageTester() throws IOException {
assumeFalse(
"LUCENE-7595: RamUsageTester does not work exact in Java 9 (estimations for maps and lists)",
Constants.JRE_IS_MINIMUM_JAVA9);
final LRUQueryCache queryCache =
new LRUQueryCache(
1 + random().nextInt(5),
@ -496,11 +492,8 @@ public class TestLRUQueryCache extends LuceneTestCase {
// that require very little memory. In that case most of the memory is taken
// by the cache itself, not cache entries, and we want to make sure that
// memory usage is not grossly underestimated.
@AwaitsFix(bugUrl = "https://issues.apache.org/jira/browse/LUCENE-7595")
public void testRamBytesUsedConstantEntryOverhead() throws IOException {
assumeFalse(
"LUCENE-7595: RamUsageTester does not work exact in Java 9 (estimations for maps and lists)",
Constants.JRE_IS_MINIMUM_JAVA9);
final LRUQueryCache queryCache =
new LRUQueryCache(1000000, 10000000, context -> true, Float.POSITIVE_INFINITY);
@ -1171,10 +1164,8 @@ public class TestLRUQueryCache extends LuceneTestCase {
}
}
@AwaitsFix(bugUrl = "https://issues.apache.org/jira/browse/LUCENE-7604")
public void testDetectMutatedQueries() throws IOException {
LuceneTestCase.assumeFalse(
"LUCENE-7604: For some unknown reason the non-constant BadQuery#hashCode() does not trigger ConcurrentModificationException on Java 9 b150",
Constants.JRE_IS_MINIMUM_JAVA9);
Directory dir = newDirectory();
final RandomIndexWriter w = new RandomIndexWriter(random(), dir);
w.addDocument(new Document());

1
lucene/test-framework/src/java/org/apache/lucene/tests/index/BaseTestCheckIndex.java
View File

@ -92,7 +92,6 @@ public class BaseTestCheckIndex extends LuceneTestCase {
assertEquals(18, seg.termVectorStatus.docCount);
assertEquals(18, seg.termVectorStatus.totVectors);
assertNotNull(seg.diagnostics.get("java.vm.version"));
assertNotNull(seg.diagnostics.get("java.runtime.version"));
assertTrue(seg.diagnostics.size() > 0);

40
lucene/test-framework/src/java/org/apache/lucene/tests/util/LuceneTestCase.java
View File

@ -48,7 +48,6 @@ import com.carrotsearch.randomizedtesting.generators.RandomNumbers;
import com.carrotsearch.randomizedtesting.generators.RandomPicks;
import com.carrotsearch.randomizedtesting.rules.NoClassHooksShadowingRule;
import com.carrotsearch.randomizedtesting.rules.NoInstanceHooksOverridesRule;
import com.carrotsearch.randomizedtesting.rules.StaticFieldsInvariantRule;
import java.io.Closeable;
import java.io.FileNotFoundException;
import java.io.IOException;
@ -83,7 +82,6 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
@ -611,24 +609,6 @@ public abstract class LuceneTestCase extends Assert {
return ignoreAfterMaxFailuresDelegate.getAndSet(newValue);
}
/**
* Max 10mb of static data stored in a test suite class after the suite is complete. Prevents
* static data structures leaking and causing OOMs in subsequent tests.
*/
private static final long STATIC_LEAK_THRESHOLD = 10 * 1024 * 1024;
/** By-name list of ignored types like loggers etc. */
private static final Set<String> STATIC_LEAK_IGNORED_TYPES =
Set.of(
"org.slf4j.Logger",
"org.apache.solr.SolrLogFormatter",
"java.io.File", // Solr sometimes refers to this in a static way, but it has a
// "java.nio.fs.Path" inside
Path.class
.getName(), // causes problems because interface is implemented by hidden classes
Class.class.getName(),
EnumSet.class.getName());
/**
* This controls how suite-level rules are nested. It is important that _all_ rules declared in
* {@link LuceneTestCase} are executed in proper order if they depend on each other.
@ -646,26 +626,6 @@ public abstract class LuceneTestCase extends Assert {
.around(new TestRuleAssertionsRequired())
.around(new TestRuleLimitSysouts(suiteFailureMarker))
.around(tempFilesCleanupRule = new TestRuleTemporaryFilesCleanup(suiteFailureMarker));
// TODO LUCENE-7595: Java 9 does not allow to look into runtime classes, so we have to fix the
// RAM usage checker!
if (!Constants.JRE_IS_MINIMUM_JAVA9) {
r =
r.around(
new StaticFieldsInvariantRule(STATIC_LEAK_THRESHOLD, true) {
@Override
protected boolean accept(java.lang.reflect.Field field) {
// Don't count known classes that consume memory once.
if (STATIC_LEAK_IGNORED_TYPES.contains(field.getType().getName())) {
return false;
}
// Don't count references from ourselves, we're top-level.
if (field.getDeclaringClass() == LuceneTestCase.class) {
return false;
}
return super.accept(field);
}
});
}
classRules =
r.around(new NoClassHooksShadowingRule())
.around(

78
lucene/test-framework/src/java/org/apache/lucene/tests/util/RamUsageTester.java
View File

@ -44,7 +44,6 @@ import java.util.function.ToLongFunction;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
import org.apache.lucene.util.Constants;
import org.apache.lucene.util.RamUsageEstimator;
import org.apache.lucene.util.SuppressForbidden;
@ -170,49 +169,44 @@ public final class RamUsageTester {
* and accumulate this object's shallow size.
*/
try {
if (Constants.JRE_IS_MINIMUM_JAVA9) {
long alignedShallowInstanceSize = RamUsageEstimator.shallowSizeOf(ob);
long alignedShallowInstanceSize = RamUsageEstimator.shallowSizeOf(ob);
Predicate<Class<?>> isJavaModule = (clazz) -> clazz.getName().startsWith("java.");
Predicate<Class<?>> isJavaModule = (clazz) -> clazz.getName().startsWith("java.");
// Java 9: Best guess for some known types, as we cannot precisely look into runtime
// classes:
final ToLongFunction<Object> func = SIMPLE_TYPES.get(obClazz);
if (func
!= null) { // some simple type like String where the size is easy to get from public
// properties
return accumulator.accumulateObject(
ob, alignedShallowInstanceSize + func.applyAsLong(ob), Collections.emptyMap(), stack);
} else if (ob instanceof Enum) {
return alignedShallowInstanceSize;
} else if (ob instanceof ByteBuffer) {
// Approximate ByteBuffers with their underlying storage (ignores field overhead).
return byteArraySize(((ByteBuffer) ob).capacity());
} else if (isJavaModule.test(obClazz) && ob instanceof Map) {
final List<Object> values =
((Map<?, ?>) ob)
.entrySet().stream()
.flatMap(e -> Stream.of(e.getKey(), e.getValue()))
.collect(Collectors.toList());
return accumulator.accumulateArray(
ob,
alignedShallowInstanceSize + RamUsageEstimator.NUM_BYTES_ARRAY_HEADER,
values,
stack)
+ RamUsageEstimator.NUM_BYTES_ARRAY_HEADER;
} else if (isJavaModule.test(obClazz) && ob instanceof Iterable) {
final List<Object> values =
StreamSupport.stream(((Iterable<?>) ob).spliterator(), false)
.collect(Collectors.toList());
return accumulator.accumulateArray(
ob,
alignedShallowInstanceSize + RamUsageEstimator.NUM_BYTES_ARRAY_HEADER,
values,
stack)
+ RamUsageEstimator.NUM_BYTES_ARRAY_HEADER;
} else {
// Fallback to reflective access.
}
// Java 9+: Best guess for some known types, as we cannot precisely look into runtime
// classes:
final ToLongFunction<Object> func = SIMPLE_TYPES.get(obClazz);
if (func != null) { // some simple type like String where the size is easy to get from public
// properties
return accumulator.accumulateObject(
ob, alignedShallowInstanceSize + func.applyAsLong(ob), Collections.emptyMap(), stack);
} else if (ob instanceof Enum) {
return alignedShallowInstanceSize;
} else if (ob instanceof ByteBuffer) {
// Approximate ByteBuffers with their underlying storage (ignores field overhead).
return byteArraySize(((ByteBuffer) ob).capacity());
} else if (isJavaModule.test(obClazz) && ob instanceof Map) {
final List<Object> values =
((Map<?, ?>) ob)
.entrySet().stream()
.flatMap(e -> Stream.of(e.getKey(), e.getValue()))
.collect(Collectors.toList());
return accumulator.accumulateArray(
ob,
alignedShallowInstanceSize + RamUsageEstimator.NUM_BYTES_ARRAY_HEADER,
values,
stack)
+ RamUsageEstimator.NUM_BYTES_ARRAY_HEADER;
} else if (isJavaModule.test(obClazz) && ob instanceof Iterable) {
final List<Object> values =
StreamSupport.stream(((Iterable<?>) ob).spliterator(), false)
.collect(Collectors.toList());
return accumulator.accumulateArray(
ob,
alignedShallowInstanceSize + RamUsageEstimator.NUM_BYTES_ARRAY_HEADER,
values,
stack)
+ RamUsageEstimator.NUM_BYTES_ARRAY_HEADER;
}
ClassCache cachedInfo = classCache.get(obClazz);