/* Create a slab cache */
slab_cache_t slab_cache_create(size_t object_size, int flags)
{
slab_cache_t slab_cache;
void *slab = addrspace_alloc(ADDRSPACE_SYSTEM, SLAB_SIZE, SLAB_SIZE, flags | PAGE_GLOBAL);
slab_cache_init(&slab_cache, slab, object_size, flags);
return slab_cache;
}
main(int argc, char **argv)
{
slab_cache_init(100, 0, 0, NULL, NULL);
fieldinfos fis;
fix_document doc1(1, 10);
dyn_document doc2(2);
document_helper h1(&doc1, fis);
document_helper h2(&doc2, fis);
long i = 100;
double d = 100.1234;
char *s = "string";
fis.add("f1", TDT_STRING);
fis.add("f2", TDT_LONG);
fis.add("f3", TDT_DOUBLE);
h1.add("f1", s);
h1.add("f2", &i);
h1.add("f3", &d);
h2.add("f1", s);
h2.add("f2", &i);
h2.add("f3", &d);
std::cout << fis.i2n(0) << ": " << (char *)doc1.field_data(0) << std::endl;
std::cout << fis.i2n(1) << ": " << *(long *)doc1.field_data(1) << std::endl;
std::cout << fis.i2n(2) << ": " << *(double *)doc1.field_data(2) << std::endl;
std::cout << fis.i2n(0) << ": " << (char *)doc2.field_data(0) << std::endl;
std::cout << fis.i2n(1) << ": " << *(long *)doc2.field_data(1) << std::endl;
std::cout << fis.i2n(2) << ": " << *(double *)doc2.field_data(2) << std::endl;
//std::string qs = "n1 > 01 AND (n2 < 0x2 OR n3 <= 3) NOT n4 >= 4. AND n5 == .5 AND n6 != 6.3 AND n7: (4.e10,.5e11) OR n8:(2.3e1,3e4] OR n9:[04e4,5223.2323e4) OR n10:[2,9]";
std::string qs = "n1 > ";
ccFlexLexer lexer(new std::istringstream(qs), &std::cout);
query_exp<document_helper>* exp = NULL;
yy::query_parser parser(&lexer, &exp);
if (parser.parse() != 0) {
std::cerr << "parse failed" << std::endl;
}
else {
std::cout << "iQuery: " << qs << std::endl;
std::cout << "Parsed: " << exp->to_string() << std::endl;
}
return 0;
}
/* Initialize an address space */
void addrspace_init(addrspace_t *addrspace, paddr_t address_space, vaddr_t free_start, vaddr_t free_length)
{
/* System address space */
if (addrspace == ADDRSPACE_SYSTEM)
{
/* Create the initial slab cache for VADs */
for (size_t i = free_start; i < free_start + SLAB_SIZE; i += PAGE_SIZE)
{
int color = vaddr_cache_color(i, NUMA_DOMAIN_BEST, 0);
vmm_map_page(address_space, i, pmm_alloc_page(0, NUMA_DOMAIN_BEST, color), PAGE_READ | PAGE_WRITE | PAGE_GLOBAL);
}
vad_cache = (slab_cache_t*) free_start;
slab_cache_init(vad_cache, sizeof(vad_t), PAGE_READ | PAGE_WRITE);
free_start += SLAB_SIZE;
free_length -= SLAB_SIZE;
/* Set up the pointer to the system address space */
addrspace = &system_addrspace;
}
/* Fill in the information */
addrspace->address_space = address_space;
addrspace->numa_domain = NUMA_DOMAIN_CURRENT;
spinlock_recursive_init(&addrspace->lock);
/* Initialize the free VAD */
addrspace->free.start = free_start;
addrspace->free.length = free_length;
addrspace->free.flags = 0;
addrspace->free.prev = addrspace->free.next = NULL;
/* Initialize the used VAD */
addrspace->used_root = &addrspace->used;
addrspace->used.height = 0;
if (addrspace == &system_addrspace)
{
addrspace->used.start = KERNEL_ADDRSPACE_START;
addrspace->used.length = free_start - KERNEL_ADDRSPACE_START;
addrspace->used.flags = PAGE_READ | PAGE_WRITE | PAGE_EXECUTE | PAGE_PRIVATE;
addrspace->used.left = addrspace->used.right = NULL;
}
else
{
addrspace->used.start = USER_ADDRSPACE_START;
addrspace->used.length = free_start - USER_ADDRSPACE_START;
addrspace->used.flags = PAGE_INVALID | PAGE_PRIVATE;
addrspace->used.left = addrspace->used.right = NULL;
}
}
void test_slab(void * pParam)
{
void *test_mem1;
int count = 0;
int i = 0;
int ret = 0;
frame_init((RAW_U32)test_page_mem, 48*1024);
slab_cache_init();
/*Decide whether the magazine work.*/
slab_enable_cpucache();
/*0--on, for user program debugging purpose;
1--off, normally, it should be off.*/
free_check_switch = 0;
for(i = 0; i < 20; i++){
test_mem1 = raw_slab_malloc(1024);
test_mem1 = raw_slab_malloc(1024);
if (test_mem1) {
vc_port_printf("test_mem1 is %p\n", test_mem1);
ret = raw_slab_free(test_mem1);
if(ret != 0)
vc_port_printf("****raw_slab_free failed!\n");
count++;
}
else {
RAW_ASSERT(0);
}
}
/*free a freed address*/
if(free_check_switch == 0){
ret = raw_slab_free(test_mem1);
if(ret != 0)
vc_port_printf("****Error: Free a freed obj!\n");
}
/*Some debug information*/
slab_print_list();
vc_port_printf("\n");
zone_print_one(0);
while (1);
}
static int slab_tests_run(int argc, char *argv[])
{
// 1. Create slab cache
srand(time(0));
const unsigned pattern = 0xdeadbeef;
slab_cache_t cache;
int ret = slab_cache_init(&cache, sizeof(int));
ok(ret == 0, "slab: created empty cache");
// 2. Couple alloc/free
bool valid_free = true;
lives_ok({
for(int i = 0; i < 100; ++i) {
int* data = (int*)slab_cache_alloc(&cache);
*data = pattern;
slab_free(data);
if (*data == pattern)
valid_free = false;
}
}, "slab: couple alloc/free");
int main(int argc, char *argv[])
{
plan(4);
// 1. Create slab cache
srand(time(0));
const unsigned pattern = 0xdeadbeef;
slab_cache_t cache;
int ret = slab_cache_init(&cache, sizeof(int));
is_int(0, ret, "slab: created empty cache");
// 2. Couple alloc/free
bool valid_free = true;
for(int i = 0; i < 100; ++i) {
int* data = (int*)slab_cache_alloc(&cache);
*data = pattern;
slab_free(data);
if (*data == pattern)
valid_free = false;
}
// 5. Verify freed block
ok(valid_free, "slab: freed memory is correctly invalidated");
// 4. Reap memory
slab_t* slab = cache.slabs_free;
int free_count = 0;
while (slab) {
slab_t* next = slab->next;
if (slab_isempty(slab)) {
++free_count;
}
slab = next;
}
int reaped = slab_cache_reap(&cache);
is_int(reaped, free_count, "slab: cache reaping works");
// Stress cache
int alloc_count = 73521;
void** ptrs = alloca(alloc_count * sizeof(void*));
int ptrs_i = 0;
for(int i = 0; i < alloc_count; ++i) {
double roll = rand() / (double) RAND_MAX;
if ((ptrs_i == 0) || (roll < 0.6)) {
int id = ptrs_i++;
ptrs[id] = slab_cache_alloc(&cache);
if (ptrs[id] == 0) {
ptrs_i--;
} else {
int* data = (int*)ptrs[id];
*data = pattern;
}
} else {
slab_free(ptrs[--ptrs_i]);
}
}
// 5. Delete cache
slab_cache_destroy(&cache);
is_int(0, cache.bufsize, "slab: freed cache");
return 0;
}
