bool mythread_function_see_opt(mythread_context_t *ctx, volatile mythread_thread_opt_t opt, size_t done_count, const struct timespec *timeout)
{
mythread_t * mythread = ctx->mythread;
mythread_queue_list_t *queue_list = mythread->queue_list;
if(done_count != queue_list->count)
return false;
if(opt & MyTHREAD_OPT_STOP)
{
if(mythread_function_see_for_all_done(queue_list, ctx->id))
{
ctx->opt = MyTHREAD_OPT_STOP;
myhtml_hread_mutex_wait(mythread, ctx);
ctx->opt = MyTHREAD_OPT_UNDEF;
return false;
}
}
else if(opt & MyTHREAD_OPT_QUIT)
{
if(mythread_function_see_for_all_done(queue_list, ctx->id))
{
myhtml_hread_mutex_close(mythread, ctx);
ctx->opt = MyTHREAD_OPT_QUIT;
return true;
}
}
myhtml_thread_nanosleep(timeout);
return false;
}
void mythread_wait_all(mythread_t *mythread)
{
const struct timespec tomeout = {0, 10000};
for (size_t idx = mythread->pth_list_root; idx < mythread->pth_list_length; idx++) {
while(mythread->pth_list[idx].data.use < mythread->queue->nodes_uses) {
myhtml_thread_nanosleep(&tomeout);
}
}
}
void mythread_function_stream(void *arg)
{
mythread_context_t *ctx = (mythread_context_t*)arg;
mythread_t * mythread = ctx->mythread;
mythread_queue_list_t *queue_list = mythread->queue_list;
const struct timespec timeout = {0, 0};
myhtml_hread_mutex_wait(mythread, ctx);
do {
if(mythread->stream_opt & MyTHREAD_OPT_WAIT) {
ctx->opt = MyTHREAD_OPT_WAIT;
while (mythread->stream_opt & MyTHREAD_OPT_WAIT) {
myhtml_thread_nanosleep(&timeout);
}
ctx->opt = MyTHREAD_OPT_UNDEF;
}
mythread_queue_list_entry_t *entry = queue_list->first;
size_t done_count = 0;
while(entry)
{
mythread_queue_thread_param_t *thread_param = &entry->thread_param[ ctx->id ];
if(thread_param->use < entry->queue->nodes_uses)
{
size_t pos = thread_param->use / entry->queue->nodes_size;
size_t len = thread_param->use % entry->queue->nodes_size;
mythread_queue_node_t *qnode = &entry->queue->nodes[pos][len];
if((qnode->tree->flags & MyHTML_TREE_FLAGS_SINGLE_MODE) == 0)
ctx->func(ctx->id, qnode);
thread_param->use++;
}
else
done_count++;
entry = entry->next;
}
if(done_count == queue_list->count &&
mythread_function_see_opt(ctx, mythread->stream_opt, done_count, &timeout))
break;
}
while (1);
}
void mythread_batch_stop_all(mythread_t *mythread)
{
if(mythread->batch_opt != MyTHREAD_OPT_STOP)
mythread->batch_opt = MyTHREAD_OPT_STOP;
size_t idx;
const struct timespec tomeout = {0, 0};
for (idx = mythread->batch_first_id; idx < (mythread->batch_first_id + mythread->batch_count); idx++) {
while(mythread->pth_list[idx].data.opt != MyTHREAD_OPT_STOP) {
myhtml_thread_nanosleep(&tomeout);
}
}
}
void mythread_queue_list_entry_wait_for_done(mythread_t *mythread, mythread_queue_list_entry_t *entry)
{
if(entry == NULL)
return;
size_t idx;
const struct timespec tomeout = {0, 0};
for (idx = mythread->pth_list_root; idx < mythread->pth_list_size; idx++) {
mythread_queue_thread_param_t *thread_param = &entry->thread_param[ idx ];
while(thread_param->use < entry->queue->nodes_uses) {
myhtml_thread_nanosleep(&tomeout);
}
}
}
void mythread_suspend_all(mythread_t *mythread)
{
if(mythread->stream_opt != MyTHREAD_OPT_WAIT)
mythread->stream_opt = MyTHREAD_OPT_WAIT;
if(mythread->batch_opt != MyTHREAD_OPT_WAIT)
mythread->batch_opt = MyTHREAD_OPT_WAIT;
const struct timespec tomeout = {0, 0};
for (size_t idx = mythread->pth_list_root; idx < mythread->pth_list_size; idx++) {
myhtml_hread_mutex_try_wait(mythread, &mythread->pth_list[idx].data);
while(mythread->pth_list[idx].data.opt != MyTHREAD_OPT_WAIT) {
myhtml_thread_nanosleep(&tomeout);
}
}
}
void mythread_wait_all_for_done(mythread_t *mythread)
{
const struct timespec tomeout = {0, 0};
mythread_queue_list_t *queue_list = mythread->queue_list;
mythread_queue_list_entry_t *entry = queue_list->first;
while(entry)
{
for (size_t idx = mythread->pth_list_root; idx < mythread->pth_list_size; idx++) {
while(entry->thread_param[idx].use < entry->queue->nodes_uses) {
myhtml_thread_nanosleep(&tomeout);
}
}
entry = entry->next;
}
}
void mythread_function_stream(void *arg)
{
mythread_context_t *ctx = (mythread_context_t*)arg;
mythread_t * mythread = ctx->mythread;
mythread_queue_t *queue = mythread->queue;
const struct timespec tomeout = {0, 10000};
myhtml_hread_sem_wait(mythread, ctx);
do {
while (ctx->use >= queue->nodes_uses) {
if(mythread->stream_opt & MyTHREAD_OPT_WAIT) {
if(ctx->use >= queue->nodes_uses) {
ctx->opt = MyTHREAD_OPT_WAIT;
myhtml_hread_sem_wait(mythread, ctx);
ctx->opt = MyTHREAD_OPT_UNDEF;
}
}
else if(mythread->stream_opt & MyTHREAD_OPT_QUIT) {
if(ctx->use >= queue->nodes_uses) {
myhtml_hread_sem_close(mythread, ctx);
ctx->opt = MyTHREAD_OPT_QUIT;
return;
}
}
myhtml_thread_nanosleep(&tomeout);
}
size_t pos = ctx->use / queue->nodes_size;
size_t len = ctx->use % queue->nodes_size;
mythread_queue_node_t *qnode = &queue->nodes[pos][len];
if((qnode->tree->flags & MyHTML_TREE_FLAGS_SINGLE_MODE) == 0)
ctx->func(ctx->id, qnode);
ctx->use++;
}
while (1);
}