Matthieu MEZIL

WCF Data Services vs WAQS – Comparatif de performance

La raison initiale pour laquelle j’ai fait WAQS était la limitation de WCF Data Services et de WCF RIA Services en terme de requêtage.

Depuis WAQS a beaucoup évolué et son périmètre est devenu beaucoup plus important.

A ce propos, je vous invite à me contacter ou à passer me voir sur le stand Infinite Square aux TechDays si vous voulez en savoir plus.

Ayant récemment procédé à quelques optimisations sur WAQS, j’ai voulu faire le test vs WCF Data Services pour voir si le gain de fonctionalités ne se faisait pas au détriment de la performance.

J’ai donc effectué des requêtes simples sur la base Contoso qui a l’avantage d’être plus fournie que Northwind.

A noter, que, dans le cas de WAQS comme dans le cas de WCF Data Services, je suis resté sur le mode par défaut.

Voici les résultats obtenus avec WCF Data Services

• Récupération des 18 869 clients de la base : 6 693 ms

  var query = _context.DimCustomers;
  var customers = (await Task.Factory.FromAsync(query.BeginExecute(null, null),
      ar => query.EndExecute(ar))).ToList();

• Récupération des CompanyName des clients : 2 652 ms

  var query = (DataServiceQuery<DimCustomer>)_context.DimCustomers
      .Select(c => new DimCustomer { CustomerKey = c.CustomerKey, CompanyName = c.CompanyName });
  var customers = (await Task.Factory.FromAsync(query.BeginExecute(null, null),
      ar => query.EndExecute(ar)))
      .Select(c => c.CompanyName).ToList();

• Récupération de 100 clients avec leurs ventes en ligne : 9 672 ms

  var query = (DataServiceQuery<DimCustomer>)_context.DimCustomers
      .Expand("FactOnlineSales")
      .Take(100);
  var customers = (await Task.Factory.FromAsync(query.BeginExecute(null, null), 
      ar => query.EndExecute(ar))).ToList();

• Récupération de 100 clients avec leurs ventes en ligne et les produits de celles-ci : 27 021 ms

  var query = (DataServiceQuery<DimCustomer>)_context.DimCustomers
      .Expand("FactOnlineSales/DimProduct")
      .Take(100);
  var customers = (await Task.Factory.FromAsync(query.BeginExecute(null, null), 
      ar => query.EndExecute(ar))).ToList();

• Récupération de 100 clients avec leurs ventes en ligne, les produits de celles-ci et les catégories de ceux-ci : 42 604 ms

  var query = (DataServiceQuery<DimCustomer>)_context.DimCustomers
      .Expand("FactOnlineSales/DimProduct/DimProductSubcategory/DimProductCategory")
      .Take(100);
  var customers = (await Task.Factory.FromAsync(query.BeginExecute(null, null), 
      ar => query.EndExecute(ar))).ToList();

• Récupération de 200 clients avec leurs ventes en ligne, les produits de celles-ci et les catégories de ceux-ci : Exception !

  var query = (DataServiceQuery<DimCustomer>)_context.DimCustomers
      .Expand("FactOnlineSales/DimProduct/DimProductSubcategory/DimProductCategory")
      .Take(200);
  var customers = (await Task.Factory.FromAsync(query.BeginExecute(null, null), 
      ar => query.EndExecute(ar))).ToList();

Maintenant faisons la même chose avec WAQS :

• Récupération des 18 869 clients de la base : 3 307 ms (au lieu de 6 693 ms)

  var customers = (await _context.DimCustomers.AsAsyncQueryable().Execute()).ToList();

• Récupération des CompanyName des clients : 187 ms (au lieu de 2 652 ms)

  var customers = (await _context.DimCustomers.AsAsyncQueryable()
      .Select(c => c.CompanyName)
      .Execute()).ToList();

• Récupération de 100 clients avec leurs ventes en ligne : 3 260 ms (au lieu de 9 672 ms)

  var customers = (await _context.DimCustomers.AsAsyncQueryable()
      .OrderBy(c => c.CustomerKey)
      .Take(100)
      .IncludeFactOnlineSales()
      .Execute()).ToList();

• Récupération de 100 clients avec leurs ventes en ligne et les produits de celles-ci : 4 336 ms (au lieu de 27 021 ms)

  var customers = (await _context.DimCustomers.AsAsyncQueryable()
      .OrderBy(c => c.CustomerKey)
      .Take(100)
      .IncludeFactOnlineSalesWithExpression(
          onlineSales => onlineSales.IncludeDimProduct())
      .Execute()).ToList();

• Récupération de 100 clients avec leurs ventes en ligne, les produits de celles-ci et les catégories de ceux-ci : 4 883 ms (au lieu de 42 604 ms)

  var customers = (await _context.DimCustomers.AsAsyncQueryable()
      .OrderBy(c => c.CustomerKey)
      .Take(100)
      .IncludeFactOnlineSalesWithExpression(
          onlineSales => onlineSales.IncludeDimProductWithExpression(
              products => products.IncludeDimProductSubcategoryWithExpression(
                  productSubcategories => productSubcategories.IncludeDimProductCategory())))
      .Execute()).ToList();

• Récupération de 200 clients avec leurs ventes en ligne, les produits de celles-ci et les catégories de ceux-ci : 7 029 ms (au lieu d’une exception)

  var customers = (await _context.DimCustomers.AsAsyncQueryable()
      .OrderBy(c => c.CustomerKey)
      .Take(200)
      .IncludeFactOnlineSalesWithExpression(
          onlineSales => onlineSales.IncludeDimProductWithExpression(
              products => products.IncludeDimProductSubcategoryWithExpression(
                  productSubcategories => productSubcategories.IncludeDimProductCategory())))
      .Execute()).ToList();

Si on ne prends pas en compte le côté infini du ratio de la dernière requête, WAQS est donc entre 2,02 et 14,18 fois plus rapide que WCF Data Services avec une moyenne sur mes tests de 6,83.

Ca va, je suis rassuré… :)

// A noter que la version de WAQS que j’ai utilisé n’est pas encore publique

Publié lundi 11 février 2013 01:30 par Matthieu MEZIL