using System;
using System.IO;
using System.Threading;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using structure_lib=lcpi.lib.structure;
using xdb=lcpi.data.oledb;

namespace Sample_024{
////////////////////////////////////////////////////////////////////////////////
//class Program

class Program
{
 public const string c_prog_arg__cn_str       = "cn_str";
 public const string c_prog_arg__thread_count = "thread_count";
 public const string c_prog_arg__rec_num      = "rec_num";
 public const string c_prog_arg__log_file     = "log_file";
 public const string c_prog_arg__summary_file = "summary_file";

 //-----------------------------------------------------------------------
 private static int Main()
 {
  int result = 0;

  try
  {
   result=Exec();
  }
  catch(Exception e)
  {
   ++result;
   Console.WriteLine("ERROR: {0}",e.Message);
  }//catch

  return result;
 }//Main

 //-----------------------------------------------------------------------
 private static int Exec()
 {
  int errCount=0;

  var cmdArgs = new structure_lib.t_command_line_parser('/');

  cmdArgs.reg_arg
   (c_prog_arg__cn_str,
    structure_lib.t_command_line_argument_flags.with_value);

  cmdArgs.reg_arg
   (c_prog_arg__thread_count,
    structure_lib.t_command_line_argument_flags.with_value);

  cmdArgs.reg_arg
   (c_prog_arg__rec_num,
    structure_lib.t_command_line_argument_flags.with_value);

  cmdArgs.reg_arg
   (c_prog_arg__log_file,
    structure_lib.t_command_line_argument_flags.with_value);

  cmdArgs.reg_arg
   (c_prog_arg__summary_file,
    structure_lib.t_command_line_argument_flags.with_value);

  //-----------------------------------
  cmdArgs.parse(Environment.CommandLine);

  //-----------------------------------
  string Arg_log_file
   =cmdArgs.get(c_prog_arg__log_file,true).Value;

  var log=new ProgramLog(Arg_log_file);
 
  try
  {
   log.Send("Hello from test!");

   //-----------------------------------
   var startupData=new StartupData(cmdArgs);

   log.Send("CommandLine: {0}",Environment.CommandLine);
   log.Send("Threads    : {0}",startupData.m_arg__thread_count);
   log.Send("Records    : {0}",startupData.m_arg__rec_num);

   //-----------------------------------
   log.Send("Try to connect to database ...");

   using(var cn=new xdb.OleDbConnection(startupData.m_arg__cn_str))
   {
    cn.Open();

    using(var tr=cn.BeginTransaction())
    {
     var cmd=new xdb.OleDbCommand("delete from TEST_SEQUENTIAL_MOVE",cn,tr);

     cmd.ExecuteNonQuery();
  
     tr.Commit();
    }//using tr

    log.Send("OK!");
   }//using cn

   //---------------------------------- create workers
   log.Send("Create workers ...");

   var workers=new ThreadWorker[startupData.m_arg__thread_count];
  
   {
    var generator=new GeneratorSeq(startupData);

    for(uint i=0;i!=startupData.m_arg__thread_count;++i)
     workers[i]=new ThreadWorker(startupData,i,generator);
   }//local

   //----------------------------------
   log.Send("Create threads ...");

   var threads=new System.Threading.Thread[startupData.m_arg__thread_count];
   
   DateTime startTS;

   try
   {
    for(uint i=0;i!=startupData.m_arg__thread_count;++i)
    {
     var t=new System.Threading.Thread(workers[i].Run);

     t.Start();

     workers[i].m_InitEvent.WaitOne();

     threads[i]=t;
    }//for i

    startTS=DateTime.Now;

    startupData.m_StartEvent.Set();
   }
   finally
   {
    for(uint i=0;i!=startupData.m_arg__thread_count;++i)
    {
     if(!Object.ReferenceEquals(threads[i],null))
     {
      log.Send("Wait thread {0}",i+1);

      threads[i].Join();

      if(!Object.ReferenceEquals(workers[i].m_exc,null))
      {
       ++errCount;

       log.Send("ERROR: {0} - {1}",workers[i].m_exc.Source,workers[i].m_exc.Message);
      }
     }//if
    }//for i
   }//finally

   var endTS=DateTime.Now;

   long duration=(long)(endTS-startTS).Duration().TotalSeconds;

   log.Send("Duration: {0} second(s).",duration);

   //----------------------------------
   {
    ulong n=0;

    for(uint i=0;i!=startupData.m_arg__thread_count;++i)
    {
     n+=workers[i].m_cRecords;

     log.Send("Thread [{0}]: {1:###} record(s)",i,workers[i].m_cRecords);
    }
   
    if(n!=(ulong)startupData.m_arg__rec_num)
    {
     throw new ApplicationException(string.Format("Wrong work. Inserted {0}. Expected {1}",
                                    n,
                                    startupData.m_arg__rec_num));
    }//if
   }//local
    
   //----------------------------------
   using(var sf=new StreamWriter(cmdArgs.get(c_prog_arg__summary_file,true).Value,true))
   {
    sf.WriteLine("{0}\t{1}\t{2}",
                 startupData.m_arg__rec_num,
                 startupData.m_arg__thread_count,
                 duration);

    sf.Close();
   }
  }
  finally
  {
   log.Close();
  }//finally

  return errCount;
 }//Exec
}//class Program

////////////////////////////////////////////////////////////////////////////////
//class ProgramLog

class ProgramLog
{
 public ProgramLog(string logFileName)
 {
  m_log_file=new StreamWriter(logFileName,false);
 }

 public void Send(string s,params object[] args)
 {
  string line=string.Format(s,args);

  line=Helper__BuildTS()+" "+line;

  Console.WriteLine("{0}",line);

  m_log_file.WriteLine("{0}",line);
 }//Send

 public void Close()
 {
  m_log_file.Close();
 }//Close

 private static string Helper__BuildTS()
 {
  var ts=DateTime.Now;

  return ts.ToString("[dd.mm.yyyy hh:mm:ss]");
 }

 private StreamWriter m_log_file;
};//class ProgramLog

////////////////////////////////////////////////////////////////////////////////
//class StartupData

class StartupData
{
 public readonly string m_arg__cn_str;
 public readonly uint   m_arg__thread_count;
 public readonly long   m_arg__rec_num;

 public readonly ManualResetEvent m_StartEvent;

 public StartupData(structure_lib.t_command_line_parser cmdArgs)
 {
  m_arg__cn_str=cmdArgs.get(Program.c_prog_arg__cn_str,true).Value;

  //-----------------------------------
  m_arg__thread_count
   =uint.Parse(cmdArgs.get(Program.c_prog_arg__thread_count,true).Value);

  if(m_arg__thread_count==0)
   throw new ApplicationException("Incorrect number of threads");

  //-----------------------------------
  m_arg__rec_num
   =long.Parse(cmdArgs.get(Program.c_prog_arg__rec_num,true).Value);
 
  if(m_arg__rec_num<=m_arg__thread_count)
   throw new ApplicationException("Incorrect number of records");

  //-----------------------------------
  m_StartEvent=new ManualResetEvent(false);
 }//StartupData

 //------------------------------------
 public bool GenNum(out long v)
 {
  v=Interlocked.Increment(ref m_rec_num);

  if(m_arg__rec_num<v)
   return false;

  return true;
 }//GenNum
   
 //------------------------------------
 private long m_rec_num=0;
};//class StartupData

////////////////////////////////////////////////////////////////////////////////
//interface Generator

interface Generator
{
 bool Gen(out long v);
};//interface Generator

 ////////////////////////////////////////////////////////////////////////////////
//class GeneratorSeq

class GeneratorSeq:Generator
{
 public GeneratorSeq(StartupData startupData)
 {
  m_StartupData=startupData;
 }

 //interface -------------------------------------------------------------
 public bool Gen(out long v)
 {
  return m_StartupData.GenNum(out v);
 }//Gen

 private readonly StartupData m_StartupData;
};//class GeneratorSeq

////////////////////////////////////////////////////////////////////////////////
//class ThreadWorker

class ThreadWorker
{
 public Exception m_exc=null;

 public readonly StartupData m_StartupData;

 public readonly Generator m_Generator;

 public readonly ManualResetEvent m_InitEvent;

 public readonly uint m_ThreadIndex;

 public ulong m_cRecords=0;

 public ThreadWorker(StartupData startupData,
                     uint        index,
                     Generator   generator)
 {
  m_StartupData=startupData;

  m_Generator=generator;

  m_InitEvent=new ManualResetEvent(false);

  m_ThreadIndex=index;
 }//ThreadWorker

 public void Run()
 {
  try
  {
   using(var cn=new xdb.OleDbConnection(m_StartupData.m_arg__cn_str))
   {
    cn.Open();

    using(var tr=cn.BeginTransaction())
    {
     using(var cmd=new xdb.OleDbCommand(null,cn,tr))
     {
      cmd.CommandText=
       "insert into TEST_SEQUENTIAL_MOVE (ID) values(:id)";

      cmd.Prepare();

      m_InitEvent.Set();

      m_StartupData.m_StartEvent.WaitOne(); //infinite!

      long v;
  
      while(m_Generator.Gen(out v))
      {
       cmd[0].Value=v;

       cmd.ExecuteNonQuery();

       ++m_cRecords;
      }//while
     }//using cmd
     tr.Commit();
    }//using tr
   }//using cn
  }
  catch(Exception e)
  {
   m_exc=e;
  }//catch
 }//Run
};//class ThreadWorker

////////////////////////////////////////////////////////////////////////////////
}//namespace Sample_024

copy /Y d:\Database\FB_03_0_0\__clear\IBP_TEST_FB30_D3.GDB d:\Database\ram\IBP_TEST_FB30_D3.GDB

bin\vs2017_net46.2_Release\Sample_024.exe /cn_str "provider=LCPI.IBProvider.3;location=localhost:d:\database\ram\ibp_test_fb30_d3.gdb;user id=GAMER;password=vermut;dbclient_type=fb.direct" /thread_count %1 /rec_num %2 /log_file _logs\result_%1_%2.log /summary_file _logs\summary.log

call run1.bat 1  %1
call run1.bat 2  %1
call run1.bat 4  %1
call run1.bat 8  %1
call run1.bat 10 %1
call run1.bat 20 %1

[17.09.2017 04:09:48] Hello from test!
[17.09.2017 04:09:48] CommandLine: bin\vs2017_net46.2_Release\Sample_024.exe  /cn_str "provider=LCPI.IBProvider.3;location=localhost:d:\database\ram\ibp_test_fb30_d3.gdb;user id=GAMER;password=vermut;dbclient_type=fb.direct" /thread_count 8 /rec_num 10000000 /log_file _logs\result_8_10000000.log /summary_file _logs\summary.log
[17.09.2017 04:09:48] Threads    : 8
[17.09.2017 04:09:48] Records    : 10000000
[17.09.2017 04:09:48] Try to connect to database ...
[17.09.2017 04:09:48] OK!
[17.09.2017 04:09:48] Create workers ...
[17.09.2017 04:09:48] Create threads ...
[17.09.2017 04:09:49] Wait thread 1
[17.15.2017 04:15:08] Wait thread 2
[17.15.2017 04:15:08] Wait thread 3
[17.15.2017 04:15:08] Wait thread 4
[17.15.2017 04:15:08] Wait thread 5
[17.15.2017 04:15:08] Wait thread 6
[17.15.2017 04:15:08] Wait thread 7
[17.15.2017 04:15:08] Wait thread 8
[17.15.2017 04:15:08] Duration: 319 second(s).
[17.15.2017 04:15:08] Thread [0]: 1113156 record(s)
[17.15.2017 04:15:08] Thread [1]: 1147915 record(s)
[17.15.2017 04:15:08] Thread [2]: 1183818 record(s)
[17.15.2017 04:15:08] Thread [3]: 1222949 record(s)
[17.15.2017 04:15:08] Thread [4]: 1263065 record(s)
[17.15.2017 04:15:08] Thread [5]: 1305448 record(s)
[17.15.2017 04:15:08] Thread [6]: 1353977 record(s)
[17.15.2017 04:15:08] Thread [7]: 1409672 record(s)