[Pintos-KAIST] Project 3 :: Anonymous Page (Lazy Loading으로 메모리 효율성 높이기)

💡 이번 파트에서는 Anonymous page라고 불리는 non-disk based image를 구현한다.

Anonymous Page란?
파일을 기반으로 하는 file-backed page와 달리, 이름이 지정된 파일 소스가 없기 때문에 anonymous라고 불리며,
 스택과 힙 영역에서 사용된다.

 

Lazy Loading을 이용한 페이지 초기화

• Lazy loading은 메모리 로딩을 필요한 시점까지 미루는 디자인 패턴이다.
• Lazy Loading을 구현하기 위해서는 페이지를 할당할 때 해당 페이지에 대응하는 page 구조체만 만들고, 물리 frame 할당 ❌  실제 내용도 ❌ (아직은 로딩하지 않는다!)
• 그럼 내용은 언제 로드하지 ?! 👉🏻 실제로 내용이 로드되는 시점은 page fault가 발생하는 시점이다.
  page fault가 발생했다는 것은 이 주소에 접근했다는 것이고, 접근했다는 것은 실제로 내용이 필요한 시점이 되었다는 것을 의미한다.
  이 page fault 시그널을 받았을 때 내용이 로드되게 구현하면 Lazy Loading 완성~!

 

🤔 이거 왜 하지?

메모리 효율성을 위해서!

Lazy loading을 사용하면 프로세스가 필요한 페이지를 필요한 시점에 로드할 수 있고, 이렇게 함으로써 불필요한 메모리 사용을 줄일 수 있다.

 

Page initialization flow

페이지가 초기화되는 과정을 먼저 살펴보자.

• uninit 페이지 구조체 생성 : 커널이 새로운 페이지 요청을 받으면 vm_alloc_page_with_initializer 함수가 호출된다.
  • 이 함수는 페이지 구조체를 생성하고, 이 구조체에 페이지 유형에 맞는 적절한 초기화 함수들을 담아둔다.
    (초기화를 하지는 않고 초기화할 때 어떤 함수를 사용해야 하는지 담아만! 둔다.)
    이렇게 초기화되지 않은 상태의 페이지의 타입은 VM과 uninitialized의 약자를 합친 VM_UNINIT이다.
• lazy loading을 구현하게 되면, 위에서 언급한 바와 같이 user 프로그램이 새 페이지에 처음 접근했을 때 page fault가 발생하게 되는데, 그 이유는, 내용이 없을 뿐더러 할당된 물리 프레임도 없기 때문이다!
• page fault가 발생했을 때 접근한 메모리의 physical frame이 존재하지 않다는 것이 확인된다면 이때가 바로 loading이 필요한 시점이다!
  이때 물리 프레임을 할당하고나서 uninit_initialize가 호출되면서 앞서 설정한 초기화 함수들이 호출되어 드디어 초기화가 이루어진다.
  • 초기화 함수는 익명 페이지의 경우 anon_initializer, 파일 기반 페이지의 경우 file_backed_initializer이다.
  • 페이지 별 초기화 함수 외에도 lazy_load_segment 함수가 호출되며 이 함수에서 내용이 로드된다.

 

Lazy Loading for Executable

💡 Implement vm_alloc_page_with_initializer().

1) vm_alloc_page_with_initializer

🔥 목표: page 구조체를 생성하고 적절한 초기화 함수를 설정한다.

page 구조체 생성

• page 구조체를 하나 할당받는다.

uninit 타입으로 초기화 & 초기화 함수 설정

• uninit_new 함수의 역할은 여기서는 uninit 타입으로 초기화시킨다고만 알아두고, 아래에서 자세히 알아볼 것이다!
• 이 page를 uninit 타입으로 초기화하기 위해서 uninit_new 함수를 호출해야 하는데,
  uninit_new 함수를 호출할 때 필요한 인자는 아래와 같다.
  • p 초기화할 page 구조체
  • upage p를 할당할 가상 주소
  • init p의 내용을 초기화하는 함수
  • aux init에 필요한 보조값
  • initializer p를 타입에 맞게 초기화하는 함수
• 인자 중에서 p는 위에서 할당받은 page 구조체를 넣어주면 되고, upage, init, aux는 일단 vm_alloc_page_with_initializer가 전달 받은 매개변수들을 그대로 전달하면 된다. (아래에서 설명)
• 마지막 인자인 initializer는 매개변수로 들어온 type에 따라 분기가 필요한데,
  1) anon 타입이면 anon_initializer를, 2) file_backed 타입이면 file_backed_initializer를 함수 포인터로 전달해야 한다.
  • 실제로 C 언어에는 "클래스"나 "상속"이 없지만, 객체 지향 프로그래밍의 "클래스 상속" 개념을 도입하기 위해 함수 포인터를 사용한다.
  • 함수 포인터를 전달한다는 것이 생소하게 느껴지는데,
    uninit_new 함수에 선언되어 있는 함수 포인터의 타입인 bool (*initializer)(struct page *, enum vm_type, void *) 의 리턴 타입과 매개변수의 타입이 일치하는 함수를 전달하면 된다.
  • initializer라는 이름은 매개변수의 이름에 불과하므로 이름은 달라져도 상관 없다.
  • 함수 자체가 주소값을 지니기 때문에 & 기호 없이 함수명만 전달하면 된다.
  • 위 타입으로 선언해두고 변수처럼 값을 바꾸는 방식으로 구현했다.

page 구조체의 필드 수정

• 매개변수 writable을 page 구조체의 writable 필드에 할당한다.
  • (이를 위해 먼저 page 구조체에 writable 필드를 추가해야 한다.)
  • 필드의 값을 수정할 때는 uninit_new 함수가 호출된 이후에 수정해야 한다.
    Why? uninit_new 함수 안에서 구조체 내용이 전부 새로 할당되기 때문이다. uninit_new 함수 호출 이전에는 아무리 값을 추가해도 다 날라가니 순서에 유의해야 한다!!!

page를 SPT에 삽입

• page를 새로 만들었으니 page table에 추가해야겠지! 초기화가 완료된 page를 프로세스의 SPT에 삽입하면 끝!

 

함수 구현을 마쳤으니, 이제부터는 페이지를 생성할 때 이 함수를 사용해서 생성하면 된다.
(Lazy Loading이 필요 없는 페이지를 생성할 때는 vm_alloc_page을 사용해도 된다.)

bool vm_alloc_page_with_initializer(enum vm_type type, void *upage, bool writable,
                                    vm_initializer *init, void *aux)
{
    ASSERT(VM_TYPE(type) != VM_UNINIT)

    struct supplemental_page_table *spt = &thread_current()->spt;

    /* Check wheter the upage is already occupied or not. */
    // upage가 이미 사용 중인지 확인합니다.
    if (spt_find_page(spt, upage) == NULL)
    {
        /* TODO: Create the page, fetch the initialier according to the VM type,
         * TODO: and then create "uninit" page struct by calling uninit_new. You
         * TODO: should modify the field after calling the uninit_new. */
         
        // 1) 페이지를 생성하고,
        struct page *p = (struct page *)malloc(sizeof(struct page));
        
        // 2) type에 따라 초기화 함수를 가져와서
        bool (*page_initializer)(struct page *, enum vm_type, void *);

        switch (VM_TYPE(type))
        {
        case VM_ANON:
            page_initializer = anon_initializer;
            break;
        case VM_FILE:
            page_initializer = file_backed_initializer;
            break;
        }

        // 3) "uninit" 타입의 페이지로 초기화한다.
        uninit_new(p, upage, init, type, aux, page_initializer);

        // 필드 수정은 uninit_new를 호출한 이후에 해야 한다.
        p->writable = writable;

        // 4) 생성한 페이지를 SPT에 추가한다.
        return spt_insert_page(spt, p);
    }
err:
    return false;
}

 

위에서 사용한 uninit_new 함수의 흐름을 따라가보자!

uninit_new 함수가 하는 일

• uninit_new 함수에서는 매개변수로 받은 page 구조체를 uninit type으로 만든다.
  (page 구조체는 uninit/anon/file/page_cache 중 한가지 타입을 가지는데, 여기서는 uninit 타입으로 만드는 거니까 page 구조체에 uninit 필드가 생기는 것이다.)
• page->operations에는 uninit_ops가 담기는데 이 구조체를 보면 swap_in에 uninit_initialize가 담겨있다.
  페이지가 실제로 로딩될 때 이 swap_in(에 담긴 uninit_initialize)가 호출되게 되면서 (uninit 페이지의) 초기화가 이루어진다.
  (uninit_initialize 안에서 지금 설정하는 초기화 함수들이 호출된다.)
  👇🏻 uninit_ops 구조체
  
   
  
• page->uninit->init에는 매개변수로 받은 init이 담기는데 함수 호출을 거슬러 올라가보면 process.c의 load_segment 함수에서 vm_alloc_page_with_initializer를 호출할 때 init 인자로 lazy_load_segment를 전달한 것을 알 수 있다.
  
  
• page->uninit->page_initializer에는 매개변수로 받은 initializer가 담기게 되는데, 지금은 ANON 타입의 페이지를 할당했으므로 anon_initializer가 담길 것이다.
• 페이지가 실제로 로딩될 때(첫번째 page fault가 발생했을 때) 호출되는 swap_in은 page_fault에서 이어지는 vm_do_claim_page 함수에서 호출되고 있는 것을 볼 수 있다.
  

• swap_in에 담겨있던 uninit_initialize에서는 uninit->page_initializer와 uninit->init이 호출되는데, 위에서 확인한 바와 같이
  uninit->page_initializer에는 anon_initializer, uninit->init에는 lazy_load_segment가 담겨있어 이 두 함수가 각각 호출된다.
  

• 정리해보면, 첫번째 page fault가 발생하면서
  vm_do_claim_page 함수에서 매핑이 이루어진 이후에 (swap_in에 해당하는) uninit_initialize 함수가 호출되고,
  그 안에서 각 페이지 타입 별 초기화 함수와 내용을 로드하는 함수(lazy_load_segment)가 호출되는 것이다.

 

 

이어서 내용을 로드하는 함수인 load_segment와 lazy_load_segment를 살펴보자!

💡 Implement load_segment and lazy_load_segment in userprog/process.c.

2) load_segment

• 이 함수는 프로세스가 실행될 때 실행 파일을 현재 스레드로 로드하는 함수인 load 함수에서 호출된다.
• 파일의 내용을 upage에 로드하는 함수이다.
  파일의 내용을 로드하기 위해서 upage를 할당할 page가 필요한데, 위에서 수정한 vm_alloc_page_with_initializer 함수를 호출해서 페이지를 생성한다.
• Lazy Loading을 사용해야 하므로, 여기서 바로 파일의 내용을 로드하지 않아야 한다.
  그래서 page에 내용을 로드할 때 사용할 함수와 필요한 인자들을 넣어줘야 하는데,
  vm_alloc_page_with_initializer 함수의 네 번째, 다섯 번째 인자가 각각 로드할 때 사용할 함수, 그리고 그때 필요한 인자에 해당한다.
• 내용을 로드할 때 사용할 함수는 lazy_load_segment를 사용하고, 인자는 직접 만들어서 넘겨주어야 한다.
  lazy_load_segment에서 필요한(인자로 넘겨줘야 할) 정보는 아래와 같다.
  • `file` 내용이 담긴 파일 객체 
  • `ofs` 이 페이지에서 읽기 시작할 위치 
  • `read_bytes` 이 페이지에서 읽어야 하는 바이트 수 
  • `zero_bytes` 이 페이지에서 read_bytes만큼 읽고 공간이 남아 0으로 채워야 하는 바이트 수 
  • lazy_load_arg라는 구조체를 새로 정의해서 선언하고 안에 위 정보들을 담아서 vm_alloc_page_with_initializer 함수의 마지막 인자로 전달했다.
• 이제 page fault가 처음 발생했을 때, lazy_load_segment가 실행되고 lazy_load_arg가 인자로 사용되어 내용이 로딩될 것이다.

static bool
load_segment(struct file *file, off_t ofs, uint8_t *upage,
			 uint32_t read_bytes, uint32_t zero_bytes, bool writable)
{
	ASSERT((read_bytes + zero_bytes) % PGSIZE == 0); // read_bytes + zero_bytes가 페이지 크기(PGSIZE)의 배수인지 확인
	ASSERT(pg_ofs(upage) == 0);						 // upage가 페이지 정렬되어 있는지 확인
	ASSERT(ofs % PGSIZE == 0)						 // ofs가 페이지 정렬되어 있는지 확인;

	while (read_bytes > 0 || zero_bytes > 0) // read_bytes와 zero_bytes가 0보다 큰 동안 루프를 실행
	{
		/* Do calculate how to fill this page.
		 * We will read PAGE_READ_BYTES bytes from FILE
		 * and zero the final PAGE_ZERO_BYTES bytes. */
		// 이 페이지를 채우는 방법을 계산합니다. 파일에서 PAGE_READ_BYTES 만큼 읽고	나머지 PAGE_ZERO_BYTES 만큼 0으로 채웁니다.
		size_t page_read_bytes = read_bytes < PGSIZE ? read_bytes : PGSIZE; // 최대로 읽을 수 있는 크기는 PGSIZE
		size_t page_zero_bytes = PGSIZE - page_read_bytes;

		/* TODO: Set up aux to pass information to the lazy_load_segment. */
		// vm_alloc_page_with_initializer에 제공할 aux 인수로 필요한 보조 값들을 설정해야 합니다.
		// loading을 위해 필요한 정보를 포함하는 구조체를 만들어야 합니다.
		struct lazy_load_arg *lazy_load_arg = (struct lazy_load_arg *)malloc(sizeof(struct lazy_load_arg));
		lazy_load_arg->file = file;					 // 내용이 담긴 파일 객체
		lazy_load_arg->ofs = ofs;					 // 이 페이지에서 읽기 시작할 위치
		lazy_load_arg->read_bytes = page_read_bytes; // 이 페이지에서 읽어야 하는 바이트 수
		lazy_load_arg->zero_bytes = page_zero_bytes; // 이 페이지에서 read_bytes만큼 읽고 공간이 남아 0으로 채워야 하는 바이트 수
		// vm_alloc_page_with_initializer를 호출하여 대기 중인 객체를 생성합니다.
		if (!vm_alloc_page_with_initializer(VM_ANON, upage,
											writable, lazy_load_segment, lazy_load_arg))
			return false;

		/* Advance. */
		// 다음 반복을 위하여 읽어들인 만큼 값을 갱신합니다.
		read_bytes -= page_read_bytes;
		zero_bytes -= page_zero_bytes;
		upage += PGSIZE;
		ofs += page_read_bytes;
	}
	return true;
}

3) lazy_load_segment

• 이 함수는 실행 파일의 내용을 페이지로 로딩하는 함수이며 첫번째 page fault가 발생할 때 호출된다.
• 이 함수가 호출되기 이전에 물리 프레임 매핑이 진행되므로, 여기서는 물리 프레임에 내용을 로딩하는 작업만 하면 된다.
• 이 함수는 페이지 구조체와 aux를 인자로 받는다.
  • aux는 load_segment에서 로딩을 위해 설정해둔 정보인 lazy_load_arg이다.
  • 이 정보를 사용하여 읽어올 파일을 찾아서 메모리에 로딩한다.

bool lazy_load_segment(struct page *page, void *aux)
{
	/* TODO: Load the segment from the file */
	/* TODO: This called when the first page fault occurs on address VA. */
	/* TODO: VA is available when calling this function. */

	struct lazy_load_arg *lazy_load_arg = (struct lazy_load_arg *)aux;

	// 1) 파일의 position을 ofs으로 지정한다.
	file_seek(lazy_load_arg->file, lazy_load_arg->ofs);
	// 2) 파일을 read_bytes만큼 물리 프레임에 읽어 들인다.
	if (file_read(lazy_load_arg->file, page->frame->kva, lazy_load_arg->read_bytes) != (int)(lazy_load_arg->read_bytes))
	{
		palloc_free_page(page->frame->kva);
		return false;
	}
	// 3) 다 읽은 지점부터 zero_bytes만큼 0으로 채운다.
	memset(page->frame->kva + lazy_load_arg->read_bytes, 0, lazy_load_arg->zero_bytes);

	return true;
}

4) setup_stack

• 이 함수도 프로세스가 실행될 때 load 함수 안에서 호출되며, STACK의 페이지를 생성하는 함수이다.
• 스택은 아래로 성장하므로, 스택의 시작점인 USER_STACK에서 PGSIZE만큼 아래로 내린 지점(stack_bottom)에서 페이지를 생성한다.
• 첫 번째 스택 페이지는 Lazy Loading을 할 필요가 없다. 프로세스가 실행될 때 이 함수가 불리고 나서 command line arguments를 스택에 추가하기 위해 이 주소에 바로 접근하기 때문이다.
  따라서, 이 주소에서 fault가 발생할 때까지 기다릴 필요없이 바로 물리 프레임을 할당받아 놓는다.
• 페이지를 할당받을 때 이 페이지가 스택의 페이지임을 표시하기 위해서 보조 마커를 사용할 수 있다.
  사용 방법은 페이지를 할당 받을 때 타입과 함께 VM_MARKER_0를 사용해서 스택 페이지를 표시했다. 👉🏻 스택에서 할당 받는 페이지에 이 마커로 표시를 해두면, 나중에 이 페이지가 스택의 페이지인지 아닌지 마커를 통해서 알 수 있음!
• 마지막으로, rsp 값을 USER_STACK으로 변경해준다. 이제 argument_stack 함수에서 이 위치(rsp)부터 인자를 push하게 된다.

static bool
setup_stack(struct intr_frame *if_)
{
	bool success = false;

	// 스택은 아래로 성장하므로, USER_STACK에서 PGSIZE만큼 아래로 내린 지점에서 페이지를 생성한다.
	void *stack_bottom = (void *)(((uint8_t *)USER_STACK) - PGSIZE);

	/* TODO: Map the stack on stack_bottom and claim the page immediately.
	 * TODO: If success, set the rsp accordingly.
	 * TODO: You should mark the page is stack. */
	/* TODO: stack_bottom에 스택을 매핑하고 페이지를 즉시 요청하세요.
	 * TODO: 성공하면, rsp를 그에 맞게 설정하세요.
	 * TODO: 페이지가 스택임을 표시해야 합니다. */
	/* TODO: Your code goes here */

	// 1) stack_bottom에 페이지를 하나 할당받는다.
	if (vm_alloc_page(VM_ANON | VM_MARKER_0, stack_bottom, 1))
	// VM_MARKER_0: 스택이 저장된 메모리 페이지임을 식별하기 위해 추가
	// writable: argument_stack()에서 값을 넣어야 하니 True
	{
		// 2) 할당 받은 페이지에 바로 물리 프레임을 매핑한다.
		success = vm_claim_page(stack_bottom);
		if (success)
			// 3) rsp를 변경한다. (argument_stack에서 이 위치부터 인자를 push한다.)
			if_->rsp = USER_STACK;
	}
	return success;
}

5) vm_try_handle_fault

• 마지막으로, spt_find_page를 통해 SPT를 참조하여 faulted address에 해당하는 페이지 구조체를 해결하도록 vm_try_handle_fault 함수를 수정해야 합니다.
• page_fault가 발생하면 제어권을 전달 받는 함수이다.
• 이 함수에서 할당된 물리 프레임이 존재하지 않아서 발생한 예외일 경우에는 매개변수인 not_present에 true를 전달받는다.
  그럴 경우, SPT에서 해당 주소에 해당하는 페이지가 있는지 확인해서 존재한다면 해당 페이지에 물리 프레임 할당을 요청하는 vm_do_claim_page 함수를 호출한다.
  이 함수에서는 위에서 설정한대로 각 페이지에 맞는 초기화 함수가 호출된다.
• not_present 값이 false인 상황을 살펴보면,
  물리 프레임이 할당되어 있지만 page fault가 일어난 것이므로 그 경우는 read-only page에 write를 한 경우가 된다. 따라서 not_present가 false인 경우는 예외로 처리하면 된다. (return false)
• not_present가 true인 경우에도, read-only page에 write 요청을 할 경우가 생길 수 있으므로 이에 대한 예외 처리를 추가한다.

bool vm_try_handle_fault(struct intr_frame *f UNUSED, void *addr UNUSED,
                         bool user UNUSED, bool write UNUSED, bool not_present UNUSED)
{
    struct supplemental_page_table *spt UNUSED = &thread_current()->spt;
    struct page *page = NULL;
    if (addr == NULL)
        return false;

    if (is_kernel_vaddr(addr))
        return false;

    if (not_present) // 접근한 메모리의 physical page가 존재하지 않은 경우
    {
        /* TODO: Validate the fault */
        page = spt_find_page(spt, addr);
        if (page == NULL)
            return false;
        if (write == 1 && page->writable == 0) // write 불가능한 페이지에 write 요청한 경우
            return false;
        return vm_do_claim_page(page);
    }
    return false;
}

💡 여기까지 구현하면 fork를 제외한 프로젝트 2의 모든 테스트가 통과된다!

• Test 결과 (55 of 141 tests failed.)

    pass tests/userprog/args-none
    pass tests/userprog/args-single
    pass tests/userprog/args-multiple
    pass tests/userprog/args-many
    pass tests/userprog/args-dbl-space
    pass tests/userprog/halt
    pass tests/userprog/exit
    pass tests/userprog/create-normal
    pass tests/userprog/create-empty
    pass tests/userprog/create-null
    pass tests/userprog/create-bad-ptr
    pass tests/userprog/create-long
    pass tests/userprog/create-exists
    pass tests/userprog/create-bound
    pass tests/userprog/open-normal
    pass tests/userprog/open-missing
    pass tests/userprog/open-boundary
    pass tests/userprog/open-empty
    pass tests/userprog/open-null
    pass tests/userprog/open-bad-ptr
    pass tests/userprog/open-twice
    pass tests/userprog/close-normal
    pass tests/userprog/close-twice
    pass tests/userprog/close-bad-fd
    pass tests/userprog/read-normal
    pass tests/userprog/read-bad-ptr
    pass tests/userprog/read-boundary
    pass tests/userprog/read-zero
    pass tests/userprog/read-stdout
    pass tests/userprog/read-bad-fd
    pass tests/userprog/write-normal
    pass tests/userprog/write-bad-ptr
    pass tests/userprog/write-boundary
    pass tests/userprog/write-zero
    pass tests/userprog/write-stdin
    pass tests/userprog/write-bad-fd
    FAIL tests/userprog/fork-once
    FAIL tests/userprog/fork-multiple
    FAIL tests/userprog/fork-recursive
    FAIL tests/userprog/fork-read
    FAIL tests/userprog/fork-close
    FAIL tests/userprog/fork-boundary
    pass tests/userprog/exec-once
    pass tests/userprog/exec-arg
    FAIL tests/userprog/exec-boundary
    pass tests/userprog/exec-missing
    pass tests/userprog/exec-bad-ptr
    FAIL tests/userprog/exec-read
    FAIL tests/userprog/wait-simple
    FAIL tests/userprog/wait-twice
    FAIL tests/userprog/wait-killed
    pass tests/userprog/wait-bad-pid
    FAIL tests/userprog/multi-recurse
    FAIL tests/userprog/multi-child-fd
    pass tests/userprog/rox-simple
    FAIL tests/userprog/rox-child
    FAIL tests/userprog/rox-multichild
    pass tests/userprog/bad-read
    pass tests/userprog/bad-write
    pass tests/userprog/bad-read2
    pass tests/userprog/bad-write2
    pass tests/userprog/bad-jump
    pass tests/userprog/bad-jump2
    FAIL tests/vm/pt-grow-stack
    pass tests/vm/pt-grow-bad
    FAIL tests/vm/pt-big-stk-obj
    pass tests/vm/pt-bad-addr
    pass tests/vm/pt-bad-read
    pass tests/vm/pt-write-code
    FAIL tests/vm/pt-write-code2
    FAIL tests/vm/pt-grow-stk-sc
    pass tests/vm/page-linear
    FAIL tests/vm/page-parallel
    FAIL tests/vm/page-merge-seq
    FAIL tests/vm/page-merge-par
    FAIL tests/vm/page-merge-stk
    FAIL tests/vm/page-merge-mm
    pass tests/vm/page-shuffle
    FAIL tests/vm/mmap-read
    FAIL tests/vm/mmap-close
    FAIL tests/vm/mmap-unmap
    FAIL tests/vm/mmap-overlap
    FAIL tests/vm/mmap-twice
    FAIL tests/vm/mmap-write
    pass tests/vm/mmap-ro
    FAIL tests/vm/mmap-exit
    FAIL tests/vm/mmap-shuffle
    FAIL tests/vm/mmap-bad-fd
    FAIL tests/vm/mmap-clean
    FAIL tests/vm/mmap-inherit
    FAIL tests/vm/mmap-misalign
    FAIL tests/vm/mmap-null
    FAIL tests/vm/mmap-over-code
    FAIL tests/vm/mmap-over-data
    FAIL tests/vm/mmap-over-stk
    FAIL tests/vm/mmap-remove
    pass tests/vm/mmap-zero
    FAIL tests/vm/mmap-bad-fd2
    FAIL tests/vm/mmap-bad-fd3
    FAIL tests/vm/mmap-zero-len
    FAIL tests/vm/mmap-off
    FAIL tests/vm/mmap-bad-off
    FAIL tests/vm/mmap-kernel
    FAIL tests/vm/lazy-file
    pass tests/vm/lazy-anon
    FAIL tests/vm/swap-file
    FAIL tests/vm/swap-anon
    FAIL tests/vm/swap-iter
    FAIL tests/vm/swap-fork
    pass tests/filesys/base/lg-create
    pass tests/filesys/base/lg-full
    pass tests/filesys/base/lg-random
    pass tests/filesys/base/lg-seq-block
    pass tests/filesys/base/lg-seq-random
    pass tests/filesys/base/sm-create
    pass tests/filesys/base/sm-full
    pass tests/filesys/base/sm-random
    pass tests/filesys/base/sm-seq-block
    pass tests/filesys/base/sm-seq-random
    FAIL tests/filesys/base/syn-read
    pass tests/filesys/base/syn-remove
    FAIL tests/filesys/base/syn-write
    pass tests/threads/alarm-single
    pass tests/threads/alarm-multiple
    pass tests/threads/alarm-simultaneous
    pass tests/threads/alarm-priority
    pass tests/threads/alarm-zero
    pass tests/threads/alarm-negative
    pass tests/threads/priority-change
    pass tests/threads/priority-donate-one
    pass tests/threads/priority-donate-multiple
    pass tests/threads/priority-donate-multiple2
    pass tests/threads/priority-donate-nest
    pass tests/threads/priority-donate-sema
    pass tests/threads/priority-donate-lower
    pass tests/threads/priority-fifo
    pass tests/threads/priority-preempt
    pass tests/threads/priority-sema
    pass tests/threads/priority-condvar
    pass tests/threads/priority-donate-chain
    FAIL tests/vm/cow/cow-simple
    55 of 141 tests failed.

 

Project2의 fork 관련 테스트가 실패하고 있는데, 이는 자식 프로세스를 생성할 때 사용되는 함수를 구현하지 않았기 때문이다. 

자식 프로세스를 생성할 때 호출되는 __do_fork 함수에서 supplemental_page_table_copy 함수를 호출하는 것을 확인할 수 있다.

이어서 이 함수에 대해서 알아보자!

 

Supplemental Page Table - Revisit

• 자식 프로세스를 생성하거나 프로세스가 종료될 때 필요한 SPT를 복사하는 함수와 정리하는 함수 두 가지가 있다.

💡 Implement supplemental_page_table_copy and supplemental_page_table_kill in vm/vm.c.

6) supplemental_page_table_copy

• 자식 프로세스를 생성할 때 부모 프로세스의 SPT도 자식에게 상속해줘야 하는데, 그때 사용되는 함수이다.
• 부모 프로세스의 SPT에 있는 모든 페이지를 각 타입에 맞게 할당을 받고, uninit 상태가 아니라면, 즉 내용이 로딩된 상태라면 바로 매핑을 진행해서 내용까지 그대로 복사한다.
• file-backed page인 경우에는 다른 처리가 필요하지만 anonymous page 파트에서는 필요하지 않다. file-backed page를 할 때 추가하도록 하자!

bool supplemental_page_table_copy(struct supplemental_page_table *dst UNUSED,
                                  struct supplemental_page_table *src UNUSED)
{
    struct hash_iterator i;
    hash_first(&i, &src->spt_hash);
    while (hash_next(&i))
    {
        // src_page 정보
        struct page *src_page = hash_entry(hash_cur(&i), struct page, hash_elem);
        enum vm_type type = src_page->operations->type;
        void *upage = src_page->va;
        bool writable = src_page->writable;

        /* 1) type이 uninit이면 */
        if (type == VM_UNINIT)
        { // uninit page 생성 & 초기화
            vm_initializer *init = src_page->uninit.init;
            void *aux = src_page->uninit.aux;
            vm_alloc_page_with_initializer(VM_ANON, upage, writable, init, aux);
            continue;
        }

        /* 2) type이 uninit이 아니면 */
        if (!vm_alloc_page(type, upage, writable)) // uninit page 생성 & 초기화
            // init이랑 aux는 Lazy Loading에 필요함
            // 지금 만드는 페이지는 기다리지 않고 바로 내용을 넣어줄 것이므로 필요 없음
            return false;

        // vm_claim_page으로 요청해서 매핑 & 페이지 타입에 맞게 초기화
        if (!vm_claim_page(upage))
            return false;

        // 매핑된 프레임에 내용 로딩
        struct page *dst_page = spt_find_page(dst, upage);
        memcpy(dst_page->frame->kva, src_page->frame->kva, PGSIZE);
    }
    return true;
}

7) supplemental_page_table_kill

• 이 함수는 프로세스가 종료될 때와 실행될 때 process_cleanup()에서 호출된다.
• 페이지 항목들을 순회하며 테이블 내의 페이지들의 타입에 맞는 destroy 함수를 호출한다.
  
  • destroy 매크로를 사용하면 페이지 타입에 따라서 uninit_destroy 혹은 anon_destroy 함수가 호출된다.
  • 할당 받은 메모리가 있을 경우에는 이 페이지로 인해 유지되던 리소스를 해제해야 하지만, 현재는 별도로 할당 받은 메모리가 없어서 비워두었다.
• 여기서는 hash table은 두고 안의 요소들만 지워줘야 한다.
  • hash_destroy 함수를 사용하면 hash가 사용하던 메모리(hash->bucket) 자체도 반환하므로, hash_destroy가 아닌 hash_clear를 사용해야 한다.
  • Why? process가 실행될 때 hash table을 생성한 이후에 process_cleanup()이 호출되는데, 이때는 hash table은 남겨두고 안의 요소들만 제거되어야 한다.
    👉🏻 hash table까지 지워버리면 만들자마자 지워버리는 게 된다.. process가 실행될 때 빈 hash table이 있어야 하므로 hash table은 남겨두고 안의 요소들만 지워야 하는 것이다!

void supplemental_page_table_kill(struct supplemental_page_table *spt UNUSED)
{
    /* TODO: Destroy all the supplemental_page_table hold by thread and
     * TODO: writeback all the modified contents to the storage. */
    hash_clear(&spt->spt_hash, hash_page_destroy); // 해시 테이블의 모든 요소를 제거
}

void hash_page_destroy(struct hash_elem *e, void *aux)
{
    struct page *page = hash_entry(e, struct page, hash_elem);
    destroy(page);
    free(page);
}

 

 

💡 이제 프로젝트 2의 모든 테스트를 통과한다. ✌🏻

• Test 결과 (36 of 141 tests failed.)

    pass tests/userprog/args-none
    pass tests/userprog/args-single
    pass tests/userprog/args-multiple
    pass tests/userprog/args-many
    pass tests/userprog/args-dbl-space
    pass tests/userprog/halt
    pass tests/userprog/exit
    pass tests/userprog/create-normal
    pass tests/userprog/create-empty
    pass tests/userprog/create-null
    pass tests/userprog/create-bad-ptr
    pass tests/userprog/create-long
    pass tests/userprog/create-exists
    pass tests/userprog/create-bound
    pass tests/userprog/open-normal
    pass tests/userprog/open-missing
    pass tests/userprog/open-boundary
    pass tests/userprog/open-empty
    pass tests/userprog/open-null
    pass tests/userprog/open-bad-ptr
    pass tests/userprog/open-twice
    pass tests/userprog/close-normal
    pass tests/userprog/close-twice
    pass tests/userprog/close-bad-fd
    pass tests/userprog/read-normal
    pass tests/userprog/read-bad-ptr
    pass tests/userprog/read-boundary
    pass tests/userprog/read-zero
    pass tests/userprog/read-stdout
    pass tests/userprog/read-bad-fd
    pass tests/userprog/write-normal
    pass tests/userprog/write-bad-ptr
    pass tests/userprog/write-boundary
    pass tests/userprog/write-zero
    pass tests/userprog/write-stdin
    pass tests/userprog/write-bad-fd
    pass tests/userprog/fork-once
    pass tests/userprog/fork-multiple
    pass tests/userprog/fork-recursive
    pass tests/userprog/fork-read
    pass tests/userprog/fork-close
    pass tests/userprog/fork-boundary
    pass tests/userprog/exec-once
    pass tests/userprog/exec-arg
    pass tests/userprog/exec-boundary
    pass tests/userprog/exec-missing
    pass tests/userprog/exec-bad-ptr
    pass tests/userprog/exec-read
    pass tests/userprog/wait-simple
    pass tests/userprog/wait-twice
    pass tests/userprog/wait-killed
    pass tests/userprog/wait-bad-pid
    pass tests/userprog/multi-recurse
    pass tests/userprog/multi-child-fd
    pass tests/userprog/rox-simple
    pass tests/userprog/rox-child
    pass tests/userprog/rox-multichild
    pass tests/userprog/bad-read
    pass tests/userprog/bad-write
    pass tests/userprog/bad-read2
    pass tests/userprog/bad-write2
    pass tests/userprog/bad-jump
    pass tests/userprog/bad-jump2
    FAIL tests/vm/pt-grow-stack
    pass tests/vm/pt-grow-bad
    FAIL tests/vm/pt-big-stk-obj
    pass tests/vm/pt-bad-addr
    pass tests/vm/pt-bad-read
    pass tests/vm/pt-write-code
    FAIL tests/vm/pt-write-code2
    FAIL tests/vm/pt-grow-stk-sc
    pass tests/vm/page-linear
    pass tests/vm/page-parallel
    pass tests/vm/page-merge-seq
    FAIL tests/vm/page-merge-par
    FAIL tests/vm/page-merge-stk
    FAIL tests/vm/page-merge-mm
    pass tests/vm/page-shuffle
    FAIL tests/vm/mmap-read
    FAIL tests/vm/mmap-close
    FAIL tests/vm/mmap-unmap
    FAIL tests/vm/mmap-overlap
    FAIL tests/vm/mmap-twice
    FAIL tests/vm/mmap-write
    pass tests/vm/mmap-ro
    FAIL tests/vm/mmap-exit
    FAIL tests/vm/mmap-shuffle
    FAIL tests/vm/mmap-bad-fd
    FAIL tests/vm/mmap-clean
    FAIL tests/vm/mmap-inherit
    FAIL tests/vm/mmap-misalign
    FAIL tests/vm/mmap-null
    FAIL tests/vm/mmap-over-code
    FAIL tests/vm/mmap-over-data
    FAIL tests/vm/mmap-over-stk
    FAIL tests/vm/mmap-remove
    pass tests/vm/mmap-zero
    FAIL tests/vm/mmap-bad-fd2
    FAIL tests/vm/mmap-bad-fd3
    FAIL tests/vm/mmap-zero-len
    FAIL tests/vm/mmap-off
    FAIL tests/vm/mmap-bad-off
    FAIL tests/vm/mmap-kernel
    FAIL tests/vm/lazy-file
    pass tests/vm/lazy-anon
    FAIL tests/vm/swap-file
    FAIL tests/vm/swap-anon
    FAIL tests/vm/swap-iter
    pass tests/vm/swap-fork
    pass tests/filesys/base/lg-create
    pass tests/filesys/base/lg-full
    pass tests/filesys/base/lg-random
    pass tests/filesys/base/lg-seq-block
    pass tests/filesys/base/lg-seq-random
    pass tests/filesys/base/sm-create
    pass tests/filesys/base/sm-full
    pass tests/filesys/base/sm-random
    pass tests/filesys/base/sm-seq-block
    pass tests/filesys/base/sm-seq-random
    pass tests/filesys/base/syn-read
    pass tests/filesys/base/syn-remove
    pass tests/filesys/base/syn-write
    pass tests/threads/alarm-single
    pass tests/threads/alarm-multiple
    pass tests/threads/alarm-simultaneous
    pass tests/threads/alarm-priority
    pass tests/threads/alarm-zero
    pass tests/threads/alarm-negative
    pass tests/threads/priority-change
    pass tests/threads/priority-donate-one
    pass tests/threads/priority-donate-multiple
    pass tests/threads/priority-donate-multiple2
    pass tests/threads/priority-donate-nest
    pass tests/threads/priority-donate-sema
    pass tests/threads/priority-donate-lower
    pass tests/threads/priority-fifo
    pass tests/threads/priority-preempt
    pass tests/threads/priority-sema
    pass tests/threads/priority-condvar
    pass tests/threads/priority-donate-chain
    FAIL tests/vm/cow/cow-simple
    36 of 141 tests failed.