Unknown cause of Segmentation Fault during destruction of a ConcurrentQueue - c++

Question

So I was messing around with a ConcurrentQueue (found here) and I am stumbling upon a Seg Fault during the destruction of the ConcurrentQueue (Seg Faults at line 3397 of concurrentqueue.h). I tried using the queue in multiple other contexts however its is only causing a Seg Fault while being used in this context (Code below.) (Which is making me wonder if my code is causing this).
#ifndef MPSCWORKER_MPSCWORKER_HPP
#define MPSCWORKER_MPSCWORKER_HPP
#include <atomic>
#include <condition_variable>
#include <exception>
#include <memory>
#include <thread>
#include "ConcurrentQueue.h"
template <class Type>
class SinkBase;
class SinkNotRegisteredException;
template <class Type, const unsigned int numOfSinks>
class MPSCWorker{
public:
//Funcs
MPSCWorker();
~MPSCWorker(){
Type msg = {};
//Send an empty msg to the reserved channel to say we're done.
send(msg, numOfSinks + 1);
if(workerThread.joinable())
workerThread.join();
for(int i = 0; i <= numOfSinks + 1; i++){
if(sinks[i].get() != nullptr){
sinks[i].get()->onExit();
}
}
}
void start(){
isThreadRunning.store(true);
workerThread = std::thread(run,
std::ref(workQueue),
std::ref(sinks),
std::ref(isThreadRunning),
std::ref(threadCondVar),
std::ref(threadMutex));
}
int addSink(std::unique_ptr<SinkBase<Type>> &&sink, unsigned int sinkID){
if(!isThreadRunning.load()){
if(sinkID <= numOfSinks + 1){
sinks[sinkID] = std::move(sink);
if(!sinks[sinkID].get()->onInit()){
return -3;
}
} else{
return -1;
}
}else{
return -2;
}
return 0;
}
void send(Type msg, unsigned int sinkID){
workQueue.enqueue(InternalType{msg, sinkID});
threadCondVar.notify_one();
}
private:
//Types
struct InternalType{
Type msg;
unsigned int sinkID;
};
//Vars
std::atomic<bool> isThreadRunning;
std::thread workerThread;
std::condition_variable threadCondVar;
std::mutex threadMutex;
//ID = numOfSinks + 1: reserved
std::unique_ptr<SinkBase<Type>> sinks[numOfSinks + 1];
moodycamel::ConcurrentQueue<InternalType> workQueue;
//Funcs
static void run(moodycamel::ConcurrentQueue<InternalType> &workQueue,
std::unique_ptr<SinkBase<Type>> (&sinks)[numOfSinks + 1],
std::atomic<bool> &isThreadRunning,
std::condition_variable &threadCondVar,
std::mutex &threadMutex){
while(isThreadRunning.load()){
InternalType msg = {};
bool isDequeueSuccess = false;
std::unique_lock<std::mutex> lock(threadMutex);
threadCondVar.wait(lock, [&workQueue, &msg, &isDequeueSuccess](){
isDequeueSuccess = workQueue.try_dequeue(msg);
return isDequeueSuccess;
});
if(msg.sinkID == numOfSinks + 1){
isThreadRunning.store(false);
return;
}
if(sinks[msg.sinkID].get() != nullptr){
sinks[msg.sinkID].get()->onProcess(msg.msg);
}else{
throw SinkNotRegisteredException("Sink ID: " + std::to_string(msg.sinkID)
+ " has not been registered. Use addSink"
"to associate this ID with a Sink before"
"starting the worker.");
}
}
}
};
template <class Type, const unsigned int numOfSinks>
MPSCWorker<Type, numOfSinks>::MPSCWorker(){
isThreadRunning.store(false);
for(unsigned int i = 0; i <= numOfSinks +1; i++){
sinks[i] = nullptr;
}
}
class SinkNotRegisteredException : std::exception{
public:
SinkNotRegisteredException(std::string msg){this->msg = msg;}
const char* what(){return msg.c_str();}
std::string whatStr(){return std::string(msg);}
private:
std::string msg;
};
template <class Type>
class SinkBase{
public:
virtual bool onInit() = 0;
virtual void onExit() = 0;
virtual void onProcess(Type data) = 0;
};
#endif //MPSCWORKER_MPSCWORKER_HPP
Here is an example usage of the code above (I know the code is meant for multi-threaded applications but the example is single threaded for simplicity).
#include <iostream>
#include "MPSCWorker.hpp"
template <class Type>
class PrintSink : public SinkBase<Type>{
public:
virtual bool onInit(){return true;}
virtual void onExit(){}
virtual void onProcess(Type data){std::cout << data << std::endl;}
};
int main(){
MPSCWorker<std::string, 1> worker;
std::unique_ptr<PrintSink<std::string>> sink(new PrintSink<std::string>);
if(sink.get() == nullptr){
return -1;
}
worker.addSink(std::move(sink), 0);
worker.start();
worker.send("test", 0);
worker.send("test", 0);
worker.send("test", 0);
worker.send("test", 0);
worker.send("test", 0);
worker.send("test", 0);
worker.send("test", 0);
worker.send("test", 0);
worker.send("test", 0);
worker.send("test", 0);
return 0;
}
Now the real question is: Is my code causing the Seg Fault? Or is it ConcurrentQueue that is doing something wrong? And in any case, How can this be solved?