int main() { insert_node_at_end(7); insert_node_at_start(5); insert_node_at_start(6); insert_node_at_end(4); insert_node_at_nth_position(10,5); print(); delete_node_at_start(); print(); delete_node_at_end(); print(); delete_node_at_nth_poistion(1); print(); insert_node_at_end(10); insert_node_at_start(5); print(); reverse_linkedlist(); print(); return 0; }
int main() { insert_node_at_start(4); insert_node_at_start(3); insert_node_at_end(5); insert_node_at_nth_position(6,3); print(); print_reverse(); delete_node_from_start(); print(); delete_node_from_end(); print(); delete_node_from_nth_position(3); print(); return 0; }
/***************************************************************************** * function: * crypto_free_to_slab(void *ptr) * * @param[in] ptr, pointer to the memory to be freed * * @description * free a slot of memory back to its slab * *****************************************************************************/ static void crypto_free_to_slab(void *ptr) { qae_slab_pools_local *tls_ptr = (qae_slab_pools_local *)pthread_getspecific(qae_key); qae_slot *slt = (void *)((unsigned char *)ptr - sizeof(qae_slot)); if (!slt) { MEM_ERROR("Error freeing memory - unknown address\n"); return; } qae_slab *slb = slt->slab; int i = slt->pool_index; if (slt->sig != SIG_ALLOC) { MEM_ERROR("%s error trying to free slot that hasn't been alloc'd %p\n", __func__, slt); return; } free(slt->file); slt->sig = SIG_FREE; slt->file = NULL; slt->line = 0; /* insert the slot into the slab */ slt->next = slb->next_slot; slb->next_slot = slt; /* decrease the reference count */ slb->used_slots--; /* if the used_slots is 0, this slab is empty, it should be * processed properly */ if(slb->used_slots == 0) { /* remove this slab from the slab list */ switch(slb->list_index) { case IN_AVAILABLE_LIST: remove_node_from_list(&tls_ptr->available_slab_list[i],slb); break; case IN_FULL_LIST: remove_node_from_list(&tls_ptr->full_slab_list,slb); break; default: break; } /* free slab or assign it to the head of the empty slab list */ if(tls_ptr->empty_slab_list[i].slot_size >= MAX_EMPTY_SLAB) { crypto_free_slab(slb,(void *)tls_ptr); slb = NULL; } else { insert_node_at_head(&tls_ptr->empty_slab_list[i],slb); slb->list_index = IN_EMPTY_LIST; } } else { /* if current slab is in full slab list, * remove it from the full_slab_list list and then * append it at the end of the available list */ switch(slb->list_index) { case IN_FULL_LIST: remove_node_from_list(&tls_ptr->full_slab_list,slb); insert_node_at_end(&tls_ptr->available_slab_list[i],slb); slt->slab->list_index = IN_AVAILABLE_LIST; break; default: break; } } }
/***************************************************************************** * function: * crypto_alloc_from_slab(int size, const char *file, int line) * * @param[in] size, the size of the memory block required * @param[in] file, the C source filename of the call site * @param[in] line, the line number withing the C source file of the call site * * @description * allocate a slot of memory from some slab * retval pointer to the allocated block * *****************************************************************************/ static void *crypto_alloc_from_slab(int size, const char *file, int line) { qae_slab *slb = NULL; qae_slot *slt; int slot_size; void *result = NULL; int i; qae_slab_pools_local *tls_ptr; tls_ptr = (qae_slab_pools_local *)pthread_getspecific(qae_key); if(tls_ptr == NULL) { crypto_init(); tls_ptr = (qae_slab_pools_local *)pthread_getspecific(qae_key); } size += sizeof(qae_slot); size += QAE_BYTE_ALIGNMENT; slot_size = SLOT_DEFAULT_INIT; for (i = 0; i < sizeof(slot_sizes_available) / sizeof(int); i++) { if (size < slot_sizes_available[i]) { slot_size = slot_sizes_available[i]; break; } } if (SLOT_DEFAULT_INIT == slot_size) { if (size <= MAX_ALLOC) { slot_size = MAX_ALLOC; } else { MEM_ERROR("%s Allocation of %d bytes is too big\n", __func__, size); goto exit; } } if(tls_ptr->available_slab_list[i].slot_size > 0) { slt = tls_ptr->available_slab_list[i].next->next_slot; } else { /* no free slots need to allocate new slab */ slb = crypto_get_empty_slab(slot_size, i, (void *)tls_ptr); if (NULL == slb) { MEM_ERROR("%s error, create_slab failed - memory allocation error\n", __func__); goto exit; } /* allocate a new slab, add it into the available slab list */ slt = slb->next_slot; slb->list_index = IN_AVAILABLE_LIST; insert_node_at_head(&tls_ptr->available_slab_list[i],slb); } slb = slt->slab; if (slt->sig != SIG_FREE) { MEM_ERROR("%s error alloc slot that isn't free %p\n", __func__, slt); exit(1); } slt->sig = SIG_ALLOC; slt->file = strdup(file); slt->line = line; /* increase the reference counter */ slb->used_slots++; /* get the available slot from the head of available slab list */ slb->next_slot = slt->next; slt->next = NULL; /* if current slab has no slot available, remove the slab from * available slab list and add it to the full slab list */ if(slb->used_slots >= slb->total_slots) { remove_node_from_list(&tls_ptr->available_slab_list[i],slb); insert_node_at_end(&tls_ptr->full_slab_list,slb); slb->list_index = IN_FULL_LIST; } result = (void *)((unsigned char *)slt + sizeof(qae_slot)); exit: return result; }