radix/radix.c

@@ -1,7 +1,7 @@
 #include "radix.h"
 
 #define GET_BIT(key, mask) ( ((key[0] & mask[0]) | (key[1] & mask[1])) != 0 )
-#define SHIFT_MASK(mask) mask[0] >>= 1, mask[1] = (mask[1] >> 1) | (!mask[0] * (1ul << 63))
+#define SHIFT_MASK(mask) mask[0] >>= 1, mask[1] = (mask[1] >> 1) || !(mask[0])
 
 int radix_insert(radix_holder_t, record_t);
 int radix_search(radix_holder_t, record_t);
@@ -11,8 +11,9 @@ radix_holder_t create_holder() {
     return ret;
 }
 
-static radix_node_t create_node(record_t record) {
+radix_node_t create_node(record_t record) {
     radix_node_t ret = malloc(sizeof(struct radix_node));
+    record->_valid = VALID_RULE;
     memcpy(&ret->_data, record, sizeof(struct routing_record));
     ret->_l = ret->_r = NULL;
     return ret;
@@ -28,7 +29,7 @@ static void split_node(radix_node_t n, unsigned bit) {
     radix_node_t tmp = clone_node(n);
     n->_data._mask = bit;
     n->_l = n->_r = tmp;
-    n->_data._rule = INVALID_RULE;
+    n->_data._valid = INVALID_RULE;
 }
 
 int destory_holder(struct radix_holder* t) {
@@ -37,7 +38,7 @@ int destory_holder(struct radix_holder* t) {
     return 1;
 }
 
-static int destory_node(struct radix_node* n) {
+int destory_node(struct radix_node* n) {
     int ret = 0;
     if (!n) return ret;
     ret = destory_node(n->_l) + destory_node(n->_r);
@@ -49,14 +50,10 @@ int radix_insert(radix_holder_t t, record_t /*restrict*/ r) {
     unsigned char b;
     unsigned char ibit = 0;
     unsigned long mask[2] = {0x01ul << 63, 0x00};
-    radix_node_t node;
-    radix_node_t* next;
+    radix_node_t node = t->_root;
+    radix_node_t* next = &t->_root;
 
-    if (!r || !t)
-        return 0;
-
-    node = t->_root;
-    next = &t->_root;
+    r->_valid = INVALID_RULE;
 
     if (!node) {
         t->_root = create_node(r);
@@ -96,6 +93,7 @@ int radix_insert(radix_holder_t t, record_t /*restrict*/ r) {
         next = b ? &node->_r : &node->_l;
         *next = NULL;
 
+        r->_valid = VALID_RULE;
         memcpy(&node->_data, r, sizeof(struct routing_record));
         ++t->_size;
         return 1;
@@ -103,9 +101,10 @@ int radix_insert(radix_holder_t t, record_t /*restrict*/ r) {
 
     /* exact match */
     if (node->_data._mask == r->_mask && ibit == r->_mask) {
-        if (node->_data._rule != INVALID_RULE)
+        if (node->_data._valid)
             return 0;
         /* make valid */
+        node->_data._valid = VALID_RULE;
         node->_data._rule = r->_rule;
         ++t->_size;
         return 1;
@@ -117,48 +116,30 @@ int radix_insert(radix_holder_t t, record_t /*restrict*/ r) {
 }
 
 int radix_search(radix_holder_t t, record_t r) {
-    radix_node_t iter;
-    int ibit;
-    unsigned char b;
-    int m;
-    unsigned long mask[2] = {0x01ul << 63, 0x00};
-
-    if (!r)
-        return INVALID_RULE;
     
-    if (!t || !t->_root)
-        return r->_rule = INVALID_RULE;
+    int ret = INVALID_RULE;
+    /*
+    radix_node_t iter = t->_root;
+    int ibit = 0;
+    if (!iter)
+        return INVALID_RULE;
+        
 
-    iter = t->_root;       
-
-    for (ibit = 0; ibit < r->_mask; ++ibit, SHIFT_MASK(mask)) {
-        b = GET_BIT(r->_ip, mask);
-        if (ibit < iter->_data._mask &&    /* bit match */
-            b == GET_BIT(iter->_data._ip, mask))
+    for (;ibit < 128; ++ibit) {
+        b = GET_BIT(key, ibit);
+        if (ibit < iter->_ip_end_bit &&
+            b == GET_BIT(iter->_ip, ibit))
             continue;
         
-        if (ibit < iter->_data._mask) {   /* bit mismatch */
-            return r->_rule;
-            /* = ibit == iter->_data._mask ? iter->_data._rule : r->_rule; */
-        }
+        if (ibit == iter->_ip_end_bit) // set result if full match
+            ret = iter->_rule_valid ? iter->_rule : ret;
         
-        /* mask ends with full match */
-        if (iter->_data._rule != INVALID_RULE) {
-            r->_rule = iter->_data._rule;
-            m = iter->_data._mask;
-        }
-
-        iter = b ? iter->_l : iter->_r; 
+        iter = b ? iter->_l : iter->_r;
         if (!iter)
-            return r->_rule;
+            return ret;
     }
-    if (ibit == iter->_data._mask && iter->_data._rule != INVALID_RULE) {
-        r->_rule = iter->_data._rule;
-        m = iter->_data._mask;
-    }
-    r->_mask = m;
-
-    return r->_rule;
+    */
+    return ret;
 }
 
 
@@ -168,15 +149,14 @@ int radix_search(radix_holder_t t, record_t r) {
 /*--------------------------------------------------------------------------------*/
 #include <assert.h>
 #include <arpa/inet.h>
-#include <time.h>
 
 #define RULES_FILE "../data/routing-data"
 #define TEST_FILE "../data/test-data"
-#define TEST_ROWS 39222 /*39222*/
+#define TEST_ROWS 0 /*66319*/
 #define READ_MODE "r"
 
 int parse_line(FILE* f, record_t r) {
-    int ikey, jkey, mask, rule;
+    int ikey, jkey;
     unsigned long key[2] = {0,0};
     struct in6_addr addr;
     char ipv6_cidr[50];
@@ -192,26 +172,24 @@ int parse_line(FILE* f, record_t r) {
     separator = strchr(ipv6_cidr, '/');
     if (!separator) {
         printf("invalid CIDR notation\n");
-        return 0;
+        return 1;
     }
 
     *separator++ = '\0';
-    mask = atoi(separator);
+    r->_mask = atoi(separator);
     
     separator = strchr(separator, ' ');
-    rule = atoi(++separator);
+    r->_rule = atoi(++separator);
 
-    if (mask < 0 || mask > 128) {
+    if (r->_mask < 0 || r->_mask > 128) {
         printf("invalid prefix length\n");
-        return 0;
+        return 1;
     }
-    r->_mask = mask;
 
-    if (rule < 0 || rule > 65536) {
+    if (r->_rule < 0 || r->_rule > 65536) {
         printf("invalid pop\n");
-        return 0;
+        return 1;
     }
-    r->_rule = rule;
 
     if (inet_pton(AF_INET6, ipv6_cidr, &addr) != 1) {
         printf("%s invalid address\n", ipv6_cidr);
@@ -226,17 +204,18 @@ int parse_line(FILE* f, record_t r) {
 
     r->_ip[0] = key[0];
     r->_ip[1] = key[1];
-    return 1;
+    r->_valid = VALID_RULE;
+    return !feof(f);
 }
 
 int load_input(radix_holder_t t) {
     struct routing_record r;
     FILE* f;
     int cnt = 0;
-
+    
     if (!(f = fopen(RULES_FILE, READ_MODE))) {
         puts("cant open input file");
-        return 0;
+        exit(1);
     }
     
     while (parse_line(f, &r)) {
@@ -249,74 +228,67 @@ int load_input(radix_holder_t t) {
     return cnt;
 }
 
-int load_tests(struct routing_record** ref) {
+int load_tests(unsigned long** subnets, int** rref) {
+    /*
+    unsigned long* ips;
+    int* ref;
+    int row;
     FILE* f;
-    int cnt = 0;
-    struct routing_record* r = malloc(sizeof(struct routing_record) * TEST_ROWS);
-
-    if (!(f = fopen(TEST_FILE, READ_MODE))) {
-        puts("cant open test file");
-        return 0;
-    }
+    struct routing_record r;
     
-    for (cnt = 0; cnt < TEST_ROWS; ++cnt) {
-        if (!parse_line(f, &r[cnt])) {
-            printf("WARNING test parse failed %d\n", cnt);
-            break;
-        }
+    if (!(f = fopen( TEST_FILE, READ_MODE ))) {
+        puts("cant open test file");
+        exit(1);
     }
 
+    ips = calloc( TEST_ROWS, sizeof(unsigned long) );
+    ref = calloc( TEST_ROWS, sizeof(int) );
+
+    for (row = 0; row < TEST_ROWS; ++ row) {
+        parse_line(f, &r);
+        ips[row] = r._ip;
+        ref[row] = r._rule;
+    }
     fclose(f);
-    *ref = r;
-    return cnt;
+    
+    *subnets = ips;
+    *rref = ref;
+    */
+    return TEST_ROWS;
 }
 
-int fire_tests(radix_holder_t t, struct routing_record* r) {
+int fire_tests(radix_holder_t t, unsigned long* subnets, int* ref, int num_tests ) {
+    /*
     int row;
-    int wrong = TEST_ROWS;
-    unsigned short ref_pop, ref_scope;
+    int wrong = 0;
+    struct routing_record r;
     
-    clock_t start, end;
-    double lookup_time;
-
-    start = clock();
-
-    for (row = 0; row < TEST_ROWS; ++row) {
-        ref_pop = r[row]._rule;
-        ref_scope = r[row]._mask;
-
-        r[row]._rule = INVALID_RULE;
-        radix_search(t, &r[row]);
-        if (ref_pop == r[row]._rule && ref_scope == r[row]._mask) {
-            --wrong;
-        } else {
-            if (ref_pop != r[row]._rule)
-                printf("pop: %d got: %d @ %d\n", ref_pop, r[row]._rule, row );
-            if (ref_scope != r[row]._mask)
-                printf("scp: %d got: %d @ %d\n", ref_scope, r[row]._mask, row );
+    for (row = 0; row < TEST_ROWS; ++ row) {
+        r._ip = subnets[row];
+        r._ip = subnets[row+1];
+        radix_search(t, &r);
+        if ( !r._valid || r._rule !=  ref[row]) {
+            printf("ref: %d got: %d @ %d\n", ref[row], r._rule, row );
+        ++wrong;
         }
     }
     
-    end = clock();
-    lookup_time = ((double) (end - start)) / CLOCKS_PER_SEC * 1000;
-
-    printf("%d lookups in %f ms (%f microseconds per op)\n", TEST_ROWS, lookup_time, ((end - start)/(double)TEST_ROWS));
-    
-    free(r);
-    
+    free(subnets);
+    free(ref);
     return wrong;
-    
+    */
     return 0;
 }
 
 int main() {
-    struct routing_record* ref;
+    unsigned long* subnets;
+    int* ref;    
 
     radix_holder_t t = create_holder();
     
     printf("Loaded %d rules\n", load_input(t) );
-    printf("Loaded %d tests\n", load_tests(&ref) );
-    printf("%d tests wrong\n", fire_tests(t, ref) );
+    printf("Loaded %d tests\n", load_tests(&subnets, &ref) );
+    printf("%d tests wrong\n", fire_tests(t, subnets, ref, TEST_ROWS) );
 
     destory_holder(t);
     return 0;

radix/radix.h

@@ -5,12 +5,15 @@
 #include "stdlib.h"
 #include "string.h"
 
-#define INVALID_RULE 0
+#define VALID_RULE      1
+#define INVALID_RULE    0
+#define RULE_NOT_FOUND -1
 
 struct routing_record {
     unsigned long     _ip[2];
     unsigned short    _rule;
-    unsigned          _mask:8;
+    unsigned          _mask:7;
+    unsigned          _valid:1;
 };
 
 struct radix_node {
@@ -29,12 +32,12 @@ typedef struct radix_holder*   radix_holder_t;
 typedef struct routing_record* record_t;
 
 radix_holder_t create_holder();
-static radix_node_t create_node(record_t record);
+radix_node_t create_node(record_t record);
 static radix_node_t clone_node(radix_node_t n);
 static void split_node(struct radix_node* n, unsigned bit);
 
 int destory_holder(struct radix_holder*);
-static int destory_node(struct radix_node*);
+int destory_node(struct radix_node*);
 
 int radix_insert(radix_holder_t, record_t);
 int radix_search(radix_holder_t, record_t);