SSDsim simulation function：get_ppn()

雨点打透心脏的1/2处 2022-02-27 14:22 170阅读 0赞

此函数是在所给的channel，chip，die，plane里面找到一个active\_block然后再在这个block里面找到一个页，再利用find\_ppn()函数找到ppn。(可能产生擦除节点挂载plane上，可能产生GC节点挂载channel上)。

当要写入的页没有相应的映射关系时，直接为该写子请求利用find\_ppn()函数找到一个空闲页获得ppn，并更新映射表。当要写入的页有相应的映射关系时，首先会将该映射关系所对应的ppn置为失效页，并设置好相关属性，然后会判断该ppn所在的block是否都是失效页，如果都是失效页的话则说明该block需要进行擦除之后才能再利用了，所以此时会产生一个可擦除节点（会开辟内存空间），该可擦除节点会挂载在此时所在的plane上，最后再利用find\_ppn()函数找到一个新的ppn并更新映射表。然后修改该写子请求的ppn以及location相关变量属性以及修改ssd因一次写操作而产生的相关属性变化。最后如果没有主动策略，只采用gc\_hard\_threshold，并且无法中断GC过程，如果plane中的free\_page的数目少于gc\_hard\_threshold所设定的阈值就产生gc操作，此时会产生一个gc\_node（会开辟内存空间），设置该gc\_node相关属性(next\_node、chip、die、plane、block、page、state、priority),最后将该gc\_node挂载到该gc\_node所在的channel的gc\_command上。gc\_node属性只会精确到plane，然后从plane寻找可擦除节点，因为由失效页过多而产生的必须擦除才可用的现象发生在plane内部的block上，所以可擦除节点挂载到了plane上，故gc\_node只需要精确到plane号就行，然后从plane寻找擦除节点，而该gc\_noed挂载在响应的channel上。

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)
    {
    	unsigned int ppn,lpn,full_page,active_block,block,page;
    	struct local *location;
    	struct direct_erase *direct_erase_node,*new_direct_erase;
    	struct gc_operation *gc_node;
    #ifdef DEBUG
    	printf("enter get_ppn,channel:%d, chip:%d, die:%d, plane:%d\n",channel,chip,die,plane);
    #endif
    	full_page=~(0xffffffff<<(ssd->parameter->subpage_page));
    	lpn=sub->lpn;
    	/*************************************************************************************
    	*利用函数find_active_block在channel，chip，die，plane找到活跃block
    	*并且修改这个channel，chip，die，plane，active_block下的last_write_page和free_page_num
    	**************************************************************************************/
    	if(find_active_block(ssd,channel,chip,die,plane)==FAILURE){  //寻找活跃块
    		printf("ERROR :there is no free page in channel:%d, chip:%d, die:%d, plane:%d\n",channel,chip,die,plane);
    		return ssd;
    	}
    	active_block=ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].active_block;
    	ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].last_write_page++;
    	ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].free_page_num--;
    	if(ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].last_write_page>63){
    		printf("error! the last write page larger than 64!!\n");
    		while(1){}
    	}
    	block=active_block;	
    	page=ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].last_write_page;	
    	if(ssd->dram->map->map_entry[lpn].state==0){    /*this is the first logical page*/
    		if(ssd->dram->map->map_entry[lpn].pn!=0)
    			printf("Error in get_ppn()\n");
    		ssd->dram->map->map_entry[lpn].pn=find_ppn(ssd,channel,chip,die,plane,block,page);
    		ssd->dram->map->map_entry[lpn].state=sub->state;
    	}else{   /*这个逻辑页进行了更新，需要将原来的页置为失效*/
    		ppn=ssd->dram->map->map_entry[lpn].pn;
    		location=find_location(ssd,ppn);
    		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)
    			printf("\nError in get_ppn()\n");
    		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*/
    		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*/
    		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;
    		ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].blk_head[location->block].invalid_page_num++;
    
    		/*该block中全是invalid的页，可以直接删除，就在创建一个可擦除的节点，挂在location下的plane下面*/
    		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){
    			new_direct_erase=(struct direct_erase *)malloc(sizeof(struct direct_erase));
    			alloc_assert(new_direct_erase,"new_direct_erase");
    			memset(new_direct_erase,0, sizeof(struct direct_erase));
    
    			new_direct_erase->block=location->block;
    			new_direct_erase->next_node=NULL;
    			direct_erase_node=ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].erase_node;
    			if(direct_erase_node==NULL)
    				ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].erase_node=new_direct_erase;
    			else{
    				new_direct_erase->next_node=ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].erase_node;
    				ssd->channel_head[location->channel].chip_head[location->chip].die_head[location->die].plane_head[location->plane].erase_node=new_direct_erase;
    			}
    		}
    		free(location);
    		location=NULL;
    		ssd->dram->map->map_entry[lpn].pn=find_ppn(ssd,channel,chip,die,plane,block,page);
    		ssd->dram->map->map_entry[lpn].state=(ssd->dram->map->map_entry[lpn].state|sub->state);
    	}
    	sub->ppn=ssd->dram->map->map_entry[lpn].pn;     /*修改sub子请求的ppn，location等变量*/
    	sub->location->channel=channel;
    	sub->location->chip=chip;
    	sub->location->die=die;
    	sub->location->plane=plane;
    	sub->location->block=active_block;
    	sub->location->page=page;
    
    	ssd->program_count++;   /*修改ssd的program_count,free_page等变量*/
    	ssd->channel_head[channel].program_count++;
    	ssd->channel_head[channel].chip_head[chip].program_count++;
    	ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].free_page--;
    	ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].page_head[page].lpn=lpn;	
    	ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].page_head[page].valid_state=sub->state;
    	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);
    	ssd->channel_head[channel].chip_head[chip].die_head[die].plane_head[plane].blk_head[active_block].page_head[page].written_count++;
    	ssd->write_flash_count++;
    
    	if(ssd->parameter->active_write==0)    /*如果没有主动策略，只采用gc_hard_threshold，并且无法中断GC过程*/
    	{	/*如果plane中的free_page的数目少于gc_hard_threshold所设定的阈值就产生gc操作*/
    		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))
    		{
    			gc_node=(struct gc_operation *)malloc(sizeof(struct gc_operation));
    			alloc_assert(gc_node,"gc_node");
    			memset(gc_node,0, sizeof(struct gc_operation));
    
    			gc_node->next_node=NULL;
    			gc_node->chip=chip;
    			gc_node->die=die;
    			gc_node->plane=plane;
    			gc_node->block=0xffffffff;
    			gc_node->page=0;
    			gc_node->state=GC_WAIT;
    			gc_node->priority=GC_UNINTERRUPT;  //不可中断的GC节点
    			gc_node->next_node=ssd->channel_head[channel].gc_command;
    			ssd->channel_head[channel].gc_command=gc_node;
    			ssd->gc_request++;
    		}
    	}
    	return ssd;
    }