code/mandelbrot/mandelbrot.c

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>


#include "../libpng/img.h"
#include "config.h"

typedef struct mandel_field_t {
    int h, w;
    int *arr;
    pthread_mutex_t mut;
} mandel_field_t;

typedef struct mandel_t {
    int x, y;
    int bail_out;
    int max_iter;
    mandel_field_t field;
} mandel_t;

typedef struct inner {
    pthread_mutex_t mut;
} inner;

typedef struct buffer {
    sem_t empty;
    sem_t full;
    pthread_mutex_t mut;
    int pos;
    mandel_t **pix;
    inner *in;
} buffer;



double map(int value, int min, int max, int map_min, int map_max)
{
    double R = (double) (map_max - map_min) / (double) (max - min);
    double y = map_min + (value * R) + R;
    return y;
}


int mandelbrot_pix(double x, double y, int bail_out, int max_iter)
{
    int k;
    double real, imaginary, x2, y2;

    x2 = x;
    y2 = y;

    // iterate a^2 - b^2 + 2ab
    for (k = 0; k < max_iter; k++) {
	// a^2 - b^2
	real = x * x - y * y;
	// 2ab
	imaginary = 2 * x * y;

	// x = real + c
	x = real + x2;
	// y = imaginary + c
	y = imaginary +y2;

	if ((x * x + y * y) > bail_out) {
	    return k;
	}
    }
    return max_iter;
}

void init_buffer(buffer * buf)
{
    sem_init(&buf->empty, 0, 0);
    sem_init(&buf->full, 0, BUFFER_SIZE);
    buf->in = malloc(sizeof(inner));
    buf->pos = 0;
    buf->pix = malloc(sizeof(mandel_t) * BUFFER_SIZE);

    for (int i = 0; i < BUFFER_SIZE; i++) {
	buf->pix[i] = NULL;
    }
}

void mandel_field_setXY(mandel_field_t m, int x, int y, int value)
{
    pthread_mutex_lock(&m.mut);
    m.arr[x * m.h + y] = value;
    pthread_mutex_unlock(&m.mut);
}

void *mandel_consumer(void *buff)
{
    buffer *buf = (buffer *) buff;
    mandel_t *pix;
    int count = 0;
    double xPrime, yPrime;

    while (1) {

	int tw = sem_trywait(&buf->empty);
	if (tw == 0) {
	    pthread_mutex_lock(&buf->mut);

	    buf->pos = buf->pos - 1;
	    pix = buf->pix[buf->pos];
	    count++;
	    sem_post(&buf->full);


	    xPrime = map(pix->x, 0, pix->field.w, -2, 2);
	    yPrime = map(pix->y, 0, pix->field.h, -2, 2);

	    int k = mandelbrot_pix(xPrime, yPrime, pix->bail_out,
				   pix->max_iter);
	    mandel_field_setXY(pix->field, pix->x, pix->y, k);
	    pthread_mutex_unlock(&buf->mut);
	} else {
	    int rc = pthread_mutex_trylock(&buf->in->mut);
	    if (rc == 0) {
		printf("\ngot lock");
		pthread_mutex_unlock(&buf->in->mut);
		pthread_exit(NULL);
	    }
	}
    }
}

void mandelbrot(int *field, int w, int h, int bail_out, int max_iter,
		int thread_count)
{
    double xPrime, yPrime;
    int x, y, k;

    buffer *buf;
    buf = malloc(sizeof(buffer));
    init_buffer(buf);

    pthread_t t[thread_count];
    pthread_attr_t attr;

    pthread_attr_init(&attr);

    pthread_mutex_lock(&buf->in->mut);
    for (int i = 0; i < thread_count; i++) {
	pthread_create(&t[i], &attr, mandel_consumer, buf);
    }

    for (int i = 0; i < w; i++) {
	for (int j = 0; j < h; j++) {
	    sem_wait(&buf->full);
	    pthread_mutex_lock(&buf->mut);


	    buf->pix[buf->pos] = malloc(sizeof(mandel_t));
	    buf->pix[buf->pos]->x = i;
	    buf->pix[buf->pos]->y = j;
	    buf->pix[buf->pos]->bail_out = bail_out;
	    buf->pix[buf->pos]->max_iter = max_iter;
	    buf->pix[buf->pos]->field.arr = field;
	    buf->pix[buf->pos]->field.h = h;
	    buf->pix[buf->pos]->field.w = w;
	    buf->pos += 1;

	    sem_post(&buf->empty);
	    pthread_mutex_unlock(&buf->mut);
	}
    }
    pthread_mutex_unlock(&buf->in->mut);
    printf("Finished filling the buffer");

    for (int i = 0; i < thread_count; i++) {
	pthread_join(t[i], NULL);
    }

    free(buf->in);
    free(buf->pix);
    free(buf);
}

int main(int argc, char **argv)
{

    int *pix_field;

    pix_field = malloc(WIDTH * HEIGHT * sizeof(int));

    printf
	("WIDTH: %d\nHEIGHT %d\nBAIL OUT %d\nMAX ITER %d\nTHREAD COUNT %d",
	 WIDTH, HEIGHT, BAIL_OUT, MAX_ITER, THREAD_COUNT);


    mandelbrot(pix_field, WIDTH, HEIGHT, BAIL_OUT, MAX_ITER, THREAD_COUNT);

    pix_row rows[WIDTH];
    pix p;

    char filename[30];
    image img;
    p.r = 200;
    p.g = 200;
    p.b = 200;

    for (int i = 0; i < WIDTH; i++) {
	rows[i].p = malloc(HEIGHT * sizeof(pix));
	for (int j = 0; j < HEIGHT; j++) {
	    p.r = map(pix_field[i * HEIGHT + j], 0, MAX_ITER, 0, 255);
	    p.g = map(pix_field[i * HEIGHT + j], 0, MAX_ITER, 0, 255);
	    p.b = map(pix_field[i * HEIGHT + j], 0, MAX_ITER, 0, 255);
	    rows[i].p[j] = p;
	}
    }
    sprintf(filename, "mandel.png");
    img = initialize_png("mandelbrot", filename, WIDTH, HEIGHT);
    write_image(&img, rows);
    finish_image(&img);
    for (int i = 0; i < WIDTH; i++) {

	free(rows[i].p);
    }

    free(pix_field);

    return (0);
}