TCPIdCmdServer langer Delay bei vielen Anfragen

[sonny2007]

Hallo Zusammen,

folgendes Ziel bereitet mir aktuell ein wenig Probleme.

Tcp Indy CommandServer mit mehreren TcpIdClient.

auf dem server wurde folgendes record deklariert.

Delphi-Quellcode:

type
  TClient = record
    sName: string[50];
    Profession : integer;
    CurValue: Cardinal;
    aContext : TIdContext;
  end;

Mit diesem Record habe ich ein array erstellt.

Delphi-Quellcode:

 arClients : array of TClient;

Von jedem Client der sich connected wird der Context im Array abgelegt.

Delphi-Quellcode:

procedure TfrmServerMain.TCPIdCmdServerConnect(AContext: TIdContext);
var
  iKnownClient : integer;
  i: Integer;
begin
  iKnownClient := -1;
  for i := 0 to High(arClients) do
    if arClients[i].aContext.Binding.PeerIP = AContext.Binding.PeerIP then
      iKnownClient := i;

  if AContext.Connection.Connected and (iKnownClient = -1) then
  begin
    SetLength(arClients,Length(arClients)+1);
    arClients[Length(arClients)-1].sName := '';
    arClients[Length(arClients)-1].aContext := AContext;
    mmoConClients.Lines.Add(AContext.Binding.IP);
    mmoServerMsg.Lines.Add('Client connected: '+AContext.Binding.IP);
  end;
 FillClientMemo;
end;

Jetzt zu meiner Frage. Jeder Client überträgt im 50-200ms Abstand einen Wert der dann an alle verteilt werden soll.
Aktuelle löse ich es so.

Delphi-Quellcode:

  sName := ASender.Params[0];
  TryStrToInt(ASender.Params[1],iDpsValue);

  for i := 0 to High(arClients) do
    if arClients[i].aContext = ASender.Context then
    begin
      CritSection.Enter;
      arClients[i].CurDpsValue := iDpsValue;
      CritSection.Leave;
    end;

  SetLength(arStreamClientdata,Length(arClients));
  for i := 0 to High(arClients) do
    begin
      arStreamClientdata[i].sName := arClients[i].sName;
      arStreamClientdata[i].iProfession := arClients[i].Profession;
      arStreamClientdata[i].CurDpsValue := arClients[i].CurDpsValue;
    end;

  ms := TMemoryStream.Create;
  Try
    for i := 0 to High(arStreamClientdata) do //Schreiben der Elemente aus dem Array in den Stream
      ms.Write(arStreamClientdata[i], SizeOf(arStreamClientdata[i]));
    ASender.Context.Connection.IOHandler.LargeStream := true;
    ASender.Context.Connection.IOHandler.WriteLn('201 Data follows');
    ms.Position := 0;
    ASender.Context.Connection.IOHandler.Write( ms, 0, True );
  Finally
    ms.Free;
  End;

Mit jedem Clienten wird diese Aufgabe immer langsamer bis es dann bis zu 1sec delay kommt.

Welcher Ansatz ist hier der Richtige? Threaded Indy wenn ein Cmd ausgeführt wird?
Welche Möglichkeiten gibt es, das im WorstCase, alle Clienten gleichzeitig Daten senden können, ohne einen Delay zu erzeugen ?

Grüße
sOn

[Bambini]

Die Schleife des Verteilens sehe ich nicht im Code, ich vermute du machst das sequenziell.
Je größer die Anzahl der Clients, desto länger wird es dauern bis an alle nicht Daten verschickt worden sind.

Der Ansatz wäre, dieses in Threads zu erledigen. Dann können an mehrere gleichzeitig die Daten verschickt werden.
Hier muss man aber sehr auf gleichzeitigen Zugriff achten, bzw. sich voreinander schützen.

Schon alleine dein Code:

Delphi-Quellcode:

...
if AContext.Connection.Connected and (iKnownClient = -1) then
  begin
    SetLength(arClients,Length(arClients)+1);
    arClients[Length(arClients)-1].sName := '';
...

ist nicht sicher. Diese Methode wird vom TidTcpipServer aus einem Thread gerufen.
D.h. wird zeitgleich aufgerufen, wenn Clients sind zeitgleich verbinden.
Ein SetLength() und deren Length() Verwendung kann dann schief gehen!

Ab XE7 gibt es in Delphi eine Unit mit welcher man recht komfortabel parallele Schleifen bauen kann:
https://www.delphi-treff.de/tutorial...lel-library/2/

Geht aber natürlich auch mit ältere Versionen, dann dort aber zu Fuß per TThread's oder mit anderen Libraries.