计算机系统lab2_datalab

zino00

已于 2022-01-27 12:59:06 修改

阅读量275

点赞数

分类专栏：计算机系统文章标签：经验分享

于 2022-01-26 22:29:06 首次发布

本文链接：https://blog.csdn.net/zino00/article/details/122709774

版权

计算机系统专栏收录该内容

3 篇文章 0 订阅

订阅专栏

lab2_datalab

个人博客地址

1.bitAnd

这个很简单

/* 

 * bitAnd - x&y using only ~ and | 
 *   Example: bitAnd(6, 5) = 4
 *   Legal ops: ~ |
 *   Max ops: 8
 *   Rating: 1
 */
int bitAnd(int x, int y) {

  	return ~(~x|~y);
}

2.getByte

舍掉最后的n个字节，即n*8位，并保留舍掉后的最后8位

/* 

 * getByte - Extract byte n from word x

 * Bytes numbered from 0 (LSB) to 3 (MSB)

 * Examples: getByte(0x12345678,1) = 0x56

 * Legal ops: ! ~ & ^ | + << >>

 * Max ops: 6

 * Rating: 2
    */
   int getByte(int x, int n) {
   int tmp =x>>(n<<3);//将目标移到最后
   tmp=tmp&0xFF;//保留目标
   return tmp;
   }

3.logicalShift

对x进行逻辑右移（算术右移补符号位，逻辑右移补0），可以采用先进行算术右移，然后将右移多出来的符号位置0。

因为不能使用减号，所以将1左移31位后采用先右移n,再左移1位的方法，最后取反。

与算术右移进行与即可得到结果

/* 
 * logicalShift - shift x to the right by n, using a logical shift
 *   Can assume that 0 <= n <= 31
 *   Examples: logicalShift(0x87654321,4) = 0x08765432
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 20
 *   Rating: 3 
 */
int logicalShift(int x, int n) {
	int result = (x >> n) & (~(((1 << 31) >> n) << 1));

  	return result;
}

4.bitCount

此问题较为复杂，参考了网上的做法，采用自底向上的方式进行求解，先求两位中1的个数、再求四位中1的个数……最后求三十二位中1的个数

具体过程如图所示:

/*
 * bitCount - returns count of number of 1's in word
 *   Examples: bitCount(5) = 2, bitCount(7) = 3
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 40
 *   Rating: 4
 */
int bitCount(int x) {
	int mask_1,mask_2,mask_4,mask_8,mask_16;

  	mask_1=0x55|(0x55<<8);
  	mask_1=mask_1|(mask_1<<16);//计算得到0x55555555,即01010101···
  	mask_2=0x33|(0x33<<8);
  	mask_2=mask_2|(mask_2<<16);//计算得到0x33333333,即00110011···
  	mask_4=0x0f|(0x0f<<8);
  	mask_4=mask_4|(mask_4<<16);//计算得到0x0f0f0f0f,即00001111···
  	mask_8=0xff|(0xff<<16);//0000000011111111 0000000011111111
  	mask_16=0xff|(0xff<<8);//00000000000000001111111111111111
  	x=(x&mask_1)+((x>>1)&mask_1);
  	x=(x&mask_2)+((x>>2)&mask_2);
  	//下面三组最高位不会是1了 
  	x=(x+(x>>4))&mask_4;//x=(x&mask_4)+((x>>4)&mask_4);
  	x=(x+(x>>8))&mask_8;//x=(x&mask_8)+((x>>8)&mask_8);
  	x=(x+(x>>16))&mask_16;//x=(x&mask_16)+((x>>16)&mask_16);
  	return x;
}

5.bang

不利用逻辑符号!求一个数的逻辑非，也就是判断该数的二进制位是否全为0，若全为0则返回1，否则返回0。

一个求补码的方法：从最低位到第一个1之间不变，其他位按位取反。

一个数与其补码相或后，只有0x00000000的结果最高位是0，其他数结果都是1，所以我们将原数与其补码相或后右移31位得到最高位，将最高位与1相与，结果为0说明原数是0，取反后输出1，否则说明原数不为0，取反后输出0。

/* 

 * bang - Compute !x without using !
 *   Examples: bang(3) = 0, bang(0) = 1
 *   Legal ops: ~ & ^ | + << >>
 *   Max ops: 12
 *   Rating: 4 
 */
int bang(int x) {

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

6.tmin

返回最小的二进制补码，为0x 8000 0000，直接左移31位即可

/* 
 * tmin - return minimum two's complement integer 
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 4
 *   Rating: 1
 */
int tmin(void) {
	return 1<<31;
}

7.fitsBits

判断一个数能否表示成n位的二进制，能则返回1，不能返回0

关键在于这个n位是包括符号位的，即对于一个整数，其最高位应为0，对于一个负数，最高位为1

先左移32-n 再右移32-n,考虑符号位，若与x相等则说明可以。

/* 
 * fitsBits - return 1 if x can be represented as an 
 * n-bit, two's complement integer.
 * 1 <= n <= 32
 * Examples: fitsBits(5,3) = 0, fitsBits(-4,3) = 1
 * Legal ops: ! ~ & ^ | + << >>
 * Max ops: 15
 * Rating: 2
    */
   int fitsBits(int x, int n) {
   int shiftNumber= 32 + (~n + 1);// 32 - n
   return !(x^((x<<shiftNumber)>>shiftNumber));
   }

8.divpwr2

将一个数除以2的n次方

除法是向下取整，正数位运算和除法运算相同，负数除法向0取整，位运算向下取整，
所以要靠位运算来实现负数除法就要加一个偏置量，使其变成比原来的数小2^n个单位的数
使得新数通过位运算的向下取整和原数的向0取整结果相同

/* 
 * divpwr2 - Compute x/(2^n), for 0 <= n <= 30
 *  Round toward zero
 *   Examples: divpwr2(15,1) = 7, divpwr2(-33,4) = -2
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 15
 *   Rating: 2

 */
int divpwr2(int x, int n) {
	int signx=x>>31;
	int mask =(1<<n)+(~0);
	int bias=signx&mask;
    return (bias+x)>>n;
}

9.negate

返回-x，很简单

/* 
 * negate - return -x 
 *   Example: negate(1) = -1.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 5
 *   Rating: 2
 */
int negate(int x) {
    return ~x+1;
}

10.isPositive

正数符号位为0，负数符号位为，0的符号位也是0。

/* 
 * isPositive - return 1 if x > 0, return 0 otherwise 
 *   Example: isPositive(-1) = 0.
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 8
 *   Rating: 3
 */
int isPositive(int x) {
    return !(x>>31|!x);
}

11.isLessOrEqual

这道题相当于枚举 x<=y 的所有情况：
1.x为负数，y 为正数
2.x 等于 y
3.x 和 y 符号相同，并且 y-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 signx = (x>>31) & 0x1;
	int signy = (y>>31) & 0x1;
	int tmp = signx ^ signy;
	int tmp1 = tmp & signx;//为1时表示x为负数，y为正数
	int y_x=y+(~x+1);
    return tmp1|(!(x^y))|(!tmp&!(y_x&(1<<31)));
}

12.ilog2

求一个数是2的几次幂，即求最高位的1的索引（0-31）

也是二分，先去掉后16位，先判断左边16位，若全是0，则!!(x>>16)返回0，否则返回1,1<<4则记录左边16位的最低位索引

若前16位中含1，则只保留了前16位，否则前16的0可以忽略，相当于考虑后16位

之后同理，将16位二分，然后记录索引。

全部索引相加就是结果

/*
 * ilog2 - return floor(log base 2 of x), where x > 0
 *   Example: ilog2(16) = 4
 *   Legal ops: ! ~ & ^ | + << >>
 *   Max ops: 90
 *   Rating: 4
 */
int ilog2(int x) {
	int bitsNumber = 0;
	bitsNumber = (!!(x >> 16)) << 4;//去掉后16位，判断左边16位是否全为0，不是则记录左边16位的最低位索引
	bitsNumber += (!!(x >> (bitsNumber + 8)) << 3);//判断左边16位是否全为0，不是则记录左边位8的最低位索引
	bitsNumber += (!!(x >> (bitsNumber + 4)) << 2);//
	bitsNumber += (!!(x >> (bitsNumber + 2)) << 1);//
	bitsNumber += (!!(x >> (bitsNumber + 1)));//
	return bitsNumber;

}

13.float_neg

返回一个无符号浮点数的负的单精度浮点数表达，参数NaN（阶码全为1，小数域非0）时返回原值

关键在于NaN的判断，其他参数加上一个符号位即可；

((uf>>23)&0xff)^0xff判断阶码是否全为1，是的话结果为0，!(uf&((1<<23)-1))判断小数域是否全为0，是的话为1

所以代码含义就是：

if(不是NaN)加符号位

否则返回原参数

/* 
 * float_neg - Return bit-level equivalent of expression -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 representations of
 *   single-precision floating point values.
 *   When argument is NaN, return argument.
 *   Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
 *   Max ops: 10
 *   Rating: 2
 */
unsigned float_neg(unsigned uf) {
	if((((uf>>23)&0xff)^0xff)||!(uf&((1<<23)-1))) uf=(1<<31)^uf;

  	return uf;
}

14.float_i2f

将一个int型数转化为浮点型。

问题重点在于考虑浮点数的舍入

浮点数舍入规则

如果以形式1.RR…RDD…D表示浮点数（R表示有效位，或保留位，而D表示舍去位），舍入规则就是：

如果DD…D < 10…0，则向下舍入

如果DD…D > 10…0，则向上舍入

如要DD…D = 10…0，则向最近偶数舍入，细则如下：

a. 如果RR…R = XX…0 （最低有效位是0），则向下舍入

b. 如果RR…R = XX…1（最低有效位是1），则向上舍入

/* 
 * float_i2f - Return bit-level equivalent of expression (float) x
 *   Result is returned as unsigned int, but
 *   it is to be interpreted as the bit-level representation of a
 *   single-precision floating point values.
 *   Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
 *   Max ops: 30
 *   Rating: 4
 */
unsigned float_i2f(int x) {
	    unsigned shiftLeft=0;
	    unsigned afterShift, tmp, flag;
	    unsigned absX=x;
	    unsigned sign=0;
	    //special case
	    if (x==0) return 0;
	    //if x < 0, sign = 1000...,abs_x = -x
	    if (x<0)//小于0，则取反
	    {
		sign=0x80000000;
		absX=-x;
	    }
	    afterShift=absX;
	    //count shift_left and after_shift
	    while (1)//计算阶码E=32-shiftLeft，aftershift保留尾数的值
	    {
		tmp=afterShift;
		afterShift<<=1;
		shiftLeft++;
		if (tmp & 0x80000000) break;
	    }
	    //afterShift的前23位保留作为尾数，要考虑舍入
	    if ((afterShift & 0x01ff)>0x0100)//进位
		flag=1;
	    else if ((afterShift & 0x03ff)==0x0300)//向偶数舍入
		flag=1;
	    else
		flag=0;
	
	    return sign +((127+32-shiftLeft)<<23) +(afterShift>>9) + flag;
	    //符号位+阶码+尾数+舍入值
}

15.float_twice

返回一个无符号浮点数的两倍

对于非规格化数，尾数左移1位就相当于乘2

对于规格化数，阶码加一即可

对于NaN，返回原值

/* 
 * float_twice - 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 float_twice(unsigned uf) {
	if((uf&0x7f800000)==0)  //阶码为0，非规格化数
		uf=((uf&0x007fffff)<<1)|(uf&0x80000000);//尾数域左移一位，别忘了符号
	else if((uf&0x7f800000)!=0x7f800000) //不是NaN ，阶码不是全1 
		uf=uf+0x800000;//阶码+1，2^(1+1)=2*2  
  	return uf;

}

测试结果截图

zino00

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
计算机系统lab2_datalab

lab2_datalab1.bitAnd这个很简单/* * bitAnd - x&y using only ~ and | * Example: bitAnd(6, 5) = 4 * Legal ops: ~ | * Max ops: 8 * Rating: 1 */int bitAnd(int x, int y) { return ~(~x|~y);}2.getByte舍掉最后的n个字节，即n*8位，并保留舍掉后的最后8位/* *
复制链接

扫一扫