__attribute__((visibility("default"))) void PL_InitArenaPool(
PLArenaPool *pool, const char *name, PRUint32 size, PRUint32 align)
{
static const PRUint8 pmasks[33] = {
0,
0, 1, 3, 3, 7, 7, 7, 7,15,15,15,15,15,15,15,15,
31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31};
if (align == 0)
align = sizeof(double);
if (align < sizeof(pmasks)/sizeof(pmasks[0]))
pool->mask = pmasks[align];
else
pool->mask = (((PRUint32)1 << (PR_CeilingLog2(align))) - 1);
pool->first.next = ((void *)0);
pool->first.base = pool->first.avail = pool->first.limit =
(PRUword)(((PRUword)(&pool->first + 1) + (pool)->mask) /* & ~(pool)->mask */);
pool->current = &pool->first;
pool->arenasize = size;
}
bool
nsAttrAndChildArray::GrowBy(PRUint32 aGrowSize)
{
PRUint32 size = mImpl ? mImpl->mBufferSize + NS_IMPL_EXTRA_SIZE : 0;
PRUint32 minSize = size + aGrowSize;
if (minSize <= ATTRCHILD_ARRAY_LINEAR_THRESHOLD) {
do {
size += ATTRCHILD_ARRAY_GROWSIZE;
} while (size < minSize);
}
else {
size = PR_BIT(PR_CeilingLog2(minSize));
}
bool needToInitialize = !mImpl;
Impl* newImpl = static_cast<Impl*>(PR_Realloc(mImpl, size * sizeof(void*)));
NS_ENSURE_TRUE(newImpl, false);
mImpl = newImpl;
// Set initial counts if we didn't have a buffer before
if (needToInitialize) {
mImpl->mMappedAttrs = nsnull;
SetAttrSlotAndChildCount(0, 0);
}
mImpl->mBufferSize = size - NS_IMPL_EXTRA_SIZE;
return true;
}
PR_IMPLEMENT(void) PL_InitArenaPool(
PLArenaPool *pool, const char *name, PRUint32 size, PRUint32 align)
{
/*
* Look-up table of PR_BITMASK(PR_CeilingLog2(align)) values for
* align = 1 to 32.
*/
static const PRUint8 pmasks[33] = {
0, /* not used */
0, 1, 3, 3, 7, 7, 7, 7,15,15,15,15,15,15,15,15, /* 1 ... 16 */
31,31,31,31,31,31,31,31,31,31,31,31,31,31,31,31}; /* 17 ... 32 */
if (align == 0)
align = PL_ARENA_DEFAULT_ALIGN;
if (align < sizeof(pmasks)/sizeof(pmasks[0]))
pool->mask = pmasks[align];
else
pool->mask = PR_BITMASK(PR_CeilingLog2(align));
pool->first.next = NULL;
pool->first.base = pool->first.avail = pool->first.limit =
(PRUword)PL_ARENA_ALIGN(pool, &pool->first + 1);
pool->current = &pool->first;
pool->arenasize = size;
#ifdef PL_ARENAMETER
memset(&pool->stats, 0, sizeof pool->stats);
pool->stats.name = strdup(name);
pool->stats.next = arena_stats_list;
arena_stats_list = &pool->stats;
#endif
}
PR_IMPLEMENT(void) PL_InitArenaPool(
PLArenaPool *pool, const char *name, PRUint32 size, PRUint32 align)
{
#if defined(XP_MAC)
#pragma unused (name)
#endif
if (align == 0)
align = PL_ARENA_DEFAULT_ALIGN;
pool->mask = PR_BITMASK(PR_CeilingLog2(align));
pool->first.next = NULL;
/* Set all three addresses in pool->first to the same dummy value.
* These addresses are only compared with each other, but never
* dereferenced. */
pool->first.base = pool->first.avail = pool->first.limit =
(PRUword)PL_ARENA_ALIGN(pool, &pool->first + 1);
pool->current = &pool->first;
pool->arenasize = size;
#ifdef PL_ARENAMETER
memset(&pool->stats, 0, sizeof pool->stats);
pool->stats.name = strdup(name);
pool->stats.next = arena_stats_list;
arena_stats_list = &pool->stats;
#endif
}
JSEventNames *
lm_GetEventNames(uint32 event_bit)
{
uint index = (uint)PR_CeilingLog2(event_bit);
if (index >= NUM_EVENTS)
return NULL;
return &event_names[index];
}
const char *
lm_EventName(uint32 event_bit)
{
uint index = (uint)PR_CeilingLog2(event_bit);
if (index >= NUM_EVENTS)
return "unknown event";
return event_names[index].lowerName;
}
PRBool nsSupportsArray::GrowArrayBy(PRInt32 aGrowBy)
{
// We have to grow the array. Grow by kGrowArrayBy slots if we're smaller
// than kLinearThreshold bytes, or a power of two if we're larger.
// This is much more efficient with most memory allocators, especially
// if it's very large, or of the allocator is binned.
if (aGrowBy < kGrowArrayBy)
aGrowBy = kGrowArrayBy;
PRUint32 newCount = mArraySize + aGrowBy; // Minimum increase
PRUint32 newSize = sizeof(mArray[0]) * newCount;
if (newSize >= (PRUint32) kLinearThreshold)
{
// newCount includes enough space for at least kGrowArrayBy new slots.
// Select the next power-of-two size in bytes above that if newSize is
// not a power of two.
if (newSize & (newSize - 1))
newSize = PR_BIT(PR_CeilingLog2(newSize));
newCount = newSize / sizeof(mArray[0]);
}
// XXX This would be far more efficient in many allocators if we used
// XXX PR_Realloc(), etc
nsISupports** oldArray = mArray;
mArray = new nsISupports*[newCount];
if (!mArray) { // ran out of memory
mArray = oldArray;
return PR_FALSE;
}
mArraySize = newCount;
#if DEBUG_SUPPORTSARRAY
if (oldArray == mArray) // can't happen without use of realloc
ADD_TO_STATS(GrowInPlace,mCount);
ADD_TO_STATS(AllocedOfSize,mArraySize*sizeof(mArray[0]));
if (mArraySize > mMaxSize)
{
ADD_TO_STATS(NumberOfSize,mArraySize*sizeof(mArray[0]));
if (oldArray != &(mAutoArray[0]))
SUB_FROM_STATS(NumberOfSize,mCount*sizeof(mArray[0]));
mMaxSize = mArraySize;
}
#endif
if (oldArray) { // need to move old data
if (0 < mCount) {
::memcpy(mArray, oldArray, mCount * sizeof(nsISupports*));
}
if (oldArray != &(mAutoArray[0])) {
delete[] oldArray;
}
}
return PR_TRUE;
}
PL_NewHashTable(PRUint32 n, PLHashFunction keyHash,
PLHashComparator keyCompare, PLHashComparator valueCompare,
const PLHashAllocOps *allocOps, void *allocPriv)
{
PLHashTable *ht;
PRSize nb;
if (n <= MINBUCKETS) {
n = MINBUCKETSLOG2;
} else {
n = PR_CeilingLog2(n);
if ((PRInt32)n < 0)
return 0;
}
if (!allocOps) allocOps = &defaultHashAllocOps;
ht = (PLHashTable*)((*allocOps->allocTable)(allocPriv, sizeof *ht));
if (!ht)
return 0;
memset(ht, 0, sizeof *ht);
ht->shift = PL_HASH_BITS - n;
n = 1 << n;
#if defined(WIN16)
if (n > 16000) {
(*allocOps->freeTable)(allocPriv, ht);
return 0;
}
#endif /* WIN16 */
nb = n * sizeof(PLHashEntry *);
ht->buckets = (PLHashEntry**)((*allocOps->allocTable)(allocPriv, nb));
if (!ht->buckets) {
(*allocOps->freeTable)(allocPriv, ht);
return 0;
}
memset(ht->buckets, 0, nb);
ht->keyHash = keyHash;
ht->keyCompare = keyCompare;
ht->valueCompare = valueCompare;
ht->allocOps = allocOps;
ht->allocPriv = allocPriv;
return ht;
}
PR_IMPLEMENT(void) PL_InitArenaPool(
PLArenaPool *pool, const char *name, PRUint32 size, PRUint32 align)
{
#if !defined (__GNUC__)
#pragma unused (name)
#endif
if (align == 0)
align = PL_ARENA_DEFAULT_ALIGN;
pool->mask = PR_BITMASK(PR_CeilingLog2(align));
pool->first.next = NULL;
pool->first.base = pool->first.avail = pool->first.limit =
(PRUword)PL_ARENA_ALIGN(pool, &pool->first + 1);
pool->current = &pool->first;
pool->arenasize = size;
#ifdef PL_ARENAMETER
memset(&pool->stats, 0, sizeof pool->stats);
pool->stats.name = strdup(name);
pool->stats.next = arena_stats_list;
arena_stats_list = &pool->stats;
#endif
}
int main(int argc, char **argv)
{
/*
** Test bitmap things.
*/
if ( PR_TEST_BIT( myMap, 0 ))
ErrorReport("Test 0.0: Failed\n");
if ( PR_TEST_BIT( myMap, 31 ))
ErrorReport("Test 0.1: Failed\n");
if ( PR_TEST_BIT( myMap, 128 ))
ErrorReport("Test 0.2: Failed\n");
if ( PR_TEST_BIT( myMap, 129 ))
ErrorReport("Test 0.3: Failed\n");
PR_SET_BIT( myMap, 0 );
if ( !PR_TEST_BIT( myMap, 0 ))
ErrorReport("Test 1.0: Failed\n");
PR_CLEAR_BIT( myMap, 0 );
if ( PR_TEST_BIT( myMap, 0 ))
ErrorReport("Test 1.0.1: Failed\n");
PR_SET_BIT( myMap, 31 );
if ( !PR_TEST_BIT( myMap, 31 ))
ErrorReport("Test 1.1: Failed\n");
PR_CLEAR_BIT( myMap, 31 );
if ( PR_TEST_BIT( myMap, 31 ))
ErrorReport("Test 1.1.1: Failed\n");
PR_SET_BIT( myMap, 128 );
if ( !PR_TEST_BIT( myMap, 128 ))
ErrorReport("Test 1.2: Failed\n");
PR_CLEAR_BIT( myMap, 128 );
if ( PR_TEST_BIT( myMap, 128 ))
ErrorReport("Test 1.2.1: Failed\n");
PR_SET_BIT( myMap, 129 );
if ( !PR_TEST_BIT( myMap, 129 ))
ErrorReport("Test 1.3: Failed\n");
PR_CLEAR_BIT( myMap, 129 );
if ( PR_TEST_BIT( myMap, 129 ))
ErrorReport("Test 1.3.1: Failed\n");
/*
** Test Ceiling and Floor functions and macros
*/
if ((rc = PR_CeilingLog2(32)) != 5 )
ErrorReport("Test 10.0: Failed\n");
if ((rc = PR_FloorLog2(32)) != 5 )
ErrorReport("Test 10.1: Failed\n");
/*
** Evaluate results and exit
*/
if (failed)
{
printf("FAILED\n");
return(1);
}
else
{
printf("PASSED\n");
return(0);
}
} /* end main() */
