[JAVA] Comparé le temps de traitement pour convertir Apache Arrow et JSON en Yosegi

Dans cet article, je voudrais comparer le temps de traitement de la conversion Apache Arrow et JSON au format colonnaire Yosegi. pense.

• En premier lieu, les performances de traitement d'écriture de Yosegi sont comparées à ORC et Parquet dans Article que j'ai écrit la dernière fois, veuillez donc vous y référer.

Préparer Yosegi

Yosegi a CLI, alors utilisez ceci.

Tout d'abord, clonez depuis GitHub. Exécutez la commande de configuration après avoir compilé ce fichier jar.

$ git clone https://github.com/yahoojapan/yosegi-tools
$ mvn clean package
$ ./bin/setup.sh

Cela rend la commande disponible. Il existe un exemple de fichier JSON, vous pouvez vérifier l'opération ici.

$ ./bin/yosegi.sh create -i ./etc/sample_json.txt -o /tmp/a.json -f json
$ ./bin/yosegi.sh cat -i /tmp/a.json -o "-"
{"summary":{"total_price":550,"total_weight":412},"number":5,"price":110,"name":"apple","class":"fruits"}
{"summary":{"total_price":800,"total_weight":600},"number":10,"price":80,"name":"orange","class":"fruits"}

Données utilisées pour la comparaison

Utilisez les données obtenues en convertissant l'élément de ligne de TPC-H en JSON. La taille des données est d'environ 3,5 Go.

$ ls -l /tmp/lineitem.json
-rwxrwxrwx 1 hoge hoge 3665538085 Mar  6 14:24 /tmp/lineitem.json

Travail de vérification

Conversion de JSON en Yosegi

Conversion de JSON en Yosegi. Le temps de traitement était d'environ 2 minutes et 41 secondes.

$ time HEAP_SIZE=1g ./bin/yosegi.sh create -i /tmp/lineitem.json -o /tmp/lineitem.yosegi.gz -f json

real    2m41.488s
user    1m47.595s
sys     0m44.432s

Conversion de Yosegi à Apache Arrow

Convertit le fichier Yosegi de sortie au format Apache Arrow. Le temps de traitement était d'environ 16 secondes.

$ time HEAP_SIZE=1g ./bin/yosegi.sh to_arrow -i /tmp/lineitem.yosegi.gz -o /tmp/lineitem.arrow

real    0m16.134s
user    0m9.927s
sys     0m2.392s

La taille des données sera d'environ 1,5 Go. Puisqu'il y a peu d'informations clés, elles sont nettement inférieures à JSON.

$ ls -l /tmp/lineitem.arrow
-rwxrwxrwx 1 hoge hoge 1566760242 Mar  6 16:24 /tmp/lineitem.arrow

Conversion d'Apache Arrow vers Yosegi

Convertit le fichier Apache Arrow de sortie au format Yosegi. Le temps de traitement était d'environ 1 minute et 9 secondes.

$ time HEAP_SIZE=1g ./bin/yosegi.sh from_arrow -i /tmp/lineitem.arrow -o /tmp/lineitem_from_arrow.yosegi.gz

real    1m9.046s
user    1m4.562s
sys     0m1.558s

Conversion de Yosegi en JSON

Enfin, effectuez la conversion de Yosegi en JSON. Le temps de traitement était d'environ 14 minutes et 43 secondes.

$ time HEAP_SIZE=1g ./bin/yosegi.sh cat -i /tmp/lineitem.yosegi.gz -f json -o /tmp/lineitem_from_yosegi.json

real    14m42.576s
user    0m10.492s
sys     8m23.839s

Puisque la destination d'écriture est un disque, je vais le définir sur / dev / null pour comparaison.

La conversion JSON a pris environ 46 secondes et la conversion Apache Arrow a pris environ 10 secondes.

$ time HEAP_SIZE=1g ./bin/yosegi.sh cat -i /tmp/lineitem.yosegi.gz -f json -o "-" > /dev/null

real    0m45.748s
user    0m44.851s
sys     0m0.429s

$ time HEAP_SIZE=1g ./bin/yosegi.sh to_arrow -i /tmp/lineitem.yosegi.gz -o "-" > /dev/null

real    0m10.141s
user    0m9.431s
sys     0m0.347s

Résumé de la comparaison

Apache Arrow est environ 2,3 fois plus rapide pour l'écriture et 4,55 fois plus rapide pour la lecture que JSON.

Résumé

--Dans le processus d'écriture, JSON est ajouté au processus d'enregistrement en mémoire avec la structure de données de colonne. Apache Arrow a une structure de données de colonne, donc il peut être converti tel quel. Par conséquent, le processus d'enregistrement temporaire dans la mémoire est omis. On suppose que la raison pour laquelle la différence est faible par rapport à la lecture est que le temps de traitement pour la compression est important.

--Dans le processus de lecture, JSON est chargé en mémoire avec la structure de données de la colonne, puis lu en unités de message et converti en JSON. Apache Arrow a une structure de données de colonne, il peut donc être chargé tel quel. Par conséquent, le processus de lecture et le processus de conversion de chaque message sont omis.

À partir de là, on peut dire qu'il est efficace de se convertir via Apache Arrow. En supposant qu'Apache Arrow se généralisera à l'avenir, il peut être plus efficace de concevoir des entrées et des sorties basées sur Apache Arrow. Cet article a décrit les formats de données, mais nous souhaitons également mieux comprendre l'échange de données entre les langues.

prime

Les binaires Apache Arrow peuvent être facilement traités avec python. Yosegi lui-même ne prend en charge que Java, mais il peut être facilement lié en passant par Apache Arrow.

import pyarrow as pa

reader = pa.RecordBatchFileReader( pa.OSFile( "/tmp/lineitem.arrow" ) )

rb = reader.get_record_batch(0)
df = rb.to_pandas()
print( df["l_linestatus"].value_counts() )

Le résultat de l'exécution du programme ci-dessus est le suivant.

$ time python a.py
F    25129
O    24871
Name: l_linestatus, dtype: int64

real    0m0.327s
user    0m0.269s
sys     0m0.042s

à la fin

Yosegi, qui se développe actuellement en tant qu'OSS, est à la recherche d'utilisateurs et de développeurs! Si vous êtes intéressé par Yosegi, n'hésitez pas à nous contacter!