Russian Qt Forum

Задача очень простая - распарсить построчно большой лог.

В языке Go существуют легковесные потоки - Gorutines. С их помощью эта задача выполняется довольно быстро.
Но как это сделать в Qt?

Сейчас я создаю список QFuture и добавляю в него задачи парсинга:

При таком подходе всё работает, но для не слишком больших логов. Если дать лог на более чем 1 миллион строк, то программа начинает подвисать из-за того, что задачи добавляются в futureList.

В какую сторону мне смотреть, чтобы, так сказать, плавно их ставить в очередь на парсинг?

Необязательно, но вполне возможно Вы столкнулись с типовой проблемой "кластер слишком мал". Попробуйте объединять строки в пачки напр по 100 (или 1000, подберете), и их уже скармливать

Да, тоже думал, что машина просто не справляется, но о таком решении не догадался. Сейчас буду тестировать.

Потребление памяти значительно снизилось из-за уменьшения создания новых QFuture.

И того: проблема осталась - программа подвисает.

Попробую сделать через QThreadPool и QRunnable. По результатам отпишусь.

Может лучше разобраться почему/где подвисает.

У меня после парсинга строки идёт её запись на диск. Уверен, что из-за этого программа начитает подвисать.

Порядок строк в выходном файле не важен? Он может отличатся от исходного файла.

Можно использовать одну нить для чтения строк из исходного файла и заполнения очереди для обработки, несколько рабочих ниток для распарсивания и заполнения очереди для сохранения и нитка для сохранения результирующих строк. Чтение и запись буферизированные, т.е. прочитали большой кусок в память - побежали разбивать на строки, и формируем буфер для записи в памяти с результирующими строками и запись их одной операцией.

Или разделить исходный файл на несколько кусков, по количеству рабочих потоков, и отдать каждый кусок своему потоку. А поток уже будет вычитывать строку из своего куска, парсить ее и сохранять результат.

Не важен.

Второй вариант больше нравится из-за своей простоты. Попробую его тоже сделать.

Футура и есть обертка над QRunnable

Это легко проверить отключив запись. Можно каждой нитке дать свой выходной файл, или использовать мутексы для записи (подход тот же, лочится запись "пачки" строк).

Докладываю, как и обещал.

Я ошибался говоря, что подвисание окна происходит из-за активной записи на диск (она происходит в другом потоке). Оказалось всё намного прозаичнее: у меня в программе присутствует прогресс-бар, который обновляется, когда парсинг одной строки завершен. Из-за этого программа и подвисала - из-за частого обновления прогресс-бара.

P.S. также сделал с QtConcurrent запуск/остановку/возобновление/остановку потоков. Вот проект, кому интересно - https://yadi.sk/d/qUh0x_rXnprSV https://yadi.sk/d/US55QXNJnr6am

ссылка битая

Исправил

Освойте https://github.com/ / https://bitbucket.org/ -- проще же будет проекты хранить, иметь к ним доступ, тут и знания о контролях версий появятся, а они в it-компаниях всегда используются, да и не нужно будет перезаливать :)
Не раз было, что в некоторых статья на хабре можно было встретить, выложенный автором проект на файлообменник, ссылка которого, конечно, давно дохлая

А вот интересен вопрос реализации и прироста скорости.
У меня имеется подобная задачка, отложенная на потом.
Как эффективнее использовать потоки?
Я полагаю, что должен быть 1 поток, который будет читать данные в QStringList, тем самым формируя очередь для парсинга. В это время другие потоки начинают парсить полученные данные в QList результатов. Причём потоков для парсинга должно соответствовать QThread::idealThreadCount().

Как считаете? Жизнеспособно? Прирост скорости получится значительный?

Тут надо смотреть именно на объем работ. Если простой парсинг, прирост будет незначительный. Если парсинг с созданием структур, выделением памяти и преобразованиями - прирост возможно будет, а мб будет замедление из-за малой нагрузки на поток.
PS как говаривал сенсей, нужно разбирать каждый конкретный случай. Одно условие может поменять всё :)

1) Выясните сколько % времени уходит чисто на чтение, просто отключите теперешний парсинг. Учтите что эффект будет/возможен только для разницы между "полным" временем и "только чтение"

2) Выясните насколько в данном случае притормаживает удобный но жирный QString. Для чтения попробуйте читать файл как двоичный (raw data), для парсинга - смотрите сами

Потом о чем-то уже можно будет говорить

Я его использую, но не хочу пока туда такой сырой код выкладывать

egorsmkv, заведите отдельную ветку для сырого кода. А потом сольёте со стабильной.

Сделал - https://github.com/egorsmkv/qt-multithreading

Интересно будет посмотреть :)

Там всё довольно тривиально реализовано. Покритикуйте хотя-бы то, что есть.

Здесь нужно захватить мутекс

C++ (Qt)
void Worker::resumeThreads() {
 //  QMutexLocker lock(&sync);
  pause = 0;
  cond.wakeAll();
}
 

Вообще QWaitCondition здесь не очень лепится, обычно он связывается с выемкой задач из очереди, но тут это уже делает Qt

Мьютекс для pause?

В первую очередь для условной переменной.

Это не простая переменная, а QAtomicInt

Условная переменная это cond.

Понял.

Вместо QWaitCondition что лучше использовать?

Это зависит от того, что хотим получить. :)
Если вам нужна эта пауза, то условная переменная для этого подходит.

В коде он используется для ожидания команды "Возобновить работу потоков":

https://github.com/egorsmkv/qt-multithreading/blob/master/worker.cpp#L28

Я дописал предыдущий пост... Если вам нужна пауза, то условная переменная для этого подходит.

Да, иначе

C++ (Qt)
void Worker::task() {
  forever {
    // pause block
    sync.lock();
    if (pause.load()) {
      // <- пробой здесь
      qDebug() << "Task[" << QThread::currentThreadId() << "] paused";
      cond.wait(&sync);
    }
    sync.unlock();
 

QSemaphore

IMHO, не очень он для организации паузы подходит.

А ожидание, циклом?

Или :

forever {
  if (pause)
    continue;

// .. do work
}

Вы какое ожидание имеете ввиду - во время паузы? Тогда нитка заснет на wait и будет спать пока состояние флага pause не изменится.

Эдак Вы напрасно жжете процессор. Возможно Вы имели ввиду

C++ (Qt)
 
while (pause)
  msleep(delay_,sec);
 

Не очень аккуратно - зато очень просто  :)

Это "не очень аккуратно" только для лабораторок, а вообще это не приемлемо. :)

Самый просто пример - многопоточное копирование файлов. Захотел пользователь - нажал кнопочку пауза. Захотел - отжал.

И да, других вариантов кроме как слипить поток я не вижу.

Да, не очень солидно :) Но все же такое решение намного лучше захвата мутекса в рабочей ф-ции. Это сталкивает рабочие нитки лбами, при малом кластере все сожжется на мутексе. Разве что задача - доли секунды, тогда проходит все что угодно.

Не очень понял про мутексы в рабочих функциях. При паузе нитка должна спать, например на wait условной переменной.

Шо тут понимать  ???

C++ (Qt)
void Worker::task() {
  forever {
    // pause block
    sync.lock();
    ...
    cond.wait(&sync);

Все рабочие нитки будут пытаться захватить один и тот же мутекс - и на каждом расчете. Это очень плохо

Вы про шутейный пример с паузой?
Да, будет честно работать мьютиксы, но, по мне, это лучше чем атомики и sleep. Тогда уж атомики и yield.

Вот архив проекта с github

Работает, спасибо!