byannoni / qthreads Goto Github PK

The name threading_queue is misleading. Perhaps thread_pool would be better.

• Pick a name for the project (keep qthreads)
• Pick a name to replace threading_queue (qtpool)
• Pick a prefix (qt)
• Refactor the code

There is no reason why fq_push() should take a struct rather than creating a struct out of two arguments internally. It's a pain to set up a struct for each element by hand. New signature could be:

enum pt_error fq_push(struct function_queue*, void (*)(void*), void*, int);

There is a lack of error handling and reporting in these function. The functions should return consistent error codes. This could be implemented through an enum, however that may not be as effective for tq_start()

One possible solution is to modify tq_start() to take a pointer parameter for storing the number of successful thread creations. This would free the return value for the enum.

This is what you need -> http://www.wtfpl.net/

There is no reason why a thread should wait a certain amount of time if nothing else is running.

• Use sched_yield() instead of usleep()
• Remove the wait time information from threading_queue_startup_information
• Add a cancellation point before calling fq_pop()

Flags may be valuable in some use cases when creating the threads.

In function_queue.c, attr is never destroyed. Possible fixes:

• Keep track of number of queues
  • Initialize attr when number changes from 0 to 1
  • Destroy attr when number changes from 1 to 0
• Initialize and destroy attributes every time a queue is initialized

The logic that checks if malloc() succeeds in fq_init() is the opposite. It should be changed from:

ret = PT_EMALLOC
pml = pthread_mutex_destroy(&q->lock)

if(pml == 0) {

to

        ret = PT_EMALLOC
        pml = pthread_mutex_destroy(&q->lock)
} else {
        if(pml == 0) {

Additionally, PT_EPTMUNLOCK is the wrong error code, it should be PT_EPTMINIT.

Use a condition variable to block to elimination repeated unnecessary checking in get_and_run(). Call pthread_cond_signal() from fq_push() and pthread_cond_wait() from fq_pop().

• Remove locking from fq_is_empty() and fq_is_full()
• Remove block parameter from fq_is_empty() and fq_is_full() (#24)
• Make the lock non-recursive
• Implement condition variable usage in fq_push() and fq_pop()

Perhaps a more efficient locking system can be used, or threads can be notified individually or a semaphore could be used to implement ticket locking?

It's a pain to manage a hand written makefile for every change. Perhaps autotools or CMake should be used.

As it currently is, the function queue cannot resize with realloc() because the elements pointer could be dereferenced while it points to freed memory (before the pointer has been replaced with the new memory). A work-around could be to allocated with malloc() and manually copy the data from the original queue over, all while holding the lock.

Some files contain Windows line endings when read on Linux systems

Allow tq_start() to report all errors, and optionally stop and reverse creation on error.

Possibly add a function specifically for checking errors from init_attr_ret

Valgrind indicates that the cleanup handler introduced by 9272e01 attempts to unlock an unlocked mutex. This results in undefined behavior according to the POSIX standard.

The call is probably not necessary. Read about preemptive multithreading.

The pointer q is dereferenced before it is checked. The simple fix is to initialize tmp to 0 instead of using the value of q immediately

The error handling is a mess. The functions should return consistent error codes. This will be implemented through an enum. The enum value indicating the error status will be the return value the functions.

• Create an enum for this purpose
• Implement the error codes through the enum throughout the project (including #18)
  • Implement in function_queue
  • Implement in threading_queue
• Create a function for looking up strings corresponding to error enums
  • Create tests for this function to ensure it works

If pthread_cancel() fails then pthread_join() may block forever.

The destructors for threading_queue and function_queue both throw exceptions.

This should not happen. Possibly fix it with pthread_cleanup_push().

Refactor C++ constructors not to call fq_init() or tq_init(). Create new methods for that purpose.

• tq::queue
• fq::queue

The name is misleading. Perhaps tp::pool would be better.

Ideally this will happen after #27 for easier integration.

The function fq_peek() can block when calling fq_is_empty() even if the block parameter is 0. The block parameter should be passed on to it instead of the constant 1.

It should read "while destroying," not "while unlocking"

The function fq_pop() can block when calling fq_is_empty() even if the block parameter is 0. The block parameter should be passed on to it instead of the constant 1.

The function fq_push() can block when calling fq_is_full() even if the block parameter is 0. The block parameter should be passed on to it instead of the constant 1.

Currently, the CI script specifically installs gcc-4.8. This may no longer be necessary. Determine if this can be removed.

It should look much cleaner and be less flaggy

• fqinit()
• fqdestroy()
• fqpush()
• fqpop()
• fqpeek()
• qtstrerror_r()
• qtinit()
• qstart_get_e() -- restructure returns; no goto

The makefile should be changed to allow for other compilers.

The pointer src is dereferenced before it is checked. Initialize len to 0 and then assign the calculated length after checking.

Adding a debug target to the makefile could be useful for building and testing

Some of the badges in README.md link to pages that don't exist

Automated tests should be created to ensure quality

This will facilitate the implementation of #16.

• Implement a union to store the struct pointers in.
• Implement an enum to determine which struct pointer to use and which features are available
• Decide whether to use the enum or a structure of function pointers to determine which specific queue functions to call (will use function pointers)
  • Implement this decision

The solution must:

• Allow users to interact with the queue in a way that does not require them to know what type is in use
• Allow for easily adding and implementing more queue structures in the future

#5 #34 caused a parameter to go unused. For backwards compatibility this will not be implemented until v0.3.0. Waiting for #8 #37 to be merged.
#5 and #8 have been canceled. #34 and #37 take their places.

This would allow the mutex to be non-recursive and make fq_is_empty() and fq_is_full() simpler.

As it is currently, the function_queue queue requires contiguous memory, which may not be available. If the memory is not required to be contiguous then there is a smaller chance of a failure to allocate.

tq_stop() should optionally join with each canceled thread

The function get_and_run() is of type void* (*) (struct function_queue*) but is called as void* (*)(void*). This results in undefined behavior according to the C Standard:

If a converted pointer is used to call a function whose type is not compatible with the pointed-to type, the behavior is undefined.

There are some serious issues in the code that need to be cleaned up. For example, error handling and null-pointer checks.

• General clean up
• Error handling in function_queue (including #6) see #17
• Error handling in threading_queue see #18
• Debug assertions (maybe) see #20

tq_start_get_ne() is not thread-safe and it is not very useful either. It should be removed.

Hey Brandon,

I just wanted to drop by and ask some existential questions.

Why does this project exist? What is the purpose of this? What problem does this solve?

Thanks,
Alex

This will use the GitHub wiki for this project for now