NeoFlock/neonucleus
2
0
Fork 0
mirror of https://github.com/NeoFlock/neonucleus.git synced 2025-09-24 09:03:32 +02:00
Code Issues Packages Projects Releases Wiki Activity

bunch of work on the interfaces

Browse Source
This commit is contained in:
IonutParau 2025-05-28 14:02:09 +02:00
parent f14474ebb7
commit 38425792b1
6 changed files with 165 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
src/components/eeprom.c
View File

@ -1,5 +1,9 @@
#include "../neonucleus.h"
nn_eepromControl nn_eeprom_getControl(nn_component *component, nn_eeprom *eeprom) {
return eeprom->control(component, eeprom->userdata);
}
void nn_eeprom_destroy(void *_, nn_component *component, nn_eeprom *eeprom) {
if(!nn_decRef(&eeprom->refc)) return;
@ -10,10 +14,24 @@ 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) {
@ -25,6 +43,13 @@ void nn_eeprom_getLabel(nn_eeprom *eeprom, void *_, nn_component *component, nn_
} else {
nn_return(computer, nn_values_string(buf, l));
}
// 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_setLabel(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
@ -37,6 +62,14 @@ void nn_eeprom_setLabel(nn_eeprom *eeprom, void *_, nn_component *component, nn_
}
l = eeprom->setLabel(component, eeprom->userdata, buf, l);
nn_return(computer, nn_values_string(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_removeHeat(computer, control.writeHeatCost);
nn_callCost(computer, control.writeCost);
}
void nn_eeprom_get(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
@ -49,6 +82,12 @@ void nn_eeprom_get(nn_eeprom *eeprom, void *_, nn_component *component, nn_compu
size_t len = eeprom->get(component, eeprom->userdata, buf);
nn_return(computer, nn_values_string(buf, len));
nn_free(buf);
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_set(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
@ -60,6 +99,13 @@ void nn_eeprom_set(nn_eeprom *eeprom, void *_, nn_component *component, nn_compu
return;
}
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_removeHeat(computer, control.writeHeatCost);
nn_callCost(computer, control.writeCost);
}
void nn_eeprom_getData(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
@ -76,6 +122,12 @@ void nn_eeprom_getData(nn_eeprom *eeprom, void *_, nn_component *component, nn_c
nn_return(computer, nn_values_string(buf, len));
}
nn_free(buf);
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_setData(nn_eeprom *eeprom, void *_, nn_component *component, nn_computer *computer) {
@ -91,10 +143,18 @@ void nn_eeprom_setData(nn_eeprom *eeprom, void *_, nn_component *component, nn_c
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
@ -113,6 +173,12 @@ void nn_eeprom_getChecksum(nn_eeprom *eeprom, void *_, nn_component *component,
nn_free(buf);
nn_return(computer, nn_values_string((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);
}
void nn_loadEepromTable(nn_universe *universe) {

10
src/computer.c
View File

@ -241,20 +241,20 @@ void nn_setState(nn_computer *computer, int state) {
computer->state = state;
}
void nn_setEnergyInfo(nn_computer *computer, size_t energy, size_t capacity) {
void nn_setEnergyInfo(nn_computer *computer, double energy, double capacity) {
computer->energy = energy;
computer->maxEnergy = capacity;
}
size_t nn_getEnergy(nn_computer *computer) {
double nn_getEnergy(nn_computer *computer) {
return computer->energy;
}
size_t nn_getMaxEnergy(nn_computer *computer) {
double nn_getMaxEnergy(nn_computer *computer) {
return computer->maxEnergy;
}
void nn_removeEnergy(nn_computer *computer, size_t energy) {
void nn_removeEnergy(nn_computer *computer, double energy) {
if(computer->energy < energy) {
// blackout
computer->energy = 0;
@ -264,7 +264,7 @@ void nn_removeEnergy(nn_computer *computer, size_t energy) {
computer->energy -= energy;
}
void nn_addEnergy(nn_computer *computer, size_t amount) {
void nn_addEnergy(nn_computer *computer, double amount) {
if(computer->maxEnergy - computer->energy < amount) {
computer->energy = computer->maxEnergy;
return;

4
src/computer.h
View File

@ -30,8 +30,8 @@ typedef struct nn_computer {
nn_universe *universe;
char *users[NN_MAX_USERS];
size_t userCount;
size_t energy;
size_t maxEnergy;
double energy;
double maxEnergy;
nn_signal signals[NN_MAX_SIGNALS];
size_t signalCount;
size_t memoryTotal;

21
src/emulator.c
View File

@ -5,6 +5,20 @@
#include "neonucleus.h"
#include "testLuaArch.h"
nn_eepromControl ne_eeprom_getControl(nn_component *component, void *_) {
return (nn_eepromControl) {
.randomLatencyMin = 0.001,
.randomLatencyMax = 0.012,
.readLatency = 0.03,
.writeLatency = 0.05,
.readCost = 3,
.writeCost = 5,
.readEnergyCost = 1,
.writeEnergyCost = 5,
.writeHeatCost = 0.2,
};
}
size_t ne_eeprom_getSize(nn_component *component, void *_) {
return 4096;
}
@ -21,14 +35,14 @@ size_t ne_eeprom_setLabel(nn_component *component, void *_, const char *buf, siz
return 0;
}
const char *ne_eeprom_location(nn_address address) {
const char *ne_location(nn_address address) {
static char buffer[256];
snprintf(buffer, 256, "data/%s", address);
return buffer;
}
size_t ne_eeprom_get(nn_component *component, void *_, char *buf) {
FILE *f = fopen(ne_eeprom_location(nn_getComponentAddress(component)), "rb");
FILE *f = fopen(ne_location(nn_getComponentAddress(component)), "rb");
fseek(f, 0, SEEK_END);
size_t len = ftell(f);
fseek(f, 0, SEEK_SET);
@ -38,7 +52,7 @@ size_t ne_eeprom_get(nn_component *component, void *_, char *buf) {
}
void ne_eeprom_set(nn_component *component, void *_, const char *buf, size_t len) {
FILE *f = fopen(ne_eeprom_location(nn_getComponentAddress(component)), "wb");
FILE *f = fopen(ne_location(nn_getComponentAddress(component)), "wb");
fwrite(buf, sizeof(char), len, f);
fclose(f);
}
@ -72,6 +86,7 @@ int main() {
.userdata = NULL,
.refc = 1,
.deinit = NULL,
.control = ne_eeprom_getControl,
.getSize = ne_eeprom_getSize,
.getDataSize = ne_eeprom_getDataSize,
.getLabel = ne_eeprom_getLabel,

77
src/neonucleus.h
View File

@ -157,6 +157,8 @@ 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 *_);
@ -233,11 +235,11 @@ void nn_unlockComputer(nn_computer *computer);
int nn_getState(nn_computer *computer);
void nn_setState(nn_computer *computer, int state);
void nn_setEnergyInfo(nn_computer *computer, size_t energy, size_t capacity);
size_t nn_getEnergy(nn_computer *computer);
size_t nn_getMaxEnergy(nn_computer *computer);
void nn_removeEnergy(nn_computer *computer, size_t energy);
void nn_addEnergy(nn_computer *computer, size_t amount);
void nn_setEnergyInfo(nn_computer *computer, double energy, double capacity);
double nn_getEnergy(nn_computer *computer);
double nn_getMaxEnergy(nn_computer *computer);
void nn_removeEnergy(nn_computer *computer, double energy);
void nn_addEnergy(nn_computer *computer, double amount);
double nn_getTemperature(nn_computer *computer);
double nn_getThermalCoefficient(nn_computer *computer);
@ -349,11 +351,30 @@ void nn_loadFilesystemTable(nn_universe *universe);
// the helpers
// EEPROM
typedef struct nn_eepromControl {
double readLatency;
double writeLatency;
double readEnergyCost;
double writeEnergyCost;
double writeHeatCost;
double randomLatencyMin;
double randomLatencyMax;
// Call costs
size_t readCost;
size_t writeCost;
} nn_eepromControl;
typedef struct nn_eeprom {
nn_refc refc;
void *userdata;
void (*deinit)(nn_component *component, void *userdata);
nn_eepromControl (*control)(nn_component *component, void *userdata);
// methods
size_t (*getSize)(nn_component *component, void *userdata);
size_t (*getDataSize)(nn_component *component, void *userdata);
@ -389,19 +410,47 @@ typedef struct nn_filesystemControl {
// thermals
double motorHeat; // this times how many chunks have been seeked will be the heat addres, +/- the heat range.
double heatRange;
// call budget
size_t readCostPerChunk;
size_t writeCostPerChunk;
size_t seekCostPerChunk;
} nn_filesystemControl;
typedef struct nn_filesystem {
nn_refc refc;
nn_filesystemControl *control;
void *userdata;
void (*deinit)(nn_component *component, void *userdata);
nn_filesystemControl (*control)(nn_component *component, void *userdata);
void (*getLabel)(nn_component *component, void *userdata, char *buf, size_t *buflen);
size_t (*setLabel)(nn_component *component, void *userdata, const char *buf, size_t buflen);
size_t (*spaceUsed)(nn_component *component, void *userdata);
size_t (*spaceTotal)(nn_component *component, void *userdata);
bool (*isReadOnly)(nn_component *component, void *userdata);
// general operations
size_t (*size)(nn_component *component, void *userdata, const char *path);
bool (*remove)(nn_component *component, void *userdata, const char *path);
size_t (*lastModified)(nn_component *component, void *userdata, const char *path);
bool (*rename)(nn_component *component, void *userdata, const char *from, const char *to);
bool (*exists)(nn_component *component, void *userdata, const char *path);
// directory operations
bool (*isDirectory)(nn_component *component, void *userdata, const char *path);
bool (*makeDirectory)(nn_component *component, void *userdata, const char *path);
// the length and array must be nn_alloc'd.
// The strings must be NULL-terminated and also nn_alloc'd.
// See nn_strdup().
char **(*list)(nn_component *component, void *userdata, const char *path, size_t *len);
// file operations
size_t (*open)(nn_component *component, void *userdata, const char *path, const char *mode);
void (*close)(nn_component *component, void *userdata, int fd);
size_t (*seek)(nn_component *component, void *userdata, int fd, int whence, int off);
size_t (*read)(nn_component *component, void *userdata, int fd, char *buf, size_t required);
bool (*write)(nn_component *component, void *userdata, int fd, char *buf, size_t len);
} nn_filesystem;
nn_filesystem *nn_volatileFileSystem(size_t capacity, nn_filesystemControl *control);
@ -412,22 +461,32 @@ typedef struct nn_driveControl {
// Set it to 0 to disable seek latency.
int rpm;
double readLatencyPerByte;
double writeLatencyPerByte;
double readLatencyPerSector;
double writeLatencyPerSector;
double randomLatencyMin;
double randomLatencyMax;
double motorHeat;
double heatRange;
// These are per sector
double motorEnergyCost;
double readEnergyCost;
double writeEnergyCost;
// call budget
size_t readCostPerChunk;
size_t writeCostPerChunk;
size_t seekCostPerChunk;
} nn_driveControl;
typedef struct nn_drive {
nn_refc refc;
nn_driveControl *control;
void *userdata;
void (*deinit)(nn_component *component, void *userdata);
nn_driveControl (*control)(nn_component *component, void *userdata);
void (*getLabel)(nn_component *component, void *userdata, char *buf, size_t *buflen);
size_t (*setLabel)(nn_component *component, void *userdata, const char *buf, size_t buflen);

6
src/utils.c
View File

@ -64,3 +64,9 @@ void nn_busySleep(double t) {
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);
}