pintOS - project1(Thread) thread.c - mlfqs

thread.c - mlfqs

< calculate_advanced_priority >

// 스레드의 고급 우선순위를 계산
int calculate_advanced_priority(struct thread* t){
	// priority = PRI_MAX - (recent_cpu / 4) - (nice * 2) 공식 이용
	int advanced_priority;
	advanced_priority = PRI_MAX - ROUND_TO_INT(DIV_INT(t->recent_cpu, 4)) - t->nice_value * 2;
	
	return advanced_priority;
}

< thread_set_nice >

// 현재 스레드의 nice값 설정
void
thread_set_nice (int nice) {
	ASSERT(thread_mlfqs == true) // mlfqs가 실행이 안됐으면 종료

	// 현재 스레드의 nice값을 인자 nice로 저장
	thread_current()->nice_value = nice;
	// new_priority에 현재 스레드의 고급 우선순위를 계산해 넣는다.
	int new_priority = calculate_advanced_priority(thread_current());

	// 스레드 우선도를 설정
	thread_set_priority(new_priority);
}

< thread_get_nice >

// 스레드의 nice를 가져온다.
int
thread_get_nice (void) {
	ASSERT(thread_mlfqs == true) // mlfqs가 실행되지 않았으면 종료

	return thread_current()->nice_value; // 현재 스레드의 nice 값을 반환
}

< update_load_avg >

// 평균 부하를 업데이트
void 
update_load_avg(){
	ASSERT(thread_mlfqs == true) // mlfqs가 실행되어 있지 않으면 종료

	struct thread* t = thread_current();
	int ready;

	ready = list_size(&ready_list); // ready에 ready_list의 리스트 크기를 저장

	// 현재 스레드가 유휴 스레드가 아니면 ready를 증가
	if (t != idle_thread)
		ready ++;
	
	// load_avg = (59/60) * load_avg + (1/60) * ready_threads 공식 계산
	load_avg = ADD_FIXED(MUL_FIXED(DIV_INT(FIXED_POINT(59), 60), load_avg),MUL_INT(DIV_INT(F,60),ready));
}

< thread_get_load_avg >

// 스레드의 평균 부하를 가져오기
int
thread_get_load_avg (void) {
	ASSERT(thread_mlfqs == true)
	
	// #define ROUND_TO_INT(x) (x >= 0 ? ((x + F / 2) /F) : ((x - F / 2 ) /F))
	// 매크로를 사용해 평균 부하를 계산해 반환
	int return_load_avg = ROUND_TO_INT(MUL_INT((load_avg), 100));
	
	return return_load_avg;
}

< calculating_recent_cpu >

// recent_cpu 계산
int
calculating_recent_cpu(struct thread* t){
	
	ASSERT(thread_mlfqs == true);

	// recent에 스레드의 recent_cpu 저장
	int recent = t->recent_cpu;
	// recent_cpu = (2 * load_avg) / (2 * load_avg + 1) * recent_cpu + nice 공식 계산
	recent = ADD_INT(MUL_FIXED(DIV_FIXED(MUL_INT(load_avg, 2), ADD_INT(MUL_INT(load_avg, 2),1)),recent),t->nice_value);

	// 스레드의 recent_cpu에 recent를 저장하고 반환
	t->recent_cpu = recent;

	return recent;
}

< calc_all_recent_cpu >

// 시스템의 모든 스레드의 recent_cpu 계산
void calc_all_recent_cpu(){
	// all_list가 비어있다면 종료
	if (list_empty(&all_list))
		return;
	
	// all_list의 맨 앞 스레드를 e에 저장 (밑 for문에서 다시 가져오는데 필요할까 싶다)
	struct list_elem*e = list_front(&all_list);
	struct thread *t;
	// e에 all_list의 첫 스레드를 넣고 끝까지 순회
	for (e = list_begin (&all_list); e != list_end (&all_list); e = list_next (e)){
		// t에 e의 구조체 스레드를 가져와 recent_cpu를 계산한 값을 저장
		t = list_entry(e, struct thread, all_elem);
		t->recent_cpu = calculating_recent_cpu(t);
	}	
}

< thread_get_recent_cpu >

// 스레드의 recent_cpu 가져오기
int
thread_get_recent_cpu (void) {
	ASSERT(thread_mlfqs == true)
	
	// ROUND_TO_INT 매크로로 계산해 return_value에 넣고 반환
	int return_value = ROUND_TO_INT(MUL_INT(calculating_recent_cpu(thread_current()), 100));

	return return_value;
}

< apply_to_all >

// 모든 스레드에 대해 calculating_recent_cpu 수행
void apply_to_all(){
	struct list_elem *e;
	struct thread *t;
	// e에 모든 리스트의 첫 요소를 넣고 리스트의 끝까지 순회
	for (e = list_begin (&all_list); e != list_end (&all_list); e = list_next (e)){
		t = list_entry(e, struct thread, all_elem); // e가 있는 all_elem의 thread 포인터를 t에 저장
		calculating_recent_cpu(t); // 최근 cpu 사용량 실행
	}
}

< advanced_scheduling >

// 고급 우선도 스케줄링 정렬
static bool advanced_scheduling(const struct list_elem *a_, const struct list_elem *b_,
            void *aux UNUSED){
  // 스레드 a와 b를 가져와 비교해서 a가 작으면 true 반환 크면 false 반환
	const struct thread *a = list_entry (a_, struct thread, all_elem);
	const struct thread *b = list_entry (b_, struct thread, all_elem);

	return a->priority > b->priority;
}