// TODO for cow
void FreePCB(PCB *pcb) {
while (!queueIsEmpty(pcb->children)) {
queuePop(pcb->children);
}
while(!queueIsEmpty(pcb->deadChildren)) {
ZCB *zombie = queuePop(pcb->deadChildren);
queueRemove(process_queue, zombie);
free(zombie);
}
free(pcb->children);
free(pcb->deadChildren);
for (int i = 0; i < MAX_PT_LEN; i++) {
if (pcb->cow.pageTable[i].valid == 1) {
if (pcb->cow.refCount[i]) {
if (*(pcb->cow.refCount[i]) == 1) {
addFrame(pcb->cow.pageTable[i].pfn);
free(pcb->cow.refCount[i]);
} else {
*(pcb->cow.refCount[i])--;
}
} else {
addFrame(pcb->cow.pageTable[i].pfn);
}
}
}
free(pcb);
}
void flip(int** board, struct Queue* q)
{
int x, y;
while (queueSize(q) > 0)
{
x = queuePop(q);
y = queuePop(q);
board[x][y] = board[x][y] ^ 1; /*0^1=1 and 1^1=0, xor with 1 effectivly flips the content*/
}
}
JausBoolean scManagerReceiveServiceConnection(NodeManagerInterface nmi, ServiceConnection requestSc, JausMessage *message)
{
ServiceConnection prevSc;
ServiceConnection sc = nmi->scm->incommingSc;
prevSc = NULL;
while(sc)
{
if(sc->commandCode == requestSc->commandCode && sc->address->id == requestSc->address->id )
{
if(getTimeSeconds() > (sc->lastSentTime + sc->timeoutSec))
{
// Connection has Timed Out
sc->isActive = JAUS_FALSE;
while(sc->queue->size)
{
jausMessageDestroy(queuePop(sc->queue));
}
// Remove Service Connection
if(prevSc)
{
prevSc->nextSc = sc->nextSc;
sc->nextSc = NULL;
}
else
{
nmi->scm->incommingSc = sc->nextSc;
sc->nextSc = NULL;
}
nmi->scm->incommingScCount--;
return JAUS_FALSE;
}
if(sc->queue->size)
{
*message = (JausMessage)queuePop(sc->queue);
return JAUS_TRUE;
}
else
{
return JAUS_FALSE;
}
}
else
{
prevSc = sc;
sc = sc->nextSc;
}
}
cError( "libnodeManager: scManagerServiceConnectionReceive: Requested SC does not exist\n" );
return JAUS_FALSE;
}
int main() {
Queue *queue = malloc(sizeof(Queue));
queueCreate(queue, 10);
queuePush(queue, 1);
queuePush(queue, 2);
queuePush(queue, 3);
queuePop(queue);
queuePop(queue);
assert(queuePeek(queue) == 3);
assert(queueEmpty(queue) == 0);
queueDestroy(queue);
return 0;
}
void queueDelete(Queue *q)
{
while(q->first != NULL) {
queuePop(q);
}
free(q);
}
void LoadNextProc(UserContext *context, int block) {
DelayPop();
if (!queueIsEmpty(ready_queue)) {
if (current_process) {
current_process->user_context = *context;
if (block == NO_BLOCK) {
queuePush(ready_queue, current_process);
}
}
PCB *next = queuePop(ready_queue);
TracePrintf(1, "LoadNextProc: Next Process Id: %d\n", next->id);
if(next->id == 2)
TracePrintf(3, "LoadNextProc: PCB has %p child\n", next->parent->children->head);
WriteRegister(REG_PTBR1, (unsigned int) &(next->cow.pageTable));
WriteRegister(REG_TLB_FLUSH, TLB_FLUSH_1);
KernelContextSwitch(MyKCS, current_process, next);
TracePrintf(1, "LoadNextProc: Got past MyKCS\n");
*context = current_process->user_context;
TracePrintf(3, "LoadNextProc: current user context pc is %p\n", context->pc);
}
}
/*
* 0 >= bytes write
* -1 = invalid args
* -2 = no message
*/
int P2_MboxCondReceive(int mbox, void *msg, int *size){
if(mbox < 0 || mbox >= P2_MAX_MBOX || mailboxes[mbox].inUse != 1 || permissionCheck()){
return -1;
}
mailbox *cur = &(mailboxes[mbox]);
P1_P(cur->mutex);
if(cur->activeSlots != 0){
P1_P(cur->fulls); //Never blocks
message *m = queuePop(&(cur->queue));
int retVal = 0;
if(*size > m->bufSize){
retVal = m->bufSize;
}else{
retVal = *size;
}
memcpy(msg,m->buf,retVal);
free(m->buf);
free(m);
cur->activeSlots--;
P1_V(cur->mutex);
P1_V(cur->empties);
return retVal;
}
P1_V(cur->mutex);
return -2;
}
int P2_MboxRelease(int mbox){
if(permissionCheck()){
return -1;
}
P1_P(mBoxSemaphore);
int i;
for(i = 0; i < P2_MAX_MBOX;i++){
if(mailboxes[i].inUse && mailboxes[i].id == mbox){
if(P1_SemFree(mailboxes[i].mutex) != 0){
USLOSS_Console("Processes waiting on mailbox. Halting.\n");
USLOSS_Halt(1);
}
if(P1_SemFree(mailboxes[i].fulls) != 0){
USLOSS_Console("Processes waiting on mailbox. Halting.\n");
USLOSS_Halt(1);
}
if(P1_SemFree(mailboxes[i].empties) != 0){
USLOSS_Console("Processes waiting on mailbox. Halting.\n");
USLOSS_Halt(1);
}
while(mailboxes[i].queue != NULL){
message *m = queuePop(&(mailboxes[i].queue));
free(m->buf);
free(m);
}
mailboxes[i].inUse = 0;
P1_V(mBoxSemaphore);
return 0;
}
}
P1_V(mBoxSemaphore);
return -1;
}
void DoWait(UserContext *context) {
if (BufferCheck(context->regs[0], INT_LENGTH) == ERROR || BufferWriteCheck(context->regs[0], INT_LENGTH) == ERROR) {
TracePrintf(1, "DoWait: Pointer given not valid. Returning Error\n");
context->regs[0] = ERROR;
return;
}
if (queueIsEmpty(current_process->children) && queueIsEmpty(current_process->deadChildren)) {
TracePrintf(2, "DoWait: PCB %d Has no children. Returning Error.\n", current_process->id);
TracePrintf(2, "DoWait: Children queue count: %d, deadChildren count: %d\n", current_process->children->length, current_process->deadChildren->length);
context->regs[0] = ERROR;
} else {
if (queueIsEmpty(current_process->deadChildren)) {
current_process->status = WAITING;
queuePush(wait_queue, current_process);
LoadNextProc(context, BLOCK);
}
ZCB *child = queuePop(current_process->deadChildren);
queueRemove(process_queue, child);
*((int *)context->regs[0]) = child->status;
context->regs[0] = child->id;
}
}
int sem_post_reply(void *request){
struct sem *find;
struct req_node_info *get;
struct reply_header reply;
*(char*)(request+sizeof(struct sem_req)+((struct sem_req*)request)->name_len)=0;
find = hashTableSearch(g_group.sem_table, ((struct sem_req*)request)->hash_id, (request+sizeof(struct sem_req)));
if(find == NULL){
return -1;
}
reply.msg_type = MSG_SEM_OK;
pthread_mutex_lock(&find->lock);
find->value++; //MAX = 65535 maybe over!! need check
if(find->value >0){
get = queuePop(find->queue);
if(get!=NULL){
find->value--;
// if(get->id == g_group.coordinator.sem_id)
// sem_post(get->sem);
// else{
reply.seq_number = get->seq_number;
sendTo(get->id, (void*)&reply, sizeof(struct request_header));
// }
}
}
pthread_mutex_unlock(&find->lock);
return 1;
}
JausBoolean scManagerCancelPeriodicEvent(NodeManagerInterface nmi, ServiceConnection deadSc)
{
CancelEventMessage cancelEvent;
JausMessage txMessage;
ServiceConnection prevSc = NULL;
ServiceConnection sc = nmi->scm->incommingSc;
while(sc)
{
if(sc->commandCode == deadSc->commandCode && jausAddressEqual(sc->address, deadSc->address) )
{
if(sc->instanceId > -1)
{
cancelEvent = cancelEventMessageCreate();
jausAddressCopy(cancelEvent->source, nmi->cmpt->address);
jausAddressCopy(cancelEvent->destination, deadSc->address);
cancelEvent->messageCode = deadSc->commandCode;
cancelEvent->eventId = deadSc->instanceId;
txMessage = cancelEventMessageToJausMessage(cancelEvent);
nodeManagerSend(nmi, txMessage);
jausMessageDestroy(txMessage);
cancelEventMessageDestroy(cancelEvent);
}
// Set SC to inactive
sc->isActive = JAUS_FALSE;
// Empty any Remaining Queue
while(sc->queue->size)
{
jausMessageDestroy(queuePop(sc->queue));
}
// Remove Service Connection
if(prevSc)
{
prevSc->nextSc = sc->nextSc;
sc->nextSc = NULL;
}
else
{
nmi->scm->incommingSc = sc->nextSc;
sc->nextSc = NULL;
}
nmi->scm->incommingScCount--;
return JAUS_TRUE;
}
else
{
prevSc = sc;
sc = sc->nextSc;
}
}
return JAUS_FALSE;
}
JausBoolean scManagerTerminateServiceConnection(NodeManagerInterface nmi, ServiceConnection deadSc)
{
TerminateServiceConnectionMessage terminateSc;
JausMessage txMessage;
ServiceConnection prevSc = NULL;
ServiceConnection sc = nmi->scm->incommingSc;
while(sc)
{
if(sc->commandCode == deadSc->commandCode && sc->address->id == deadSc->address->id )
{
if(sc->instanceId > -1)
{
terminateSc = terminateServiceConnectionMessageCreate();
terminateSc->source->id = nmi->cmpt->address->id;
terminateSc->destination->id = deadSc->address->id;
terminateSc->serviceConnectionCommandCode = deadSc->commandCode;
terminateSc->instanceId = deadSc->instanceId;
txMessage = terminateServiceConnectionMessageToJausMessage(terminateSc);
nodeManagerSend(nmi, txMessage);
jausMessageDestroy(txMessage);
terminateServiceConnectionMessageDestroy(terminateSc);
}
// Set SC to inactive
sc->isActive = JAUS_FALSE;
// Empty any Remaining Queue
while(sc->queue->size)
{
jausMessageDestroy(queuePop(sc->queue));
}
// Remove Service Connection
if(prevSc)
{
prevSc->nextSc = sc->nextSc;
sc->nextSc = NULL;
}
else
{
nmi->scm->incommingSc = sc->nextSc;
sc->nextSc = NULL;
}
nmi->scm->incommingScCount--;
return JAUS_TRUE;
}
else
{
prevSc = sc;
sc = sc->nextSc;
}
}
return JAUS_FALSE;
}
/* int Dstar::computeShortestPath()
* --------------------------
* As per [S. Koenig, 2002] except for 2 main modifications:
* 1. We stop planning after a number of steps, 'maxsteps' we do this
* because this algorithm can plan forever if the start is
* surrounded by obstacles.
* 2. We lazily remove states from the open list so we never have to
* iterate through it.
*/
int Dstar::computeShortestPath() {
list<state> s;
list<state>::iterator i;
if (openList.empty()) return 1;
int k=0;
while ((!openList.empty()) &&
(openList.top() < (calculateKey(s_start))) ||
(!isConsistent(s_start))) {
if (k++ > maxSteps) {
fprintf(stderr, "At maxsteps\n");
return -1;
}
state u;
// check consistency (one of the loop conditions)
bool test = isConsistent(s_start);
//(getRHS(s_start) != getG(s_start));
// lazy remove
while(1) {
if (openList.empty()) return 1; // checks outer loop condition #1
u = openList.top();
if (!queuePop()) continue;
if (!(u < s_start) && test) return 2; // checks outer loop conditions #2,3 still hold
break;
}
state k_old = u;
if (k_old < calculateKey(u)) { // u is out of date
insert(u); // u has been removed already, reinsert into pq with new key
} else if (getG(u) > getRHS(u)) { // needs update (got better)
setG(u,getRHS(u));
getPred(u,s);
for (i=s.begin();i != s.end(); i++) {
updateVertex(*i);
}
} else { // g <= rhs, state has got worse
setG(u,INFINITY);
getPred(u,s);
for (i=s.begin();i != s.end(); i++) {
updateVertex(*i);
}
updateVertex(u);
}
}
return 0;
}
JausBoolean scManagerReceiveServiceConnection(NodeManagerInterface nmi, ServiceConnection requestSc, JausMessage *message)
{
ServiceConnection prevSc;
ServiceConnection sc;
pthread_mutex_lock(&nmi->scm->mutex);
sc = nmi->scm->incomingSc;
prevSc = NULL;
while(sc)
{
if(sc->commandCode == requestSc->commandCode && jausAddressEqual(sc->address, requestSc->address) )
{
if(ojGetTimeSec() > (sc->lastSentTime + sc->timeoutSec))
{
// Connection has Timed Out
sc->isActive = JAUS_FALSE;
queueEmpty(sc->queue, (void *)jausMessageDestroy);
// Remove Service Connection
if(prevSc)
{
prevSc->nextSc = sc->nextSc;
sc->nextSc = NULL;
}
else
{
nmi->scm->incomingSc = sc->nextSc;
sc->nextSc = NULL;
}
nmi->scm->incomingScCount--;
pthread_mutex_unlock(&nmi->scm->mutex);
return JAUS_FALSE;
}
if(sc->queue->size)
{
*message = (JausMessage)queuePop(sc->queue);
pthread_mutex_unlock(&nmi->scm->mutex);
return JAUS_TRUE;
}
else
{
pthread_mutex_unlock(&nmi->scm->mutex);
return JAUS_FALSE;
}
}
else
{
prevSc = sc;
sc = sc->nextSc;
}
}
pthread_mutex_unlock(&nmi->scm->mutex);
return JAUS_FALSE;
}
int sem_imanager_req(){
int i, j;
void *buf;
unsigned int offset;
unsigned int queue_count;
unsigned int src_node;
unsigned int seq_number;
struct sem *find;
struct req_node_info node;
char *sem_name;
if(g_group.coordinator.sem_id == g_group.node_id)
return 1;
//max 33 sem
buf = mem_malloc(SEM_ISEM_SIZE);
((struct request_header*)buf)->msg_type = MSG_ISEM_MANAGER;
sendRecv(g_group.coordinator.sem_id, buf, sizeof(struct request_header),
buf, SEM_ISEM_SIZE);
if(g_group.sem_table == NULL){
g_group.sem_table = hashTableCreate(SEM_HASH_SIZE);
}
src_node = ((struct isem_reply*)buf)->req.src_node;
seq_number = ((struct isem_reply*)buf)->req.src_seq_number;
offset = sizeof(struct isem_reply);
for(i=0; i<((struct isem_reply*)buf)->sem_num; i++){
//sem name
sem_name = malloc(((struct sem_info*)(buf+offset))->name_len);
memcpy(sem_name, buf+offset+sizeof(struct sem_info), ((struct sem_info*)(buf+offset))->name_len);
sem_name[((struct sem_info*)(buf+offset))->name_len] = 0;
//search sem
find = hashTableSearch(g_group.sem_table, ((struct sem_info*)(buf+offset))->hash_id, sem_name);
if(find == NULL){
//create new
find = createNewSem(((struct sem_info*)(buf+offset))->hash_id, sem_name, ((struct sem_info*)(buf+offset))->value);
hashTableInsert(g_group.sem_table, (struct hashheader*)find);
}else{
if(find->queue->use!=0){
while(queuePop(find->queue)!=NULL);
}
}
//copy queue info
queue_count = ((struct sem_info*)(buf+offset))->queue_count;
offset += sizeof(struct sem_info)+strlen(sem_name);
for(j=0; j< queue_count;j++){
node.id = ((struct req_node_info*)(buf+offset))->id;
node.seq_number = ((struct req_node_info*)(buf+offset))->seq_number;
queuePush(find->queue, (void*)&node);
offset += sizeof(struct req_node_info);
}
}
g_group.coordinator.sem_id = g_group.node_id;
((struct request_header*)buf)->msg_type = MSG_ISEM_READY;
((struct request_header*)buf)->seq_number = seq_number;
sendTo(src_node ,buf, sizeof(struct request_header));
mem_free(buf);
return 1;
}
void pqPush(PayQueue pq, Payload pld) {
Payload pay;
if (queueIsFull(pq)) {
pay = (Payload)queuePop(pq);
payDelete(pay);
}
queueAppend(pq, pld);
}
int
main()
{
Queue queue;
queueCreate(&queue, 5);
queuePush(&queue, 1);
queuePush(&queue, 2);
queuePop(&queue);
printf("%d\n", queuePeek(&queue));
queuePop(&queue);
queuePush(&queue, 1);
queuePush(&queue, 2);
printf("%d\n", queuePeek(&queue));
queuePush(&queue, 3);
printf("%d\n", queuePeek(&queue));
printf("%d\n", queuePeek(&queue));
queueDestroy(&queue);
return 0;
}
int main(int argc, char *argv[])
{
Queue *q = queueCreate();
queuePush(q, 'a');
queuePush(q, 'b');
queuePush(q, 'c');
queuePush(q, 'd');
printf("%c", queuePop(q));
printf("%c", queuePop(q));
printf("%c", queuePop(q));
queuePush(q, 'e');
queuePush(q, '\n');
printf("%c", queuePop(q));
printf("%c", queuePop(q));
printf("%c", queuePop(q));
queuePush(q, 0);
queuePush(q, 0);
queuePush(q, 0);
queuePush(q, 0);
queueDelete(q);
return 0;
}
int main()
{
Queue q;
queueCreate(&q, 100);
for (int i = 0; i < 10; ++i) {
queuePush(&q, i);
}
printf("Bingo\n");
for (int i = 0; i < 10; ++i) {
queuePop(&q);
}
return 0;
}
int main ( void )
{
fun_queue = queueInit(FUN_Q_LEN);
rx_pay_queue = pqInit(12); //replace 12 with a #define const later
test_function tf;
/* Initialization */
SetupClock();
SwitchClocks();
SetupPorts();
SetupInterrupts();
SetupI2C();
SetupADC();
SetupTimer1();
SetupPWM();
SetupTimer2();
gyroSetup();
xlSetup();
dfmemSetup();
WordVal pan_id = {RADIO_PAN_ID};
WordVal src_addr = {RADIO_SRC_ADDR};
WordVal dest_addr = {RADIO_DEST_ADDR};
radioInit(src_addr, pan_id, RADIO_RXPQ_MAX_SIZE, RADIO_TXPQ_MAX_SIZE);
radioSetDestAddr(dest_addr);
radioSetChannel(RADIO_MY_CHAN);
char j;
for(j=0; j<3; j++){
LED_2 = ON;
delay_ms(500);
LED_2 = OFF;
delay_ms(500);
}
LED_2 = ON;
EnableIntT2;
while(1){
while(!queueIsEmpty(fun_queue))
{
rx_payload = pqPop(rx_pay_queue);
tf = (test_function)queuePop(fun_queue);
(*tf)(payGetType(rx_payload), payGetStatus(rx_payload), payGetDataLength(rx_payload), payGetData(rx_payload));
payDelete(rx_payload);
}
}
return 0;
}
void CsmaAloha::txData()
{
Packet* data_pkt = curr_data_pkt->copy();
if ( (ack_mode == CSMA_NO_ACK_MODE) ) {
queuePop();
}
incrDataPktsTx();
incrCurrTxRounds();
Mac2PhyStartTx(data_pkt);
}
int LockRelease(Lock *lock) {
if (lock == NULL) {
TracePrintf(2, "LockRelease: Lock not found.\n");
return ERROR;
} else if (lock->owner != current_process) {
TracePrintf(2, "LockRelease: Current process does not hold lock it is trying to release.\n");
return ERROR;
} else {
lock->owner = queuePop(lock->waiting);
if (lock->owner) {
queuePush(ready_queue, lock->owner);
}
return SUCCESS;
}
}
/*----------------------------------------------------------------------------*/
static size_t canWrite(void *object, const void *buffer, size_t length)
{
assert(length % sizeof(struct CanStandardMessage) == 0);
struct Can * const interface = object;
if (interface->mode == MODE_LISTENER)
return 0;
LPC_CAN_Type * const reg = interface->base.reg;
const struct CanStandardMessage *input = buffer;
const size_t initialLength = length;
const irqState state = irqSave();
if (queueEmpty(&interface->txQueue))
{
uint32_t status = reg->SR;
while (length && (status & SR_TBS_MASK))
{
/* One of transmit buffers is empty */
status = sendMessage(interface, (const struct CanMessage *)input, status);
length -= sizeof(*input);
++input;
}
}
while (length && !queueFull(&interface->txQueue))
{
struct CanMessage *output;
queuePop(&interface->pool, &output);
memcpy(output, input, sizeof(*input));
queuePush(&interface->txQueue, &output);
length -= sizeof(*input);
++input;
}
irqRestore(state);
return initialLength - length;
}
void scManagerReceiveMessage(NodeManagerInterface nmi, JausMessage message)
{
ServiceConnection sc;
char string[32] = {0};
pthread_mutex_lock(&nmi->scm->mutex);
sc = nmi->scm->incomingSc;
while(sc)
{
if(sc->commandCode == message->commandCode && jausAddressEqual(sc->address, message->source) )
{
if(sc->isActive)
{
sc->lastSentTime = ojGetTimeSec();
if(sc->queueSize && sc->queueSize == sc->queue->size)
{
jausMessageDestroy(queuePop(sc->queue));
queuePush(sc->queue, (void *)message);
}
else
{
queuePush(sc->queue, (void *)message);
}
}
else
{
// TODO: Error? received a message for inactive SC
jausMessageDestroy(message);
}
pthread_mutex_unlock(&nmi->scm->mutex);
return;
}
sc = sc->nextSc;
}
jausAddressToString(message->source, string);
jausMessageDestroy(message);
pthread_mutex_unlock(&nmi->scm->mutex);
}
int TestQueue()
{
Queue* Q;
int i;
Q = malloc(sizeof(struct Queue));
queueCreate(Q, 10);
for (i = 0; i < 100; ++i)
queuePush(Q, i);
while (!queueEmpty(Q))
{
printf("%d ", queuePeek(Q));
queuePop(Q);
}
printf("\n");
queueDestroy(Q);
}
void scManagerReceiveMessage(NodeManagerInterface nmi, JausMessage message)
{
ServiceConnection sc = nmi->scm->incommingSc;
char string[32] = {0};
while(sc)
{
if(sc->commandCode == message->commandCode && sc->address->id == message->source->id )
{
if(sc->isActive)
{
sc->lastSentTime = getTimeSeconds();
if(sc->queueSize && sc->queueSize == sc->queue->size)
{
jausMessageDestroy(queuePop(sc->queue));
queuePush(sc->queue, (void *)message);
}
else
{
queuePush(sc->queue, (void *)message);
}
// cDebug(3, "Queue Size: %d\n", sc->queue->size);
}
else
{
// TODO: Error? received a message for inactive SC
jausMessageDestroy(message);
}
return;
}
sc = sc->nextSc;
}
jausAddressToString(message->source, string);
cError("libnodeManager: scManangerReceiveMessage: No SC for: %s, from: %s\n", jausMessageCommandCodeString(message), string);
jausMessageDestroy(message);
}
int main (int argc, char **argv)
{
int i;
int val[] = {2,3,6,8,10,12,14,16,18,20,21,22,23,24,25};
int value;
Queue q ;
queueCreate(&q, 1024);
for(i = 0; i < 15; i++) {
queuePush(&q, val[i]);
print_list(q.node);
}
for(i = 0; i < 15; i++) {
value = queuePeek(&q);
printf("val = %d\n", value);
queuePop(&q);
print_list(q.node);
}
queueDestroy(&q);
return 0;
}
void CsmaAloha::stateTxData()
{
refreshState(CSMA_STATE_TX_DATA);
if (debug_) cout << NOW << " CsmaAloha("<< addr << ")::stateTxData() " << endl;
if (print_transitions) printStateInfo();
curr_data_pkt = Q.front();
if ( data_sn_queue.front() != last_sent_data_id) {
resetCurrTxRounds();
ack_timer.resetCounter();
listen_timer.resetCounter();
backoff_timer.resetCounter();
}
if ( curr_tx_rounds < max_tx_tries ) {
hdr_mac* mach = HDR_MAC(curr_data_pkt);
mach->macSA() = addr;
start_tx_time = NOW;
last_sent_data_id = data_sn_queue.front();
txData();
}
else {
queuePop(false);
incrDroppedPktsTx();
refreshReason(CSMA_REASON_MAX_TX_TRIES);
if (debug_) cout << NOW << " CsmaAloha("<< addr << ")::stateTxData() curr_tx_rounds " << curr_tx_rounds
<< " > max_tx_tries = " << max_tx_tries << endl;
stateIdle();
}
}
void CsmaAloha::stateRxAck(Packet* p) {
ack_timer.stop();
refreshState(CSMA_STATE_ACK_RX);
if (debug_) cout << NOW << " CsmaAloha("<< addr << ")::stateRxAck() " << endl;
Packet::free(p);
refreshReason(CSMA_REASON_ACK_RX);
switch( prev_state ) {
case CSMA_STATE_RX_IDLE:
stateIdle();
break;
case CSMA_STATE_RX_LISTEN:
stateCheckListenExpired();
break;
case CSMA_STATE_RX_BACKOFF:
stateCheckBackoffExpired();
break;
case CSMA_STATE_RX_WAIT_ACK:
queuePop();
updateAckTimeout(NOW - start_tx_time);
incrAckPktsRx();
stateIdle();
break;
default:
cerr << NOW << " CsmaAloha("<< addr << ")::stateRxAck() logical error, prev state = " << status_info[prev_state]
<< endl;
}
}
int main()
{
int num =0;
Init();
while(1)
{
printf("insert num : ");
scanf("%d",&num);
if(num<0)
{
printf("EXIT\n");
return 0;
}
else if(num==0)
{
printf("[%d]\n",queuePop());
}
else
{
Push(num);
}
}
}
