Access violations writing task scheduler

[Kyle98750]

Hello,
I am trying to write a task scheduler for an OpenGL engine I am writing.
The idea is that I can have a class with pure virtual functions and a get_task function that gets the function as a task using std::bind. Schedule the task on a thread with the OpenGL context, and the thread will execute the task. Heres my code thus far:

/*------------------------------- Task Class------------------------------- */ 
template <class R, class ...Args>
class Task;

template <class R, class ...Args>
class Task<R(Args...)> {
public:
	Task(std::function<R(Args...)> t);

	virtual void operator()(Args... args);

	virtual void wait();
	virtual R get();
protected:
	Task();
private:
	mutable std::mutex mu;

	std::future<R> future;
	std::packaged_task<R(Args...)> task;
};

template <class R, class ...Args>
inline Task<R(Args...)>::Task(std::function<R(Args...)> t) : task(t) {
	std::lock_guard<std::mutex> lock(this->mu);
	this->future = this->task.get_future();
}

template <class R, class ...Args>
inline Task<R(Args...)>::Task() {}

template <class R, class ...Args>
inline void Task<R(Args...)>::operator()(Args... args) {
	std::lock_guard<std::mutex> lock(this->mu);
	std::move(this->task)();
}

template <class R, class ...Args>
inline void Task<R(Args...)>::wait() {
	std::lock_guard<std::mutex> lock(this->mu);
	if (!this->future.valid()) {
		throw std::future_error(std::future_errc::no_state);
	}
	this->future.wait();
}

template <class R, class ...Args>
inline R Task<R(Args...)>::get() {
	std::lock_guard<std::mutex> lock(this->mu);
	if (!this->future.valid()) {
		throw std::future_error(std::future_errc::no_state);
	}
	return this->future.get();
}

/*------------------------------- Task Bundle Class------------------------------- */

template<class R, class ...Args>
class TaskBundle;

template<class R, class ...Args>
class TaskBundle<R(Args...)> : public Task<R(Args...)> {
public:
	template <class Task, class ...Rest>
	TaskBundle(Task task, Rest ...rest) : TaskBundle(rest...) {
		this->tasks.push_front(task); 
	}

	void operator()(Args... args) override;

	void wait() override;
protected:
	TaskBundle();
private:
	std::list<std::shared_ptr<Task<R(Args...)>>> tasks;
};



template<class R, class ...Args>
inline TaskBundle<R(Args...)>::TaskBundle() {}

template<class R, class ...Args>
inline void TaskBundle<R(Args...)>::operator()(Args... args) {
	while (!this->tasks.empty()) {
		(*this->tasks.front())(args...);
		this->tasks.pop_front();
	}
}

template<class R, class ...Args>
inline void TaskBundle<R(Args...)>::wait() {
	while (!this->tasks.empty());
}

/*------------------------------- Task Factory Class------------------------------- */

template <class R, class ...Args>
class TaskFactory;

template <class R, class ...Args>
class TaskFactory<R(Args...)> {
public:
	static TaskFactory<R(Args...)>* get_instance();

	template <class ...T>
	std::unique_ptr<TaskBundle<R(Args...)>> create_bundle(T ...task);

	std::unique_ptr<Task<R(Args...)>> create(std::function<R(Args...)> task);
private:
	TaskFactory();
};

template<class R, class ...Args>
inline TaskFactory<R(Args...)>::TaskFactory() {}

template<class R, class ...Args>
inline TaskFactory<R(Args...)>* TaskFactory<R(Args...)>::get_instance() {
	static TaskFactory<R(Args...)> instance;
	return &instance;
}

template<class R, class ...Args>
inline std::unique_ptr<Task<R(Args...)>> TaskFactory<R(Args...)>::create(std::function<R(Args...)> task) {
	//return std::unique_ptr<Task<R(Args...)>>(new Task<R(Args...)>(task));
	return std::make_unique<Task<R(Args...)>>(task);
}

template<class R, class ...Args>
template<class ...T>
inline std::unique_ptr<TaskBundle<R(Args...)>> TaskFactory<R(Args...)>::create_bundle(T ...task) {
	//return std::unique_ptr<TaskBundle<R(Args...)>>(new TaskBundle<R(Args...)>(task...));
	return std::make_unique<TaskBundle<R(Args...)>>(task...);
}

/*------------------------------- Task Manager Class------------------------------- */

template <class R, class ...Args>
class TaskManager;

template <class R, class ...Args>
class TaskManager<R(Args...)> {
public:
	enum Priority {
		LOW = -1, NORMAL = 0, HIGH = 1
	};

	struct PrioritizedTask {
		std::shared_ptr<Task<R(Args...)>> task;
		Priority priority;

		bool operator<(const PrioritizedTask &t) const {
			return this->priority < t.priority;
		}

		bool operator>(const PrioritizedTask &t) const {
			return this->priority > t.priority;
		}

		bool operator==(const PrioritizedTask &t) const {
			return this->priority == t.priority;
		}

		bool operator!=(const PrioritizedTask &t) const {
			return this->priority != t.priority;
		}
	};

	TaskManager();

	bool has_task();

	void execute_top();
	void execute_all();
	void execute_n(unsigned int n);

	void schedule(std::shared_ptr<Task<R(Args...)>> task, Priority priority = Priority::NORMAL);

	template <class T, class ...Rest>
	void schedule_all(T task, Rest ...rest);

private:
	std::mutex mu;
	std::priority_queue<PrioritizedTask, std::vector<PrioritizedTask>, std::less<PrioritizedTask>> queue;
};

template <class R, class ...Args>
inline TaskManager<R(Args...)>::TaskManager() {}

template <class R, class ...Args>
inline bool TaskManager<R(Args...)>::has_task() {
	std::lock_guard<std::mutex> queue_lock(this->mu);
	return !this->queue.empty();
}

template <class R, class ...Args>
inline void TaskManager<R(Args...)>::execute_top() {
	std::lock_guard<std::mutex> queue_lock(this->mu);
	if (!this->queue.empty()) {
		(*this->queue.top().task)();
		this->queue.pop();
	}
}

template <class R, class ...Args>
inline void TaskManager<R(Args...)>::execute_all() {
	while (!this->queue.empty()) {
		this->execute_top();
	}
}

template <class R, class ...Args>
inline void TaskManager<R(Args...)>::execute_n(unsigned int n) {
	for (int i = 0; i < (n <= this->queue.size() ? n : this->queue.size()); i++) {
		this->execute_top();
	}
}

template <class R, class ...Args>
inline void TaskManager<R(Args...)>::schedule(std::shared_ptr<Task<R(Args...)>> task, Priority priority) {
	std::lock_guard<std::mutex> queue_lock(this->mu);
	this->queue.push(PrioritizedTask{ task, priority });
}

template <class R, class ...Args>
template <class T, class ...Rest>
inline void TaskManager<R(Args...)>::schedule_all(T task, Rest ...rest) {
	std::lock_guard<std::mutex> queue_lock(this->mu);
	this->queue.push(task);
	this->schedule_all(rest...);
}

This is an example of a class that has a pure virtual function and provides a task for it:

	
class Generator {
public:
	TaskUnique_t generate_task() {
            return TaskFactory_t::get_instance()->create(std::bind(&Generator::generate, this));
         }
         TaskUnique_t destroy_task() {
             return TaskFactory_t::get_instance()->create(std::bind(&Generator::destroy, this));
         }
protected:
	virtual void generate() = 0;
	virtual void destroy() = 0;
};

This works perfectly fine in my test environment, but when I use it in my engine I get access violations. Something is getting deleted and I can't figure out what. My assumption is that it has to do with the 'this' pointer in the std::bind call. Maybe I need an to write my own bind that takes a std::shared_ptr to the object?
This could be very obvious however I am still relatively new to C++.

[poteto]

I would recommend to use asio (independent library) or boost::asio. As far out as it seems because this is a library for networking to most people, this library has something called an io_context which pretty much does what you are trying to do, which is just a manager for calling functions. You queue a function by calling post, and you call the functions by calling run or a single function with poll_one.

For prioritized execution here is an example but it is quite boost intensive, and it uses multiple threads (which shouldn't be too hard to rip out).
https://stackoverflow.com/questions/16311389/boostasio-and-active-object/16346092#16346092

But a problem that I may be naive to bring up since I don't use opengl, but why would you want to call render functions from another thread, or even with a priority? Everything in opengl needs to be sequentially called I believe (unless you are using a depth buffer, but you still need to call in order for menus to render on top).

I think the way how engines work is the logic is multi threaded, but you need to stop the logic when you are doing rendering, or you could have the renderer have its own state of the world which has everything the renderer needs to try to have a lock-free system, but I believe you seriously need to do some bench marking to see if you actually make a performance gain by doing that.

Also what does your debuggee tell you? It should be able to tell you exactly where the line of code breaks if the fault is in your code.

And if you want real help, you should have a full (short) compile-able example (with your test cases), and also spend a little time trying to reproduce it in the small sample (if you haven't already, remember, you must have test cases that actually stress your code out like for example sleeping before calling the functions make it more likely for there to be a collision), and does the first function in the engine crash or is it random? If your debugger refuses to give you any information, you should do some cave man debugging with logs.

Also you have some data races, like execute_all and execute_n access the queue without a lock, but I am unsure if this is your problem, since it doesn't seem like it.

Also note that std::bind does allow shared pointers as a replacement for this. Just make sure you don't call shared_from_this() inside the bind, you need a copy of it before calling it. And don't call it inside a constructor which has enabled shared from this.