Display: Prohibit allocation in iterrupts. This prevents non-deterministic and impossible to debug errors caused by aysynchronous GC.

markshannon · markshannon · commit a463521976cf · 2016-07-14T20:30:53.000-07:00
diff --git a/docs/display.rst b/docs/display.rst
@@ -47,6 +47,12 @@ Functions
     Note that the ``wait``, ``loop`` and ``clear`` arguments must be specified
     using their keyword.
 
+.. note::
+
+    If using a generator as the ``iterable``, then take care not to allocate any memory
+    in the generator as allocating memory in an interrupt is prohibited and will raise a
+    ``MemoryError``.
+
 .. py:function:: scroll(string, delay=150, \*, wait=True, loop=False, monospace=False)
 
     Similar to ``show``, but scrolls the ``string`` horizontally instead. The
diff --git a/examples/analog_watch.py b/examples/analog_watch.py
@@ -30,7 +30,6 @@ def ticks():
             on = not on
 
 #Run a clock speeded up 60 times, so we can watch the animation.
-display.show(ticks(), 1000)
-
-
-
+for tick in ticks():
+    display.show(tick)
+    sleep(1000)
diff --git a/inc/microbit/microbitimage.h b/inc/microbit/microbitimage.h
@@ -37,6 +37,8 @@ typedef struct _greyscale_t {
     uint8_t width;
     uint8_t byte_data[]; /* Static initializer for this will have to be C, not C++ */
     void clear();
+    void shiftLeftInplace(mp_int_t n);
+    void shiftRightInplace(mp_int_t n);
     
     /* Thiese are internal methods and it is up to the caller to validate the inputs */
     uint8_t getPixelValue(mp_int_t x, mp_int_t y);
diff --git a/source/microbit/microbitdisplay.cpp b/source/microbit/microbitdisplay.cpp
@@ -30,6 +30,7 @@
 
 extern "C" {
 #include "py/runtime.h"
+#include "py/gc.h"
 #include "modmicrobit.h"
 #include "microbitimage.h"
 #include "microbitdisplay.h"
@@ -130,7 +131,6 @@ static volatile bool wakeup_event = false;
 static mp_uint_t async_delay = 1000;
 static mp_uint_t async_tick = 0;
 static bool async_clear = false;
-static bool async_error = true;
 
 STATIC void async_stop(void) {
     async_iterator = NULL;
@@ -281,6 +281,30 @@ static int32_t callback(void) {
     return render_timings[brightness];
 }
 
+static void draw_object(mp_obj_t obj) {
+    microbit_display_obj_t *display = (microbit_display_obj_t*)MP_STATE_PORT(async_data)[0];
+    if (obj == MP_OBJ_STOP_ITERATION) {
+        if (async_clear) {
+            microbit_display_show(&microbit_display_obj, BLANK_IMAGE);
+            async_clear = false;
+        } else {
+            async_stop();
+        }
+    } else if (mp_obj_get_type(obj) == &microbit_image_type) {
+        microbit_display_show(display, (microbit_image_obj_t *)obj);
+    } else if (MP_OBJ_IS_STR(obj)) {
+        mp_uint_t len;
+        const char *str = mp_obj_str_get_data(obj, &len);
+        if (len == 1) {
+            microbit_display_show(display, microbit_image_for_char(str[0]));
+        } else {
+            async_stop();
+        }
+    } else {
+        MP_STATE_VM(mp_pending_exception) = mp_obj_new_exception_msg(&mp_type_TypeError, "not an image.");
+        async_stop();
+    }
+}
 
 static void microbit_display_update(void) {
     async_tick += MILLISECONDS_PER_MACRO_TICK;
@@ -295,44 +319,29 @@ static void microbit_display_update(void) {
                 async_stop();
                 break;
             }
-            microbit_display_obj_t *display = (microbit_display_obj_t*)MP_STATE_PORT(async_data)[0];
             /* WARNING: We are executing in an interrupt handler.
              * If an exception is raised here then we must hand it to the VM. */
             mp_obj_t obj;
             nlr_buf_t nlr;
+            gc_lock();
             if (nlr_push(&nlr) == 0) {
                 obj = mp_iternext_allow_raise(async_iterator);
                 nlr_pop();
+                gc_unlock();
             } else {
+                gc_unlock();
                 if (!mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(((mp_obj_base_t*)nlr.ret_val)->type),
                     MP_OBJ_FROM_PTR(&mp_type_StopIteration))) {
-                    // an exception other than StopIteration, so set it for the VM to raise later
+                    // An exception other than StopIteration, so set it for the VM to raise later
+                    // If memory error, write an appropriate message.
+                    if (mp_obj_get_type(nlr.ret_val) == &mp_type_MemoryError) {
+                        mp_printf(&mp_plat_print, "Allocation in interrupt handler");
+                    }
                     MP_STATE_VM(mp_pending_exception) = MP_OBJ_FROM_PTR(nlr.ret_val);
                 }
                 obj = MP_OBJ_STOP_ITERATION;
             }
-            if (obj == MP_OBJ_STOP_ITERATION) {
-                if (async_clear) {
-                    microbit_display_show(&microbit_display_obj, BLANK_IMAGE);
-                    async_clear = false;
-                } else {
-                    async_stop();
-                }
-            } else if (mp_obj_get_type(obj) == &microbit_image_type) {
-                microbit_display_show(display, (microbit_image_obj_t *)obj);
-            } else if (MP_OBJ_IS_STR(obj)) {
-                mp_uint_t len;
-                const char *str = mp_obj_str_get_data(obj, &len);
-                if (len == 1) {
-                    microbit_display_show(display, microbit_image_for_char(str[0]));
-                } else {
-                    async_error = true;
-                    async_stop();
-                }
-            } else {
-                async_error = true;
-                async_stop();
-            }
+            draw_object(obj);
             break;
         }
         case ASYNC_MODE_CLEAR:
@@ -367,13 +376,14 @@ void microbit_display_animate(microbit_display_obj_t *self, mp_obj_t iterable, m
     MP_STATE_PORT(async_data)[0] = NULL;
     MP_STATE_PORT(async_data)[1] = NULL;
     async_iterator = mp_getiter(iterable);
-    async_error = false;
     async_delay = delay;
     async_clear = clear;
     MP_STATE_PORT(async_data)[0] = self; // so it doesn't get GC'd
     MP_STATE_PORT(async_data)[1] = async_iterator;
     wakeup_event = false;
     async_mode = ASYNC_MODE_ANIMATION;
+    mp_obj_t obj = mp_iternext_allow_raise(async_iterator);
+    draw_object(obj);
     if (wait) {
         wait_for_event();
     }
diff --git a/source/microbit/microbitimage.cpp b/source/microbit/microbitimage.cpp
@@ -142,31 +142,50 @@ greyscale_t *microbit_image_obj_t::invert() {
     return result;
 }
 
-greyscale_t *microbit_image_obj_t::shiftLeft(mp_int_t n) {
-    mp_int_t w = this->width();
-    mp_int_t h = this->height();
-    n = max(n, -w);
-    n = min(n, w);
-    mp_int_t src_start = max(n, 0);
-    mp_int_t src_end = min(w+n,w);
-    mp_int_t dest = max(0,-n);
-    greyscale_t *result = greyscale_new(w, h);
-    for (mp_int_t x = 0; x < dest; ++x) {
+/** Internal method, does no error checking. Result is undefined if n < 0 or n > width */
+void greyscale_t::shiftLeftInplace(mp_int_t n) {
+    mp_int_t w = this->width;
+    mp_int_t h = this->height;
+    for (mp_int_t x = n; x < w; ++x) {
         for (mp_int_t y = 0; y < h; y++) {
-            result->setPixelValue(x, y, 0);
+             this->setPixelValue(x-n, y, this->getPixelValue(x, y));
         }
     }
-    for (mp_int_t x = src_start; x < src_end; ++x) {
+    for (mp_int_t x = w-n; x < w; ++x) {
         for (mp_int_t y = 0; y < h; y++) {
-             result->setPixelValue(dest, y, this->getPixelValue(x, y));
+            this->setPixelValue(x, y, 0);
         }
-        ++dest;
     }
-    for (mp_int_t x = dest; x < w; ++x) {
+}
+
+/** Internal method, does no error checking. Result is undefined if n < 0 or n > width */
+void greyscale_t::shiftRightInplace(mp_int_t n) {
+    if (n < 0)
+        return;
+    mp_int_t w = this->width;
+    mp_int_t h = this->height;
+    for (mp_int_t x = w-1; x >= n; --x) {
         for (mp_int_t y = 0; y < h; y++) {
-            result->setPixelValue(x, y, 0);
+             this->setPixelValue(x, y, this->getPixelValue(x-n, y));
         }
     }
+    for (mp_int_t x = 0; x < n; ++x) {
+        for (mp_int_t y = 0; y < h; y++) {
+            this->setPixelValue(x, y, 0);
+        }
+    }
+}
+
+greyscale_t *microbit_image_obj_t::shiftLeft(mp_int_t n) {
+    mp_int_t w = this->width();
+    if (n <= -w || n >= w)
+        return greyscale_new(w, this->height());
+    greyscale_t *result = this->copy();
+    if (n >= 0) {
+        result->shiftLeftInplace(n);
+    } else {
+        result->shiftRightInplace(-n);
+    }
     return result;
 }
 
@@ -643,7 +662,7 @@ typedef struct _scrolling_string_t {
 typedef struct _scrolling_string_iterator_t {
     mp_obj_base_t base; 
     mp_obj_t ref;
-    microbit_image_obj_t *img;
+    greyscale_t *img;
     char const *next_char;
     char const *end;
     uint8_t offset;
@@ -689,7 +708,7 @@ STATIC mp_obj_t get_microbit_scrolling_string_iter(mp_obj_t o_in) {
     scrolling_string_t *str = (scrolling_string_t *)o_in;
     scrolling_string_iterator_t *result = m_new_obj(scrolling_string_iterator_t);
     result->base.type = &microbit_scrolling_string_iterator_type;
-    result->img = BLANK_IMAGE;
+    result->img = greyscale_new(5,5);
     result->offset = 0;
     result->next_char = str->str;
     result->ref = str->ref;
@@ -714,14 +733,13 @@ STATIC mp_obj_t microbit_scrolling_string_iter_next(mp_obj_t o_in) {
     if (iter->next_char == iter->end && iter->offset == 5) {
         return MP_OBJ_STOP_ITERATION;
     }
-    greyscale_t *result = iter->img->shiftLeft(1);
-    iter->img = (microbit_image_obj_t*)result;
+    iter->img->shiftLeftInplace(1);
     const unsigned char *font_data;
     if (iter->offset < iter->offset_limit) {
         font_data = get_font_data_from_char(iter->right);
         for (int y = 0; y < 5; ++y) {
             int pix = get_pixel_from_font_data(font_data, iter->offset, y)*MAX_BRIGHTNESS;
-            result->setPixelValue(4, y, pix);
+            iter->img->setPixelValue(4, y, pix);
         }
     } else if (iter->offset == iter->offset_limit) {
         ++iter->next_char;
@@ -742,7 +760,7 @@ STATIC mp_obj_t microbit_scrolling_string_iter_next(mp_obj_t o_in) {
         }
     }
     ++iter->offset;
-    return result;
+    return iter->img;
 }
 
 const mp_obj_type_t microbit_scrolling_string_type = {
