我的线程图像生成应用程序如何将其数据获取到gui？

Question

Mandelbrot生成器的慢速多精度实现。 使用POSIX线程进行线程化。 Gtk GUI。

我有点迷路了。 这是我第一次编写线程程序。 我实际上并没有尝试转换它的单线程版本，只是试图实现基本框架。

到目前为止的简要说明：

Main创建了watch_render_start线程，该线程等待一个pthread_cond_signal，单击“ render”按钮时，GUI回调会发出信号。

watch_render_start检查图像是否已经在渲染，是否退出等，但是如果一切顺利，它将创建render_create_threads线程。

然后，render_create_threads线程创建渲染线程，然后使用pthread_join等待它们完成（并且使用get_time_of_day进行一些计时工作-线程是否不好？）。

渲染线程的入口点（想象中）称为render，循环，而next_line计算函数返回TRUE以便处理更多行。 在此while循环中，检查是否停止或退出。

next_line函数在递增变量以指示要计算的下一个线程的下一行之前，获取要计算的行。 如果要处理的线超出图像高度，则返回。 如果不是，则计算该行的内容。 然后增加lines_done并对照图像的高度对其进行检查，如果> =，则返回0，如果<，则返回1。

这是470多行代码，我敢肯定，您会发现它很有趣。

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <mpfr.h>
#include <string.h>
#include <gtk/gtk.h>
#include <sys/time.h>

/* build with:

gcc threaded_app.c -o threaded_app -Wall -pedantic -std=gnu99 -lgmp -lmpfr -pthread -D_REENTRANT -ggdb `pkg-config --cflags gtk+-2.0` `pkg-config --libs gtk+-2.0`

*/

typedef struct
{
    struct timeval tv_start;
    struct timeval tv_end;
} Timer;

void timer_start(Timer* t)
{
    gettimeofday(&t->tv_start, 0);
}

void timer_stop(Timer* t)
{
    gettimeofday(&t->tv_end, 0);
}

long timer_get_elapsed(Timer* t)
{
    if (t->tv_start.tv_sec == t->tv_end.tv_sec)
        return t->tv_end.tv_usec - t->tv_start.tv_usec;
    else
        return (t->tv_end.tv_sec - t->tv_start.tv_sec) *
            1e6 + (t->tv_end.tv_usec - t->tv_start.tv_usec);
}

#define NTHREADS 8

#define IMG_WIDTH  480
#define IMG_HEIGHT 360

typedef struct
{
    int rc;
    pthread_t thread;
} rthrds;

typedef struct
{
    int* arr;
    int next_line;
    int lines_done;
    int rendering;
    int start;
    int stop;
    pthread_t rend[NTHREADS];

    int all_quit;

    int width;
    int height;

    double xmin, xmax, ymax;
    int depth;

} image_info;


static gboolean delete_event(GtkWidget *widget,
                             GdkEvent  *event,
                             gpointer   data);
static void destroy(GtkWidget *widget, gpointer data);

void gui_start_render(GtkWidget* widget, gpointer data);
void gui_stop_render(GtkWidget* widget, gpointer data);

static GtkWidget* gui_pbar = NULL;

void *render(void* ptr);
int next_line(image_info* img);

void* watch_render_start(void* ptr);
void* watch_render_stop(void* ptr);
void* watch_render_done(void* ptr);

void* threads_render_create(void* ptr);

pthread_mutex_t next_line_mutex =  PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lines_done_mutex = PTHREAD_MUTEX_INITIALIZER;

pthread_mutex_t img_start_mutex =      PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t img_stop_mutex =       PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t img_rendering_mutex =  PTHREAD_MUTEX_INITIALIZER;

pthread_cond_t img_start_cond =  PTHREAD_COND_INITIALIZER;
pthread_cond_t img_stop_cond =   PTHREAD_COND_INITIALIZER;
pthread_cond_t img_done_cond =   PTHREAD_COND_INITIALIZER;

pthread_mutex_t all_quit_mutex = PTHREAD_MUTEX_INITIALIZER;

int main(int argc, char **argv)
{
    printf("initializing...\n");
    image_info* img = malloc(sizeof(image_info));
    memset(img, 0, sizeof(image_info));

    img->start = 0;

    img->width = IMG_WIDTH;
    img->height = IMG_HEIGHT;

    img->xmin =  -0.75509089265046296296296259;
    img->xmax = -0.75506025752314814814814765;
    img->ymax =  0.050215494791666666666666005;
    img->depth = 30000;

    size_t arr_size = img->width * img->height * sizeof(int);

    printf("creating array size: %ld bytes\n", arr_size);
    img->arr = malloc(arr_size);
    if (!img->arr)
    {
        fprintf(stderr, "image dimension too large!\n");
        free(img);
        exit(-1);
    }
    memset(img->arr, 0, arr_size);

    int rc_err;
    pthread_t thread_start;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

    printf("creating watch render start thread...\n");

    rc_err = pthread_create(&thread_start, &attr,
                              &watch_render_start, (void*)img);
    if (rc_err)
    {
        fprintf(stderr, "Thread start creation failed: %d\n",
                        rc_err);
        free(img->arr);
        free(img);
        exit(-1);
    }

    printf("creating GUI...\n");

    GtkWidget *window;
    GtkWidget *startbutton;
    GtkWidget *stopbutton;
    GtkWidget *box1;
    gtk_init (&argc, &argv);
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    g_signal_connect (G_OBJECT (window), "delete_event",
                      G_CALLBACK (delete_event), NULL);
    g_signal_connect (G_OBJECT (window), "destroy",
                      G_CALLBACK (destroy), NULL);
    gtk_container_set_border_width (GTK_CONTAINER (window), 10);

    box1 = gtk_hbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(window), box1);

    startbutton = gtk_button_new_with_label ("Start render");
    g_signal_connect (G_OBJECT (startbutton), "clicked",
                      G_CALLBACK (gui_start_render), img);
    gtk_box_pack_start(GTK_BOX(box1), startbutton, TRUE, TRUE, 0);
    stopbutton = gtk_button_new_with_label ("Stop render");
    g_signal_connect (G_OBJECT (stopbutton), "clicked",
                      G_CALLBACK (gui_stop_render), img);
    gtk_box_pack_start(GTK_BOX(box1), stopbutton, TRUE, TRUE, 0);

    gui_pbar = gtk_progress_bar_new();
    gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(gui_pbar),
                                     GTK_PROGRESS_LEFT_TO_RIGHT);
    gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(gui_pbar), 
                               (gfloat)1.0 ); /* img->real_height); */
    gtk_widget_set_size_request(gui_pbar, 75, 0);
    gtk_box_pack_end(GTK_BOX(box1), gui_pbar, FALSE, FALSE, 0);

    gtk_widget_show(startbutton);
    gtk_widget_show(stopbutton);
    gtk_widget_show(box1);
    gtk_widget_show(window);

    printf("starting GUI\n");

    gtk_main ();

    printf("************************\n"
           "GUI shutdown\n"
           "************************\n");

    printf("setting all_quit\n");

    pthread_mutex_lock(&all_quit_mutex);
    img->all_quit = 1;
    pthread_mutex_unlock(&all_quit_mutex);

    printf("signalling watch render start thread to wakeup...\n");

    pthread_mutex_lock(&img_start_mutex);
    pthread_cond_signal(&img_start_cond);
    pthread_mutex_unlock(&img_start_mutex);

    printf("waiting for watch render start thread to quit...\n");

    pthread_join(thread_start, NULL);

    printf("done\n");

    printf("freeing memory\n");

    free(img->arr);
    free(img);

    printf("goodbye!\n");

    exit(0);
}

void gui_start_render(GtkWidget* widget, gpointer ptr)
{
    image_info* img = (image_info*)ptr;

    printf("************\n"
           "GUI signalling to start render...\n"
           "************\n");

    pthread_mutex_lock(&img_start_mutex);
    img->start = 1;
    pthread_cond_signal(&img_start_cond);
    pthread_mutex_unlock(&img_start_mutex);
}

void gui_stop_render(GtkWidget* widget, gpointer ptr)
{
    image_info* img = (image_info*)ptr;

    printf("************\n"
           "GUI signalling to stop render...\n"
           "************\n");

    pthread_mutex_lock(&img_stop_mutex);
    img->stop = 1;
    pthread_mutex_unlock(&img_stop_mutex);
}

void* watch_render_start(void* ptr)
{
    image_info* img = (image_info*)ptr;

    int rc_err;
    pthread_t render_thread;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

    int r;

    int quit = 0;

    for(;;)
    {
        printf("watch_render_start: waiting for img_start_cond\n");
        pthread_mutex_lock(&img_start_mutex);
        if (!img->start)
            pthread_cond_wait(&img_start_cond, &img_start_mutex);
        img->start = 0;
        pthread_mutex_unlock(&img_start_mutex);
        printf("watch_render_start: recieved img_start_cond\n");

        pthread_mutex_lock(&img_rendering_mutex);
        r = img->rendering;
        pthread_mutex_unlock(&img_rendering_mutex);

        printf("checking if we are rendering... ");

        if (r)
        {
            printf("yes\nStopping render...\n");
            pthread_mutex_lock(&img_stop_mutex);
            img->stop = 1;
            pthread_cond_signal(&img_stop_cond);
            pthread_mutex_unlock(&img_stop_mutex);
            pthread_join(render_thread, NULL);
            printf("render stopped\n");
        }
        else
            printf("no\n");

        pthread_mutex_lock(&all_quit_mutex);
        quit = img->all_quit;
        pthread_mutex_unlock(&all_quit_mutex);

        if (quit)
        {
            printf("exiting watch render start thread\n");
            pthread_exit(0);
        }

        printf("creating render thread...\n");
        rc_err = pthread_create(&render_thread, &attr,
                                &threads_render_create, (void*)img);
        if (rc_err)
            pthread_exit(0);
    }
}

void* threads_render_create(void* ptr)
{
    Timer timing_info;

    printf("initializing render thread\n");

    image_info* img = (image_info*)ptr;

    pthread_mutex_lock(&img_rendering_mutex);

    img->rendering = 1;
    pthread_mutex_unlock(&img_rendering_mutex);

    pthread_mutex_lock(&lines_done_mutex);
    img->lines_done = 0;
    pthread_mutex_unlock(&lines_done_mutex);

    pthread_mutex_lock(&img_stop_mutex);
    img->stop = 0;
    pthread_mutex_unlock(&img_stop_mutex);

    pthread_mutex_lock(&next_line_mutex);
    img->next_line = 0;
    pthread_mutex_unlock(&next_line_mutex);

    int rc_err, i;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

    timer_start(&timing_info);

    for (i = 0; i < NTHREADS; ++i)
    {
        printf("creating renderer thread #%d...\n", i);
        rc_err = pthread_create(&img->rend[i], &attr,
                                &render, (void*)img);
        if (rc_err)
        {
            fprintf(stderr, "\nrender thread #%d creation failed: %d\n",
                            i, rc_err);
            return 0;
        }
    }

    for (i = 0; i < NTHREADS; ++i)
    {
        printf("joining renderer thread #%d...\n", i);
        pthread_join(img->rend[i], NULL);
    }

    timer_stop(&timing_info);
    printf("render-time %.3fs\n\n",
            timer_get_elapsed(&timing_info) / (double)1e6);

    printf("all renderer threads finished\n");

    pthread_mutex_lock(&img_stop_mutex);
    img->stop = 0;
    pthread_mutex_unlock(&img_stop_mutex);

    pthread_mutex_lock(&img_rendering_mutex);
    img->rendering = 0;
    pthread_mutex_unlock(&img_rendering_mutex);

    printf("at end of threads_render_create\n");
    pthread_mutex_lock(&lines_done_mutex);
    if (img->lines_done >= img->height)
        printf("image complete\n");
    else
        printf("image interuppted\n");
    pthread_mutex_unlock(&lines_done_mutex);

    pthread_mutex_lock(&img_start_mutex);
    img->start = 0;
    pthread_mutex_unlock(&img_start_mutex);
    printf("exiting render thread\n");
    pthread_exit(NULL);
}

void* render(void* ptr)
{
    image_info* img = (image_info*)ptr;
    int quit = 0;
    printf("starting render..\n");
    while(next_line(img) && !quit)
    {
        pthread_mutex_lock(&img_stop_mutex);
        quit = img->stop;
        pthread_mutex_unlock(&img_stop_mutex);
        pthread_mutex_lock(&all_quit_mutex);
        quit |= img->all_quit;
        pthread_mutex_unlock(&all_quit_mutex);
    }
    printf("exiting render thread\n");
    pthread_exit(0);
}

int next_line(image_info* img)
{
    int line;

    pthread_mutex_lock(&next_line_mutex);
    line = img->next_line++;
    pthread_mutex_unlock(&next_line_mutex);

    if (line >= img->height)
        return 0;

    int ix,wz;
    int img_width = img->width;
    long double x,y,x2,y2,wre=0,wim=0,wre2=0,wim2=0;
    long double xmin = img->xmin, xmax = img->xmax, ymax = img->ymax;
    long double xdiff = xmax - xmin;
    int depth = img->depth;
    long double c_im = 0, c_re = 0;

    y = ymax - (xdiff / (long double)img_width)
                * (long double)line;
    y2 = y * y;

    for (ix = 0; ix < img_width; ++ix)
    {
        x = ((long double)ix / (long double)img_width) * xdiff + xmin;
        x2 = x * x;
        wre = x;
        wim = y;
        wre2 = x2;
        wim2 = y2;
        for (wz = 0; wz < depth; ++wz)
        {
            wim = 2.0 * wre * wim + c_im;
            wre = wre2 - wim2 + c_re;
            wim2 = wim * wim;
            wre2 = wre * wre;
            if (wim2 + wre2 > 4.0F)
                break;
        }
        if (wz == depth + 1)
            wz = 0;
        img->arr[line * img_width + ix] = wz;
    }

    printf("line %d complete\n", line);

    pthread_mutex_lock(&lines_done_mutex);
    img->lines_done++;
    if (img->lines_done == img->height)
    {
        pthread_mutex_unlock(&lines_done_mutex);
        return 0;
    }
    pthread_mutex_unlock(&lines_done_mutex);

    return 1;
}

static gboolean delete_event(GtkWidget *widget,
                             GdkEvent  *event,
                             gpointer   data)
{
   return FALSE;
}

static void destroy(GtkWidget *widget, gpointer data)
{
    gtk_main_quit ();
}

我已经走了很远，需要一些有关如何进行的指示。 对于我面对的每个问题，我只会看到迷惑的迷宫般的解决方案，导致死胡同！

我想先解决进度栏。 gui将需要在lines_done上设置锁。 但是如何知道何时执行此操作呢？ 多久看一次lines_done？ 我想我可以为此使用g_idle_add。

然后是真正渲染所有那些快乐线程正在生成的数据的真正难题。 正如在另一个问题上讨论的那样，我将有一个标志数组来指示实际渲染的行（因为由于线程和os调度程序的特性，它们将以任意顺序渲染）。 但是，GUI将如何检查这些内容？ 在与进度条相同的空闲回调中？ 假设正在生成一个大的8000像素高的大图像，那就是每隔这么多毫秒就锁定和解锁8000个互斥锁-这一定要付出代价吗？

那么我应该怎么做呢？ 我正在使用的这个模型（无论它是什么）能够执行我想要的操作吗？

Answer 1

减少互斥锁的数量：

• 有一个互斥锁可访问已完成信号的行位缓冲区（8000 / 8bits = 1000byte缓冲区）。

• 第二个临时位缓冲区。

• 工作线程锁定互斥锁，在第一个缓冲区中设置位并解锁互斥锁。

• 主循环锁定互斥锁，将第一个缓冲区复制到第二个并解锁互斥锁。

• 然后扫描第二个缓冲区是否为非零，并为每个设置的位复制该行的数据以输出/屏幕。

• 为了减少对第一个位缓冲区的争用，您可以将第一个位缓冲区划分为8个或什至16个段（根据行号mod 8或mod 16在我们中查找该段），并且每个段都有一个互斥量。

-

可能的方法是使用我建议的设计，但是使用“ try_lock”（而不是等待）锁，执行几次NOP并重试，直到它们可用而不是屈服为止。 直接使用atomic inc / dec而不是pthread互斥锁以获得更高的性能可能是值得的。

最后，除非您有8个处理器，否则不值得拥有8个线程，而且我不了解get_time_of_day。

编辑 ：我建议如果主线程在锁定位缓冲区互斥锁时被抢占，则其他线程可能会浪费时间。 降低其他线程的优先级可以降低发生这种情况的频率，但是我认为更好的总体策略是使用8000个atomic_t类型的数组以及atomic inc / dec指令来指示从工作线程到主线程的行完成情况。 可以通过主线程搜索这8000个atomic_t。 我也假设您将工作线程的数量减少到比CPU的数量少一。

编辑 ：八个线程似乎有点武断。 您从哪里得到这个号码？ 显然，您至少需要一个工作线程。

编辑 ：更快的方法是使用atomic_set_mask在前端循环扫描的1000字节缓冲区中设置位。

编辑 ：假设您的平台上有atomic_set_mask。

Answer 2

将条件变量与next_line_mutex一起使用。 渲染到GUI函数可以保留变量并保留其最后一行，并在条件触发时将其与next_line变量进行比较，以便可以查看需要渲染的行。 next_line函数可以触发条件。

正如我所指出的，上述条件变量将导致GUI锁定，因此这不是一个好主意。 取而代之的是，我认为GUI应该每隔一段时间检查一次行变量，也许每秒一次。

如果8000个锁定/解锁操作的性能太慢，那么我建议分3、5、7甚至8（对于8个线程）进行批量处理。 如果为每个线程分配不同数量的行来处理，并且每行花费大约相同的处理时间，则锁定在被使用时很可能是无竞争的。 无竞争的锁非常便宜，尽管它仍然比正常的CPU操作昂贵（它必须从使用它的最后一个CPU中拉出缓存行）。 通过使next_line为next_lines（img，8）可以很容易地做到这一点。

Answer 3

如果您有权访问平台上的原子读取和原子写入，则创建一个工作分配表（阅读平台的体系结构说明-可能会或可能不会是普通读写足够好，您可能会或可能会不需要添加内存屏障）：

每行一个字节，最初为零，非零表示该行分配给的线程

...并在每个工作线程的int字段中创建原子更新的行数。 该表应使用原子读/写指令进行更新和读取（因此，根据平台上的可用指令，以8、16、32或64位的块为单位）。

顶级逻辑必须确定是直接在主线程上直接完成所有工作（如果映像确实很小），还是启动一个工作线程，或者启动N个工作线程。

协调线程（或者如果我是我可能会废弃协调线程，并在主线程上执行此操作）将循环中的一半作业分配给线程（如果少于一定数量，则分配所有工作）。 如果分配的工作量少于所有工作量，则它将监视其他线程并确定平均线程和最佳线程的性能基准。 它确保线程整体上不会耗尽工作，但尽量不要使线程无所事事。

前端为每个工作人员保留一个指针，该指针指向该工作人员要完成的分配表的位置，并且当该工作人员增加其整数字段以完成工作的行数时，前端将在工作分配表中向前搜索查找分配给该工作人员的已完成工作的行索引，并更新完成特定行的位缓冲区，并更新总完成字段。

-

这是一种用于动态地将工作分配给线程的通用算法，正如另一位发布者所建议的，您可以通过使工作线程应处理的行号为工作线程数和工作线程号的函数，来替代地静态分配工作，然后只需将每个工作人员通过原子场完成的行数传递到前端即可。