Esempio n. 1
0
/* 根据LFU算法进行页面替换 */
void do_LFU(Ptr_PageTableItem ptr_pageTabIt)
{
	unsigned int i, min, page;
	printf("没有空闲物理块,开始进行LFU页面替换...\n");
	/*for (i = 0, min = 0xFFFFFFFF, page = 0; i < BLOCK_SUM; i++)
	{
		if (actualMemory[i]->count < min)
		{
			min = actualMemory[i]->count;
			page = i;
		}
	}*/
	page=clear();
	printf("选择第%u页进行替换\n", page);
	if (actualMemory[i]->edited)
	{
		/* 页面内容有修改,需要写回至辅存 */
		printf("该页内容有修改,写回至辅存\n");
		do_page_out(actualMemory[page]);
	}
	actualMemory[i]->filled = FALSE;
	actualMemory[i]->count = 0;


	/* 读辅存内容,写入到实存 */
	do_page_in(ptr_pageTabIt,page);
		
	/* 更新页表内容 */
	ptr_pageTabIt->blockNum=page;
	ptr_pageTabIt->filled=TRUE;
	ptr_pageTabIt->edited=FALSE;
	ptr_pageTabIt->count=0;
	blockStatus[page]=TRUE;
	printf("页面替换成功\n");
}
/* 根据LFU算法进行页面替换 */
void do_LFU(Ptr_PageTableItem ptr_pageTabIt)
{
	unsigned int i, min, page;
	printf("没有空闲物理块,开始进行LFU页面替换...\n");
	for (i = 0, min = 0xFFFFFFFF, page = 0; i < PAGE_SUM; i++)
	{
		if (pageTable[i].count < min)
		{
			min = pageTable[i].count;
			page = i;
		}
	}
	printf("选择第%u页进行替换\n", page);
	if (pageTable[page].edited)
	{
		/* 页面内容有修改,需要写回至辅存 */
		printf("该页内容有修改,写回至辅存\n");
		do_page_out(&pageTable[page]);
	}
	pageTable[page].filled = FALSE;
	pageTable[page].count = 0;


	/* 读辅存内容,写入到实存 */
	do_page_in(ptr_pageTabIt, pageTable[page].blockNum);
	
	/* 更新页表内容 */
	ptr_pageTabIt->blockNum = pageTable[page].blockNum;
	ptr_pageTabIt->filled = TRUE;
	ptr_pageTabIt->edited = FALSE;
	ptr_pageTabIt->count = 0;
	printf("页面替换成功\n");
}
Esempio n. 3
0
void do_switch(Ptr_PageTableItem ptr_pageTabIt)
{
    unsigned int rec = 0, i;
    unsigned char min = 255;
	printf("没有空闲物理块,开始进行老化页面替换...\n");
    for (i = 0; i < PAGE_SUM; i++)
    {
        if (pageTable[i].filled && pageTable[i].count < min){
            min = pageTable[i].count;
            rec = i;
        }
    }
    printf("选择第%u页进行替换\n", rec);
    if (pageTable[rec].edited)
	{
		/* 页面内容有修改,需要写回至辅存 */
		printf("该页内容有修改,写回至辅存\n");
		do_page_out(pageTable + rec);
	}
	pageTable[rec].filled = FALSE;
	pageTable[rec].count = 0;

	/* 读辅存内容,写入到实存 */
	do_page_in(ptr_pageTabIt, pageTable[rec].blockNum);
	
	/* 更新页表内容 */
	ptr_pageTabIt->blockNum = pageTable[rec].blockNum;
	ptr_pageTabIt->filled = TRUE;
	ptr_pageTabIt->edited = FALSE;
	printf("页面替换成功\n");
}
Esempio n. 4
0
void do_LRU(Ptr_PageTableItem ptr_pageTabIt)//LRU算法
{
	unsigned int i, page;
	int max;
	printf("没有空闲物理块,开始进行LRU页面替换...\n");
	for (i = 0, max=-1, page = 0; i < PAGE_SUM; i++)
	{
		if (pageTable[i].filled&&pageTable[i].count_LRU > max)
		{
			max= pageTable[i].count_LRU;
			page = i;
		}//选择计数值最大的页面替换
	}
	printf("选择第%u页进行替换\n", page);
	if (pageTable[page].edited)
	{
		/* 页面内容有修改,需要写回至辅存 */
		printf("该页内容有修改,写回至辅存\n");
		do_page_out(&pageTable[page]);
	}
	pageTable[page].filled = FALSE;
	pageTable[page].count = 0;
	pageTable[page].count_1=0;
	pageTable[page].count_LRU=0;
	/* 读辅存内容,写入到实存 */
	do_page_in(ptr_pageTabIt, pageTable[page].blockNum);//
	/* 更新页表内容 */
	ptr_pageTabIt->blockNum = pageTable[page].blockNum;
	ptr_pageTabIt->filled = TRUE;
	ptr_pageTabIt->edited = FALSE;
	ptr_pageTabIt->count_LRU= 0;//  
	printf("页面替换成功\n");
}
Esempio n. 5
0
/////jm
void do_OldPage(Ptr_PageTableItem ptr_pageTabIt)//页面老化算法
{
	unsigned int i, min, page;
	printf("没有空闲物理块,开始进行页面老化替换...\n");
	for (i = 0, min = 0xFFFFFFFF, page = 0; i < PAGE_SUM; i++)
	{
		if (pageTable[i].filled&&pageTable[i].count_1<min)//修改源码中的bug
		{
			min = pageTable[i].count_1;
			page = i;
		}//选择计数值最小的页面替换
	}
	printf("选择第%u页进行替换\n", page);
	if (pageTable[page].edited)
	{
		/* 页面内容有修改,需要写回至辅存 */
		printf("该页内容有修改,写回至辅存\n");
		do_page_out(&pageTable[page]);
	}
	pageTable[page].filled = FALSE;
	pageTable[page].count = 0;
	pageTable[page].count_1=0;
	pageTable[page].R=0;
	/* 读辅存内容,写入到实存 */
	do_page_in(ptr_pageTabIt, pageTable[page].blockNum);
	/* 更新页表内容 */
	ptr_pageTabIt->blockNum = pageTable[page].blockNum;
	ptr_pageTabIt->filled = TRUE;
	ptr_pageTabIt->edited = FALSE;
	ptr_pageTabIt->count = 0;
	ptr_pageTabIt->count_1=0;
	ptr_pageTabIt->R=1;
	printf("页面替换成功\n");
}
Esempio n. 6
0
static  void    finish_page_section( doc_section ds, bool eject )
{
    if( eject ) {
        g_skip = 0;                     // ignore remaining skip value
    }
    new_section( ds );
    do_page_out();
}
Esempio n. 7
0
void text_page_out( void )
{
    while( n_page.col_main != NULL ) {
        do_page_out();
        update_t_page();
    }
    return;
}
Esempio n. 8
0
void full_page_out( void )
{
    while( (n_page.col_top != NULL) || (n_page.col_main != NULL)
            || (n_page.col_bot != NULL) || (n_page.col_fn != NULL) ) {
        do_page_out();
        update_t_page();
    }
    return;
}
Esempio n. 9
0
void    gml_exmp( const gmltag * entry )
{
    tag_cb  *   wk;

    entry = entry;
    scr_process_break();
    if( !ProcFlags.xmp_active ) {       // no preceding :XMP tag
        g_err_tag_prec( "XMP" );
        scan_start = scan_stop + 1;
        return;
    }
    g_curr_font = font_save;
    ProcFlags.xmp_active = false;
    ProcFlags.justify = justify_save;
    wk = nest_cb;
    nest_cb = nest_cb->prev;
    add_tag_cb_to_pool( wk );

    /*  place the accumulated xlines on the proper page */

    ProcFlags.group_elements = false;
    if( t_doc_el_group.first != NULL ) {
        t_doc_el_group.depth += (t_doc_el_group.first->blank_lines +
                                t_doc_el_group.first->subs_skip);
    }

    if( (t_doc_el_group.depth + t_page.cur_depth) > t_page.max_depth ) {
        /*  the block won't fit on this page */

        if( t_doc_el_group.depth  <= t_page.max_depth ) {
            /*  the block will be on the next page */

            do_page_out();
            reset_t_page();
        }
    }

    while( t_doc_el_group.first != NULL ) {
        insert_col_main( t_doc_el_group.first );
        t_doc_el_group.first = t_doc_el_group.first->next;
    }

    t_doc_el_group.depth    = 0;
    t_doc_el_group.last     = NULL;
    scan_start = scan_stop + 1;
    return;
}
Esempio n. 10
0
/* 根据页面老化算法进行页面替换 */
void do_PA(Ptr_PageTableItem ptr_pageTabIt)
{
	unsigned int i,k,s, min, page,index,processNum, c, temp_count;
	printf("没有空闲物理块,开始进行页面老化算法页面替换...\n");
	for(s=0,min=0xFFFFFFFF,page=0,index=0,processNum=0;s<Process_SUM;s++)
        for(k=0;k<INDEX_SUM;k++)
            for (i = 0; i < INDEX_PAGE; i++)
            {
                for(c = 0, temp_count = 0;c < 8;c++){
                    temp_count = temp_count * 10 + pageIndex[s][k].index[i].count[c] - '0';
                }
                if (temp_count < min && pageIndex[s][k].index[i].filled==TRUE)
                {
                    min = temp_count;
                    processNum=s;
                    page = i;
                    index=k;
                }
            }
    printf("选择第%u个目录第%u页进行替换\n",index,page);
	if (pageIndex[processNum][index].index[page].edited)
	{
		/* 页面内容有修改,需要写回至辅存 */
		printf("该页内容有修改,写回至辅存\n");
		do_page_out(&pageIndex[processNum][index].index[page]);
	}
	pageIndex[processNum][index].index[page].filled = FALSE;
	pageIndex[processNum][index].index[page].visited = 0;
	for(c = 0;c < 8;c++){
		pageIndex[processNum][index].index[page].count[c] = '0';
	}

	/* 读辅存内容,写入到实存 */
	do_page_in(ptr_pageTabIt,pageIndex[processNum][index].index[page].blockNum);

	/* 更新页表内容 */
	ptr_pageTabIt->blockNum =pageIndex[processNum][index].index[page].blockNum;
	ptr_pageTabIt->filled = TRUE;
	ptr_pageTabIt->edited = FALSE;
	ptr_pageTabIt->visited = 0;
	for(c = 0;c < 8;c++){
		ptr_pageTabIt->count[c] = '0';
	}
	printf("页面替换成功\n");
}
Esempio n. 11
0
void do_LRU (Ptr_PageTableItem ptr_pageTabIt){
	unsigned int i,page,popagenum;
	unsigned int popage[PAGE_SUM];
	printf("没有空闲物理块,开始进行LRU页面替换...\n");
	for (i = 0,page = 0,popagenum=0; i < PAGE_SUM ; i++){
		if (pageTable[i].filled && pageTable[i].LRU_flag ==0){
			popage[popagenum++] = i;
		}
	}
	if(popagenum>0){
		page = popage[random()%popagenum] ;
	}

	else if (popagenum==0){ //没有找到未被使用的,随机选择一个	
		for (i = 0; i < PAGE_SUM; i++){
			if (pageTable[i].filled){
				popage[popagenum++] = i;
			}
		}
		page = popage[random()%popagenum];
	}
	//随机选择一个 
	printf("选择第%u页进行替换\n", page);
	//该页面对应的物理块修改了
	if (pageTable[page].edited)
	{
		/* 页面内容有修改,需要写回至辅存 */
		printf("该页内容有修改,写回至辅存\n");
		do_page_out(&pageTable[page]);
	}
	pageTable[page].filled = FALSE;
	pageTable[page].LRU_flag = 0;


	/* 读辅存内容,写入到实存 */
	do_page_in(ptr_pageTabIt, pageTable[page].blockNum);
	
	/* 更新页表内容 */
	ptr_pageTabIt->blockNum = pageTable[page].blockNum;
	ptr_pageTabIt->filled = TRUE;
	ptr_pageTabIt->edited = FALSE;
	ptr_pageTabIt->LRU_flag = 0;
	printf("页面替换成功\n");

}
Esempio n. 12
0
File: vmm.c Progetto: ZZJC1306/VMM
//和LFU差不多,就是判断条件变了;怎么知道什么是最早最久使用的呢,建立一个链表,一旦使用了哪个
void do_LRU(Ptr_PageTableItem ptr_pageTabIt){
	unsigned int i,j, pagei = 0,pagej = 0,blockNum;
	int flag = 0;
	printf("没有空闲物理块,开始进行LRU页面替换...\n");
	while(flag==0){
		//如果一直没有找到,说明当前的第一个已经被挪走了,再取一个;
		blockNum = LRU_get();
		for (i = 0; i < ROOT_PAGE_SUM; i++)
		{
			for(j = 0; j<CHILD_PAGE_SUM; j++)
			{
				if (pageTable[i][j].blockNum==blockNum && pageTable[i][j].filled==TRUE)
				//在所有的被装入的页表中查找呦;谁最久没有被使用过了;找到在物理内存中的并且最早最久没被使用过的;
				{
					flag = 1;
					pagei = i;
					pagej = j;
					//如何跳出两个循环?设置一个标示位;
					break;
				}
				if(flag==1)
					break;
			}
		}
	}
	printf("选择第%u页目录进行替换,选择选择第%u页号进行替换\n", pagei,pagej);
	if (pageTable[pagei][pagej].edited)//被改写过了
	{
		/* 页面内容有修改,需要写回至辅存 */
		printf("该页的内容有修改,写回至辅存\n");
		do_page_out(&pageTable[pagei][pagej]);
	}
	pageTable[pagei][pagej].filled = FALSE;//没有被装入;
	pageTable[pagei][pagej].count = 0;

	/* 将辅存内容写入实存 */
	do_page_in(ptr_pageTabIt, pageTable[pagei][pagej].blockNum);//这个位置的被取代了;
	/* 更新页表内容 */
	ptr_pageTabIt->blockNum = pageTable[pagei][pagej].blockNum;
	ptr_pageTabIt->filled = TRUE;
	ptr_pageTabIt->edited = FALSE;
	ptr_pageTabIt->count = 0;
	LRU_ChangeAdd(blockNum);
	printf("页面替换成功\n");
}
Esempio n. 13
0
/* 根据LFU算法进行页面替换 */
void do_LFU(Ptr_PageTableItem ptr_pageTabIt)
{
	unsigned int i, j, k,min, firstpage, page;
	int whichprogress=0;
	printf("没有空闲物理块,开始进行LFU页面替换...\n");
	for(k=0;k<VIRTUAL_PROGRESSES;k++)
	for (i = 0, min = 0xFFFFFFFF, firstpage = 0, page = 0; i < LV1_PAGE_SUM; i++)
	{
		for (j = 0; j < LV2_PAGE_SUM; j++)
		{
			if (pageTable[k][i][j].count < min)                                                
			{
			    whichprogress=k;
				min = pageTable[k][i][j].count;
				firstpage = i;
				page = j;
			}
		}
	}
	printf("选择第%u页进行替换\n", firstpage * LV1_PAGE_SUM + page);
	if (pageTable[whichprogress][firstpage][page].edited)
	{
		/* 页面内容有修改,需要写回至辅存 */
		printf("该页内容有修改,写回至辅存\n");
		do_page_out(&pageTable[whichprogress][firstpage][page]);
	}
	pageTable[whichprogress][firstpage][page].filled = FALSE;
	pageTable[whichprogress][firstpage][page].count = 0;
    for(i=0;i<8;i++)
    {
        actmemcount[whichprogress][firstpage * LV1_PAGE_SUM + page][i]=0;
    }


	/* 读辅存内容,写入到实存 */
	do_page_in(ptr_pageTabIt, pageTable[whichprogress][firstpage][page].blockNum);

	/* 更新页表内容 */
	ptr_pageTabIt->blockNum = pageTable[whichprogress][firstpage][page].blockNum;
	ptr_pageTabIt->filled = TRUE;
	ptr_pageTabIt->edited = FALSE;
	ptr_pageTabIt->count = 0;
	printf("页面替换成功\n");
}
Esempio n. 14
0
File: vmm.c Progetto: ZZJC1306/VMM
//修改了,
void do_LFU(Ptr_PageTableItem ptr_pageTabIt)

{
	unsigned int i,j, min = 0xFFFFFFFF, pagei = 0,pagej = 0;
	printf("没有空闲物理块,开始进行LRU页面替换...\n");
	for (i = 0, min = 0xFFFFFFFF; i < ROOT_PAGE_SUM; i++)
	{
		for(j = 0; j<CHILD_PAGE_SUM; j++)
		{
			if (pageTable[i][j].count < min&&pageTable[i][j].filled==TRUE)//在所有的被装入的页表中查找呦;
			{
				min = pageTable[i][j].count;
				pagei = i;
				pagej = j;
			}
		}
	}
	printf("选择第%u页目录进行替换,选择选择第%u页号进行替换\n", pagei,pagej);
	if (pageTable[pagei][pagej].edited)//被改写过了
	{
		/* 页面内容有修改,需要写回至辅存 */
		printf("该页的内容有修改,写回至辅存\n");
		do_page_out(&pageTable[pagei][pagej]);
	}
	pageTable[pagei][pagej].filled = FALSE;//没有被装入;
	pageTable[pagei][pagej].count = 0;
	/* 将辅存内容写入实存 */
	do_page_in(ptr_pageTabIt, pageTable[pagei][pagej].blockNum);//这个位置的被取代了;
	/* 更新页表内容 */
	ptr_pageTabIt->blockNum = pageTable[pagei][pagej].blockNum;
	ptr_pageTabIt->filled = TRUE;
	ptr_pageTabIt->edited = FALSE;
	ptr_pageTabIt->count = 0;
	printf("页面替换成功\n");

}
Esempio n. 15
0
/* 根据LFU算法进行页面替换 */
void do_LFU(Ptr_PageTableItem ptr_pageTabIt)
{
	unsigned int i,k, min, page2 ,page1;
	printf("没有空闲物理块,开始进行LFU页面替换...\n");
	for (k = 0, min = 0xFFFFFFFF, page1 = 0,page2 = 0; k < PAGE_SUM2; k++)
	{
	    for(i = 0;i< PAGE_SUM1; i++){
            if (pageTable[k][i].count < min&&pageTable[k][i].filled)                                        //修改4:加上filled的判断
            {
                min = pageTable[k][i].count;
                page1 = i;
                page2 = k;
            }
	    }
	}
	printf("选择第%u页中的第%u页进行替换\n", page2 , page1 );
	if (pageTable[page2][page1].edited)
	{
		/* 页面内容有修改,需要写回至辅存 */
		printf("该页内容有修改,写回至辅存\n");
		do_page_out(&pageTable[page2][page1]);
	}
	pageTable[page2][page1].filled = FALSE;
	pageTable[page2][page1].count = 0;


	/* 读辅存内容,写入到实存 */
	do_page_in(ptr_pageTabIt, pageTable[page2][page1].blockNum);

	/* 更新页表内容 */
	ptr_pageTabIt->blockNum = pageTable[page2][page1].blockNum;
	ptr_pageTabIt->filled = TRUE;
	ptr_pageTabIt->edited = FALSE;
	ptr_pageTabIt->count = 0;
	printf("页面替换成功\n");
}
Esempio n. 16
0
void do_LRU_aging(Ptr_PageTableItem ptr_pageTabIt){
	unsigned int i,j,page,popagenum;
	unsigned int popage[PAGE_SUM] = {0};
	unsigned int Mincount = AgingCountBit+1;
	unsigned int Pagecount;
	printf("没有空闲物理块,开始进行老化算法页面替换...\n");
	for (i = 0,page = 0,popagenum=0; i < PAGE_SUM ; i++){
		Pagecount = 0;
		if (pageTable[i].filled && pageTable[i].LRU_flag ==0){
			for(j=0;j<AgingCountBit;j++){
				Pagecount += Aging_counter[pageTable[i].blockNum][j];
			}
			if (Pagecount<Mincount)
			{
				popagenum = 0;
				popage[popagenum++] = i;
				Mincount = Pagecount;
			}
			else if(pageTable == Mincount){
				popage[popagenum++] = i;
			}
			
		}
	}
	if(popagenum>0){
		page = popage[random()%popagenum];
	}

	else if (popagenum==0){ //没有找到未被使用的,随机选择一个	
		Mincount = AgingCountBit+1;
		for (i = 0; i < PAGE_SUM; i++){
			if (pageTable[i].filled){
				for(j=0;j<AgingCountBit;j++){
				Pagecount += Aging_counter[pageTable[i].blockNum][j];
				}
			
				if (Pagecount<Mincount){
					popagenum = 0;
					popage[popagenum++] = i;
					Mincount = Pagecount;
					}

				else if(pageTable == Mincount){
					popage[popagenum++] = i;
					}
				}
			}
		page = popage[random()%popagenum];
	}
	//随机选择一个 
	printf("选择第%u页进行替换\n", page);
	//该页面对应的物理块修改了
	if (pageTable[page].edited)
	{
		/* 页面内容有修改,需要写回至辅存 */
		printf("该页内容有修改,写回至辅存\n");
		do_page_out(&pageTable[page]);
	}
	pageTable[page].filled = FALSE;
	pageTable[page].LRU_flag = 0;


	/* 读辅存内容,写入到实存 */
	do_page_in(ptr_pageTabIt, pageTable[page].blockNum);
	
	/* 更新页表内容 */
	ptr_pageTabIt->blockNum = pageTable[page].blockNum;
	ptr_pageTabIt->filled = TRUE;
	ptr_pageTabIt->edited = FALSE;
	ptr_pageTabIt->LRU_flag = 0;
	printf("页面替换成功\n");

}
Esempio n. 17
0
void scr_pa( void )
{
    char        *   pa;
    char        *   p;
    int             len;
    char            cwcurr[4];

    cwcurr[0] = SCR_char;
    cwcurr[1] = 'p';
    cwcurr[2] = 'a';
    cwcurr[3] = '\0';

    p = scan_start;
    while( *p && *p != ' ' ) {          // over cw
        p++;
    }
    while( *p && *p == ' ' ) {          // next word start
        p++;
    }
    pa = p;

    while( *p && *p != ' ' ) {          // end of word
        p++;
    }
    len = p - pa;
    switch( len ) {
    case 7 :
        if( strnicmp( "NOSTART", pa, 7 ) ) {
            xx_opt_err( cwcurr, pa );
            break;
        }
        /* fallthru for NOSTART */
    case 0 :
        last_page_out();                // default action
        reset_t_page();
        break;
    case 3 :
        if( !strnicmp( "ODD", pa, 3 ) ) {
            last_page_out();
            reset_t_page();
            if( (page & 1) ) {          // next page would be even
                do_page_out();
                reset_t_page();
            }
        } else {
            xx_opt_err( cwcurr, pa );
        }
        break;
    case 4 :
        if( !strnicmp( "EVEN", pa, 4 ) ) {
            last_page_out();
            reset_t_page();
            if( !(page & 1) ) {         // next page would be odd
                do_page_out();
                reset_t_page();
            }
        } else {
            xx_opt_err( cwcurr, pa );
        }
        break;
    default:
        xx_opt_err( cwcurr, pa );
        break;
    }
    scan_restart = scan_stop +1;
    return;
}
Esempio n. 18
0
static  void    gml_hx_common( gml_tag gtag, int hx_lvl )
{
    char    *   p;
    char    *   headp;
    bool        idseen;
    bool        stitleseen;
    int         rc;
    int         k;
    size_t      headlen;
    size_t      txtlen;
    char        hnumstr[64];
    ref_entry   *   re;
    ref_entry   *   rwk;
    static char hxstr[4] = ":HX";
    static char htextx[8] = "$htextX";
    static char headx[7]  = "$headX";

    gtag = gtag;

    *(hxstr + 2) = '0' + hx_lvl;
    htextx[6] = '0' + hx_lvl;
    hnumx[5] = '0' + hx_lvl;
    headx[5] = '0' + hx_lvl;

    switch( hx_lvl ) {
    case   0:
        if( !((ProcFlags.doc_sect == doc_sect_body) ||
            (ProcFlags.doc_sect_nxt == doc_sect_body)) ) {

            g_err( err_tag_wrong_sect, hxstr, ":BODY section" );
            err_count++;
            file_mac_info();
        }
        break;
    case  1:
        if( !((ProcFlags.doc_sect >= doc_sect_body) ||
            (ProcFlags.doc_sect_nxt >= doc_sect_body)) ) {

            g_err( err_tag_wrong_sect, hxstr, ":BODY :APPENDIX :BACKM sections" );
            err_count++;
            file_mac_info();
        }
        break;
    default:
        if( !((ProcFlags.doc_sect >= doc_sect_abstract) ||
            (ProcFlags.doc_sect_nxt >= doc_sect_abstract)) ) {

            g_err( err_tag_wrong_sect, hxstr, ":ABSTRACT section or later" );
            err_count++;
            file_mac_info();
        }
        break;
    }
    if( layout_work.hx[hx_lvl].number_form != num_none ) {
        layout_work.hx[hx_lvl].headn++;
    }

    idseen = false;
    stitleseen = false;
    p = scan_start;
    re = NULL;

    /***********************************************************************/
    /*  Scan attributes  for :Hx                                           */
    /*  id=                                                                */
    /*  stitle=                                                            */
    /***********************************************************************/

    for( ;; ) {
        while( *p == ' ' ) {
            p++;
        }
        if( *p == '\0' || *p == '.'  ) {
            break;                      // tag end found
        }
        if( !strnicmp( "stitle=", p, 7 ) ) {
            p += 6;
            stitleseen = true;

            /***************************************************************/
            /*  Although unsupported scan stitle='xxx'                     */
            /***************************************************************/
            g_warn( wng_unsupp_att, "stitle" );
            wng_count++;
            file_mac_info();

            p = get_att_value( p );

            scan_start = p;
            if( !ProcFlags.tag_end_found ) {
                continue;
            }
            break;
        }

        /*******************************************************************/
        /*  ID='xxxxxxxx'                                                  */
        /*******************************************************************/

        if( !strnicmp( "id=", p, 3 ) ) {
            p += 2;

            p = get_refid_value( p );

            if( val_len > 0 ) {
                idseen = true;          // valid id attribute found
                *(val_start + val_len) = '\0';

                if( re == NULL ) {      // prepare reference entry
                    re = mem_alloc( sizeof( ref_entry ) );
                    init_ref_entry( re, val_start, val_len );
                } else {
                    fill_id( re, val_start, val_len );
                }
            }
            scan_start = p;
            if( !ProcFlags.tag_end_found ) {
                continue;
            }
            break;
        }

        /*******************************************************************/
        /* no more valid attributes, process remaining input as header text*/
        /*******************************************************************/
        break;
    }
    if( *p == '.' ) {                   // tag end ?
        p++;
    }

    /************************************************************************/
    /*  set the global vars $headx, $headnumx, $htextx                      */
    /*    perhaps text translated to upper or lower case                    */
    /************************************************************************/
    while( *p == ' ' ) {                // ignore leading blanks
        p++;
    }
    if( *p ) {                          // text exists
        if( layout_work.hx[hx_lvl].cases == case_lower ) {
            strlwr( p );
        } else if( layout_work.hx[hx_lvl].cases == case_upper ) {
            strupr( p );
        }
    }
    rc = add_symvar( &global_dict, htextx, p, no_subscript, 0 );

    update_headnumx( hx_lvl, hnumstr, sizeof( hnumstr ) );

    txtlen = strlen( p );
    headlen = strlen( hnumstr) + txtlen + 2;
    headp = mem_alloc( headlen );
    if( layout_work.hx[hx_lvl].number_form != num_none ) {
        strcpy( headp, hnumstr); // numbered header
        strcat( headp, " " );
    } else {
        *headp = '\0';
    }
    strcat( headp, p );
    rc = add_symvar( &global_dict, headx, headp, no_subscript, 0 );

    out_msg( " %s\n", headp );          // always verbose output ? TBD

    mem_free( headp );

    /***********************************************************************/
    /*  if id  specified add it to reference dict                          */
    /***********************************************************************/
    if( idseen ) {
        rwk = find_refid( ref_dict, re->id );
        if( !rwk ) {                    // new entry
            if( txtlen > 0 ) {          // text line not empty
                re->u.info.text_cap = mem_alloc( txtlen + 1 );
                strcpy( re->u.info.text_cap, p );
            }
            add_ref_entry( &ref_dict, re );
            re = NULL;                  // free will be done via dictionary
        } else {
            /***************************************************************/
            /*  test for duplicate id                                      */
            /*  it is done with comparing line no only, in the hope that   */
            /*  two identical ids are not specified in different files on  */
            /*  the same line no.                                          */
            /***************************************************************/
            if( re->lineno != rwk->lineno ) {
                g_err( wng_id_xxx, re->id );
                g_info( inf_id_duplicate );
                file_mac_info();
                err_count++;
            }
            if( re->u.info.text_cap != NULL ) {
                mem_free( re->u.info.text_cap );
            }
            mem_free( re );
        }
    }

    if( layout_work.hx[hx_lvl].number_reset ) {
        for( k = hx_lvl + 1; k < 7; k++ ) {
            layout_work.hx[k].headn = 0;// reset following levels
            if( layout_work.hx[k].headnsub != NULL ) {
                *(layout_work.hx[k].headnsub->value) = '\0';
            }
        }
    }

    /***********************************************************************/
    /*  creation of actual heading                                         */
    /***********************************************************************/

    /***********************************************************************/
    /*  eject page(s) if specified                                         */
    /***********************************************************************/
    if( layout_work.hx[hx_lvl].page_eject != ej_no ) {

        if( ProcFlags.page_started ) {
            do_page_out();
            reset_t_page();
        }

        if( !ProcFlags.start_section ) {
            start_doc_sect();
        }
        set_headx_banners( hx_lvl );        // set possible banners
        reset_t_page();                     // and adjust page margins


        if( (layout_work.hx[hx_lvl].page_eject == ej_odd) && (page & 1) ) {
            do_page_out();              // next page would be even
            reset_t_page();
        } else if( (layout_work.hx[hx_lvl].page_eject == ej_even) && !(page & 1) ) {
            do_page_out();              // next page would be odd
            reset_t_page();
        }
    }

    if( layout_work.hx[hx_lvl].display_heading ) {

        hx_header( hx_lvl, hnumstr, p );
    }

    scan_start = scan_stop;
    return;
}
Esempio n. 19
0
void do_LRU(Ptr_PageTableItem ptr_pageTabIt)
{
    unsigned int i,j,k,min,page,firstpage;
    int flag=0;
    int count[VIRTUAL_PROGRESSES][PAGE_SUM]={0};
    int Whichprogress=0;
    for(k=0;k<VIRTUAL_PROGRESSES;k++)
    for(i=0;i<PAGE_SUM;i++)
    {
        for(j=0;j<8;j++)
        count[k][i]=count[k][i]*2+actmemcount[k][i][j];
        //printf("%d\n",count[i]);
    }
    printf("没有空闲物理块,开始进行LRU页面替换...\n");
    for(k=0;k<VIRTUAL_PROGRESSES;k++)
    for (i = 0, firstpage = 0, page = 0; i < LV1_PAGE_SUM; i++)
	{
		for (j = 0; j < LV2_PAGE_SUM; j++)
		{
			if (pageTable[k][i][j].filled)                                                  
			{
			    Whichprogress=k;
				firstpage = i;
				page = j;
				flag=1;
			}
			break;
		}
		if(flag==1)
        {
            break;
        }
	}
	for(k=0;k<VIRTUAL_PROGRESSES;k++)
    for (i = 0, min = 0xFFFFFFFF; i < LV1_PAGE_SUM; i++)
	{
		for (j = 0; j < LV2_PAGE_SUM; j++)
		{
			if (count[k][i*LV1_PAGE_SUM+j] < min
            &&pageTable[k][i][j].filled)                                                   
			{
			    Whichprogress=k;
				min = count[k][i*LV1_PAGE_SUM+j];
				firstpage = i;
				page = j;
			}
		}
	}
    printf("选择第%u个进程页表的第%u页进行替换\n", k, firstpage * LV1_PAGE_SUM + page);
    if (pageTable[Whichprogress][firstpage][page].edited)
	{
		/* 页面内容有修改,需要写回至辅存 */
		printf("该页内容有修改,写回至辅存\n");
		do_page_out(&pageTable[Whichprogress][firstpage][page]);
	}
	for(i=0;i<8;i++)
	{
	    actmemcount[Whichprogress][firstpage * LV1_PAGE_SUM + page][i]=0;
	}
	whichprogress[pageTable[Whichprogress][firstpage][page].blockNum]=ptr_memAccReq->FromProgress;
	pageTable[Whichprogress][firstpage][page].filled = FALSE;
	pageTable[Whichprogress][firstpage][page].count = 0;
	pageTable[Whichprogress][firstpage][page].blockNum = 0;


	/* 读辅存内容,写入到实存 */
	do_page_in(ptr_pageTabIt, pageTable[Whichprogress][firstpage][page].blockNum);

	/* 更新页表内容 */
	ptr_pageTabIt->blockNum = pageTable[Whichprogress][firstpage][page].blockNum;
	ptr_pageTabIt->filled = TRUE;
	ptr_pageTabIt->edited = FALSE;
	ptr_pageTabIt->count = 0;
	//ptr_pageTabIt->progressNum=ptr_memAccReq->FromProgress;
	printf("页面替换成功\n");
}
Esempio n. 20
0
void last_page_out( void )
{
    full_page_out();
    do_page_out();  // last page
    return;
}
Esempio n. 21
0
void    start_doc_sect( void )
{
    bool            first_section;
    bool            header;
    bool            page_r;
    doc_section     ds;
    font_number     font;
    spacing_line    spacing_ln;
    page_ej         page_e;
    su              *p_sk;
    su              *top_sk;
    uint32_t        ind;
    xx_str          *h_string;

    if( ProcFlags.start_section ) {
        return;                         // once is enough
    }
    if( !ProcFlags.fb_document_done ) { // the very first section/page
        do_layout_end_processing();
    }

    first_section = (ProcFlags.doc_sect == doc_sect_none);

    header = false;                 // no header string (ABSTRACT, ... )  output
    page_r = false;                 // no page number reset
    page_e = ej_no;                 // no page eject
    ProcFlags.start_section = true;
    ProcFlags.keep_left_margin = false;
    ds = ProcFlags.doc_sect_nxt;        // new section

    if( ds == doc_sect_none ) {
        ds = doc_sect_body;      // if text without section start assume body
    }

    /***********************************************************************/
    /*  process special section attributes                                 */
    /***********************************************************************/

    switch( ds ) {
    case   doc_sect_body:
        page_r   = layout_work.body.page_reset;
        page_e   = layout_work.body.page_eject;
        if( layout_work.body.header ) {
            header   = true;
            h_string = layout_work.body.string;
            top_sk   = &layout_work.body.pre_top_skip;
            p_sk     = &layout_work.body.post_skip;
            font     = layout_work.body.font;
            spacing_ln = g_spacing_ln;  // standard spacing
        }
        break;
    case   doc_sect_titlep:             // for preceding :BINCLUDE/:GRAPHIC
        page_e = ej_yes;

        init_nest_cb( true );

        nest_cb->gtag = t_TITLEP;
        nest_cb->p_stack->lineno = titlep_lineno; // correct line number
        break;
    case   doc_sect_abstract:
        page_r   = layout_work.abstract.page_reset;
        page_e   = layout_work.abstract.page_eject;
        if( layout_work.abstract.header ) {
            header = true;
            h_string = layout_work.abstract.string;
            top_sk   = &layout_work.abstract.pre_top_skip;
            p_sk     = &layout_work.abstract.post_skip;
            font     = layout_work.abstract.font;
            spacing_ln = layout_work.abstract.spacing;
        }
        break;
    case   doc_sect_preface:
        page_r   = layout_work.preface.page_reset;
        page_e   = layout_work.preface.page_eject;
        if( layout_work.preface.header ) {
            header = true;
            h_string = layout_work.preface.string;
            top_sk   = &layout_work.preface.pre_top_skip;
            p_sk     = &layout_work.preface.post_skip;
            font     = layout_work.preface.font;
            spacing_ln = layout_work.preface.spacing;
        }
        break;
    case   doc_sect_appendix:
        page_r   = layout_work.appendix.page_reset;
        page_e   = layout_work.appendix.page_eject;
        if( layout_work.appendix.header ) {
            header = true;
            h_string = layout_work.appendix.string;
            top_sk   = &layout_work.appendix.pre_top_skip;
            p_sk     = &layout_work.appendix.post_skip;
            font     = layout_work.appendix.font;
            spacing_ln = layout_work.appendix.spacing;
        }
        break;
    case   doc_sect_backm:
        page_r   = layout_work.backm.page_reset;
        page_e   = layout_work.backm.page_eject;
        if( layout_work.backm.header ) {
            header = true;
            h_string = layout_work.backm.string;
            top_sk   = &layout_work.backm.pre_top_skip;
            p_sk     = &layout_work.backm.post_skip;
            font     = layout_work.backm.font;
            spacing_ln = g_spacing_ln;  // standard spacing
        }
        break;
    case   doc_sect_index:
        page_r   = layout_work.index.page_reset;
        page_e   = layout_work.index.page_eject;
        if( layout_work.index.header ) {
            header = true;
            h_string = layout_work.index.index_string;
            top_sk   = &layout_work.index.pre_top_skip;
            p_sk     = &layout_work.index.post_skip;
            font     = layout_work.index.font;
            spacing_ln = layout_work.index.spacing;
        }
        break;
    default:
        new_section( ds );
        break;
    }

    if( first_section ) {               // nothing precedes the first section
        if( page_e == ej_even ) {
            do_page_out();              // apage of first page is odd
            page = 0;                   // restart page for first text page
        }
        new_section( ds );
        reset_t_page();
        document_new_position();        // first text page ready for content
    } else {
        full_page_out();                // ensure are on last page
        switch( page_e ) {              // page eject requested
        case ej_yes :
            finish_page_section( ds, true );// emit last page in old section
            if( page_r ) {
                page = 0;
            }
            reset_t_page();
            break;
        case ej_odd :
            if( !(apage & 1) ) {        // first page would be even
                do_page_out();          // emit last page in old section
                reset_t_page();
            }
            finish_page_section( ds, true );// emit last page in old section
            if( page_r ) {
                page = 0;
            }
            reset_t_page();
            break;
        case ej_even :
            if( (apage & 1) ) {         // first page will be odd
                do_page_out();          // emit last page in old section
                reset_t_page();
            }
            finish_page_section( ds, true );// emit last page in old section
            if( page_r ) {
                page = 0;
            }
            reset_t_page();
            break;
        default:                        //  ej_no
            new_section( ds );

            /****************************************************/
            /*  set page bottom banner/limit for new section    */
            /****************************************************/

            ind = !(page & 1);
            t_page.bottom_banner = sect_ban_bot[ind];
            if( sect_ban_bot[ind] != NULL ) {
                if( bin_driver->y_positive == 0 ) {
                    g_page_bottom = g_page_bottom_org + sect_ban_bot[ind]->ban_depth;
                } else {
                    g_page_bottom = g_page_bottom_org - sect_ban_bot[ind]->ban_depth;
                }
            } else {
                g_page_bottom = g_page_bottom_org;
            }
            break;
        }
    }
    g_cur_left = g_page_left_org;
    g_cur_h_start = g_page_left_org + g_indent;
    if( header ) {
        doc_header( p_sk, top_sk, h_string, font, spacing_ln, page_e == ej_no );
    }
    ProcFlags.doc_sect = ds;
}
Esempio n. 22
0
void start_doc_sect( void )
{
    bool                first_section;
    bool                header;
    bool                page_r;
    char            *   h_text;
    doc_section         ds;
    hdsrc               hds_lvl;
    int                 k;
    page_ej             page_e;
    uint32_t            page_c;
    uint32_t            page_s;


    if( ProcFlags.start_section ) {
        return;                         // once is enough
    }
    if( !ProcFlags.fb_document_done ) { // the very first section/page
        do_layout_end_processing();
    }

    scr_process_break();                // commit any prior text 

    first_section = (ProcFlags.doc_sect == doc_sect_none);

    ProcFlags.start_section = true;
    ProcFlags.keep_left_margin = false;

    page_c = layout_work.defaults.columns;
    ds = ProcFlags.doc_sect_nxt;    // new section

    if( ds == doc_sect_none ) {
        ds = doc_sect_body;      // if text without section start assume body
    }

    /***********************************************************************/
    /*  process special section attributes                                 */
    /***********************************************************************/

    switch( ds ) {
    case   doc_sect_titlep :
        page_c = layout_work.titlep.columns;
        page_e = ej_yes;
        page_r = false;                 // no page number reset
        header = false;                 // no header string (ABSTRACT, ... )  output
        init_nest_cb();
        nest_cb->p_stack = copy_to_nest_stack();
        nest_cb->c_tag = t_TITLEP;
        nest_cb->p_stack->lineno = titlep_lineno; // correct line number
        break;
    case   doc_sect_abstract :
        page_c = layout_work.abstract.columns;
        page_e = layout_work.abstract.page_eject;
        page_r = layout_work.abstract.page_reset;
        page_s = layout_work.hx.hx_sect[hds_abstract].spacing;
        header = layout_work.hx.hx_sect[hds_abstract].header;
        if( header ) {
            h_text = &layout_work.abstract.string;
            hds_lvl = hds_abstract;
        }
        break;
    case   doc_sect_preface :
        page_c = layout_work.preface.columns;
        page_e = layout_work.preface.page_eject;
        page_r = layout_work.preface.page_reset;
        page_s = layout_work.hx.hx_sect[hds_preface].spacing;
        header = layout_work.hx.hx_sect[hds_preface].header;
        if( header ) {
            h_text = &layout_work.preface.string;
            hds_lvl = hds_preface;
        }
        break;
    case   doc_sect_body :
        page_c = layout_work.body.columns;
        page_e = layout_work.body.page_eject;
        page_r = layout_work.body.page_reset;
        page_s = layout_work.hx.hx_sect[hds_body].spacing;
        header = layout_work.hx.hx_sect[hds_body].header;
        if( header ) {
            h_text = &layout_work.body.string;
            hds_lvl = hds_body;
        }
        break;
    case   doc_sect_appendix :
        page_c = layout_work.appendix.columns;
        page_e = layout_work.appendix.section_eject;
        page_r = layout_work.appendix.page_reset;
        page_s = layout_work.hx.hx_sect[hds_appendix].spacing;
        header = false;                 // no section header string output, as such
        if( page_e != ej_no ) {
            page_e = ej_yes;                        // "even" and "odd" act like "yes"
        }
        for( k = 1; k < hds_appendix; k++ ) {       // reset heading levels
            hd_nums[k].headn = 0;
            if( hd_nums[k].headnsub != NULL ) {
                *(hd_nums[k].headnsub->value) = '\0';
            }
        }
        break;
    case   doc_sect_backm :
        page_c = layout_work.backm.columns;
        page_e = layout_work.backm.page_eject;
        page_r = layout_work.backm.page_reset;
        page_s = layout_work.hx.hx_sect[hds_backm].spacing;
        header = layout_work.hx.hx_sect[hds_backm].header;
        if( header ) {
            h_text = &layout_work.backm.string;
            hds_lvl = hds_backm;
        }
        break;
    case   doc_sect_index :
        page_c = layout_work.index.columns;
        page_e = layout_work.index.page_eject;
        page_r = layout_work.index.page_reset;
        page_s = layout_work.hx.hx_sect[hds_index].spacing;
        header = layout_work.hx.hx_sect[hds_index].header;
        if( header ) {
            h_text = &layout_work.index.index_string;
            hds_lvl = hds_index;
        }
        break;
    case   doc_sect_gdoc :
    case   doc_sect_etitlep :
    case   doc_sect_frontm :
        page_c = layout_work.defaults.columns;
        page_e = ej_no;                         // no page eject
        page_r = false;                         // no page number reset
        page_s = layout_work.defaults.spacing;  // default spacing
        header = false;                         // no section header
        break;
    case   doc_sect_egdoc :
        page_c = layout_work.defaults.columns;
        page_e = ej_yes;
        page_r = false;                         // no page number reset
        page_s = layout_work.defaults.spacing;  // default spacing
        header = false;                         // no section header
        break;
    default:
        internal_err( __FILE__, __LINE__ );
        break;
    }

    if( first_section ) {               // nothing precedes the first section
        if( page_e == ej_even ) {
            do_page_out();              // apage of first page is odd
            page = 0;                   // restart page for first text page
            ProcFlags.page_ejected = true;
        }
        set_section_banners( ds );
        reset_t_page();
        document_new_position();        // first text page ready for content
    } else if( page_e == ej_no ) {
        full_page_out();                // ensure are on last page
        ProcFlags.page_ejected = false;
        set_section_banners( ds );
        reset_bot_ban();
    } else {
        last_page_out();                // ensure last page output
        ProcFlags.page_ejected = true;  // only first section has nothing to output

        if( page_e == ej_odd ) {
            if( (page & 1) ) {          // first page will be odd
                do_page_out();          // emit blank page
            }
        } else if( page_e == ej_even ) {
            if( !(page & 1) ) {         // first page will be even
                do_page_out();          // emit blank page
            }
        } else if( page_e != ej_yes ) {
            internal_err( __FILE__, __LINE__ );
        }
        g_skip = 0;                     // ignore remaining skip value
        set_section_banners( ds );
        reset_t_page();
    }

    ProcFlags.doc_sect = ds;
    t_page.col_count = page_c;
    set_cols();
    if( page_r ) {
        page = 0;
    }
    spacing = page_s;

    g_cur_left = g_page_left_org;
    if( header ) {
        line_position = pos_center;
        concat_save = ProcFlags.concat;
        ProcFlags.concat = true;
        justify_save = ProcFlags.justify;
        ProcFlags.justify = ju_off;
        gen_heading( h_text, NULL, 0, hds_lvl );
        g_indent = 0;                           // reset for section body
        ProcFlags.concat = concat_save;
        ProcFlags.justify = justify_save;
    }
    g_curr_font = layout_work.defaults.font;
    g_cur_h_start = g_page_left_org + g_indent;
    ProcFlags.doc_sect = ds;
}