From a7db7bced3aa759285a81da73d93c5dcdc2ecaee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Carlos=20Cuevas?= <reset.reboot@gmail.com>
Date: Thu, 29 Aug 2013 19:31:20 +0200
Subject: [PATCH] First commit

---
 .Makefile.swp             | Bin 0 -> 12288 bytes
 .main.c.swp               | Bin 0 -> 36864 bytes
 .mandel_classic.c.swp     | Bin 0 -> 45056 bytes
 .mandelbrot_kernel.cl.swp | Bin 0 -> 12288 bytes
 .sum_kernel.cl.swp        | Bin 0 -> 12288 bytes
 .vector_add_kernel.cl.swp | Bin 0 -> 12288 bytes
 CL                        |   1 +
 Makefile                  |  38 ++++
 frag_shader.glsl          |  38 ++++
 main.c                    | 209 +++++++++++++++++
 mandel_classic.c          | 462 ++++++++++++++++++++++++++++++++++++++
 mandel_classic.o          | Bin 0 -> 7200 bytes
 mandelbrot_kernel.cl      |  45 ++++
 mandelclassic             | Bin 0 -> 11941 bytes
 test                      | Bin 0 -> 10172 bytes
 test.c                    | 301 +++++++++++++++++++++++++
 test.o                    | Bin 0 -> 5136 bytes
 vector_add_kernel.cl      |  12 +
 18 files changed, 1106 insertions(+)
 create mode 100644 .Makefile.swp
 create mode 100644 .main.c.swp
 create mode 100644 .mandel_classic.c.swp
 create mode 100644 .mandelbrot_kernel.cl.swp
 create mode 100644 .sum_kernel.cl.swp
 create mode 100644 .vector_add_kernel.cl.swp
 create mode 120000 CL
 create mode 100644 Makefile
 create mode 100644 frag_shader.glsl
 create mode 100644 main.c
 create mode 100644 mandel_classic.c
 create mode 100644 mandel_classic.o
 create mode 100644 mandelbrot_kernel.cl
 create mode 100755 mandelclassic
 create mode 100755 test
 create mode 100644 test.c
 create mode 100644 test.o
 create mode 100644 vector_add_kernel.cl

diff --git a/.Makefile.swp b/.Makefile.swp
new file mode 100644
index 0000000000000000000000000000000000000000..ca472e6402486ce6ee8b815076d0cf5e2dd036af
GIT binary patch
literal 12288
zcmeI2O=}ZD7{@1~hk&)BC+)%M3(^RiwCO<!1gxpm)a?tFT0H4yGTE$7cFNAg_Ef=7
zpx?j`U_B|QpG5JhH}75q{qIX-k`@a+S$G1!%<Swl&pyv@Ps?s&=0Sa#UoXxv{LVAB
z`{K&|-00)nhaJWuX{3$UkN6qgwe9U7Y#tG}n<Ol)Mf!;p)|5J4*p#XfX<J(Mp2}9B
z<PjO@G#MZR$1>2hE$7Avn=8-G#QP^F#`(ny8^=mTo5%neAOmE843GgbKnBPF8912+
z>{gCFN9m`s@~>uNZfML7X&?h+fDDiUGC&5%02v?yWPl8i0Wv@aPM`q~FYWK0W$ZVI
z-~aDF|Nj_e>^t}dzJmAQ9WY=W6u=p98vHuP*cb2_d;%ZA9(V&@ftO$hY=cd38C(KC
zM;Lnx_P}ef4W0oXl))^R1QTEkBsHEu$5b*IAOmE843GgbKnBPF86X4yfq{HJe>3Xv
zYemh|Z;^%aj0ps{(pV;x^uh{b#kISuD-SC?Ic6+BHC?L}IQ|#i`8(_JtiDonHx_Qk
zQ@4H#OY#1q;Eqmbnk5UmlAY*F(%YIw^fF{yla1Ln-M8%@*G@Zml(mvpF|?-HK)Xd0
zHWVTHuGK4XC`R`eJ1B54|AFl2#8Ya2c|bbLu2yyGrLKueK`2zWDNE}ME*=JXJv}tz
zjK!v_j_PnnZP|7ty(a2GSaJvOkebe_Q`4p`mExwU9HGNj;B&`OLBkY~&c%pSlRWiV
zb#Tu%Q5tuAzu8FhrFZ$TnAI|O7M3>L`usrTfn117D*KyBcRDh(+_nS5RS-&!FX4GN
z6uouHL%D+h&3$S4Qdb2YZ$+N4o-#>qNv^}26D{TWNqdX&1pU=&RbL3Su$+8xUvn|Z
HzPJAa8N(Zv

literal 0
HcmV?d00001

diff --git a/.main.c.swp b/.main.c.swp
new file mode 100644
index 0000000000000000000000000000000000000000..98ad4a8de0a41d9273c037077e4eb3da9ec6931d
GIT binary patch
literal 36864
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
AIRF3v

literal 0
HcmV?d00001

diff --git a/.mandel_classic.c.swp b/.mandel_classic.c.swp
new file mode 100644
index 0000000000000000000000000000000000000000..a715f0d7eadd6fb71f09df2f070c30b2b19c8d06
GIT binary patch
literal 45056
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

literal 0
HcmV?d00001

diff --git a/.mandelbrot_kernel.cl.swp b/.mandelbrot_kernel.cl.swp
new file mode 100644
index 0000000000000000000000000000000000000000..8db853b701d05d226472f991fdb69a1678f14ccd
GIT binary patch
literal 12288
zcmeI2zi-n(6vwX}V1Q6m*jOI0*e!9~mcq~<6A}UmR6wvGWSrz0n>u#nT!~EuhzZ2M
zzycEj!NSCUfS3?WjEDjL2PVE}UmF)%l@1J*o~2Lh+`aew?&IrF#ZC9dg-dkSnGrY+
z3vskIesy&0_Q?B8h*b8a(&IZE{bW@IgD`II5ci-c*jP%FJF=zvjjkWJWz<X)Rk`$5
zWE#uJX+=9!<7qa)26ktlCT6CmT%B|B#Bn+@etmc89L)yU02^QfY=8~00XDz}*ub7P
zpn4<XAyzPIR#7+Skw4DnE1%c^8(;%$fDNz#Hoykh02^QfY=8~0fjwxz$B*{W0U_oO
zqIvxOzyAOK_c0;9fj8hacm<w<C*T^m0+ztXLqdE2&%gk9;0&mNUo|0qf*;@$cn4m9
z=inYt;4*MP9UKGu!9MU6{d@tR!CUYWJO+<I22yYloCAwM_df^tU;}J`4X^<=zy{a=
z8(;%$;Qtu7FGwH7r@1ETq<$~(qA->>!>-?vUUrKXC{!}_RhYzcMf6(nDWkspmt?n^
z6fTpsQH>TCsOx9m#(*t07u3;KMiZ3TG)Y#DtK8OE)@jGJZEB{{UzsbDh=y%WPL}t?
zScdj9CA+<0SdO7-$JJ$ZK~(M~eJ>xT=y07@MAQ*6jLNEu83bV@tLvHHayiRU;;Z#0
z&=Q5Q+8n4Gnw>36>&Xovn1DW^lgcW(ch@mWP2s<XiuGW)>-W6eDj#Hiitqxrm)qrS
z%3K|&4e7wl1ZHJmW&(?TimjmUt#?MH&vJ`kyd#y@iIS!td12dfO>Uz>=cOVQNUXUn
zGfI|=FRj%yl~|{YWEW?#COq@vINeRcHriQ#wcP6^Xu$GJacU)TAAXRl7lT%}nZate
zn9<!=CUlvJ;f}XSi1H61m1;GOvG=S(lbut8%w-_MPM~aT32Y&o>NKUF#+oR78sVsm
n26TB7zFpyLSa=Y&RiNw6IJ3I$w1W*%t&8V_f>^RXmC@oir3qDQ

literal 0
HcmV?d00001

diff --git a/.sum_kernel.cl.swp b/.sum_kernel.cl.swp
new file mode 100644
index 0000000000000000000000000000000000000000..9fd3b55b2343ebd660beebc8e5957e0b7ace69f9
GIT binary patch
literal 12288
zcmeI&%}T>S5C`zBCofj5dLQ-DR&8o~P!JDo1wTL#K`$b)O{Q%$W=pcEf~YSeK8z3G
zV|e%GBt#JrN{@yA!Z7T|>?Xfk$abpdhsU&4sVix7O1(AaPe1clxsQ@kAxCVI@ewW3
zvFYD=fjeT|Q@Wvb66$MqOl0W+2aazWj*Jz>xAqN(0s9rlAF&UnApn6f1!B|P*q%}K
z+GaJWTwPhFg~HjGn_xKvAOHafKmY;|fB*y_Fv$XDkW<g{0#n&bOlLXwCudzG2tWV=
z5P$##AOHafKmY;|fB*z0P@pY8?ceiC6=vn(<^TWp_y4Q(UnKexM-m4TRf$E3WbKj!
z8U!E!0SG_<0uX=z1Rwwb2tZ(R1s)YiYh8Gkv`dX7tx+>cWvcC@bCyMWnoOTbZm@@K
z<LN+AI^zX~JSpq3v3tJmw0+xii`CLk-9DSNP%g{!J?U=RapEv!sbrsTlWa6~m<FMC
yIEvVnz3uF7JPozy(ok;C>(FkyZqd$;Ax8(1oGsPm#yb5s-2641u4|R(L45(0HE?18

literal 0
HcmV?d00001

diff --git a/.vector_add_kernel.cl.swp b/.vector_add_kernel.cl.swp
new file mode 100644
index 0000000000000000000000000000000000000000..e443a72af76eda34d2f4ecad0ede91cffb83d00d
GIT binary patch
literal 12288
zcmeI&&o2W(6bJBEXX@8K@Nj9XZ0UhS9I8Y}BqHG=vbNp9vUZy3ETX|5<DVh^40qz>
z>g{F`y|h=&caqo1{CID7KDTD4Q90P!;idU1NgE^D-WcEe%pd38ibO`Wl}+Y*w6>1z
z*>w>4J@(zF1)W`^&sEd59o<q<Gjy$LTjxq<v~fM(cQ2HQR5;%Zdz8a61R&6_Kx|Lu
zmPe?%xKK$_W~Qfja$>*VZ0v&o1Rwwb2tWV=5P$##20*~Ja`YhQ7|PBvob|b`J{zKg
z00bZa0SG_<0uX=z1Rwwb2teQ;3V8C-{xMJVE|Gly|Nj5~I!g2+@htHqaVrr^Y)Q;Y
zlq4o3KE8AR;o0%Z5P$##AOHafKmY;|fB*y_Fn9uYStFKKKMam|mF3QPa^ai{H5r$A
zO@50j=?2H)b<OrnvD{HNo(*(F=|T`$4kYzdS@$&54KH*9zfk#2+f+8qliTp>hV@B0
zXvW4U$yA}bls>IQZg$a~uXNxi?~>hrFSuD{P99dOmHF?)TK7b~$Q`1)w5m}yHW3#*
Zp5;c7OI%%{q|DDzlYv)GOUrtPz5w$|f|39L

literal 0
HcmV?d00001

diff --git a/CL b/CL
new file mode 120000
index 0000000..ec67360
--- /dev/null
+++ b/CL
@@ -0,0 +1 @@
+/opt/intel/opencl-1.2-3.0.67279/include/CL
\ No newline at end of file
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..954d8c4
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,38 @@
+# MandelCL Makefile
+CC=gcc
+
+# Flags!
+SDLFLAGS=$(shell sdl-config --cflags)
+
+# Comment this line and uncomment the next to get Julia fractals
+CFLAGS=-c -Wall -O2 $(SDLFLAGS)
+# CFLAGS=-c -Wall -O2 -DJULIA $(SDLFLAGS)
+# CFLAGS=-c -Wall -ggdb $(SDLFLAGS)
+
+# Libs!
+SDLLIBS=$(shell sdl-config --libs)
+
+LIBS=-lm -lpthread $(SDLLIBS)
+
+# Includes!
+
+INCLUDE=-I/usr/include/SDL
+
+all: mandelclassic test
+
+mandelclassic: mandel_classic.o
+	$(CC) $(INCLUDE) mandel_classic.o $(LIBS) -o  mandelclassic
+
+mandelclassic.o: mandel_classic.c
+	$(CC) $(CFLAGS) $(INCLUDE) $(LIBS) mandel_classic.c -o mandel_classic.o
+
+test: test.o
+	$(CC) $(INCLUDE) test.o $(LIBS) -o test
+
+test.o: test.c
+	$(CC) $(CFLAGS) $(INCLUDE) $(LIBS) test.c -o test.o
+
+.PHONY: clean
+
+clean:
+	@rm *.o mandelclassic test
diff --git a/frag_shader.glsl b/frag_shader.glsl
new file mode 100644
index 0000000..29f9ccd
--- /dev/null
+++ b/frag_shader.glsl
@@ -0,0 +1,38 @@
+void main(void)
+{
+	float zoom = float(iMouse.x) / float(iResolution.x);
+    float pos_x = ((float(gl_FragCoord.x) / float(iResolution.x)) * 3.5 * zoom) - (2.5 - (1.0 - zoom));
+	float pos_y = ((float(gl_FragCoord.y) / float(iResolution.y)) * 2.0 * zoom) - (1.0 - (1.0 - zoom));
+    float x = 0.0;
+    float y = 0.0;
+
+    int iteration = 0;
+	float normal_iter = 0.0;
+    int max_iteration = 255;
+    float xtemp;
+
+    while (iteration < max_iteration)
+    {
+       xtemp = x * x - y * y + pos_x;
+       y = 2.0 * x * y + pos_y;
+	   if ((x * x) + (y * y) >= (4.0)) break;
+
+       x = xtemp;
+       iteration++;
+    }
+
+    if (iteration >= max_iteration)
+    {
+		gl_FragColor = vec4(0.0,0.0,0.0,1.0);
+    }
+    else if (iteration < 128)
+    {
+		normal_iter = float(iteration) / 255.0;
+        gl_FragColor = vec4(0,0.1 + normal_iter,normal_iter,1.0);
+    }
+	else
+	{
+		normal_iter = float(iteration) / 255.0;
+		gl_FragColor = vec4(1.0 - normal_iter, 1.0, 1.0 - normal_iter, 1.0);
+	}
+}
diff --git a/main.c b/main.c
new file mode 100644
index 0000000..213c099
--- /dev/null
+++ b/main.c
@@ -0,0 +1,209 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#ifdef __APPLE__
+#include <OpenCL/opencl.h>
+#else
+#include <CL/cl.h>
+#endif
+
+#include <SDL.h>
+
+#define MAX_SOURCE_SIZE (0x100000)
+
+int main(int argn, char **argv) {
+    
+    // Init SDL
+    if(SDL_Init(SDL_INIT_VIDEO) != 0)
+        fprintf(stderr, "Could not initialize SDL: %s\n", SDL_GetError());
+
+    printf("SDL Initialized\n");
+
+    // Create screen surface
+    SDL_Surface *screen;
+    int res_x = 800;
+    int res_y = 600;
+    int current_line = 0;
+    int total_res = res_x * res_y;
+
+    screen = SDL_SetVideoMode(res_x, res_y, 0, SDL_HWSURFACE|SDL_DOUBLEBUF);
+    if(!screen)
+	    fprintf(stderr,"Could not set video mode: %s\n",SDL_GetError());
+
+    // Prepare the resolution and sizes and colors...
+    int i;
+    int temp;
+    const int ITERATIONS = 256;
+    int *red_scale = (int*)malloc(sizeof(int)*ITERATIONS);
+    int *blue_scale = (int*)malloc(sizeof(int)*ITERATIONS);
+    for(i = 0; i < ITERATIONS; i++) {
+        red_scale[i] = i;
+        blue_scale[i] = 255 - i;   
+    }
+
+
+    // Load the kernel source code into the array source_str
+    FILE *fp;
+    char *source_str;
+    size_t source_size;
+
+    fp = fopen("mandelbrot_kernel.cl", "r");
+    if (!fp) {
+        fprintf(stderr, "Failed to load kernel.\n");
+        exit(1);
+    }
+    source_str = (char*)malloc(MAX_SOURCE_SIZE);
+    source_size = fread( source_str, 1, MAX_SOURCE_SIZE, fp);
+    fclose( fp );
+
+    // Get platform and device information
+    cl_platform_id platform_id = NULL;
+    cl_device_id device_id = NULL;   
+    cl_uint ret_num_devices;
+    cl_uint ret_num_platforms;
+    cl_int ret = clGetPlatformIDs(1, &platform_id, &ret_num_platforms);
+    ret = clGetDeviceIDs( platform_id, CL_DEVICE_TYPE_GPU, 1, 
+            &device_id, &ret_num_devices);
+
+    // Create an OpenCL context
+    cl_context context = clCreateContext( NULL, 1, &device_id, NULL, NULL, &ret);
+
+    // Create a command queue
+    cl_command_queue command_queue = clCreateCommandQueue(context, device_id, 0, &ret);
+
+    // Create memory buffers on the device for returning iterations 
+    cl_mem kernel_res_x = clCreateBuffer(context, CL_MEM_READ_ONLY,
+            sizeof(cl_int), NULL, &ret);
+    cl_mem kernel_res_y = clCreateBuffer(context, CL_MEM_READ_ONLY,
+            sizeof(cl_int), NULL, &ret);
+    cl_mem kernel_current_line = clCreateBuffer(context, CL_MEM_READ_ONLY,
+            sizeof(cl_int), NULL, &ret);
+    cl_mem graph_mem_obj = clCreateBuffer(context, CL_MEM_WRITE_ONLY, 
+            res_x * sizeof(cl_int), NULL, &ret);
+
+    // Copy resolution x and y for the kernel
+    ret = clEnqueueWriteBuffer(command_queue, kernel_res_x, CL_TRUE, 0,
+            sizeof(cl_int), &res_x, 0, NULL, NULL);
+
+    ret = clEnqueueWriteBuffer(command_queue, kernel_res_y, CL_TRUE, 0,
+            sizeof(cl_int), &res_y, 0, NULL, NULL);
+
+    ret = clEnqueueWriteBuffer(command_queue, kernel_current_line, CL_TRUE, 0,
+            sizeof(cl_int), &current_line, 0, NULL, NULL);
+
+    // Create a program from the kernel source
+    cl_program program = clCreateProgramWithSource(context, 1, 
+            (const char **)&source_str, (const size_t *)&source_size, &ret);
+
+    // Build the program
+    ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL);
+
+    // Create the OpenCL kernel
+    cl_kernel kernel = clCreateKernel(program, "mandelbrot_point", &ret);
+
+    // Our screen in a linear array
+    int *graph_dots = (int*)malloc(total_res * sizeof(int)); 
+    cl_int *graph_line = (cl_int*)malloc(res_x * sizeof(cl_int));
+
+    for (current_line = 0; current_line < 600; current_line++)
+    {
+        // Set the arguments of the kernel
+        ret = clEnqueueWriteBuffer(command_queue, kernel_current_line, CL_TRUE, 0,
+                sizeof(cl_int), &current_line, 0, NULL, NULL);
+
+        ret = clSetKernelArg(kernel, 0, sizeof(cl_mem), &kernel_res_x);
+        ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), &kernel_res_y);
+        ret = clSetKernelArg(kernel, 2, sizeof(cl_mem), &kernel_current_line);
+        ret = clSetKernelArg(kernel, 3, sizeof(cl_mem), graph_mem_obj);
+        
+        // Execute the OpenCL kernel on the list
+        size_t global_item_size = res_x; // Process the entire screen
+        size_t local_item_size = 64; // Process in groups of 64
+        ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, 
+                &global_item_size, &local_item_size, 0, NULL, NULL);
+
+        // Read the memory buffer graph_mem_obj on the device to the local variable graph_dots
+        ret = clEnqueueReadBuffer(command_queue, graph_mem_obj, CL_TRUE, 0, 
+                res_x * sizeof(cl_int), graph_line, 0, NULL, NULL);
+
+        for (i = 0; i < 800; i++)
+        {
+            graph_dots[(current_line * 800) + i] = graph_line[i];
+        }
+    }
+
+    // Display the result to the screen
+    /* for(i = 0; i < 3078; i++)
+        printf("Linear: %d -> %d\n", i, graph_dots[i]); */
+
+    printf("Rendering...\n");
+
+    int iteration;
+	Uint32 *pixel;
+	// Lock surface
+	SDL_LockSurface(screen);
+	// rank = screen->pitch/sizeof(Uint32);
+	pixel = (Uint32*)screen->pixels;
+	/* Draw all dots */
+	for(i = 0;i < total_res;i++)
+	{
+		// Get the iterations for the point
+        // printf("Point %d\n", i);
+        iteration = graph_dots[i];
+        if ((iteration < 1000) && (iteration >= 0)) {
+            pixel[i] = SDL_MapRGBA(screen->format,
+                                   red_scale[iteration],
+                                   0,
+                                   blue_scale[iteration],
+                                   255);
+        }
+        else
+        {
+            pixel[i] = SDL_MapRGBA(screen->format,
+                                   0,
+                                   0,
+                                   0,
+                                   255);
+        }
+            
+	}
+	// Unlock surface
+	SDL_UnlockSurface(screen);
+
+    // Draw to the scree
+    SDL_Flip(screen);
+
+    // Clean up
+    ret = clFlush(command_queue);
+    ret = clFinish(command_queue);
+    ret = clReleaseKernel(kernel);
+    ret = clReleaseProgram(program);
+    // ret = clReleaseMemObject(a_mem_obj);
+    // ret = clReleaseMemObject(b_mem_obj);
+    ret = clReleaseMemObject(graph_mem_obj);
+    ret = clReleaseCommandQueue(command_queue);
+    ret = clReleaseContext(context);
+    // free(A);
+    // free(B);
+    free(graph_dots);
+
+    SDL_Event ev;
+    int active;
+
+    active = 1;
+    while(active)
+    {
+        /* Handle events */
+        while(SDL_PollEvent(&ev))
+        {
+            if(ev.type == SDL_QUIT)
+                active = 0; /* End */
+        }
+    }
+
+    SDL_Quit();
+
+    return 0;
+}
+
diff --git a/mandel_classic.c b/mandel_classic.c
new file mode 100644
index 0000000..beabd01
--- /dev/null
+++ b/mandel_classic.c
@@ -0,0 +1,462 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <math.h>
+
+#include <SDL.h>
+
+#define MAX_SOURCE_SIZE (0x100000)
+
+
+#ifdef CACHE
+int** cached_points;
+int** cached_x;
+int** cached_y;
+#endif
+
+int *iteration_pixels;
+
+typedef struct point_args point_args;
+struct point_args
+{
+    int res_x;
+    int res_y;
+    int image_x;
+    int image_y;
+    float zoom;
+    int max_iteration;
+    int thread_number;
+};
+
+typedef struct piece_args piece_args;
+struct piece_args
+{
+    int res_x;
+    int res_y;
+    float zoom;
+    int max_iteration;
+    int total_threads;
+    int thread_number;
+};
+
+
+int get_x (int linear_point, int width) 
+{
+    return linear_point % width;
+}
+
+int get_y (int linear_point, int height) 
+{
+    return floor(linear_point / height);
+}
+
+float map_x(int x, int width, float zoom)
+{
+#ifndef JULIA
+    return (((float)x / (float)width) * (3.5 * zoom)) - (2.5 - (1.0 - zoom));
+#else
+    return (((float)x / (float)width) * (3.5 * zoom)) - (1.75 - (1.0 - zoom));
+#endif
+}
+
+float map_y(int y, int height, float zoom)
+{
+    return (((float)y / (float)height) * (2.0 * zoom)) - (1.00001 - (1.0 - zoom));
+}
+
+#ifdef CACHE
+int cached_iteration(float pos_x, float pos_y)
+{
+    float centered_x = pos_x + 2.5;
+    float centered_y = pos_y + 1.0;
+    float temp_x = floor(centered_x * 1000.0);
+    float temp_y = floor(centered_y * 1000.0);
+
+    int trs_pos_x = (int)temp_x;
+    int trs_pos_y = (int)temp_y;
+
+    return cached_points[trs_pos_x][trs_pos_y];
+}
+
+float get_cached_x(float pos_x, float pos_y)
+{
+    float centered_x = pos_x + 2.5;
+    float centered_y = pos_y + 1.0;
+    float temp_x = floor(centered_x * 1000.0);
+    float temp_y = floor(centered_y * 1000.0);
+
+    int trs_pos_x = (int)temp_x;
+    int trs_pos_y = (int)temp_y;
+
+    return cached_x[trs_pos_x][trs_pos_y];
+}
+
+float get_cached_y(float pos_x, float pos_y)
+{
+    float centered_x = pos_x + 2.5;
+    float centered_y = pos_y + 1.0;
+    float temp_x = floor(centered_x * 1000.0);
+    float temp_y = floor(centered_y * 1000.0);
+
+    int trs_pos_x = (int)temp_x;
+    int trs_pos_y = (int)temp_y;
+
+    return cached_y[trs_pos_x][trs_pos_y];
+}
+
+void store_iteration(float pos_x, float pos_y, int iteration, float x, float y)
+{
+    float centered_x = pos_x + 2.5;
+    float centered_y = pos_y + 1.0;
+    float temp_x = floor(centered_x * 1000.0);
+    float temp_y = floor(centered_y * 1000.0);
+
+    int trs_pos_x = (int)temp_x;
+    int trs_pos_y = (int)temp_y;
+
+    cached_points[trs_pos_x][trs_pos_y] = iteration;
+    cached_x[trs_pos_x][trs_pos_y] = x;
+    cached_y[trs_pos_x][trs_pos_y] = y;
+}
+#endif
+
+int mandelbrot_point(int res_x, int res_y, int image_x, int image_y, float zoom, int max_iteration)
+{
+    // Get the index of the current element
+    float pos_x = map_x(image_x, res_x, zoom);
+    float pos_y = map_y(image_y, res_y, zoom);
+    float x = 0.0;
+    float y = 0.0;
+    float q, x_term;
+    float xtemp, xx, yy;
+#ifdef CACHE
+    int storeable = 1;
+#endif
+    int iteration = 0;
+
+    yy = y * y;
+
+    // Period-2 bulb check 
+    if (((x + 1) * (x + 1) + yy) < 0.0625) return 0;
+
+    // Cardioid check
+    x_term = x - 0.25;
+    q = x_term * x_term + yy;
+    q = q * (q + x_term);
+    if (q > (0.25 * yy)) return 0; 
+
+#ifdef CACHE
+    // Look up our cache
+    iteration = cached_iteration(pos_x, pos_y);
+
+    if (iteration > 0)
+    {
+        x = get_cached_x(pos_x, pos_y);
+        y = get_cached_y(pos_x, pos_y);
+        yy = y * y;
+    }
+    if (iteration < 0) storeable = 0;
+#endif
+
+    while (iteration < max_iteration)
+    {
+        xx = x * x;
+        if ((xx) + (yy) > (4.0)) break;
+        y = (x + y) * (x + y) - xx - yy;
+        y = y + pos_y;
+        xtemp = xx - yy + pos_x;
+
+        x = xtemp;
+        yy = y * y;
+        iteration++;
+    }
+
+    if (iteration >= max_iteration)
+    {
+        return 0;
+    }
+    else
+    {
+#ifdef CACHE
+        if (storeable == 1)
+        {
+            store_iteration(pos_x, pos_y, iteration, x, y);
+        }
+#endif
+        return iteration;
+    }
+}
+
+int julia_point(int res_x, int res_y, int image_x, int image_y, float zoom, int max_iteration)
+{
+    // Get the index of the current element
+    float pos_x = map_x(image_x, res_x, 1.0);
+    float pos_y = map_y(image_y, res_y, 1.0);
+    float x = pos_x;
+    float y = pos_y;
+    float xtemp, xx, yy;
+#ifdef CACHE
+    int storeable = 1;
+#endif
+    int iteration = 0;
+
+#ifdef CACHE
+    // Look up our cache
+    iteration = cached_iteration(pos_x, pos_y);
+
+    if (iteration > 0)
+    {
+        x = get_cached_x(pos_x, pos_y);
+        y = get_cached_y(pos_x, pos_y);
+        yy = y * y;
+    }
+    if (iteration < 0) storeable = 0;
+#endif
+
+    while (iteration < max_iteration)
+    {
+        xx = x * x;
+        yy = y * y;
+        if ((xx) + (yy) > (4.0)) break;
+        y = pow((x + y), 2) - xx - yy;
+        y = y + 0.288;
+        xtemp = xx - yy + 0.353 + zoom;
+
+        x = xtemp;
+        iteration++;
+    }
+
+    if (iteration >= max_iteration)
+    {
+        return 0;
+    }
+    else
+    {
+#ifdef CACHE
+        if (storeable == 1)
+        {
+            store_iteration(pos_x, pos_y, iteration, x, y);
+        }
+#endif
+        return iteration;
+    }
+}
+
+void *thread_launcher(void *arguments)
+{
+    piece_args *args;
+    args = (piece_args *) arguments;
+
+    int x,y, small_res_x, small_res_y, init_x, init_y, limit_x, limit_y;
+    int iteration, split, piece_x, piece_y;
+
+    if(args->total_threads != 1)
+    {
+        split = args->total_threads / 2;
+    }
+    else
+    {
+        split = 1;
+    }
+
+    if (args->thread_number > 0)
+    {
+        piece_x = args->thread_number % split;
+        piece_y = floor((float)args->thread_number / (float)split);
+    }
+    else
+    {
+        piece_x = 0;
+        piece_y = 0;
+    }
+
+    small_res_x = floor((float)args->res_x / (float)split);
+    small_res_y = floor((float)args->res_y / (float)split);
+    init_x = small_res_x * piece_x;
+    init_y = small_res_y * piece_y;
+    limit_x = init_x + small_res_x;
+    limit_y = init_y + small_res_y;
+
+    for (y = init_y; y < limit_y; y++)
+    {
+        for (x = init_x; x < limit_x; x++)
+        {
+#ifndef JULIA
+                iteration_pixels[x + (y * args->res_x)] = mandelbrot_point(args->res_x, args->res_y, x, y, args->zoom, args->max_iteration);
+#else
+                iteration_pixels[x + (y * args->res_x)] = julia_point(args->res_x, args->res_y, x, y, args->zoom, args->max_iteration);
+#endif
+        }
+    }
+}
+
+int get_cpus()
+{
+    int number_of_cores = 0;
+    number_of_cores = sysconf(_SC_NPROCESSORS_ONLN);
+    return number_of_cores;
+}
+
+int main(int argn, char **argv) 
+{
+    // Init SDL
+    if(SDL_Init(SDL_INIT_VIDEO) != 0)
+        fprintf(stderr, "Could not initialize SDL: %s\n", SDL_GetError());
+
+    printf("SDL Initialized\n");
+
+    // Create screen surface
+    SDL_Surface *screen;
+    int res_x = 800;
+    int res_y = 600;
+
+    int number_threads = get_cpus();
+
+    printf("Number of threads autodetect: %d\n", number_threads);
+
+#ifdef CACHE
+    // Init our cached points
+    cached_points = malloc(res_y * 1000 * sizeof(int *));
+    cached_x = malloc(res_y * 1000 * sizeof(float *));
+    cached_y = malloc(res_y * 1000 * sizeof(float *));
+    if (cached_points == NULL)
+    {
+        fprintf(stderr, "Bad luck, out of memory\n");
+        return 2;
+    }
+
+    int count;
+    for (count = 0; count < res_y * 1000; count++)
+    {
+        cached_points[count] = malloc(res_x * 1000 * sizeof(int));
+        if(cached_points[count] == NULL)
+        {
+            fprintf(stderr, "Bad luck, out of memory\n");
+            return 2;
+        }
+        cached_x[count] = malloc(res_x * 1000 * sizeof(float));
+        cached_y[count] = malloc(res_x * 1000 * sizeof(float));
+        /*for (count2 = 0; count2 < res_x * 100; count2++)
+        {
+            cached_points[count][count2] = -1;
+        }*/
+    }
+
+    printf("Cache ready\n");
+#endif
+
+    // screen = SDL_SetVideoMode(res_x, res_y, 0, SDL_HWSURFACE|SDL_DOUBLEBUF);
+    screen = SDL_SetVideoMode(res_x, res_y, 0, SDL_DOUBLEBUF);
+    if(!screen)
+	    fprintf(stderr,"Could not set video mode: %s\n",SDL_GetError());
+
+    // Prepare the resolution and sizes and colors, threads...
+    int i;
+    iteration_pixels = malloc(res_x * res_y * sizeof(int));
+    pthread_t threads[number_threads];
+    piece_args arguments[number_threads];
+
+    printf("Rendering...\n");
+
+    float zoom;
+
+#ifndef JULIA
+    for (zoom = 1.0; zoom > 0.0001 ; zoom = zoom * 0.98)
+#else
+    for (zoom = 1.0; zoom > -2.5 ; zoom -= 0.01)
+#endif
+    {
+        i = 0;
+        int iteration, max_iteration, x, y, res;
+        if((zoom < -0.02) && (zoom > -1.0))
+        {
+            max_iteration = 100;
+        }
+        else
+        {
+            max_iteration = 170;
+        }
+
+        int thread_count;
+
+        for(thread_count = 0; thread_count < number_threads; thread_count++)
+        {
+            arguments[thread_count].res_x = res_x;
+            arguments[thread_count].res_y = res_y;
+            arguments[thread_count].zoom = zoom;
+            arguments[thread_count].max_iteration = max_iteration;
+            arguments[thread_count].total_threads = number_threads;
+            arguments[thread_count].thread_number = thread_count;
+            pthread_create( &threads[thread_count], NULL, thread_launcher, (void*) &arguments[thread_count]);
+        }
+
+        for(thread_count = 0; thread_count < number_threads; thread_count++)
+        {
+            res = pthread_join(threads[thread_count], NULL);
+            if (res != 0)
+            {
+                printf("Error in %d thread\n", thread_count);
+            }
+        }
+
+        int rank;
+        Uint32 *pixel;
+        rank = screen->pitch/sizeof(Uint32);
+        pixel = (Uint32*)screen->pixels;
+
+        for(y = 0; y < res_y ; y++)
+        {
+            for(x = 0; x < res_x; x++)
+            {
+                iteration = iteration_pixels[x + y * res_x];
+                if ((iteration < 128) && (iteration > 0)) {
+                    pixel[x + y * rank] = SDL_MapRGBA(screen->format,
+                                                       0,
+                                                       20 + iteration,
+                                                       0,
+                                                       255);
+                }
+                else if ((iteration >= 128) && (iteration < max_iteration))
+                {
+                    pixel[x + y * rank] = SDL_MapRGBA(screen->format,
+                                                       iteration,
+                                                       148,
+                                                       iteration,
+                                                       255);
+                }
+                else
+                {
+                    pixel[x + y * rank] = SDL_MapRGBA(screen->format,
+                                                       0,
+                                                       0,
+                                                       0,
+                                                       255);
+                } 
+            }
+        }
+
+        SDL_Flip(screen);
+    }
+
+    // printf("Max Iteration value: %d\n", max_iter);
+
+    SDL_Event ev;
+    int active;
+
+    active = 1;
+    while(active)
+    {
+        /* Handle events */
+        while(SDL_PollEvent(&ev))
+        {
+            if(ev.type == SDL_QUIT)
+                active = 0; /* End */
+        }
+    }
+
+    SDL_Quit();
+
+    return 0;
+}
+
diff --git a/mandel_classic.o b/mandel_classic.o
new file mode 100644
index 0000000000000000000000000000000000000000..18eaf60ff216f6578042be9b6b0b760ed4247b4e
GIT binary patch
literal 7200
zcmbtY4RBM(5k6TC{;8uAiQ0M^QY)!Rg$pW52!W6mJzK)h9XUS)62}qPLVgM&vgMJU
z0^|ogRZR0L1hkV*(>9q&ra!}UG9{TdO&Vr`z<`1L5r<L&Oq)WIv2mF=_SB(C26gw|
zoqY(YGi`U~z1{n6cW-a+_TEXG{efj=77Gz%A>Sp_ErAk}tDcs<O!Shg2qng6#)Z9~
z)qQ%=I66S<ysWLJ|53@XaoUg@MrAd<zjB<;%?<3Jj@$%oI8NIS0UMm4tM`pl`<GE?
zoZj~i^wRbmND>-+2Q;oUHG)URX>e}@)FPk<1Cq=AMW_ob+WvcAeK-b0^%s9X#(2(j
z{fQWz1r~&`SD%wYJ_<wSsN+0sKM!F`Js5WI9L^QOJrCiY2g`Bln56BKpg9IUuHci}
z3z}n~H3?dio7(BUL!KOUousaP)OBQZ7OnFU0+X7+1i8*k(6+PGJsWM;d!Vrwl+roN
z1P#9KTMU8U2T$9Z(A)>l0LTZa>jc0jQoB95fr)_#lAG2&jvk0|Z;O#v?on1MD^}hO
z3+Ku-+tU{;^zn<(X$<%?>m7SX>nsEBeD3d`gxP?@nZ9}l-G==W3T-$D(*l4kGj$z8
zsKSImv!<Tm6Fxfkee7v2H@kesxX&2FJ@UCicO5fU)YqDd)Lv6R0UHIL5xQ&GGVHT<
z)z=0x^Dx%M!-lVZ)}}VxXTBwXZ}Ndtdvj$bSYK<#wL{4)RWj?#jg$UNbIk;`Lukf`
zae?kSU^$T<u&7V9X7zr;2J<aGs~9s<Z>A4emc;63rJjdf>bifG5>!?xtCbEmcksYg
z$@IP(D+BUCx0mJfd1<Pi^Tp@M&_Q2)EryTt8fgGSIscH-x6S=F1mb&;9$4pww}8J#
z9YfS{inb5Y_EWH9c#*V$9OQEFTJ#G$X9%8CuzP^FkJ4?s0c9KLLs<8d@O(&JuftAw
zgSuHE(I5N_H5@q))SCS}=mhx9$YGa{UWavs`>%xg`cClmXN=A90qi{3br@><5!(JP
zY`N1A>tX1GFabGcvUj0Oun-PIfQLaoib0!Autel--aC?d+>@Jt(l+-eo+W!$KwvDD
zc#aG-#Z$2^XHQ&rMth=qG!%<ItU2%Y1#WfDPF52ToGnv$7n#;hYP$2GXqOgucE`Ik
zQ`?_N#1r7hIlIfLuT5y7u4=Me>*>-G(Vhp~Za29-)xAbbIO7rCopgp$I+*KPSO*uN
zekrZo;{-r8K2+{Cs|t&10}H-Cr(a{vBEwRy8v9;DV~=@8?m?OL%Ybpv@bBb+XXsC$
z;(e{HjF3G}tH?=zuEjWz`p>Qd*AnHm---cLgKcUx?BB^oRkMx*Ux7|FTkeJDz*Q)x
z&y1;aj;ZPQ$5cb>Q|IhgjbCqo-OECR?ZS4_pnvNjC<;*~<8)^0j*Ne&-}8Z*c?Pxn
zb9CD;z#V{U<|Ra+l$t7iM%XcE#W@T%mE(MjCVNYGzt2e4Krmj=>F)$xCB5IGrUz=(
zY|U{sv$D@Ksb+86_bT|~CA>u231c(e)YG0*fsEESS_KxC#jAF1x}ha=+iB0FNdB<#
zS5Iy_%Uo;oNrk@buWij}&O!h47)nd_>H5AJ;Gdq3>>VznFXtenejHQ%^aP}*A3IfJ
z<+G~ce=3mO-8YfXkJi(=K2%9x+`LIKK6&*?klDbBQPGkfEDtRHT=%LOmiK_={l?6K
zMcHNf^o31y3)Z4<@nlQpu}bBYJTxAC)pOW0!~>tUPvunWs%HaM?WuJ4^OjV9!1!3K
z1#_G3-fDr`^Y4I4V&6w#@SSCAqTeT0%-jYM>TcaZx7>9xpQmnS{Yn>xL7T@$ZUZnP
z>JOtzA9R?3dFdaILuh73A+V9_VU1v|*}14@AA5nPI#t(yDs_&1w-};kwG*D){o-U@
zHPH9i3pEP$ogO^`g96of86#s$O<wLz>~DXx8rn<#c1QN7Jwr>om~edQBaYuS|NY@7
z_XM}^`==}TG3fV!Z6ESIq`9f-R;SCSt%-(uoD1ByxNn-baE>XMehG1K!Se8OV%cD~
zTvJm~xdV2v9q?Ja50;k^>dxnK9dgxXUv8^px+=$8IY;{-ms=#Pm&<23M?3RmBSgo~
zNu$laz07Z`-DYjHIkV-BHrLiG6x;kQGZfpRbcN5>S(dN1EdoTbxj>`QRtpx5wo2to
zERLhxZ!P))!k9l`5+PS3_u1^XL(FqQ{DR~2q3noavu`O=ubk1k-MXzjd&Sln=?W{g
zRzo_#GmtyEv0D$V0j?)ZzE(&HEf#X?+6JAtyFz-1xYs0;#GQy^1Jyll&!x>p&=fYH
z5K8E&-YJc6QpbMN8X60TI~?!s)_TA_9P*mG`Sz9bz$pA6_oA)sh$KSY8lTPo$DCk}
zshd&Y#>?Bu@=H5#on^WP8U-q>yOVvQ33&nz6eP66aVoI^#BKz@Z-57JToRdnU(6{e
z@MWG-#dSrW|Es-+`@C_=qbZ2-y9;nJzTjTyN4e16$qp4lt}n0`^B49jxP4*%@8tGu
zuSz}&^M42Q6-(9dS52c%o*1;NfJclk^1lW!j0Hb=GWBsquMC1L>;;blR?I%f6~tL0
z+=y5Of0WzL7Ydxe!R^@%PwEqS6TF|>ODaqp5dju-2s;7)90bJpHWe@#<MyrsgF?4I
z0ShsgDPs^+EDWF%CS&^_Zw$g-<bNh$g?krGYWc<LSJ;rKAe^GHqq>)xMu&KCI1Y|k
zIDQpi#m2AXABuYl1}tcrgA{qAUOD+BU!)7hEAGWwG!l%jScVbjMN%+`^|I5<RIsuN
zC{Tu`m0%VwCo3tu-I_X9Qn;%H&hCVlI5O+%a{p#|R!yykFfzZvRcyZq4Ec4eQ8jgL
ziatC)Ns&0e#qq+-nRQl0oUDKP#eV!i9$eE9lWt}2Dzc~m_j0_jZkI8<`m%W;Y$fc=
z$~43)0K!$$eh`^m&T%}qkl6hLcpE$dLtM~m5YUf^N8C%gINrw<#oc5b$B%OS4Cjw<
zJjb^vyQ2V>fv4EGKL&gz8PAKl68x9kkCzvhxS#Cecqd;Nc1Hp16?lsI&oO;GxlIz^
zg9FekrvFw6{8R}X=UvRtxf1xtCGg1-cm?FKn15Rd{Mr(DLkWCg34Cb@ytM>Qx<l}*
zH`Wo3g_6l=*c~SBK+}AD!CfxUbR)iQ!q?6CT8OV(@C8>lP+@Hk>-Q`m4`_PF2KL@a
zBC&Wp0nU2?!S_Z!(3(VC@92$3;g)Cq?(T?%Qa$0dTEaAmkf^RDLV7gb)6pB<pv978
zT`Cq0aT^>W+?z_0<i=z;-V*_@(H{Km-+{mVnb551?AJX>>hN<O-1fq6dObpVQ+kqc
z84d2%^n37MfmZlc4{l<yc$oC^n8NUnfUZq7*Fn6@cWbD3d2^$}<YlpFFB9&J$7246
z@ZO4U?@B=&)At|zzJ3j!FW?swl6g*;-(9SEfs5Y|sE?<qz}JF|gt!eJf$u~Rs8Ih8
zCd_dB6bk*1BwY6YFA109xf=EhQsKDYk#O1nMhVA#FUGAx2SCX1EED*3CGhW+z}HH+
zQ}Xk&gyWq__&+P*cn1)86+f4-TaKr$1pc6e%lTO^;qtm{mT);gFG{$apZyY!-%Jtb
z8xoFZrNGA|T=uh$pQ|{pZ%F$5I?VDvTf&_nBcVQiONIY$A_#;y$^!p3f<SmPkZ&Ig
z8EWdgKo<H-I4<<R&f8wj(f=HHgnqMxUoYVSj-#I$Tt<f9LnQRm0FUs~gCG#%coz^j
ze&3J~m*@L^hMKrM-yd>Z#P8<qA4&T1e4mr>xgd*i<vMjr_={X$`0wQHvz%j`a(+f7
zT&~~GBwXI-8m~w6FLIBn>!doJ2W=7OlM;?|75H<KA6$2_9>0<F8zlWJF>oMcxMzeP
zr-VBtyj8+w{kVkBm-N?5I9}C-|7Ro|e}W7AB?-sBItBibgv;aRCEO$F&y?!!MhSO<
zjD%*~l(iSI_cV^RiX`$U^l@%To$NiW-^bhdEkP3cN6jXAf^&h3d)u)BT-?Kk3vh7{
OgR3JW^i#ogko_C1!1C_^

literal 0
HcmV?d00001

diff --git a/mandelbrot_kernel.cl b/mandelbrot_kernel.cl
new file mode 100644
index 0000000..029599b
--- /dev/null
+++ b/mandelbrot_kernel.cl
@@ -0,0 +1,45 @@
+float map_x(int x, int width)
+{
+    return (((float)x / (float)width) * 3.5) - 2.5;
+}
+
+float map_y(int y, int height)
+{
+    return (((float)y / (float)height) * 2.0) - 1.0;
+}
+
+__kernel void mandelbrot_point(__global const int res_x, __global const int res_y, __global const int line, __global int *graph_line) 
+{
+    // Get the index of the current element
+    int image_x = get_global_id(0);
+    int image_y = line;
+    float pos_x = map_x(image_x, res_x);
+    float pos_y = map_y(image_y, res_y);
+    float x = 0.0;
+    float y = 0.0;
+
+    int iteration = 0;
+    int max_iteration = 255;
+    float xtemp;
+
+    while (iteration < max_iteration)
+    {
+       xtemp = x * x - y * y + pos_x;
+       y = 2.0 * x * y + pos_y;
+
+       x = xtemp;
+       iteration++;
+
+       if ((x * x) + (y * y) >= (4.0)) break;
+    }
+
+    if (iteration >= max_iteration)
+    {
+       graph_line[image_x] = 0;
+    }
+    else
+    {
+       graph_line[image_x] = iteration;
+    }
+     
+}
diff --git a/mandelclassic b/mandelclassic
new file mode 100755
index 0000000000000000000000000000000000000000..389c684aa6d8d91a2c7df6db185483e996e6276a
GIT binary patch
literal 11941
zcmcIqeRLC7b{|PL7%&<+F^L1DsHsQ|2WwH5un=I8u!P4%CWJsj9D^(@8AN5v(Fd4(
zux^EEW{nAFH{GP^rscG04^3%9+aya!PLMI-Bb)6K^5qS5<C3sPg3vgaIOJpF{_dOi
z?2#;W_mB4J%-nZ>@80|F-1jx}^nT#+E;kwsl1N7B`x0>nCp#IW-I1NfSdJ}_N+hTB
z2LQ(bDaPewB}BEHpeb%z&=M|Z0xhDvkpo7jmf>`|#z}$-4~bHJqshs$8vW)5jTKaq
ztPCJM@>RN#v7n7whSNUo$AIvM>k&(O6<n`^%L_W{zh+K6A3Ymg)49FrMkhGpokS!z
zyN^;93t+1*!~>K+P_79aD0i}qpm7bB1QmLBLytWlFaKS{!Uet)4sD!2?>pf@RXEg|
zXs>EtFu!X4JbNr+zm54%aumCom1~)Xh=&y%)lF_vTT=N?V)s_Qov8TU#lP_VYxA~)
z-~VA%?R`{6O(Np|SdY~p6*(snR)LGU)!~nR^hmYm-B0=+TsM8em9FV8cYkKS^!BG_
z6ctRfVeq;<rC$NdhyO8fYaaRe1@IdR*q>GacND-+!G1n}std^X7m%M+z|R#0@INhJ
z=lufsmIC<R0(hzb{#gP1-wWV@0{E-~@!0^}BHbhn+|&ro(R3%nE2O?0d^MNP#cu&#
z20H>5<My9n@;YgfR5`&pY8<(7kiSkcOD|lXjY}9mEi_!_OTOAQb-q9_8r&3$#e>l`
zb=BcWYjBN!V>l@Je4AP#t-e^?AC3Ebl5fRU-)b&b9rnj!!I-9=SGhSHi9{uKZ>IX%
z;+vyEe}HP8D{;ox1SlRHVYfs=tt5Mo+gs(Z-=@j>Lam{=1jtttjC-O{SS4n8IMl{6
zt0LjBXKS!klc^QL_XOkjh62GzT_g}>a(5@VnL2;l>Y8OP$=3|aR9%x6inc^NCbjs(
z;YgDdiz6m*zbzVSjW;6_B*r7r;)j>9?XjjvD@uX^f7}m&jj@<k4yZLC)p%={Rr_wk
zL)=bHA|_}fa+DXmwxZCTQW0<i`w2=M^&LsF;z~>nO(3Zz0+FcnLD1}SQ&xE?WT~8z
zrf(c6ui*WT=3wCi$%+0&Yt~H!@U(!-j|b0PU?ol+E}o1E6dkU&ze<Pe*Tr=@T)!?f
z>Ts%Cq|G{9j0Gxd)8Po%NNU&N6Gu=<>d@hnb@*dCTtBhz)#0*E{wW<UVot^Tba<Ig
ze!mXa&$kD4`1LyZLpq!<wX8Iy!>8!vmE<QSN>}j(*(xcWsd#a^8ih*oSV^x=2-)G=
z&p>2&<~z8{Gn~i~znO$G{liEz-yoivJad}yM~SDV&ZHQBn0RX9%t6Ng8}YQ%X7(}u
zIpV3QGkY2Tx5QHuXF3@FH1X85nKs7%h<Iw!Oe5oeNIW%VW)<WAjCg9ojFa&X5l_oa
zW-jBS#Fr9pW&9T6scAD7#&0CvOuWSSdg7@mGXviOn7NvGYQjuE<5v(*O_w<he(ez}
zvWj}ab)V~A*IL(_dl2dNbP$>d^R)B<WR$KYRZvpYqpuyq^y^5aUjlmMJo4!`VFSSJ
zc)%kI@UEmDS3Uay>?Him%dqWyZ5^U}#EOun{~IWpuU36MF)e+!X8Md-Gkrxf{Q#Mk
zyf;g(*PerR`e9O0i(e(FCeQvOHdLZ?m%mOgFiLlk6W8n1;gsb00cF-ZO0s`IQG*@I
ztYeD$_w6v2o&^h6WXt3);o}L<?vrTyLD^D#E85_STvoTY%d_9(_*m(BhNL@F@}9qf
zIe<#ni-ZiyWz{8awW<7siJsv^brC&}T5YLqI_6emrEtaxnNDh5SMr!aN%mGK-KFm-
zU28iWLrVAJqlX(Uh?Eg-xEBTYqi!af_^IQpw=39jX#zA13)k=8acgbY;&YCnbO|I8
z{IvRON9u?L&zqkATLeLq`oRY-`DdPrx~`!0gy#UcQrrDgTL(Hw?HA{od(uYvXDPVU
ziD!_MFZvLkPAXK?wfhv+^OU#ym5#yT;Y&7oMhA%`zx}}um-^Y^Cy-Bn_zfOG9bcO~
zQRH3tb=-*o=bmhpyoUZ|UGo-nFCR``+ad4zONhD`4%K!&TH-o14Cax;j#G{^aQttw
z^b;w?w0@u06nrY#a=?)2^s1kxm*7Fr7RAqCfFxUX8?MOrd-gWV<*8=5J_RDzpJZ(k
zzn@wx0x7K<G|Tq7z4ETR5gFNDO!y&sb8*Wx1DVADo8=ih!6OLpDtWwIbId8f^d4Lr
zN{`bV%iMxCLR-H=!(Zus^k8}k3OZAX8J%Yn7v&jl#NeNRDBZz6N9qArgKNEOgUh$R
zx8u=+r7qch?$R5M%eCrT8x-}tlKgmJ)tcH9se|aZ%84E;BPTj0qPgDxdU*IMT!Otr
zA7VmVt5o%YD9LMPjI?dW^}UD4SDMJKu0KLW!~MKH4iP8hd#;%vk8!8;TwJOcPAlqh
z<*jcM&_Ar{pBd3V&-FW&sFSQ%9?RB3Gra@PyZ(6bRzQZqUYZY;<dUaKAP}E6;zHTl
zBbFQCoqA#T^!m)hP|0k?P4i#<O1;+e)r>E`RZla0;%P2s*cEwpD*ZGbmL}pW@|;xf
zUbNw$Jo`PgBglzCdBagO<dm(LFVWO*u@+7t$55I@ugDE=QBw!B{2SnVM1Meq(pY=V
zawRm@<=C38vt`Y1tAk<&uip1`l8+ZP)1Oi8zb=v_bU;)Nw>MlQmwN%h(bK339rLnW
ze;FJrd6|`v+YJ}#S>f(wbl=O+ydswm$@N2!9Dt4DCpF0)NDe@12vS2k>gD^+I8t)u
z2Xf_6x$=!m(^)^kLk&`ZD$ftf>pqh0Gn3HW<^a<Jp=8Q1C^!7vy%3Jyk89m8z#hfb
zi~Mo9vJY@y;uS}#cd)mal3k1k*L}6>ur{-=rK!ELtHzSNW{`J&i(sg|o~~`>J(p$}
zdf)om(>a8vfx$Ajtz6zi<%2GH_HjHGfOONB7<!c_2^z0KkSw*O?*u;Rmgn?SNllSf
z<W{e^)dA`wU%TYz-%;1tD$=)*plm6%4Wgsq%E-^B4QaP2V5{(URh>hpT$onfw&^?8
zQ9pGr0=~lyqn4VIt_E9$=GR_V*HTy4wj%WdPghMT%)vD^qh6Drf8EfB2~v5gt~=f-
zrKey{a4-DGrH)JdBKf*uQP?&;aR9xv@`3eYRI_KNh2Un)>Y8;nFCY%`<3<bs-J?1#
zr<<<jdCqhl&=YPOeM!T{oK$8ujT~M45z=33{p}30ze0G>&a?jm^jC8E8M*wdTz^Kc
zKZ_nS<!;R7=xxY1Oj*nF4L1`-&pCtZEP4-U{Uv$NE2xcipbKdC4{%+OD}Roj@TP2^
zd?z&IKc_hw{o8>qZCO&mj9G3cie7%{4{2Oc|I4FZ3Yl$<u=OtaR{k-19(o<QTK|Sz
z|2DeZIrw@Cg>VzdI~sW#j?+Lm1qV+df0~@uSZEUROJ15u>~y4PF4{>k!+i8f$&oe4
zq>m11^GNS#=Y^k&8n*R$)qt&E>8^U;gvF?P=1CAmZLpp8qA=}M<F)~>`iPC@r3Kzu
z7hLLatvaOi{MJ;fzUw%f?)e;sJ1@tlQor)57rp9`8)IU){2VQ*%EC*Diwb%eUN6Ho
zi?@sQ$FR-n?TXtfy<Lyk=Az#$fWsZ+?_jUyvv~D1;5(-}k_ZQ^t&zBuzVAZ*aOk0+
z6(4qYSZBs2(g&NBKIJq#pp%XT<JPV8VP|c@mz^ffz6xQ-Ix}F^J~JmutML^U#Mj#<
zyWLJcP+FO2*%*vkBh6eYX7wlHuo4e8#bGHxFO;LH)T!kMmTI)f89i42$V6#i>7ozs
z>VC5I%+dhMytnk>@_(uMuZNyE((w4v&np`~g?tBeJBS`JOfxNNg8_Q^eD><_@T;Kj
zAh_qSoEBkp?*@Mr^kdMXuZD-e0kwgaqdX2e2lN=I8}tRN8V#WH@Ir6^bPWdVG0-?D
z^}!;Hqj{j>+raS9YRS-UF-$8RU$WOQ-a`0vTx}SDvq445FAqN;K=S=~`I(D)B(r6?
zxnhMpX<JE$v~=pC+26I@LN-X>jjIIDf!C&yM0f*nz-JIu%$C*W5+)x9OY(Ju^F;C#
z4=3<i0fG|#EUtFo=XJOj`B!nRLVV)n-!il1aihmvvB$K`Z0#;uX0F^_>@v^YHO^&T
zkR0zeHyVd0nil|ZnJXc&%v=GDW#$qWeL86M(D!l&;#@)Yc%u4k;2*<l4*MQ+n=LEx
z9CLs#20lRX!GtKe%$8k7W%9VX$4z^Rx{G&@OO7|mrilnYtAXMfhI}LJsK`qzc8%Lz
z+-!Cx$9EU)F+FZHu7g$0k0&5^5^`wHF{#b$WY{WBg#c7o%B2tH;Lqgn^vsk>H8Qe~
zB))~k{?W)@z>SSeavGN>pD9h%h*ZMMsqat{<)42$93j5Z=)`?=Puy9o@#33*pHbt*
zc#LrWv{usgU?n8|w=VJ21eC0J9i${;caZB-J5s`%FiT=vy?wls@d8&kFZ`aXiAxhW
zWh)o*7<TM=(&L=01jCQ<!jA#YALQj+{r{be?DOZ;)Xet>w{p6R)1Pqq51hWl>2Xfq
z<McP24skkeqLbBd1E;rgI-k?!oZic6GpAcQ&2dkvsjj}mTImjM4EbBF^X%WVf46G>
zEG;8R_Sp88xPK#PJgU*nB8NS?V6;uLV>JodUCU~#;{HvX+tiw{Z%l;nS3xKs*@@fi
zk8PIhf$goZr_p#+E7=;1#zK+SEXIejXfW(21)ggQ$0a*0T9Q2;Y{#ALBif@8wi9R%
zZuT`t{VhS?<^XgBr)l{7(WrmBrXliMnji-2{+3V^s*b=QZgy6SW)WM9lD#R?(n6b@
z{}+kIEe#1VJ|v?P91;h_xYfYyy*|SJ2p5eNp+DW|1ULG>k(F_yx1!N3%Q<k@>n}Ds
z8NQesq<K=Ga`oLP#EVZv)Zb`y0-<?@5oxhTM*edv;k+O#k(q=`=<hQ+!C{|{1A@|g
zL~#=OV%*;gjK;Xo7xR}B-%ymqe5G+?<F^3?G*<|HF+UvS6W{`_$jyz^Bjo=C<uvyQ
zUd%sfuHVS@i6uXU{~VScLWW{0^u>Iq@Ci`NccOlwFP?vAj=q>b+qu4&Z%LollwAEi
zz$mWV-I4XCl25Q=9f1f-x$RGDr(S;*pO02?efF-xb&1eM9wkAaKwhukG0{oIQU_mf
zZW9wdLr3*ED?N>jUSF(_FYwLU9Ca3Jp-XfhF47nAPhlH`Qi|(;!no0!h@U|ABcs<B
z|Feq!Uvp=P-1xneqi>z!WTvfrL8W(7eafvrg+enfvCc_1HiARq3u>->F8?M(Wn4mE
zyf2jep89>zB^QN0?Zi;B{GR&%30W~VNKdSn;{S5dFrt47|3&}#4RrMNSMc|Z3jTs5
z<jFQA!3%l`m|kDJuUNVMex@~g6MBMP&Cx%}>p#i$g`dKL&=dSu$PgytN84wV`nbLr
z=M2OxSAQ57`9D_(a4Pf*tskUAsSKB>n*scGRm4vSay*A+b&Ij1*YCJR<J!2xH-oLh
zCHxo9MdLGH{R8}?=*67E-1@az^50G5ozXd_(1cDU)=7P#37&}cFB>l!c~8#9i?L2Q
z^$^RO(4)mVq%SmKr4{Q-HeMo$bt4;}Ac^%L8=okNc|IE-`@b`ln=tc>c{y8tGUi#Q
z9%6Y@zW=FFV!})z=10Af3A4GF_p<RaNz7;2IR5Yu^OUZ@Bwau9y`qCrZ#m|ZMm@yx
zCVX{>`9fc4!if<v4`kyvj(m?~;}wz^x7qmU|NGhaR6Wb`)Gv#q&uBPiCHiY8A5P=J
zkmtFm+Z(Y%(LdRV+-SlE2E#38=O~EWYL4fAe{KeDz(2<Qd_EE5W*fuD#`&+g9q~O2
zmZj%#H{j$#ZhIAau2W3DOuBZ1lj)1w`wY+Dj``yA5tAR=USBeU*Ny2X6WIff_48)n
zhCKb`R^V2gAj)m`Lg#QikiQP?LjRUf5_8^Kf#<Xr?G2H9f0-sP_Auz5TZ&z7qCFF9
zE(ktZ0DrQ8oquHb*mEY&GkmhNkN2NaUe}8S?3^lqrwiai+`h!)!(X4I;R5pI2w=WA
z%mkh<4ldwjy7@=EN3AL#zXiA@Py22Ip0C~?GkmhtXmPU0ustl~{;q)hfdY7n+d0VN
z%=X$~=Xe46e&A)svFDCH;rMAjewkCaeaY=xd7M>VFahf%^|v<J$&m9Lp9-ALJBjxS
z4okOkc`KK%<pp!N{6J2<4kj<ON9i2}@M_@s&PUOKzI^cy6u`Fur*_Qse@6lN9|Na)
z)7*dYzVR%RpDdl`?NY}d;W>_rb&%~HqU?Ew=UGo%{MgJ6`<m#~RjA3{BsE3jv3LT1
znKa?((TeKTK5y+kYj8$u^dy%r-U4}?<%&t-e3lOK`2rE&rf_7VKkN&{Bhi@8pJ<n`
z$IuqWZg{{x-{F`G%Xx&@sVQym0tcPq(e0A9+Yv~#v}}ipj$<dcvP6Bp<*QwF9-n8W
zn+}vQ&w0Mad)G3T*LT<Q<@b2j_|~|Vc|9aS`z#|S0@(mNm?rt$_pfx-)mBTiS;CKC
zX~(vlPW>q?euk?lme3A<anUV_aLDg#!^t!40NKdtu-|?7jSh_E)WNobHU;Cpc7Bp9
zr#$x@S#~j<Ya2bzMrNAY5;1YsY^-e78MpuSBwy`ac-%m!)t86`5k)%mCwfKBkw1MD
zwf|E1DZT9Kc~RJ(Xl>dY)Q;rQA2$5NU$!tk$@Z*Me%a+dADkHJ6oFX8w;3Itoj_#g
z?x@Y!hMP7HHbx_H-eUT5cP;)l)WS~RQ6NVS2(p8J+JV08YDsG3Od&g|m|f1#_VGi2
e*<~T@IQrw*E%dd8+Jj*_IM~J-J=7{`zWxugcaH4<

literal 0
HcmV?d00001

diff --git a/test b/test
new file mode 100755
index 0000000000000000000000000000000000000000..4db960e12f3d425da2abc5e65821cb75d751c009
GIT binary patch
literal 10172
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

literal 0
HcmV?d00001

diff --git a/test.c b/test.c
new file mode 100644
index 0000000..d4669b0
--- /dev/null
+++ b/test.c
@@ -0,0 +1,301 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include <SDL.h>
+
+#define MAX_SOURCE_SIZE (0x100000)
+
+
+#ifdef CACHE
+int** cached_points;
+int** cached_x;
+int** cached_y;
+#endif
+
+int get_x (int linear_point, int width) 
+{
+    return linear_point % width;
+}
+
+int get_y (int linear_point, int height) 
+{
+    return floor(linear_point / height);
+}
+
+double map_x(int x, int width, double zoom)
+{
+#ifndef JULIA
+    return (((double)x / (double)width) * (3.5 * zoom)) - (2.5 - (1.0 - zoom));
+#else
+    return (((double)x / (double)width) * (3.5 * zoom)) - (1.7 - (1.0 - zoom));
+#endif
+}
+
+double map_y(int y, int height, double zoom)
+{
+    return (((double)y / (double)height) * (2.0 * zoom)) - (1.0 - (1.0 - zoom));
+}
+
+#ifdef CACHE
+int cached_iteration(double pos_x, double pos_y)
+{
+    double centered_x = pos_x + 2.5;
+    double centered_y = pos_y + 1.0;
+    double temp_x = floor(centered_x * 1000.0);
+    double temp_y = floor(centered_y * 1000.0);
+
+    int trs_pos_x = (int)temp_x;
+    int trs_pos_y = (int)temp_y;
+
+    return cached_points[trs_pos_x][trs_pos_y];
+}
+
+double get_cached_x(double pos_x, double pos_y)
+{
+    double centered_x = pos_x + 2.5;
+    double centered_y = pos_y + 1.0;
+    double temp_x = floor(centered_x * 1000.0);
+    double temp_y = floor(centered_y * 1000.0);
+
+    int trs_pos_x = (int)temp_x;
+    int trs_pos_y = (int)temp_y;
+
+    return cached_x[trs_pos_x][trs_pos_y];
+}
+
+double get_cached_y(double pos_x, double pos_y)
+{
+    double centered_x = pos_x + 2.5;
+    double centered_y = pos_y + 1.0;
+    double temp_x = floor(centered_x * 1000.0);
+    double temp_y = floor(centered_y * 1000.0);
+
+    int trs_pos_x = (int)temp_x;
+    int trs_pos_y = (int)temp_y;
+
+    return cached_y[trs_pos_x][trs_pos_y];
+}
+
+void store_iteration(double pos_x, double pos_y, int iteration, double x, double y)
+{
+    double centered_x = pos_x + 2.5;
+    double centered_y = pos_y + 1.0;
+    double temp_x = floor(centered_x * 1000.0);
+    double temp_y = floor(centered_y * 1000.0);
+
+    int trs_pos_x = (int)temp_x;
+    int trs_pos_y = (int)temp_y;
+
+    cached_points[trs_pos_x][trs_pos_y] = iteration;
+    cached_x[trs_pos_x][trs_pos_y] = x;
+    cached_y[trs_pos_x][trs_pos_y] = y;
+}
+#endif
+
+int mandelbrot_point(int res_x, int res_y, int image_x, int image_y, double zoom, int max_iteration)
+{
+    return abs(floor(sin(((double)image_x + zoom) * 0.1) * 127) + floor(cos(((double)image_y + zoom) * 0.1) * 127));
+}
+
+int julia_point(int res_x, int res_y, int image_x, int image_y, double zoom, int max_iteration)
+{
+    // Get the index of the current element
+    double pos_x = map_x(image_x, res_x, 1.0);
+    double pos_y = map_y(image_y, res_y, 1.0);
+    double x = pos_x;
+    double y = pos_y;
+    double q, x_term;
+    double xtemp, xx, yy;
+#ifdef CACHE
+    int storeable = 1;
+#endif
+    int iteration = 0;
+
+#ifdef CACHE
+    // Look up our cache
+    iteration = cached_iteration(pos_x, pos_y);
+
+    if (iteration > 0)
+    {
+        x = get_cached_x(pos_x, pos_y);
+        y = get_cached_y(pos_x, pos_y);
+        yy = y * y;
+    }
+    if (iteration < 0) storeable = 0;
+#endif
+
+    while (iteration < max_iteration)
+    {
+        xx = x * x;
+        yy = y * y;
+        if ((xx) + (yy) > (4.0)) break;
+        y = pow((x + y), 2) - xx - yy;
+        y = y + 0.288;
+        xtemp = xx - yy + 0.353 + zoom;
+
+        x = xtemp;
+        iteration++;
+    }
+
+    if (iteration >= max_iteration)
+    {
+        return 0;
+    }
+    else
+    {
+#ifdef CACHE
+        if (storeable == 1)
+        {
+            store_iteration(pos_x, pos_y, iteration, x, y);
+        }
+#endif
+        return iteration;
+    }
+}
+
+int main(int argn, char **argv) {
+    // Init SDL
+    if(SDL_Init(SDL_INIT_VIDEO) != 0)
+        fprintf(stderr, "Could not initialize SDL: %s\n", SDL_GetError());
+
+    printf("SDL Initialized\n");
+
+    // Create screen surface
+    SDL_Surface *screen;
+    int res_x = 800;
+    int res_y = 600;
+    int total_res = res_x * res_y;
+
+#ifdef CACHE
+    // Init our cached points
+    cached_points = malloc(res_y * 1000 * sizeof(int *));
+    cached_x = malloc(res_y * 1000 * sizeof(double *));
+    cached_y = malloc(res_y * 1000 * sizeof(double *));
+    if (cached_points == NULL)
+    {
+        fprintf(stderr, "Bad luck, out of memory\n");
+        return 2;
+    }
+
+    int count;
+    for (count = 0; count < res_y * 1000; count++)
+    {
+        cached_points[count] = malloc(res_x * 1000 * sizeof(int));
+        if(cached_points[count] == NULL)
+        {
+            fprintf(stderr, "Bad luck, out of memory\n");
+            return 2;
+        }
+        cached_x[count] = malloc(res_x * 1000 * sizeof(double));
+        cached_y[count] = malloc(res_x * 1000 * sizeof(double));
+        /*for (count2 = 0; count2 < res_x * 100; count2++)
+        {
+            cached_points[count][count2] = -1;
+        }*/
+    }
+
+    printf("Cache ready\n");
+#endif
+
+    // screen = SDL_SetVideoMode(res_x, res_y, 0, SDL_HWSURFACE|SDL_DOUBLEBUF);
+    screen = SDL_SetVideoMode(res_x, res_y, 0, SDL_DOUBLEBUF);
+    if(!screen)
+	    fprintf(stderr,"Could not set video mode: %s\n",SDL_GetError());
+
+    // Prepare the resolution and sizes and colors...
+    int i;
+    int temp;
+    const int ITERATIONS = 256;
+
+    printf("Rendering...\n");
+
+    double zoom;
+
+#ifndef JULIA
+    for (zoom = 1.0; zoom < 200.0 ; zoom += 1.0)
+#else
+    for (zoom = 1.0; zoom > -2.5 ; zoom -= 0.01)
+#endif
+    {
+        i = 0;
+        int iteration, max_iteration, x, y;
+        if((zoom < -0.02) && (zoom > -1.0))
+        {
+            max_iteration = 100;
+        }
+        else
+        {
+            max_iteration = 255;
+        }
+        int col_value;
+        Uint32 *pixel;
+        int rank;
+        // Lock surface
+        // SDL_LockSurface(screen);
+        rank = screen->pitch/sizeof(Uint32);
+        pixel = (Uint32*)screen->pixels;
+        /* Draw all dots */
+        for(y = 0;y < res_y;y++)
+        {
+            for(x = 0;x < res_x;x++)
+            {
+                #ifndef JULIA
+                iteration = mandelbrot_point(res_x, res_y, x, y, zoom, max_iteration);
+                #else
+                iteration = julia_point(res_x, res_y, x, y, zoom, max_iteration);
+                #endif
+                if ((iteration < 128) && (iteration > 0)) {
+                    pixel[x + y * rank] = SDL_MapRGBA(screen->format,
+                                           0,
+                                           20 + iteration,
+                                           0,
+                                           255);
+                }
+                else if ((iteration >= 128) && (iteration < max_iteration))
+                {
+                    pixel[x + y * rank] = SDL_MapRGBA(screen->format,
+                                           iteration,
+                                           200,
+                                           iteration,
+                                           255);
+                }
+                else
+                {
+                    pixel[x + y * rank] = SDL_MapRGBA(screen->format,
+                                           0,
+                                           0,
+                                           0,
+                                           255);
+                }
+                i++;
+            }       
+        }
+        // Unlock surface
+        // SDL_UnlockSurface(screen);
+
+        // Draw to the screen
+        SDL_Flip(screen);
+    }
+
+    // printf("Max Iteration value: %d\n", max_iter);
+
+    SDL_Event ev;
+    int active;
+
+    active = 1;
+    while(active)
+    {
+        /* Handle events */
+        while(SDL_PollEvent(&ev))
+        {
+            if(ev.type == SDL_QUIT)
+                active = 0; /* End */
+        }
+    }
+
+    SDL_Quit();
+
+    return 0;
+}
+
diff --git a/test.o b/test.o
new file mode 100644
index 0000000000000000000000000000000000000000..261f5603d22c0028ade971b50bd09d92866fd8ce
GIT binary patch
literal 5136
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
S;Co#54I;j0C0@F%82bl$udZqU

literal 0
HcmV?d00001

diff --git a/vector_add_kernel.cl b/vector_add_kernel.cl
new file mode 100644
index 0000000..7db0bda
--- /dev/null
+++ b/vector_add_kernel.cl
@@ -0,0 +1,12 @@
+int vec_add (int a, int b) {
+    return (a + b) * 3;
+}
+
+__kernel void vector_add(__global int *A, __global int *B, __global int *C) {
+    
+    // Get the index of the current element
+    int i = get_global_id(0);
+
+    // Do the operation
+    C[i] = vec_add (A[i], B[i]);
+}