shithub: gpufs

--- a/cops.c

+++ b/cops.c

@@ -1,8 +1,8 @@

 #include <u.h>

 #include <libc.h>

 #include "objects.h"

-#include "vm.h"

 #include "ops.h"

+#include "vm.h"

 #include "names.h"

 extern int debug;

@@ -30,6 +30,12 @@

 void

+OpTypeVoid(Frame *f, u32int)

+{

+	DPRINT("OpTypeVoid\n");

+}

+void

 OpTypeFloat(Frame *f, u32int)

 	u32int varid = *(f->pc+1);

@@ -110,6 +116,7 @@

 		s->items[varid].type = TTYPE;

 		s->items[varid].t.optype = 33;

+	DPRINT("OpTypeFunction\n");

 	return;

@@ -135,7 +142,8 @@

 		s->lastfunction = result;

 		return;

-	// TODO: new stack

+	// TODO: new stack should be done in OpCallFunction

+	DPRINT("OpFunction\n");

 	return;

@@ -147,7 +155,10 @@

 	if (f->ctxt.type == COMPILE)

 		return;

-	// TODO: pop stack

+	// pop stack (test)

+	*f->ctxt.r.frameptr = f->next;

+	free(f);

 	return;

@@ -154,12 +165,11 @@

 void

 OpLabel(Frame *f, u32int len)

+	DPRINT("OpLabel\n");

 	if (f->ctxt.type == COMPILE) {

 		Shader *s = f->ctxt.c.shader;

 		u32int retvar = f->pc[1];

-		DPRINT("OpLabel\n");

 		if (!updatenitems(s, retvar))

 			return;

@@ -166,6 +176,10 @@

 		s->items[retvar].type = TLABEL;

 		s->items[retvar].l.ptr = &f->pc[len + 1];

+		if (debug) {

+			fprint(2, "Label: %p\n", s->items[retvar].l.ptr);

+		}

 		if (s->lastfunction >= 0) {

 			s->items[s->lastfunction].f.label = retvar;

 			s->lastfunction = -1;

@@ -178,6 +192,7 @@

 Op oplist[] = {

 	{    5, OpName },

 	{   15, OpEntryPoint },

+	{   19, OpTypeVoid },

 	{   21, OpTypeInt },

 	{   22, OpTypeFloat },

 	{   33, OpTypeFunction },

--- a/dops.c

+++ b/dops.c

@@ -1,7 +1,6 @@

 #include <u.h>

 #include <libc.h>

 #include "objects.h"

-#include "vm.h"

 #include "ops.h"

 #include "names.h"

--- a/gpufs.c

+++ b/gpufs.c

@@ -4,6 +4,8 @@

 #include <thread.h>

 #include <9p.h>

 #include <String.h>

+#include "objects.h"

+#include "ops.h"

 #include "vm.h"

 void

@@ -473,6 +475,7 @@

 				responderr(r);

 				return;

+			respond(r, nil);

 			return;

 		if (strcmp(argv[0], "b") == 0) {

--- a/ops.h

+++ b/ops.h

@@ -1,8 +1,16 @@

+typedef struct Frame Frame;

 typedef struct CompileTimeContext CompileTimeContext;

 struct CompileTimeContext {

 	Shader *shader;

};

+typedef struct RunTimeContext RunTimeContext;

+struct RunTimeContext {

+	Shader *shader;

+	Frame **frameptr;

+};

 enum {

 	COMPILE,

 	RUNTIME,

@@ -13,10 +21,10 @@

 	short type;

 	union {

 		CompileTimeContext c;

+		RunTimeContext r;

};

};

-typedef struct Frame Frame;

 struct Frame {

 	u32int *pc;

 	FrameContext ctxt;

--- a/spirvd.c

+++ b/spirvd.c

@@ -1,7 +1,6 @@

 #include <u.h>

 #include <libc.h>

 #include "objects.h"

-#include "vm.h"

 #include "ops.h"

 int debug = 0;

--- a/vm.c

+++ b/vm.c

@@ -14,20 +14,39 @@

 #define IDVALID(c) (c < numobjects)

-Frame *stack = nil;

+typedef struct PidStack PidStack;

+struct PidStack {

+	int pid;

+	Frame *stack;

+};

+#define NSTACKS 10

+int nstacks = NSTACKS;

+PidStack stacks[NSTACKS];

 u32int

-runinst(u32int *ptr)

+runinst(Frame *stack, u32int *ptr)

 	u32int len, opcode;

 	void (*func)(Frame*,u32int);

+	Frame **fptr;

+	fptr = stack->ctxt.r.frameptr;

 	opcode = (*ptr) & 0x0000ffff;

 	len = ((*ptr) & 0xffff0000) >> 16;

+	fprint(2, "op: %ux\n", opcode);

 	if (oplookup(opcode, &func)) {

 		func(stack, len);

+		// if frame changed, return (and quit)

+		if (*fptr != stack) {

+			fprint(2, "stack changed\n");

+			return 0;

+		}

 		// if (func) changes pc, ignore it

 		if (ptr == stack->pc) {

 			stack->pc += len;

@@ -39,43 +58,64 @@

 void

-runstack(u32int *ptr)

+runstack(Frame *frame, u32int *ptr)

-	Frame *n = malloc(sizeof(Frame));

+	Frame **fptr = frame->ctxt.r.frameptr;

-	n->next = stack;

-	stack = n;

-	stack->pc = ptr;

-	while (runinst(stack->pc)) {

-		;

+	while (runinst(frame, frame->pc)) {

+		if (1) {

+			Frame *cs;

+			for (cs = *fptr; cs; cs = cs->next) {

+				fprint(2, "Stack: %p (PC: %p)\n", cs, cs->pc);

+			}

+		}

 void

-retstack(void)

+vmrun(Shader *s, u32int *ptr)

-	Frame *p, *c;

+	Frame *n;

-	p = stack->next;

-	c = stack;

+	int pid = getpid();

+	int sid = -1;

+	for (int i = 0; i < nstacks; i++) {

+		if (stacks[i].pid <= 0) {

+			stacks[i].pid = pid;

+			sid = i;

+			break;

+		}

+	}

-	if (!p)

-		goto fin;

+	if (sid < 0) {

+		fprint(2, "no free pid stack found!");

+		exits(nil);

+		return;

+	}

-	stack = p;

-fin:

-	free(c);

+	n = malloc(sizeof(Frame));

+	n->next = stacks[sid].stack;

+	stacks[sid].stack = n;

+	n->pc = ptr;

+	n->ctxt.type = RUNTIME;

+	n->ctxt.r.shader = s;

+	n->ctxt.r.frameptr = &stacks[sid].stack;

+	runstack(n, ptr);

+	// free all stacks for this PID

+	for (n = stacks[sid].stack; n; ) {

+		Frame *ns = n->next;

+		free(n);

+		n = ns;

+	}

+	stacks[sid].stack = nil;

+	stacks[sid].pid = -1;

+	exits(nil);

-void

-vmrun(u32int *ptr)

-{

-	stack = nil; // TODO clean stack

-	runstack(ptr);

-}

 typedef struct Object Object;

 struct Object {

 	int id;

@@ -159,8 +199,23 @@

 	u32int *ptr = s->items[label].l.ptr;

-	werrstr("passed tests, but not implemented yet");

-	return 0;

+	if (debug) {

+		fprint(2, "running from %p\n", ptr);

+		fprint(2, "ptr: %ux\n", *ptr);

+	}

+	switch (rfork(RFFDG|RFREND|RFPROC|RFMEM)) {

+	case 0:

+		// child

+		vmrun(s, ptr);

+		return 0;

+	case -1:

+		// error

+		werrstr("error spawning child process");

+		return 0;

+	}

+	// parent

+	return 1;

 String*

@@ -405,6 +460,8 @@

 		if (oplookup(opcode, &func)) {

 			func(&f, len);

+		} else {

+			fprint(2, "error: %r\n");

 		if (oldpc == f.pc) {

@@ -412,8 +469,9 @@

+	sh->compiled = 1;

 	updateinfostring(id);

-	return sh->compiled = 1;

+	return sh->compiled;

int

--- a/vm.h

+++ b/vm.h

@@ -1,5 +1,4 @@

-void vmrun(u32int *ptr);

-void runstack(u32int *ptr);

+void runstack(Frame *frame, u32int *pc);

 void retstack(void);

 int runshader(vlong id, char *entrypoint);