/* Execute one instruction from each running context. */ void ke_run(void) { struct ctx_t *ctx, *ctx_trav; int k = 0; /* Run an instruction from every running process */ for (k=0, ctx = ke->suspended_list_head; ctx; ctx = ctx->suspended_next, k++); //printf ("Instruction number: %lld, suspended processes:%d, queue_size: %d\n", instr_num, k, sched_count); for (ctx = ke->running_list_head; ctx; ctx = ctx->running_next) { int i; for ( i = 0 ; i < ctx->instr_slice && ctx_get_status(ctx, ctx_running); ++i) { while (interrupts_exist() && instr_num >= next_interrupt_num()) handle_interrupt (pop_interrupt()); ctx_execute_inst(ctx); instr_num++; } } /* Free finished contexts */ while (ke->finished_list_head) ctx_free(ke->finished_list_head); /* Process list of suspended contexts */ //ke_process_events(); while (!(ke->running_list_head) && interrupts_exist()) { //printf ("Instruction number updated from %lld to %lld\n", instr_num, next_interrupt_num()); instr_num = next_interrupt_num(); handle_interrupt(pop_interrupt()); } }
/* Execute one instruction from each running context. */ void ke_run(void) { struct ctx_t *ctx, *ctx_trav; int flag = 0; /* Run an instruction from every running process */ for (ctx = ke->running_list_head; ctx; ctx = ctx->running_next) { int i; //printf ("out - %p\n", ctx); for ( i = 0 ; i < ctx->instr_slice ; ++i) { if((no_instructions == get_least_interrupt_time()) && least_interrupt!=NULL){ struct interrupt_t* curr_interrupt = get_least_interrupt(); curr_interrupt->details->p_ctx->blocked = 0; printf("program with pid %d unblocked at %d\n",curr_interrupt->details->p_ctx->pid,no_instructions); delete_interrupt(curr_interrupt); } if(!ctx->blocked){ ctx_execute_inst(ctx); no_instructions++; printf("%d,%d\n",ctx->pid,no_instructions); } if (ctx!=ke->running_list_head) break; } } /* Free finished contexts */ while (ke->finished_list_head) ctx_free(ke->finished_list_head); /* Process list of suspended contexts */ ke_process_events(); }
/* Execute one instruction from each running context. */ void ke_run(void) { //printf("ke run called\n"); struct ctx_t *ctx, *ctx_trav; int flag = 0; if(!ke->running_list_head){ if (!print_no_more) { printf("============ Running list empty ! . Fast forward to next interrupt. ============\n"); print_no_more = true; pl = true; } if(!isEmpty()){ isa_inst_count = findMin().instr_no; //printf("non-empty instruction list\n"); handle_top_interrupt(); } else{ if (!print_no_more || (print_no_more && pl)) { printf("Interrupt queue is also empty.\n"); print_no_more = true; pl = false; } } } /* Run an instruction from every running process */ for (ctx = ke->running_list_head; ctx; ctx = ctx->running_next) { print_no_more = false; int i; //printf ("out - %p\n", ctx); //printf("after\n"); printf("[%d] exec instr\n", ctx->pid); for ( i = 0 ; i < ctx->instr_slice ; ++i) { //printf(" non-empty instruction list\n"); handle_top_interrupt(); if(!ctx_get_status(ctx,ctx_running)){ printf("%d no more running\n", ctx->pid); break; } page_in_out_count = 0; fault_count_in_instruction = 0; //value printed in ctx_execute_inst in context.c ctx_execute_inst(ctx); printf("ins_count: %"PRIu64" | [%d] : page_in_out_count : %d\n", isa_inst_count, ctx->pid, page_in_out_count); //if page_in_out_count > 0, then put the process to suspended list and insert an interrupt if(page_in_out_count > 0){ printf("[%d] : Blocking process for page fault\n", ctx->pid); ctx_update_status(isa_ctx, ctx_suspended); struct interrupt in; in.instr_no = isa_inst_count + page_in_out_count * 10; in.type = iocomplete; in.ctx = isa_ctx; insert(in); } // if (ctx!=ke->running_list_head) // break; } } /* Free finished contexts */ while (ke->finished_list_head) ctx_free(ke->finished_list_head); /* Process list of suspended contexts */ ke_process_events(); }
/* Execute one instruction from each running context. */ void ke_run(void) { struct ctx_t *ctx, *ctx_trav; int flag = 0; ctx = ke->running_list_head; if (!ctx) { printf ("Running List is Empty\n"); if (!my_top(interrupt_list)) { /* Free finished contexts */ while (ke->finished_list_head) ctx_free(ke->finished_list_head); /* Process list of suspended contexts */ // ke_process_events(); return; } else { num_instr_executed = my_top(interrupt_list)->inst_no; struct ctx_t *interrupting_process_context = my_top(interrupt_list)->ctx; if (!ctx_get_status(interrupting_process_context, ctx_suspended)) { printf("suspended process is not suspended which means we don't know what is happening\n"); fflush(stdout); return; } printf("Inside the ISR2\n"); fflush(stdout); ke_list_remove(ke_list_suspended, interrupting_process_context); //ctx_set_status(interrupting_process_context, ctx_running); interrupting_process_context->status = ctx_running; ke_list_insert_tail(ke_list_running, interrupting_process_context); my_delete(interrupt_list); /* Free finished contexts */ while (ke->finished_list_head) ctx_free(ke->finished_list_head); // comment this ?? /* Process list of suspended contexts */ // ke_process_events(); return; } } /* Run an instruction from every running process */ while (ctx) { struct ctx_t * ctx_temp = ctx->running_next; int i; //printf ("out - %p\n", ctx); for ( i = 0 ; i < ctx->instr_slice ; ++i) { if (ctx_get_status(ctx, ctx_suspended)) { printf("Process suspended\n"); break; } if (ctx_get_status(ctx, ctx_finished)) { break; } // CHECK IF THERE ARE INTERRUPTS WAITING TO HAPPEN node* interrupt_list_head = my_top(interrupt_list); while (interrupt_list_head != NULL && interrupt_list_head->inst_no <= num_instr_executed) { printf ("Instruction number %d\n", interrupt_list_head->inst_no); // service interrupt here struct ctx_t *interrupting_process_context = interrupt_list_head->ctx; if (!ctx_get_status(interrupting_process_context, ctx_suspended)) { printf("suspended process is not suspended which means we don't know what is happening\n"); fflush(stdout); return; } printf("Inside the ISR1\n"); fflush(stdout); ke_list_remove(ke_list_suspended, interrupting_process_context); //ctx_set_status(interrupting_process_context, ctx_running); interrupting_process_context->status = ctx_running; ke_list_insert_tail(ke_list_running, interrupting_process_context); my_delete(interrupt_list); interrupt_list_head = my_top(interrupt_list); } fflush(stdout); ctx_execute_inst(ctx); num_instr_executed++; fflush(stdout); } ctx = ctx_temp; } /* Free finished contexts */ while (ke->finished_list_head) ctx_free(ke->finished_list_head); /* Process list of suspended contexts */ // ke_process_events(); }