Medir y monitorear el tamaño de gran HashMap

Ryan Ella:

¿Cuáles son las mejores opciones de medición o por lo menos algo estimar con precisión el consumo de memoria total por un mapa hash sostener objetos personalizados?

Antecedentes:

Nuestro sistema tiene varias tiendas en memoria (de ConcurrentHashMap) que mantiene 1K-200K objetos de diferentes tipos. Nos gustaría controlar periódicamente el consumo de memoria de éstos.

Restricciones / Expectativas:

No nos podemos permitir GC frecuente o total iteración de estos mapas hash que tendría un impacto negativo en la latencia. Por lo que yo sé, no hay sizeof () en Java, por lo que estamos de acuerdo con la estimación.

Teniendo en cuenta estas opciones:

Tener un hilo que informa del uso de la memoria # para cada HashMap por:

1. Medir el tamaño de objeto de tipo X usando algo como classmexer y se multiplica por el tamaño de HashMap. Esta memoria ignora utilizado por hashmap sí asumiendo que es relativamente pequeño comparado con el de su contenido.
2. Crear otra HashMap, a continuación, añadir N objetos del tipo, medir el tamaño de esto, entonces extrapolar el número para aproximar el tamaño completo.
3. Externamente medir, y luego alimentar esta al mapa. Pensando en jmap o similar, pero no esta operación sea muy pesado, ya que mide todo en JVM?
4. Tome Delta en tamaño de la pila a medida que añadimos objetos a la HashMap. No estoy seguro si esto es factible, ya que es multi-roscado
5. Cualquier otra opción impresionante?

Eugene:

En primer lugar, existe este gran artículo de Alexey Shipilev (un ex ingeniero de JVM en Oracle, ahora en RedHat) que explican que se trata no es tan fácil .

Todos los objetos de Java tiene dos cabeceras, sus tamaños pueden depender de la plataforma o en la configuración que JVM se inicia con ( UseCompressedOops).

Entonces, no es el relleno y la alineación entre los campos y objetos ellos mismos (8 bytes de alineación). Entonces, no hay espacio que una JVM simplemente no se presenta debido a que no pueden o no tienen necesidad de hacerlo.

Todas estas cosas hacen que sea un poco ONU-trivial para calcular cuánto será el tamaño del objeto tiene un cierto en el montón; Afortunadamente JOL existe. Incluso tiene un montón de muestras también ... Aquí está un pequeño ejemplo, suponga que tiene una clase de este tipo:

static class MyValue {

    private final int left;
    private final String right;

    public MyValue(int left, String right) {
        this.left = left;
        this.right = right;
    }
}

Y se crea una HashMap:

    Map<String, MyValue> map = new HashMap<>();
    System.out.println("empty map = " + GraphLayout.parseInstance(map).totalSize());

    MyValue one = new MyValue(1, "one");
    System.out.println("one = " + GraphLayout.parseInstance(one).totalSize());

    map.put("one", one);
    System.out.println("map after one = " + GraphLayout.parseInstance(map).totalSize());

    MyValue two = new MyValue(1, "two");
    map.put("two", two);
    System.out.println("map after two = " + 
    GraphLayout.parseInstance(map).totalSize());