int main( )
{
int rc = 0;
//heap_dump();
int original_count = heap_count( );
try {
if( !construct_test( ) || !heap_ok( "t1" ) ) rc = 1;
if( !access_test( ) || !heap_ok( "t2" ) ) rc = 1;
//if( !string_test( ) || !heap_ok( "t3" ) ) rc = 1;
//if( !torture_test( ) || !heap_ok( "t4" ) ) rc = 1;
//if( !clear_test( ) || !heap_ok( "t5" ) ) rc = 1;
if( !iterator_test( ) || !heap_ok( "t6" ) ) rc = 1;
if( !copy_test( ) || !heap_ok( "t7" ) ) rc = 1;
if( !allocator_test( ) || !heap_ok( "t8" ) ) rc = 1;
if( !bounds_test( ) || !heap_ok( "t9" ) ) rc = 1;
if( !hint_ins_test( ) || !heap_ok( "tA" ) ) rc = 1;
}
catch( ... ) {
std::cout << "Unexpected exception of unexpected type.\n";
rc = 1;
}
int heap_diff = heap_count( ) - original_count;
if( heap_diff ) {
heap_dump();
std::cout << "Possible memory leak! " << heap_diff << " " << original_count << "\n";
rc = 1;
}
return( rc );
}
void gc_sweep(VM* _vm) {
ObjectHeader** object = &(vm->heap_list);
debug2("object =%p\n", object);
while (*object) {
if (!(*object)->marked) {
ObjectHeader* unreached = *object;
*object = unreached->next;
if(unreached->type == OBJ_VM) vm_finalize((VM*)&unreached[1]);
free(unreached);
vm->heap_num--;
} else {
(*object)->marked = 0;
if(_vm) {
printf("gc sweep vm\n");
ObjectHeader* moving = *object;
*object = moving->next;
debug2("id change\n");
_vm->heap_num++;
moving->next = _vm->heap_list;
_vm->heap_list = moving;
printf("heap_num %ld %ld\n", _vm->heap_num, heap_count(_vm->heap_list));
assert(_vm->heap_num == heap_count(_vm->heap_list));
} else {
object = &(*object)->next;
}
}
}
}
static void __batcher_loop(void *n)
{
batch_monitor_t* m = n;
uv_mutex_lock(&m->lock);
batch_queue_t *bq = &m->queues[m->curr_idx];
batch_queue_t *prev_bq =
&m->queues[(m->curr_idx + 1) % MAX_BATCH_QUEUES];
if (0 < prev_bq->puts_waiting || 0 == heap_count(bq->queue))
{
struct timespec tim, tim2;
tim.tv_sec = 0;
tim.tv_nsec = m->nanos;
if (nanosleep(&tim, &tim2) < 0)
printf("Nano sleep system call failed \n");
uv_mutex_unlock(&m->lock);
return;
}
m->commit(m, bq);
m->curr_idx = (m->curr_idx + 1) % MAX_BATCH_QUEUES;
uv_mutex_unlock(&m->lock);
uv_cond_signal(&m->done);
}
int main( )
{
int rc = 0;
int original_count = heap_count( );
try {
if( !construct_test( ) || !heap_ok( "t01" ) ) rc = 1;
if( !assign_test( ) || !heap_ok( "t02" ) ) rc = 1;
if( !access_test( ) || !heap_ok( "t03" ) ) rc = 1;
if( !relational_test( ) || !heap_ok( "t04" ) ) rc = 1;
if( !capacity_test( ) || !heap_ok( "t05" ) ) rc = 1;
if( !iterator_test( ) || !heap_ok( "t06" ) ) rc = 1;
if( !append_test( ) || !heap_ok( "t07" ) ) rc = 1;
if( !insert_test( ) || !heap_ok( "t08" ) ) rc = 1;
if( !erase_test( ) || !heap_ok( "t09" ) ) rc = 1;
if( !replace_test( ) || !heap_ok( "t10" ) ) rc = 1;
if( !iterator_replace_test( ) || !heap_ok( "t11" ) ) rc = 1;
if( !copy_test( ) || !heap_ok( "t12" ) ) rc = 1;
if( !swap_test( ) || !heap_ok( "t13" ) ) rc = 1;
if( !cstr_test( ) || !heap_ok( "t14" ) ) rc = 1;
if( !find_test( ) || !heap_ok( "t15" ) ) rc = 1;
if( !rfind_test( ) || !heap_ok( "t16" ) ) rc = 1;
if( !find_first_of_test( ) || !heap_ok( "t17" ) ) rc = 1;
if( !find_last_of_test( ) || !heap_ok( "t18" ) ) rc = 1;
if( !find_first_not_of_test( ) || !heap_ok( "t19" ) ) rc = 1;
if( !find_last_not_of_test( ) || !heap_ok( "t20" ) ) rc = 1;
if( !substr_test( ) || !heap_ok( "t21" ) ) rc = 1;
}
catch( std::out_of_range e ) {
std::cout << "Unexpected out_of_range exception: " << e.what( ) << "\n";
rc = 1;
}
catch( std::length_error e ) {
std::cout << "Unexpected length_error exception: " << e.what( ) << "\n";
rc = 1;
}
catch( ... ) {
std::cout << "Unexpected exception of unexpected type.\n";
rc = 1;
}
if( heap_count( ) != original_count ) {
std::cout << "Possible memory leak!\n";
rc = 1;
}
return( rc );
}
int main( )
{
int rc = 0;
int original_count = heap_count( );
try {
if( !some_test( ) || !heap_ok( "t01" ) ) rc = 1;
}
catch( ... ) {
std::cout << "Unexpected exception of unexpected type.\n";
rc = 1;
}
if( heap_count( ) != original_count ) {
std::cout << "Possible memory leak!\n";
rc = 1;
}
return( rc );
}
/**
* @return the item on the top of the heap */
void *heap_peek(heap_t * hp)
{
if (!hp)
return NULL;
if (0 == heap_count(hp))
return NULL;
return hp->array[0];
}
static int __batcher_commit(batch_monitor_t* m, batch_queue_t* bq)
{
if (0 == heap_count(bq->queue))
return 0;
MDB_txn *txn;
int e = mdb_txn_begin(sv->db_env, NULL, 0, &txn);
if (0 != e)
mdb_fatal(e);
while (0 < heap_count(bq->queue))
{
batch_item_t* item = heap_poll(bq->queue);
e = mdb_put(txn, sv->docs, &item->key, &item->val, item->flags);
switch (e)
{
case 0:
break;
case MDB_MAP_FULL:
{
mdb_txn_abort(txn);
while ((item = heap_poll(bq->queue)))
;
snprintf(batcher_error, BATCHER_ERROR_LEN, "NOT ENOUGH SPACE");
return -1;
}
case MDB_KEYEXIST:
item->flags = WOULD_OVERWRITE;
break;
default:
mdb_fatal(e);
}
}
e = mdb_txn_commit(txn);
if (0 != e)
mdb_fatal(e);
return 0;
}
int main( )
{
int rc = 0;
int original_count = heap_count( );
try {
if( !basic_test< std::deque< int > >( ) || !heap_ok( "t01" ) ) rc = 1;
if( !basic_test< std::list< int > >( ) || !heap_ok( "t02" ) ) rc = 1;
if( !relational_test( ) || !heap_ok( "t03" ) ) rc = 1;
if( !basic_priority_test( ) || !heap_ok( "t04" ) ) rc = 1;
}
catch( ... ) {
std::cout << "Unexpected exception of unexpected type.\n";
rc = 1;
}
if( heap_count( ) != original_count ) {
std::cout << "Possible memory leak!\n";
rc = 1;
}
return( rc );
}
static bool
heap_resize(heap_t h, size_t newsz)
{
if (!newsz)
newsz = 1;
if (newsz < heap_count(h))
return false;
void **newloc = realloc(h->tree, newsz * sizeof *newloc);
if (!newloc)
return false;
h->tree = newloc;
h->treesz = newsz;
return true;
}
/**
* Find a slot that is free on this VBO
* @return a new item slot on this VBO
*/
int ren_vbosquare_new_itemslot(const int id)
{
vbo_t *vb = __get_vbo_from_id(id);
/* if the heap is empty just use the most latest slot */
if (0 == heap_count(vb->heap))
{
assert(vb->n_length_inuse < vb->n_elem);
return vb->n_length_inuse++;
}
else
{
unsigned long slot;
slot = (unsigned long) heap_poll(vb->heap);
return slot;
}
}
/**
* Find a slot that is free on this VBO
* @return a new item slot on this VBO
*/
int ren_vbom_new_itemslot(
const int id
)
{
vbo_t *vb = __get_vbo_from_id(id);
if (0 == heap_count(vb->heap))
{
assert(vb->n_length_inuse < vb->n_elem);
return vb->n_length_inuse++;
}
else
{
unsigned long slot;
slot = (unsigned long) heap_poll(vb->heap);
return slot;
}
}
/**
* Remove the top value from this heap.
* @return top item of the heap */
void *heap_poll(heap_t * hp)
{
void *item;
assert(hp);
if (!hp)
return NULL;
if (0 == heap_count(hp))
return NULL;
#if DEBUG
DEBUG_check_validity(hp);
#endif
item = hp->array[0];
hp->array[0] = NULL;
__swap(hp, 0, hp->count - 1);
hp->count--;
#if DEBUG
DEBUG_check_validity(hp);
#endif
if (hp->count > 0)
{
assert(hp->array[0]);
__pushdown(hp, 0);
}
#if DEBUG
DEBUG_check_validity(hp);
#endif
return item;
}
int
priqueue_count(struct PriQueue *priqueue)
{
assert(priqueue != NULL);
return heap_count(priqueue->heap);
}
void evg_compute_unit_free(struct evg_compute_unit_t *compute_unit)
{
struct heap_t *event_queue;
struct evg_uop_t *uop;
int i;
/* CF Engine - free uops in fetch buffer, instruction buffer, and complete queue */
for (i = 0; i < evg_gpu_max_wavefronts_per_compute_unit; i++)
{
evg_uop_free(compute_unit->cf_engine.fetch_buffer[i]);
evg_uop_free(compute_unit->cf_engine.inst_buffer[i]);
}
evg_uop_list_free(compute_unit->cf_engine.complete_queue);
/* CF Engine - free structures */
free(compute_unit->cf_engine.fetch_buffer);
free(compute_unit->cf_engine.inst_buffer);
linked_list_free(compute_unit->cf_engine.complete_queue);
/* ALU Engine - free uops in event queue (heap) */
event_queue = compute_unit->alu_engine.event_queue;
while (heap_count(event_queue))
{
heap_extract(event_queue, (void **) &uop);
uop->write_subwavefront_count++;
if (uop->write_subwavefront_count == uop->subwavefront_count)
evg_uop_free(uop);
}
/* ALU Engine - free uops in fetch queue, instruction buffer, execution buffer,
* and event queue. Also free CF instruction currently running. */
evg_uop_list_free(compute_unit->alu_engine.pending_queue);
evg_uop_list_free(compute_unit->alu_engine.finished_queue);
evg_uop_list_free(compute_unit->alu_engine.fetch_queue);
evg_uop_free(compute_unit->alu_engine.inst_buffer);
evg_uop_free(compute_unit->alu_engine.exec_buffer);
/* ALU Engine - structures */
linked_list_free(compute_unit->alu_engine.pending_queue);
linked_list_free(compute_unit->alu_engine.finished_queue);
linked_list_free(compute_unit->alu_engine.fetch_queue);
heap_free(compute_unit->alu_engine.event_queue);
/* TEX Engine - free uop in fetch queue, instruction buffer, write buffer. */
evg_uop_list_free(compute_unit->tex_engine.pending_queue);
evg_uop_list_free(compute_unit->tex_engine.finished_queue);
evg_uop_list_free(compute_unit->tex_engine.fetch_queue);
evg_uop_free(compute_unit->tex_engine.inst_buffer);
evg_uop_list_free(compute_unit->tex_engine.load_queue);
/* TEX Engine - structures */
linked_list_free(compute_unit->tex_engine.pending_queue);
linked_list_free(compute_unit->tex_engine.finished_queue);
linked_list_free(compute_unit->tex_engine.fetch_queue);
linked_list_free(compute_unit->tex_engine.load_queue);
/* Compute unit */
linked_list_free(compute_unit->wavefront_pool);
free(compute_unit->work_groups); /* List of mapped work-groups */
mod_free(compute_unit->local_memory);
free(compute_unit);
}
QueryResult *Query_Execute(Query *query) {
//__queryStage_Print(query->root, 0);
QueryResult *res = malloc(sizeof(QueryResult));
res->error = 0;
res->errorString = NULL;
res->totalResults = 0;
res->ids = NULL;
res->numIds = 0;
int num = query->offset + query->limit;
heap_t *pq = malloc(heap_sizeof(num));
heap_init(pq, cmpHits, NULL, num);
// start lazy evaluation of all query steps
IndexIterator *it = NULL;
if (query->root != NULL) {
it = Query_EvalStage(query, query->root);
}
// no query evaluation plan?
if (query->root == NULL || it == NULL) {
res->error = QUERY_ERROR_INTERNAL;
res->errorString = QUERY_ERROR_INTERNAL_STR;
return res;
}
IndexHit *pooledHit = NULL;
// iterate the root iterator and push everything to the PQ
while (1) {
// TODO - Use static allocation
if (pooledHit == NULL) {
pooledHit = malloc(sizeof(IndexHit));
}
IndexHit *h = pooledHit;
IndexHit_Init(h);
int rc = it->Read(it->ctx, h);
if (rc == INDEXREAD_EOF) {
break;
} else if (rc == INDEXREAD_NOTFOUND) {
continue;
}
h->totalFreq = processHitScore(h, query->docTable);
++res->totalResults;
if (heap_count(pq) < heap_size(pq)) {
heap_offerx(pq, h);
pooledHit = NULL;
} else {
IndexHit *qh = heap_peek(pq);
if (qh->totalFreq < h->totalFreq) {
pooledHit = heap_poll(pq);
heap_offerx(pq, h);
// IndexHit_Terminate(pooledHit);
} else {
pooledHit = h;
// IndexHit_Terminate(pooledHit);
}
}
}
if (pooledHit) {
free(pooledHit);
}
it->Free(it);
// Reverse the results into the final result
size_t n = MIN(heap_count(pq), query->limit);
res->numIds = n;
res->ids = calloc(n, sizeof(RedisModuleString *));
for (int i = 0; i < n; ++i) {
IndexHit *h = heap_poll(pq);
LG_DEBUG("Popping %d freq %f", h->docId, h->totalFreq);
res->ids[n - i - 1] = Redis_GetDocKey(query->ctx, h->docId);
free(h);
}
// if we still have something in the heap (meaning offset > 0), we need to
// poll...
while (heap_count(pq) > 0) {
IndexHit *h = heap_poll(pq);
free(h);
}
heap_free(pq);
return res;
}
void print_memory(){
int s = stack_count();
int h = heap_count();
printf("\nSTACK:\n %d bytes used\n", s);
printf("\n HEAP:\n %d pages used -> %d bytes\n\n", h, h*4096);
}
