CSAPP实验——DataLab

任务：按照要求补充13个函数，会限制你能使用的操作及数量

• bitXor(x,y) 只使用 ~ 和 & 实现 ^
• tmin() 返回最小补码
• isTmax(x) 判断是否是补码最大值
• allOddBits(x) 判断补码所有奇数位是否都是1
• negate(x) 不使用负号 - 实现 -x
• isAsciiDigit(x) 判断 x 是否是 ASCII 码
• conditional(x, y, z) 类似于 C 语言中的 x?y:z
• isLessOrEqual(x,y) x<=y
• logicalNeg(x) 计算 !x (不用 ! 运算符)
• howManyBits(x) 计算表达 x 所需的最少位数
• floatScale2(uf) 计算 2.0*uf
• floatFloat2Int(uf) 计算 (int) f
• floatPower2(x) 计算 2.0的x次方
  
   

/*
 * bitXor - x^y using only ~ and &
 *   Example: bitXor(4, 5) = 1
 *   Legal ops: ~ &
 *   Max ops: 14
 *   Rating: 1
 */
int bitXor(int x, int y) {
  return ~((~(x & (~y))) & (~((~x) & y))); // 直接推公式，^可以使用~、&和|表示，而|又可以用~和&表示
}

推导一下公式就可以直接写出来了。

 

/*
 * tmin - return minimum two's complement integer
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 4
 *   Rating: 1
 */
int tmin(void) {
  int one = 1;
  return (one << 31); // 最小的有符号数，符号位为1，其余都是0
}

有符号数是用补码来表示的，Tmin表示最小补码数，对于1个字节大小的补码，最小补码数形式为1000 0000，C语言中int类型占4字节，即32位，所以对1左移31位来构造最小补码。

 

/*
 * isTmax - returns 1 if x is the maximum, two's complement number,
 *     and 0 otherwise
 *   Legal ops: ! ~ & ^ | +
 *   Max ops: 10
 *   Rating: 1
 */
int isTmax(int x) {
  int neg1;
  neg1 = !(~x); // 如果x为-1, 则neg1为1，否则neg1为0，这里是为了排除-1的干扰
  return !((~(x+1)^x)|neg1); // 给x加1，再翻转，最后和自身取异或，如果x为Tmax，则返回1，否则返回0
}

函数功能是判断x是否是有符号数的最大值，也就是补码最大值，还是拿1个字节来看，最大补码数的形式为0111 1111，代码中的neg1是为了将-1单独判断出来，因为如果只使用return后面那句(!(~(x+1)^x))的话，会导致当x=-1的时候也会返回1，判断出现错误，而改变后的返回结果可以排除-1的干扰。

 

/*
 * allOddBits - return 1 if all odd-numbered bits in word set to 1
 *   where bits are numbered from 0 (least significant) to 31 (most significant)
 *   Examples allOddBits(0xFFFFFFFD) = 0, allOddBits(0xAAAAAAAA) = 1
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 12
 *   Rating: 2
 */
int allOddBits(int x) {
  int mask = (0xAA << 8) + 0xAA;
  mask = (mask << 16) + mask; // 构造掩码
  return !((x & mask) ^ mask); // &操作将x的奇数位取出，偶数位置0，之后再与掩码异或判断是否满足条件
}

构造掩码操作即可，将掩码和x进行与操作，可以让x的奇数位置不变，而偶数位置变为0。

 

/*
 * negate - return -x
 *   Example: negate(1) = -1.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 5
 *   Rating: 2
 */
int negate(int x) {
  return ~x + 1; // 补码取相反数操作：按位取反再加一
}

直接套用公式。

 

/*
 * isAsciiDigit - return 1 if 0x30 <= x <= 0x39 (ASCII codes for characters '0' to '9')
 *   Example: isAsciiDigit(0x35) = 1.
 *            isAsciiDigit(0x3a) = 0.
 *            isAsciiDigit(0x05) = 0.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 15
 *   Rating: 3
 */
int isAsciiDigit(int x) {
  int negative = 1 << 31;
  int lessthan = ~(negative | 0x39); // 构造上界，如果超过，则符号位变为1
  int greatthan = (~(0x30) + 1); // 构造下界，如果不足，则符号位变为1

  lessthan = negative & (lessthan + x) >> 31;
  greatthan = negative & (greatthan + x) >> 31;

  return !(lessthan | greatthan); // 判断符号位是否为1
  return 2;
}

通过上下界来判断输入的x是否在0x30~0x39的范围中，使用x分别加上界和下界，当x不在这个范围中时，通过判断符号位的变化来得出判断。

 

/*
 * conditional - same as x ? y : z
 *   Example: conditional(2,4,5) = 4
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 16
 *   Rating: 3
 */
int conditional(int x, int y, int z) {
  x = !!x; // 判断x是否为0，若x=0，则x赋值为0；若x不为0，则x赋值为1
  x = ~x + 1; // 得到x的补码，0的补码还是0，1的补码为-1(二进制序列全1)

  return (x&y)|(~x&z); // 若x为0，则返回z；若x为1，则返回y
}

重点在于return语句，这个操作可以根据x的不同来返回不同的值。

 

/*
 * isLessOrEqual - if x <= y  then return 1, else return 0
 *   Example: isLessOrEqual(4,5) = 1.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 24
 *   Rating: 3
 */
int isLessOrEqual(int x, int y) {
  int minusx = ~x + 1; // 得到-x
  int result = y + minusx; // 得到y - x
  int sign = (result >> 31) & 1; // 判断result的符号，如果y>=x，则sign等于0，否则等于1
  int xsign = (x >> 31) & 1; // 取出x的符号
  int ysign = (y >> 31) & 1; // 取出y的符号
  int bitXor = xsign ^ ysign; // 判断x和y符号是否一致
  return ((!bitXor)&(!sign)) | ((bitXor&xsign)); // 要么x和y符号相同并且x<=y，要么x和y符号不同并且x<0
}

判断方法：如果x和y同符号，当x<=y则返回1；或者如果x和y不同符号，那么当x<0则返回1；其余情况返回0。

这里根据y-x的结果的符号来判断x和y的大小。

 

/*
 * logicalNeg - implement the ! operator, using all of
 *              the legal operators except !
 *   Examples: logicalNeg(3) = 0, logicalNeg(0) = 1
 *   Legal ops: ~ & ^ | + << >>
 *   Max ops: 12
 *   Rating: 4
 */
int logicalNeg(int x) {

  return ((x | (~x + 1)) >> 31) + 1;
}

 

/* howManyBits - return the minimum number of bits required to represent x in
 *             two's complement
 *  Examples: howManyBits(12) = 5
 *            howManyBits(298) = 10
 *            howManyBits(-5) = 4
 *            howManyBits(0)  = 1
 *            howManyBits(-1) = 1
 *            howManyBits(0x80000000) = 32
 *  Legal ops: ! ~ & ^ | + << >>
 *  Max ops: 90
 *  Rating: 4
 */
int howManyBits(int x) {
  // 原理：对于正数，从高位到低位，找第一个位是1的（比如是n），再加上符号位，则最少需要n+1个位；
  // 对于负数，从高位到低位，找第一个位是0的（比如是n），则最少需要n位
  int b16, b8, b4, b2, b1, b0; // 表示0~15、16~23、24~27、28~29、30、31的位置处是否含有1，如有，则对其赋值需要的位数
  int sign = x >> 31; // 取符号位
  x = (sign&~x)|(~sign&x); // 如果x为正则不变，x为负则取反，这里是为了统一正负数，我们之后只用找到含有1的位置即可

  b16 = !!(x >> 16) << 4;// 先看高16位是否含有1，若有则表示至少需要16位，所以给b16赋值为16(1 << 4 = 16)
  x =  x >> b16; // 若有1，则原数右移16位，因为上面已经确定是否至少需要16位(针对0~15)；若没有1，则b16为0，x不用移位，继续往下面判断

  b8 = !!(x >> 8) << 3; // 看剩余位的高8位是否含有1，若有则表示至少还需要8位，给b8赋值为8
  x = x >> b8; // 同理...

  b4 = !!(x >> 4) << 2;
  x = x >> b4;

  b2 = !!(x >> 2) << 1;
  x = x >> b2;

  b1 = !!(x >> 1);
  x = x >> b1;
  b0 = x;
  return b16+b8+b4+b2+b1+b0+1; // 最后加上符号位
}

注释已经写的很清楚了，可以边看代码边打草稿，很容易理解。

 

/*
 * floatScale2 - Return bit-level equivalent of expression 2*f for
 *   floating point argument f.
 *   Both the argument and result are passed as unsigned int's, but
 *   they are to be interpreted as the bit-level representation of
 *   single-precision floating point values.
 *   When argument is NaN, return argument
 *   Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
 *   Max ops: 30
 *   Rating: 4
 */
unsigned floatScale2(unsigned uf) {
  int exp = (uf&0x7F800000) >> 23; // 取出阶码
  int sign = uf&(1 << 31); // 取符号位
  if (exp == 0) return uf<<1|sign; // 若为非规格数，直接给uf乘以2后加上符号位即可
  if (exp == 255) return uf; // 若为无穷大或者NaN，直接返回自身
  exp = exp + 1; // 若uf乘以2（也就是阶码加1）后变成255，则返回无穷大
  if (exp == 255) return (0x7F800000|sign);
  return (exp << 23)|(uf&0x807FFFFF); // 返回阶码加1后的原符号数
}

需要了解计算机内浮点数的表示方法，了解浮点数中的规格数、非规格数、无穷大和未定义的区别和表示。

我们先看如何表示浮点数：

这里的uf类型为unsigned int，并不是浮点数，但是我们将uf看作为单精度类型，它有32位，最高位是符号位，之后8位保存指数信息，最后23位保存小数信息，所以在代码中我们可以看到，我们通过和0x7F800000取与操作来获得指数信息，再右移23位取出这一部分。

浮点数有几种特殊情况：

1.若exp部分全为0(exp = 0)，则是非规格化数，它是一种非常接近0的数；

2.若exp部分全为1(exp = 255)，当小数部分全为0时，表示无穷大；当小数部分不为全0时，表示未初始化数据NaN；

3.以上两种情况以外，就是规格化数。

所以我们需要判断uf是哪一种浮点数，并根据它的类型来进行相应的操作。

 

/*
 * floatFloat2Int - Return bit-level equivalent of expression (int) f
 *   for floating point argument f.
 *   Argument is passed as unsigned int, but
 *   it is to be interpreted as the bit-level representation of a
 *   single-precision floating point value.
 *   Anything out of range (including NaN and infinity) should return
 *   0x80000000u.
 *   Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
 *   Max ops: 30
 *   Rating: 4
 */
int floatFloat2Int(unsigned uf) {
  int exp = ((uf&0x7F800000) >> 23) - 127; // 计算出指数
  int sign = uf >> 31; // 取符号位
  int frac = ((uf&0x007FFFFF) | 0x00800000);
  if (!(uf&0x7FFFFFFF)) return 0; // 若原浮点数为0，则返回0

  if (exp > 31) return 0x80000000; // 若原浮点数指数大于31，返回溢出值
  if (exp < 0) return 0; // 若浮点数小于0，则返回0；

  if (exp > 23) frac = frac << (exp - 23); // 将小数转化为整数
  else frac = frac >> (23 - exp);

  if (!((frac >> 31) ^ sign)) return frac; // 判断是否溢出，若符号位没有变化，则没有溢出，返回正确的值
  else if (frac >> 31) return 0x80000000; // 原数为正值，现在为负值，返回溢出值
  else return ~frac + 1; // 原数为负值，现在为正值，返回相反数
}

需要了解整数和浮点数之间的转化方法，我们要做的就是将浮点数中的指数部分和小数部分取出来，然后通过这两部分来转化为整数，具体操作可以看代码，在这个过程中还要判断是否会产生溢出，以及浮点数是否为规格数等情况，如果产生溢出，我们需要返回一个特定的溢出值。

这里有一个将整数转化为浮点数的例子：

 

/*
 * floatPower2 - Return bit-level equivalent of the expression 2.0^x
 *   (2.0 raised to the power x) for any 32-bit integer x.
 *
 *   The unsigned value that is returned should have the identical bit
 *   representation as the single-precision floating-point number 2.0^x.
 *   If the result is too small to be represented as a denorm, return
 *   0. If too large, return +INF.
 *
 *   Legal ops: Any integer/unsigned operations incl. ||, &&. Also if, while
 *   Max ops: 30
 *   Rating: 4
 */
unsigned floatPower2(int x) {
  int INF = 0xFF << 23; // 设定一个最大值，也就是阶码位置都为1
  int exp = x + 127; // 计算阶码
  if (exp <= 0) return 0; // 阶码小于等于0，则返回0
  if (exp >= 255) return INF; // 阶码大于等于255，则返回INF
  return exp << 23;
}

所有代码及相关实验说明材料都在这里