Rename fletch -> dartino

platforms/stm/disco_dartino/src/cmpctmalloc.c

 // Copyright (c) 2016, the Dartino project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE.md file.
 
 // This code is ported from the LK repository. To keep the code in
-// sync the define FLETCH_TARGET_OS_LK provides the code from the LK
-// repository. Without the define FLETCH_TARGET_OS_LK this code will
-// build and link for the disco_fletch project.
-#ifdef FLETCH_TARGET_OS_LK
+// sync the define DARTINO_TARGET_OS_LK provides the code from the LK
+// repository. Without the define DARTINO_TARGET_OS_LK this code will
+// build and link for the disco_dartino project.
+#ifdef DARTINO_TARGET_OS_LK
 
 #include <debug.h>
 #include <trace.h>
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <kernel/thread.h>
 #include <kernel/mutex.h>
 #include <kernel/spinlock.h>
 #include <lib/cmpctmalloc.h>
 #include <lib/heap.h>
 #include <lib/page_alloc.h>
 
-#else  // FLETCH_TARGET_OS_LK
+#else  // DARTINO_TARGET_OS_LK
 
-#include "platforms/stm/disco_fletch/src/cmpctmalloc.h"
+#include "platforms/stm/disco_dartino/src/cmpctmalloc.h"
 
 #include <inttypes.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
-#include "platforms/stm/disco_fletch/src/globals.h"
+#include "platforms/stm/disco_dartino/src/globals.h"
 
 void* page_alloc(size_t pages);
 void page_free(void* start, size_t pages);
 
 typedef uintptr_t addr_t;
 typedef uintptr_t vaddr_t;
 
 #define LTRACEF(...)
 #define LTRACE_ENTRY
 #define DEBUG_ASSERT ASSERT
 #define ASSERT(condition)        \
   while (false && (condition)) { \
   }
 #define STATIC_ASSERT(condition)
 #define dprintf(...) fprintf(__VA_ARGS__)
 #define INFO stdout
 
-#endif  // FLETCH_TARGET_OS_LK
+#endif  // DARTINO_TARGET_OS_LK
 
 // Malloc implementation tuned for space.
 //
 // Allocation strategy takes place with a global mutex.  Freelist entries are
 // kept in linked lists with 8 different sizes per binary order of magnitude
 // and the header size is two words with eager coalescing on free.
 
 #ifdef DEBUG
 #define CMPCT_DEBUG
 #endif
 
-#ifdef FLETCH_TARGET_OS_LK
+#ifdef DARTINO_TARGET_OS_LK
 #define LOCAL_TRACE 0
 #endif
 
 #define ALLOC_FILL 0x99
 #define FREE_FILL 0x77
 #define PADDING_FILL 0x55
 
-#ifdef FLETCH_TARGET_OS_LK
+#ifdef DARTINO_TARGET_OS_LK
 #if WITH_KERNEL_VM && !defined(HEAP_GROW_SIZE)
 #define HEAP_GROW_SIZE (1 * 1024 * 1024) /* Grow aggressively */
 #elif !defined(HEAP_GROW_SIZE)
 #define HEAP_GROW_SIZE (4 * 1024) /* Grow less aggressively */
 #endif
 #else
 #define HEAP_GROW_SIZE (4 * 1024) /* Grow less aggressively */
 #endif
 
 STATIC_ASSERT(IS_PAGE_ALIGNED(HEAP_GROW_SIZE));
@@ skipping 23 matching lines @@
 
 typedef struct free_struct {
     header_t header;
     struct free_struct *next;
     struct free_struct *prev;
 } free_t;
 
 struct heap {
     size_t size;
     size_t remaining;
-#ifdef FLETCH_TARGET_OS_LK
+#ifdef DARTINO_TARGET_OS_LK
     mutex_t lock;
 #endif
     free_t *free_lists[NUMBER_OF_BUCKETS];
     // We have some 32 bit words that tell us whether there is an entry in the
     // freelist.
 #define BUCKET_WORDS (((NUMBER_OF_BUCKETS) + 31) >> 5)
     uint32_t free_list_bits[BUCKET_WORDS];
 };
 
 // Heap static vars.
 static struct heap theheap;
 
 static ssize_t heap_grow(size_t len, free_t **bucket);
 
 static void lock(void)
 {
-#ifdef FLETCH_TARGET_OS_LK
+#ifdef DARTINO_TARGET_OS_LK
     mutex_acquire(&theheap.lock);
 #endif
 }
 
 static void unlock(void)
 {
-#ifdef FLETCH_TARGET_OS_LK
+#ifdef DARTINO_TARGET_OS_LK
     mutex_release(&theheap.lock);
 #endif
 }
 
 static void dump_free(header_t *header)
 {
     dprintf(INFO, "\t\tbase %p, end 0x%lx, len 0x%zx\n", header, (vaddr_t)header + header->size, header->size);
 }
 
 void cmpct_dump(void)
@@ skipping 230 matching lines @@
 
 static void TestTrimFreeHelper(char *block)
 {
     while (block) {
         char *next_block = *(char **)block;
         cmpct_free(block);
         block = next_block;
     }
 }
 
-#ifdef FLETCH_TARGET_OS_LK
+#ifdef DARTINO_TARGET_OS_LK
 static void cmpct_test_trim(void)
 #else
 void cmpct_test_trim(void)
 #endif
 {
     WasteFreeMemory();
 
     size_t test_sizes[200];
     int sizes = 0;
 
@@ skipping 82 matching lines @@
 
             // We should have < 1 page on either side of the big allocation.
             ASSERT(remaining < PAGE_SIZE * 2);
 
             TestTrimFreeHelper(big_bit_in_the_middle);
         }
     }
 }
 
 
-#ifdef FLETCH_TARGET_OS_LK
+#ifdef DARTINO_TARGET_OS_LK
 static void cmpct_test_buckets(void)
 #else
 void cmpct_test_buckets(void)
 #endif
 {
     size_t rounded;
     unsigned bucket;
     // Check for the 8-spaced buckets up to 128.
     for (unsigned i = 1; i <= 128; i++) {
         // Round up when allocating.
@@ skipping 61 matching lines @@
 
     cmpct_free(allocated);
     void *allocated3 = cmpct_alloc(size);
     // To avoid churn and fragmentation we would want to get the newly freed
     // memory back again when we allocate the same size shortly after.
     ASSERT(allocated3 == allocated);
     cmpct_free(allocated2);
     cmpct_free(allocated3);
 }
 
-#ifdef FLETCH_TARGET_OS_LK
+#ifdef DARTINO_TARGET_OS_LK
 static void cmpct_test_get_back_newly_freed(void)
 #else
 void cmpct_test_get_back_newly_freed(void)
 #endif
 {
     size_t increment = 16;
     for (size_t i = 128; i <= 0x8000000; i *= 2, increment *= 2) {
         for (size_t j = i; j < i * 2; j += increment) {
             cmpct_test_get_back_newly_freed_helper(i - 8);
             cmpct_test_get_back_newly_freed_helper(i);
             cmpct_test_get_back_newly_freed_helper(i + 1);
         }
     }
     for (size_t i = 1024; i <= 2048; i++) {
         cmpct_test_get_back_newly_freed_helper(i);
     }
 }
 
-#ifdef FLETCH_TARGET_OS_LK
+#ifdef DARTINO_TARGET_OS_LK
 static void cmpct_test_return_to_os(void)
 #else
 void cmpct_test_return_to_os(void)
 #endif
 {
     cmpct_trim();
     size_t remaining = theheap.remaining;
     // This goes in a new OS allocation since the trim above removed any free
     // area big enough to contain it.
     void *a = cmpct_alloc(5000);
@@ skipping 267 matching lines @@
     LTRACEF("growing heap by 0x%zx bytes, new ptr %p\n", size, ptr);
     add_to_heap(ptr, size, bucket);
     return size;
 }
 
 void cmpct_init(void)
 {
     LTRACE_ENTRY;
 
     // Create a mutex.
-#ifdef FLETCH_TARGET_OS_LK
+#ifdef DARTINO_TARGET_OS_LK
     mutex_init(&theheap.lock);
 #endif
 
     // Initialize the free list.
     for (int i = 0; i < NUMBER_OF_BUCKETS; i++) {
         theheap.free_lists[i] = NULL;
     }
     for (int i = 0; i < BUCKET_WORDS; i++) {
         theheap.free_list_bits[i] = 0;
     }
 
     size_t initial_alloc = HEAP_GROW_SIZE - 2 * sizeof(header_t);
 
     theheap.remaining = 0;
 
     heap_grow(initial_alloc, NULL);
 }