401 lines
10 KiB
C++
401 lines
10 KiB
C++
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is [Open Source Virtual Machine.].
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Adobe System Incorporated.
|
|
* Portions created by the Initial Developer are Copyright (C) 1993-2006
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Adobe AS3 Team
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
|
|
#include "avmplus.h"
|
|
|
|
using namespace MMgc;
|
|
|
|
// WARNING:
|
|
// WARNING:
|
|
// WARNING:
|
|
// Never do "MMgc::GC::GetGC(this)" in the HashTable object. It is dynamically
|
|
// placed at the end of a ScriptObject following traits data which can extend
|
|
// greater than 4k off the starting pointer. This will cause GetGC(this) to fail.
|
|
// WARNING:
|
|
// WARNING:
|
|
// WARNING:
|
|
|
|
namespace avmplus
|
|
{
|
|
void Hashtable::initialize(GC *gc, int capacity)
|
|
{
|
|
capacity = MathUtils::nextPowerOfTwo(capacity);
|
|
setNumAtoms(capacity*2);
|
|
AvmAssert(getNumAtoms());
|
|
MMGC_MEM_TYPE(this);
|
|
setAtoms((Atom *) gc->Alloc (sizeof(Atom) * getNumAtoms(), GC::kContainsPointers|GC::kZero));
|
|
flags = 0;
|
|
}
|
|
|
|
Hashtable::~Hashtable()
|
|
{
|
|
destroy();
|
|
}
|
|
|
|
void Hashtable::destroy()
|
|
{
|
|
if(atoms) {
|
|
GC *gc = GC::GetGC(atoms);
|
|
#ifdef MMGC_DRC
|
|
AvmCore::decrementAtomRegion(atoms, getNumAtoms());
|
|
#endif
|
|
gc->Free (atoms);
|
|
}
|
|
atoms = NULL;
|
|
setNumAtoms(0);
|
|
size = 0;
|
|
flags = 0;
|
|
}
|
|
|
|
void Hashtable::setAtoms(Atom *newAtoms)
|
|
{
|
|
GC *gc = GC::GetGC(newAtoms);
|
|
gc->writeBarrier(gc->FindBeginning(this), &atoms, newAtoms);
|
|
}
|
|
|
|
void Hashtable::put(Atom name, Atom value)
|
|
{
|
|
int i = find(name, atoms, getNumAtoms());
|
|
GC *gc = GC::GetGC(atoms);
|
|
if ((atoms[i] & ~dontEnumMask()) != name) {
|
|
AvmAssert(!isFull());
|
|
//atoms[i] = name;
|
|
WBATOM(gc, atoms, &atoms[i], name);
|
|
size++;
|
|
}
|
|
//atoms[i+1] = value;
|
|
WBATOM( gc, atoms, &atoms[i+1], value);
|
|
}
|
|
|
|
Atom Hashtable::get(Atom name) const
|
|
{
|
|
int i;
|
|
return atoms[i = find(name, atoms, getNumAtoms())] == name ? atoms[i+1] : undefinedAtom;
|
|
}
|
|
|
|
int Hashtable::find(Stringp x, const Atom *t, unsigned tLen) const
|
|
{
|
|
AvmAssert(x != NULL);
|
|
return find(x->atom(), t, tLen);
|
|
}
|
|
|
|
int Hashtable::find(Atom x, const Atom *t, unsigned m) const
|
|
{
|
|
int mask = ~dontEnumMask();
|
|
x &= mask;
|
|
|
|
#if 0 // debug code to print out the strings we're searching for
|
|
static int debug =0;
|
|
if (debug && AvmCore::isString(x))
|
|
{
|
|
Stringp s = AvmCore::atomToString(x);
|
|
AvmDebugMsg (s->c_str(), false);
|
|
AvmDebugMsg ("\n", false);
|
|
}
|
|
#endif
|
|
|
|
int bitmask = (m - 1) & ~0x1;
|
|
|
|
AvmAssert(x != EMPTY && x != DELETED);
|
|
// this is a quadratic probe but we only hit even numbered slots since those hold keys.
|
|
int n = 7 << 1;
|
|
#ifdef _DEBUG
|
|
unsigned loopCount = 0;
|
|
#endif
|
|
// Note: Mask off MSB to avoid negative indices. Mask off bottom
|
|
// 3 bits because it doesn't contribute to hash. Double it
|
|
// because names, values stored adjacently.
|
|
unsigned i = ((0x7FFFFFF8 & x)>>2) & bitmask;
|
|
Atom k;
|
|
while ((k=t[i]&mask) != x && k != EMPTY)
|
|
{
|
|
i = (i + (n += 2)) & bitmask; // quadratic probe
|
|
AvmAssert(loopCount++ < m); // don't scan forever
|
|
}
|
|
AvmAssert(i <= ((m-1)&~0x1));
|
|
return i;
|
|
}
|
|
|
|
Atom Hashtable::remove(Atom name)
|
|
{
|
|
int i = find(name, atoms, getNumAtoms());
|
|
Atom val = undefinedAtom;
|
|
if ((atoms[i]&~dontEnumMask()) == name)
|
|
{
|
|
val = atoms[i+1];
|
|
atoms[i] = DELETED;
|
|
atoms[i+1] = DELETED;
|
|
setHasDeletedItems(true);
|
|
}
|
|
return val;
|
|
}
|
|
|
|
int Hashtable::rehash(Atom *oldAtoms, int oldlen, Atom *newAtoms, int newlen)
|
|
{
|
|
int newSize = 0;
|
|
for (int i=0, n=oldlen; i < n; i += 2)
|
|
{
|
|
Atom oldAtom;
|
|
if ((oldAtom=oldAtoms[i]) != EMPTY && oldAtom != DELETED)
|
|
{
|
|
// inlined & simplified version of put()
|
|
int j = find(oldAtom, newAtoms, newlen);
|
|
newAtoms[j] = oldAtom;
|
|
newAtoms[j+1] = oldAtoms[i+1];
|
|
newSize++;
|
|
}
|
|
}
|
|
|
|
return newSize;
|
|
}
|
|
|
|
/**
|
|
* load factor is 0.75 so we're full if size >= M*0.75
|
|
* where M = atoms.length/2<br>
|
|
* size >= M*3/4<br>
|
|
* 4*size >= 3*M<br>
|
|
* 4*size >= 3*atoms.length/2<br>
|
|
* 8*size >= 3*atoms.length<br>
|
|
* size<<3 >= 3*atoms.length
|
|
*/
|
|
/**
|
|
* load factor is 0.9 so we're full if size >= M*0.9
|
|
* where M = atoms.length/2<br>
|
|
* size >= M*9/10<br>
|
|
* 10*size >= 9*M<br>
|
|
* 10*size >= 9*atoms.length/2<br>
|
|
* 20*size >= 9*atoms.length<br>
|
|
*/
|
|
bool Hashtable::isFull() const
|
|
{
|
|
// This seems to work very well and the Intel compiler converts both the multiplies
|
|
// into shift+add operations.
|
|
return (5*(getSize()+1)) >= 2*getNumAtoms(); // 0.80
|
|
#if 0
|
|
//return ((size<<3)+1) >= 3*getNumAtoms(); // 0.75
|
|
//return ((40*size)+1) >= 19*getNumAtoms(); // 0.95
|
|
//return ((40*size)+1) >= 18*getNumAtoms(); // 0.90
|
|
//return ((40*size)+1) >= 17*getNumAtoms(); // 0.85
|
|
//return ((40*size)+1) >= 15*getNumAtoms(); // 0.75
|
|
//Edwins suggestion - if (size > max - max>>N)) grow (N = 5, 4, 3, 2)
|
|
//#define SHIFTFACTOR 4
|
|
//NOT CORRECT
|
|
//return ( ( size << SHIFTFACTOR ) + size > (getNumAtoms() << (SHIFTFACTOR-1)) );
|
|
#endif
|
|
}
|
|
|
|
void Hashtable::add(Atom name, Atom value)
|
|
{
|
|
if (isFull())
|
|
{
|
|
grow();
|
|
}
|
|
put(name, value);
|
|
}
|
|
|
|
void Hashtable::grow()
|
|
{
|
|
// grow the table by 2N+1
|
|
// new = 2*old+1 ; old == o.atoms.length/2
|
|
// = 2*(o.atoms.length/2)+1
|
|
// = o.atoms.length + 1
|
|
// If we have deleted slots, we don't grow our HT because our rehash will clear
|
|
// out spots for us.
|
|
int capacity = hasDeletedItems() ? getNumAtoms() : MathUtils::nextPowerOfTwo(getNumAtoms()+1);
|
|
GC* gc = GC::GetGC(atoms);
|
|
MMGC_MEM_TYPE(this);
|
|
Atom *newAtoms = (Atom *) gc->Calloc(capacity, sizeof(Atom), GC::kContainsPointers|GC::kZero);
|
|
size = rehash(atoms, getNumAtoms(), newAtoms, capacity);
|
|
gc->Free (atoms);
|
|
setAtoms(newAtoms);
|
|
setNumAtoms(capacity);
|
|
setHasDeletedItems(false);
|
|
return;
|
|
}
|
|
|
|
Atom Hashtable::keyAt(int index)
|
|
{
|
|
return atoms[(index-1)<<1];
|
|
}
|
|
|
|
Atom Hashtable::valueAt(int index)
|
|
{
|
|
return atoms[((index-1)<<1)+1];
|
|
}
|
|
|
|
/* void Hashtable::removeAt(int index)
|
|
{
|
|
int i = (index-1)<<1;
|
|
atoms[i] = DELETED;
|
|
atoms[i+1] = DELETED;
|
|
setHasDeletedItems(true);
|
|
}*/
|
|
|
|
// call this method using the previous value returned
|
|
// by this method starting with 0, until 0 is returned.
|
|
int Hashtable::next(int index)
|
|
{
|
|
if (index != 0) {
|
|
index = index<<1;
|
|
}
|
|
// Advance to first non-empty slot.
|
|
int mask = dontEnumMask();
|
|
int numAtoms = getNumAtoms();
|
|
while (index < numAtoms) {
|
|
if ((atoms[index]&7) != EMPTY && (atoms[index]&7) != DELETED && (atoms[index]&mask) != kDontEnumBit) {
|
|
return (index>>1)+1;
|
|
}
|
|
index += 2;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool Hashtable::getAtomPropertyIsEnumerable(Atom name) const
|
|
{
|
|
if (hasDontEnumSupport())
|
|
{
|
|
int i = find(name, atoms, getNumAtoms());
|
|
if ((atoms[i]&~kDontEnumBit) == name)
|
|
{
|
|
return (atoms[i]&kDontEnumBit) == 0;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return contains(name);
|
|
}
|
|
}
|
|
|
|
void Hashtable::setAtomPropertyIsEnumerable(Atom name, bool enumerable)
|
|
{
|
|
if (hasDontEnumSupport())
|
|
{
|
|
int i = find(name, atoms, getNumAtoms());
|
|
if ((atoms[i]&~kDontEnumBit) == name)
|
|
{
|
|
atoms[i] = (atoms[i]&~kDontEnumBit) | (enumerable ? 0 : kDontEnumBit);
|
|
}
|
|
}
|
|
}
|
|
|
|
Atom WeakKeyHashtable::getKey(Atom key)
|
|
{
|
|
// this gets a weak ref number, ie double keys, okay I guess
|
|
if(AvmCore::isPointer(key)) {
|
|
GCWeakRef *weakRef = ((GCObject*)(key&~7))->GetWeakRef();
|
|
key = AvmCore::gcObjectToAtom(weakRef);
|
|
}
|
|
return key;
|
|
}
|
|
|
|
void WeakKeyHashtable::add(Atom key, Atom value)
|
|
{
|
|
if(isFull()) {
|
|
prune();
|
|
grow();
|
|
}
|
|
put(getKey(key), value);
|
|
}
|
|
|
|
void WeakKeyHashtable::prune()
|
|
{
|
|
for(int i=0, n=getNumAtoms(); i<n; i+=2) {
|
|
if(AvmCore::isGCObject(atoms[i])) {
|
|
GCWeakRef *ref = (GCWeakRef*)(atoms[i]&~7);
|
|
if(ref && ref->get() == NULL) {
|
|
// inlined delete
|
|
atoms[i] = DELETED;
|
|
atoms[i+1] = DELETED;
|
|
setHasDeletedItems(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Atom WeakValueHashtable::getValue(Atom key, Atom value)
|
|
{
|
|
if(AvmCore::isGCObject(value)) {
|
|
GCWeakRef *wr = (GCWeakRef*)(value&~7);
|
|
if(wr->get() != NULL) {
|
|
// note wr could be a pointer to a double, that's what this is for
|
|
if(GC::GetGC(atoms)->IsRCObject(wr->get())) {
|
|
value = ((AvmPlusScriptableObject*)wr->get())->toAtom();
|
|
} else {
|
|
AvmAssert(false);
|
|
}
|
|
} else {
|
|
remove(key);
|
|
value = undefinedAtom;
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
void WeakValueHashtable::add(Atom key, Atom value)
|
|
{
|
|
if(isFull()) {
|
|
prune();
|
|
grow();
|
|
}
|
|
if(AvmCore::isPointer(value)) {
|
|
GCWeakRef* wf = ((GCObject*)(value&~7))->GetWeakRef();
|
|
value = AvmCore::gcObjectToAtom(wf);
|
|
}
|
|
put(key, value);
|
|
}
|
|
|
|
void WeakValueHashtable::prune()
|
|
{
|
|
for(int i=0, n=getNumAtoms(); i<n; i+=2) {
|
|
if(AvmCore::isPointer(atoms[i+1])) {
|
|
GCWeakRef *ref = (GCWeakRef*)(atoms[i+1]&~7);
|
|
if(ref && ref->get() == NULL) {
|
|
// inlined delete
|
|
atoms[i] = DELETED;
|
|
atoms[i+1] = DELETED;
|
|
setHasDeletedItems(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|