CSAPP 第三版 第九章 家庭作业and so on

最新推荐文章于 2022-07-21 23:53:51 发布
最新推荐文章于 2022-07-21 23:53:51 发布
阅读量1.4k 收藏 7
点赞数 5
分类专栏： CSAPP 作业
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43172803/article/details/103620579
版权

CSAPP 第三版 第九章 作业
自己做的 仅供参考 可能出现错误

9.11

A.

131211109876543210
00001001111100

B.

参数值
VPN0x09
TLB索引0x01
TLB标记0x02
TLB命中？（是/否）否
缺页？（是/否）否
PPN0x17

C.

11109876543210
010111111100

D.

参数值
字节偏移0x0
缓存索引0xf
缓存标记0x17
缓存命中？（是/否）否
返回的缓存字节——

9.12

A.

131211109876543210
00001110101001

B.

参数值
VPN0xe
TLB索引0x2
TLB标记0x3
TLB命中？（是/否）否
缺页？（是/否）否
PPN0x11

C.

11109876543210
010001101001

D.

参数值
字节偏移0x1
缓存索引0xa
缓存标记0x11
缓存命中？（是/否）否
返回的缓存字节——

9.13

A.

131211109876543210
00000001000000

B.

参数值
VPN0x1
TLB索引0x1
TLB标记0x0
TLB命中？（是/否）否
缺页？（是/否）是
PPN——

C.
缺页
D.
缺页

9.14

#include <unistd.h>  
#include <stdio.h>  
#include <stdlib.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
#include <sys/mman.h>  
#include <fcntl.h>    
int main(int argc, char const *argv[])  
{  
    int fd;  
    if ((fd = open("hello.txt", O_RDWR)) == -1) {
        perror("Failed to open hello.txt");  
        exit(EXIT_FAILURE);  
    }  
    struct stat stat_of_file;  
    if (fstat(fd, &stat_of_file) == -1) { 
        perror("Failed to get stat of hello.txt");  
        exit(EXIT_FAILURE);  
    }    
    char *p;  
    if ((p = mmap(NULL, stat_of_file.st_size, PROT_WRITE, MAP_SHARED, fd, 0)) == (void *)-1) {
        perror("Failed to mmap");  
        exit(EXIT_FAILURE);  
    }  
    p[0] = 'J';  
    munmap(p, stat_of_file.st_size);
    close(fd);
    return 0;  
}

9.15

请求块大小（十进制字节）块头部（十六进制）
malloc(3)80x9
malloc(11)160x11
malloc(20)240x19
malloc(21)320x21

9.16

对齐要求已分配块空闲块最小块大小（字节）
单字头部和脚部头部和脚部16
单字头部，但是没有脚部头部和脚部16
双字头部和脚部头部和脚部16
双字头部，但是没有脚部头部和脚部16

9.17

去官网下一下代码就好了

/* Global variables */
static char *heap_listp = 0;  /* Pointer to first block */  
static char *rover;           /* Next fit rover */

static void *find_fit(size_t asize);
static void *coalesce(void *bp);

/* 
 * mm_init - Initialize the memory manager 
 */
/* $begin mminit */
int mm_init(void) 
{
    /* Create the initial empty heap */
    if ((heap_listp = mem_sbrk(4*WSIZE)) == (void *)-1) //line:vm:mm:begininit
        return -1;
    PUT(heap_listp, 0);                          /* Alignment padding */
    PUT(heap_listp + (1*WSIZE), PACK(DSIZE, 1)); /* Prologue header */ 
    PUT(heap_listp + (2*WSIZE), PACK(DSIZE, 1)); /* Prologue footer */ 
    PUT(heap_listp + (3*WSIZE), PACK(0, 1));     /* Epilogue header */
    heap_listp += (2*WSIZE);                     //line:vm:mm:endinit  
    /* $end mminit */

    rover = heap_listp;
    /* $begin mminit */

    /* Extend the empty heap with a free block of CHUNKSIZE bytes */
    if (extend_heap(CHUNKSIZE/WSIZE) == NULL) 
        return -1;
    return 0;
}
/* $end mminit */

/*
 * coalesce - Boundary tag coalescing. Return ptr to coalesced block
 */
/* $begin mmfree */
static void *coalesce(void *bp) 
{
    size_t prev_alloc = GET_ALLOC(FTRP(PREV_BLKP(bp)));
    size_t next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(bp)));
    size_t size = GET_SIZE(HDRP(bp));

    if (prev_alloc && next_alloc) {            /* Case 1 */
        return bp;
    }

    else if (prev_alloc && !next_alloc) {      /* Case 2 */
        size += GET_SIZE(HDRP(NEXT_BLKP(bp)));
        PUT(HDRP(bp), PACK(size, 0));
        PUT(FTRP(bp), PACK(size,0));
    }

    else if (!prev_alloc && next_alloc) {      /* Case 3 */
        size += GET_SIZE(HDRP(PREV_BLKP(bp)));
        PUT(FTRP(bp), PACK(size, 0));
        PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0));
        bp = PREV_BLKP(bp);
    }

    else {                                     /* Case 4 */
        size += GET_SIZE(HDRP(PREV_BLKP(bp))) + 
            GET_SIZE(FTRP(NEXT_BLKP(bp)));
        PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0));
        PUT(FTRP(NEXT_BLKP(bp)), PACK(size, 0));
        bp = PREV_BLKP(bp);
    }
    /* $end mmfree */
    /* Make sure the rover isn't pointing into the free block */
    /* that we just coalesced */
    if ((rover > (char *)bp) && (rover < NEXT_BLKP(bp))) 
        rover = bp;
    /* $begin mmfree */
    return bp;
}
/* $end mmfree */

/* 
 * find_fit - Find a fit for a block with asize bytes 
 */
static void *find_fit(size_t asize)
{
    /* Next fit search */
    char *oldrover = rover;

    /* Search from the rover to the end of list */
    for ( ; GET_SIZE(HDRP(rover)) > 0; rover = NEXT_BLKP(rover))
        if (!GET_ALLOC(HDRP(rover)) && (asize <= GET_SIZE(HDRP(rover))))
            return rover;

    /* search from start of list to old rover */
    for (rover = heap_listp; rover < oldrover; rover = NEXT_BLKP(rover))
        if (!GET_ALLOC(HDRP(rover)) && (asize <= GET_SIZE(HDRP(rover))))
            return rover;

    return NULL;  /* no fit found */
}
/* $end mmfirstfit */

9.18

代码去官网下一下改一改就好了

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#include "mm.h"
#include "memlib.h"
 
/* $begin mallocmacros */
/* Basic constants and macros */
#define WSIZE       4       /* Word and header/footer size (bytes) */ //line:vm:mm:beginconst
#define DSIZE       8       /* Double word size (bytes) */
#define CHUNKSIZE  (1<<12)  /* Extend heap by this amount (bytes) */  //line:vm:mm:endconst
 
#define MAX(x, y) ((x) > (y)? (x) : (y))
 
/* Pack a size and allocated bit into a word */
#define PACK(size, alloc)  ((size) | (alloc)) //line:vm:mm:pack
 
/* Read and write a word at address p */
#define GET(p)       (*(unsigned int *)(p))            //line:vm:mm:get
#define PUT(p, val)  (*(unsigned int *)(p) = (val))    //line:vm:mm:put
 
/* Read the size and allocated fields from address p */
#define GET_SIZE(p)  (GET(p) & ~0x7)                   //line:vm:mm:getsize
#define GET_ALLOC(p) (GET(p) & 0x1)                    //line:vm:mm:getalloc
#define GET_PREVIOUS_ALLOC(p) (GET(p) & 0x2) /* ! CHANGED ! */
 
/* Given block ptr bp, compute address of its header and footer */
#define HDRP(bp)       ((char *)(bp) - WSIZE)                      //line:vm:mm:hdrp
#define FTRP(bp)       ((char *)(bp) + GET_SIZE(HDRP(bp)) - DSIZE) //line:vm:mm:ftrp
 
/* Given block ptr bp, compute address of next and previous blocks */
#define NEXT_BLKP(bp)  ((char *)(bp) + GET_SIZE(((char *)(bp) - WSIZE))) //line:vm:mm:nextblkp
#define PREV_BLKP(bp)  ((char *)(bp) - GET_SIZE(((char *)(bp) - DSIZE))) //line:vm:mm:prevblkp
/* $end mallocmacros */
 
/* Global variables */
static char *heap_listp = 0;  /* Pointer to first block */
static char *rover;           /* Next fit rover */
 
/* Function prototypes for internal helper routines */
static void *extend_heap(size_t words);
static void place(void *bp, size_t asize);
static void *find_fit(size_t asize);
static void *coalesce(void *bp);
 
/*
 * mm_init - Initialize the memory manager
 */
/* $begin mminit */
int mm_init(void)
{
    /* Create the initial empty heap */
    if ((heap_listp = mem_sbrk(4*WSIZE)) == (void *)-1) //line:vm:mm:begininit
        return -1;
    PUT(heap_listp, 0);                          /* Alignment padding */
    PUT(heap_listp + (1*WSIZE), PACK(DSIZE, 0x1 | 0x2)); /* Prologue header */
    PUT(heap_listp + (2*WSIZE), PACK(DSIZE, 0x1 | 0x2)); /* Prologue footer */
    PUT(heap_listp + (3*WSIZE), PACK(0, 0x1 | 0x2));     /* Epilogue header */
    heap_listp += (2*WSIZE);                     //line:vm:mm:endinit
    /* $end mminit */
 
    rover = heap_listp;
    /* $begin mminit */
 
    /* Extend the empty heap with a free block of CHUNKSIZE bytes */
    if (extend_heap(CHUNKSIZE/WSIZE) == NULL)
        return -1;
    return 0;
}
/* $end mminit */
 
/*
 * mm_malloc - Allocate a block with at least size bytes of payload
 */
/* $begin mmmalloc */
void *mm_malloc(size_t size)
{
    size_t Wsize;      /* round up to an WSIZE */ /* ! CHANGED ! */
    size_t Dsize;      /* DSIZE after align WSIZE */ /* ! CHANGED ! */
 
    size_t asize;      /* Adjusted block size */
    size_t extendsize; /* Amount to extend heap if no fit */
    char *bp;
 
    /* $end mmmalloc */
    if (heap_listp == 0){
        mm_init();
    }
    /* $begin mmmalloc */
    /* Ignore spurious requests */
    if (size == 0)
        return NULL;
 
    Wsize = (size + (WSIZE-1)) / WSIZE; /* ! CHANGED ! */
    Dsize = Wsize/2 + 1; /* ! CHANGED ! */
    asize = DSIZE * Dsize; /* ! CHANGED ! */
 
    /* Search the free list for a fit */
    if ((bp = find_fit(asize)) != NULL) {  //line:vm:mm:findfitcall
        place(bp, asize);                  //line:vm:mm:findfitplace
        return bp;
    }
 
    /* No fit found. Get more memory and place the block */
    extendsize = MAX(asize,CHUNKSIZE);                 //line:vm:mm:growheap1
    if ((bp = extend_heap(extendsize/WSIZE)) == NULL)
        return NULL;                                  //line:vm:mm:growheap2
    place(bp, asize);                                 //line:vm:mm:growheap3
    return bp;
}
/* $end mmmalloc */
 
/*
 * mm_free - Free a block
 */
/* $begin mmfree */
void mm_free(void *bp)
{
    /* $end mmfree */
    if (bp == 0)
        return;
 
    /* $begin mmfree */
    size_t size = GET_SIZE(HDRP(bp));
    /* $end mmfree */
    if (heap_listp == 0){
        mm_init();
    }
    /* $begin mmfree */
 
    if (GET_PREVIOUS_ALLOC(HDRP(bp))) /* ! CHANGED ! */
    {
        PUT(HDRP(bp), PACK(size, 0x2));
    }
    else
    {
        PUT(HDRP(bp), PACK(size, 0));
    }
    PUT(FTRP(bp), PACK(size, 0)); /* ! CHANGED ! */
    /* pack next block */
    *HDRP(NEXT_BLKP(bp)) &= ~0x2; /* ! CHANGED ! */
    coalesce(bp);
}
 
/* $end mmfree */
/*
 * coalesce - Boundary tag coalescing. Return ptr to coalesced block
 */
/* $begin mmfree */
static void *coalesce(void *bp)
{
    size_t prev_alloc = GET_PREVIOUS_ALLOC(HDRP(bp)); /* ! CHANGED ! */
    size_t next_alloc = GET_ALLOC(HDRP(NEXT_BLKP(bp)));
    size_t size = GET_SIZE(HDRP(bp));
 
    if (prev_alloc && next_alloc) {            /* Case 1 */
        return bp;
    }
 
    else if (prev_alloc && !next_alloc) {      /* Case 2 */
        size += GET_SIZE(HDRP(NEXT_BLKP(bp)));
        PUT(HDRP(bp), PACK(size, 0x2)); /* ! CHANGED ! */
        PUT(FTRP(bp), PACK(size,0)); /* ! CHANGED ! */
    }
 
    else if (!prev_alloc && next_alloc) {      /* Case 3 */
        size += GET_SIZE(HDRP(PREV_BLKP(bp)));
        PUT(FTRP(bp), PACK(size, 0));
 
        if (GET_PREVIOUS_ALLOC(HDRP(PREV_BLKP(bp)))) /* ! CHANGED ! */
        {
            PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0x2));
        }
        else
        {
            PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0));
        }
        bp = PREV_BLKP(bp); /* ! CHANGED ! */
    }
 
    else {                                     /* Case 4 */
        size += GET_SIZE(HDRP(PREV_BLKP(bp))) +
            GET_SIZE(FTRP(NEXT_BLKP(bp)));
 
        if (GET_PREVIOUS_ALLOC(HDRP(PREV_BLKP(bp)))) /* ! CHANGED ! */
        {
            PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0x2));
        }
        else
        {
            PUT(HDRP(PREV_BLKP(bp)), PACK(size, 0));
        }
        PUT(FTRP(NEXT_BLKP(bp)), PACK(size, 0));
        bp = PREV_BLKP(bp);
    }
    /* $end mmfree */
    /* Make sure the rover isn't pointing into the free block */
    /* that we just coalesced */
    if ((rover > (char *)bp) && (rover < NEXT_BLKP(bp)))
        rover = bp;
    /* $begin mmfree */
    return bp;
}
/* $end mmfree */
 
/*
 * mm_realloc - Naive implementation of realloc
 */
void *mm_realloc(void *ptr, size_t size)
{
    size_t oldsize;
    void *newptr;
 
    /* If size == 0 then this is just free, and we return NULL. */
    if(size == 0) {
        mm_free(ptr);
        return 0;
    }
 
    /* If oldptr is NULL, then this is just malloc. */
    if(ptr == NULL) {
        return mm_malloc(size);
    }
 
    newptr = mm_malloc(size);
 
    /* If realloc() fails the original block is left untouched  */
    if(!newptr) {
        return 0;
    }
 
    /* Copy the old data. */
    oldsize = GET_SIZE(HDRP(ptr));
    if(size < oldsize) oldsize = size;
    memcpy(newptr, ptr, oldsize);
 
    /* Free the old block. */
    mm_free(ptr);
 
    return newptr;
}
 
/*
 * The remaining routines are internal helper routines
 */
 
/*
 * extend_heap - Extend heap with free block and return its block pointer
 */
/* $begin mmextendheap */
static void *extend_heap(size_t words)
{
    char *bp;
    size_t size;
 
    /* Allocate an even number of words to maintain alignment */
    size = (words % 2) ? (words+1) * WSIZE : words * WSIZE; //line:vm:mm:beginextend
    if ((long)(bp = mem_sbrk(size)) == -1)
        return NULL;                                        //line:vm:mm:endextend
 
    /* Initialize free block header/footer and the epilogue header */
    if (GET_PREVIOUS_ALLOC(HDRP(bp))) /* ! CHANGED ! */
    {
        PUT(HDRP(bp), PACK(size, 0x2));
    }
    else
    {
        PUT(HDRP(bp), PACK(size, 0));
    }
    PUT(FTRP(bp), PACK(size, 0));         /* Free block footer */   //line:vm:mm:freeblockftr
    PUT(HDRP(NEXT_BLKP(bp)), PACK(0, 1)); /* New epilogue header */ //line:vm:mm:newepihdr
    /* Coalesce if the previous block was free */
    return coalesce(bp);                                          //line:vm:mm:returnblock
}
/* $end mmextendheap */
 
/*
 * place - Place block of asize bytes at start of free block bp
 *         and split if remainder would be at least minimum block size
 */
/* $begin mmplace */
/* $begin mmplace-proto */
static void place(void *bp, size_t asize)
/* $end mmplace-proto */
{
    size_t csize = GET_SIZE(HDRP(bp));
 
    if ((csize - asize) >= DSIZE) { /* ! CHANGED ! */
        if (GET_PREVIOUS_ALLOC(HDRP(bp))) /* ! CHANGED ! */
        {
            PUT(HDRP(bp), PACK(asize, 0x2|0x1));
        }
        else
        {
            PUT(HDRP(bp), PACK(asize, 0x1));
        }
        PUT(FTRP(bp), PACK(asize, 1));
        bp = NEXT_BLKP(bp);
        PUT(HDRP(bp), PACK(csize-asize, 0x2)); /* ! CHANGED ! */
        PUT(FTRP(bp), PACK(csize-asize, 0));
    }
    else {
        if (GET_PREVIOUS_ALLOC(HDRP(bp))) /* ! CHANGED ! */
        {
            PUT(HDRP(bp), PACK(csize, 0x2|0x1));
        }
        else
        {
            PUT(HDRP(bp), PACK(csize, 0x1));
        }
        PUT(FTRP(bp), PACK(csize, 1));  /* ! CHANGED ! */
        *HDRP(NEXT_BLKP(bp)) |= 0x2; /* ! CHANGED ! */
    }
 
}
/* $end mmplace */
 
/*
 * find_fit - Find a fit for a block with asize bytes
 */
static void *find_fit(size_t asize)
{
    /* Next fit search */
    char *oldrover = rover;
 
    /* Search from the rover to the end of list */
    for ( ; GET_SIZE(HDRP(rover)) > 0; rover = NEXT_BLKP(rover))
        if (!GET_ALLOC(HDRP(rover)) && (asize <= GET_SIZE(HDRP(rover))))
            return rover;
 
    /* search from start of list to old rover */
    for (rover = heap_listp; rover < oldrover; rover = NEXT_BLKP(rover))
        if (!GET_ALLOC(HDRP(rover)) && (asize <= GET_SIZE(HDRP(rover))))
            return rover;
 
    return NULL;  /* no fit found */
}
/* $end mmfirstfit */

9.19

1)  a
2)  d
3)  b

9.20

这个就学校实验，就不动了

fastaway
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CSAPP学习笔记第9章:
pyb的博客
11-18 3043
每一个进程需要属于自己的程序代码和变量,但是如果进程太多那么需要的内存也太多,可能导致一些进程没有办法运行。当一个程序没有空间可用的时候,它可能会写到别的进程的存储器里面,这样会带来很难离解的错误！为了方便管理存储器(内存),操作系统提供了这样一个抽象:虚拟存储器,它将主存作为磁盘的缓存,并且为每一个单独的进程都提供了统一的虚拟地址.保护了存储器不会受到破坏.[1]虚拟地址和物理地址,每一个程序里面
本站最全《CSAPP》（第三版）答案合集
热门推荐
SWY's Workshop
04-06 6万+
本站最全《CSAPP》（第三版）答案合集 封面 第一章 第二章（一） 第二章（二） 第二章（三） 第三章（一） 第三章（二） 第四章 第五章 第六章（一） 第六章（二） 第七章 第八章 第九章 第十章 第十一章 第十二章（一） 第十二章（二） 开源万岁 Long live open source Да здравствует открытый исходный код Longue vie op...
深入理解计算机系统（第三版）家庭作业 第九章
RivaJ的博客
07-21 3237
《深入理解计算机系统（第三版）》家庭作业答案，望指正
《CSAPP》（第3版）答案（第九章）
SWY's Workshop
04-03 1万+
P11 A 13 12 11 10 9 8 7 6 5 4 3 2 1 0 +--|--|--|--|--|--|--|--|--|--|--|--|--|--+ | 0| 0| 0| 0| 1| 0| 0| 1| 1| 1| 1| 1| 0| 0| +--|--|--|--|--|--|--|--|--|--|--|--|--|-...
CSAPP家庭作业答案7 8 9章
jzb的博客
06-04 1790
答案仅供参考解题思路是模仿链接器的行为:使用重定位记录来识别位置然后使用图7.9中的算法计算重新定位的绝对地址，或者简单地从图7.10中的重定位指令中提取它们。有两点需要注意的是第8行的movl指令包含两个需要重定位的引用。第5行和第8行的指令包含对buf[1]的引用，初始值为Ox4，重定位的地址计算为ADDR(buf) +4。结果如下表所示：在.text的节的节偏移12处调用了函数，在节偏移为19处发生了值的传递，并且值为0x0，则要被重定位。结合c代码可知在此处将调用p3（）的返回值放在edx寄存器中，
第9章 课后习题
Lijing_666的博客
06-08 1014
习题一、填空题（1）运行异常，可以                ，但不能避免，它是由               造成的。（2）在小型程序开发中，一旦发生异常所采取的方法一般是                      。（3）C++的异常处理机制使得异常的引发和处理                在同一函数中。（4）如果预料某段程序(成对某个函数的调用)有可能发生异常，就将它放在       ...
csapp-3e-solutions:深入理解计算机系统第三版作业题答案
03-11
"csapp-3e-solutions" 是一个开源项目，提供了该书第三版的所有作业题的解答。这样的资源对于自学或在没有教师指导的情况下学习这本书的学生来说是非常宝贵的。它允许他们检查自己的答案，理解解题思路，并深入探讨...
深入理解计算机系统 第三版 csapp 3ed
01-13
深入理解计算机系统 第三版 英文扫描pdf
深入理解计算机系统（第二版）家庭作业答案
01-09
深入理解计算机系统（第二版）家庭作业答案.doc
CSAPP深入理解计算机系统 Kindle版本
01-15
深入理解计算机系统（CSAPP）第三版，适用于kindle，经典好书！
《深入理解计算机系统》家庭作业的答案
01-30
经典名著 深入理解计算机系统， 在你完成阅读的时候，如何检测学习的程度，这里给你提供了课后题的答案，让你对每一个问题茅塞顿开。
CSAPP第九章家庭作业参考答案
Talk is cheap,give me the code!
01-22 7881
（CSAPP第三版系列）导航篇传送门 9.12 对于下面的地址，重复习题9.11： 虚拟地址： 0x03a9  A. 虚拟地址格式 B. 地址翻译 参数 值 VPN 0xE TLB索引 0x2 TLB标记 0x3 TLB命中？（是/否）
CSAPP:第9章 虚拟内存
椰子奶糖的博客
02-13 1512
CSAPP:第9章 虚拟内存 文章目录CSAPP:第9章 虚拟内存9.1 物理和虚拟寻址9.2 地址空间9.3 虚拟内存作为缓存的工具9.3.1 DRAM缓存的组织结构9.3.2 页表9.3.3 页命中9.3.4 缺页9.3.5 分配页面9.3.6 又是局部性解救了我们9.4 虚拟内存作为缓存管理的工具9.5 虚拟内存作为内存保护的工具9.6 地址翻译9.6.1 结合高速缓存和虚拟缓存9.6.2 利用TLB加速地址翻译9.6.3 多级页表9.6.4 总和：端到端的地址翻译9.7 案例研究：Intel Cor
CSAPP第8&9章家庭作业（部分）
One of thre_tigers的博客
06-06 1693
画出进程图： 原则如下： （1） 遇到fork函数就分支，每个水平的箭头对应于从 左到右执行指令的进程，而每个垂直的箭头对应于 fork 函数的执行 （2） 分支的时候专注于父进程执行完，再处理另一个分支 （3） 父进程中， fork 返回子进程的 PID、在子进程中， fork 返回 0 （4） 在新的进程中可以认为执行的是上一个fork以下的部分。 对于执行过程，由于程序不会按照特定的顺序回收子进程，子进程回收的顺序是这台特定的计算机的属性。所以这个输出结果不是确定的，但是对于这道题，exit...
深入理解计算机系统(第二版) 家庭作业 第九章
zhanyu1990的专栏
01-19 1万+
9.11 A.虚拟地址0x027c 13 12 11 10 9 8 7 6 5 4 3 2 1 0 0 0 0 0 1 0 0 1 1 1
CSAPP第三章家庭作业参考答案
Talk is cheap,give me the code!
01-22 5253
（CSAPP第三版系列）导航篇传送门 3.58写出等价的decode2的C代码。 /*rdi,rsi,rdx*/ long decode2(long x,long y,long z) { y = y - z; x = x * y; y = (y > 63; return x ^ y; } 3.60  A. x:%rdi  n:
CSAPP第八、九章家庭作业（原书第二版）
无知亦乐
01-14 1278
答：到达第一个Fork()函数时，创建一个子进程，此时由于还没有调用过exit函数，故此时atexit函数此时还不会被调用，等待exit函数调用才打印2。第二个Fork()由创建一个子进程，此时有4个进程，其中2个打印0,2个打印1，当第一个Fork创建的子进程创建的子进程中每有一个子进程调用exit时，atexit函数就被调用打印2。如下图，所以每打印2之前都要先打印一个0或者一个1，故在5个选项中只有ACE符合可能输出的结果。 8.23 答：父进程接收并捕获第一个信号，当处理程序还在处理第一个信号时.
[第八章] 深入理解计算机系统第三版 家庭作业参考答案
CHOOOU的博客
10-22 1万+
8.9 进程对 并发么？ AB × AC √ AD √ BC √ BD √ CD √ 8.10 A. fork B. longjmp execve C. setjmp 8.11 4次，画画进程图就行了 8.12 8次 8.13 x=4 x=3 x=2 8.14 3 8.15 5 8.16 counter = 2 8.17 hello 0 1 B..
CSAPP第九章读书笔记
qq_34489443的博客
07-11 428
虚拟内存与缓存的关系（在这一篇中，缓存，内存和物理内存是同样的东西） 虚拟内存被分割为若干个虚拟页，物理内存（也就是主存）也被分割为若干个物理页 虚拟内存开始是被存放在磁盘上的（个人理解），要想被程序使用，先要从磁盘中将内容复制到物理内存中，才可以被使用。 所以虚拟页分为三种： 1.未分配的：虚拟内存还未分配或者创建的虚拟页（我的理解是在linux系统中，每个进程都有4G的虚拟内存，但是并...
csapp第三版中文pdf
最新发布
07-14
### 回答1： 《CSAPP第三版中文PDF》是指《深入理解计算机系统》（Computer Systems: A Programmer's Perspective）这本书的中文翻译版。这本书是由Randal E. Bryant和David R. O'Hallaron共同编写的，旨在帮助读者深入理解计算机系统的工作原理和设计思想。 该书分为主要的十四章，内容涵盖了计算机系统的方方面面，从程序的执行和优化，到处理器的设计和优化，再到内存层次结构和虚拟内存管理。书中包含了大量的实例和代码，以帮助读者理解和实践所学的概念。 这本书的第三版在第二版的基础上进行了全面的更新和扩展。新版增加了对多核处理器、并行计算和网络编程等新兴领域的讨论，使读者能够更好地了解当代计算机系统的工作原理。 《CSAPP第三版中文PDF》的中文翻译版提供了更便捷的学习途径，使更多的中文读者能够通过这本书深入了解计算机系统。无论是对于计算机专业的学生，还是对于从事软件开发或系统维护工作的技术人员，这本书都是一本非常宝贵的参考书。通过阅读这本书，读者可以更全面地掌握计算机系统的原理和知识，提升自己在计算机领域的理解和能力。 ### 回答2： 《深入理解计算机系统(第三版)》是由Randal E. Bryant和David R. O'Hallaron合著的一本计算机科学教材，也被称为CSAPP。这本书提供了一个全面而深入的视角来理解计算机系统的内部工作原理。 《深入理解计算机系统(第三版)》通过逐步解释计算机系统的各个组成部分，从硬件基础、系统软件、过程级并发性到存储器层次结构等，使读者能够获得对计算机系统设计和优化的全面认识。书中的例子和练习旨在帮助读者思考和解决各种计算机系统问题。 该书有如下特点： 1. 着重于概念和原则：CSAPP并不仅仅关注于具体技术和工具，它更关注理解计算机系统的基本原理和概念。这使得读者能够适应各种计算机系统，并可以将其应用到其他类似的系统中。 2. 强调实际应用：书中提供了许多例子和实践，这些都是真实世界中计算机系统的典型问题和解决方案。这使得读者能够更好地将理论知识应用于实际工作中。 3. 全面而深入：CSAPP从底层到顶层逐渐延伸，从而形成一个全面而深入的计算机系统的学习路径。这使得读者能够快速了解计算机系统的整体结构和工作原理。 4. 结构清晰：书中的章节和内容组织架构清晰，逻辑性强。这使得读者可以根据自己的需求和兴趣来选择阅读和学习的内容。 总结起来，《深入理解计算机系统(第三版)》是一本具有全面性、深入性和实用性的计算机系统教材。通过阅读这本书，读者可以深入理解计算机系统的内部工作原理，迅速适应各种计算机系统，并将理论知识应用于实际工作中。这本书对于计算机科学和工程领域的学生和从业人员都是一本不可或缺的指导书。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值