WCF de la performance, de la latence et de l'évolutivité

Je suis en train de le port d'un simple async serveur TCP en F# C# 4. Le serveur reçoit une connexion, se lit d'une seule demande et des ruisseaux d'une séquence de réponses avant de fermer la connexion.

Async en C# 4 semble fastidieux et source d'erreur, donc je pensais que je voudrais essayer en utilisant WCF à la place. Ce serveur n'est pas rare de voir de 1 000 demandes simultanées dans la nature donc je pense qu'à la fois le débit et la latence sont d'intérêt.

J'ai écrit un minimum duplex service web WCF et client de la console en C#. Même si je suis en utilisant WCF au lieu de les sockets raw, c'est déjà 175 lignes de code par rapport à 80 lignes de l'original. Mais je suis plus préoccupé par la performance et l'évolutivité:

Temps de latence est de 154× pire avec WCF.
Le débit est de 54× pire avec WCF.
TCP gère de 1 000 connexions simultanées facilement, mais WCF étouffe sur 20.

Tout d'abord, je suis en utilisant les paramètres par défaut pour tout, alors je me demandais si il n'y a rien que je peux modifier pour améliorer ces performances?

Deuxièmement, je me demandais si quelqu'un est à l'aide de la WCF pour ce genre de chose ou si c'est le bon outil pour le travail?

Voici mon WCF serveur en C#:

IService1.cs

[DataContract]
public class Stock
{
  [DataMember]
  public DateTime FirstDealDate { get; set; }
  [DataMember]
  public DateTime LastDealDate { get; set; }
  [DataMember]
  public DateTime StartDate { get; set; }
  [DataMember]
  public DateTime EndDate { get; set; }
  [DataMember]
  public decimal Open { get; set; }
  [DataMember]
  public decimal High { get; set; }
  [DataMember]
  public decimal Low { get; set; }
  [DataMember]
  public decimal Close { get; set; }
  [DataMember]
  public decimal VolumeWeightedPrice { get; set; }
  [DataMember]
  public decimal TotalQuantity { get; set; }
}

[ServiceContract(CallbackContract = typeof(IPutStock))]
public interface IStock
{
  [OperationContract]
  void GetStocks();
}

public interface IPutStock
{
  [OperationContract]
  void PutStock(Stock stock);
}

Service1.svc

<%@ ServiceHost Language="C#" Debug="true" Service="DuplexWcfService2.Stocks" CodeBehind="Service1.svc.cs" %>

Service1.svc.cs

 [ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple)]
 public class Stocks : IStock
 {
   IPutStock callback;

   #region IStock Members
   public void GetStocks()
   {
     callback = OperationContext.Current.GetCallbackChannel<IPutStock>();
     Stock st = null;
     st = new Stock
     {
       FirstDealDate = System.DateTime.Now,
       LastDealDate = System.DateTime.Now,
       StartDate = System.DateTime.Now,
       EndDate = System.DateTime.Now,
       Open = 495,
       High = 495,
       Low = 495,
       Close = 495,
       VolumeWeightedPrice = 495,
       TotalQuantity = 495
     };
     for (int i=0; i<1000; ++i)
       callback.PutStock(st);
   }
   #endregion
 }

Web.config

<?xml version="1.0"?>
<configuration>
  <system.web>
    <compilation debug="true" targetFramework="4.0" />
  </system.web>
  <system.serviceModel>
    <services>
      <service name="DuplexWcfService2.Stocks">
        <endpoint address="" binding="wsDualHttpBinding" contract="DuplexWcfService2.IStock">
          <identity>
            <dns value="localhost"/>
          </identity>
        </endpoint>
        <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange"/>
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior>
          <serviceMetadata httpGetEnabled="true"/>
          <serviceDebug includeExceptionDetailInFaults="true"/>
        </behavior>
      </serviceBehaviors>
    </behaviors>
    <serviceHostingEnvironment multipleSiteBindingsEnabled="true" />
  </system.serviceModel>
  <system.webServer>
    <modules runAllManagedModulesForAllRequests="true"/>
  </system.webServer>
</configuration>

Voici le C# WCF client:

Program.cs

 [CallbackBehavior(ConcurrencyMode = ConcurrencyMode.Multiple, UseSynchronizationContext = false)]
class Callback : DuplexWcfService2.IStockCallback
{
System.Diagnostics.Stopwatch timer;
int n;
public Callback(System.Diagnostics.Stopwatch t)
{
timer = t;
n = 0;
}
public void PutStock(DuplexWcfService2.Stock st)
{
++n;
if (n == 1)
Console.WriteLine("First result in " + this.timer.Elapsed.TotalSeconds + "s");
if (n == 1000)
Console.WriteLine("1,000 results in " + this.timer.Elapsed.TotalSeconds + "s");
}
}
class Program
{
static void Test(int i)
{
var timer = System.Diagnostics.Stopwatch.StartNew();
var ctx = new InstanceContext(new Callback(timer));
var proxy = new DuplexWcfService2.StockClient(ctx);
proxy.GetStocks();
Console.WriteLine(i + " connected");
}
static void Main(string[] args)
{
for (int i=0; i<10; ++i)
{
int j = i;
new System.Threading.Thread(() => Test(j)).Start();
}
}
}

Voici mon async TCP code client et serveur en F#:

type AggregatedDeals =
{
FirstDealTime: System.DateTime
LastDealTime: System.DateTime
StartTime: System.DateTime
EndTime: System.DateTime
Open: decimal
High: decimal
Low: decimal
Close: decimal
VolumeWeightedPrice: decimal
TotalQuantity: decimal
}
let read (stream: System.IO.Stream) = async {
let! header = stream.AsyncRead 4
let length = System.BitConverter.ToInt32(header, 0)
let! body = stream.AsyncRead length
let fmt = System.Runtime.Serialization.Formatters.Binary.BinaryFormatter()
use stream = new System.IO.MemoryStream(body)
return fmt.Deserialize(stream)
}
let write (stream: System.IO.Stream) value = async {
let body =
let fmt = System.Runtime.Serialization.Formatters.Binary.BinaryFormatter()
use stream = new System.IO.MemoryStream()
fmt.Serialize(stream, value)
stream.ToArray()
let header = System.BitConverter.GetBytes body.Length
do! stream.AsyncWrite header
do! stream.AsyncWrite body
}
let endPoint = System.Net.IPEndPoint(System.Net.IPAddress.Loopback, 4502)
let server() = async {
let listener = System.Net.Sockets.TcpListener(endPoint)
listener.Start()
while true do
let client = listener.AcceptTcpClient()
async {
use stream = client.GetStream()
let! _ = stream.AsyncRead 1
for i in 1..1000 do
let aggregatedDeals =
{
FirstDealTime = System.DateTime.Now
LastDealTime = System.DateTime.Now
StartTime = System.DateTime.Now
EndTime = System.DateTime.Now
Open = 1m
High = 1m
Low = 1m
Close = 1m
VolumeWeightedPrice = 1m
TotalQuantity = 1m
}
do! write stream aggregatedDeals
} |> Async.Start
}
let client() = async {
let timer = System.Diagnostics.Stopwatch.StartNew()
use client = new System.Net.Sockets.TcpClient()
client.Connect endPoint
use stream = client.GetStream()
do! stream.AsyncWrite [|0uy|]
for i in 1..1000 do
let! _ = read stream
if i=1 then lock stdout (fun () ->
printfn "First result in %fs" timer.Elapsed.TotalSeconds)
lock stdout (fun () ->
printfn "1,000 results in %fs" timer.Elapsed.TotalSeconds)
}
do
server() |> Async.Start
seq { for i in 1..100 -> client() }
|> Async.Parallel
|> Async.RunSynchronously
|> ignore

Le premier truc que j'aimerais essayer est de passer la wcf de liaison de wsdualhttp à nettcp (avec sécurité désactivé) pour quelque chose de plus comparables.
Voir aussi peut-être devproconnections.com/article/net-framework2/...
Bonne question. J'ai reçu votre C# service s'exécutant localement, mais je ne peux pas obtenir le F# pour compiler pour une comparaison de performances. Je n'ai jamais lu F# avant... que dois-je ajouter pour faire de rassembler au-delà de couper et de coller le code ci-dessus?

InformationsquelleAutor Jon Harrop | 2011-10-10

c#f#tcp wcf

WCF sélectionne de très des valeurs sûres pour presque tous ses paramètres par défaut. Ceci est conforme à la philosophie de ne pas laisser le novice développeur de tirer eux-mêmes. Toutefois, si vous savez les manettes de changement et les fixations à utiliser, vous pouvez obtenir des performances acceptables et de mise à l'échelle.

Sur mon core i5-2400 (quad core, pas de l'hyper threading, 3.10 GHz) la solution ci-dessous sera exécuté 1000 clients avec un 1000 rappels de chacun, pour une moyenne de temps de fonctionnement total de 20 secondes. C'est 1 000 000 de WCF appels en 20 secondes.

Malheureusement, je ne pouvais pas obtenir votre F# programme à exécuter pour une comparaison directe. Si vous exécutez ma solution sur votre boîte, pourriez-vous s'il vous plaît poster quelques F# vs C# WCF comparaison des performances des chiffres?

Avertissement: La ci-dessous est destiné à être une preuve de concept. Certains de ces paramètres ne font pas sens pour la production.

Ce que j'ai fait:

Supprimé le duplex de la liaison et avait les clients à créer leur propre
le service des hôtes pour recevoir les rappels. C'est essentiellement ce qu'est un
duplex de la liaison est de le faire sous le capot. (Il est aussi Pratique de l'
suggestion)
Changé la liaison à netTcpBinding.
Changé valeurs de limitation:
- WCF: paramètre, maxConcurrentSessions,
  maxConcurrentInstances tous à 1000
- TCP liaison: maxConnections=1000
- Pool de threads: Min threads = 1000, Min IO threads = 2000
Ajouté IsOneWay pour les opérations de service

Noter que dans ce prototype de tous les services et les clients sont dans le même Domaine d'Application et partage le même pool de threads.

Ce que j'ai appris:

Lorsqu'un client a obtenu une “Aucune connexion n'a pu être établie car l'ordinateur cible l'a expressément refusé” d'exception
- Causes possibles:
  1. WCF limite a été atteint
  2. TCP limite a été atteint
  3. Il n'y a pas de thread d'e/S disponibles pour traiter l'appel.
- La solution pour le #3 est soit:
  1. Augmenter le min IO nombre de threads OU
  2. Ont la StockService faire ses rappels sur un thread de travail (ce qui augmente la durée totale d'utilisation)
Ajoutant IsOneWay couper le temps d'exécution de moitié (à partir de 40 sec à 20 sec).

De sortie du programme en cours d'exécution sur un core i5-2400.
Remarque les compteurs sont utilisés de la même manière que dans la question d'origine (voir le code).

All client hosts open.
Service Host opened. Starting timer...
Press ENTER to close the host one you see 'ALL DONE'.
Client #100 completed 1,000 results in 0.0542168 s
Client #200 completed 1,000 results in 0.0794684 s
Client #300 completed 1,000 results in 0.0673078 s
Client #400 completed 1,000 results in 0.0527753 s
Client #500 completed 1,000 results in 0.0581796 s
Client #600 completed 1,000 results in 0.0770291 s
Client #700 completed 1,000 results in 0.0681298 s
Client #800 completed 1,000 results in 0.0649353 s
Client #900 completed 1,000 results in 0.0714947 s
Client #1000 completed 1,000 results in 0.0450857 s
ALL DONE. Total number of clients: 1000 Total runtime: 19323 msec

Code dans une application console fichier:

using System;
using System.Collections.Generic;
using System.ServiceModel;
using System.Diagnostics;
using System.Threading;
using System.Runtime.Serialization;
namespace StockApp
{
[DataContract]
public class Stock
{
[DataMember]
public DateTime FirstDealDate { get; set; }
[DataMember]
public DateTime LastDealDate { get; set; }
[DataMember]
public DateTime StartDate { get; set; }
[DataMember]
public DateTime EndDate { get; set; }
[DataMember]
public decimal Open { get; set; }
[DataMember]
public decimal High { get; set; }
[DataMember]
public decimal Low { get; set; }
[DataMember]
public decimal Close { get; set; }
[DataMember]
public decimal VolumeWeightedPrice { get; set; }
[DataMember]
public decimal TotalQuantity { get; set; }
}
[ServiceContract]
public interface IStock
{
[OperationContract(IsOneWay = true)]
void GetStocks(string address);
}
[ServiceContract]
public interface IPutStock
{
[OperationContract(IsOneWay = true)]
void PutStock(Stock stock);
} 
[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
public class StocksService : IStock
{
public void SendStocks(object obj)
{
string address = (string)obj;
ChannelFactory<IPutStock> factory = new ChannelFactory<IPutStock>("CallbackClientEndpoint");
IPutStock callback = factory.CreateChannel(new EndpointAddress(address));
Stock st = null; st = new Stock
{
FirstDealDate = System.DateTime.Now,
LastDealDate = System.DateTime.Now,
StartDate = System.DateTime.Now,
EndDate = System.DateTime.Now,
Open = 495,
High = 495,
Low = 495,
Close = 495,
VolumeWeightedPrice = 495,
TotalQuantity = 495
};
for (int i = 0; i < 1000; ++i)
callback.PutStock(st);
//Console.WriteLine("Done calling {0}", address);
((ICommunicationObject)callback).Shutdown();
factory.Shutdown();
}
public void GetStocks(string address)
{
///WCF service methods execute on IO threads. 
///Passing work off to worker thread improves service responsiveness... with a measurable cost in total runtime.
System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(SendStocks), address);
//SendStocks(address);
}
} 
[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]
public class Callback : IPutStock
{
public static int CallbacksCompleted = 0;
System.Diagnostics.Stopwatch timer = Stopwatch.StartNew();
int n = 0;
public void PutStock(Stock st)
{
++n;
if (n == 1000)
{
//Console.WriteLine("1,000 results in " + this.timer.Elapsed.TotalSeconds + "s");
int compelted = Interlocked.Increment(ref CallbacksCompleted);
if (compelted % 100 == 0)
{
Console.WriteLine("Client #{0} completed 1,000 results in {1} s", compelted, this.timer.Elapsed.TotalSeconds);
if (compelted == Program.CLIENT_COUNT)
{
Console.WriteLine("ALL DONE. Total number of clients: {0} Total runtime: {1} msec", Program.CLIENT_COUNT, Program.ProgramTimer.ElapsedMilliseconds);
}
}
}
}
}
class Program
{
public const int CLIENT_COUNT = 1000;           //TEST WITH DIFFERENT VALUES
public static System.Diagnostics.Stopwatch ProgramTimer;
static void StartCallPool(object uriObj)
{
string callbackUri = (string)uriObj;
ChannelFactory<IStock> factory = new ChannelFactory<IStock>("StockClientEndpoint");
IStock proxy = factory.CreateChannel();
proxy.GetStocks(callbackUri);
((ICommunicationObject)proxy).Shutdown();
factory.Shutdown();
}
static void Test()
{
ThreadPool.SetMinThreads(CLIENT_COUNT, CLIENT_COUNT * 2);
//Create all the hosts that will recieve call backs.
List<ServiceHost> callBackHosts = new List<ServiceHost>();
for (int i = 0; i < CLIENT_COUNT; ++i)
{
string port = string.Format("{0}", i).PadLeft(3, '0');
string baseAddress = "net.tcp://localhost:7" + port + "/";
ServiceHost callbackHost = new ServiceHost(typeof(Callback), new Uri[] { new Uri( baseAddress)});
callbackHost.Open();
callBackHosts.Add(callbackHost);            
}
Console.WriteLine("All client hosts open.");
ServiceHost stockHost = new ServiceHost(typeof(StocksService));
stockHost.Open();
Console.WriteLine("Service Host opened. Starting timer...");
ProgramTimer = Stopwatch.StartNew();
foreach (var callbackHost in callBackHosts)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(StartCallPool), callbackHost.BaseAddresses[0].AbsoluteUri);
}
Console.WriteLine("Press ENTER to close the host once you see 'ALL DONE'.");
Console.ReadLine();
foreach (var h in callBackHosts)
h.Shutdown();
stockHost.Shutdown(); 
}
static void Main(string[] args)
{
Test();
}
}
public static class Extensions
{
static public void Shutdown(this ICommunicationObject obj)
{
try
{
obj.Close();
}
catch (Exception ex)
{
Console.WriteLine("Shutdown exception: {0}", ex.Message);
obj.Abort();
}
}
}
}

app.config:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.serviceModel>
<services>
<service name="StockApp.StocksService">
<host>
<baseAddresses>
<add baseAddress="net.tcp://localhost:8123/StockApp/"/>
</baseAddresses>
</host>
<endpoint address="" binding="netTcpBinding" bindingConfiguration="tcpConfig" contract="StockApp.IStock">
<identity>
<dns value="localhost"/>
</identity>
</endpoint>
</service>
<service name="StockApp.Callback">
<host>
<baseAddresses>
<!-- Base address defined at runtime. -->
</baseAddresses>
</host>
<endpoint address="" binding="netTcpBinding" bindingConfiguration="tcpConfig" contract="StockApp.IPutStock">
<identity>
<dns value="localhost"/>
</identity>
</endpoint>
</service>
</services>
<client>
<endpoint name="StockClientEndpoint"
address="net.tcp://localhost:8123/StockApp/"
binding="netTcpBinding"
bindingConfiguration="tcpConfig"
contract="StockApp.IStock" >
</endpoint>
<!-- CallbackClientEndpoint address defined at runtime. -->
<endpoint name="CallbackClientEndpoint"
binding="netTcpBinding"
bindingConfiguration="tcpConfig"
contract="StockApp.IPutStock" >
</endpoint>
</client>
<behaviors>
<serviceBehaviors>
<behavior>
<!--<serviceMetadata httpGetEnabled="true"/>-->
<serviceDebug includeExceptionDetailInFaults="true"/>
<serviceThrottling maxConcurrentCalls="1000" maxConcurrentSessions="1000" maxConcurrentInstances="1000" />
</behavior>
</serviceBehaviors>
</behaviors>
<bindings>
<netTcpBinding>
<binding name="tcpConfig" listenBacklog="100" maxConnections="1000">
<security mode="None"/>
<reliableSession enabled="false" />
</binding>
</netTcpBinding>
</bindings>
</system.serviceModel>
</configuration>

Mise à jour:
J'ai juste essayé la solution ci-dessus avec un netNamedPipeBinding:

  <netNamedPipeBinding >
<binding name="pipeConfig" maxConnections="1000" >
<security mode="None"/>
</binding>
</netNamedPipeBinding>

Elle a effectivement mis 3 secondes de plus (de 20 à 23 secondes). Depuis cet exemple particulier est tous les inter-processus, je ne sais pas pourquoi. Si quelqu'un a des idées, s'il vous plaît commentaire.

InformationsquelleAutor ErnieL

5

Pour répondre à votre deuxième question, WCF aura toujours une surcharge par rapport à raw sockets. Mais il a une tonne de fonctionnalités (comme la sécurité, la fiabilité, l'interopérabilité, plusieurs protocoles de transport, de traçage, etc.) par rapport à raw sockets, si le compromis est acceptable pour vous, c'est en fonction de votre scénario. On dirait que vous faites des opérations financières de l'application et de la WCF est peut-être pas adapté à votre cas (bien que je ne suis pas dans la finance, l'industrie afin de qualifier cette avec de l'expérience).

Pour votre première question, au lieu de la double liaison http essayer d'hébergement séparé service WCF dans le client de sorte que le client peut être un service en soi, et d'utiliser le netTCP liaison si possible. Ajuster les attributs dans maxconcurrentcalls élément du comportement en service. Les valeurs par défaut ont été plus faibles avant .Net 4.

InformationsquelleAutor softveda
2

Je dirais que cela dépend de vos objectifs. Si vous voulez pousser votre matériel autant que possible, alors il est certainement possible d'obtenir+ de 10 000 clients connectés facilement, le secret est de minimiser le temps passé dans le garbage collector et à l'aide de sockets efficacement.

J'ai un peu de posts sur les Sockets en F# ici: http://moiraesoftware.com

Im faire certains travaux en cours avec une bibliothèque appelée Fracture-IO ici: https://github.com/fractureio/fracture

Vous pourriez vouloir vérifier ceux d'idées...

InformationsquelleAutor 7sharp9

Vous devez vous connecter pour publier un commentaire.