Если бы я был архитектором QUIK, Что стоило бы изменить в QUIK по-крупному
Пользователь
Сообщений: Регистрация: 15.06.2023
18.07.2026 20:12:29
TGB, Ну просто не могу ни промолчать. Вы это серьёзно? Ну в какие это времена, "Черный ящик" кому то помог? Не примите за навязчивость, но очень Вам советую прочесть книгу доктора технических наук И.Н. Острецова. Учёный, физик-ядерщик, доктор технических наук, профессор, специалист по ядерной физике и атомной энергетике, ликвидатор Чернобыля в своих выводах и доказательствах, приходит к выводу единого начала. Думаю хватит Вам компетенций по достоинству ее осмыслить. От себя лишь добавлю, у любой системы есть начало и ее конец, и ее главное звено (Идея).
Пользователь
Сообщений: Регистрация: 12.05.2020
20.07.2026 09:57:06
Цитата
TGB написал: ---- Ответ ИИ ---- Вы затронули одну из самых захватывающих и сложных тем в системном программировании — отказ от атомарных переменных (Lock-free без std::atomic) ради выжимания последних наносекунд производительности. На теоретическом уровне вы абсолютно правы: если математически гарантировать, что писатель не наступил на пятки читателю «спереди» и не обогнал его «сзади», то данные должны быть корректными.
В коде моего комментария 97 есть ошибка реализации моего теоретического представления, найденная ИИ.
Пользователь
Сообщений: Регистрация: 12.05.2020
25.07.2026 10:55:17
Версия кода после обсуждения с ИИ:
Код
// ============== Вариант реализации очередей событий QUIK (Lock-free, ~300 строк) ============
// Параметр Q_MAX определяет количество очередей в схеме очередей. Схем обработки очередей можно
// создать несколько.
// Данные, передаваемые в информационных очередях, строки.
// 1. Формат записи данных - текст описания таблицы Lua:
// {name = <Имя коллбека>, tbl = {<Таблица для формирования вызова функции пользователя>}}
// После чтения выполнять десереализацию текста таблицы Lua и дальше обрабатывать с учетом значения name.
// name обеспечивает возможность группировка коллбеков по очередям.
// 2. Коллбеки можно, но необязательно, сгруппировать и группы распределить по очередям с учетом того,
// что при чтении обработка начинается с 0-й очереди. Параметры очередей size_max следует задать
// такими, чтобы в них помещались строки их данных.
// Для коллбеков пользовательских таблиц QUIK, наверное, имеет смысл использовать все таки отдельную
// очередь.
// 3. Параметр FILLING_THRESHOLD - порог заполненности очередей для выдачи предупреждения о высоком уровне
// заполненности очередей.
// 4. После первого цикла любой очереди, память ее созданных элементов переиспользуется
// (кроме чтения указателя нет затрат на управление ее памятью).
// 5. Если для читающего потока в какой то его очереди возникнет переполнение, то об этом
// выдается сообщение.
// 6. Реализованы режимы записи в очереди: 0 - без сигналов (более эффективный); 1 - с сигналами.
// ----------------------------------------------------------------------
// Результат теста (оценка эффективности реализации очередей)
// Режим записи в очереди: без сигналов.
// Писатель выполняет в цикле запись в 10 очередей. Циклов записи : 1000
// T - время выполнения потоков с учетом их пауз в млс.
//-->Писатель. Пауза: 1. T (млс.): 1977. Обработано записей: 10000. Время ЦП (млс.): 3.4494
//Читатель 3. Пауза: 50. T (млс.): 2023. Обработано записей: 10000. Время ЦП (млс.): 1.3174
//Читатель 1. Пауза: 5. T (млс.): 2023. Обработано записей: 10000. Время ЦП (млс.): 1.1746
//Читатель 4. Пауза: 100. T (млс.): 2023. Обработано записей: 10000. Время ЦП (млс.): 1.2129
//Читатель 2. Пауза: 10. T (млс.): 2023. Обработано записей: 10000. Время ЦП (млс.): 1.2194
// -------------------------------------------------------------------------------
// Краткое ТЗ на разработку очередей
// 1) Создаются несколько циклических информационных очередей с разными типами данных и общим объектом
// управления ими.
// 2) В очереди пишет данные один поток, а читают эти очереди несколько потоков.
// 3) Дополнительно создается специальная служебная циклическая очередь: битовые шкалы непустых информационных
// очередей, записываемых пишущим потоком, после записи в информационные очереди.
// 4) У читающих потоков должны быть свои указатели чтения циклических очередей и их локальные битовые шкалы
// непустых очередей, хранящиеся в их объекте доступа к информационным очередям.
// 5) Читающие потоки циклически, выполнив свои коды переходят в состояние ожидания сигнала появления данных
// в их очередях или истечения заданного интервала времени на их общем объекте ожидания.
// 6) При записи в любую очередь пишущий поток после записи в информационные очереди записывает битовые шкалы
// непустых очередей в служебную очередь шкал непустых очередей и [активирует в режиме 1] все читающие потоки.
// 7) Каждый читающий поток, при пробуждении, читает все появившиеся записи в служебной очереди шкал непустых
// очередей и формирует свою локальную шкалу непустых очередей и далее, на ее основании, читает без
// синхронизации, непустые очереди с признаком : состояние прочитанных очередей в виде размера непрочитанных
// данных.
// 8) Реализовать эффективное управление памятью при передаче данных в этих очередях.
// C++20 (используется std::countr_zero) ---
#include <shlobj.h>
#include <windows.h>>
#include <iostream>
#include <vector>
#include <thread>
#include <chrono>
#include <mutex>
//#include <condition_variable>
//#include <atomic>
//#include <bitset>
//#include <intrin.h>
#pragma comment(lib, "winmm.lib") // Установить точность таймера 1 мс
// Параметры тестирования очередей ---
const int N_MAX = 2000; // Количество циклов записи при тестировании
//#define win32_API // В реализации очередей используется win32_API
const int QUEUE_RECORDING_MODE = 0; // Режим записи в очереди: 0 - без сигналов; 1 - с сигналами
const INT64 Q_SIZE = 64; // Длина информационной очереди по умолчанию
const INT64 Q_SIZE_SL = 128; // Длина служебной очереди шкал непустых информационных очередей
const int Q_MAX = 64; // Максимальное количество очередей
const int Количество_очередей = 64; // Количество используемых очередей ( <= Q_MAX)
const int LEN_STR_MAX = 4096; // Размер буфера потоков чтения (максимум size_max_str всех используемых очередей)
const double FILLING_THRESHOLD = 0.4; // Порог заполненности очередей для выдачи предупреждения об уровне заполненности очередей
// Системное время (синхронизированное). Точность 0,1 мкс.---
static INT64 T_OS_high_mls()
{
FILETIME lpSystemTimeAsFileTime;
GetSystemTimePreciseAsFileTime(&lpSystemTimeAsFileTime); // Системное время (синхронизированное)
INT64 tt = lpSystemTimeAsFileTime.dwHighDateTime;
tt = (tt << 32) + lpSystemTimeAsFileTime.dwLowDateTime;
return tt;
}
// Строка-объект информационной очереди (переиспользуемая) --
struct alignas(64) q_str {
INT64 tail = -1; // Указатель записи ---
INT64 size_max = 0; // Максимальный размер памяти строки (с учетом символа конца строки '\0')
INT64 size = 0; // Текущий размер памяти строки (с учетом символа конца строки '\0')
int n_q = 0; // Номер очереди
char* str = NULL; // Память строки (размер size_max) ----
int state = 0; // Состояние (не используется, но на всякий случай): 1 - занята пишущим потоком; 2 - в очереди.
};
// Параметры очереди, задаваемые при ее инициализации --
struct q_parm {
std::string name_Queue = ""; // имя очереди
INT64 q_size = 64; // длина очереди
INT64 size_max_str = 64; // максимальная память строки в информационной очереди
};
// Шаблонная циклическая очередь (Lock-free)
// Используется для служебной и информационных очередей
template<typename T>
class alignas(64) Queue {
public:
std::vector<T> buffer;
//volatile INT64 tail = 0;
std::atomic<INT64> tail{ 0 }; // пишет только один писатель
std::string name_Queue = ""; // имя очереди (можно менять при начальной инициализации)
INT64 q_size = 64; // размер очереди (можно менять при начальной инициализации)
INT64 size_max_str = 64; // максимальная память строки в очереди (можно менять при начальной инициализации)
Queue(INT64 s = Q_SIZE) : buffer(s), q_size(s) {}
// Изменение длины очереди ---
void q_size_set(int s) {
buffer.reserve(s); q_size = s;
}
// запись в очередь --
bool push_v(T val) {
buffer[tail.load(std::memory_order_relaxed) % q_size] = val;
//++tail;
tail.fetch_add(1, std::memory_order_relaxed);
return true;
}
// Чтение из очереди --
T get_v(INT64 h_v) {
if (tail.load(std::memory_order_relaxed) - h_v <= 0) return NULL;
T val = buffer[h_v % q_size];
if (tail.load(std::memory_order_relaxed) - h_v >= q_size - 1) throw std::invalid_argument("**** Переполнение при чтении");
return val;
}
// Количества доступных элементов очереди для конкретного читателя
// local_head - указатель чтения (читающего потока)
// Если отрицательное значение, то: количество пропущенных при чтении записей очереди --
INT64 get_pending_count(INT64 local_head) const {
INT64 t = tail.load(std::memory_order_relaxed) - local_head;
return (t <= q_size ? t : q_size - t);
}
};
// Объявления (определяются позже)
struct alignas(64) ReaderAccess;
struct alignas(64) Manager;
//-------------------------------
// Информационные очереди событий --
struct alignas(64) DataCluster {
// Деструктор (! выход из блока кода, в котором определен DataCluster
// только при завершения потоков, использующих его) --
~DataCluster() {
for (int i = 0; i < Q_MAX; ++i) {
INT64 size = Queue_QUIK[i].buffer.size();
INT64 tail = Queue_QUIK[i].tail.load(std::memory_order_relaxed);
INT64 N = (tail >= size) ? size : tail; // Буфер может быть неполным ---
for (int j = 0; j < N; ++j) {
q_str* q_s = Queue_QUIK[i].buffer[j]; // #### ИИ: заменить 1 на j
delete[]q_s->str;
delete q_s;
}
}
}
int count_q = 64; // Количество используемых информационных очередей (<= Q_MAX) --
// При количестве очередей > 64 один бит шкалы непустых очередей соотносится
// к нескольким ((count_q - 1) / 64 + 1) последовательным очередям, в которых,
// возможно, есть записи.
UINT32 Queue_grouping = 1;
Queue<q_str*> Queue_QUIK[Q_MAX];
// Задать количество используемых очередей и их параметры
void set_parm_q(int n, q_parm* parm) {
if (n > 0 && n <= Q_MAX)
count_q = n;
else
throw std::runtime_error(" Количество используемых очередей > Q_MAX или <= 0"); /* #### ошибка*/
Queue_grouping = (count_q - 1) / 64 + 1;
if (parm != NULL)
for (int i = 0; i < count_q; ++i) {
Queue_QUIK[i].name_Queue = parm->name_Queue;
Queue_QUIK[i].q_size = parm->q_size;
Queue_QUIK[i].q_size_set(parm->q_size);
Queue_QUIK[i].size_max_str = parm->size_max_str;
}
}
// Функция формирования маски группировки очередей (многозначное отображение очередей на шкалу непустых)
uint64_t q_mask(int q_i) { return (uint64_t)1 << (q_i / Queue_grouping); }
// Запрос памяти потоком писателем под запись очереди --
// Запрос памяти системы и формирование строки-объекта -----
q_str* get_q_s(int q_i) {
INT64 size_max_str = Queue_QUIK[q_i].size_max_str;
char* str = new char[size_max_str];
str[size_max_str - 1] = '\0';
q_str* q_s = new q_str;
q_s->str = str;
q_s->size_max = size_max_str;
q_s->size = 0;
q_s->n_q = q_i;
return q_s;
}
// Запрос строки-объекта потоком записи для формирования строки
q_str* get_str(int q_i) {
q_str* q_s;
INT64 t = Queue_QUIK[q_i].tail.load(std::memory_order_relaxed) % Queue_QUIK[q_i].q_size;
if (Queue_QUIK[q_i].buffer[t] != NULL) { // Получение памяти из очереди --
q_s = Queue_QUIK[q_i].buffer[t];
q_s->tail = -1;
}
else { // Запрос памяти у системы --
q_s = get_q_s(q_i);
q_s->tail = -1;
}
return q_s;
}
// Инициализация используемых очередей строками-объектами --
// #### Вряд ли стоит использовать ---
void initialization_q_str() {
if (count_q > 0) {
for (int i = 0; i < count_q; ++i) {
int size = Queue_QUIK[i].q_size;
for (int j = 0; j < size; ++j) {
if (Queue_QUIK[i].buffer[j] == NULL)
Queue_QUIK[i].buffer[j] = get_q_s(i);
}
}
}
}
// Начальная инициализация указателей чтения в потоке-читателе на основе указателей
// записи в очереди (при начальной инициализации потока)
// Объявление.
void init_access(ReaderAccess* access, Manager* mgr, DataCluster* dc);
// запись в очередь --
bool push(int q_n, q_str* val) {
if (q_n < 0 || q_n >= count_q) throw std::runtime_error("*** Ошибка: нет такой очереди");
INT64 tail_p = Queue_QUIK[q_n].tail.load(std::memory_order_relaxed);
val->tail = tail_p;
Queue_QUIK[q_n].buffer[tail_p % Queue_QUIK[q_n].q_size] = val;
Queue_QUIK[q_n].tail.fetch_add(1, std::memory_order_relaxed);
return true;
}
};
//struct ReaderAccess; // Используется в Manager
#ifndef win32_API
// Объект управления потоками чтения
struct Manager {
INT64 signal_counter = 0; // Счетчик сигналов записи
int Выдавать_сигналы = 0; // 0 - без выдачи сигнала; 1 - выдача сигнала
Queue<uint64_t> service_q{ Q_SIZE_SL }; // Служебная очередь битовых шкал
//--------- condition_variable --
std::mutex mtx; // Для синхронизации при ожидании
std::condition_variable cv; // Общий объект ожидания
void pulse(uint64_t mask) {
service_q.push_v(mask); ++signal_counter;
if (Выдавать_сигналы == 1)
cv.notify_all();
}
void wait(ReaderAccess* access); // !! Реализация после struct ReaderAccess (иначе недоступны поля)
};
#else // !win32_API
// Вариант 2. #### Этот вариант работает, но предыдущий лучше --
struct Manager {
INT64 signal_counter = 0; // Счетчик сигналов записи
int Выдавать_сигналы = 0; // 0 - без выдачи сигнала; 1 - выдача сигнала
Queue<uint64_t> service_q{ Q_SIZE_SL }; // Служебная очередь битовых шкал
//--------- condition_variable --
CRITICAL_SECTION cs;
CONDITION_VARIABLE cv;
Manager() {
InitializeCriticalSection(&cs);
InitializeConditionVariable(&cv);
}
void pulse(uint64_t mask) {
service_q.push(mask);
++signal_counter;
EnterCriticalSection(&cs); // #### ?
if (Выдавать_сигналы == 1) {
WakeAllConditionVariable(&cv); // Будим тех, кто еще спит
}
LeaveCriticalSection(&cs); // #### ?
}
void wait(ReaderAccess* access); // !! Реализация после struct ReaderAccess (иначе недоступны поля)
};
#endif // !win32_API
// Объект доступа к очередям для читающих потоков --
struct alignas(64) ReaderAccess {
INT64 h_data[Q_MAX] = { 0 }; // Локальные указатели чтения очередей
INT64 h_service = 0; // Указатель чтения служебной очереди
uint64_t local_bitmask = 0; // Локальная шкала непустых очередей потока-читателя
INT64 signal_counter = 0; // Локальный счетчик сигналов записи
// -------- Статистика очередей ---------
INT64 NN[Q_MAX] = { 0 }; // Коичество обращений к непустым очередям
double statistics[Q_MAX] = { 0 }; // Сумма относительной заполненности очередей (среднее = statistics [i]/ (NN[i]))
double q_filling_threshold = 0.4; // Порог заполненности очередей для выдачи предупреждения --
int period_agr = 9; // Период скользящей
// ------- Данные снимка состояния очередей потока чтения ---
int q_len[Q_MAX] = { 0 }; // Количество непустых непрочитанных записей в очередях
int q_n[Q_MAX] = { 0 }; // Номера непустых очередей
int q_p = 0; // Длина векторов q_n и q_len
// Снимок состояния очередей потока-читателя ("мгновенный", чтобы меньше было повторных чтений очередей).
void snapshot_queue_state(DataCluster& dc, Manager& mgr) {
q_p = 0; // Сброс длины векторов q_n и q_len
// Формирование шкалы непустых очередей потока-читателя и снимка состояния очередей потока-читателя
INT64 count = mgr.service_q.get_pending_count(h_service);
if (count > 0) {
// Формируем общую локальную шкалу непустых очередей потока-читателя --
local_bitmask = 0;
uint64_t mask_val;
// -----
INT64 q_size = mgr.service_q.q_size;
for (int i = 0; i < count; ++i) {
mask_val = mgr.service_q.buffer[h_service % q_size];
if (mgr.service_q.tail.load(std::memory_order_relaxed) - h_service >= q_size - 1) // ####
std::cout << " *** Ошибка переполнение служебной очереди (при чтении) Queue_QUIK \n"; // #### Ошибка переполнение очереди
++h_service;
local_bitmask |= mask_val;
//++h_service;
}
// Формирование снимка состояния очередей потока-читателя (на основе его шкалы) --
int pos_old = 0;
int Queue_grouping = dc.Queue_grouping;
while (local_bitmask) { // Эффективная обработка шкалы непустых очередей --
//// ! Способ определения позиции младшего разряда для старых стандартов (MSVC) -----
// unsigned long pos3 = 0;
// _BitScanForward64(&pos3, local_bitmask); // позиция младшего разряда с 1
//// -------------------------------------------------
int Сдвиг = std::countr_zero(local_bitmask); // C++20 (позиция младшего разряда с 1)
int pos = Сдвиг + pos_old;
pos_old = pos + 1;
pos *= Queue_grouping;
for (int i = 0; i < Queue_grouping; ++i) { // обработка групп очередей разряда шкалы --
INT64 q_count = dc.Queue_QUIK[pos + i].get_pending_count(h_data[pos + i]);
if (q_count > 0) {
int p = q_p;
q_n[p] = pos + i;
q_len[p] = q_count;
// Статистика заполненности очереди (относительная, приблизительно средне скользящая)
if (++NN[pos + i] < period_agr) {
statistics[pos + i] += (double)q_count / (double)dc.Queue_QUIK[pos + i].q_size;
}
else {
statistics[pos + i] += (double)q_count / (double)dc.Queue_QUIK[pos + i].q_size - statistics[pos + i] / period_agr;
}
// --------------------------------------------------------------------------------
++q_p;
}
else
if (q_count < 0) std::cout << " *** Ошибка переполнение очереди (при чтении) Queue_QUIK = " << pos + i << ": q_count = " << q_count << "\n"; // #### Ошибка переполнение очереди
}
local_bitmask >>= Сдвиг + 1;
}
}
else
if (count < 0) std::cout << " *** -- Ошибка переполнение служебной очереди шкал --\n";
}
// Чтение строки-объекта очереди --
// q_n - номер очереди
// q_str* s1 -- буфер чтения (структура в стеке)
q_str* get_q_str(int q_n, q_str* s1, DataCluster& dc) {
if (s1->str == NULL) throw std::runtime_error("*** Ошибка: нет памяти для копирования");
INT64 tail_h = h_data[q_n];
if (tail_h >= dc.Queue_QUIK[q_n].tail.load(std::memory_order_relaxed)) return NULL; // нет записи --
INT64 q_size = dc.Queue_QUIK[q_n].q_size;
q_str* val = dc.Queue_QUIK[q_n].buffer[tail_h % q_size];
if (val != NULL) { // есть запись --
s1->size = val->size;
s1->n_q = val->n_q;
// s1->size - размер памяти строки (с учетом символа конца строки '\0')
// Длина строки: (s1->size - 1)
memcpy(s1->str, val->str, s1->size); s1->tail = tail_h; // ! Обязательно в таком порядке --
s1->state = val->state;
// Дополнительный контроль корректности чтения очереди (после копирования в буфер потока чтения)
// ! Чтение dc.Queue_QUIK[q_n].tail обязательно
if (dc.Queue_QUIK[q_n].tail.load(std::memory_order_relaxed) - tail_h >= q_size - 1) std::cout << " *** Ошибка чтения очереди (переполнение) " << s1->n_q << "\n";
++h_data[q_n];
}
return val;
}
};
// ! Реализация члена DataCluster (расположена после struct ReaderAccess, Manager и DataCluster
// чтобы в методе были доступны их поля)
// Начальная инициализация указателей чтения в потоке-читателе на основе указателей
// записи в очереди (при начальной инициализации потока)
void DataCluster::init_access(ReaderAccess* access, Manager* mgr, DataCluster* dc) {
int count_q = dc->count_q;
if (count_q <= 0) throw std::runtime_error("*** Ошибка: не задано количество используемых очередей");
// Получение указателя служебной очереди
access->h_service = mgr->service_q.tail.load(std::memory_order_relaxed);
// Получение указателей информационных очередей
for (int i = 0; i < count_q; ++i) access->h_data[i] = Queue_QUIK[i].tail.load(std::memory_order_relaxed);
}
// ! Реализация члена Manager (расположена после struct ReaderAccess чтобы в методе были
// доступны ее поля)
// Пауза
#ifndef win32_API
void Manager::wait(ReaderAccess* access) {
if (access->signal_counter == signal_counter) {// не было сигнала записи при отсутствии ожидания в потоке чтения
std::unique_lock<std::mutex> lock(mtx);
cv.wait_for(lock, std::chrono::milliseconds(2)) == std::cv_status::timeout;
}
access->signal_counter = signal_counter; // Обрабатываемый сигнал записи в потоке чтения
}
#else // !win32_API
// Вариант 2. #### -------
void Manager::wait(ReaderAccess* access) {
if (access->signal_counter == signal_counter) {// не было сигнала записи при отсутствии ожидания в потоке чтения
EnterCriticalSection(&cs);
// Пытаемся дождаться условия в течение заданного timeout
if (!SleepConditionVariableCS(&cv, &cs, 2)) {
if (GetLastError() == ERROR_TIMEOUT) {
//std::cout << "Thread [" << tt << "ms] TIMED OUT!" << std::endl;
}
}
else {
//std::cout << "Thread [" << tt << "ms] GOT SIGNAL!" << std::endl;
}
LeaveCriticalSection(&cs);
}
access->signal_counter = signal_counter; // Обрабатываемый сигнал записи в потоке чтения
}
#endif // !win32_API
// Тестирование очередей событий ------------------------------------------------
// Формат записываемых строк общий для всех очередей: тексты таблиц Lua (сереализация).
// Читающий поток выполняет десереализацию полученных строк и запуск Lua-функций обработки событий.
// ----------------------------------------------------
// Функция потока-писателя
void producer(DataCluster& dc, Manager& mgr) {
std::cout << "Писатель. Запись выполняется в 10 очередей. Циклов записи: " << N_MAX << std::endl;
std::cout << "T - время выполнения потоков с учетом их пауз." << std::endl;
// -------------------------------------
INT64 tt = T_OS_high_mls(); // Для подсчета времени ЦП --
INT64 TT = tt; // Для замера времени выполнения ---
INT64 TCP = 0; // Время ЦП ---
INT64 NRQ = 0; // Количество обработанных записей
int dt = 1;
int q_n_test = 0;
for (int i = 1; i <= N_MAX; ++i) {
tt = T_OS_high_mls() - tt;
TCP += tt;
//std::this_thread::sleep_for(std::chrono::milliseconds(dt)); // Пауза потока записи
Sleep(dt); // И так можно
tt = T_OS_high_mls();
// %%%%%% Подготовка данных для записи в очереди в виде C-строк
// Запись строк в очереди --
uint64_t mask = 0; // шкала непустых очередей
// Запись в разные очереди
// !! rec->size - размер памяти строки (с учетом символа конца строки '\0')
// Длина строки: (rec->size - 1)
const char* source = "{name = 'OnCleanUp',tbl = { ....] }";
int sz = strlen(source) + 1;
q_n_test %= 2;
int q_n_test1 = q_n_test * 4; // Для записи в разные очереди
q_str* rec = dc.get_str(0 + q_n_test1); memcpy(rec->str, source, sz); rec->size = sz;
if (dc.push(0 + q_n_test1, rec)) mask |= dc.q_mask(0 + q_n_test1); ++NRQ;
rec = dc.get_str(1 + q_n_test1); memcpy(rec->str, source, sz); rec->size = sz;
if (dc.push(1 + q_n_test1, rec)) mask |= dc.q_mask(1 + q_n_test1); ++NRQ;
rec = dc.get_str(2 + q_n_test1); memcpy(rec->str, source, sz); rec->size = sz;
if (dc.push(2 + q_n_test1, rec)) mask |= dc.q_mask(2 + q_n_test1); ++NRQ;
rec = dc.get_str(3 + q_n_test1); memcpy(rec->str, source, sz); rec->size = sz;
if (dc.push(3 + q_n_test1, rec)) mask |= dc.q_mask(3 + q_n_test1); ++NRQ;
++q_n_test;
rec = dc.get_str(40); memcpy(rec->str, source, sz); rec->size = sz;
if (dc.push(40, rec)) mask |= dc.q_mask(40); ++NRQ;
rec = dc.get_str(41); memcpy(rec->str, source, sz); rec->size = sz;
if (dc.push(41, rec)) mask |= dc.q_mask(41); ++NRQ;
rec = dc.get_str(40); memcpy(rec->str, source, sz); rec->size = sz;
if (dc.push(40, rec)) mask |= dc.q_mask(40); ++NRQ;
rec = dc.get_str(41); memcpy(rec->str, source, sz); rec->size = sz;
if (dc.push(41, rec)) mask |= dc.q_mask(41); ++NRQ;
rec = dc.get_str(42); memcpy(rec->str, source, sz); rec->size = sz;
if (dc.push(42, rec)) mask |= dc.q_mask(42); ++NRQ;
rec = dc.get_str(60); memcpy(rec->str, "шшшшшш", 7); rec->size = 7;
if (i >= N_MAX) rec->state= -1; // Признак читателям завершить поток ---
if (dc.push(60, rec)) mask |= dc.q_mask(60); ++NRQ; // "шшшшшш"
// std::cout << "[P] Данные записаны, маска: " << std::bitset<64>(mask) << std::endl; // ####
// Запись маски и активация потоков
mgr.pulse(mask);
}
std::stringstream out; // можно использовать <<
out << "---> Писатель. Пауза:" << dt
<< ". T (млс.):"
<< (int)((T_OS_high_mls() - TT) * 0.0001) << ". Обработано записей:" << NRQ
<< ". Время ЦП (млс.):" << TCP * 0.0001 << "\n";
std::string result = out.str(); // Получаем std::string
std::cout << result;
}
// Заглушка функции обработки событий --
// Выполняет десереализацию полученных строк и запуск Lua-функций обработки событий
// в зависимости от name (вида очереди)
// 1) !! Память q_s возвращать не надо
// 2) !! q_s->size - размер памяти строки (с учетом символа конца строки '\0')
// Длина строки: (q_s->size - 1)
void event_handling(q_str* q_s, std::string name) {
}
// Функция потоков-читателей --
// filling_threshold - порог заполненности очередей (<текущее количество записей очереди> / <размер очереди>)
// для выдачи предупреждений: "Превышен порог заполненности очередей"
// dt - пауза (млс.)
void consumer(int id, DataCluster& dc, Manager& mgr, double filling_threshold, int dt) {
ReaderAccess access;
access.q_filling_threshold = filling_threshold;
// Инициализация access.h_data и access->h_service с учетом текущего состояния очередей
dc.init_access(&access, &mgr, &dc); // "Встраивание" потока чтения в очереди
// Буфер строки-объекта для дальнейшей обработки - q_str_c --
const char str_copy[LEN_STR_MAX] = {'\0'};
q_str q_str_c; q_str_c.str = (char*)str_copy; q_str_c.size_max = LEN_STR_MAX;
// -------------------------------------
INT64 tt;
INT64 TT = T_OS_high_mls(); // Для замера общего времени выполнения ---
INT64 DT = 2 * 10000; //
INT64 DTT = 0;
INT64 TCP = 0; // Для замера времени ЦП обработки очередей
INT64 NRQ = 0; // Количество обработанных записей
INT64 NACT = 0; // Количество активаций потока чтения
while (true) { // Пользовательский цикл обработки
DTT = T_OS_high_mls() + DT;
while ((T_OS_high_mls() - DTT) < 0) { // Цикл обработки очередей событий
// Пауза
mgr.wait(&access);
tt = T_OS_high_mls();
++NACT;
// ------------------------------------------------------------------
// Получение снимка состояния очередей потока
access.snapshot_queue_state(dc, mgr);
// Обработка снимка состояния очередей потока:
// 1) access.q_p - вектор номеров непустых очередей
// 2) access.q_len - вектор длин необработанных очередей
// 3) access.q_p - длина векторов 1), 2)
int q_p = access.q_p;
// Просмотр и обработка вектора непустых очередей потока чтения
for (int i = 0; i < q_p; ++i) {
int q_n = access.q_n[i];
int count = access.q_len[i]; // Количество записей в очереди --
// ------- Сбор статистики ----
double statistics_agr = access.statistics[q_n] / (access.NN[q_n] < access.period_agr ? access.NN[q_n] : access.period_agr);
if (statistics_agr > access.q_filling_threshold) // #### Предупреждающее сообщение --
std::cout << "[Поток: " << id << "] Очередь "
<< q_n << ". Заполненность (средняя): " << statistics_agr
<< ". *** Превышен порог заполненности очередей: " << access.q_filling_threshold << "\n";
//// Отладочная печать
//if (count > 0 || count < 0)
// std::cout << "[Поток: " << id << "] Очередь "
// << q_n << ". Заполненность (средняя): " << statistics_agr
// << ". Количество: " << count << ". Ук чтения " << access.h_data[q_n] << "\n";
// --------------------
INT64 q_size = dc.Queue_QUIK[q_n].q_size;
// Чтение и обработка очередей
while (count-- > 0) {
// Копировать запись очереди в буфер обработки q_str_c (типа q_str),
// созданный в стеке --
q_str* val_q = access.get_q_str(q_n, &q_str_c, dc);
if (val_q == NULL) continue;
event_handling(&q_str_c, dc.Queue_QUIK[q_n].name_Queue); // Вызов функции обработки записи очереди
++NRQ; // Количество обработанных записей
// Результат теста
// Завершение потока при тестировании --
if (q_str_c.state == -1) { // Признак читателям завершить поток ---
std::stringstream out; // можно использовать <<
out << "Читатель " << id << ". Пауза:" << dt
<< ". T (млс.):"
<< (int)((T_OS_high_mls() - TT) * 0.0001) << ". Обработано записей:" << NRQ
<< ". Циклов обработки:" << NACT
<< ". Время ЦП (млс.):" << TCP * 0.0001 << "\n";
std::string result = out.str(); // Получаем std::string
std::cout << result;
return;
}
// Отладочная печать
//const char* val_str = q_str_c.str;
//if (access.h_data[q_n] == N_MAX) {
// std::cout << " Поток " << id << ". Очередь " << q_n << " -> Val(str): " << val_str << ". Указатель чтения "
// << access.h_data[q_n] << ". Интервал (млс.) " << (T_OS_high_mls() - TT) * 0.0001 << "\n";
//}
}
}
TCP += (T_OS_high_mls() - tt); // время обработки очередей --
}
tt = T_OS_high_mls(); // Начало обработки пользовательского цикла --
//// %%%%%%%%%%%% Обработка остальных кодов (пользователя) в потоке чтения --
//if (dt > 50)
// std::cout << " Поток " << id << ". Интервал " << dt * 10000 - (T_OS_high_mls() - tt) << "\n";
// Конец обработки пользовательского цикла --
// Коррекция DT с учетом времени выполнения пользовательского цикла --
DT = dt * 10000 - (T_OS_high_mls() - tt);
DT = DT > 20000 ? DT : 20000;
}
}
// --------------------- Тест очередей -------------------------
int main() {
SetConsoleCP(1251); // Кодировка 1251 (! #include <shlobj.h>)
setlocale(LC_ALL, ""); // #### Русификация вывода ввода (работает) -----
timeBeginPeriod(1); // Установить точность 1 мс
// ==================================
#ifdef win32_API
std::cout << "В реализации используется win32_API" << std::endl;
#endif
DataCluster dc; // Очереди ---
// 1. Для каждой очереди должен быть задан размер памяти для максимальной строки, передаваемой
// в ней (с учетом признака конца строки '\0').
// 2. В вызове метода set_parm_q второй параметр: вектор типа q_parm * с параметрами очередей
// 3. Порядок элементов в векторе определяет приоритет обработки очередей (0 -> 1 ...)
q_parm* Параметры_очередей = NULL; // Параметры_очередей[Количество_очередей]
dc.set_parm_q(Количество_очередей, Параметры_очередей);
//dc.initialization_q_str(); // #### Вряд ли стоит использовать ---
Manager mgr; // Объект управления потоками чтения
mgr.Выдавать_сигналы = QUEUE_RECORDING_MODE; // Режим записи в очереди: 0 - без сигналов; 1 - с сигналами
std::cout << "Режим записи в очереди: " << (mgr.Выдавать_сигналы == 0 ? "без сигналов" : "с сигналами") << std::endl;
// Читающие потоки --
// Последний параметр интервал ожидания (млс.)
std::thread c1(consumer, 1, std::ref(dc), std::ref(mgr), FILLING_THRESHOLD, 3);
std::thread c2(consumer, 2, std::ref(dc), std::ref(mgr), FILLING_THRESHOLD, 10);
std::thread c3(consumer, 3, std::ref(dc), std::ref(mgr), FILLING_THRESHOLD, 50);
std::thread c4(consumer, 4, std::ref(dc), std::ref(mgr), FILLING_THRESHOLD, 100);
// Пишущий поток --
std::thread p(producer, std::ref(dc), std::ref(mgr));
// подключение читающего потока к обработке очередей в произвольный момент времени.
const int Задержка_запуска_читателя = 700;
std::cout << "Задержка_запуска_читателя 5 на " << Задержка_запуска_читателя << " млс." << std::endl;
Sleep(Задержка_запуска_читателя);
std::thread c5(consumer, 5, std::ref(dc), std::ref(mgr), FILLING_THRESHOLD, 1);
p.join(); c1.join(); c2.join(); c3.join(); c4.join(); c5.join();
timeEndPeriod(1); // Освободить точность 1 млс.
char nazv_sh[100];
std::cout << "Введите что-нибудь:" << std::endl;
std::cin >> nazv_sh;
return 0;
}
Пользователь
Сообщений: Регистрация: 12.05.2020
27.07.2026 16:47:37
Мой вопрос ИИ: При перезапуске QUIK восстановление взаимодействия с сервером выполняется медленно: ~1,5 минут. Какой эффективный протокол восстановления взаимодействия QUIK с сервером вы можете рекомендовать?
--- Ответ ИИ --- Техническое предложение: Модернизация протокола синхронизации QUIK-сервер/клиент на базе Delta-Sync и Event Sourcing 1. Текущая проблема и её экономические последствия В текущей архитектуре восстановление связи между терминалом QUIK и сервером после кратковременного обрыва или перезапуска занимает в среднем от 1.5 до 3 минут. Причина: Сервер использует модель полной репликации состояния («выливание» Snapshot'а дня). При переподключении сервер заново передает мегабайты исторических логов всех сделок за день, чтобы клиент перестроил таблицы в ОЗУ. Следствие для брокера: В моменты массовых утренних подключений или после секундного сетевого сбоя на бирже тысячи терминалов одновременно набрасываются на сервер, запрашивая историю (проблема Thundering Herd / Грохочущее стадо). Это приводит к лавинообразному росту нагрузки на CPU и дисковую подсистему серверов брокера, вызывая микрозависания самого ядра QUIK-сервера. Следствие для трейдера: Роботы остаются «слепыми» в самые волатильные минуты рынка, что генерирует инфраструктурные риски и финансовые потери. 2. Предлагаемое решение: Дельта-синхронизация по Sequence IDВместо полной передачи Snapshot'а предлагается внедрить механизм Delta-Sync, аналогично промышленным протоколам FIX Session, Apache Kafka или брокерам сообщений высокой доступности.Архитектура на стороне QUIK-сервера:Event Sourcing (Журналирование событий): Каждый поток данных на сервере (Все сделки, Личные заявки, Позиции) получает сквозной инкрементируемый индекс (Sequence ID) в рамках торговой сессии.Ring Buffer в ОЗУ: Сервер удерживает в оперативной памяти скользящее окно (кольцевой буфер) транзакций, например, за последние 30-40 минут.CQRS разделение каналов: Тяжелые публичные данные (Обезличенные сделки) выносятся в асинхронный поток (например, UDP Multicast), а приватные данные (Заявки/Позиции) идут по гарантированному TCP-каналу.Логика быстрого переподключения (Reconciliation): Перед закрытием или при потере связи терминал QUIK локально сериализует текущие таблицы на SSD (сохраняя состояние). В заголовке локальной базы фиксируется последний успешно полученный Sequence ID (например, 14502300).При восстановлении связи терминал отправляет серверу короткий хэндшейк: «Запрос синхронизации с Sequence ID: 14502300».Сервер считывает из своего Ring Buffer в ОЗУ только дельту — сообщения с индексами от 14502301 до текущего момента. Терминал «вшивает» (аппендит) полученную дельту в свою локальную базу данных. 3. Преимущества для ARQA Technologies и Брокеров. Снижение нагрузки на сервера в 10–50 раз: В моменты массовых переподключений сервера брокера будут отдавать не мегабайты истории на каждого клиента, а считанные килобайты дельта-пакетов. Это позволит брокерам обслуживать кратно больше клиентов на том же аппаратном обеспечении (Hardware cost reduction). Сокращение времени восстановления до < 100 мс: Терминал будет возвращаться в строй мгновенно и незаметно для пользователя. Сохранение обратной совместимости: Данный протокол может быть внедрен как альтернативный тип сессии. Старые клиенты могут продолжать запрашивать Snapshot, тогда как новые терминалы (и роботы через QLua) перейдут на Delta-Sync.
----- Мой комментарий --- То, что выложил ИИ может быть основой для ТЗ на сокращение времени восстановления взаимодействия QUIK с сервером.
Пользователь
Сообщений: Регистрация: 02.01.2026
27.07.2026 17:52:11
Цитата
TGB написал: При переподключении сервер заново передает мегабайты исторических логов всех сделок за день
Это только при переключении на другой сервер. В диспетчере задач можно посмотреть сетевую активность.
Пользователь
Сообщений: Регистрация: 12.05.2020
27.07.2026 18:07:19
Цитата
Йцукен написал: Это только при переключении на другой сервер. В диспетчере задач можно посмотреть сетевую активность.
ИИ может ошибаться, но фактом является долгое восстановление взаимодействия QUIK с сервером во многих случаях. И
Цитата
TGB написал: То, что выложил ИИ может быть основой для ТЗ на сокращение времени восстановления взаимодействия QUIK с сервером.
Пользователь
Сообщений: Регистрация: 12.05.2020
09.10.2026 09:34:19
Цитата
Oleg Kuzembaev написал: В данном случае, нам видится возможность зарегистрировать пожелание на доработку будущих версий ПО. Однако необходимо достичь понимания, какая именно доработка требуется.Если у вас уже есть такая наготове, то просьба предметно описать ее: что именно стоит добавить? Как это будет выглядеть в вашем представлении? После сбора всей информации, мы с радостью зарегистрируем такое пожелание.
Nikolay в своей ветке: "Работа колбеков" () детально продемонстрировал проблемы существующей архитектуры QLua. Для решения этих проблем в этой ветке, начиная с 2024г., выложены конкретные предложения (вплоть до "сырых" но транслируемых и исполныямых кодов) по устранению этих проблем. Вопрос разработчику QUIK: что непонятно в этих предложениях? Какие есть возражения?
Пользователь
Сообщений: Регистрация: 12.05.2020
26.10.2026 09:58:22
Я как то это уже выкладывал. Но: "Повторение - мать учения". На своих проектах я использую памятку для разработчиков, при реальном использовании которой, существенно сокращаются сроки и улучшается качество проектов. Памятка по работе с пользователями проекта 1. Пользователи являются ценнейшим ресурсом любого проекта, правильное управление которым существенно определяет успех проекта. Фактически это внештатные бесплатные отладчики проекта. Поэтому к ним следует относиться очень внимательно и доброжелательно. За найденные ими ошибки в проекте или предложения, улучшающие проект, их следует благодарить. К ошибкам, совершаемые ими, относиться спокойно и давать четкие разъяснения таким образом, чтобы не отбивать желания повторного обращения. 2. При работе с пользователями, как правило (через некоторое время), можно выделить следующие группы пользователей: 1) суперпользователи; эта наиболее ценная для проекта группа пользователей, хорошо разбирающаяся в проекте, предлагающая ценные решения и конструктивно взаимодействующая с поддержкой проекта по его отладке; как правило, это группа небольшая и поддержке проекта следует обращать на ее особое внимание, выделяя для общения с ней своих наиболее квалифицированных сотрудников, а также ключевых разработчиков проекта; 2) ключевые пользователи; это следующая, по ценности для проекта, группа пользователей, на работу с которой следует уделять повышенное внимание со стороны поддержки проекта; 3) пользователи; 4) тролли и хамы; эта группа, кроме того, что засоряет каналы коммуникации, наносит имиджевый урон проекту; поэтому ее следует блокировать.
Дополнительно. При общении с пользователями, надо исходить из того, что: 1) пользователь имеет право на ошибки; 2) на любую ошибку пользователя, диагностируемую в программе проекта, должна выдаваться понятная ему диагностика; 3) любое «падение (зацикливание, блокировка, неожиданное завершение)» программы проекта, является ошибкой разработчика программы проекта; 4) параметры производительности программ проекта важны для пользователей (а в некоторых проектах очень) и являются критериями оценки успешности проекта, наряду со стабильностью и всеми остальными критериями оценки проекта.
Пользователь
Сообщений: Регистрация: 12.05.2020
22.11.2026 09:25:48
По ссылке: представлен вариант реализации таймера, который мне показался сложным. Ниже представлен более простой и универсальный вариант. В этом варианте, в любой функции скрипта обеспечивается возможность создания таймерных событий, по которым могут быть выполнены любые функции скрипта (при необходимости с заданием параметров): через заданный интервал, циклически, в заданный момент времени. Схема генерации таймерных событий следующая: 1) в таблицу таймерных событий записываются записи (в виде таблиц-массивов), хранящие функцию обработки события, время запуска ее и при необходимости ее параметры; 2) в цикле просматривается таблица таймерных событий и для наступивших событий, определяемых по часам ПК, выполняются соответствующие функции обработки таймерных событий. Надо учитывать, что задержки в обработке таймерных событий, при ! любых вариантах реализации в QLua, существенно зависят от длительности функций обработки наступивших событий. Таймерные функции реализованы в виде модуля. Описания этих функций приведены в комментариях. Код модуля выложен ниже. При его тестировании, файл с этим кодом, под именем timer_module.lua, надо переслать в папку хранения info.exe.
Код
--------- Реализация таймера -------
--- Формат таймерного события
-- <Таймерное событие (таблица-массив)> ::= {
-- <Вид события (интервал(0)|интервал повторения(1)|интервал повторения директивный(2)
-- |время суток(3)|время суток повторение(4)>,
-- <Значение млс.>,
-- ! <Значение> для времени суток таблица: {[1] = ч,[2] = м,[3] = с,[4] = млс};
-- "хвост" таблицы, включая ч, может отсутствовать;
-- <Имя таймерного события (строка)>,
-- <Функция обработки>,
-- {<Список параметров функции (таблица-массив)>} -- необязательный --
-- }
-- !! Если первым значением результата <Функции обработки> является '@Удалить таймерное событие', то событие
-- безусловно удаляется из очереди таймера.
-- ! При исключении в таймере, в TIMER.ERROR_TIMER записывается описание исключения
----------------------------
-- Время с начала суток в млс. ---
local time_day_mls = function()
local dt = os.sysdate()
return (dt.hour * 3600 + dt.min * 60) * 1000 + dt.ms
end
---
-- Время (с 1970г. млсек.) --
local time_day_1970_mls = function()
local dt = os.sysdate()
return (os.time(dt)) * 1000 + dt.ms
end
---
local TIMER = {}
TIMER.ERROR_TIMER = false
---
local table_Timer = {} -- Таблица запрошенных таймерных событий ---
local time_day_1970 = time_day_1970_mls()
local D_MLS = 86400000 -- Сутки в млс. ---
-----
-- Запрос таймерного события ---
-- Параметры: 1) <Вид события: 0,1,2,3,4>;
-- 2) <Интервал в млс.> (! для времени суток таблица {[1] = ч,[2] = м,[3] = с,[4] = млс};
-- "хвост" таблицы, включая ч, может отсутствовать);
-- 3) <Имя события: строка>
-- 4) <Функция>;
-- Не обязательный параметр:
-- 5) {<Список параметров функции>}
TIMER.SET_TIMER = function(view, T, name, f, par)
name = type(name) ~= 'string' and 'Без имени' or name
if not ((view >= 0 and view <= 4) and type(f) == 'function' and (par == nil or (par and type(par) == 'table'))) then
message('#'..debug.getinfo(1).currentline .. '!! Ошибка в параметрах вызова SetTimer.\n'
.. 'Параметры: view = '.. tostring(view) .. ' T = '.. tostring(T) .. ' f = '.. tostring(f) .. ' par = '.. table.Dump(par), 3)
error('*** !!! TIMER.SET_TIMER ОШИБКА 1: смотрите лог' .. '\n' .. debug.traceback())
end
if (view == 3 or view == 4) and (type(T) ~= 'table') then
message('#'..debug.getinfo(1).currentline .. '!! (view == 3 or view == 4) время должно быть задано таблицей', 3)
error('*** !!! TIMER.SET_TIMER ОШИБКА 2: смотрите лог' .. '\n' .. debug.traceback())
end
---
if type(T) == 'table' then
T = (T[1] or 0) * 3600000 + (T[2] or 0) * 60000 + (T[3] or 0) * 1000 + (T[4] or 0)
end
local evnt = {view, T, name, f, par} -- ! evnt[6] = 1 - событие удалено --
----
time_day_1970 = time_day_1970_mls()
-- Преобразование <Значение (интервал(0)|интервал повторения(1)|директивное время обработки цикла(2)
-- |время(3)|время повторения(4))> в интервал ожидания ---
if view == 0 or view == 1 or view == 2 then
table_Timer[evnt] = time_day_1970 + T
end
if view == 3 or view == 4 then -- время|время повторения ---
local time = time_day_mls()
if T < time then -- время суток прошло ---
table_Timer[evnt] = time_day_1970 - time + T + D_MLS -- выставление на следующие сутки ---
else
table_Timer[evnt] = time_day_1970 - time + T
end
end
return evnt
end
-- Удаление таймерного события evnt
TIMER.DEL_TIMER = function(evnt)
if evnt and table_Timer[evnt] then table_Timer[evnt] = nil end
end
-- Создание таймерных событий
TIMER.TIMER = function()
--- Вычисление текущего времени ---
local delta, par_1, par_2, par_3, par_4, par_5, del, del_f
time_day_1970 = time_day_1970_mls()
local time_day = time_day_mls()
-------------------------------
--- При удалении формируется признак k[6] = 1
for k, v in next, table_Timer do
delta = (time_day_1970 - v) -- запаздывание --
if delta >= 0 then
del = true
del_f = false -- при true безусловное удаление события ---
par_1 = k[1]
par_2 = k[2]
par_3 = k[3]
par_4 = k[4]
par_5 = k[5]
if par_1 == 2 then -- директивный интервал повторения (есть учет delta и выполнения функций в таймере)--
table_Timer[k] = time_day_1970 + par_2 - delta -- delta - запаздывание события --
del = false
end
if par_1 == 4 then -- время повторения --
-- ! Предпологается что time_day_1970_mls и time_day_mls синхронизированы --
local cor = par_2 - time_day
if math.abs(cor) > 86000000 then -- коррекция с учетом перехода в новые сутки --
cor = (cor > 0 and (par_2 - (time_day + D_MLS))) or ((par_2 + D_MLS) - time_day)
end
table_Timer[k] = time_day_1970 + cor + D_MLS -- выставление на следующие сутки ---
del = false
end
local kod, mess
-- Dыполнение функции
if par_5 then
kod, mess = xpcall(par_4, debug.traceback, table.unpack(par_5))
else
kod, mess = xpcall(par_4, debug.traceback)
end
if not kod then
TIMER.ERROR_TIMER = '! Ошибка в функции таймерного события ' .. tostring(par_3)
.. '. Исключение: ' .. mess
del_f = true
else
if mess == '@Удалить таймерное событие' then del_f = true end -- ! безусловное удаление события из очереди таймера
end
if par_1 == 1 then -- интервал повторения (нет учета выполнения функций в таймере)---
table_Timer[k] = time_day_1970_mls() + par_2
del = false
end
-----------------------------------
if del or del_f then -- #### !!! Удаление обязательно в конце цикла ---
k[6] = 1 -- таймерное событие обработано и удалено из очереди ---
table_Timer[k] = nil
end
end
end
end
-- Срочный вызов таймерного события evnt
TIMER.TIMER_URGENTLY = function(evnt)
if evnt[6] == 1 then error('! Ошибка в TIMER.TIMER_URGENTLY. событие ' .. evnt[3] .. 'было удалено') end
if evnt[5] then
evnt[4](table.unpack(evnt[5]))
else
evnt[4]()
end
end
TIMER.TIMER_TBL = table_Timer
return TIMER
----------
Скрипт проверки модуля реализации таймера:
Код
local run = true
function main()
local TIMER = require ("timer_modul")
---- Функции работы с таймером -----
-- 1. Запрос таймерного события: local evnt = TIMER.SET_TIMER(view, T, name, f, par)
-- Параметры: 1) <Вид события: 0,1,2,3,4>;
-- интервал(0)|интервал повторения(1)|интервал повторения директивный(2)|время суток(3)
-- |время суток повторение(4)
-- 2) <Интервал млс.> (! для времени суток таблица {[1] = ч,[2] = м,[3] = с,[4] = млс};
-- "хвост" таблицы, включая ч, может отсутствовать);
-- 3) <Имя события: строка>
-- 4) <Функция обработки таймерного события>;
-- Не обязательный параметр:
-- 5) {<Список параметров функции>}
----
-- !! Если первым значением результата <Функции обработки> является '@Удалить таймерное событие', то событие
-- безусловно удаляется из очереди таймера.
-- ! При исключении в таймере, в TIMER.ERROR_TIMER записывается описание исключения
---------------
-- 2. Удаление таймерного события evnt: TIMER.DEL_TIMER(evnt)
---------------
-- 3. Создание таймерных событий: TIMER.TIMER()
-- ! Вызывается в цикле
---------------
-- 4. Срочный вызов таймерного события evnt: TIMER.TIMER_URGENTLY(evnt)
-- Функция основного цикла скрипта ---
local function main_cycle()
message('Основной цикл обработки скрипта')
----
end
---
-- Функция, выполняемая циклически в 12:00 ---
local function hour_12_00(mess)
message(mess)
----
end
---
message('Начало тестирования таймера')
-- Запрос таймерных событий можно выполнять в любых функциях скрипта --
-- Запрос циклического таймерного события
local evn = TIMER.SET_TIMER(1, 1500, 'Таймерное событие основного цикла', main_cycle)
-- Запрос одиночного таймерного события
local evn1 = TIMER.SET_TIMER(0, 10000, 'Интервал', function () message('Одиночный интервал 10000 млс.') end)
-- Создание циклического события в 12:00 (с параметром) ---
local evn2 = TIMER.SET_TIMER(4, {12}, 'hour_12_00', hour_12_00, {'hour_12_00(mess)'})
---- Срочное выполнение evn2 --
TIMER.TIMER_URGENTLY(evn2)
-- Цикл генерации таймерных событий
while run do
TIMER.TIMER()
sleep(1)
end
end
function OnStop()
run = false
end
---- P.S. В моих скрипта для sleep устанавливается разрешение 1 млс.
Пользователь
Сообщений: Регистрация: 15.06.2023
22.11.2026 11:28:38
Посмотрел. Модуль рабочий, но брать его целиком не стал бы. но одна вещь в нём есть такая, которой не было (timer.lua).
Что понравилось: - Идея "вид события" (интервал / повтор / время суток / повтор по времени суток) - более правильная таксономия, в моем примере (timer.lua) покрывала не всё. - xpcall(..., debug.traceback) вокруг обработчика - конечно нужен, обработчик не должен ронять цикл. - Сроки считаются от плана, а не от "сейчас" (это view 2, директивный интервал). Иначе дрейф. -- (timer.lua) это было с самого начала.
Где он сломается?
* Описка, файл timer_module.lua, а в примере require("timer_modul") - пример не запустится нужно поправить.-- (module 'timer_modul' not found)
* TIMER.TIMER() перебирает все события, а цикл sleep(1), O(N) каждые 1 мс, 1000 витков в секунду даже когда срабатывать нечему? А ведь речь в первую очередь про квантования событий ТТП, мои прогоны показывают просто не достаточность данных на интервале 1 секунда (пришлось от него отказаться).
* os.sysdate() + os.time(dt) на каждом витке, два системных вызова на миллисекунду вместо одного?
Есть еще места, вызывающие вопросы, но прежде чем делать выводы, стенд нужно починить (нашел ошибку) .
Пользователь
Сообщений: Регистрация: 12.05.2020
22.11.2026 12:39:18
1.
Цитата
VPM написал: * Описка, файл timer_module.lua, а в примере require("timer_modul") - пример не запустится нужно поправить.-- (module 'timer_modul' not found)
Да. Спасибо. Вместо:
Цитата
TGB написал: При его тестировании, файл с этим кодом, под именем timer_module.lua, надо переслать в папку хранения info.exe.
Должно быть: При его тестировании, файл с этим кодом, под именем timer_modul.lua, надо переслать в папку хранения info.exe.
2.
Цитата
VPM написал: TIMER.TIMER() перебирает все события, а цикл sleep(1), O(N) каждые 1 мс
Ну, и сколько у вас различных таймерных событий будет в перебираемой таблице, по которым надо обрабатывать различные коды. Скорее всего < 10.
Цитата
VPM написал: 1000 витков в секунду даже когда срабатывать нечему
Ну и пусть 1000 витков. Можете сами убедится, что при этом на ЦП мизерная нагрузка.
Цитата
VPM написал: * os.sysdate() + os.time(dt) на каждом витке, два системных вызова на миллисекунду вместо одного?
Ваш вариант реализации в Qlua: время с 1970г. млсек.?
Пользователь
Сообщений: Регистрация: 15.06.2023
22.11.2026 14:31:18
TGB, Дело даже не в оптимизации производительности, есть более серьезные моменты в вашей реализации (стенд у себя поправил, а замечания остались). Обратите внимание, вот на эти места:
* Отдельно: table_Timer[evnt], где evnt - таблица-событие, само по себе нормально, классное решение (ключ по идентичности), но TIMER_URGENTLY проверяет evnt[6] == 1 - признак, который выставляется только при удалении в цикле. Событие, удалённое через DEL_TIMER, этого флага не получит, и TIMER_URGENTLY по нему вызовет обработчик уже удалённого события.
* table_Timer[k] = nil и next - ок, но SET_TIMER внутри обработчика добавляет новый ключ во время обхода, по мануалу Lua поведение next в этом случае не определено, то есть события могут потеряться "молча"?
* ошибка > del_f = true > событие удаляется, > один сбойный отсчёт и мониторинг без метрик навсегда. След — глобальная строка TIMER.ERROR_TIMER, которую перезаписывает следующая ошибка?
* view 1 (интервал повторения) переставляет срок как now + T после обработчика, на тренде отчётов копится систематическое отставание; лечится только переходом на view 2?
* math.abs(cor) > 86000000 для перехода через сутки, работает, но это "магия" на ровном месте, (та же задача - вычитание по модулю суток)?
Вывод. Реализация полезна, для моего варианта как напоминание, что таймеру нужен вид "время суток". Но как основа - требует доработки, уступает по следующим моментам: а) удаляет события при ошибке; б) крутит O(N) каждую миллисекунду; с) имеет неопределённое поведение при создании события из обработчика. Мое не профессиональное мнение, нужна доработка реализации.
Чтоб не путаться, у себя выложу обновленный вариант своей версии timer.lua 1.1
Пользователь
Сообщений: Регистрация: 12.05.2020
22.11.2026 17:23:47
1.
Цитата
VPM написал: TIMER_URGENTLY проверяет evnt[6] == 1 - признак, который выставляется только при удалении в цикле. Событие, удалённое через DEL_TIMER, этого флага не получит, и TIMER_URGENTLY по нему вызовет обработчик уже удалённого события.
Это ошибка. Спасибо. Никогда не запускал срочно событий, которые были удалены. Исправление:
Код
-- Удаление таймерного события ---
-- Результат: nil - удалено ---
SYS.DEL_TIMER = function(evnt)
if evnt and table_Timer[evnt] then
evnt[6] = 1 -- признак удаления
table_Timer[evnt] = nil
end
return nil
end
2.
Цитата
VPM написал: SET_TIMER внутри обработчика добавляет новый ключ во время обхода
Где вы нашли обход таблицы в SET_TIMER? Укажите строку.
3.
Цитата
VPM написал: * view 1 (интервал повторения) переставляет срок как now + T после обработчика, на тренде отчётов копится систематическое отставание; лечится только переходом на view 2?
Используйте сразу view 2.
4.
Цитата
VPM написал: TIMER.ERROR_TIMER, которую перезаписывает следующая ошибка?
Следующая ошибка не перезаписывает, так как анализ TIMER.ERROR_TIMER у меня выполняется в цикле генерации таймерных событий. Выложенный тест таймеров упрощен и в нем отсутствует анализ TIMER.ERROR_TIMER.
Пользователь
Сообщений: Регистрация: 27.01.2017
22.11.2026 17:45:34
Я, наверно, не понимаю зачем все это.
У меня таймер - это либо циклический, т.е. выполнять каждые 10 секунд, например. Запускается просто по факту вызова, указав либо текущее время os.time, либо другое необходимое, от которого запустить циклы проверки. Либо однократный, тоже с интервалом - сделай что-то через 2 часа.
Я же здесь вижу Будильник, а не таймер - сделай что-то в 12:00. Такое у меня реализуете через запуск банальной проверки по достижению нужного os.time( от 12:00 дня). Банальная проверка двух чисел. И такое я помещаю в очередь задач, которая постоянно крутится в любом скрипте. Для новых суток банально новая задача.
Пользователь
Сообщений: Регистрация: 12.05.2020
22.11.2026 18:01:34
Цитата
Nikolay написал: такое я помещаю в очередь задач, которая постоянно крутится в любом скрипте
По сути, в предложенном мной варианте реализована таблица задач, выполняемых по заданному расписанию.