iTask - how to use variables as parameters to TTask procedure

See also questions close to this topic

• Multi-threaded Conway's Game of Life in C++ occasionally hitching?

  For practice I've implemented Conways' Game of Life in C++ with updates to the "world" being handled with parallel processing. I'm using SFML for graphics.

  Adding multi-threading definitely made it run faster (at least on this 4-core machine) but I noticed it has issues. If I run it in a Debug configuration from Visual Studio 2017 it seems to start very slow, but after running for 2 seconds it suddenly gets faster and runs smoothly. But if I run it in Release configuration then it runs even faster than Debug did but every half a second or so it "hitches" or stutters and doesn't run smoothly like I expected.

  What could be causing these two behavior issues and how can I fix them?

  GameOfLife.cpp:

  #include "GameOfLife.h"
  #include <iostream>
  #include <vector>
  #include <math.h>
  #include <thread>
  #include <mutex>
  #include <SFML/Graphics.hpp>
  
  class GameOfLife
  {
  public:
      GameOfLife(int sizeX, int sizeY);
      uint8_t & getCell(int x, int y);
      sf::Vector2i get2D(int i);
      void doUpdate(int start, int end);
      virtual ~GameOfLife() = default;
      void update();
      std::vector<sf::Vector2i> getLiveCells();
  
  private:
      std::vector<uint8_t> world;
  };
  
  std::mutex updateListLock;
  std::vector<sf::Vector2i> pendingUpdates;
  sf::Vector2i worldSize;
  
  GameOfLife::GameOfLife(int sizeX, int sizeY)
  {
      worldSize = sf::Vector2i(sizeX, sizeY);
  
      // initialize world to specified size, all starting as dead
      world = std::vector<uint8_t>(sizeX * sizeY, 0);
  
      // reserve space for worst case (every cell needs to be updated)
      pendingUpdates.reserve(sizeX * sizeY);
  
      // place a glider
      getCell(1, 3) = true;
      getCell(2, 4) = true;
      getCell(3, 2) = true;
      getCell(3, 3) = true;
      getCell(3, 4) = true;
  
      // place a glider at top-center
      int midX = std::floor(worldSize.x / 2);
      getCell(midX + 1, 3) = true;
      getCell(midX + 2, 4) = true;
      getCell(midX + 3, 2) = true;
      getCell(midX + 3, 3) = true;
      getCell(midX + 3, 4) = true;
  }
  
  uint8_t& GameOfLife::getCell(int x, int y)
  {
      return world[y * worldSize.x + x];
  }
  
  sf::Vector2i GameOfLife::get2D(int index)
  {
      int y = std::floor(index / worldSize.x);
      int x = index % worldSize.x;
      return sf::Vector2i(x, y);
  }
  
  // Update the cells from position start (inclusive) to position end (exclusive).
  void GameOfLife::doUpdate(int start, int end)
  {
      for (int i = start; i < end; i++)
      {
          auto pos = get2D(i);
  
          // # of alive neighbors
          int aliveCount = 0;
  
          // check all 8 surrounding neighbors
          for (int nX = -1; nX <= 1; nX++) // nX = -1, 0, 1
          {
              for (int nY = -1; nY <= 1; nY++) // nY = -1, 0, 1
              {
                  // make sure to skip the current cell!
                  if (nX == 0 && nY == 0)
                      continue;
  
                  // wrap around to other side if neighbor would be outside world
                  int newX = (nX + pos.x + worldSize.x) % worldSize.x;
                  int newY = (nY + pos.y + worldSize.y) % worldSize.y;
  
                  aliveCount += getCell(newX, newY);
              }
          }
  
          // Evaluate game rules on current cell
          switch (world[i]) // is current cell alive?
          {
          case true:
              if (aliveCount < 2 || aliveCount > 3)
              {
                  std::lock_guard<std::mutex> lock(updateListLock);
                  pendingUpdates.push_back(pos); // this cell will be toggled to dead
              }
              break;
  
          case false:
              if (aliveCount == 3)
              {
                  std::lock_guard<std::mutex> lock(updateListLock);
                  pendingUpdates.push_back(pos); // this cell will be toggled to alive
              }
              break;
          }
      }
  }
  
  void GameOfLife::update()
  {
      unsigned maxThreads = std::thread::hardware_concurrency();
  
      // divide the grid into horizontal slices
      int chunkSize = (worldSize.x * worldSize.y) / maxThreads;
  
      // split the work into threads
      std::vector<std::thread> threads;
      for (int i = 0; i < maxThreads; i++)
      {
          int start = i * chunkSize;
  
          int end;
          if (i == maxThreads - 1) // if this is the last thread, endPos will be set to cover remaining "height"
              end = worldSize.x * worldSize.y;
          else
              end = (i + 1) * chunkSize;
  
          std::thread t([this, start, end] {
              this->doUpdate(start, end);
          });
  
          threads.push_back(std::move(t));
      }
  
      for (std::thread & t : threads) {
          if (t.joinable())
              t.join();
      }
  
      // apply updates to cell states
      for each (auto loc in pendingUpdates)
      {
          // toggle the dead/alive state of every cell with a pending update
          getCell(loc.x, loc.y) = !getCell(loc.x, loc.y);
      }
  
      // clear updates
      pendingUpdates.clear();
  }
  
  std::vector<sf::Vector2i> GameOfLife::getLiveCells()
  {
      std::vector<sf::Vector2i> liveCells;
      liveCells.reserve(worldSize.x * worldSize.y); // reserve space for worst case (every cell is alive)
  
      for (int i = 0; i < worldSize.x * worldSize.y; i++) {
          auto pos = get2D(i);
          if (world[i])
              liveCells.push_back(sf::Vector2i(pos.x, pos.y));
      }
  
      return liveCells;
  }
  
• How to have my defined refresh function running in the background of my twisted server

  I have a simple twisted TCP server running absolutely fine, it basically deals with database requests and displays the right things its just an echo client with a bunch of functions, the database that is being read also updates I have this refresh function to open the database and refresh it however if I add this to the message functions it'll take too long to respond as the refresh function takes around 6/7 seconds to complete, my initial idea was to have this function in a while loop and running constantly refreshing every 5/10 mins but after reading about the global interpreter lock its made me think that that isn't possible, any suggestions on how to run this function in the background of my code would be greatly appreciated

  I've tried having it in a thread but it doesn't seem to run at all when I start the thread, I put it under the if name == 'main': function and no luck!

  Here is my refresh function

  def refreshit()
      Application = win32com.client.Dispatch("Excel.Application")
      Workbook = Application.Workbooks.open(database)
      Workbook.RefreshAll()
      Workbook.Save()
      Application.Quit()
      xlsx = pd.ExcelFile(database)
      global datess
      global refss
      df = pd.read_excel(xlsx, sheet_name='Sheet1')
      datess = df.groupby('documentDate')
      refss = df.groupby('reference')
  
  
  class Echo(Protocol):
      global Picked_DFS
      Picked_DFS = None
      label = None
      global errors
      global picked
      errors = []
      picked = []
      def dataReceived(self, data):
          """
          As soon as any data is received, write it back.
          """
          response = self.handle_message(data)
          print('responding with this')
          print(response)
          self.transport.write(response)
  
  def main():
      f = Factory()
      f.protocol = Echo
      reactor.listenTCP(8000, f)
      reactor.run()
  
  if __name__ == '__main__':
      main()
  

  I had tried this to no avail

  if __name__ == '__main__':
      main()
      thread = Thread(target = refreshit())
      thread.start()
      thread.join()
  
• Wait for spark server execution if tests

  I am trying to write simple test for my app. This test required another server (around spark).

  I run this server via:

  public MyServer(int port, Route route) {
      this.port = port;
      this.route = route;
      this.executorService = Executors.newSingleThreadExecutor();
      this.executorService.submit(this);
  }
  

  And run method:

  Spark.port(this.port);
  Spark.post("/myServer", "application/json", route);
  

  My custom implementation of spark.Route are very simple and looks like this:

  public class MyRoute implements Route {
  @Override
  public Object handle(Request request, Response response) throws Exception {
      return "some response";
  }
  

  }

  The problem i facing with is when i run my test like:

  MyServer myServer = new MyServer("1111", new MyRoute());
  

  My test ends right after:

  Spark.post("/myServer", "application/json", route);
  

  String. All waht i need is that server continue working untill i stop server.

  I tryed to set thread option daemon to true, but that do nothing.

  How can i start spark server and be sure, that it will work untill i call

  Spark.stop();
  
• Access violation when freeing form

  I'm backing up a database using Devart controls. Everything runs fine until I try to free the form having the backup component(TDump) and a progress bar on it. I moved the call to the finally portion of code and checked if it was assigned before trying to free it still same problem

  procedure TfrmMain.CmdBackupExecute(Sender: TObject);
  var
      SaveDialog: TSaveDialog;
      QRYString: String;
      frmBackup: TfrmBackup;
      Password: String;
      BackupPassword: String;
      MasterPassword: String;
      CurrentFrame: TFrameType;
      OldUser: String;
      OldPassword: String;
  begin
      dmVintage.tblSettings.Open;
      BackupPassword:= dmVintage.tblSettings.FieldByName('BackupRestorePWord').AsString;
      MasterPassword:= dmVintage.tblSettings.FieldByName('MasterPWord').AsString;
      InputPassword('Enter Backup Password', Password);
          if Password = BackupPassword then
              try
                  try
                      //close current frame and change to root
                      CurrentFrame:= FrameManager.CurrentFrameType;
                      FrameManager.Clear;
                      dmVintage.connMain.LoginPrompt:= False;
                      OldUser:= dmVintage.connMain.Username;
                      OldPassword:= dmVintage.connMain.Password;
                      dmVintage.connMain.Connected:= False;
                      dmVintage.connMain.Username:= 'root';
                      dmVintage.connMain.Password:= MasterPassword;
                      dmVintage.connMain.Connect;
                      SaveDialog:= TsaveDialog.Create(frmMain);
                      SaveDialog.Filter := 'SQL file|*.sql';
                      SaveDialog.DefaultExt:= '.sql';
                      SaveDialog.FileName:= 'VintageData';
                      if SaveDialog.Execute then
                          begin
                           frmBackup:= TfrmBackup.Create(frmMain);
                           frmBackup.Show;
                           frmBackup.mdVintage.BackupToFile(AddTimestampToFilename(SaveDialog.FileName), QryString);
                           //FreeAndNil(frmBackup);
                           //FreeAndNil(SaveDialog);
                           dlgI('Backup Seccessful');
                          end;
                  Except on E: Exception do
                      dlgW2('TfrmMain.CmdBackupExecute', E.Message);
                    end;
              finally
                  //ShowMessage('Finally');
                  if Assigned(frmBackup) then
                    FreeAndNil(frmBackup);
                  if Assigned(SaveDialog) then
                    FreeAndNil(SaveDialog);
  
                  //reset connection and load old frame
                  dmVintage.connMain.Connected:= False;
                  dmVintage.connMain.Username:= OldUser;
                  dmVintage.connMain.Password:= OldPassword;
                  dmVintage.connMain.Connect;
                  dmVintage.connMain.LoginPrompt:= True;
                  FrameManager.LoadFrame(CurrentFrame);
              end
          else
            dlgE('Invalid Backup Password');
  end;
  
  function TfrmMain.AddTimestampToFilename(Value: String): String;
  var
    Extension: String;
    FileName: String;
    FormattedDataTime: String;
  begin
    Extension:= ExtractFileExt(Value);
    FileName:= ChangeFileExt(Value, '');
    DateTimeToString(FormattedDataTime, 'yyyymmdd_hhmm', Now);
    FileName:= FileName + '_' + FormattedDataTime;
    Result:= ChangeFileExt(FileName, Extension);
  end;
  

  The Backup form is very simple with a few labels the TDump component and a progress bar.

  unit uBackup;
  
  interface
  
  uses
    Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
    Vcl.Controls, Vcl.Forms, Vcl.Dialogs, uDataVintage, DADump, MyDump,
    Vcl.ComCtrls, Vcl.StdCtrls;
  
  type
    TfrmBackup = class(TForm)
      mdVintage: TMyDump;
      lblBackingUpTable: TLabel;
      lblTable: TLabel;
      Label3: TLabel;
      pbBackup: TProgressBar;
      procedure mdVintageBackupProgress(Sender: TObject; ObjectName: string;
        ObjectNum, ObjectCount, Percent: Integer);
    private
      { Private declarations }
    public
      { Public declarations }
    end;
  
  
  
  implementation
  
  {$R *.dfm}
  
  procedure TfrmBackup.mdVintageBackupProgress(Sender: TObject;
    ObjectName: string; ObjectNum, ObjectCount, Percent: Integer);
  begin
    Application.ProcessMessages;
    if lblTable.Caption <> ObjectName then
      lblTable.Caption:= ObjectName;
    pbBackup.Position:= Percent;
  end;
  
  end.
  
• Is there an easy way to make that the design of my readonly TEdit will be the same as my disabled TEdit?

  how to make that the design (mostly font color) of my TMyedit (TmyEdit = Class(Tedit)) when they are in readonly will be exactly the same as if they was disabled?
• Indy TIdhttp.Get is not loading proper version of SSL

  I am trying to make an interface to FreshDesk API

  Here is my source code for the call:

  procedure TForm1.Button1Click(Sender: TObject);
  var
    IdSSLIOHandlerSocket1: TIdSSLIOHandlerSocketOpenSSL;
    idhttp:  TIdHttp;
  begin
    idhttp := TIdHttp.Create(self);
    idhttp.Request.ContentType := 'application/json';
    IdHTTP.Request.BasicAuthentication:= True;
    IdHTTP.Request.Username := 'marks@mytestcompany.com';
    IdHTTP.Request.Password := 'XYZ';
    idhttp.Request.Connection:='keep-alive';
    IdSSLIOHandlerSocket1 := TIdSSLIOHandlerSocketOpenSSL.create(nil);
    with IdSSLIOHandlerSocket1 do begin
      SSLOptions.Method := sslvTLSv1_2;
      SSLOptions.SSLVersions := [sslvTLSv1_2];
      SSLOptions.VerifyMode := [];
      SSLOptions.VerifyDepth := 2;
    end;
    idhttp.IOHandler := IdSSLIOHandlerSocket1;
    idhttp.Request.Accept := '*/*';
  
    idhttp.HandleRedirects := True;
    if usefiddler.checked then begin
      idhttp.ProxyParams.ProxyServer := '127.0.0.1';
      idhttp.ProxyParams.ProxyPort := 8888 ;
    end;
    showMessage(idhttp.get('https://mytestcompany.freshdesk.com/api/v2/contacts'));
  end;
  

  When I run using Fiddler it shows it is using Version: 3.1 (TLS/1.0):

  

  Here is successful curl call (it seems to be using Version: 3.3 (TLS/1.2):

  curl -v -u marks@mytestcompnay:XYZ -H "Content-Type: application/json" -X GET "https://mytestcompany.freshdesk.com/api/v2/contacts"
  

  Here is Fiddler results when using curl:

  

  Is my problem that I am using the wrong version of TLS?
• What are the possible causes where a task is successfully created, but it didn't get added to the queue in the Microsoft Dynamics CRM?

  When a task is successfully created it is supposed to be added to the queue of the thing that created that task. But what are the possible reasons that a task is not appearing in the queue?
• Find deadlock in Task.WhenAll

  I find the code snippet below has deadlock, although I already solved this problem by using read write lock, I still have no idea what exactly happens under the hood in Task.WhenAll that causes deadlock.

  Problematic code:

     public async static Task<Dictionary<string, Log4SerialPort>> AvailableLog4SerialPorts()
          {
              var ports = App.SerialPortService.GetAvailablePorts();
              await Task.WhenAll(ports.Select(async port =>
              {
                  if (!_availableLog4SerialPorts.ContainsKey(port.Path))
                  {
                      var log4Port = new Log4SerialPort(port);
                      var isValid = await log4Port.Verify();
                      if (isValid)
                      {
                          _availableLog4SerialPorts.Add(port.Path, log4Port);
                      }
  
                  }
              }));
              return _availableLog4SerialPorts;
          }
  

  By adding read write lock, problem solved:

     public async static Task<Dictionary<string, Log4SerialPort>> AvailableLog4SerialPorts()
          {
              var ports = App.SerialPortService.GetAvailablePorts();
              await Task.WhenAll(ports.Select(async port =>
              {
                  rwl.AcquireReaderLock(VERIFY_TIMEOUT);
                  if (!_availableLog4SerialPorts.ContainsKey(port.Path))
                  {
                      rwl.ReleaseReaderLock();
                      var log4Port = new Log4SerialPort(port);
                      var isValid = await log4Port.Verify();
                      if (isValid)
                      {
                          rwl.AcquireWriterLock(VERIFY_TIMEOUT);
                          _availableLog4SerialPorts.Add(port.Path, log4Port);
                          rwl.ReleaseWriterLock();
                      }
  
                  }
              }));
              return _availableLog4SerialPorts;
          }
  

  _availableLog4SerialPorts is a static field.

  log4Port.Verify() doesn't share any static resources, it just does some time-consuming tasks.

  It seems Task.WhenAll will lock the static resources automatically, but not sure how it works and the detailed blocking reason in this case.
• Using Task.Run to start a continuously running background job with a BlockingCollection

  I am using Task.Run to start a continuous background processing job on a BlockingCollection. It works but I don't think it's the ideal way to structure the code.

  This issue concerns the line: public async Task ProcessQueue(). I get a warning:

  This async method lacks 'await' operators and will run synchronously.

  If I remove async there is an error:

  'MessageProcessor.ProcessQueue()': not all code paths return a value

  This is reasonable because the compiler doesn't see that getConsumingEnumerable blocks. Should I use the async version and ignore this warning or restructure my code in a different way?

  Note: Imagine I have 100s of these MessageProcessor's, I don't think creating a separate thread for each of them would be an efficient use of memory hence my use of Task.Run.

  ---

  using System;
  using System.Collections.Concurrent;
  using System.Collections.Generic;
  using System.Threading;
  using System.Threading.Tasks;
  
  public class Message
  {
      public int id { get; set; }
      public int value { get; set; }
  }
  
  public class MessageProcessor
  {
      private CancellationToken token;
      private BlockingCollection<Message> messageQueue;
      private List<Message> processedMessageList;
  
      public MessageProcessor(CancellationToken token)
      {
          this.token = token;
          messageQueue = new BlockingCollection<Message>(new ConcurrentQueue<Message>());
          processedMessageList = new List<Message>(10);
      }
  
      public void Add(Message m)
      {
          if (!messageQueue.IsAddingCompleted)
          {
              messageQueue.Add(m);
          }
      }
  
      public void CompleteAdding()
      {
          messageQueue.CompleteAdding();
      }
  
      public async Task ProcessQueue()
      {
          foreach (Message m in messageQueue.GetConsumingEnumerable())
          {
              Console.WriteLine($"Processing. id: {m.id}, value: {m.value}");
              processedMessageList.Add(m);
  
          }
      }
  }
  
  class Program
  {
      static void Main(string[] args)
      {
          Random random = new Random();
          CancellationTokenSource tokenSource = new CancellationTokenSource();
          CancellationToken token = tokenSource.Token;
          MessageProcessor messageProcessor = new MessageProcessor(token);
  
          var messageProcessorResult = Task.Run(() => messageProcessor.ProcessQueue());
  
          for (int i = 0; i < 10; i++)
          {
              Message m = new Message();
              m.id = i;
              m.value = random.Next(-2, 2);
  
              Console.WriteLine($"Producing. id: {m.id}, value: {m.value}");
              messageProcessor.Add(m);
          }
  
          messageProcessor.CompleteAdding();
          messageProcessorResult.Wait();
      }
  }