IO分割

昨天写了一个小程序，具体功能是实现IO分割的。

题目：将给定的一个IO的起始位置，再给定一个长度，比如（24542,16438），将其分割成几个小的IO，分割要求是

1，  不足16的单独处理

2，  满8192的一大块，单独处理

3，  不足8192但大于16的放一起处理。

例子，  如给定IO（24542,16438），分割结果如下：

（24542,24544）

（24544,24576）

（24576,32768）

（32768,40960）

（40960,40976）

（40976,40980）

也就是说，给定IO的起始位置，加上IO的长度，等于最终的值。即24542+16438=40980；也有2+32+8192+8192+16+4 = 16438；

话不多说，直接上代码：

#include<stdio.h>int is_division(int tmp);void  deal_big_tidy(int begin,int len);void deal_big_untidy(int begin,int len);int is_division(int tmp){printf("isdivision hahaha\n");if((tmp % 16) == 0){printf("the begin is division\n");return 1;}else{printf("the begin is not division\n");return 0;}}void  deal_big_tidy(int begin,int len)                      //IO大于8192，对齐的方式{int big_tidy_need,m,n,big_residue,tmp,pos,i,len_change,opt,opt_n;if(begin >= 8192)                                    //起始位置是否处于一个8192中{big_tidy_need = 8192 - (begin%8192);}else{big_tidy_need = 8192 - begin;}printf("the big_tidy_need is :%d\n",big_tidy_need);opt = big_tidy_need % 16;                //补填剩余不够16的大小opt_n = (big_tidy_need - opt) / 16;      //要补填的16的个数if(big_tidy_need < len){printf("%d %d %d\n",begin,begin+opt_n*16,opt_n*16);tmp = begin+big_tidy_need; //其实big_tidy_need == opt_n*16，由于是整除16，所以余数为0len_change = len - big_tidy_need;if(len_change >= 8192)                //判断len的长度，并分割{m = len_change / 8192;n = (len_change - 8192 * m) / 16;big_residue = len_change - (8192 * m +16 *n);for(i= 0; i < m; i++){pos = tmp;pos += 8192;printf("the num i:%d\n",i);printf("%d %d %d\n",tmp,pos,8192);tmp = pos;}pos = tmp;printf("the pos is :%d\n",pos);printf("%d %d %d\n",pos,pos+n*16,n * 16);printf("%d %d %d\n",pos+n*16,pos+n*16+big_residue,big_residue);}else if(len > 16){n = len_change / 16;big_residue = len_change - n*16;printf("%d %d %d\n",tmp,tmp+n*16,n*16);printf("%d %d %d\n",tmp+n*16,tmp+n*16+big_residue,big_residue);}else{printf("%d %d %d\n",begin,begin+len,len);}}else if(big_tidy_need > 16){n = len / 16;big_residue = len - n*16;printf("%d %d %d\n",begin,begin+n*16,n*16);printf("%d %d %d\n",begin+n*16,begin+n*16+big_residue,big_residue);}else{printf("%d %d %d\n",begin,begin+len,len);}}void deal_big_untidy(int begin,int len)                              //IO大于8192，不对齐的方式{int big_untidy_need,m,n,big_residue,tmp,pos,i,offest_num,len_change,storage;storage = 8192;if(begin >= 8192){big_untidy_need = 8192 - (begin%8192);}else{big_untidy_need = 8192 - begin;}offest_num = 16 - (begin % 16);if(big_untidy_need < len){printf("%d %d %d\n",begin,begin+offest_num,offest_num);printf("%d %d %d\n",begin+offest_num,begin+big_untidy_need,big_untidy_need-offest_num);tmp = begin+big_untidy_need;len_change = len - big_untidy_need;  //补齐8192后判断剩余的len是否大于8192；if(len_change >= 8192){m = len_change / 8192;n = (len_change - 8192 * m) / 16;big_residue = len_change - (8192 * m +16 *n);for(i=0;i < m;i++){pos = tmp;pos += 8192;printf("%d %d %d\n",tmp,pos,storage);tmp = pos;}printf("%d %d %d\n",pos,pos+n*16,n*16);printf("%d %d %d\n",pos+n * 16,pos+n * 16+big_residue,big_residue);}else if(len > 16){n = len_change / 16;big_residue = len_change - 16*n;printf("%d %d %d\n",begin+offest_num,begin+offest_num+ n*16,n*16);printf("%d %d %d\n",begin+offest_num+ n*16,begin+offest_num+ n*16+big_residue,big_residue);}else{printf("%d %d %d\n",begin,begin+len,len);}}else if(big_untidy_need > 16){printf("%d %d %d\n",begin,begin+offest_num,offest_num);n = (len - offest_num)/16;big_residue = len - n*16-offest_num;printf("%d %d %d\n",begin+offest_num,begin+offest_num+n*16,n*16);printf("%d %d %d\n",begin+offest_num+n*16,begin+offest_num+n*16+big_residue,big_residue);}else{printf("%d %d %d\n",begin,begin+len,len);}}int main(){int begin,length;printf("please input two number:\n");scanf("%d%d",&begin,&length);if(is_division(begin)){printf("the begin bigger 8192 and is tidy\n");deal_big_tidy(begin,length);}else{printf("the begin is bigger 8192 and is not tidy\n");deal_big_untidy(begin,length);}return 0;}

要实现这个小功能，必须屡清楚思路，我简单的画草图理解下这几种情况：

1        起始位置能被16整除，且小于8192

比较要补齐8192所缺IO大小big_tidy_need  和  总IO大小len

a.      big_tidy_need  > len

b.      big_tidy_need  > 16

c.      big_tidy_need  < 16

2 起始位置能被16整除，且大于8192

         （内部逻辑同上）

3 起始位置不能被16整除，且小于8192；

（同上）；

4 起始位置不能被16整除，且大于8192；

（同上）   

总结：不论是否是16整数倍，只要len大于需要补齐的big_tidy_need，就先填满再一次分割，否则，再big_tidy_need内部一次分割。

上面的代码虽然能够实现功能，但不够精简，不够健壮，于是，又写了另一个版本。

#include<stdio.h>int offset_tail_16(int lba){    return (((lba>>4)<<4)+16-lba);}int offset_tail_8192(int lba){    return (((lba>>13)<<13)+8192-lba);}int floor_16(int size){    return ((size>>4)<<4);}#define SUWEI_MIN(a,b)  ((a>b?b:a))int main(){#define SUWEI_16    16#define SUWEI_8192  8192    int begin, length;    int tmp_start, tmp_len=0;    int remain_size;    int cmd_id = 0;        printf("please input two number:\n");    scanf("%d%d", &begin, &length);    tmp_start = begin;    remain_size = length;    while(remain_size>0)    {        if(tmp_start%SUWEI_16)        {            tmp_len= SUWEI_MIN(remain_size, offset_tail_16(tmp_start));                    }        else if(tmp_start%SUWEI_8192)        {            if(remain_size >= offset_tail_8192(tmp_start))            {                tmp_len= offset_tail_8192(tmp_start);            }            else if(remain_size >= offset_tail_16(tmp_start))            {                tmp_len= floor_16(remain_size);            }            else            {                tmp_len= remain_size;            }        }        else        {            if(remain_size >= SUWEI_8192)            {                tmp_len= SUWEI_8192;            }            else if(remain_size < SUWEI_16)            {                tmp_len= remain_size;            }            else            {                tmp_len= floor_16(remain_size);            }        }        printf("CMD%d : Start=%d, len=%d\n", cmd_id++, tmp_start, tmp_len);                remain_size -= tmp_len;        tmp_start += tmp_len;    }    printf("DONE!!!\n");    return 0;}