colin
/
CuPBoP
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
CuPBoP/examples/btree/main.c

2193 lines
63 KiB
C
Raw Blame History

// # ifdef __cplusplus
// extern "C" {
// # endif
//========================================================================================================================================================================================================200
//======================================================================================================================================================150
//====================================================================================================100
//==================================================50
//========================================================================================================================================================================================================200
// INFORMATION
//========================================================================================================================================================================================================200
//======================================================================================================================================================150
// UPDATE
//======================================================================================================================================================150
// 2009; Amittai Aviram; entire code written in C;
// 2010; Jordan Fix and Andrew Wilkes; code converted to CUDA;
// 2011.10; Lukasz G. Szafaryn; code converted to portable form, to C, OpenMP,
// CUDA, PGI versions; 2011.12; Lukasz G. Szafaryn; Split different versions for
// Rodinia. 2011.12; Lukasz G. Szafaryn; code converted to OpenCL; 2012.10; Ke
// Wang; Change it to non-interactive mode. Use command option read command from
// file. And also add output for easy verification among different platforms and
// devices.Merged into Rodinia main distribution 2.2.
//======================================================================================================================================================150
// DESCRIPTION
//======================================================================================================================================================150
// Description
//======================================================================================================================================================150
// USE
//======================================================================================================================================================150
// EXAMPLE:
// ./b+tree file ./input/mil.txt command ./command.txt
// ...then enter any of the following commands after the prompt > :
// f <x> -- Find the value under key <x>
// p <x> -- Print the path from the root to key k and its associated value
// t -- Print the B+ tree
// l -- Print the keys of the leaves (bottom row of the tree)
// v -- Toggle output of pointer addresses ("verbose") in tree and leaves.
// k <x> -- Run <x> bundled queries on the CPU and GPU (B+Tree) (Selects random
// values for each search) j <x> <y> -- Run a range search of <x> bundled
// queries on the CPU and GPU (B+Tree) with the range of each search of size <y>
// x <z> -- Run a single search for value z on the GPU and CPU
// y <a> <b> -- Run a single range search for range a-b on the GPU and CPU
// q -- Quit. (Or use Ctl-D.)
//======================================================================================================================================================150
// END
//======================================================================================================================================================150
//========================================================================================================================================================================================================200
// DEFINE/INCLUDE
//========================================================================================================================================================================================================200
//======================================================================================================================================================150
// LIBRARIES
//======================================================================================================================================================150
#include <limits.h> // (in directory known to compiler) needed by INT_MIN, INT_MAX
#include <stdio.h> // (in directory known to compiler) needed by printf, stderr
// #include <sys/time.h> //
// (in directory known to compiler) needed by ???
#include <math.h> // (in directory known to compiler) needed by log, pow
#include <string.h> // (in directory known to compiler) needed by memset
//======================================================================================================================================================150
// COMMON
//======================================================================================================================================================150
#include "./common.h" // (in directory provided here)
//======================================================================================================================================================150
// DEFINE
//======================================================================================================================================================150
//======================================================================================================================================================150
// UTILITIES
//======================================================================================================================================================150
#include "./util/num/num.h" // (in directory provided here)
#include "./util/timer/timer.h" // (in directory provided here)
//======================================================================================================================================================150
// KERNEL HEADERS
//======================================================================================================================================================150
#include "./kernel/kernel_gpu_cuda_wrapper.h" // (in directory provided here)
#include "./kernel/kernel_gpu_cuda_wrapper_2.h" // (in directory provided here)
//======================================================================================================================================================150
// HEADER
//======================================================================================================================================================150
#include "./main.h" // (in directory provided here)
//======================================================================================================================================================150
// END
//======================================================================================================================================================150
//========================================================================================================================================================================================================200
// VARIABLES
//========================================================================================================================================================================================================200
// general variables
knode *knodes;
record *krecords;
char *mem;
long freeptr;
long malloc_size;
long size;
long maxheight;
/* The order determines the maximum and minimum
* number of entries (keys and pointers) in any
* node. Every node has at most order - 1 keys and
* at least (roughly speaking) half that number.
* Every leaf has as many pointers to data as keys,
* and every internal node has one more pointer
* to a subtree than the number of keys.
* This global variable is initialized to the
* default value.
*/
int order = DEFAULT_ORDER;
/* The queue is used to print the tree in
* level order, starting from the root
* printing each entire rank on a separate
* line, finishing with the leaves.
*/
node *queue = NULL;
/* The user can toggle on and off the "verbose"
* property, which causes the pointer addresses
* to be printed out in hexadecimal notation
* next to their corresponding keys.
*/
bool verbose_output = false;
//========================================================================================================================================================================================================200
// FUNCTIONS
//========================================================================================================================================================================================================200
//======================================================================================================================================================150
// Components
//======================================================================================================================================================150
void list_init(list_t *l, int32_t (*compare)(const void *key, const void *with),
void (*datum_delete)(void *)) {
l->head = l->tail = NULL;
l->length = 0;
l->compare = compare;
l->datum_delete = datum_delete;
}
void list_delete(list_t *l) {
list_item_t *li, *del;
for (li = l->head; li;) {
del = li;
li = li->next;
list_item_delete(del, l->datum_delete);
}
l->head = l->tail = NULL;
l->length = 0;
}
void list_reset(list_t *l) { list_delete(l); }
void list_insert_item_head(list_t *l, list_item_t *i) {
if (l->head) {
i->next = l->head;
l->head->pred = i;
l->head = i;
l->head->pred = NULL;
} else {
l->head = l->tail = i;
i->next = i->pred = NULL;
}
l->length++;
}
void list_insert_item_tail(list_t *l, list_item_t *i) {
if (l->head) {
l->tail->next = i;
i->pred = l->tail;
i->next = NULL;
l->tail = i;
} else {
l->head = l->tail = i;
i->next = i->pred = NULL;
}
l->length++;
}
void list_insert_item_before(list_t *l, list_item_t *next, list_item_t *i) {
/* Assume next is actually in the list! */
/* If it's not, we may lose the list. */
if (l->head == next) {
i->next = next;
i->pred = NULL;
l->head = i;
next->pred = i;
} else {
i->next = next;
i->pred = next->pred;
next->pred->next = i;
next->pred = i;
}
l->length++;
}
void list_insert_item_after(list_t *l, list_item_t *pred, list_item_t *i) {
/* Assume pred is actually in the list! */
/* If it's not, we may lose the list. */
if (l->tail == pred) {
i->pred = pred;
i->next = NULL;
l->tail = i;
pred->next = i;
} else {
i->pred = pred;
i->next = pred->next;
pred->next->pred = i;
pred->next = i;
}
l->length++;
}
void list_insert_item_sorted(list_t *l, list_item_t *i) {
list_item_t *itr;
if (l->head) {
for (itr = l->head; itr && l->compare(list_item_get_datum(i),
list_item_get_datum(itr)) < 0;
itr = itr->next)
;
if (itr) {
i->next = itr;
i->pred = itr->pred;
itr->pred = i;
i->pred->next = i;
} else {
l->tail->next = i;
i->pred = l->tail;
i->next = NULL;
l->tail = i;
}
} else {
l->head = l->tail = i;
i->pred = i->next = NULL;
}
l->length++;
}
void list_insert_head(list_t *l, void *v) {
list_item_t *i;
i = (list_item_t *)malloc(sizeof(*i));
list_item_init(i, v);
if (l->head) {
i->next = l->head;
l->head->pred = i;
l->head = i;
l->head->pred = NULL;
} else {
l->head = l->tail = i;
i->next = i->pred = NULL;
}
l->length++;
}
void list_insert_tail(list_t *l, void *v) {
list_item_t *i;
i = (list_item_t *)malloc(sizeof(*i));
list_item_init(i, v);
if (l->head) {
l->tail->next = i;
i->pred = l->tail;
i->next = NULL;
l->tail = i;
} else {
l->head = l->tail = i;
i->next = i->pred = NULL;
}
l->length++;
}
void list_insert_before(list_t *l, list_item_t *next, void *v) {
list_item_t *i;
i = (list_item_t *)malloc(sizeof(*i));
list_item_init(i, v);
/* Assume next is actually in the list! */
/* If it's not, we may lose the list. */
if (l->head == next) {
i->next = next;
i->pred = NULL;
l->head = i;
next->pred = i;
} else {
i->next = next;
i->pred = next->pred;
next->pred->next = i;
next->pred = i;
}
l->length++;
}
void list_insert_after(list_t *l, list_item_t *pred, void *v) {
list_item_t *i;
i = (list_item_t *)malloc(sizeof(*i));
list_item_init(i, v);
/* Assume pred is actually in the list! */
/* If it's not, we may lose the list. */
if (l->tail == pred) {
i->pred = pred;
i->next = NULL;
l->tail = i;
pred->next = i;
} else {
i->pred = pred;
i->next = pred->next;
pred->next->pred = i;
pred->next = i;
}
l->length++;
}
void list_insert_sorted(list_t *l, void *v) {
list_item_t *itr;
list_item_t *i;
i = (list_item_t *)malloc(sizeof(*i));
list_item_init(i, v);
if (l->head) {
for (itr = l->head; itr && l->compare(list_item_get_datum(i),
list_item_get_datum(itr)) < 0;
itr = itr->next)
;
if (itr) {
i->next = itr;
i->pred = itr->pred;
itr->pred = i;
i->pred->next = i;
} else {
l->tail->next = i;
i->pred = l->tail;
i->next = NULL;
l->tail = i;
}
} else {
l->head = l->tail = i;
i->pred = i->next = NULL;
}
l->length++;
}
void list_remove_item(list_t *l, list_item_t *i) {
if (i == l->head) {
l->head = l->head->next;
if (l->head)
l->head->pred = NULL;
else
l->tail = NULL;
} else if (i == l->tail) {
l->tail = l->tail->pred;
l->tail->next = NULL;
} else {
i->pred->next = i->next;
i->next->pred = i->pred;
}
l->length--;
list_item_delete(i, l->datum_delete);
}
void list_remove_head(list_t *l) { list_remove_item(l, l->head); }
void list_remove_tail(list_t *l) { list_remove_item(l, l->tail); }
list_item_t *list_find_item(list_t *l, void *datum) {
list_item_t *li;
for (li = l->head; li && l->compare(datum, list_item_get_datum(li));
li = li->next)
;
return li;
}
list_item_t *list_get_head_item(list_t *l) { return l->head; }
list_item_t *list_get_tail_item(list_t *l) { return l->tail; }
void *list_find(list_t *l, void *datum) {
list_item_t *li;
for (li = l->head; li && l->compare(datum, list_item_get_datum(li));
li = li->next)
;
return li ? li->datum : NULL;
}
void *list_get_head(list_t *l) { return l->head ? l->head->datum : NULL; }
void *list_get_tail(list_t *l) { return l->tail ? l->tail->datum : NULL; }
uint32_t list_get_length(list_t *l) { return l->length; }
bool list_is_empty(list_t *l) { return (l->length == 0); }
bool list_not_empty(list_t *l) { return (l->length != 0); }
void list_visit_items(list_t *l, void (*visitor)(void *v)) {
list_item_t *li;
for (li = l->head; li; li = li->next)
visitor(list_item_get_datum(li));
}
void list_item_init(list_item_t *li, void *datum) {
li->pred = li->next = NULL;
li->datum = datum;
}
void list_item_delete(list_item_t *li, void (*datum_delete)(void *datum)) {
if (datum_delete) {
datum_delete(li->datum);
}
free(li);
}
void *list_item_get_datum(list_item_t *li) { return li->datum; }
void list_iterator_init(list_t *l, list_iterator_t *li) {
*li = l ? l->head : NULL;
}
void list_iterator_delete(list_iterator_t *li) { *li = NULL; }
void list_iterator_next(list_iterator_t *li) {
if (*li)
*li = (*li)->next;
}
void list_iterator_prev(list_iterator_t *li) {
if (*li)
*li = (*li)->pred;
}
void *list_iterator_get_datum(list_iterator_t *li) {
return *li ? (*li)->datum : NULL;
}
bool list_iterator_is_valid(list_iterator_t *li) { return (*li != NULL); }
void list_reverse_iterator_init(list_t *l, list_reverse_iterator_t *li) {
*li = l ? l->tail : NULL;
}
void list_reverse_iterator_delete(list_reverse_iterator_t *li) { *li = NULL; }
void list_reverse_iterator_next(list_reverse_iterator_t *li) {
if (*li)
*li = (*li)->pred;
}
void list_reverse_iterator_prev(list_reverse_iterator_t *li) {
if (*li)
*li = (*li)->next;
}
void *list_reverse_iterator_get_datum(list_reverse_iterator_t *li) {
return *li ? (*li)->datum : NULL;
}
bool list_reverse_iterator_is_valid(list_reverse_iterator_t *li) {
return (li != NULL);
}
//======================================================================================================================================================150
// OUTPUT AND UTILITIES
//======================================================================================================================================================150
/* */
void *kmalloc(int size) {
// printf("size: %d, current offset: %p\n",size,freeptr);
void *r = (void *)freeptr;
freeptr += size;
if (freeptr > malloc_size + (long)mem) {
printf("Memory Overflow\n");
exit(1);
}
return r;
}
// transforms the current B+ Tree into a single, contiguous block of memory to
// be used on the GPU
long transform_to_cuda(node *root, bool verbose) {
struct timeval one, two;
double time;
gettimeofday(&one, NULL);
long max_nodes = (long)(pow(order, log(size) / log(order / 2.0) - 1) + 1);
malloc_size = size * sizeof(record) + max_nodes * sizeof(knode);
mem = (char *)malloc(malloc_size);
if (mem == NULL) {
printf("Initial malloc error\n");
exit(1);
}
freeptr = (long)mem;
krecords = (record *)kmalloc(size * sizeof(record));
// printf("%d records\n", size);
knodes = (knode *)kmalloc(max_nodes * sizeof(knode));
// printf("%d knodes\n", max_nodes);
queue = NULL;
enqueue(root);
node *n;
knode *k;
int i;
long nodeindex = 0;
long recordindex = 0;
long queueindex = 0;
knodes[0].location = nodeindex++;
while (queue != NULL) {
n = dequeue();
k = &knodes[queueindex];
k->location = queueindex++;
k->is_leaf = n->is_leaf;
k->num_keys = n->num_keys + 2;
// start at 1 because 0 is set to INT_MIN
k->keys[0] = INT_MIN;
k->keys[k->num_keys - 1] = INT_MAX;
for (i = k->num_keys; i < order; i++)
k->keys[i] = INT_MAX;
if (!k->is_leaf) {
k->indices[0] = nodeindex++;
// if(k->indices[0]>3953){
// printf("ERROR: %d\n", k->indices[0]);
// }
for (i = 1; i < k->num_keys - 1; i++) {
k->keys[i] = n->keys[i - 1];
enqueue((node *)n->pointers[i - 1]);
k->indices[i] = nodeindex++;
// if(k->indices[i]>3953){
// printf("ERROR 1: %d\n", k->indices[i]);
// }
// knodes[nodeindex].location = nodeindex++;
}
// for final point of n
enqueue((node *)n->pointers[i - 1]);
} else {
k->indices[0] = 0;
for (i = 1; i < k->num_keys - 1; i++) {
k->keys[i] = n->keys[i - 1];
krecords[recordindex].value = ((record *)n->pointers[i - 1])->value;
k->indices[i] = recordindex++;
// if(k->indices[i]>3953){
// printf("ERROR 2: %d\n", k->indices[i]);
// }
}
}
k->indices[k->num_keys - 1] = queueindex;
// if(k->indices[k->num_keys-1]>3953){
// printf("ERROR 3: %d\n", k->indices[k->num_keys-1]);
// }
if (verbose) {
printf("Successfully created knode with index %d\n", k->location);
printf("Is Leaf: %d, Num Keys: %d\n", k->is_leaf, k->num_keys);
printf("Pointers: ");
for (i = 0; i < k->num_keys; i++)
printf("%d | ", k->indices[i]);
printf("\nKeys: ");
for (i = 0; i < k->num_keys; i++)
printf("%d | ", k->keys[i]);
printf("\n\n");
}
}
long mem_used = size * sizeof(record) + (nodeindex) * sizeof(knode);
if (verbose) {
for (i = 0; i < size; i++)
printf("%d ", krecords[i].value);
printf("\nNumber of records = %d, sizeof(record)=%d, total=%d\n", size,
sizeof(record), size * sizeof(record));
printf("Number of knodes = %d, sizeof(knode)=%d, total=%d\n", nodeindex,
sizeof(knode), (nodeindex) * sizeof(knode));
printf("\nDone Transformation. Mem used: %d\n", mem_used);
}
gettimeofday(&two, NULL);
double oneD = one.tv_sec + (double)one.tv_usec * .000001;
double twoD = two.tv_sec + (double)two.tv_usec * .000001;
time = twoD - oneD;
printf("Tree transformation took %f\n", time);
return mem_used;
}
/* */
list_t *findRange(node *root, int start, int end) {
int i;
node *c = find_leaf(root, start, false);
if (c == NULL)
return NULL;
list_t *retList = (list_t *)malloc(sizeof(list_t));
list_init(retList, NULL, NULL);
int counter = 0;
bool cont = true;
while (cont && c != 0) {
cont = false;
for (i = 0; i < c->num_keys; i++) {
if (c->keys[i] >= start && c->keys[i] <= end) {
// list_insert_tail(retList,(record *)c->pointers[i]);
counter++;
cont = true;
} else {
cont = false;
break;
}
}
c = (node *)c->pointers[order - 1];
}
return retList;
}
/* First message to the user. */
void usage_1(void) {
printf("B+ Tree of Order %d.\n", order);
printf("\tAmittai Aviram -- amittai.aviram@yale.edu Version %s\n", Version);
printf("\tfollowing Silberschatz, Korth, Sidarshan, Database Concepts, 5th "
"ed.\n\n");
printf("To build a B+ tree of a different order, start again and enter the "
"order\n");
printf("as an integer argument: bpt <order>. ");
printf("3 <= order <=20\n");
printf("To start with input from a file of newline-delimited integers, start "
"again and enter\n");
printf("the order followed by the filename: bpt <order> <inputfile>.\n");
}
/* Second message to the user. */
void usage_2(void) {
printf("Enter any of the following commands after the prompt > :\n");
printf("\ti <k> -- Insert <k> (an integer) as both key and value).\n");
printf("\tf <k> -- Find the value under key <k>.\n");
printf("\tp <k> -- Print the path from the root to key k and its associated "
"value.\n");
printf("\td <k> -- Delete key <k> and its associated value.\n");
printf("\tx -- Destroy the whole tree. Start again with an empty tree of "
"the same order.\n");
printf("\tt -- Print the B+ tree.\n");
printf("\tl -- Print the keys of the leaves (bottom row of the tree).\n");
printf("\tv -- Toggle output of pointer addresses (\"verbose\") in tree and "
"leaves.\n");
printf("\tq -- Quit. (Or use Ctl-D.)\n");
printf("\t? -- Print this help message.\n");
}
/* Helper function for printing the tree out. See print_tree. */
void enqueue(node *new_node) {
node *c;
if (queue == NULL) {
queue = new_node;
queue->next = NULL;
} else {
c = queue;
while (c->next != NULL) {
c = c->next;
}
c->next = new_node;
new_node->next = NULL;
}
}
/* Helper function for printing the tree out. See print_tree. */
node *dequeue(void) {
node *n = queue;
queue = queue->next;
n->next = NULL;
return n;
}
/* Prints the bottom row of keys of the tree (with their respective pointers, if
* the verbose_output flag is set. */
void print_leaves(node *root) {
int i;
node *c = root;
if (root == NULL) {
printf("Empty tree.\n");
return;
}
while (!c->is_leaf)
c = (node *)c->pointers[0];
while (true) {
for (i = 0; i < c->num_keys; i++) {
if (verbose_output)
// printf("%x ", (unsigned int)c->pointers[i]);
printf("%d ", c->keys[i]);
}
if (verbose_output)
// printf("%x ", (unsigned int)c->pointers[order - 1]);
if (c->pointers[order - 1] != NULL) {
printf(" | ");
c = (node *)c->pointers[order - 1];
} else
break;
}
printf("\n");
}
/* Utility function to give the height of the tree, which length in number of
* edges of the path from the root to any leaf. */
int height(node *root) {
int h = 0;
node *c = root;
while (!c->is_leaf) {
c = (node *)c->pointers[0];
h++;
}
return h;
}
/* Utility function to give the length in edges of the path from any node to the
* root. */
int path_to_root(node *root, node *child) {
int length = 0;
node *c = child;
while (c != root) {
c = c->parent;
length++;
}
return length;
}
/* Prints the B+ tree in the command line in level (rank) order, with the keys
* in each node and the '|' symbol to separate nodes. With the verbose_output
* flag set. the values of the pointers corresponding to the keys also appear
* next to their respective keys, in hexadecimal notation. */
void print_tree(node *root) {
node *n = NULL;
int i = 0;
int rank = 0;
int new_rank = 0;
if (root == NULL) {
printf("Empty tree.\n");
return;
}
queue = NULL;
enqueue(root);
while (queue != NULL) {
n = dequeue();
if (n->parent != NULL && n == n->parent->pointers[0]) {
new_rank = path_to_root(root, n);
if (new_rank != rank) {
rank = new_rank;
printf("\n");
}
}
if (verbose_output)
printf("(%x)", n);
for (i = 0; i < n->num_keys; i++) {
if (verbose_output)
printf("%x ", n->pointers[i]);
printf("%d ", n->keys[i]);
}
if (!n->is_leaf)
for (i = 0; i <= n->num_keys; i++)
enqueue((node *)n->pointers[i]);
if (verbose_output) {
if (n->is_leaf)
printf("%x ", n->pointers[order - 1]);
else
printf("%x ", n->pointers[n->num_keys]);
}
printf("| ");
}
printf("\n");
}
/* Traces the path from the root to a leaf, searching by key. Displays
* information about the path if the verbose flag is set. Returns the leaf
* containing the given key. */
node *find_leaf(node *root, int key, bool verbose) {
int i = 0;
node *c = root;
if (c == NULL) {
if (verbose)
printf("Empty tree.\n");
return c;
}
while (!c->is_leaf) {
if (verbose) {
printf("[");
for (i = 0; i < c->num_keys - 1; i++)
printf("%d ", c->keys[i]);
printf("%d] ", c->keys[i]);
}
i = 0;
while (i < c->num_keys) {
if (key >= c->keys[i])
i++;
else
break;
}
if (verbose)
printf("%d ->\n", i);
c = (node *)c->pointers[i];
}
if (verbose) {
printf("Leaf [");
for (i = 0; i < c->num_keys - 1; i++)
printf("%d ", c->keys[i]);
printf("%d] ->\n", c->keys[i]);
}
return c;
}
/* Finds and returns the record to which a key refers. */
record *find(node *root, int key, bool verbose) {
int i = 0;
node *c = find_leaf(root, key, verbose);
if (c == NULL)
return NULL;
for (i = 0; i < c->num_keys; i++)
if (c->keys[i] == key)
break;
if (i == c->num_keys)
return NULL;
else
return (record *)c->pointers[i];
}
/* Finds the appropriate place to split a node that is too big into two. */
int cut(int length) {
if (length % 2 == 0)
return length / 2;
else
return length / 2 + 1;
}
//======================================================================================================================================================150
// INSERTION
//======================================================================================================================================================150
/* Creates a new record to hold the value to which a key refers. */
record *make_record(int value) {
record *new_record = (record *)malloc(sizeof(record));
if (new_record == NULL) {
perror("Record creation.");
exit(EXIT_FAILURE);
} else {
new_record->value = value;
}
return new_record;
}
/* Creates a new general node, which can be adapted to serve as either a leaf or
* an internal node. */
node *make_node(void) {
node *new_node;
new_node = (node *)malloc(sizeof(node));
if (new_node == NULL) {
perror("Node creation.");
exit(EXIT_FAILURE);
}
new_node->keys = (int *)malloc((order - 1) * sizeof(int));
if (new_node->keys == NULL) {
perror("New node keys array.");
exit(EXIT_FAILURE);
}
new_node->pointers = (void **)malloc(order * sizeof(void *));
if (new_node->pointers == NULL) {
perror("New node pointers array.");
exit(EXIT_FAILURE);
}
new_node->is_leaf = false;
new_node->num_keys = 0;
new_node->parent = NULL;
new_node->next = NULL;
return new_node;
}
/* Creates a new leaf by creating a node and then adapting it appropriately. */
node *make_leaf(void) {
node *leaf = make_node();
leaf->is_leaf = true;
return leaf;
}
/* Helper function used in insert_into_parent to find the index of the parent's
* pointer to the node to the left of the key to be inserted. */
int get_left_index(node *parent, node *left) {
int left_index = 0;
while (left_index <= parent->num_keys && parent->pointers[left_index] != left)
left_index++;
return left_index;
}
/* Inserts a new pointer to a record and its corresponding key into a leaf.
* Returns the altered leaf. */
node *insert_into_leaf(node *leaf, int key, record *pointer) {
int i, insertion_point;
insertion_point = 0;
while (insertion_point < leaf->num_keys && leaf->keys[insertion_point] < key)
insertion_point++;
for (i = leaf->num_keys; i > insertion_point; i--) {
leaf->keys[i] = leaf->keys[i - 1];
leaf->pointers[i] = leaf->pointers[i - 1];
}
leaf->keys[insertion_point] = key;
leaf->pointers[insertion_point] = pointer;
leaf->num_keys++;
return leaf;
}
/* Inserts a new key and pointer to a new record into a leaf so as to exceed the
* tree's order, causing the leaf to be split in half. */
node *insert_into_leaf_after_splitting(node *root, node *leaf, int key,
record *pointer) {
node *new_leaf;
int *temp_keys;
void **temp_pointers;
int insertion_index, split, new_key, i, j;
new_leaf = make_leaf();
temp_keys = (int *)malloc(order * sizeof(int));
if (temp_keys == NULL) {
perror("Temporary keys array.");
exit(EXIT_FAILURE);
}
temp_pointers = (void **)malloc(order * sizeof(void *));
if (temp_pointers == NULL) {
perror("Temporary pointers array.");
exit(EXIT_FAILURE);
}
insertion_index = 0;
while (leaf->keys[insertion_index] < key && insertion_index < order - 1)
insertion_index++;
for (i = 0, j = 0; i < leaf->num_keys; i++, j++) {
if (j == insertion_index)
j++;
temp_keys[j] = leaf->keys[i];
temp_pointers[j] = leaf->pointers[i];
}
temp_keys[insertion_index] = key;
temp_pointers[insertion_index] = pointer;
leaf->num_keys = 0;
split = cut(order - 1);
for (i = 0; i < split; i++) {
leaf->pointers[i] = temp_pointers[i];
leaf->keys[i] = temp_keys[i];
leaf->num_keys++;
}
for (i = split, j = 0; i < order; i++, j++) {
new_leaf->pointers[j] = temp_pointers[i];
new_leaf->keys[j] = temp_keys[i];
new_leaf->num_keys++;
}
free(temp_pointers);
free(temp_keys);
new_leaf->pointers[order - 1] = leaf->pointers[order - 1];
leaf->pointers[order - 1] = new_leaf;
for (i = leaf->num_keys; i < order - 1; i++)
leaf->pointers[i] = NULL;
for (i = new_leaf->num_keys; i < order - 1; i++)
new_leaf->pointers[i] = NULL;
new_leaf->parent = leaf->parent;
new_key = new_leaf->keys[0];
return insert_into_parent(root, leaf, new_key, new_leaf);
}
/* Inserts a new key and pointer to a node into a node into which these can fit
* without violating the B+ tree properties. */
node *insert_into_node(node *root, node *n, int left_index, int key,
node *right) {
int i;
for (i = n->num_keys; i > left_index; i--) {
n->pointers[i + 1] = n->pointers[i];
n->keys[i] = n->keys[i - 1];
}
n->pointers[left_index + 1] = right;
n->keys[left_index] = key;
n->num_keys++;
return root;
}
/* Inserts a new key and pointer to a node into a node, causing the node's size
* to exceed the order, and causing the node to split into two. */
node *insert_into_node_after_splitting(node *root, node *old_node,
int left_index, int key, node *right) {
int i, j, split, k_prime;
node *new_node, *child;
int *temp_keys;
node **temp_pointers;
/* First create a temporary set of keys and pointers
* to hold everything in order, including
* the new key and pointer, inserted in their
* correct places.
* Then create a new node and copy half of the
* keys and pointers to the old node and
* the other half to the new.
*/
temp_pointers = (node **)malloc((order + 1) * sizeof(node *));
if (temp_pointers == NULL) {
perror("Temporary pointers array for splitting nodes.");
exit(EXIT_FAILURE);
}
temp_keys = (int *)malloc(order * sizeof(int));
if (temp_keys == NULL) {
perror("Temporary keys array for splitting nodes.");
exit(EXIT_FAILURE);
}
for (i = 0, j = 0; i < old_node->num_keys + 1; i++, j++) {
if (j == left_index + 1)
j++;
temp_pointers[j] = (node *)old_node->pointers[i];
}
for (i = 0, j = 0; i < old_node->num_keys; i++, j++) {
if (j == left_index)
j++;
temp_keys[j] = old_node->keys[i];
}
temp_pointers[left_index + 1] = right;
temp_keys[left_index] = key;
/* Create the new node and copy
* half the keys and pointers to the
* old and half to the new.
*/
split = cut(order);
new_node = make_node();
old_node->num_keys = 0;
for (i = 0; i < split - 1; i++) {
old_node->pointers[i] = temp_pointers[i];
old_node->keys[i] = temp_keys[i];
old_node->num_keys++;
}
old_node->pointers[i] = temp_pointers[i];
k_prime = temp_keys[split - 1];
for (++i, j = 0; i < order; i++, j++) {
new_node->pointers[j] = temp_pointers[i];
new_node->keys[j] = temp_keys[i];
new_node->num_keys++;
}
new_node->pointers[j] = temp_pointers[i];
free(temp_pointers);
free(temp_keys);
new_node->parent = old_node->parent;
for (i = 0; i <= new_node->num_keys; i++) {
child = (node *)new_node->pointers[i];
child->parent = new_node;
}
/* Insert a new key into the parent of the two
* nodes resulting from the split, with
* the old node to the left and the new to the right.
*/
return insert_into_parent(root, old_node, k_prime, new_node);
}
/* Inserts a new node (leaf or internal node) into the B+ tree. Returns the root
* of the tree after insertion. */
node *insert_into_parent(node *root, node *left, int key, node *right) {
int left_index;
node *parent;
parent = left->parent;
/* Case: new root. */
if (parent == NULL)
return insert_into_new_root(left, key, right);
/* Case: leaf or node. (Remainder of
* function body.)
*/
/* Find the parent's pointer to the left
* node.
*/
left_index = get_left_index(parent, left);
/* Simple case: the new key fits into the node.
*/
if (parent->num_keys < order - 1)
return insert_into_node(root, parent, left_index, key, right);
/* Harder case: split a node in order
* to preserve the B+ tree properties.
*/
return insert_into_node_after_splitting(root, parent, left_index, key, right);
}
/* Creates a new root for two subtrees and inserts the appropriate key into the
* new root. */
node *insert_into_new_root(node *left, int key, node *right) {
node *root = make_node();
root->keys[0] = key;
root->pointers[0] = left;
root->pointers[1] = right;
root->num_keys++;
root->parent = NULL;
left->parent = root;
right->parent = root;
return root;
}
/* First insertion: start a new tree. */
node *start_new_tree(int key, record *pointer) {
node *root = make_leaf();
root->keys[0] = key;
root->pointers[0] = pointer;
root->pointers[order - 1] = NULL;
root->parent = NULL;
root->num_keys++;
return root;
}
/* Master insertion function. Inserts a key and an associated value into the B+
* tree, causing the tree to be adjusted however necessary to maintain the B+
* tree properties. */
node *insert(node *root, int key, int value) {
record *pointer;
node *leaf;
/* The current implementation ignores duplicates. */
if (find(root, key, false) != NULL)
return root;
/* Create a new record for the value. */
pointer = make_record(value);
/* Case: the tree does not exist yet. Start a new tree. */
if (root == NULL)
return start_new_tree(key, pointer);
/* Case: the tree already exists. (Rest of function body.) */
leaf = find_leaf(root, key, false);
/* Case: leaf has room for key and pointer. */
if (leaf->num_keys < order - 1) {
leaf = insert_into_leaf(leaf, key, pointer);
return root;
}
/* Case: leaf must be split. */
return insert_into_leaf_after_splitting(root, leaf, key, pointer);
}
//======================================================================================================================================================150
// DELETION
//======================================================================================================================================================150
/* Utility function for deletion. Retrieves the index of a node's nearest
* neighbor (sibling) to the left if one exists. If not (the node is the
* leftmost child), returns -1 to signify this special case. */
int get_neighbor_index(node *n) {
int i;
/* Return the index of the key to the left
* of the pointer in the parent pointing
* to n.
* If n is the leftmost child, this means
* return -1.
*/
for (i = 0; i <= n->parent->num_keys; i++)
if (n->parent->pointers[i] == n)
return i - 1;
// Error state.
printf("Search for nonexistent pointer to node in parent.\n");
// printf("Node: %#x\n", (unsigned int)n);
exit(EXIT_FAILURE);
}
/* */
node *remove_entry_from_node(node *n, int key, node *pointer) {
int i, num_pointers;
// Remove the key and shift other keys accordingly.
i = 0;
while (n->keys[i] != key)
i++;
for (++i; i < n->num_keys; i++)
n->keys[i - 1] = n->keys[i];
// Remove the pointer and shift other pointers accordingly.
// First determine number of pointers.
num_pointers = n->is_leaf ? n->num_keys : n->num_keys + 1;
i = 0;
while (n->pointers[i] != pointer)
i++;
for (++i; i < num_pointers; i++)
n->pointers[i - 1] = n->pointers[i];
// One key fewer.
n->num_keys--;
// Set the other pointers to NULL for tidiness.
// A leaf uses the last pointer to point to the next leaf.
if (n->is_leaf)
for (i = n->num_keys; i < order - 1; i++)
n->pointers[i] = NULL;
else
for (i = n->num_keys + 1; i < order; i++)
n->pointers[i] = NULL;
return n;
}
/* */
node *adjust_root(node *root) {
node *new_root;
/* Case: nonempty root.
* Key and pointer have already been deleted,
* so nothing to be done.
*/
if (root->num_keys > 0)
return root;
/* Case: empty root.
*/
// If it has a child, promote
// the first (only) child
// as the new root.
if (!root->is_leaf) {
new_root = (node *)root->pointers[0];
new_root->parent = NULL;
}
// If it is a leaf (has no children),
// then the whole tree is empty.
else
new_root = NULL;
free(root->keys);
free(root->pointers);
free(root);
return new_root;
}
/* Coalesces a node that has become too small after deletion with a neighboring
* node that can accept the additional entries without exceeding the maximum. */
node *coalesce_nodes(node *root, node *n, node *neighbor, int neighbor_index,
int k_prime) {
int i, j, neighbor_insertion_index, n_start, n_end, new_k_prime;
node *tmp;
bool split;
/* Swap neighbor with node if node is on the
* extreme left and neighbor is to its right.
*/
if (neighbor_index == -1) {
tmp = n;
n = neighbor;
neighbor = tmp;
}
/* Starting point in the neighbor for copying
* keys and pointers from n.
* Recall that n and neighbor have swapped places
* in the special case of n being a leftmost child.
*/
neighbor_insertion_index = neighbor->num_keys;
/*
* Nonleaf nodes may sometimes need to remain split,
* if the insertion of k_prime would cause the resulting
* single coalesced node to exceed the limit order - 1.
* The variable split is always false for leaf nodes
* and only sometimes set to true for nonleaf nodes.
*/
split = false;
/* Case: nonleaf node.
* Append k_prime and the following pointer.
* If there is room in the neighbor, append
* all pointers and keys from the neighbor.
* Otherwise, append only cut(order) - 2 keys and
* cut(order) - 1 pointers.
*/
if (!n->is_leaf) {
/* Append k_prime.
*/
neighbor->keys[neighbor_insertion_index] = k_prime;
neighbor->num_keys++;
/* Case (default): there is room for all of n's keys and pointers
* in the neighbor after appending k_prime.
*/
n_end = n->num_keys;
/* Case (special): k cannot fit with all the other keys and pointers
* into one coalesced node.
*/
n_start = 0; // Only used in this special case.
if (n->num_keys + neighbor->num_keys >= order) {
split = true;
n_end = cut(order) - 2;
}
for (i = neighbor_insertion_index + 1, j = 0; j < n_end; i++, j++) {
neighbor->keys[i] = n->keys[j];
neighbor->pointers[i] = n->pointers[j];
neighbor->num_keys++;
n->num_keys--;
n_start++;
}
/* The number of pointers is always
* one more than the number of keys.
*/
neighbor->pointers[i] = n->pointers[j];
/* If the nodes are still split, remove the first key from
* n.
*/
if (split) {
new_k_prime = n->keys[n_start];
for (i = 0, j = n_start + 1; i < n->num_keys; i++, j++) {
n->keys[i] = n->keys[j];
n->pointers[i] = n->pointers[j];
}
n->pointers[i] = n->pointers[j];
n->num_keys--;
}
/* All children must now point up to the same parent.
*/
for (i = 0; i < neighbor->num_keys + 1; i++) {
tmp = (node *)neighbor->pointers[i];
tmp->parent = neighbor;
}
}
/* In a leaf, append the keys and pointers of
* n to the neighbor.
* Set the neighbor's last pointer to point to
* what had been n's right neighbor.
*/
else {
for (i = neighbor_insertion_index, j = 0; j < n->num_keys; i++, j++) {
neighbor->keys[i] = n->keys[j];
neighbor->pointers[i] = n->pointers[j];
neighbor->num_keys++;
}
neighbor->pointers[order - 1] = n->pointers[order - 1];
}
if (!split) {
root = delete_entry(root, n->parent, k_prime, n);
free(n->keys);
free(n->pointers);
free(n);
} else
for (i = 0; i < n->parent->num_keys; i++)
if (n->parent->pointers[i + 1] == n) {
n->parent->keys[i] = new_k_prime;
break;
}
return root;
}
/* Redistributes entries between two nodes when one has become too small after
* deletion but its neighbor is too big to append the small node's entries
* without exceeding the maximum */
node *redistribute_nodes(node *root, node *n, node *neighbor,
int neighbor_index, int k_prime_index, int k_prime) {
int i;
node *tmp;
/* Case: n has a neighbor to the left.
* Pull the neighbor's last key-pointer pair over
* from the neighbor's right end to n's left end.
*/
if (neighbor_index != -1) {
if (!n->is_leaf)
n->pointers[n->num_keys + 1] = n->pointers[n->num_keys];
for (i = n->num_keys; i > 0; i--) {
n->keys[i] = n->keys[i - 1];
n->pointers[i] = n->pointers[i - 1];
}
if (!n->is_leaf) {
n->pointers[0] = neighbor->pointers[neighbor->num_keys];
tmp = (node *)n->pointers[0];
tmp->parent = n;
neighbor->pointers[neighbor->num_keys] = NULL;
n->keys[0] = k_prime;
n->parent->keys[k_prime_index] = neighbor->keys[neighbor->num_keys - 1];
} else {
n->pointers[0] = neighbor->pointers[neighbor->num_keys - 1];
neighbor->pointers[neighbor->num_keys - 1] = NULL;
n->keys[0] = neighbor->keys[neighbor->num_keys - 1];
n->parent->keys[k_prime_index] = n->keys[0];
}
}
/* Case: n is the leftmost child.
* Take a key-pointer pair from the neighbor to the right.
* Move the neighbor's leftmost key-pointer pair
* to n's rightmost position.
*/
else {
if (n->is_leaf) {
n->keys[n->num_keys] = neighbor->keys[0];
n->pointers[n->num_keys] = neighbor->pointers[0];
n->parent->keys[k_prime_index] = neighbor->keys[1];
} else {
n->keys[n->num_keys] = k_prime;
n->pointers[n->num_keys + 1] = neighbor->pointers[0];
tmp = (node *)n->pointers[n->num_keys + 1];
tmp->parent = n;
n->parent->keys[k_prime_index] = neighbor->keys[0];
}
for (i = 0; i < neighbor->num_keys; i++) {
neighbor->keys[i] = neighbor->keys[i + 1];
neighbor->pointers[i] = neighbor->pointers[i + 1];
}
if (!n->is_leaf)
neighbor->pointers[i] = neighbor->pointers[i + 1];
}
/* n now has one more key and one more pointer;
* the neighbor has one fewer of each.
*/
n->num_keys++;
neighbor->num_keys--;
return root;
}
/* Deletes an entry from the B+ tree. Removes the record and its key and pointer
* from the leaf, and then makes all appropriate changes to preserve the B+ tree
* properties. */
node *delete_entry(node *root, node *n, int key, void *pointer) {
int min_keys;
node *neighbor;
int neighbor_index;
int k_prime_index, k_prime;
int capacity;
// Remove key and pointer from node.
n = remove_entry_from_node(n, key, (node *)pointer);
/* Case: deletion from the root.
*/
if (n == root)
return adjust_root(root);
/* Case: deletion from a node below the root.
* (Rest of function body.)
*/
/* Determine minimum allowable size of node,
* to be preserved after deletion.
*/
min_keys = n->is_leaf ? cut(order - 1) : cut(order) - 1;
/* Case: node stays at or above minimum.
* (The simple case.)
*/
if (n->num_keys >= min_keys)
return root;
/* Case: node falls below minimum.
* Either coalescence or redistribution
* is needed.
*/
/* Find the appropriate neighbor node with which
* to coalesce.
* Also find the key (k_prime) in the parent
* between the pointer to node n and the pointer
* to the neighbor.
*/
neighbor_index = get_neighbor_index(n);
k_prime_index = neighbor_index == -1 ? 0 : neighbor_index;
k_prime = n->parent->keys[k_prime_index];
neighbor = neighbor_index == -1 ? (node *)n->parent->pointers[1]
: (node *)n->parent->pointers[neighbor_index];
capacity = n->is_leaf ? order : order - 1;
/* Coalescence. */
if (neighbor->num_keys + n->num_keys < capacity)
return coalesce_nodes(root, n, neighbor, neighbor_index, k_prime);
/* Redistribution. */
else
return redistribute_nodes(root, n, neighbor, neighbor_index, k_prime_index,
k_prime);
}
/* Master deletion function. */
node *deleteVal(node *root, int key) {
node *key_leaf;
record *key_record;
key_record = find(root, key, false);
key_leaf = find_leaf(root, key, false);
if (key_record != NULL && key_leaf != NULL) {
free(key_record);
root = delete_entry(root, key_leaf, key, key_record);
}
return root;
}
/* */
void destroy_tree_nodes(node *root) {
int i;
if (root->is_leaf)
for (i = 0; i < root->num_keys; i++)
free(root->pointers[i]);
else
for (i = 0; i < root->num_keys + 1; i++)
destroy_tree_nodes((node *)root->pointers[i]);
free(root->pointers);
free(root->keys);
free(root);
}
/* */
node *destroy_tree(node *root) {
destroy_tree_nodes(root);
return NULL;
}
//======================================================================================================================================================150
// END
//======================================================================================================================================================150
//========================================================================================================================================================================================================200
// MAIN FUNCTION
//========================================================================================================================================================================================================200
int main(int argc, char **argv) {
printf("WG size of kernel 1 & 2 = %d \n", DEFAULT_ORDER);
// ------------------------------------------------------------60
// figure out and display whether 32-bit or 64-bit architecture
// ------------------------------------------------------------60
// if(sizeof(int *)==8){
// printf("64 bit machine\n");
// }
// else if(sizeof(int *)==4){
// printf("32 bit machine\n");
// }
// ------------------------------------------------------------60
// set GPU
// ------------------------------------------------------------60
int device = 0;
cudaSetDevice(device);
printf("Selecting device %d\n", device);
// ------------------------------------------------------------60
// read inputs
// ------------------------------------------------------------60
// assing default values
int cur_arg;
int arch_arg;
arch_arg = 0;
int cores_arg;
cores_arg = 1;
char *input_file = NULL;
char *command_file = NULL;
char *output = "output.txt";
FILE *pFile;
// go through arguments
for (cur_arg = 1; cur_arg < argc; cur_arg++) {
// check if -file
if (strcmp(argv[cur_arg], "file") == 0) {
// check if value provided
if (argc >= cur_arg + 1) {
input_file = argv[cur_arg + 1];
cur_arg = cur_arg + 1;
// value is not a number
}
// value not provided
else {
printf("ERROR: Missing value to -file parameter\n");
return -1;
}
} else if (strcmp(argv[cur_arg], "command") == 0) {
// check if value provided
if (argc >= cur_arg + 1) {
command_file = argv[cur_arg + 1];
cur_arg = cur_arg + 1;
// value is not a number
}
// value not provided
else {
printf("ERROR: Missing value to command parameter\n");
return -1;
}
}
}
// Print configuration
if ((input_file == NULL) || (command_file == NULL))
printf("Usage: ./b+tree file input_file command command_list\n");
// For debug
printf("Input File: %s \n", input_file);
printf("Command File: %s \n", command_file);
FILE *commandFile;
long lSize;
char *commandBuffer;
size_t result;
commandFile = fopen(command_file, "rb");
if (commandFile == NULL) {
fputs("Command File error", stderr);
exit(1);
}
// obtain file size:
fseek(commandFile, 0, SEEK_END);
lSize = ftell(commandFile);
rewind(commandFile);
// allocate memory to contain the whole file:
commandBuffer = (char *)malloc(sizeof(char) * lSize);
if (commandBuffer == NULL) {
fputs("Command Buffer memory error", stderr);
exit(2);
}
// copy the file into the buffer:
result = fread(commandBuffer, 1, lSize, commandFile);
if (result != lSize) {
fputs("Command file reading error", stderr);
exit(3);
}
/* the whole file is now loaded in the memory buffer. */
// terminate
fclose(commandFile);
// For Debug
char *sPointer = commandBuffer;
printf("Command Buffer: \n");
printf("%s", commandBuffer);
//
pFile = fopen(output, "w+");
if (pFile == NULL)
fputs("Fail to open %s !\n", output);
fprintf(pFile, "******starting******\n");
fclose(pFile);
// ------------------------------------------------------------60
// general variables
// ------------------------------------------------------------60
FILE *file_pointer;
node *root;
root = NULL;
record *r;
int input;
char instruction;
order = DEFAULT_ORDER;
verbose_output = false;
// usage_1();
// usage_2();
// ------------------------------------------------------------60
// get input from file, if file provided
// ------------------------------------------------------------60
if (input_file != NULL) {
printf("Getting input from file %s...\n", input_file);
// open input file
file_pointer = fopen(input_file, "r");
if (file_pointer == NULL) {
perror("Failure to open input file.");
exit(EXIT_FAILURE);
}
// get # of numbers in the file
fscanf(file_pointer, "%d\n", &input);
size = input;
// save all numbers
while (!feof(file_pointer)) {
fscanf(file_pointer, "%d\n", &input);
root = insert(root, input, input);
}
// close file
fclose(file_pointer);
// print_tree(root);
// printf("Height of tree = %d\n", height(root));
} else {
printf("ERROR: Argument -file missing\n");
return 0;
}
// ------------------------------------------------------------60
// get tree statistics
// ------------------------------------------------------------60
printf("Transforming data to a GPU suitable structure...\n");
long mem_used = transform_to_cuda(root, 0);
maxheight = height(root);
long rootLoc = (long)knodes - (long)mem;
// ------------------------------------------------------------60
// process commands
// ------------------------------------------------------------60
char *commandPointer = commandBuffer;
printf("Waiting for command\n");
printf("> ");
while (sscanf(commandPointer, "%c", &instruction) != EOF) {
commandPointer++;
switch (instruction) {
// ----------------------------------------40
// Insert
// ----------------------------------------40
case 'i': {
scanf("%d", &input);
while (getchar() != (int)'\n')
;
root = insert(root, input, input);
print_tree(root);
break;
}
// ----------------------------------------40
// n/a
// ----------------------------------------40
case 'f': {
}
// ----------------------------------------40
// find
// ----------------------------------------40
case 'p': {
scanf("%d", &input);
while (getchar() != (int)'\n')
;
r = find(root, input, instruction == 'p');
if (r == NULL)
printf("Record not found under key %d.\n", input);
else
printf("Record found: %d\n", r->value);
break;
}
// ----------------------------------------40
// delete value
// ----------------------------------------40
case 'd': {
scanf("%d", &input);
while (getchar() != (int)'\n')
;
root = (node *)deleteVal(root, input);
print_tree(root);
break;
}
// ----------------------------------------40
// destroy tree
// ----------------------------------------40
case 'x': {
while (getchar() != (int)'\n')
;
root = destroy_tree(root);
print_tree(root);
break;
}
// ----------------------------------------40
// print leaves
// ----------------------------------------40
case 'l': {
while (getchar() != (int)'\n')
;
print_leaves(root);
break;
}
// ----------------------------------------40
// print tree
// ----------------------------------------40
case 't': {
while (getchar() != (int)'\n')
;
print_tree(root);
break;
}
// ----------------------------------------40
// toggle verbose output
// ----------------------------------------40
case 'v': {
while (getchar() != (int)'\n')
;
verbose_output = !verbose_output;
break;
}
// ----------------------------------------40
// quit
// ----------------------------------------40
case 'q': {
while (getchar() != (int)'\n')
;
return EXIT_SUCCESS;
}
// ----------------------------------------40
// [GPU] find K (initK, findK)
// ----------------------------------------40
case 'k': {
// get # of queries from user
int count;
sscanf(commandPointer, "%d", &count);
while (*commandPointer != 32 && commandPointer != '\n')
commandPointer++;
printf("\n ******command: k count=%d \n", count);
if (count > 65535) {
printf("ERROR: Number of requested querries should be 65,535 at most. "
"(limited by # of CUDA blocks)\n");
exit(0);
}
// INPUT: records CPU allocation (setting pointer in mem variable)
record *records = (record *)mem;
long records_elem = (long)rootLoc / sizeof(record);
long records_mem = (long)rootLoc;
printf("records_elem=%d, records_unit_mem=%d, records_mem=%d\n",
(int)records_elem, (int)sizeof(record), (int)records_mem);
// INPUT: knodes CPU allocation (setting pointer in mem variable)
knode *knodes = (knode *)((long)mem + (long)rootLoc);
long knodes_elem = ((long)(mem_used) - (long)rootLoc) / sizeof(knode);
long knodes_mem = (long)(mem_used) - (long)rootLoc;
printf("knodes_elem=%d, knodes_unit_mem=%d, knodes_mem=%d\n",
(int)knodes_elem, (int)sizeof(knode), (int)knodes_mem);
// INPUT: currKnode CPU allocation
long *currKnode;
currKnode = (long *)malloc(count * sizeof(long));
// INPUT: offset CPU initialization
memset(currKnode, 0, count * sizeof(long));
// INPUT: offset CPU allocation
long *offset;
offset = (long *)malloc(count * sizeof(long));
// INPUT: offset CPU initialization
memset(offset, 0, count * sizeof(long));
// INPUT: keys CPU allocation
int *keys;
keys = (int *)malloc(count * sizeof(int));
// INPUT: keys CPU initialization
int i;
for (i = 0; i < count; i++) {
keys[i] = (rand() / (float)RAND_MAX) * size;
}
// OUTPUT: ans CPU allocation
record *ans = (record *)malloc(sizeof(record) * count);
// OUTPUT: ans CPU initialization
for (i = 0; i < count; i++) {
ans[i].value = -1;
}
// CUDA kernel
kernel_gpu_cuda_wrapper(records, records_mem, knodes, knodes_elem,
knodes_mem,
order, maxheight, count,
currKnode, offset, keys, ans);
/* printf("ans: \n"); */
/* for(i = 0; i < count; i++){ */
/* printf("%d ",ans[i].value); */
/* } */
/* printf(" \n"); */
pFile = fopen(output, "aw+");
if (pFile == NULL) {
fputs("Fail to open %s !\n", output);
}
fprintf(pFile, "\n ******command: k count=%d \n", count);
for (i = 0; i < count; i++) {
fprintf(pFile, "%d %d\n", i, ans[i].value);
}
fprintf(pFile, " \n");
fclose(pFile);
// free memory
free(currKnode);
free(offset);
free(keys);
free(ans);
// break out of case
break;
}
// ----------------------------------------40
// find range
// ----------------------------------------40
case 'r': {
int start, end;
scanf("%d", &start);
scanf("%d", &end);
if (start > end) {
input = start;
start = end;
end = input;
}
printf("For range %d to %d, ", start, end);
list_t *ansList;
ansList = findRange(root, start, end);
printf("%d records found\n", list_get_length(ansList));
// list_iterator_t iter;
free(ansList);
break;
}
// ----------------------------------------40
// [GPU] find Range K (initK, findRangeK)
// ----------------------------------------40
case 'j': {
// get # of queries from user
int count;
sscanf(commandPointer, "%d", &count);
while (*commandPointer != 32 && commandPointer != '\n')
commandPointer++;
int rSize;
sscanf(commandPointer, "%d", &rSize);
while (*commandPointer != 32 && commandPointer != '\n')
commandPointer++;
printf("\n******command: j count=%d, rSize=%d \n", count, rSize);
if (rSize > size || rSize < 0) {
printf("Search range size is larger than data set size %d.\n",
(int)size);
exit(0);
}
// INPUT: knodes CPU allocation (setting pointer in mem variable)
knode *knodes = (knode *)((long)mem + (long)rootLoc);
long knodes_elem = ((long)(mem_used) - (long)rootLoc) / sizeof(knode);
long knodes_mem = (long)(mem_used) - (long)rootLoc;
printf("knodes_elem=%d, knodes_unit_mem=%d, knodes_mem=%d\n",
(int)knodes_elem, (int)sizeof(knode), (int)knodes_mem);
// INPUT: currKnode CPU allocation
long *currKnode;
currKnode = (long *)malloc(count * sizeof(long));
// INPUT: offset CPU initialization
memset(currKnode, 0, count * sizeof(long));
// INPUT: offset CPU allocation
long *offset;
offset = (long *)malloc(count * sizeof(long));
// INPUT: offset CPU initialization
memset(offset, 0, count * sizeof(long));
// INPUT: lastKnode CPU allocation
long *lastKnode;
lastKnode = (long *)malloc(count * sizeof(long));
// INPUT: offset CPU initialization
memset(lastKnode, 0, count * sizeof(long));
// INPUT: offset_2 CPU allocation
long *offset_2;
offset_2 = (long *)malloc(count * sizeof(long));
// INPUT: offset CPU initialization
memset(offset_2, 0, count * sizeof(long));
// INPUT: start, end CPU allocation
int *start;
start = (int *)malloc(count * sizeof(int));
int *end;
end = (int *)malloc(count * sizeof(int));
// INPUT: start, end CPU initialization
int i;
for (i = 0; i < count; i++) {
start[i] = (rand() / (float)RAND_MAX) * size;
end[i] = start[i] + rSize;
if (end[i] >= size) {
start[i] = start[i] - (end[i] - size);
end[i] = size - 1;
}
}
// INPUT: recstart, reclenght CPU allocation
int *recstart;
recstart = (int *)malloc(count * sizeof(int));
int *reclength;
reclength = (int *)malloc(count * sizeof(int));
// OUTPUT: ans CPU initialization
for (i = 0; i < count; i++) {
recstart[i] = 0;
reclength[i] = 0;
}
// CUDA kernel
kernel_gpu_cuda_wrapper_2(knodes, knodes_elem, knodes_mem,
order, maxheight, count,
currKnode, offset, lastKnode, offset_2, start,
end, recstart, reclength);
pFile = fopen(output, "aw+");
if (pFile == NULL) {
fputs("Fail to open %s !\n", output);
}
fprintf(pFile, "\n******command: j count=%d, rSize=%d \n", count, rSize);
for (i = 0; i < count; i++) {
fprintf(pFile, "%d %d %d\n", i, recstart[i], reclength[i]);
}
fprintf(pFile, " \n");
fclose(pFile);
// free memory
free(currKnode);
free(offset);
free(lastKnode);
free(offset_2);
free(start);
free(end);
free(recstart);
free(reclength);
// break out of case
break;
}
// ----------------------------------------40
// default
// ----------------------------------------40
default: {
// usage_2();
break;
}
}
printf("> ");
}
printf("\n");
// ------------------------------------------------------------60
// free remaining memory and exit
// ------------------------------------------------------------60
free(mem);
return EXIT_SUCCESS;
}
//========================================================================================================================================================================================================200
// END
//========================================================================================================================================================================================================200
// # ifdef __cplusplus
// }
// # endif
Reference in New Issue View Git Blame Copy Permalink