自己写的共享内存链表CAlgShareList

CAlgShareList.h

#ifndef _C_ALG_SHARE_LIST_H_
#define _C_ALG_SHARE_LIST_H_
#include <string.h>
#include <stdlib.h>
#include "CAlgCommon.h"

#ifdef	__cplusplus
extern "C" {
#endif

#define ALG_SHARE_LIST_INVALID_POS (-1)

typedef struct _CAlgShareNode{
	void * curr_data; /* node data pointer */

	int prev; /* previous link No. */
	int next; /* next link No. */
	int curr; /* current link No. */
}CAlgShareNode;

typedef struct {
	int head; /* list head */
	int tail; /* list tail */

	int elem_count;         /* list element counts */
	unsigned int elem_size; /* list size of each element */
}CAlgShareList;


typedef CAlgShareNode* (*AlgShareList_RealNode_F)(int);
typedef struct {
	/* position to real node pointer convert function */
	AlgShareList_RealNode_F real_node_f;
	/* compare function. NOTE: pass position (int) to (Node*) */
	Alg_Cmp_F cmp_f;
}CAlgShareList_F;


/**
  * l->head, l->next is int index, may means postion
  */
static inline void CAlgShareList_ReSet(CAlgShareList* l, unsigned int elem_size)
{
	l->head = l->tail = ALG_SHARE_LIST_INVALID_POS;
	l->elem_count = 0;
	l->elem_size = elem_size;
}

/**
  *            insert n to list after prev
  *@prev       previous position, link n to real_node(n)->next, 
  *            if real_node(n) return NULL , means add to head
  *@n          make sure real_node(n) return valid pointer !!!
  *@real_node  position to node position converter, convert prev and n to CAlgShareNode*
  */
//static inline void CAlgShareList_Insert(CAlgShareList* l, int prev, int n, AlgShareList_RealNode_F real_node)
//{
//	CAlgShareNode*p_prev, *p_n;
//	p_prev = real_node(prev);
//	p_n = real_node(n);
//	if(p_prev)
//	{
//		p_n->prev = prev;
//		p_n->next = p_prev->next;
//		p_prev->next = n;
//	}
//	else
//	{
//		p_n->prev = ALG_SHARE_LIST_INVALID_POS;
//		p_n->next = l->head;
//		l->head = n;
//	}
//
//	p_n->curr = n;
//	p_prev = real_node(p_n->next);
//	if(p_prev)
//		p_prev->prev = n;
//
//	if(prev == l->tail)
//		l->tail = n;
//
//	l->elem_count ++;
//}

/**
  *     add n to list head
  *@f   function pointer methods
  *@l   the share list which n should add to
  *@n   make sure real_node_f(n) return valid pointer !!!
  *@ret return the tail position
  */
//static inline int CAlgShareList_AddHead(CAlgShareList* l, int n, AlgShareList_RealNode_F real_node_f)
//{
//	CAlgShareList_Insert(l, ALG_SHARE_LIST_INVALID_POS, n, real_node_f);
//	return l->head;
//}

/**
  *     add n to list tail
  *@f   real node function methods
  *@l   the share list which n should add to
  *@n   make sure real_node_f(n) return valid pointer
  *@ret return the tail position
  */
//static inline int CAlgShareList_AddTail(CAlgShareList* l, int n, AlgShareList_RealNode_F real_node_f)
//{
//	CAlgShareList_Insert(l, l->tail, n, real_node_f);
//	return l->tail;
//}

/**
  *    find the node with data
  *@f     function pointer methods, use f.cmp_f() to compare
  *@l     the share list which n should add to
  *@data  make sure real_node_f(n) return valid pointer
  *@ret   return node position if found, else return ALG_SHARE_LIST_INVALID_POS
  */
static inline int CAlgShareList_Find(CAlgShareList_F f, CAlgShareList* l, void* data)
{
	CAlgShareNode* tmp = f.real_node_f(l->head);
	int rc = l->head;
	while(tmp)
	{
		if(0 == f.cmp_f(tmp->curr_data, data, l->elem_size))
			return rc;

		rc = tmp->next;
		tmp = f.real_node_f(tmp->next);
	}

	return ALG_SHARE_LIST_INVALID_POS;
}

/**
  *    remove node n from list
  *@l  the share list which n should add to
  *@n  make sure real_node_f(n) return valid pointer
  *@f  function pointer methods
  */
static inline int CAlgShareList_RemoveNode(CAlgShareList* l, int n, AlgShareList_RealNode_F real_node)
{
	CAlgShareNode* curr = real_node(n);
	CAlgShareNode* tmp;
	if( curr == NULL) return -1;
	if(n == l->head)
		l->head = curr->next;
	if(n == l->tail)
		l->tail = curr->prev;
	if(tmp= real_node(curr->prev))
		tmp->next = curr->next;
	if(tmp= real_node(curr->next))
		tmp->prev = curr->prev;

	l->elem_count --;

	return 0;
}

///**
//  *     remove head node from list
//  *@l   the share list which n should add to
//  *@f   function pointer methods
//  *@ret return the head node position
//  */
//static inline int CAlgShareList_RemoveHead(CAlgShareList_F f, CAlgShareList* l)
//{
//	int head = l->head;
//	CAlgShareList_RemoveNode(l, l->head, f.real_node_f);
//	return head;
//}
//
///**
//  *     remove tail node from list
//  *@l   the share list which n should add to
//  *@f   function pointer methods
//  *@ret return the head node position
//  */
//static inline int CAlgShareList_RemoveTail(CAlgShareList_F f, CAlgShareList* l)
//{
//	int tail = l->tail;
//	CAlgShareList_RemoveNode(l, l->tail, f.real_node_f);
//	return tail;
//}

#define ALG_SHARE_LIST_FOREACH(alglist, node, f) do{\
	for(node=f.real_node_f(alglist->head); NULL != node; node =f.real_node_f(node->next)){


#define ALG_SHARE_LIST_FOREACH_END() }}while(0)

/**
  *traverse all node data with function it
  *@l       the share list which n should add to
  *@it      it function pointer methods , perform it(node->curr_data)
  *@reverse sequence or reverse traverse the node
  *@ret     return traverse node counts
  */
static inline int CAlgShareList_Enum(const CAlgShareList* l,Alg_IteRator_F it, 
											  AlgShareList_RealNode_F real_node, int reverse)
{
	int count = 0u;
	CAlgShareNode* tmp ;
	CAlgEnum rc ;
	if(reverse)
		tmp = real_node(l->tail);
	else
		tmp = real_node(l->head);

	while(tmp)
	{
		count ++;
		rc = it(tmp->curr_data);
		if(rc == CALG_ENUM_REPEAT)
			continue;
		else if(rc == CALG_ENUM_STOP)
			return count;
		if(reverse)
			tmp = real_node(tmp->prev);
		else
			tmp = real_node(tmp->next);
	}

	return count;
}


//////////////////////////////////////////////////////////////////////////
/**
  *            insert n to list after prev
  *@p_prev     previous position, link n to p_n->prev, 
  *            if p_prev is NULL , means add to head
  *@p_next     next position, link n to p_n->next, 
  *            if p_bext is NULL , means add to tail
  *@p_n        p_n = real_node(n)
  */
static inline void CAlgShareList_InsertPointer(CAlgShareList* l, CAlgShareNode*p_prev, CAlgShareNode*p_next, 
											   CAlgShareNode*p_n, int n)
{
	p_n->curr = n;
	if(p_prev)
	{
		p_prev->next = n;//p_n->curr;
		p_n->prev = p_prev->curr;
	}
	else
	{
		p_n->prev = ALG_SHARE_LIST_INVALID_POS;
		l->head = n;//p_n->curr;
	}

	if(p_next)
	{
		p_next->prev = n;//p_n->curr;
		p_n->next = p_next->curr;
	}
	else
	{
		p_n->next = ALG_SHARE_LIST_INVALID_POS;
		l->tail = n;//p_n->curr;
	}

	l->elem_count ++;
}

/**
  *     add n to list head
  *@f   function pointer methods
  *@l   the share list which n should add to
  *@n   make sure real_node_f(n) return valid pointer !!!
  *@ret return the tail position
  */
static inline int CAlgShareList_AddHead(CAlgShareList* l, int n, AlgShareList_RealNode_F real_node_f)
{
	CAlgShareList_InsertPointer(l, NULL, real_node_f(l->head), real_node_f(n), n);
	return l->head;
}

/**
  *     add n to list tail
  *@f   real node function methods
  *@l   the share list which n should add to
  *@n   make sure real_node_f(n) return valid pointer
  *@ret return the tail position
  */
static inline int CAlgShareList_AddTail(CAlgShareList* l, int n, AlgShareList_RealNode_F real_node_f)
{
	CAlgShareList_InsertPointer(l, real_node_f(l->tail), NULL, real_node_f(n), n);
	return l->tail;
}


static inline void CAlgShareList_Insert(CAlgShareList* l, int prev, int n, AlgShareList_RealNode_F real_node_f)
{
	CAlgShareNode* p_prev = real_node_f(prev);
	CAlgShareNode* p_next = p_prev ? real_node_f(p_prev->next) : NULL;
	CAlgShareList_InsertPointer(l, p_prev, p_next, real_node_f(n), n);
}

static inline int CAlgShareList_RemoveNodePointer(CAlgShareList* l, CAlgShareNode* prev, CAlgShareNode* next, CAlgShareNode* n)
{
	if(n->curr == l->head)
		l->head = n->next;
	if(n->curr == l->tail)
		l->tail = n->prev;
	if(prev)
		prev->next = n->next;
	if(next)
		next->prev = n->prev;

	l->elem_count --;

	return 0;
}

/**
  *     remove head node from list
  *@l   the share list which n should add to
  *@f   function pointer methods
  *@ret return the head node position
  */
static inline int CAlgShareList_RemoveHead(CAlgShareList_F f, CAlgShareList* l)
{
	int head = l->head;
	CAlgShareNode* curr = f.real_node_f(head);
	if(!curr) return ALG_SHARE_LIST_INVALID_POS;
	CAlgShareList_RemoveNodePointer(l, NULL, f.real_node_f(curr->next), curr);
	return head;
}

/**
  *     remove tail node from list
  *@l   the share list which n should add to
  *@f   function pointer methods
  *@ret return the head node position
  */
static inline int CAlgShareList_RemoveTail(CAlgShareList_F f, CAlgShareList* l)
{
	int tail = l->tail;
	CAlgShareNode* curr = f.real_node_f(tail);
	if(!curr) return ALG_SHARE_LIST_INVALID_POS;
	CAlgShareList_RemoveNodePointer(l, f.real_node_f(curr->prev), NULL, curr);
	//CAlgShareList_RemoveNode(l, l->tail, f.real_node_f);
	return tail;
}

#ifdef	__cplusplus
}
#endif

#endif
//end of file

单元测试：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include "CAlgList.h"
#include "CAlgShareList.h"

#define MAX_SHARE_NODE_ELEM   10000000
typedef struct {
	int a;
	int b;
}CAlgListNodeData;

static CAlgListNodeData* g_NodeDataPool = NULL;
static CAlgShareNode* g_CAlgNodes = NULL;
static CAlgShareList* g_CAlgList = NULL;

extern "C" static int TestAlgShareList_node_cmp(const void* left, const void* right, unsigned int size)
{
	CAlgListNodeData* l, *r;
	l = (CAlgListNodeData*)left;
	r = (CAlgListNodeData*)right;
	if (l->a != r->a) 
		return l->a - r->a;

	return l->b - r->b;
}


extern "C" CAlgShareNode* TestAlgShareList_RealNode_F(int pos)
{
	if(pos <0 || pos >=MAX_SHARE_NODE_ELEM) return NULL;
	return &g_CAlgNodes[pos];
}


static CAlgShareList_F g_ShareListF = {
	TestAlgShareList_RealNode_F, TestAlgShareList_node_cmp
};

extern "C" CAlgEnum TestAlgShareList_Enum(void* elem)
{
	CAlgListNodeData* e = (CAlgListNodeData*)elem;
	printf("%5d, a=%5d, b=%5d\n", e - g_NodeDataPool, e->a, e->b);
	return CALG_ENUM_NEXT;
}

extern "C" CAlgEnum TestAlgShareList_EnumNothing(void* elem)
{
	return CALG_ENUM_NEXT;
}

void TestAlgShareList_Init()
{
	g_NodeDataPool = (CAlgListNodeData*)malloc(sizeof(CAlgListNodeData)*MAX_SHARE_NODE_ELEM);
	g_CAlgNodes = (CAlgShareNode*)malloc(sizeof(CAlgShareNode)*MAX_SHARE_NODE_ELEM);
	g_CAlgList = (CAlgShareList*)malloc(sizeof(CAlgShareList));
	
	CAlgShareList_ReSet(g_CAlgList, sizeof(CAlgListNodeData));
}

void TestAlgShareList_Free()
{
	free(g_NodeDataPool);
	g_NodeDataPool = NULL;

	free(g_CAlgNodes);
	g_CAlgNodes = NULL;

	free(g_CAlgList);
	g_CAlgList = NULL;
}

void TestAlgShareList_AddAll_Pointer(int add_tail)
{
	CAlgShareNode* n = g_CAlgNodes;
	CAlgListNodeData* d = g_NodeDataPool;
	int i, pos;
	for(i=0; i<MAX_SHARE_NODE_ELEM; i++)
	{
		d->a = i+1;
		d->b = i+2;

		n[i].curr_data = (void*)d;
		if(add_tail)
			CAlgShareList_AddTail(g_CAlgList, i, g_ShareListF.real_node_f);
		else
			CAlgShareList_AddHead(g_CAlgList, i, g_ShareListF.real_node_f);

		d++;
		assert(g_CAlgList->elem_count == i +1);
	}

	i=0;
	pos = g_CAlgList->head;
	n = g_ShareListF.real_node_f(pos);
	do{
		if(pos == g_CAlgList->head)
		{
			assert(g_ShareListF.real_node_f(n->prev) == NULL);
		}
		if(pos == g_CAlgList->tail)
		{
			assert(g_ShareListF.real_node_f(n->next) == NULL);
		}

		d = (CAlgListNodeData*)n->curr_data;
		if(add_tail){
			assert(d->a == i+1);
			assert(d->b == i+2);
		}
		else
		{
			assert(d->a == MAX_SHARE_NODE_ELEM - i);
			assert(d->b == MAX_SHARE_NODE_ELEM - i +1);
		}

		pos++;
		i++;
	}while(n=TestAlgShareList_RealNode_F(n->next));
	assert(i == MAX_SHARE_NODE_ELEM);
	assert(g_CAlgList->elem_count == MAX_SHARE_NODE_ELEM);
}

void TestAlgShareList_RemoveHead()
{
	CAlgShareNode* n = g_CAlgNodes;
	CAlgListNodeData* d;
	int i;

	for(i=0; i<MAX_SHARE_NODE_ELEM; i++)
	{
		n = TestAlgShareList_RealNode_F(CAlgShareList_RemoveHead(g_ShareListF, g_CAlgList));
		d = (CAlgListNodeData*)n->curr_data;
		assert(d->a == i+1);
		assert(d->b == i+2);
		assert(g_CAlgList->elem_count == MAX_SHARE_NODE_ELEM - i -1);
	}

	assert(g_CAlgList->head == ALG_SHARE_LIST_INVALID_POS);
	assert(g_CAlgList->tail == ALG_SHARE_LIST_INVALID_POS);
}

void TestAlgShareList_RemoveTail()
{
	CAlgShareNode* n = g_CAlgNodes;
	CAlgListNodeData* d;
	int i;

	for(i=0; i<MAX_SHARE_NODE_ELEM; i++)
	{
		n = TestAlgShareList_RealNode_F(CAlgShareList_RemoveTail(g_ShareListF, g_CAlgList));
		d = (CAlgListNodeData*)n->curr_data;
		assert(d->a == i+1);
		assert(d->b == i+2);
		assert(g_CAlgList->elem_count == MAX_SHARE_NODE_ELEM - i - 1);
	}

	assert(g_CAlgList->head == ALG_SHARE_LIST_INVALID_POS);
	assert(g_CAlgList->tail == ALG_SHARE_LIST_INVALID_POS);
}

void TestAlgShareList_Insert_Remove()
{
	const int node_num = 10;
	CAlgShareNode* n = g_CAlgNodes;
	CAlgListNodeData* d = g_NodeDataPool;
	int i, pos;
	CAlgListNodeData tmp;

	//list empty find fail
	for(i=0; i<node_num/2; i++)
	{
		d = &g_NodeDataPool[node_num/2+i];
		tmp.a = i+1;
		tmp.b = i+2;

		n = TestAlgShareList_RealNode_F(CAlgShareList_Find(g_ShareListF, g_CAlgList, &tmp));
		assert(n == NULL);
	}

	//list empty remove fail
	assert (NULL == TestAlgShareList_RealNode_F(CAlgShareList_RemoveTail(g_ShareListF, g_CAlgList)));
	assert (NULL == TestAlgShareList_RealNode_F(CAlgShareList_RemoveHead(g_ShareListF, g_CAlgList)));
	assert (g_CAlgList->elem_count == 0);


	//add node_num/2 nodes
	for(i=0; i<node_num/2; i++)
	{
		d = &g_NodeDataPool[i];
		d->a = i+1;
		d->b = i+2;

		g_CAlgNodes[i].curr_data = (void*)d;
		CAlgShareList_AddTail(g_CAlgList, i, g_ShareListF.real_node_f);

		assert(g_CAlgList->elem_count == i +1);
	}

	assert(g_CAlgList->elem_count == node_num/2);
	printf("add 5 nodes using CAlgShareList_AddTail()\n");
	CAlgShareList_Enum(g_CAlgList,TestAlgShareList_Enum,g_ShareListF.real_node_f, 0);

	//insert node_num/2 nodes into the list
	//1,      2,      3,      4,      5 
	//1,1001, 2,1002, 3,1003, 4,1004, 5,1005
	for(i=0; i<node_num/2; i++)
	{
		d = &g_NodeDataPool[node_num/2+i];
		tmp.a = i+1;
		tmp.b = i+2;

		pos = CAlgShareList_Find(g_ShareListF, g_CAlgList, &tmp);
		n = g_ShareListF.real_node_f(pos);
		assert(n != NULL);

		d->a = 1000+i+1;
		d->b = 2000+i+1;

		g_CAlgNodes[node_num/2+i].curr_data = d;

		CAlgShareList_Insert(g_CAlgList, pos, node_num/2+i, g_ShareListF.real_node_f);
	}
	printf("\nafter add 5 nodes using CAlgList_Insert()\n");
	CAlgShareList_Enum(g_CAlgList,TestAlgShareList_Enum,g_ShareListF.real_node_f,0);

	i=0;
	n = g_ShareListF.real_node_f(g_CAlgList->head);
	do{
		if(n == g_ShareListF.real_node_f(g_CAlgList->head))
		{
			assert(n->prev == ALG_SHARE_LIST_INVALID_POS);
		}
		if(n == g_ShareListF.real_node_f(g_CAlgList->tail))
		{
			assert(n->next == ALG_SHARE_LIST_INVALID_POS);
		}

		d = (CAlgListNodeData*)n->curr_data;
		if((i % 2) == 0)
		{
			assert(d->a == i/2+1);
			assert(d->b == i/2+2);
		}
		else
		{
			assert(d->a == 1000+i/2+1);
			assert(d->b == 2000+i/2+1);
		}

		i++;
	}while(n=g_ShareListF.real_node_f(n->next));
	assert(i == node_num);
	assert(g_CAlgList->elem_count == node_num);

	//remove node 1001,1002,1003,1004,1005
	//before 1,1001, 2,1002, 3,1003, 4,1004, 5,1005
	//after  1,      2,      3,      4,      5 
	for(i=0; i<node_num/2; i++)
	{
		tmp.a = 1000+i+1;
		tmp.b = 2000+i+1;
		pos = CAlgShareList_Find(g_ShareListF, g_CAlgList, &tmp);
		n = g_ShareListF.real_node_f(pos);
		assert(n != NULL);
		assert(0 == CAlgShareList_RemoveNode( g_CAlgList, pos, g_ShareListF.real_node_f));
	}
	printf("\nafter remove 5 nodes using CAlgList_RemoveNode\n");
	CAlgShareList_Enum(g_CAlgList,TestAlgShareList_Enum,g_ShareListF.real_node_f,0);
	assert(g_CAlgList->elem_count == node_num/2);

	i=0;
	n = g_ShareListF.real_node_f(g_CAlgList->head);
	do{
		if(n == g_ShareListF.real_node_f(g_CAlgList->head))
		{
			assert(n->prev == ALG_SHARE_LIST_INVALID_POS);
		}
		if(n == g_ShareListF.real_node_f(g_CAlgList->tail))
		{
			assert(n->next == ALG_SHARE_LIST_INVALID_POS);
		}

		d = (CAlgListNodeData*)n->curr_data;
		assert(d->a == i+1);
		assert(d->b == i+2);

		i++;
	}while(n=g_ShareListF.real_node_f(n->next));

	//remove head 1
	//after  2,      3,      4,      5 
	pos = CAlgShareList_RemoveHead(g_ShareListF, g_CAlgList);
	n = g_ShareListF.real_node_f(pos);
	assert(n != NULL && g_CAlgList->elem_count > 2);
	d = (CAlgListNodeData*)n->curr_data;
	assert(d->a == 1);
	assert(d->b == 2);

	//remove tail 5
	//after  2,      3,      4,      
	pos = CAlgShareList_RemoveTail(g_ShareListF, g_CAlgList);
	n = g_ShareListF.real_node_f(pos);
	assert(n != NULL && g_CAlgList->elem_count > 2);
	d = (CAlgListNodeData*)n->curr_data;
	assert(d->a == 5);
	assert(d->b == 6);

	assert(g_CAlgList->elem_count == 3);
	i=1;
	n = g_ShareListF.real_node_f(g_CAlgList->head);
	do{
		if(n == g_ShareListF.real_node_f(g_CAlgList->head))
		{
			assert(n->prev == ALG_SHARE_LIST_INVALID_POS);
		}
		if(n == g_ShareListF.real_node_f(g_CAlgList->tail))
		{
			assert(n->next == ALG_SHARE_LIST_INVALID_POS);
		}

		d = (CAlgListNodeData*)n->curr_data;
		assert(d->a == i+1);
		assert(d->b == i+2);

		i++;
	}while(n=g_ShareListF.real_node_f(n->next));
	assert(i == 4);
	printf("\nafter CAlgShareList_RemoveHead && CAlgShareList_RemoveTail\n");
	CAlgShareList_Enum(g_CAlgList,TestAlgShareList_Enum,g_ShareListF.real_node_f, 0);

	//remove all
	while(g_ShareListF.real_node_f(CAlgShareList_RemoveHead(g_ShareListF, g_CAlgList)))
		printf("remove...\n");

	assert(g_CAlgList->elem_count == 0);

}


#include <Windows.h>
void TestAlgShareList_Run()
{
	SYSTEMTIME st1, st2;
	FILETIME ft1, ft2; //100ns
	CAlgShareNode* n;
	int i;
	TestAlgShareList_Init();

	//test add head
	GetLocalTime(&st1);
	TestAlgShareList_AddAll_Pointer(1);
	GetLocalTime(&st2);
	SystemTimeToFileTime(&st1, &ft1);
	SystemTimeToFileTime(&st2, &ft2);
	printf("%s using %u.%03ums to add head %d nodes %02u:%02u:%02u.%03u - %02u:%02u:%02u.%03u\n", 
		__FILE__,
		(ft2.dwLowDateTime-ft1.dwLowDateTime)/10000,
		(ft2.dwLowDateTime-ft1.dwLowDateTime)/10, MAX_SHARE_NODE_ELEM,
		st1.wHour,st1.wMinute,st1.wSecond,st1.wMilliseconds,
		st2.wHour,st2.wMinute,st2.wSecond,st2.wMilliseconds);

	//iterate all elements
	GetLocalTime(&st1);
	CAlgShareList_Enum(g_CAlgList,TestAlgShareList_EnumNothing,g_ShareListF.real_node_f,0);
	GetLocalTime(&st2);
	SystemTimeToFileTime(&st1, &ft1);
	SystemTimeToFileTime(&st2, &ft2);
	printf("%s using %u.%03ums to iterate %d nodes %02u:%02u:%02u.%03u - %02u:%02u:%02u.%03u\n", 
		__FILE__,
		(ft2.dwLowDateTime-ft1.dwLowDateTime)/10000,
		(ft2.dwLowDateTime-ft1.dwLowDateTime)/10, MAX_SHARE_NODE_ELEM,
		st1.wHour,st1.wMinute,st1.wSecond,st1.wMilliseconds,
		st2.wHour,st2.wMinute,st2.wSecond,st2.wMilliseconds);

	i=0;
	GetLocalTime(&st1);
	ALG_SHARE_LIST_FOREACH(g_CAlgList, n, g_ShareListF);
	i++;
	ALG_SHARE_LIST_FOREACH_END();
	GetLocalTime(&st2);
	SystemTimeToFileTime(&st1, &ft1);
	SystemTimeToFileTime(&st2, &ft2);
	printf("%s using %u.%03ums to iterate %d nodes %02u:%02u:%02u.%03u - %02u:%02u:%02u.%03u\n", 
		__FILE__,
		(ft2.dwLowDateTime-ft1.dwLowDateTime)/10000,
		(ft2.dwLowDateTime-ft1.dwLowDateTime)/10, i,
		st1.wHour,st1.wMinute,st1.wSecond,st1.wMilliseconds,
		st2.wHour,st2.wMinute,st2.wSecond,st2.wMilliseconds);

	//CAlgList_Enum(CAlgList_GetAlgFunc(),g_CAlgList,TestAlgList_Enum,0);
	//remove all 
	TestAlgShareList_RemoveHead();

	//test add tail
	GetLocalTime(&st1);
	TestAlgShareList_AddAll_Pointer(0);
	GetLocalTime(&st2);
	SystemTimeToFileTime(&st1, &ft1);
	SystemTimeToFileTime(&st2, &ft2);
	printf("%s using %u.%03ums to add tail %d nodes %02u:%02u:%02u.%03u - %02u:%02u:%02u.%03u\n", 
		__FILE__,
		(ft2.dwLowDateTime-ft1.dwLowDateTime)/10000,
		(ft2.dwLowDateTime-ft1.dwLowDateTime)/10, MAX_SHARE_NODE_ELEM,
		st1.wHour,st1.wMinute,st1.wSecond,st1.wMilliseconds,
		st2.wHour,st2.wMinute,st2.wSecond,st2.wMilliseconds);
	//CAlgList_Enum(CAlgList_GetAlgFunc(),g_CAlgList,TestAlgList_Enum,1);
	TestAlgShareList_RemoveTail();

	//test find and insert
	CAlgShareList_ReSet(g_CAlgList, sizeof(CAlgListNodeData));
	TestAlgShareList_Insert_Remove();

	TestAlgShareList_Free();
}