/* 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; }