handle executing code that uses JS vars in an IRQ

Author: gfwilliams

src/jsutils.h

@@ -371,13 +371,15 @@ void jsWarn_flash(const char *fmt, ...);
 #endif
 
 // ------------
+/// Error flags for internal errors - update jswrap_espruino_getErrorFlags if you add to this
 typedef enum {
   JSERR_NONE = 0,
   JSERR_RX_FIFO_FULL = 1, ///< The IO buffer (ioBuffer in jsdevices.c) is full and data was lost. Happens for character data and watch events
   JSERR_BUFFER_FULL = 2, ///< eg. Serial1's buffer exceeded the max size. Doesn't happen if you have an on('data') callback
   JSERR_CALLBACK = 4, ///< A callback (on data/watch/timer) caused an error and was removed
   JSERR_LOW_MEMORY = 8, ///< Memory is running low - Espruino had to run a garbage collection pass or remove some of the command history
   JSERR_MEMORY = 16, ///< Espruino ran out of memory and was unable to allocate some data that it needed.
+  JSERR_MEMORY_BUSY = 32, ///< Espruino was busy doing something with memory (eg. garbage collection) so an IRQ couldn't allocate memory
 } PACKED_FLAGS JsErrorFlags;
 
 /** Error flags for things that we don't really want to report on the console,

src/jsvar.c

@@ -45,7 +45,8 @@ JsVar jsVars[JSVAR_CACHE_SIZE];
 unsigned int jsVarsSize = JSVAR_CACHE_SIZE;
 #endif
 
-JsVarRef jsVarFirstEmpty; ///< reference of first unused variable (variables are in a linked list)
+volatile JsVarRef jsVarFirstEmpty; ///< reference of first unused variable (variables are in a linked list)
+volatile bool isMemoryBusy; ///< Are we doing garbage collection or similar, so can't access memory?
 
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
@@ -161,6 +162,8 @@ void jsvSetMaxVarsUsed(unsigned int size) {
 
 // maps the empty variables in...
 void jsvCreateEmptyVarList() {
+  assert(!isMemoryBusy);
+  isMemoryBusy = true;
   jsVarFirstEmpty = 0;
   JsVar firstVar; // temporary var to simplify code in the loop below
   jsvSetNextSibling(&firstVar, 0);
@@ -179,12 +182,15 @@ void jsvCreateEmptyVarList() {
   }
   jsvSetNextSibling(lastEmpty, 0);
   jsVarFirstEmpty = jsvGetNextSibling(&firstVar);
+  isMemoryBusy = false;
 }
 
 /* Removes the empty variable counter, cleaving clear runs of 0s
  where no data resides. This helps if compressing the variables
  for storage. */
 void jsvClearEmptyVarList() {
+  assert(!isMemoryBusy);
+  isMemoryBusy = true;
   jsVarFirstEmpty = 0;
   JsVarRef i;
   for (i=1;i<=jsVarsSize;i++) {
@@ -197,6 +203,7 @@ void jsvClearEmptyVarList() {
       i = (JsVarRef)(i+jsvGetFlatStringBlocks(var));
     }
   }
+  isMemoryBusy = false;
 }
 
 void jsvSoftInit() {
@@ -281,6 +288,8 @@ unsigned int jsvGetMemoryTotal() {
 /// Try and allocate more memory - only works if RESIZABLE_JSVARS is defined
 void jsvSetMemoryTotal(unsigned int jsNewVarCount) {
 #ifdef RESIZABLE_JSVARS
+  assert(!isMemoryBusy);
+  isMemoryBusy = true;
   if (jsNewVarCount <= jsVarsSize) return; // never allow us to have less!
   // When resizing, we just allocate a bunch more
   unsigned int oldSize = jsVarsSize;
@@ -298,6 +307,7 @@ void jsvSetMemoryTotal(unsigned int jsNewVarCount) {
   assert(!jsVarFirstEmpty);
   jsVarFirstEmpty = jsvInitJsVars(oldSize+1, jsVarsSize-oldSize);
   // jsiConsolePrintf("Resized memory from %d blocks to %d\n", oldBlockCount, newBlockCount);
+  isMemoryBusy = false;
 #else
   NOT_USED(jsNewVarCount);
   assert(0);
@@ -367,24 +377,40 @@ void jsvResetVariable(JsVar *v, JsVarFlags flags) {
 }
 
 JsVar *jsvNewWithFlags(JsVarFlags flags) {
+  if (isMemoryBusy) {
+    jsErrorFlags |= JSERR_MEMORY_BUSY;
+    return 0;
+  }
   if (jsVarFirstEmpty!=0) {
-    assert(jsvGetAddressOf(jsVarFirstEmpty)->flags == JSV_UNUSED);
     jshInterruptOff(); // to allow this to be used from an IRQ
     JsVar *v = jsvGetAddressOf(jsVarFirstEmpty); // jsvResetVariable will lock
-    jsVarFirstEmpty = jsvGetNextSibling(v); // move our reference to the next in the free list
+    jsVarFirstEmpty = jsvGetNextSibling(v); // move our reference to the next in the fr
     jshInterruptOn();
+    assert(v->flags == JSV_UNUSED);
+    // Cope with IRQs/multi-threading when getting a new free variable
+ /*   JsVarRef empty;
+    JsVarRef next;
+    JsVar *v;
+    do {
+      empty = jsVarFirstEmpty;
+      v = jsvGetAddressOf(empty); // jsvResetVariable will lock
+      next = jsvGetNextSibling(v); // move our reference to the next in the free list
+    } while (!__sync_bool_compare_and_swap(&jsVarFirstEmpty, empty, next));
+    assert(v->flags == JSV_UNUSED);*/
     jsvResetVariable(v, flags); // setup variable, and add one lock
     // return pointer
     return v;
   }
   jsErrorFlags |= JSERR_LOW_MEMORY;
   /* we don't have memory - second last hope - run garbage collector */
-  if (jsvGarbageCollect())
+  if (jsvGarbageCollect()) {
     return jsvNewWithFlags(flags); // if it freed something, continue
+  }
   /* we don't have memory - last hope - ask jsInteractive to try and free some it
    may have kicking around */
-  if (jsiFreeMoreMemory())
+  if (jsiFreeMoreMemory()) {
     return jsvNewWithFlags(flags);
+  }
   /* We couldn't claim any more memory by Garbage collecting... */
 #ifdef RESIZABLE_JSVARS
   jsvSetMemoryTotal(jsVarsSize*2);
@@ -628,6 +654,11 @@ JsVarRef jsvUnRefRef(JsVarRef ref) {
 }
 
 JsVar *jsvNewFlatStringOfLength(unsigned int byteLength) {
+  if (isMemoryBusy) {
+    jsErrorFlags |= JSERR_MEMORY_BUSY;
+    return 0;
+  }
+  isMemoryBusy = true;
   // Work out how many blocks we need. One for the header, plus some for the characters
   size_t blocks = 1 + ((byteLength+sizeof(JsVar)-1) / sizeof(JsVar));
   // Now try and find them
@@ -695,18 +726,15 @@ JsVar *jsvNewFlatStringOfLength(unsigned int byteLength) {
   }
   jsvSetNextSibling(lastEmpty, 0);
   jsVarFirstEmpty = jsvGetNextSibling(&firstVar);
-
+  isMemoryBusy = false;
   // Return whatever we had (0 if we couldn't manage it)
   return flatString;
 }
 
 JsVar *jsvNewFromString(const char *str) {
   // Create a var
   JsVar *first = jsvNewWithFlags(JSV_STRING_0);
-  if (!first) {
-    jsWarn("Unable to create string as not enough memory");
-    return 0;
-  }
+  if (!first) return 0; // out of memory
   // Now we copy the string, but keep creating new jsVars if we go
   // over the end
   JsVar *var = jsvLockAgain(first);
@@ -725,7 +753,7 @@ JsVar *jsvNewFromString(const char *str) {
     if (*str) {
       JsVar *next = jsvNewWithFlags(JSV_STRING_EXT_0);
       if (!next) {
-        jsWarn("Truncating string as not enough memory");
+        // Truncating string as not enough memory
         jsvUnLock(var);
         return first;
       }
@@ -3123,6 +3151,8 @@ static void jsvGarbageCollectMarkUsed(JsVar *var) {
 
 /** Run a garbage collection sweep - return true if things have been freed */
 bool jsvGarbageCollect() {
+  if (isMemoryBusy) return false;
+  isMemoryBusy = true;
   JsVarRef i;
   // clear garbage collect flags
   for (i=1;i<=jsVarsSize;i++)  {
@@ -3224,7 +3254,7 @@ bool jsvGarbageCollect() {
    * our fake 'firstVar' variable */
   jsvSetNextSibling(lastEmpty, 0);
   jsVarFirstEmpty = jsvGetNextSibling(&firstVar);
-
+  isMemoryBusy = false;
   return freedSomething;
 }
 

src/jsvar.h

@@ -202,7 +202,7 @@ typedef struct {
   JsVarData varData;
 
   /** the flags determine the type of the variable - int/double/string/etc. */
-  JsVarFlags flags;
+  volatile JsVarFlags flags;
 } PACKED_FLAGS __attribute__((aligned(4))) JsVar;
 
 /* We have a few different types:

src/jswrap_espruino.c

@@ -610,6 +610,7 @@ JsVar *jswrap_espruino_getErrorFlags() {
   if (jsErrorFlags&JSERR_CALLBACK) jsvArrayPushAndUnLock(arr, jsvNewFromString("CALLBACK"));
   if (jsErrorFlags&JSERR_LOW_MEMORY) jsvArrayPushAndUnLock(arr, jsvNewFromString("LOW_MEMORY"));
   if (jsErrorFlags&JSERR_MEMORY) jsvArrayPushAndUnLock(arr, jsvNewFromString("MEMORY"));
+  if (jsErrorFlags&JSERR_MEMORY_BUSY) jsvArrayPushAndUnLock(arr, jsvNewFromString("JSERR_MEMORY_BUSY"));
   jsErrorFlags = JSERR_NONE;
   return arr;
 }