Benchmarks Mysql, Mongodb, Map Reduce, Scala

Objectif

Comparer les performances entre MySQL, les différentes méthodes d’aggrégation disponibles sur mongodb (group, aggregate, map reduce) et un map reduce en scala.

Résultats obtenus sur des données issues d’Imdb. Pour la récupération des données IMDB, voir le post ici.

Les tests ont été effectués sur un HP-Z800 (X5650  @ 2.67GHz 24 cores) 12 Go RAM sour Debian.

Résultats

Mysql sans index Mysql avec index MongoDb group MongoDb aggregate MongoDb map reduce MongoDb/Scala map reduce
Temps(ms)  2310 780  26972  3395  57468  12338

Prérequis

    • Python 3+
    • Mysql
sudo apt-get install mysql-server mysql-client libmysqlclient15-dev mysql-common

Mysql

  • Mysql sans Index
select year,count(year) as nb from movies group by year order by nb;
136 rows in set (2.31 sec)
  • Mysql avec index
ALTER TABLE movies ADD INDEX (year);

136 rows in set (0.78 sec)

Mongodb

  • Group sans Index
db.setProfilingLevel(1)
db.movie.group({
	key : { year:1},
	reduce: function ( curr, result ) { 
	 result.count++;
	},
	initial: { count: 0 }
                } )
db.system.profile.find()

Temps :  26972 ms

  • Group avec index
db.movie.ensureIndex( { year: 1 } )

Temps : 27494 ms

  • Aggregate
db.movie.aggregate( [ { $group : { _id: {year : "$year"} ,
number : { $sum : 1 } } } ,
{ $sort : { year : 1 } }
] )

Temps : 3395 ms

  • MapReduce
var mapFunction1 = function() {emit(this.year, {count: 1}); }
var reduceFunction1 = function(key, values) {
var count = 0;
values.forEach( function(v) { count += v['count']; });
return {count: count};
}

db.movie.mapReduce(mapFunction1,reduceFunction1,{ out: "map_reduce_example" })

Temps : 57468 ms

Scala + MongoDb + MapReduce

Installation casbah (Scala toolkit for MongoDB) voir ici

import com.mongodb.casbah.Imports._

object Main {
    def time[R](block: => R): R = {
        val t0 = System.nanoTime()
        val result = block    // call-by-name
        val t1 = System.nanoTime()
        println("Elapsed time: " + (t1 - t0)/1000000 + "ms")
        result
    }  
    def mapper(movie:DBObject): (Int, Int) =  (movie.as[Int]("year"),1)  
    def f(year:Int, mymap:Map[Int,Iterable[(Int, Int)]]) : (Int,Int) = (year,mymap.get(year) match  {
    	case Some(z) => z.count(x => true)
    	case None => throw new Exception
	})

    def reducer(tuple:Iterable[(Int,Int)]): Iterable[(Int,Int)] = {
	val mymap = tuple.groupBy(_._1)	  
	val uniqueYears = mymap.keys	  
	uniqueYears.map(year => f(year,mymap))	    
    }    
    def main(args: Array[String]) {
	val mongoClient = MongoClient("localhost", 27017)
	val db = mongoClient("imdb")
	val movies = db("movie1")
	val tuple = time {reducer(movies.map(mapper)).toList.sortBy(_._1)}
	println(tuple);	    
    }
}

Elapsed time: 15673ms

 

 

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s