操作系統(tǒng)課程設計報告-linux頁面換入換出分析、進程管理器

上傳人：奔*** IP屬地：河北更新時間：2024-03-01 格式：doc 頁數：16 大?。?62.00KB 人氣指數：12 舉報 版權申訴

操作系統(tǒng)課程設計報告-linux頁面換入換出分析、進程管理器_第1頁

已閱讀1頁，還剩15頁未讀，繼續(xù)免費閱讀

版權說明：本文檔由用戶提供并上傳，收益歸屬內容提供方，若內容存在侵權，請進行舉報或認領

文檔簡介

1、　　計算機與通信工程學院　　操作系統(tǒng)課程設計　　設計題目 Linux頁面換入換出分析、進程管理器　　課程設計任務書　　設計題目：Linux頁面換入換出分析、進程管理器

2、　　一、設計實驗條件　　Ubuntu Kylin 16.04, Visual Studio 2015　　二、設計任務及要求　　必做題目：Linux頁面換入換出分析。<

3、p>　　要求：分析Linux內核對頁面換入換出地實現。說明主要函數的功能及相互間地調用關系。畫出換入換出流程圖，并用文字加以說明。　　選作題目：進程管理器　　設計任務：在Linux或Windows系統(tǒng)環(huán)境下，實現一個系統(tǒng)進程管理器，能夠顯示當前系統(tǒng)的活動進程信息（進程名、用戶、優(yōu)先級、內存使用等），并能結束或創(chuàng)建特定進程?？蓞⒖糤indows下“任

4、務管理器”功能。　　三、設計報告的內容　　設計題目與設計任務　　Linux頁面換入換出分析　　要求：分析Linux內核對頁面換入換出地實現。說明主要函數的功能及相互間地調用關系。畫出換入換出流程圖

5、，并用文字加以說明。　　進程管理器　　設計任務：在Linux或Windows系統(tǒng)環(huán)境下，實現一個系統(tǒng)進程管理器，能夠顯示當前系統(tǒng)的活動進程信息（進程名、用戶、優(yōu)先級、內存使用等），并能結束或創(chuàng)建特定進程?？蓞⒖糤indows下“任務管理器”功能。　　前言&l

6、t;/b>　　Linux頁面換入換出分析　　目的與意義：深入理解Linux內核中換入換出的操作，對操作系統(tǒng)虛擬存儲器操作有進一步認識。　　進程管理器　　目的與意義：深入理解操作系統(tǒng)進程管理的原理<p

7、>　　設計主體　　Linux頁面換入換出分析　　換出的流程圖：　　圖中的相關代碼：　　==================== mm/vmscan.c

8、1146 1153 ====================　　1146 static int __init kswapd_init(void)　　1147 {　　1148 printk("Starting kswapd v1.8\n");</

9、p>　　1149 swap_setup();　　1150 kernel_thread(kswapd, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGNAL);　　1151 kernel_thread(kreclaimd, NULL, CLONE_FS | CLONE_FILE

10、S | CLONE_SIGNAL);　　1152 return 0;　　1153 }　　==================== mm/swap.c 293 305 ====================　　[kswapd_i

11、nit()>swap_setup()]　　293 /*　　294 * Perform any setup for the swap system　　295 */　　296 voi

12、d __init swap_setup(void)　　297 {　　298 /* Use a smaller cluster for memory <16MB or <32MB */　　299 if (num_physpages < ((1

13、6 * 1024 * 1024) >> PAGE_SHIFT))　　300 page_cluster = 2;　　301 else if (num_physpages < ((32 * 1024 * 1024) >> PAGE_SHIFT))　　302

14、 page_cluster = 3;　　303 else　　304 page_cluster = 4;　　305 }　　==================== mm/vmscan.c 1146 11

15、53 ====================　　1146 static int __init kswapd_init(void)　　1147 {　　1148 printk("Starting kswapd v1.8\n");

16、　　1149 swap_setup();　　1150 kernel_thread(kswapd, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGNAL);　　1151 kernel_thread(kreclaimd, NULL, CLONE_FS | CLONE_FILES | CLO

17、NE_SIGNAL);　　1152 return 0;　　1153 }　　==================== mm/swap.c 293 305 ====================　　[kswapd_init()&g

18、t;swap_setup()]　　293 /*　　294 * Perform any setup for the swap system　　295 */　　296 void __ini

19、t swap_setup(void)　　297 {　　298 /* Use a smaller cluster for memory <16MB or <32MB */　　299 if (num_physpages < ((16 * 102

20、4 * 1024) >> PAGE_SHIFT))　　300 page_cluster = 2;　　301 else if (num_physpages < ((32 * 1024 * 1024) >> PAGE_SHIFT))　　302 pa

21、ge_cluster = 3;　　303 else　　304 page_cluster = 4;　　305 }　　==================== mm/vmscan.c 805 822 ======

22、==============　　[kswapd()>inactive_shortage()]　　805 /*　　806 * How many inactive pages are we short?　　8

23、07 */　　808 int inactive_shortage(void)　　809 {　　810 int shortage = 0;　　811</p&

24、gt;　　812 shortage += freepages.high;　　813 shortage += inactive_target;　　814 shortage -= nr_free_pages();　　815 shortage -= nr_inact

25、ive_clean_pages();　　816 shortage -= nr_inactive_dirty_pages;　　817　　818 if (shortage > 0)　　819 retu

26、rn shortage;　　820　　821 return 0;　　822 }　　==================== mm/vmscan.c 907 941 ===========

27、=========　　[kswapd()>do_try_to_free_pages()]　　907 static int do_try_to_free_pages(unsigned int gfp_mask, int user)　　908 {

28、　　909 int ret = 0;　　910　　911 /*　　912 * If we‘re low on free pages, move pages from the　　913

29、* inactive_dirty list to the inactive_clean list.　　914 *　　915 * Usually bdflush will have pre-cleaned the pages　　916 * before

30、we get around to moving them to the other　　917 * list, so this is a relatively cheap operation.　　918 */　　919 if (free_shortage() || nr_inactive_d

31、irty_pages > nr_free_pages() +　　920 nr_inactive_clean_pages())　　921 ret += page_launder(gfp_mask, user);　　922</p

32、>　　923 /*　　924 * If needed, we move pages from the active list　　925 * to the inactive list. We also "eat" pages from　　926

33、 * the inode and dentry cache whenever we do this.　　927 */　　928 if (free_shortage() || inactive_shortage()) {　　929 shrink_dcache_memory(6

34、, gfp_mask);　　930 shrink_icache_memory(6, gfp_mask);　　931 ret += refill_inactive(gfp_mask, user);　　932 } else {　　933

35、 /*　　934 * Reclaim unused slab cache memory.　　935 */　　936 kmem_cache_reap(gfp_mask);　　937 ret =

36、1;　　938 }　　939　　940 return ret;　　941 }　　=========

37、=========== mm/vmscan.c 465 670 ====================　　[kswapd()>do_try_to_free_pages()>page_launder()]　　465 /**　　466 * page_laund

38、er - clean dirty inactive pages, move to inactive_clean list　　467 * @gfp_mask: what operations we are allowed to do　　468 * @sync: should we wait synchronously for the cleanin

39、g of pages　　469 *　　470 * When this function is called, we are most likely low on free +　　471 * inactive_clean pages. Since we want t

40、o refill those pages as　　472 * soon as possible, we‘ll make two loops over the inactive list,　　473 * one to move the already cleaned pages to the inactive_clean lists</p&g

41、t;　　474 * and one to (often asynchronously) clean the dirty inactive pages.　　475 *　　476 * In situations where kswapd cannot keep up, user proc

42、esses will　　477 * end up calling this function. Since the user process needs to　　478 * have a page before it can continue with its allocation, we‘ll　　479

43、 * do synchronous page flushing in that case.　　480 *　　481 * This code is heavily inspired by the FreeBSD source code. Thanks　　482

44、* go out to Matthew Dillon.　　483 */　　484 #define MAX_LAUNDER (4 * (1 << page_cluster))　　485 int page_launder(int gfp_mask, int s

45、ync)　　486 {　　487 int launder_loop, maxscan, cleaned_pages, maxlaunder;　　488 int can_get_io_locks;　　489 s

46、truct list_head * page_lru;　　490 struct page * page;　　491　　492 /*　　493 * We can only grab the IO locks (e

47、g. for flushing dirty　　494 * buffers to disk) if __GFP_IO is set.　　495 */　　496 can_get_io_locks = gfp_mask & __GFP_IO;&l

48、t;b>　　497　　498 launder_loop = 0;　　499 maxlaunder = 0;　　500 cleaned_pages = 0;　　501

49、　　502 dirty_page_rescan:　　503 spin_lock(&pagemap_lru_lock);　　504 maxscan = nr_inactive_dirty_pages;　　505 while ((page_lru = inact

50、ive_dirty_list.prev) != &inactive_dirty_list &&　　506 maxscan-- > 0) {　　507 page = list_entry(page_lru, struct page, lru);&

51、lt;b>　　508　　509 /* Wrong page on list?! (list corruption, should not happen) */　　510 if (!PageInactiveDirty(page)) {　　511

52、 printk("VM: page_launder, wrong page on list.\n");　　512 list_del(page_lru);　　513 nr_inactive_dirty_pages--;　　514

53、 page->zone->inactive_dirty_pages--;　　515 continue;　　516 }　　517　　518 /* Page

54、 is or was in use? Move it to the active list. */　　519 if (PageTestandClearReferenced(page) || page->age > 0 ||　　520 (!page->buffers &&

55、page_count(page) > 1) ||　　521 page_ramdisk(page)) {　　522 del_page_from_inactive_dirty_list(page);　　523 add_page_to

56、_active_list(page);　　524 continue;　　525 }　　526　　527 /*　　528

57、* The page is locked. IO in progress?　　529 * Move it to the back of the list.　　530 */　　531 if (TryLockPage(page)) {<p&

58、gt;　　532 list_del(page_lru);　　533 list_add(page_lru, &inactive_dirty_list);　　534 continue;　　535 }

59、　　536　　537 /*　　538 * Dirty swap-cache page? Write it out if　　539 * last copy..　　540

60、 */　　541 if (PageDirty(page)) {　　542 int (*writepage)(struct page *) = page->mapping->a_ops->writepage;　　543

61、int result;　　544　　545 if (!writepage)　　546 goto page_active;　　547</

62、p>　　548 /* First time through? Move it to the back of the list */　　549 if (!launder_loop) {　　550 list_del(page_lru);</p&g

63、t;　　551 list_add(page_lru, &inactive_dirty_list);　　552 UnlockPage(page);　　553 continue;　　554

64、 }　　555　　556 /* OK, do a physical asynchronous write to swap. */　　557 ClearPageDirty(page);

65、　　558 page_cache_get(page);　　559 spin_unlock(&pagemap_lru_lock);　　560　　561 result = write

66、page(page);　　562 page_cache_release(page);　　563　　564 /* And re-start the thing.. */　　565

67、 spin_lock(&pagemap_lru_lock);　　566 if (result != 1)　　567 continue;　　568 /* writepage refused to do anythi

68、ng */　　569 set_page_dirty(page);　　570 goto page_active;　　571 }　　572<p&

69、gt;　　573 /*　　574 * If the page has buffers, try to free the buffer mappings　　575 * associated with this page. If we succeed we either free<

70、p>　　576 * the page (in case it was a buffercache only page) or we　　577 * move the page to the inactive_clean list.　　578 *　　579

71、 * On the first round, we should free all previously cleaned　　580 * buffer pages　　581 */　　582 if (page->buffers) {

72、　　583 int wait, clearedbuf;　　584 int freed_page = 0;　　585 /*　　586 * Since we might be doing disk IO,

73、 we have to　　587 * drop the spinlock and take an extra reference　　588 * on the page so it doesn‘t go away from under us.　　589

74、 */　　590 del_page_from_inactive_dirty_list(page);　　591 page_cache_get(page);　　592 spin_unlock(&pagemap_lru_lock);

75、　　593　　594 /* Will we do (asynchronous) IO? */　　595 if (launder_loop && maxlaunder == 0 && sync)&l

76、t;/p>　　596 wait = 2; /* Synchrounous IO */　　597 else if (launder_loop && maxlaunder-- > 0)　　598 wait = 1; /*

77、Async IO */　　599 else　　600 wait = 0; /* No IO */　　601　　602 /* Try to free the

78、 page buffers. */　　603 clearedbuf = try_to_free_buffers(page, wait);　　604　　605 /*　　606

79、 * Re-take the spinlock. Note that we cannot　　607 * unlock the page yet since we‘re still　　608 * accessing the page_struct here...<p&g

80、t;　　609 */　　610 spin_lock(&pagemap_lru_lock);　　611　　612 /* The buffers were not freed. */

81、;　　613 if (!clearedbuf) {　　614 add_page_to_inactive_dirty_list(page);　　615　　616 /* The

82、page was only in the buffer cache. */　　617 } else if (!page->mapping) {　　618 atomic_dec(&buffermem_pages);　　619

83、 freed_page = 1;　　620 cleaned_pages++;　　621　　622 /* The page has more users besides the cache and us. */&

84、lt;/p>　　623 } else if (page_count(page) > 2) {　　624 add_page_to_active_list(page);　　625　　626

85、 /* OK, we "created" a freeable page. */　　627 } else /* page->mapping && page_count(page) == 2 */ {　　628 add_page_to_i

86、nactive_clean_list(page);　　629 cleaned_pages++;　　630 }　　631　　632 /*

87、　　633 * Unlock the page and drop the extra reference.　　634 * We can only do it here because we ar accessing　　635 * the page struct

88、above.　　636 */　　637 UnlockPage(page);　　638 page_cache_release(page);　　639</p&g

89、t;　　640 /*　　641 * If we‘re freeing buffer cache pages, stop when　　642 * we‘ve got enough free memory.　　643

90、 */　　644 if (freed_page && !free_shortage())　　645 break;　　646 continue;　　647

91、 } else if (page->mapping && !PageDirty(page)) {　　648 /*　　649 * If a page had an extra reference in　　650 *

92、 deactivate_page(), we will find it here.　　651 * Now the page is really freeable, so we　　652 * move it to the inactive_clean list.　　6

93、53 */　　654 del_page_from_inactive_dirty_list(page);　　655 add_page_to_inactive_clean_list(page);　　656 UnlockPa

94、ge(page);　　657 leaned_pages++;　　658 } else {　　659 page_active:　　660 /*

95、　661 * OK, we don‘t know what to do with the page.　　662 * It‘s no use keeping it here, so we move it to　　663 * the active list.<

96、;p>　　664 */　　665 del_page_from_inactive_dirty_list(page);　　666 add_page_to_active_list(page);　　667 UnlockP

97、age(page);　　668 }　　669 }　　670 spin_unlock(&pagemap_lru_lock);　　==================== mm/vmscan.c 6

98、71 697 ====================　　[kswapd()>do_try_to_free_pages()>page_launder()]　　671　　672 /*　　673 * If we

99、 don‘t have enough free pages, we loop back once　　674 * to queue the dirty pages for writeout. When we were called　　675 * by a user process (that /needs/ a free page) and

100、 we didn‘t　　676 * free anything yet, we wait synchronously on the writeout of　　677 * MAX_SYNC_LAUNDER pages.　　678 *

101、　　679 * We also wake up bdflush, since bdflush should, under most　　680 * loads, flush out the dirty pages before we have to wait on　　681 * IO.&l

102、t;p>　　682 */　　683 if (can_get_io_locks && !launder_loop && free_shortage()) {　　684 launder_loop = 1;　　685 /* If we

103、 cleaned pages, never do synchronous IO. */　　686 if (cleaned_pages)　　687 sync = 0;　　688 * We only do a few "out of order&quo

104、t; flushes. */　　689 maxlaunder = MAX_LAUNDER;　　690 /* Kflushd takes care of the rest. */　　691 wakeup_bdflush(0);

105、　　692 goto dirty_page_rescan;　　693 }　　694　　695 /* Return the number of pages moved to the inactive_clea

106、n list. */　　696 return cleaned_pages;　　697 }　　換入的流程圖：　　相關代碼：&l

107、t;p>　　/* 　　* These routines also need to handle stuff like marking pages dirty 　　* and/or accessed for architectures that don't do it in hardware (mos

108、t 　　* RISC architectures). The early dirtying is also good on the i386. 　　* 　　* There is also a hook called "update_mmu_cache()&q

109、uot; that architectures 　　* with external mmu caches can use to update those (ie the Sparc or 　　* PowerPC hashed page tables that act as extended TLBs). &

110、lt;b>　　* 　　* We enter with non-exclusive mmap_sem (to exclude vma changes, 　　* but allow concurrent faults), and pte mapped but not yet locked. <p&

111、gt;　　* We return with pte unmapped and unlocked. 　　* 　　* The mmap_sem may have been released depending on flags and our 　　* return valu

112、e. See filemap_fault() and __lock_page_or_retry(). 　　*/ 　　static int handle_pte_fault(struct mm_struct *mm, 　　struct vm_area_struct *v

113、ma, unsigned long address, 　　pte_t *pte, pmd_t *pmd, unsigned int flags) 　　{ 　　pte_t entry; 　　spinlock_t *ptl; &

114、lt;/p>　　/* 　　* some architectures can have larger ptes than wordsize, 　　* e.g.ppc44x-defconfig has CONFIG_PTE_64BIT=y and CONFIG_32BIT=y, <

115、/p>　　* so READ_ONCE or ACCESS_ONCE cannot guarantee atomic accesses. 　　* The code below just needs a consistent view for the ifs and 　　* we later double check any

116、way with the ptl lock held. So here 　　* a barrier will do. 　　*/ 　　entry = *pte; 　　barrier(); <p&g

117、t;　　if (!pte_present(entry)) { 　　if (pte_none(entry)) { 　　if (vma->vm_ops) 　　return do_fault(mm, vma, address, pte, pmd, 　　flags,

118、 entry); 　　return do_anonymous_page(mm, vma, address, pte, pmd, 　　flags); 　　} 　　return do_swap

119、_page(mm, vma, address, 　　pte, pmd, flags, entry); 　　} 　　進程管理器　　軟件功能：</p&

120、gt;　　1）顯示當前系統(tǒng)所有的進程，并提供刷新操作　　2）可以結束當前選定進程　　3）打開系統(tǒng)記事本　　軟件截圖演示：　　1）顯示&l

121、t;/p>　　2）打開記事本　　3）找到notepad并結束進程　　源碼重要部分分析：　　private void Window_Loaded(object sender, RoutedEventArgs e)

122、 //窗體啟動時運行的代碼　　{　　processes = System.Diagnostics.Process.GetProcesses();//獲得系統(tǒng)全部進程　　this.textBlock1.Text = "進程任務管理器，這里顯示所有的系統(tǒng)進程，共&quo

123、t; + processes.Length + "個進程";　　processesCollection.Clear();//清除之前的進程Collection記錄　　foreach (System.Diagnostics.Process eachProcess in processes)<

眾賞文庫> 全部分類> 畢業(yè)設計

溫馨提示

1. 本站所有資源如無特殊說明，都需要本地電腦安裝OFFICE2007和PDF閱讀器。圖紙軟件為CAD,CAXA,PROE,UG,SolidWorks等.壓縮文件請下載最新的WinRAR軟件解壓。
2. 本站的文檔不包含任何第三方提供的附件圖紙等，如果需要附件，請聯系上傳者。文件的所有權益歸上傳用戶所有。
3. 本站RAR壓縮包中若帶圖紙，網頁內容里面會有圖紙預覽，若沒有圖紙預覽就沒有圖紙。
4. 未經權益所有人同意不得將文件中的內容挪作商業(yè)或盈利用途。
5. 眾賞文庫僅提供信息存儲空間，僅對用戶上傳內容的表現方式做保護處理，對用戶上傳分享的文檔內容本身不做任何修改或編輯，并不能對任何下載內容負責。
6. 下載文件中如有侵權或不適當內容，請與我們聯系，我們立即糾正。
7. 本站不保證下載資源的準確性、安全性和完整性, 同時也不承擔用戶因使用這些下載資源對自己和他人造成任何形式的傷害或損失。

操作系統(tǒng)課程設計報告-linux頁面換入換出分析、進程管理器

文檔簡介

溫馨提示

最新文檔

評論

操作系統(tǒng)課程設計報告-linux頁面換入換出分析、進程管理器

文檔簡介

溫馨提示

最新文檔

評論

免費下載

操作系統(tǒng)課程設計報告-linux頁面換入換出分析、進程管理器