Hazelcast vs Enflammer de référence

Je suis à l'aide de grilles de données que mon la primaire "base de données". J'ai remarqué une différence radicale entre Hazelcast et Enflammer les performances des requêtes. J'ai optimisé ma grille de données utilisation de la sérialisation personnalisée et d'index, mais la différence est encore perceptible de l'OMI.

Puisque personne n'a demandé ici, je vais répondre à ma propre question pour toutes les futures références. Ce n'est pas un résumé (de l'apprentissage), mais dans le monde réel de référence, que les modèles de ma grille de données d'utilisation dans les grandes SaaS, les systèmes principalement pour afficher triés et filtrés paginé listes. J'ai d'abord voulu savoir combien de surcharge mon universal JDBC-ish, la grille de données de la couche d'accès ajoute par rapport à raw non-cadres Hazelcast et Enflammer l'utilisation. Mais depuis que je suis à comparer des pommes avec des pommes, voici l'indice de référence.

OriginalL'auteur Alex Rogachevsky | 2015-08-11

  1. 11

    J'ai passé en revue le code fourni sur GitHub et ont de nombreux commentaires:

    Indexation et Rejoint

    1. Probablement le point le plus important, c'est que Apache Enflammer l'indexation est beaucoup plus sophistiqué qu'Hazelcast. Contrairement à Hazelcast, Ignite prend en charge ANSI 99 SQL, de sorte que vous pouvez écrire vos requêtes.
    2. Le plus important, contrairement à Hazelcast, Ignite prend en charge des indices et des Jointures SQL à travers les différents caches ou des types de données. Imaginez que vous avez la Personne et de l'Organisation des tables, et vous devez sélectionner toutes les Personnes qui travaillent pour la même Organisation. Ce serait impossible de le faire en 1 étape dans Hazelcast (corrigez-moi si je me trompe), mais en s'Enflammer c'est une simple JOINTURE SQL de la requête.

    Compte tenu de ce qui précède, s'Enflammer index va prendre un peu plus de temps à créer, en particulier dans votre test, où vous disposez de 7 d'entre eux.

    Correctifs dans TestEntity Classe

    Dans votre code, l'entité que vous stocker dans le cache, TestEntity, recalcule la valeur pour idSort, createdAtSort, et modifiedAtSort chaque fois que le getter est appelé. Ignite appelle ces méthodes à plusieurs reprises alors que l'entité est stocké dans l'index de l'arbre. Une solution simple pour la TestEntity classe fournit 4x amélioration de la performance: https://gist.github.com/dsetrakyan/6bfe089d53f888448503

    Tas de Mesure n'est Pas Précise

    La façon dont vous mesurez le tas est incorrect. Vous devriez au moins appeler Système.gc() avant de prendre le tas de mesure, et même ce qui ne serait pas exacte. Par exemple, dans les résultats ci-dessous, je reçois négatif de la taille de segment de mémoire à l'aide de votre méthode.

    De chauffe

    Chaque test nécessite un warm-up. Par exemple, quand j'applique la TestEntity fixer, comme suggéré ci-dessus, et ne le cache de la population et des requêtes en 2 fois, j'obtiens de meilleurs résultats.

    MySQL Comparaison

    Je ne pense pas que la comparaison d'un seul nœud de Grille de Données de test pour MySQL est juste, ni pour s'Enflammer, ni pour Hazelcast. Les bases de données ont leur propre mise en cache et dès que l'on travaille avec ces petites tailles de mémoire, vous êtes généralement d'essai de la base de données en mémoire cache vs Grille de Données en mémoire cache.

    L'avantage de performance vient habituellement quand faire un test distribué plus d'un cache de partition. De cette façon, une Grille de Données va exécuter la requête sur chaque nœud de cluster en parallèle, et les résultats devraient revenir beaucoup plus vite.

    Résultats

    Voici les résultats que j'ai obtenu pour Apache s'Enflammer. Ils regardent beaucoup mieux, après j'ai fait les corrections susmentionnées.

    Noter que la 2ème fois que nous exécutons le cache de la population et de mettre en cache les requêtes, nous obtenons de meilleurs résultats, car la JVM HotSpot est réchauffé.

    Il vaut la peine de mentionner que Ignite ne met pas en cache les résultats de la requête. Chaque fois que vous exécutez la requête, vous sont en cours d'exécution à partir de zéro.

    [00:45:15] Ignite node started OK (id=0960e091, grid=Benchmark)
[00:45:15] Topology snapshot [ver=1, servers=1, clients=0, CPUs=4, heap=8.0GB]
Starting - used heap: 225847216 bytes
Inserting 100000 records: ....................................................................................................
Inserted all records - used heap: 1001824120 bytes
Cache: 100000 entries, heap size: 775976904 bytes, inserts took 14819 ms
------------------------------------
Starting - used heap: 1139467848 bytes
Inserting 100000 records: ....................................................................................................
Inserted all records - used heap: 978473664 bytes
Cache: 100000 entries, heap size: **-160994184** bytes, inserts took 11082 ms
------------------------------------
Query 1 count: 100, time: 110 ms, heap size: 1037116472 bytes
Query 2 count: 100, time: 285 ms, heap size: 1037116472 bytes
Query 3 count: 100, time: 19 ms, heap size: 1037116472 bytes
Query 4 count: 100, time: 123 ms, heap size: 1037116472 bytes
------------------------------------
Query 1 count: 100, time: 10 ms, heap size: 1037116472 bytes
Query 2 count: 100, time: 116 ms, heap size: 1056692952 bytes
Query 3 count: 100, time: 6 ms, heap size: 1056692952 bytes
Query 4 count: 100, time: 119 ms, heap size: 1056692952 bytes
------------------------------------
[00:45:52] Ignite node stopped OK [uptime=00:00:36:515]

    Je vais créer un autre dépôt GitHub avec le code corrigé et le poster ici quand je suis plus éveillé (le café n'est pas d'aider plus).

    Merci, Dmitriy. Juste une brève histoire de mon projet. Je vais vous écrire, gars, une lettre privée. J'ai de grands projets pour s'Enflammer.
    Merci, Dmitriy. Juste une brève histoire de mon projet. J'ai commencé à Px100 avec Hazelcast (c'était à l'aide de la norme SQL/JPA dans la version précédente si vous vous demandez). Je n'étais pas naïf de penser que ça serait surpasser MySQL par simplement d'être "en mémoire", mais je m'attendais au moins des performances comparables. Comme tout le monde, j'ai utilisé Serializable et ne se soucient pas d'index. J'ai optimisé par Hazelcast officiel de la recommandation. Il a amélioré un peu les choses, mais les problèmes réapparaissaient sur de grands ensembles de données. Je vais vous écrire, gars, une lettre distincte sur Px100 privé. J'ai de grands projets pour s'Enflammer.
    Alex, ça sonne bien. J'attends avec impatience les plans que vous avez pour Apache s'Enflammer.
    Dmitry, j'ai suivi votre suggestion concernant calculé getters, cependant, vous devriez aussi vous assurer de les appeler une fois et de passer ensuite que la valeur tout au long. Ces méthodes sont tout à fait commun pour rien, mais muet DTO-style entités. La deuxième question que j'ai est sur l'index composés. J'aimerais avoir IgniteBiTuple expliqué dans la javadoc + des exemples détaillés dans la documentation. Et qu'est-ce exactement le booléen signifie: probablement dans l'ordre croissant. Des choses comme ça ne sont pas toujours "un cheval de comprendre une sorte d'évidence". Enfin vous avez un sérieux performance bug lors de la spécification de journalisation log4j w/o log4j config.
    Voici la documentation de l'Ignite fonctionnalités SQL, y compris les index composés: apacheignite.gridgain.org/v1.3/docs/sql-queries

    OriginalL'auteur Dmitriy

  2. 5

    Ici est la source de référence code: https://github.com/a-rog/px100data/tree/master/examples/HazelcastVsIgnite

    Il fait partie de la JDBC-ish NoSQL cadre je l'ai mentionné plus tôt: Px100 De Données

    La construction et de l'exécuter:

    cd <project-dir>
mvn clean package
cd target
java -cp "grid-benchmark.jar:lib/*" -Xms512m -Xmx3000m -Xss4m com.px100systems.platform.benchmark.HazelcastTest 100000
java -cp "grid-benchmark.jar:lib/*" -Xms512m -Xmx3000m -Xss4m com.px100systems.platform.benchmark.IgniteTest 100000

    Comme vous pouvez le voir, j'ai mis les limites de la mémoire haute pour éviter la collecte des ordures. Vous pouvez également exécuter mon propre framework de test (voir Px100DataTest.java) et de la comparer aux deux ci-dessus, mais concentrons-nous sur la performance pure. Ni test utilise Printemps ou quoi que ce soit d'autre, sauf pour Hazelcast 3.5.1 et Enflammer 1.3.3 - la dernière pour le moment.

    La référence du point de vue transactionnel insère le nombre spécifié de rapp. 1K-size records (100000 d'entre eux - vous pouvez l'augmenter, mais méfiez-vous de la mémoire) dans les lots (les opérations) de 1000. Il exécute ensuite deux requêtes avec ascendant et descendant de tri: un total de quatre. Tous les champs de la requête et de l'ORDRE EN sont indexés.

    Je ne vais pas poster l'ensemble de la classe (le télécharger à partir de GitHub). Le Hazelcast requête ressemble à ceci:

    PagingPredicate predicate = new PagingPredicate(
        new Predicates.AndPredicate(new Predicates.LikePredicate("textField", "%Jane%"),
            new Predicates.GreaterLessPredicate("id", first.getId(), false, false)),
        (o1, o2) -> ((TestEntity)o1.getValue()).getId().compareTo(((TestEntity)o2.getValue()).getId()),
        100);

    La correspondance de s'Enflammer requête:

    SqlQuery<Object, TestEntity> query = new SqlQuery<>(TestEntity.class,
        "FROM TestEntity WHERE textField LIKE '%Jane%' AND id > '" + first.getId() + "' ORDER BY id LIMIT 100");
    query.setPageSize(100);

    Voici les résultats exécutés sur mon 2012 8-core MBP avec 8G de mémoire:

    Hazelcast

    Starting - used heap: 49791048 bytes
Inserting 100000 records: ....................................................................................................
Inserted all records - used heap: 580885264 bytes
Map: 100000 entries, used heap: 531094216 bytes, inserts took 5458 ms
Query 1 count: 100, time: 344 ms, heap size: 298844824 bytes
Query 2 count: 100, time: 115 ms, heap size: 454902648 bytes
Query 3 count: 100, time: 165 ms, heap size: 657153784 bytes
Query 4 count: 100, time: 106 ms, heap size: 811155544 bytes

    Enflammer

    Starting - used heap: 100261632 bytes
Inserting 100000 records: ....................................................................................................
Inserted all records - used heap: 1241999968 bytes
Cache: 100000 entries, heap size: 1141738336 bytes, inserts took 14387 ms
Query 1 count: 100, time: 222 ms, heap size: 917907456 bytes
Query 2 count: 100, time: 128 ms, heap size: 926325264 bytes
Query 3 count: 100, time: 7 ms, heap size: 926325264 bytes
Query 4 count: 100, time: 103 ms, heap size: 934743064 bytes

    Une différence évidente est la performance de l'insert - perceptible dans la vie réelle. Cependant, très rarement, on insère un 1000 enregistrements. En général, il est l'un insert ou update (sauvegarder les données de l'utilisateur, etc.), donc ça ne me dérange pas. Cependant les performances de la requête. La plupart des données d'entreprise centrée sur le logiciel est en lecture lourd.

    Note la consommation de mémoire. Ignite est beaucoup plus RAM-faim que Hazelcast. Qui peut mieux expliquer les performances des requêtes. Eh bien, si j'ai décidé d'utiliser une mémoire de la grille, dois-je m'inquiéter au sujet de la mémoire?

    Vous pouvez clairement dire lorsque les données des grilles de frapper les index et quand ils ne le font pas, comment ils le cache de requêtes compilées (7ms), etc ... Je ne veux pas spéculer et vous permettra de jouer avec elle, ainsi, comme Hazelcast et Enflammer les développeurs donnent une idée.

    Autant, comme le général de performance, il est comparable, si ce n'est en dessous de MySQL. L'OMI dans la mémoire de la technologie devrait faire mieux. Je suis sûr que les deux sociétés vont prendre des notes.

    Les résultats ci-dessus sont assez proches. Toutefois, lorsqu'il est utilisé dans Px100 de Données et le niveau plus élevé Px100 (qui s'appuie fortement sur l'indexation "champs de tri" pour la pagination) s'Enflammer tire à l'avance et est mieux adapté pour mon cadre. Je me soucie principalement sur les performances de la requête.

    "si j'ai décidé d'utiliser une mémoire de la grille, dois-je m'inquiéter au sujet de la mémoire?", eh bien, oui, vous devez, sauf si vous voulez une requête pour faire baisser votre cluster avec un OOME. Bien sûr, la performance est vraiment très important, mais cela ne signifie pas que vous ne devriez pas vous inquiéter au sujet de l'utilisation de la mémoire.

    OriginalL'auteur Alex Rogachevsky