Неблокирующая нитей остановка - или почему станд :: atomic_flag замедлиться мой код

Question

я реализовал немного многопоточных приложений, которая делает следующее:

MainThread

Основной поток запускает таймер используя setitimer и запускает до 8 потоков. Таймер из основного потока используется для повторного чтения из> файла (каждые 0,25 с). Когда таймер вызывается 20 раз (после ~ 5 секунд), я хочу, чтобы остановить потоки и получить количество выполненных вычислений каждой нитью.

MainThread.h

class MainThread { 
    private: 
    int counter; 
    ThreadManager tm; 
    bool registerTimer(double seconds); 
    void startTimerWithInterval(double interval); 
    void read() { 
     /** 
     * If counter >= 20, call stopWorker on all threads 
     */ 
     tm.stopWorkers(); 
    } 
    public: 
    MainThread():counter(0){} 
} 

WorkerThreads

Выполните некоторые дорогие вычисления Whithin петли бесконечности. После определенного количества вычислений поток должен хранить количество выполненных вычислений . Это значение (количество вычислений) должно быть довольно точным, поэтому я думаю, что мне нужно остановить потоки (довольно) немедленно.

ThreadClass.h

class WorkerThread { 
    private: 
    /** 
    * ... 
    */ 
    std::atomic_flag keep_Running = ATOMIC_FLAG_INIT; 

    static void* run(void* args) { 
     ((WorkerThread*)args)->process(); 
     pthread_exit(nullptr); 
     return nullptr; 
    } 

    public: 
    /** 
    * ... 
    */ 
    bool startWorker() { 
     keep_Running.test_and_set(); 
     bool result = (pthread_create(&thread, pthread_attr, run, this) == 0); 
     if(!result) { 
     keep_Running.clear(); 
     } 
     return result; 
    } 
    void stopWorker() { 
     keep_Running.clear(); 
    } 
    bool keepRunning() { 
     return keep_Running.test_and_set(); 
    } 
    virtual void process() = 0; 
}; 

ComputationThread.h

class ComputationThread : public WorkerThread { 
    public: 
    virtual void process() override { 
     /** 
     * Perform computations with ~400MB data 
     * check every 16B, whether keepRunning still true 
     */ 
     bool keep_running = true; 
     while(keep_running) { 
     /** 
     * Process 4B 
     */ 
     keep_running = keepRunning(); 
     } 
    } 
}; 

Если я использую какой-то флаг, чтобы отслеживать состояние движения в потоке, я должен сделать это поточно флаг , не так ли? Я пробовал std::atomic_flag, потому что он должен быть заблокированным и иметь атомарные операции, но это приводит к резко падать производительности. Мой вопрос в том, приводит ли std::atomic_flag к снижению производительности, или это потому, что я слишком часто выполняю проверку? Кто-нибудь знает лучший способ?

Прежде чем вы спросите, я должен использовать pthread вместо std::thread, чтобы назначить поток указанному ядру в создании потока (используя pthread_attrib_t).

Answer 1

std::atomic_flag::test_and_set() включает аргумент по умолчанию std::memory_orderorder = memory_order_seq_cst

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

...

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

Этот флаг для memory_order будет вызывать каждый поток для выполнения своих операций памяти для test_and_set в порядке, загрузка и сохранение в последовательной памяти, которая собирается быть медленнее, каждый поток будет тратить время ожидания на других потоках для выполнения операций с памятью.

Answer 2

Не использовать std::atomic_flag.

Подразумевается как примитивный примитив низкого уровня atomic и поэтому имеет очень ограниченный интерфейс.
Главное его ограничение состоит в том, что вы можете только проверить его значение, установив его в true в одном вызове atomic с именем test_and_set()
Это операция Read-Modify-Write (RMW), которая выполняет дорогостоящую синхронизацию между всеми ядрами. Поскольку вы вызываете это на каждой итерации цикла, он значительно замедляется.

Используйте обычный atomic<bool> и установите его, как только вы закончите. Таким образом, внутри цикла вам нужно только прочитать его, что является нагрузкой atomic, и это переводит на обычную операцию mov. Установка определенного порядка памяти не повлияет на производительность (по крайней мере, на X86).