NeoFlock/neonucleus
9
1
Fork 0
Code Issues Packages Projects Releases Wiki Activity

improved eeprom costs

Browse Source
This commit is contained in:
IonutParau
2025-07-04 16:06:05 +02:00
parent 4249f56344
commit d4d84881ef
8 changed files with 76 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
src/components/eeprom.c
View File

@@ -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_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
nn_busySleep(control.readLatency);
nn_removeEnergy(computer, control.readEnergyCost);
nn_callCost(computer, control.readCost);
nn_eeprom_readCost(component, l);
}
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_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
nn_busySleep(control.writeLatency);
nn_removeEnergy(computer, control.writeEnergyCost);
nn_addHeat(computer, control.writeHeatCost);
nn_callCost(computer, control.writeCost);
nn_eeprom_writeCost(component, l);
}
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_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
nn_busySleep(control.readLatency);
nn_removeEnergy(computer, control.readEnergyCost);
nn_callCost(computer, control.readCost);
nn_eeprom_readCost(component, len);
}
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_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
nn_busySleep(control.writeLatency);
nn_removeEnergy(computer, control.writeEnergyCost);
nn_addHeat(computer, control.writeHeatCost);
nn_callCost(computer, control.writeCost);
nn_eeprom_writeCost(component, len);
}
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_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
nn_busySleep(control.readLatency);
nn_removeEnergy(computer, control.readEnergyCost);
nn_callCost(computer, control.readCost);
nn_eeprom_readCost(component, len);
}
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_randomLatency(control.randomLatencyMin, control.randomLatencyMax);
nn_busySleep(control.readLatency);
nn_removeEnergy(computer, control.readEnergyCost);
nn_callCost(computer, control.readCost);
nn_eeprom_readCost(component, len);
}
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, "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, "get", false, (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, "getData", false, (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, "isReadOnly", false, (void *)nn_eeprom_isReadOnly, NULL, "isReadOnly(): boolean - Returns whether this EEPROM is read-only.");
nn_defineMethod(eepromTable, "getLabel", true, (void *)nn_eeprom_getLabel, NULL, "getLabel(): string - Returns the current label.");
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", true, (void *)nn_eeprom_get, NULL, "get(): string - Reads 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", true, (void *)nn_eeprom_getData, NULL, "getData(): string - Reads 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", 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) {

8
src/components/filesystem.c
View File

@@ -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);
}

11
src/components/gpu.c
View File

@@ -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));
}