XShmSegmentInfo segmentInfo;
	XImage* image;
	Pixmap pixelMap;
	Window window;
	XVisualInfo visualInfo;
	Display* display;
	
	Atom atomClose;
	
	void* buffer;
	
	// Init
	display = XOpenDisplay(NO_POINTER);
	
	ASSERT(display);
	ASSERT(XShmQueryExtension(display));
	ASSERT(XMatchVisualInfo(display, DefaultScreen(display), 24, TrueColor, &visualInfo));
	
	u32 width  = 1024;
	u32 height = 768;
	
	image =
		XShmCreateImage(
		display,
		visualInfo.visual,
		visualInfo.depth,
		ZPixmap,
		NO_POINTER,
		&segmentInfo,
		width, height);
	
	// Allocate image memory
	segmentInfo.shmid =
		shmget(
		IPC_PRIVATE,
		image->bytes_per_line * image->height,
		IPC_CREAT | 0777);
	
	segmentInfo.readOnly = false;
	
	// Attach memory to this process
	segmentInfo.shmaddr = (char*)(shmat(segmentInfo.shmid, 0, 0));
	image->data = segmentInfo.shmaddr;
	buffer = image->data;
	
	ASSERT(XShmAttach(display, &segmentInfo));
	
	// Mark for removal after process end
	shmctl(segmentInfo.shmid, IPC_RMID, NO_POINTER);
	
	// Window
	XSetWindowAttributes attribs;
	
	attribs.background_pixmap = BlackPixel(display, visualInfo.screen),
	
	attribs.colormap =
		XCreateColormap(
		display,
		RootWindow(display, visualInfo.screen),
		visualInfo.visual,
		AllocNone);
	
	attribs.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask,
	
	window =
		XCreateWindow(
		display, RootWindow(display, visualInfo.screen),
		0, 0, width, height,
		0, visualInfo.depth, InputOutput, visualInfo.visual,
		CWBackPixel | CWEventMask, &attribs);
	
	XStoreName(display, window, "RayMarcher");
	
	XMapRaised(display, window);
	
	atomClose = XInternAtom(display, "WM_DELETE_WINDOW", 0);
	XSetWMProtocols(display, window, &atomClose, 1);
	
	pixelMap = XCreatePixmap(display, window, image->width, image->height, visualInfo.depth);
	

			XShmPutImage(
				display, pixelMap, DefaultGC(display, visualInfo.screen),
				image, 0, 0, 0, 0, image->width, image->height, true);
			
			XFlush(display);

void RenderTiles(renderQueue* q)
{
	PRINT_STRING("Begin work");
	
	q->numTilesDone = 0; //volatile
	q->nextTile = 0; // volatile
	
	loop (i, 0, q->numThreads, 1)
	{
		Increment(&q->semaphore); // Calls sem_post(&s->handle);
	}
	
	PRINT_STRING("Wait for work");
	
	while (q->numTilesDone < q->numTilesTotal) // Both volatile
	{
	}
	
	PRINT_STRING("Work done");
}

void* WorkerThread(void* params)
{
	CAST(threadParameters, parameters, params);
	
	PRINT_STRING("Thread %u started", parameters->thread->id);
	
	CAST(renderQueue, queue, parameters->data);
	
	while (true)
	{
		if (queue->nextTile < queue->numTilesTotal)
		{
			u32 indexTile = SyncedGetAndAdd(&queue->nextTile, 1);
			
			PRINT_STRING("Thread %u doing tile %u", parameters->thread->id, indexTile);
			
			renderTileWork* tile = queue->workQueue + indexTile;

			RenderTile(
				queue->image,
				queue->view,
				tile->xMin, tile->xMax,
				tile->yMin, tile->yMax);

			SyncedGetAndAdd(&queue->numTilesDone, 1); // Calls __sync_fetch_and_add
		}
		else
		{
			PRINT_STRING("Thread %u pausing", parameters->thread->id);
			Decrement(&queue->semaphore); // Calls sem_wait(&s->handle);
		}
	}
}

void RenderTile(
    renderImage* image,
    renderView* view,
    u32 xMin, u32 xMax,
    u32 yMin, u32 yMax)
{
	DrawRectangle(image, xMin, yMin, xMax, yMax, V4(1.0f, 1.0f, 0.0f, 0.5f));

	loop (y, yMin, yMax, 1)
	{
		loop (x, xMin, xMax, 1)
		{
			RenderPixel(image, view, x, y, 0.0f);
		}
	}

	DrawLinedRectangle(image, xMin, yMin, xMax, yMax, V4(0.0f, 1.0f, 1.0f, 0.5f));
}

Begin work
Thread 0 doing tile 0
Thread 4 doing tile 3
Thread 1 doing tile 1
Thread 7 doing tile 5
Wait for work
Thread 6 doing tile 6
Thread 3 doing tile 2
Thread 2 doing tile 4
Thread 5 started
Thread 5 doing tile 7
Thread 5 doing tile 8
Thread 1 doing tile 9
Thread 0 doing tile 10
Thread 2 doing tile 11
Thread 3 doing tile 12
Thread 4 doing tile 13
Thread 0 doing tile 14
Thread 6 doing tile 15
Thread 5 doing tile 16
Thread 7 doing tile 17
Thread 4 doing tile 18
Thread 1 doing tile 19
Thread 2 doing tile 20
...

while (true)
	{
		if (queue->nextTile < queue->numTilesTotal)
		{
			u32 indexTile = SyncedGetAndAdd(&queue->nextTile, 1); <== no guarantee queue->nextTile will have the same value as above

while (true)
	{
		u32 indexTile = SyncedGetAndAdd(&queue->nextTile, 1);
		if (indexTile < queue->numTilesTotal)
		{
			// do work

while (run)
{
    if () // Time to update
    {
        if (CameraControls(viewP, inputP))
        {
            RenderTiles(queueP);
				
            XShmPutImage(display, windowP->window, context, imageX, 0, 0, 0, 0, imageX->width, imageX->height, true);
        }
    }
}