Rework flash flush so it preserves the cache

tannewt · tannewt · commit ceb6f2e4fc7e · 2019-04-03T18:28:27.000-07:00
This should make filesystem writes quicker and cause less heap
churn.
diff --git a/ports/atmel-samd/supervisor/internal_flash.c b/ports/atmel-samd/supervisor/internal_flash.c
@@ -76,6 +76,9 @@ uint32_t supervisor_flash_get_block_count(void) {
 void supervisor_flash_flush(void) {
 }
 
+void supervisor_flash_release_cache(void) {
+}
+
 void flash_flush(void) {
     supervisor_flash_flush();
 }
diff --git a/ports/nrf/supervisor/internal_flash.c b/ports/nrf/supervisor/internal_flash.c
@@ -137,6 +137,9 @@ void supervisor_flash_flush(void) {
     _flash_page_addr = NO_CACHE;
 }
 
+void supervisor_flash_release_cache(void) {
+}
+
 mp_uint_t supervisor_flash_read_blocks(uint8_t *dest, uint32_t block, uint32_t num_blocks) {
     // Must write out anything in cache before trying to read.
     supervisor_flash_flush();
diff --git a/supervisor/flash.h b/supervisor/flash.h
@@ -40,7 +40,6 @@
 void supervisor_flash_init(void);
 uint32_t supervisor_flash_get_block_size(void);
 uint32_t supervisor_flash_get_block_count(void);
-void supervisor_flash_flush(void);
 
 // these return 0 on success, non-zero on error
 mp_uint_t supervisor_flash_read_blocks(uint8_t *dest, uint32_t block_num, uint32_t num_blocks);
@@ -49,5 +48,6 @@ mp_uint_t supervisor_flash_write_blocks(const uint8_t *src, uint32_t block_num,
 struct _fs_user_mount_t;
 void supervisor_flash_init_vfs(struct _fs_user_mount_t *vfs);
 void supervisor_flash_flush(void);
+void supervisor_flash_release_cache(void);
 
 #endif  // MICROPY_INCLUDED_SUPERVISOR_FLASH_H
diff --git a/supervisor/shared/external_flash/external_flash.c b/supervisor/shared/external_flash/external_flash.c
@@ -272,6 +272,9 @@ uint32_t supervisor_flash_get_block_count(void) {
 // Flush the cache that was written to the scratch portion of flash. Only used
 // when ram is tight.
 static bool flush_scratch_flash(void) {
+    if (current_sector == NO_SECTOR_LOADED) {
+        return true;
+    }
     // First, copy out any blocks that we haven't touched from the sector we've
     // cached.
     bool copy_to_scratch_ok = true;
@@ -360,9 +363,25 @@ static bool allocate_ram_cache(void) {
     return success;
 }
 
+static void release_ram_cache(void) {
+    if (supervisor_cache != NULL) {
+        free_memory(supervisor_cache);
+        supervisor_cache = NULL;
+    } else {
+        m_free(MP_STATE_VM(flash_ram_cache));
+    }
+    MP_STATE_VM(flash_ram_cache) = NULL;
+}
+
 // Flush the cached sector from ram onto the flash. We'll free the cache unless
 // keep_cache is true.
 static bool flush_ram_cache(bool keep_cache) {
+    if (current_sector == NO_SECTOR_LOADED) {
+        if (!keep_cache) {
+            release_ram_cache();
+        }
+        return true;
+    }
     // First, copy out any blocks that we haven't touched from the sector
     // we've cached. If we don't do this we'll erase the data during the sector
     // erase below.
@@ -403,22 +422,13 @@ static bool flush_ram_cache(bool keep_cache) {
     }
     // We're done with the cache for now so give it back.
     if (!keep_cache) {
-        if (supervisor_cache != NULL) {
-            free_memory(supervisor_cache);
-            supervisor_cache = NULL;
-        } else {
-            m_free(MP_STATE_VM(flash_ram_cache));
-        }
-        MP_STATE_VM(flash_ram_cache) = NULL;
+        release_ram_cache();
     }
     return true;
 }
 
 // Delegates to the correct flash flush method depending on the existing cache.
 static void spi_flash_flush_keep_cache(bool keep_cache) {
-    if (current_sector == NO_SECTOR_LOADED) {
-        return;
-    }
     #ifdef MICROPY_HW_LED_MSC
         port_pin_set_output_level(MICROPY_HW_LED_MSC, true);
     #endif
@@ -436,9 +446,11 @@ static void spi_flash_flush_keep_cache(bool keep_cache) {
     #endif
 }
 
-// External flash function used. If called externally we assume we won't need
-// the cache after.
 void supervisor_flash_flush(void) {
+    spi_flash_flush_keep_cache(true);
+}
+
+void supervisor_flash_release_cache(void) {
     spi_flash_flush_keep_cache(false);
 }
 
@@ -502,7 +514,7 @@ bool external_flash_write_block(const uint8_t *data, uint32_t block) {
             return write_flash(address, data, FILESYSTEM_BLOCK_SIZE);
         }
         if (current_sector != NO_SECTOR_LOADED) {
-            spi_flash_flush_keep_cache(true);
+            supervisor_flash_flush();
         }
         if (MP_STATE_VM(flash_ram_cache) == NULL && !allocate_ram_cache()) {
             erase_sector(flash_device->total_size - SPI_FLASH_ERASE_SIZE);
diff --git a/supervisor/shared/filesystem.c b/supervisor/shared/filesystem.c
@@ -42,7 +42,9 @@ volatile bool filesystem_flush_requested = false;
 
 void filesystem_background(void) {
     if (filesystem_flush_requested) {
-        filesystem_flush();
+        filesystem_flush_interval_ms = CIRCUITPY_FILESYSTEM_FLUSH_INTERVAL_MS;
+        // Flush but keep caches
+        supervisor_flash_flush();
         filesystem_flush_requested = false;
     }
 }
@@ -118,6 +120,8 @@ void filesystem_flush(void) {
     // Reset interval before next flush.
     filesystem_flush_interval_ms = CIRCUITPY_FILESYSTEM_FLUSH_INTERVAL_MS;
     supervisor_flash_flush();
+    // Don't keep caches because this is called when starting or stopping the VM.
+    supervisor_flash_release_cache();
 }
 
 void filesystem_set_internal_writable_by_usb(bool writable) {

Original file line number	Diff line number	Diff line change
`@@ -76,6 +76,9 @@ uint32_t supervisor_flash_get_block_count(void) {`
`76`	`76`	`void supervisor_flash_flush(void) {`
`77`	`77`	`}`
`78`	`78`
	`79`	`+void supervisor_flash_release_cache(void) {`
	`80`	`+}`
	`81`	`+`
`79`	`82`	`void flash_flush(void) {`
`80`	`83`	`supervisor_flash_flush();`
`81`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -137,6 +137,9 @@ void supervisor_flash_flush(void) {`
`137`	`137`	`_flash_page_addr = NO_CACHE;`
`138`	`138`	`}`
`139`	`139`
	`140`	`+void supervisor_flash_release_cache(void) {`
	`141`	`+}`
	`142`	`+`
`140`	`143`	`mp_uint_t supervisor_flash_read_blocks(uint8_t *dest, uint32_t block, uint32_t num_blocks) {`
`141`	`144`	`// Must write out anything in cache before trying to read.`
`142`	`145`	`supervisor_flash_flush();`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,9 @@ volatile bool filesystem_flush_requested = false;`
`42`	`42`
`43`	`43`	`void filesystem_background(void) {`
`44`	`44`	`if (filesystem_flush_requested) {`
`45`		`- filesystem_flush();`
	`45`	`+ filesystem_flush_interval_ms = CIRCUITPY_FILESYSTEM_FLUSH_INTERVAL_MS;`
	`46`	`+ // Flush but keep caches`
	`47`	`+ supervisor_flash_flush();`
`46`	`48`	`filesystem_flush_requested = false;`
`47`	`49`	`}`
`48`	`50`	`}`
`@@ -118,6 +120,8 @@ void filesystem_flush(void) {`
`118`	`120`	`// Reset interval before next flush.`
`119`	`121`	`filesystem_flush_interval_ms = CIRCUITPY_FILESYSTEM_FLUSH_INTERVAL_MS;`
`120`	`122`	`supervisor_flash_flush();`
	`123`	`+ // Don't keep caches because this is called when starting or stopping the VM.`
	`124`	`+ supervisor_flash_release_cache();`
`121`	`125`	`}`
`122`	`126`
`123`	`127`	`void filesystem_set_internal_writable_by_usb(bool writable) {`