main.c

eXtremeDB数据库在Linux平台下的使用源码。内含多个示例程序

/***************************************************************
 *                                                             *
 * Copyright (c) 2001-2007 McObject LLC. All Right Reserved.   *
 *                                                             *
 ***************************************************************/

/* 
 * This sample demonstrate the use of eXtremeDB for the Routing Table Management software.
 * The program measures the performance for routing table inserts and lookups. The program
 * randomly generates IP addresses, each masked with three masks - 255.255.0.0, 255.255.255.0
 * or 255.255.255.255. We then insert these routes into the routing table, creating a
 * hash-based index based on the {mask/ip address} pair. The database engine filters out
 * duplicate pairs of {mask/ip address} as the new routes are installed into the routing table.
 * After the table is populated, the program searches for a route for a random packet.
 * The algorithm is a combination of a linear search and a tree search, masking the address with
 * each of the three possible masks and then using the index to locate the route. Therefore each
 * address is searched up to three times to find the best match. If more than one route exists,
 * the one with the longest matching prefix is chosen.
 *
 * A somewhat detailed discussion of the routing table implementaion using eXtremeDB
 * could be found in the whitepaper "The Role of In-Memory Database Systems in Routing
 * Table Management in IP Routers" - http://mcobject.com/whitepapers.htm
 */

#include <platform.h>
#include <stdio.h>
#include <stdlib.h>

#include "rtdb.h"

static const char   *dbname = "Route1";
static const int     SEGSZ  = 1024 * 1024 * 16UL;
#ifndef MCO_PLATFORM_X64
static const int     PAGESIZE = 96;
#else
static const int     PAGESIZE = 192;
#endif


const int MAP_ADDRESS =  0x20000000;

#define NROUTES    200000
#define NSEARCHES  500000

static void _SH_(void) {

	char text[] = {
		"\nThis sample demonstrate the use of eXtremeDB for the Routing Table\n"
		"Management software.The program measures the performance for routing\n"
		"randomly generates IP addresses, each masked with three masks - 255.255.0.0,\n"
		"255.255.255.0 or 255.255.255.255. We then insert these routes into the\n"
		"routing table.After the table is populated, the program searches for a route\n"
		"for a random packet.The algorithm is a combination of a linear search and\n"
		"a tree search, masking the address with each of the three possible masks and\n"
		"then using the index to locate the route.\n"
	};

	char text1[] = {
		"Copyright (c) 2001-2007 McObject LLC. All Right Reserved.\n\n"
	};

	printf("%s\neXtremeDB runtime version %d.%d, build %d\n%s\n\nPress Enter to start",
		text, MCO_COMP_VER_MAJOR, MCO_COMP_VER_MINOR, MCO_COMP_BUILD_NUM,text1);

	getchar();
}


/* Produces database memory report
 */
void showMem( mco_db_h db ) {
	mco_puint freepg, totalpg;

	mco_db_free_pages( db, & freepg );
	mco_db_total_pages( db, & totalpg );

	printf(	"\n\tMemory Report:\n\ttotal pages=%d (%dK)\n\tfree pages=%d (%dK)\n\tused %dK\n",
		totalpg,
		totalpg * PAGESIZE / 1024,
		freepg,
		freepg * PAGESIZE / 1024,
		(totalpg - freepg) * PAGESIZE / 1024
		);
}


/* fatal error handler */
static void errhandler( int n ) {
	printf( "\neXtremeDB fatal error: %d", n );
	getchar();
	exit( -1 );
}


static uint1 calcNbits(uint4 mask) {
	static int n8[16] = {0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4};
	int rc = 0, i;
	for(i=0; i<8; i++) {
		int halfbt = ( mask >> (i<<2) ) & 15;
		rc += n8[halfbt];
	}
	return (uint1)rc;
}


static MCO_RET addRoute(mco_db_h db,
uint4 dest, uint4 mask, uint4 gatew, uint4 interf, uint2 weight) {
	MCO_RET     rc;
	mco_trans_h t;
	Mask        hmask;
	Route       rt;
	uint1       nbit = calcNbits(mask);
	// mco_cursor_t csr;

	rc = mco_trans_start(db,MCO_READ_WRITE,MCO_TRANS_FOREGROUND,&t);
	if(rc) return rc;

	// add mask if need:
	rc =  Mask_all_find( t, nbit, mask, & hmask );
	if(rc == MCO_S_NOTFOUND) {
		rc = Mask_new(t, & hmask);
		if(rc) goto End;
		Mask_mask_put(& hmask, mask);
		Mask_nbits_put(& hmask, nbit);
	}
	else {
		if(rc) goto End;
	}

	// add route:
	rc = Route_new(t, &rt);
	if(rc) goto End;

	Route_dest_put(&rt, dest);
	Route_mask_put(&rt, mask);
	Route_gateway_put(&rt, gatew);
	Route_interf_put(&rt, interf);
	Route_metric_put(&rt, weight);

	End:
	rc = mco_trans_commit(t);
	return rc;
}


static uint4 genIP(void) {
	uint4 rc = 0x2A3B0000;
	int rn = rand() | (rand()<<16);

	rc |= rn & 0xFFFFFF;
	if( rn & 0x01000000 ) {
	  rc |= 0x0E000000;	  // ^= (rn & 0x0F000000);
	}
	return rc;
}


static uint4 genMask(uint4 ip) {
	int rn = rand() & 15;
	if(rn < 12 ) {
		return 0xFFFFFFFF;
	}
	if( rn < 15 )
		return 0xFFFFFF00;
	return 0xFFFF0000;
}


static const char * prtip(uint4 n) {
	static char rc[100];
	sprintf(rc, "%03d.%03d.%03d.%03d  ",
		(n>>24) & 255,
		(n>>16) & 255,
		(n>>8) & 255,
		(n) & 255
		);
	return rc;
}


/* This is used to dump the content of the routing table into the file
 * In oredr to use this, change the schema so, that the tree index is
 * declared, and remove the #define DUMP_TABLE on the top of this file
 */
#define DUMP_TABLE
static void dumpRoutingTable(mco_db_h db, const char *fnm) {
#ifdef DUMP_TABLE
	FILE * f = fopen(fnm, "w");

	mco_cursor_t  csr;
	Route         rt;
	uint4         mask, dest, gateway, interf;
	mco_trans_h   t;
	MCO_RET       rc;

	if(! f)
		return;

	mco_trans_start(db,MCO_READ_WRITE,MCO_TRANS_FOREGROUND,&t);

	Route_byMaskDest_index_cursor(t, &csr);

	for(rc = mco_cursor_first(t, &csr); rc==MCO_S_OK; rc = mco_cursor_next(t, &csr) ) {
		Route_from_cursor(t, &csr, &rt);
		Route_dest_get(&rt, &dest);
		Route_mask_get(&rt, &mask);
		Route_interf_get(&rt, &interf);
		Route_gateway_get(&rt, &gateway);

		fprintf(f, "%s", prtip( dest ) );
		fprintf(f, "%s", prtip( mask ) );
		fprintf(f, "%s", prtip( gateway ) );
		fprintf(f, "%s", prtip( interf ) );
		fprintf(f,"\n");

	}

	mco_trans_commit(t);
	fclose(f);
#endif
}


/* 
 * searchRoute()
 */
static int searchRoute(mco_db_h db, uint4 ip, uint4 * res_gatew, uint4 * res_interf) {
	MCO_RET rc;
	mco_cursor_t csr;
	Mask hmask;
	uint4 mask;
	mco_trans_h t;

	int ok = 0;

	rc = mco_trans_start(db,MCO_READ_ONLY,MCO_TRANS_FOREGROUND,&t);
	if(rc) return rc;

	// scan all possible masks
	rc = Mask_all_index_cursor(t, &csr);
	if(rc) goto End;

	for(rc = mco_cursor_last(t, &csr); rc ==MCO_S_OK; rc = mco_cursor_prev(t, &csr) ) {
		Route rt;

		Mask_from_cursor(t, &csr, & hmask);
		Mask_mask_get( & hmask, & mask );
		rc = Route_byMaskDest_find(t, mask, mask & ip, & rt);
		if(rc == MCO_S_OK) {
			ok = 1;
			break;
		}
	}

	End:
	rc = mco_trans_commit(t);
	return ok;

}


static void dodo(mco_db_h db) {
	int j;
	MCO_RET rc;
	uint4 gway = genIP();
	uint4 interf = genIP();
	int nok = 0;
	int nskipped = 0;
	uint4 ip;
	uint4 mask;

	time_t t1, t2, t3, t4;

	printf ("\nPopulating Routing Table with %d randomly generated routes\n", NROUTES);
	Sleep(50);
	time(&t1);
	for(j=0; j<NROUTES; j++) {

	    ip = genIP();
 	    mask = genMask(ip);
        ip = ip & mask;

		rc = addRoute(db, ip, mask, gway, interf, 1);

		if(rc) {
			if(rc == MCO_S_DUPLICATE)
				nskipped++;
			else {
				printf("\nRoute add error: %d", rc);
				break;
			}
		}
		if(j % 5000 == 0 ) {
			printf(".");
		}
	}
	time(&t2);

	printf("\nAdded %d routes, %d duplicate routes rejected -- %d sec\n\n", j - nskipped, nskipped,t2-t1);
	Sleep(50);
	showMem( db );

	dumpRoutingTable(db, "rt_.txt");

	printf ("\nLooking for a random IP %d times\n", NSEARCHES);
	Sleep(50);

	time(&t3);
	for(j=0; j<NSEARCHES; j++) {
		uint4 ip = genIP();
		uint4 res_gatew, res_interf;
		int ok = searchRoute(db, ip, & res_gatew, & res_interf);
		if(ok) nok++;
		if(j % 5000 == 0 )
			printf(".");
	}
	time(&t4);

	printf("\nSearched %d destinations -- %d sec -- %d succeeded\n\n", j, t4-t3, nok);

}


int main( void ) {
	MCO_RET     rc;
	mco_db_h    db = 0;
	char      *start_mem;
	mco_runtime_info_t info;

	_SH_();
	mco_get_runtime_info( &info);
	if ( info.mco_shm_supported ) {
		start_mem = (char*)MAP_ADDRESS;
	}
	else {
		start_mem = (char*)malloc(SEGSZ);
		if (!start_mem) {
			printf("Couldn't allocated memory\n");
			exit (1);
		}
	};

	/* set fatal error handler */
	mco_error_set_handler( &errhandler );

	rc = mco_runtime_start();

	/* Create a database, using first memory segment */
	rc = mco_db_open( dbname, rtdb_get_dictionary(), start_mem, SEGSZ, (uint2) PAGESIZE );

	if ( rc ) {
		printf( "\nerror creating database" );
		if ( !info.mco_shm_supported )
			free( start_mem );
		exit( 1 );
	}

	/* connect to the database, obtain a database handle */
	mco_db_connect( dbname, &db );
	showMem( db );

	dodo(db);

	/* disconnect from the database, db is no longer valid */
	mco_db_disconnect( db );

	/* destroys the memory manager */
	mco_db_close( dbname );

	mco_runtime_stop();

	if ( !info.mco_shm_supported )
		free( start_mem );

	printf( "press Enter to finish \n" );
	getchar();
  PROG_EXIT(0);
}