1 files changed, 85 insertions, 0 deletions
diff --git a/memtestEDK/Memtest/Test1/test.c b/memtestEDK/Memtest/Test1/test.c
new file mode 100644
index 0000000..818a193
--- /dev/null
+++ b/memtestEDK/Memtest/Test1/test.c
@@ -0,0 +1,85 @@
+typedef void(*segment_fn)(ulong* start,  // start address
+                          ulong len_dw,  // length of segment in dwords
+                          const void* ctx);  // any context data needed
+
+static const void* const nullptr = 0x0;
+ int me = 0; // my_cpu_num in main.c
+
+/*
+ * Memory address test, walking ones
+ */
+void addr_tst1(int me) // TODO TEST STARTS HERE
+{
+    unsliced_foreach_segment(nullptr, me, addr_tst1_seg);
+}
+
+
+/* Calls segment_fn() for each segment in vv->map.
+ *
+ * Does not slice by CPU number, so it covers the entire memory.
+ * Contrast to sliced_foreach_segment().
+ */
+STATIC void unsliced_foreach_segment
+(const void* ctx, int me, segment_fn func) {
+    int j;
+    for (j=0; j<segs; j++) {
+        foreach_segment(vv->map[j].start,
+                        vv->map[j].end,
+                        me, ctx, func);
+    }
+}
+
+/* Call segment_fn() for each up-to-SPINSZ segment between
+ * 'start' and 'end'.
+ */
+void foreach_segment
+(ulong* start, ulong* end,
+ int me, const void* ctx, segment_fn func) {
+
+    ASSERT(start < end);
+
+    // Confirm 'start' points to an even dword, and 'end'
+    // should point to an odd dword
+    ASSERT(0   == (((ulong)start) & 0x7));
+    ASSERT(0x4 == (((ulong)end)   & 0x7));
+
+    // 'end' may be exactly 0xfffffffc, right at the 4GB boundary.
+    //
+    // To avoid overflow in our loop tests and length calculations,
+    // use dword indices (the '_dw' vars) to avoid overflows.
+    ulong start_dw = ((ulong)start) >> 2;
+    ulong   end_dw = ((ulong)  end) >> 2;
+
+    // end is always xxxxxffc, but increment end_dw to an
+    // address beyond the segment for easier boundary calculations.
+    ++end_dw;
+
+    ulong seg_dw     = start_dw;
+    ulong seg_end_dw = start_dw;
+
+    int done = 0;
+    do {
+        do_tick(me);
+        { BAILR }
+
+        // ensure no overflow
+        ASSERT((seg_end_dw + SPINSZ_DWORDS) > seg_end_dw);
+        seg_end_dw += SPINSZ_DWORDS;
+
+        if (seg_end_dw >= end_dw) {
+            seg_end_dw = end_dw;
+            done++;
+        }
+        if (seg_dw == seg_end_dw) {
+            break;
+        }
+
+        ASSERT(((ulong)seg_end_dw) <= 0x40000000);
+        ASSERT(seg_end_dw > seg_dw);
+        ulong seg_len_dw = seg_end_dw - seg_dw;
+
+        func((ulong*)(seg_dw << 2), seg_len_dw, ctx);
+
+        seg_dw = seg_end_dw;
+    } while (!done);
+}
+\ No newline at end of file