Новые версии QUIK стали заметно устойчивее, чем это было в мае 2020г. Однако, нечасто, но в течении двух-трех суток версия QUIK 8.13, в которой запущен мой тест синхронизации в QLua, без подключения к серверу, зависает с выдачей сообщения: Critical error ACCESS_VIOLATION (Критическая ошибка НАРУШЕНИЕ ДОСТУПА). Дампы при этом не сбрасываются. Многое указывает на то, что в QUIK 8.13 есть ошибка синхронизации (и все-таки земля вертится ). Попробую это обосновать. 1. Ошибка «error ACCESS_VIOLATION» в QUIK 8.13 возникает в разных местах моей тестовой программы, и в разные моменты времени. 2. Я собрал из исходников Lua 5.3.5 вариант исполняемого кода Lua (свой стенд), в котором допустимы обращения к VM-Lua из разных потоков. На этом стенде, точно та же моя тестовая программа (16 интенсивно нагруженных потоков в одном Lua-скрипте), работает непрерывно неделями, и я не могу дождаться, когда же она, наконец, упадет. 3. Я провел следующий эксперимент: 1) Запустил на выполнение программу на «чистом» Lua (без обращения к С-кодам, где отсутствует синхронизация) в QUIK 8.13 и на моем стенде. Время выполнения оказалось одинаковым. 2) Запустил на выполнении программу на «смешанном» Lua (с обращениями к С-кодам, где должна работать синхронизация) в QUIK 8.13 и на моем стенде. Время выполнения оказалось разным. Причем на моем стенде ~ 1, 4 раза больше. Вопрос: в QUIK 8.13 сумели, как то сильно оптимизировать синхронизацию доступа к VM-Lua из разных потоков? Я думаю, это вряд ли. Скорее всего, есть ошибка в реализации синхронизации в QLua 8.13.
В своем стенде, для синхронизации доступа к VM-Lua, я использую критическую секцию, и далее я приведу все места в исходном тексте Lua 5.3.5, где мною были внесены изменения для обеспечения синхронизации. Обращаю ваше внимание на то, что при синхронизации должен использоваться общий объект синхронизации. Возможно?, место синхронизации в QLua было выбрано неудачно. ----- Мои изменения (для обеспечения синхронизации) в исходном коде Lua 5.3.5 приведены в следующем виде: 1) № изменения 2) <Имя файла исходника> 3) <Текст исходника, позволяющий определить место после которого внесено изменение> 4) <Текст изменения> -------------------------------------------------------------------------------- 1. Изменение № 1 Файл: ldo.c Место: #include "ldo.h" Добавление: #include "DbgHelp.h" #pragma comment(lib, "Dbghelp.lib") void lua_lock_MT(lua_State *L) { global_State *g = G(L); EnterCriticalSection(&g->Глобальная_критическая_секция); }
4. Изменение № 4 Файл: limits.h Место: /* ** macros that are executed whenever program enters the Lua core ** ('lua_lock') and leaves the core ('lua_unlock') */ Добавление: #if !defined(lua_lock) #define lua_lock(L) lua_lock_MT(L) #define lua_unlock(L) lua_unlock_MT(L) #endif ----- 5. Изменение № 5 Файл: luaconf.h Место: ** the libraries, you may want to use the following definition (define ** LUA_BUILD_AS_DLL to get it). */ Добавление: #define LUA_BUILD_AS_DLL ----- 6. Изменение № 6 Файл: lstate.c Место: g->gcstepmul = LUAI_GCMUL; Добавление: InitializeCriticalSection(&g->Глобальная_критическая_секция); ----- 6. Изменение № 7 Файл: lstate.h Место: TString *strcache[STRCACHE_N][STRCACHE_M]; /* cache for strings in API */ Добавление: CRITICAL_SECTION Глобальная_критическая_секция;
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Конструктивной частью нашей (во многом, содержательной) дискуссии с Артемом я считаю, для себя, реализацию модифицированного модуля сереализации Lua-таблиц. Этот модуль создан в соответствии с вариантом решения, который был кратко описан мною в комментарии № 164. Замечу, что мои комментарии в ходе дискуссии с Артемом, особенно в части размеров кода, относились к функциональности, выложенного им модуля. Функциональность модифицированного модуля, а также эффективность выполнения в нем сереализации и восстановления таблиц, иные. --- Код модуля выложен в конце данного комментария. ----- В простом варианте восстановления сереализованной таблицы (в том числе и после перезапуска скрипта), когда контекст (определение приведено в описании модуля) ее восстановления не отличается от контекста сереализации, все просто: -- Сереализация таблицы -- <Строка образа (! в случае отсутствия 3-го параметра)> = tbl_to_str (<Таблица> [, <Путь файла сохранения образа или вид результата (0 | 1 байт-код или строка-скрипт)> [ ,<Контекст сереализации>]])
………… !! Здесь может быть и перезапуск скрипта --
-- Полное восстановление таблицы (со всеми ее значениями без исключения ) -- <Таблица)> = str_to_tbl (<Сохраненный где образ - результат функции tbl_to_str > [,<Контекст сереализации>]) ------ Более сложный вариант использования модуля (при различии контекста восстановления таблицы от контекста сереализации) приведен далее, в его описа-нии. -------------------------------------------- В описании модуля значения типов function, userdata и thread называются ссылочными значениями. Сереализуемая таблица, в описании, обозначена именем <T>. Внутренним именем ссылочного значения называется результат функции internal_name (<Cсылочное значение>), определенной в модуле. Составное имя имеет вид адреса поля в таблице: <T1>.<T2>…..<Tn>.<Поле таблицы Tn> Под контекстом выполнения (сереализации, восстановления) далее описываемых функций понимается список доступных им, в момент их выполнения, ссылочных значений, на которые есть ссылки из <T>. -- Описание модуля. 1. Существенных отличий данного модуля, от выложенного Артемом, три: 1) Формирование таблицы ссылочных значений <T> в формате, обеспечивающем, полное восстановление <T> (в том числе, с учетом ее локаль-ного окружения) в контексте ее сереализации из образа, сохраненного в файле (в том числе и после перезапуска скрипта). Кроме того, обеспечен удобный контроль и коррекция результата восстановления <T> в контексте, отличном от контекста ее сереализации. 2) Результатом сереализации таблицы <T> является Lua-скрипт восстановления этой таблицы (в виде байт-кода или исходного кода Lua), со-держащий в себе две таблицы ссылочных значений (контекста и <T>), 3) На таблице _G (в моем скрипте) время выполнения сереализации в дан-ном модуле в ~1,5 раза меньше, чем в сравниваемом модуле, а время восстановления _G меньше в ~ в восемьнадцать раз (мои конкретные числа данного модуля для _G ~ 8000 элементов: сереализация ~ 55 млсек., восстановление ~ 2 млсек.). С уменьшением сереализуемой таб-лицы, описанные выше времена, уменьшаются почти линейно.
2. В модуле доступны пять функций: 1) Сереализация таблицы: tbl_to_str (<T> [, <Признак выдачи результата в виде байт-кода или строки-скрипта 0|1> | <Путь файла записи строки-скрипта > [ ,<Контекст сереализации: таблица или функция >] ]) Результат в зависимости от входных параметров: <байт-код восстановления <T> | <Строка-скрипт восстановления <T>> | <Запись строки-скрипта в файл с заданным путем>.
2) Восстановление таблицы: str_to_tbl (< Байт-код скрипта для восстановления <T>, либо строка-скрипт>[ , <Контекст восстановления: таблица или функция >]) Результаты. Их может быть один или три (если есть висячие ссылочные значения): 1-й - восстановленная таблица с пометкой висячих ссылок, если такие существуют в виде составных имен в контексте сереализации. Второй и третий – nil, если висячих ссылок нет или две таблицы: - таблица висячих ссылок с указанием составных имен-адресов в кон-тексте сереализации; - таблица висячих ссылок с указанием составных имен –адресов в <T>. Эти данные могут быть основой для восстановление таких ссылок.
3) Формирование служебных таблиц, используемых в функциях tbl_to_str и str_to_tbl: creating_link_tables (<Контекст выполнения функций tbl_to_str и str_to_tbl > [, <Признак обновления существующего контекста = 1>]) Первый параметр либо таблица (например, _G), либо пользователь-ская функция создания таблиц контекста (по образцу аналогично тому, как это делается в creating_link_tables). В случае функции, при создании | изменении контекста, вместо creating_link_tables запускается пользовательская функция. По умолчанию контекстом является _G. Результаты функции две таблицы формируемые в ней.
5) Печать любой таблицы Lua в виде удобном для анализа, с указанием уровней вложенности всех ее элементов: dump_tbl (<Таблица>, <Символ отступов для выделения вложенности эле-ментов таблицы>, <Уровень раскрываемых вложенностей таблицы (если 0, то показывается все > [, <Вид выдачи результата: false – таблица (по умол-чанию); true - строка> [, < Таблица имен элементов (задаваемых в ключах) , не разворачиваемых далее >]]). ---- В квадратных скобках при описании всех функций указаны необязательные параметры.
3. При сереализации <T> ее ссылочные значения не сохраняются, но при восстановлении <T>, ссылки на ее ссылочные значения, разрешаются (устанавливают-ся на значения) в контексте ее восстановления. Если контекст, в момент восстановления <T>, такой же (в части всех ее ссылочных значений), как и в момент ее сереализации, то ничего кроме запуска функции str_to_tbl с единственным параметром-результатом, полученным из функции tbl_to_str не требуется; в этом случае таблица <T> будет восстановлена полностью (со всеми ее значениями, включая ссылочные). При отличии контекста восстановления от контекста сереализации таблицы в момент ее восстановления, некоторые ссылки могут оказаться «висячими». Для возможности восстановления висячих ссылок функция str_to_tbl выдает дополнительно к восстановленной <T> c указанием в ней висячих ссылок, две таблицы описания таких ссылок в удобном для анализа виде.
4. В функции str_to_tbl выполняется автоматический контроль разрешимости ссылок <T> на ее ссылочные значения. Выполняемый контроль частичный, в том смысле, что если он не проходит, то это значит, что контекст восстановления <T> точно отличен от контекста ее сереализации. Если же этот контроль проходит, то это означает, что имеется всего лишь полное совпадение сформированных имен ссылочных значений <T>, с именами контекста ее восстановления. При этом может оказаться (! только при отличии контекста восстановления <T> от контекста сереализации), что какая то часть восстановленных ссылочных значений не валидна (восстановленное значение отличается от сереализованного). Вероятность появления невалидности значений, скорее всего, будет очень малой, но не 0. Это надо учитывать и, для случая отличия контекста восстановления от контекста сереализации, желательно выполнять дополнительный контроль а, при необходимости и исправление. ---------- Модуль можно использовать свободно, а при распространении, желательна ссылка на меня. Сообщения об обнаруженных ошибках, замечания и вопросы будут мне интересны. --- Одним из вариантов использования данного модуля может быть реализация контрольной точки, обеспечивающей продолжение выполнения любой цикличе-ской функции (аналога функции main в QLua) после ее перезапуска (по любой причине). При этом, для эффективности контрольной точки (уменьшения сохра-няемых данных) а также защищенности данных функции, можно реализовывать (по крайней мере, начиная с версии 5.3), с помощью _ENV, дополнительно к ее локальным переменным, собственное окружение функции, хранящее только ис-пользуемые в ней, ее сереализуемые значения. Такой вариант реализован мною в OS_Quesha для некоторых ее системных циклических функций.
Код модуля:
Код
-- Модуль сериализации таблиц. Автор TGB ---
---------------------------
--- Быстрая сборка строки из массива строк ----
-- Не обязательный параметр pr = false - строка собирается в прямом порядке (от начала массива к концу); true - строка собирается в обратном порядке --
local function m_str_to_str_fast ( m_str , pr)
if type (m_str) ~= 'table' then return nil, ' ! Ошибка. Первый параметр m_str_to_str_fast не таблица ***' end
local const_mod = 10, m_str_tm
local mod, N , NN
local N_mod, i_mod
----
if pr then
m_str_tm = {}
NN = #m_str
for i = NN, 1, -1 do m_str_tm [NN - i +1] = m_str [i] end
m_str = m_str_tm; m_str_tm = {}
end
while 1 do
m_str_tm = {}
mod, N, NN = #m_str % const_mod, math.floor (#m_str / const_mod), #m_str
N_mod = N * const_mod
for i = 1, N do
i_mod = (i -1)*const_mod
m_str_tm [i] = m_str [ i_mod + 1] .. m_str[ i_mod + 2] .. m_str [ i_mod + 3] .. m_str [ i_mod + 4] .. m_str [ i_mod + 5]
.. m_str [ i_mod + 6] .. m_str [ i_mod + 7] .. m_str [ i_mod + 8] .. m_str [ i_mod + 9] .. m_str [ i_mod + const_mod]
end
if mod > 0 then
N = N + 1; m_str_tm [N] = ''
for i = 1, mod do m_str_tm [N] = m_str_tm [N] .. m_str [N_mod + i] end
end
----
if #m_str_tm > 1 then
m_str = m_str_tm
else return m_str_tm [1]
end
end
end
----------------------------------
----------------------------------
--- Вывод произвольной таблицы в виде таблицы-массива строк (либо в виде строки) ------
------ Параметры:
-- 1) t - таблица (выводятся все вложения до limit);
-- 2) i - строка формирования отступа при выводе вложений (например, ' ')
---- 3) limit - уровень вложенности до которого просматривается таблица (если = 0, то все уровни)-----
---- 4) (не обязательный) <Вид выдачи резкльтата: false – таблица (по умол-чанию); true - строка>
---- 5) (не обязательный) <Таблица имен элементов (задаваемых в ключах) , не разворачиваемых далее >
--- ! Результат: таблица строк: структура со значениями таблицы t (текстовая сортировка по возрастанию индексов таблиц) либо строка,
--- в зависимости от параметра pr-----
--- !! Элемент таблицы [1] - заголовок таблицы. Остальные элементы - строковые представления структуры таблицы t
--- с дополнительными служебными описаниями вложенных в t таблиц.
local function dump_tbl (t, i, limit, pr, list)
if type(t) ~= 'table' then
if pr then return ' Первый параметр t не таблица. Результат: ' .. tostring(t) end
return nil, '! Ошибка. Первый параметр t не таблица'
end
list = list or {}
if type(list) ~= 'table' then
return nil, '! Ошибка. Параметр list не таблица'
end
limit = limit or 0
local tbl = {}; --- для результата ----
tbl[#tbl +1] = '===== Таблица (текстовая сортировка по возрастанию индексов таблиц): ' .. tostring(t)
.. ' \n ! Количество выводимых уровней вложенности (если = 0, то выводятся все) = ' .. limit .. '\n'
local seen={} -- просмотренные --
local Level = 0
------------------------------------------
local function dump(t,i, nm) -----
nm = nm or 'T'
if seen [t] then
return seen [t]
end
------
seen [t] = nm --- !
local t_v, t_k, nm_tm
Level = Level +1 --- Уровень вложенности таблицы ----
--- Обработка метатаблицы ----
local mt = debug.getmetatable ( t )
if mt then
nm_tm = seen[mt]
if nm_tm then
tbl[#tbl +1] = i .. 'Для таблицы ' .. nm .. ' cсылка на существующую метатаблицу -> ' .. nm_tm .. '\n'
else
nm_tm = tostring(mt)
tbl[#tbl +1] = i .. 'Вложенность: ' .. Level .. ' === Содержимое метатаблицы ### : ' .. nm_tm .. '\n'
dump(mt, i..'\t', nm_tm)
tbl[#tbl +1] = i .. 'Вложенность: ' .. Level .. ' === Конец метатаблицы ## ' .. nm_tm .. '\n'
end
end
if next (t) == nil then ---- Таблица пустая ---
tbl[#tbl +1] = i .. 'Вложенность: ' .. Level .. ' Таблица: ' .. nm .. ' пустая ### '.. '\n'
Level = Level - 1
return ''
end
local s={} --- массив хранение имен ключей (строк) для сортировки ---
local ss={} -- массив для хранения самих ключей --
local n=0
local ks=0
for k, v in next, t do
ks = tostring(k)
n=n+1
s[n] = ks
ss[ks] = k
end
table.sort(s)
for k,v in ipairs(s) do ---
t_k = ss [v] -- ключ записи в t
t_v=t [t_k] -- значение записи в t
if Level < limit or limit == 0 then
if type(t_k) == 'table' then --- Обработка ключа-таблицы ---
nm_tm = seen[t_k]
if nm_tm then
tbl[#tbl +1] = i .. '[ ' .. tostring(t_k) .. ' - cсылка на существующую таблицу-ключ -> ' .. nm_tm .. ']' .. '\n'
else
tbl[#tbl +1] = i .. 'Вложенность: ' .. Level .. ' === Содержимое ключа-таблица $$ : ' .. v .. '\n'
dump(t_k, i..'\t', tostring(t_k))
tbl[#tbl +1] = i .. 'Вложенность: ' .. Level .. ' === Конец ключа-таблицы $$ ' .. v .. '\n'
end
end
if list [v] then
if type(t_v) == 'table' then
tbl[#tbl +1] = i .. '[' .. v .. '] (' .. type(t_v) .. ') = ' .. tostring(t_v) .. ' | Терминальная таблица (в печати задано далее не разворачивать) ### \n'
else
tbl[#tbl +1] = i .. '[' .. v .. '] (' .. type(t_v) .. ') = ' .. tostring(t_v) .. '\n'
end
else
tbl[#tbl +1] = i .. '[' .. v .. '] (' .. type(t_v) .. ') = ' .. tostring(t_v) .. '\n'
if type(t_v) == 'table' then --- Обработка таблицы ----
nm_tm = seen [ t_v]
if nm_tm then
tbl[#tbl +1] = i .. '[' .. v .. '] ссылка на существующую таблицу -> ' .. nm_tm .. '\n'
else
tbl[#tbl +1] = i .. 'Вложенность: ' .. Level .. ' === Содержимое таблицы : ' .. v .. '\n'
dump(t_v, i..'\t', tostring(t_k))
tbl[#tbl +1] = i .. 'Вложенность: ' .. Level .. ' === Конец таблицы ' .. v .. '\n'
end
end
end
end
end
Level = Level - 1
return ''
end
--------------
dump(t,i, tostring(t))
if pr then --- Выдача результата в виде строки
return m_str_to_str_fast ( tbl)
else return tbl --- Выдача результата в виде массива строк
end
end
-------------------------------- Общие данные модуля -----------------------------------------
--- 1. Для выделения строк используется скобки [[ ]] и поэтому внутри них не надо никаких преобразований (типа замены \ на \\ и т.д).
-- 2. В выдаваемых стоках для удобства анализа, места, на которые надо обращать внимание в первую очередь выделены символом ###.
----
local aliases_cont = { } --- [ <Внутреннее имя ссылочного значения> ] = <Внешнее имя ссылочного значения в контексте>
local aliases_v_cont = { } --- [ <Внешнее имя ссылочного значения в контексте> ] = <Ссылочное значение в контексте>
local wo_creator -- Призак где сформирована таблицы
local tbl_cont = _G --- Контекст по умолчанию ---
local context_tbl = 'CONT' -- Имя, присвоенное контексту
-----
----- Формирование внутренних имен --
local function internal_name ( s )
return tostring ( s ):gsub ( ': ', '' )
end
----------------------------------------------
-- Параметры
-- 1) 1-й параметр либо таблица, либо пользовательская функция соз-дания таблиц контекста (по образцу аналогично тому,
-- как это делается в creating_link_tables). В случае функции, при создании, изменении контек-стэтом вместо creating_link_tables
-- запускается пользовательская функ-ция.
-- 2) необязательный, если 1, то принудительное обновление таблиц формируемых в ней
-- Результаты : две таблицы формируемые в ней.
---
local function creating_link_tables (context, pr)
if type(context) == 'function' then
wo_creator = 'no creating_link_tables'
local cont, v_cont = context (pr) --- context должен выдавать два результата ---
if cont then aliases_cont, aliases_v_cont = cont, v_cont end
return aliases_cont, aliases_v_cont
end
------
if pr then aliases_cont, aliases_v_cont = {}, {} end -- Обновление общих данных ---
if next (aliases_cont) ~= nil and not pr then return end ----
if type(context) ~= 'table' then context = tbl_cont end
----
wo_creator = 'creating_link_tables'
local path = '###: ' .. context_tbl
----------------------------
local function cr_link_tables (item, path, seen)
seen = seen or { }
path = path or context_tbl
local mt
if item == nil or seen [ item ] ~= nil then
return
elseif type ( item ) == 'table' then
seen [ item ] = true
-- Обработка метатаблицы (если есть в item)---
mt = debug.getmetatable ( item )
if type ( mt ) == 'table' then cr_link_tables (mt, path .. '.' .. '.metatable###', seen ) end
---
local path_tm, kl_tm, k_tm
for k, v in pairs ( item ) do
if type ( v ) == 'table' then ---- таблица-значение --
cr_link_tables (v, path .. '.' .. tostring ( k ), seen )
else
if not (type(v) == 'number' or type(v) == 'boolean' or type(v) == 'string') then
if type(k) == 'string' then kl_tm = '.' .. tostring ( k ) else kl_tm = '[' .. tostring ( k ) .. '] ' end
path_tm = path .. kl_tm
k_tm = internal_name (v)
if not aliases_cont [k_tm] then aliases_cont [k_tm] = path_tm end --- ### ?? возможна перезапись ---
aliases_v_cont [ path_tm ] = v
end
end
----
if type ( k) == 'table' then ---- таблица-ключ --
cr_link_tables (k, path ..'.' .. tostring ( k ), seen )
else
if not (type(k) == 'number' or type(k) == 'boolean' or type(k) == 'string') then
if type(k) == 'string' then kl_tm = '.' .. tostring ( k ) else kl_tm = '[' .. tostring ( k ) .. '] ' end
path_tm = '### ключ: ' .. path .. kl_tm
k_tm = internal_name (k)
if not aliases_cont [k_tm] then aliases_cont [k_tm] = path_tm end --- ### ?? возможна перезапись ---
aliases_v_cont [ path_tm] = k
end
end
end
end
end
cr_link_tables (context, path)
-- MessageDb ( 1, 1, 'Скрипт', ' Финальные проверки. creating_link_tables - aliases_v_cont : \n' .. dump_str ( aliases_v_cont , ' ', 0))
---[[
-- Обработка внешних локальных ссылочных данных контекста ---
local level = 2, ii, name, value
local k_tm, path_tm
while 1 do
if debug.getinfo (level, 'n') then
ii = 1
while 1 do
name, value = debug.getlocal(level, ii)
if name then
if not ( type(value) == 'table' or type(value) == 'number' or type(value) == 'boolean' or type(value) == 'string') then
k_tm = internal_name ( value)
path_tm = '###: LOC.' .. tostring (level) .. '.' .. tostring (ii) .. '.' .. name
if not aliases_cont [k_tm] then aliases_cont [k_tm] = path_tm end --- ### ?? возможна перезапись ---
-- aliases_cont [k_tm] = path_tm
aliases_v_cont [ path_tm ] = value
end
else
break
end
ii = ii + 1
end
else
break
end
level = level + 1
end
----------------------------
---]]
return aliases_cont, aliases_v_cont
end
------------------------------------------------------------
-- Функция создает байт-код либо строку-скрипт Lua, при запуске которого восстанавливается таблица t.
-- В эту же строку в конец добавляется две таблицы ссылочных значений
---- Параметры:
-- 1. t - сереализуемая таблица
-- 2. ph_f - (не обязательный) путь файл сброса строки-скрипта либо признак (0 | 1) выдачи образа в виде (байт-кода | строки - скрипта)
-- 3. context - - (не обязательный) контекст
-- Результат в зависимости от входных параметров: <Функция Lua > (один тараметр) | <Строка-скрипт> (второй параметр = 1)
-- | <Запись строки-скрипта в файл> (второй параметр строка путь к файлу)
local function tbl_to_str ( t, ph_f, context)
----Контроль параметров ---
if type ( t ) ~= 'table' then
return nil, '!! Ошибка. Второй параметр не таблица.'
end
ph_f = ph_f or 0
local f_t
if type(ph_f) == 'string' then
f_t = io.open( ph_f, 'w')
if type(f_t ) ~= 'userdata' then return nil, '!! Ошибка при открытии файла' end
end
creating_link_tables (context)
------
local name_alias = 'alias' --- для формирования команд с учетом alias ----
local env_t = context_tbl
local env = env_t .. '.'
local path = '###: TBL'
local t_str = {} --- для сбора строк
---
local name_t, context_t = {}, {}
-----------------------------------------
local function tbl_str ( t, path, seen )
seen = seen or { }
if seen [ t ] then
return false, env .. internal_name ( t )
else seen [ t ] = 0 end
-------
local n_t, mt = env .. internal_name ( t ), debug.getmetatable ( t )
t_str [ #t_str + 1 ] = n_t .. ' = {} --- создание таблицы: ' .. n_t .. ' -- \n'
local n_tt, n_kt, n_vt , st, nm_t, path_t
for k, v in pairs ( t ) do
if (type(v) == 'number' or type(v) == 'boolean' or type(v) == 'string') then -- Простое значение --
if type(v) == 'string' then
n_vt = '[[' .. v .. ']]'
else n_vt = tostring (v)
end
elseif type ( v ) == 'table' then --- Таблица-значение --
n_vt = internal_name (k)
t_str[ #t_str + 1 ] = ' --- ' .. n_vt .. ' - значение-таблица (начало) @ \n'
st, n_vt = tbl_str ( v, path .. '.' .. n_vt, seen )
if not st then t_str [ #t_str + 1 ] = ' -- Таблица ' .. n_vt .. ' была создана ранее ----\n ' end
t_str[ #t_str + 1 ] = ' --- ' .. n_vt .. ' - [' .. internal_name (v) .. '] значение-таблица (конец) @ \n'
else --- Ссылочное значение ---
nm_t = internal_name (v)
path_t = path .. '.' .. internal_name (k)
context_t [nm_t] = aliases_cont [nm_t]
if name_t [nm_t] then
name_t [nm_t] = name_t [nm_t] .. ' | ' .. path_t
else name_t [nm_t] = path_t
end
n_vt = name_alias .. '[ [[' .. nm_t .. ']] ]' or '### err'
end
if (type(k) == 'number' or type(k) == 'boolean' or type(k) == 'string') then -- Простое значение --
if type(k) == 'string' then
n_kt = '[[' .. k .. ']]'
else n_kt = tostring (k)
end
elseif type ( k ) == 'table' then --- Таблица-ключ ---
n_kt = internal_name (k)
t_str[ #t_str + 1 ] = ' --- ' .. n_kt .. ' - ключ-таблица (начало) @ \n'
st, n_kt = tbl_str ( k, path .. '.' .. n_kt, seen ) --- Создание таблицы ключа и ее 'скобок' ----
if not st then t_str[ #t_str + 1 ] = ' -- Таблица ' .. internal_name ( k ) .. ' была создана ранее ----\n ' end
t_str[ #t_str + 1 ] = ' --- ' .. n_kt .. ' - [' .. internal_name (k) .. '] ключ таблица (конец) @ \n' ---
else --- Ссылочное значение ключа ---
nm_t = internal_name (k)
path_t = path .. '.' .. nm_t
context_t [nm_t] = aliases_cont [nm_t]
name_t [nm_t] = path .. '.' .. nm_t .. '.ключ###'
if name_t [nm_t] then
name_t [nm_t] = name_t [nm_t] .. ' | ' .. path_t
else name_t [nm_t] = path_t
end
n_kt = name_alias .. '[ [[' .. nm_t .. ']] ]' or '### err'
end
n_tt = env .. internal_name ( t )
t_str[ #t_str + 1 ] = n_tt .. ' [ ' .. n_kt .. ' ] = ' .. n_vt .. ' \n'
end
if mt then -- создание и подключение метатаблицы в конце прохода по таблице с тем, чтобы она не мешала заполнять таблицу. Иначе пришлось бы использовать rawset ---
t_str[ #t_str + 1 ] = ' --- Создание метатаблицы --- \n'
st, mt = tbl_str ( mt, path .. '.' .. internal_name (mt), seen )
if not st then t_str[ #t_str + 1 ] = '-- Метатаблица ' .. mt .. ' была создана ранее ----\n ' end
t_str[ #t_str + 1 ] = 'debug.setmetatable ( ' .. n_t .. ', ' .. mt .. ' ) --- подключение метатаблицы ' .. mt .. ' --- \n'
end
return true, n_t --- 1 - й результат - признак создания таблицы
end
---------------------
tbl_str (t, path)
--- Формирование фрагментов скрипта -----
local scr1 = 'local '.. name_alias .. ' = {...}; ' .. name_alias .. ' = ' .. name_alias .. ' [1] ; local ' .. env_t .. ' = {} \n'
.. '\n if type(' .. name_alias .. ') == "table" then \n'
local scr2 = '\n return ' .. t_str[1]: match ( '(%S*)') .. '\n else \n--- Две таблицы внутренних имен ссылочных значений : \n '
.. ' -- 1) name_cont [<Внутреннее имя ссылочного значения >] = ###: <Составное имя значения в контексте сереализации таблицы> \n'
.. ' -- 2) name_t [<Внутреннее имя ссылочного значения >] = ###: <Список составных имен таблицы, ссылающиеся на значение > \n'
.. '--- ! Составные имена таблицы (если их неколько) разделены символом | . \n'
local scr3 = '\n local name_cont = { '
local scr4= '\n local name_t= { '
local scr5 = '\n} '
local scr6 = '\n return name_cont, name_t end \n '
----------------------------
if type(f_t ) == 'userdata' then --- Запись строки-скрипта в файл ----
f_t: write (scr1)
for i = 1, #t_str do f_t:write (t_str[i]) end
f_t: write (scr2)
f_t:write (scr3)
for k, v in pairs ( context_t ) do f_t:write ( '\n [ [[' .. k .. ']] ] = [[' .. v ..']],' ) end
f_t:write (scr5)
f_t:write (scr4)
for k, v in pairs ( name_t ) do f_t:write ( '\n [ [[' .. k .. ']] ] = [[' .. v ..']],' ) end
f_t:write (scr5)
f_t:write (scr6)
f_t:close()
return
else ----------------------
local s_a = {} --- для сбора строк ----
----
local s = scr1 .. m_str_to_str_fast ( t_str)
s_a[ #s_a + 1 ] = scr2
s_a[ #s_a + 1 ] = scr3
for k, v in pairs ( context_t ) do s_a[ #s_a + 1 ] = '\n [ [[' .. k .. ']] ] = [[' .. v ..']],' end
s_a[ #s_a + 1 ] = scr5
s_a[ #s_a + 1 ] = scr4
for k, v in pairs ( name_t ) do s_a[ #s_a + 1 ] = '\n [ [[' .. k .. ']] ] = [[' .. v ..']],' end
s_a[ #s_a + 1 ] = scr5
s_a[ #s_a + 1 ] = scr6
s_a = m_str_to_str_fast ( s_a) -- массив строк -> строка
-----
s = s .. s_a
if ph_f == 1 then
return s --- Строка-скрипт ---
else
return load ( s ) -- !!! байт-код скрипта (два результата) ---
end
end
------
end
----------------------------------------------------------------------
--- str_to_tbl (<Байт-код скрипта для восстановления <T>, либо строка-скрипт)>[, <Контекст>] )
--- Результаты. Их может быть один или три (если есть висячие ссылочные значения):
-- 1-й - восстановленная таблица с gjvtnrjq висячих ссылок, если такие существуют в виде составных имен в контексте сереализации.
-- Второй и третий – nil, если висячих ссылок нет или две таблицы:
-- - таблица висячих ссылок с указанием составных имен-адресов в кон-тексте сереализации;
-- - таблица висячих ссылок с указанием составных имен –адресов в <T>.
-- В таблицах висячих ссылок есть данные, облегчающие восстановление этих ссылок.-
------
local function str_to_tbl (str_fun, context)
--MessageDb ( 2, 0, 'Скрипт', ' str_fun str_fun: \n' .. dump_str ( str_fun , ' ', 0))
if type (str_fun) ~= 'string' and type (str_fun) ~= 'function' then
return nil, '! Ошибка во 2-м параметре ф-ции str_to_tb (он должен быть типа string или function )'
end
local err
if type (str_fun) == 'string' then
str_fun , err = load ( str_fun ); if err ~= nil then return nil, err end
end
---------
local cont_t, tbl_t = str_fun ()
creating_link_tables ( context )
--- Проверка существования ссылочных значений таблицы -----
local cont_err, t_err = {}, {}
local N_err = 0
local v_tm
--- Первый этап разрешения ссылок ---
for k, v in pairs ( cont_t ) do
v_tm = aliases_v_cont [ v]
if v_tm then --- есть ссылочное значение ---
cont_t [k] = v_tm
else
N_err = N_err + 1
cont_err [ k] = v
t_err [ k] = tbl_t [k]
end
end
--- Второй этап разрешения ссылок ---
if N_err > 0 then
local cont_err_tm = cont_err
for k, v in pairs ( cont_err_tm) do
local i_mt = # v
local v_tm, yes
for i = i_mt , 1 do if v: sub(i, i) == ',' then i_mt = i; break end end
if i_mt <= # v then
for i = i_mt - 1 , 1 do if v: sub(i, i) == ',' then i_mt = i; break end end
i_mt = i_mt + 1
v_tm = v: sub(i_mt)
yes = nil
for k_k, v_v in pairs ( aliases_v_cont ) do ---
if k_k: find( v_tm, i_mt) then
cont_t [k] = v_v; yes = 1 break
end
end
if yes then
N_err = N_err -1
cont_err [ k] = nil
t_err [ k] = nil
end
end
end
end
-----
if N_err > 0 then
return str_fun (cont_t), cont_err, t_err
else
return str_fun (cont_t)
end
end
-----
return { tbl_to_str = tbl_to_str, str_to_tbl = str_to_tbl, creating_link_tables = creating_link_tables, dump_tbl = dump_tbl , m_str_to_str_fast = m_str_to_str_fast } ---
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Владимир написал: сам Квик, сервер брокера, к которому обращения идут через провайдера и (в теории) биржа. Ошибки и рассогласования возможны при движении по всей этой цепочке, причём в обе стороны.
Все это надо учитывать. А какие претензии к Lua?
Цитата
Владимир написал: Сам факт, что "двухуровневость была заложена в проект языка и реализована изначально" уже доказывает, что Lua не есть хороший язык, а эта "интегрированность с C/C++ имеет целый ряд весьма неприятных следствий,из-за которых я и писал с самого начала скрипт на чистейшем Lua,
Вы сами себя опровергаете. Вы ни с чем не желаете иметь дело кроме Lua и вполне этим обходитесь (при этом не мало покувыркашись с реализацией диалога на таблицах QUIK). Я после того как увидел то, что собой представляет собой архитектура QUIK в части обработки колбеков, а также в части реализации таблиц QUIK (не путать с таблицами Lua) имел возможность, используя второй уровень Lua, потроить то, что считал нужным для себя. Все почти счастливы. А вы вы утверждаете, что двухуровневость это недостаток. После того, как у вас в портфеле появится 1 000 000 акций, вам не надо выбрасывать разработанный вами код, Достаточно будет дополнить его некоторой частью на C, который вам знаком
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Артем написал: Язык отличный и документация исчерпывающая - всё верно.
Добавлю свои «пять копеек». Чтобы было понятно, что у меня есть с чем сравнивать, отмечу: Lua не первый язык, с которым я знаком, и даже не пятый. Далее коротко. 1. Lua, по сути, двухуровневый язык: Lua/C. Эта двухуровневость была заложена в проект языка и реализована изначально (Lua тесно интегрирован с C/C++). Таким образом никаких ограничений ни на функиональность, разрабатываемых программ, ни на их эффективность, языком не накладывается. 2. Сам Lua очень компактный, как по исполняемому коду, так и по его описанию, достаточного для его начального использования. Особенно это заметно на фоне многочисленных монструозных средств разработки программ. Пожалуй, отношение <функциональности Lua> к <его компактности> одно из самых высоких среди известных мне языков программирования. Для хорошего понимания Lua, в основном, достаточно четкого представления об устройстве ассоциативной таблице, которая используется, в том числе, и для хранения всех переменных самой программы Lua. Переменные всех типов Lua это всего лишь типы полей в таких таблицах. В переводе на другие известные языки: обычные таблицы Lua это динамичный список свойств, а метатаблицы - это методы, связанные с этими свойствами. И это, почти все, что достаточно знать, чтобы хорошо разбираться в остальных деталях Lua (в областях видимости переменных и т.д.). Профессионал, наверное, сможет изучить этот язык, почти в полном объеме, дня за два-три. Для начинающих программировать это язык тоже, наверное, один из самых простых. Если делать в программах на Lua проверку типов параметров (а может быть и областей значений) более-менее содержательных функций, то можно повысить и надежность разрабатываемых на Lua программ.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Владимир написал: НАДО! Причём не только автору, но и нам! Если автор нас не устраивает, а тема интересная, заводим свою ветку по той же тематике и ведём дискуссию уже там.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Владимир написал: Автор ветки как никто заинтересован в её качестве, а также в притоке туда других участников! Ему и вожжи в руки! Бразды правления, в смысле. Он и будет убирать флуд и поощрять предметные дискуссии.
Автор сможет убрать и комментарии по существу, но не приятные для него. А нам это надо?
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Владимир написал: TGB , А я ещё тогда предлагал наделять хозяина ветки правами её модератора - это снимает почти все вопросы. Реализовано это было много позже, на Фейсбуке, но не как замену модераторам, а как дополнение к ним. Результат - налицо: ФБ тоже фактически угроблен!
А вот это совершенно лишнее. Называется это перегибы на местах .
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Владимир написал: TGB , Это путь в тупик. Я в Инете с 1992 года, и я ещё помню времена, когда никаких модераторов вообще не было. Качество дискуссий при этом было на порядок выше и обеспечивалось самими участниками. А угроблено это качество было в начале "нулевых", и угроблено именно модераторами.
Ну вы анархист и романтик . Жизнь меняется и уже у собак появились аккаунты. Конечно, какой-то простор для творчества необходим, и если вы заметили, то для пользователей форума мною в моих указаниях это оставляется . Но когда, для того чтобы прочесть на форуме что-то не тривиальное, приходится пробиваться через сугробы напечатанного это не комильфо.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Что то на форуме много взаимных оскорблений. Зачем? Кому это нужно? Это, в том числе, наносит и имиджевый ущерб разработчику QUIK. Градус общения на любом форуме определяются не пользователями (они бывают очень разные) а хозяином форума. Если бы я был директором , то выдал бы следующие указания: добавить пользователям форума в их профиль закрытые по записи два раздела: предупреждения и благодарности. Кроме того, ввести лимит количества символов, вводимых пользователем в течении месяца, исключив из него коды программ. В правила форума добавить пункт, определяющий основания для блокировки (на какой то срок), а также автоматическое удаления учетной записи пользователя на основании данных раздела предупреждения. Установить для предупреждений годовой срок давности, после которого они автоматически снимаются. --------- Удалять учетную запись пользователя без некоторой формализации, наверное, было бы вольюнтаризмом .
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Владимир написал: если нулевой байт считается терминатором, то "a" и "a\0b" И В САМОМ ДЕЛЕ "эквивалентные строки" (но разные массивы данных).
В в строке Lua нулевой байт не считается терминатором. Если мы что то разрабатываем в Lua, то приходится учитывать среду разработки, даже если она нам не нравится.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
TGB написал: Так как символ \0 в Lua это признак завершения строки, то для Lua "a" и "a\0b" - эквивалентные строки.
В этом я ошибся.
Цитата
Артем написал: Lua использует бинарные строки с указанной длиной. Указанные строки - разные, и Lua будет их считать разными; при выгрузке в файл значения разные (и совпадающие со входящими). То что они отобразились одинаково это вероятно из-за того, что в используемом терминале используется С стандарт строк с нуль-терминатором.
Замечание верное, действительно, в своем выводе в файлы и на экран я придерживался стандарта С и с учетом того, что стандарт Lua другой это моя ошибка.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Артем написал: TGB , я ассерт на копии значений поставил в функцию инвертирования таблицы, но не упомянул. Так как нужно это только для дебага ручных операций, то не стал заморачиваться с такими вещами как вторичная инвертированная таблица для проверки уникальности по месту.
Есть хорошо известный принцип любой разработки (и не только программ): контроль должен выполняться в том месте, в котором используются данные, а не известно где. Это делается хотя бы потому, никто не знает требований к данным. лучше чем потребитель. -----
Цитата
Артем написал: Генерировать сериализированные файлы в формате исполняемого кода это что называется все фломастеры на вкус разные. Вывод всё равно получается кашеобразный и нечитаемый.
Зря вы это написали, вынудив меня ответить. Я нигде не утверждал, что предложенный мною вариант реализации обсуждаемого модуля нацелен на виализацию таблиц. Хотя, мне кажется, что вы понимаете, что нет проблем добавить в этот вариант отступы вложенности и комментарии и это сильно повысит качество виализации. Но опять же, я не про это. Я про другое:
Цитата
TGB написал: 2) str_to_tbl - короче аналогичной loadstr в ~10 раз. .
На самом деле, как я вас понимаю, но возможно ошибочно, ваша квалификация позволяет вам быстро достаточно реально оценивать программы (напмсанные, во всяком случае, на Lua). Здесь же. похоже, имеет фактор, отмеченный в моем филосовском отступлении:
Цитата
TGB написал: P.S. Все мы, время от времени, в чем-то ошибаемся. Существенная разница состоит только в том, что одни больше усилий предпринимают для устранения своих ошибок, а другие на их оправдание и надувание щёк.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Артем написал: С алиасингом булевых значений в глубоких таблицах действительно была ошибка которую надо исправить, хотя в целом некритичная - булы они и в африке булы, под каким именно алиасом они сидели это неважно.
Я еще раз посмотрел addalias ( item, path, deep, seen ) и не увидел контроля уникальности path (с выдачей сообщения об ошибке в каком-то виде). Делать это надо отдельно от уже реализованного контроля уникальности item.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Артем написал: TGB , в Lua имеется встроенный компилятор который производит бинарный байткод, который может выполняться в виртуальной машине Lua. и т.д ..........
Это мне известно.
Похоже, мы обсуждаем:
Цитата
TGB написал: То, что делается в исходном, обсуждаемом модуле, можно сделать, как мне кажется, элегантнее, формируя в качестве строки образа таблицы, текст исполняемого скрипта. Результат такого подхода: 1) tbl_to_str на ~20% - длиннее, чем dumpstr; 2) str_to_tbl - короче аналогичной loadstr в ~10 раз. .
Здесь рассмотрен вариант когда результатом выполнения функции tbl_to_str (аналога dumpstr) является строка-скрипт вида: local TBL = {} TBL.table00000263878C31B0 = {} --- создание таблицы -- TBL.table00000263878C31B0 [ [[expansion]] ] = [[txt]] TBL.table00000263878C31B0 [ [[INTERVAL_W1]] ] = 10080 TBL.table00000263878C31B0 [ [[QTABLE_DOUBLE_TYPE]] ] = 2 TBL.table00000263878C31B0 [ [[INTERVAL_M5]] ] = 5 ---- и так далее. return TBL.table00000263878C31B0 ------- Функцию str_to_tbl я приведу полностью: --- Рузультат функции: таблица полученная из строки s или текст описания ошибки --- local function str_to_tbl (s ) do local tt= { } for k, v in pairs ( alias ) do tt[ v ] = k end alias = tt end --- alias: переворот: alias = { [ <Имя> ] = <Значение (> } local fun , err = load ( s ) if err ~= nil then return err else return fun() end end --------------------
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Артем написал: elseif kt == 'boolean' then kcurr = alias[ k ] or k == 'true' elseif kv == 'boolean' then v = alias[ v ] or v == 'true'
С этим согласен.
Цитата
Артем написал: Я понял в чём проблема с метатаблицами: возможны ситуации, когда метатаблица загружается до того, как исползующий ей стол, тогда метаметоды будут активны сразу. [QUOTE] Именно о такой ситуации я написал в комментарии кода. [QUOTE]Артем написал: Метаметоды можно обойти через rawset.
Тоже нормальный (и более простой) вариант.
Цитата
Артем написал: При желании можно с байткодом конечно шаманить но с функциями на С это всё равно не работает, так что ради единообразности и Lua функции тоже не поддерживаются.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Артем написал: TGB ,про бинарные строки вам уже рассказали. Собственно эта информация прямым текстом написана в третьем параграфе первой главы, т.е. в самом начале инструкции - которую вы очевидно не читали. Так что пожалуйста прочитайте, целиком и полностью. Перед тем как делать библиотеки для других людей, сначала убедитесь что ваши познания и умения находятся на уровне повыше плинтуса.
После этого комментария, когда у меня появилось время, мне (сразу, без переобувания в тапочки ) захотелось поучиться у вас, и посмотреть тот код, который вы тут выложили. Выложенный вами модуль, в целом, написан в хорошем стиле. Если вы это сделали сами, то, похоже на то, что Lua вы знаете. Однако, несколько настораживает то, что в модуле нет ни одного комментария и много операторов одной строкой. Такое ощущение, что это написано сразу начисто (и без отладки). Я бы так не смог . При более детальном просмотре я увидел, что в представленном вами модуле есть ошибки (я сделал правки в 8-ми местах). Чего я не ожидал так это то, что в нем не учтено существование в Lua типа boolean (смотрите правки в коде модуля). Этот тип хорошо описан в любезно предложенной вами инструкции на сайте https://www.lua.org/manual/5.3/ в разделе 2.1 (в 1.3 этого описания не ищите). Я поправил в модуле те ошибки, которые, как мне кажется, увидел (но возможно и добавил свои ). Понятно, что какие-то ошибки могли и остаться. Свои правки я как-то прокомментировал, выделив существенные изменения символами ###. Модифицированный код модуля выложен в конце данного комментария. Кстати, я проверил быстродействие dumpstr модуля на своем ПК и моем _G (понятно, что у нас с вами в этом могут быть большие различия). Мой dump_str (написанный два года назад, в тренировочных целях, когда мне пришлось перейти на QUIK) выполняется (на таблице _G) в 3 раза быстрее, чем dumpstr модуля, но это мелочи. У представленного вами модуля назначение другое (в том виде как он есть, это точно не визуализация) и его функциональность богаче. ---- То, что делается в исходном, обсуждаемом модуле, можно сделать, как мне кажется, элегантнее, формируя в качестве строки образа таблицы, текст исполняемого скрипта. Результат такого подхода: 1) tbl_to_str на ~20% - длиннее, чем dumpstr; 2) str_to_tbl - короче аналогичной loadstr в ~10 раз. . -------------------------------- P.S. Все мы, время от времени, в чем-то ошибаемся. Существенная разница состоит только в том, что одни больше усилий предпринимают для устранения своих ошибок, а другие на их оправдание и надувание щёк. ------- Измененный код обсуждаемого модуля:
Код
local aliases = { }
local function escape ( s )
s = tostring ( s ):gsub ( "\n", "\\n" )
return s
end
local function dumpstr ( t, alias, seen )
alias, seen = alias or aliases, seen or { }
if seen[ t ] then return "" else seen[ t ] = true end
local s, mt = string.format ( "newtable %s\n", alias[ t ] or escape ( t ) ), getmetatable ( t )
if mt then s = string.format ( "%smetatable %s\n", s, alias [ mt ] or escape ( mt ) ) end
local k_t, v_t
for k, v in pairs ( t ) do
k_t, v_t = alias[ k ] or escape ( k ), alias[ v ] or escape ( v )
if k_t == 'charpattern' then v_t = '%[' end ---- ??? --- и без этого все работает, но если этот символ оставить в покое, обрубается виализация результата dumpstr ?
s = string.format ( "%sk %s %s\nv %s %s\n", s, type ( k ), k_t, type ( v ), v_t )
end
if mt then s = string.format ( "%s%s", s, dumpstr ( mt, alias, seen ) ) end
for k, v in pairs ( t ) do
if type ( k ) == 'table' then s = string.format ( "%s%s", s, dumpstr ( k, alias, seen ) ) end
if type ( v ) == 'table' then s = string.format ( "%s%s", s, dumpstr ( v, alias, seen ) ) end
end
return s
end
local function unescape ( s )
s = s:gsub ( "\\n", "\n" )
return s
end
--------------- ! Символами ### выделены измененные места, для исправления ошибок -------
local function loadstr ( s, alias )
alias = alias or aliases
do local t = { } for k, v in pairs ( alias ) do t[ v ] = k end alias = t end
local tlist, tcurr, kcurr, troot = { }, nil, nil, nil
local tmt, ttb
for l in s:gmatch ( "([^\n]+)\n" ) do
local nt = l:match ( "newtable (.+)" )
local mt = l:match ( "metatable (.+)" )
local kt, k = l:match ( "k ([^ ]+) (.+)" )
local vt, v = l:match ( "v ([^ ]+) (.+)" )
if nt then if tmt then setmetatable ( ttb, tmt ); tmt, ttb = nil, nil end --- ### 1. setmetatable выполняется после завершения формирования ttb (смотрите п.2)
tlist[ nt ] = tlist [ nt ] or alias[ nt ] or { }; tcurr = tlist[ nt ]; troot = troot or tcurr; d_nt = nt
elseif mt then tlist[ mt ] = tlist[ mt ] or alias [ mt ] or { }; ttb = tcurr; tmt = tlist [ mt ] -- ### 2. setmetatable нужно выполнять после того как будет полностью сформирована tcurr.
elseif k then ---- Иначе могут срабатывать метаметоды, если метатаблица была сформирована раньше.
if kt == 'table' then tlist[ k ] = tlist[ k ] or alias[ k ] or { }; kcurr = tlist[ k ]
elseif kt == 'number' then kcurr = alias[ k ] or tonumber ( k ) or 0/0
elseif kt == 'string' then kcurr = alias[ k ] or unescape ( k )
elseif kt == 'boolean' then kcurr = alias[ k ] or k ----- ### 3. добавлено (учет типа boolean): elseif kt == 'boolean' then kcurr = alias[ k ] or k ---
else kcurr = alias[ k ] or k ----- ### 4. добавлено (учет:элеметов не входящих в alias) or k ---
end
elseif v and tcurr and kcurr ~= nil then
if vt == 'table' then tlist[ v ] = tlist[ v ] or alias[ v ] or { }; tcurr[ kcurr ] = tlist[ v ]
elseif vt == 'number' then tcurr[ kcurr ] = alias[ v ] or tonumber ( v ) or 0/0
elseif vt == 'string' then tcurr[ kcurr ] = alias[ v ] or unescape ( v )
elseif vt == 'boolean' then tcurr [ kcurr ] = alias[ v ] or v ---- ### 5. добавлено: elseif vt == 'boolean' then tcurr [ kcurr ] = alias[ v ] or v ---
else tcurr [ kcurr ] = alias[ v ] or v ----- ### 6. добавлено: or v ---
end
end
end
if tmt then setmetatable ( ttb, tmt ) end --- ### 7. Выполняется в поледней обработанной таблице (! если у нее есть метатаблица)
return troot
end
local function dumpfile ( file, t, alias, seen )
alias, seen = alias or aliases, seen or { }
if seen[ t ] then return else seen[ t ] = true end
local mt = getmetatable ( t )
file:write ( string.format ( "newtable %s\n", alias[ t ] or escape ( t ) ) )
if mt then file:write ( string.format ( "metatable %s\n", alias [ mt ] or escape ( mt ) ) ) end
for k, v in pairs ( t ) do
file:write ( string.format ( "k %s %s\nv %s %s\n", type ( k ), alias[ k ] or escape ( k ), type ( v ), alias[ v ] or escape ( v ) ) )
end
if mt then dumpfile ( file, mt, alias, seen ) end
for k, v in pairs ( t ) do
if type ( k ) == 'table' then dumpfile ( file, k, alias, seen ) end
if type ( v ) == 'table' then dumpfile ( file, v, alias, seen) end
end
end
local function addalias ( item, path, deep, seen )
if item == nil and path == nil and deep == nil and seen == nil then item, path, deep = _G, "_G", true end
seen = seen or { }
if item == nil or path == nil or seen[ item ] ~= nil then
return
elseif type ( item ) == 'table' and deep then
seen[ item ] = true
for k, v in pairs ( item ) do
if type ( v ) == 'table' then
addalias ( v, string.format ( "%s.%s", path , escape( k ) ), deep, seen )
elseif type ( v ) ~= 'string' and type ( v ) ~= 'number' and type ( v ) ~= 'boolean' then ----- ### 8. добавлено (учет boolean): and type ( v ) ~= 'boolean'
aliases[ v ] = string.format ( "%s.%s", path, escape ( k ) )
end
end
else
aliases[ item ] = path
end
end
addalias ( math.huge, "math.huge" )
addalias ( -math.huge, "-math.huge" )
return { dumpstr = dumpstr, dumpfile = dumpfile, loadstr = loadstr, addalias = addalias }
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
s_mike@rambler.ru написал: в первом примере не раскрыто содержимое таблицы, являющеся ключом. Сериализация это подразумевает. Таблица ключа может содержать вложенные таблицы, которые также должны быть раскрыты.
Я при описании dump_tbl ни разу не упоминал про сериализацию и в этой функции ключи типа table, userdata и function не раскрываются. Для них выдается их служебный код (ссылка).
Цитата
s_mike@rambler.ru написал: во втором случае результат явно неверен. "a" и "a\0b" - совершенно разные строки.
Так как символ \0 в Lua это признак завершения строки, то для Lua "a" и "a\0b" - эквивалентные строки.
Цитата
s_mike@rambler.ru написал: в третьем случае 1.#inf не является допустимым числом lua. Это всего лишь нерегламентированное внутреннее представление, которое не может попадать в результат.
Результат 1.#inf выдает Lua и я не собираюсь переделывать его.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Незнайка написал: И там и там конкатенация строк. В чём профит?
В том как я предложил вам собирать строку профита нет. Профит есть при использовании специальной быстрой C-функции сборки строки из массива строк (тоже из API, но С-пакета, который пришлось бы устанавливать). Если собирать без профита, то при выполнении операции <строка1> = <строка1> .. <добавляемая строка> в Lua всякий раз выполняется отказ от предыдущей памяти <строка1> и запрашивается новая память под новое значение <строка1>. В быстрой C-функции сборки строки на C++ реализована эффективная динамическая строка, в которую последовательно добавляются <добавляемые строки> вообще без описанной мною в предыдущем предложении нагрузки на автоматическое управление памятью.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Незнайка написал: Ставить дополнительную библиотеку только лишь для создания уникальных ключей - не лучшее решение.
Согласен. Но я не предлагаю что-то ставить. Я привел оглавление описания API и одну из простых, но полезных, по моему мнению, для разработчиков функций.
Цитата
Незнайка написал: Может, лучше сразу распечатать таблицу в виде строки, без конвертации в другую таблицу?
У меня используется специальная быстрая функция сборки строки из массива строк и я это делаю в dump_str используя dump_tbl. Дело в том, что цикл вида: <строка1> = <строка1> .. <добавляемая строка> при большом количестве повторений (а я предполагаю что это может быть) в Lua заметно нагружает управление памятью. Вы же можете получать свою строку следующим образом: local str = "" for k,v in next, dump_tbl (<Параметры>) do str = str .. v end или модифицировать код функции dump_tbl.
Цитата
Nikolay написал: Вы попробуйте им вывести Класс или таблицы с перекрестными ссылками.
Функция dump_tbl рекурсивная и в ней раскручиваются все ссылки.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Комментариев обсуждения функции cоздания последовательности ключей я насчитал более двадцати. Это одна из самых простых функций из списка API OS_Quesha, оглавление описания которого в документации приводится ниже. 1. Вывод сообщений. 2. Работа со временем. 3. Создание последовательностей ключей. 4. Создание среды функционирования разрабатываемого робота. 5. Взаимодействие потоков. 6. Обеспечение явной синхронизации потоков. 7. Работа с таймерными событиями. 8. Работа с контрольными точками. 9. Работа с фоновыми заданиями. 10. Обеспечение отладки функций и взаимодействия потоков. 11. Разное. Примером простой (классическая задача на рекурсию), но, наверное, полезной функции из раздела 10 является универсальная функция печати переменных dump_str. Она может быть использована в тексте программ для вывода любых переменных (и таблиц произвольной вложенности) Lua. Ниже приводится код функции, которую можно использовать автономно (может быть кому то окажется полезной):
Код
--- Вывод произвольной таблицы в виде таблицы-массива строк ------
------ Параметры: 1) t - таблица (выводятся все вложения до limit); 2) i - строка формирования отступа при выводе вложений (например, " ")
---- 3) limit - уровень вложенности до которого просматривается таблица (если = 0, то все уровни)-----
--- ! Результат: таблица строк: структура со значениями таблицы t (текстовая сортировка по возрастанию индексов таблиц). -----
--- !! Элемент таблицы [1] - заголовок таблицы. Остальные элементы - строковые представления структуры таблицы t
--- с дополнительными служебными описаниями вложенных в t таблиц. -----
function dump_tbl(t, i, limit)
if type(t) ~= "table" then
return nil
end
local tbl = {}; --- для результата ----
tbl[#tbl +1] = "===== Таблица (текстовая сортировка по возрастанию индексов таблиц): " .. tostring(t)
.. " \n ! Количество выводимых уровней вложенности (если = 0, то выводятся все) = " .. limit .. "\n"
if next(t) == nil then --- таблица пустая -------
tbl[#tbl +1] = "Таблица пустая"
return tbl
end
local seen={} -- просмотренные --
local Level =1
-----------
function dump(t,i) ---------
if seen[t] then return end
seen[t]=true
local s={} --- массив хранение имен ключей (строк) для сортировки ---
local ss={} -- массив для хранения самих ключей --
local n=0
local ks=0
for k, v in next,t do
ks = tostring(k)
n=n+1
s[n] = ks
ss[ks] = k
end
table.sort(s)
local tt
for k,v in next,s do
tt=t[ss[v]]
if not seen[tt] then
tbl[#tbl +1] = i .. "[" .. v .. "] (" .. type(tt) .. ") = " .. tostring(tt) .. "\n"
if Level < limit or limit == 0 then
if type(tt) == "table" then
Level = Level +1
tbl[#tbl +1] = i .. "Вложенность: " .. Level .. " === Содержимое таблицы : " .. v .. "\n"
dump(tt, i.."\t")
tbl[#tbl +1] = i .. "Вложенность: " .. Level .. " === Конец таблицы " .. v .. "\n"
Level = Level - 1
end
end
end
end
end
---------------------
dump(t,i)
return (tbl)
end
В диалоге OS_Quesha, в процессе ее работы, функцию dump_str можно вызвать в любой момент для любой глобальной переменной скрипта с тем, чтобы распечатать ее с выдачей в журнал отладки. Например, у меня контекст Lua (переменная _G) выводится (это ~5000 строк) за 20 млсек (по поводу скорости вывода жду комментария Владимира ).
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
И по теме (описание интерфейсных функций OS_Quesha): 5.3 Создание последовательности ключей Последовательность ключей это функция, при обращении к которой выдаются значения некото- рого типа, уникальные в некотором контексте их использования. Дополнительным требованием (кроме уникальности значений), в некоторых случаях использования таких функций, может быть необходимость формирования их значений по определенным правилам. В качестве примера использования последовательности можно привести создание идентифи- каторов заявок при их выставлении в QUIKе с помощью функции sendTransaction. 1. Запрос последовательности ключей (number): Cl_LuaGL () Результат функции: number - глобальный ключ системы формата: <Номер запус- ка/перезапуска системы >(старшие, оставшиеся разряды, начиная с 6-го )<Счетчик запросов ключей после запуска/перезапуска системы>(6 десятичных разрядов) Эта функция при обращении из любого потока (функции скрипта), выдает значение отличное от всех ранее ее вы- данных (независимо того, были запуски или перезапуски системы).
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Владимир написал: или просто нумеровать их у себя как 1, 2, 3, 4,...
Если у вашего робота не предусмотрен перезапуск с продолжением с прерванного места, то это самое подходящее. Если же перезапуск предусмотрен, то необходимо предусмотреть и продолжение нумерации после перезапуска (с сохранением ее последнего значения в энергонезависимой памяти).
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Артем написал: какой такой сценарий в контексте брокерского торгового терминала предпологает "некоммерческое" использование?
Некоммерческое использование это значит, что любое частное лицо (пользователь) может использовать обсуждаемые средства (в том виде как они есть, без гарантии последующей их поддержки с моей стороны) для создания своего робота.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Александр М написал: У разработчика уже есть готовые набор библиотек, каркасы роботов, индикаторов и т.д. из которых он собирает продукт. Все это переделывать на ЧУЖУЮ библиотеку:1. Непонятно зачем, т.к. уже есть свое и готовое.2. Опасно.
Я, во многом, согласен с выше написанным относительно разработчиков, давно работающими над внешними проектами. Но среди большого количества пользователей, по моему представлению (основанным на моем опыте), найдутся те (их будет очень мало), кому это будет интересно и кто способен в этом быстро разобраться и использовать. И мне интересны такие пользователи. Кроме того, представленное мною (некоторая готовая инфраструктура создания роботов, которая создавалась для решения собственных задач) может вдруг показаться полезной и профессиональным разработчикам.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Владимир написал: кое-что можно сделать ТОЛЬКО на ассемблере. А потому именно на нём и можно предельно быстро и качественно разрабатывать любые приложения. В общем случае, быстрее, чем на любом другом языке.
Ваше утверждение слишком сильное, но оно же сильно расходится с вашей практикой. Вы же своего робота сделали на QLua и мало того, что не используете в нем ассемблер, но даже отказываетесь использовать C.
Цитата
Владимир написал: задачи. которые решаются в Квике по определению не требуют ни "нескольких ядер в ЦП компьютера", ни параллельных вычислений, ни какого-либо "расхода ресурсов ПК"
Я согласен с тем, что подавляющее большинства пользователей QLua эффективность вычислений (параллелизм т.д.) мало волнует, но это в перечислении основных функций OS_Quesha всего лишь первый пункт. У меня самого возникла потребность в потоках не из-за проблем с вычислительными ресурсами, а из-за того, что появилась группа взаимодействующих задач, и в рамках одного потока надо было реализовывать некоторый диспетчер, занимающийся распределением процессорного времени одного потока между этими задачами. Вместо реализации такого диспетчера (а это была бы реализация в корявом виде функций потоков) были реализованы функции первого пункта, которые не только решали проблемы диспетчирования задач, но и при необходимости могли решать проблемы обеспечения эффективности вычислений. Возможность создания потока внутри скрипта обеспечила также беспроблемное использование любых доступных отлаженных графических пакетов, из которых я выбрал IUP.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Александр М написал: Большинство перечисленных пунктов в "Основные функции OS_Quesha." решаются в виде простого lua скрипта, включая и графические интерфейсы
Когда обсуждаются любые средства, облегчающие разработку программ, возражение типа: «Это можно сделать существующими средствами», «не катит», так как, в конце концов, все можно сделать и на ассемблере. По существу же, обсуждать имеет смысл то, насколько быстро и качественно можно разрабатывать приложения, использую предлагаемые средства по сравнению с тем, что обеспечивают существующие средства их разработки. Конечно, только практика использования любого средства разработки программ может определить его реальную полезность для разработчиков. Такая возможность разработчикам роботов в QUiK предоставлена в виде кодов и документации OS_Quesha.
Цитата
Александр М написал: Очень специфическое возможное использование, я даже не смог придумать сходу, где бы мне это решение понадобилось с учетом всех реализованных мною проектов, включая заказные
Мне непонятно в чем состоит специфичность использования OS_Quesha, если вместо одной функции main в QLua, в OS_Quesha, при использовании исходника TS_QUIK_RT.lua, предоставляется четыре (количество определяется в исходнике, в описании схемы обработки в табличном виде), аналогичные функции, в которых доступен весь API QLua. Эти функции могут, при наличии нескольких ядер в ЦП компьютера, выполняться параллельно (с учетом особенностей версий QUIK > 8.4, описанных в моем начальном комментарии). Дополнительно они могут взаимодействовать между собой через готовые очереди. Кроме того, в них доступны все возможности, описанные в моем начальном комментарии. Причем, расход ресурсов ПК на функционирование OS_Quesha ничтожен и в этом можно убедиться, запустив немодифицированный исходник TS_QUIK_RT.lua. Все дополнительное использовать не обязательно, но это может потребоваться при последующем расширении возможностей робота.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
BlaZed написал: читаю и понимаю, что вроде что-то может быть даже и нужное, но вот зачем оно мне и какие преимущества даст совершенно не понятно.
В документацию я добавил исходник TS_QUIK_RT.lua (это TS_QUIK.lua без тестовых функций) полностью готовый для практического использования пользователем. В нем определены четыре циклические функции-шаблоны: main, main_user1, main_user2, main_user3, в которые пользователь может вставить свои фрагменты программ, обрабатываемые в циклах этих функций. Эти функции запускаются в разных потоках. У всех перечисленных циклических функций есть входные очереди, обеспечивающие (при необходимости) их взаимодействие (чтение/запись). Любая функция активируется либо по истечении интервала ожидания (как в sleep), либо в момент записи данных в любую ее входную очередь. Во всех четырех функциях вместо известной функции sleep используется функция WaitEventOCLua, реализующая описанную схему обработки циклов. В функции main реализована схема обработки колбеков, в которой основной поток QUIK записывает параметры колбеков в очереди, обрабатываемые в main. Операция записи в очередь быстрая и поэтому основной поток, при обработке колбеков, не блокируется. Количество циклических функций, их очереди и другие параметры определяются в TS_QUIK_RT.lua схемой описания обработки данных, которую пользователь может модифицировать под свои задачи. Кроме того, пользователь может использовать следующие, уже подключен-ные, пакеты: 1) iup (графический пакет); 2) sqlite (пакет работы с встроенными базами данных); 3) lfs (файловый пакет). Дополнительные возможности (настраиваемый диалог, ведение журналов диалога и отладки, средства отладка скриптов и т.д.) при использовании OS_Quesha были описаны в моем начальном комментарии. --- P.S. Текущая версия OS_Quesha работоспособна и для QUIK (Lua 5.4).
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
BlaZed написал: Короче, грамотный рекламщик вам нужен, если хотите в массы свой софт пустить.
В том виде как он есть, софт не массовый, а потому о рекламе речь не идет. Те, кому он может показаться интересным практически (а таких, я думаю, окажется мало), наверное, и без рекламы поставят его в тестовую конфигурацию QUIK и быстро разберутся, нужен ли он им и зачем.
Nikolay написал: include файлы и lua54.lib взято с оф. сайта lua.
Не точно, но возможно, вы взяли статическую библиотеку lua54.lib (~300 кб.). Надо использовать библиотеку импорта dll lua54.lib (~30 кб.) с тем, чтобы использовались функции QUIK из его lua54.dll. Либо надо самому создать библиотеку импорта lua54.lib, используя lua54.dll из QUIK.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Владимир написал: Но вот специализированную ОС под задачи торговли - такого я ещё не видывал ни разу за всю свою (не очень-то и короткую) жизнь.
Ну! Это уже реклама. Я бы так не смог А если серьезно Ведь было доброе время, когда программы набирались на тумблерах. Все ошибки в них, кроме ошибок железа, были свои и ведь они как-то работали. Потом появились операционные системы, трансляторы языков программирования и т.д. и теперь нам приходиться иметь дело со всей этой огромной лабудой, искать не только свои ошибки но и чужие глюки.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Владимир написал: У моего так ГИБКАЯ стратегия, алгоритм меняет поведение в зависимости от поведения рынка здесь и сейчас (причём как рынка вообще, так и поведение по каждому конкретному тикеру в частности), от настроек, заданных юзером (именно они и меняются в диалоге при необходимости)
Вы счастливый человек и я не очень понимаю, зачем вам так много писать в этой теме
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Владимир написал: АКИЕ возможности для торговли она предоставила лично Вам?
1. У меня автоматически парсятся некоторые сайты с аналитикой фондовых рынков. На основе полученных данных автоматически выбираются бумаги и стратегия для внутридневных торгов. 2. На основе базовой (выбранной) стратегии автоматически выставляются заявки и отслеживаются сделки, 3. Паралльльно, по трем альтернативным стратегиям торговли ведется виртуальная торговля. При значительной разнице результатов происходит переход на более прибыльную стратегию. Все я не буду описавать. Думаю, что этого доствточно.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Незнайка написал: Но кому-то может, и пригодятся реализованные автором средства, которых нет изначально в qlua.Вы ведь не думаете, что автор предложил исключительно вам двоим опробовать свой продукт?С таким же успехом можно, пойти, например на форум TSLaba и возмущаться там, зачем мне ваша хрень, я и сам могу тестер написать.
Достойный ответ, который я не смог сформулировать так четко.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Владимир написал: И любые примочки доморощенных "сторонних исполнителей" - библиотеки, внешние модули, не говоря уже про "специализированную ОС" - только добавляют глюков в этот винегрет.
Я согласен с выше написанным, но вы ломитесь в открытую дверь
Цитата
TGB написал: уговариваю пользователей не лезть без нужды ни в какие дебри, а решать свои задачи наиболее простыми и понятными для себя средствами.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Владимир написал: И он прекрасно реализован с помощью парочки lua-таблиц: одна основная, другая - контекстное меню, всплывающее по клику на строчку первой.
Я же написал, что диалог можно сделать на таблицах, некстати, обслуживаемых основным потоком QUIK. У вас все хорошо. Ну и замечательно! Кстати, какой-то диалог можно реализовать и на обычном Блокноте -----
Цитата
TGB написал: Кроме того, для пользователя предусмотрена возможность настройки обработки собственных сложных команд, задаваемых в командной строке формы диалога.
Дополнительно, для пользователя доступны все возможности графического пакета iup (это, по поводу комментария Nikolay о простом диалоге). ---- Вообще, мне кажется, что у нас спор ни о чем. Я же не предлагаю заменить диалог Nikolay или запретить использование таблиц QUIK. Я даже уговариваю пользователей не лезть без нужды ни в какие дебри, а решать свои задачи наиболее простыми и понятными для себя средствами.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Nikolay написал: Так я и спрашиваю какой такой случай требует использование этого продукта. Просто для примера.
1. Допустим, что в вашем скрипте нужен диалог. В данном продукте реализация диалога пользователя это модификация в TS_QUIK.lua готовой таблицы «меню пользователя» с заданием функций-обработчиков команд и определение этих функций. И это все, что при этом требуется.
Образец таблицы меню пользователя, который надо будет модифицировать под конкретное приложение: -- Таблица описания диалога приложения (образец) --- local mmenu = { "Меню 1 (образец)", { "Команда 1", default, -- default - функция-реакция ---- "Команда 2", default, "Команда 3",default, "-", nil, "...........", default } ,"Меню 2 (образец)", { "Команда 4",default, "Команда 5", default, "-------------",nil, "Подменю ", { "Команда 6", default, "Команда 7", default } } } В образце default это функция-обработчик команды (их надо заменить на свои после изменения таблицы под свои нужды). Кроме того, для пользователя предусмотрена возможность настройки обработки собственных сложных команд, задаваемых в командной строке формы диалога. Можно сделать диалог другим способом? Конечно, можно (на таблице QUIK, используя VCLua, вообще написать на ассемблере). Вопрос состоит только в том, насколько удобным, расширяемым будет этот диалог и как это сделать быстрее.
2. Допустим, что вам нужны таймерные события, обеспечивающие временные интервалы. В данном продукте вы их можете заказывать. Можно реализовать таймерные события другим способом? Можно, но это надо будет делать.
3. Предположим, что вам нужно реализовать контрольные точки, обеспечивающие продолжение работы скрипта после его перезапуска по любой причине. В данном продукте есть специальные средства создания и использования контрольных точек. Можете вы это сделать сами? Да, но при этом вам придется, в каком-то виде разработать что-то похожее на то, что уже реализовано. ------
Приведенный список можно продолжить, но, кому это интересно, может прочесть в файле OS_Quesha.pdf.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
При работе с iup в отдельном потоке (как это сделано у меня) я проблем не встретил.
Цитата
swerg написал: Посмотрите иностранные рекламные ролики сельхоз. техники. Это крайне залипательно! И, главное, там много что можно почерпнуть в плане формата подачи рекламного материала.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
В нормативно-правовых актах определено некоммерческое использование: "Допускается без согласия автора или иного правообладателя воспроизведение, осуществляемое только гражданином и только в личных целях, под которыми по смыслу статьи 1273 Кодекса понимается последующее некоммерческое использование соответствующего экземпляра для удовлетворения собственных потребностей или потребностей обычного круга семьи этого гражданина (который определяется судом с учетом конкретных обстоятельств рассматриваемого дела)." (Постановление от 26 марта 2009 г. № 5/29 Пленума Верховного Суда Российской Федерации и Пленума Высшего Арбитражного Суда Российской Федерации)
Цитата
Nikolay написал: Раз уж Вы разместили это здесь, то хотелось бы увидеть пример применения, где средств lua будет явно недостаточно и необходимо использовать данный продукт.
Список операций, поддерживаемых Lua алгоритмически полный. То есть, на этом языке можно реализовать любой алгоритм. Но точно также, можно задать похожий вопрос: почему бы вместо Lua не использовать ассемблер? Назначение данного продукта не в том чтобы заменить Lua. Это в каком-то смысле «станок» с готовой инфраструктурой, которая в том или ином виде требуется для разработки сложных программных систем. Как было сразу отмечено в моем начальном комментарии, для простых случаев не надо ничем заморачиваться, а использовать обычные QLua-скрипты.
Средства разработки многопоточных скриптов в QUIK., OS_Quesha, свидетельство регистрации в Роспатенте № RU 2020612905. Бесплатная для некоммерческого использования.
Владимир написал: НА КОЙ, простите, мне эту хрень устанавливать у себя?
Читаем:
Цитата
Владимир написал: если ваш робот простой и не требует возможности, предоставляемых OS_Quesha, то, скорее всего, его проще создать в виде обычного QLua-скрипта.