Comment chronométrer une transformation dans Spark, compte tenu du style d'exécution paresseux?

Question

J'ai du code qui exécute quelques étapes, et je sais combien de temps tout le processus prend. Cependant, j'aimerais pouvoir calculer combien de temps prend chaque transformation individuelle. Voici quelques exemples simples des étapes:

rdd1 = sc.textFile("my/filepath/*").map(lambda x: x.split(",")) 
rdd2 = sc.textFile("other/filepath/*").map(lambda x: x.split(",")) 
to_kv1 = rdd1.map(lambda x: (x[0], x[1])) # x[0] is key, x[1] is numeric 
to_kv2 = rdd2.map(lambda x: (x[0], x[1])) # x[0] is key, x[1] is numeric 
reduced1 = to_kv1.reduceByKey(lambda a, b: a+b) 
reduced2 = to_kv1.reduceByKey(lambda a, b: a+b) 
outer_joined = reduced1.fullOuterJoin(reduced2) # let's just assume there is key overlap 
outer_joined.saveAsTextFile("my_output") 

Maintenant: comment est-ce que je compare une partie spécifique de ce code? Je sais que l'exécutant bout à bout prend un certain laps de temps (le saveAsTextFile forcera à exécuter), mais comment faire référence je ne l'reduceByKey ou fullOuterJoin partie du code? Je sais que je pourrais exécuter count() après chaque opération pour forcer l'exécution, mais cela ne permettrait pas d'évaluer correctement l'opération car elle ajoute le temps nécessaire pour effectuer le count ainsi que le temps nécessaire pour effectuer la transformation.

Quelle est la meilleure façon de référence transformations Spark, compte tenu de leur style d'exécution paresseux?

S'il vous plaît noter que je ne demande pas comment mesurer le temps. Je sais que sur le module time, start = time.time(), etc. Je demande comment le style de référence compte tenu de l'exécution paresseuse des transformations Spark, qui n'exécutent pas jusqu'à ce que vous appelez une action qui a besoin d'informations à retourner au conducteur.

Answer 1

Votre meilleur pari est d'utiliser l'interface utilisateur Spark pour lire ces informations. Le problème est double:

• Les calculs sont distribués même si vous avez ajouté un mécanisme de synchronisation dans chacune des transformations, il serait un peu difficile de dire quand la tâche est vraiment fait comme il pourrait se faire en une machine, mais pas une autre. Cela dit, vous POUVEZ ajouter la journalisation à l'intérieur et trouver la première instance de l'exécution, puis trouver l'exécution finale. Gardez à l'esprit le point suivant si
• Les transformations sont pipelines autant que possible. Ainsi, Spark exécutera plusieurs transformations en même temps pour plus d'efficacité, donc vous devrez tester explicitement une seule action.