Anton (Все сообщения пользователя)

------------------------------------------------------------------------------
--              'CONSTANTS' (Lua has no true constants, you know)           --
------------------------------------------------------------------------------

local inFileName = getScriptPath() .. '\\IN.lua'
local outFileName = getScriptPath() .. '\\OUT.lua'
local mainLoopTimeout = 500

------------------------------------------------------------------------------
--                               BUSINESS LOGIC                             --
------------------------------------------------------------------------------

local inSecList = nil

local function writeSecList()
   local f = io.open(outFileName, 'wb')
   if not f then
      error('Failed to open OUT.lua for write')
   end
   f:write('return {\r\n')
   if inSecList then
      for _, r in ipairs(inSecList) do
         f:write('\t{ classcode = "' .. (r.classcode or '') ..
            '", seccode = "' .. (r.seccode or '') .. '" },\r\n')
      end
   end
   f:write('}\r\n')
   f:flush()
   f:close()
end

-- called in main thread before the main loop
local function onMainInit()
   inSecList = dofile(inFileName)
   -- TODO: further initialization here
end

-- called in main thread on each time step
local function onTimeStep()
   -- TODO: your trading code here
end

-- called in main thread after the main loop 
local function onMainCleanup()
   writeSecList()
   -- TODO: further cleanup here
end

------------------------------------------------------------------------------
--    THE CODE BELOW SHOULD NOT BE EDITED UNLESS YOU FULLY UNDERSTAND IT    --
------------------------------------------------------------------------------

local runStatus = 0

function OnStop()
   assert(runStatus == 3, "Unexpected runStatus in OnStop: " .. runStatus)
   runStatus = runStatus - 1
   while runStatus == 2 do
      sleep(10)
   end
   runStatus = runStatus - 1
end

function main()
   onMainInit()
   runStatus = 3
   while runStatus == 3 do
      onTimeStep()
      sleep(mainLoopTimeout)
   end
   do
      local s, e = pcall(onMainCleanup)
      runStatus = runStatus - 1
      while runStatus == 1 do
         sleep(10)
      end
      if not s then error(e) end
   end
end

return {
   { classcode = "TQBR", seccode = "SBER" },
   { classcode = "TQBR", seccode = "GAZP" },
   { classcode = "TQBR", seccode = "GMKN" },
   { classcode = "SPBFUT", seccode = "RIZ1" },
}

-- COMMANDS
-----------

-- comment
message('Command 1')

-- another comment
local function cmd2(txt)
  message('Command 2: ' .. txt or '')
end

cmd2('hello')
cmd2('world')
-- cmd2('commented out')

-- SECURITIES
-------------

inSecList =
{
  { classcode = "TQBR", seccode = "SBER" },
  -- NOTE: the next line is commented out
  -- { classcode = "TQBR", seccode = "GAZP" },
  { classcode = "TQBR", seccode = "GMKN" },
  { classcode = "SPBFUT", seccode = "RIZ1" }
}

-- COMMANDS (again)
-------------------

message('Command 3')

require(GetScriptPath() .. '\\IN.lua')

local for_OnParam = 2
local N_OnParam = 0
IsRun = true

function OnParam(p1, p2)
   for i = 1, for_OnParam do 
      N_OnParam = N_OnParam + 1                                                                              
   end
end

function main()
   while IsRun do 
    do
      local OnParam_begin = N_OnParam   
      local J = 100000000   
      while ( J > 0  )   do   J = J - 1  end
      if N_OnParam ~= OnParam_begin then
         message ( ' Переключение колбека и потока main:  N_OnParam - OnParam_begin = ' .. tostring(N_OnParam - OnParam_begin))
      end      
   end
   sleep(10)  
   end
end   
   
function OnStop()
   IsRun = false
   return 10000   
end

#include <cstdio>
#include <intrin.h>
#include <process.h>
#include <Windows.h>

static const unsigned int NTHRD = 64;
static const unsigned int NITER = 10000000;
static volatile long cnt[NTHRD];

static unsigned int __stdcall RawLoopThread(void * pvoid)
{
   volatile long * pcnt = cnt + reinterpret_cast<unsigned int>(pvoid);
   *pcnt = 0;
   for(unsigned int n = 0; n < NITER; ++n)
      *pcnt = *pcnt + 1;
   return *pcnt;
}

static unsigned int __stdcall InterlockedLoopThread(void * pvoid)
{
   volatile long * pcnt = cnt + reinterpret_cast<unsigned int>(pvoid);
   *pcnt = 0;
   for(unsigned int n = 0; n < NITER; ++n)
      _InterlockedIncrement(pcnt);
   return *pcnt;
}

static void MeasureLoop(unsigned int (__stdcall * pfn)(void *), const char * name)
{
   unsigned long long t = ::GetTickCount64();
   HANDLE threads[NTHRD] = { 0 };
   for(unsigned int n = 0; n < NTHRD; ++n)
   {
      unsigned int tid;
      threads[n] = reinterpret_cast<HANDLE>(_beginthreadex(nullptr, 0,
         pfn, reinterpret_cast<void *>(n), CREATE_SUSPENDED, &tid));
   }
   for(unsigned int n = 0; n < NTHRD; ++n)
      ::ResumeThread(threads[n]);
   ::WaitForMultipleObjects(NTHRD, threads, TRUE, INFINITE);
   t = ::GetTickCount64() - t;
   for(unsigned int n = 0; n < NTHRD; ++n)
      ::CloseHandle(threads[n]);
   printf("  %s:\n    %0.9f seconds\n    %0.9f microseconds per iteration\n",
      name, t / 1000.0, t * 1000.0 / NITER);
}

void main(void)
{
   printf("Performance:\n");
   ::MeasureLoop(::RawLoopThread, "RawLoopThread");
   ::MeasureLoop(::InterlockedLoopThread, "InterlockedLoopThread");
   printf("Press ENTER to exit\n");
   getchar();
}

class Order
{
    void SendTransaction(...);
    virtual void OnTransReply(...);
    virtual void OnOrder(...);
};

class Order
{
    virtual void OnOrder(...);
};

class Transaction
{
    SendTransaction(...);
    virtual void OnTransReply(...);
};

io.open("\\\\.\\PIPE\\MySuperPuperServer", "wb")