X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=quick-test.c;h=5da47c322bcc90ca410ed010182972eb59616ae4;hb=1d5058058a811a03a1985d18ff3071ce95b99c08;hp=8255f79ceca59bdd15d4a102a752a2313bf92ad2;hpb=7da449a2f634d1807a5aaa8cd8dceb360032343e;p=platform%2Fupstream%2Fbtrfs-progs.git diff --git a/quick-test.c b/quick-test.c index 8255f79..5da47c3 100644 --- a/quick-test.c +++ b/quick-test.c @@ -1,37 +1,65 @@ +/* + * Copyright (C) 2007 Oracle. All rights reserved. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License v2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 021110-1307, USA. + */ + #include #include +#include #include "kerncompat.h" #include "radix-tree.h" #include "ctree.h" #include "disk-io.h" #include "print-tree.h" +#include "transaction.h" /* for testing only */ -int next_key(int i, int max_key) { +static int next_key(int i, int max_key) { return rand() % max_key; - //return i; + // return i; } int main(int ac, char **av) { - struct key ins; - struct key last = { (u64)-1, 0, 0}; + struct btrfs_key ins; + struct btrfs_key last = { (u64)-1, 0, 0}; char *buf; int i; int num; int ret; - int run_size = 1024; + int run_size = 300000; int max_key = 100000000; - int tree_size = 0; - struct ctree_path path; - struct ctree_super_block super; - struct ctree_root *root; + int tree_size = 2; + struct btrfs_path path; + struct btrfs_root *root; + struct btrfs_trans_handle *trans; + + buf = calloc(1, 512); radix_tree_init(); - root = open_ctree("dbfile", &super); + root = open_ctree(av[1], BTRFS_SUPER_INFO_OFFSET, OPEN_CTREE_WRITES); + if (!root) { + fprintf(stderr, "Open ctree failed\n"); + exit(1); + } + trans = btrfs_start_transaction(root, 1); + BUG_ON(IS_ERR(trans)); srand(55); + ins.type = BTRFS_STRING_ITEM_KEY; for (i = 0; i < run_size; i++) { - buf = malloc(64); num = next_key(i, max_key); // num = i; sprintf(buf, "string-%d", num); @@ -39,127 +67,160 @@ int main(int ac, char **av) { fprintf(stderr, "insert %d:%d\n", num, i); ins.objectid = num; ins.offset = 0; - ins.flags = 0; - ret = insert_item(root, &ins, buf, strlen(buf)); + ret = btrfs_insert_item(trans, root, &ins, buf, 512); if (!ret) tree_size++; - free(buf); + if (i == run_size - 5) { + btrfs_commit_transaction(trans, root); + trans = btrfs_start_transaction(root, 1); + BUG_ON(IS_ERR(trans)); + } } - write_ctree_super(root, &super); + btrfs_commit_transaction(trans, root); close_ctree(root); - - root = open_ctree("dbfile", &super); + exit(1); + root = open_ctree(av[1], BTRFS_SUPER_INFO_OFFSET, OPEN_CTREE_WRITES); + if (!root) { + fprintf(stderr, "Open ctree failed\n"); + exit(1); + } printf("starting search\n"); srand(55); for (i = 0; i < run_size; i++) { num = next_key(i, max_key); ins.objectid = num; - init_path(&path); + btrfs_init_path(&path); if (i % 10000 == 0) fprintf(stderr, "search %d:%d\n", num, i); - ret = search_slot(root, &ins, &path, 0, 0); + ret = btrfs_search_slot(NULL, root, &ins, &path, 0, 0); if (ret) { - print_tree(root, root->node); + btrfs_print_tree(root, root->node, 1); printf("unable to find %d\n", num); exit(1); } - release_path(root, &path); + btrfs_release_path(&path); } - write_ctree_super(root, &super); close_ctree(root); - root = open_ctree("dbfile", &super); + + root = open_ctree(av[1], BTRFS_SUPER_INFO_OFFSET, OPEN_CTREE_WRITES); + if (!root) { + fprintf(stderr, "Open ctree failed\n"); + exit(1); + } printf("node %p level %d total ptrs %d free spc %lu\n", root->node, - node_level(root->node->node.header.flags), - root->node->node.header.nritems, - NODEPTRS_PER_BLOCK - root->node->node.header.nritems); + btrfs_header_level(root->node), + btrfs_header_nritems(root->node), + (unsigned long)BTRFS_NODEPTRS_PER_BLOCK(root->fs_info) - + btrfs_header_nritems(root->node)); printf("all searches good, deleting some items\n"); i = 0; srand(55); + trans = btrfs_start_transaction(root, 1); + BUG_ON(IS_ERR(trans)); for (i = 0 ; i < run_size/4; i++) { num = next_key(i, max_key); ins.objectid = num; - init_path(&path); - ret = search_slot(root, &ins, &path, -1, 1); + btrfs_init_path(&path); + ret = btrfs_search_slot(trans, root, &ins, &path, -1, 1); if (!ret) { if (i % 10000 == 0) fprintf(stderr, "del %d:%d\n", num, i); - ret = del_item(root, &path); + ret = btrfs_del_item(trans, root, &path); if (ret != 0) BUG(); tree_size--; } - release_path(root, &path); + btrfs_release_path(&path); } - write_ctree_super(root, &super); + btrfs_commit_transaction(trans, root); close_ctree(root); - root = open_ctree("dbfile", &super); + + root = open_ctree(av[1], BTRFS_SUPER_INFO_OFFSET, OPEN_CTREE_WRITES); + if (!root) { + fprintf(stderr, "Open ctree failed\n"); + exit(1); + } + trans = btrfs_start_transaction(root, 1); + BUG_ON(IS_ERR(trans)); srand(128); for (i = 0; i < run_size; i++) { - buf = malloc(64); num = next_key(i, max_key); sprintf(buf, "string-%d", num); ins.objectid = num; if (i % 10000 == 0) fprintf(stderr, "insert %d:%d\n", num, i); - ret = insert_item(root, &ins, buf, strlen(buf)); + ret = btrfs_insert_item(trans, root, &ins, buf, 512); if (!ret) tree_size++; - free(buf); } - write_ctree_super(root, &super); + btrfs_commit_transaction(trans, root); close_ctree(root); - root = open_ctree("dbfile", &super); + + root = open_ctree(av[1], BTRFS_SUPER_INFO_OFFSET, OPEN_CTREE_WRITES); + if (!root) { + fprintf(stderr, "Open ctree failed\n"); + exit(1); + } srand(128); printf("starting search2\n"); for (i = 0; i < run_size; i++) { num = next_key(i, max_key); ins.objectid = num; - init_path(&path); + btrfs_init_path(&path); if (i % 10000 == 0) fprintf(stderr, "search %d:%d\n", num, i); - ret = search_slot(root, &ins, &path, 0, 0); + ret = btrfs_search_slot(NULL, root, &ins, &path, 0, 0); if (ret) { - print_tree(root, root->node); + btrfs_print_tree(root, root->node, 1); printf("unable to find %d\n", num); exit(1); } - release_path(root, &path); + btrfs_release_path(&path); } printf("starting big long delete run\n"); - while(root->node && root->node->node.header.nritems > 0) { - struct leaf *leaf; + trans = btrfs_start_transaction(root, 1); + BUG_ON(IS_ERR(trans)); + while(root->node && btrfs_header_nritems(root->node) > 0) { + struct extent_buffer *leaf; int slot; ins.objectid = (u64)-1; - init_path(&path); - ret = search_slot(root, &ins, &path, -1, 1); + btrfs_init_path(&path); + ret = btrfs_search_slot(trans, root, &ins, &path, -1, 1); if (ret == 0) BUG(); - leaf = &path.nodes[0]->leaf; + leaf = path.nodes[0]; slot = path.slots[0]; - if (slot != leaf->header.nritems) + if (slot != btrfs_header_nritems(leaf)) BUG(); while(path.slots[0] > 0) { path.slots[0] -= 1; slot = path.slots[0]; - leaf = &path.nodes[0]->leaf; + leaf = path.nodes[0]; + + btrfs_item_key_to_cpu(leaf, &last, slot); - memcpy(&last, &leaf->items[slot].key, sizeof(last)); if (tree_size % 10000 == 0) printf("big del %d:%d\n", tree_size, i); - ret = del_item(root, &path); + ret = btrfs_del_item(trans, root, &path); if (ret != 0) { printf("del_item returned %d\n", ret); BUG(); } tree_size--; } - release_path(root, &path); + btrfs_release_path(&path); } + /* + printf("previous tree:\n"); + btrfs_print_tree(root, root->commit_root); + printf("map before commit\n"); + btrfs_print_tree(root->extent_root, root->extent_root->node); + */ + btrfs_commit_transaction(trans, root); printf("tree size is now %d\n", tree_size); - printf("map tree\n"); - print_tree(root->extent_root, root->extent_root->node); - write_ctree_super(root, &super); + printf("root %p commit root %p\n", root->node, root->commit_root); + btrfs_print_tree(root, root->node, 1); close_ctree(root); return 0; }