improved eeprom costs

src/components/eeprom.c

@@ -4,6 +4,24 @@ nn_eepromControl nn_eeprom_getControl(nn_component *component, nn_eeprom *eeprom
     return eeprom->control(component, eeprom->userdata);
 }
 
+static void nn_eeprom_readCost(nn_component *component, size_t bytesRead) {
+    nn_eepromControl control = nn_eeprom_getControl(component, nn_getComponentUserdata(component));
+    nn_computer *computer = nn_getComputerOfComponent(component);
+
+    nn_removeEnergy(computer, control.readEnergyCostPerByte * bytesRead);
+    nn_addHeat(computer, control.readHeatPerByte * bytesRead);
+    nn_simulateBufferedIndirect(component, bytesRead, control.bytesReadPerTick);
+}
+
+static void nn_eeprom_writeCost(nn_component *component, size_t bytesWritten) {
+    nn_eepromControl control = nn_eeprom_getControl(component, nn_getComponentUserdata(component));
+    nn_computer *computer = nn_getComputerOfComponent(component);
+
+    nn_removeEnergy(computer, control.writeEnergyCostPerByte * bytesWritten);
+    nn_addHeat(computer, control.writeHeatPerByte * bytesWritten);
+    nn_simulateBufferedIndirect(component, bytesWritten, control.bytesWrittenPerTick);
+}
+
 void nn_eeprom_destroy(void *_, nn_component *component, nn_eeprom *eeprom) {
     if(!nn_decRef(&eeprom->refc)) return;
 
@@ -14,24 +32,10 @@ void nn_eeprom_destroy(void *_, nn_component *component, nn_eeprom *eeprom) {
 
 void nn_eeprom_getSize(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
     nn_return(computer, nn_values_integer(eeprom->getSize(component, eeprom->userdata)));
-
-    // Latency, energy costs and stuff
-    nn_eepromControl control = nn_eeprom_getControl(component, eeprom);
-    nn_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
-    nn_busySleep(control.readLatency);
-    nn_removeEnergy(computer, control.readEnergyCost);
-    nn_callCost(computer, control.readCost);
 }
 
 void nn_eeprom_getDataSize(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
     nn_return(computer, nn_values_integer(eeprom->getDataSize(component, eeprom->userdata)));
-    
-    // Latency, energy costs and stuff
-    nn_eepromControl control = nn_eeprom_getControl(component, eeprom);
-    nn_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
-    nn_busySleep(control.readLatency);
-    nn_removeEnergy(computer, control.readEnergyCost);
-    nn_callCost(computer, control.readCost);
 }
 
 void nn_eeprom_getLabel(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
@@ -45,11 +49,7 @@ void nn_eeprom_getLabel(nn_eeprom *eeprom, void *_, nn_component *component, nn_
     }
     
     // Latency, energy costs and stuff
-    nn_eepromControl control = nn_eeprom_getControl(component, eeprom);
+    nn_eeprom_readCost(component, l);
-    nn_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
-    nn_busySleep(control.readLatency);
-    nn_removeEnergy(computer, control.readEnergyCost);
-    nn_callCost(computer, control.readCost);
 }
 
 void nn_eeprom_setLabel(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
@@ -64,12 +64,7 @@ void nn_eeprom_setLabel(nn_eeprom *eeprom, void *_, nn_component *component, nn_
     nn_return_string(computer, buf, l);
     
     // Latency, energy costs and stuff
-    nn_eepromControl control = nn_eeprom_getControl(component, eeprom);
+    nn_eeprom_writeCost(component, l);
-    nn_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
-    nn_busySleep(control.writeLatency);
-    nn_removeEnergy(computer, control.writeEnergyCost);
-    nn_addHeat(computer, control.writeHeatCost);
-    nn_callCost(computer, control.writeCost);
 }
 
 void nn_eeprom_get(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
@@ -83,12 +78,8 @@ void nn_eeprom_get(nn_eeprom *eeprom, void *_, nn_component *component, nn_compu
     size_t len = eeprom->get(component, eeprom->userdata, buf);
     nn_return_string(computer, buf, len);
     nn_dealloc(alloc, buf, cap);
-    
+
-    nn_eepromControl control = nn_eeprom_getControl(component, eeprom);
+    nn_eeprom_readCost(component, len);
-    nn_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
-    nn_busySleep(control.readLatency);
-    nn_removeEnergy(computer, control.readEnergyCost);
-    nn_callCost(computer, control.readCost);
 }
 
 void nn_eeprom_set(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
@@ -110,12 +101,7 @@ void nn_eeprom_set(nn_eeprom *eeprom, void *_, nn_component *component, nn_compu
     }
     eeprom->set(component, eeprom->userdata, buf, len);
     
-    nn_eepromControl control = nn_eeprom_getControl(component, eeprom);
+    nn_eeprom_writeCost(component, len);
-    nn_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
-    nn_busySleep(control.writeLatency);
-    nn_removeEnergy(computer, control.writeEnergyCost);
-    nn_addHeat(computer, control.writeHeatCost);
-    nn_callCost(computer, control.writeCost);
 }
 
 void nn_eeprom_getData(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
@@ -134,11 +120,7 @@ void nn_eeprom_getData(nn_eeprom *eeprom, void *_, nn_component *component, nn_c
     }
     nn_dealloc(alloc, buf, cap);
     
-    nn_eepromControl control = nn_eeprom_getControl(component, eeprom);
+    nn_eeprom_readCost(component, len);
-    nn_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
-    nn_busySleep(control.readLatency);
-    nn_removeEnergy(computer, control.readEnergyCost);
-    nn_callCost(computer, control.readCost);
 }
 
 void nn_eeprom_setData(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
@@ -159,22 +141,16 @@ void nn_eeprom_setData(nn_eeprom *eeprom, void *_, nn_component *component, nn_c
         return;
     }
     eeprom->setData(component, eeprom->userdata, buf, len);
+
+    nn_eeprom_writeCost(component, len);
 }
 
 void nn_eeprom_isReadOnly(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
     nn_return(computer, nn_values_boolean(eeprom->isReadonly(component, eeprom->userdata)));
-    
-    nn_eepromControl control = nn_eeprom_getControl(component, eeprom);
-    nn_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
-    nn_removeEnergy(computer, control.readEnergyCost);
 }
 
 void nn_eeprom_makeReadonly(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
     eeprom->makeReadonly(component, eeprom->userdata);
-    
-    nn_eepromControl control = nn_eeprom_getControl(component, eeprom);
-    nn_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
-    nn_removeEnergy(computer, control.writeEnergyCost);
 }
 
 // TODO: make good
@@ -195,11 +171,7 @@ void nn_eeprom_getChecksum(nn_eeprom *eeprom, void *_, nn_component *component,
 
     nn_return_string(computer, (void *)&sum, sizeof(sum));
     
-    nn_eepromControl control = nn_eeprom_getControl(component, eeprom);
+    nn_eeprom_readCost(component, len);
-    nn_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
-    nn_busySleep(control.readLatency);
-    nn_removeEnergy(computer, control.readEnergyCost);
-    nn_callCost(computer, control.readCost);
 }
 
 void nn_loadEepromTable(nn_universe *universe) {
@@ -208,16 +180,16 @@ void nn_loadEepromTable(nn_universe *universe) {
 
     nn_defineMethod(eepromTable, "getSize", true, (void *)nn_eeprom_getSize, NULL, "getSize(): integer - Returns the maximum code capacity of the EEPROM.");
     nn_defineMethod(eepromTable, "getDataSize", true, (void *)nn_eeprom_getDataSize, NULL, "getDataSize(): integer - Returns the maximum data capacity of the EEPROM.");
-    nn_defineMethod(eepromTable, "getLabel", false, (void *)nn_eeprom_getLabel, NULL, "getLabel(): string - Returns the current label.");
+    nn_defineMethod(eepromTable, "getLabel", true, (void *)nn_eeprom_getLabel, NULL, "getLabel(): string - Returns the current label.");
-    nn_defineMethod(eepromTable, "setLabel", false, (void *)nn_eeprom_setLabel, NULL, "setLabel(label: string): string - Sets the new label. Returns the actual label set to, which may be truncated.");
+    nn_defineMethod(eepromTable, "setLabel", true, (void *)nn_eeprom_setLabel, NULL, "setLabel(label: string): string - Sets the new label. Returns the actual label set to, which may be truncated.");
-    nn_defineMethod(eepromTable, "get", false, (void *)nn_eeprom_get, NULL, "get(): string - Reads the current code contents.");
+    nn_defineMethod(eepromTable, "get", true, (void *)nn_eeprom_get, NULL, "get(): string - Reads the current code contents.");
-    nn_defineMethod(eepromTable, "set", false, (void *)nn_eeprom_set, NULL, "set(data: string) - Sets the current code contents.");
+    nn_defineMethod(eepromTable, "set", true, (void *)nn_eeprom_set, NULL, "set(data: string) - Sets the current code contents.");
-    nn_defineMethod(eepromTable, "getData", false, (void *)nn_eeprom_getData, NULL, "getData(): string - Reads the current data contents.");
+    nn_defineMethod(eepromTable, "getData", true, (void *)nn_eeprom_getData, NULL, "getData(): string - Reads the current data contents.");
-    nn_defineMethod(eepromTable, "setData", false, (void *)nn_eeprom_setData, NULL, "setData(data: string) - Sets the current data contents.");
+    nn_defineMethod(eepromTable, "setData", true, (void *)nn_eeprom_setData, NULL, "setData(data: string) - Sets the current data contents.");
-    nn_defineMethod(eepromTable, "isReadOnly", false, (void *)nn_eeprom_isReadOnly, NULL, "isReadOnly(): boolean - Returns whether this EEPROM is read-only.");
+    nn_defineMethod(eepromTable, "isReadOnly", true, (void *)nn_eeprom_isReadOnly, NULL, "isReadOnly(): boolean - Returns whether this EEPROM is read-only.");
     nn_defineMethod(eepromTable, "makeReadOnly", false, (void *)nn_eeprom_makeReadonly, NULL, "makeReadOnly() - Makes the current EEPROM read-only. Normally, this cannot be undone.");
     nn_defineMethod(eepromTable, "makeReadonly", false, (void *)nn_eeprom_makeReadonly, NULL, "makeReadonly() - Legacy alias to makeReadOnly()");
-    nn_defineMethod(eepromTable, "getChecksum", false, (void *)nn_eeprom_getChecksum, NULL, "getChecksum(): string - Returns a checksum of the data on the EEPROM.");
+    nn_defineMethod(eepromTable, "getChecksum", true, (void *)nn_eeprom_getChecksum, NULL, "getChecksum(): string - Returns a checksum of the data on the EEPROM.");
 }
 
 nn_component *nn_addEeprom(nn_computer *computer, nn_address address, int slot, nn_eeprom *eeprom) {

src/components/filesystem.c

@@ -34,16 +34,12 @@ size_t nn_fs_countChunks(nn_filesystem *fs, size_t bytes, nn_component *componen
 
 void nn_fs_readCost(nn_filesystem *fs, size_t count, nn_component *component, nn_computer *computer) {
     nn_filesystemControl control = nn_fs_getControl(component, fs);
-    nn_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
-    nn_busySleep(control.readLatencyPerChunk * count);
     nn_removeEnergy(computer, control.readEnergyCost * count);
     nn_callCost(computer, control.readCostPerChunk * count);
 }
 
 void nn_fs_writeCost(nn_filesystem *fs, size_t count, nn_component *component, nn_computer *computer) {
     nn_filesystemControl control = nn_fs_getControl(component, fs);
-    nn_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
-    nn_busySleep(control.writeLatencyPerChunk * count);
     nn_removeEnergy(computer, control.writeEnergyCost * count);
     nn_addHeat(computer, control.writeHeatPerChunk * count);
     nn_callCost(computer, control.writeCostPerChunk * count);
@@ -55,8 +51,6 @@ void nn_fs_seekCost(nn_filesystem *fs, size_t count, nn_component *component, nn
     double rps = (double)control.pretendRPM / 60;
     double seekLatency = 1.0 / ((double)fs->spaceTotal(component, fs->userdata) / control.pretendChunkSize) / rps;
 
-    nn_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
-    nn_busySleep(seekLatency * count);
     nn_removeEnergy(computer, control.writeEnergyCost * count);
     nn_addHeat(computer, control.writeHeatPerChunk * count);
     nn_callCost(computer, control.writeCostPerChunk * count);
@@ -74,8 +68,6 @@ void nn_fs_getLabel(nn_filesystem *fs, void *_, nn_component *component, nn_comp
     
     // Latency, energy costs and stuff
     nn_filesystemControl control = nn_fs_getControl(component, fs);
-    nn_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
-    nn_busySleep(control.readLatencyPerChunk);
     nn_removeEnergy(computer, control.readEnergyCost);
     nn_callCost(computer, control.readCostPerChunk);
 }

src/components/gpu.c

@@ -110,7 +110,6 @@ void nni_gpu_bind(nni_gpu *gpu, void *_, nn_component *component, nn_computer *c
         nn_addHeat(computer, gpu->ctrl.pixelResetHeat * area);
         nn_callCost(computer, gpu->ctrl.pixelResetCost * area);
         nn_removeEnergy(computer, gpu->ctrl.pixelResetEnergy * area);
-        nn_busySleep(gpu->ctrl.pixelResetLatency * area);
     }
 
     gpu->currentScreen = screen;
@@ -122,7 +121,6 @@ void nni_gpu_bind(nni_gpu *gpu, void *_, nn_component *component, nn_computer *c
     nn_addHeat(computer, gpu->ctrl.bindHeat);
     nn_callCost(computer, gpu->ctrl.bindCost);
     nn_removeEnergy(computer, gpu->ctrl.bindEnergy);
-    nn_busySleep(gpu->ctrl.bindLatency);
 
     nn_return(computer, nn_values_boolean(true));
 }
@@ -164,7 +162,8 @@ void nni_gpu_get(nni_gpu *gpu, void *_, nn_component *component, nn_computer *co
     nn_scrchr_t pxl = nn_getPixel(gpu->currentScreen, x, y);
 
     size_t l;
-    const char *chr = nn_unicode_codepointToChar(pxl.codepoint, &l);
+    char chr[NN_MAXIMUM_UNICODE_BUFFER];
+    nn_unicode_codepointToChar(chr, pxl.codepoint, &l);
 
     // TODO: gosh darn palettes
     nn_return(computer, nn_values_cstring(chr));
@@ -247,7 +246,6 @@ void nni_gpu_setBackground(nni_gpu *gpu, void *_, nn_component *component, nn_co
     nn_addHeat(computer, gpu->ctrl.colorChangeHeat);
     nn_callCost(computer, gpu->ctrl.colorChangeCost);
     nn_removeEnergy(computer, gpu->ctrl.colorChangeEnergy);
-    nn_busySleep(gpu->ctrl.colorChangeLatency);
 
     nn_return(computer, nn_values_integer(old));
     if(idx != -1) {
@@ -282,7 +280,6 @@ void nni_gpu_setForeground(nni_gpu *gpu, void *_, nn_component *component, nn_co
     nn_addHeat(computer, gpu->ctrl.colorChangeHeat);
     nn_callCost(computer, gpu->ctrl.colorChangeCost);
     nn_removeEnergy(computer, gpu->ctrl.colorChangeEnergy);
-    nn_busySleep(gpu->ctrl.colorChangeLatency);
 
     nn_return(computer, nn_values_integer(old));
     if(idx != -1) {
@@ -337,12 +334,10 @@ void nni_gpu_fill(nni_gpu *gpu, void *_, nn_component *component, nn_computer *c
     nn_addHeat(computer, gpu->ctrl.pixelChangeHeat * changes);
     nn_callCost(computer, gpu->ctrl.pixelChangeCost * changes);
     nn_removeEnergy(computer, gpu->ctrl.pixelChangeEnergy * changes);
-    nn_busySleep(gpu->ctrl.pixelChangeLatency * changes);
     
     nn_addHeat(computer, gpu->ctrl.pixelChangeHeat * clears);
     nn_callCost(computer, gpu->ctrl.pixelChangeCost * clears);
     nn_removeEnergy(computer, gpu->ctrl.pixelChangeEnergy * clears);
-    nn_busySleep(gpu->ctrl.pixelChangeLatency * clears);
 
     nn_return(computer, nn_values_boolean(true));
 }
@@ -397,12 +392,10 @@ void nni_gpu_copy(nni_gpu *gpu, void *_, nn_component *component, nn_computer *c
     nn_addHeat(computer, gpu->ctrl.pixelChangeHeat * changes);
     nn_callCost(computer, gpu->ctrl.pixelChangeCost * changes);
     nn_removeEnergy(computer, gpu->ctrl.pixelChangeEnergy * changes);
-    nn_busySleep(gpu->ctrl.pixelChangeLatency * changes);
     
     nn_addHeat(computer, gpu->ctrl.pixelChangeHeat * clears);
     nn_callCost(computer, gpu->ctrl.pixelChangeCost * clears);
     nn_removeEnergy(computer, gpu->ctrl.pixelChangeEnergy * clears);
-    nn_busySleep(gpu->ctrl.pixelChangeLatency * clears);
 
     nn_return(computer, nn_values_boolean(true));
 }

src/emulator.c

@@ -15,15 +15,12 @@ Color ne_processColor(unsigned int color) {
 
 nn_eepromControl ne_eeprom_getControl(nn_component *component, void *_) {
     return (nn_eepromControl) {
-        .randomLatencyMin = 0.001,
+        .readHeatPerByte = 0.0015,
-        .randomLatencyMax = 0.012,
+        .writeHeatPerByte = 0.03,
-        .readLatency = 0.03,
+        .readEnergyCostPerByte = 0.001,
-        .writeLatency = 0.05,
+        .writeEnergyCostPerByte = 0.05,
-        .readCost = 3,
+        .bytesReadPerTick = 32768,
-        .writeCost = 5,
+        .bytesWrittenPerTick = 4096,
-        .readEnergyCost = 1,
-        .writeEnergyCost = 5,
-        .writeHeatCost = 0.2,
     };
 }
     

src/lock.c

@@ -29,7 +29,7 @@ void nn_deleteGuard(nn_Alloc *alloc, nn_guard *guard) {
 }
 
 void nn_addRef(nn_refc *refc, size_t count) {
-    atomic_fetch_add(refc, count);
+    (*refc) += count;
 }
 
 void nn_incRef(nn_refc *refc) {
@@ -37,8 +37,8 @@ void nn_incRef(nn_refc *refc) {
 }
 
 bool nn_removeRef(nn_refc *refc, size_t count) {
-    size_t old = atomic_fetch_sub(refc, count);
+    (*refc) -= count;
-    return old == count;
+    return *refc == 0;
 }
 
 bool nn_decRef(nn_refc *refc) {

src/neonucleus.h

@@ -4,7 +4,6 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <stdbool.h>
-#include <stdatomic.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -70,8 +69,14 @@ extern "C" {
 #define NN_CALL_COST 1
 #define NN_LABEL_SIZE 128
 
+#define NN_MAXIMUM_UNICODE_BUFFER 4
+
 typedef struct nn_guard nn_guard;
+#ifdef __STDC_NO_ATOMICS__
 typedef atomic_size_t nn_refc;
+#else
+typedef _Atomic(size_t) nn_refc;
+#endif
 typedef struct nn_universe nn_universe;
 typedef struct nn_computer nn_computer;
 typedef struct nn_component nn_component;
@@ -186,7 +191,7 @@ unsigned int *nn_unicode_codepoints(nn_Alloc *alloc, const char *s, size_t *len)
 size_t nn_unicode_len(const char *s);
 unsigned int nn_unicode_codepointAt(const char *s, size_t byteOffset);
 size_t nn_unicode_codepointSize(unsigned int codepoint);
-const char *nn_unicode_codepointToChar(unsigned int codepoint, size_t *len);
+void nn_unicode_codepointToChar(char buffer[NN_MAXIMUM_UNICODE_BUFFER], unsigned int codepoint, size_t *len);
 size_t nn_unicode_charWidth(unsigned int codepoint);
 size_t nn_unicode_wlen(const char *s);
 unsigned int nn_unicode_upperCodepoint(unsigned int codepoint);
@@ -198,10 +203,6 @@ char *nn_unicode_lower(nn_Alloc *alloc, const char *s);
 
 double nn_realTime();
 double nn_realTimeClock(void *_);
-/* Will busy-loop until the time passes. This is meant for computed latencies in components. */
-void nn_busySleep(double t);
-// calls nn_busySleep with a random latency
-void nn_randomLatency(double min, double max);
 
 typedef double nn_clock_t(void *_);
 
@@ -419,20 +420,14 @@ nn_component *nn_mountKeyboard(nn_computer *computer, nn_address address, int sl
 
 // EEPROM
 typedef struct nn_eepromControl {
-    double readLatency;
+    double readHeatPerByte;
-    double writeLatency;
+    double writeHeatPerByte;
 
-    double readEnergyCost;
+    double readEnergyCostPerByte;
-    double writeEnergyCost;
+    double writeEnergyCostPerByte;
 
-    double writeHeatCost;
+    double bytesReadPerTick;
-
+    double bytesWrittenPerTick;
-    double randomLatencyMin;
-    double randomLatencyMax;
-
-    // Call costs
-    size_t readCost;
-    size_t writeCost;
 } nn_eepromControl;
 
 typedef struct nn_eeprom {

src/unicode.c

@@ -219,7 +219,8 @@ char *nn_unicode_char(nn_Alloc *alloc, unsigned int *codepoints, size_t codepoin
     for (size_t i = 0; i < codepointCount; i++) {
         int codepoint = codepoints[i];
         size_t codepointLen = 0;
-        const char *c = nn_unicode_codepointToChar(codepoint, &codepointLen);
+        char c[NN_MAXIMUM_UNICODE_BUFFER];
+        nn_unicode_codepointToChar(c, codepoint, &codepointLen);
         memcpy(buf + j, c, codepointLen);
         j += codepointLen;
     }
@@ -302,11 +303,10 @@ size_t nn_unicode_codepointSize(unsigned int codepoint) {
     return 1;
 }
 
-const char *nn_unicode_codepointToChar(unsigned int codepoint, size_t *len) {
+void nn_unicode_codepointToChar(char *buffer, unsigned int codepoint, size_t *len) {
     size_t codepointSize = nn_unicode_codepointSize(codepoint);
     *len = codepointSize;
 
-    static char buffer[4];
     memset(buffer, 0, 4); // Clear static array
 
     if (codepointSize == 1) {
@@ -324,8 +324,6 @@ const char *nn_unicode_codepointToChar(unsigned int codepoint, size_t *len) {
         buffer[2] = 0b10000000 + ((codepoint >> 6) & 0b111111);
         buffer[3] = 0b10000000 + (codepoint & 0b111111);
     }
-
-    return buffer;
 }
 
 // copied straight from opencomputers and musl's libc

src/utils.c

@@ -3,12 +3,16 @@
 #include <stdlib.h>
 #include <string.h>
 
+#ifndef NN_BAREMETAL
+
 #ifdef NN_POSIX
 #include <time.h>
 #else
 #include <windows.h>
 #endif
 
+#endif
+
 void *nn_alloc(nn_Alloc *alloc, size_t size) {
     if(size == 0) return alloc->proc;
     return alloc->proc(alloc->userdata, NULL, 0, size, NULL);
@@ -74,6 +78,14 @@ void nn_deallocStr(nn_Alloc *alloc, char *s) {
     nn_dealloc(alloc, s, strlen(s)+1);
 }
 
+#ifdef NN_BAREMETAL
+
+double nn_realTime() {
+    return 0;
+}
+
+#else
+
 #ifdef NN_POSIX
 
 double nn_realTime() {
@@ -96,19 +108,9 @@ double nn_realTime() {
 
 #endif
 
+#endif
+
 double nn_realTimeClock(void *_) {
     return nn_realTime();
 }
 
-void nn_busySleep(double t) {
-    return; // fuck sleep
-    double deadline = nn_realTime() + t;
-    while(nn_realTime() < deadline) {}
-}
-
-void nn_randomLatency(double min, double max) {
-    double t = (double)rand() / RAND_MAX;
-    double latency = min + t * (max - min);
-    nn_busySleep(latency);
-}
-