/**
* Helper method that can be used to dynamically figure out enumeration type of given {@link
* EnumSet}, without having access to its declaration. Code is needed to work around design flaw
* in JDK.
*
* @since 1.5
*/
public static Class<? extends Enum<?>> findEnumType(EnumSet<?> s) {
// First things first: if not empty, easy to determine
if (!s.isEmpty()) {
return findEnumType(s.iterator().next());
}
// Otherwise need to locate using an internal field
return EnumTypeLocator.instance.enumTypeFor(s);
}
void showDiagnostics(boolean showAll) {
Set<JCDiagnostic.Kind> kinds = EnumSet.allOf(JCDiagnostic.Kind.class);
if (!showAll) {
// suppress errors, which are all presumed to be transient resolve errors
kinds.remove(JCDiagnostic.Kind.ERROR);
}
log.reportDeferredDiagnostics(kinds);
}
/** Return the set of supported JVM features that improve the estimation. */
public static EnumSet<JvmFeature> getSupportedFeatures() {
return EnumSet.copyOf(supportedFeatures);
}
/** Return the set of unsupported JVM features that improve the estimation. */
public static EnumSet<JvmFeature> getUnsupportedFeatures() {
EnumSet<JvmFeature> unsupported = EnumSet.allOf(JvmFeature.class);
unsupported.removeAll(supportedFeatures);
return unsupported;
}
/**
* Returns true, if the current JVM is fully supported by {@code RamUsageEstimator}. If this
* method returns {@code false} you are maybe using a 3rd party Java VM that is not supporting
* Oracle/Sun private APIs. The memory estimates can be imprecise then (no way of detecting
* compressed references, alignments, etc.). Lucene still tries to use sensible defaults.
*/
public static boolean isSupportedJVM() {
return supportedFeatures.size() == JvmFeature.values().length;
}
/** Initialize constants and try to collect information about the JVM internals. */
static {
// Initialize empirically measured defaults. We'll modify them to the current
// JVM settings later on if possible.
int referenceSize = Constants.JRE_IS_64BIT ? 8 : 4;
int objectHeader = Constants.JRE_IS_64BIT ? 16 : 8;
// The following is objectHeader + NUM_BYTES_INT, but aligned (object alignment)
// so on 64 bit JVMs it'll be align(16 + 4, @8) = 24.
int arrayHeader = Constants.JRE_IS_64BIT ? 24 : 12;
supportedFeatures = EnumSet.noneOf(JvmFeature.class);
Class<?> unsafeClass = null;
Object tempTheUnsafe = null;
try {
unsafeClass = Class.forName("sun.misc.Unsafe");
final Field unsafeField = unsafeClass.getDeclaredField("theUnsafe");
unsafeField.setAccessible(true);
tempTheUnsafe = unsafeField.get(null);
} catch (Exception e) {
// Ignore.
}
theUnsafe = tempTheUnsafe;
// get object reference size by getting scale factor of Object[] arrays:
try {
final Method arrayIndexScaleM = unsafeClass.getMethod("arrayIndexScale", Class.class);
referenceSize = ((Number) arrayIndexScaleM.invoke(theUnsafe, Object[].class)).intValue();
supportedFeatures.add(JvmFeature.OBJECT_REFERENCE_SIZE);
} catch (Exception e) {
// ignore.
}
// "best guess" based on reference size. We will attempt to modify
// these to exact values if there is supported infrastructure.
objectHeader = Constants.JRE_IS_64BIT ? (8 + referenceSize) : 8;
arrayHeader = Constants.JRE_IS_64BIT ? (8 + 2 * referenceSize) : 12;
// get the object header size:
// - first try out if the field offsets are not scaled (see warning in Unsafe docs)
// - get the object header size by getting the field offset of the first field of a dummy object
// If the scaling is byte-wise and unsafe is available, enable dynamic size measurement for
// estimateRamUsage().
Method tempObjectFieldOffsetMethod = null;
try {
final Method objectFieldOffsetM = unsafeClass.getMethod("objectFieldOffset", Field.class);
final Field dummy1Field = DummyTwoLongObject.class.getDeclaredField("dummy1");
final int ofs1 = ((Number) objectFieldOffsetM.invoke(theUnsafe, dummy1Field)).intValue();
final Field dummy2Field = DummyTwoLongObject.class.getDeclaredField("dummy2");
final int ofs2 = ((Number) objectFieldOffsetM.invoke(theUnsafe, dummy2Field)).intValue();
if (Math.abs(ofs2 - ofs1) == NUM_BYTES_LONG) {
final Field baseField = DummyOneFieldObject.class.getDeclaredField("base");
objectHeader = ((Number) objectFieldOffsetM.invoke(theUnsafe, baseField)).intValue();
supportedFeatures.add(JvmFeature.FIELD_OFFSETS);
tempObjectFieldOffsetMethod = objectFieldOffsetM;
}
} catch (Exception e) {
// Ignore.
}
objectFieldOffsetMethod = tempObjectFieldOffsetMethod;
// Get the array header size by retrieving the array base offset
// (offset of the first element of an array).
try {
final Method arrayBaseOffsetM = unsafeClass.getMethod("arrayBaseOffset", Class.class);
// we calculate that only for byte[] arrays, it's actually the same for all types:
arrayHeader = ((Number) arrayBaseOffsetM.invoke(theUnsafe, byte[].class)).intValue();
supportedFeatures.add(JvmFeature.ARRAY_HEADER_SIZE);
} catch (Exception e) {
// Ignore.
}
NUM_BYTES_OBJECT_REF = referenceSize;
NUM_BYTES_OBJECT_HEADER = objectHeader;
NUM_BYTES_ARRAY_HEADER = arrayHeader;
// Try to get the object alignment (the default seems to be 8 on Hotspot,
// regardless of the architecture).
int objectAlignment = 8;
try {
final Class<?> beanClazz = Class.forName("com.sun.management.HotSpotDiagnosticMXBean");
// Try to get the diagnostic mxbean without calling {@link
// ManagementFactory#getPlatformMBeanServer()}
// which starts AWT thread (and shows junk in the dock) on a Mac:
Object hotSpotBean;
// Java 7+, HotSpot
try {
hotSpotBean =
ManagementFactory.class
.getMethod("getPlatformMXBean", Class.class)
.invoke(null, beanClazz);
} catch (Exception e1) {
// Java 6, HotSpot
try {
Class<?> sunMF = Class.forName("sun.management.ManagementFactory");
hotSpotBean = sunMF.getMethod("getDiagnosticMXBean").invoke(null);
} catch (Exception e2) {
// Last resort option is an attempt to get it from ManagementFactory's server anyway (may
// start AWT).
hotSpotBean =
ManagementFactory.newPlatformMXBeanProxy(
ManagementFactory.getPlatformMBeanServer(),
"com.sun.management:type=HotSpotDiagnostic",
beanClazz);
}
}
if (hotSpotBean != null) {
final Method getVMOptionMethod = beanClazz.getMethod("getVMOption", String.class);
final Object vmOption = getVMOptionMethod.invoke(hotSpotBean, "ObjectAlignmentInBytes");
objectAlignment =
Integer.parseInt(vmOption.getClass().getMethod("getValue").invoke(vmOption).toString());
supportedFeatures.add(JvmFeature.OBJECT_ALIGNMENT);
}
} catch (Exception e) {
// Ignore.
}
NUM_BYTES_OBJECT_ALIGNMENT = objectAlignment;
JVM_INFO_STRING =
"[JVM: "
+ Constants.JVM_NAME
+ ", "
+ Constants.JVM_VERSION
+ ", "
+ Constants.JVM_VENDOR
+ ", "
+ Constants.JAVA_VENDOR
+ ", "
+ Constants.JAVA_VERSION
+ "]";
}
@SuppressWarnings("unchecked")
private static <T> T createFinalArgumentPlaceholder(Class<T> clazz) {
if (clazz == Boolean.TYPE || clazz == Boolean.class) return (T) Boolean.FALSE;
if (clazz.isEnum()) return (T) EnumSet.allOf((Class<? extends Enum>) clazz).iterator().next();
return (T) createArgumentPlaceholder(clazz, FINAL_PLACEHOLDER_SEED);
}
private <E extends Enum<E>> Enum<E> getNextEnumPlaceholder(Class<E> clazz) {
List<E> enums = new ArrayList<E>(EnumSet.allOf(clazz));
return enums.get(enumPlaceholder++ % enums.size());
}
public List<Revision> filter(Collection<Revision> list, EnumSet<Library.Phase> phases) {
List<Revision> filtered = new ArrayList<Library.Revision>();
for (Revision r : list) if (phases.contains(r.phase)) filtered.add(r);
return filtered;
}