void CachedResource::setDecodedSize(unsigned size)
{
if (size == m_decodedSize)
return;
int delta = size - m_decodedSize;
// The object must now be moved to a different queue, since its size has been changed.
// We have to remove explicitly before updating m_decodedSize, so that we find the correct previous
// queue.
if (inCache())
cache()->removeFromLRUList(this);
m_decodedSize = size;
if (inCache()) {
// Now insert into the new LRU list.
cache()->insertInLRUList(this);
// Insert into or remove from the live decoded list if necessary.
if (m_decodedSize && !m_inLiveDecodedResourcesList && referenced())
cache()->insertInLiveDecodedResourcesList(this);
else if (!m_decodedSize && m_inLiveDecodedResourcesList)
cache()->removeFromLiveDecodedResourcesList(this);
// Update the cache's size totals.
cache()->adjustSize(referenced(), delta);
}
}
//#####################################################################
// Function Destroy_Unreferenced_Geometry
//#####################################################################
template<class TV> void RIGID_GEOMETRY_COLLECTION<TV>::
Destroy_Unreferenced_Geometry()
{
ARRAY<bool> referenced(structure_list.Number_Of_Active_Elements());
for(int i=1;i<=particles.array_collection->Size();i++) for(int j=1;j<=particles.structure_ids(i).m;j++) if(particles.structure_ids(i)(j))
referenced(structure_list.Element_Index(particles.structure_ids(i)(j)))=true;
for(int i=structure_list.Number_Of_Active_Elements();i>=1;i--) if(!referenced(i)) structure_list.Remove_Element(structure_list.Active_Element_Id(i));
}
void CachedResource::setEncodedSize(unsigned size)
{
if (size == m_encodedSize)
return;
// The size cannot ever shrink (unless it is being nulled out because of an error). If it ever does, assert.
ASSERT(size == 0 || size >= m_encodedSize);
int delta = size - m_encodedSize;
// The object must now be moved to a different queue, since its size has been changed.
// We have to remove explicitly before updating m_encodedSize, so that we find the correct previous
// queue.
if (inCache())
cache()->removeFromLRUList(this);
m_encodedSize = size;
if (inCache()) {
// Now insert into the new LRU list.
cache()->insertInLRUList(this);
// Update the cache's size totals.
cache()->adjustSize(referenced(), delta);
}
}
/*
* Add this AST_Enum node (an enum declaration) to this scope
*/
AST_Enum *AST_Module::fe_add_enum(AST_Enum *t)
{
AST_Decl *d;
/*
* Already defined and cannot be redefined? Or already used?
*/
if ((d = lookup_for_add (t)) != NULL)
{
if (!can_be_redefined (d))
{
idl_global->err()->error3(UTL_Error::EIDL_REDEF, t, this, d);
return NULL;
}
if (referenced (d))
{
idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, t, this, d);
return NULL;
}
}
/*
* Add it to scope
*/
add_to_scope(t);
/*
* Add it to set of locally referenced symbols
*/
add_to_referenced(t, false);
return t;
}
// Add a node to set of nodes referenced in this scope
void
UTL_Scope::add_to_referenced(AST_Decl *e, idl_bool recursive)
{
UTL_Scope *s;
AST_Decl **tmp;
AST_Interface *itf;
long oreferenced_allocated;
long i;
if (e == NULL)
return ;
// Special cases for forward declared interfaces and valuetypes in
// the scope in which they're defined. Cannot add before full
// definition is seen
if ((e->node_type() == AST_Decl::NT_interface)
|| (e->node_type() == AST_Decl::NT_value))
{
itf = AST_Interface::narrow_from_decl(e);
if (itf != NULL && itf->defined_in() == this && !itf->is_defined())
return ;
}
// Only insert if it is not there already
if (referenced(e))
return ;
// Make sure there's space for one more
if (pd_referenced_allocated == pd_referenced_used)
{
oreferenced_allocated = pd_referenced_allocated;
pd_referenced_allocated += INCREMENT;
tmp = new AST_Decl * [pd_referenced_allocated];
for (i = 0; i < oreferenced_allocated; i++)
tmp[i] = pd_referenced[i];
delete [] pd_referenced;
pd_referenced = tmp;
}
// Insert new reference
pd_referenced[pd_referenced_used++] = e;
// Now, if recursive is specified and "this" is not a common ancestor
// of the referencing scope and the scope of definition of "e" then
// add "e" to the set of referenced nodes in the parent of "this"
if (recursive && !(e->has_ancestor(ScopeAsDecl(this))))
{
s = e->defined_in();
if (s != NULL)
s->add_to_referenced(e, recursive);
}
}
void map(mmu *m, int index, int phy, int instnnd){
PRINT_INST(instnnd, "MAP", index, phy);
present(&(m->pageT[index]));
referenced(&(m->pageT[index]));
pagedin(&(m->pageT[index]),phy);
m->frames[phy] = index;
m->frameN += 1;
m->maps_N += 1;
return;
}
/*
* Add this AST_InterfaceFwd node (a forward declaration of an IDL
* interface) to this scope
*/
AST_InterfaceFwd * AST_Module::fe_add_interface_fwd (AST_InterfaceFwd * i)
{
AST_Decl * d = lookup_for_add (i);
AST_Interface * itf;
/*
* Already defined and cannot be redefined? Or already used?
*/
if (d)
{
if (d->node_type() == AST_Decl::NT_interface && d->defined_in() == this)
{
itf = AST_Interface::narrow_from_decl (d);
if (itf == 0)
{
return 0;
}
i->set_full_definition (itf);
return i;
}
if (!can_be_redefined (d))
{
idl_global->err()->error3(UTL_Error::EIDL_REDEF, i, this, d);
return NULL;
}
if (referenced (d))
{
idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, i, this, d);
return NULL;
}
if (i->has_ancestor (d))
{
idl_global->err()->redefinition_in_scope(i, d);
return NULL;
}
}
/*
* Add it to scope
*/
add_to_scope (i);
/*
* Add it to set of locally referenced symbols
*/
add_to_referenced (i, false);
return i;
}
AST_ValueFwd *AST_Module::fe_add_valuetype_fwd(AST_ValueFwd *v)
{
AST_Decl *d;
AST_Value *val;
/*
* Already defined and cannot be redefined? Or already used?
*/
if ((d = lookup_for_add (v)) != NULL)
{
if (d->node_type() == AST_Decl::NT_value && d->defined_in() == this)
{
val = AST_Value::narrow_from_decl(d);
if (val == NULL)
return NULL;
v->set_full_definition(val);
return v;
}
if (!can_be_redefined(d))
{
idl_global->err()->error3(UTL_Error::EIDL_REDEF, v, this, d);
return NULL;
}
if (referenced(d))
{
idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, v, this, d);
return NULL;
}
if (v->has_ancestor(d))
{
idl_global->err()->redefinition_in_scope(v, d);
return NULL;
}
}
/*
* Add it to scope
*/
add_to_scope(v);
/*
* Add it to set of locally referenced symbols
*/
add_to_referenced(v, I_FALSE);
return v;
}
void CachedResource::deref(CachedResourceClient *c)
{
ASSERT(m_clients.contains(c));
m_clients.remove(c);
if (canDelete() && !inCache())
delete this;
else if (!referenced() && inCache()) {
cache()->removeFromLiveResourcesSize(this);
cache()->removeFromLiveDecodedResourcesList(this);
allReferencesRemoved();
cache()->prune();
}
}
AST_StateMember *AST_Value::fe_add_state_member(AST_StateMember *t)
{
AST_Decl *d;
/*
* Can't add to interface which was not yet defined
*/
if (!is_defined())
{
idl_global->err()->error2(UTL_Error::EIDL_DECL_NOT_DEFINED, this, t);
return NULL;
}
/*
* Already defined and cannot be redefined? Or already used?
*/
if ((d = lookup_for_add (t)) != NULL)
{
if (!can_be_redefined(d))
{
idl_global->err()->error3(UTL_Error::EIDL_REDEF, t, this, d);
return NULL;
}
if (referenced(d))
{
idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, t, this, d);
return NULL;
}
if (t->has_ancestor(d))
{
idl_global->err()->redefinition_in_scope(t, d);
return NULL;
}
}
/*
* Add it to scope
*/
add_to_scope(t);
/*
* Add it to set of locally referenced symbols
*/
add_to_referenced(t, I_FALSE);
return t;
}
void simulate(mmu *m){
inst *elt, *tmp;
while (instList != NULL){
tmp = instList;
elt = popInst(tmp);
if (elt == NULL){ continue; } //invalid instruction
m->insts_N +=1;
int rw = elt->rw;
int page = elt->page;
int instN = elt->instN;
free(elt); elt =NULL; tmp = NULL;
if (algo==3){
m->mmucounter +=1;
m->cT64[page] = m->mmucounter;
//printf("==> %llu %lu\n", m->cT64[page],m->mmucounter);
}
if (isPresent(m->pageT[page])){
if (rw ==1){
modified(&(m->pageT[page]));
}
referenced(&(m->pageT[page]));
continue;
} //page present
int victim, nextFID;
if (m->frameN < numFrames){
victim = page;
nextFID = m->frameN;
}
else {
updateMMU(m, page);
victim = nextFrame(m);
nextFID = unmap(m,victim,instN);
}
pageIn(m, page, rw, instN, nextFID);
map(m, page, nextFID, instN); /* MAP */
} //while instList NOT NULL
return;
}
/*
* Add this AST_EnumVal (enumerator declaration) to the current scope.
* This is done to conform to the C++ scoping rules which declare
* enumerators in the enclosing scope (in addition to declaring them
* in the enum itself)
*/
AST_EnumVal *AST_Exception::fe_add_enum_val(AST_EnumVal *t)
{
AST_Decl *d;
/*
* Already defined and cannot be redefined? Or already used?
*/
if ((d = lookup_for_add (t)) != NULL)
{
if (!can_be_redefined(d))
{
idl_global->err()->error3(UTL_Error::EIDL_REDEF, t, this, d);
return NULL;
}
if (referenced(d))
{
idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, t, this, d);
return NULL;
}
if (t->has_ancestor(d))
{
idl_global->err()->redefinition_in_scope(t, d);
return NULL;
}
}
/*
* Add it to scope
*/
add_to_scope(t);
/*
* Add it to set of locally referenced symbols
*/
add_to_referenced(t, I_FALSE);
return t;
}
AST_Opaque*
AST_Module::fe_add_opaque(AST_Opaque* o)
{
AST_Decl *d;
/*
* Already defined and cannot be redefined? Or already used?
*/
if ((d = lookup_for_add (o)) != NULL)
{
if (!can_be_redefined(d))
{
idl_global->err()->error3(UTL_Error::EIDL_REDEF, o, this, d);
return NULL;
}
if (referenced(d))
{
idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, o, this, d);
return NULL;
}
}
/*
* Add it to scope
*/
add_to_scope(o);
/*
* Add it to set of locally referenced symbols
*/
add_to_referenced(o, I_FALSE);
return o;
}
void CachedResource::ref(CachedResourceClient *c)
{
if (!referenced() && inCache())
cache()->addToLiveResourcesSize(this);
m_clients.add(c);
}
/*
* Add this AST_Value node (a value type declaration) to this scope
*/
AST_BoxedValue *AST_Module::fe_add_boxed_valuetype(AST_BoxedValue *v)
{
AST_Decl *predef;
AST_Interface *fwd;
/*
* Already defined?
*/
if ((predef = lookup_for_add (v)) != NULL)
{
/*
* Treat fwd declared interfaces specially
*/
if (predef->node_type() == AST_Decl::NT_value)
{
fwd = AST_Value::narrow_from_decl(predef);
if (fwd == NULL)
return NULL;
if (!fwd->is_defined())
{ /* Forward declared and not defined yet */
if (fwd->defined_in() != this)
{
idl_global->err()
->error3(UTL_Error::EIDL_SCOPE_CONFLICT, fwd, v, this);
return NULL;
}
}
/*
* OK, not illegal redef of forward declaration. Now check whether
* it has been referenced already
*/
else if (referenced(predef))
{
idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, v, this, predef);
return NULL;
}
}
else if (!can_be_redefined(predef))
{
idl_global->err()->error3(UTL_Error::EIDL_REDEF, v, this, predef);
return NULL;
}
else if (referenced(predef))
{
idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, v, this, predef);
return NULL;
}
else if (v->has_ancestor(predef))
{
idl_global->err()->redefinition_in_scope(v, predef);
return NULL;
}
}
/*
* Add it to scope
*/
add_to_scope(v);
/*
* Add it to set of locally referenced symbols
*/
add_to_referenced(v, I_FALSE);
return v;
}
DECL *
UTL_Scope::fe_add_full_intf_decl (DECL *t)
{
if (t->redef_clash ())
{
return 0;
}
AST_Decl *predef = 0;
DECL *fwd = 0;
// Already defined?
if ((predef = this->lookup_for_add (t)) != 0)
{
// Treat fwd declared interfaces specially
if (predef->node_type () == DECL::NT)
{
fwd = DECL::narrow_from_decl (predef);
if (fwd == 0)
{
return 0;
}
// Forward declared and not defined yet.
if (!fwd->is_defined ())
{
if (fwd->defined_in () != this)
{
idl_global->err ()->error3 (UTL_Error::EIDL_SCOPE_CONFLICT,
fwd,
t,
ScopeAsDecl (this));
return 0;
}
}
// OK, not illegal redef of forward declaration. Now check whether.
// it has been referenced already.
else if (this->referenced (predef, t->local_name ()))
{
idl_global->err ()->error3 (UTL_Error::EIDL_DEF_USE,
t,
ScopeAsDecl (this),
predef);
return 0;
}
}
else if (!FE_Utils::can_be_redefined (predef, t))
{
idl_global->err ()->error3 (UTL_Error::EIDL_REDEF,
t,
ScopeAsDecl (this),
predef);
return 0;
}
else if (referenced (predef, t->local_name ()) && !t->is_defined ())
{
idl_global->err ()->error3 (UTL_Error::EIDL_DEF_USE,
t,
ScopeAsDecl (this),
predef);
return 0;
}
else if (t->has_ancestor (predef))
{
idl_global->err ()->redefinition_in_scope (t, predef);
return 0;
}
}
// Add it to scope
this->add_to_scope (t);
// We do this for interfaces, valuetypes and components in
// a different place than we do for structs and unions,
// since fwd declared structs and unions must be defined in
// the same translation unit.
AST_InterfaceFwd *fd = t->fwd_decl ();
if (0 != fd)
{
fd->set_as_defined ();
}
// Add it to set of locally referenced symbols
this->add_to_referenced (t,
false,
t->local_name ());
return t;
}
