Multithread SDL renderer
diff --git a/CMakeLists.txt b/CMakeLists.txt
index fe0e4cd..8fc9b17 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,6 +3,7 @@
project(6502 VERSION 0.1.0 LANGUAGES C)
option(GEN_INSTRUCTIONS_HEADER ON)
+option(NO_PTHREAD OFF)
include_directories(nuklear)
@@ -14,5 +15,11 @@
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
endif()
+if (${NO_PTHREAD})
+ add_definitions(-DNO_PTHREAD)
+else()
+ set(THREAD pthread)
+endif()
+
add_executable(6502 main.c cpu.c cpu.h dbg.c dbg.h instructions.h gui.h gui.c screen.h screen.c)
-target_link_libraries(6502 readline SDL2 GL GLU GLEW m)
+target_link_libraries(6502 readline SDL2 GL GLU GLEW m ${THREAD})
diff --git a/README.md b/README.md
index eb48cbf..3f34714 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,6 @@
# 6502 Toolchain
<center>
-**Click for demonstration:**
-
[](colors.webm)
</center>
diff --git a/cpu.c b/cpu.c
index cfcd89d..6e56134 100644
--- a/cpu.c
+++ b/cpu.c
@@ -33,6 +33,7 @@
cpu.pc = 0x600; // arbitrary program counter start
cpu.running = true;
cpu.mem = malloc(0xFFFF);
+ cpu.screen_dirty = true;
memset(cpu.mem, 0, 0xFFFF);
if (!cpu.mem)
@@ -95,36 +96,36 @@
}
// rotate right
-inline uint8_t ror(uint8_t a, uint8_t n)
+uint8_t ror(uint8_t a, uint8_t n)
{
return (a >> n) | (a << (8 - n));
}
// rotate left
-inline uint8_t rol(uint8_t a, uint8_t n)
+uint8_t rol(uint8_t a, uint8_t n)
{
return (a << n) | (a >> (8 - n));
}
-inline void stat_nz(cpu_t *cpu, int8_t v)
+void stat_nz(cpu_t *cpu, int8_t v)
{
cpu->status.negative = v < 0;
cpu->status.zero = v == 0;
}
// Used to check for overflow, is c unique?
-inline bool last_unique(bool a, bool b, bool c)
+bool last_unique(bool a, bool b, bool c)
{
return a == b && a != c;
}
-inline void stat_cv(cpu_t *cpu, uint8_t a, uint8_t b, uint8_t c)
+void stat_cv(cpu_t *cpu, uint8_t a, uint8_t b, uint8_t c)
{
cpu->status.overflow = last_unique(a >> 7, b >> 7, c >> 7);
cpu->status.carry = c < a || c < b;
}
-inline void cmp(cpu_t *cpu, uint8_t reg, uint8_t mem)
+void cmp(cpu_t *cpu, uint8_t reg, uint8_t mem)
{
cpu->status.negative = 0;
cpu->status.zero = 0;
@@ -144,6 +145,14 @@
}
}
+uint16_t scr_dirty(cpu_t *cpu, uint16_t mem)
+{
+ if (mem >= 0x200 && mem <= 0x200 + 32 * 32)
+ cpu->screen_dirty = true;
+
+ return mem;
+}
+
void execute(cpu_t *cpu, const char *mnemonic, uint8_t op, arg_t a, uint8_t am)
{
// used to save space
@@ -164,7 +173,7 @@
#define R(reg) \
case ST##reg: \
- cpu->mem[a.ptr] = cpu->regs[reg]; \
+ cpu->mem[scr_dirty(cpu, a.ptr)] = cpu->regs[reg]; \
break; \
REGS
@@ -194,8 +203,8 @@
}
case INC:
- cpu->mem[a.ptr]++;
- stat_nz(cpu, cpu->mem[a.ptr]);
+ cpu->mem[scr_dirty(cpu, scr_dirty(cpu, a.ptr))]++;
+ stat_nz(cpu, cpu->mem[scr_dirty(cpu, a.ptr)]);
break;
case INX:
@@ -209,8 +218,8 @@
break;
case DEC:
- cpu->mem[a.ptr]--;
- stat_nz(cpu, cpu->mem[a.ptr]);
+ cpu->mem[scr_dirty(cpu, a.ptr)]--;
+ stat_nz(cpu, cpu->mem[scr_dirty(cpu, a.ptr)]);
break;
case DEX:
@@ -235,9 +244,9 @@
}
else
{
- cpu->status.carry = cpu->mem[a.val] >> 7;
- cpu->mem[a.ptr] <<= 1;
- stat_nz(cpu, cpu->mem[a.ptr]);
+ cpu->status.carry = cpu->mem[scr_dirty(cpu, a.val)] >> 7;
+ cpu->mem[scr_dirty(cpu, a.ptr)] <<= 1;
+ stat_nz(cpu, cpu->mem[scr_dirty(cpu, a.ptr)]);
}
break;
@@ -250,9 +259,9 @@
}
else
{
- cpu->status.carry = cpu->mem[a.val] & 7;
- cpu->mem[a.ptr] >>= 1;
- stat_nz(cpu, cpu->mem[a.ptr]);
+ cpu->status.carry = cpu->mem[scr_dirty(cpu, a.val)] & 7;
+ cpu->mem[scr_dirty(cpu, a.ptr)] >>= 1;
+ stat_nz(cpu, cpu->mem[scr_dirty(cpu, a.ptr)]);
}
break;
@@ -265,9 +274,9 @@
}
else
{
- cpu->status.carry = cpu->mem[a.val] >> 7;
- cpu->mem[a.ptr] = rol(a.val, 1);
- stat_nz(cpu, cpu->mem[a.ptr]);
+ cpu->status.carry = cpu->mem[scr_dirty(cpu, a.val)] >> 7;
+ cpu->mem[scr_dirty(cpu, a.ptr)] = rol(a.val, 1);
+ stat_nz(cpu, cpu->mem[scr_dirty(cpu, a.ptr)]);
}
break;
@@ -280,9 +289,9 @@
}
else
{
- cpu->status.carry = cpu->mem[a.val] & 1;
- cpu->mem[a.ptr] = ror(a.val, 1);
- stat_nz(cpu, cpu->mem[a.ptr]);
+ cpu->status.carry = cpu->mem[scr_dirty(cpu, a.val)] & 1;
+ cpu->mem[scr_dirty(cpu, a.ptr)] = ror(a.val, 1);
+ stat_nz(cpu, cpu->mem[scr_dirty(cpu, a.ptr)]);
}
break;
@@ -411,19 +420,19 @@
#undef REGS
}
-inline uint16_t fetch_le(cpu_t *cpu)
+uint16_t fetch_le(cpu_t *cpu)
{
- uint8_t a = cpu->mem[cpu->pc++];
- uint8_t b = cpu->mem[cpu->pc++];
+ uint8_t a = cpu->mem[scr_dirty(cpu, cpu->pc++)];
+ uint8_t b = cpu->mem[scr_dirty(cpu, cpu->pc++)];
return le_to_native(a, b);
}
-inline arg_t arg_imm(uint16_t a)
+arg_t arg_imm(uint16_t a)
{
return (arg_t){ a, a };
}
-inline arg_t arg_ptr(cpu_t *c, uint flags, uint16_t p)
+arg_t arg_ptr(cpu_t *c, uint flags, uint16_t p)
{
if (flags & FETCH_NO_INDIRECTION)
return arg_imm(p);
@@ -431,7 +440,7 @@
return (arg_t){ c->mem[p], p };
}
-inline arg_t arg(uint16_t v, uint16_t a)
+arg_t arg(uint16_t v, uint16_t a)
{
return (arg_t){ v, a };
}
@@ -447,7 +456,7 @@
// In both cases return immediate 8 bit value
case AM_IMM:
case AM_ZP:
- return arg_imm(cpu->mem[cpu->pc++]);
+ return arg_imm(cpu->mem[scr_dirty(cpu, cpu->pc++)]);
case AM_ABS:
return arg_ptr(cpu, f, fetch_le(cpu));
@@ -459,7 +468,7 @@
// I have discovered this through testing the output of other
// assemblers.
uint16_t pc = cpu->pc + 1;
- return arg_ptr(cpu, f, (int8_t)cpu->mem[cpu->pc++] + pc);
+ return arg_ptr(cpu, f, (int8_t)cpu->mem[scr_dirty(cpu, cpu->pc++)] + pc);
}
case AM_IND:
@@ -469,8 +478,8 @@
if (f & FETCH_NO_INDIRECTION)
return arg_imm(addr);
- uint8_t low = cpu->mem[addr],
- high = cpu->mem[addr + 1];
+ uint8_t low = cpu->mem[scr_dirty(cpu, addr)],
+ high = cpu->mem[scr_dirty(cpu, addr + 1)];
return arg_ptr(cpu, f, le_to_native(low, high));
}
@@ -489,34 +498,34 @@
case AM_ZPX:
if (f & FETCH_NO_INDIRECTION)
- return arg_ptr(cpu, f, cpu->mem[cpu->pc++]);
- return arg_ptr(cpu, f, cpu->mem[cpu->pc++] + cpu->regs[X]);
+ return arg_ptr(cpu, f, cpu->mem[scr_dirty(cpu, cpu->pc++)]);
+ return arg_ptr(cpu, f, cpu->mem[scr_dirty(cpu, cpu->pc++)] + cpu->regs[X]);
case AM_ZPY:
if (f & FETCH_NO_INDIRECTION)
- return arg_ptr(cpu, f, cpu->mem[cpu->pc++]);
- return arg_ptr(cpu, f, cpu->mem[cpu->pc++] + cpu->regs[Y]);
+ return arg_ptr(cpu, f, cpu->mem[scr_dirty(cpu, cpu->pc++)]);
+ return arg_ptr(cpu, f, cpu->mem[scr_dirty(cpu, cpu->pc++)] + cpu->regs[Y]);
case AM_ZIX:
{
- uint8_t zp = cpu->mem[cpu->pc++];
+ uint8_t zp = cpu->mem[scr_dirty(cpu, cpu->pc++)];
if (f & FETCH_NO_INDIRECTION)
return arg_imm(zp);
uint16_t addr = zp + cpu->regs[X];
- uint16_t indirect = le_to_native(cpu->mem[addr], cpu->mem[addr + 1]);
+ uint16_t indirect = le_to_native(cpu->mem[scr_dirty(cpu, addr)], cpu->mem[scr_dirty(cpu, addr + 1)]);
return arg_ptr(cpu, f, indirect);
}
case AM_ZIY:
{
- uint8_t zp = cpu->mem[cpu->pc++];
+ uint8_t zp = cpu->mem[scr_dirty(cpu, cpu->pc++)];
if (f & FETCH_NO_INDIRECTION)
return arg_imm(zp);
- uint16_t base = le_to_native(cpu->mem[zp], cpu->mem[zp + 1]);
+ uint16_t base = le_to_native(cpu->mem[scr_dirty(cpu, zp)], cpu->mem[scr_dirty(cpu, zp + 1)]);
return arg_ptr(cpu, f, base + cpu->regs[Y]);
}
@@ -526,11 +535,12 @@
}
}
-inline void step(cpu_t *cpu)
+void step(cpu_t *cpu)
{
static int steps;
steps++;
- switch (cpu->mem[cpu->pc++])
+ cpu->screen_dirty = false;
+ switch (cpu->mem[scr_dirty(cpu, cpu->pc++)])
{
#define INST(mn, am, op) \
case op: \
@@ -548,10 +558,13 @@
if (steps % 100 == 0)
printf("%d\n", steps);
+// If can't run screen in seperate thread, just run it here (bad)
+#ifdef NO_PTHREAD
if (g_scr)
{
- sdl_screen(g_scr, cpu->mem + CPU_FB_ADDR);
+ sdl_screen(g_scr, cpu->mem + CPU_FB_ADDR, cpu->screen_dirty);
}
+#endif
}
int dump_inst(cpu_t *cpu, char *buf, const char *mn, uint16_t addr, uint8_t am)
@@ -601,7 +614,7 @@
char *end = buffer;
// end += sprintf(buffer, "$%x", cpu->pc);
- uint8_t op = cpu->mem[cpu->pc++];
+ uint8_t op = cpu->mem[scr_dirty(cpu, cpu->pc++)];
switch (op)
{
#define INST(mn, am, op) \
diff --git a/cpu.h b/cpu.h
index cee84c5..5b91ed4 100644
--- a/cpu.h
+++ b/cpu.h
@@ -128,6 +128,7 @@
status_t status;
uint8_t *mem;
bool running;
+ bool screen_dirty;
} cpu_t;
// Argument type, includes both pointer and its value
diff --git a/main.c b/main.c
index 84e9779..e91e699 100644
--- a/main.c
+++ b/main.c
@@ -92,8 +92,12 @@
if (scrflag)
{
+#ifndef NO_PTHREAD
+ start_screen_thread(cpu.mem + CPU_FB_ADDR);
+#else
sdl_screen_t scr = new_sdl_screen(8);
g_scr = &scr;
+#endif
}
if (guiflag)
@@ -113,6 +117,9 @@
debug(&cpu);
}
+ if (scrflag)
+ free_sdl_screen(g_scr);
+
if (should_read)
free_cpu(&cpu);
}
diff --git a/screen.c b/screen.c
index fedc151..e2bf5e0 100644
--- a/screen.c
+++ b/screen.c
@@ -3,6 +3,10 @@
#include <SDL2/SDL.h>
+#ifndef NO_PTHREAD
+#include <pthread.h>
+#endif
+
struct nk_color byte_to_color(uint8_t b)
{
struct nk_color c;
@@ -50,13 +54,27 @@
0);
scr.size = size;
scr.r = SDL_CreateRenderer(scr.win, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
+ scr.tex = SDL_CreateTexture(scr.r, SDL_PIXELFORMAT_RGB332, SDL_TEXTUREACCESS_STREAMING,
+ CPU_FB_W, CPU_FB_H);
return scr;
}
-void sdl_screen(sdl_screen_t *scr, uint8_t *mem)
+void free_sdl_screen(sdl_screen_t *scr)
{
- SDL_RenderClear(scr->r);
+ //free(scr->fb);
+ SDL_DestroyTexture(scr->tex);
+ SDL_DestroyRenderer(scr->r);
+ SDL_DestroyWindow(scr->win);
+}
+
+bool sdl_screen(sdl_screen_t *scr, uint8_t *mem, bool dirty)
+{
+ static bool texture_set = false;
+ if (!texture_set)
+ {
+ SDL_UpdateTexture(scr->tex, NULL, mem, CPU_FB_W);
+ }
SDL_Event e;
@@ -65,28 +83,42 @@
switch (e.type)
{
case SDL_QUIT:
- exit(0);
+ return true;
}
}
- for (int i = 0; i < CPU_FB_H; i++)
+ if (dirty)
{
- for (int j = 0; j < CPU_FB_W; j++)
- {
- SDL_Rect r =
- {
- i * scr->size,
- j * scr->size,
- scr->size,
- scr->size,
- };
-
- struct nk_color c = byte_to_color(mem[i + CPU_FB_H * j]);
-
- SDL_SetRenderDrawColor(scr->r, c.r, c.g, c.b, c.a);
- SDL_RenderFillRect(scr->r, &r);
- }
+ SDL_RenderClear(scr->r);
+ SDL_RenderCopy(scr->r, scr->tex, NULL, NULL);
+ SDL_RenderPresent(scr->r);
}
- SDL_RenderPresent(scr->r);
+ return false;
}
+
+
+#ifndef NO_PTHREAD
+
+void *screen_thread(uint8_t *mem)
+{
+ sdl_screen_t scr = new_sdl_screen(8);
+ while (true)
+ {
+ if (sdl_screen(&scr, mem, true))
+ break;
+ }
+ free_sdl_screen(&scr);
+
+ exit(0);
+
+ return NULL;
+}
+
+void start_screen_thread(uint8_t *mem)
+{
+ pthread_t thread;
+ pthread_create(&thread, NULL, (void *(*)(void *))&screen_thread, mem);
+}
+
+#endif
diff --git a/screen.h b/screen.h
index 4128005..75dc8cf 100644
--- a/screen.h
+++ b/screen.h
@@ -1,6 +1,7 @@
#pragma once
#include <stdint.h>
+#include <stdbool.h>
#ifndef SCREEN_ONLY_SDL
@@ -25,9 +26,16 @@
{
SDL_Window *win;
SDL_Renderer *r;
+ SDL_Texture *tex;
uint8_t size;
} sdl_screen_t;
// draw the CPU screen
sdl_screen_t new_sdl_screen(uint8_t size);
-void sdl_screen(sdl_screen_t *scr, uint8_t *mem);
+void free_sdl_screen(sdl_screen_t *scr);
+bool sdl_screen(sdl_screen_t *scr, uint8_t *mem, bool dirty);
+
+#ifndef NO_PTHREAD
+void *screen_thread(uint8_t *mem);
+void start_screen_thread(uint8_t *mem);
+#endif