[第二章] 深入理解计算机系统第三版 家庭作业参考答案
代码均经过或复杂或简单的测试，如果有什么不对的地方，敬请留下评论
第二章
2.55 2.56 2.57
#include 2.58
int is_little_endian() {
int a = 1;
byte_pointer p = &a;
return p[0];
}
2.59
#include 2.60
#include 2.61
#include 2.62
#include2.63
#include2.64
/*Return 1 when any odd bit of x equals 1; 0 otherwise. Assume w=32*/
int any_odd_one(unsigned x) {
unsigned int t = 0x55555555;
return (x & t) != 0;
}
2.65
搬来的，完全没有思路
int odd_ones(unsigned x) {
// 这是第一层的处理，对某一位i而言，通过右移了一位，我们就获取到了i前边的那一位，把他们异或后，
// 得到的位的值为0或者1，1就表示和前边的一位中有奇数个1，0表示有偶数个1.
x ^= (x >> 1);
// 经过上边的处理后呢，x中每一位的值的意义就不同了，他表示该位和它前边的位1的个数是奇数还是偶数
// 此时我们再右移2位，就获得了i前边的前边的值j，这个值j表示j和前边一位1的个数是奇数还是偶数
// 异或后，的值就便是到j前边，一共四位1的个数是奇数还是偶数
x ^= (x >> 2);
// 后面的都是按照上边的原理依次类推的
x ^= (x >> 4);
x ^= (x >> 8);
x ^= (x >> 16);
return x & 1;
}
2.66
// 1. 先使用或加位移让第一个1的后边都是1
// 2. 然后取非后右移一位后，最右边的1就是我们想要的掩码
// 3. 由于上边得到的那个1就是原值中的第一个1的位置，因此&上原值就清空了1前边的位
int leftmost_one(unsigned x) {
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
return x & (~x >> 1);
}
2.67
A. 位移量大于等于位数， C语言对其行为没有定义
B. C.
#include2.68
#include2.69
#include2.70
#include2.71
A. 得到的结果是unsigned，而并非扩展为signed的结果。
B. 使用int，将待抽取字节左移到最高字节，再右移到最低字节即可。
int xbyte(unsigned word, int bytenum){
int ret = word << ((3 - bytenum)<<3);
return ret >> 24;
}
2.72
A. >=语句左边始终是 unsigned，无论怎样都大于等于 0
B. 改为 if(maxbytes > 0 && maxbytes - sizeof(val) >= 0)
2.73
#include2.74
这个题参考了课本习题 2.30，减一个数等于加这个数的相反数，但是 INT_MIN 的相反数溢出，因此分开讨论；
如果 y 不是 INT_MIN，很简单，直接取反；
否则，-y 一定溢出，等于 INT_MAX + 1，如果 x 小于 0，INT_MAX + 1 + x 小于 INT_MAX，一定不溢出；如果 x 大于 0，INT_MAX + 1 + x 一定大于 INT_MAX，一定溢出。
#include2.75
这个题我不太理解，在 StackOverflow 找到的推导 _ (:з」∠)_
To convert a signed, 2's complement, 32-bit integer to an unsigned 32-bit integer, we add 2³² to its value if it is negative.
signed_high_prod does a signed multiplication and returns bits 63 to 32 of the product. We want unsigned_high_prod to do the same for unsigned multiplication and to make use of signed_high_prod and then compensate for the difference between unsigned and signed multiplication.
Let N(i) = { 1, i < 0
{ 0, i >= 0
Let U(i) = i + N(i)·2³² { −2³¹ <= i < 2³¹ }
Then:
U(x)·U(y) = (x + N(x)·2³²)·(y + N(y)·2³²)
= x·y + x·N(y)·2³² + N(x)·2³²·y + N(x)·2³²·N(y)·2³²
= x·y + x·N(y)·2³² + y·N(x)·2³² + N(x)·N(y)·2⁶⁴
⌊U(x)·U(y)/2³²⌋ = ⌊x·y/2³²⌋ + x·N(y) + y·N(x) + N(x)·N(y)·2³²
Since the arithmetic on unsigned, 32-bit integers will be performed modulo 2³², we have:
⌊U(x)·U(y)/2³²⌋ mod 2³² = (⌊x·y/2³²⌋ + x·N(y) + y·N(x) + N(x)·N(y)·2³²) mod 2³²
= (⌊x·y/2³²⌋ + x·N(y) + y·N(x)) mod 2³²
I believe that accounts for the calculations performed by your unsigned_high_prod function.
下面是我自己写的代码:
#include2.76
void *Calloc(size_t nmemb, size_t size) {
if (nmemb == 0 || size == 0) return NULL;
int s = nmemb * size;
if (s / size == nmemb) { //检测溢出
void *p = malloc(s);
memset(p, 0, s);
return p;
}
return NULL;
}
2.77
A. (x << 4) + x
B. x - (x << 3)
C. (x << 6) - (x << 2)
D. (x << 4) - (x << 7)
2.78
int divide_power2(int x, int k) {
int K = k & (x >> (w - 1)); //如果 x 为负， K 为 k；否则 K 为 0
x += (1 << K) - 1; //如果 K 为 0， x 不变；否则进行偏置
x >>= k;
return x;
}
2.79
#include2.80
这个题目我不太会，从别的博客搬来的
#include2.81
#include2.82
A. x 当 x = 0， y = INT_MIN
B. √ 无论是否溢出，其对低32位的运算没有影响
C. √
~x + ~y + 1 = ~x + 1 + ~y + 1 - 1 = -x + -y - 1 = -(x + y) - 1 = ~(x + y) + 1 - 1 = ~(x + y)
D. √ 无符号数和有符号数位级表示相同
E. √ 左移只能在低位引入0，可能会使 x 变小
2.83
A. 令x为无穷序列表示的值，可以得到x*2^k = Y + x。所以 x = Y/(2 ^k - 1)。
B. (a)5/7, (b)6/15 = 2/5, (c) 19/63
2.84
return ((ux << 1) == (uy << 1)) || //都为0 +0 -0
(!sx && sy) || //x 为负， y 为正
(sx && sy && (ux <= uy)) || //都为正
(!sx && !sy && (ux >= uy)); //都为负
2.85
A.
7.0 = 111.0（二进制）; M = 1.11; f = 0.11;
E = 2; Bias = 2^(k - 1) - 1; e = E + Bias = 2 + 2 ^ (k -1) - 1 = 2^(k - 1) + 1;
位表示 = e~f = 10…01 ~ 110…00
B.
e_MAX = 11…110 = 2^k - 2; E_MAX = e_MAX - Bias = 2^(k - 1) - 1;
当 E = n; M = 1.11…; f = 0.11… ;这样才能保证最大而且最低位为 1，即最大奇整数（前提条件是 E_MAX >= n，即指数位数足够大）;
此时 e = E + Bias = n + 2^(k - 1) - 1; V = 2^(n+1) - 1;
位表示 = e~f = e ~ 11…11
C.
最小的（正）规格化数： e = 1; E = 1 - 2^(k - 1) + 1 = 2 - 2^(k - 1); M = 1.0; f = 0.0; V = 2^E;
则其倒数：Vr = 2^(-E)； Er = -E = 2^(k-1) - 2; Mr = M = 1.0; fr = f = 0.0; er = Er + Bias = 2^k - 3;
位表示 = er~fr = 11…101 ~ 00…00
2.86
便于理解，我加了一列
| 描述 | 值 | 十进制 | 二进制表示 |
|---|---|---|---|
| 最小的正非规格化数 | 2^(-61-2^14) | 3.6452e-4951 | 0~000…000~0~000…001 |
| 最小的正规格化数 | 2^(-2^14+2) | 3.3621e-4932 | 0~000…001~1~000…000 |
| 最大的规格化数 | (2 - 2^(-63)) * 2^(2^14 - 1) | 1.1897e+4932 | 0~111…110~1~111…111 |
2.87
| 描述 | Hex | M | E | V | D |
|---|---|---|---|---|---|
| -0 | 0x8000 | 0 | -14 | -0 | -0.0 |
| 最小的>2的值 | 0x4001 | 1025/1024 | 1 | 1025 * 2^(-9) | 2.001953 |
| 512 | 0x6000 | 1 | 9 | 512 | 512.0 |
| 最大的非规格化的数 | 0x03FF | 1023/1024 | -14 | 1023 * 2^(-24) | 0.000061 |
| -∞ | 0xFC00 | —— | —— | -∞ | -∞ |
| 十六进制表示为 3BB0 的数 | 3BB0 | 123/64 | -1 | 123 * 2^(-7) | 0.960938 |
2.88
| 格式A | 格式B | ||
| 位 | 值 | 位 | 值 |
| 1 01110 001 | -9/16 | 1 0110 0010 | -9/16 |
| 0 10110 101 | 208 | 0 1110 1010 | 208 |
| 1 00111 110 | -7/2^10 | 1 0000 0111 | -7/2^10 |
| 0 00000 101 | 5/2^17 | 0 0000 0000 | 0 |
| 1 11011 000 | -2^12 | 1 1111 0000 | -∞ |
| 0 11000 100 | 768 | 0 1111 0000 | +∞ |
2.89
测试代码：
#include A.√
int转double不会损失；虽然int转float，double转float有可能小数部分损失，但两者仍然相等
B.x
x = INT_MAX，y = -1，int会溢出
C.√
double不会溢出
D.√
x = INT_MAX;
y = INT_MAX - 222;
z = INT_MAX - 3333333333;
double 小数部分可能溢出
E.x
dx = 1；dz = 0
dz/dz = NaN != dx/dx = 1
2.90
float fpwr2(int x)
{
/* Result exponent and fraction */
unsigned exp, frac;
unsigned u;
if (x < -149) {
/* Too small. Return 0.0 */
exp = 0;
frac = 0;
} else if (x < -126) {
/* Denormalized result */
exp = 0;
frac = 1<<(x+149);
} else if (x < 128) {
/* Normalized result. */
exp = x + 127;
frac = 0;
} else {
/* Too big. Return +oo */
exp = 0xFF;
frac = 0;
}
/* Pack exp and frac into 32 bits */
u = exp << 23 | frac;
/* Return as float */
return u2f(u);
}
Bias = 127
最小的正非规格化数 = 2^(1-Bias) * 2^(-23) = 2^(-149)，因此比 -149 小的都是 0
最大的正规格化数 = 2^(1-Bias) = 2^(-126)，因此比 -126 都是非规格化数
最大的规格化数 = 2(28-2 - bias) = 2^127，比 128 小的都是规格化数
2.91
A. 3.141593
B. 根据 2.83，x = Y/(2^k - 1)，则 22/7 = 21/7 + 1/7的二进制小数表示为 11.001001001…(y=001)
C. 第一个 π 的二进制小数 11.0010010000111，可以看出是第 9 位
2.92
typedef unsigned float_bits;
int IsNaN(float_bits f) {
if (((f & 0x7F800000) == 0x7F800000) && ((f & 0x7FFFFF) != 0))
return 1;
return 0;
}
float_bits float_negate(const float_bits f) {
if (IsNaN(f)) {
return f;
} else {
return f ^ 0x80000000;
}
}
2.93
typedef unsigned float_bits;
int IsNaN(float_bits f) {
if (((f & 0x7F800000) == 0x7F800000) && ((f & 0x7FFFFF) != 0))
return 1;
return 0;
}
float_bits float_absval(float_bits f) {
if (IsNaN(f)) {
return f;
} else {
return f & 0x7FFFFFFF;
}
}
2.94
非规格化数 frac 直接左移，尽管可能进位到 exp，值却是正确的；
最大规格化阶数在 exp 加一的同时，frac = 0，使 f 变为 inf；
其他普通的直接 exp 加一；
测试时发现在 f 为 NaN 时会产生难以描述的行为，这就是为什么课本让我们简单的返回 f 的原因吧；
使用了四个线程，速度快很多，i7 大概一分钟就跑完了
#include 2.95
这里我们考虑舍入，比如 f = 0 000…001 XXX…XYZ 进行右移变为 0 000…000 1XX…XXY(Z)，题目要求偶数舍入，需要看 Z 位，如果 Z 是 1，则需要舍入。偶数舍入要使 Y 位(最低有效位)为 0，如果 Y 是 1，那么就 f 就要加 1；如果 Y 是 0，直接舍掉 Z。
#include 2.96
比较简单
#include 2.97
如 int i = 0 001XX…XX，将其表示为浮点数为 1.XX…XX * 2^Y，所以首先要找到最高位；
单精度浮点数的小数部分长度为23，可能容纳不下，所以需要进行偶数舍入；
另外，如果小数部分 1.11…11 且 Y 为 1，进位变成 10.00…00，这种情况需特殊考虑；
而负数需要 求补 变成正数，方便运算；
#include