# 2017-2018-1 20155337《信息安全系统设计基础》第十三周学习总结

2017-2018-1 20155337《信息安全系统设计基础》第十三周学习总结

我认为本书重要的一章也是我学的比较不错的一章就是第六章

--存储器层次结构。

存储技术

  • 1、 基本的存储技术包括随机存储器（RAM）、非易失性存储器（ROM）和磁盘。RAM分静态RAM（SRAM）和动态RAM（DRAM）。SRAM快些，也贵些，主要用做CPU芯片上的高速缓存，也可以用作芯片下的高速缓存。DRAM慢些，便宜些，主要用作驻村和图形帧缓冲区。ROM也叫做只读存储器，即使在断电的情况下，也能保持他们的信息，它们用来存储固件。
  • 2、传统的DRAM芯片单元被分成d个超单元，每个超单元由w个DRAM单元组成。一个dxW的DRAM总共存储了dw位信息。一个16x8的DRAM芯片组织如下图所示：

  • 3、电路设计者将DRAM组织成二维阵列而不是线性数组的一个原因是降低芯片上地址引脚的数量。（因为每个引脚一次只能传送一位）读一个DRAM超单元内容的方式如下图所示：

    DRAM芯片包装在存储器模块中，示例模块用8个64Mbit的8Mx8的DRAM芯片，总共存储64MB（兆字节），如下图所示：

  • 4、增强的DRAM：FPM DRAM , EDO DRAM , SDRAM , DDR DRAM , RDRAM , VRAM。
  • 5、访问主存，数据流通过总线在CPU和DRAM主存之间来来回回。

    movl A, %eax指令会发生如下流程：

    movl %eax, A指令会发生如下流程：

    6、磁盘存储（基本都没看）

    固态硬盘是一种基于闪存的存储技术。

    局部性

  • 1、局部性通常分两种不同的形式，时间局部性和空间局部性。有良好局部性的程序比局部性差的程序运行的更快。在一个有良好时间局部性的程序中，被引用过一次的存储器位置很可能在不远的将来被多次引用；具有良好控件局部性的程序中，如果一个存储器被引用一次，那么程序可能在不久的将来引用附近的一个存储器位置。
  • 2、对程序数据引用的局部性

a）一维数组示例如下：

对于sum来说，有很好的时间局部性，因为sum是标量，对于sum来说，没有空间局部性；对于变量v，有很好的控件局部性，但是因为每个向量元素只被访问一次，因此时间局部性很差。因此，总体来说，sumvec函数有很好的局部性。

b）二维数组示例如下：

该段代码有很好的局部性：

该段代码局部性不好：

  • 3、取指令局部性

    因为程序指令是存放在存储器中的，CPU必须取出这些指令，所以我们也能评价一个程序关于取指令的局部性。例如，上述一维数组示例中，for循环中的指令是按照连续的存储器顺序执行的，因此循环有良好的空间局部性。因为循环体会被执行多次，所以也有很好的时间局部性。

  • 4、局部性小结

    一些量化评价一个程序中局部性的简单原则：

    重复引用同一个变量从的程序有良好的时间局部性；

    对于步长为k的引用模式的程序，步长越小，空间局部性越好。具有步长为1的引用模式的程序有很好的空间局部性；

    对于取指令来说，循环有很好的时间和空间局部性。循环体越小，循环迭代次数越多，局部性越好。

三、存储器层次结构

存储器层次结构的中心思想是，对于每个k，位于k层的更快更小的存储设备作为位于k+1层的更大更慢的存储设备的缓存。数据总是以块大小作为传送单元在第k层和k+1层之间来回拷贝的。存储器层次结构示例如下图所示：

几个基本术语：缓存命中，缓存不命中（冷不命中，冲突不命中，容量不命中）

四、高速缓存存储器

  • 1、通用的高速缓存存储器结构

    （m=t+s+b）

  • 2、直接映射高速缓存

    每组只有一行的高速缓存叫直接映射高速缓存。高速缓存确定一个请求是否命中，然后抽取出被请求的字的过程，分为三步：

  • 1）组选择
  • -2）行匹配
  • -3）字抽取

a）组选择

b）直接映射高速缓存行匹配

当且仅当设置了有效位，而且告诉缓存行中的标记与w的地址中标记相匹配时，这一行中包含w的一个拷贝。（有效位+标记）

c）直接映射高速缓存中的子选择块偏移位提供了所需要的字的第一个字节的偏移。

  • 3、综合示例

    假设我们有一个直接映射高速缓存，描述如下：（S，E，B，m）=（4,1,2,4），即4个组，每个组1行，每个块2个字节，地址是4位。这里假设每个字都是单字节，每次都读1个字。由上得知，

    射高速缓存的4位地址空间

    示例过程如下：初始时，高速缓存是空的：

    a）读地址0的字。因为组0的有效位是0，缓存不命中，所以高速缓存从存储器取出块0，，并存储在组0中。然后高速缓存返回取出的高速缓存行的m[0]。

    b）读地址1的字。高速缓存命中。

c）度地址13的字。

d）读地址8的字。（组0的行确实有效，但标记不匹配）

e）读地址0的字。又发生缓存不命中，因为前面引用地址8时，刚好替换了块8。

  • 6、直接映射高速缓存中的冲突不命中

    以下代码容易产生抖动问题：

    简单来说，即使程序有良好的空间局部性，而且我们的高速缓存中也有足够的空间来存放x[i]和y[i]的块，每次引用还是会引起冲突不命中，这是因为这些块被映射到了同一个高速缓存组。参考如下表：

    采用如下方法，可以消除抖动，把x定义为float x[12]，在x结尾加了填充，x[i]和y[i]现在就映射到了不同的组：

    7、组相连高速缓存：每个组都保存有多于一个的高速缓存行。

    8、全相联高速缓存：只有一个组，这个组包含所有的高速缓存行。

家庭作业

  • 6.22

假设磁道沿半径均匀分布，即总磁道数和(1-x)r成正比，设磁道数为(1-x)rk；

由题单个磁道的位数和周长成正比，即和半径xr成正比，设单个磁道的位数为xrz；

其中r、k、z均为常数。

所以C = (1-x)rk * xrz = (-x^2 + x) * r^2 * kz，即需要-x^2 + x最大，得到x = 0.5。

  • 6.23

seek time : 4 ms

average rotational latency : 0.5 * 60 / 15000 * 1000 = 2 ms

transfer time : 60 / 15000 / 800 * 1000= 0.005 ms

4 + 2 + 0.005 = 6.005 ms

  • 6.24

A.

2MB = 512 bytes * 4096，即需要读取4096个扇区。

定位时间为：4 + 0.560/150001000 = 6 ms

最理想的情况下，这4096个扇区都在一个柱面上（一个磁道读完后继续读下一个，磁头不用移动），也就是4096/1000 = 5个磁道。

即transfer time = 4096 / 1000 * 60 / 15000 * 1000 = 16.384 ms

所以理想时间为：6 + 16.384 = 22.384 ms

B.

2MB = 512 bytes * 4096，即需要读取4096个扇区。

定位时间为：4 + 0.560/150001000 = 6 ms

在完全随机的情况下，这4096个扇区分布在不同的磁道上，每一个扇区读完以后磁头都要再次去定位。

所以总的时间为：6 * 4096 + transfer time = 24592.384 ms （这里书上有一个类似的题目，但是没有加上transfer time ，我觉得还是要加上）

  • 6.25

 ·  S      t    s     b
1. 64    24    6    2
2. 1     30    0    2
3. 128   22    7    3
4. 1     29    0    3
5. 32    22    5    5
6. 8     24    3    5
  • 6.26

·   m    C    B    E    S    t    s    b
1.      2048           256
2.            4    4
3.                           25   6
4.            32                       5
  • 6.27

A.

0x08A4 0x08A5 0x08A6 0x08A7

0x0704 0x0705 0x0706 0x0707

B.

0x1238 0x1239 0x123A 0x123B

  • 6.28

A.

None

B.

0x18F0 0x18F1 0x18F2 0x18F3

0x00B0 0x00B1 0x00B2 0x00B3

C.

0x0E34 0x0E35 0x0E36 0x0E37

D.

0x1BDC 0x1BDD 0x1BDE 0x1BDF

  • 6.29

A.

CTCTCTCTCTCTCTCT, CICI, COCO

B.

Hit?    Read value(or unknown)
N           -
Y           unknown
Y           0xC0
  • 6.30

A.

C = S * E * B = 128 Bytes

B.

CTCTCTCTCTCTCTCT, CICICI, COCO

  • 6.31

A.

00111000, 110, 10

B.

CO 0x2

CI 0x6

CT 0x38

Cache hit? Y

Cache byte returned 0xEB

  • 6.32

A.

10110111, 010, 00

B.

CO 0x0

CI 0x2

CT 0xB7

Cache hit? N

Cache byte returned -

  • 6.33

0x1788 0x1789 0x178A 0x178B

0x16C8 0x16C9 0x16CA 0x16CB

  • 6.34

cache共有两个block，分别位于两个set中，设他们为b1和b2。每个block可以放下4个int类型的变量，也就是数组中的一行。在这一题中，源数组和目的数组是相邻排列的。所以内存和cache的映射情况是这样的：

b1 : src[0][] src[2][] dst[0][] dst[2][]

b2 : src[1][] src[3][] dst[1][] dst[3][]

    dst array                                   src array
       Col.0  Col.1  Col.2  Col.3                 Col.0  Col.1  Col.2  Col.3
Row0     m      m       h     m                    m       m      m      m
Row1     m      h       m     h                    m       m      m      m
Row2     m      m       h     m                    m       m      m      m
Row3     m      h       m     h                    m       m      m      m
  • 6.35

cache共有八个block，分别位于八个set中，设他们为b1、b2、b3、b4、b5、b6、b7、b8。每个block可以放下4个int类型的变量，也就是数组中的一行。在这一题中，源数组和目的数组是相邻排列的。所以内存和cache的映射情况是这样的：（这时不会有冲突）

b1 : src[0][]

b2 : src[1][]

b3 : src[2][]

b4 : src[3][]

b5 : dst[0][]

b6 : dst[1][]

b7 : dst[2][]

b8 : dst[3][]

  dst array                                   src array
       Col.0  Col.1  Col.2  Col.3                 Col.0  Col.1  Col.2  Col.3
Row0     m      h      h      h                     m      h      h      h
Row1     m      h      h      h                     m      h      h      h
Row2     m      h      h      h                     m      h      h      h
Row3     m      h      h      h                     m      h      h      h
  • 6.36

A.

cache共有32个block，分别位于32个set中，每个block可以放下4个int类型的变量，所以所有的block可以放下x数组中的一行。由映射关系，x[0][i]和x[1][i]对应的set是一样的。所以每一次的运算都会发生miss的情况，所以miss rate = 100%。

B.

cache共有64个block，分别位于64个set中，每个block可以放下4个int类型的变量，所以所有的block可以放下x数组中的两行，即全部放入。每四次读取中的第一次会发生miss，所以miss rate = 25%。

C.

cache共有32个block，分别位于16个set中，每个block可以放下4个int类型的变量，每个set可以放下8个int类型的变量，所有的block可以放下x数组中的一行。由映射关系，x[0][i]和x[1][i]对应的set是一样的，x[y][i]和x[y][i+64]对应的set也是一样的。

对于x[0][0] * x[1][0] ~ x[0][63] * x[1][63] ，每四次运算会有第一次miss。

对于x[0][64] * x[1][64] ~ x[0][127] * x[1][127] ，每四次运算会有第一次miss（擦去前面warm up的cache）。

综上，miss rate = 25%。

D.

不会，因为此时block大小是限制因素（每四次读取第一次miss）。

E.

会，更大的block会降低miss rate，因为miss只发生在第一次读入block的时候，所以更大的block会使得miss占总读取的比例降低。

  • 6.37

cache共有256个block，分别位于256个set中，每个block可以放下4个int类型的变量，所有的block可以放下1024个int类型的变量。

当N = 64：

映射关系：a[0][0] ~ a[15][63]、a[16][0] ~ a[31][63]、a[32][0] ~ a[47][63]、a[48][0] ~ a[63][63] 互相重叠。

sumA按照行来读取，所以每四次读取第一次都会miss，即miss rate = 25%。

sumB按照列来读取，所以每一次读取都会发生miss（读取后的block又会被覆盖），即miss rate = 100%。

sumC按照列来读取，但是每次读取后都会按照行再读取一次，所以每四次读取会有两次miss，即miss rate = 50%。

当N = 60

映射关系：a[0][0] ~ a[17][3]、a[17][4] ~ a[34][7]、a[34][8] ~ a[51][11]、a[51][12] ~ a[59][59]互相重叠，其中最后的a[51][12] ~ a[59][59]没有到达cache的尾部。

sumA按照行来读取，所以每四次读取第一次都会miss，即miss rate = 25%。

sumB按照列来读取，这里的情况有些复杂，我写了一个程序来分析：

#include <stdio.h>

#define SIZEOFCACHE 256
#define SIZEOFBLOCK 4
#define N 60

int main()
{
    int cache[SIZEOFCACHE];
    for (int k = 0; k < SIZEOFCACHE; ++k)
    {
        cache[k] = -1;
    }

    int read = 0;
    int miss = 0;
    for (int j = 0; j < N; ++j)
    {
        for (int i = 0; i < N; ++i)
        {
            //read a[i][j]
            ++read;
            int position = i * N + j;
            int need_start = position/SIZEOFBLOCK;
            if (cache[need_start%SIZEOFCACHE] != need_start)
            {
                ++miss;
                cache[need_start%SIZEOFCACHE] = need_start;
            }
        }
    }

    printf("%g\n", miss/(double)read);

    return 0;
}

输出结果为25%。

C.

将上面程序的循环部分更改为：

for (int j = 0; j < N; j+=2)
    {
        for (int i = 0; i < N; i+=2)
        {
            //read a[i][j] a[i+1][j] a[i][j+1] a[i+1][j+1]
            ++read;
            int position = i * N + j;
            int need_start = position/SIZEOFBLOCK;
            if (cache[need_start%SIZEOFCACHE] != need_start)
            {
                ++miss;
                cache[need_start%SIZEOFCACHE] = need_start;
            }

            ++read;
            position = (i+1) * N + j;
            need_start = position/SIZEOFBLOCK;
            if (cache[need_start%SIZEOFCACHE] != need_start)
            {
                ++miss;
                cache[need_start%SIZEOFCACHE] = need_start;
            }

            ++read;
            position = i * N + j + 1;
            need_start = position/SIZEOFBLOCK;
            if (cache[need_start%SIZEOFCACHE] != need_start)
            {
                ++miss;
                cache[need_start%SIZEOFCACHE] = need_start;
            }

            ++read;
            position = (i+1) * N + j + 1;
            need_start = position/SIZEOFBLOCK;
            if (cache[need_start%SIZEOFCACHE] != need_start)
            {
                ++miss;
                cache[need_start%SIZEOFCACHE] = need_start;
            }
        }
    }

输出结果为25%。

  • 6.38

这个cache有64个block，每个block可以放4个int类型的变量，也就是一个point_color的结构体，即cache总共可以放置64个结构体。

映射关系为：square[0][0] ~ square[3][15]、square[4][0] ~ square[7][15]、square[8][0] ~ square[11][15]、square[12][0] ~ square[15][15] 互相重叠。

A.

16 * 16 * 4 = 1024

B.

这个程序是按照行来写的，所以每四次写入只有第一次miss，即miss的次数为1024 / 4 = 256

C.

25%

  • 6.39

这个cache有64个block，每个block可以放4个int类型的变量，也就是一个point_color的结构体，即cache总共可以放置64个结构体。

映射关系为：square[0][0] ~ square[3][15]、square[4][0] ~ square[7][15]、square[8][0] ~ square[11][15]、square[12][0] ~ square[15][15] 互相重叠。

A.

16 * 16 * 4 = 1024

B.

这个程序是按照列来写的，每四次写入只有第一次miss（每次都完整利用了一个block，没有读入block的浪费，此时miss rate只取决于block的大小），即miss的次数为1024 / 4 = 256

C.

25%

  • 6.40

这个cache有64个block，每个block可以放4个int类型的变量，也就是一个point_color的结构体，即cache总共可以放置64个结构体。

映射关系为：square[0][0] ~ square[3][15]、square[4][0] ~ square[7][15]、square[8][0] ~ square[11][15]、square[12][0] ~ square[15][15] 互相重叠。

A.

16 * 16 + 3 * 16 * 16 = 1024

B.

对于第一个循环，每一次写入都会发生miss的情况，最后cache中保存的是square[12][0] ~ square[15][15]，而第二个循环又从头开始写入，所以每三次写入的第一次都会发生miss。总的miss次数就是16 * 16 * 2 = 512。

C.

50%

  • 6.41

这个cache有16K个block，每个block可以放4个char类型的变量，也就是一个pixel的结构体，即cache总共可以放置16K个结构体。buffer里面一共有480 * 640 = 300K个结构体，所以映射时会有18个完全重叠的，最后一次重叠3/4.

这个程序按照列来写，每四次写入只有第一次miss（每次都完整利用了一个block，没有读入block的浪费，此时miss rate只取决于block的大小），所以miss rate = 25%。

  • 6.42

这个cache有16K个block，每个block可以放4个char类型的变量，也就是一个pixel的结构体，即cache总共可以放置16K个结构体。buffer里面一共有480 * 640 = 300K个结构体，所以映射时会有18个完全重叠的，最后一次重叠3/4.

这个程序实际上就是按照行来写的指针版本，每四次写入只有第一次miss，miss rate = 25%。

  • 6.43

这个cache有16K个block，每个block可以放4个char类型的变量，也就是一个pixel的结构体，即cache总共可以放置16K个结构体。buffer里面一共有480 * 640 = 300K个结构体，所以映射时会有18个完全重叠的，最后一次重叠3/4.

这个程序实际上还是按照行来写的指针版本，但是只写了buffer数组的1/4。每四次写入只有第一次miss，miss rate = 25%。

  • 6.44

为了辨识缓存的大小，选取中间的列（例如S8）来判断——避免CPU的prefetching带来干扰。可以看出，在32K和512K以及8M的地方有明显的落差，所以判断L1:32k、L2:512k、L3:8M。

用lscpu验证分析正确：

  • 6.45

这个题要求我们利用第5章和第6章中学到的优化知识。对于第5章，就是减少循环的数据依赖，从而利用流水线并行执行；对于第6章，则是从两个方面（temporary、spatial）利用数据的“本地性”。

void transpose(int *dst, int *src, int dim)
{
    int i, j;
    for (i = 0; i < dim; ++i)
    {
        for (j = 0; j < dim; ++j)
        {
            dst[j*dim + i] = src[i*dim +j] /* ! */
        }
    }
}

以上的关键语句中的乘法和加法已经实现了循环之间独立，src也是按照行读入的，但是dst却是按照列读入的，这样没有充分利用每一次读入的block。于是我们想到可不可以每一次读入dst[j*dim + i]所在的block之后继续写入例如dst[j*dim + i + 1] dst[j*dim + i + 2]这样的变量，但是这样有需要src的部分变为src[(i+1)*dim +j]等等，所以我们现在不仅要“横向”扩展dst，还要“纵向”扩展src，其实这是一种叫做blocking的技术，即每次读入一块数据，对此块数据完全利用后抛弃，然后读取下一个块。可以参考csapp网上给的注解：MEM:BLOCKING — Using blocking to increase temporal locality

设我们的数据块的宽度是B，由于我们要对两个数组进行读写操作，所以2B^2 < C（其中C是cache的容量），在此限制下B尽可能取大。

#define B chunkdatas_length_of_side
void faster_transpose(int *dst, int *src, int dim)
{
    long limit = dim * dim;
    for (int i = 0; i < dim; i += B)
    {
        for (int j = 0; j < dim; j += B)
        {
            /* Using blocking to improve temporal locality */

            for (int k = i; k < i+B; ++k)
            {
                for (int l = j; l < j+B; ++l)
                {
                    /* independent calculations */
                    int d = l*dim + k;
                    int s = k*dim + l;
                    if (s < limit && d < limit)
                    {
                        dst[d] = src[s]
                    }
                }
            }

        }
    }
}

6.46

这个题仅仅是6.45的一个实践版。但这个题有一个小技巧，就是G[d] || G[s]这个运算对于G[d]和G[s]都是一样的，所以只用计算一次，从而我们只用计算对角线的上半部分的内容，也就是第二外层循环的j不用从0而是从最外层循环的i开始。

#define B chunkdatas_length_of_side
void faster_col_convert(int *G, int dim)
{
    long limit = dim * dim;
    for (int i = 0; i < dim; i += B)
    {
        for (int j = i; j < dim; j += B)
        {
            /* Using blocking to improve temporal locality */

            for (int k = i; k < i+B; ++k)
            {
                for (int l = j; l < j+B; ++l)
                {
                    /* independent calculations */
                    int d = l*dim + k;
                    int s = k*dim + l;
                    if (s < limit && d < limit)
                    {
                        _Bool temp = G[d] || G[s];
                        G[d] = temp;
                        G[s] = temp;
                    }
                }
            }

        }
    }
}
时间： 2024-11-08 21:16:01

# 2017-2018-1 20155337《信息安全系统设计基础》第十三周学习总结的相关文章

20135223何伟钦—信息安全系统设计基础第十三周学习总结

学习任务: 1. 掌握三种并发的方式:进程.线程.I/O多路复用 2. 掌握线程控制及相关系统调用 3. 掌握线程同步互斥及相关系统调用 1.并发的意义 概念:只要逻辑控制流在时间上重叠,那么就可以称为并发. 意义: 访问慢速设备(如I/O设备):[CPU可以在这样的慢速中“腾出手”再去做其他事情,使自己保持“繁忙”.] 与人交互:每次用户进行某种操作的请求的时候[用户不会在意在自己进行操作的时候系统是否还处理着其他程序],一个独立的逻辑并发流被用来处理这个程序. 通过推迟工作来降低延迟 服务多

信息安全系统设计基础第十三周学习总结——20135308

第11章 网络编程 所有的网络应用都是基于相同的基本编程模型有着相似的整体逻辑结构,并且依赖相同的编程接口. 网络应用依赖于很多在系统研究中已经学习过的概念,例如,进程.信号.字节器映射以及动态存储分配,都扮演着重要的角色. 我们需要理解基本的客户端-服务器编程模型,以及如何编写使用因特网提供的服务的客户端―服务器程序. 我们将把所有这些概念结合起来,开发一个小的但功能齐全的Web的服务器,能够为真实的Web,浏览器提供静态和动态的文本和图形内容. 11.1 客户端-服务器编程模型 1.每个网络

20135210程涵——信息安全系统设计基础第十三周学习总结

第12章 并发编程648 三种基本的构造并发程序的方法:进程.I/O多路复用.线程. 12.1 基于进程的并发编程 基于进程的并发服务器 关于进程的优劣 在父.子进程间共享状态信息,进程有一个非常清晰的模型:共享文件表,但是不共享用户地址空间.进程有独立的地址控件爱你既是优点又是缺点.由于独立的地址空间,所以进程不会覆盖另一个进程的虚拟存储器.但是另一方面进程间通信就比较麻烦,至少开销很高. 12.2 基于i/o多路复用的并发编程 I/O多路复用技术 基本思想:使用select函数,要求内核挂起

信息安全系统设计基础第十三周学习总结

第九章  虚拟存储器 一.虚拟存储器提供了三个重要能力: 1.将主存看作是一个存储在磁盘上的地址空间的高速缓存,在主存中只保护活动的区域,并根据需要在磁盘和主存之间来回传送数据: 2.为每个进程提供了一致的地址空间,从而简化了存储器管理: 3.保护了每个进程的地址空间不被其它进程破坏. 二.理解虚拟存储器的原因: 1.虚拟存储器是中心的:它是硬件异常.硬件地址翻译.主存.磁盘文件和内核软件的交互中心: 2.虚拟存储器是强大的:它可以创建和销毁存储器片.可以映射存储器片映射到磁盘某个部分等等: 3

20135205信息安全系统设计基础第十三周学习总结

第11章 网络编程 网络应用依赖于很多在系统研究中已经学习过的概念,例如,进程.信号.字节器映射以及动态存储分配,都扮演着重要的角色.还有一些新概念要掌握.我们需要理解基本的客户端-服务器编程模型,以及如何编写使用因特网提供的服务的客户端―服务器程序.最后,我们将把所有这些概念结合起来,开发一个小的但功能齐全的Web的服务器,能够为真实的Web,浏览器提供静态和动态的文本和图形内容. 11.1 客户端-服务器编程模型 每个人网络应用都是基于客户端-服务器模型的.才有陪你过这个模型,一个应用是由一

信息安全系统设计基础第十三周学习总结—20135227黄晓妍

第九章 虚拟存储器 将主存看成是一个存储在磁盘上的地址空间的高速缓存,在主存中只保存活动区域,并根据需要在磁盘和主存之间来回传送数据,通过这种方式,它高效地使用了主存.其实这一章还是讲解虚拟内存的,也就是和内核中的内存管理相关. 它为每个进程提供了一致的地址空间,从而简化了存储器管理 它保护了每个进程的地址空间不被其他进程破坏. 在硬件异常.汇编器.链接器.加载器.共享对象.文件和进程的设计中扮演着重要角色. 存储器让应用程序有了强大的能力,可以创建和销毁存储器片.将存储器片映射到磁盘文件的某个

20135234马启扬-——信息安全系统设计基础第十三周学习总结

第十一章 网络编程 11.1 客户端-服务器编程模型 基本操作:事务 当一个客户端需要服务时,向服务器发送一个请求,发起一个事务. 服务器收到请求后,解释它,并以适当的方式操作它的资源. 服务器给客户端发送一个相应,并等待下一个请求. 客户端收到响应并处理它. 11.2 网络 (1)对主机而言:网络是一种I/O设备 从网络上接收到的数据从适配器经过I/O和存储器总线拷贝到存储器,典型地是通过DMA(直接存储器存取方式)传送. (2)物理上:网络是一个按照地理远近组成的层次系统 最底层:LAN(局

信息安全系统设计基础第十三周学习总结-吕松鸿

第九章 虚拟存储器 虚拟存储器是计算机系统最重要的概念之一,它是对主存的一个抽象 三个重要能力: 它将主存看成是一个存储在磁盘上的地址空间的高速缓存,在主存中只保存活动区域,并根据需要在磁盘和主存之间来回传送数据,通过这种方式,高效的使用了主存 它为每个进程提供了一致的地址空间,从而简化了存储器管理 它保护了每个进程的地址空间不被其他进程破坏 9.1 物理和虚拟寻址 1.物理地址 计算机系统的主存被组织成一个由M个连续的字节大小的单元组成的数组,每字节都有一个唯一的物理地址PA. 根据物理地址寻

20145216 史婧瑶《信息安全系统设计基础》第一周学习总结

20145216 <信息安全系统设计基础>第一周学习总结 教材学习内容总结 Linux基础 1.ls命令 ls或ls .显示是当前目录的内容,这里“.”就是参数,表示当前目录,是缺省的可以省略.我们可以用ls -a .显示当前目录中的所有内容,包括隐藏文件和目录.其中“-a” 就是选项,改变了显示的内容.如图所示: 2.man命令 man命令可以查看帮助文档,如 man man : 若在shell中输入 man+数字+命令/函数 即可以查到相关的命令和函数:若不加数字,那man命令默认从数字较

20145311 《信息安全系统设计基础》第一周学习总结

20145311 <信息安全系统设计基础>第一周学习总结 教材学习内容总结 常用的部分命令 CTRL+SHIFT+T:新建标签页,编程时有重要应用: ALT+数字N:终端中切换到第N个标签页,编程时有重要应用: Tab:终端中命令补全,当输入某个命令的开头的一部分后,按下Tab键就可以得到提示或者帮助完成: CTRL+C:中断程序运行 Ctrl+D:键盘输入结束或退出终端 Ctrl+S: 暂定当前程序,暂停后按下任意键恢复运行 Ctrl+A: 将光标移至输入行头,相当于Home键 Ctrl+E