aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/memory.c48
-rw-r--r--src/render.c93
2 files changed, 93 insertions, 48 deletions
diff --git a/src/memory.c b/src/memory.c
index 1036152..b02a5b9 100644
--- a/src/memory.c
+++ b/src/memory.c
@@ -7,8 +7,6 @@
#include "instset.h"
#include "memory.h"
-#define MAX_ZOOM 0x10000
-
static boolean g_is_init;
static uint32 g_order;
static uint32 g_size;
@@ -185,52 +183,6 @@ uint8 sal_mem_get_byte(uint32 address)
return g_memory[address];
}
-void sal_mem_render_image(
- uint32 origin, uint32 cell_size, uint32 buff_size, uint8_p buffer
-) {
- /* Render a 1D image of a given section of memory, at a given resolution
- (zoom) and store it in a pre-allocated 'buffer'.
-
- On the Salis python handler we draw memory as a 1D 'image' on the WORLD
- page. If we were to render this image directly on python, it would be
- excruciatingly slow, as we have to iterate over large areas of memory!
- Therefore, this memory module comes with a built-in, super fast renderer.
- */
- uint32 i;
- assert(g_is_init);
- assert(sal_mem_is_address_valid(origin));
- assert(cell_size);
- assert(cell_size <= MAX_ZOOM);
- assert(buff_size);
- assert(buffer);
-
- /* We make use of openmp for multi-threaded looping. This allows even
- faster render times, wherever openmp is supported.
- */
- #pragma omp parallel for
- for (i = 0; i < buff_size; i++) {
- uint32 j;
- uint32 inst_sum = 0;
- uint32 alloc_found = 0;
- uint32 cell_addr = origin + (i * cell_size);
-
- for (j = 0; j < cell_size; j++) {
- uint32 address = j + cell_addr;
-
- if (sal_mem_is_address_valid(address)) {
- inst_sum += sal_mem_get_inst(address);
-
- if (sal_mem_is_allocated(address)) {
- alloc_found = ALLOCATED_FLAG;
- }
- }
- }
-
- buffer[i] = (uint8)(inst_sum / cell_size);
- buffer[i] |= (uint8)(alloc_found);
- }
-}
-
static boolean inst_count_is_correct(void)
{
/* Check that the instruction counter is in a valid state
diff --git a/src/render.c b/src/render.c
new file mode 100644
index 0000000..128ce3b
--- /dev/null
+++ b/src/render.c
@@ -0,0 +1,93 @@
+#include <assert.h>
+#include <stdio.h>
+#include "types.h"
+#include "memory.h"
+#include "process.h"
+#include "render.h"
+
+#define MAX_ZOOM 0x10000
+#define BLOCK_FLAG 0x40
+#define IP_FLAG 0x80
+
+static void apply_flag(
+ uint32 origin, uint32 max_pos, uint32 cell_size, uint32 address,
+ uint32 flag, uint8_p buffer
+) {
+ if (address >= origin && address < max_pos) {
+ /* Flag falls inside rendered image. We can 'and' the bit to the
+ corresponding pixel.
+ */
+ uint32 pixel = (address - origin) / cell_size;
+ buffer[pixel] |= flag;
+ }
+}
+
+void sal_ren_get_image(
+ uint32 origin, uint32 cell_size, uint32 buff_size, uint8_p buffer
+) {
+ /* Render a 1D image of a given section of memory, at a given resolution
+ (zoom) and store it in a pre-allocated 'buffer'.
+
+ On the Salis python handler we draw memory as a 1D 'image' on the WORLD
+ page. If we were to render this image directly on python, it would be
+ excruciatingly slow, as we have to iterate over large areas of memory!
+ Therefore, this memory module comes with a built-in, super fast renderer.
+ */
+ uint32 i;
+ uint32 max_pos;
+ assert(sal_mem_is_address_valid(origin));
+ assert(cell_size);
+ assert(cell_size <= MAX_ZOOM);
+ assert(buff_size);
+ assert(buffer);
+
+ /* We make use of openmp for multi-threaded looping. This allows even
+ faster render times, wherever openmp is supported.
+ */
+ #pragma omp parallel for
+ for (i = 0; i < buff_size; i++) {
+ uint32 j;
+ uint32 inst_sum = 0;
+ uint32 alloc_flag = 0;
+ uint32 cell_addr = origin + (i * cell_size);
+
+ for (j = 0; j < cell_size; j++) {
+ uint32 address = j + cell_addr;
+
+ if (!sal_mem_is_address_valid(address)) {
+ continue;
+ }
+
+ inst_sum += sal_mem_get_inst(address);
+
+ if (sal_mem_is_allocated(address)) {
+ alloc_flag = ALLOCATED_FLAG;
+ }
+ }
+
+ buffer[i] = (uint8)(inst_sum / cell_size);
+ buffer[i] |= (uint8)(alloc_flag);
+ }
+
+ /* We also iterate through all processes and append extra bit flags to the
+ rendered image signaling process IP position and memory block limits.
+ */
+ max_pos = origin + (cell_size * buff_size);
+
+ #pragma omp parallel for
+ for (i = 0; i < sal_proc_get_count(); i++) {
+ if (!sal_proc_is_free(i)) {
+ Process proc = sal_proc_get_proc(i);
+ apply_flag(origin, max_pos, cell_size, proc.ip, IP_FLAG, buffer);
+ apply_flag(
+ origin, max_pos, cell_size, proc.mb1a, BLOCK_FLAG, buffer
+ );
+
+ if (proc.mb2s) {
+ apply_flag(
+ origin, max_pos, cell_size, proc.mb2a, BLOCK_FLAG, buffer
+ );
+ }
+ }
+ }
+}