void
RegAlloc::markAsClean(const Location& loc) {
PhysReg pr = mapGet(m_contToRegMap, RegContent(loc), InvalidReg);
if (pr != InvalidReg) {
stateTransition(physRegToInfo(pr), RegInfo::CLEAN);
}
}
void
RegAlloc::reset() {
TRACE(1, ">>> regalloc reset! <<<\n");
m_epoch = 0;
m_contToRegMap.clear();
// m_info is sparse.
for (int i = 0; i < kMaxRegs; ++i) {
m_info[i].m_epoch = 0;
m_info[i].m_pReg = PhysReg(i);
m_info[i].m_cont = RegContent();
m_info[i].m_type = KindOfInvalid;
m_info[i].m_state = RegInfo::INVALID;
}
RegSet all = m_allRegs;
PhysReg pr;
for (int i = 0; all.findFirst(pr); i++) {
all.remove(pr);
physRegToInfo(pr)->m_pReg = PhysReg(pr);
stateTransition(physRegToInfo(pr), RegInfo::FREE);
// Put the most favorable register last, so it is picked first.
m_lru[(m_numRegs - 1) - i] = pr;
}
m_branchSynced = false;
verify();
}
void
RegAlloc::cleanReg(PhysReg reg) {
RegInfo* r = physRegToInfo(reg);
if (r->m_state == RegInfo::DIRTY) {
spill(r);
stateTransition(r, RegInfo::CLEAN);
}
}
/**
* Returns the successor of the supplied state node <current>.
* If the state transition has not yet been calculated,
* a new node is inserted into the tree <root>.
* <numElementsPerEntry> is the number of array elements required to store one state.
* <net> describes the network for which a state transition is performed.
* <basinCounter> is a counter to be increased when a new state is identified
*/
StateTreeNode * findSuccessor(StateTree * tree, StateTreeNode * current,
unsigned int numElementsPerEntry, TruthTableBooleanNetwork * net, unsigned int * basinCounter)
{
bool found;
if (current->type.sync.successor == 0)
// the state does not exist => calculate state transition and insert it
{
unsigned int nextState[numElementsPerEntry];
stateTransition(current->data,nextState,net);
current->type.sync.successor = findNode(tree,nextState,numElementsPerEntry, &found);
++ *basinCounter;
}
return current->type.sync.successor;
}
void MenuState::onEvent()
{
while (SDL_PollEvent(&event))
{
if (event.type == SDL_QUIT)
{
applicationStateManager->setNextState(STATE_EXIT);
}
else if (event.type == SDL_KEYDOWN)
{
switch(event.key.keysym.scancode)
{
case SDL_SCANCODE_ESCAPE:
stateTransition(STATE_EXIT);
break;
case SDL_SCANCODE_RETURN:
stateTransition(STATE_GAME);
break;
}
}
gameEntityManager.onEvent(&event);
}
}
FOR_EACH_REG_IN_SET(r, regs) {
if (r->m_state == RegInfo::DIRTY) {
spill(r);
stateTransition(r, RegInfo::CLEAN);
}
}
void handleCommand(deluge_app* app, comBuf* pkt, uint8_t port)
{
deluge_foot_command* command = (deluge_foot_command*)
&pkt->data[pkt->size - sizeof(deluge_foot_command)];
#ifdef DELUGE_PRINT_PACKETS
printf_P(sRecvComm, command->seq, command->command, command->to);
#endif
if (checkCache(command->id, command->seq)) return;
// Temporarily switch to max power to make sure the command gets through
/*uint8_t oldPower;
com_ioctl(IFACE_RADIO, CC1000_GET_TX_POWER, &oldPower);
com_ioctl(IFACE_RADIO, CC1000_TX_POWER, 0xFF);*/
// If the command is not specifically addessed to us, forward it now
/*if (command->to != mos_node_id_get())
net_send(pkt, DELUGE_PROTO_ID, port, port);*/
if (command->to != -1 && command->to != mos_node_id_get()) {
//com_ioctl(IFACE_RADIO, CC1000_TX_POWER, oldPower);
return;
}
//extern mutex epromLock;
switch(command->command) {
case DELUGE_COMMAND_HELLO:
printf_P(sHello);
logHeader(&spkt, DELUGE_COMMAND_HELLO);
com_send(IFACE_SERIAL, &spkt);
break;
//case DELUGE_COMMAND_SEQNO: seqNo = 0; break;
/*case DELUGE_COMMAND_STOPALL:
//app->dcb.codeSize;
//app->dcb.programcrc;
memset(app->dcb.pagesNeeded, 0, sizeof(app->dcb.pagesNeeded));
//app->dcb.version;
app->dcb.incomingPage = app->dcb.highPage = app->dcb.goalPage;
deluge_saveState(app);
deluge_app_init(app, app->index);
break;*/
#ifdef DELUGE_KEEP_STATS
case DELUGE_COMMAND_CLEARSTATS:
#ifdef DELUGE_PRINT_EVENT
printf_P(sClearStats);
//printf_P(sClearTimer); // reset timer
#endif
memset(packet_counts, 0, sizeof(packet_counts));
logHeader(&spkt, DELUGE_COMMAND_CLEARSTATS);
com_send(IFACE_SERIAL, &spkt);
break;
case DELUGE_COMMAND_STARTRECORD:
#ifdef DELUGE_PRINT_EVENT
printf_P(sStartRec);
//printf_P(sClearTimer); // reset timer
#endif
logHeader(&spkt, DELUGE_COMMAND_STARTRECORD);
com_send(IFACE_SERIAL, &spkt);
deluge_recordstats = 1;
break;
case DELUGE_COMMAND_ENDRECORD:
#ifdef DELUGE_PRINT_EVENT
//printf_P(sDisplayTime); // display timer
printf_P(sStopRec);
#endif
deluge_recordstats = 0;
/*mos_mutex_lock(&epromLock);
dev_ioctl(DEV_AVR_EEPROM, DEV_SEEK, DELUGE_STATS_ADDR);
dev_write(DEV_AVR_EEPROM, (uint8_t*)packet_counts, sizeof(packet_counts));
mos_mutex_unlock(&epromLock);*/
logHeader(&spkt, DELUGE_COMMAND_ENDRECORD);
com_send(IFACE_SERIAL, &spkt);
break;
case DELUGE_COMMAND_SENDSTATS:
if (-1 != command->to && !sendingStats) { // it's addressed to us
sendingStats = 1;
statsPort = port;
// This is a slow procedure that requires multiple packets to
// reply, so run it in another thread.
//mos_thread_new(statsThread, 256, PRIORITY_NORMAL);
uint8_t r = 0;
uint8_t i = 0;
for (r=0; r<DELUGE_STATS_COUNT;)
{
logHeader(&spkt, DELUGE_COMMAND_SENDSTATS_REPLY);
spkt.data[spkt.size++] = r;
for (i=0; i<4 && r+i<DELUGE_STATS_COUNT; i++)
{
uint8_t j;
for (j=0; j<4; j++)
{
uint16_t stat = packet_counts[r+i][j];
spkt.data[spkt.size++] = (uint8_t)(stat >> 8);
spkt.data[spkt.size++] = (uint8_t)(stat);
}
}
r += i;
com_send(IFACE_SERIAL, &spkt);
}
sendingStats = 0;
}
break;
#endif
case DELUGE_COMMAND_VERSION:
#ifdef DELUGE_PRINT_EVENT
printf_P(sChangeVer, pkt->data[0]);
printf_P(sClearTimer); // clear timer
#endif
mos_mutex_lock(&app->delugeLock);
app->dcb.version = pkt->data[0];
deluge_saveState(app);
app->detectedInconsistency = 1;
stateTransition(app, DELUGE_STATE_MAINTAIN);
mos_mutex_unlock(&app->delugeLock);
if (command->to != -1) {
/*command->seq = ++seqNo;
command->command = DELUGE_COMMAND_VERSION_REPLY;
command->to = command->id;
command->id = mos_node_id_get();
command->type = DELUGE_PACKET_COMMAND;
mos_thread_sleep(1000);
net_send(pkt, DELUGE_PROTO_ID, port, port);*/
logHeader(&spkt, DELUGE_COMMAND_VERSION_REPLY);
com_send(IFACE_SERIAL, &spkt);
}
break;
#ifdef DELUGE_SYMMETRIC_LINKS
/*case DELUGE_COMMAND_NEIGHBORS:
if (-1 != command->to) { // it's addressed to us
memcpy(pkt->data, app->neighbors, sizeof(app->neighbors));
pkt->size = sizeof(app->neighbors);
//memcpy(&pkt->data[pkt->size], app->symdtbs, sizeof(app->symdtbs));
//pkt->size += sizeof(app->symdtbs);
command = (deluge_foot_command*)&pkt->data[pkt->size];
command->seq = ++seqNo;
command->command = DELUGE_COMMAND_NEIGHBORS_REPLY;
command->to = -1;
command->id = mos_node_id_get();
command->type = DELUGE_PACKET_COMMAND;
pkt->size += sizeof(deluge_foot_command);
mos_thread_sleep(1000);
net_send(pkt, DELUGE_PROTO_ID, port, port);
}
break;*/
#endif
/*case DELUGE_COMMAND_WIPE: {
com_mode(IFACE_RADIO, IF_OFF);
deluge_suspend();
#ifdef DELUGE_PRINT_EVENT
printf_P(sWipe);
#endif
uint16_t zero = 0;
uint16_t addr;
mos_mutex_lock(&epromLock);
for (addr = DELUGE_CONTROL_BLOCK_ADDR; addr < SIMPLE_FS_ADDR; addr += 2)
{
dev_ioctl(DEV_AVR_EEPROM, DEV_SEEK, addr);
dev_write(DEV_AVR_EEPROM, (uint8_t*)&zero, 2);
}
simple_fs_format();
uint8_t default_portmap[DELUGE_INSTANCE_COUNT];
uint8_t i;
for (i=0; i<DELUGE_INSTANCE_COUNT; i++)
default_portmap[i] = i+1;
dev_ioctl(DEV_AVR_EEPROM, DEV_SEEK, DELUGE_DIRECTORY_ADDR);
dev_write(DEV_AVR_EEPROM, default_portmap, sizeof (default_portmap));
mos_mutex_unlock(&epromLock);
#ifdef DELUGE_PRINT_EVENT
printf_P(sDone);
#endif
deluge_init();
com_mode(IFACE_RADIO, IF_LISTEN);
break;
}*/
case DELUGE_COMMAND_BOOT: {
mos_mutex_lock(&app->delugeLock);
com_mode(IFACE_RADIO, IF_OFF);
deluge_suspend();
if (pkt->data[0]==0) {
// Just reboot
reboot();
break;
}
// Open the requested backup image
char name[4] = { 'b', 'k', '0'+pkt->data[0], 0 };
mos_file* file = mos_file_open(name);
if (!file) {
printf_P(sFileErr, name);
deluge_resume();
com_mode(IFACE_RADIO, IF_LISTEN);
break;
}
// We keep our current state, but we boot the backup image
deluge_saveState(app);
// Reboot. This function will copy the file location into the
// boot control block for reprogramming
app->image_file = file;
runReprogram(app);
// We shouldn't return from runReprogram
mos_mutex_unlock(&app->delugeLock);
break;
}
#if DELUGE_CACHE_PAGES > 1
case DELUGE_COMMAND_CACHESIZE: {
if (pkt->data[0] >= DELUGE_CACHE_PAGES) break;
#ifdef DELUGE_PRINT_EVENT
printf_P(sChangeCache, pkt->data[0]);
#endif
mos_mutex_lock(&app->delugeLock);
app->cacheSize = pkt->data[0];
int8_t i;
for (i=0; i<DELUGE_CACHE_PAGES; i++)
app->cache_map[i] = -1;
app->outgoingCachePage = 0;
app->incomingCachePage = 0;
stateTransition(app, DELUGE_STATE_MAINTAIN);
mos_mutex_unlock(&app->delugeLock);
break;
}
#endif
case DELUGE_COMMAND_POWER: {
#ifdef DELUGE_PRINT_EVENT
printf_P(sChangeTx, pkt->data[0]);
#endif
//oldPower = pkt->data[0]; // Will get changed at the end
com_ioctl(IFACE_RADIO, CC1000_TX_POWER, pkt->data[0]);
break;
}
default:
break;
}
