acl/lib_acl/samples/slice/main.c

230 lines
5.1 KiB
C
Raw Normal View History

2014-11-19 00:25:21 +08:00
#include "lib_acl.h"
#include "ring.h"
typedef struct DUMMY {
char s[8];
int n;
struct DUMMY *next;
RING entry;
} DUMMY;
static void slice_alloc(int n)
{
int i;
ACL_SLICE *slice = acl_slice_create("slice_alloc", 0, sizeof(DUMMY), ACL_SLICE_FLAG_GC1);
DUMMY *ptr, *head = NULL;
printf("in slice_alloc\n");
ACL_METER_TIME(NULL);
for (i = 0; i < n; i++) {
ptr = (DUMMY*) acl_slice_alloc(slice);
if (head != NULL)
ptr->next = head;
else
ptr->next = NULL;
}
ACL_METER_TIME(NULL);
i = 0;
while (i++ < 10) {
printf("sleep one second\n");
sleep(1);
}
ACL_METER_TIME(NULL);
acl_slice_destroy(slice);
ACL_METER_TIME(NULL);
}
static void sys_alloc(int n)
{
int i;
DUMMY *ptr, *head = NULL;
printf("in sys_alloc\n");
ACL_METER_TIME(NULL);
for (i = 0; i < n; i++) {
ptr = (DUMMY*) acl_mymalloc(sizeof(DUMMY));
if (head != NULL)
ptr->next = head;
else
ptr->next = NULL;
head = ptr;
}
ACL_METER_TIME(NULL);
i = 0;
while (i++ < 10) {
printf("sleep one second\n");
sleep(1);
}
ACL_METER_TIME(NULL);
while (head) {
ptr = head;
head = head->next;
acl_myfree(ptr);
}
ACL_METER_TIME(NULL);
}
static void slice_gc1(void)
{
DUMMY head;
DUMMY *ptr0, *ptr1, *ptr2, *ptr3;
ACL_SLICE *slice = acl_slice_create("slice_gc1", 4096 * 64, sizeof(DUMMY),
ACL_SLICE_FLAG_GC1 /* | ACL_SLICE_FLAG_RTGC_OFF */);
ring_init(&head.entry);
ptr0 = acl_slice_alloc(slice);
ptr1 = acl_slice_alloc(slice);
ptr2 = acl_slice_alloc(slice);
ptr3 = acl_slice_alloc(slice);
memset(ptr0->s, 'a', sizeof(ptr0->s));
memset(ptr1->s, 'a', sizeof(ptr0->s));
memset(ptr2->s, 'a', sizeof(ptr0->s));
memset(ptr3->s, 'a', sizeof(ptr0->s));
ptr0->n = 0;
ptr1->n = 1;
ptr2->n = 2;
ptr3->n = 3;
ring_prepend(&head.entry, &ptr0->entry);
ring_prepend(&head.entry, &ptr1->entry);
ring_prepend(&head.entry, &ptr2->entry);
ring_prepend(&head.entry, &ptr3->entry);
acl_slice_free2(slice, ptr3);
acl_slice_free2(slice, ptr2);
acl_slice_free2(slice, ptr1);
acl_slice_free2(slice, ptr0);
acl_slice_destroy(slice);
}
static void slice_gc2(void)
{
int i, max = 10000000;
ACL_BINHASH *table;
#if 1
unsigned int flag = ACL_BINHASH_FLAG_SLICE2;
#else
unsigned int flag = 0;
#endif
table = acl_binhash_create(max, flag);
ACL_METER_TIME("---- begin add to hash ------");
for (i = max - 1; i >= 0; i--) {
acl_binhash_enter(table, &i, sizeof(i), 0);
}
ACL_METER_TIME("---- end add and begin free table ---");
acl_binhash_free(table, 0);
ACL_METER_TIME("--- end free table ---");
}
static void slice_gc(void)
{
ACL_SLICE *slice;
DUMMY *head = NULL, *ptr;
int i, n = 10240000;
int nsleep = 0;
ACL_SLICE_STAT sbuf;
unsigned int flag = ACL_SLICE_FLAG_GC2 /* | ACL_SLICE_FLAG_RTGC_OFF */;
acl_memory_debug_start();
printf("sizeof DUMMY: %d\n", (int) sizeof(DUMMY));
slice = acl_slice_create("slice_gc", 1024 * 100, sizeof(DUMMY), flag);
ACL_METER_TIME("------ begin alloc ------");
for (i = 0; i < n; i++) {
ptr = (DUMMY*) acl_slice_alloc(slice);
if (head != NULL)
ptr->next = head;
else
ptr->next = NULL;
head = ptr;
}
ACL_METER_TIME("------ end alloc and begin free ------");
acl_memory_stat();
while (nsleep-- > 0) {
printf("sleep 1 second\n");
sleep(1);
}
acl_slice_stat(slice, &sbuf);
printf("islots: %d, nslots: %d, total length: %d, nbuf: %d\n",
(int) sbuf.islots, (int) sbuf.nslots,
(int) sbuf.length, (int) sbuf.nbuf);
while (head) {
ptr = head;
head = head->next;
if ((flag & ACL_SLICE_FLAG_GC1))
acl_slice_free2(slice, ptr);
else {
acl_slice_free(ptr);
}
}
ACL_METER_TIME("------ end free ------");
acl_slice_stat(slice, &sbuf);
printf("call slice gc, sizeof(DUMMY): %d, islots: %d, nslots: %d, total length: %d, nbuf: %d\n",
(int) sizeof(DUMMY), (int) sbuf.islots, (int) sbuf.nslots,
(int) sbuf.length, (int) sbuf.nbuf);
i = 0;
ACL_METER_TIME("------ and begin gc ------");
printf("------------ islots: %d, nslots: %d, nbuf: %d ------\n", sbuf.islots, sbuf.nslots, sbuf.nbuf);
while (sbuf.nbuf > 0 && (sbuf.flag & ACL_SLICE_FLAG_GC1) == 0) {
acl_slice_gc(slice);
acl_slice_stat(slice, &sbuf);
i++;
}
ACL_METER_TIME("------ end gc and begin destroy ------");
acl_slice_destroy(slice);
ACL_METER_TIME("------ end destroy ------");
printf("slice gc over, call %d times\n", i);
acl_memory_debug_stop();
}
static void mem_slice(void)
{
char *ptr;
acl_mem_slice_init(8, 10240, 100, ACL_SLICE_FLAG_GC2 | ACL_SLICE_FLAG_RTGC_OFF);
ptr = acl_mystrdup("hello world");
printf("ptr: %s\n", ptr);
ptr = (char*) acl_myrealloc(ptr, 1024);
printf("ptr: %s\n", ptr);
acl_myfree(ptr);
acl_mem_slice_destroy();
}
int main(int argc acl_unused, char *argv[] acl_unused)
{
int n = 10000000;
mem_slice(); return (0);
slice_gc(); return (0);
slice_gc2(); return (0);
slice_gc1(); return (0);
slice_alloc(n);
sys_alloc(n);
printf("enter any key to exit\n");
getchar();
return (0);
}