├── parameters_name.txt
├── parameters_value.txt
├── pagemap.h
├── readme.txt
├── page.parameters
├── Makefile
├── ssd.h
├── license.txt
├── avlTree.h
├── flash.h
├── initialize.h
├── initialize.c
├── avlTree.c
├── ssd.c
└── pagemap.c


/parameters_name.txt:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/parameters_value.txt:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/pagemap.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/huaicheng/ssdsim/HEAD/pagemap.h


--------------------------------------------------------------------------------
/readme.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/huaicheng/ssdsim/HEAD/readme.txt


--------------------------------------------------------------------------------
/page.parameters:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/huaicheng/ssdsim/HEAD/page.parameters


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | # ssdsim linux support
 2 | all:ssd 
 3 | 	
 4 | clean:
 5 | 	rm -f ssd *.o *~
 6 | .PHONY: clean
 7 | 
 8 | ssd: ssd.o avlTree.o flash.o initialize.o pagemap.o     
 9 | 	cc -g -o ssd ssd.o avlTree.o flash.o initialize.o pagemap.o
10 | ssd.o: flash.h initialize.h pagemap.h
11 | 	gcc -c -g ssd.c
12 | flash.o: pagemap.h
13 | 	gcc -c -g flash.c
14 | initialize.o: avlTree.h pagemap.h
15 | 	gcc -c -g initialize.c
16 | pagemap.o: initialize.h
17 | 	gcc -c -g pagemap.c
18 | avlTree.o: 
19 | 	gcc -c -g avlTree.c
20 | 
21 | 


--------------------------------------------------------------------------------
/ssd.h:
--------------------------------------------------------------------------------
 1 | /*****************************************************************************************************************************
 2 |   This project was supported by the National Basic Research 973 Program of China under Grant No.2011CB302301
 3 |   Huazhong University of Science and Technology (HUST)   Wuhan National Laboratory for Optoelectronics
 4 | 
 5 | FileName: ssd.h
 6 | Author: Hu Yang		Version: 2.1	Date:2011/12/02
 7 | Description: 
 8 | 
 9 | History:
10 | <contributor>     <time>        <version>       <desc>                   <e-mail>
11 | Yang Hu	        2009/09/25	      1.0		    Creat SSDsim       yanghu@foxmail.com
12 | 2010/05/01        2.x           Change 
13 | Zhiming Zhu     2011/07/01        2.0           Change               812839842@qq.com
14 | Shuangwu Zhang  2011/11/01        2.1           Change               820876427@qq.com
15 | Chao Ren        2011/07/01        2.0           Change               529517386@qq.com
16 | Hao Luo         2011/01/01        2.0           Change               luohao135680@gmail.com
17 |  *****************************************************************************************************************************/
18 | #include <stdlib.h>
19 | #include <stdio.h>
20 | #include <time.h>
21 | #include <string.h>
22 | #include <sys/types.h>
23 | #include "initialize.h"
24 | #include "flash.h"
25 | #include "pagemap.h"
26 | 
27 | #define MAX_INT64  0x7fffffffffffffffll
28 | 
29 | struct ssd_info *simulate(struct ssd_info *);
30 | int get_requests(struct ssd_info *);
31 | struct ssd_info *buffer_management(struct ssd_info *);
32 | unsigned int lpn2ppn(struct ssd_info * ,unsigned int lsn);
33 | struct ssd_info *distribute(struct ssd_info *);
34 | void trace_output(struct ssd_info* );
35 | void statistic_output(struct ssd_info *);
36 | unsigned int size(unsigned int);
37 | unsigned int transfer_size(struct ssd_info *,int,unsigned int,struct request *);
38 | int64_t find_nearest_event(struct ssd_info *);
39 | void free_all_node(struct ssd_info *);
40 | struct ssd_info *make_aged(struct ssd_info *);
41 | struct ssd_info *no_buffer_distribute(struct ssd_info *);
42 | 


--------------------------------------------------------------------------------
/license.txt:
--------------------------------------------------------------------------------
 1 | /****************************************************************************************************
 2 |  Copyright (c) 2010, Data Storage and Application Lab
 3 |  Huazhong University of Science and Technology (HUST), Wuhan National Laboratory for Optoelectronics
 4 |  All rights reserved
 5 |  
 6 |  This source code is a SSD simulator and can simulate the SSD's working. The source code 
 7 |  is free and you can redistribute and/or modify it by providing that the following 
 8 |  conditions are met:
 9 | 
10 |  1) Redistributions of source code must retain the above copyright notice,
11 |      this list of conditions and the following disclaimer.
12 |  
13 |  2) Redistributions in binary form must reproduce the above copyright notice,
14 |      this list of conditions and the following disclaimer in the documentation
15 |      and/or other materials provided with the distribution.
16 |  
17 |   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 |   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 |   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 |   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 |   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 |   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 |   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 |   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 |   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 |   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 |   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 |  
29 |  Author : Yang Hu
30 |    
31 |  History:					 
32 |  <contributor>     <time>        <version>       <desc>                   <e-mail>
33 |  Yang Hu	     2009/09/25	       1.0		     Creat SSDsim         yanghu@foxmail.com
34 |                  2010/05/01        2.x           Change 
35 |  Zhiming Zhu     2011/07/01        2.0           Change               812839842@qq.com
36 |  Shuangwu Zhang  2011/11/01        2.1           Change               820876427@qq.com
37 |  Chao Ren        2011/07/01        2.0           Change               529517386@qq.com
38 |  Hao Luo         2011/01/01        2.0           Change               luohao135680@gmail.com
39 |  Zhiming Zhu     2012/07/19        2.1.1         Correct erase_planes()   812839842@qq.com  					 
40 | 					 
41 | 					 
42 | 					 
43 | ****************************************************************************************************/					 
44 | 					 
45 | 
46 | 
47 | 
48 | 
49 | 
50 | 
51 | 
52 | 
53 | 
54 | 
55 | 
56 | 
57 | 
58 | 
59 | 
60 | 
61 | 
62 | 
63 | 
64 | 
65 | 
66 | 
67 | 
68 | 
69 | 
70 | 


--------------------------------------------------------------------------------
/avlTree.h:
--------------------------------------------------------------------------------
 1 | #ifndef AVLTREE_H
 2 | #define AVLTREE_H 10000
 3 | 
 4 | #include <string.h>
 5 | #include <malloc.h>
 6 | #include <stdlib.h>
 7 | 
 8 | #define AVL_NULL		(TREE_NODE *)0
 9 | 
10 | #define EH_FACTOR	0
11 | #define LH_FACTOR	1
12 | #define RH_FACTOR	-1
13 | #define LEFT_MINUS	0
14 | #define RIGHT_MINUS	1
15 | 
16 | 
17 | #define ORDER_LIST_WANTED
18 | 
19 | #define INSERT_PREV	0
20 | #define INSERT_NEXT	1
21 | 
22 | typedef struct _AVL_TREE_NODE
23 | {
24 | #ifdef ORDER_LIST_WANTED
25 |     struct _AVL_TREE_NODE *prev;
26 |     struct _AVL_TREE_NODE *next;
27 | #endif
28 |     struct _AVL_TREE_NODE *tree_root;
29 |     struct _AVL_TREE_NODE *left_child;
30 |     struct _AVL_TREE_NODE *right_child;
31 |     int  bf;    			                     /*平衡因子；当平衡因子的绝对值大于 或等于2的时候就表示树不平衡(balance_factor)*/
32 | }TREE_NODE;
33 | 
34 | typedef struct buffer_info
35 | {
36 |     unsigned long read_hit;                      /*这里的hit都表示sector的命中次数或是没命中的次数*/
37 |     unsigned long read_miss_hit;  
38 |     unsigned long write_hit;   
39 |     unsigned long write_miss_hit;
40 | 
41 |     struct buffer_group *buffer_head;            /*as LRU head which is most recently used*/
42 |     struct buffer_group *buffer_tail;            /*as LRU tail which is least recently used*/
43 |     TREE_NODE	*pTreeHeader;     				 /*for search target lsn is LRU table*/
44 | 
45 |     unsigned int max_buffer_sector;
46 |     unsigned int buffer_sector_count;
47 | 
48 | #ifdef ORDER_LIST_WANTED
49 |     TREE_NODE	*pListHeader;
50 |     TREE_NODE	*pListTail;
51 | #endif
52 |     unsigned int	count;		                 /*AVL树里的节点总数*/
53 |     int 			(*keyCompare)(TREE_NODE * , TREE_NODE *);
54 |     int			(*free)(TREE_NODE *);
55 | } tAVLTree;
56 | 
57 | 
58 | int avlTreeHigh(TREE_NODE *);
59 | int avlTreeCheck(tAVLTree *,TREE_NODE *);
60 | static void R_Rotate(TREE_NODE **);
61 | static void L_Rotate(TREE_NODE **);
62 | static void LeftBalance(TREE_NODE **);
63 | static void RightBalance(TREE_NODE **);
64 | static int avlDelBalance(tAVLTree *,TREE_NODE *,int);
65 | void AVL_TREE_LOCK(tAVLTree *,int);
66 | void AVL_TREE_UNLOCK(tAVLTree *);
67 | void AVL_TREENODE_FREE(tAVLTree *,TREE_NODE *);
68 | 
69 | #ifdef ORDER_LIST_WANTED
70 | static int orderListInsert(tAVLTree *,TREE_NODE *,TREE_NODE *,int);
71 | static int orderListRemove(tAVLTree *,TREE_NODE *);
72 | TREE_NODE *avlTreeFirst(tAVLTree *);
73 | TREE_NODE *avlTreeLast(tAVLTree *);
74 | TREE_NODE *avlTreeNext(TREE_NODE *pNode);
75 | TREE_NODE *avlTreePrev(TREE_NODE *pNode);
76 | #endif
77 | 
78 | static int avlTreeInsert(tAVLTree *,TREE_NODE **,TREE_NODE *,int *);
79 | static int avlTreeRemove(tAVLTree *,TREE_NODE *);
80 | static TREE_NODE *avlTreeLookup(tAVLTree *,TREE_NODE *,TREE_NODE *);
81 | tAVLTree *avlTreeCreate(int *,int *);
82 | int avlTreeDestroy(tAVLTree *);
83 | int avlTreeFlush(tAVLTree *);
84 | int avlTreeAdd(tAVLTree *,TREE_NODE *);
85 | int avlTreeDel(tAVLTree *,TREE_NODE *);
86 | TREE_NODE *avlTreeFind(tAVLTree *,TREE_NODE *);
87 | unsigned int avlTreeCount(tAVLTree *);
88 | 
89 | #endif
90 | 
91 | 
92 | 


--------------------------------------------------------------------------------
/flash.h:
--------------------------------------------------------------------------------
 1 | /*****************************************************************************************************************************
 2 |   This project was supported by the National Basic Research 973 Program of China under Grant No.2011CB302301
 3 |   Huazhong University of Science and Technology (HUST)   Wuhan National Laboratory for Optoelectronics
 4 | 
 5 |   FileName： flash.h
 6 | Author: Hu Yang		Version: 2.1	Date:2011/12/02
 7 | Description: 
 8 | 
 9 | History:
10 | <contributor>     <time>        <version>       <desc>                   <e-mail>
11 | Yang Hu	        2009/09/25	      1.0		    Creat SSDsim       yanghu@foxmail.com
12 | 2010/05/01        2.x           Change 
13 | Zhiming Zhu     2011/07/01        2.0           Change               812839842@qq.com
14 | Shuangwu Zhang  2011/11/01        2.1           Change               820876427@qq.com
15 | Chao Ren        2011/07/01        2.0           Change               529517386@qq.com
16 | Hao Luo         2011/01/01        2.0           Change               luohao135680@gmail.com
17 |  *****************************************************************************************************************************/
18 | 
19 | #ifndef FLASH_H
20 | #define FLASH_H 100000
21 | 
22 | #include <stdlib.h>
23 | #include "pagemap.h"
24 | 
25 | struct ssd_info *process(struct ssd_info *);
26 | struct ssd_info *insert2buffer(struct ssd_info *,unsigned int,int,struct sub_request *,struct request *);
27 | 
28 | struct ssd_info *flash_page_state_modify(struct ssd_info *,struct sub_request *,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int);
29 | struct ssd_info *make_same_level(struct ssd_info *,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int,unsigned int);
30 | int find_level_page(struct ssd_info *,unsigned int,unsigned int,unsigned int,struct sub_request *,struct sub_request *);
31 | int make_level_page(struct ssd_info * ssd, struct sub_request * sub0,struct sub_request * sub1);//为sub1分配与sub0相同位置的页
32 | struct ssd_info *compute_serve_time(struct ssd_info *ssd,unsigned int channel,unsigned int chip,unsigned int die,struct sub_request **subs,unsigned int subs_count,unsigned int command);
33 | int get_ppn_for_advanced_commands(struct ssd_info *ssd,unsigned int channel,unsigned int chip,struct sub_request * * subs ,unsigned int subs_count,unsigned int command);
34 | int get_ppn_for_normal_command(struct ssd_info * ssd, unsigned int channel,unsigned int chip,struct sub_request * sub);
35 | struct ssd_info *dynamic_advanced_process(struct ssd_info *ssd,unsigned int channel,unsigned int chip);
36 | 
37 | struct sub_request *find_two_plane_page(struct ssd_info *, struct sub_request *);
38 | struct sub_request *find_interleave_read_page(struct ssd_info *, struct sub_request *);
39 | int find_twoplane_write_sub_request(struct ssd_info * ssd, unsigned int channel, struct sub_request * sub_twoplane_one,struct sub_request * sub_twoplane_two);
40 | int find_interleave_sub_request(struct ssd_info * ssd, unsigned int channel, struct sub_request * sub_interleave_one,struct sub_request * sub_interleave_two);
41 | struct sub_request * find_read_sub_request(struct ssd_info * ssd, unsigned int channel, unsigned int chip, unsigned int die);
42 | struct sub_request * find_write_sub_request(struct ssd_info * ssd, unsigned int channel);
43 | struct sub_request * creat_sub_request(struct ssd_info * ssd,unsigned int lpn,int size,unsigned int state,struct request * req,unsigned int operation);
44 | 
45 | struct sub_request *find_interleave_twoplane_page(struct ssd_info *ssd, struct sub_request *onepage,unsigned int command);
46 | int find_interleave_twoplane_sub_request(struct ssd_info * ssd, unsigned int channel,struct sub_request * sub_request_one,struct sub_request * sub_request_two,unsigned int command);
47 | 
48 | struct ssd_info *delete_from_channel(struct ssd_info *ssd,unsigned int channel,struct sub_request * sub_req);
49 | struct ssd_info *un_greed_interleave_copyback(struct ssd_info *,unsigned int,unsigned int,unsigned int,struct sub_request *,struct sub_request *);
50 | struct ssd_info *un_greed_copyback(struct ssd_info *,unsigned int,unsigned int,unsigned int,struct sub_request *);
51 | int  find_active_block(struct ssd_info *ssd,unsigned int channel,unsigned int chip,unsigned int die,unsigned int plane);
52 | int write_page(struct ssd_info *ssd,unsigned int channel,unsigned int chip,unsigned int die,unsigned int plane,unsigned int active_block,unsigned int *ppn);
53 | int allocate_location(struct ssd_info * ssd ,struct sub_request *sub_req);
54 | 
55 | 
56 | int go_one_step(struct ssd_info * ssd, struct sub_request * sub1,struct sub_request *sub2, unsigned int aim_state,unsigned int command);
57 | int services_2_r_cmd_trans_and_complete(struct ssd_info * ssd);
58 | int services_2_r_wait(struct ssd_info * ssd,unsigned int channel,unsigned int * channel_busy_flag, unsigned int * change_current_time_flag);
59 | 
60 | int services_2_r_data_trans(struct ssd_info * ssd,unsigned int channel,unsigned int * channel_busy_flag, unsigned int * change_current_time_flag);
61 | int services_2_write(struct ssd_info * ssd,unsigned int channel,unsigned int * channel_busy_flag, unsigned int * change_current_time_flag);
62 | int delete_w_sub_request(struct ssd_info * ssd, unsigned int channel, struct sub_request * sub );
63 | int copy_back(struct ssd_info * ssd, unsigned int channel, unsigned int chip, unsigned int die,struct sub_request * sub);
64 | int static_write(struct ssd_info * ssd, unsigned int channel,unsigned int chip, unsigned int die,struct sub_request * sub);
65 | 
66 | #endif
67 | 
68 | 


--------------------------------------------------------------------------------
/initialize.h:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************************************************************
  2 |   This project was supported by the National Basic Research 973 Program of China under Grant No.2011CB302301
  3 |   Huazhong University of Science and Technology (HUST)   Wuhan National Laboratory for Optoelectronics
  4 | 
  5 |   FileName： initialize.h
  6 | Author: Hu Yang		Version: 2.1	Date:2011/12/02
  7 | Description: 
  8 | 
  9 | History:
 10 | <contributor>     <time>        <version>       <desc>                   <e-mail>
 11 | Yang Hu	        2009/09/25	      1.0		    Creat SSDsim       yanghu@foxmail.com
 12 | 2010/05/01        2.x           Change 
 13 | Zhiming Zhu     2011/07/01        2.0           Change               812839842@qq.com
 14 | Shuangwu Zhang  2011/11/01        2.1           Change               820876427@qq.com
 15 | Chao Ren        2011/07/01        2.0           Change               529517386@qq.com
 16 | Hao Luo         2011/01/01        2.0           Change               luohao135680@gmail.com
 17 |  *****************************************************************************************************************************/
 18 | #ifndef INITIALIZE_H
 19 | #define INITIALIZE_H 10000
 20 | 
 21 | #include <stdio.h>
 22 | #include <string.h>
 23 | #include <stdlib.h>
 24 | #include <time.h>
 25 | #include <ctype.h>
 26 | #include <sys/types.h>
 27 | #include "avlTree.h"
 28 | 
 29 | #define SECTOR 512
 30 | #define BUFSIZE 200
 31 | 
 32 | #define DYNAMIC_ALLOCATION 0
 33 | #define STATIC_ALLOCATION 1
 34 | 
 35 | #define INTERLEAVE 0
 36 | #define TWO_PLANE 1
 37 | 
 38 | #define NORMAL    2
 39 | #define INTERLEAVE_TWO_PLANE 3
 40 | #define COPY_BACK	4
 41 | 
 42 | #define AD_RANDOM 1
 43 | #define AD_COPYBACK 2
 44 | #define AD_TWOPLANE 4
 45 | #define AD_INTERLEAVE 8
 46 | #define AD_TWOPLANE_READ 16
 47 | 
 48 | #define READ 1
 49 | #define WRITE 0
 50 | 
 51 | /*********************************all states of each objects************************************************
 52 |  *一下定义了channel的空闲，命令地址传输，数据传输，传输，其他等状态
 53 |  *还有chip的空闲，写忙，读忙，命令地址传输，数据传输，擦除忙，copyback忙，其他等状态
 54 |  *还有读写子请求（sub）的等待，读命令地址传输，读，读数据传输，写命令地址传输，写数据传输，写传输，完成等状态
 55 |  ************************************************************************************************************/
 56 | 
 57 | #define CHANNEL_IDLE 000
 58 | #define CHANNEL_C_A_TRANSFER 3
 59 | #define CHANNEL_GC 4           
 60 | #define CHANNEL_DATA_TRANSFER 7
 61 | #define CHANNEL_TRANSFER 8
 62 | #define CHANNEL_UNKNOWN 9
 63 | 
 64 | #define CHIP_IDLE 100
 65 | #define CHIP_WRITE_BUSY 101
 66 | #define CHIP_READ_BUSY 102
 67 | #define CHIP_C_A_TRANSFER 103
 68 | #define CHIP_DATA_TRANSFER 107
 69 | #define CHIP_WAIT 108
 70 | #define CHIP_ERASE_BUSY 109
 71 | #define CHIP_COPYBACK_BUSY 110
 72 | #define UNKNOWN 111
 73 | 
 74 | #define SR_WAIT 200                 
 75 | #define SR_R_C_A_TRANSFER 201
 76 | #define SR_R_READ 202
 77 | #define SR_R_DATA_TRANSFER 203
 78 | #define SR_W_C_A_TRANSFER 204
 79 | #define SR_W_DATA_TRANSFER 205
 80 | #define SR_W_TRANSFER 206
 81 | #define SR_COMPLETE 299
 82 | 
 83 | #define REQUEST_IN 300         //下一条请求到达的时间
 84 | #define OUTPUT 301             //下一次数据输出的时间
 85 | 
 86 | #define GC_WAIT 400
 87 | #define GC_ERASE_C_A 401
 88 | #define GC_COPY_BACK 402
 89 | #define GC_COMPLETE 403
 90 | #define GC_INTERRUPT 0
 91 | #define GC_UNINTERRUPT 1
 92 | 
 93 | #define CHANNEL(lsn) (lsn&0x0000)>>16      
 94 | #define chip(lsn) (lsn&0x0000)>>16 
 95 | #define die(lsn) (lsn&0x0000)>>16 
 96 | #define PLANE(lsn) (lsn&0x0000)>>16 
 97 | #define BLOKC(lsn) (lsn&0x0000)>>16 
 98 | #define PAGE(lsn) (lsn&0x0000)>>16 
 99 | #define SUBPAGE(lsn) (lsn&0x0000)>>16  
100 | 
101 | #define PG_SUB 0xffffffff			
102 | 
103 | /*****************************************
104 |  *函数结果状态代码
105 |  *Status 是函数类型，其值是函数结果状态代码
106 |  ******************************************/
107 | #define TRUE		1
108 | #define FALSE		0
109 | #define SUCCESS		1
110 | #define FAILURE		0
111 | #define ERROR		-1
112 | #define INFEASIBLE	-2
113 | #define OVERFLOW	-3
114 | typedef int Status;     
115 | 
116 | struct ac_time_characteristics{
117 |     int tPROG;     //program time
118 |     int tDBSY;     //bummy busy time for two-plane program
119 |     int tBERS;     //block erase time
120 |     int tCLS;      //CLE setup time
121 |     int tCLH;      //CLE hold time
122 |     int tCS;       //CE setup time
123 |     int tCH;       //CE hold time
124 |     int tWP;       //WE pulse width
125 |     int tALS;      //ALE setup time
126 |     int tALH;      //ALE hold time
127 |     int tDS;       //data setup time
128 |     int tDH;       //data hold time
129 |     int tWC;       //write cycle time
130 |     int tWH;       //WE high hold time
131 |     int tADL;      //address to data loading time
132 |     int tR;        //data transfer from cell to register
133 |     int tAR;       //ALE to RE delay
134 |     int tCLR;      //CLE to RE delay
135 |     int tRR;       //ready to RE low
136 |     int tRP;       //RE pulse width
137 |     int tWB;       //WE high to busy
138 |     int tRC;       //read cycle time
139 |     int tREA;      //RE access time
140 |     int tCEA;      //CE access time
141 |     int tRHZ;      //RE high to output hi-z
142 |     int tCHZ;      //CE high to output hi-z
143 |     int tRHOH;     //RE high to output hold
144 |     int tRLOH;     //RE low to output hold
145 |     int tCOH;      //CE high to output hold
146 |     int tREH;      //RE high to output time
147 |     int tIR;       //output hi-z to RE low
148 |     int tRHW;      //RE high to WE low
149 |     int tWHR;      //WE high to RE low
150 |     int tRST;      //device resetting time
151 | }ac_timing;
152 | 
153 | 
154 | struct ssd_info{ 
155 |     double ssd_energy;                   //SSD的能耗，是时间和芯片数的函数,能耗因子
156 |     int64_t current_time;                //记录系统时间
157 |     int64_t next_request_time;
158 |     unsigned int real_time_subreq;       //记录实时的写请求个数，用在全动态分配时，channel优先的情况
159 |     int flag;
160 |     int active_flag;                     //记录主动写是否阻塞，如果发现柱塞，需要将时间向前推进,0表示没有阻塞，1表示被阻塞，需要向前推进时间
161 |     unsigned int page;
162 | 
163 |     unsigned int token;                  //在动态分配中，为防止每次分配在第一个channel需要维持一个令牌，每次从令牌所指的位置开始分配
164 |     unsigned int gc_request;             //记录在SSD中，当前时刻有多少gc操作的请求
165 | 
166 |     unsigned int write_request_count;    //记录写操作的次数
167 |     unsigned int read_request_count;     //记录读操作的次数
168 |     int64_t write_avg;                   //记录用于计算写请求平均响应时间的时间
169 |     int64_t read_avg;                    //记录用于计算读请求平均响应时间的时间
170 | 
171 |     unsigned int min_lsn;
172 |     unsigned int max_lsn;
173 |     unsigned long read_count;
174 |     unsigned long program_count;
175 |     unsigned long erase_count;
176 |     unsigned long direct_erase_count;
177 |     unsigned long copy_back_count;
178 |     unsigned long m_plane_read_count;
179 |     unsigned long m_plane_prog_count;
180 |     unsigned long interleave_count;
181 |     unsigned long interleave_read_count;
182 |     unsigned long inter_mplane_count;
183 |     unsigned long inter_mplane_prog_count;
184 |     unsigned long interleave_erase_count;
185 |     unsigned long mplane_erase_conut;
186 |     unsigned long interleave_mplane_erase_count;
187 |     unsigned long gc_copy_back;
188 |     unsigned long write_flash_count;     //实际产生的对flash的写操作
189 |     unsigned long waste_page_count;      //记录因为高级命令的限制导致的页浪费
190 |     float ave_read_size;
191 |     float ave_write_size;
192 |     unsigned int request_queue_length;
193 |     unsigned int update_read_count;      //记录因为更新操作导致的额外读出操作
194 | 
195 |     char parameterfilename[30];
196 |     char tracefilename[30];
197 |     char outputfilename[30];
198 |     char statisticfilename[30];
199 |     char statisticfilename2[30];
200 | 
201 |     FILE * outputfile;
202 |     FILE * tracefile;
203 |     FILE * statisticfile;
204 |     FILE * statisticfile2;
205 | 
206 |     struct parameter_value *parameter;   //SSD参数因子
207 |     struct dram_info *dram;
208 |     struct request *request_queue;       //dynamic request queue
209 |     struct request *request_tail;	     // the tail of the request queue
210 |     struct sub_request *subs_w_head;     //当采用全动态分配时，分配是不知道应该挂载哪个channel上，所以先挂在ssd上，等进入process函数时才挂到相应的channel的读请求队列上
211 |     struct sub_request *subs_w_tail;
212 |     struct event_node *event;            //事件队列，每产生一个新的事件，按照时间顺序加到这个队列，在simulate函数最后，根据这个队列队首的时间，确定时间
213 |     struct channel_info *channel_head;   //指向channel结构体数组的首地址
214 | };
215 | 
216 | 
217 | struct channel_info{
218 |     int chip;                            //表示在该总线上有多少颗粒
219 |     unsigned long read_count;
220 |     unsigned long program_count;
221 |     unsigned long erase_count;
222 |     unsigned int token;                  //在动态分配中，为防止每次分配在第一个chip需要维持一个令牌，每次从令牌所指的位置开始分配
223 | 
224 |     int current_state;                   //channel has serveral states, including idle, command/address transfer,data transfer,unknown
225 |     int next_state;
226 |     int64_t current_time;                //记录该通道的当前时间
227 |     int64_t next_state_predict_time;     //the predict time of next state, used to decide the sate at the moment
228 | 
229 |     struct event_node *event;
230 |     struct sub_request *subs_r_head;     //channel上的读请求队列头，先服务处于队列头的子请求
231 |     struct sub_request *subs_r_tail;     //channel上的读请求队列尾，新加进来的子请求加到队尾
232 |     struct sub_request *subs_w_head;     //channel上的写请求队列头，先服务处于队列头的子请求
233 |     struct sub_request *subs_w_tail;     //channel上的写请求队列，新加进来的子请求加到队尾
234 |     struct gc_operation *gc_command;     //记录需要产生gc的位置
235 |     struct chip_info *chip_head;        
236 | };
237 | 
238 | 
239 | struct chip_info{
240 |     unsigned int die_num;               //表示一个颗粒中有多少个die
241 |     unsigned int plane_num_die;         //indicate how many planes in a die
242 |     unsigned int block_num_plane;       //indicate how many blocks in a plane
243 |     unsigned int page_num_block;        //indicate how many pages in a block
244 |     unsigned int subpage_num_page;      //indicate how many subpage in a page
245 |     unsigned int ers_limit;             //该chip中每块能够被擦除的次数
246 |     unsigned int token;                 //在动态分配中，为防止每次分配在第一个die需要维持一个令牌，每次从令牌所指的位置开始分配
247 | 
248 |     int current_state;                  //channel has serveral states, including idle, command/address transfer,data transfer,unknown
249 |     int next_state;
250 |     int64_t current_time;               //记录该通道的当前时间
251 |     int64_t next_state_predict_time;    //the predict time of next state, used to decide the sate at the moment
252 | 
253 |     unsigned long read_count;           //how many read count in the process of workload
254 |     unsigned long program_count;
255 |     unsigned long erase_count;
256 | 
257 |     struct ac_time_characteristics ac_timing;  
258 |     struct die_info *die_head;
259 | };
260 | 
261 | 
262 | struct die_info{
263 | 
264 |     unsigned int token;                 //在动态分配中，为防止每次分配在第一个plane需要维持一个令牌，每次从令牌所指的位置开始分配
265 |     struct plane_info *plane_head;
266 | 
267 | };
268 | 
269 | 
270 | struct plane_info{
271 |     int add_reg_ppn;                    //read，write时把地址传送到该变量，该变量代表地址寄存器。die由busy变为idle时，清除地址 //有可能因为一对多的映射，在一个读请求时，有多个相同的lpn，所以需要用ppn来区分  
272 |     unsigned int free_page;             //该plane中有多少free page
273 |     unsigned int ers_invalid;           //记录该plane中擦除失效的块数
274 |     unsigned int active_block;          //if a die has a active block, 该项表示其物理块号
275 |     int can_erase_block;                //记录在一个plane中准备在gc操作中被擦除操作的块,-1表示还没有找到合适的块
276 |     struct direct_erase *erase_node;    //用来记录可以直接删除的块号,在获取新的ppn时，每当出现invalid_page_num==64时，将其添加到这个指针上，供GC操作时直接删除
277 |     struct blk_info *blk_head;
278 | };
279 | 
280 | 
281 | struct blk_info{
282 |     unsigned int erase_count;          //块的擦除次数，该项记录在ram中，用于GC
283 |     unsigned int free_page_num;        //记录该块中的free页个数，同上
284 |     unsigned int invalid_page_num;     //记录该块中失效页的个数，同上
285 |     int last_write_page;               //记录最近一次写操作执行的页数,-1表示该块没有一页被写过
286 |     struct page_info *page_head;       //记录每一子页的状态
287 | };
288 | 
289 | 
290 | struct page_info{                      //lpn记录该物理页存储的逻辑页，当该逻辑页有效时，valid_state大于0，free_state大于0；
291 |     int valid_state;                   //indicate the page is valid or invalid
292 |     int free_state;                    //each bit indicates the subpage is free or occupted. 1 indicates that the bit is free and 0 indicates that the bit is used
293 |     unsigned int lpn;                 
294 |     unsigned int written_count;        //记录该页被写的次数
295 | };
296 | 
297 | 
298 | struct dram_info{
299 |     unsigned int dram_capacity;     
300 |     int64_t current_time;
301 | 
302 |     struct dram_parameter *dram_paramters;      
303 |     struct map_info *map;
304 |     struct buffer_info *buffer; 
305 | 
306 | };
307 | 
308 | 
309 | /*********************************************************************************************
310 |  *buffer中的已写回的页的管理方法:在buffer_info中维持一个队列:written。这个队列有队首，队尾。
311 |  *每次buffer management中，请求命中时，这个group要移到LRU的队首，同时看这个group中是否有已
312 |  *写回的lsn，有的话，需要将这个group同时移动到written队列的队尾。这个队列的增长和减少的方法
313 |  *如下:当需要通过删除已写回的lsn为新的写请求腾出空间时，在written队首中找出可以删除的lsn。
314 |  *当需要增加新的写回lsn时，找到可以写回的页，将这个group加到指针written_insert所指队列written
315 |  *节点前。我们需要再维持一个指针，在buffer的LRU队列中指向最老的一个写回了的页，下次要再写回时，
316 |  *只需由这个指针回退到前一个group写回即可。
317 |  **********************************************************************************************/
318 | typedef struct buffer_group{
319 |     TREE_NODE node;                     //树节点的结构一定要放在用户自定义结构的最前面，注意!
320 |     struct buffer_group *LRU_link_next;	// next node in LRU list
321 |     struct buffer_group *LRU_link_pre;	// previous node in LRU list
322 | 
323 |     unsigned int group;                 //the first data logic sector number of a group stored in buffer 
324 |     unsigned int stored;                //indicate the sector is stored in buffer or not. 1 indicates the sector is stored and 0 indicate the sector isn't stored.EX.  00110011 indicates the first, second, fifth, sixth sector is stored in buffer.
325 |     unsigned int dirty_clean;           //it is flag of the data has been modified, one bit indicates one subpage. EX. 0001 indicates the first subpage is dirty
326 |     int flag;			                //indicates if this node is the last 20% of the LRU list	
327 | }buf_node;
328 | 
329 | 
330 | struct dram_parameter{
331 |     float active_current;
332 |     float sleep_current;
333 |     float voltage;
334 |     int clock_time;
335 | };
336 | 
337 | 
338 | struct map_info{
339 |     struct entry *map_entry;            //该项是映射表结构体指针,each entry indicate a mapping information
340 |     struct buffer_info *attach_info;	// info about attach map
341 | };
342 | 
343 | 
344 | struct controller_info{
345 |     unsigned int frequency;             //表示该控制器的工作频率
346 |     int64_t clock_time;                 //表示一个时钟周期的时间
347 |     float power;                        //表示控制器单位时间的能耗
348 | };
349 | 
350 | 
351 | struct request{
352 |     int64_t time;                      //请求到达的时间，单位为us,这里和通常的习惯不一样，通常的是ms为单位，这里需要有个单位变换过程
353 |     unsigned int lsn;                  //请求的起始地址，逻辑地址
354 |     unsigned int size;                 //请求的大小，既多少个扇区
355 |     unsigned int operation;            //请求的种类，1为读，0为写
356 | 
357 |     unsigned int* need_distr_flag;
358 |     unsigned int complete_lsn_count;   //record the count of lsn served by buffer
359 | 
360 |     int distri_flag;		           // indicate whether this request has been distributed already
361 | 
362 |     int64_t begin_time;
363 |     int64_t response_time;
364 |     double energy_consumption;         //记录该请求的能量消耗，单位为uJ
365 | 
366 |     struct sub_request *subs;          //链接到属于该请求的所有子请求
367 |     struct request *next_node;         //指向下一个请求结构体
368 | };
369 | 
370 | 
371 | struct sub_request{
372 |     unsigned int lpn;                  //这里表示该子请求的逻辑页号
373 |     unsigned int ppn;                  //分配那个物理子页给这个子请求。在multi_chip_page_mapping中，产生子页请求时可能就知道psn的值，其他时候psn的值由page_map_read,page_map_write等FTL最底层函数产生。 
374 |     unsigned int operation;            //表示该子请求的类型，除了读1 写0，还有擦除，two plane等操作 
375 |     int size;
376 | 
377 |     unsigned int current_state;        //表示该子请求所处的状态，见宏定义sub request
378 |     int64_t current_time;
379 |     unsigned int next_state;
380 |     int64_t next_state_predict_time;
381 |     unsigned int state;              //使用state的最高位表示该子请求是否是一对多映射关系中的一个，是的话，需要读到buffer中。1表示是一对多，0表示不用写到buffer
382 |     //读请求不需要这个成员，lsn加size就可以分辨出该页的状态;但是写请求需要这个成员，大部分写子请求来自于buffer写回操作，可能有类似子页不连续的情况，所以需要单独维持该成员
383 | 
384 |     int64_t begin_time;               //子请求开始时间
385 |     int64_t complete_time;            //记录该子请求的处理时间,既真正写入或者读出数据的时间
386 | 
387 |     struct local *location;           //在静态分配和混合分配方式中，已知lpn就知道该lpn该分配到那个channel，chip，die，plane，这个结构体用来保存计算得到的地址
388 |     struct sub_request *next_subs;    //指向属于同一个request的子请求
389 |     struct sub_request *next_node;    //指向同一个channel中下一个子请求结构体
390 |     struct sub_request *update;       //因为在写操作中存在更新操作，因为在动态分配方式中无法使用copyback操作，需要将原来的页读出后才能进行写操作，所以，将因更新产生的读操作挂在这个指针上
391 | };
392 | 
393 | 
394 | /***********************************************************************
395 |  *事件节点控制时间的增长，每次时间的增加是根据时间最近的一个事件来确定的
396 |  ************************************************************************/
397 | struct event_node{
398 |     int type;                        //记录该事件的类型，1表示命令类型，2表示数据传输类型
399 |     int64_t predict_time;            //记录这个时间开始的预计时间，防止提前执行这个时间
400 |     struct event_node *next_node;
401 |     struct event_node *pre_node;
402 | };
403 | 
404 | struct parameter_value{
405 |     unsigned int chip_num;          //记录一个SSD中有多少个颗粒
406 |     unsigned int dram_capacity;     //记录SSD中DRAM capacity
407 |     unsigned int cpu_sdram;         //记录片内有多少
408 | 
409 |     unsigned int channel_number;    //记录SSD中有多少个通道，每个通道是单独的bus
410 |     unsigned int chip_channel[100]; //设置SSD中channel数和每channel上颗粒的数量
411 | 
412 |     unsigned int die_chip;    
413 |     unsigned int plane_die;
414 |     unsigned int block_plane;
415 |     unsigned int page_block;
416 |     unsigned int subpage_page;
417 | 
418 |     unsigned int page_capacity;
419 |     unsigned int subpage_capacity;
420 | 
421 | 
422 |     unsigned int ers_limit;         //记录每个块可擦除的次数
423 |     int address_mapping;            //记录映射的类型，1：page；2：block；3：fast
424 |     int wear_leveling;              // WL算法
425 |     int gc;                         //记录gc策略
426 |     int clean_in_background;        //清除操作是否在前台完成
427 |     int alloc_pool;                 //allocation pool 大小(plane，die，chip，channel),也就是拥有active_block的单位
428 |     float overprovide;
429 |     float gc_threshold;             //当达到这个阈值时，开始GC操作，在主动写策略中，开始GC操作后可以临时中断GC操作，服务新到的请求；在普通策略中，GC不可中断
430 | 
431 |     double operating_current;       //NAND FLASH的工作电流单位是uA
432 |     double supply_voltage;	
433 |     double dram_active_current;     //cpu sdram work current   uA
434 |     double dram_standby_current;    //cpu sdram work current   uA
435 |     double dram_refresh_current;    //cpu sdram work current   uA
436 |     double dram_voltage;            //cpu sdram work voltage  V
437 | 
438 |     int buffer_management;          //indicates that there are buffer management or not
439 |     int scheduling_algorithm;       //记录使用哪种调度算法，1:FCFS
440 |     float quick_radio;
441 |     int related_mapping;
442 | 
443 |     unsigned int time_step;
444 |     unsigned int small_large_write; //the threshould of large write, large write do not occupt buffer, which is written back to flash directly
445 | 
446 |     int striping;                   //表示是否使用了striping方式，0表示没有，1表示有
447 |     int interleaving;
448 |     int pipelining;
449 |     int threshold_fixed_adjust;
450 |     int threshold_value;
451 |     int active_write;               //表示是否执行主动写操作1,yes;0,no
452 |     float gc_hard_threshold;        //普通策略中用不到该参数，只有在主动写策略中，当满足这个阈值时，GC操作不可中断
453 |     int allocation_scheme;          //记录分配方式的选择，0表示动态分配，1表示静态分配
454 |     int static_allocation;          //记录是那种静态分配方式，如ICS09那篇文章所述的所有静态分配方式
455 |     int dynamic_allocation;         //记录动态分配的方式
456 |     int advanced_commands;  
457 |     int ad_priority;                //record the priority between two plane operation and interleave operation
458 |     int ad_priority2;               //record the priority of channel-level, 0 indicates that the priority order of channel-level is highest; 1 indicates the contrary
459 |     int greed_CB_ad;                //0 don't use copyback advanced commands greedily; 1 use copyback advanced commands greedily
460 |     int greed_MPW_ad;               //0 don't use multi-plane write advanced commands greedily; 1 use multi-plane write advanced commands greedily
461 |     int aged;                       //1表示需要将这个SSD变成aged，0表示需要将这个SSD保持non-aged
462 |     float aged_ratio; 
463 |     int queue_length;               //请求队列的长度限制
464 | 
465 |     struct ac_time_characteristics time_characteristics;
466 | };
467 | 
468 | /********************************************************
469 |  *mapping information,state的最高位表示是否有附加映射关系
470 |  *********************************************************/
471 | struct entry{                       
472 |     unsigned int pn;                //物理号，既可以表示物理页号，也可以表示物理子页号，也可以表示物理块号
473 |     int state;                      //十六进制表示的话是0000-FFFF，每位表示相应的子页是否有效（页映射）。比如在这个页中，0，1号子页有效，2，3无效，这个应该是0x0003.
474 | };
475 | 
476 | 
477 | struct local{          
478 |     unsigned int channel;
479 |     unsigned int chip;
480 |     unsigned int die;
481 |     unsigned int plane;
482 |     unsigned int block;
483 |     unsigned int page;
484 |     unsigned int sub_page;
485 | };
486 | 
487 | 
488 | struct gc_info{
489 |     int64_t begin_time;            //记录一个plane什么时候开始gc操作的
490 |     int copy_back_count;    
491 |     int erase_count;
492 |     int64_t process_time;          //该plane花了多少时间在gc操作上
493 |     double energy_consumption;     //该plane花了多少能量在gc操作上
494 | };
495 | 
496 | 
497 | struct direct_erase{
498 |     unsigned int block;
499 |     struct direct_erase *next_node;
500 | };
501 | 
502 | 
503 | /**************************************************************************************
504 |  *当产生一个GC操作时，将这个结构挂在相应的channel上，等待channel空闲时，发出GC操作命令
505 |  ***************************************************************************************/
506 | struct gc_operation{          
507 |     unsigned int chip;
508 |     unsigned int die;
509 |     unsigned int plane;
510 |     unsigned int block;           //该参数只在可中断的gc函数中使用（gc_interrupt），用来记录已近找出来的目标块号
511 |     unsigned int page;            //该参数只在可中断的gc函数中使用（gc_interrupt），用来记录已经完成的数据迁移的页号
512 |     unsigned int state;           //记录当前gc请求的状态
513 |     unsigned int priority;        //记录该gc操作的优先级，1表示不可中断，0表示可中断（软阈值产生的gc请求）
514 |     struct gc_operation *next_node;
515 | };
516 | 
517 | /*
518 |  *add by ninja
519 |  *used for map_pre function
520 |  */
521 | typedef struct Dram_write_map
522 | {
523 |     unsigned int state; 
524 | }Dram_write_map;
525 | 
526 | 
527 | struct ssd_info *initiation(struct ssd_info *);
528 | struct parameter_value *load_parameters(char parameter_file[30]);
529 | struct page_info * initialize_page(struct page_info * p_page);
530 | struct blk_info * initialize_block(struct blk_info * p_block,struct parameter_value *parameter);
531 | struct plane_info * initialize_plane(struct plane_info * p_plane,struct parameter_value *parameter );
532 | struct die_info * initialize_die(struct die_info * p_die,struct parameter_value *parameter,long long current_time );
533 | struct chip_info * initialize_chip(struct chip_info * p_chip,struct parameter_value *parameter,long long current_time );
534 | struct ssd_info * initialize_channels(struct ssd_info * ssd );
535 | struct dram_info * initialize_dram(struct ssd_info * ssd);
536 | 
537 | #endif
538 | 
539 | 


--------------------------------------------------------------------------------
/initialize.c:
--------------------------------------------------------------------------------
  1 | /*****************************************************************************************************************************
  2 |   This project was supported by the National Basic Research 973 Program of China under Grant No.2011CB302301
  3 |   Huazhong University of Science and Technology (HUST)   Wuhan National Laboratory for Optoelectronics
  4 | 
  5 |   FileName： initialize.c
  6 | Author: Hu Yang		Version: 2.1	Date:2011/12/02
  7 | Description: 
  8 | 
  9 | History:
 10 | <contributor>     <time>        <version>       <desc>                   <e-mail>
 11 | Yang Hu	        2009/09/25	      1.0		    Creat SSDsim       yanghu@foxmail.com
 12 | 2010/05/01        2.x           Change 
 13 | Zhiming Zhu     2011/07/01        2.0           Change               812839842@qq.com
 14 | Shuangwu Zhang  2011/11/01        2.1           Change               820876427@qq.com
 15 | Chao Ren        2011/07/01        2.0           Change               529517386@qq.com
 16 | Hao Luo         2011/01/01        2.0           Change               luohao135680@gmail.com
 17 |  *****************************************************************************************************************************/
 18 | 
 19 | #define _CRTDBG_MAP_ALLOC
 20 | 
 21 | #include <stdlib.h>
 22 | #include "initialize.h"
 23 | 
 24 | #define FALSE		0
 25 | #define TRUE		1
 26 | 
 27 | #define ACTIVE_FIXED 0
 28 | #define ACTIVE_ADJUST 1
 29 | 
 30 | 
 31 | /************************************************************************
 32 |  * Compare function for AVL Tree                                        
 33 |  ************************************************************************/
 34 | extern int keyCompareFunc(TREE_NODE *p , TREE_NODE *p1)
 35 | {
 36 |     struct buffer_group *T1=NULL,*T2=NULL;
 37 | 
 38 |     T1=(struct buffer_group*)p;
 39 |     T2=(struct buffer_group*)p1;
 40 | 
 41 | 
 42 |     if(T1->group< T2->group) return 1;
 43 |     if(T1->group> T2->group) return -1;
 44 | 
 45 |     return 0;
 46 | }
 47 | 
 48 | 
 49 | extern int freeFunc(TREE_NODE *pNode)
 50 | {
 51 | 
 52 |     if(pNode!=NULL)
 53 |     {
 54 |         free((void *)pNode);
 55 |     }
 56 | 
 57 | 
 58 |     pNode=NULL;
 59 |     return 1;
 60 | }
 61 | 
 62 | 
 63 | /**********   initiation   ******************
 64 |  *modify by zhouwen
 65 |  *November 08,2011
 66 |  *initialize the ssd struct to simulate the ssd hardware
 67 |  *1.this function allocate memory for ssd structure 
 68 |  *2.set the infomation according to the parameter file
 69 |  *******************************************/
 70 | struct ssd_info *initiation(struct ssd_info *ssd)
 71 | {
 72 |     unsigned int x=0,y=0,i=0,j=0,k=0,l=0,m=0,n=0;
 73 |     //errno_t err;
 74 |     char buffer[300];
 75 |     struct parameter_value *parameters;
 76 |     FILE *fp=NULL;
 77 | 
 78 |     /*printf("input parameter file name:");
 79 |       gets(ssd->parameterfilename);
 80 |       strcpy_s(ssd->parameterfilename,16,"page.parameters");
 81 | 
 82 |       printf("\ninput trace file name:");
 83 |       gets(ssd->tracefilename);
 84 |       strcpy_s(ssd->tracefilename,25,"Exchange.ascii");
 85 | 
 86 |       printf("\ninput output file name:");
 87 |       gets(ssd->outputfilename);
 88 |       strcpy_s(ssd->outputfilename,7,"ex.out");
 89 | 
 90 |       printf("\ninput statistic file name:");
 91 |       gets(ssd->statisticfilename);
 92 |       strcpy_s(ssd->statisticfilename,16,"statistic10.dat");
 93 | 
 94 |       strcpy_s(ssd->statisticfilename2 ,16,"statistic2.dat");*/
 95 | 
 96 |     strncpy(ssd->parameterfilename,"page.parameters",16);
 97 |     //strncpy(ssd->tracefilename,"example.ascii",25);
 98 |     printf("\ninput trace file name:");
 99 |     scanf("%s",ssd->tracefilename);
100 |     strncpy(ssd->outputfilename,"ex.out",7);
101 |     strncpy(ssd->statisticfilename,"statistic10.dat",16);
102 |     strncpy(ssd->statisticfilename2,"statistic2.dat",15);
103 | 
104 |     //导入ssd的配置文件
105 |     parameters=load_parameters(ssd->parameterfilename);
106 |     ssd->parameter=parameters;
107 |     ssd->min_lsn=0x7fffffff;
108 |     ssd->page=ssd->parameter->chip_num*ssd->parameter->die_chip*ssd->parameter->plane_die*ssd->parameter->block_plane*ssd->parameter->page_block;
109 | 
110 |     //初始化 dram
111 |     ssd->dram = (struct dram_info *)malloc(sizeof(struct dram_info));
112 |     alloc_assert(ssd->dram,"ssd->dram");
113 |     memset(ssd->dram,0,sizeof(struct dram_info));
114 |     initialize_dram(ssd);
115 | 
116 |     //初始化通道
117 |     ssd->channel_head=(struct channel_info*)malloc(ssd->parameter->channel_number * sizeof(struct channel_info));
118 |     alloc_assert(ssd->channel_head,"ssd->channel_head");
119 |     memset(ssd->channel_head,0,ssd->parameter->channel_number * sizeof(struct channel_info));
120 |     initialize_channels(ssd );
121 | 
122 | 
123 |     printf("\n");
124 |     ssd->outputfile=fopen(ssd->outputfilename,"w");
125 |     if(ssd->outputfile==NULL)
126 |     {
127 |         printf("the output file can't open\n");
128 |         return NULL;
129 |     }
130 | 
131 |     printf("\n");
132 |     ssd->statisticfile=fopen(ssd->statisticfilename,"w");
133 |     if(ssd->statisticfile==NULL)
134 |     {
135 |         printf("the statistic file can't open\n");
136 |         return NULL;
137 |     }
138 | 
139 |     printf("\n");
140 | 
141 | 
142 |     fprintf(ssd->outputfile,"parameter file: %s\n",ssd->parameterfilename); 
143 |     fprintf(ssd->outputfile,"trace file: %s\n",ssd->tracefilename);
144 |     fprintf(ssd->statisticfile,"parameter file: %s\n",ssd->parameterfilename); 
145 |     fprintf(ssd->statisticfile,"trace file: %s\n",ssd->tracefilename);
146 | 
147 |     fflush(ssd->outputfile);
148 |     fflush(ssd->statisticfile);
149 | 
150 |     fp=fopen(ssd->parameterfilename,"r");
151 |     if(fp==NULL)
152 |     {
153 |         printf("\nthe parameter file can't open!\n");
154 |         return NULL;
155 |     }
156 | 
157 |     //fp=fopen(ssd->parameterfilename,"r");
158 | 
159 |     fprintf(ssd->outputfile,"-----------------------parameter file----------------------\n");
160 |     fprintf(ssd->statisticfile,"-----------------------parameter file----------------------\n");
161 |     while(fgets(buffer,300,fp))
162 |     {
163 |         fprintf(ssd->outputfile,"%s",buffer);
164 |         fflush(ssd->outputfile);
165 |         fprintf(ssd->statisticfile,"%s",buffer);
166 |         fflush(ssd->statisticfile);
167 |     }
168 | 
169 |     fprintf(ssd->outputfile,"\n");
170 |     fprintf(ssd->outputfile,"-----------------------simulation output----------------------\n");
171 |     fflush(ssd->outputfile);
172 | 
173 |     fprintf(ssd->statisticfile,"\n");
174 |     fprintf(ssd->statisticfile,"-----------------------simulation output----------------------\n");
175 |     fflush(ssd->statisticfile);
176 | 
177 |     fclose(fp);
178 |     printf("initiation is completed!\n");
179 | 
180 |     return ssd;
181 | }
182 | 
183 | 
184 | struct dram_info * initialize_dram(struct ssd_info * ssd)
185 | {
186 |     unsigned int page_num;
187 | 
188 |     struct dram_info *dram=ssd->dram;
189 |     dram->dram_capacity = ssd->parameter->dram_capacity;		
190 |     dram->buffer = (tAVLTree *)avlTreeCreate((void*)keyCompareFunc , (void *)freeFunc);
191 |     dram->buffer->max_buffer_sector=ssd->parameter->dram_capacity/SECTOR; //512
192 | 
193 |     dram->map = (struct map_info *)malloc(sizeof(struct map_info));
194 |     alloc_assert(dram->map,"dram->map");
195 |     memset(dram->map,0, sizeof(struct map_info));
196 | 
197 |     page_num = ssd->parameter->page_block*ssd->parameter->block_plane*ssd->parameter->plane_die*ssd->parameter->die_chip*ssd->parameter->chip_num;
198 | 
199 |     dram->map->map_entry = (struct entry *)malloc(sizeof(struct entry) * page_num); //每个物理页和逻辑页都有对应关系
200 |     alloc_assert(dram->map->map_entry,"dram->map->map_entry");
201 |     memset(dram->map->map_entry,0,sizeof(struct entry) * page_num);
202 | 
203 |     return dram;
204 | }
205 | 
206 | struct page_info * initialize_page(struct page_info * p_page )
207 | {
208 |     p_page->valid_state =0;
209 |     p_page->free_state = PG_SUB;
210 |     p_page->lpn = -1;
211 |     p_page->written_count=0;
212 |     return p_page;
213 | }
214 | 
215 | struct blk_info * initialize_block(struct blk_info * p_block,struct parameter_value *parameter)
216 | {
217 |     unsigned int i;
218 |     struct page_info * p_page;
219 | 
220 |     p_block->free_page_num = parameter->page_block;	// all pages are free
221 |     p_block->last_write_page = -1;	// no page has been programmed
222 | 
223 |     p_block->page_head = (struct page_info *)malloc(parameter->page_block * sizeof(struct page_info));
224 |     alloc_assert(p_block->page_head,"p_block->page_head");
225 |     memset(p_block->page_head,0,parameter->page_block * sizeof(struct page_info));
226 | 
227 |     for(i = 0; i<parameter->page_block; i++)
228 |     {
229 |         p_page = &(p_block->page_head[i]);
230 |         initialize_page(p_page );
231 |     }
232 |     return p_block;
233 | 
234 | }
235 | 
236 | struct plane_info * initialize_plane(struct plane_info * p_plane,struct parameter_value *parameter )
237 | {
238 |     unsigned int i;
239 |     struct blk_info * p_block;
240 |     p_plane->add_reg_ppn = -1;  //plane 里面的额外寄存器additional register -1 表示无数据
241 |     p_plane->free_page=parameter->block_plane*parameter->page_block;
242 | 
243 |     p_plane->blk_head = (struct blk_info *)malloc(parameter->block_plane * sizeof(struct blk_info));
244 |     alloc_assert(p_plane->blk_head,"p_plane->blk_head");
245 |     memset(p_plane->blk_head,0,parameter->block_plane * sizeof(struct blk_info));
246 | 
247 |     for(i = 0; i<parameter->block_plane; i++)
248 |     {
249 |         p_block = &(p_plane->blk_head[i]);
250 |         initialize_block( p_block ,parameter);			
251 |     }
252 |     return p_plane;
253 | }
254 | 
255 | struct die_info * initialize_die(struct die_info * p_die,struct parameter_value *parameter,long long current_time )
256 | {
257 |     unsigned int i;
258 |     struct plane_info * p_plane;
259 | 
260 |     p_die->token=0;
261 | 
262 |     p_die->plane_head = (struct plane_info*)malloc(parameter->plane_die * sizeof(struct plane_info));
263 |     alloc_assert(p_die->plane_head,"p_die->plane_head");
264 |     memset(p_die->plane_head,0,parameter->plane_die * sizeof(struct plane_info));
265 | 
266 |     for (i = 0; i<parameter->plane_die; i++)
267 |     {
268 |         p_plane = &(p_die->plane_head[i]);
269 |         initialize_plane(p_plane,parameter );
270 |     }
271 | 
272 |     return p_die;
273 | }
274 | 
275 | struct chip_info * initialize_chip(struct chip_info * p_chip,struct parameter_value *parameter,long long current_time )
276 | {
277 |     unsigned int i;
278 |     struct die_info *p_die;
279 | 
280 |     p_chip->current_state = CHIP_IDLE;
281 |     p_chip->next_state = CHIP_IDLE;
282 |     p_chip->current_time = current_time;
283 |     p_chip->next_state_predict_time = 0;			
284 |     p_chip->die_num = parameter->die_chip;
285 |     p_chip->plane_num_die = parameter->plane_die;
286 |     p_chip->block_num_plane = parameter->block_plane;
287 |     p_chip->page_num_block = parameter->block_plane;
288 |     p_chip->subpage_num_page = parameter->subpage_page;
289 |     p_chip->ers_limit = parameter->ers_limit;
290 |     p_chip->token=0;
291 |     p_chip->ac_timing = parameter->time_characteristics;		
292 |     p_chip->read_count = 0;
293 |     p_chip->program_count = 0;
294 |     p_chip->erase_count = 0;
295 | 
296 |     p_chip->die_head = (struct die_info *)malloc(parameter->die_chip * sizeof(struct die_info));
297 |     alloc_assert(p_chip->die_head,"p_chip->die_head");
298 |     memset(p_chip->die_head,0,parameter->die_chip * sizeof(struct die_info));
299 | 
300 |     for (i = 0; i<parameter->die_chip; i++)
301 |     {
302 |         p_die = &(p_chip->die_head[i]);
303 |         initialize_die( p_die,parameter,current_time );	
304 |     }
305 | 
306 |     return p_chip;
307 | }
308 | 
309 | struct ssd_info * initialize_channels(struct ssd_info * ssd )
310 | {
311 |     unsigned int i,j;
312 |     struct channel_info * p_channel;
313 |     struct chip_info * p_chip;
314 | 
315 |     // set the parameter of each channel
316 |     for (i = 0; i< ssd->parameter->channel_number; i++)
317 |     {
318 |         p_channel = &(ssd->channel_head[i]);
319 |         p_channel->chip = ssd->parameter->chip_channel[i];
320 |         p_channel->current_state = CHANNEL_IDLE;
321 |         p_channel->next_state = CHANNEL_IDLE;
322 | 
323 |         p_channel->chip_head = (struct chip_info *)malloc(ssd->parameter->chip_channel[i]* sizeof(struct chip_info));
324 |         alloc_assert(p_channel->chip_head,"p_channel->chip_head");
325 |         memset(p_channel->chip_head,0,ssd->parameter->chip_channel[i]* sizeof(struct chip_info));
326 | 
327 |         for (j = 0; j< ssd->parameter->chip_channel[i]; j++)
328 |         {
329 |             p_chip = &(p_channel->chip_head[j]);
330 |             initialize_chip(p_chip,ssd->parameter,ssd->current_time );
331 |         }
332 |     }
333 | 
334 |     return ssd;
335 | }
336 | 
337 | 
338 | /*************************************************
339 |  *将page.parameters里面的参数导入到ssd->parameter里
340 |  *modify by zhouwen
341 |  *November 8,2011
342 |  **************************************************/
343 | struct parameter_value *load_parameters(char parameter_file[30])
344 | {
345 |     FILE * fp;
346 |     FILE * fp1;
347 |     FILE * fp2;
348 |     //errno_t ferr;
349 |     struct parameter_value *p;
350 |     char buf[BUFSIZE];
351 |     int i;
352 |     int pre_eql,next_eql;
353 |     int res_eql;
354 |     char *ptr;
355 | 
356 |     p = (struct parameter_value *)malloc(sizeof(struct parameter_value));
357 |     alloc_assert(p,"parameter_value");
358 |     memset(p,0,sizeof(struct parameter_value));
359 |     p->queue_length=5;
360 |     memset(buf,0,BUFSIZE);
361 | 
362 |     fp=fopen(parameter_file,"r");
363 |     if(fp == NULL)
364 |     {	
365 |         printf("the file parameter_file error!\n");	
366 |         return p;
367 |     }
368 |     fp1=fopen("parameters_name.txt","w");
369 |     if(fp1==NULL)
370 |     {	
371 |         printf("the file parameter_name error!\n");	
372 |         return p;
373 |     }
374 |     fp2=fopen("parameters_value.txt","w");
375 |     if(fp2==NULL)
376 |     {	
377 |         printf("the file parameter_value error!\n");	
378 |         return p;
379 |     }
380 | 
381 | 
382 | 
383 |     while(fgets(buf,200,fp)){
384 |         if(buf[0] =='#' || buf[0] == ' ') continue;
385 |         ptr=strchr(buf,'=');
386 |         if(!ptr) continue; 
387 | 
388 |         pre_eql = ptr - buf;
389 |         next_eql = pre_eql + 1;
390 | 
391 |         while(buf[pre_eql-1] == ' ') pre_eql--;
392 |         buf[pre_eql] = 0;
393 |         if((res_eql=strcmp(buf,"chip number")) ==0){			
394 |             sscanf(buf + next_eql,"%d",&p->chip_num);
395 |         }else if((res_eql=strcmp(buf,"dram capacity")) ==0){
396 |             sscanf(buf + next_eql,"%d",&p->dram_capacity);
397 |         }else if((res_eql=strcmp(buf,"cpu sdram")) ==0){
398 |             sscanf(buf + next_eql,"%d",&p->cpu_sdram);
399 |         }else if((res_eql=strcmp(buf,"channel number")) ==0){
400 |             sscanf(buf + next_eql,"%d",&p->channel_number); 
401 |         }else if((res_eql=strcmp(buf,"die number")) ==0){
402 |             sscanf(buf + next_eql,"%d",&p->die_chip); 
403 |         }else if((res_eql=strcmp(buf,"plane number")) ==0){
404 |             sscanf(buf + next_eql,"%d",&p->plane_die); 
405 |         }else if((res_eql=strcmp(buf,"block number")) ==0){
406 |             sscanf(buf + next_eql,"%d",&p->block_plane); 
407 |         }else if((res_eql=strcmp(buf,"page number")) ==0){
408 |             sscanf(buf + next_eql,"%d",&p->page_block); 
409 |         }else if((res_eql=strcmp(buf,"subpage page")) ==0){
410 |             sscanf(buf + next_eql,"%d",&p->subpage_page); 
411 |         }else if((res_eql=strcmp(buf,"page capacity")) ==0){
412 |             sscanf(buf + next_eql,"%d",&p->page_capacity); 
413 |         }else if((res_eql=strcmp(buf,"subpage capacity")) ==0){
414 |             sscanf(buf + next_eql,"%d",&p->subpage_capacity); 
415 |         }else if((res_eql=strcmp(buf,"t_PROG")) ==0){
416 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tPROG); 
417 |         }else if((res_eql=strcmp(buf,"t_DBSY")) ==0){
418 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tDBSY); 
419 |         }else if((res_eql=strcmp(buf,"t_BERS")) ==0){
420 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tBERS); 
421 |         }else if((res_eql=strcmp(buf,"t_CLS")) ==0){
422 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tCLS); 
423 |         }else if((res_eql=strcmp(buf,"t_CLH")) ==0){
424 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tCLH); 
425 |         }else if((res_eql=strcmp(buf,"t_CS")) ==0){
426 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tCS); 
427 |         }else if((res_eql=strcmp(buf,"t_CH")) ==0){
428 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tCH); 
429 |         }else if((res_eql=strcmp(buf,"t_WP")) ==0){
430 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tWP); 
431 |         }else if((res_eql=strcmp(buf,"t_ALS")) ==0){
432 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tALS); 
433 |         }else if((res_eql=strcmp(buf,"t_ALH")) ==0){
434 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tALH); 
435 |         }else if((res_eql=strcmp(buf,"t_DS")) ==0){
436 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tDS); 
437 |         }else if((res_eql=strcmp(buf,"t_DH")) ==0){
438 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tDH); 
439 |         }else if((res_eql=strcmp(buf,"t_WC")) ==0){
440 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tWC); 
441 |         }else if((res_eql=strcmp(buf,"t_WH")) ==0){
442 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tWH); 
443 |         }else if((res_eql=strcmp(buf,"t_ADL")) ==0){
444 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tADL); 
445 |         }else if((res_eql=strcmp(buf,"t_R")) ==0){
446 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tR); 
447 |         }else if((res_eql=strcmp(buf,"t_AR")) ==0){
448 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tAR); 
449 |         }else if((res_eql=strcmp(buf,"t_CLR")) ==0){
450 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tCLR); 
451 |         }else if((res_eql=strcmp(buf,"t_RR")) ==0){
452 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tRR); 
453 |         }else if((res_eql=strcmp(buf,"t_RP")) ==0){
454 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tRP); 
455 |         }else if((res_eql=strcmp(buf,"t_WB")) ==0){
456 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tWB); 
457 |         }else if((res_eql=strcmp(buf,"t_RC")) ==0){
458 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tRC); 
459 |         }else if((res_eql=strcmp(buf,"t_REA")) ==0){
460 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tREA); 
461 |         }else if((res_eql=strcmp(buf,"t_CEA")) ==0){
462 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tCEA); 
463 |         }else if((res_eql=strcmp(buf,"t_RHZ")) ==0){
464 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tRHZ); 
465 |         }else if((res_eql=strcmp(buf,"t_CHZ")) ==0){
466 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tCHZ); 
467 |         }else if((res_eql=strcmp(buf,"t_RHOH")) ==0){
468 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tRHOH); 
469 |         }else if((res_eql=strcmp(buf,"t_RLOH")) ==0){
470 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tRLOH); 
471 |         }else if((res_eql=strcmp(buf,"t_COH")) ==0){
472 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tCOH); 
473 |         }else if((res_eql=strcmp(buf,"t_REH")) ==0){
474 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tREH); 
475 |         }else if((res_eql=strcmp(buf,"t_IR")) ==0){
476 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tIR); 
477 |         }else if((res_eql=strcmp(buf,"t_RHW")) ==0){
478 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tRHW); 
479 |         }else if((res_eql=strcmp(buf,"t_WHR")) ==0){
480 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tWHR); 
481 |         }else if((res_eql=strcmp(buf,"t_RST")) ==0){
482 |             sscanf(buf + next_eql,"%d",&p->time_characteristics.tRST); 
483 |         }else if((res_eql=strcmp(buf,"erase limit")) ==0){
484 |             sscanf(buf + next_eql,"%d",&p->ers_limit); 
485 |         }else if((res_eql=strcmp(buf,"flash operating current")) ==0){
486 |             sscanf(buf + next_eql,"%lf",&p->operating_current); 
487 |         }else if((res_eql=strcmp(buf,"flash supply voltage")) ==0){
488 |             sscanf(buf + next_eql,"%lf",&p->supply_voltage); 
489 |         }else if((res_eql=strcmp(buf,"dram active current")) ==0){
490 |             sscanf(buf + next_eql,"%lf",&p->dram_active_current); 
491 |         }else if((res_eql=strcmp(buf,"dram standby current")) ==0){
492 |             sscanf(buf + next_eql,"%lf",&p->dram_standby_current); 
493 |         }else if((res_eql=strcmp(buf,"dram refresh current")) ==0){
494 |             sscanf(buf + next_eql,"%lf",&p->dram_refresh_current); 
495 |         }else if((res_eql=strcmp(buf,"dram voltage")) ==0){
496 |             sscanf(buf + next_eql,"%lf",&p->dram_voltage); 
497 |         }else if((res_eql=strcmp(buf,"address mapping")) ==0){
498 |             sscanf(buf + next_eql,"%d",&p->address_mapping); 
499 |         }else if((res_eql=strcmp(buf,"wear leveling")) ==0){
500 |             sscanf(buf + next_eql,"%d",&p->wear_leveling); 
501 |         }else if((res_eql=strcmp(buf,"gc")) ==0){
502 |             sscanf(buf + next_eql,"%d",&p->gc); 
503 |         }else if((res_eql=strcmp(buf,"clean in background")) ==0){
504 |             sscanf(buf + next_eql,"%d",&p->clean_in_background); 
505 |         }else if((res_eql=strcmp(buf,"overprovide")) ==0){
506 |             sscanf(buf + next_eql,"%f",&p->overprovide); 
507 |         }else if((res_eql=strcmp(buf,"gc threshold")) ==0){
508 |             sscanf(buf + next_eql,"%f",&p->gc_threshold); 
509 |         }else if((res_eql=strcmp(buf,"buffer management")) ==0){
510 |             sscanf(buf + next_eql,"%d",&p->buffer_management); 
511 |         }else if((res_eql=strcmp(buf,"scheduling algorithm")) ==0){
512 |             sscanf(buf + next_eql,"%d",&p->scheduling_algorithm); 
513 |         }else if((res_eql=strcmp(buf,"quick table radio")) ==0){
514 |             sscanf(buf + next_eql,"%f",&p->quick_radio); 
515 |         }else if((res_eql=strcmp(buf,"related mapping")) ==0){
516 |             sscanf(buf + next_eql,"%d",&p->related_mapping); 
517 |         }else if((res_eql=strcmp(buf,"striping")) ==0){
518 |             sscanf(buf + next_eql,"%d",&p->striping); 
519 |         }else if((res_eql=strcmp(buf,"interleaving")) ==0){
520 |             sscanf(buf + next_eql,"%d",&p->interleaving); 
521 |         }else if((res_eql=strcmp(buf,"pipelining")) ==0){
522 |             sscanf(buf + next_eql,"%d",&p->pipelining); 
523 |         }else if((res_eql=strcmp(buf,"time_step")) ==0){
524 |             sscanf(buf + next_eql,"%d",&p->time_step); 
525 |         }else if((res_eql=strcmp(buf,"small large write")) ==0){
526 |             sscanf(buf + next_eql,"%d",&p->small_large_write); 
527 |         }else if((res_eql=strcmp(buf,"active write threshold")) ==0){
528 |             sscanf(buf + next_eql,"%d",&p->threshold_fixed_adjust); 
529 |         }else if((res_eql=strcmp(buf,"threshold value")) ==0){
530 |             sscanf(buf + next_eql,"%f",&p->threshold_value); 
531 |         }else if((res_eql=strcmp(buf,"active write")) ==0){
532 |             sscanf(buf + next_eql,"%d",&p->active_write); 
533 |         }else if((res_eql=strcmp(buf,"gc hard threshold")) ==0){
534 |             sscanf(buf + next_eql,"%f",&p->gc_hard_threshold); 
535 |         }else if((res_eql=strcmp(buf,"allocation")) ==0){
536 |             sscanf(buf + next_eql,"%d",&p->allocation_scheme); 
537 |         }else if((res_eql=strcmp(buf,"static_allocation")) ==0){
538 |             sscanf(buf + next_eql,"%d",&p->static_allocation); 
539 |         }else if((res_eql=strcmp(buf,"dynamic_allocation")) ==0){
540 |             sscanf(buf + next_eql,"%d",&p->dynamic_allocation); 
541 |         }else if((res_eql=strcmp(buf,"advanced command")) ==0){
542 |             sscanf(buf + next_eql,"%d",&p->advanced_commands); 
543 |         }else if((res_eql=strcmp(buf,"advanced command priority")) ==0){
544 |             sscanf(buf + next_eql,"%d",&p->ad_priority); 
545 |         }else if((res_eql=strcmp(buf,"advanced command priority2")) ==0){
546 |             sscanf(buf + next_eql,"%d",&p->ad_priority2); 
547 |         }else if((res_eql=strcmp(buf,"greed CB command")) ==0){
548 |             sscanf(buf + next_eql,"%d",&p->greed_CB_ad); 
549 |         }else if((res_eql=strcmp(buf,"greed MPW command")) ==0){
550 |             sscanf(buf + next_eql,"%d",&p->greed_MPW_ad); 
551 |         }else if((res_eql=strcmp(buf,"aged")) ==0){
552 |             sscanf(buf + next_eql,"%d",&p->aged); 
553 |         }else if((res_eql=strcmp(buf,"aged ratio")) ==0){
554 |             sscanf(buf + next_eql,"%f",&p->aged_ratio); 
555 |         }else if((res_eql=strcmp(buf,"queue_length")) ==0){
556 |             sscanf(buf + next_eql,"%d",&p->queue_length); 
557 |         }else if((res_eql=strncmp(buf,"chip number",11)) ==0)
558 |         {
559 |             sscanf(buf+12,"%d",&i);
560 |             sscanf(buf + next_eql,"%d",&p->chip_channel[i]); 
561 |         }else{
562 |             printf("don't match\t %s\n",buf);
563 |         }
564 | 
565 |         memset(buf,0,BUFSIZE);
566 | 
567 |     }
568 |     fclose(fp);
569 |     fclose(fp1);
570 |     fclose(fp2);
571 | 
572 |     return p;
573 | }
574 | 
575 | 
576 | 


--------------------------------------------------------------------------------
/avlTree.c:
--------------------------------------------------------------------------------
   1 | #include "avlTree.h"
   2 | 
   3 | 
   4 | 
   5 | /******************************************************************** 
   6 |  * 
   7 |  * avlTreeHigh(TREE_NODE *pNode)
   8 |  * 
   9 |  * 计算当前树的高度
  10 |  *  
  11 |  * Returns         : 树的高度
  12 |  * 
  13 |  *********************************************************************/ 
  14 | int avlTreeHigh(TREE_NODE *pNode)
  15 | {
  16 |     int lh=0,rh=0;
  17 |     if(!pNode)
  18 |         return 0;
  19 | 
  20 |     lh = avlTreeHigh(pNode->left_child);
  21 |     rh = avlTreeHigh(pNode->right_child);
  22 | 
  23 |     return (1+((lh>rh)?lh:rh));
  24 | }
  25 | 
  26 | 
  27 | /******************************************************************** 
  28 |  * 
  29 |  * avlTreeCheck(tAVLTree *pTree , TREE_NODE *pNode)
  30 |  * 
  31 |  * 检验当前的有序平衡二叉树是否平衡
  32 |  * 是否是有序的，并且各节点的指针没有
  33 |  * 错误
  34 |  * 
  35 |  * Returns         : 
  36 |  * 			  1 : 表示是一棵完备的有序平衡二叉树	
  37 |  *			  0 : 表示是一棵 不健康的二叉树
  38 |  *                             不健康可能是不平衡，可能是平衡因子
  39 |  *                             有错误，也可能是指针不匹配
  40 |  *********************************************************************/ 
  41 | int avlTreeCheck(tAVLTree *pTree , TREE_NODE *pNode)
  42 | {
  43 |     int lh=0,rh=0;
  44 |     TREE_NODE *tree_root = AVL_NULL;
  45 | 
  46 |     if(!pTree || !pNode)
  47 |         return 0;
  48 | 
  49 |     lh = avlTreeHigh(pNode->left_child);
  50 |     rh = avlTreeHigh(pNode->right_child);
  51 |     if(pNode->bf != lh-rh)   /*平衡因子是正确的*/
  52 |         return 0;
  53 | 
  54 |     /*存在左子树，但是左子树要大于自己*/
  55 |     if(pNode->left_child && ((*pTree->keyCompare)(pNode , pNode->left_child))>=0)
  56 |         return 0;
  57 | 
  58 |     /*存在右子树，但是右子树要大于自己*/
  59 |     if(pNode->right_child && ((*pTree->keyCompare)(pNode , pNode->right_child))<=0)
  60 |         return 0;
  61 | 
  62 |     /*如果本节点的父亲节点为空，但是树根不是自己*/
  63 |     tree_root = pNode->tree_root;
  64 |     if(!tree_root && (pTree->pTreeHeader != pNode))
  65 |         return 0;
  66 | 
  67 |     if(tree_root)
  68 |     {
  69 |         /******************************
  70 |          *父亲节点的左右子树都不是自己或
  71 |          *父亲节点的左右子树都是自己
  72 |          *******************************/
  73 |         if((tree_root->left_child != pNode && tree_root->right_child != pNode) ||
  74 |                 (tree_root->left_child == pNode && tree_root->right_child == pNode))
  75 |             return 0;
  76 |     }
  77 | 
  78 |     /****************************
  79 |      *左子树的父亲节点不是自己或者
  80 |      *右子树的父亲节点不是自己
  81 |      *****************************/
  82 |     if((pNode->left_child && pNode->left_child->tree_root != pNode) ||
  83 |             (pNode->right_child && pNode->right_child->tree_root != pNode))
  84 |         return 0;
  85 | 
  86 |     if(pNode->left_child && !avlTreeCheck(pTree, pNode->left_child))
  87 |         return 0;
  88 | 
  89 |     if(pNode->right_child && !avlTreeCheck(pTree, pNode->right_child))
  90 |         return 0;
  91 | 
  92 |     return 1;
  93 | }
  94 | 
  95 | 
  96 | /******************************************************************** 
  97 |  * 
  98 |  * R_Rotate(TREE_NODE **ppNode)
  99 |  * 
 100 |  * 二叉树以*ppNode为根节点，进行右旋转操作
 101 |  * 
 102 |  * Returns         :  无
 103 |  *
 104 |  *           字母后面的数字表示是平衡因子
 105 |  *
 106 |  *             E2                C0  
 107 |  *            / \               / \                    
 108 |  *           C1  F0            B1  E0                  
 109 |  *          / \       ==>     /   / \                        
 110 |  *         B1  D0            A0  D0  F0                      
 111 |  *        /                                                
 112 |  *       A0                                                 
 113 |  *                                              
 114 | 
 115 |  *                                              
 116 |  **********************************************************************/
 117 | static void R_Rotate(TREE_NODE **ppNode)
 118 | {
 119 |     TREE_NODE *l_child = AVL_NULL;
 120 |     TREE_NODE *pNode = (TREE_NODE *)(*ppNode);
 121 | 
 122 |     l_child = pNode->left_child;
 123 |     pNode->left_child = l_child->right_child;
 124 |     if(l_child->right_child)
 125 |         l_child->right_child->tree_root = pNode;
 126 |     l_child->right_child = pNode;
 127 |     l_child->tree_root = pNode->tree_root;
 128 |     pNode->tree_root = l_child;
 129 |     (*ppNode) = l_child;
 130 | }
 131 | 
 132 | 
 133 | /******************************************************************** 
 134 |  * 
 135 |  * L_Rotate(TREE_NODE **ppNode)
 136 |  * 
 137 |  * 二叉树以*ppNode为根节点，进行左旋转操作
 138 |  * 
 139 |  * Returns         :  无
 140 |  *                   
 141 |  *          字母后面的数字表示是平衡因子
 142 |  *                             
 143 |  *           B-2                  D0                
 144 |  *          / \       ==>        / \                      
 145 |  *         A0  D-1              B0  E0                     
 146 |  *            / \              / \   \                   
 147 |  *           C0  E-1          A0  C0  F0                  
 148 |  *                \
 149 |  *                 F0       
 150 |  *******************************************************************/ 
 151 | static void L_Rotate(TREE_NODE **ppNode)
 152 | {
 153 |     TREE_NODE *r_child = AVL_NULL;
 154 |     TREE_NODE *pNode = (TREE_NODE *)(*ppNode);
 155 | 
 156 |     r_child = pNode->right_child;
 157 |     pNode->right_child = r_child->left_child;
 158 |     if(r_child->left_child)
 159 |         r_child->left_child->tree_root = pNode;
 160 |     r_child->left_child = pNode;
 161 |     r_child->tree_root = pNode->tree_root;
 162 |     pNode->tree_root = r_child;
 163 |     (*ppNode) = r_child;
 164 | }
 165 | 
 166 | 
 167 | /******************************************************************** 
 168 |  * 
 169 |  * LeftBalance(TREE_NODE **ppNode)
 170 |  * 
 171 |  * 二叉树*ppNode左边偏高，失去平衡，进行左平衡操作
 172 |  * 
 173 |  * Returns         :  无
 174 |  ********************************************************************/ 
 175 | static void LeftBalance(TREE_NODE **ppNode)
 176 | {
 177 |     TREE_NODE *left_child = AVL_NULL;
 178 |     TREE_NODE *right_child = AVL_NULL;
 179 |     TREE_NODE *tree_root = AVL_NULL;
 180 |     TREE_NODE *pNode = (TREE_NODE *)(*ppNode);
 181 | 
 182 |     tree_root = pNode->tree_root;               /*保存当前节点的父节点*/
 183 |     left_child = pNode->left_child;             /*保存当前节点的左子树*/
 184 |     switch(left_child->bf)
 185 |     {
 186 |         case LH_FACTOR:                             /*如果左子树的平衡因子为1，证明原始状态为左子树比右子树高*/
 187 |             pNode->bf = left_child->bf = EH_FACTOR; /*当前节点的平衡因子和左子树的平衡因子设为0*/
 188 |             R_Rotate(ppNode);  /*当前子树右旋*/
 189 |             break;
 190 |         case RH_FACTOR:                             /*如果左子树的平衡因子为-1，证明原始状态为右子树比左子树高*/
 191 |             /*那么平衡因子的计算就需要根据右子树的平衡因子来计算*/
 192 |             right_child = left_child->right_child;
 193 |             switch(right_child->bf)
 194 |             {
 195 |                 case LH_FACTOR:
 196 |                     pNode->bf = RH_FACTOR;
 197 |                     left_child->bf = EH_FACTOR;
 198 |                     break;
 199 |                 case EH_FACTOR:
 200 |                     pNode->bf = left_child->bf = EH_FACTOR;
 201 |                     break;
 202 |                 case RH_FACTOR:
 203 |                     pNode->bf = EH_FACTOR;
 204 |                     left_child->bf = LH_FACTOR;
 205 |                     break;
 206 |             }
 207 |             right_child->bf = EH_FACTOR;
 208 |             L_Rotate(&pNode->left_child);          /*将本节点的左子树进行左旋*/
 209 |             R_Rotate(ppNode);                      /*将本节点进行右旋*/
 210 |             break;
 211 |         case EH_FACTOR:                            /*左子树的平衡因子为0，表明原始状态下该子树是平衡的*/
 212 |             pNode->bf = LH_FACTOR;
 213 |             left_child->bf = RH_FACTOR;
 214 |             R_Rotate(ppNode);                     /*将本节点进行右旋*/
 215 |             break;
 216 |     }
 217 |     (*ppNode)->tree_root = tree_root;
 218 |     if(tree_root && tree_root->left_child == pNode)
 219 |         tree_root->left_child = *ppNode;
 220 |     if(tree_root && tree_root->right_child == pNode)
 221 |         tree_root->right_child = *ppNode;
 222 | }
 223 | 
 224 | 
 225 | /******************************************************************** 
 226 |  * 
 227 |  * RightBalance(TREE_NODE **ppNode)
 228 |  * 
 229 |  * 二叉树*ppNode右边偏高，失去平衡，进行右平衡操作
 230 |  * 
 231 |  * Returns         :  无
 232 |  ********************************************************************/ 
 233 | static void RightBalance(TREE_NODE **ppNode)
 234 | {
 235 |     TREE_NODE *left_child = AVL_NULL;
 236 |     TREE_NODE *right_child = AVL_NULL;
 237 |     TREE_NODE *tree_root = AVL_NULL;
 238 |     TREE_NODE *pNode = (TREE_NODE *)(*ppNode);
 239 | 
 240 |     tree_root = pNode->tree_root;
 241 |     right_child = pNode->right_child;
 242 |     switch(right_child->bf)
 243 |     {
 244 |         case RH_FACTOR:
 245 |             pNode->bf = right_child->bf = EH_FACTOR;
 246 |             L_Rotate(ppNode);
 247 |             break;
 248 |         case LH_FACTOR:
 249 |             left_child = right_child->left_child;
 250 |             switch(left_child->bf)
 251 |             {
 252 |                 case RH_FACTOR:
 253 |                     pNode->bf = LH_FACTOR;
 254 |                     right_child->bf = EH_FACTOR;
 255 |                     break;
 256 |                 case EH_FACTOR:
 257 |                     pNode->bf = right_child->bf = EH_FACTOR;
 258 |                     break;
 259 |                 case LH_FACTOR:
 260 |                     pNode->bf = EH_FACTOR;
 261 |                     right_child->bf = RH_FACTOR;
 262 |                     break;
 263 |             }
 264 |             left_child->bf = EH_FACTOR;
 265 |             R_Rotate(&pNode->right_child);
 266 |             L_Rotate(ppNode);
 267 |             break;
 268 |         case EH_FACTOR:
 269 |             pNode->bf = RH_FACTOR;
 270 |             right_child->bf = LH_FACTOR;
 271 |             L_Rotate(ppNode);
 272 |             break;
 273 |     }
 274 |     (*ppNode)->tree_root = tree_root;
 275 |     if(tree_root && tree_root->left_child == pNode)
 276 |         tree_root->left_child = *ppNode;
 277 |     if(tree_root && tree_root->right_child == pNode)
 278 |         tree_root->right_child = *ppNode;
 279 | }
 280 | 
 281 | 
 282 | /******************************************************************** 
 283 |  * 
 284 |  * avlDelBalance(tAVLTree *pTree , TREE_NODE *pNode,int L_R_MINUS)
 285 |  * 
 286 |  * 删除节点之后，二叉树可能已经不平衡了，此时需要用
 287 |  * 此函数来实现删除节点之后的平衡操作。
 288 |  * 子树自平衡的过程中，可能出现一种情况：那就是子树自身平衡了，但是
 289 |  * 破坏了父亲的平衡性，所以此函数做了递归平衡操作，能够使最小不平衡
 290 |  * 子树之上的所有祖先节点都能够平衡。
 291 |  * 最坏可能的情况就是从最小不平衡字数的树根一直到整个大树的树根节点
 292 |  * 之间的所有子树都不平衡，不过这种概率很低，一般来说递归最多三次就
 293 |  * 可以实现整个树的平衡
 294 |  * pTree 		:  二叉树指针
 295 |  * pNode		:  最小不平衡子树的根节点
 296 |  * L_R_MINUS	:  
 297 |  *			LEFT_MINUS    -- 左边失去平衡，树高减少了1层
 298 |  *                      RIGHT_MINUS  -- 右边失去平衡，树高减少了1层
 299 |  *
 300 |  * Returns         :  无
 301 |  ******************************************************************/ 
 302 |     static int avlDelBalance
 303 | (
 304 |  tAVLTree *pTree , 
 305 |  TREE_NODE *pNode,
 306 |  int L_R_MINUS
 307 |  )
 308 | {
 309 |     TREE_NODE *tree_root = AVL_NULL;
 310 | 
 311 |     tree_root = pNode->tree_root;
 312 |     if(L_R_MINUS == LEFT_MINUS)
 313 |     {
 314 |         switch(pNode->bf)
 315 |         {
 316 |             case EH_FACTOR:
 317 |                 pNode->bf = RH_FACTOR;
 318 |                 break;
 319 |             case RH_FACTOR:
 320 |                 RightBalance(&pNode);
 321 |                 if(!tree_root)
 322 |                     pTree->pTreeHeader = pNode;
 323 |                 if(pNode->tree_root && pNode->bf == EH_FACTOR)
 324 |                 {
 325 |                     if(pNode->tree_root->left_child == pNode)
 326 |                         avlDelBalance(pTree , pNode->tree_root , LEFT_MINUS);
 327 |                     else
 328 |                         avlDelBalance(pTree , pNode->tree_root , RIGHT_MINUS);
 329 |                 }
 330 |                 break;
 331 |             case LH_FACTOR:
 332 |                 pNode->bf = EH_FACTOR;
 333 |                 if(pNode->tree_root && pNode->bf == EH_FACTOR)
 334 |                 {
 335 |                     if(pNode->tree_root->left_child == pNode)
 336 |                         avlDelBalance(pTree , pNode->tree_root , LEFT_MINUS);
 337 |                     else
 338 |                         avlDelBalance(pTree , pNode->tree_root , RIGHT_MINUS);
 339 |                 }
 340 |                 break;
 341 |         }
 342 |     }
 343 | 
 344 |     if(L_R_MINUS == RIGHT_MINUS)
 345 |     {
 346 |         switch(pNode->bf)
 347 |         {
 348 |             case EH_FACTOR:
 349 |                 pNode->bf = LH_FACTOR;
 350 |                 break;
 351 |             case LH_FACTOR:
 352 |                 LeftBalance(&pNode);
 353 |                 if(!tree_root)
 354 |                     pTree->pTreeHeader = pNode;
 355 |                 if(pNode->tree_root && pNode->bf == EH_FACTOR)
 356 |                 {
 357 |                     if(pNode->tree_root->left_child == pNode)
 358 |                         avlDelBalance(pTree , pNode->tree_root , LEFT_MINUS);
 359 |                     else
 360 |                         avlDelBalance(pTree , pNode->tree_root , RIGHT_MINUS);
 361 |                 }
 362 |                 break;
 363 |             case RH_FACTOR:
 364 |                 pNode->bf = EH_FACTOR;
 365 |                 if(pNode->tree_root && pNode->bf == EH_FACTOR)
 366 |                 {
 367 |                     if(pNode->tree_root->left_child == pNode)
 368 |                         avlDelBalance(pTree , pNode->tree_root , LEFT_MINUS);
 369 |                     else
 370 |                         avlDelBalance(pTree , pNode->tree_root , RIGHT_MINUS);
 371 |                 }
 372 |                 break;
 373 |         }
 374 |     }
 375 | 
 376 |     return 1;
 377 | }
 378 | 
 379 | 
 380 | /******************************************************************** 
 381 |  * 
 382 |  * AVL_TREE_LOCK(tAVLTree *pTree , int timeout)
 383 |  * 
 384 |  * 锁定二叉树，防止多个任务同时对树进行添加或删除操作
 385 |  * 此函数是针对vxworks系统的扩展，如果不是vxworks系统，那么树的互斥操作
 386 |  * 需要自定义
 387 |  * timeout		: 等待时间，vxworks操作系统里面timeout=1就是1/60秒
 388 |  *
 389 |  * Returns         :  无
 390 |  *********************************************************************/ 
 391 |     void AVL_TREE_LOCK
 392 | (
 393 |  tAVLTree *pTree,
 394 |  int timeout
 395 |  )
 396 | {
 397 |     if(!pTree
 398 | #if OS==3 || OS==4		
 399 |             || !pTree->sem
 400 | #endif		
 401 |       )
 402 |         return;
 403 | 
 404 | #if OS==3 || OS==4
 405 |     semTake(pTree->sem,timeout);
 406 | #endif
 407 |     return;
 408 | }
 409 | 
 410 | /********************************************************************* 
 411 |  * 
 412 |  * AVL_TREE_UNLOCK(tAVLTree *pTree , int timeout)
 413 |  * 
 414 |  * 解除锁定
 415 |  * 此函数是针对vxworks系统的扩展，如果不是vxworks系统，那么树的互斥操作
 416 |  * 需要自定义
 417 |  * Returns         :  无
 418 |  *********************************************************************/ 
 419 |     void AVL_TREE_UNLOCK
 420 | (
 421 |  tAVLTree *pTree
 422 |  )
 423 | {
 424 |     if(!pTree
 425 | #if OS==3 || OS==4		
 426 |             || !pTree->sem
 427 | #endif		
 428 |       )
 429 |         return;
 430 | 
 431 | #if OS==3 || OS==4
 432 |     semGive(pTree->sem);
 433 | #endif
 434 |     return;
 435 | }
 436 | 
 437 | /******************************************************************** 
 438 |  * 
 439 |  * AVL_TREENODE_FREE(tAVLTree *pTree , TREE_NODE *pNode)
 440 |  * 
 441 |  * 释放一个节点所占用的内存，释放函数需要用户自定义
 442 |  * ，并且需要在创建二叉树的时候传递给二叉树
 443 |  * 
 444 |  * Returns         :  无
 445 |  *********************************************************************/ 
 446 |     void AVL_TREENODE_FREE
 447 | (
 448 |  tAVLTree *pTree,
 449 |  TREE_NODE *pNode
 450 |  )
 451 | {
 452 |     if(!pTree || !pNode)
 453 |         return;
 454 | 
 455 |     (*pTree->free)(pNode);
 456 |     return ;
 457 | }
 458 | 
 459 | #ifdef ORDER_LIST_WANTED
 460 | /******************************************************************************** 
 461 |  * 
 462 |  * orderListInsert
 463 |  *	(
 464 |  *	tAVLTree *pTree,	      //树结构的指针	
 465 |  *	TREE_NODE *pNode ,    //pInsertNode即将插在此节点前面或后面
 466 |  *	TREE_NODE *pInsertNode, //即将插入的节点指针
 467 |  *	int prev_or_next      // INSERT_PREV : 待插入节点插在pNode之前
 468 |  *                                           INSERT_NEXT : 待插入节点插在pNode之后           
 469 |  *	)
 470 |  * 
 471 |  *   当平衡二叉树里增加一个节点之后，用此函数来更新
 472 |  *  有序双向链表
 473 |  * 
 474 |  * Returns         :  1:成功  0:失败
 475 |  *********************************************************************************/ 
 476 |     static int orderListInsert
 477 | (
 478 |  tAVLTree *pTree,
 479 |  TREE_NODE *pNode , 
 480 |  TREE_NODE *pInsertNode,
 481 |  int prev_or_next
 482 |  )
 483 | {
 484 |     TREE_NODE *p = AVL_NULL;
 485 | 
 486 |     if(!pNode)
 487 |         return 0;
 488 | 
 489 |     if(prev_or_next == INSERT_PREV)
 490 |     {
 491 |         p = pNode->prev;
 492 |         if(p)	p->next = pInsertNode;
 493 |         else	pTree->pListHeader = pInsertNode;
 494 | 
 495 |         pInsertNode->prev = p;
 496 |         pInsertNode->next = pNode;
 497 |         pNode->prev = pInsertNode;
 498 |     }
 499 | 
 500 |     if(prev_or_next == INSERT_NEXT)
 501 |     {
 502 |         p = pNode->next;
 503 |         if(p)	p->prev = pInsertNode;
 504 |         else	pTree->pListTail = pInsertNode;
 505 | 
 506 |         pInsertNode->prev = pNode;
 507 |         pInsertNode->next = p;
 508 |         pNode->next = pInsertNode;
 509 |     }
 510 |     return 1;
 511 | }
 512 | 
 513 | /******************************************************************** 
 514 |  * int orderListRemove
 515 |  *	(
 516 |  *	tAVLTree *pTree,    //树结构的指针
 517 |  *	TREE_NODE *pRemoveNode   //即将从有序双向链表中删除的节点
 518 |  *	)
 519 |  * 
 520 |  *   当平衡二叉树里删除一个节点之后，用此函数来更新
 521 |  *  有序双向链表
 522 |  * 
 523 |  * Returns         :  1:成功   0:失败
 524 |  ********************************************************************/ 
 525 |     static int orderListRemove
 526 | (
 527 |  tAVLTree *pTree,
 528 |  TREE_NODE *pRemoveNode
 529 |  )
 530 | {
 531 |     TREE_NODE *pPrev = AVL_NULL;
 532 |     TREE_NODE *pNext = AVL_NULL;
 533 | 
 534 |     if(!pRemoveNode)
 535 |         return 0;
 536 | 
 537 |     pPrev = pRemoveNode->prev;
 538 |     pNext = pRemoveNode->next;
 539 |     if(!pPrev && !pNext)
 540 |     {
 541 |         pTree->pListHeader = pTree->pListTail = AVL_NULL;
 542 |         return 1;
 543 |     }
 544 |     if(pPrev && pNext)
 545 |     {
 546 |         pPrev->next = pNext;
 547 |         pNext->prev = pPrev;
 548 |         return 1;
 549 |     }
 550 | 
 551 |     if(pPrev)
 552 |     {
 553 |         pPrev->next = AVL_NULL;
 554 |         pTree->pListTail = pPrev;
 555 |         return 1;
 556 |     }
 557 | 
 558 |     if(pNext)
 559 |     {
 560 |         pNext->prev = AVL_NULL;
 561 |         pTree->pListHeader = pNext;
 562 |         return 1;
 563 |     }
 564 |     else 
 565 |     {
 566 |         return 0;
 567 |     }
 568 | }
 569 | 
 570 | 
 571 | /******************************************************************** 
 572 |  *      avlTreeFirst(tAVLTree *pTree)
 573 |  * 
 574 |  *   获取有序双向链表里面的第一个成员节点
 575 |  * 
 576 |  * Returns         :  成功:  第一个成员节点的指针
 577 |  *                         失败:  AVL_NULL
 578 |  *********************************************************************/ 
 579 |     TREE_NODE *avlTreeFirst
 580 | (
 581 |  tAVLTree *pTree
 582 |  )
 583 | {
 584 |     if(!pTree)
 585 |         return AVL_NULL;
 586 | 
 587 |     if(!pTree->count || !pTree->pTreeHeader)
 588 |         return AVL_NULL;
 589 | 
 590 |     return (TREE_NODE *)pTree->pListHeader;
 591 | }
 592 | 
 593 | 
 594 | /******************************************************************** 
 595 |  *      avlTreeLast(tAVLTree *pTree)
 596 |  * 
 597 |  *   获取有序双向链表里面的最后一个成员节点
 598 |  * 
 599 |  * Returns         :  成功:  最后一个成员节点的指针
 600 |  *                         失败:  AVL_NULL
 601 |  *********************************************************************/ 
 602 |     TREE_NODE *avlTreeLast
 603 | (
 604 |  tAVLTree *pTree
 605 |  )
 606 | {
 607 |     if(!pTree)
 608 |         return AVL_NULL;
 609 | 
 610 |     if(!pTree->count || !pTree->pTreeHeader)
 611 |         return AVL_NULL;
 612 | 
 613 |     return (TREE_NODE *)pTree->pListTail;
 614 | }
 615 | 
 616 | /******************************************************************** 
 617 |  *      avlTreeNext(TREE_NODE *pNode)
 618 |  * 
 619 |  *   获取有序双向链表里面当前成员节点的后一个节点
 620 |  * 
 621 |  * Returns         :  成功: 后一个成员节点的指针
 622 |  *                         失败:  AVL_NULL
 623 |  *********************************************************************/ 
 624 |     TREE_NODE *avlTreeNext
 625 | (
 626 |  TREE_NODE *pNode
 627 |  )
 628 | {
 629 |     if(!pNode)
 630 |         return AVL_NULL;
 631 | 
 632 |     return (TREE_NODE *)pNode->next;
 633 | }
 634 | 
 635 | /******************************************************************** 
 636 |  *      avlTreePrev(TREE_NODE *pNode)
 637 |  * 
 638 |  *   获取有序双向链表里面当前成员节点的前一个节点
 639 |  * 
 640 |  * Returns         :  成功: 前一个成员节点的指针
 641 |  *                         失败:  AVL_NULL
 642 |  *********************************************************************/ 
 643 |     TREE_NODE *avlTreePrev
 644 | (
 645 |  TREE_NODE *pNode
 646 |  )
 647 | {
 648 |     if(!pNode)
 649 |         return AVL_NULL;
 650 | 
 651 |     return (TREE_NODE *)pNode->prev;
 652 | }
 653 | #endif
 654 | 
 655 | /*****************************************************************************************
 656 |  *      int avlTreeInsert
 657 |  *	(
 658 |  *	tAVLTree *pTree ,      //树结构的指针
 659 |  *	TREE_NODE **ppNode ,  //待插入节点所在的子树的指针的指针
 660 |  *	TREE_NODE *pInsertNode,  //待插入的节点
 661 |  *	int *growthFlag  //子树是否长高的标志 *growthFlag=1表示长高1层 *growthFlag=0表示没有
 662 |  *	)
 663 |  * 
 664 |  *   将一个节点插入一颗子树之中，插入过程之中可能导致子树不
 665 |  *  平衡，此函数还将执行递归平衡操作，直到所有子树均平衡为止
 666 |  * 
 667 |  * Returns         :  1:成功
 668 |  *                         0:失败
 669 |  ******************************************************************************************/ 
 670 |     static int avlTreeInsert
 671 | (
 672 |  tAVLTree *pTree , 
 673 |  TREE_NODE **ppNode , 
 674 |  TREE_NODE *pInsertNode,
 675 |  int *growthFlag
 676 |  )
 677 | {
 678 |     int compFlag = 0;
 679 |     TREE_NODE *pNode = (TREE_NODE *)(*ppNode);
 680 | 
 681 |     if(pTree->count == 0)
 682 |     {
 683 |         pTree->pTreeHeader = pInsertNode;
 684 |         pInsertNode->bf = EH_FACTOR;
 685 |         pInsertNode->left_child = pInsertNode->right_child = AVL_NULL;
 686 |         pInsertNode->tree_root = AVL_NULL;
 687 | #ifdef ORDER_LIST_WANTED
 688 |         pTree->pListHeader = pTree->pListTail = pInsertNode;
 689 |         pInsertNode->prev = pInsertNode->next = AVL_NULL;
 690 | #endif
 691 |         return 1;
 692 |     }
 693 | 
 694 |     compFlag = ((*pTree->keyCompare)(pNode , pInsertNode));
 695 |     if(!compFlag)
 696 |     {
 697 |         *growthFlag = 0;
 698 |         return 0;
 699 |     }
 700 | 
 701 |     if(compFlag < 0)
 702 |     {
 703 |         if(!pNode->left_child)
 704 |         {
 705 |             pNode->left_child = pInsertNode;
 706 |             pInsertNode->bf = EH_FACTOR;
 707 |             pInsertNode->left_child = pInsertNode->right_child = AVL_NULL;
 708 |             pInsertNode->tree_root = (TREE_NODE *)pNode;
 709 | #ifdef ORDER_LIST_WANTED
 710 |             orderListInsert(pTree,pNode, pInsertNode, INSERT_PREV);
 711 | #endif
 712 |             switch(pNode->bf)
 713 |             {
 714 |                 case EH_FACTOR:
 715 |                     pNode->bf = LH_FACTOR;
 716 |                     *growthFlag = 1;
 717 |                     break;
 718 |                 case RH_FACTOR:
 719 |                     pNode->bf = EH_FACTOR;
 720 |                     *growthFlag = 0;
 721 |                     break;
 722 |             }
 723 |         }
 724 |         else
 725 |         {
 726 |             if(!avlTreeInsert(pTree, &pNode->left_child,pInsertNode, growthFlag))
 727 |                 return 0;
 728 | 
 729 |             if(*growthFlag)
 730 |             {
 731 |                 switch(pNode->bf)
 732 |                 {
 733 |                     case LH_FACTOR:
 734 |                         LeftBalance(ppNode);
 735 |                         *growthFlag = 0;
 736 |                         break;
 737 |                     case EH_FACTOR:
 738 |                         pNode->bf = LH_FACTOR;
 739 |                         *growthFlag = 1;
 740 |                         break;
 741 |                     case RH_FACTOR:
 742 |                         pNode->bf = EH_FACTOR;
 743 |                         *growthFlag = 0;
 744 |                         break;
 745 |                 }
 746 |             }
 747 |         }
 748 |     }
 749 | 
 750 |     if(compFlag > 0)
 751 |     {
 752 |         if(!pNode->right_child)
 753 |         {
 754 |             pNode->right_child = pInsertNode;
 755 |             pInsertNode->bf = EH_FACTOR;
 756 |             pInsertNode->left_child = pInsertNode->right_child = AVL_NULL;
 757 |             pInsertNode->tree_root = (TREE_NODE *)pNode;
 758 | #ifdef ORDER_LIST_WANTED
 759 |             orderListInsert(pTree,pNode, pInsertNode, INSERT_NEXT);
 760 | #endif
 761 |             switch(pNode->bf)
 762 |             {
 763 |                 case EH_FACTOR:
 764 |                     pNode->bf = RH_FACTOR;
 765 |                     *growthFlag = 1;
 766 |                     break;
 767 |                 case LH_FACTOR:
 768 |                     pNode->bf = EH_FACTOR;
 769 |                     *growthFlag = 0;
 770 |                     break;
 771 |             }
 772 |         }
 773 |         else
 774 |         {
 775 |             if(!avlTreeInsert(pTree, &pNode->right_child,pInsertNode, growthFlag))
 776 |                 return 0;
 777 | 
 778 |             if(*growthFlag)
 779 |             {
 780 |                 switch(pNode->bf)
 781 |                 {
 782 |                     case LH_FACTOR:
 783 |                         pNode->bf = EH_FACTOR;
 784 |                         *growthFlag = 0;
 785 |                         break;
 786 |                     case EH_FACTOR:
 787 |                         pNode->bf = RH_FACTOR;
 788 |                         *growthFlag = 1;
 789 |                         break;
 790 |                     case RH_FACTOR:
 791 |                         RightBalance(ppNode);
 792 |                         *growthFlag = 0;
 793 |                         break;
 794 |                 }
 795 |             }
 796 |         }
 797 |     }
 798 | 
 799 |     return 1;
 800 | }
 801 | 
 802 | 
 803 | /******************************************************************** 
 804 |  *      int avlTreeRemove
 805 |  *	(
 806 |  *	tAVLTree *pTree ,      //树结构的指针
 807 |  *	TREE_NODE *pRemoveNode  //待删除节点的指针
 808 |  *	)
 809 |  * 
 810 |  *   从树里面删除一个节点，此函数能够做递归操作，能够
 811 |  *  循环自平衡，使所有受删除节点影响而导致不平衡的子树
 812 |  *  都能自平衡
 813 |  * 
 814 |  * Returns         :  1:成功
 815 |  *                    0:失败
 816 |  *                                                    
 817 |  *          C               C                                                           
 818 |  *         / \             / \                     C                                     
 819 |  *        B   E    ==>    B  .F.      ==>         / \                                     
 820 |  *       /   / \         /   / \                 B  .F.                                   
 821 |  *      A   D   G       A   D   G               /   / \                                   
 822 |  *             / \             / \             A   D   G                                 
 823 |  *            F   H          .E.  H                     \                                  
 824 |  *                                                       H                  
 825 |  *      删除E节点  ==> 找到比E大一点的F ==>  删除E节点，自平衡                                                           
 826 |  *                     F和E互换指针                                                
 827 |  ********************************************************************/ 
 828 |     static int avlTreeRemove
 829 | (
 830 |  tAVLTree *pTree , 
 831 |  TREE_NODE *pRemoveNode
 832 |  )
 833 | {
 834 |     int compFlag = 0;
 835 |     TREE_NODE *tree_root = AVL_NULL;
 836 |     TREE_NODE *p = AVL_NULL;
 837 |     TREE_NODE *root_p = AVL_NULL;
 838 |     TREE_NODE swapNode;
 839 | 
 840 |     tree_root = pRemoveNode->tree_root;
 841 |     if(!pRemoveNode->left_child && !pRemoveNode->right_child)
 842 |     {
 843 |         if(!tree_root)
 844 |         {
 845 |             pTree->pTreeHeader = AVL_NULL;
 846 | #ifdef ORDER_LIST_WANTED
 847 |             pTree->pListHeader = pTree->pListTail = AVL_NULL;
 848 | #endif
 849 |             return 1;
 850 |         }
 851 |         else if(tree_root->left_child == pRemoveNode)
 852 |         {
 853 | #ifdef ORDER_LIST_WANTED
 854 |             orderListRemove(pTree, pRemoveNode);
 855 | #endif
 856 |             tree_root->left_child = AVL_NULL;
 857 |             avlDelBalance(pTree, tree_root , LEFT_MINUS);
 858 |         }
 859 |         else
 860 |         {
 861 | #ifdef ORDER_LIST_WANTED
 862 |             orderListRemove(pTree, pRemoveNode);
 863 | #endif
 864 |             tree_root->right_child = AVL_NULL;
 865 |             avlDelBalance(pTree, tree_root , RIGHT_MINUS);
 866 |         }
 867 |     }
 868 | 
 869 |     if(pRemoveNode->left_child && pRemoveNode->right_child)
 870 |     {
 871 |         TREE_NODE *prev = AVL_NULL;
 872 |         TREE_NODE *next = AVL_NULL;
 873 |         TREE_NODE *r_child = AVL_NULL;
 874 |         root_p = pRemoveNode;
 875 |         p = pRemoveNode->right_child;
 876 |         while(p->left_child)
 877 |         {
 878 |             root_p = p;
 879 |             p = p->left_child;
 880 |         }
 881 |         if(p == pRemoveNode->right_child)
 882 |         {
 883 |             p->tree_root = p;
 884 |             pRemoveNode->right_child = pRemoveNode;
 885 |         }
 886 |         swapNode = *p;
 887 |         prev = p->prev;
 888 |         next = p->next;
 889 |         *p = *pRemoveNode;
 890 |         p->prev = prev;
 891 |         p->next = next;
 892 |         prev = pRemoveNode->prev;
 893 |         next = pRemoveNode->next;
 894 |         *pRemoveNode = swapNode;
 895 |         pRemoveNode->prev = prev;
 896 |         pRemoveNode->next = next;
 897 |         if(!tree_root) 
 898 |             pTree->pTreeHeader = p;
 899 |         else if(tree_root->left_child == pRemoveNode)
 900 |             tree_root->left_child = p;
 901 |         else
 902 |             tree_root->right_child = p;
 903 | 
 904 |         if(p->left_child) 
 905 |             p->left_child->tree_root = p;
 906 |         if(p->right_child)  
 907 |             p->right_child->tree_root = p;
 908 | 
 909 |         if(pRemoveNode->left_child) 
 910 |             pRemoveNode->left_child->tree_root = pRemoveNode;
 911 |         if(pRemoveNode->right_child)  
 912 |             pRemoveNode->right_child->tree_root = pRemoveNode;
 913 | 
 914 |         if(root_p != pRemoveNode)
 915 |         {
 916 |             if(root_p->left_child == p)
 917 |                 root_p->left_child = pRemoveNode;
 918 |             else 
 919 |                 root_p->right_child = pRemoveNode;
 920 |         }
 921 | 
 922 |         return avlTreeRemove(pTree, pRemoveNode);
 923 |     }
 924 | 
 925 |     if(pRemoveNode->left_child)
 926 |     {
 927 | #ifdef ORDER_LIST_WANTED
 928 |         orderListRemove(pTree, pRemoveNode);
 929 | #endif
 930 |         if(!tree_root)
 931 |         {
 932 |             pTree->pTreeHeader = pRemoveNode->left_child;
 933 |             pRemoveNode->left_child->tree_root = AVL_NULL;
 934 |             return 1;
 935 |         }
 936 | 
 937 |         if(tree_root->left_child == pRemoveNode)
 938 |         {
 939 |             tree_root->left_child = pRemoveNode->left_child;
 940 |             pRemoveNode->left_child->tree_root= tree_root;
 941 |             avlDelBalance(pTree , tree_root , LEFT_MINUS);
 942 |         }
 943 |         else
 944 |         {
 945 |             tree_root->right_child = pRemoveNode->left_child;
 946 |             pRemoveNode->left_child->tree_root = tree_root;
 947 |             avlDelBalance(pTree , tree_root , RIGHT_MINUS);
 948 |         }
 949 | 
 950 |         return 1;
 951 |     }
 952 | 
 953 |     if(pRemoveNode->right_child)
 954 |     {
 955 | #ifdef ORDER_LIST_WANTED
 956 |         orderListRemove(pTree, pRemoveNode);
 957 | #endif
 958 |         if(!tree_root)
 959 |         {
 960 |             pTree->pTreeHeader = pRemoveNode->right_child;
 961 |             pRemoveNode->right_child->tree_root = AVL_NULL;
 962 |             return 1;
 963 |         }
 964 | 
 965 |         if(tree_root->left_child == pRemoveNode)
 966 |         {
 967 |             tree_root->left_child = pRemoveNode->right_child;
 968 |             pRemoveNode->right_child->tree_root = tree_root;
 969 |             avlDelBalance(pTree , tree_root , LEFT_MINUS);
 970 |         }
 971 |         else
 972 |         {
 973 |             tree_root->right_child = pRemoveNode->right_child;
 974 |             pRemoveNode->right_child->tree_root = tree_root;
 975 |             avlDelBalance(pTree , tree_root , RIGHT_MINUS);
 976 |         }
 977 | 
 978 |         return 1;
 979 |     }
 980 | 
 981 |     return 1;
 982 | }
 983 | 
 984 | /******************************************************************** 
 985 |  *      int avlTreeLookup
 986 |  *	(
 987 |  *	tAVLTree *pTree,
 988 |  *	TREE_NODE *pNode , 
 989 |  *	TREE_NODE *pSearchKey
 990 |  *	)
 991 |  * 
 992 |  *    递归查找关键字比较完全匹配的节点，比较函数是在
 993 |  *     树创建的时候就指定好的
 994 |  *
 995 |  * Returns         :  1:成功
 996 |  *                         0:失败
 997 |  *********************************************************************/ 
 998 |     static TREE_NODE *avlTreeLookup
 999 | (
1000 |  tAVLTree *pTree,
1001 |  TREE_NODE *pNode , 
1002 |  TREE_NODE *pSearchKey
1003 |  )
1004 | {
1005 |     int compFlag = 0;
1006 |     if(!pTree || !pNode)
1007 |         return AVL_NULL;
1008 | 
1009 |     compFlag = (*pTree->keyCompare)(pNode , pSearchKey);
1010 |     if(!compFlag)
1011 |         return (TREE_NODE *)pNode;
1012 | 
1013 |     if(compFlag>0) pNode = pNode->right_child;
1014 |     else pNode = pNode->left_child;
1015 | 
1016 |     return (TREE_NODE *)avlTreeLookup(pTree, pNode, pSearchKey);
1017 | }
1018 | 
1019 | 
1020 | /*******************************************************************/
1021 | /**************************AVL TREE API*****************************/
1022 | /*******************************************************************/
1023 | /*
1024 |    ★描述            : 创建一颗有序平衡二叉树
1025 |    ★参数描述: 
1026 | keyCompareFunc:比较两个节点的大小(关键字的比较)
1027 | ★返回值      :
1028 | 成功 :   平衡二叉树的指针
1029 | 失败 :   空指针
1030 |  *******************************************************************/
1031 | tAVLTree *avlTreeCreate(int *keyCompareFunc,int *freeFunc)
1032 | {
1033 |     tAVLTree *pTree = (tAVLTree *)0;
1034 | 
1035 |     if(!keyCompareFunc || !freeFunc)
1036 |         return (tAVLTree *)0;
1037 | 
1038 |     pTree = (tAVLTree *)malloc(sizeof(tAVLTree));
1039 | 
1040 |     if(pTree != (tAVLTree *)0)
1041 |     {
1042 |         memset((void *)pTree , 0 , sizeof(tAVLTree));
1043 |         pTree->keyCompare = (void *)keyCompareFunc;
1044 |         pTree->free = (void *)freeFunc;
1045 | #ifdef ORDER_LIST_WANTED
1046 |         pTree->pListHeader = pTree->pListTail = AVL_NULL;
1047 | #endif
1048 | 
1049 | #if OS==3 || OS==4 
1050 |         pTree->sem = semBCreate(0 , 1);
1051 |         if(!pTree->sem)
1052 |         {
1053 |             free((void *)pTree);
1054 |             return (tAVLTree *)0;
1055 |         }
1056 | #endif
1057 |     }
1058 | 
1059 |     return (tAVLTree *)pTree;
1060 | }
1061 | 
1062 | /*******************************************************************/
1063 | /**************************AVL TREE API*****************************/
1064 | /*******************************************************************/
1065 | /*
1066 |    ★描述            :  删除一个节点
1067 | 
1068 |    ★参数描述: 
1069 | pTree:树结构的指针
1070 | pDelNode : 待删除的节点指针
1071 | ★返回值      :
1072 | 成功 :  1
1073 | 失败 :   0
1074 |  *******************************************************************/
1075 | int avlTreeDel( tAVLTree *pTree ,TREE_NODE *pDelNode)
1076 | {
1077 |     int ret = 0;
1078 | 
1079 |     if(!pTree || !pDelNode || !pTree->count)
1080 |         return 0;
1081 | 
1082 |     ret = avlTreeRemove(pTree, pDelNode);
1083 |     if(ret)
1084 |         pTree->count--;
1085 | 
1086 |     return 1;
1087 | }
1088 | 
1089 | 
1090 | /*******************************************************************/
1091 | /**************************AVL TREE API*****************************/
1092 | /*******************************************************************/
1093 | /*
1094 |    ★描述            : 摧毁一颗平衡二叉树，并释放所有成员节点占用的内存
1095 |    释放内存的函数在创建树的时候已经指定好
1096 |    ★参数描述: 
1097 | pTree:树结构的指针
1098 | ★返回值      :
1099 | 成功 :  1
1100 | 失败 :   0
1101 |  ********************************************************************/
1102 |     int avlTreeDestroy
1103 | (
1104 |  tAVLTree *pTree
1105 |  )
1106 | {
1107 |     TREE_NODE *pNode = AVL_NULL;
1108 |     if(!pTree)
1109 |         return 0;
1110 | 
1111 |     while(pNode = pTree->pTreeHeader)
1112 |     {
1113 |         avlTreeDel(pTree,pNode);
1114 |         AVL_TREENODE_FREE(pTree, pNode);
1115 |     }
1116 | 
1117 |     if(!pTree->count || !pTree->pTreeHeader)
1118 |     {
1119 | #if OS==3 || OS==4
1120 |         semDelete(pTree->sem);
1121 | #endif
1122 |         free((void *)pTree);
1123 |         return 1;
1124 |     }
1125 | 
1126 |     return 0;
1127 | }
1128 | 
1129 | 
1130 | /*******************************************************************/
1131 | /**************************AVL TREE API*****************************/
1132 | /*******************************************************************/
1133 | /*
1134 |    ★描述            : 清空一颗树，释放所有成员节点占用的内存，
1135 |    但是不释放树结构所占用的内存
1136 |    ★参数描述: 
1137 | pTree:树结构的指针
1138 | ★返回值      :
1139 | 成功 :  1
1140 | 失败 :   0
1141 |  ********************************************************************/
1142 |     int avlTreeFlush
1143 | (
1144 |  tAVLTree *pTree
1145 |  )
1146 | {
1147 |     TREE_NODE *pNode = AVL_NULL;
1148 | 
1149 |     if(!pTree)
1150 |         return 0;
1151 | 
1152 |     if(!pTree->count || !pTree->pTreeHeader)
1153 |         return 1;
1154 | 
1155 |     while(pNode = pTree->pTreeHeader)
1156 |     {
1157 |         avlTreeDel(pTree,pNode);
1158 |         AVL_TREENODE_FREE(pTree, pNode);
1159 |     }
1160 | 
1161 |     return 0;
1162 | }
1163 | 
1164 | 
1165 | /*******************************************************************/
1166 | /**************************AVL TREE API*****************************/
1167 | /*******************************************************************/
1168 | /*
1169 |    ★描述            :  增加一个节点
1170 | 
1171 |    ★参数描述: 
1172 | pTree:树结构的指针
1173 | pInsertNode : 待添加的节点指针
1174 | ★返回值      :
1175 | 成功 :  1
1176 | 失败 :   0
1177 |  *******************************************************************/
1178 |     int avlTreeAdd
1179 | (
1180 |  tAVLTree *pTree , 
1181 |  TREE_NODE *pInsertNode
1182 |  )
1183 | {
1184 |     int growthFlag=0 , ret = 0;
1185 | 
1186 |     if(!pTree || !pInsertNode)
1187 |         return 0;
1188 | 
1189 |     ret = avlTreeInsert(pTree , &pTree->pTreeHeader , pInsertNode , &growthFlag);
1190 |     if(ret)
1191 |         pTree->count++;
1192 |     return ret;
1193 | }
1194 | 
1195 | 
1196 | 
1197 | /*******************************************************************/
1198 | /**************************AVL TREE API*****************************/
1199 | /*******************************************************************/
1200 | /*
1201 |    ★描述            : 根据关键字结构来查询一个节点是否存在
1202 | 
1203 |    ★参数描述: 
1204 | pTree:树结构的指针
1205 | pKeyNode : 关键字结构指针
1206 | ★返回值      :
1207 | 成功 :  查找到的节点指针
1208 | 失败 :   AVL_NULL
1209 |  ********************************************************************/
1210 |     TREE_NODE *avlTreeFind
1211 | (
1212 |  tAVLTree *pTree,
1213 |  TREE_NODE *pKeyNode
1214 |  )
1215 | {
1216 |     if(!pTree || !pTree->count || !pTree->pTreeHeader)
1217 |         return AVL_NULL;
1218 | 
1219 |     return (TREE_NODE *)avlTreeLookup(pTree, pTree->pTreeHeader , pKeyNode);
1220 | }
1221 | 
1222 | /*******************************************************************/
1223 | /**************************AVL TREE API*****************************/
1224 | /*******************************************************************/
1225 | /*
1226 |    ★描述            : 获取树里面的所有节点总数
1227 | 
1228 |    ★参数描述: 
1229 | pTree:树结构的指针
1230 | ★返回值      :
1231 | 树里面的节点成员总数
1232 |  ********************************************************************/
1233 |     unsigned int avlTreeCount
1234 | (
1235 |  tAVLTree *pTree
1236 |  )
1237 | {
1238 |     if(!pTree)
1239 |         return 0;
1240 | 
1241 |     return pTree->count;
1242 | }
1243 | 
1244 | 
1245 | 


--------------------------------------------------------------------------------
/ssd.c:
--------------------------------------------------------------------------------
   1 | /*****************************************************************************************************************************
   2 |   This project was supported by the National Basic Research 973 Program of China under Grant No.2011CB302301
   3 |   Huazhong University of Science and Technology (HUST)   Wuhan National Laboratory for Optoelectronics
   4 | 
   5 | FileName: ssd.c
   6 | Author: Hu Yang		Version: 2.1	Date:2011/12/02
   7 | Description: 
   8 | 
   9 | History:
  10 | <contributor>     <time>        <version>       <desc>                   <e-mail>
  11 | Yang Hu	        2009/09/25	      1.0		    Creat SSDsim       yanghu@foxmail.com
  12 | 2010/05/01        2.x           Change 
  13 | Zhiming Zhu     2011/07/01        2.0           Change               812839842@qq.com
  14 | Shuangwu Zhang  2011/11/01        2.1           Change               820876427@qq.com
  15 | Chao Ren        2011/07/01        2.0           Change               529517386@qq.com
  16 | Hao Luo         2011/01/01        2.0           Change               luohao135680@gmail.com
  17 |  *****************************************************************************************************************************/
  18 | 
  19 | 
  20 | 
  21 | #include "ssd.h"
  22 | 
  23 | /********************************************************************************************************************************
  24 |   1，main函数中initiatio()函数用来初始化ssd,；2，make_aged()函数使SSD成为aged，aged的ssd相当于使用过一段时间的ssd，里面有失效页，
  25 |   non_aged的ssd是新的ssd，无失效页，失效页的比例可以在初始化参数中设置；3，pre_process_page()函数提前扫一遍读请求，把读请求
  26 |   的lpn<--->ppn映射关系事先建立好，写请求的lpn<--->ppn映射关系在写的时候再建立，预处理trace防止读请求是读不到数据；4，simulate()是
  27 |   核心处理函数，trace文件从读进来到处理完成都由这个函数来完成；5，statistic_output()函数将ssd结构中的信息输出到输出文件，输出的是
  28 |   统计数据和平均数据，输出文件较小，trace_output文件则很大很详细；6，free_all_node()函数释放整个main函数中申请的节点
  29 |  *********************************************************************************************************************************/
  30 | int  main()
  31 | {
  32 |     unsigned  int i,j,k;
  33 |     struct ssd_info *ssd;
  34 | 
  35 | #ifdef DEBUG
  36 |     printf("enter main\n"); 
  37 | #endif
  38 | 
  39 |     ssd=(struct ssd_info*)malloc(sizeof(struct ssd_info));
  40 |     alloc_assert(ssd,"ssd");
  41 |     memset(ssd,0, sizeof(struct ssd_info));
  42 | 
  43 |     ssd=initiation(ssd);
  44 |     make_aged(ssd);
  45 |     pre_process_page(ssd);
  46 | 
  47 |     for (i=0;i<ssd->parameter->channel_number;i++)
  48 |     {
  49 |         for (j=0;j<ssd->parameter->die_chip;j++)
  50 |         {
  51 |             for (k=0;k<ssd->parameter->plane_die;k++)
  52 |             {
  53 |                 printf("%d,0,%d,%d:  %5d\n",i,j,k,ssd->channel_head[i].chip_head[0].die_head[j].plane_head[k].free_page);
  54 |             }
  55 |         }
  56 |     }
  57 |     fprintf(ssd->outputfile,"\t\t\t\t\t\t\t\t\tOUTPUT\n");
  58 |     fprintf(ssd->outputfile,"****************** TRACE INFO ******************\n");
  59 | 
  60 |     ssd=simulate(ssd);
  61 |     statistic_output(ssd);  
  62 |     /*	free_all_node(ssd);*/
  63 | 
  64 |     printf("\n");
  65 |     printf("the simulation is completed!\n");
  66 | 
  67 |     return 1;
  68 |     /* 	_CrtDumpMemoryLeaks(); */
  69 | }
  70 | 
  71 | 
  72 | /******************simulate() *********************************************************************
  73 |  *simulate()是核心处理函数，主要实现的功能包括
  74 |  *1,从trace文件中获取一条请求，挂到ssd->request
  75 |  *2，根据ssd是否有dram分别处理读出来的请求，把这些请求处理成为读写子请求，挂到ssd->channel或者ssd上
  76 |  *3，按照事件的先后来处理这些读写子请求。
  77 |  *4，输出每条请求的子请求都处理完后的相关信息到outputfile文件中
  78 |  **************************************************************************************************/
  79 | struct ssd_info *simulate(struct ssd_info *ssd)
  80 | {
  81 |     int flag=1,flag1=0;
  82 |     double output_step=0;
  83 |     unsigned int a=0,b=0;
  84 |     //errno_t err;
  85 | 
  86 |     printf("\n");
  87 |     printf("begin simulating.......................\n");
  88 |     printf("\n");
  89 |     printf("\n");
  90 |     printf("   ^o^    OK, please wait a moment, and enjoy music and coffee   ^o^    \n");
  91 | 
  92 |     ssd->tracefile = fopen(ssd->tracefilename,"r");
  93 |     if(ssd->tracefile == NULL)
  94 |     {  
  95 |         printf("the trace file can't open\n");
  96 |         return NULL;
  97 |     }
  98 | 
  99 |     fprintf(ssd->outputfile,"      arrive           lsn     size ope     begin time    response time    process time\n");	
 100 |     fflush(ssd->outputfile);
 101 | 
 102 |     while(flag!=100)      
 103 |     {
 104 | 
 105 |         flag=get_requests(ssd);
 106 | 
 107 |         if(flag == 1)
 108 |         {   
 109 |             //printf("once\n");
 110 |             if (ssd->parameter->dram_capacity!=0)
 111 |             {
 112 |                 buffer_management(ssd);  
 113 |                 distribute(ssd); 
 114 |             } 
 115 |             else
 116 |             {
 117 |                 no_buffer_distribute(ssd);
 118 |             }		
 119 |         }
 120 | 
 121 |         process(ssd);    
 122 |         trace_output(ssd);
 123 |         if(flag == 0 && ssd->request_queue == NULL)
 124 |             flag = 100;
 125 |     }
 126 | 
 127 |     fclose(ssd->tracefile);
 128 |     return ssd;
 129 | }
 130 | 
 131 | 
 132 | 
 133 | /********    get_request    ******************************************************
 134 |  *	1.get requests that arrived already
 135 |  *	2.add those request node to ssd->reuqest_queue
 136 |  *	return	0: reach the end of the trace
 137 |  *			-1: no request has been added
 138 |  *			1: add one request to list
 139 |  *SSD模拟器有三种驱动方式:时钟驱动(精确，太慢) 事件驱动(本程序采用) trace驱动()，
 140 |  *两种方式推进事件：channel/chip状态改变、trace文件请求达到。
 141 |  *channel/chip状态改变和trace文件请求到达是散布在时间轴上的点，每次从当前状态到达
 142 |  *下一个状态都要到达最近的一个状态，每到达一个点执行一次process
 143 |  ********************************************************************************/
 144 | int get_requests(struct ssd_info *ssd)  
 145 | {  
 146 |     char buffer[200];
 147 |     unsigned int lsn=0;
 148 |     int device,  size, ope,large_lsn, i = 0,j=0;
 149 |     struct request *request1;
 150 |     int flag = 1;
 151 |     long filepoint; 
 152 |     int64_t time_t = 0;
 153 |     int64_t nearest_event_time;    
 154 | 
 155 | #ifdef DEBUG
 156 |     printf("enter get_requests,  current time:%lld\n",ssd->current_time);
 157 | #endif
 158 | 
 159 |     if(feof(ssd->tracefile))
 160 |         return 0; 
 161 | 
 162 |     filepoint = ftell(ssd->tracefile);	
 163 |     fgets(buffer, 200, ssd->tracefile); 
 164 |     sscanf(buffer,"%lld %d %d %d %d",&time_t,&device,&lsn,&size,&ope);
 165 | 
 166 |     if ((device<0)&&(lsn<0)&&(size<0)&&(ope<0))
 167 |     {
 168 |         return 100;
 169 |     }
 170 |     if (lsn<ssd->min_lsn) 
 171 |         ssd->min_lsn=lsn;
 172 |     if (lsn>ssd->max_lsn)
 173 |         ssd->max_lsn=lsn;
 174 |     /******************************************************************************************************
 175 |      *上层文件系统发送给SSD的任何读写命令包括两个部分（LSN，size） LSN是逻辑扇区号，对于文件系统而言，它所看到的存
 176 |      *储空间是一个线性的连续空间。例如，读请求（260，6）表示的是需要读取从扇区号为260的逻辑扇区开始，总共6个扇区。
 177 |      *large_lsn: channel下面有多少个subpage，即多少个sector。overprovide系数：SSD中并不是所有的空间都可以给用户使用，
 178 |      *比如32G的SSD可能有10%的空间保留下来留作他用，所以乘以1-provide
 179 |      ***********************************************************************************************************/
 180 |     large_lsn=(int)((ssd->parameter->subpage_page*ssd->parameter->page_block*ssd->parameter->block_plane*ssd->parameter->plane_die*ssd->parameter->die_chip*ssd->parameter->chip_num)*(1-ssd->parameter->overprovide));
 181 |     lsn = lsn%large_lsn;
 182 | 
 183 |     nearest_event_time=find_nearest_event(ssd);
 184 |     if (nearest_event_time==MAX_INT64)
 185 |     {
 186 |         ssd->current_time=time_t;           
 187 | 
 188 |         //if (ssd->request_queue_length>ssd->parameter->queue_length)    //如果请求队列的长度超过了配置文件中所设置的长度                     
 189 |         //{
 190 |         //printf("error in get request , the queue length is too long\n");
 191 |         //}
 192 |     }
 193 |     else
 194 |     {   
 195 |         if(nearest_event_time<time_t)
 196 |         {
 197 |             /*******************************************************************************
 198 |              *回滚，即如果没有把time_t赋给ssd->current_time，则trace文件已读的一条记录回滚
 199 |              *filepoint记录了执行fgets之前的文件指针位置，回滚到文件头+filepoint处
 200 |              *int fseek(FILE *stream, long offset, int fromwhere);函数设置文件指针stream的位置。
 201 |              *如果执行成功，stream将指向以fromwhere（偏移起始位置：文件头0，当前位置1，文件尾2）为基准，
 202 |              *偏移offset（指针偏移量）个字节的位置。如果执行失败(比如offset超过文件自身大小)，则不改变stream指向的位置。
 203 |              *文本文件只能采用文件头0的定位方式，本程序中打开文件方式是"r":以只读方式打开文本文件	
 204 |              **********************************************************************************/
 205 |             fseek(ssd->tracefile,filepoint,0); 
 206 |             if(ssd->current_time<=nearest_event_time)
 207 |                 ssd->current_time=nearest_event_time;
 208 |             return -1;
 209 |         }
 210 |         else
 211 |         {
 212 |             if (ssd->request_queue_length>=ssd->parameter->queue_length)
 213 |             {
 214 |                 fseek(ssd->tracefile,filepoint,0);
 215 |                 ssd->current_time=nearest_event_time;
 216 |                 return -1;
 217 |             } 
 218 |             else
 219 |             {
 220 |                 ssd->current_time=time_t;
 221 |             }
 222 |         }
 223 |     }
 224 | 
 225 |     if(time_t < 0)
 226 |     {
 227 |         printf("error!\n");
 228 |         while(1){}
 229 |     }
 230 | 
 231 |     if(feof(ssd->tracefile))
 232 |     {
 233 |         request1=NULL;
 234 |         return 0;
 235 |     }
 236 | 
 237 |     request1 = (struct request*)malloc(sizeof(struct request));
 238 |     alloc_assert(request1,"request");
 239 |     memset(request1,0, sizeof(struct request));
 240 | 
 241 |     request1->time = time_t;
 242 |     request1->lsn = lsn;
 243 |     request1->size = size;
 244 |     request1->operation = ope;	
 245 |     request1->begin_time = time_t;
 246 |     request1->response_time = 0;	
 247 |     request1->energy_consumption = 0;	
 248 |     request1->next_node = NULL;
 249 |     request1->distri_flag = 0;              // indicate whether this request has been distributed already
 250 |     request1->subs = NULL;
 251 |     request1->need_distr_flag = NULL;
 252 |     request1->complete_lsn_count=0;         //record the count of lsn served by buffer
 253 |     filepoint = ftell(ssd->tracefile);		// set the file point
 254 | 
 255 |     if(ssd->request_queue == NULL)          //The queue is empty
 256 |     {
 257 |         ssd->request_queue = request1;
 258 |         ssd->request_tail = request1;
 259 |         ssd->request_queue_length++;
 260 |     }
 261 |     else
 262 |     {			
 263 |         (ssd->request_tail)->next_node = request1;	
 264 |         ssd->request_tail = request1;			
 265 |         ssd->request_queue_length++;
 266 |     }
 267 | 
 268 |     if (request1->operation==1)             //计算平均请求大小 1为读 0为写
 269 |     {
 270 |         ssd->ave_read_size=(ssd->ave_read_size*ssd->read_request_count+request1->size)/(ssd->read_request_count+1);
 271 |     } 
 272 |     else
 273 |     {
 274 |         ssd->ave_write_size=(ssd->ave_write_size*ssd->write_request_count+request1->size)/(ssd->write_request_count+1);
 275 |     }
 276 | 
 277 | 
 278 |     filepoint = ftell(ssd->tracefile);	
 279 |     fgets(buffer, 200, ssd->tracefile);    //寻找下一条请求的到达时间
 280 |     sscanf(buffer,"%lld %d %d %d %d",&time_t,&device,&lsn,&size,&ope);
 281 |     ssd->next_request_time=time_t;
 282 |     fseek(ssd->tracefile,filepoint,0);
 283 | 
 284 |     return 1;
 285 | }
 286 | 
 287 | /**********************************************************************************************************************************************
 288 |  *首先buffer是个写buffer，就是为写请求服务的，因为读flash的时间tR为20us，写flash的时间tprog为200us，所以为写服务更能节省时间
 289 |  *  读操作：如果命中了buffer，从buffer读，不占用channel的I/O总线，没有命中buffer，从flash读，占用channel的I/O总线，但是不进buffer了
 290 |  *  写操作：首先request分成sub_request子请求，如果是动态分配，sub_request挂到ssd->sub_request上，因为不知道要先挂到哪个channel的sub_request上
 291 |  *          如果是静态分配则sub_request挂到channel的sub_request链上,同时不管动态分配还是静态分配sub_request都要挂到request的sub_request链上
 292 |  *		   因为每处理完一个request，都要在traceoutput文件中输出关于这个request的信息。处理完一个sub_request,就将其从channel的sub_request链
 293 |  *		   或ssd的sub_request链上摘除，但是在traceoutput文件输出一条后再清空request的sub_request链。
 294 |  *		   sub_request命中buffer则在buffer里面写就行了，并且将该sub_page提到buffer链头(LRU)，若没有命中且buffer满，则先将buffer链尾的sub_request
 295 |  *		   写入flash(这会产生一个sub_request写请求，挂到这个请求request的sub_request链上，同时视动态分配还是静态分配挂到channel或ssd的
 296 |  *		   sub_request链上),在将要写的sub_page写入buffer链头
 297 |  ***********************************************************************************************************************************************/
 298 | struct ssd_info *buffer_management(struct ssd_info *ssd)
 299 | {   
 300 |     unsigned int j,lsn,lpn,last_lpn,first_lpn,index,complete_flag=0, state,full_page;
 301 |     unsigned int flag=0,need_distb_flag,lsn_flag,flag1=1,active_region_flag=0;           
 302 |     struct request *new_request;
 303 |     struct buffer_group *buffer_node,key;
 304 |     unsigned int mask=0,offset1=0,offset2=0;
 305 | 
 306 | #ifdef DEBUG
 307 |     printf("enter buffer_management,  current time:%lld\n",ssd->current_time);
 308 | #endif
 309 |     ssd->dram->current_time=ssd->current_time;
 310 |     full_page=~(0xffffffff<<ssd->parameter->subpage_page);
 311 | 
 312 |     new_request=ssd->request_tail;
 313 |     lsn=new_request->lsn;
 314 |     lpn=new_request->lsn/ssd->parameter->subpage_page;
 315 |     last_lpn=(new_request->lsn+new_request->size-1)/ssd->parameter->subpage_page;
 316 |     first_lpn=new_request->lsn/ssd->parameter->subpage_page;
 317 | 
 318 |     new_request->need_distr_flag=(unsigned int*)malloc(sizeof(unsigned int)*((last_lpn-first_lpn+1)*ssd->parameter->subpage_page/32+1));
 319 |     alloc_assert(new_request->need_distr_flag,"new_request->need_distr_flag");
 320 |     memset(new_request->need_distr_flag, 0, sizeof(unsigned int)*((last_lpn-first_lpn+1)*ssd->parameter->subpage_page/32+1));
 321 | 
 322 |     if(new_request->operation==READ) 
 323 |     {		
 324 |         while(lpn<=last_lpn)      		
 325 |         {
 326 |             /************************************************************************************************
 327 |              *need_distb_flag表示是否需要执行distribution函数，1表示需要执行，buffer中没有，0表示不需要执行
 328 |              *即1表示需要分发，0表示不需要分发，对应点初始全部赋为1
 329 |              *************************************************************************************************/
 330 |             need_distb_flag=full_page;   
 331 |             key.group=lpn;
 332 |             buffer_node= (struct buffer_group*)avlTreeFind(ssd->dram->buffer, (TREE_NODE *)&key);		// buffer node 
 333 | 
 334 |             while((buffer_node!=NULL)&&(lsn<(lpn+1)*ssd->parameter->subpage_page)&&(lsn<=(new_request->lsn+new_request->size-1)))             			
 335 |             {             	
 336 |                 lsn_flag=full_page;
 337 |                 mask=1 << (lsn%ssd->parameter->subpage_page);
 338 |                 if(mask>31)
 339 |                 {
 340 |                     printf("the subpage number is larger than 32!add some cases");
 341 |                     getchar(); 		   
 342 |                 }
 343 |                 else if((buffer_node->stored & mask)==mask)
 344 |                 {
 345 |                     flag=1;
 346 |                     lsn_flag=lsn_flag&(~mask);
 347 |                 }
 348 | 
 349 |                 if(flag==1)				
 350 |                 {	//如果该buffer节点不在buffer的队首，需要将这个节点提到队首，实现了LRU算法，这个是一个双向队列。		       		
 351 |                     if(ssd->dram->buffer->buffer_head!=buffer_node)     
 352 |                     {		
 353 |                         if(ssd->dram->buffer->buffer_tail==buffer_node)								
 354 |                         {			
 355 |                             buffer_node->LRU_link_pre->LRU_link_next=NULL;					
 356 |                             ssd->dram->buffer->buffer_tail=buffer_node->LRU_link_pre;							
 357 |                         }				
 358 |                         else								
 359 |                         {				
 360 |                             buffer_node->LRU_link_pre->LRU_link_next=buffer_node->LRU_link_next;				
 361 |                             buffer_node->LRU_link_next->LRU_link_pre=buffer_node->LRU_link_pre;								
 362 |                         }								
 363 |                         buffer_node->LRU_link_next=ssd->dram->buffer->buffer_head;
 364 |                         ssd->dram->buffer->buffer_head->LRU_link_pre=buffer_node;
 365 |                         buffer_node->LRU_link_pre=NULL;			
 366 |                         ssd->dram->buffer->buffer_head=buffer_node;													
 367 |                     }						
 368 |                     ssd->dram->buffer->read_hit++;					
 369 |                     new_request->complete_lsn_count++;											
 370 |                 }		
 371 |                 else if(flag==0)
 372 |                 {
 373 |                     ssd->dram->buffer->read_miss_hit++;
 374 |                 }
 375 | 
 376 |                 need_distb_flag=need_distb_flag&lsn_flag;
 377 | 
 378 |                 flag=0;		
 379 |                 lsn++;						
 380 |             }	
 381 | 
 382 |             index=(lpn-first_lpn)/(32/ssd->parameter->subpage_page); 			
 383 |             new_request->need_distr_flag[index]=new_request->need_distr_flag[index]|(need_distb_flag<<(((lpn-first_lpn)%(32/ssd->parameter->subpage_page))*ssd->parameter->subpage_page));	
 384 |             lpn++;
 385 | 
 386 |         }
 387 |     }  
 388 |     else if(new_request->operation==WRITE)
 389 |     {
 390 |         while(lpn<=last_lpn)           	
 391 |         {	
 392 |             need_distb_flag=full_page;
 393 |             mask=~(0xffffffff<<(ssd->parameter->subpage_page));
 394 |             state=mask;
 395 | 
 396 |             if(lpn==first_lpn)
 397 |             {
 398 |                 offset1=ssd->parameter->subpage_page-((lpn+1)*ssd->parameter->subpage_page-new_request->lsn);
 399 |                 state=state&(0xffffffff<<offset1);
 400 |             }
 401 |             if(lpn==last_lpn)
 402 |             {
 403 |                 offset2=ssd->parameter->subpage_page-((lpn+1)*ssd->parameter->subpage_page-(new_request->lsn+new_request->size));
 404 |                 state=state&(~(0xffffffff<<offset2));
 405 |             }
 406 | 
 407 |             ssd=insert2buffer(ssd, lpn, state,NULL,new_request);
 408 |             lpn++;
 409 |         }
 410 |     }
 411 |     complete_flag = 1;
 412 |     for(j=0;j<=(last_lpn-first_lpn+1)*ssd->parameter->subpage_page/32;j++)
 413 |     {
 414 |         if(new_request->need_distr_flag[j] != 0)
 415 |         {
 416 |             complete_flag = 0;
 417 |         }
 418 |     }
 419 | 
 420 |     /*************************************************************
 421 |      *如果请求已经被全部由buffer服务，该请求可以被直接响应，输出结果
 422 |      *这里假设dram的服务时间为1000ns
 423 |      **************************************************************/
 424 |     if((complete_flag == 1)&&(new_request->subs==NULL))               
 425 |     {
 426 |         new_request->begin_time=ssd->current_time;
 427 |         new_request->response_time=ssd->current_time+1000;            
 428 |     }
 429 | 
 430 |     return ssd;
 431 | }
 432 | 
 433 | /*****************************
 434 |  *lpn向ppn的转换
 435 |  ******************************/
 436 | unsigned int lpn2ppn(struct ssd_info *ssd,unsigned int lsn)
 437 | {
 438 |     int lpn, ppn;	
 439 |     struct entry *p_map = ssd->dram->map->map_entry;
 440 | #ifdef DEBUG
 441 |     printf("enter lpn2ppn,  current time:%lld\n",ssd->current_time);
 442 | #endif
 443 |     lpn = lsn/ssd->parameter->subpage_page;			//lpn
 444 |     ppn = (p_map[lpn]).pn;
 445 |     return ppn;
 446 | }
 447 | 
 448 | /**********************************************************************************
 449 |  *读请求分配子请求函数，这里只处理读请求，写请求已经在buffer_management()函数中处理了
 450 |  *根据请求队列和buffer命中的检查，将每个请求分解成子请求，将子请求队列挂在channel上，
 451 |  *不同的channel有自己的子请求队列
 452 |  **********************************************************************************/
 453 | 
 454 | struct ssd_info *distribute(struct ssd_info *ssd) 
 455 | {
 456 |     unsigned int start, end, first_lsn,last_lsn,lpn,flag=0,flag_attached=0,full_page;
 457 |     unsigned int j, k, sub_size;
 458 |     int i=0;
 459 |     struct request *req;
 460 |     struct sub_request *sub;
 461 |     int* complt;
 462 | 
 463 | #ifdef DEBUG
 464 |     printf("enter distribute,  current time:%lld\n",ssd->current_time);
 465 | #endif
 466 |     full_page=~(0xffffffff<<ssd->parameter->subpage_page);
 467 | 
 468 |     req = ssd->request_tail;
 469 |     if(req->response_time != 0){
 470 |         return ssd;
 471 |     }
 472 |     if (req->operation==WRITE)
 473 |     {
 474 |         return ssd;
 475 |     }
 476 | 
 477 |     if(req != NULL)
 478 |     {
 479 |         if(req->distri_flag == 0)
 480 |         {
 481 |             //如果还有一些读请求需要处理
 482 |             if(req->complete_lsn_count != ssd->request_tail->size)
 483 |             {		
 484 |                 first_lsn = req->lsn;				
 485 |                 last_lsn = first_lsn + req->size;
 486 |                 complt = req->need_distr_flag;
 487 |                 start = first_lsn - first_lsn % ssd->parameter->subpage_page;
 488 |                 end = (last_lsn/ssd->parameter->subpage_page + 1) * ssd->parameter->subpage_page;
 489 |                 i = (end - start)/32;	
 490 | 
 491 |                 while(i >= 0)
 492 |                 {	
 493 |                     /*************************************************************************************
 494 |                      *一个32位的整型数据的每一位代表一个子页，32/ssd->parameter->subpage_page就表示有多少页，
 495 |                      *这里的每一页的状态都存放在了 req->need_distr_flag中，也就是complt中，通过比较complt的
 496 |                      *每一项与full_page，就可以知道，这一页是否处理完成。如果没处理完成则通过creat_sub_request
 497 |                      函数创建子请求。
 498 |                      *************************************************************************************/
 499 |                     for(j=0; j<32/ssd->parameter->subpage_page; j++)
 500 |                     {	
 501 |                         k = (complt[((end-start)/32-i)] >>(ssd->parameter->subpage_page*j)) & full_page;	
 502 |                         if (k !=0)
 503 |                         {
 504 |                             lpn = start/ssd->parameter->subpage_page+ ((end-start)/32-i)*32/ssd->parameter->subpage_page + j;
 505 |                             sub_size=transfer_size(ssd,k,lpn,req);    
 506 |                             if (sub_size==0) 
 507 |                             {
 508 |                                 continue;
 509 |                             }
 510 |                             else
 511 |                             {
 512 |                                 sub=creat_sub_request(ssd,lpn,sub_size,0,req,req->operation);
 513 |                             }	
 514 |                         }
 515 |                     }
 516 |                     i = i-1;
 517 |                 }
 518 | 
 519 |             }
 520 |             else
 521 |             {
 522 |                 req->begin_time=ssd->current_time;
 523 |                 req->response_time=ssd->current_time+1000;   
 524 |             }
 525 | 
 526 |         }
 527 |     }
 528 |     return ssd;
 529 | }
 530 | 
 531 | 
 532 | /**********************************************************************
 533 |  *trace_output()函数是在每一条请求的所有子请求经过process()函数处理完后，
 534 |  *打印输出相关的运行结果到outputfile文件中，这里的结果主要是运行的时间
 535 |  **********************************************************************/
 536 | void trace_output(struct ssd_info* ssd){
 537 |     int flag = 1;	
 538 |     int64_t start_time, end_time;
 539 |     struct request *req, *pre_node;
 540 |     struct sub_request *sub, *tmp;
 541 | 
 542 | #ifdef DEBUG
 543 |     printf("enter trace_output,  current time:%lld\n",ssd->current_time);
 544 | #endif
 545 | 
 546 |     pre_node=NULL;
 547 |     req = ssd->request_queue;
 548 |     start_time = 0;
 549 |     end_time = 0;
 550 | 
 551 |     if(req == NULL)
 552 |         return;
 553 | 
 554 |     while(req != NULL)	
 555 |     {
 556 |         sub = req->subs;
 557 |         flag = 1;
 558 |         start_time = 0;
 559 |         end_time = 0;
 560 |         if(req->response_time != 0)
 561 |         {
 562 |             fprintf(ssd->outputfile,"%16lld %10d %6d %2d %16lld %16lld %10lld\n",req->time,req->lsn, req->size, req->operation, req->begin_time, req->response_time, req->response_time-req->time);
 563 |             fflush(ssd->outputfile);
 564 | 
 565 |             if(req->response_time-req->begin_time==0)
 566 |             {
 567 |                 printf("the response time is 0?? \n");
 568 |                 getchar();
 569 |             }
 570 | 
 571 |             if (req->operation==READ)
 572 |             {
 573 |                 ssd->read_request_count++;
 574 |                 ssd->read_avg=ssd->read_avg+(req->response_time-req->time);
 575 |             } 
 576 |             else
 577 |             {
 578 |                 ssd->write_request_count++;
 579 |                 ssd->write_avg=ssd->write_avg+(req->response_time-req->time);
 580 |             }
 581 | 
 582 |             if(pre_node == NULL)
 583 |             {
 584 |                 if(req->next_node == NULL)
 585 |                 {
 586 |                     free(req->need_distr_flag);
 587 |                     req->need_distr_flag=NULL;
 588 |                     free(req);
 589 |                     req = NULL;
 590 |                     ssd->request_queue = NULL;
 591 |                     ssd->request_tail = NULL;
 592 |                     ssd->request_queue_length--;
 593 |                 }
 594 |                 else
 595 |                 {
 596 |                     ssd->request_queue = req->next_node;
 597 |                     pre_node = req;
 598 |                     req = req->next_node;
 599 |                     free(pre_node->need_distr_flag);
 600 |                     pre_node->need_distr_flag=NULL;
 601 |                     free((void *)pre_node);
 602 |                     pre_node = NULL;
 603 |                     ssd->request_queue_length--;
 604 |                 }
 605 |             }
 606 |             else
 607 |             {
 608 |                 if(req->next_node == NULL)
 609 |                 {
 610 |                     pre_node->next_node = NULL;
 611 |                     free(req->need_distr_flag);
 612 |                     req->need_distr_flag=NULL;
 613 |                     free(req);
 614 |                     req = NULL;
 615 |                     ssd->request_tail = pre_node;
 616 |                     ssd->request_queue_length--;
 617 |                 }
 618 |                 else
 619 |                 {
 620 |                     pre_node->next_node = req->next_node;
 621 |                     free(req->need_distr_flag);
 622 |                     req->need_distr_flag=NULL;
 623 |                     free((void *)req);
 624 |                     req = pre_node->next_node;
 625 |                     ssd->request_queue_length--;
 626 |                 }
 627 |             }
 628 |         }
 629 |         else
 630 |         {
 631 |             flag=1;
 632 |             while(sub != NULL)
 633 |             {
 634 |                 if(start_time == 0)
 635 |                     start_time = sub->begin_time;
 636 |                 if(start_time > sub->begin_time)
 637 |                     start_time = sub->begin_time;
 638 |                 if(end_time < sub->complete_time)
 639 |                     end_time = sub->complete_time;
 640 |                 if((sub->current_state == SR_COMPLETE)||((sub->next_state==SR_COMPLETE)&&(sub->next_state_predict_time<=ssd->current_time)))	// if any sub-request is not completed, the request is not completed
 641 |                 {
 642 |                     sub = sub->next_subs;
 643 |                 }
 644 |                 else
 645 |                 {
 646 |                     flag=0;
 647 |                     break;
 648 |                 }
 649 | 
 650 |             }
 651 | 
 652 |             if (flag == 1)
 653 |             {		
 654 |                 //fprintf(ssd->outputfile,"%10I64u %10u %6u %2u %16I64u %16I64u %10I64u\n",req->time,req->lsn, req->size, req->operation, start_time, end_time, end_time-req->time);
 655 |                 fprintf(ssd->outputfile,"%16lld %10d %6d %2d %16lld %16lld %10lld\n",req->time,req->lsn, req->size, req->operation, start_time, end_time, end_time-req->time);
 656 |                 fflush(ssd->outputfile);
 657 | 
 658 |                 if(end_time-start_time==0)
 659 |                 {
 660 |                     printf("the response time is 0?? \n");
 661 |                     getchar();
 662 |                 }
 663 | 
 664 |                 if (req->operation==READ)
 665 |                 {
 666 |                     ssd->read_request_count++;
 667 |                     ssd->read_avg=ssd->read_avg+(end_time-req->time);
 668 |                 } 
 669 |                 else
 670 |                 {
 671 |                     ssd->write_request_count++;
 672 |                     ssd->write_avg=ssd->write_avg+(end_time-req->time);
 673 |                 }
 674 | 
 675 |                 while(req->subs!=NULL)
 676 |                 {
 677 |                     tmp = req->subs;
 678 |                     req->subs = tmp->next_subs;
 679 |                     if (tmp->update!=NULL)
 680 |                     {
 681 |                         free(tmp->update->location);
 682 |                         tmp->update->location=NULL;
 683 |                         free(tmp->update);
 684 |                         tmp->update=NULL;
 685 |                     }
 686 |                     free(tmp->location);
 687 |                     tmp->location=NULL;
 688 |                     free(tmp);
 689 |                     tmp=NULL;
 690 | 
 691 |                 }
 692 | 
 693 |                 if(pre_node == NULL)
 694 |                 {
 695 |                     if(req->next_node == NULL)
 696 |                     {
 697 |                         free(req->need_distr_flag);
 698 |                         req->need_distr_flag=NULL;
 699 |                         free(req);
 700 |                         req = NULL;
 701 |                         ssd->request_queue = NULL;
 702 |                         ssd->request_tail = NULL;
 703 |                         ssd->request_queue_length--;
 704 |                     }
 705 |                     else
 706 |                     {
 707 |                         ssd->request_queue = req->next_node;
 708 |                         pre_node = req;
 709 |                         req = req->next_node;
 710 |                         free(pre_node->need_distr_flag);
 711 |                         pre_node->need_distr_flag=NULL;
 712 |                         free(pre_node);
 713 |                         pre_node = NULL;
 714 |                         ssd->request_queue_length--;
 715 |                     }
 716 |                 }
 717 |                 else
 718 |                 {
 719 |                     if(req->next_node == NULL)
 720 |                     {
 721 |                         pre_node->next_node = NULL;
 722 |                         free(req->need_distr_flag);
 723 |                         req->need_distr_flag=NULL;
 724 |                         free(req);
 725 |                         req = NULL;
 726 |                         ssd->request_tail = pre_node;	
 727 |                         ssd->request_queue_length--;
 728 |                     }
 729 |                     else
 730 |                     {
 731 |                         pre_node->next_node = req->next_node;
 732 |                         free(req->need_distr_flag);
 733 |                         req->need_distr_flag=NULL;
 734 |                         free(req);
 735 |                         req = pre_node->next_node;
 736 |                         ssd->request_queue_length--;
 737 |                     }
 738 | 
 739 |                 }
 740 |             }
 741 |             else
 742 |             {	
 743 |                 pre_node = req;
 744 |                 req = req->next_node;
 745 |             }
 746 |         }		
 747 |     }
 748 | }
 749 | 
 750 | 
 751 | /*******************************************************************************
 752 |  *statistic_output()函数主要是输出处理完一条请求后的相关处理信息。
 753 |  *1，计算出每个plane的擦除次数即plane_erase和总的擦除次数即erase
 754 |  *2，打印min_lsn，max_lsn，read_count，program_count等统计信息到文件outputfile中。
 755 |  *3，打印相同的信息到文件statisticfile中
 756 |  *******************************************************************************/
 757 | void statistic_output(struct ssd_info *ssd)
 758 | {
 759 |     unsigned int lpn_count=0,i,j,k,m,erase=0,plane_erase=0;
 760 |     double gc_energy=0.0;
 761 | #ifdef DEBUG
 762 |     printf("enter statistic_output,  current time:%lld\n",ssd->current_time);
 763 | #endif
 764 | 
 765 |     for(i=0;i<ssd->parameter->channel_number;i++)
 766 |     {
 767 |         for(j=0;j<ssd->parameter->die_chip;j++)
 768 |         {
 769 |             for(k=0;k<ssd->parameter->plane_die;k++)
 770 |             {
 771 |                 plane_erase=0;
 772 |                 for(m=0;m<ssd->parameter->block_plane;m++)
 773 |                 {
 774 |                     if(ssd->channel_head[i].chip_head[0].die_head[j].plane_head[k].blk_head[m].erase_count>0)
 775 |                     {
 776 |                         erase=erase+ssd->channel_head[i].chip_head[0].die_head[j].plane_head[k].blk_head[m].erase_count;
 777 |                         plane_erase+=ssd->channel_head[i].chip_head[0].die_head[j].plane_head[k].blk_head[m].erase_count;
 778 |                     }
 779 |                 }
 780 |                 fprintf(ssd->outputfile,"the %d channel, %d chip, %d die, %d plane has : %13d erase operations\n",i,j,k,m,plane_erase);
 781 |                 fprintf(ssd->statisticfile,"the %d channel, %d chip, %d die, %d plane has : %13d erase operations\n",i,j,k,m,plane_erase);
 782 |             }
 783 |         }
 784 |     }
 785 | 
 786 |     fprintf(ssd->outputfile,"\n");
 787 |     fprintf(ssd->outputfile,"\n");
 788 |     fprintf(ssd->outputfile,"---------------------------statistic data---------------------------\n");	 
 789 |     fprintf(ssd->outputfile,"min lsn: %13d\n",ssd->min_lsn);	
 790 |     fprintf(ssd->outputfile,"max lsn: %13d\n",ssd->max_lsn);
 791 |     fprintf(ssd->outputfile,"read count: %13d\n",ssd->read_count);	  
 792 |     fprintf(ssd->outputfile,"program count: %13d",ssd->program_count);	
 793 |     fprintf(ssd->outputfile,"                        include the flash write count leaded by read requests\n");
 794 |     fprintf(ssd->outputfile,"the read operation leaded by un-covered update count: %13d\n",ssd->update_read_count);
 795 |     fprintf(ssd->outputfile,"erase count: %13d\n",ssd->erase_count);
 796 |     fprintf(ssd->outputfile,"direct erase count: %13d\n",ssd->direct_erase_count);
 797 |     fprintf(ssd->outputfile,"copy back count: %13d\n",ssd->copy_back_count);
 798 |     fprintf(ssd->outputfile,"multi-plane program count: %13d\n",ssd->m_plane_prog_count);
 799 |     fprintf(ssd->outputfile,"multi-plane read count: %13d\n",ssd->m_plane_read_count);
 800 |     fprintf(ssd->outputfile,"interleave write count: %13d\n",ssd->interleave_count);
 801 |     fprintf(ssd->outputfile,"interleave read count: %13d\n",ssd->interleave_read_count);
 802 |     fprintf(ssd->outputfile,"interleave two plane and one program count: %13d\n",ssd->inter_mplane_prog_count);
 803 |     fprintf(ssd->outputfile,"interleave two plane count: %13d\n",ssd->inter_mplane_count);
 804 |     fprintf(ssd->outputfile,"gc copy back count: %13d\n",ssd->gc_copy_back);
 805 |     fprintf(ssd->outputfile,"write flash count: %13d\n",ssd->write_flash_count);
 806 |     fprintf(ssd->outputfile,"interleave erase count: %13d\n",ssd->interleave_erase_count);
 807 |     fprintf(ssd->outputfile,"multiple plane erase count: %13d\n",ssd->mplane_erase_conut);
 808 |     fprintf(ssd->outputfile,"interleave multiple plane erase count: %13d\n",ssd->interleave_mplane_erase_count);
 809 |     fprintf(ssd->outputfile,"read request count: %13d\n",ssd->read_request_count);
 810 |     fprintf(ssd->outputfile,"write request count: %13d\n",ssd->write_request_count);
 811 |     fprintf(ssd->outputfile,"read request average size: %13f\n",ssd->ave_read_size);
 812 |     fprintf(ssd->outputfile,"write request average size: %13f\n",ssd->ave_write_size);
 813 |     fprintf(ssd->outputfile,"read request average response time: %lld\n",ssd->read_avg/ssd->read_request_count);
 814 |     fprintf(ssd->outputfile,"write request average response time: %lld\n",ssd->write_avg/ssd->write_request_count);
 815 |     fprintf(ssd->outputfile,"buffer read hits: %13d\n",ssd->dram->buffer->read_hit);
 816 |     fprintf(ssd->outputfile,"buffer read miss: %13d\n",ssd->dram->buffer->read_miss_hit);
 817 |     fprintf(ssd->outputfile,"buffer write hits: %13d\n",ssd->dram->buffer->write_hit);
 818 |     fprintf(ssd->outputfile,"buffer write miss: %13d\n",ssd->dram->buffer->write_miss_hit);
 819 |     fprintf(ssd->outputfile,"erase: %13d\n",erase);
 820 |     fflush(ssd->outputfile);
 821 | 
 822 |     fclose(ssd->outputfile);
 823 | 
 824 | 
 825 |     fprintf(ssd->statisticfile,"\n");
 826 |     fprintf(ssd->statisticfile,"\n");
 827 |     fprintf(ssd->statisticfile,"---------------------------statistic data---------------------------\n");	
 828 |     fprintf(ssd->statisticfile,"min lsn: %13d\n",ssd->min_lsn);	
 829 |     fprintf(ssd->statisticfile,"max lsn: %13d\n",ssd->max_lsn);
 830 |     fprintf(ssd->statisticfile,"read count: %13d\n",ssd->read_count);	  
 831 |     fprintf(ssd->statisticfile,"program count: %13d",ssd->program_count);	  
 832 |     fprintf(ssd->statisticfile,"                        include the flash write count leaded by read requests\n");
 833 |     fprintf(ssd->statisticfile,"the read operation leaded by un-covered update count: %13d\n",ssd->update_read_count);
 834 |     fprintf(ssd->statisticfile,"erase count: %13d\n",ssd->erase_count);	  
 835 |     fprintf(ssd->statisticfile,"direct erase count: %13d\n",ssd->direct_erase_count);
 836 |     fprintf(ssd->statisticfile,"copy back count: %13d\n",ssd->copy_back_count);
 837 |     fprintf(ssd->statisticfile,"multi-plane program count: %13d\n",ssd->m_plane_prog_count);
 838 |     fprintf(ssd->statisticfile,"multi-plane read count: %13d\n",ssd->m_plane_read_count);
 839 |     fprintf(ssd->statisticfile,"interleave count: %13d\n",ssd->interleave_count);
 840 |     fprintf(ssd->statisticfile,"interleave read count: %13d\n",ssd->interleave_read_count);
 841 |     fprintf(ssd->statisticfile,"interleave two plane and one program count: %13d\n",ssd->inter_mplane_prog_count);
 842 |     fprintf(ssd->statisticfile,"interleave two plane count: %13d\n",ssd->inter_mplane_count);
 843 |     fprintf(ssd->statisticfile,"gc copy back count: %13d\n",ssd->gc_copy_back);
 844 |     fprintf(ssd->statisticfile,"write flash count: %13d\n",ssd->write_flash_count);
 845 |     fprintf(ssd->statisticfile,"waste page count: %13d\n",ssd->waste_page_count);
 846 |     fprintf(ssd->statisticfile,"interleave erase count: %13d\n",ssd->interleave_erase_count);
 847 |     fprintf(ssd->statisticfile,"multiple plane erase count: %13d\n",ssd->mplane_erase_conut);
 848 |     fprintf(ssd->statisticfile,"interleave multiple plane erase count: %13d\n",ssd->interleave_mplane_erase_count);
 849 |     fprintf(ssd->statisticfile,"read request count: %13d\n",ssd->read_request_count);
 850 |     fprintf(ssd->statisticfile,"write request count: %13d\n",ssd->write_request_count);
 851 |     fprintf(ssd->statisticfile,"read request average size: %13f\n",ssd->ave_read_size);
 852 |     fprintf(ssd->statisticfile,"write request average size: %13f\n",ssd->ave_write_size);
 853 |     fprintf(ssd->statisticfile,"read request average response time: %lld\n",ssd->read_avg/ssd->read_request_count);
 854 |     fprintf(ssd->statisticfile,"write request average response time: %lld\n",ssd->write_avg/ssd->write_request_count);
 855 |     fprintf(ssd->statisticfile,"buffer read hits: %13d\n",ssd->dram->buffer->read_hit);
 856 |     fprintf(ssd->statisticfile,"buffer read miss: %13d\n",ssd->dram->buffer->read_miss_hit);
 857 |     fprintf(ssd->statisticfile,"buffer write hits: %13d\n",ssd->dram->buffer->write_hit);
 858 |     fprintf(ssd->statisticfile,"buffer write miss: %13d\n",ssd->dram->buffer->write_miss_hit);
 859 |     fprintf(ssd->statisticfile,"erase: %13d\n",erase);
 860 |     fflush(ssd->statisticfile);
 861 | 
 862 |     fclose(ssd->statisticfile);
 863 | }
 864 | 
 865 | 
 866 | /***********************************************************************************
 867 |  *根据每一页的状态计算出每一需要处理的子页的数目，也就是一个子请求需要处理的子页的页数
 868 |  ************************************************************************************/
 869 | unsigned int size(unsigned int stored)
 870 | {
 871 |     unsigned int i,total=0,mask=0x80000000;
 872 | 
 873 | #ifdef DEBUG
 874 |     printf("enter size\n");
 875 | #endif
 876 |     for(i=1;i<=32;i++)
 877 |     {
 878 |         if(stored & mask) total++;
 879 |         stored<<=1;
 880 |     }
 881 | #ifdef DEBUG
 882 |     printf("leave size\n");
 883 | #endif
 884 |     return total;
 885 | }
 886 | 
 887 | 
 888 | /*********************************************************
 889 |  *transfer_size()函数的作用就是计算出子请求的需要处理的size
 890 |  *函数中单独处理了first_lpn，last_lpn这两个特别情况，因为这
 891 |  *两种情况下很有可能不是处理一整页而是处理一页的一部分，因
 892 |  *为lsn有可能不是一页的第一个子页。
 893 |  *********************************************************/
 894 | unsigned int transfer_size(struct ssd_info *ssd,int need_distribute,unsigned int lpn,struct request *req)
 895 | {
 896 |     unsigned int first_lpn,last_lpn,state,trans_size;
 897 |     unsigned int mask=0,offset1=0,offset2=0;
 898 | 
 899 |     first_lpn=req->lsn/ssd->parameter->subpage_page;
 900 |     last_lpn=(req->lsn+req->size-1)/ssd->parameter->subpage_page;
 901 | 
 902 |     mask=~(0xffffffff<<(ssd->parameter->subpage_page));
 903 |     state=mask;
 904 |     if(lpn==first_lpn)
 905 |     {
 906 |         offset1=ssd->parameter->subpage_page-((lpn+1)*ssd->parameter->subpage_page-req->lsn);
 907 |         state=state&(0xffffffff<<offset1);
 908 |     }
 909 |     if(lpn==last_lpn)
 910 |     {
 911 |         offset2=ssd->parameter->subpage_page-((lpn+1)*ssd->parameter->subpage_page-(req->lsn+req->size));
 912 |         state=state&(~(0xffffffff<<offset2));
 913 |     }
 914 | 
 915 |     trans_size=size(state&need_distribute);
 916 | 
 917 |     return trans_size;
 918 | }
 919 | 
 920 | 
 921 | /**********************************************************************************************************  
 922 |  *int64_t find_nearest_event(struct ssd_info *ssd)       
 923 |  *寻找所有子请求的最早到达的下个状态时间,首先看请求的下一个状态时间，如果请求的下个状态时间小于等于当前时间，
 924 |  *说明请求被阻塞，需要查看channel或者对应die的下一状态时间。Int64是有符号 64 位整数数据类型，值类型表示值介于
 925 |  *-2^63 ( -9,223,372,036,854,775,808)到2^63-1(+9,223,372,036,854,775,807 )之间的整数。存储空间占 8 字节。
 926 |  *channel,die是事件向前推进的关键因素，三种情况可以使事件继续向前推进，channel，die分别回到idle状态，die中的
 927 |  *读数据准备好了
 928 |  ***********************************************************************************************************/
 929 | int64_t find_nearest_event(struct ssd_info *ssd) 
 930 | {
 931 |     unsigned int i,j;
 932 |     int64_t time=MAX_INT64;
 933 |     int64_t time1=MAX_INT64;
 934 |     int64_t time2=MAX_INT64;
 935 | 
 936 |     for (i=0;i<ssd->parameter->channel_number;i++)
 937 |     {
 938 |         if (ssd->channel_head[i].next_state==CHANNEL_IDLE)
 939 |             if(time1>ssd->channel_head[i].next_state_predict_time)
 940 |                 if (ssd->channel_head[i].next_state_predict_time>ssd->current_time)    
 941 |                     time1=ssd->channel_head[i].next_state_predict_time;
 942 |         for (j=0;j<ssd->parameter->chip_channel[i];j++)
 943 |         {
 944 |             if ((ssd->channel_head[i].chip_head[j].next_state==CHIP_IDLE)||(ssd->channel_head[i].chip_head[j].next_state==CHIP_DATA_TRANSFER))
 945 |                 if(time2>ssd->channel_head[i].chip_head[j].next_state_predict_time)
 946 |                     if (ssd->channel_head[i].chip_head[j].next_state_predict_time>ssd->current_time)    
 947 |                         time2=ssd->channel_head[i].chip_head[j].next_state_predict_time;	
 948 |         }   
 949 |     } 
 950 | 
 951 |     /*****************************************************************************************************
 952 |      *time为所有 A.下一状态为CHANNEL_IDLE且下一状态预计时间大于ssd当前时间的CHANNEL的下一状态预计时间
 953 |      *           B.下一状态为CHIP_IDLE且下一状态预计时间大于ssd当前时间的DIE的下一状态预计时间
 954 |      *		     C.下一状态为CHIP_DATA_TRANSFER且下一状态预计时间大于ssd当前时间的DIE的下一状态预计时间
 955 |      *CHIP_DATA_TRANSFER读准备好状态，数据已从介质传到了register，下一状态是从register传往buffer中的最小值 
 956 |      *注意可能都没有满足要求的time，这时time返回0x7fffffffffffffff 。
 957 |      *****************************************************************************************************/
 958 |     time=(time1>time2)?time2:time1;
 959 |     return time;
 960 | }
 961 | 
 962 | /***********************************************
 963 |  *free_all_node()函数的作用就是释放所有申请的节点
 964 |  ************************************************/
 965 | void free_all_node(struct ssd_info *ssd)
 966 | {
 967 |     unsigned int i,j,k,l,n;
 968 |     struct buffer_group *pt=NULL;
 969 |     struct direct_erase * erase_node=NULL;
 970 |     for (i=0;i<ssd->parameter->channel_number;i++)
 971 |     {
 972 |         for (j=0;j<ssd->parameter->chip_channel[0];j++)
 973 |         {
 974 |             for (k=0;k<ssd->parameter->die_chip;k++)
 975 |             {
 976 |                 for (l=0;l<ssd->parameter->plane_die;l++)
 977 |                 {
 978 |                     for (n=0;n<ssd->parameter->block_plane;n++)
 979 |                     {
 980 |                         free(ssd->channel_head[i].chip_head[j].die_head[k].plane_head[l].blk_head[n].page_head);
 981 |                         ssd->channel_head[i].chip_head[j].die_head[k].plane_head[l].blk_head[n].page_head=NULL;
 982 |                     }
 983 |                     free(ssd->channel_head[i].chip_head[j].die_head[k].plane_head[l].blk_head);
 984 |                     ssd->channel_head[i].chip_head[j].die_head[k].plane_head[l].blk_head=NULL;
 985 |                     while(ssd->channel_head[i].chip_head[j].die_head[k].plane_head[l].erase_node!=NULL)
 986 |                     {
 987 |                         erase_node=ssd->channel_head[i].chip_head[j].die_head[k].plane_head[l].erase_node;
 988 |                         ssd->channel_head[i].chip_head[j].die_head[k].plane_head[l].erase_node=erase_node->next_node;
 989 |                         free(erase_node);
 990 |                         erase_node=NULL;
 991 |                     }
 992 |                 }
 993 | 
 994 |                 free(ssd->channel_head[i].chip_head[j].die_head[k].plane_head);
 995 |                 ssd->channel_head[i].chip_head[j].die_head[k].plane_head=NULL;
 996 |             }
 997 |             free(ssd->channel_head[i].chip_head[j].die_head);
 998 |             ssd->channel_head[i].chip_head[j].die_head=NULL;
 999 |         }
1000 |         free(ssd->channel_head[i].chip_head);
1001 |         ssd->channel_head[i].chip_head=NULL;
1002 |     }
1003 |     free(ssd->channel_head);
1004 |     ssd->channel_head=NULL;
1005 | 
1006 |     avlTreeDestroy( ssd->dram->buffer);
1007 |     ssd->dram->buffer=NULL;
1008 | 
1009 |     free(ssd->dram->map->map_entry);
1010 |     ssd->dram->map->map_entry=NULL;
1011 |     free(ssd->dram->map);
1012 |     ssd->dram->map=NULL;
1013 |     free(ssd->dram);
1014 |     ssd->dram=NULL;
1015 |     free(ssd->parameter);
1016 |     ssd->parameter=NULL;
1017 | 
1018 |     free(ssd);
1019 |     ssd=NULL;
1020 | }
1021 | 
1022 | 
1023 | /*****************************************************************************
1024 |  *make_aged()函数的作用就死模拟真实的用过一段时间的ssd，
1025 |  *那么这个ssd的相应的参数就要改变，所以这个函数实质上就是对ssd中各个参数的赋值。
1026 |  ******************************************************************************/
1027 | struct ssd_info *make_aged(struct ssd_info *ssd)
1028 | {
1029 |     unsigned int i,j,k,l,m,n,ppn;
1030 |     int threshould,flag=0;
1031 | 
1032 |     if (ssd->parameter->aged==1)
1033 |     {
1034 |         //threshold表示一个plane中有多少页需要提前置为失效
1035 |         threshould=(int)(ssd->parameter->block_plane*ssd->parameter->page_block*ssd->parameter->aged_ratio);  
1036 |         for (i=0;i<ssd->parameter->channel_number;i++)
1037 |             for (j=0;j<ssd->parameter->chip_channel[i];j++)
1038 |                 for (k=0;k<ssd->parameter->die_chip;k++)
1039 |                     for (l=0;l<ssd->parameter->plane_die;l++)
1040 |                     {  
1041 |                         flag=0;
1042 |                         for (m=0;m<ssd->parameter->block_plane;m++)
1043 |                         {  
1044 |                             if (flag>=threshould)
1045 |                             {
1046 |                                 break;
1047 |                             }
1048 |                             for (n=0;n<(ssd->parameter->page_block*ssd->parameter->aged_ratio+1);n++)
1049 |                             {  
1050 |                                 ssd->channel_head[i].chip_head[j].die_head[k].plane_head[l].blk_head[m].page_head[n].valid_state=0;        //表示某一页失效，同时标记valid和free状态都为0
1051 |                                 ssd->channel_head[i].chip_head[j].die_head[k].plane_head[l].blk_head[m].page_head[n].free_state=0;         //表示某一页失效，同时标记valid和free状态都为0
1052 |                                 ssd->channel_head[i].chip_head[j].die_head[k].plane_head[l].blk_head[m].page_head[n].lpn=0;  //把valid_state free_state lpn都置为0表示页失效，检测的时候三项都检测，单独lpn=0可以是有效页
1053 |                                 ssd->channel_head[i].chip_head[j].die_head[k].plane_head[l].blk_head[m].free_page_num--;
1054 |                                 ssd->channel_head[i].chip_head[j].die_head[k].plane_head[l].blk_head[m].invalid_page_num++;
1055 |                                 ssd->channel_head[i].chip_head[j].die_head[k].plane_head[l].blk_head[m].last_write_page++;
1056 |                                 ssd->channel_head[i].chip_head[j].die_head[k].plane_head[l].free_page--;
1057 |                                 flag++;
1058 | 
1059 |                                 ppn=find_ppn(ssd,i,j,k,l,m,n);
1060 | 
1061 |                             }
1062 |                         } 
1063 |                     }	 
1064 |     }  
1065 |     else
1066 |     {
1067 |         return ssd;
1068 |     }
1069 | 
1070 |     return ssd;
1071 | }
1072 | 
1073 | 
1074 | /*********************************************************************************************
1075 |  *no_buffer_distribute()函数是处理当ssd没有dram的时候，
1076 |  *这是读写请求就不必再需要在buffer里面寻找，直接利用creat_sub_request()函数创建子请求，再处理。
1077 |  *********************************************************************************************/
1078 | struct ssd_info *no_buffer_distribute(struct ssd_info *ssd)
1079 | {
1080 |     unsigned int lsn,lpn,last_lpn,first_lpn,complete_flag=0, state;
1081 |     unsigned int flag=0,flag1=1,active_region_flag=0;           //to indicate the lsn is hitted or not
1082 |     struct request *req=NULL;
1083 |     struct sub_request *sub=NULL,*sub_r=NULL,*update=NULL;
1084 |     struct local *loc=NULL;
1085 |     struct channel_info *p_ch=NULL;
1086 | 
1087 | 
1088 |     unsigned int mask=0; 
1089 |     unsigned int offset1=0, offset2=0;
1090 |     unsigned int sub_size=0;
1091 |     unsigned int sub_state=0;
1092 | 
1093 |     ssd->dram->current_time=ssd->current_time;
1094 |     req=ssd->request_tail;       
1095 |     lsn=req->lsn;
1096 |     lpn=req->lsn/ssd->parameter->subpage_page;
1097 |     last_lpn=(req->lsn+req->size-1)/ssd->parameter->subpage_page;
1098 |     first_lpn=req->lsn/ssd->parameter->subpage_page;
1099 | 
1100 |     if(req->operation==READ)        
1101 |     {		
1102 |         while(lpn<=last_lpn) 		
1103 |         {
1104 |             sub_state=(ssd->dram->map->map_entry[lpn].state&0x7fffffff);
1105 |             sub_size=size(sub_state);
1106 |             sub=creat_sub_request(ssd,lpn,sub_size,sub_state,req,req->operation);
1107 |             lpn++;
1108 |         }
1109 |     }
1110 |     else if(req->operation==WRITE)
1111 |     {
1112 |         while(lpn<=last_lpn)     	
1113 |         {	
1114 |             mask=~(0xffffffff<<(ssd->parameter->subpage_page));
1115 |             state=mask;
1116 |             if(lpn==first_lpn)
1117 |             {
1118 |                 offset1=ssd->parameter->subpage_page-((lpn+1)*ssd->parameter->subpage_page-req->lsn);
1119 |                 state=state&(0xffffffff<<offset1);
1120 |             }
1121 |             if(lpn==last_lpn)
1122 |             {
1123 |                 offset2=ssd->parameter->subpage_page-((lpn+1)*ssd->parameter->subpage_page-(req->lsn+req->size));
1124 |                 state=state&(~(0xffffffff<<offset2));
1125 |             }
1126 |             sub_size=size(state);
1127 | 
1128 |             sub=creat_sub_request(ssd,lpn,sub_size,state,req,req->operation);
1129 |             lpn++;
1130 |         }
1131 |     }
1132 | 
1133 |     return ssd;
1134 | }
1135 | 
1136 | 
1137 | 


--------------------------------------------------------------------------------
/pagemap.c:
--------------------------------------------------------------------------------
   1 | /*****************************************************************************************************************************
   2 |   This project was supported by the National Basic Research 973 Program of China under Grant No.2011CB302301
   3 |   Huazhong University of Science and Technology (HUST)   Wuhan National Laboratory for Optoelectronics
   4 | 
   5 |   FileName： pagemap.h
   6 | Author: Hu Yang		Version: 2.1	Date:2011/12/02
   7 | Description: 
   8 | 
   9 | History:
  10 | <contributor>     <time>        <version>       <desc>                   <e-mail>
  11 | Yang Hu	        2009/09/25	      1.0		    Creat SSDsim       yanghu@foxmail.com
  12 | 2010/05/01        2.x           Change 
  13 | Zhiming Zhu     2011/07/01        2.0           Change               812839842@qq.com
  14 | Shuangwu Zhang  2011/11/01        2.1           Change               820876427@qq.com
  15 | Chao Ren        2011/07/01        2.0           Change               529517386@qq.com
  16 | Hao Luo         2011/01/01        2.0           Change               luohao135680@gmail.com
  17 |  *****************************************************************************************************************************/
  18 | 
  19 | #define _CRTDBG_MAP_ALLOC
  20 | 
  21 | #include "pagemap.h"
  22 | 
  23 | 
  24 | /************************************************
  25 |  *断言,当打开文件失败时，输出“open 文件名 error”
  26 |  *************************************************/
  27 | void file_assert(int error,char *s)
  28 | {
  29 |     if(error == 0) return;
  30 |     printf("open %s error\n",s);
  31 |     getchar();
  32 |     exit(-1);
  33 | }
  34 | 
  35 | /*****************************************************
  36 |  *断言,当申请内存空间失败时，输出“malloc 变量名 error”
  37 |  ******************************************************/
  38 | void alloc_assert(void *p,char *s)//断言
  39 | {
  40 |     if(p!=NULL) return;
  41 |     printf("malloc %s error\n",s);
  42 |     getchar();
  43 |     exit(-1);
  44 | }
  45 | 
  46 | /*********************************************************************************
  47 |  *断言
  48 |  *A，读到的time_t，device，lsn，size，ope都<0时，输出“trace error:.....”
  49 |  *B，读到的time_t，device，lsn，size，ope都=0时，输出“probable read a blank line”
  50 |  **********************************************************************************/
  51 | void trace_assert(int64_t time_t,int device,unsigned int lsn,int size,int ope)//断言
  52 | {
  53 |     if(time_t <0 || device < 0 || lsn < 0 || size < 0 || ope < 0)
  54 |     {
  55 |         printf("trace error:%lld %d %d %d %d\n",time_t,device,lsn,size,ope);
  56 |         getchar();
  57 |         exit(-1);
  58 |     }
  59 |     if(time_t == 0 && device == 0 && lsn == 0 && size == 0 && ope == 0)
  60 |     {
  61 |         printf("probable read a blank line\n");
  62 |         getchar();
  63 |     }
  64 | }
  65 | 
  66 | 
  67 | /************************************************************************************
  68 |  *函数的功能是根据物理页号ppn查找该物理页所在的channel，chip，die，plane，block，page
  69 |  *得到的channel，chip，die，plane，block，page放在结构location中并作为返回值
  70 |  *************************************************************************************/
  71 | struct local *find_location(struct ssd_info *ssd,unsigned int ppn)
  72 | {
  73 |     struct local *location=NULL;
  74 |     unsigned int i=0;
  75 |     int pn,ppn_value=ppn;
  76 |     int page_plane=0,page_die=0,page_chip=0,page_channel=0;
  77 | 
  78 |     pn = ppn;
  79 | 
  80 | #ifdef DEBUG
  81 |     printf("enter find_location\n");
  82 | #endif
  83 | 
  84 |     location=(struct local *)malloc(sizeof(struct local));
  85 |     alloc_assert(location,"location");
  86 |     memset(location,0, sizeof(struct local));
  87 | 
  88 |     page_plane=ssd->parameter->page_block*ssd->parameter->block_plane;
  89 |     page_die=page_plane*ssd->parameter->plane_die;
  90 |     page_chip=page_die*ssd->parameter->die_chip;
  91 |     page_channel=page_chip*ssd->parameter->chip_channel[0];
  92 | 
  93 |     /*******************************************************************************
  94 |      *page_channel是一个channel中page的数目， ppn/page_channel就得到了在哪个channel中
  95 |      *用同样的办法可以得到chip，die，plane，block，page
  96 |      ********************************************************************************/
  97 |     location->channel = ppn/page_channel;
  98 |     location->chip = (ppn%page_channel)/page_chip;
  99 |     location->die = ((ppn%page_channel)%page_chip)/page_die;
 100 |     location->plane = (((ppn%page_channel)%page_chip)%page_die)/page_plane;
 101 |     location->block = ((((ppn%page_channel)%page_chip)%page_die)%page_plane)/ssd->parameter->page_block;
 102 |     location->page = (((((ppn%page_channel)%page_chip)%page_die)%page_plane)%ssd->parameter->page_block)%ssd->parameter->page_block;
 103 | 
 104 |     return location;
 105 | }
 106 | 
 107 | 
 108 | /*****************************************************************************
 109 |  *这个函数的功能是根据参数channel，chip，die，plane，block，page，找到该物理页号
 110 |  *函数的返回值就是这个物理页号
 111 |  ******************************************************************************/
 112 | unsigned int find_ppn(struct ssd_info * ssd,unsigned int channel,unsigned int chip,unsigned int die,unsigned int plane,unsigned int block,unsigned int page)
 113 | {
 114 |     unsigned int ppn=0;
 115 |     unsigned int i=0;
 116 |     int page_plane=0,page_die=0,page_chip=0;
 117 |     int page_channel[100];                  /*这个数组存放的是每个channel的page数目*/
 118 | 
 119 | #ifdef DEBUG
 120 |     printf("enter find_psn,channel:%d, chip:%d, die:%d, plane:%d, block:%d, page:%d\n",channel,chip,die,plane,block,page);
 121 | #endif
 122 | 
 123 |     /*********************************************
 124 |      *计算出plane，die，chip，channel中的page的数目
 125 |      **********************************************/
 126 |     page_plane=ssd->parameter->page_block*ssd->parameter->block_plane;
 127 |     page_die=page_plane*ssd->parameter->plane_die;
 128 |     page_chip=page_die*ssd->parameter->die_chip;
 129 |     while(i<ssd->parameter->channel_number)
 130 |     {
 131 |         page_channel[i]=ssd->parameter->chip_channel[i]*page_chip;
 132 |         i++;
 133 |     }
 134 | 
 135 |     /****************************************************************************
 136 |      *计算物理页号ppn，ppn是channel，chip，die，plane，block，page中page个数的总和
 137 |      *****************************************************************************/
 138 |     i=0;
 139 |     while(i<channel)
 140 |     {
 141 |         ppn=ppn+page_channel[i];
 142 |         i++;
 143 |     }
 144 |     ppn=ppn+page_chip*chip+page_die*die+page_plane*plane+block*ssd->parameter->page_block+page;
 145 | 
 146 |     return ppn;
 147 | }
 148 | 
 149 | /********************************
 150 |  *函数功能是获得一个读子请求的状态
 151 |  *********************************/
 152 | int set_entry_state(struct ssd_info *ssd,unsigned int lsn,unsigned int size)
 153 | {
 154 |     int temp,state,move;
 155 | 
 156 |     temp=~(0xffffffff<<size);
 157 |     move=lsn%ssd->parameter->subpage_page;
 158 |     state=temp<<move;
 159 | 
 160 |     return state;
 161 | }
 162 | 
 163 | /**************************************************
 164 |  *读请求预处理函数，当读请求所读得页里面没有数据时，
 165 |  *需要预处理网该页里面写数据，以保证能读到数据
 166 |  ***************************************************/
 167 | struct ssd_info *pre_process_page(struct ssd_info *ssd)
 168 | {
 169 |     int fl=0;
 170 |     unsigned int device,lsn,size,ope,lpn,full_page;
 171 |     unsigned int largest_lsn,sub_size,ppn,add_size=0;
 172 |     unsigned int i=0,j,k;
 173 |     int map_entry_new,map_entry_old,modify;
 174 |     int flag=0;
 175 |     char buffer_request[200];
 176 |     struct local *location;
 177 |     int64_t time;
 178 | 
 179 |     printf("\n");
 180 |     printf("begin pre_process_page.................\n");
 181 | 
 182 |     ssd->tracefile=fopen(ssd->tracefilename,"r");
 183 |     if(ssd->tracefile == NULL )      /*打开trace文件从中读取请求*/
 184 |     {
 185 |         printf("the trace file can't open\n");
 186 |         return NULL;
 187 |     }
 188 | 
 189 |     full_page=~(0xffffffff<<(ssd->parameter->subpage_page));
 190 |     /*计算出这个ssd的最大逻辑扇区号*/
 191 |     largest_lsn=(unsigned int )((ssd->parameter->chip_num*ssd->parameter->die_chip*ssd->parameter->plane_die*ssd->parameter->block_plane*ssd->parameter->page_block*ssd->parameter->subpage_page)*(1-ssd->parameter->overprovide));
 192 | 
 193 |     while(fgets(buffer_request,200,ssd->tracefile))
 194 |     {
 195 |         sscanf(buffer_request,"%lld %d %d %d %d",&time,&device,&lsn,&size,&ope);
 196 |         fl++;
 197 |         trace_assert(time,device,lsn,size,ope);                         /*断言，当读到的time，device，lsn，size，ope不合法时就会处理*/
 198 | 
 199 |         add_size=0;                                                     /*add_size是这个请求已经预处理的大小*/
 200 | 
 201 |         if(ope==1)                                                      /*这里只是读请求的预处理，需要提前将相应位置的信息进行相应修改*/
 202 |         {
 203 |             while(add_size<size)
 204 |             {				
 205 |                 lsn=lsn%largest_lsn;                                    /*防止获得的lsn比最大的lsn还大*/		
 206 |                 sub_size=ssd->parameter->subpage_page-(lsn%ssd->parameter->subpage_page);		
 207 |                 if(add_size+sub_size>=size)                             /*只有当一个请求的大小小于一个page的大小时或者是处理一个请求的最后一个page时会出现这种情况*/
 208 |                 {		
 209 |                     sub_size=size-add_size;		
 210 |                     add_size+=sub_size;		
 211 |                 }
 212 | 
 213 |                 if((sub_size>ssd->parameter->subpage_page)||(add_size>size))/*当预处理一个子大小时，这个大小大于一个page或是已经处理的大小大于size就报错*/		
 214 |                 {		
 215 |                     printf("pre_process sub_size:%d\n",sub_size);		
 216 |                 }
 217 | 
 218 |                 /*******************************************************************************************************
 219 |                  *利用逻辑扇区号lsn计算出逻辑页号lpn
 220 |                  *判断这个dram中映射表map中在lpn位置的状态
 221 |                  *A，这个状态==0，表示以前没有写过，现在需要直接将ub_size大小的子页写进去写进去
 222 |                  *B，这个状态>0，表示，以前有写过，这需要进一步比较状态，因为新写的状态可以与以前的状态有重叠的扇区的地方
 223 |                  ********************************************************************************************************/
 224 |                 lpn=lsn/ssd->parameter->subpage_page;
 225 |                 if(ssd->dram->map->map_entry[lpn].state==0)                 /*状态为0的情况*/
 226 |                 {
 227 |                     /**************************************************************
 228 |                      *获得利用get_ppn_for_pre_process函数获得ppn，再得到location
 229 |                      *修改ssd的相关参数，dram的映射表map，以及location下的page的状态
 230 |                      ***************************************************************/
 231 |                     ppn=get_ppn_for_pre_process(ssd,lsn);                  
 232 |                     location=find_location(ssd,ppn);
 233 |                     ssd->program_count++;	
 234 |                     ssd->channel_head[location->channel].program_count++;
 235 |                     ssd->channel_head[location->channel].chip_head[location->chip].program_count++;		
 236 |                     ssd->dram->map->map_entry[lpn].pn=ppn;	
 237 |                     ssd->dram->map->map_entry[lpn].state=set_entry_state(ssd,lsn,sub_size);   //0001
 238 |                     ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].page_head[location->page].lpn=lpn;
 239 |                     ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].page_head[location->page].valid_state=ssd->dram->map->map_entry[lpn].state;
 240 |                     ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].page_head[location->page].free_state=((~ssd->dram->map->map_entry[lpn].state)&full_page);
 241 | 
 242 |                     free(location);
 243 |                     location=NULL;
 244 |                 }//if(ssd->dram->map->map_entry[lpn].state==0)
 245 |                 else if(ssd->dram->map->map_entry[lpn].state>0)           /*状态不为0的情况*/
 246 |                 {
 247 |                     map_entry_new=set_entry_state(ssd,lsn,sub_size);      /*得到新的状态，并与原来的状态相或的到一个状态*/
 248 |                     map_entry_old=ssd->dram->map->map_entry[lpn].state;
 249 |                     modify=map_entry_new|map_entry_old;
 250 |                     ppn=ssd->dram->map->map_entry[lpn].pn;
 251 |                     location=find_location(ssd,ppn);
 252 | 
 253 |                     ssd->program_count++;	
 254 |                     ssd->channel_head[location->channel].program_count++;
 255 |                     ssd->channel_head[location->channel].chip_head[location->chip].program_count++;		
 256 |                     ssd->dram->map->map_entry[lsn/ssd->parameter->subpage_page].state=modify; 
 257 |                     ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].page_head[location->page].valid_state=modify;
 258 |                     ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].page_head[location->page].free_state=((~modify)&full_page);
 259 | 
 260 |                     free(location);
 261 |                     location=NULL;
 262 |                 }//else if(ssd->dram->map->map_entry[lpn].state>0)
 263 |                 lsn=lsn+sub_size;                                         /*下个子请求的起始位置*/
 264 |                 add_size+=sub_size;                                       /*已经处理了的add_size大小变化*/
 265 |             }//while(add_size<size)
 266 |         }//if(ope==1) 
 267 |     }	
 268 | 
 269 |     printf("\n");
 270 |     printf("pre_process is complete!\n");
 271 | 
 272 |     fclose(ssd->tracefile);
 273 | 
 274 |     for(i=0;i<ssd->parameter->channel_number;i++)
 275 |         for(j=0;j<ssd->parameter->die_chip;j++)
 276 |             for(k=0;k<ssd->parameter->plane_die;k++)
 277 |             {
 278 |                 fprintf(ssd->outputfile,"chip:%d,die:%d,plane:%d have free page: %d\n",i,j,k,ssd->channel_head[i].chip_head[0].die_head[j].plane_head[k].free_page);				
 279 |                 fflush(ssd->outputfile);
 280 |             }
 281 | 
 282 |     return ssd;
 283 | }
 284 | 
 285 | /**************************************
 286 |  *函数功能是为预处理函数获取物理页号ppn
 287 |  *获取页号分为动态获取和静态获取
 288 |  **************************************/
 289 | unsigned int get_ppn_for_pre_process(struct ssd_info *ssd,unsigned int lsn)     
 290 | {
 291 |     unsigned int channel=0,chip=0,die=0,plane=0; 
 292 |     unsigned int ppn,lpn;
 293 |     unsigned int active_block;
 294 |     unsigned int channel_num=0,chip_num=0,die_num=0,plane_num=0;
 295 | 
 296 | #ifdef DEBUG
 297 |     printf("enter get_psn_for_pre_process\n");
 298 | #endif
 299 | 
 300 |     channel_num=ssd->parameter->channel_number;
 301 |     chip_num=ssd->parameter->chip_channel[0];
 302 |     die_num=ssd->parameter->die_chip;
 303 |     plane_num=ssd->parameter->plane_die;
 304 |     lpn=lsn/ssd->parameter->subpage_page;
 305 | 
 306 |     if (ssd->parameter->allocation_scheme==0)                           /*动态方式下获取ppn*/
 307 |     {
 308 |         if (ssd->parameter->dynamic_allocation==0)                      /*表示全动态方式下，也就是channel，chip，die，plane，block等都是动态分配*/
 309 |         {
 310 |             channel=ssd->token;
 311 |             ssd->token=(ssd->token+1)%ssd->parameter->channel_number;
 312 |             chip=ssd->channel_head[channel].token;
 313 |             ssd->channel_head[channel].token=(chip+1)%ssd->parameter->chip_channel[0];
 314 |             die=ssd->channel_head[channel].chip_head[chip].token;
 315 |             ssd->channel_head[channel].chip_head[chip].token=(die+1)%ssd->parameter->die_chip;
 316 |             plane=ssd->channel_head[channel].chip_head[chip].die_head[die].token;
 317 |             ssd->channel_head[channel].chip_head[chip].die_head[die].token=(plane+1)%ssd->parameter->plane_die;
 318 |         } 
 319 |         else if (ssd->parameter->dynamic_allocation==1)                 /*表示半动态方式，channel静态给出，package，die，plane动态分配*/                 
 320 |         {
 321 |             channel=lpn%ssd->parameter->channel_number;
 322 |             chip=ssd->channel_head[channel].token;
 323 |             ssd->channel_head[channel].token=(chip+1)%ssd->parameter->chip_channel[0];
 324 |             die=ssd->channel_head[channel].chip_head[chip].token;
 325 |             ssd->channel_head[channel].chip_head[chip].token=(die+1)%ssd->parameter->die_chip;
 326 |             plane=ssd->channel_head[channel].chip_head[chip].die_head[die].token;
 327 |             ssd->channel_head[channel].chip_head[chip].die_head[die].token=(plane+1)%ssd->parameter->plane_die;
 328 |         }
 329 |     } 
 330 |     else if (ssd->parameter->allocation_scheme==1)                       /*表示静态分配，同时也有0,1,2,3,4,5这6中不同静态分配方式*/
 331 |     {
 332 |         switch (ssd->parameter->static_allocation)
 333 |         {
 334 | 
 335 |             case 0:         
 336 |                 {
 337 |                     channel=(lpn/(plane_num*die_num*chip_num))%channel_num;
 338 |                     chip=lpn%chip_num;
 339 |                     die=(lpn/chip_num)%die_num;
 340 |                     plane=(lpn/(die_num*chip_num))%plane_num;
 341 |                     break;
 342 |                 }
 343 |             case 1:
 344 |                 {
 345 |                     channel=lpn%channel_num;
 346 |                     chip=(lpn/channel_num)%chip_num;
 347 |                     die=(lpn/(chip_num*channel_num))%die_num;
 348 |                     plane=(lpn/(die_num*chip_num*channel_num))%plane_num;
 349 | 
 350 |                     break;
 351 |                 }
 352 |             case 2:
 353 |                 {
 354 |                     channel=lpn%channel_num;
 355 |                     chip=(lpn/(plane_num*channel_num))%chip_num;
 356 |                     die=(lpn/(plane_num*chip_num*channel_num))%die_num;
 357 |                     plane=(lpn/channel_num)%plane_num;
 358 |                     break;
 359 |                 }
 360 |             case 3:
 361 |                 {
 362 |                     channel=lpn%channel_num;
 363 |                     chip=(lpn/(die_num*channel_num))%chip_num;
 364 |                     die=(lpn/channel_num)%die_num;
 365 |                     plane=(lpn/(die_num*chip_num*channel_num))%plane_num;
 366 |                     break;
 367 |                 }
 368 |             case 4:  
 369 |                 {
 370 |                     channel=lpn%channel_num;
 371 |                     chip=(lpn/(plane_num*die_num*channel_num))%chip_num;
 372 |                     die=(lpn/(plane_num*channel_num))%die_num;
 373 |                     plane=(lpn/channel_num)%plane_num;
 374 | 
 375 |                     break;
 376 |                 }
 377 |             case 5:   
 378 |                 {
 379 |                     channel=lpn%channel_num;
 380 |                     chip=(lpn/(plane_num*die_num*channel_num))%chip_num;
 381 |                     die=(lpn/channel_num)%die_num;
 382 |                     plane=(lpn/(die_num*channel_num))%plane_num;
 383 | 
 384 |                     break;
 385 |                 }
 386 |             default : return 0;
 387 |         }
 388 |     }
 389 | 
 390 |     /******************************************************************************
 391 |      *根据上述分配方法找到channel，chip，die，plane后，再在这个里面找到active_block
 392 |      *接着获得ppn
 393 |      ******************************************************************************/
 394 |     if(find_active_block(ssd,channel,chip,die,plane)==FAILURE)
 395 |     {
 396 |         printf("the read operation is expand the capacity of SSD\n");	
 397 |         return 0;
 398 |     }
 399 |     active_block=ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].active_block;
 400 |     if(write_page(ssd,channel,chip,die,plane,active_block,&ppn)==ERROR)
 401 |     {
 402 |         return 0;
 403 |     }
 404 | 
 405 |     return ppn;
 406 | }
 407 | 
 408 | 
 409 | /***************************************************************************************************
 410 |  *函数功能是在所给的channel，chip，die，plane里面找到一个active_block然后再在这个block里面找到一个页，
 411 |  *再利用find_ppn找到ppn。
 412 |  ****************************************************************************************************/
 413 | struct ssd_info *get_ppn(struct ssd_info *ssd,unsigned int channel,unsigned int chip,unsigned int die,unsigned int plane,struct sub_request *sub)
 414 | {
 415 |     int old_ppn=-1;
 416 |     unsigned int ppn,lpn,full_page;
 417 |     unsigned int active_block;
 418 |     unsigned int block;
 419 |     unsigned int page,flag=0,flag1=0;
 420 |     unsigned int old_state=0,state=0,copy_subpage=0;
 421 |     struct local *location;
 422 |     struct direct_erase *direct_erase_node,*new_direct_erase;
 423 |     struct gc_operation *gc_node;
 424 | 
 425 |     unsigned int i=0,j=0,k=0,l=0,m=0,n=0;
 426 | 
 427 | #ifdef DEBUG
 428 |     printf("enter get_ppn,channel:%d, chip:%d, die:%d, plane:%d\n",channel,chip,die,plane);
 429 | #endif
 430 | 
 431 |     full_page=~(0xffffffff<<(ssd->parameter->subpage_page));
 432 |     lpn=sub->lpn;
 433 | 
 434 |     /*************************************************************************************
 435 |      *利用函数find_active_block在channel，chip，die，plane找到活跃block
 436 |      *并且修改这个channel，chip，die，plane，active_block下的last_write_page和free_page_num
 437 |      **************************************************************************************/
 438 |     if(find_active_block(ssd,channel,chip,die,plane)==FAILURE)                      
 439 |     {
 440 |         printf("ERROR :there is no free page in channel:%d, chip:%d, die:%d, plane:%d\n",channel,chip,die,plane);	
 441 |         return ssd;
 442 |     }
 443 | 
 444 |     active_block=ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].active_block;
 445 |     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].last_write_page++;	
 446 |     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].free_page_num--;
 447 | 
 448 |     if(ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].last_write_page>63)
 449 |     {
 450 |         printf("error! the last write page larger than 64!!\n");
 451 |         while(1){}
 452 |     }
 453 | 
 454 |     block=active_block;	
 455 |     page=ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].last_write_page;	
 456 | 
 457 |     if(ssd->dram->map->map_entry[lpn].state==0)                                       /*this is the first logical page*/
 458 |     {
 459 |         if(ssd->dram->map->map_entry[lpn].pn!=0)
 460 |         {
 461 |             printf("Error in get_ppn()\n");
 462 |         }
 463 |         ssd->dram->map->map_entry[lpn].pn=find_ppn(ssd,channel,chip,die,plane,block,page);
 464 |         ssd->dram->map->map_entry[lpn].state=sub->state;
 465 |     }
 466 |     else                                                                            /*这个逻辑页进行了更新，需要将原来的页置为失效*/
 467 |     {
 468 |         ppn=ssd->dram->map->map_entry[lpn].pn;
 469 |         location=find_location(ssd,ppn);
 470 |         if(	ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].page_head[location->page].lpn!=lpn)
 471 |         {
 472 |             printf("\nError in get_ppn()\n");
 473 |         }
 474 | 
 475 |         ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].page_head[location->page].valid_state=0;             /*表示某一页失效，同时标记valid和free状态都为0*/
 476 |         ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].page_head[location->page].free_state=0;              /*表示某一页失效，同时标记valid和free状态都为0*/
 477 |         ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].page_head[location->page].lpn=0;
 478 |         ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].invalid_page_num++;
 479 | 
 480 |         /*******************************************************************************************
 481 |          *该block中全是invalid的页，可以直接删除，就在创建一个可擦除的节点，挂在location下的plane下面
 482 |          ********************************************************************************************/
 483 |         if (ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].invalid_page_num==ssd->parameter->page_block)    
 484 |         {
 485 |             new_direct_erase=(struct direct_erase *)malloc(sizeof(struct direct_erase));
 486 |             alloc_assert(new_direct_erase,"new_direct_erase");
 487 |             memset(new_direct_erase,0, sizeof(struct direct_erase));
 488 | 
 489 |             new_direct_erase->block=location->block;
 490 |             new_direct_erase->next_node=NULL;
 491 |             direct_erase_node=ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].erase_node;
 492 |             if (direct_erase_node==NULL)
 493 |             {
 494 |                 ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].erase_node=new_direct_erase;
 495 |             } 
 496 |             else
 497 |             {
 498 |                 new_direct_erase->next_node=ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].erase_node;
 499 |                 ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].erase_node=new_direct_erase;
 500 |             }
 501 |         }
 502 | 
 503 |         free(location);
 504 |         location=NULL;
 505 |         ssd->dram->map->map_entry[lpn].pn=find_ppn(ssd,channel,chip,die,plane,block,page);
 506 |         ssd->dram->map->map_entry[lpn].state=(ssd->dram->map->map_entry[lpn].state|sub->state);
 507 |     }
 508 | 
 509 | 
 510 |     sub->ppn=ssd->dram->map->map_entry[lpn].pn;                                      /*修改sub子请求的ppn，location等变量*/
 511 |     sub->location->channel=channel;
 512 |     sub->location->chip=chip;
 513 |     sub->location->die=die;
 514 |     sub->location->plane=plane;
 515 |     sub->location->block=active_block;
 516 |     sub->location->page=page;
 517 | 
 518 |     ssd->program_count++;                                                           /*修改ssd的program_count,free_page等变量*/
 519 |     ssd->channel_head[channel].program_count++;
 520 |     ssd->channel_head[channel].chip_head[chip].program_count++;
 521 |     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].free_page--;
 522 |     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].page_head[page].lpn=lpn;	
 523 |     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].page_head[page].valid_state=sub->state;
 524 |     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].page_head[page].free_state=((~(sub->state))&full_page);
 525 |     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].page_head[page].written_count++;
 526 |     ssd->write_flash_count++;
 527 | 
 528 |     if (ssd->parameter->active_write==0)                                            /*如果没有主动策略，只采用gc_hard_threshold，并且无法中断GC过程*/
 529 |     {                                                                               /*如果plane中的free_page的数目少于gc_hard_threshold所设定的阈值就产生gc操作*/
 530 |         if (ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].free_page<(ssd->parameter->page_block*ssd->parameter->block_plane*ssd->parameter->gc_hard_threshold))
 531 |         {
 532 |             gc_node=(struct gc_operation *)malloc(sizeof(struct gc_operation));
 533 |             alloc_assert(gc_node,"gc_node");
 534 |             memset(gc_node,0, sizeof(struct gc_operation));
 535 | 
 536 |             gc_node->next_node=NULL;
 537 |             gc_node->chip=chip;
 538 |             gc_node->die=die;
 539 |             gc_node->plane=plane;
 540 |             gc_node->block=0xffffffff;
 541 |             gc_node->page=0;
 542 |             gc_node->state=GC_WAIT;
 543 |             gc_node->priority=GC_UNINTERRUPT;
 544 |             gc_node->next_node=ssd->channel_head[channel].gc_command;
 545 |             ssd->channel_head[channel].gc_command=gc_node;
 546 |             ssd->gc_request++;
 547 |         }
 548 |     } 
 549 | 
 550 |     return ssd;
 551 | }
 552 | /*****************************************************************************************
 553 |  *这个函数功能是为gc操作寻找新的ppn，因为在gc操作中需要找到新的物理块存放原来物理块上的数据
 554 |  *在gc中寻找新物理块的函数，不会引起循环的gc操作
 555 |  ******************************************************************************************/
 556 | unsigned int get_ppn_for_gc(struct ssd_info *ssd,unsigned int channel,unsigned int chip,unsigned int die,unsigned int plane)     
 557 | {
 558 |     unsigned int ppn;
 559 |     unsigned int active_block,block,page;
 560 | 
 561 | #ifdef DEBUG
 562 |     printf("enter get_ppn_for_gc,channel:%d, chip:%d, die:%d, plane:%d\n",channel,chip,die,plane);
 563 | #endif
 564 | 
 565 |     if(find_active_block(ssd,channel,chip,die,plane)!=SUCCESS)
 566 |     {
 567 |         printf("\n\n Error int get_ppn_for_gc().\n");
 568 |         return 0xffffffff;
 569 |     }
 570 | 
 571 |     active_block=ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].active_block;
 572 | 
 573 |     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].last_write_page++;	
 574 |     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].free_page_num--;
 575 | 
 576 |     if(ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].last_write_page>63)
 577 |     {
 578 |         printf("error! the last write page larger than 64!!\n");
 579 |         while(1){}
 580 |     }
 581 | 
 582 |     block=active_block;	
 583 |     page=ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].last_write_page;	
 584 | 
 585 |     ppn=find_ppn(ssd,channel,chip,die,plane,block,page);
 586 | 
 587 |     ssd->program_count++;
 588 |     ssd->channel_head[channel].program_count++;
 589 |     ssd->channel_head[channel].chip_head[chip].program_count++;
 590 |     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].free_page--;
 591 |     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].page_head[page].written_count++;
 592 |     ssd->write_flash_count++;
 593 | 
 594 |     return ppn;
 595 | 
 596 | }
 597 | 
 598 | /*********************************************************************************************************************
 599 |  * 朱志明 于2011年7月28日修改   
 600 |  *函数的功能就是erase_operation擦除操作，把channel，chip，die，plane下的block擦除掉
 601 |  *也就是初始化这个block的相关参数，eg：free_page_num=page_block，invalid_page_num=0，last_write_page=-1，erase_count++
 602 |  *还有这个block下面的每个page的相关参数也要修改。
 603 |  *********************************************************************************************************************/
 604 | 
 605 | Status erase_operation(struct ssd_info * ssd,unsigned int channel ,unsigned int chip ,unsigned int die ,unsigned int plane ,unsigned int block)
 606 | {
 607 |     unsigned int i=0;
 608 |     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[block].free_page_num=ssd->parameter->page_block;
 609 |     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[block].invalid_page_num=0;
 610 |     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[block].last_write_page=-1;
 611 |     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[block].erase_count++;
 612 |     for (i=0;i<ssd->parameter->page_block;i++)
 613 |     {
 614 |         ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[block].page_head[i].free_state=PG_SUB;
 615 |         ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[block].page_head[i].valid_state=0;
 616 |         ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[block].page_head[i].lpn=-1;
 617 |     }
 618 |     ssd->erase_count++;
 619 |     ssd->channel_head[channel].erase_count++;			
 620 |     ssd->channel_head[channel].chip_head[chip].erase_count++;
 621 |     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].free_page+=ssd->parameter->page_block;
 622 | 
 623 |     return SUCCESS;
 624 | 
 625 | }
 626 | 
 627 | 
 628 | /**************************************************************************************
 629 |  *这个函数的功能是处理INTERLEAVE_TWO_PLANE，INTERLEAVE，TWO_PLANE，NORMAL下的擦除的操作。
 630 |  ***************************************************************************************/
 631 | Status erase_planes(struct ssd_info * ssd, unsigned int channel, unsigned int chip, unsigned int die1, unsigned int plane1,unsigned int command)
 632 | {
 633 |     unsigned int die=0;
 634 |     unsigned int plane=0;
 635 |     unsigned int block=0;
 636 |     struct direct_erase *direct_erase_node=NULL;
 637 |     unsigned int block0=0xffffffff;
 638 |     unsigned int block1=0;
 639 | 
 640 |     if((ssd->channel_head[channel].chip_head[chip].die_head[die1].plane_head[plane1].erase_node==NULL)||               
 641 |             ((command!=INTERLEAVE_TWO_PLANE)&&(command!=INTERLEAVE)&&(command!=TWO_PLANE)&&(command!=NORMAL)))     /*如果没有擦除操作，或者command不对，返回错误*/           
 642 |     {
 643 |         return ERROR;
 644 |     }
 645 | 
 646 |     /************************************************************************************************************
 647 |      *处理擦除操作时，首先要传送擦除命令，这是channel，chip处于传送命令的状态，即CHANNEL_TRANSFER，CHIP_ERASE_BUSY
 648 |      *下一状态是CHANNEL_IDLE，CHIP_IDLE。
 649 |      *************************************************************************************************************/
 650 |     block1=ssd->channel_head[channel].chip_head[chip].die_head[die1].plane_head[plane1].erase_node->block;
 651 | 
 652 |     ssd->channel_head[channel].current_state=CHANNEL_TRANSFER;										
 653 |     ssd->channel_head[channel].current_time=ssd->current_time;										
 654 |     ssd->channel_head[channel].next_state=CHANNEL_IDLE;	
 655 | 
 656 |     ssd->channel_head[channel].chip_head[chip].current_state=CHIP_ERASE_BUSY;										
 657 |     ssd->channel_head[channel].chip_head[chip].current_time=ssd->current_time;									
 658 |     ssd->channel_head[channel].chip_head[chip].next_state=CHIP_IDLE;
 659 | 
 660 |     if(command==INTERLEAVE_TWO_PLANE)                                       /*高级命令INTERLEAVE_TWO_PLANE的处理*/
 661 |     {
 662 |         for(die=0;die<ssd->parameter->die_chip;die++)
 663 |         {
 664 |             block0=0xffffffff;
 665 |             if(die==die1)
 666 |             {
 667 |                 block0=block1;
 668 |             }
 669 |             for (plane=0;plane<ssd->parameter->plane_die;plane++)
 670 |             {
 671 |                 direct_erase_node=ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].erase_node;
 672 |                 if(direct_erase_node!=NULL)
 673 |                 {
 674 | 
 675 |                     block=direct_erase_node->block; 
 676 | 
 677 |                     if(block0==0xffffffff)
 678 |                     {
 679 |                         block0=block;
 680 |                     }
 681 |                     else
 682 |                     {
 683 |                         if(block!=block0)
 684 |                         {
 685 |                             continue;
 686 |                         }
 687 | 
 688 |                     }
 689 |                     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].erase_node=direct_erase_node->next_node;
 690 |                     erase_operation(ssd,channel,chip,die,plane,block);     /*真实的擦除操作的处理*/
 691 |                     free(direct_erase_node);                               
 692 |                     direct_erase_node=NULL;
 693 |                     ssd->direct_erase_count++;
 694 |                 }
 695 | 
 696 |             }
 697 |         }
 698 | 
 699 |         ssd->interleave_mplane_erase_count++;                             /*发送了一个interleave two plane erase命令,并计算这个处理的时间，以及下一个状态的时间*/
 700 |         ssd->channel_head[channel].next_state_predict_time=ssd->current_time+18*ssd->parameter->time_characteristics.tWC+ssd->parameter->time_characteristics.tWB;       
 701 |         ssd->channel_head[channel].chip_head[chip].next_state_predict_time=ssd->channel_head[channel].next_state_predict_time-9*ssd->parameter->time_characteristics.tWC+ssd->parameter->time_characteristics.tBERS;
 702 | 
 703 |     }
 704 |     else if(command==INTERLEAVE)                                          /*高级命令INTERLEAVE的处理*/
 705 |     {
 706 |         for(die=0;die<ssd->parameter->die_chip;die++)
 707 |         {
 708 |             for (plane=0;plane<ssd->parameter->plane_die;plane++)
 709 |             {
 710 |                 if(die==die1)
 711 |                 {
 712 |                     plane=plane1;
 713 |                 }
 714 |                 direct_erase_node=ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].erase_node;
 715 |                 if(direct_erase_node!=NULL)
 716 |                 {
 717 |                     block=direct_erase_node->block;
 718 |                     ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].erase_node=direct_erase_node->next_node;
 719 |                     erase_operation(ssd,channel,chip,die,plane,block);
 720 |                     free(direct_erase_node);
 721 |                     direct_erase_node=NULL;
 722 |                     ssd->direct_erase_count++;
 723 |                     break;
 724 |                 }	
 725 |             }
 726 |         }
 727 |         ssd->interleave_erase_count++;
 728 |         ssd->channel_head[channel].next_state_predict_time=ssd->current_time+14*ssd->parameter->time_characteristics.tWC;       
 729 |         ssd->channel_head[channel].chip_head[chip].next_state_predict_time=ssd->channel_head[channel].next_state_predict_time+ssd->parameter->time_characteristics.tBERS;
 730 |     }
 731 |     else if(command==TWO_PLANE)                                          /*高级命令TWO_PLANE的处理*/
 732 |     {
 733 | 
 734 |         for(plane=0;plane<ssd->parameter->plane_die;plane++)
 735 |         {
 736 |             direct_erase_node=ssd->channel_head[channel].chip_head[chip].die_head[die1].plane_head[plane].erase_node;
 737 |             if((direct_erase_node!=NULL))
 738 |             {
 739 |                 block=direct_erase_node->block;
 740 |                 if(block==block1)
 741 |                 {
 742 |                     ssd->channel_head[channel].chip_head[chip].die_head[die1].plane_head[plane].erase_node=direct_erase_node->next_node;
 743 |                     erase_operation(ssd,channel,chip,die1,plane,block);
 744 |                     free(direct_erase_node);
 745 |                     direct_erase_node=NULL;
 746 |                     ssd->direct_erase_count++;
 747 |                 }
 748 |             }
 749 |         }
 750 | 
 751 |         ssd->mplane_erase_conut++;
 752 |         ssd->channel_head[channel].next_state_predict_time=ssd->current_time+14*ssd->parameter->time_characteristics.tWC;      
 753 |         ssd->channel_head[channel].chip_head[chip].next_state_predict_time=ssd->channel_head[channel].next_state_predict_time+ssd->parameter->time_characteristics.tBERS;
 754 |     }
 755 |     else if(command==NORMAL)                                             /*普通命令NORMAL的处理*/
 756 |     {
 757 |         direct_erase_node=ssd->channel_head[channel].chip_head[chip].die_head[die1].plane_head[plane1].erase_node;
 758 |         block=direct_erase_node->block;
 759 |         ssd->channel_head[channel].chip_head[chip].die_head[die1].plane_head[plane1].erase_node=direct_erase_node->next_node;
 760 |         free(direct_erase_node);
 761 |         direct_erase_node=NULL;
 762 |         erase_operation(ssd,channel,chip,die1,plane1,block);
 763 | 
 764 |         ssd->direct_erase_count++;
 765 |         ssd->channel_head[channel].next_state_predict_time=ssd->current_time+5*ssd->parameter->time_characteristics.tWC;       								
 766 |         ssd->channel_head[channel].chip_head[chip].next_state_predict_time=ssd->channel_head[channel].next_state_predict_time+ssd->parameter->time_characteristics.tWB+ssd->parameter->time_characteristics.tBERS;	
 767 |     }
 768 |     else
 769 |     {
 770 |         return ERROR;
 771 |     }
 772 | 
 773 |     direct_erase_node=ssd->channel_head[channel].chip_head[chip].die_head[die1].plane_head[plane1].erase_node;
 774 | 
 775 |     if(((direct_erase_node)!=NULL)&&(direct_erase_node->block==block1))
 776 |     {
 777 |         return FAILURE; 
 778 |     }
 779 |     else
 780 |     {
 781 |         return SUCCESS;
 782 |     }
 783 | }
 784 | 
 785 | 
 786 | /*******************************************************************************************************************
 787 |  *GC操作由某个plane的free块少于阈值进行触发，当某个plane被触发时，GC操作占据这个plane所在的die，因为die是一个独立单元。
 788 |  *对一个die的GC操作，尽量做到四个plane同时erase，利用interleave erase操作。GC操作应该做到可以随时停止（移动数据和擦除
 789 |  *时不行，但是间隙时间可以停止GC操作），以服务新到达的请求，当请求服务完后，利用请求间隙时间，继续GC操作。可以设置两个
 790 |  *GC阈值，一个软阈值，一个硬阈值。软阈值表示到达该阈值后，可以开始主动的GC操作，利用间歇时间，GC可以被新到的请求中断；
 791 |  *当到达硬阈值后，强制性执行GC操作，且此GC操作不能被中断，直到回到硬阈值以上。
 792 |  *在这个函数里面，找出这个die所有的plane中，有没有可以直接删除的block，要是有的话，利用interleave two plane命令，删除
 793 |  *这些block，否则有多少plane有这种直接删除的block就同时删除，不行的话，最差就是单独这个plane进行删除，连这也不满足的话，
 794 |  *直接跳出，到gc_parallelism函数进行进一步GC操作。该函数寻找全部为invalid的块，直接删除，找到可直接删除的返回1，没有找
 795 |  *到返回-1。
 796 |  *********************************************************************************************************************/
 797 | int gc_direct_erase(struct ssd_info *ssd,unsigned int channel,unsigned int chip,unsigned int die,unsigned int plane)     
 798 | {
 799 |     unsigned int lv_die=0,lv_plane=0;                                                           /*为避免重名而使用的局部变量 Local variables*/
 800 |     unsigned int interleaver_flag=FALSE,muilt_plane_flag=FALSE;
 801 |     unsigned int normal_erase_flag=TRUE;
 802 | 
 803 |     struct direct_erase * direct_erase_node1=NULL;
 804 |     struct direct_erase * direct_erase_node2=NULL;
 805 | 
 806 |     direct_erase_node1=ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].erase_node;
 807 |     if (direct_erase_node1==NULL)
 808 |     {
 809 |         return FAILURE;
 810 |     }
 811 | 
 812 |     /********************************************************************************************************
 813 |      *当能处理TWOPLANE高级命令时，就在相应的channel，chip，die中两个不同的plane找到可以执行TWOPLANE操作的block
 814 |      *并置muilt_plane_flag为TRUE
 815 |      *********************************************************************************************************/
 816 |     if((ssd->parameter->advanced_commands&AD_TWOPLANE)==AD_TWOPLANE)
 817 |     {	
 818 |         for(lv_plane=0;lv_plane<ssd->parameter->plane_die;lv_plane++)
 819 |         {
 820 |             direct_erase_node2=ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].erase_node;
 821 |             if((lv_plane!=plane)&&(direct_erase_node2!=NULL))
 822 |             {
 823 |                 if((direct_erase_node1->block)==(direct_erase_node2->block))
 824 |                 {
 825 |                     muilt_plane_flag=TRUE;
 826 |                     break;
 827 |                 }
 828 |             }
 829 |         }
 830 |     }
 831 | 
 832 |     /***************************************************************************************
 833 |      *当能处理INTERLEAVE高级命令时，就在相应的channel，chip找到可以执行INTERLEAVE的两个block
 834 |      *并置interleaver_flag为TRUE
 835 |      ****************************************************************************************/
 836 |     if((ssd->parameter->advanced_commands&AD_INTERLEAVE)==AD_INTERLEAVE)
 837 |     {
 838 |         for(lv_die=0;lv_die<ssd->parameter->die_chip;lv_die++)
 839 |         {
 840 |             if(lv_die!=die)
 841 |             {
 842 |                 for(lv_plane=0;lv_plane<ssd->parameter->plane_die;lv_plane++)
 843 |                 {
 844 |                     if(ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].erase_node!=NULL)
 845 |                     {
 846 |                         interleaver_flag=TRUE;
 847 |                         break;
 848 |                     }
 849 |                 }
 850 |             }
 851 |             if(interleaver_flag==TRUE)
 852 |             {
 853 |                 break;
 854 |             }
 855 |         }
 856 |     }
 857 | 
 858 |     /************************************************************************************************************************
 859 |      *A，如果既可以执行twoplane的两个block又有可以执行interleaver的两个block，那么就执行INTERLEAVE_TWO_PLANE的高级命令擦除操作
 860 |      *B，如果只有能执行interleaver的两个block，那么就执行INTERLEAVE高级命令的擦除操作
 861 |      *C，如果只有能执行TWO_PLANE的两个block，那么就执行TWO_PLANE高级命令的擦除操作
 862 |      *D，没有上述这些情况，那么就只能够执行普通的擦除操作了
 863 |      *************************************************************************************************************************/
 864 |     if ((muilt_plane_flag==TRUE)&&(interleaver_flag==TRUE)&&((ssd->parameter->advanced_commands&AD_TWOPLANE)==AD_TWOPLANE)&&((ssd->parameter->advanced_commands&AD_INTERLEAVE)==AD_INTERLEAVE))     
 865 |     {
 866 |         if(erase_planes(ssd,channel,chip,die,plane,INTERLEAVE_TWO_PLANE)==SUCCESS)
 867 |         {
 868 |             return SUCCESS;
 869 |         }
 870 |     } 
 871 |     else if ((interleaver_flag==TRUE)&&((ssd->parameter->advanced_commands&AD_INTERLEAVE)==AD_INTERLEAVE))
 872 |     {
 873 |         if(erase_planes(ssd,channel,chip,die,plane,INTERLEAVE)==SUCCESS)
 874 |         {
 875 |             return SUCCESS;
 876 |         }
 877 |     }
 878 |     else if ((muilt_plane_flag==TRUE)&&((ssd->parameter->advanced_commands&AD_TWOPLANE)==AD_TWOPLANE))
 879 |     {
 880 |         if(erase_planes(ssd,channel,chip,die,plane,TWO_PLANE)==SUCCESS)
 881 |         {
 882 |             return SUCCESS;
 883 |         }
 884 |     }
 885 | 
 886 |     if ((normal_erase_flag==TRUE))                              /*不是每个plane都有可以直接删除的block，只对当前plane进行普通的erase操作，或者只能执行普通命令*/
 887 |     {
 888 |         if (erase_planes(ssd,channel,chip,die,plane,NORMAL)==SUCCESS)
 889 |         {
 890 |             return SUCCESS;
 891 |         } 
 892 |         else
 893 |         {
 894 |             return FAILURE;                                     /*目标的plane没有可以直接删除的block，需要寻找目标擦除块后在实施擦除操作*/
 895 |         }
 896 |     }
 897 |     return SUCCESS;
 898 | }
 899 | 
 900 | 
 901 | Status move_page(struct ssd_info * ssd, struct local *location, unsigned int * transfer_size)
 902 | {
 903 |     struct local *new_location=NULL;
 904 |     unsigned int free_state=0,valid_state=0;
 905 |     unsigned int lpn=0,old_ppn=0,ppn=0;
 906 | 
 907 |     lpn=ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].page_head[location->page].lpn;
 908 |     valid_state=ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].page_head[location->page].valid_state;
 909 |     free_state=ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].page_head[location->page].free_state;
 910 |     old_ppn=find_ppn(ssd,location->channel,location->chip,location->die,location->plane,location->block,location->page);      /*记录这个有效移动页的ppn，对比map或者额外映射关系中的ppn，进行删除和添加操作*/
 911 |     ppn=get_ppn_for_gc(ssd,location->channel,location->chip,location->die,location->plane);                /*找出来的ppn一定是在发生gc操作的plane中,才能使用copyback操作，为gc操作获取ppn*/
 912 | 
 913 |     new_location=find_location(ssd,ppn);                                                                   /*根据新获得的ppn获取new_location*/
 914 | 
 915 |     if ((ssd->parameter->advanced_commands&AD_COPYBACK)==AD_COPYBACK)
 916 |     {
 917 |         if (ssd->parameter->greed_CB_ad==1)                                                                /*贪婪地使用高级命令*/
 918 |         {
 919 |             ssd->copy_back_count++;
 920 |             ssd->gc_copy_back++;
 921 |             while (old_ppn%2!=ppn%2)
 922 |             {
 923 |                 ssd->channel_head[new_location->channel].chip_head[new_location->chip].die_head[new_location->die].plane_head[new_location->plane].blk_head[new_location->block].page_head[new_location->page].free_state=0;
 924 |                 ssd->channel_head[new_location->channel].chip_head[new_location->chip].die_head[new_location->die].plane_head[new_location->plane].blk_head[new_location->block].page_head[new_location->page].lpn=0;
 925 |                 ssd->channel_head[new_location->channel].chip_head[new_location->chip].die_head[new_location->die].plane_head[new_location->plane].blk_head[new_location->block].page_head[new_location->page].valid_state=0;
 926 |                 ssd->channel_head[new_location->channel].chip_head[new_location->chip].die_head[new_location->die].plane_head[new_location->plane].blk_head[new_location->block].invalid_page_num++;
 927 | 
 928 |                 free(new_location);
 929 |                 new_location=NULL;
 930 | 
 931 |                 ppn=get_ppn_for_gc(ssd,location->channel,location->chip,location->die,location->plane);    /*找出来的ppn一定是在发生gc操作的plane中，并且满足奇偶地址限制,才能使用copyback操作*/
 932 |                 ssd->program_count--;
 933 |                 ssd->write_flash_count--;
 934 |                 ssd->waste_page_count++;
 935 |             }
 936 |             if(new_location==NULL)
 937 |             {
 938 |                 new_location=find_location(ssd,ppn);
 939 |             }
 940 | 
 941 |             ssd->channel_head[new_location->channel].chip_head[new_location->chip].die_head[new_location->die].plane_head[new_location->plane].blk_head[new_location->block].page_head[new_location->page].free_state=free_state;
 942 |             ssd->channel_head[new_location->channel].chip_head[new_location->chip].die_head[new_location->die].plane_head[new_location->plane].blk_head[new_location->block].page_head[new_location->page].lpn=lpn;
 943 |             ssd->channel_head[new_location->channel].chip_head[new_location->chip].die_head[new_location->die].plane_head[new_location->plane].blk_head[new_location->block].page_head[new_location->page].valid_state=valid_state;
 944 |         } 
 945 |         else
 946 |         {
 947 |             if (old_ppn%2!=ppn%2)
 948 |             {
 949 |                 (* transfer_size)+=size(valid_state);
 950 |             }
 951 |             else
 952 |             {
 953 | 
 954 |                 ssd->copy_back_count++;
 955 |                 ssd->gc_copy_back++;
 956 |             }
 957 |         }	
 958 |     } 
 959 |     else
 960 |     {
 961 |         (* transfer_size)+=size(valid_state);
 962 |     }
 963 |     ssd->channel_head[new_location->channel].chip_head[new_location->chip].die_head[new_location->die].plane_head[new_location->plane].blk_head[new_location->block].page_head[new_location->page].free_state=free_state;
 964 |     ssd->channel_head[new_location->channel].chip_head[new_location->chip].die_head[new_location->die].plane_head[new_location->plane].blk_head[new_location->block].page_head[new_location->page].lpn=lpn;
 965 |     ssd->channel_head[new_location->channel].chip_head[new_location->chip].die_head[new_location->die].plane_head[new_location->plane].blk_head[new_location->block].page_head[new_location->page].valid_state=valid_state;
 966 | 
 967 | 
 968 |     ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].page_head[location->page].free_state=0;
 969 |     ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].page_head[location->page].lpn=0;
 970 |     ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].page_head[location->page].valid_state=0;
 971 |     ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].invalid_page_num++;
 972 | 
 973 |     if (old_ppn==ssd->dram->map->map_entry[lpn].pn)                                                     /*修改映射表*/
 974 |     {
 975 |         ssd->dram->map->map_entry[lpn].pn=ppn;
 976 |     }
 977 | 
 978 |     free(new_location);
 979 |     new_location=NULL;
 980 | 
 981 |     return SUCCESS;
 982 | }
 983 | 
 984 | /*******************************************************************************************************************************************
 985 |  *目标的plane没有可以直接删除的block，需要寻找目标擦除块后在实施擦除操作，用在不能中断的gc操作中，成功删除一个块，返回1，没有删除一个块返回-1
 986 |  *在这个函数中，不用考虑目标channel,die是否是空闲的,擦除invalid_page_num最多的block
 987 |  ********************************************************************************************************************************************/
 988 | int uninterrupt_gc(struct ssd_info *ssd,unsigned int channel,unsigned int chip,unsigned int die,unsigned int plane)       
 989 | {
 990 |     unsigned int i=0,invalid_page=0;
 991 |     unsigned int block,active_block,transfer_size,free_page,page_move_count=0;                           /*记录失效页最多的块号*/
 992 |     struct local *  location=NULL;
 993 |     unsigned int total_invalid_page_num=0;
 994 | 
 995 |     if(find_active_block(ssd,channel,chip,die,plane)!=SUCCESS)                                           /*获取活跃块*/
 996 |     {
 997 |         printf("\n\n Error in uninterrupt_gc().\n");
 998 |         return ERROR;
 999 |     }
1000 |     active_block=ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].active_block;
1001 | 
1002 |     invalid_page=0;
1003 |     transfer_size=0;
1004 |     block=-1;
1005 |     for(i=0;i<ssd->parameter->block_plane;i++)                                                           /*查找最多invalid_page的块号，以及最大的invalid_page_num*/
1006 |     {	
1007 |         total_invalid_page_num+=ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[i].invalid_page_num;
1008 |         if((active_block!=i)&&(ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[i].invalid_page_num>invalid_page))						
1009 |         {				
1010 |             invalid_page=ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[i].invalid_page_num;
1011 |             block=i;						
1012 |         }
1013 |     }
1014 |     if (block==-1)
1015 |     {
1016 |         return 1;
1017 |     }
1018 | 
1019 |     //if(invalid_page<5)
1020 |     //{
1021 |     //printf("\ntoo less invalid page. \t %d\t %d\t%d\t%d\t%d\t%d\t\n",invalid_page,channel,chip,die,plane,block);
1022 |     //}
1023 | 
1024 |     free_page=0;
1025 |     for(i=0;i<ssd->parameter->page_block;i++)		                                                     /*逐个检查每个page，如果有有效数据的page需要移动到其他地方存储*/		
1026 |     {		
1027 |         if ((ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[block].page_head[i].free_state&PG_SUB)==0x0000000f)
1028 |         {
1029 |             free_page++;
1030 |         }
1031 |         if(free_page!=0)
1032 |         {
1033 |             printf("\ntoo much free page. \t %d\t .%d\t%d\t%d\t%d\t\n",free_page,channel,chip,die,plane);
1034 |         }
1035 |         if(ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[block].page_head[i].valid_state>0) /*该页是有效页，需要copyback操作*/		
1036 |         {	
1037 |             location=(struct local * )malloc(sizeof(struct local ));
1038 |             alloc_assert(location,"location");
1039 |             memset(location,0, sizeof(struct local));
1040 | 
1041 |             location->channel=channel;
1042 |             location->chip=chip;
1043 |             location->die=die;
1044 |             location->plane=plane;
1045 |             location->block=block;
1046 |             location->page=i;
1047 |             move_page( ssd, location, &transfer_size);                                                   /*真实的move_page操作*/
1048 |             page_move_count++;
1049 | 
1050 |             free(location);	
1051 |             location=NULL;
1052 |         }				
1053 |     }
1054 |     erase_operation(ssd,channel ,chip , die,plane ,block);	                                              /*执行完move_page操作后，就立即执行block的擦除操作*/
1055 | 
1056 |     ssd->channel_head[channel].current_state=CHANNEL_GC;									
1057 |     ssd->channel_head[channel].current_time=ssd->current_time;										
1058 |     ssd->channel_head[channel].next_state=CHANNEL_IDLE;	
1059 |     ssd->channel_head[channel].chip_head[chip].current_state=CHIP_ERASE_BUSY;								
1060 |     ssd->channel_head[channel].chip_head[chip].current_time=ssd->current_time;						
1061 |     ssd->channel_head[channel].chip_head[chip].next_state=CHIP_IDLE;			
1062 | 
1063 |     /***************************************************************
1064 |      *在可执行COPYBACK高级命令与不可执行COPYBACK高级命令这两种情况下，
1065 |      *channel下个状态时间的计算，以及chip下个状态时间的计算
1066 |      ***************************************************************/
1067 |     if ((ssd->parameter->advanced_commands&AD_COPYBACK)==AD_COPYBACK)
1068 |     {
1069 |         if (ssd->parameter->greed_CB_ad==1)
1070 |         {
1071 | 
1072 |             ssd->channel_head[channel].next_state_predict_time=ssd->current_time+page_move_count*(7*ssd->parameter->time_characteristics.tWC+ssd->parameter->time_characteristics.tR+7*ssd->parameter->time_characteristics.tWC+ssd->parameter->time_characteristics.tPROG);			
1073 |             ssd->channel_head[channel].chip_head[chip].next_state_predict_time=ssd->channel_head[channel].next_state_predict_time+ssd->parameter->time_characteristics.tBERS;
1074 |         } 
1075 |     } 
1076 |     else
1077 |     {
1078 | 
1079 |         ssd->channel_head[channel].next_state_predict_time=ssd->current_time+page_move_count*(7*ssd->parameter->time_characteristics.tWC+ssd->parameter->time_characteristics.tR+7*ssd->parameter->time_characteristics.tWC+ssd->parameter->time_characteristics.tPROG)+transfer_size*SECTOR*(ssd->parameter->time_characteristics.tWC+ssd->parameter->time_characteristics.tRC);					
1080 |         ssd->channel_head[channel].chip_head[chip].next_state_predict_time=ssd->channel_head[channel].next_state_predict_time+ssd->parameter->time_characteristics.tBERS;
1081 | 
1082 |     }
1083 | 
1084 |     return 1;
1085 | }
1086 | 
1087 | 
1088 | /*******************************************************************************************************************************************
1089 |  *目标的plane没有可以直接删除的block，需要寻找目标擦除块后在实施擦除操作，用在可以中断的gc操作中，成功删除一个块，返回1，没有删除一个块返回-1
1090 |  *在这个函数中，不用考虑目标channel,die是否是空闲的
1091 |  ********************************************************************************************************************************************/
1092 | int interrupt_gc(struct ssd_info *ssd,unsigned int channel,unsigned int chip,unsigned int die,unsigned int plane,struct gc_operation *gc_node)        
1093 | {
1094 |     unsigned int i,block,active_block,transfer_size,invalid_page=0;
1095 |     struct local *location;
1096 | 
1097 |     active_block=ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].active_block;
1098 |     transfer_size=0;
1099 |     if (gc_node->block>=ssd->parameter->block_plane)
1100 |     {
1101 |         for(i=0;i<ssd->parameter->block_plane;i++)
1102 |         {			
1103 |             if((active_block!=i)&&(ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[i].invalid_page_num>invalid_page))						
1104 |             {				
1105 |                 invalid_page=ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[i].invalid_page_num;
1106 |                 block=i;						
1107 |             }
1108 |         }
1109 |         gc_node->block=block;
1110 |     }
1111 | 
1112 |     if (ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[gc_node->block].invalid_page_num!=ssd->parameter->page_block)     /*还需要执行copyback操作*/
1113 |     {
1114 |         for (i=gc_node->page;i<ssd->parameter->page_block;i++)
1115 |         {
1116 |             if (ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[gc_node->block].page_head[i].valid_state>0)
1117 |             {
1118 |                 location=(struct local * )malloc(sizeof(struct local ));
1119 |                 alloc_assert(location,"location");
1120 |                 memset(location,0, sizeof(struct local));
1121 | 
1122 |                 location->channel=channel;
1123 |                 location->chip=chip;
1124 |                 location->die=die;
1125 |                 location->plane=plane;
1126 |                 location->block=block;
1127 |                 location->page=i;
1128 |                 transfer_size=0;
1129 | 
1130 |                 move_page( ssd, location, &transfer_size);
1131 | 
1132 |                 free(location);
1133 |                 location=NULL;
1134 | 
1135 |                 gc_node->page=i+1;
1136 |                 ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[gc_node->block].invalid_page_num++;
1137 |                 ssd->channel_head[channel].current_state=CHANNEL_C_A_TRANSFER;									
1138 |                 ssd->channel_head[channel].current_time=ssd->current_time;										
1139 |                 ssd->channel_head[channel].next_state=CHANNEL_IDLE;	
1140 |                 ssd->channel_head[channel].chip_head[chip].current_state=CHIP_COPYBACK_BUSY;								
1141 |                 ssd->channel_head[channel].chip_head[chip].current_time=ssd->current_time;						
1142 |                 ssd->channel_head[channel].chip_head[chip].next_state=CHIP_IDLE;		
1143 | 
1144 |                 if ((ssd->parameter->advanced_commands&AD_COPYBACK)==AD_COPYBACK)
1145 |                 {					
1146 |                     ssd->channel_head[channel].next_state_predict_time=ssd->current_time+7*ssd->parameter->time_characteristics.tWC+ssd->parameter->time_characteristics.tR+7*ssd->parameter->time_characteristics.tWC;		
1147 |                     ssd->channel_head[channel].chip_head[chip].next_state_predict_time=ssd->channel_head[channel].next_state_predict_time+ssd->parameter->time_characteristics.tPROG;
1148 |                 } 
1149 |                 else
1150 |                 {	
1151 |                     ssd->channel_head[channel].next_state_predict_time=ssd->current_time+(7+transfer_size*SECTOR)*ssd->parameter->time_characteristics.tWC+ssd->parameter->time_characteristics.tR+(7+transfer_size*SECTOR)*ssd->parameter->time_characteristics.tWC;					
1152 |                     ssd->channel_head[channel].chip_head[chip].next_state_predict_time=ssd->channel_head[channel].next_state_predict_time+ssd->parameter->time_characteristics.tPROG;
1153 |                 }
1154 |                 return 0;    
1155 |             }
1156 |         }
1157 |     }
1158 |     else
1159 |     {
1160 |         erase_operation(ssd,channel ,chip, die,plane,gc_node->block);	
1161 | 
1162 |         ssd->channel_head[channel].current_state=CHANNEL_C_A_TRANSFER;									
1163 |         ssd->channel_head[channel].current_time=ssd->current_time;										
1164 |         ssd->channel_head[channel].next_state=CHANNEL_IDLE;								
1165 |         ssd->channel_head[channel].next_state_predict_time=ssd->current_time+5*ssd->parameter->time_characteristics.tWC;
1166 | 
1167 |         ssd->channel_head[channel].chip_head[chip].current_state=CHIP_ERASE_BUSY;								
1168 |         ssd->channel_head[channel].chip_head[chip].current_time=ssd->current_time;						
1169 |         ssd->channel_head[channel].chip_head[chip].next_state=CHIP_IDLE;							
1170 |         ssd->channel_head[channel].chip_head[chip].next_state_predict_time=ssd->channel_head[channel].next_state_predict_time+ssd->parameter->time_characteristics.tBERS;
1171 | 
1172 |         return 1;                                                                      /*该gc操作完成，返回1，可以将channel上的gc请求节点删除*/
1173 |     }
1174 | 
1175 |     printf("there is a problem in interrupt_gc\n");
1176 |     return 1;
1177 | }
1178 | 
1179 | /*************************************************************
1180 |  *函数的功能是当处理完一个gc操作时，需要把gc链上的gc_node删除掉
1181 |  **************************************************************/
1182 | int delete_gc_node(struct ssd_info *ssd, unsigned int channel,struct gc_operation *gc_node)
1183 | {
1184 |     struct gc_operation *gc_pre=NULL;
1185 |     if(gc_node==NULL)                                                                  
1186 |     {
1187 |         return ERROR;
1188 |     }
1189 | 
1190 |     if (gc_node==ssd->channel_head[channel].gc_command)
1191 |     {
1192 |         ssd->channel_head[channel].gc_command=gc_node->next_node;
1193 |     }
1194 |     else
1195 |     {
1196 |         gc_pre=ssd->channel_head[channel].gc_command;
1197 |         while (gc_pre->next_node!=NULL)
1198 |         {
1199 |             if (gc_pre->next_node==gc_node)
1200 |             {
1201 |                 gc_pre->next_node=gc_node->next_node;
1202 |                 break;
1203 |             }
1204 |             gc_pre=gc_pre->next_node;
1205 |         }
1206 |     }
1207 |     free(gc_node);
1208 |     gc_node=NULL;
1209 |     ssd->gc_request--;
1210 |     return SUCCESS;
1211 | }
1212 | 
1213 | /***************************************
1214 |  *这个函数的功能是处理channel的每个gc操作
1215 |  ****************************************/
1216 | Status gc_for_channel(struct ssd_info *ssd, unsigned int channel)
1217 | {
1218 |     int flag_direct_erase=1,flag_gc=1,flag_invoke_gc=1;
1219 |     unsigned int chip,die,plane,flag_priority=0;
1220 |     unsigned int current_state=0, next_state=0;
1221 |     long long next_state_predict_time=0;
1222 |     struct gc_operation *gc_node=NULL,*gc_p=NULL;
1223 | 
1224 |     /*******************************************************************************************
1225 |      *查找每一个gc_node，获取gc_node所在的chip的当前状态，下个状态，下个状态的预计时间
1226 |      *如果当前状态是空闲，或是下个状态是空闲而下个状态的预计时间小于当前时间，并且是不可中断的gc
1227 |      *那么就flag_priority令为1，否则为0
1228 |      ********************************************************************************************/
1229 |     gc_node=ssd->channel_head[channel].gc_command;
1230 |     while (gc_node!=NULL)
1231 |     {
1232 |         current_state=ssd->channel_head[channel].chip_head[gc_node->chip].current_state;
1233 |         next_state=ssd->channel_head[channel].chip_head[gc_node->chip].next_state;
1234 |         next_state_predict_time=ssd->channel_head[channel].chip_head[gc_node->chip].next_state_predict_time;
1235 |         if((current_state==CHIP_IDLE)||((next_state==CHIP_IDLE)&&(next_state_predict_time<=ssd->current_time)))
1236 |         {
1237 |             if (gc_node->priority==GC_UNINTERRUPT)                                     /*这个gc请求是不可中断的，优先服务这个gc操作*/
1238 |             {
1239 |                 flag_priority=1;
1240 |                 break;
1241 |             }
1242 |         }
1243 |         gc_node=gc_node->next_node;
1244 |     }
1245 |     if (flag_priority!=1)                                                              /*没有找到不可中断的gc请求，首先执行队首的gc请求*/
1246 |     {
1247 |         gc_node=ssd->channel_head[channel].gc_command;
1248 |         while (gc_node!=NULL)
1249 |         {
1250 |             current_state=ssd->channel_head[channel].chip_head[gc_node->chip].current_state;
1251 |             next_state=ssd->channel_head[channel].chip_head[gc_node->chip].next_state;
1252 |             next_state_predict_time=ssd->channel_head[channel].chip_head[gc_node->chip].next_state_predict_time;
1253 |             /**********************************************
1254 |              *需要gc操作的目标chip是空闲的，才可以进行gc操作
1255 |              ***********************************************/
1256 |             if((current_state==CHIP_IDLE)||((next_state==CHIP_IDLE)&&(next_state_predict_time<=ssd->current_time)))   
1257 |             {
1258 |                 break;
1259 |             }
1260 |             gc_node=gc_node->next_node;
1261 |         }
1262 | 
1263 |     }
1264 |     if(gc_node==NULL)
1265 |     {
1266 |         return FAILURE;
1267 |     }
1268 | 
1269 |     chip=gc_node->chip;
1270 |     die=gc_node->die;
1271 |     plane=gc_node->plane;
1272 | 
1273 |     if (gc_node->priority==GC_UNINTERRUPT)
1274 |     {
1275 |         flag_direct_erase=gc_direct_erase(ssd,channel,chip,die,plane);
1276 |         if (flag_direct_erase!=SUCCESS)
1277 |         {
1278 |             flag_gc=uninterrupt_gc(ssd,channel,chip,die,plane);                         /*当一个完整的gc操作完成时（已经擦除一个块，回收了一定数量的flash空间），返回1，将channel上相应的gc操作请求节点删除*/
1279 |             if (flag_gc==1)
1280 |             {
1281 |                 delete_gc_node(ssd,channel,gc_node);
1282 |             }
1283 |         }
1284 |         else
1285 |         {
1286 |             delete_gc_node(ssd,channel,gc_node);
1287 |         }
1288 |         return SUCCESS;
1289 |     }
1290 |     /*******************************************************************************
1291 |      *可中断的gc请求，需要首先确认该channel上没有子请求在这个时刻需要使用这个channel，
1292 |      *没有的话，在执行gc操作，有的话，不执行gc操作
1293 |      ********************************************************************************/
1294 |     else        
1295 |     {
1296 |         flag_invoke_gc=decide_gc_invoke(ssd,channel);                                  /*判断是否有子请求需要channel，如果有子请求需要这个channel，那么这个gc操作就被中断了*/
1297 | 
1298 |         if (flag_invoke_gc==1)
1299 |         {
1300 |             flag_direct_erase=gc_direct_erase(ssd,channel,chip,die,plane);
1301 |             if (flag_direct_erase==-1)
1302 |             {
1303 |                 flag_gc=interrupt_gc(ssd,channel,chip,die,plane,gc_node);             /*当一个完整的gc操作完成时（已经擦除一个块，回收了一定数量的flash空间），返回1，将channel上相应的gc操作请求节点删除*/
1304 |                 if (flag_gc==1)
1305 |                 {
1306 |                     delete_gc_node(ssd,channel,gc_node);
1307 |                 }
1308 |             }
1309 |             else if (flag_direct_erase==1)
1310 |             {
1311 |                 delete_gc_node(ssd,channel,gc_node);
1312 |             }
1313 |             return SUCCESS;
1314 |         } 
1315 |         else
1316 |         {
1317 |             return FAILURE;
1318 |         }		
1319 |     }
1320 | }
1321 | 
1322 | 
1323 | 
1324 | /************************************************************************************************************
1325 |  *flag用来标记gc函数是在ssd整个都是idle的情况下被调用的（1），还是确定了channel，chip，die，plane被调用（0）
1326 |  *进入gc函数，需要判断是否是不可中断的gc操作，如果是，需要将一整块目标block完全擦除后才算完成；如果是可中断的，
1327 |  *在进行GC操作前，需要判断该channel，die是否有子请求在等待操作，如果没有则开始一步一步的操作，找到目标
1328 |  *块后，一次执行一个copyback操作，跳出gc函数，待时间向前推进后，再做下一个copyback或者erase操作
1329 |  *进入gc函数不一定需要进行gc操作，需要进行一定的判断，当处于硬阈值以下时，必须进行gc操作；当处于软阈值以下时，
1330 |  *需要判断，看这个channel上是否有子请求在等待(有写子请求等待就不行，gc的目标die处于busy状态也不行)，如果
1331 |  *有就不执行gc，跳出，否则可以执行一步操作
1332 |  ************************************************************************************************************/
1333 | unsigned int gc(struct ssd_info *ssd,unsigned int channel, unsigned int flag)
1334 | {
1335 |     unsigned int i;
1336 |     int flag_direct_erase=1,flag_gc=1,flag_invoke_gc=1;
1337 |     unsigned int flag_priority=0;
1338 |     struct gc_operation *gc_node=NULL,*gc_p=NULL;
1339 | 
1340 |     if (flag==1)                                                                       /*整个ssd都是IDEL的情况*/
1341 |     {
1342 |         for (i=0;i<ssd->parameter->channel_number;i++)
1343 |         {
1344 |             flag_priority=0;
1345 |             flag_direct_erase=1;
1346 |             flag_gc=1;
1347 |             flag_invoke_gc=1;
1348 |             gc_node=NULL;
1349 |             gc_p=NULL;
1350 |             if((ssd->channel_head[i].current_state==CHANNEL_IDLE)||(ssd->channel_head[i].next_state==CHANNEL_IDLE&&ssd->channel_head[i].next_state_predict_time<=ssd->current_time))
1351 |             {
1352 |                 channel=i;
1353 |                 if (ssd->channel_head[channel].gc_command!=NULL)
1354 |                 {
1355 |                     gc_for_channel(ssd, channel);
1356 |                 }
1357 |             }
1358 |         }
1359 |         return SUCCESS;
1360 | 
1361 |     } 
1362 |     else                                                                               /*只需针对某个特定的channel，chip，die进行gc请求的操作(只需对目标die进行判定，看是不是idle）*/
1363 |     {
1364 |         if ((ssd->parameter->allocation_scheme==1)||((ssd->parameter->allocation_scheme==0)&&(ssd->parameter->dynamic_allocation==1)))
1365 |         {
1366 |             if ((ssd->channel_head[channel].subs_r_head!=NULL)||(ssd->channel_head[channel].subs_w_head!=NULL))    /*队列上有请求，先服务请求*/
1367 |             {
1368 |                 return 0;
1369 |             }
1370 |         }
1371 | 
1372 |         gc_for_channel(ssd,channel);
1373 |         return SUCCESS;
1374 |     }
1375 | }
1376 | 
1377 | 
1378 | 
1379 | /**********************************************************
1380 |  *判断是否有子请求血药channel，若果没有返回1就可以发送gc操作
1381 |  *如果有返回0，就不能执行gc操作，gc操作被中断
1382 |  ***********************************************************/
1383 | int decide_gc_invoke(struct ssd_info *ssd, unsigned int channel)      
1384 | {
1385 |     struct sub_request *sub;
1386 |     struct local *location;
1387 | 
1388 |     if ((ssd->channel_head[channel].subs_r_head==NULL)&&(ssd->channel_head[channel].subs_w_head==NULL))    /*这里查找读写子请求是否需要占用这个channel，不用的话才能执行GC操作*/
1389 |     {
1390 |         return 1;                                                                        /*表示当前时间这个channel没有子请求需要占用channel*/
1391 |     }
1392 |     else
1393 |     {
1394 |         if (ssd->channel_head[channel].subs_w_head!=NULL)
1395 |         {
1396 |             return 0;
1397 |         }
1398 |         else if (ssd->channel_head[channel].subs_r_head!=NULL)
1399 |         {
1400 |             sub=ssd->channel_head[channel].subs_r_head;
1401 |             while (sub!=NULL)
1402 |             {
1403 |                 if (sub->current_state==SR_WAIT)                                         /*这个读请求是处于等待状态，如果他的目标die处于idle，则不能执行gc操作，返回0*/
1404 |                 {
1405 |                     location=find_location(ssd,sub->ppn);
1406 |                     if ((ssd->channel_head[location->channel].chip_head[location->chip].current_state==CHIP_IDLE)||((ssd->channel_head[location->channel].chip_head[location->chip].next_state==CHIP_IDLE)&&
1407 |                                 (ssd->channel_head[location->channel].chip_head[location->chip].next_state_predict_time<=ssd->current_time)))
1408 |                     {
1409 |                         free(location);
1410 |                         location=NULL;
1411 |                         return 0;
1412 |                     }
1413 |                     free(location);
1414 |                     location=NULL;
1415 |                 }
1416 |                 else if (sub->next_state==SR_R_DATA_TRANSFER)
1417 |                 {
1418 |                     location=find_location(ssd,sub->ppn);
1419 |                     if (ssd->channel_head[location->channel].chip_head[location->chip].next_state_predict_time<=ssd->current_time)
1420 |                     {
1421 |                         free(location);
1422 |                         location=NULL;
1423 |                         return 0;
1424 |                     }
1425 |                     free(location);
1426 |                     location=NULL;
1427 |                 }
1428 |                 sub=sub->next_node;
1429 |             }
1430 |         }
1431 |         return 1;
1432 |     }
1433 | }
1434 | 
1435 | 


--------------------------------------------------------------------------------