Пример #1
0
Файл: Expr.cpp Проект: FMX/CGAL
void ExprRep::reduceToZero() {
  appValue() = CORE_REAL_ZERO;
  appComputed() = true;
  flagsComputed() = true;
  knownPrecision() = CORE_negInfty;
#ifdef CORE_DEBUG
  relPrecision() = EXTLONG_ZERO;
  absPrecision() = CORE_negInfty;
  //  numNodes() = 0;
#endif

  d_e() = EXTLONG_ONE;
  visited() = false;
  sign() = 0;
  uMSB() = CORE_negInfty;
  lMSB() = CORE_negInfty;
  // length() = 0; 	// fixed? original = 1
  measure() = EXTLONG_ZERO;

  // BFMSS[2,5] bound.
  u25() = l25() = v2p() = v2m() = v5p() = v5m() = EXTLONG_ZERO;

  low() = EXTLONG_ONE;		// fixed? original = 0
  high() = lc() = tc() = EXTLONG_ZERO;

  if (rationalReduceFlag) {
    if (ratFlag() > 0) {
      ratFlag() ++;
      if (ratValue() == NULL)
        ratValue() = new BigRat(0);
      else
        *(ratValue()) = 0;
    } else
      ratFlag() = 1;
  }
}
Пример #2
0
Файл: vm.c Проект: hxp/xv6
// Allocate page tables and physical memory to grow process from oldsz to
// newsz, which need not be page aligned.  Returns new size or 0 on error.
int
allocuvm(pde_t *pgdir, uint oldsz, uint newsz)
{
  char *mem;
  uint a;

  if(newsz >= KERNBASE)
    return 0;
  if(newsz < oldsz)
    return oldsz;

  a = PGROUNDUP(oldsz);
  for(; a < newsz; a += PGSIZE){
    mem = kalloc();
    if(mem == 0){
      cprintf("allocuvm out of memory\n");
      deallocuvm(pgdir, newsz, oldsz);
      return 0;
    }
    memset(mem, 0, PGSIZE);
    mappages(pgdir, (char*)a, PGSIZE, v2p(mem), PTE_W|PTE_U);
  }
  return newsz;
}
Пример #3
0
bool IsVectorOfImplicationsIdentical(std::vector<FCA::Implication> v1, std::vector<FCA::Implication> v2)
{
    std::vector<std::pair<std::vector<std::string>, std::vector<std::string> > > v1p(v1.size()), v2p(v2.size());	

    for (size_t i = 0; i < v1.size(); ++i)
    {
        v1p[i].first = v1[i].Premise();
        v1p[i].second = v1[i].Conclusion();
    }

    for (size_t i = 0; i < v2.size(); ++i)
    {
        v2p[i].first = v2[i].Premise();
        v2p[i].second = v2[i].Conclusion();
    }

    std::sort(v1p.begin(), v1p.end());
    std::sort(v2p.begin(), v2p.end());

    for (size_t i = 0; i < v1p.size(); ++i)
    {
        std::sort(v1p[i].first.begin(), v1p[i].first.end());
        std::sort(v1p[i].second.begin(), v1p[i].second.end());		
    }

    for (size_t i = 0; i < v1p.size(); ++i)
    {
        std::sort(v2p[i].first.begin(), v2p[i].first.end());
        std::sort(v2p[i].second.begin(), v2p[i].second.end());		
    }

    return v1p == v2p;
}
Пример #4
0
// Switch h/w page table register to the kernel-only page table,
// for when no process is running.
void
switchkvm(struct cpu *c)
{
  lcr3(v2p(c->kpgdir));   // switch to the kernel page table
}
Пример #5
0
// Switch h/w page table register to the kernel-only page table,
// for when no process is running.
void
switchkvm(void)
{
  lcr3(v2p(kpgdir));   // switch to the kernel page table
}
Пример #6
0
void
switchkvm()
{
    lcr3(v2p(kpgmap));
}
Пример #7
0
void SqrtRep::computeExactFlags() {
  if (!child->flagsComputed())
    child->computeExactFlags();

  if (rationalReduceFlag)
    ratFlag() = -1;

  sign() = child->sign();
  if (sign() < 0)
    core_error("squareroot is called with negative operand.",
               __FILE__, __LINE__, true);

  uMSB() = child->uMSB() / EXTLONG_TWO;
  lMSB() = child->lMSB() / EXTLONG_TWO;

  // length() = child->length();
  measure() = child->measure();

  // BFMSS[2,5] bound.
  if (child->v2p() + ceilLg5(child->v5p()) + child->u25() >=
      child->v2m() + ceilLg5(child->v5m()) + child->l25()) {
    extLong vtilda2 = child->v2p() + child->v2m();
    v2p() = vtilda2 / EXTLONG_TWO;
    v2m() = child->v2m();
    extLong vmod2;
    if (v2p().isInfty())
      vmod2 = CORE_INFTY;
    else
      vmod2 = vtilda2 - EXTLONG_TWO*v2p(); // == vtilda2 % 2
    extLong vtilda5 = child->v5p() + child->v5m();
    v5p() = vtilda5 / EXTLONG_TWO;
    v5m() = child->v5m();
    extLong vmod5;
    if (v5p().isInfty())
      vmod5 = CORE_INFTY;
    else
      vmod5 = vtilda5 - EXTLONG_TWO*v5p(); // == vtilda5 % 2
    u25() = (child->u25() + child->l25() + vmod2 + ceilLg5(vmod5) + EXTLONG_ONE) / EXTLONG_TWO;
    l25() = child->l25();
  } else {
    extLong vtilda2 = child->v2p() + child->v2m();
    v2p() = child->v2p();
    v2m() = vtilda2 / EXTLONG_TWO;
    extLong vmod2;
    if (v2m().isInfty())
      vmod2 = CORE_INFTY;
    else
      vmod2 = vtilda2 - EXTLONG_TWO*v2m(); // == vtilda2 % 2
    extLong vtilda5 = child->v5p() + child->v5m();
    v5p() = child->v5p();
    v5m() = vtilda5 / EXTLONG_TWO;
    u25() = child->u25();
    extLong vmod5;
    if (v5m().isInfty())
      vmod5 = CORE_INFTY;
    else
      vmod5 = vtilda5 - EXTLONG_TWO*v5m(); // == vtilda5 % 2
    l25() = (child->u25() + child->l25() + vmod2 + ceilLg5(vmod5) + EXTLONG_ONE) / EXTLONG_TWO;
  }

  high() = (child->high() +EXTLONG_ONE)/EXTLONG_TWO;
  low() = child->low() / EXTLONG_TWO;
  lc() = child->lc();
  tc() = child->tc();
  flagsComputed() = true;
}// SqrtRep::computeExactFlags
Пример #8
0
// This only copies the current information of the argument e to
// 	*this ExprRep.
void ExprRep::reduceTo(const ExprRep *e) {
  if (e->appComputed()) {
    appValue() = e->appValue();
    appComputed() = true;
    flagsComputed() = true;
    knownPrecision() = e->knownPrecision();
#ifdef CORE_DEBUG
    relPrecision() = e->relPrecision();
    absPrecision() = e->absPrecision();
    numNodes() = e->numNodes();
#endif

  }
  d_e() = e->d_e();
  //visited() = e->visited();
  sign() = e->sign();
  uMSB() = e->uMSB();
  lMSB() = e->lMSB();
  // length() = e->length(); 	// fixed? original = 1
  measure() = e->measure();

  // BFMSS[2,5] bound.
  u25() = e->u25();
  l25() = e->l25();
  v2p() = e->v2p();
  v2m() = e->v2m();
  v5p() = e->v5p();
  v5m() = e->v5m();

  high() = e->high();
  low() = e->low();		// fixed? original = 0
  lc() = e->lc();
  tc() = e->tc();

  // Chee (Mar 23, 2004), Notes on ratFlag():
  // ===============================================================
  // For more information on the use of this flag, see progs/pentagon.
  // This is an integer valued member of the NodeInfo class.
  // Its value is used to determine whether
  // we can ``reduce'' an Expression to a single node containing
  // a BigRat value.  This reduction is done if the global variable
  // rationalReduceFlag=true.  The default value is false.
  // This is the intepretation of ratFlag:
  //	ratFlag < 0 means irrational
  //	ratFlag = 0 means not initialized
  //	ratFlag > 0 means rational
  // Currently, ratFlag>0 is an upper bound on the size of the expression,
  // since we recursively compute
  // 		ratFlag(v) = ratFlag(v.lchild)+ratFlag(v.rchild) + 1.
  // PROPOSAL: if ratFlag() > RAT_REDUCE_THRESHHOLD
  // 	then we automatically do a reduction.  We must determine
  // 	an empirical value for RAT_REDUCE_THRESHOLD

  if (rationalReduceFlag) {
    ratFlag() = e->ratFlag();

    if (e->ratFlag() > 0 && e->ratValue() != NULL) {
      ratFlag() ++;
      if (ratValue() == NULL)
        ratValue() = new BigRat(*(e->ratValue()));
      else
        *(ratValue()) = *(e->ratValue());
    } else
      ratFlag() = -1;
  }
}
Пример #9
0
// Computes the root bit bound of the expression.
// In effect, computeBound() returns the current value of low.
extLong ExprRep::computeBound() {
  extLong measureBd = measure();
  // extLong cauchyBd = length();
  extLong ourBd = (d_e() - EXTLONG_ONE) * high() + lc();
  // BFMSS[2,5] bound.
  extLong bfmsskBd;
  if (v2p().isInfty() || v2m().isInfty())
    bfmsskBd = CORE_INFTY;
  else
    bfmsskBd = l25() + u25() * (d_e() - EXTLONG_ONE) - v2() - ceilLg5(v5());

  // since we might compute \infty - \infty for this bound
  if (bfmsskBd.isNaN())
    bfmsskBd = CORE_INFTY;

  extLong bd = core_min(measureBd,
                        // core_min(cauchyBd,
                        core_min(bfmsskBd, ourBd));
#ifdef CORE_SHOW_BOUNDS
    std::cout << "Bounds (" << measureBd <<
                    "," << bfmsskBd << ", " << ourBd << "),  ";
    std::cout << "MIN = " << bd << std::endl;
    std::cout << "d_e= " << d_e() << std::endl;
#endif

#ifdef CORE_DEBUG_BOUND
  // Some statistics about which one is/are the winner[s].
  computeBoundCallsCounter++;
  int number_of_winners = 0;
  std::cerr << " New contest " << std::endl;
  if (bd == bfmsskBd) {
    BFMSS_counter++;
    number_of_winners++;
    std::cerr << " BFMSS is the winner " << std::endl;
  }
  if (bd == measureBd) {
    Measure_counter++;
    number_of_winners++;
    std::cerr << " measureBd is the winner " << std::endl;
  }
  /*  if (bd == cauchyBd) {
      Cauchy_counter++;
      number_of_winners++;
      std::cerr << " cauchyBd is the winner " << std::endl;
    }
   */
  if (bd == ourBd) {
    LiYap_counter++;
    number_of_winners++;
    std::cerr << " ourBd is the winner " << std::endl;
  }

  assert(number_of_winners >= 1);

  if (number_of_winners == 1) {
    if (bd == bfmsskBd) {
      BFMSS_only_counter++;
      std::cerr << " BFMSSBd is the only winner " << std::endl;
    } else if (bd == measureBd) {
      Measure_only_counter++;
      std::cerr << " measureBd is the only winner " << std::endl;
    }
    /* else if (bd == cauchyBd) {
      Cauchy_only_counter++;
      std::cerr << " cauchyBd is the only winner " << std::endl;
    } */
    else if (bd == ourBd) {
      LiYap_only_counter++;
      std::cerr << " ourBd is the only winner " << std::endl;
    }
  }
#endif

  return bd;
}//computeBound()
Пример #10
0
void
switchkvm(void)
{
  lcr3(v2p(kpml4));
}
Пример #11
0
Файл: trap.c Проект: oskarth/xv6
//PAGEBREAK: 41
void
trap(struct trapframe *tf)
{
  if(tf->trapno == T_SYSCALL){
    if(proc->killed)
      exit();
    proc->tf = tf;
    syscall();
    if(proc->killed)
      exit();
    return;
  }

  // Lazy page allocation
  if(tf->trapno == T_PGFLT) {
    uint a = PGROUNDDOWN(rcr2()); // round down faulting VA to page boundary
    char *mem;
    mem = kalloc();
    memset(mem, 0, PGSIZE);
    //cprintf("Lazy page allocation at 0x%x\n", a);
    mappages(proc->pgdir, (char*)a, PGSIZE, v2p(mem), PTE_W|PTE_U);
    return;
  }

  switch(tf->trapno){
  case T_IRQ0 + IRQ_TIMER:
    if(cpu->id == 0){
      acquire(&tickslock);
      ticks++;

      if(proc && (tf->cs & 3) == 3){
        proc->alarmleft--;
        if(proc->alarmleft == 0){
          proc->alarmleft = proc->alarmticks;
          tf->esp -= 4;
          *(uint*)tf->esp = tf->eip; // XXX: security flaw, need check before
          tf->eip = (uint) proc->alarmhandler;
        }
      }

      wakeup(&ticks);
      release(&tickslock);
    }
    lapiceoi();
    break;
  case T_IRQ0 + IRQ_IDE:
    ideintr();
    lapiceoi();
    break;
  case T_IRQ0 + IRQ_IDE+1:
    // Bochs generates spurious IDE1 interrupts.
    break;
  case T_IRQ0 + IRQ_KBD:
    kbdintr();
    lapiceoi();
    break;
  case T_IRQ0 + IRQ_COM1:
    uartintr();
    lapiceoi();
    break;
  case T_IRQ0 + 7:
  case T_IRQ0 + IRQ_SPURIOUS:
    cprintf("cpu%d: spurious interrupt at %x:%x\n",
            cpu->id, tf->cs, tf->eip);
    lapiceoi();
    break;
  //PAGEBREAK: 13
  default:
    if(proc == 0 || (tf->cs&3) == 0){
      // In kernel, it must be our mistake.
      cprintf("unexpected trap %d from cpu %d eip %x (cr2=0x%x)\n",
              tf->trapno, cpu->id, tf->eip, rcr2());
      panic("trap");
    }
    // In user space, assume process misbehaved.
    cprintf("pid %d %s: trap %d err %d on cpu %d "
            "eip 0x%x addr 0x%x--kill proc\n",
            proc->pid, proc->name, tf->trapno, tf->err, cpu->id, tf->eip, 
            rcr2());
    proc->killed = 1;
  }

  // Force process exit if it has been killed and is in user space.
  // (If it is still executing in the kernel, let it keep running 
  // until it gets to the regular system call return.)
  if(proc && proc->killed && (tf->cs&3) == DPL_USER)
    exit();

  // Force process to give up CPU on clock tick.
  // If interrupts were on while locks held, would need to check nlock.
  if(proc && proc->state == RUNNING && tf->trapno == T_IRQ0+IRQ_TIMER)
    yield();

  // Check if the process has been killed since we yielded
  if(proc && proc->killed && (tf->cs&3) == DPL_USER)
    exit();
}
Пример #12
0
//PAGEBREAK: 41
void
trap(struct trapframe *tf)
{
  if(tf->trapno == T_SYSCALL){
    if(proc->killed)
      exit();
    proc->tf = tf;
    syscall();
    if(proc->killed)
      exit();
    return;
  }

  switch(tf->trapno){
  case T_IRQ0 + IRQ_TIMER:
    if(cpu->id == 0){
      acquire(&tickslock);
      ticks++;
      wakeup(&ticks);

		// We're in user space
		if(proc && (tf->cs & 3) == DPL_USER) {
			//is the alarm set?
			if(proc->alarmticks != 0 && proc->alarmhandler != 0) {
				proc->alarmticksleft--;
				if(proc->alarmticksleft == 0) {
					proc->tf->esp--;
					*(uint*)proc->tf->esp = proc->tf->eip;
					proc->tf->eip = (uint)proc->alarmhandler;
					proc->alarmticksleft = proc->alarmticks;
				}
			}
		}

      release(&tickslock);
    }
    lapiceoi();
    break;
  case T_IRQ0 + IRQ_IDE:
    ideintr();
    lapiceoi();
    break;
  case T_IRQ0 + IRQ_IDE+1:
    // Bochs generates spurious IDE1 interrupts.
    break;
  case T_IRQ0 + IRQ_KBD:
    kbdintr();
    lapiceoi();
    break;
  case T_IRQ0 + IRQ_COM1:
    uartintr();
    lapiceoi();
    break;
  case T_IRQ0 + 7:
  case T_IRQ0 + IRQ_SPURIOUS:
    cprintf("cpu%d: spurious interrupt at %x:%x\n",
            cpu->id, tf->cs, tf->eip);
    lapiceoi();
    break;
   
  //PAGEBREAK: 13
  default:
    if(proc == 0 || (tf->cs&3) == 0){
      // In kernel, it must be our mistake.
      cprintf("unexpected trap %d from cpu %d eip %x (cr2=0x%x)\n",
              tf->trapno, cpu->id, tf->eip, rcr2());
      panic("trap");
    }
    // In user space, check whether it is an access to an lazy allocated address
    if(tf->trapno == T_PGFLT) {
    	char *mem;
        uint a;

        a = PGROUNDDOWN(rcr2());
		mem = kalloc();
		if(mem == 0){
		  cprintf("allocuvm out of memory\n");
		  deallocuvm(proc->pgdir, a+PGSIZE, rcr2());
		  exit();
		}
		memset(mem, 0, PGSIZE);
		mappages(proc->pgdir, (char*)a, PGSIZE, v2p(mem), PTE_W|PTE_U);
    } else {
    	//If not, the user program is misbehaving
    	cprintf("pid %d %s: trap %d err %d on cpu %d "
				"eip 0x%x addr 0x%x--kill proc\n",
				proc->pid, proc->name, tf->trapno, tf->err, cpu->id, tf->eip,
				rcr2());
		proc->killed = 1;
    }
  }

  // Force process exit if it has been killed and is in user space.
  // (If it is still executing in the kernel, let it keep running 
  // until it gets to the regular system call return.)
  if(proc && proc->killed && (tf->cs&3) == DPL_USER)
    exit();

  // Force process to give up CPU on clock tick.
  // If interrupts were on while locks held, would need to check nlock.
  if(proc && proc->state == RUNNING && tf->trapno == T_IRQ0+IRQ_TIMER)
    yield();

  // Check if the process has been killed since we yielded
  if(proc && proc->killed && (tf->cs&3) == DPL_USER)
    exit();
}
Пример #13
0
int
exec(char *path, char **argv)
{
  char *s, *last;
  int i, off;
  uint argc, sz, sp, ustack[3+MAXARG+1];
  struct elfhdr elf;
  struct inode *ip;
  struct proghdr ph;
  pde_t *pgdir, *oldpgdir;

  if((ip = namei(path)) == 0)
    return -1;
  ilock(ip);
  pgdir = 0;

  // Check ELF header
  if(readi(ip, (char*)&elf, 0, sizeof(elf)) < sizeof(elf))
    goto bad;
  if(elf.magic != ELF_MAGIC)
    goto bad;

  if((pgdir = setupkvm(kalloc)) == 0)
    goto bad;

  // Load program into memory.

  // leave first page inaccessible (to make NULL ref fail)
  sz = PGSIZE-1;

  for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
    if(readi(ip, (char*)&ph, off, sizeof(ph)) != sizeof(ph))
      goto bad;
    if(ph.type != ELF_PROG_LOAD)
      continue;
    if(ph.memsz < ph.filesz)
      goto bad;
    if((sz = allocuvm(pgdir, sz, ph.vaddr + ph.memsz)) == 0)
      goto bad;
    if(loaduvm(pgdir, (char*)ph.vaddr, ip, ph.off, ph.filesz) < 0)
      goto bad;
  }
  iunlockput(ip);
  ip = 0;

  // Allocate two pages at the next page boundary.
  // Make the first inaccessible.  Use the second as the user stack.
  sz = PGROUNDUP(sz);
  if((sz = allocuvm(pgdir, sz, sz + 2*PGSIZE)) == 0)
    goto bad;
  clearpteu(pgdir, (char*)(sz - 2*PGSIZE));
  sp = sz;

  // Push argument strings, prepare rest of stack in ustack.
  for(argc = 0; argv[argc]; argc++) {
    if(argc >= MAXARG)
      goto bad;
    sp = (sp - (strlen(argv[argc]) + 1)) & ~3;
    if(copyout(pgdir, sp, argv[argc], strlen(argv[argc]) + 1) < 0)
      goto bad;
    ustack[3+argc] = sp;
  }
  ustack[3+argc] = 0;

  ustack[0] = 0xffffffff;  // fake return PC
  ustack[1] = argc;
  ustack[2] = sp - (argc+1)*4;  // argv pointer

  sp -= (3+argc+1) * 4;
  if(copyout(pgdir, sp, ustack, (3+argc+1)*4) < 0)
    goto bad;

  // Save program name for debugging.
  for(last=s=path; *s; s++)
    if(*s == '/')
      last = s+1;
  safestrcpy(proc->name, last, sizeof(proc->name));

  // hook up the old shared memory to the new addr space
  // (no need to change refcount, because the old ref goes away with
  // this exec, so it's +1 then -1 => 0 change
  if (proc->shared) {
    extern void mappages(pde_t *pgdir, void *va, uint size, uint pa, int perm);
    mappages(pgdir, (char *)SHARED_V, PGSIZE, v2p(proc->shared->page), PTE_W|PTE_U);
  }

  // Commit to the user image.
  oldpgdir = proc->pgdir;
  proc->pgdir = pgdir;
  proc->sz = sz;
  proc->tf->eip = elf.entry;  // main
  proc->tf->esp = sp;
  switchuvm(proc);
  freevm(oldpgdir);
  return 0;

 bad:
  if(pgdir)
    freevm(pgdir);
  if(ip)
    iunlockput(ip);
  return -1;
}
Пример #14
0
bool RenderableObject::IsInstance(RenderableObject& model)
{
	// First test is the number of indices
	if (m_indices_size != model.m_indices_size)
		return false;
	// Second test is the number of buffers
	if (m_buffers.size() != model.m_buffers.size())
		return false;
	// Third test buffers size
	for (BufferMap::const_iterator it = m_buffers.begin();
			it != m_buffers.end(); it++)
			{
		BufferMap::const_iterator it2 = model.m_buffers.find(it->first);
		if (it2 == model.m_buffers.end())
			return false;
		if (it2->second.dimension != it->second.dimension)
			return false;
		if (it2->second.size != it->second.size)
			return false;
	}
	// Last step : Check buffer contents
	// * Check if they needs to compute the transformation
	bool needTransformation = false;
	Math::CMatrix4 transformationMatrix;
	if (m_buffers.find(VERTEX_ATTRIBUT) != m_buffers.end()
			&& m_buffers[VERTEX_ATTRIBUT].size >= 11)
	{
		Logger::Log() << "[INFO] Try to find the transformations ... \n";
		RenderableBuffer b1 = m_buffers[VERTEX_ATTRIBUT];
		RenderableBuffer b2 = model.m_buffers[VERTEX_ATTRIBUT];
		if (b1.buffer[0] != b2.buffer[0])
		{
			needTransformation = true;
			// Frist matrix
			Math::TVector3F v1(b1.buffer[0], b1.buffer[1], b1.buffer[2]);
			Math::TVector3F v2(b1.buffer[3], b1.buffer[4], b1.buffer[5]);
			Math::TVector3F v3(b1.buffer[6], b1.buffer[7], b1.buffer[8]);
			Math::TVector3F v4 = v1 + ((v2 - v1) ^ (v3 - v1));
			Math::CMatrix4 t1(v1.x, v2.x, v3.x, v4.x, v1.y, v2.y, v3.y, v4.y,
					v1.z, v2.z, v3.z, v4.z, 1, 1, 1, 1);
			// second matrix
			Math::TVector3F v1p(b2.buffer[0], b2.buffer[1], b2.buffer[2]);
			Math::TVector3F v2p(b2.buffer[3], b2.buffer[4], b2.buffer[5]);
			Math::TVector3F v3p(b2.buffer[6], b2.buffer[7], b2.buffer[8]);
			Math::TVector3F v4p = v1p + ((v2p - v1p) ^ (v3p - v1p));
			Math::CMatrix4 t2(v1p.x, v2p.x, v3p.x, v4p.x, v1p.y, v2p.y, v3p.y,
					v4p.y, v1p.z, v2p.z, v3p.z, v4p.z, 1, 1, 1, 1);

			transformationMatrix = t1.Inverse() * t2;
			Logger::Log() << "[INFO] Transform matrice : \n"
					<< transformationMatrix;
		}
	}
	for (BufferMap::const_iterator it = m_buffers.begin();
			it != m_buffers.end(); it++)
			{

		BufferMap::const_iterator it2 = model.m_buffers.find(it->first);
		Logger::Log() << "[INFO] INSTANCE : " << it->first
				<< " buffer check instance ... \n";
		for (int i = 0; i < it->second.size; i++)
		{
			if (!needTransformation)
			{
				if (it->second.buffer[i] != it2->second.buffer[i])
				{
					Logger::Log() << "[INFO] Buffer difference detected : " << i
							<< " ( " << it->second.buffer[i] << " != "
							<< it2->second.buffer[i] << " )\n";
					return false;
				}
			}
			else
			{
				if (it->first == VERTEX_ATTRIBUT || it->first == NORMAL_ATTRIBUT
						|| it->first == TANGENT_ATTRIBUT
						|| it->first == BITANGENT_ATTRIBUT)
				{
					// Construct the Vector
					Math::TVector4F v1(it->second.buffer[i],
							it->second.buffer[i + 1], it->second.buffer[i + 2],
							1.0);
					Math::TVector4F v2(it2->second.buffer[i],
							it2->second.buffer[i + 1],
							it2->second.buffer[i + 2], 1.0);
					Math::TVector4F vTrans = transformationMatrix.Transform(v1);
					vTrans /= vTrans.w;
					if (v2 != vTrans)
					{
						Logger::Log() << "[INFO] Buffer difference detected : "
								<< i << " ( " << v2 << " != " << vTrans
								<< " )\n";
						return false;
					}
					// Must add two steps
					i += 2;
				}
				else
				{
					// XXX: Somes copy from other tests
					if (it->second.buffer[i] != it2->second.buffer[i])
					{
						Logger::Log() << "[INFO] Buffer difference detected : "
								<< i << " ( " << it->second.buffer[i] << " != "
								<< it2->second.buffer[i] << " )\n";
						return false;
					}
				}
			}
		}
	}
	// All tests is Ok so Model is an instance
	return true;
}
Пример #15
0
void mmuWriteByte(Word vAddr, Byte data, Bool userMode) {
  memoryWriteByte(v2p(vAddr, userMode, true, MMU_ACCS_BYTE), data);
}
Пример #16
0
Byte mmuReadByte(Word vAddr, Bool userMode) {
  return memoryReadByte(v2p(vAddr, userMode, false, MMU_ACCS_BYTE));
}