Das Threadpool-Programm läuft auf einem viel schnelleren Server viel langsamer
upd Ich denke jetzt, dass die Wurzel meines Problems nicht "Threading" ist, weil ich an jedem Punkt meines Programms eine Verlangsamung feststelle. Ich denke irgendwie, wenn ich 2 Prozessoren benutze, wird mein Programm wahrscheinlich langsamer ausgeführt, weil zwei Prozessoren miteinander "kommunizieren" müssen. Ich muss ein paar Tests machen. Ich werde versuchen, einen der Prozessoren zu deaktivieren und zu sehen, was passiert.
===================================
Ich bin mir nicht sicher, ob es sich um eine C # -Frage handelt, wahrscheinlich eher um Hardware, aber ich denke, C # ist am besten geeignet.
Ich habe einen billigen DL120-Server verwendet und mich für ein Upgrade auf einen viel teureren DL360p-Server mit zwei Prozessoren entschieden. Unerwartet arbeitet mein C # -Programm auf neuen Servern ca. 2-mal langsamer, was vermutlich mehrere Male schneller sein soll.
Ich habe verarbeitetSCHNELL Daten für ca. 60 Instrumente. Ich habe für jedes Instrument eine eigene Aufgabe angelegt:
BlockingCollection<OrderUpdate> updatesQuery;
if (instrument2OrderUpdates.ContainsKey(instrument))
{
updatesQuery = instrument2OrderUpdates[instrument];
} else
{
updatesQuery = new BlockingCollection<OrderUpdate>();
instrument2OrderUpdates[instrument] = updatesQuery;
ScheduleFastOrdersProcessing(updatesQuery);
}
orderUpdate.Checkpoint("updatesQuery.Add");
updatesQuery.Add(orderUpdate);
}
private void ScheduleFastOrdersProcessing(BlockingCollection<OrderUpdate> updatesQuery)
{
Task.Factory.StartNew(() =>
{
Instrument instrument = null;
OrderBook orderBook = null;
int lastRptSeqNum = -1;
while (!updatesQuery.IsCompleted)
{
OrderUpdate orderUpdate;
try
{
orderUpdate = updatesQuery.Take();
} catch(InvalidOperationException e)
{
Log.Push(LogItemType.Error, e.Message);
continue;
}
orderUpdate.Checkpoint("received from updatesQuery.Take()");
......................
...................... // long not interesting processing code
}, TaskCreationOptions.LongRunning);
Da ich ungefähr 60 Aufgaben habe, die parallel ausgeführt werden können, erwarte ich, dass 2 * E5-2640 (24 virtuelle Threads, 12 reale Threads) viel schneller ausgeführt werden sollten als 1 * E3-1220 (4 reale Threads). Es scheint, dass ich mit DL360p 95 Threads im Task-Manager gefunden habe. Mit DL120 habe ich nur 55 Threads.
Aber die Ausführungszeit auf DL120G7 ist 2 (!!) mal schneller! E3-1220 hat eine etwas bessere Taktrate als E5-2640 (3,1 GHz vs 2,5 GHz), ich erwarte jedoch weiterhin, dass mein Code auf 2 * E5-2640 schneller funktioniert, da er viel besser parallelisiert werden kann und ich absolut nicht erwarte dass es 2 mal langsamer geht!
~ 50 Threads im Task-Manager am besten = 24 durchschnittlich ~ 80 Mikrosekunden
calling market.UpdateFastOrder = 23 updatesQuery.Add = 25 received from updatesQuery.Take() = 67 in orderbook = 80
calling market.UpdateFastOrder = 30 updatesQuery.Add = 32 received from updatesQuery.Take() = 64 in orderbook = 73
calling market.UpdateFastOrder = 31 updatesQuery.Add = 32 received from updatesQuery.Take() = 195 in orderbook = 204
calling market.UpdateFastOrder = 31 updatesQuery.Add = 32 received from updatesQuery.Take() = 74 in orderbook = 86
calling market.UpdateFastOrder = 18 updatesQuery.Add = 21 received from updatesQuery.Take() = 65 in orderbook = 78
calling market.UpdateFastOrder = 29 updatesQuery.Add = 32 received from updatesQuery.Take() = 76 in orderbook = 88
calling market.UpdateFastOrder = 30 updatesQuery.Add = 32 received from updatesQuery.Take() = 80 in orderbook = 92
calling market.UpdateFastOrder = 20 updatesQuery.Add = 21 received from updatesQuery.Take() = 65 in orderbook = 78
calling market.UpdateFastOrder = 21 updatesQuery.Add = 24 received from updatesQuery.Take() = 68 in orderbook = 81
calling market.UpdateFastOrder = 12 updatesQuery.Add = 13 received from updatesQuery.Take() = 58 in orderbook = 72
calling market.UpdateFastOrder = 22 updatesQuery.Add = 23 received from updatesQuery.Take() = 51 in orderbook = 59
calling market.UpdateFastOrder = 16 updatesQuery.Add = 16 received from updatesQuery.Take() = 20 in orderbook = 24
calling market.UpdateFastOrder = 28 updatesQuery.Add = 31 received from updatesQuery.Take() = 82 in orderbook = 94
calling market.UpdateFastOrder = 18 updatesQuery.Add = 21 received from updatesQuery.Take() = 65 in orderbook = 77
calling market.UpdateFastOrder = 29 updatesQuery.Add = 29 received from updatesQuery.Take() = 259 in orderbook = 264
calling market.UpdateFastOrder = 49 updatesQuery.Add = 52 received from updatesQuery.Take() = 99 in orderbook = 113
calling market.UpdateFastOrder = 22 updatesQuery.Add = 23 received from updatesQuery.Take() = 50 in orderbook = 60
calling market.UpdateFastOrder = 29 updatesQuery.Add = 32 received from updatesQuery.Take() = 76 in orderbook = 88
calling market.UpdateFastOrder = 16 updatesQuery.Add = 19 received from updatesQuery.Take() = 63 in orderbook = 75
calling market.UpdateFastOrder = 27 updatesQuery.Add = 27 received from updatesQuery.Take() = 226 in orderbook = 231
calling market.UpdateFastOrder = 15 updatesQuery.Add = 16 received from updatesQuery.Take() = 35 in orderbook = 42
calling market.UpdateFastOrder = 18 updatesQuery.Add = 21 received from updatesQuery.Take() = 66 in orderbook = 78
~ 95 Threads im Task-Manager; best = 40 Durchschnitt ~ 150 Mikrosekunden
calling market.UpdateFastOrder = 62 updatesQuery.Add = 64 received from updatesQuery.Take() = 144 in orderbook = 205
calling market.UpdateFastOrder = 27 updatesQuery.Add = 32 received from updatesQuery.Take() = 101 in orderbook = 154
calling market.UpdateFastOrder = 45 updatesQuery.Add = 50 received from updatesQuery.Take() = 124 in orderbook = 187
calling market.UpdateFastOrder = 46 updatesQuery.Add = 51 received from updatesQuery.Take() = 127 in orderbook = 162
calling market.UpdateFastOrder = 63 updatesQuery.Add = 68 received from updatesQuery.Take() = 137 in orderbook = 174
calling market.UpdateFastOrder = 53 updatesQuery.Add = 55 received from updatesQuery.Take() = 133 in orderbook = 171
calling market.UpdateFastOrder = 44 updatesQuery.Add = 46 received from updatesQuery.Take() = 131 in orderbook = 158
calling market.UpdateFastOrder = 37 updatesQuery.Add = 39 received from updatesQuery.Take() = 102 in orderbook = 140
calling market.UpdateFastOrder = 45 updatesQuery.Add = 50 received from updatesQuery.Take() = 115 in orderbook = 154
calling market.UpdateFastOrder = 50 updatesQuery.Add = 55 received from updatesQuery.Take() = 133 in orderbook = 160
calling market.UpdateFastOrder = 26 updatesQuery.Add = 50 received from updatesQuery.Take() = 99 in orderbook = 111
calling market.UpdateFastOrder = 14 updatesQuery.Add = 30 received from updatesQuery.Take() = 36 in orderbook = 40 <-- best one I can find among thousands
Können Sie sehen, warum mein Programm auf einem mehrfach schnelleren Server zweimal langsamer ausgeführt wird? Wahrscheinlich sollte ich keine ~ 60 Aufgabe erstellen? Wahrscheinlich sollte ich .NET anweisen, 95 Threads nicht zu verwenden, sondern auf 50 oder sogar 24 zu beschränken? Vermutlich handelt es sich um ein Problem mit 2 Prozessoren gegenüber 1 Prozessor? Wenn Sie wahrscheinlich nur einen der Prozessoren meines DL360P Gen8 deaktivieren, wird das Programm erheblich beschleunigt?
Hinzugefügt
Aufruf von market.UpdateFastOrder - orderUpdate-Objekt wird erstelltupdatesQuery.Add - orderUpdate wird in BlockingCollection abgelegtempfangen von updatesQuery.Take () - orderUpdate aus BlockingCollection ausgeworfenin orderbook - orderUpdated wird analysiert und auf orderBook angewendet