#include "sarray.h"
#include "runtime.h"
#include <stdio.h>
#include "assert.h"
int nbuckets = 0;
int nindices = 0;
int narrays = 0;
int idxsize = 0;
static void * first_free_data = NULL;
#ifdef OBJC_SPARSE2
const char* __objc_sparse2_id = "2 level sparse indices";
#endif
#ifdef OBJC_SPARSE3
const char* __objc_sparse3_id = "3 level sparse indices";
#endif
void
sarray_remove_garbage(void)
{
void **vp;
void *np;
objc_mutex_lock(__objc_runtime_mutex);
vp = first_free_data;
first_free_data = NULL;
while (vp) {
np = *vp;
objc_free(vp);
vp = np;
}
objc_mutex_unlock(__objc_runtime_mutex);
}
static void
sarray_free_garbage(void *vp)
{
objc_mutex_lock(__objc_runtime_mutex);
if (__objc_runtime_threads_alive == 1) {
objc_free(vp);
if (first_free_data)
sarray_remove_garbage();
}
else {
*(void **)vp = first_free_data;
first_free_data = vp;
}
objc_mutex_unlock(__objc_runtime_mutex);
}
void
sarray_at_put(struct sarray* array, sidx index, void* element)
{
#ifdef OBJC_SPARSE3
struct sindex** the_index;
struct sindex* new_index;
#endif
struct sbucket** the_bucket;
struct sbucket* new_bucket;
#ifdef OBJC_SPARSE3
size_t ioffset;
#endif
size_t boffset;
size_t eoffset;
#ifdef PRECOMPUTE_SELECTORS
union sofftype xx;
xx.idx = index;
#ifdef OBJC_SPARSE3
ioffset = xx.off.ioffset;
#endif
boffset = xx.off.boffset;
eoffset = xx.off.eoffset;
#else
#ifdef OBJC_SPARSE3
ioffset = index/INDEX_CAPACITY;
boffset = (index/BUCKET_SIZE)%INDEX_SIZE;
eoffset = index%BUCKET_SIZE;
#else
boffset = index/BUCKET_SIZE;
eoffset = index%BUCKET_SIZE;
#endif
#endif
assert(soffset_decode(index) < array->capacity);
#ifdef OBJC_SPARSE3
the_index = &(array->indices[ioffset]);
the_bucket = &((*the_index)->buckets[boffset]);
#else
the_bucket = &(array->buckets[boffset]);
#endif
if ((*the_bucket)->elems[eoffset] == element)
return;
#ifdef OBJC_SPARSE3
if ((*the_index) == array->empty_index) {
new_index = (struct sindex*)objc_malloc(sizeof(struct sindex));
memcpy(new_index, array->empty_index, sizeof(struct sindex));
new_index->version.version = array->version.version;
*the_index = new_index;
the_bucket = &((*the_index)->buckets[boffset]);
nindices += 1;
} else if ((*the_index)->version.version != array->version.version) {
struct sindex* old_index = *the_index;
new_index = (struct sindex*)objc_malloc(sizeof(struct sindex));
memcpy( new_index, old_index, sizeof(struct sindex));
new_index->version.version = array->version.version;
*the_index = new_index;
the_bucket = &((*the_index)->buckets[boffset]);
nindices += 1;
}
#endif
if ((*the_bucket) == array->empty_bucket) {
new_bucket = (struct sbucket*)objc_malloc(sizeof(struct sbucket));
memcpy((void *) new_bucket, (const void*)array->empty_bucket,
sizeof(struct sbucket));
new_bucket->version.version = array->version.version;
*the_bucket = new_bucket;
nbuckets += 1;
} else if ((*the_bucket)->version.version != array->version.version) {
struct sbucket* old_bucket = *the_bucket;
new_bucket = (struct sbucket*)objc_malloc(sizeof(struct sbucket));
memcpy( new_bucket, old_bucket, sizeof(struct sbucket));
new_bucket->version.version = array->version.version;
*the_bucket = new_bucket;
nbuckets += 1;
}
(*the_bucket)->elems[eoffset] = element;
}
void
sarray_at_put_safe(struct sarray* array, sidx index, void* element)
{
if(soffset_decode(index) >= array->capacity)
sarray_realloc(array, soffset_decode(index)+1);
sarray_at_put(array, index, element);
}
struct sarray*
sarray_new (int size, void* default_element)
{
struct sarray* arr;
#ifdef OBJC_SPARSE3
size_t num_indices = ((size-1)/(INDEX_CAPACITY))+1;
struct sindex ** new_indices;
#else
size_t num_indices = ((size-1)/BUCKET_SIZE)+1;
struct sbucket ** new_buckets;
#endif
int counter;
assert(size > 0);
arr = (struct sarray*) objc_malloc(sizeof(struct sarray));
arr->version.version = 0;
#ifdef OBJC_SPARSE3
arr->capacity = num_indices*INDEX_CAPACITY;
new_indices = (struct sindex**)
objc_malloc(sizeof(struct sindex*)*num_indices);
arr->empty_index = (struct sindex*) objc_malloc(sizeof(struct sindex));
arr->empty_index->version.version = 0;
narrays += 1;
idxsize += num_indices;
nindices += 1;
#else
arr->capacity = num_indices*BUCKET_SIZE;
new_buckets = (struct sbucket**)
objc_malloc(sizeof(struct sbucket*)*num_indices);
narrays += 1;
idxsize += num_indices;
#endif
arr->empty_bucket = (struct sbucket*) objc_malloc(sizeof(struct sbucket));
arr->empty_bucket->version.version = 0;
nbuckets += 1;
arr->ref_count = 1;
arr->is_copy_of = (struct sarray*)0;
for (counter=0; counter<BUCKET_SIZE; counter++)
arr->empty_bucket->elems[counter] = default_element;
#ifdef OBJC_SPARSE3
for (counter=0; counter<INDEX_SIZE; counter++)
arr->empty_index->buckets[counter] = arr->empty_bucket;
for (counter=0; counter<num_indices; counter++)
new_indices[counter] = arr->empty_index;
#else
for (counter=0; counter<num_indices; counter++)
new_buckets[counter] = arr->empty_bucket;
#endif
#ifdef OBJC_SPARSE3
arr->indices = new_indices;
#else
arr->buckets = new_buckets;
#endif
return arr;
}
void
sarray_realloc(struct sarray* array, int newsize)
{
#ifdef OBJC_SPARSE3
size_t old_max_index = (array->capacity-1)/INDEX_CAPACITY;
size_t new_max_index = ((newsize-1)/INDEX_CAPACITY);
size_t rounded_size = (new_max_index+1)*INDEX_CAPACITY;
struct sindex ** new_indices;
struct sindex ** old_indices;
#else
size_t old_max_index = (array->capacity-1)/BUCKET_SIZE;
size_t new_max_index = ((newsize-1)/BUCKET_SIZE);
size_t rounded_size = (new_max_index+1)*BUCKET_SIZE;
struct sbucket ** new_buckets;
struct sbucket ** old_buckets;
#endif
int counter;
assert(newsize > 0);
if(rounded_size <= array->capacity)
return;
assert(array->ref_count == 1);
if(rounded_size > array->capacity)
{
#ifdef OBJC_SPARSE3
new_max_index += 4;
rounded_size = (new_max_index+1)*INDEX_CAPACITY;
#else
new_max_index += 4;
rounded_size = (new_max_index+1)*BUCKET_SIZE;
#endif
array->capacity = rounded_size;
#ifdef OBJC_SPARSE3
old_indices = array->indices;
new_indices = (struct sindex**)
objc_malloc((new_max_index+1)*sizeof(struct sindex*));
#else
old_buckets = array->buckets;
new_buckets = (struct sbucket**)
objc_malloc((new_max_index+1)*sizeof(struct sbucket*));
#endif
for(counter = 0; counter <= old_max_index; counter++ ) {
#ifdef OBJC_SPARSE3
new_indices[counter] = old_indices[counter];
#else
new_buckets[counter] = old_buckets[counter];
#endif
}
#ifdef OBJC_SPARSE3
for(counter = old_max_index+1; counter <= new_max_index; counter++)
new_indices[counter] = array->empty_index;
#else
for(counter = old_max_index+1; counter <= new_max_index; counter++)
new_buckets[counter] = array->empty_bucket;
#endif
#ifdef OBJC_SPARSE3
array->indices = new_indices;
#else
array->buckets = new_buckets;
#endif
#ifdef OBJC_SPARSE3
sarray_free_garbage(old_indices);
#else
sarray_free_garbage(old_buckets);
#endif
idxsize += (new_max_index-old_max_index);
return;
}
}
void
sarray_free(struct sarray* array) {
#ifdef OBJC_SPARSE3
size_t old_max_index = (array->capacity-1)/INDEX_CAPACITY;
struct sindex ** old_indices;
#else
size_t old_max_index = (array->capacity-1)/BUCKET_SIZE;
struct sbucket ** old_buckets;
#endif
int counter = 0;
assert(array->ref_count != 0);
if(--(array->ref_count) != 0)
return;
#ifdef OBJC_SPARSE3
old_indices = array->indices;
#else
old_buckets = array->buckets;
#endif
if((array->is_copy_of) && ((array->is_copy_of->ref_count - 1) == 0))
sarray_free(array->is_copy_of);
for(counter = 0; counter <= old_max_index; counter++ ) {
#ifdef OBJC_SPARSE3
struct sindex* idx = old_indices[counter];
if((idx != array->empty_index) &&
(idx->version.version == array->version.version)) {
int c2;
for(c2=0; c2<INDEX_SIZE; c2++) {
struct sbucket* bkt = idx->buckets[c2];
if((bkt != array->empty_bucket) &&
(bkt->version.version == array->version.version))
{
sarray_free_garbage(bkt);
nbuckets -= 1;
}
}
sarray_free_garbage(idx);
nindices -= 1;
}
#else
struct sbucket* bkt = array->buckets[counter];
if ((bkt != array->empty_bucket) &&
(bkt->version.version == array->version.version))
{
sarray_free_garbage(bkt);
nbuckets -= 1;
}
#endif
}
#ifdef OBJC_SPARSE3
if(array->empty_index->version.version == array->version.version) {
sarray_free_garbage(array->empty_index);
nindices -= 1;
}
#endif
if(array->empty_bucket->version.version == array->version.version) {
sarray_free_garbage(array->empty_bucket);
nbuckets -= 1;
}
idxsize -= (old_max_index+1);
narrays -= 1;
#ifdef OBJC_SPARSE3
sarray_free_garbage(array->indices);
#else
sarray_free_garbage(array->buckets);
#endif
sarray_free_garbage(array);
}
struct sarray*
sarray_lazy_copy(struct sarray* oarr)
{
struct sarray* arr;
#ifdef OBJC_SPARSE3
size_t num_indices = ((oarr->capacity-1)/INDEX_CAPACITY)+1;
struct sindex ** new_indices;
#else
size_t num_indices = ((oarr->capacity-1)/BUCKET_SIZE)+1;
struct sbucket ** new_buckets;
#endif
arr = (struct sarray*) objc_malloc(sizeof(struct sarray));
arr->version.version = oarr->version.version + 1;
#ifdef OBJC_SPARSE3
arr->empty_index = oarr->empty_index;
#endif
arr->empty_bucket = oarr->empty_bucket;
arr->ref_count = 1;
oarr->ref_count += 1;
arr->is_copy_of = oarr;
arr->capacity = oarr->capacity;
#ifdef OBJC_SPARSE3
new_indices = (struct sindex**)
objc_malloc(sizeof(struct sindex*)*num_indices);
memcpy( new_indices,oarr->indices,
sizeof(struct sindex*)*num_indices);
arr->indices = new_indices;
#else
new_buckets = (struct sbucket**)
objc_malloc(sizeof(struct sbucket*)*num_indices);
memcpy( new_buckets,oarr->buckets,
sizeof(struct sbucket*)*num_indices);
arr->buckets = new_buckets;
#endif
idxsize += num_indices;
narrays += 1;
return arr;
}