int readCpuCounters(SFLHost_cpu_counters *cpu) { int gotData = NO; kstat_ctl_t *kc; kstat_t *ksp = NULL; kstat_named_t *knp; kc = kstat_open(); if (NULL == kc) { myLog(LOG_ERR, "readCpuCounters kstat_open() failed"); } else { ksp = kstat_lookup(kc, "unix", 0, "system_misc"); if (NULL == ksp) { myLog(LOG_ERR, "kstat_loockup error (unix:*:system_misc:*)"); } } if (NULL != ksp) { if (-1 == kstat_read(kc, ksp, NULL)) { myLog(LOG_ERR, "kstat_read error (module: %s, name: %s, class: %s)", ksp->ks_module, ksp->ks_name, ksp->ks_class); } else { // load_one knp = kstat_data_lookup(ksp, "avenrun_1min"); cpu->load_one = (float)knp->value.ui32; // load_five knp = kstat_data_lookup(ksp, "avenrun_5min"); cpu->load_five = (float)knp->value.ui32; // load_fifteen knp = kstat_data_lookup(ksp, "avenrun_15min"); cpu->load_fifteen = (float)knp->value.ui32; // proc_total knp = kstat_data_lookup(ksp, "nproc"); cpu->proc_total = knp->value.ui32; // cpu_num knp = kstat_data_lookup(ksp, "ncpus"); cpu->cpu_num = knp->value.ui32; // uptime knp = kstat_data_lookup(ksp, "boot_time"); time_t boot = knp->value.ui32; time_t uptime = time(NULL) - boot; cpu->uptime = uptime; gotData = YES; } } ksp = kstat_lookup(kc, "cpu_info", -1, NULL); if (NULL == ksp) { myLog(LOG_ERR, "kstat_loockup error (cpu_info:*:cpu_info0:*)"); } if (NULL != ksp) { if (-1 == kstat_read(kc, ksp, NULL)) { myLog(LOG_ERR, "kstat_read error (module: %s, name: %s, class: %s)", ksp->ks_module, ksp->ks_name, ksp->ks_class); } else { // cpu_speed knp = kstat_data_lookup(ksp, "clock_MHz"); cpu->cpu_speed = (uint32_t)knp->value.i32; gotData = YES; } } // running processes int running = runningProcesses(); if(running > 0) { cpu->proc_run = running; gotData = YES; } // From Ganglia's libmetrics #define CPUSTATES 5 #define CPUSTATE_IDLE 0 #define CPUSTATE_USER 1 #define CPUSTATE_KERNEL 2 #define CPUSTATE_IOWAIT 3 #define CPUSTATE_SWAP 4 cpu_stat_t cpu_stat; int cpu_id = sysconf(_SC_NPROCESSORS_ONLN); uint64_t cpu_info[CPUSTATES] = { 0 }; long stathz = sysconf(_SC_CLK_TCK); uint64_t interrupts = 0; uint64_t contexts = 0; #ifndef KSNAME_BUFFER_SIZE #define KSNAME_BUFFER_SIZE 32 #endif #define STATHZ_TO_MS(t) (((t) * 1000) / stathz) char ks_name[KSNAME_BUFFER_SIZE]; int i, n; for (i = 0; cpu_id > 0; i++) { n = p_online(i, P_STATUS); if (1 == n || (-1 == n && EINVAL == errno)) { continue; } snprintf(ks_name, KSNAME_BUFFER_SIZE, "cpu_stat%d", i); cpu_id--; ksp = kstat_lookup(kc, "cpu_stat", i, ks_name); if (NULL == ksp) { myLog(LOG_ERR, "kstat_lookup error (module: cpu_stat, inst: %d, name %s)", i, ks_name); continue; } if (-1 == kstat_read(kc, ksp, &cpu_stat)) { myLog(LOG_ERR, "kstat_read error (module: %s, name: %s, class: %s)", ksp->ks_module, ksp->ks_name, ksp->ks_class); continue; } if(debug>1) { myLog(LOG_INFO, "adding cpu stats for cpu=%d (idle=%u user=%u wait=%u swap=%u kernel=%u)", cpu_id, cpu_stat.cpu_sysinfo.cpu[CPU_IDLE], cpu_stat.cpu_sysinfo.cpu[CPU_USER], cpu_stat.cpu_sysinfo.wait[W_IO] + cpu_stat.cpu_sysinfo.wait[W_PIO], cpu_stat.cpu_sysinfo.wait[W_SWAP], cpu_stat.cpu_sysinfo.cpu[CPU_KERNEL]); } cpu_info[CPUSTATE_IDLE] += cpu_stat.cpu_sysinfo.cpu[CPU_IDLE]; cpu_info[CPUSTATE_USER] += cpu_stat.cpu_sysinfo.cpu[CPU_USER]; cpu_info[CPUSTATE_IOWAIT] += cpu_stat.cpu_sysinfo.wait[W_IO] + cpu_stat.cpu_sysinfo.wait[W_PIO]; cpu_info[CPUSTATE_SWAP] += cpu_stat.cpu_sysinfo.wait[W_SWAP]; cpu_info[CPUSTATE_KERNEL] += cpu_stat.cpu_sysinfo.cpu[CPU_KERNEL]; interrupts += cpu_stat.cpu_sysinfo.intr + cpu_stat.cpu_sysinfo.trap; contexts += cpu_stat.cpu_sysinfo.pswitch; gotData = YES; } // cpu_user cpu->cpu_user = (uint32_t)STATHZ_TO_MS(cpu_info[CPUSTATE_USER]); // cpu_nice SFL_UNDEF_COUNTER(cpu->cpu_nice); // cpu_system cpu->cpu_system = (uint32_t)STATHZ_TO_MS(cpu_info[CPUSTATE_KERNEL]); // cpu_idle cpu->cpu_idle = (uint32_t)STATHZ_TO_MS(cpu_info[CPUSTATE_IDLE]); // cpu_wio cpu->cpu_wio = (uint32_t)STATHZ_TO_MS(cpu_info[CPUSTATE_IOWAIT]); // cpu_intr SFL_UNDEF_COUNTER(cpu->cpu_intr); // cpu_sintr SFL_UNDEF_COUNTER(cpu->cpu_sintr); // interrupts cpu->interrupts = interrupts; // contexts cpu->contexts = contexts; if(kc) kstat_close(kc); return gotData; }
int main() { clock_t ticks; time_t start_time, end_time; time(&start_time); int i; int status = 0; log_file = fopen("log_file.txt", "w+"); if (log_file == NULL) { fprintf(stderr, "LOG FILE CANNOT BE OPEN\n"); } // initialize cpus for (i = 0; i < NUMBER_OF_PROCESSORS; i++) { CPU[i] = NULL; } init_(); initializeProcessQueue(&readyQueue); initializeProcessQueue(&waitingQueue); // read in process and initialize process values while ((status = (readProcess(&processes[number_of_processes])))) { if (status == 1) { number_of_processes++; } if (number_of_processes > MAX_PROCESSES || number_of_processes == 0) { break; } } //sort process by their arrival times qsort(processes, number_of_processes, sizeof (process), compareByArrival); // main execution loop while (TRUE) { ticks = clock(); incoming_process_init(); running_process_to_waiting(); most_ready_running_in_cpu(); waiting_to_ready(); refresh_processes(); cpu_utilized_time += runningProcesses(); simulation_time++; // break when there are no more running or incoming processes, and the waiting queue is empty if (runningProcesses() == 0 && (number_of_processes - nextProcess) == 0 && waitingQueue.size == 0) { break; } } // calculations based on CPU simulations int total_waiting_time = 0; int turn_around_time = 0; for (i = 0; i < number_of_processes; i++) { turn_around_time += processes[i].endTime - processes[i].arrivalTime; total_waiting_time += processes[i].waitingTime; } printf("********************************************************************\n"); printf("Average Waiting Time\t\t\t:%.2f\n", total_waiting_time / (double) number_of_processes); printf("Average Turn Around Time\t\t:%.2f\n", turn_around_time / (double) number_of_processes); printf("Time all for all CPU processes\t\t:%d\n", simulation_time); printf("CPU Utilization Time\t\t\t:%.2f%c\n", (double) (cpu_utilized_time * 100.0) / (double) (simulation_time), (int) 37); printf("Total Number of Context Switches\t:%d\n", context_switches); printf("Last Process to finish "); for (i = 0; i < number_of_processes; i++) { if (processes[i].endTime == last_process_end_time) { printf("PID\t\t:%d\n", processes[i].pid); } } //printf("%d\n" , processes[number_of_processes].pid); printf("********************************************************************\n"); time(&end_time); double prg_time = (end_time - start_time) * 0.001; double cpu_time = (double) ticks / CLOCKS_PER_SEC; fprintf(log_file, "Program Time\t:%.2fsecs\n", prg_time); fprintf(log_file, "CPU Time\t:%.2fsecs\n", cpu_time); fclose(log_file); return 0; }
int main(int argc, char **argv) { if (argc < 3) { fprintf(stderr, "Please enter a time quantums . . . . \n"); exit(1); } time_slice = atoi(argv[1]); time_slice_1 = atoi(argv[2]); if (time_slice <= 0 || time_slice_1 <= 0) { fprintf(stderr, "Error! program usage rr < positive time quantum> < data file . . .\n"); exit(1); } init_(); clock_t ticks; time_t start_time, end_time; time(&start_time); int i; int status = 0; log_file = fopen("log_file.txt", "w+"); if (log_file == NULL) { fprintf(stderr, "LOG FILE CANNOT BE OPEN\n"); } //initialize cpu's for (i = 0; i < NUMBER_OF_PROCESSORS; i++) { CPU[i] = NULL; } initializeProcessQueue(&readyQueue); initializeProcessQueue(&waitingQueue); initializeProcessQueue(&level_one); initializeProcessQueue(&second_level); //initializeProcessQueue(&promoted); // read in process and initialize process values while ((status = (readProcess(&processes[number_of_processes])))) { if (status == 1) { number_of_processes++; } } if (number_of_processes > MAX_PROCESSES) { return -2; } if (number_of_processes == 0) { return -1; } int remaining_process = 0; //sort process by their arrival times qsort(processes, number_of_processes, sizeof (process), compareByArrival); // main execution loop while (TRUE) { ticks = clock(); waiting_to_ready(); incoming_process_init(); running_process_to_waiting(); most_ready_running_in_cpu(); refresh_processes(); increase_io_work(); increase_cpu_work(); cpu_utilized_time += runningProcesses(); remaining_process = ex(); // break when there are no more running or incoming processes, and the waiting queue is empty if (remaining_process == 0 && runningProcesses() == 0 && waitingQueue.size == 0) { break; } simulation_time++; } int total_waiting_time = 0; int turn_around_time = 0; for (i = 0; i < number_of_processes; i++) { turn_around_time += processes[i].endTime - processes[i].arrivalTime; total_waiting_time += processes[i].waitingTime; } printf(">>>>>>>>>>>>> FBQ with Q1 :%d\tQ2 :%d <<<<<<<<<<<<<<<\n", time_slice, time_slice_1); printf("********************************************************************\n"); printf("Average Waiting Time\t\t\t:%.2f\n", total_waiting_time / (double) number_of_processes); printf("Average Turn Around Time\t\t:%.2f\n", turn_around_time / (double) number_of_processes); printf("Time all for all CPU processes\t\t:%d\n", simulation_time); printf("CPU Utilization Time\t\t\t:%.2f%c\n", (double) (cpu_utilized_time * 100.0) / (double) (simulation_time), (int) 37); printf("Total Number of Context Switches\t:%d\n", context_switches); printf("Last Process to finish "); for (i = 0; i < number_of_processes; i++) { if (processes[i].endTime == simulation_time) { printf("PID\t\t:%d\n", processes[i].pid); } } printf("********************************************************************\n"); time(&end_time); double prg_time = (end_time - start_time) * 0.001; double cpu_time = (double) ticks / CLOCKS_PER_SEC; fprintf(log_file, "Program Time\t:%.2fsecs\n", prg_time); fprintf(log_file, "CPU Time\t:%.2fsecs\n", cpu_time); fclose(log_file); return 0; }
int main(void) { int sumOfTurnaroundTimes = 0; int doneReading = 0; int i; /* read in all process data and populate processes array with the results */ initializeGlobals(); while (doneReading=readProcess(&processes[numberOfProcesses])) { if(doneReading==1) numberOfProcesses ++; if(numberOfProcesses > MAX_PROCESSES) break; } /* handle invalid number of processes in input */ if (numberOfProcesses == 0) { fprintf(stderr, "Error: no processes specified in input.\n"); return -1; } else if (numberOfProcesses > MAX_PROCESSES) { fprintf(stderr, "Error: too many processes specified in input; " "they cannot number more than %d.\n", MAX_PROCESSES); return -1; } /* sort the processes array ascending by arrival time */ qsort(processes, numberOfProcesses, sizeof(process), compareByArrival); /* run the simulation */ while (1) { moveIncomingProcesses(); /* admit any newly arriving processes */ moveRunningProcesses(); /* move procs that shouldn't be running */ moveWaitingProcesses(); /* move procs finished waiting to ready-Q */ moveReadyProcesses(); /* move ready procs into any free cpu slots */ updateWaitingProcesses(); /* update burst progress for waiting procs */ updateReadyProcesses(); /* update waiting time for ready procs */ updateRunningProcesses(); /* update burst progress for running procs */ cpuTimeUtilized += runningProcesses(); /* terminate simulation when: - no processes are running - no more processes await entry into the system - there are no waiting processes */ if (runningProcesses() == 0 && incomingProcesses() == 0 && waitingQueue.size == 0) break; simulationTime++; } for (i = 0; i < numberOfProcesses; i++) printf("Process #%d: Arrival=%d, Start=%d, End=%d, Waiting=%d\n", processes[i].pid, processes[i].arrivalTime, processes[i].startTime, processes[i].endTime, processes[i].waitingTime); /* compute and output performance metrics */ for (i=0;i<numberOfProcesses;i++) { sumOfTurnaroundTimes += processes[i].endTime - processes[i].arrivalTime; totalWaitingTime += processes[i].waitingTime; } printf("totalWaitingTime = %d\nnumberOfProcesses = %d\n", totalWaitingTime, numberOfProcesses); printf("Average waiting time : %.2f units\n" "Average turnaround time : %.2f units\n" "Time all processes finished : %d\n" "Average CPU utilization : %.1f%%\n" "Number of context switches : %d\n", totalWaitingTime / (double) numberOfProcesses, sumOfTurnaroundTimes / (double) numberOfProcesses, simulationTime, 100.0 * cpuTimeUtilized / simulationTime, totalContextSwitches); printf("PID(s) of last process(es) to finish :"); for (i=0;i<numberOfProcesses;i++) { if (processes[i].endTime == simulationTime) { printf(" %d", processes[i].pid); } } printf("\n"); return 0; }