2. 程式人生 > >[第三章] 深入理解計算機系統第三版 家庭作業參考答案

[第三章] 深入理解計算機系統第三版 家庭作業參考答案

阿新 • • 發佈：2019-01-27

人非聖賢孰能無過，歡迎大家提問與糾錯

3.58

long decode2(long x, long y, long z) {
	y -= z;
	x *= y;
	return ((y << 63) >> 63) ^ x;
}

3.59

∵ x = 2^64 * xh + xl; y = 2^64 * yh + yl;
∴ x * y = 2^128 * xh * yh + 2^64 * xh * yl + 2^64 * yh * xl + xl * yl
因為是128位，所以(x * y) mod 2^128 才是正解
∴ x * y = 2^64 * xh * yl + 2^64 * yh * xl + xl * yl

rdi = dest； rsi = xl； rdx = yl；
cqto 是將 rax 符號擴充套件到 rdx : rax，即 yh : yl；而 xh : xl 是用 rcx : rsi 來表示的；

store_prod:
    movq   %rdx, %rax   # rax = yl
    cqto                # 符號擴充套件 rdx : rax = yh : yl
    movq   %rsi, %rcx   # rcx = xl
    sarq   $63,  %rcx   # 符號擴充套件 rcx : rsi = xh : yl；與cqto功能相同
    imulq  %rax, %rcx   # rcx = xh * yl
    imulq  %rsi, %rdx   # rdx = yh * xl
    addq   %rdx, %rcx   # rcx = xh * yl + yh * xl
    mulq   %rsi         # rdx : rax = xl * yl；
                        # mul是無符號運算，因為此時 x 和 y 都是 128 位的值，符號在高位上，低位運算不應使用有符號運算；
                        # 注意這裡 xl * yl 可能產生向高位的進位
    addq   %rcx, %rdx   # rdx = rdx + xh * yl + yh * xl
                        # 因為可能有低位進位，所以不直接使用 rcx 作為結果的高位，而是要加上 rdx
    movq   %rax, (%rdi) # 將 rax 的值放到結果的低位
    movq   %rdx, 8(%rdi)# 將 rdx 的值放到結果的高位
    ret

3.60

loop:
    movl  %esi, %ecx # ecx = esi
    movl  $1, %edx   # edx = 1 = mask
    movl  $0, %eax   # eax = 0 = result
    jmp   .L2
.L3:
    movq  %rdi, %r8  # r8 = x
    andq  %rdx, %r8  # r8 = r8 & rdx = x & mask
    orq   %r8, %rax  # rax = rax | r8 = result | (x & mask)
    salq  %cl, %rdx  # rdx = rdx << cl = mask << (n & 0xFF)
.L2:
    testq %rdx, %rdx
    jne   .L3        # if rdx != 0 -> jmp L3
    rep; ret

A. rdi = x; rsi = n; rax = reault; rdx = mask
B. result = 0; mask = 1;
C. mask != 0
D. mask << (n & 0xFF)
E. result | (x & mask)
F.

long loop(long x, int n)
{
    long result = 0;
    long mask;
    for(mask = 1;mask != 0;mask = mask << (n&0xFF)){
        result |= x & mask;
    }
    return result;
}

3.61

不要在判斷指標是否為空之前就解引用

long cread_alt(long *xp) {
	long zero = 0;
	return *(xp ? xp : (&zero));
}

3.62

很簡單，不要忘記 break

case MODE_A:
    result = *p2;
    *p2 = *p1;
    break;
case MODE_B:
    result = *p1 + *p2;
    *p1 = result;
    break;
case MODE_C:
    *p1 = 59;
    result = *p2;
    break;
case MODE_D:
    *p1 = *p2;
    result = 27;
    break;
case MODE_E:
    result = 27;
    break;
default:
    result = 12;

3.63

簡單的 switch 和跳轉表，只需注意 break 和 順延

long switch_prob(long x, long n) {
	long result = x;
	switch (n) {
	case 60:
	case 62:
		result = 8 * x;
		break;
	case 63:
		result = x >> 3;
		break;
	case 64:
		x = x * 15;
	case 65:
		x *= x;
	case 61:
	default:
		result = x + 75;
	}
	return result;
}

3.64

A.
擴充套件到三維：
定義 T D[R][S][T]；
&D[i][j][k] = xa + L(S * T * i + T * j + k)

B.
根據公式，知索引為 S * T * i + T * j + k；
則 R = 3640/5/13/8 = 7；S = 65/13 = 5；T = 13

3.65

根據 rdx 和 rax 每次迴圈的遞增值即可判斷
A. rdx
B. rax
C. M = 120/8 = 15

3.66

sum_col:
    leaq   1(, %rdi, 4), %r8        # r8 = 4 * n + 1
    leaq   (%rdi, %rdi, 2), %rax    # rax = 3 * n
    movq   %rax, %rdi               # rdi = rax = 3 * n
    testq  %rax, %rax
    jle    .L4                      # if rax == 0 -> jmp L4
    salq   $3, %r8                  # r8 = 8 * (4 * n + 1)
    leaq   (%rsi, %rdx, 8), %rcx    # rcx = A + 8 * j = A[0][j]
    movl   $0, %eax                 # result = 0
    movl   $0, %edx                 # i = 0
.L3:
    addq   (%rcx), %rax             # result = result + A[i][j]
    addq   $1, %rdx                 # i += 1
    addq   %r8, %rcx                # 每次加8 * (4n + 1),說明每一行有 4n + 1 個元素，因此 NC(n) 為 4n + 1
    cmpq   %rdi, %rdx               
    jne    .L3                      # rdx != 3*n 就繼續迴圈，因此 NR(n) 為 3 * n
    rep; ret
.L4:
    movl $0, %eax
    ret

巨集定義如下：

#define NR(n) (3 * (n))
#define NC(n) (4 * (n) + 1)

3.67

A.
表格中的地址指的是相對於 eval 的原始棧頂的地址，自上向下遞減的

相對地址 棧值 當前棧頂
-104 x <-----
-96 y
-88 &z
-80 z
… 垃圾值
0 eval 的原始棧頂

B.
傳遞了整個結構體 strA，包括 x y &z

C.
使用 rsp 加偏移訪問

相對地址 棧值 當前棧頂
-112 返回地址 <-----
-104 x
-96 y
-88 &z
-80 z
… 垃圾值
-40 u[0]
-32 u[1]
-24 q
… 垃圾值
0 eval 的原始棧頂

D.
使用 rdi 加偏移訪問

E.
同樣是使用 rsp 加偏移訪問

相對地址 棧值 當前棧頂
-104 x <-----
-96 y
-88 &z
-80 z
… 垃圾值
-40 u[0]
-32 u[1]
-24 q
… 垃圾值
0 eval 的原始棧頂

F.
由於結構體的複雜性，是通過儲存在棧上訪問的

3.68

做這個題時應注意 資料對齊
對齊原則：任何 K 位元組的基本物件的地址必須是 K 的倍數

setVal:
    movslq  8(%rsi), %rax   # 為使 int 四位元組對齊，可得 5 <= B <= 8
    addq    32(%rsi), %rax  # 為使 long 八位元組對齊，7 <= A <= 10
    movq    %rax, 184(%rdi) # 180 <= A * B * 4 <= 184
    ret

解得 A=9 B=5

3.69

<test>:
    mov    0x120(%rsi), %ecx        # ecx = *(bp + 288)
    add    (%rsi), %ecx             # ecx += *bp
                                    # 上兩行可推斷 288 是 last 與 first 的首地址之差
    lea    (%rdi, %rdi, 4), %rax    # rax = 5i
    lea    (%rsi, %rax, 8), %rax    # rax = bp + 40i
    mov    0x8(%rax), %rdx          # rdx = *(bp + 40i + 8)
    movslq %ecx, %rcx               # rcx = ecx(符號擴充套件)
                                    # ecx = n，將其符號擴充套件，賦值給 x 
                                    # 由此推斷 a_struct 中的 x 是長整型 long 的陣列
    mov    %rcx, 0x10(%rax, %rdx, 8)# 8 * (*(bp + 40i + 8)) + bp + 40i + 16 = rcx
    retq

比較簡單的推斷在上圖中列出；
難點在mov 0x8(%rax), %rdx # rdx = *(bp + 40i + 8)和mov %rcx, 0x10(%rax, %rdx, 8)# 8 * (*(bp + 40i + 8)) + bp + 40i + 16 = rcx，bp + 8 + 40i 很容易猜出它是 b_struct 中 a[i] 的首地址，且 b_struct 八位元組對齊，結構 a_struct 的位元組數為 40；
而 8 * ( *(bp + 40i + 8) ) 可以知道這是索引，進而推斷 a_struct 中 idx 排在 x 前面；
那麼 bp + 40i + 16 就可以寫成 bp + 8 + 40i + 8，前一個 8 是 first 的偏移，後一個 8 是 idx 的偏移；

A.
根據推斷，結構 a_struct 的位元組數為 40
CNT = (288 - 8)/40 = 7
B.

typedef struct {
    long idx;
    long x[4];
} a_struct;

3.70

A.

e1.p     0  
e1.y     8  
e2.x     0  
e2.next  8

B.
16

C.

proc:
    movq    8(%rdi), %rax   # rax = *(up + 8)
    movq    (%rax), %rdx    # rdx = *(*(up + 8))
    movq    (%rdx), %rdx    # rdx = *(*(*(up + 8)))
    subq    8(%rax), %rdx   # rdx = *(*(*(up + 8))) - *(*(up + 8) + 8) 
    movq    %rdx, (%rdi)    # *up = rdx
    ret

根據上圖註釋推理出下圖程式碼：

void proc(union ele *up) {
	up->e2.x = *(up->e2.next->e1.p) - (up->e2.next->e1.y);
}

3.71

#include<stdio.h>
#define MAX 10
void good_echo() {
	char buffer[MAX];
	while (fgets(buffer, MAX, stdin) != NULL) {
		printf("%s", buffer);

		if (ferror(stdin)) {
			printf("\nError\n");
			return;
		}
	}
}

int main() {
	good_echo();
	system("pause");
}

3.72

A.
第5行 leaq 計算得到 8n + 30，然後 andq 將其向下舍入到最近接近的 16 的倍數；-16 = 0xFFFF…FFF0；

(8n + 30) & 0xFFFF…FFF0
= 8n + 30 - (8n + 30) mod 16

當 n 為偶數時:
上式 = 8n + 30 - (16 * n/2 + 30) mod 16
= 8n + 30 - 30 mod 16
= 8n + 16

當 n 為奇數時:
上式 = 8n + 30 - (16 * ((n+1)/2 - 1/2) + 30) mod 16
= 8n + 30 - ((-8 + 30)mod 16)
= 8n + 24

所以：
當 n 為偶數時:
s2 = s1 − (8n + 16)
當 n 為奇數時:
s2 = s1 − (8n + 24)

B.
p = (s2 + 15) & 0xFFFF…FFF0
利用了“偏置”將 s2 向上舍入到最近的 16 的倍數；

C.
這裡給出數學證明：

已知：
p = s1 - 8n - e1                                       (1)

當 n 為偶數時:
p = (s2 + 15) & 0xFFFF…FFF0
= (s1 − (8n + 16) + 15) & 0xFFFF…FFF0
= (s1 - 8n - 1) & 0xFFFF…FFF0
= (s1 - 8n - 1) - (s1 - 8n - 1) mod 16
= s1 - 8n - 1 - (s1 - 1) mod 16                (2)

由 s2 = s1 − (8n + 16) 可得 e1 + e2 = 16
進而可設 0 <= e1 <= 16                          (3)

結合(1)(2)式可得：
s1 - 8n - 1 - (s1 - 1) mod 16 = s1 - 8n - e1
(-s1 + 1) mod 16 = -e1 + 1
-s1 + 1 = 16t - e1 + 1 （t 可為任意整數）
s1 = -16t + e1                                         (4)

結合(3)(4)式可得：
MAX_e1 = 16：s1 = 16t（t 可能為任意正整數）
MIN_e1 = 0：s1 = 16t（t 可能為任意正整數）

同理，當 n 為奇數時:
p = (s2 + 15) & 0xFFFF…FFF0
= s1 - 8n - 9 - (s1 - 1) mod 16

s1 - 8n - 9 - (s1 - 1) mod 16 = s1 - 8n - e1
(-s1 + 1) mod 16 = -e1 + 9
-s1 + 1 = 16t -e1 + 9
s1 = 16t + e1 - 8

0 <= e1 <= 24
MAX_e1 = 24：s1 = 16t（t 可能為任意正整數）
MIN_e1 = 0：s1 = 16t - 8（t 可能為任意正整數）

因此：
MIN_e1 = 0，n 為偶數，s1 為 16t ； n 為奇數，s1 為 16t -8;
MAX_e1 = 24，n 為奇數，s1 為 16t（t 可能為任意正整數）

D.
s2 將 8 * n 大小的空間偏移量保留為最小的 16 的倍數
p 以 16 位元組的倍數對齊

3.73

#include<stdio.h>

typedef enum { NEG, ZERO, POS, OTHER } range_t;

range_t find_range(float x) {
	int result;
	float zero = 0.0;
	asm(
		"vucomiss %[x], %[z]										# Compare 0:x		\n\t"
		"jp	.O														# NaN \n\t"
		"ja	.N														# 0 > x		\n\t"
		"jb	.P														# 0 < x		\n\t"
		"je	.Z														# 0 = x		\n\t"
		".O: mov $3, %[r]											 # NaN	\n\t"
		"jmp		.Done											# jmp done	\n\t"
		".P: mov $2, %[r]											 # POS \n\t"
		"jmp		.Done											# jmp done \n\t"
		".N: mov $0, %[r]									    	 # NEG \n\t"
		"jmp		.Done											# jmp done \n\t"
		".Z: mov $1, %[r]									    	 # ZERO \n\t"
		"jmp		.Done											# jmp done \n\t"
		".Done:nop"
		: [r] "=r" (result)											/*output*/
		: [x] "x" (x), [z] "x" (zero)								/*input*/
	);

	return result;
}

int main() {
	printf("%d %d %d %d\n", find_range(12.234), find_range(0.0), find_range(-11.433), find_range(0.0 / 0.0));
	return 0;
}

最開始我是想用 xmm1 的，卻總是有錯誤（見下圖），靈活變通一下，將 0.0 儲存在了一個區域性變數 zero 裡就行了。

findrange.c: In function ‘find_range’:
findrange.c:10:2: error: invalid 'asm': operand number missing after %-letter
  asm("vxorps %%xmm1, %%xmm1, %%xmm1  # Set %xmm1 = 0 \n\t"
  ^~~

3.74

#include<stdio.h>

typedef enum { NEG, ZERO, POS, OTHER } range_t;

range_t find_range(float x) {
	int result, temp;
	float zero = 0.0;
	asm(
		"mov $0, %%r8\n\t"
		"mov $2, %%r9\n\t"
		"mov $3, %%r10\n\t"
		"vucomiss %[x], %[z]										    # Compare 0:x		\n\t"
		"mov $1, %%rax													 # result = 0		\n\t"
		"cmovb %%r9, %%rax												# POS		\n\t"						
		"cmova %%r8, %%rax												# NEG		\n\t"
		"cmovp %%r10, %%rax												# NaN		\n\t"
		:
		: [x] "x" (x), [z] "x" (zero)									/*input*/
		: "%rax"
	);
}

int main() {
	printf("%d %d %d %d\n", find_range(12.234), find_range(0.0), find_range(-11.433), find_range(0.0 / 0.0));
	return 0;
}

3.75

A.
通過兩個連續的 xmm 暫存器，例如第一個複數引數以 %xmm0 和 %xmm1 傳遞，第二個以 %xmm2 和 %xmm3 傳遞，以此類推
B.
%xmm0 作為返回值的實部， %xmm1 作為返回值的虛部

相關推薦

[第五章] 深入理解計算機系統第三版 家庭作業參考答案

5.13 A. 畫圖： 關鍵路徑為第三幅圖加粗部分 B. 下界為浮點加法的延遲界限，CPE 為 3.00 C. 整數加法的延遲界限，CPE 為 1.00 D. 關鍵路徑上只有浮點加法 5.14 v

[第八章] 深入理解計算機系統第三版 家庭作業參考答案

8.9 程序對 併發麼？ AB × AC √ AD √ BC √ BD √ CD √ 8.10 A. fork B. longjmp execve C. setjmp 8.11 4次，畫畫程序圖就行了 8.12 8次

[第三章] 深入理解計算機系統第三版 家庭作業參考答案

人非聖賢孰能無過，歡迎大家提問與糾錯 3.58 long decode2(long x, long y, long z) { y -= z; x *= y; return ((y << 63) >> 63) ^ x; } 3.5

[第六章] 深入理解計算機系統第三版 家庭作業參考答案

6.22 磁軌數 d 與 r - x * r 成正比 設 d = k(r - x * r) = kr(1 - x) 總容量 c = 2πxk(r^2)(1 - x) = 2πk(r^2)(x - x^2) 上式實際上是關於 x 的二次式，其對稱軸為 1/2，即當

深入理解計算機系統 第三章大略和第五章大略

$0 一個 編譯 存儲器 系統 32位 做了 ++i 擴展 這2章總結的很少，主要是覺得沒那麽重要。 1.2個操作數的指令，第二個操作數通常是目的操作數:movb a b，move a to b,而add a b,b+=a，指令分為指令類，如mov類：movb,movw,m

<深入理解計算機系統(第三版)》第一章

第一章 計算機系統漫遊 計算機系統是由硬體和系統軟體組成的,它們共同工作來執行應用程式. 1.1 資訊就是位+上下文 源程式實際上就是由一個值0和1組成的位(bit)序列,8個位被組織成一組,稱為位元組.每個位元組表示程式中某個文字字元. 大部分現代系統都是有ASCII標準表示文字字元,只由ASCII字

深入理解計算機系統 第三章 程式的機器級表示 part1

  如題所示，這一章講解了程式在機器中是怎樣表示的，主要講組合語言與機器語言。   學習什麼，為什麼學，以及學了之後有什麼用 我們不用學習如何建立機器級的程式碼，但是我們要能夠閱讀和理解機器級的程式碼。 雖然現代的優化編譯器能夠很有效的將高階程式碼翻譯成機器級的程式碼，但是，為了

深入理解計算機系統 第三章 程式的機器級表示 part2

  這周由於時間和精力有限，只讀一小節：3.4.4  壓入和彈出棧資料   棧是一種特殊的資料結構，遵循“後進先出”的原則，可以用陣列實現，總是從陣列的一端插入和刪除元素，這一端被稱為棧頂。   棧有兩個常用指令： push：把資料壓入棧中 pop：刪除資

深入理解計算機系統 第三章 程式的機器級表示 part3

  這周看了劉老師提供的相關視訊，以及書中對應的章節“3.7 過程”   這一節分為執行時棧、轉移控制、資料傳送、棧上的區域性儲存、暫存器中的區域性儲存空間和遞迴過程這 6 個小節   其中前 3 小節看懂了一部分內容，後面兩個還沒來得及看，下週看完補上  

《深入理解計算機系統第三版》第三章家庭作業參考答案

簡述 最近看docker和k8s的底層實現原理,嚴重感覺自己對底層的知識瞭解不足，於是開始業餘時間深入看一些底層書籍，就找了本據說是理解整個計算機體系的入門書-《深入理解計算機系統》.直接買的最新的第三版，從第三章開始看的，第二章接下來有心情再看(看了幾眼全是

深入理解計算機系統第三版家庭作業答案-第二章

2.55-2.57答案：show_bytes 原始碼：#include<stdio.h> typedef unsigned char* byte_pointer; void show_bytes(byte_pointer ch, int len){ prin

深入理解計算機系統 ——第三章 程式的機器級表示

### 這一章主要是介紹高階語言，例如C語言編寫的程式，經過編譯後轉換為彙編程式。以往在程式設計師對機器進行操作主要都是使用匯編語言。筆者在大學做微控制器開發的時候，老師制訂的實驗，明確要求使用匯編語言。 組合語言的使用和掌握能夠很好地幫助程式設

深入理解計算機系統 第三版 第三章 家庭作業 答案

3.58long decode2(long x,long y,long z) { int ret; y=y-z; x=x*y; ret=y; ret<<=63; ret>>=63; return ret^x; }算術左移63再右移6

深入理解計算機系統第十二章學習筆記

應用級併發應用情況：訪問慢速I/O裝置；與人互動；通過推遲工作以降低延遲；服務多個網路客戶端；在多核機器上進行併發計算。 三種基本構造併發程式的方法：程序、I/O多路複用、執行緒 1、基於程序的併發程式設計 例如構建一個併發伺服器： 假設有1個伺服器和2個客戶端，伺服器正在監聽lis

深入理解計算機系統 第六章 儲存器層次結構

  為什麼要學習儲存器的層次結構？ 如果我們理解了系統是如何將資料在儲存器層次結構中上上下下移動的，那麼我們就可以編寫自己的應用程式，使得它們的資料項儲存在層次結構較高的地方，在那裡 CPU 能更快地訪問到它們。   區域性性原理 計算機程式傾向於引用臨近於其他最近引用過的資料項

深入理解計算機系統——第六章

有一個 圖片 組成 技術分享 data- 計算機 系統 大量 src 存儲器 磁盤 磁盤可以存儲大量的數據，但是速度慢 磁盤由盤片組成，每個盤片有兩面，上面覆蓋著磁性記錄材料，盤片中央有一個可以旋轉的主軸 深入理解計算機系統——第六章

深入理解計算機系統--第七章課後作業

對於問題一，輸出結果如下圖所示：   兩個都是弱定義值，所以連結器隨機選擇一個，而這時在c2.c中，g的值為37（強定義），故c1.c的g為37，呼叫函式f，g變為38 當執行第二條語句時，結果如圖：   多次定義變數g，程式在連結的時候報錯！！！ 對

深入理解計算機系統----第九章虛擬記憶體

原文連結 https://www.jianshu.com/p/e1b82b230917 虛擬儲存器又叫做虛擬記憶體，我們現在的作業系統普遍都支援了虛擬記憶體，這樣做是因為我們同時執行著太多的程式了，就目前我電腦的狀態來看，我既要開啟瀏覽器，又要聽歌，可能同時還登陸的有QQ，如果不使用虛擬記

深入理解計算機系統----第八章異常控制流

原文連結 https://www.jianshu.com/p/c8a6c4154219 目  錄 每次從一條指令過渡到另外一條指令的過程稱為控制轉移，這樣的一個控制轉移序列叫做控制流，如果每條指令都是相鄰的，這樣的過渡就是平滑序列。如果一條指令與另外一條指令不相鄰，這樣突發性

深入理解計算機系統----第七章連結

原文連結 https://www.jianshu.com/p/7f27c0316355 目  錄 連結是將各種不同檔案的程式碼和資料部分收集（符號解析和重定位）起來並組合成一個單一檔案的過程。本章節我們將要學習連結器工作的詳細原理。通過對這一方面知識的學習，將有助於理解一些危