int main(int argc, char** argv)
{
int i;
test_reallocate();
{
deque_t d;
int lots = 2;
deque_init(4, &d, 0);
push_front_counting(4, &d, lots);
//print_deque(4, &d);
pop_back_check_counting(4, &d, lots);
//print_deque(4, &d);
check_empty(4, &d);
deque_destroy(&d);
}
for( i = 0; i < 32; i++ ) {
test_deque(i);
}
for( i = 127; i < 512; i++ ) {
test_deque(i);
}
test_deque(1 << 15);
printf("deque_test PASS\n");
return 0;
}
qioerr qbuffer_init(qbuffer_t* buf)
{
memset(buf, 0, sizeof(qbuffer_t));
DO_INIT_REFCNT(buf);
return deque_init(sizeof(qbuffer_part_t), & buf->deque, 0);
//return 0;
}
thread_pool_t* thread_pool_create(int max_thread_num){
int i, ret;
if (max_thread_num <= 0 || max_thread_num > MAX_THREAD_NUM){
return NULL;
}
thread_pool_t *self = (thread_pool_t*)malloc(sizeof(thread_pool_t));
self->working_threads_num = 0;
self->alive_threads_num = 0;
self->keep_alive = 1;
self->max_thread_num = max_thread_num;
self->thread_id_array = (pthread_t*)malloc(sizeof(pthread_t) *self->max_thread_num);
self->task_deque = (task_deque_t*)malloc(sizeof(task_deque_t));
deque_init(self->task_deque);
pthread_mutex_init(&self->threads_num_mutex, NULL);
pthread_cond_init(&self->threads_all_idle_cond, NULL);
self->task_sem = (task_sem_t*)malloc(sizeof(task_sem_t));
task_sem_init(self->task_sem);
for (i = 0; i < self->max_thread_num; i++){
ret = pthread_create(&self->thread_id_array[i], NULL, thread_pool_thread_do, self);
}
/*等待线程全部创建好*/
while(self->alive_threads_num != self->max_thread_num){
}
return self;
}
/* deque_t */
void _type_init_deque(const void* cpv_input, void* pv_output)
{
bool_t b_result = false;
assert(cpv_input != NULL && pv_output != NULL);
b_result = _create_deque_auxiliary((deque_t*)cpv_input, (char*)pv_output);
assert(b_result);
/* initialize deque_t */
deque_init((deque_t*)cpv_input);
}
/**
* Initialize an empty queue adaptor
*/
void queue_init(queue_t* pque_queue)
{
assert(pque_queue != NULL);
#ifdef CSTL_QUEUE_LIST_SEQUENCE
list_init(&pque_queue->_t_sequence);
#else
deque_init(&pque_queue->_t_sequence);
#endif
}
/**
* Initialize an empty stack adaptor
*/
void stack_init(cstl_stack_t* psk_stack)
{
assert(psk_stack != NULL);
#if defined (CSTL_STACK_VECTOR_SEQUENCE)
vector_init(&psk_stack->_t_sequence);
#elif defined (CSTL_STACK_LIST_SEQUENCE)
list_init(&psk_stack->_t_sequence);
#else
deque_init(&psk_stack->_t_sequence);
#endif
}
int main(int argc, char* argv[])
{
deque_t* pdeq_coll = NULL;
person_t t_person;
type_register(person_t, NULL, NULL, NULL, NULL);
pdeq_coll = create_deque(person_t);
if(pdeq_coll == NULL)
{
return -1;
}
deque_init(pdeq_coll);
memset(t_person.s_firstname, '\0', 21);
memset(t_person.s_lastname, '\0', 21);
strcpy(t_person.s_firstname, "Jonh");
strcpy(t_person.s_lastname, "right");
deque_push_back(pdeq_coll, &t_person);
memset(t_person.s_firstname, '\0', 21);
memset(t_person.s_lastname, '\0', 21);
strcpy(t_person.s_firstname, "Bill");
strcpy(t_person.s_lastname, "killer");
deque_push_back(pdeq_coll, &t_person);
memset(t_person.s_firstname, '\0', 21);
memset(t_person.s_lastname, '\0', 21);
strcpy(t_person.s_firstname, "Jonh");
strcpy(t_person.s_lastname, "sound");
deque_push_back(pdeq_coll, &t_person);
memset(t_person.s_firstname, '\0', 21);
memset(t_person.s_lastname, '\0', 21);
strcpy(t_person.s_firstname, "Bin");
strcpy(t_person.s_lastname, "lee");
deque_push_back(pdeq_coll, &t_person);
memset(t_person.s_firstname, '\0', 21);
memset(t_person.s_lastname, '\0', 21);
strcpy(t_person.s_firstname, "Lee");
strcpy(t_person.s_lastname, "bird");
deque_push_back(pdeq_coll, &t_person);
algo_for_each(deque_begin(pdeq_coll), deque_end(pdeq_coll), _print);
printf("\n");
algo_sort_if(deque_begin(pdeq_coll), deque_end(pdeq_coll), _person_sort_criterion);
algo_for_each(deque_begin(pdeq_coll), deque_end(pdeq_coll), _print);
printf("\n");
deque_destroy(pdeq_coll);
return 0;
}
static int deque_basic() {
Deque d[1];
deque_init(d, sizeof(int), 10);
*(int*)deque_pushback(d) = 2;
*(int*)deque_pushback(d) = 3;
*(int*)deque_pushfront(d) = 1;
*(int*)deque_pushback(d) = 4;
*(int*)deque_pushfront(d) = 0;
for (int i = 0; i <= 4; i++) {
int val = *(int*)deque_front(d);
deque_popfront(d);
assertEqual(i, val);
assertEqual(4-i, deque_size(d));
}
deque_close(d);
return 0;
}
static int deque_fuzz() {
Deque d[1];
for (size_t cap = 1; cap <= 10; cap++) {
deque_init(d, sizeof(int), cap);
for (int i = 0; i < 5; i++) {
*(int*)deque_pushback(d) = 4 - i;
}
for (int i = 0; i < 5; i++) {
*(int*)deque_pushfront(d) = 5 + i;
}
for (int i = 0; i < 10; i++) {
int val = *(int*)deque_back(d);
deque_popback(d);
assertEqual(i, val);
}
assertEqual(0, deque_size(d));
deque_close(d);
}
return 0;
}
void test_reallocate(void)
{
// hit the different reallocate cases.
// map_size > 2* num_new_nodes
// add to front, add to back
{
// start with copy forward/copy backward.
deque_node_t nodes[4];
nodes[0].data = (void*) 0x100;
nodes[1].data = (void*) 0x101;
nodes[2].data = (void*) 0x102;
nodes[3].data = (void*) 0x103;
// test overlapping copy forward.
// dstBeg should be before srcBegin
_deque_map_copy_forward( &nodes[2], &nodes[4], &nodes[1]);
assert(nodes[0].data == (void*) 0x100);
assert(nodes[1].data == (void*) 0x102);
assert(nodes[2].data == (void*) 0x103);
assert(nodes[3].data == (void*) 0x103);
nodes[0].data = (void*) 0x100;
nodes[1].data = (void*) 0x101;
nodes[2].data = (void*) 0x102;
nodes[3].data = (void*) 0x103;
// test overlapping copy backward.
// dstEnd should be after srcEnd
_deque_map_copy_backward( &nodes[0], &nodes[2], &nodes[3]);
assert(nodes[0].data == (void*) 0x100);
assert(nodes[1].data == (void*) 0x100);
assert(nodes[2].data == (void*) 0x101);
assert(nodes[3].data == (void*) 0x103);
}
// Now, suppose we've allocated our stuff...
// let's reallocate.
{
deque_t d;
qioerr err;
ssize_t saved_size;
deque_node_t saved_nodes[2*_DEQUE_INITIAL_MAP_SIZE];
deque_node_t* cur;
int i;
// this time, try with map_size < 2*num_new_nodes
err = deque_init(16, &d, 16*_DEQUE_INITIAL_MAP_SIZE);
assert(!err);
// save the pointers.
assert(d.map_size < 2*_DEQUE_INITIAL_MAP_SIZE);// fits in test buffer
saved_size = 0;
for( cur = d.start.node; cur < d.finish.node; ++cur ) {
saved_nodes[saved_size++].data = cur->data;
}
_deque_reallocate_map(16, 512, /* first two args dont matter in this test*/
&d, 1, 0 /* not at front */);
assert(d.map_size > saved_size); // make sure it grew
i = 0;
for( cur = d.start.node; cur < d.finish.node && i < saved_size; ++cur ) {
assert(saved_nodes[i++].data == cur->data);
}
// don't care value of nodes[saved_size], the new slot.
deque_destroy(&d);
err = deque_init(16, &d, 16*_DEQUE_INITIAL_MAP_SIZE);
assert(!err);
assert(d.map_size < 2*_DEQUE_INITIAL_MAP_SIZE);// fits in test buffer
saved_size = 0;
for( cur = d.start.node; cur < d.finish.node; ++cur ) {
saved_nodes[saved_size++].data = cur->data;
}
_deque_reallocate_map(16, 512, /* first two args dont matter in this test*/
&d, 1, 1 /* at front */);
assert(d.map_size > saved_size); // make sure it grew
// don't care value of nodes[0], the new slot.
i = 0;
for( cur = d.start.node; cur < d.finish.node && i < saved_size ; ++cur ) {
assert(saved_nodes[i++].data == cur->data);
}
// don't care of value of nodes[saved_size+1], the previous new slot.
deque_destroy(&d);
// this time, try with map_size > 2*num_new_nodes
err = deque_init(16, &d, 0);
assert(!err);
// save the pointers.
assert(d.map_size < 2*_DEQUE_INITIAL_MAP_SIZE);// fits in test buffer
saved_size = 0;
for( cur = d.start.node; cur < d.finish.node; ++cur ) {
saved_nodes[saved_size++].data = cur->data;
}
_deque_reallocate_map(16, 512, /* first two args dont matter in this test*/
&d, 1, 0 /* not at front */);
i = 0;
for( cur = d.start.node; cur < d.finish.node; ++cur ) {
assert(saved_nodes[i++].data == cur->data);
}
assert( i == saved_size );
deque_destroy(&d);
err = deque_init(16, &d, 0);
assert(!err);
// save the pointers.
assert(d.map_size < 2*_DEQUE_INITIAL_MAP_SIZE);// fits in test buffer
saved_size = 0;
for( cur = d.start.node; cur < d.finish.node; ++cur ) {
saved_nodes[saved_size++].data = cur->data;
}
_deque_reallocate_map(16, 512, /* first two args dont matter in this test*/
&d, 1, 1 /* at front */);
i = 0;
for( cur = d.start.node; cur < d.finish.node; ++cur ) {
assert(saved_nodes[i++].data == cur->data);
}
assert( i == saved_size );
deque_destroy(&d);
}
}
void test_deque(int lots)
{
deque_t d;
// test: space for zeros.
deque_init(4, &d, 0);
check_empty(4, &d);
deque_destroy(&d);
// test: space for zeros.
deque_init(4, &d, 10);
pop_back_check_constant(4, &d, 10, 0);
check_empty(4, &d);
deque_destroy(&d);
// test: space for zeros.
deque_init(4, &d, 10);
pop_front_check_constant(4, &d, 10, 0);
check_empty(4, &d);
deque_destroy(&d);
// test: push back lots, destroy
deque_init(4, &d, 0);
push_back_counting(4, &d, lots);
iterate_counting(4, &d, lots);
deque_destroy(&d);
// test: push back lots, pop front lots.
deque_init(4, &d, 0);
push_back_counting(4, &d, lots);
iterate_counting(4, &d, lots);
pop_front_check_counting(4, &d, lots);
check_empty(4, &d);
deque_destroy(&d);
// test: push back lots, pop back lots.
deque_init(4, &d, 0);
push_back_counting(4, &d, lots);
pop_back_check_counting_reverse(4, &d, lots);
check_empty(4, &d);
deque_destroy(&d);
// test: push front lots, pop front lots.
deque_init(4, &d, 0);
push_front_counting(4, &d, lots);
iterate_counting_reverse(4, &d, lots);
//print_deque(4, &d);
pop_front_check_counting_reverse(4, &d, lots);
//print_deque(4, &d);
check_empty(4, &d);
deque_destroy(&d);
// test: push front lots, pop back lots.
deque_init(4, &d, 0);
push_front_counting(4, &d, lots);
//print_deque(4, &d);
pop_back_check_counting(4, &d, lots);
//print_deque(4, &d);
check_empty(4, &d);
deque_destroy(&d);
// test: push both lots, pop back lots, pop back lots.
deque_init(4, &d, 0);
push_both_counting(4, &d, lots);
//print_deque(4, &d);
pop_back_check_counting_reverse(4, &d, lots);
pop_back_check_counting(4, &d, lots);
check_empty(4, &d);
deque_destroy(&d);
// test: push both lots, pop front lots, pop front lots.
deque_init(4, &d, 0);
push_both_counting(4, &d, lots);
//print_deque(4, &d);
pop_front_check_counting_reverse(4, &d, lots);
pop_front_check_counting(4, &d, lots);
check_empty(4, &d);
deque_destroy(&d);
// test: push both lots, pop back lots, pop front lots
deque_init(4, &d, 0);
push_both_counting(4, &d, lots);
//print_deque(4, &d);
pop_back_check_counting_reverse(4, &d, lots);
pop_front_check_counting_reverse(4, &d, lots);
check_empty(4, &d);
deque_destroy(&d);
// test: push both lots, pop front lots, pop back lots
deque_init(4, &d, 0);
push_both_counting(4, &d, lots);
//print_deque(4, &d);
pop_front_check_counting_reverse(4, &d, lots);
pop_back_check_counting_reverse(4, &d, lots);
check_empty(4, &d);
deque_destroy(&d);
}
queue_t * queue_init(void) {
return deque_init();
}
