Пример #1
0
// **************************************************************************
// **************************************************************************
// vma <a>
int P4_vmaccess(int argc, char* argv[])
{
	unsigned short int adr, rpt, upt;

	printf("\nValidate arguments...");	// ?? validate arguments
	adr = INTEGER(argv[1]);

	printf(" = %04x", getMemAdr(adr, 1)-&MEMWORD(0));
	for (rpt = 0; rpt < 64; rpt+=2)
	{
		if (MEMWORD(rpt+TASK_RPT) || MEMWORD(rpt+TASK_RPT+1))
		{
			outPTE("  RPT  =", rpt+TASK_RPT);
			for(upt = 0; upt < 64; upt+=2)
			{
				if (DEFINED(MEMWORD(rpt+TASK_RPT)) &&
						(DEFINED(MEMWORD((FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt))
								|| PAGED(MEMWORD((FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt+1))))
				{
					outPTE("    UPT=", (FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt);
				}
			}
		}
	}
	printf("\nPages = %d", nextPage);
	return 0;
} // end P4_vmaccess
Пример #2
0
unsigned short int *getMemAdr(int va, int rwFlg)
{
	unsigned short int pa;
	int rpta, rpte1, rpte2;
	int upta, upte1, upte2;
	int rptFrame, uptFrame;

	// turn off virtual addressing for system RAM
	if (va < 0x3000) return &memory[va];
#if MMU_ENABLE
	rpta = tcb[curTask].RPT + RPTI(va);		// root page table address
	rpte1 = memory[rpta];					// FDRP__ffffffffff
	rpte2 = memory[rpta+1];					// S___pppppppppppp
	if (DEFINED(rpte1))	{ }					// rpte defined
		else			{ }					// rpte undefined
	memory[rpta] = SET_REF(rpte1);			// set rpt frame access bit

	upta = (FRAME(rpte1)<<6) + UPTI(va);	// user page table address
	upte1 = memory[upta]; 					// FDRP__ffffffffff
	upte2 = memory[upta+1]; 				// S___pppppppppppp
	if (DEFINED(upte1))	{ }					// upte defined
		else			{ }					// upte undefined
	memory[upta] = SET_REF(upte1); 			// set upt frame access bit
	return &memory[(FRAME(upte1)<<6) + FRAMEOFFSET(va)];
#else
	return &memory[va];
#endif
} // end getMemAdr
Пример #3
0
// **************************************************************************
// **************************************************************************
// vma <a>
int P4_vmaccess(int argc, char* argv[])
{
	unsigned short int adr, rpt, upt;

	adr = INTEGER(argv[1]);
	printf(" = %04x", getMemAdr(adr, 1)-&MEMWORD(0));
	printf("\nRPTI:%d(0x%x) UPTI:%d(0x%x) OFFSET:%d(0x%x)", RPTI(adr)/2, RPTI(adr), UPTI(adr)/2, UPTI(adr), FRAMEOFFSET(adr), FRAMEOFFSET(adr));

	for (rpt = 0; rpt < 64; rpt+=2)
	{
		if (MEMWORD(rpt+TASK_RPT) || MEMWORD(rpt+TASK_RPT+1))
		{
			outPTE("  RPT  =", rpt+TASK_RPT);
			for(upt = 0; upt < 64; upt+=2)
			{
				if (DEFINED(MEMWORD(rpt+TASK_RPT)) &&
					(DEFINED(MEMWORD((FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt))
					|| PAGED(MEMWORD((FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt+1))))
				{
					outPTE("    UPT=", (FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt);
				}
			}
		}
	}
	printf("\nPages = %d", nextPage);
	return 0;
} // end P4_vmaccess
Пример #4
0
structure()
	{
	VERT v, *head;

	if (progress)
		fprintf(stderr,"	getreach:\n");
	getreach();
	if (routerr) return;
	if (progress)
		fprintf(stderr,"	getflow:\n");
	getflow();
	if (progress)
		fprintf(stderr,"	getthen:\n");
	getthen(START);
	head = challoc(nodenum * sizeof(*head));
	for (v = 0; v < nodenum; ++v)
		head[v] = UNDEFINED;
	for (v = START; DEFINED(v); v = RSIB(v))
		fixhd(v,UNDEFINED,head);
			/* fixhd must be called before getloop so that
				it gets applied to IFVX which becomes NXT(w) for UNTVX w */
	if (progress)
		fprintf(stderr,"	getloop:\n");
	getloop();
	if (progress)
		fprintf(stderr,"	getbranch:\n");
	getbranch(head);
	chfree(head,nodenum * sizeof(*head));
	head = 0;
	}
Пример #5
0
void dolog(int level, const char *msg,
           const char *func, const char *file, int line, ...)
{
    const bool use_colors = !DEFINED(__APPLE__) && !DEFINED(__EMSCRIPTEN__);
    char *msg_formatted, *full_msg;
    const char *format;
    char time_str[32] = "";
    va_list args;

    va_start(args, line);
    vasprintf(&msg_formatted, msg, args);
    va_end(args);

    if (use_colors && level >= GOX_LOG_WARN) {
        format = "\e[33;31m%s%-60s\e[m %s (%s:%d)";
    } else {
Пример #6
0
output()
	{
	VERT w;
	int i;
	brace = challoc(nodenum * sizeof(*brace));
	for (i = 0; i < nodenum; ++i)
		brace[i] = FALSE;
	if (progress) fprintf(stderr,"ndbrace:\n");
	for (w = START; DEFINED(w); w = RSIB(w))
		ndbrace(w);
	if (progress) fprintf(stderr,"outrat:\n");
	for (w = START; DEFINED(w); w = RSIB(w))
		outrat(w,0,YESTAB);
	OUTSTR("END\n");
	chfree(brace,nodenum * sizeof(*brace));
	brace = 0;
	}
Пример #7
0
void dump_rpt_and_upt()
{
  int rpt, upt;
  for (rpt = 0; rpt < 64; rpt+=2)
  {
    if (MEMWORD(rpt+TASK_RPT) || MEMWORD(rpt+TASK_RPT+1))
    {
      outPTE("  RPT  =", rpt+TASK_RPT);
      for(upt = 0; upt < 64; upt+=2)
      {
        if (DEFINED(MEMWORD(rpt+TASK_RPT)) &&(DEFINED(MEMWORD((FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt))
                          || PAGED(MEMWORD((FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt+1))))
        {
          outPTE("    UPT=", (FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt);
        }
      }
    }
  }
}
Пример #8
0
// **************************************************************************
// **************************************************************************
// look at virtual memory location va
void lookVM(int va)
{
   unsigned short int rpte1, rpte2, upte1, upte2, pa;

   // get root page table entry
	rpte1 = MEMWORD(LC3_RPT + RPTI(va));
   rpte2 = MEMWORD(LC3_RPT + RPTI(va) + 1);
   if (DEFINED(rpte1))
   {	upte1 = MEMWORD((FRAME(rpte1)<<6) + UPTI(va));
		upte2 = MEMWORD((FRAME(rpte1)<<6) + UPTI(va) + 1);
   }
   else
   {
		// rpte undefined
		printf("\n  RTB[Undefined]");
		return;
	}
  	if (DEFINED(upte1))
	{
		pa = (FRAME(upte1)<<6) + FRAMEOFFSET(va);
	}
   else
   {
		// upte undefined
     	printf("\n  UTB[Undefined]");
		return;
   }
   printf("\n  RPT[0x%04x] = %04x %04x", LC3_RPT + RPTI(va), rpte1, rpte2);
      if (rpte1&BIT_14_MASK) printf(" D");
      if (rpte1&BIT_13_MASK) printf(" R");
      if (rpte1&BIT_12_MASK) printf(" P");
      printf(" Frame=%d", rpte1&0x03ff);
      if (DEFINED(rpte2)) printf(" Page=%d", rpte2&0x0fff);
   printf("\n  UPT[0x%04x] = %04x %04x", (FRAME(rpte1)<<6) + UPTI(va), upte1, upte2);
      if (upte1&BIT_14_MASK) printf(" D");
      if (upte1&BIT_13_MASK) printf(" R");
      if (upte1&BIT_12_MASK) printf(" P");
      printf(" Frame=%d", upte1&0x03ff);
      if (DEFINED(upte2)) printf(" Page=%d", upte2&0x0fff);
   printf("\n  MEM[0x%04x] = %04x", pa, MEMWORD(pa));
	return;
} // end lookVM
Пример #9
0
// **************************************************************************
// **************************************************************************
// output page table entry
void outPTE(char* s, int pte)
{
	int pte1, pte2;
	char flags[10];

	// read pt
	pte1 = memory[pte];
	pte2 = memory[pte+1];

	// look at appropriate flags
	strcpy(flags, "-----");
	if (DEFINED(pte1)) flags[0] = 'F';
	if (DIRTY(pte1)) flags[1] = 'D';
	if (REFERENCED(pte1)) flags[2] = 'R';
	if (PINNED(pte1)) flags[3] = 'P';
	if (PAGED(pte2)) flags[4] = 'S';

	// output pte line
	if(DEFINED(pte1) || DEFINED(pte2))
		printf("\n%s x%04x = %04x %04x  %s", s, pte, pte1, pte2, flags);
	if (DEFINED(pte1) || DEFINED(pte2)) printf(" Frame=%d", FRAME(pte1));
	if (DEFINED(pte2)) printf(" Page=%d", SWAPPAGE(pte2));

	return;
} // end outPTE
Пример #10
0
getreach()		/* obtain REACH(v) for each node v */
	{
	VERT v;
	struct pair *pr;
	for (v = 0; v < nodenum; ++v)
		REACH(v) = UNDEFINED;
	number(START);
	for (v = START; DEFINED(v); v = RSIB(v))
		{
		pr = exits(v);	/* need to free the space for pr */
		chfree(pr,sizeof(*pr));
		}
	}
Пример #11
0
// **************************************************************************
// **************************************************************************
// display contents of UPT
void displayUPT(int rptNum, int uptNum)
{
	unsigned short int rpte, upt, upte1, upte2, uptba;
	rptNum &= BITS_3_0_MASK;
	uptNum &= BITS_4_0_MASK;

	// index to process <rptNum>'s rpt + <uptNum> index
	rpte = MEMWORD(((LC3_RPT + (rptNum<<6)) + uptNum*2));
	// calculate upt's base address
	uptba = uptNum<<11;
	if (!DEFINED(rpte))
		return;
	printf("\nUser Page Table %d", FRAME(rpte));
	upt = FRAME(rpte)<<6;
	displayPT(upt, uptba, 1<<6);
	return;
} // end displayUPT
Пример #12
0
static 
void configure_caches(cache_t* I1c, cache_t* D1c, cache_t* L2c)
{
#define DEFINED(L)   (-1 != L.size  || -1 != L.assoc || -1 != L.line_size)

   Int n_clos = 0;

   // Count how many were defined on the command line.
   if (DEFINED(clo_I1_cache)) { n_clos++; }
   if (DEFINED(clo_D1_cache)) { n_clos++; }
   if (DEFINED(clo_L2_cache)) { n_clos++; }

   // Set the cache config (using auto-detection, if supported by the
   // architecture)
   VG_(configure_caches)( I1c, D1c, L2c, (3 == n_clos) );

   // Then replace with any defined on the command line.
   if (DEFINED(clo_I1_cache)) { *I1c = clo_I1_cache; }
   if (DEFINED(clo_D1_cache)) { *D1c = clo_D1_cache; }
   if (DEFINED(clo_L2_cache)) { *L2c = clo_L2_cache; }

   // Then check values and fix if not acceptable.
   check_cache(I1c, "I1");
   check_cache(D1c, "D1");
   check_cache(L2c, "L2");

   if (VG_(clo_verbosity) > 1) {
      VG_(message)(Vg_UserMsg, "Cache configuration used:");
      VG_(message)(Vg_UserMsg, "  I1: %dB, %d-way, %dB lines",
                               I1c->size, I1c->assoc, I1c->line_size);
      VG_(message)(Vg_UserMsg, "  D1: %dB, %d-way, %dB lines",
                               D1c->size, D1c->assoc, D1c->line_size);
      VG_(message)(Vg_UserMsg, "  L2: %dB, %d-way, %dB lines",
                               L2c->size, L2c->assoc, L2c->line_size);
   }
#undef CMD_LINE_DEFINED
}
Пример #13
0
static int update(gesture_t *gest, const inputs_t *inputs, int mask)
{
    const touch_t *ts = inputs->touches;
    int nb_ts = 0;
    int i, j;

    for (i = 0; i < ARRAY_SIZE(inputs->touches); i++) {
        for (j = 0; j < ARRAY_SIZE(inputs->touches[i].down); j++) {
            if (ts[i].down[j]) {
                nb_ts++;
                break;
            }
        }
    }

    if (gest->type == GESTURE_DRAG) {
        switch (gest->state) {
        case GESTURE_POSSIBLE:
            if (nb_ts == 1 && ts[0].down[gest->button]) {
                vec2_copy(ts[0].pos, gest->start_pos[0]);
                vec2_copy(gest->start_pos[0], gest->pos);
                if (!rect_contains(gest->viewport, gest->pos)) {
                    gest->state = GESTURE_FAILED;
                    break;
                }
                gest->state = (mask & (GESTURE_CLICK | GESTURE_PINCH)) ?
                            GESTURE_RECOGNISED : GESTURE_BEGIN;
            }
            break;
        case GESTURE_RECOGNISED:
            if (vec2_dist(gest->start_pos[0], ts[0].pos) >= g_start_dist)
                gest->state = GESTURE_BEGIN;
            if (nb_ts == 0) {
                gest->state = (!(mask & GESTURE_CLICK)) ?
                    GESTURE_BEGIN : GESTURE_FAILED;
            }
            if (nb_ts > 1) gest->state = GESTURE_FAILED;
            break;
        case GESTURE_BEGIN:
        case GESTURE_UPDATE:
            vec2_copy(ts[0].pos, gest->pos);
            gest->state = GESTURE_UPDATE;
            if (!ts[0].down[gest->button])
                gest->state = GESTURE_END;
            break;
        }
    }

    if (gest->type == GESTURE_CLICK) {
        vec2_copy(ts[0].pos, gest->pos);
        switch (gest->state) {
        case GESTURE_POSSIBLE:
            if (ts[0].down[gest->button]) {
                vec2_copy(ts[0].pos, gest->start_pos[0]);
                gest->state = GESTURE_RECOGNISED;
            }
            break;
        case GESTURE_RECOGNISED:
            if (!ts[0].down[gest->button])
                gest->state = GESTURE_TRIGGERED;
            break;
        }
    }

    if (gest->type == GESTURE_PINCH) {
        switch (gest->state) {
        case GESTURE_POSSIBLE:
            if (ts[0].down[0] && ts[1].down[0]) {
                gest->state = GESTURE_BEGIN;
                vec2_copy(ts[0].pos, gest->start_pos[0]);
                vec2_copy(ts[1].pos, gest->start_pos[1]);
                gest->pinch = 1;
                gest->rotation = 0;
                vec2_mix(ts[0].pos, ts[1].pos, 0.5, gest->pos);
            }
            break;
        case GESTURE_BEGIN:
        case GESTURE_UPDATE:
            gest->state = GESTURE_UPDATE;
            gest->pinch = vec2_dist(ts[0].pos, ts[1].pos) /
                          vec2_dist(gest->start_pos[0], gest->start_pos[1]);
            gest->rotation = get_angle(gest->start_pos[0], gest->start_pos[1],
                                       ts[0].pos, ts[1].pos);
            vec2_mix(ts[0].pos, ts[1].pos, 0.5, gest->pos);
            if (!ts[0].down[0] || !ts[1].down[0])
                gest->state = GESTURE_END;
            break;
        }
    }

    if (gest->type == GESTURE_HOVER) {
        switch (gest->state) {
        case GESTURE_POSSIBLE:
            if (DEFINED(GOXEL_MOBILE)) break; //Workaround.
            if (nb_ts == 0) {
                vec2_copy(ts[0].pos, gest->pos);
                if (rect_contains(gest->viewport, gest->pos)) {
                    gest->state = GESTURE_BEGIN;
                }
            }
            break;
        case GESTURE_BEGIN:
        case GESTURE_UPDATE:
            vec2_copy(ts[0].pos, gest->pos);
            gest->state = rect_contains(gest->viewport, gest->pos) ?
                GESTURE_UPDATE : GESTURE_END;
            break;
        }
    }

    return 0;
}
Пример #14
0
unsigned short int *getMemAdr(int va, int rwFlg)
{
	unsigned short int pa;
	int rpta, rpte1, rpte2;
	int upta, upte1, upte2;
	int rptFrame, uptFrame;

	rpta = 0x2400 + RPTI(va) + 0x40*curTask; // address of the root page table
	rpte1 = memory[rpta];		// get a word
	rpte2 = memory[rpta+1];		// get another word

	// turn off virtual addressing for system RAM
	if (va < 0x3000) return &memory[va];
#if MMU_ENABLE

	// printf("using memory Management\n");

	if (DEFINED(rpte1))
	{
		memHits++;
		// defined
	}
	else
	{
		memPageFaults++;
		// fault
		rptFrame = getFrame(-1);
		rpte1 = SET_DEFINED(rptFrame); // setting the frame bit in the user page table
		rpte1 = SET_DIRTY(rpte1);
		if (PAGED(rpte2)) // it exists in swap space
		{
			accessPage(SWAPPAGE(rpte2), rptFrame, PAGE_READ);
		}
		else
		{
			memset(&memory[(rptFrame<<6)], 0, 128); //sets 128 bytes to 0 why is it 128? why bitshift by 6?
		}
	}


	memory[rpta] = rpte1 = SET_REF(rpte1); // sets the referenced bit in the root page table
	memory[rpta+1] = rpte2;

	upta = (FRAME(rpte1)<<6) + UPTI(va);
	upte1 = memory[upta];
	upte2 = memory[upta+1];

	if (DEFINED(upte1))
	{
		memHits++;
		// defined
	}
	else
	{
		memPageFaults++;
		// fault
		uptFrame = getFrame(FRAME(memory[rpta]));
		upte1 = SET_DEFINED(uptFrame);
		upte1 = SET_DIRTY(upte1);
		if (PAGED(upte2))
		{
			accessPage(SWAPPAGE(upte2), uptFrame, PAGE_READ);
		}
		else
		{
			memset(&memory[(uptFrame<<6)], 0, 128); //sets 128 bytes to 0 why is it 128? why bitshift by 6?
		}
	}

	if(rwFlg){
		memory[rpta] = SET_DIRTY(memory[rpta]);
	}else{

	}

	memory[upta] = SET_REF(upte1);
	memory[upta+1] = upte2;

	return &memory[(FRAME(upte1)<<6) + FRAMEOFFSET(va)];
#else
	return &memory[va];
#endif
} // end getMemAdr
Пример #15
0
int getFrame(int notme)
{
	int frame;
	frame = getAvailableFrame();
	if (frame >=0) return frame;

	// run clock
	int i, j, upta, frameToRemove;
	i = lastRpte;
	// i = 0x2400;
	// j = lastUpte;
	while(1){
		// for(i=0x2400;i<0x3000;i+=2){
			// printf("%x", i);
			if(DEFINED(memory[i])){

				upta = FRAME(memory[i]);
				upta = (upta<<6);

				//double confirm
				int k;
				bool nothingInFrame = 1;
				for(k=upta;k<upta+64;k+=2){
					if(DEFINED(memory[k])){
						nothingInFrame = 0;
						break;
					}
				}

				if(nothingInFrame && FRAME(memory[i])!=notme){
					frameToRemove = FRAME(memory[i]);
					lastRpte=i+2;
					memory[i] = CLEAR_DEFINED(memory[i]);
					memory[i] = CLEAR_REF(memory[i]);

					if(PAGED(memory[i+1]) && DIRTY(memory[i])){
						memory[i+1] = accessPage(SWAPPAGE(memory[i+1]), frameToRemove, PAGE_OLD_WRITE);
					}else{
						memory[i+1] = accessPage(0, frameToRemove, PAGE_NEW_WRITE);
					}
					memory[i+1] = SET_PAGED(memory[i+1]);
					memory[i] = SET_DIRTY(memory[i]);
					//possibly clear frame number
					return frameToRemove;
					// i can swap out this upt
				}

				// for(j=upta;j<upta+64;j+=2){
				while(uptOffset < 64){
					j = upta + uptOffset;
				
					if(DEFINED(memory[j])){
						if(REFERENCED(memory[j])){
							memory[j] = CLEAR_REF(memory[j]);
						}else{
							//use this data frame
							frameToRemove = FRAME(memory[j]);
							lastRpte = i;
							memory[j] = CLEAR_DEFINED(memory[j]);
							memory[j] = CLEAR_REF(memory[j]);
							// memory[j] = SWAPPAGE(memory[j]);
							if(PAGED(memory[j+1]) && DIRTY(memory[j])){
								memory[j+1] = accessPage(SWAPPAGE(memory[j+1]), frameToRemove, PAGE_OLD_WRITE);
							}else{
								memory[j+1] = accessPage(0, frameToRemove, PAGE_NEW_WRITE);
							}
							memory[j+1] = SET_PAGED(memory[j+1]);
							uptOffset+=2; // may not need this line
							//need to loop through rest next time but if nothing dont remove this one
							return frameToRemove;
						}
					}

					uptOffset+=2;
				}
				uptOffset = 0;
				// }
			}
		i+=2;
		if(i==0x3000){
			i=0x2400;
		}
		// }
	}

	// memory[(frameToRemove<<6)] 
	return frame;
}
Пример #16
0
int getClockFrame(int notme)
{
    int frame;

    // iterate through rpts (0x2400 - LC3_RPT_END)
    int maxWrap = 20;
    for (;maxWrap; cBigHand += 2, cLittleHand = 0) {
        int i;
        int rpte1;
        int upta, upte1;

        if (cBigHand >= LC3_RPT_END) {
            DEBUG_STATEMENT(DEBUG_MMU,"\nClock is wrapping");
            cBigHand = LC3_RPT;
            maxWrap--;
        }

        rpte1 = memory[cBigHand];

        if (DEFINED(rpte1) && REFERENCED(rpte1)) {
            // clear reference
            DEBUG_STATEMENT(DEBUG_MMU,"\nclearing ref for rpte");
            memory[cBigHand] = rpte1 = CLEAR_REF(rpte1);
        } else if (DEFINED(rpte1)) { // if one is non-referenced go to the user page table
            // scout out the upt!! note that this has not been referenced
            if (DEBUG_MMU) { outPTE("\nRPT entry being checked - ", cBigHand); }
            upta = (FRAME(rpte1)<<6);

            for (i = cLittleHand % 64; i < 64;i += 2, cLittleHand = i % 64) { // - iterate over userpage table
                upte1 = memory[upta + (i)];
                if (PINNED(upte1) || FRAME(upte1) == notme) {
                    DEBUG_STATEMENT(DEBUG_MMU,"\nupte1 frame was the notme frame (%x = %x) or pinned", FRAME(upte1), notme);
                    if (DEBUG_MMU) { outPTE("UPT entry being checked - ", upta + i); }

                    continue;
                }

                if (DEFINED(upte1) && REFERENCED(upte1)) { // - if entry is referenced un-reference and move on
                    // clear reference
                    DEBUG_STATEMENT(DEBUG_MMU,"\nclearing ref for upte %d", cLittleHand);
                    memory[cBigHand] = rpte1 = SET_PINNED(rpte1);
                    memory[upta + (i)] = upte1 = CLEAR_REF(upte1);
                } else if (DEFINED(upte1)) { // - otherwise prep it for being put into swap
                    // we can use the frame referenced by upte1
                    if (DEBUG_MMU) { outPTE("UPT entry being checked - ", upta + 1); }
                    DEBUG_STATEMENT(DEBUG_MMU,"\nUpte1 %x, Upte2 %x", upte1, memory[upta + (i + 1)]);
                    memory[cBigHand] = rpte1 = SET_DIRTY(rpte1);
                    frame = FRAME(upte1);
                    swapOutFrame(upta + i);
                    cLittleHand += 2;
                    DEBUG_STATEMENT(DEBUG_MMU,"\nFound a data frame that can be used! (%d, %x)", frame, frame);

                    return frame;
                }
            }

            cLittleHand = 0;
            if (!REFERENCED(rpte1) && !PINNED(rpte1) && FRAME(rpte1) != notme) { // if we only replaced or did nothing to upte entries
                // we can use the frame referenced by rpte1
                frame = FRAME(rpte1);

                DEBUG_STATEMENT(DEBUG_MMU,"\nFound a upt frame that can be used! (%d, %x)", frame, frame);
                swapOutFrame(cBigHand);
                cBigHand += 2;
                return frame;
            } else { // otherwise remove the pin flag
                memory[cBigHand] = rpte1 = CLEAR_PINNED(rpte1);
            }

        }
    } // when you get the bottom start at the top again

    DEBUG_STATEMENT(DEBUG_MMU,"\n No valid frame found notme = %d", notme);
    if (DEBUG_MMU) {  displayTableHierarchy(); }

    return -1;
}
Пример #17
0
unsigned short int *getMemAdr(int va, int rwFlg)
{
	unsigned short int pa;
	int rpta, rpte1, rpte2;
	int upta, upte1, upte2;
	int rptFrame, uptFrame;
    memAccess += 2;

//	rpta = 0x2400 + RPTI(va);
    rpta = tcb[curTask].RPT + RPTI(va);
	rpte1 = memory[rpta];
	rpte2 = memory[rpta+1];

	// turn off virtual addressing for system RAM
	if (va < 0x3000) return &memory[va];
#if MMU_ENABLE
	if (DEFINED(rpte1))
	{
//        printf("\nUPT frame already defined");
		// defined
        memHits++;
	}
	else
	{
		// fault
        memPageFaults++;
		rptFrame = getFrame(-1);
		rpte1 = SET_DEFINED(rptFrame);
		if (PAGED(rpte2))
		{
            //upt is in swap and we need to read it back in
			accessPage(SWAPPAGE(rpte2), rptFrame, PAGE_READ);
		}
		else
		{
            //initialize the upt memory
            memset(&memory[(rptFrame<<6)], 0, 128);
		}
	}


	memory[rpta] = rpte1 = SET_REF(rpte1);
	memory[rpta+1] = rpte2;

	upta = (FRAME(rpte1)<<6) + UPTI(va);
	upte1 = memory[upta];
	upte2 = memory[upta+1];

	if (DEFINED(upte1))
	{
		// defined
        memHits++;
	}
	else
	{
		// fault
        memPageFaults++;
		uptFrame = getFrame(FRAME(memory[rpta]));
        memory[rpta] = rpte1 = SET_REF(SET_DIRTY(rpte1));
        upte1 = SET_DEFINED(uptFrame);

        if (PAGED(upte2))
		{
            //get the data frame from swap
			accessPage(SWAPPAGE(upte2), uptFrame, PAGE_READ);
		}
		else
		{
            //we don't need to do anything
            //but we could initialize the mem to 0xf025 which is lc-3 halt instruction
            memset(&memory[(uptFrame<<6)], 0xf025, 128);
		}
	}

    if (rwFlg) {
        upte1 = SET_DIRTY(upte1);
    }

    memory[upta] = SET_REF(upte1);
	memory[upta+1] = upte2;

	return &memory[(FRAME(upte1)<<6) + FRAMEOFFSET(va)];
#else
	return &memory[va];
#endif
} // end getMemAdr
Пример #18
0
int getFrame(int notme)
{
	int UPTClock;						// clock for UPT
	int frame;
	frame = getAvailableFrame();
	if (frame >=0) return frame;

	if(RPTClock == 0){
		RPTClock = LC3_RPT;
	}


	int RPTBegin = RPTClock;
	int first = 1;
	int rptCount = 0;

	//iterate the first time through the tables
	while(first || RPTClock != RPTBegin){
		rptCount++;
		first = 0;
		//Check and make sure the notme condition holds
		if(DEFINED(memory[RPTClock])){
			UPTClock = (FRAME(memory[RPTClock])<<6);
			int UPTBegin = UPTClock;
			int uFirst = 1;

			int hadDefined = 0;
			int uptcount = 0;
			while(uFirst || UPTClock != UPTBegin){
				uptcount++;

				uFirst = 0;
				if(DEFINED(memory[UPTClock])){
					hadDefined = 1;
				}
				if(notme != UPTClock && DEFINED(memory[UPTClock])){
					//swap out if not referenced
					if(!REFERENCED(memory[UPTClock])){
						//if it's dirty, write it to memory
						int swapPage = 0;
						if (DIRTY(memory[UPTClock])){
							if(PAGED(memory[UPTClock + 1])) swapPage = accessPage(SWAPPAGE(memory[UPTClock + 1]), FRAME(memory[UPTClock]), PAGE_OLD_WRITE);
							else swapPage = accessPage(0, FRAME(memory[UPTClock]), PAGE_NEW_WRITE);
							memory[UPTClock] = CLEAR_DIRTY(memory[UPTClock]);
							memory[UPTClock+1] = SET_PAGED(swapPage);
							pageWrites++;
						}

						//no longer in main memory--it's swapped!
						memory[UPTClock] = CLEAR_DEFINED(memory[UPTClock]);
						//increment the clock
						if(RPTClock + 2 < LC3_RPT_END)
									RPTClock += 2;
								else
									RPTClock = LC3_RPT;
						return FRAME(memory[UPTClock]);
					}
					memory[UPTClock] = CLEAR_REF(memory[UPTClock]);
				}

				//sanity check
				assert(UPTClock >= 0x3000);
				if(UPTClock + 2 < UPTBegin + LC3_FRAME_SIZE)
					UPTClock += 2;
				else
					UPTClock = UPTBegin;
			}

			if(!REFERENCED(memory[RPTClock]) && !hadDefined && notme != RPTClock){
				int swapPage;
				if(PAGED(memory[RPTClock + 1])) swapPage = accessPage(SWAPPAGE(memory[RPTClock + 1]), FRAME(memory[RPTClock]), PAGE_OLD_WRITE);
				else swapPage = accessPage(0, FRAME(memory[RPTClock]), PAGE_NEW_WRITE);

				memory[RPTClock] = CLEAR_DIRTY(memory[RPTClock]);
				memory[RPTClock+1] = SET_PAGED(swapPage);
				pageWrites++;

				memory[RPTClock] = CLEAR_DEFINED(memory[RPTClock]);

				int rE1 = memory[RPTClock];

				if(RPTClock + 2 < LC3_RPT_END)
							RPTClock += 2;
						else
							RPTClock = LC3_RPT;
				return FRAME(rE1);
			}

			//clear the reference bit
			memory[RPTClock] = CLEAR_REF(memory[RPTClock]);
		}

		if(RPTClock + 2 < LC3_RPT_END){
			RPTClock += 2;
		}
		else{
			RPTClock = LC3_RPT;
		}
	}

	RPTBegin = RPTClock;
	first = 1;

	while(first || RPTClock != RPTBegin){
		rptCount++;
		first = 0;
		//Check and make sure the notme condition holds
		if(DEFINED(memory[RPTClock])){
			UPTClock = (FRAME(memory[RPTClock])<<6);
			int UPTBegin = UPTClock;
			int uFirst = 1;

			int hadDefined = 0;
			int uptcount = 0;
			while(uFirst || UPTClock != UPTBegin){
				uptcount++;

				uFirst = 0;
				if(DEFINED(memory[UPTClock])){
					hadDefined = 1;
				}
				if(notme != UPTClock && DEFINED(memory[UPTClock])){
					//swap out if not referenced
					if(!REFERENCED(memory[UPTClock])){
						//if it's dirty, write it to memory
						int swapPage = 0;
						if (DIRTY(memory[UPTClock])){
							if(PAGED(memory[UPTClock + 1])) swapPage = accessPage(SWAPPAGE(memory[UPTClock + 1]), FRAME(memory[UPTClock]), PAGE_OLD_WRITE);
							else swapPage = accessPage(0, FRAME(memory[UPTClock]), PAGE_NEW_WRITE);
							memory[UPTClock] = CLEAR_DIRTY(memory[UPTClock]);
							memory[UPTClock+1] = SET_PAGED(swapPage);
							pageWrites++;
						}

						//no longer in main memory--it's swapped!
						memory[UPTClock] = CLEAR_DEFINED(memory[UPTClock]);
						//increment the clock
						if(RPTClock + 2 < LC3_RPT_END)
									RPTClock += 2;
								else
									RPTClock = LC3_RPT;
						return FRAME(memory[UPTClock]);
					}
					memory[UPTClock] = CLEAR_REF(memory[UPTClock]);
				}

				//sanity check
				assert(UPTClock >= 0x3000);
				if(UPTClock + 2 < UPTBegin + LC3_FRAME_SIZE)
					UPTClock += 2;
				else
					UPTClock = UPTBegin;
			}

			if(!REFERENCED(memory[RPTClock]) && !hadDefined && notme != RPTClock){
				int swapPage;
				if(PAGED(memory[RPTClock + 1])) swapPage = accessPage(SWAPPAGE(memory[RPTClock + 1]), FRAME(memory[RPTClock]), PAGE_OLD_WRITE);
				else swapPage = accessPage(0, FRAME(memory[RPTClock]), PAGE_NEW_WRITE);

				memory[RPTClock] = CLEAR_DIRTY(memory[RPTClock]);
				memory[RPTClock+1] = SET_PAGED(swapPage);
				pageWrites++;

				memory[RPTClock] = CLEAR_DEFINED(memory[RPTClock]);

				int rE1 = memory[RPTClock];

				if(RPTClock + 2 < LC3_RPT_END)
							RPTClock += 2;
						else
							RPTClock = LC3_RPT;
				return FRAME(rE1);
			}

			//clear the reference bit
			memory[RPTClock] = CLEAR_REF(memory[RPTClock]);
		}

		if(RPTClock + 2 < LC3_RPT_END){
			RPTClock += 2;
		}
		else{
			RPTClock = LC3_RPT;
		}
	}




	//we should never ever be here
	assert(0);



	return -1;
}
Пример #19
0
unsigned short int *getMemAdr(int va, int rwFlg)
{
	unsigned short int pa;
	int rpta, rpte1, rpte2;
	int upta, upte1, upte2;
	int rptFrame, uptFrame;


	rpta = tcb[curTask].RPT + RPTI(va);
	rpte1 = memory[rpta];
	rpte2 = memory[rpta+1];

	// turn off virtual addressing for system RAM
	if (va < 0x3000) return &memory[va];


#if MMU_ENABLE
	if (DEFINED(rpte1))
	{
		memHits++;
	}
	else
	{
		// fault
		memPageFaults++;
		rptFrame = getFrame(-1);
		assert(rptFrame >= 192);
		rpte1 = SET_DEFINED(rptFrame);
		if (PAGED(rpte2))
		{
			accessPage(SWAPPAGE(rpte2), rptFrame, PAGE_READ);
			pageReads++;
		}
		else
		{
			rpte1 = SET_DIRTY(rpte1); rpte2 = 0;
			memset(&memory[(rptFrame<<6)], 0, 128);
		}
	}


	memory[rpta] = rpte1 = SET_REF(rpte1);
	memory[rpta+1] = rpte2;

	upta = (FRAME(rpte1)<<6) + UPTI(va);
	upte1 = memory[upta];
	upte2 = memory[upta+1];

	if (DEFINED(upte1))
	{
		memHits++;
	}
	else
	{
		// fault
		memPageFaults++;
		uptFrame = getFrame(FRAME(memory[rpta]));
		assert(uptFrame >= 192);
		upte1 = SET_DEFINED(uptFrame);
		if (PAGED(upte2))
		{
			accessPage(SWAPPAGE(upte2), uptFrame, PAGE_READ);
			pageReads++;
		}
		else
		{
			upte1 = SET_DIRTY(upte1); upte2 = 0;
		}
	}

	if(rwFlg != 0){
		upte1 = SET_DIRTY(upte1);
	}

	memory[upta] = SET_REF(upte1);
	memory[upta+1] = upte2;

	memAccess = memHits + memPageFaults;
	return &memory[(FRAME(upte1)<<6) + FRAMEOFFSET(va)];
#else
	pa = va;
#endif
	return &memory[pa];
} // end getMemAdr
Пример #20
0
void single_hook_fill(pTHX_ const char *hook, const char *type, SingleHook *sth,
                            SV *sub, U32 allowed_args)
{
  if (!DEFINED(sub))
  {
    sth->sub = NULL;
    sth->arg = NULL;
  }
  else if (SvROK(sub))
  {
    SV *sv = SvRV(sub);

    switch (SvTYPE(sv))
    {
      case SVt_PVCV:
        sth->sub = sv;
        sth->arg = NULL;
        break;

      case SVt_PVAV:
        {
          AV *in = (AV *) sv;
          I32 len = av_len(in);

          if (len < 0)
            Perl_croak(aTHX_ "Need at least a code reference in %s hook for "
                             "type '%s'", hook, type);
          else
          {
            SV **pSV = av_fetch(in, 0, 0);

            if (pSV == NULL || !SvROK(*pSV) ||
                SvTYPE(sv = SvRV(*pSV)) != SVt_PVCV)
              Perl_croak(aTHX_ "%s hook defined for '%s' is not "
                               "a code reference", hook, type);
            else
            {
              I32 ix;
              AV *out;

              for (ix = 0; ix < len; ++ix)
              {
                pSV = av_fetch(in, ix+1, 0);
                
                if (pSV == NULL)
                  fatal("NULL returned by av_fetch() in single_hook_fill()");

                if (SvROK(*pSV) && sv_isa(*pSV, ARGTYPE_PACKAGE))
                {
                  HookArgType argtype = (HookArgType) SvIV(SvRV(*pSV));

#define CHECK_ARG_TYPE(type)                                   \
          case HOOK_ARG_ ## type:                              \
            if ((allowed_args & SHF_ALLOW_ARG_ ## type) == 0)  \
              Perl_croak(aTHX_ #type " argument not allowed"); \
            break

                  switch (argtype)
                  {
                    CHECK_ARG_TYPE(SELF);
                    CHECK_ARG_TYPE(TYPE);
                    CHECK_ARG_TYPE(DATA);
                    CHECK_ARG_TYPE(HOOK);
                  }

#undef CHECK_ARG_TYPE
                }
              }

              sth->sub = sv;

              out = newAV();
              av_extend(out, len-1);

              for (ix = 0; ix < len; ++ix)
              {
                pSV = av_fetch(in, ix+1, 0);

                if (pSV == NULL)
                  fatal("NULL returned by av_fetch() in single_hook_fill()");

                SvREFCNT_inc(*pSV);

                if (av_store(out, ix, *pSV) == NULL)
                  SvREFCNT_dec(*pSV);
              }

              sth->arg = (AV *) sv_2mortal((SV *) out);
            }
          }
        }
        break;

      default:
        goto not_code_or_array_ref;
    }
  }
  else
  {
not_code_or_array_ref:
    Perl_croak(aTHX_ "%s hook defined for '%s' is not "
                     "a code or array reference", hook, type);
  }
}
Пример #21
0
unsigned short int *getMemAdr(int va, int rwFlg)
{
	unsigned short int pa;
	int rpta, rpte1, rpte2;
	int upta, upte1, upte2;
	int rptFrame, uptFrame;
	extern TCB tcb[MAX_TASKS];
	extern int curTask;

	//stat
	memAccess++;

	rpta = tcb[curTask].RPT + RPTI(va);	// 0x2400 + RPTI(va);
	rpte1 = memory[rpta];
	rpte2 = memory[rpta+1];

	// turn off virtual addressing for system RAM
	if (va < 0x3000) return &memory[va];
#if MMU_ENABLE
	if (DEFINED(rpte1))
	{
		// defined
		//stat
		memHits++;
		if (rwFlg)
			rpte1 = SET_DIRTY(rpte1);
	}
	else
	{
		// fault
		//stat
		memPageFaults++;

		rptFrame = getFrame(-1);
		rpte1 = SET_DEFINED(rptFrame);
		if (PAGED(rpte2))
		{
			accessPage(SWAPPAGE(rpte2), rptFrame, PAGE_READ);
			//stat
			pageReads++;
			//clean
			if (rwFlg)
				rpte1 = SET_DIRTY(rpte1);
			else
				rpte1 = CLEAR_DIRTY(rpte1);
		}
		else
		{
			memset(&memory[(rptFrame<<6)], 0, 128);
			//dirty
			rpte1 = SET_DIRTY(rpte1);
		}
	}

	
	rpte1 = SET_PINNED(rpte1);
	memory[rpta] = rpte1 = SET_REF(rpte1);
	memory[rpta+1] = rpte2;

	upta = (FRAME(rpte1)<<6) + UPTI(va);
	upte1 = memory[upta];
	upte2 = memory[upta+1];

	//stat
	memAccess++;

	if (DEFINED(upte1))
	{
		// defined
		//stat
		memHits++;
		if (rwFlg)
			upte1 = SET_DIRTY(upte1);
	}
	else
	{
		// fault
		//stat
		memPageFaults++;

		uptFrame = getFrame(FRAME(memory[rpta]));
		upte1 = SET_DEFINED(uptFrame);
		if (PAGED(upte2))
		{
			accessPage(SWAPPAGE(upte2), uptFrame, PAGE_READ);
			//stat
			pageReads++;
			//clean unless being written to
			if (rwFlg)
				upte1 = SET_DIRTY(upte1);
			else
				upte1 = CLEAR_DIRTY(upte1);
		}
		else
		{
			//dirty
			upte1 = SET_DIRTY(upte1);
		}
	}

	rpte1 = SET_PINNED(rpte1);
	memory[rpta] = rpte1;
	memory[upta] = upte1 = SET_REF(upte1);
	memory[upta+1] = upte2;


	return &memory[(FRAME(upte1)<<6) + FRAMEOFFSET(va)];
#else
	return &memory[va];
#endif
} // end getMemAdr
Пример #22
0
int clockRunner(int notme)
{
	//extern int curRPT;
	//extern TCB tcb[MAX_TASKS];
	int i,j,k;
	int rpta, rpte1, rpte2;
	int upta, upte1, upte2;
	int victimFrame;
	int tupta, tupte1;

	//printf("\nClock running...%d\n",clockCount++);
	//victimEntry = 0;

	while (1)
	{
		//rpta = tcb[curRPT].RPT;
		for (i = curRPTE; i < 0x3000; i+=2)
		{
			//rpte1 = memory[rpta + i];
			//rpte2 = memory[rpta + i + 1];
			rpte1 = memory[i];
			rpte2 = memory[i + 1];
			
			if (DEFINED(rpte1))
			{
				if (curUPTE == 0)
				{
					if(PINNED(rpte1))
					{
						//memory[rpta + i] = rpte1 = CLEAR_PINNED(rpte1);
						memory[i] = rpte1 = CLEAR_PINNED(rpte1);
					}

				}

				upta = (FRAME(rpte1)<<6);

				for (j = curUPTE; j < 64; j+=2)
				{
					upte1 = memory[upta + j];
					upte2 = memory[upta + j + 1];

					if (DEFINED(upte1))
					{
						//memory[rpta + i] = rpte1 = SET_PINNED(rpte1);
						memory[i] = rpte1 = SET_PINNED(rpte1);

						if (REFERENCED(upte1))
						{
							memory[upta + j] = upte1 = CLEAR_REF(upte1);
						}
						else
						{
							//victimEntry = upte1;
							// if end of UPT, reset upte and move to next UPT
							//break;	// because this is the victim
							// instead of break, do swapping and return victim frame number

							// immunity from notme
							//if (FRAME(upte1) != notme)
							//{ 	
							
								if (DIRTY(upte1))
								{
									int page;

									//stat
									pageWrites++;

									if(PAGED(upte2))
									{
										page = accessPage(SWAPPAGE(upte2),FRAME(upte1),PAGE_OLD_WRITE);
									}
									else
									{
										page = accessPage(0,FRAME(upte1),PAGE_NEW_WRITE);
									}

									upte2 = page;
									memory[upta + j + 1] = upte2 = SET_PAGED(upte2);
									
								}


								// save frame number before obliterating first word
								victimFrame = FRAME(upte1);
								//memory[upta + j] = upte1 = CLEAR_DEFINED(upte1);
								memory[upta + j] = upte1 = 0;

								curUPTE = (j + 2) % 64;

								//printf("\nChose a UPT victim: %d\n",victimFrame);
								return victimFrame;
							//}
						}
					}
				}

				// immunity from notme
				if ((FRAME(rpte1) != notme) && (!PINNED(rpte1)))
				{
					//victimEntry = rpte1;
					// if end of RPT, reset rpte and move to next RPT
					//break;		// because this is the victim
					// instead of break, do swapping and return victim frame number

					//victimEntry = FRAME(rpte1);
						

					// sanity check
					tupta = (FRAME(rpte1)<<6);
					for (k = 0; k < 64; k+=2)
					{
						tupte1 = memory[tupta + k];
						if (DEFINED(tupte1))
							printf("\nEvicting a UPT that has defined entries!!!\n");
					}


					//if (DIRTY(rpte1))
					{
						int page;

						//stat
						pageWrites++;

						if(PAGED(rpte2))
						{
							page = accessPage(SWAPPAGE(rpte2),FRAME(rpte1),PAGE_OLD_WRITE);
						}
						else
						{
							page = accessPage(0,FRAME(rpte1),PAGE_NEW_WRITE);
						}

						rpte2 = page;
						//memory[rpta + i + 1] = rpte2 = SET_PAGED(rpte2);
						memory[i + 1] = rpte2 = SET_PAGED(rpte2);
						
					}

					// save frame number before obliterating first word
					victimFrame = FRAME(rpte1);
					//memory[rpta + i] = rpte1 = CLEAR_DEFINED(rpte1);
					//memory[rpta + i] = rpte1 = 0;
					memory[i] = rpte1 = 0;

					//curRPTE = (i + 2) % 64;

					//printf("\nChose a RPT victim: %d\n",victimFrame);
					return victimFrame;
				}

				curUPTE = 0;
			}

		}

		//curRPT = (curRPT + 1) % MAX_TASKS;
		curRPTE = 0x2400;
	}


}