整理原始报文收发逻辑，支持与协议栈系统收发包。

29 files changed, 826 insertions, 1432 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ff4d660..86536c0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -41,7 +41,7 @@ add_subdirectory(${CMAKE_SOURCE_DIR}/stack)
 add_subdirectory(${CMAKE_SOURCE_DIR}/service)
 add_subdirectory(${CMAKE_SOURCE_DIR}/slave)
 add_subdirectory(${CMAKE_SOURCE_DIR}/pag)
-#add_subdirectory(${CMAKE_SOURCE_DIR}/examples)
+add_subdirectory(${CMAKE_SOURCE_DIR}/examples)
 add_subdirectory(${CMAKE_SOURCE_DIR}/tools)
 add_subdirectory(${CMAKE_SOURCE_DIR}/test)
 add_subdirectory(${CMAKE_SOURCE_DIR}/conf)
diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index 3a64c8c..288f41e 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -6,7 +6,7 @@ include_directories(${DPDK_INCLUDE_DIR})
 

 add_definitions(${DPDK_C_PREDEFINED})

 include_directories(include)

-add_library(core src/core.c src/device.c src/vnode.c src/mrbuf.c src/vman.c src/stat.c src/rtdev.c)

+add_library(core src/core.c src/device.c src/vnode.c src/stat.c src/rtdev.c)

 target_link_libraries(core MESA_prof_load_static mruntime)

 target_link_libraries(core rt pthread dl)

 target_include_directories(core INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include/")
\ No newline at end of file
diff --git a/core/include/mr_buffer.h b/core/include/mr_buffer.h
new file mode 100644
index 0000000..8ad34f7
--- /dev/null
+++ b/core/include/mr_buffer.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <rte_mempool.h>
+
+struct mrb_pool_t
+{
+	unsigned int pool_num;
+	unsigned int total_ctrl_zone_size;
+	struct rte_mempool ** mr_pkt_pool;
+	struct rte_mempool ** mr_indirect_pool;
+};
+
+enum MRB_para_type_t
+{
+	MRB_PARA_DATA_SIZE,
+	MRB_PARA_CACHE_SIZE,
+	MRB_PARA_USR_POOL_SIZE,
+};
+
+struct mrb_pool_t* MRB_pool_handle_create(void);
+int MRB_set_pool_handle(struct mrb_pool_t *handle, enum MRB_para_type_t type, uint32_t value);
+int MRB_pool_produce(struct mrb_pool_t* handle, unsigned int socket_id, unsigned int pool_size);
+int MRB_ctrlzone_register(struct mrb_pool_t * handle, uint8_t id, uint8_t size);
+
+#ifdef __cplusplus
+}
+#endif
\ No newline at end of file
diff --git a/core/include/mr_core.h b/core/include/mr_core.h
index 0b33e12..7d96417 100644
--- a/core/include/mr_core.h
+++ b/core/include/mr_core.h
@@ -6,6 +6,7 @@ struct devman_ctx;
 struct stat_ctx;
 struct vnodeman_ctx;
 struct mrb_pool_t;
+struct rtdev_desc_list;
 
 // Core��ʵ���ṹ�壨ȫ�֣�
 struct mr_core_instance
@@ -15,6 +16,10 @@ struct mr_core_instance
 	struct stat_ctx * stat_ctx;
 	struct vnodeman_ctx * vnodeman_ctx;
 	struct mrb_pool_t * mrb_pool_handle;
+
+	/* ����ʱ�豸�б� */
+	struct rtdev_desc_list * rtdev_list;
+	unsigned int nr_rtdev;
 };
 
 struct mr_core_config
diff --git a/core/include/mr_mrbuf.h b/core/include/mr_mrbuf.h
deleted file mode 100644
index df14e0d..0000000
--- a/core/include/mr_mrbuf.h
+++ /dev/null
@@ -1,73 +0,0 @@
-#ifndef _MARSIO_BUF_INTERNAL_H_

-#define _MARSIO_BUF_INTERNAL_H_ 1

-

-/*

-	marsio mbuf internal definition.

-*/

-

-#ifdef __cplusplus

-extern "C" {

-#endif

-#include <stdint.h>

-#include "mr_common.h"

-

-#define MR_BASE_ON_DPDK 		1

-

-#ifdef MR_BASE_ON_DPDK	/* ����Intel-DPDK rte_mbuf��װ */

-#include <rte_mempool.h>

-#include <rte_mbuf.h>

-#include <rte_atomic.h>

-#endif

-

-#define MAX_CZ_NUM		(8)

-

-struct marsio_pri_t{

-    struct rte_mbuf *pkt_next; /* ���mbuf�ṹ����, ��ʾ��ͬ���ݰ�������, ����ͬ��mbuf��next, ��һ�����Ķ��segment */

-    void *ctrlzone[MAX_CZ_NUM];

-};

-

-

-struct mrbuf_ctx

-{

-	uint32_t mempool_block_num;

-	uint32_t mempool_dataroom_size;

-	uint32_t mempool_priv_size;

-

-	rte_atomic32_t mr_ctrl_zone_id;

-	int32_t mr_buf_pool_num;

-	struct rte_mempool **mr_buf_pool;

-};

-	

-typedef struct{

-	uint32_t lcore_id;

-	uint32_t __pad1;

-	uint64_t alloc_mbuf_num;

-	uint64_t __pad2[6];

-}mr_buf_stat_t; /* 64Byte cache alignment */

-

-#define MRBUF_PROC_MAGIC		(0xA1B2C3D4E5F65AA5)	

-typedef struct{

-	uint64_t magic;

-	mr_buf_stat_t mr_buf_stat;

-}mr_process_ctx_t;

-

-struct rte_mempool * mrbuf_get_mempool(socket_id_t socket_id);

-

-#ifdef MR_BASE_ON_PCAP

-

-/* TODO others */

-

-typedef struct{

-	void *baseaddr;

-}marsio_buff_t;

-

-#endif

-

-

-

-#ifdef __cplusplus

-}

-#endif

-

-#endif

-

diff --git a/core/include/mr_rtdev.h b/core/include/mr_rtdev.h
index 0dda88c..66c242c 100644
--- a/core/include/mr_rtdev.h
+++ b/core/include/mr_rtdev.h
@@ -8,40 +8,62 @@
 */
 
 
+#include <rte_mempool.h>
+#include <mr_core.h>
+#include <mr_vnode.h>
 #include <mr_vman.h>
 #include <mr_common.h>
+#include <sys/queue.h>
 
-struct mr_rtdev_stream
+struct rtdev_app_desc
 {
+	TAILQ_ENTRY(rtdev_app_desc) next;
+	struct rtdev_desc * dev_desc;
+	struct vnode_ops ops;
+	
 	char symbol[MR_SYMBOL_MAX];
-	struct vnodeman_attach_desc * rxd;
-	struct vnodeman_attach_desc * txd;
-	struct vnodeman_attach_desc * fasttxd;
+	unsigned int nr_rx_stream;
+	unsigned int nr_tx_stream;
+
+	struct vnode_cons * vnode_cons_rx;
+	struct vnode_prod * vnode_prod_tx;
+	struct vnode_prod * vnode_prod_ftx;
 };
 
-// ����һ������ʱ�����豸
-int rt_device_serv_create(const char * devsym, const char * servsym, unsigned int nr_serv_thread,
-	unsigned int sz_tunnel, unsigned int sz_buffer);
+TAILQ_HEAD(rtdev_app_desc_list, rtdev_app_desc);
 
-// ����һ������ʱ�����豸
-int rt_device_serv_destory(const char * devsym);
+struct rtdev_desc
+{
+	TAILQ_ENTRY(rtdev_desc) next;
 
-// ���豸��ͨ����Slave������ʹ��
-int rt_device_open(const char * devsym, const char * appsym,
-	unsigned int nr_rxstream, unsigned int nr_txstream);
+	char symbol[MR_SYMBOL_MAX];
+	unsigned int nr_serv_stream;
 
-// ���豸����ÿ���̵߳���һ�Σ���ȡ��ǰ�̵߳������������������ʹ�ã�
-struct mr_rtdev_stream * rt_dev_serv_open_stream(const char * devsym,
-	const char * servsym);
+	struct vnode_ops ops;
+	
+	struct vnode * vnode_rx;
+	struct vnode * vnode_tx;
+	struct vnode * vnode_ftx;
 
-#define RTDEV_FLAGS_OPEN_STREAM_RX	( 1UL << 0 )
-#define RTDEV_FLAGS_OPEN_STREAM_TX	( 1UL << 1 )
-#define RTDEV_FLAGS_OPEN_STREAM_ALL	( RTDEV_FLAGS_OPEN_STREAM_RX | RTDEV_FLAGS_OPEN_STREAM_TX )
+	struct vnode_prod * vnode_prod_rx;
+	struct vnode_cons * vnode_cons_tx;
+	struct vnode_cons * vnode_cons_ftx;
 
-// ���豸����ÿ���̵߳���һ�Σ���ȡ��ǰ�̵߳���������
-struct mr_rtdev_stream * rt_dev_open_stream(const char * devsym,
-	const char * appsym, flags_t flags);
+	rte_rwlock_t app_desc_lock;
+	struct rtdev_app_desc_list app_desc_list;
+};
 
-int rt_dev_stream_close(struct mr_rtdev_stream * stream);
+TAILQ_HEAD(rtdev_desc_list, rtdev_desc);
+
+// ����һ������ʱ�����豸
+struct rtdev_desc * mr_rtdev_create(struct mr_core_instance * instance, const char * devsym,
+	struct rte_mempool * pool, unsigned int nr_serv_thread, unsigned int sz_tunnel, unsigned int sz_buffer);
+
+// ����һ������ʱ�����豸
+int mr_rt_device_destory(struct rtdev_desc * desc);
+
+// ���豸��ͨ����Slave������ʹ��
+struct rtdev_app_desc * mr_rt_device_open(struct mr_core_instance * instance, const char * devsym, const char * appsym,
+	unsigned int nr_rxstream, unsigned int nr_txstream);
 
-int rt_device_close(const char * devsym, const char * appsym);
\ No newline at end of file
+int mr_rt_device_close(struct rtdev_app_desc * desc);
\ No newline at end of file
diff --git a/core/include/mr_vnode.h b/core/include/mr_vnode.h
index e6fc8cd..3723ef1 100644
--- a/core/include/mr_vnode.h
+++ b/core/include/mr_vnode.h
@@ -6,6 +6,7 @@ extern "C" {
 
 #include <mr_common.h>
 #include <sys/queue.h>
+#include <rte_memory.h>
 
 #if MR_LIBVNODE_OPT_THREAD_SAFE
 #include <rte_rwlock.h>
@@ -37,16 +38,16 @@ TAILQ_HEAD(tunnel_block_list, tunnel_block_list_item);
 
 struct vnode_cons_stat
 {
-	uint64_t object_enqueue;
-	uint64_t object_drop;
+	rte_atomic64_t on_line;
+	rte_atomic64_t recieved;
+	rte_atomic64_t missed;
 } __rte_cache_aligned;
 
 struct vnode_prod_stat
 {
-	uint64_t object_enqueue;
-	uint64_t object_dequeue;
-	uint64_t object_drop_by_app;
-	uint64_t object_drop_by_dup;
+	rte_atomic64_t on_line;
+	rte_atomic64_t sent;
+	rte_atomic64_t missed;
 } __rte_cache_aligned;
 
 /* Virtual Data-Node Consumer Structure */
@@ -60,7 +61,7 @@ struct vnode_cons
 	struct tunnel_block_list block_list;
 	unsigned int nr_block;
 	unsigned int cur_attach;
-	struct vnode_cons_stat stat[MR_GSID_MAX];
+	struct vnode_cons_stat stat[MR_SID_MAX];
 };
 
 /* Virtual Data-Node Producer Structure */
@@ -122,10 +123,15 @@ struct vnode
 
 struct vnode_ops
 {
+	/* Pool */
+	void * pool_new_object;
+	/* Pool */
+	void * pool_dup_object;
+	
 	/* Object Operation Functions */
-	void *(*op_object_new)();
+	void *(*op_object_new)(void * pool);
 	void(*op_object_delete)(void * object);
-	void *(*op_object_dup)(void * object);
+	void *(*op_object_dup)(void * object, void * pool);
 };
 
 struct vnode * vnode_create(const char * sym, struct vnode_ops * ops,
diff --git a/core/src/Mr_buffer.c b/core/src/Mr_buffer.c
deleted file mode 100644
index b237301..0000000
--- a/core/src/Mr_buffer.c
+++ /dev/null
@@ -1,313 +0,0 @@
-/******************************************************************
-  * DPDK rte_mbuf wrap.
-  * Author: [email protected]
-  * Date: 2016-11-18
-  ******************************************************************/
-
-#include <stdio.h>
-#include <stdint.h>
-#include <string.h>
-#include <unistd.h>
-#include <assert.h>
-
-#include <mr_buffer.h>
-#include <mr_runtime.h>
-#include <mr_core.h>
-
-#include <rte_malloc.h>
-#include <rte_mbuf.h>
-#include <rte_common.h>
-
-
-#define	MRB_MAX_CTRLZONE_NUM	16
-
-struct mrb_zone_idx_t
-{
-	uint8_t offset;
-	uint8_t size;
-};
-struct mrb_priv_zone_t
-{
-	struct rte_mempool * next;
-	uint8_t cz_num;
-	struct mrb_zone_idx_t idx[0];
-}__rte_packed;
-
-struct whole_mrb_pool_t
-{
-	struct mrb_pool_t external;	//"external" must be the first member of this struct
-	struct rte_mempool * usr_pkt_pool;
-	struct rte_mempool * usr_indirect_pool;
-
-	unsigned int usr_pool_size;
-	unsigned int total_ctrl_zone_size;
-	unsigned int data_size;
-	uint8_t ctrlzone_num;
-	struct mrb_zone_idx_t ctrlzone[MRB_MAX_CTRLZONE_NUM];
-
-};
- 
-#define mrbuf_priv(m)	((struct mrb_priv_zone_t*)((char*)m+sizeof(struct rte_mbuf)))
-#define	mrbuf_cz(m,k)	(&(mrbuf_priv(m)->idx[k]))
-#define mrbuf_cz_data(m,k) ((void*)((char*)mrbuf_priv(m)+mrbuf_cz(m,k)->offset))
-#define mrbuf_cz_num(m)	(mrbuf_priv(m)->cz_num)
-
-
-
-void set_element_ctrlzone(__attribute__((unused))struct rte_mempool *mp,
-							void *opaque, 
-							void *obj,
-							__attribute__((unused)) unsigned obj_idx)
-{
-	struct whole_mrb_pool_t *_handle=(struct whole_mrb_pool_t *)opaque;
-	struct mrb_priv_zone_t* private=mrbuf_priv(obj);
-	private->cz_num=_handle->ctrlzone_num;
-	private->next=NULL;
-	memcpy(private->idx,_handle->ctrlzone,sizeof(struct mrb_zone_idx_t)*_handle->ctrlzone_num);
-	return;
-}
-void* MRB_create_pool_handle(void)
-{
-	struct mrb_pool_t *handle=rte_calloc(sizeof(struct mrb_pool_t),1);
-	handle->pool_num=0;
-	handle->total_ctrl_zone_size=sizeof(struct mrb_priv_zone_t);
-	return handle;
-}
-int MRB_set_pool_handle(struct mrb_pool_t *handle,enum MRB_para_type_t type,uint32_t value)
-{
-	struct whole_mrb_pool_t *_handle=(struct whole_mrb_pool_t *)handle;
-
-	switch(type)
-	{
-		case MRB_PARA_DATA_SIZE:
-			_handle->data_size=value;
-			break;
-		case MRB_PARA_USR_POOL_SIZE:
-			_handle->usr_pool_size=value;
-			break;
-		default:
-			return -1;
-			break;
-	}
-	return 0;
-}
-int MRB_pool_produce(struct mrb_pool_t* handle,unsigned int socket_id,unsigned int pool_size)
-{
-	struct whole_mrb_pool_t *_handle=(struct whole_mrb_pool_t *)handle;
-	char pool_name[64]={0};
-	uint32_t ret;
-	int i=_handle->external.pool_num;
-	if(_handle->usr_pkt_pool==NULL)
-	{
-		snprintf(pool_name,sizeof(pool_name),"mrb_usr_pkt_pool");
-		handle->usr_pkt_pool=rte_pktmbuf_pool_create(
-									pool_name,
-									_handle->usr_pool_size, 
-									256, //cache size
-									_handle->total_ctrl_zone_size,//private size
-									_handle->data_size,
-									socket_id);
-	}
-	if(_handle->usr_indirect_pool==NULL)
-	{
-		snprintf(pool_name,sizeof(pool_name),"mrb_usr_indirect_pool");
-		handle->usr_pkt_pool=rte_pktmbuf_pool_create(
-									pool_name,
-									_handle->usr_pool_size, 
-									256, //cache size
-									_handle->total_ctrl_zone_size,//private size
-									_handle->data_size,
-									socket_id);
-	}
-	handle->mr_pkt_pool=(struct rte_mempool **)rte_realloc(handle->mr_pkt_pool,
-															sizeof(struct rte_mempool*)*(i+1),
-															0);
-	handle->mr_indirect_pool=(struct rte_mempool **)rte_realloc(handle->mr_indirect_pool,
-															sizeof(struct rte_mempool*)*(i+1),
-															0);
-	snprintf(pool_name,sizeof(pool_name),"mrb_pkt_pool_%d",i);
-	handle->mr_pkt_pool[i]=rte_pktmbuf_pool_create(
-										pool_name,
-										pool_size, 
-										256, //cache size
-										_handle->total_ctrl_zone_size,//private size
-										_handle->data_size,
-										socket_id);
-	assert(handle->mr_pkt_pool[i]!=NULL);
-	ret=rte_mempool_obj_iter(handle->mr_pkt_pool[i],set_element_ctrlzone, _handle);
-	assert(ret==_handle->usr_pool_size);
-
-	
-	snprintf(pool_name,sizeof(pool_name),"mrb_indirect_pool_%d",i);
-	handle->mr_indirect_pool[i]=rte_pktmbuf_pool_create(
-										pool_name,
-										pool_size, 
-										256, //cache size
-										_handle->total_ctrl_zone_size,//private size
-										0,
-										socket_id);
-	assert(handle->mr_indirect_pool[i]!=0);
-	ret=rte_mempool_obj_iter(handle->mr_indirect_pool[i],set_element_ctrlzone, _handle);
-	assert(ret==_handle->usr_pool_size);
-	handle->pool_num++;
-	return i;
-}
-int MRB_ctrlzone_register(struct mrb_pool_t * handle,uint8_t id,uint8_t size)
-{
-	struct whole_mrb_pool_t *_handle=(struct whole_mrb_pool_t *)handle;
-	int i=0;
-	_handle->ctrlzone_num++;
-	if(_handle->ctrlzone_num<=MRB_MAX_CTRLZONE_NUM)
-	{
-		return -1;
-	}
-	if(_handle->ctrlzone[id].size!=0)
-	{
-		return -1;
-	}
-	_handle->ctrlzone[id].size=size;
-	_handle->ctrlzone[id].offset=_handle->total_ctrl_zone_size;
-	_handle->total_ctrl_zone_size+=(size+sizeof(struct mrb_zone_idx_t));
-	return 0;
-}
-void *marsio_buff_ctrlzone(marsio_buff_t *mr_buff,uint8_t id)
-{
-	struct mrb_zone_idx_t* cz=mrbuf_cz(mr_buff, id);
-	assert(id<mrbuf_cz_num(mr_buff));
-	return mrbuf_cz_data(mr_buff, id);
-}
-void *marsio_buff_ctrlzone_data(marsio_buff_t *mr_buff,uint8_t id,uint8_t *size)
-{
-	struct mrb_zone_idx_t* cz=mrbuf_cz(mr_buff, id);
-	assert(id<mrbuf_cz_num(mr_buff));
-	*size=cz->size;
-	return mrbuf_cz_data(mr_buff, id);
-}
-void marsio_buff_ctrlzone_set(marsio_buff_t *mr_buff,uint8_t id,void* ptr_data,uint8_t size)
-{
-	struct mrb_zone_idx_t* cz=mrbuf_cz(mr_buff, id);
-	assert(id<mrbuf_cz_num(mr_buff));
-	assert(size<=cz->size);
-	memcpy(mrbuf_cz_data(mr_buff, id),ptr_data,size);
-	return;
-}
-int marsio_buff_malloc(marsio_buff_t *marsio_buff[], 
-						unsigned int nb_buff,
-						__attribute__((unused))unsigned int flags,
-						__attribute__((unused))int thread_seq)
-{
-	struct mr_core_instance *this_core=NULL;
-	struct whole_mrb_pool_t *_handle=NULL;
-	int i=0;
-	this_core=mr_core_default_instance_get();
-	_handle=(struct whole_mrb_pool_t *)this_core->mrb_pool_handle;
-	for(i=0;i<nb_buff;i++)
-	{
-		marsio_buff[i]=rte_pktmbuf_alloc(_handle->usr_pkt_pool);
-		if(marsio_buff[i]==NULL)
-		{
-			break;
-		}
-	}
-	return i;
-}
-void marsio_buff_free(marsio_buff_t *marsio_buff[], unsigned int nb_buff)
-{
-	int i=0;
-	for(i=0;i<nb_buff;i++)
-	{
-		mrbuf_priv(marsio_buff[i])->next=NULL;
-		rte_pktmbuf_free((struct rte_mbuf *)marsio_buff[i]);
-	}
-	return;
-}
-
-
-void marsio_buff_append_pkt(marsio_buff_t *previous, marsio_buff_t *next)
-{
-	mrbuf_priv(previous)->next=next;
-}
-void marsio_buff_append_seg(marsio_buff_t *previous, marsio_buff_t *next)
-{
-	((struct rte_mbuf *)previous)->next=next;
-}
-marsio_buff_t *marsio_buff_getnext_seg(marsio_buff_t *m)
-{
-	return (marsio_buff_t *)(((struct rte_mbuf*)m)->next);
-}
-marsio_buff_t *marsio_buff_getnext_pkt(marsio_buff_t *m)
-{
-	return mrbuf_priv(m)->next;
-}
-
-void marsio_buff_reset(marsio_buff_t *m)
-{
-	struct mrb_priv_zone_t* priv_zone=mrbuf_priv(m);
-	struct mrb_zone_idx_t* cz_first=NULL,*cz_last=NULL;
-	
-	rte_pktmbuf_reset((struct rte_mbuf *)m);
-	priv_zone->next=NULL;
-	if(mrbuf_cz_num(m)>0)
-	{
-		cz_first=mrbuf_cz(m, 0);
-		cz_last=mrbuf_cz(m, mrbuf_cz_num(m)-1);
-		memset(mrbuf_cz_data(m, 0),0,cz_last->offset+cz_last->size-cz_first->offset);
-	}
-	return;
-}
-
-char *marsio_buff_mtod(marsio_buff_t *m)
-{
-	return rte_pktmbuf_mtod((struct rte_mbuf *)m, char *);
-}
-
-uint32_t marsio_buff_buflen(marsio_buff_t *m)
-{
-	return rte_pktmbuf_pkt_len((struct rte_mbuf *)m);
-}
-uint32_t marsio_buff_datalen(marsio_buff_t *m)
-{
-	return rte_pktmbuf_data_len((struct rte_mbuf *)m);
-}
-
-char *marsio_buff_prepend(marsio_buff_t *m, uint16_t len)
-{
-	return rte_pktmbuf_prepend((struct rte_mbuf *)m, len);
-}
-
-char *marsio_buff_append(marsio_buff_t *m, uint16_t len)
-{
-	return rte_pktmbuf_append((struct rte_mbuf *)m, len);
-}
-
-char *marsio_buff_adj(marsio_buff_t *m, uint16_t len)
-{
-	return rte_pktmbuf_adj((struct rte_mbuf *)m, len);
-}
-
-int marsio_buff_trim(marsio_buff_t *m, uint16_t len)
-{
-	return rte_pktmbuf_trim((struct rte_mbuf *)m, len);
-}
-
-uint16_t marsio_buff_headroom(const marsio_buff_t *m)
-{
-	return rte_pktmbuf_headroom((const struct rte_mbuf *)m);
-}
-
-uint16_t marsio_buff_tailroom(const marsio_buff_t *m)
-{
-	return rte_pktmbuf_tailroom((const struct rte_mbuf *)m);
-}
-uint32_t marsio_get_pkt_type(marsio_buff_t *m)
-{
-	return ((struct rte_mbuf *)m)->packet_type;
-}
-
-marsio_buff_t *marsio_buff_dup(marsio_buff_t *m)
-{
-	mr_process_ctx_t *proc_ctx;
-	rte_mbuf_refcnt_update((struct rte_mbuf *)m, 1);
-	return m;
-}
-
diff --git a/core/src/buffer.c b/core/src/buffer.c
new file mode 100644
index 0000000..2d913a9
--- /dev/null
+++ b/core/src/buffer.c
@@ -0,0 +1,344 @@
+/******************************************************************
+  * DPDK rte_mbuf wrap.
+  * Author: [email protected]
+  * Date: 2016-11-18
+  ******************************************************************/
+
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <assert.h>
+
+#include <mr_buffer.h>
+#include <mr_runtime.h>
+#include <mr_core.h>
+
+#include <rte_malloc.h>
+#include <rte_mbuf.h>
+#include <rte_common.h>
+
+
+#define	MRB_MAX_CTRLZONE_NUM	16
+
+struct mrb_zone_idx_t
+{
+	uint8_t offset;
+	uint8_t size;
+};
+
+struct mrb_priv_zone_t
+{
+	struct rte_mempool * next;
+	uint8_t cz_num;
+	struct mrb_zone_idx_t idx[0];
+}__rte_packed;
+
+struct whole_mrb_pool_t
+{
+	struct mrb_pool_t external;	//"external" must be the first member of this struct
+	struct rte_mempool * usr_pkt_pool;
+	struct rte_mempool * usr_indirect_pool;
+
+	unsigned int usr_pool_size;
+	unsigned int total_ctrl_zone_size;
+	unsigned int cache_size;
+	unsigned int data_size;
+	uint8_t ctrlzone_num;
+	struct mrb_zone_idx_t ctrlzone[MRB_MAX_CTRLZONE_NUM];
+};
+
+#define mrbuf_priv(m)	((struct mrb_priv_zone_t*)((char*)m+sizeof(struct rte_mbuf)))
+#define	mrbuf_cz(m,k)	(&(mrbuf_priv(m)->idx[k]))
+#define mrbuf_cz_data(m,k) ((void*)((char*)mrbuf_priv(m)+mrbuf_cz(m,k)->offset))
+#define mrbuf_cz_num(m)	(mrbuf_priv(m)->cz_num)
+
+static void set_element_ctrlzone(__attribute__((unused))struct rte_mempool *mp,
+	void *opaque, void *obj, __attribute__((unused)) unsigned obj_idx)
+{
+	struct whole_mrb_pool_t *_handle = (struct whole_mrb_pool_t *)opaque;
+	struct mrb_priv_zone_t* private = mrbuf_priv(obj);
+	private->cz_num = _handle->ctrlzone_num;
+	private->next = NULL;
+	memcpy(private->idx, _handle->ctrlzone, sizeof(struct mrb_zone_idx_t)*_handle->ctrlzone_num);
+	return;
+}
+
+struct mrb_pool_t * MRB_pool_handle_create(void)
+{
+	struct mrb_pool_t *handle = rte_zmalloc("mrb_handle", sizeof(struct mrb_pool_t), 0);
+	handle->pool_num = 0;
+	handle->total_ctrl_zone_size = sizeof(struct mrb_priv_zone_t);
+	return handle;
+}
+
+int MRB_set_pool_handle(struct mrb_pool_t *handle, enum MRB_para_type_t type, uint32_t value)
+{
+	struct whole_mrb_pool_t *_handle = (struct whole_mrb_pool_t *)handle;
+
+	switch (type)
+	{
+	case MRB_PARA_DATA_SIZE:
+		_handle->data_size = value;
+		break;
+	case MRB_PARA_USR_POOL_SIZE:
+		_handle->usr_pool_size = value;
+		break;
+	case MRB_PARA_CACHE_SIZE:
+		_handle->cache_size = value;
+		break;
+		
+	default:
+		return -1;
+		break;
+	}
+	return 0;
+}
+
+int MRB_pool_produce(struct mrb_pool_t* handle, unsigned int socket_id, unsigned int pool_size)
+{
+	struct whole_mrb_pool_t *_handle = (struct whole_mrb_pool_t *)handle;
+	char str_pool_sym[MR_SYMBOL_MAX];
+	int i = _handle->external.pool_num;
+	uint32_t ret;
+
+	if (_handle->usr_pkt_pool == NULL)
+	{
+		snprintf(str_pool_sym, sizeof(str_pool_sym), "mrb_usr_pkt_pool");
+		_handle->usr_pkt_pool = rte_pktmbuf_pool_create(str_pool_sym, _handle->usr_pool_size,
+			_handle->cache_size, _handle->total_ctrl_zone_size, _handle->data_size,	socket_id);
+	}
+
+	if (_handle->usr_pkt_pool == NULL)
+	{
+		MR_LOG(WARNING, BASE, "Creating user direct pktmbuf pool(symbol=%s, size=%d, cache=%d, "
+			"ctrlzone=%d, datasize=%d) : failed - %s)", str_pool_sym, _handle->usr_pool_size,
+			_handle->cache_size, _handle->total_ctrl_zone_size, _handle->data_size, __str_errno());
+		return -1;
+	}
+
+	if (_handle->usr_indirect_pool == NULL)
+	{
+		snprintf(str_pool_sym, sizeof(str_pool_sym), "mrb_usr_indirect_pool");
+		_handle->usr_pkt_pool = rte_pktmbuf_pool_create(str_pool_sym, _handle->usr_pool_size,
+			_handle->cache_size, _handle->total_ctrl_zone_size, _handle->data_size, socket_id);
+	}
+
+	if(_handle->usr_indirect_pool == NULL)
+	{
+		MR_LOG(WARNING, BASE, "Creating user indrect pktmbuf pool(symbol=%s, size=%d, cache=%d, "
+			"ctrlzone=%d, datasize=%d) : failed - %s)", str_pool_sym, _handle->usr_pool_size,
+			_handle->cache_size, _handle->total_ctrl_zone_size, _handle->data_size, __str_errno());
+		return -1;
+	}
+
+	handle->mr_pkt_pool = (struct rte_mempool **)rte_realloc(handle->mr_pkt_pool, 
+		sizeof(struct rte_mempool*)*(i + 1), 0);
+
+	handle->mr_indirect_pool = (struct rte_mempool **)rte_realloc(handle->mr_indirect_pool,
+		sizeof(struct rte_mempool*)*(i + 1), 0);
+
+	snprintf(str_pool_sym, sizeof(str_pool_sym), "mrb_pkt_pool_%d", i);
+	handle->mr_pkt_pool[i] = rte_pktmbuf_pool_create(str_pool_sym, pool_size,_handle->cache_size,
+		_handle->total_ctrl_zone_size, _handle->data_size, socket_id);
+
+	if(handle->mr_pkt_pool[i] == NULL)
+	{
+		MR_LOG(WARNING, BASE, "Creating dataplane pktmbuf pool(symbol=%s, size=%d, cache=%d, "
+			"ctrlzone=%d, datasize=%d) : failed - %s)", str_pool_sym, pool_size, _handle->cache_size,
+			_handle->total_ctrl_zone_size, _handle->data_size, __str_errno());
+		return -3;
+	}
+	
+	ret = rte_mempool_obj_iter(handle->mr_pkt_pool[i], set_element_ctrlzone, _handle);
+	assert(ret == _handle->usr_pool_size);
+	
+	snprintf(str_pool_sym, sizeof(str_pool_sym), "mrb_indirect_pool_%d", i);
+	handle->mr_indirect_pool[i] = rte_pktmbuf_pool_create(str_pool_sym, pool_size,
+		_handle->cache_size, _handle->total_ctrl_zone_size, 0, socket_id);
+	
+	if (handle->mr_indirect_pool[i] == NULL)
+	{
+		MR_LOG(WARNING, BASE, "Creating dataplane indirect pktmbuf pool(symbol=%s, size=%d, cache=%d, "
+			"ctrlzone=%d, datasize=%d) : failed - %s)", str_pool_sym, pool_size, _handle->cache_size,
+			_handle->total_ctrl_zone_size, _handle->data_size, __str_errno());
+		return -4;
+	}
+	
+	ret = rte_mempool_obj_iter(handle->mr_indirect_pool[i], set_element_ctrlzone, _handle);
+	assert(ret == _handle->usr_pool_size);
+
+	handle->pool_num++;
+	return i;
+}
+
+int MRB_ctrlzone_register(struct mrb_pool_t * handle, uint8_t id, uint8_t size)
+{
+	struct whole_mrb_pool_t *_handle = (struct whole_mrb_pool_t *)handle;
+	int i = 0;
+	_handle->ctrlzone_num++;
+
+	if (_handle->ctrlzone_num <= MRB_MAX_CTRLZONE_NUM)
+	{
+		return -1;
+	}
+
+	if (_handle->ctrlzone[id].size != 0)
+	{
+		return -1;
+	}
+
+	_handle->ctrlzone[id].size = size;
+	_handle->ctrlzone[id].offset = _handle->total_ctrl_zone_size;
+	_handle->total_ctrl_zone_size += (size + sizeof(struct mrb_zone_idx_t));
+	return 0;
+}
+
+void *marsio_buff_ctrlzone(marsio_buff_t *mr_buff, uint8_t id)
+{
+	struct mrb_zone_idx_t* cz = mrbuf_cz(mr_buff, id);
+	assert(id < mrbuf_cz_num(mr_buff));
+	return mrbuf_cz_data(mr_buff, id);
+}
+
+void *marsio_buff_ctrlzone_data(marsio_buff_t *mr_buff, uint8_t id, uint8_t *size)
+{
+	struct mrb_zone_idx_t* cz = mrbuf_cz(mr_buff, id);
+	assert(id < mrbuf_cz_num(mr_buff));
+	*size = cz->size;
+	return mrbuf_cz_data(mr_buff, id);
+}
+
+void marsio_buff_ctrlzone_set(marsio_buff_t *mr_buff, uint8_t id, void* ptr_data, uint8_t size)
+{
+	struct mrb_zone_idx_t* cz = mrbuf_cz(mr_buff, id);
+	assert(id < mrbuf_cz_num(mr_buff));
+	assert(size <= cz->size);
+	memcpy(mrbuf_cz_data(mr_buff, id), ptr_data, size);
+	return;
+}
+
+int marsio_buff_malloc(marsio_buff_t *marsio_buff[], unsigned int nb_buff, 
+	__attribute__((unused))unsigned int flags,
+	__attribute__((unused))int thread_seq)
+{
+	struct mr_core_instance *this_core = NULL;
+	struct whole_mrb_pool_t *_handle = NULL;
+	int i = 0;
+
+	this_core = mr_core_default_instance_get();
+	_handle = (struct whole_mrb_pool_t *)this_core->mrb_pool_handle;
+	for (i = 0; i < nb_buff; i++)
+	{
+		marsio_buff[i] = rte_pktmbuf_alloc(_handle->usr_pkt_pool);
+		if (marsio_buff[i] == NULL)
+		{
+			break;
+		}
+	}
+
+	return i;
+}
+void marsio_buff_free(marsio_buff_t *marsio_buff[], unsigned int nb_buff)
+{
+	int i = 0;
+	for (i = 0; i < nb_buff; i++)
+	{
+		mrbuf_priv(marsio_buff[i])->next = NULL;
+		rte_pktmbuf_free((struct rte_mbuf *)marsio_buff[i]);
+	}
+	return;
+}
+
+
+void marsio_buff_append_pkt(marsio_buff_t *previous, marsio_buff_t *next)
+{
+	mrbuf_priv(previous)->next = next;
+}
+void marsio_buff_append_seg(marsio_buff_t *previous, marsio_buff_t *next)
+{
+	((struct rte_mbuf *)previous)->next = next;
+}
+
+marsio_buff_t *marsio_buff_getnext_seg(marsio_buff_t *m)
+{
+	return (marsio_buff_t *)(((struct rte_mbuf*)m)->next);
+}
+
+marsio_buff_t *marsio_buff_getnext_pkt(marsio_buff_t *m)
+{
+	return mrbuf_priv(m)->next;
+}
+
+void marsio_buff_reset(marsio_buff_t *m)
+{
+	struct mrb_priv_zone_t* priv_zone = mrbuf_priv(m);
+	struct mrb_zone_idx_t* cz_first = NULL, *cz_last = NULL;
+
+	rte_pktmbuf_reset((struct rte_mbuf *)m);
+	priv_zone->next = NULL;
+	if (mrbuf_cz_num(m) > 0)
+	{
+		cz_first = mrbuf_cz(m, 0);
+		cz_last = mrbuf_cz(m, mrbuf_cz_num(m) - 1);
+		memset(mrbuf_cz_data(m, 0), 0, cz_last->offset + cz_last->size - cz_first->offset);
+	}
+	return;
+}
+
+char *marsio_buff_mtod(marsio_buff_t *m)
+{
+	return rte_pktmbuf_mtod((struct rte_mbuf *)m, char *);
+}
+
+uint32_t marsio_buff_buflen(marsio_buff_t *m)
+{
+	return rte_pktmbuf_pkt_len((struct rte_mbuf *)m);
+}
+
+uint32_t marsio_buff_datalen(marsio_buff_t *m)
+{
+	return rte_pktmbuf_data_len((struct rte_mbuf *)m);
+}
+
+char *marsio_buff_prepend(marsio_buff_t *m, uint16_t len)
+{
+	return rte_pktmbuf_prepend((struct rte_mbuf *)m, len);
+}
+
+char *marsio_buff_append(marsio_buff_t *m, uint16_t len)
+{
+	return rte_pktmbuf_append((struct rte_mbuf *)m, len);
+}
+
+char *marsio_buff_adj(marsio_buff_t *m, uint16_t len)
+{
+	return rte_pktmbuf_adj((struct rte_mbuf *)m, len);
+}
+
+int marsio_buff_trim(marsio_buff_t *m, uint16_t len)
+{
+	return rte_pktmbuf_trim((struct rte_mbuf *)m, len);
+}
+
+uint16_t marsio_buff_headroom(const marsio_buff_t *m)
+{
+	return rte_pktmbuf_headroom((const struct rte_mbuf *)m);
+}
+
+uint16_t marsio_buff_tailroom(const marsio_buff_t *m)
+{
+	return rte_pktmbuf_tailroom((const struct rte_mbuf *)m);
+}
+
+uint32_t marsio_get_pkt_type(marsio_buff_t *m)
+{
+	return ((struct rte_mbuf *)m)->packet_type;
+}
+
+marsio_buff_t *marsio_buff_dup(marsio_buff_t *m)
+{
+	mr_process_ctx_t *proc_ctx;
+	rte_mbuf_refcnt_update((struct rte_mbuf *)m, 1);
+	return m;
+}
\ No newline at end of file
diff --git a/core/src/core.c b/core/src/core.c
index ec59082..9bca28c 100644
--- a/core/src/core.c
+++ b/core/src/core.c
@@ -48,9 +48,6 @@ struct mr_core_instance * mr_core_instance_create(struct mr_core_config* config)
 	ret = devman_init(instance);
 	MR_CHECK(ret >= 0, "Failed at CoreDevice Preinit stage.");
 
-	ret = vnodeman_init(instance);
-	MR_CHECK(ret >= 0, "Failed at CoreVNodeMan Preinit stage.");
-
 	ret = stat_init(instance);
 	MR_CHECK(ret >= 0, "Failed at CoreStat Preinit stage.");
 	return instance;
diff --git a/core/src/device.c b/core/src/device.c
index 69577ae..68a5c44 100644
--- a/core/src/device.c
+++ b/core/src/device.c
@@ -14,7 +14,6 @@
 #include <rte_ethdev.h>
 
 #include <mr_common.h>
-#include <mr_mrbuf.h>
 #include <mr_device.h>
 #include <mr_core.h>
 
diff --git a/core/src/rtdev.c b/core/src/rtdev.c
index bed0c37..e1da074 100644
--- a/core/src/rtdev.c
+++ b/core/src/rtdev.c
@@ -7,9 +7,10 @@
 
 #include <rte_malloc.h>
 #include <mr_device.h>
-#include <mr_vman.h>
 #include <mr_common.h>
 #include <mr_rtdev.h>
+#include <mr_core.h>
+#include <mr_vnode.h>
 
 #define __PATTERN_DEV_RX			"%s-RX"
 #define __PATTERN_DEV_TX			"%s-TX"
@@ -19,457 +20,222 @@
 #define __PATTERN_PROD_APP			"%s"
 #define __PATTERN_CONS_APP			"%s"
 
-static int __unregister_app_for_rxvnode(const char * devsym, const char * appsym)
+static void __wrap_object_delete(void * object)
 {
-	char vnodesym[MR_SYMBOL_MAX];
-	char conssym[MR_SYMBOL_MAX];
-
-	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_RX, devsym);
-	snprintf(conssym, sizeof(conssym), __PATTERN_CONS_APP, appsym);
-
-	int ret = mr_vnodeman_unregister_consumer(vnodesym, conssym);
-	if (ret < 0)
-	{
-		MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceClose, "
-			"Cannot unregister consumer %s for vnode %s. \n",
-			conssym, vnodesym);
-		return ret;
-	}
-
-	return 0;
+	return rte_pktmbuf_free(object);
 }
 
-static int __unregister_app_for_txvnode(const char * devsym, const char * appsym)
+static void * __wrap_object_new(void * pool)
 {
-	char vnodesym[MR_SYMBOL_MAX];
-	char prodsym[MR_SYMBOL_MAX];
-
-	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_TX, devsym);
-	snprintf(prodsym, sizeof(prodsym), __PATTERN_PROD_APP, appsym);
-
-	int ret = mr_vnodeman_unregister_producer(vnodesym, prodsym);
-	if (ret < 0)
-	{
-		MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceClose, "
-			"Cannot unregister consumer %s for vnode %s. \n",
-			prodsym, vnodesym);
-		return ret;
-	}
-
-	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_FTX, devsym);
-	snprintf(prodsym, sizeof(prodsym), __PATTERN_PROD_APP, appsym);
-
-	ret = mr_vnodeman_unregister_producer(vnodesym, prodsym);
-	if (ret < 0)
-	{
-		MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceClose, "
-			"Cannot unregister consumer %s for vnode %s. \n",
-			prodsym, vnodesym);
-		return ret;
-	}
-
-	return 0;
+	return rte_pktmbuf_alloc(pool);
 }
 
-static int __register_app_for_rxvnode(const char * devsym, const char * appsym, 
-	unsigned int nr_queues)
+static void * __wrap_object_dup(void * object, void * pool)
 {
-	char vnodesym[MR_SYMBOL_MAX];
-	char conssym[MR_SYMBOL_MAX];
-
-	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_RX, devsym);
-	snprintf(conssym, sizeof(conssym), __PATTERN_CONS_APP, appsym);
-
-	int ret = mr_vnodeman_register_consumer(vnodesym, conssym, nr_queues);
-	if (ret < 0)
-	{
-		MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceOpen, "
-			"Cannot register consumer %s(nr_queues=%d) for vnode %s. \n",
-			conssym, nr_queues, vnodesym);
-		return ret;
-	}
-
-	return 0;
+	return rte_pktmbuf_clone(object, pool);
 }
 
-static int __register_app_for_txvnode(const char * devsym, const char * appsym,
-	unsigned int nr_queues)
+struct vnode_ops _rtdev_vnode_ops =
 {
-	char vnodesym[MR_SYMBOL_MAX];
-	char prodsym[MR_SYMBOL_MAX];
-
-	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_TX, devsym);
-	snprintf(prodsym, sizeof(prodsym), __PATTERN_PROD_APP, appsym);
+	.op_object_new = __wrap_object_new,
+	.op_object_dup = __wrap_object_dup,
+	.op_object_delete = __wrap_object_delete
+};
 
-	int ret = mr_vnodeman_register_producer(vnodesym, prodsym, nr_queues);
-	if (ret < 0)
+static struct rtdev_desc * __rtdev_lookup_unsafe(struct mr_core_instance * instance, const char * devsym)
+{
+	struct rtdev_desc * desc_iter;
+	TAILQ_FOREACH(desc_iter, instance->rtdev_list, next)
 	{
-		MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceOpen, "
-			"Cannot register consumer %s(nr_queues=%d) for vnode %s. \n",
-			prodsym, nr_queues, vnodesym);
-			return ret;
+		if (strcmp(desc_iter->symbol, devsym) != 0) continue;
+		return desc_iter;
 	}
 
-	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_FTX, devsym);
-	snprintf(prodsym, sizeof(prodsym), __PATTERN_PROD_APP, appsym);
+	return NULL;
+}
 
-	ret = mr_vnodeman_register_producer(vnodesym, prodsym, nr_queues);
-	if (ret < 0)
+static struct rtdev_app_desc * __rtdev_app_lookup_unsafe(struct rtdev_desc * dev_desc, const char * appsym)
+{
+	struct rtdev_app_desc * app_desc_iter;
+	TAILQ_FOREACH(app_desc_iter, &dev_desc->app_desc_list, next)
 	{
-		MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceOpen, "
-			"Cannot register consumer %s(nr_queues=%d) for vnode %s. \n",
-			prodsym, nr_queues, vnodesym);
-		return ret;
+		if (strcmp(app_desc_iter->symbol, appsym) != 0) continue;
+		return app_desc_iter;
 	}
 	
-	return 0;
+	return NULL;
 }
 
-static int __register_service_for_rxvnode(const char * devsym, const char * servsym,
-	unsigned int nr_queues)
+struct rtdev_desc * mr_rtdev_lookup(struct mr_core_instance * instance, const char * devsym)
 {
-	char vnodesym[MR_STRING_MAX];
-	char prodsym[MR_STRING_MAX];
-
-	// ����VNode������
-	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_RX, devsym);
-	snprintf(prodsym, sizeof(prodsym), __PATTERN_PROD_SERVICE, servsym);
-
-	// ע�������ߣ������ߵĶ��������������߳���һ��
-	int ret = mr_vnodeman_register_producer(vnodesym, prodsym, nr_queues);
-
-	if (ret < 0)
-	{
-		MR_LOG(WARNING, SERVICE, "Rtdevice, RtdeviceCreate, "
-			"Cannot register producer %s(nr_queues=%d) for vnode %s. \n",
-			prodsym, nr_queues, vnodesym);
-		return ret;
-	}
-
-	return 0;
+	return __rtdev_lookup_unsafe(instance, devsym);
 }
 
-static int __register_service_for_txvnode(const char * devsym, const char * servsym,
-	unsigned int nr_queues)
+struct rtdev_app_desc * mr_rtdev_app_lookup(struct rtdev_desc * dev_desc, const char * appsym)
 {
-	char vnodesym[MR_SYMBOL_MAX];
-	char conssym[MR_SYMBOL_MAX];
-
-	// ����VNode�����֣���ͨ����·��
-	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_TX, devsym);
-	snprintf(conssym, sizeof(conssym), __PATTERN_CONS_SERVICE, servsym);
-
-	// ע��������
-	int ret = mr_vnodeman_register_consumer(vnodesym, conssym, nr_queues);
-
-	if (ret < 0)
-	{
-		MR_LOG(WARNING, SERVICE, "Rtdevice, RtdeviceCreate, "
-			"Cannot register consumer %s(nr_queues=%d) for vnode %s. \n",
-			conssym, nr_queues, vnodesym);
-		return ret;
-	}
-
-	// ����VNode�����֣����ٷ���·��
-	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_FTX, devsym);
-	snprintf(conssym, sizeof(conssym), __PATTERN_CONS_SERVICE, servsym);
-
-	// ע��������
-	ret = mr_vnodeman_register_consumer(vnodesym, conssym, nr_queues);
-
-	if (ret < 0)
-	{
-		MR_LOG(WARNING, SERVICE, "Rtdevice, RtdeviceCreate, "
-			"Cannot register consumer %s(nr_queues=%d) for vnode %s. \n",
-			conssym, nr_queues, vnodesym);
-		return ret;
-	}
-	
-	return 0;
+	return __rtdev_app_lookup_unsafe(dev_desc, appsym);
 }
 
-// ΪRtdevice����VNode�ڵ�
-static int __create_device_vnode(const char * symbol, unsigned int sz_tunnel, unsigned int sz_buffer)
+ // ����һ������ʱ�����豸
+struct rtdev_desc * mr_rtdev_create(struct mr_core_instance * instance, const char * devsym, 
+	struct rte_mempool * pool, unsigned int nr_serv_thread, unsigned int sz_tunnel, unsigned int sz_buffer)
 {
-	char vnodesym[MR_SYMBOL_MAX];
-	int ret = 0;
-
-	// Ϊ�ձ�·��ע���µ�VNode�ڵ�
-	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_RX, symbol);
-	ret = mr_vnodeman_create(vnodesym, sz_tunnel, sz_buffer, 0);
-
-	if (ret < 0)
+	// �б���û�г�ʼ������������ʱ�б���ʼ��
+	if(instance->rtdev_list == NULL)
 	{
-		MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceCreate, "
-			"Cannot create vnode %s(sz_tunnel=%d, sz_buffer=%d) for rt-device %s\n",
-			vnodesym, sz_tunnel, sz_buffer, symbol);
-		return ret;
+		instance->rtdev_list = rte_zmalloc(NULL, sizeof(struct rtdev_desc_list), 0);
+		TAILQ_INIT(instance->rtdev_list);
 	}
 
-	// Ϊ����·��ע���µ�VNode�ڵ�
-	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_TX, symbol);
-	ret = mr_vnodeman_create(vnodesym, sz_tunnel, sz_buffer, 0);
+	// �����������ڴ�
+	struct rtdev_desc * desc = rte_zmalloc(NULL, sizeof(struct rtdev_desc), 0);
+	MR_CHECK(desc != NULL, "Cannot alloc memory for rtdev-desc %s", devsym);
 
-	if (ret < 0)
-	{
-		MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceCreate, "
-			"Cannot create vnode %s(sz_tunnel=%d, sz_buffer=%d) for rt-device %s\n",
-			vnodesym, sz_tunnel, sz_buffer, symbol);
-		return ret;
-	}
+	snprintf(desc->symbol, sizeof(desc->symbol), "%s", devsym);
+	desc->nr_serv_stream = nr_serv_thread;
+
+	desc->ops = _rtdev_vnode_ops;
+	desc->ops.pool_dup_object = pool;
+	desc->ops.pool_new_object = pool;
+		
+	// ����VNode
+	char vnodesym[MR_SYMBOL_MAX];
+	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_RX, desc->symbol);
 
-	// Ϊ���ٱ��ķ���·��ע���µ�VNode�ڵ�
-	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_FTX, symbol);
-	ret = mr_vnodeman_create(vnodesym, sz_tunnel, sz_buffer, 0);
+	desc->vnode_rx = vnode_create(vnodesym, &desc->ops, sz_tunnel, sz_buffer);
+	if (desc->vnode_rx == NULL) goto vnode_create_failed;
 
-	if(ret < 0)
-	{
-		MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceCreate, "
-			"Cannot create vnode %s(sz_tunnel=%d, sz_buffer=%d) for rt-device %s\n",
-			vnodesym, sz_tunnel, sz_buffer, symbol);
-		return ret;
-	}
+	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_TX, desc->symbol);
+	desc->vnode_tx = vnode_create(vnodesym, NULL, sz_tunnel, sz_buffer);
+	if (desc->vnode_tx == NULL) goto vnode_create_failed;
 
-	MR_LOG(DEBUG, BASE, "Rtdevice, RtdeviceCreate, "
-		"Create vnodes for rt-device %s successful. \n", symbol);
+	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_FTX, desc->symbol);
+	desc->vnode_ftx = vnode_create(vnodesym, NULL, sz_tunnel, 0);
+	if (desc->vnode_ftx == NULL) goto vnode_create_failed;
 	
-	return 0;
-}
+	// ע��������
+	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_PROD_SERVICE, "service");
+	desc->vnode_prod_rx = vnode_create_prod(desc->vnode_rx, &desc->ops, vnodesym, nr_serv_thread);
+	if (desc->vnode_prod_rx == NULL) goto prod_cons_create_failed;
 
-// ����һ������ʱ�����豸
-int rt_device_serv_create(const char * devsym, 
-	const char * servsym, unsigned int nr_serv_thread,
-	unsigned int sz_tunnel, unsigned int sz_buffer)
-{
-	// ����VNode�ڵ�
-	int ret = __create_device_vnode(devsym, sz_tunnel, sz_buffer);
-	if(unlikely(ret < 0))
-	{
-		MR_LOG(ERR, BASE, "Rtdevice, RtdeviceCreate, "
-			"Cannot create vnodes for rt-device %s\n", devsym);
-		return ret;
-	}
+	// ע��������
+	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_CONS_SERVICE, "service");
+	desc->vnode_cons_tx = vnode_create_cons(desc->vnode_tx, &desc->ops, vnodesym, nr_serv_thread);
+	if (desc->vnode_cons_tx == NULL) goto prod_cons_create_failed;
 
-	// ע��Service���ձ���������
-	ret = __register_service_for_rxvnode(devsym, servsym, nr_serv_thread);
-	if(unlikely(ret < 0))
-	{
-		MR_LOG(ERR, BASE, "Rtdevice, RtdeviceCreate, "
-			"Cannot register rxvnodes for rt-device %s\n", devsym);
-		return ret;
-	}
+	// ע��������
+	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_CONS_SERVICE, "service");
+	desc->vnode_cons_ftx = vnode_create_cons(desc->vnode_ftx, &desc->ops, vnodesym, nr_serv_thread);
+	if (desc->vnode_cons_ftx == NULL) goto prod_cons_create_failed;
 
-	// ע��Service�ķ�����������
-	ret = __register_service_for_txvnode(devsym, servsym, nr_serv_thread);
-	if(unlikely(ret < 0))
-	{
-		MR_LOG(ERR, BASE, "Rtdevice, RtdeviceCreate, "
-			"Cannot register txvnodes for rt-device %s\n", devsym);
-		return ret;
-	}
+	// ����ע���б�
+	TAILQ_INSERT_TAIL(instance->rtdev_list, desc, next);
+	instance->nr_rtdev++;
 	
-	return 0;
+	MR_LOG(INFO, BASE, "Rtdevice %s(nr_serv_thread=%u, sz_tunnel=%u, sz_buffer=%u) created. \n",
+		desc->symbol, nr_serv_thread, sz_tunnel, sz_buffer);
+	
+	return desc;
+
+prod_cons_create_failed:
+	MR_LOG(WARNING, BASE, "Creating prod/cons %s (nr_queues=%d) of rtdev %s failed. \n",
+		vnodesym, nr_serv_thread, desc->symbol);
+	goto clean;
+
+vnode_create_failed:
+	MR_LOG(WARNING, BASE, "Creating vnode %s(sz_tunnel=%d, sz_buffer=%d)"
+		"of rtdev %s failed. \n", vnodesym, sz_tunnel, sz_buffer, desc->symbol);
+	goto clean;
+
+clean:
+	if (desc->vnode_prod_rx != NULL) vnode_delete_prod(desc->vnode_prod_rx, &desc->ops);
+	if (desc->vnode_cons_tx != NULL) vnode_delete_cons(desc->vnode_cons_tx, &desc->ops);
+	if (desc->vnode_cons_ftx != NULL) vnode_delete_cons(desc->vnode_cons_ftx, &desc->ops);
+	if (desc->vnode_rx != NULL) vnode_delete(desc->vnode_rx, &desc->ops);
+	if (desc->vnode_tx != NULL) vnode_delete(desc->vnode_tx, &desc->ops);
+	if (desc->vnode_ftx != NULL) vnode_delete(desc->vnode_ftx, &desc->ops);
+	if (desc) rte_free(desc);
+	return NULL;
 }
 
 // ����һ������ʱ�����豸
-int rt_device_serv_destory(const char * devsym)
-{
-	return 0;
-}
-
-// ���豸��ͨ����Slave������ʹ��
-int rt_device_open(const char * devsym, const char * appsym, 
-	unsigned int nr_rxstream, unsigned int nr_txstream)
-{
-	// ע��App���ձ���������
-	int ret = __register_app_for_rxvnode(devsym, appsym, nr_rxstream);
-	if(unlikely(ret < 0))
-	{
-		MR_LOG(ERR, BASE, "Rtdevice, RtdeviceOpen, "
-			"Cannot register rxvnodes for rt-device %s\n", devsym);
-		return ret;
-	}
-
-	// ע��App�ķ�����������
-	ret = __register_app_for_txvnode(devsym, appsym, nr_txstream);
-	if(unlikely(ret < 0))
-	{
-		MR_LOG(ERR, BASE, "Rtdevice, RtdeviceOpen, "
-			"Cannot register txvnodes for rt-device %s\n", devsym);
-		return ret;
-	}
-
-	return 0;
-}
-
-int rt_device_close(const char * devsym, const char * appsym)
+int mr_rt_device_destory(struct rtdev_desc * desc)
 {
-	int ret = __unregister_app_for_rxvnode(devsym, appsym);
-	if (unlikely(ret < 0))
-	{
-		MR_LOG(ERR, BASE, "Rtdevice, RtdeviceClose, "
-			"Cannot unregister rxvnodes for rt-device %s\n", devsym);
-		return ret;
-	}
-
-	ret = __unregister_app_for_txvnode(devsym, appsym);
-	if (unlikely(ret < 0))
-	{
-		MR_LOG(ERR, BASE, "Rtdevice, RtdeviceOpen, "
-			"Cannot register txvnodes for rt-device %s\n", devsym);
-		return ret;
-	}
-
 	return 0;
 }
 
-struct mr_rtdev_stream * rt_dev_serv_open_stream(const char * devsym,
-	const char * servsym)
+// ���豸
+struct rtdev_app_desc * mr_rt_device_open(struct mr_core_instance * instance, 
+	const char * devsym, const char * appsym, unsigned int nr_rx_stream, unsigned int nr_tx_stream)
 {
-	char vnodesym[MR_STRING_MAX];
-	char prod_or_cons_sym[MR_STRING_MAX];
-
-	struct mr_rtdev_stream * rtdev_stream;
-	rtdev_stream = rte_zmalloc(NULL, sizeof(struct mr_rtdev_stream), 0);
-	if (unlikely(rtdev_stream == NULL))
-	{
-		MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceServOpen, "
-			"Cannot alloc rtdev_stream for rtdevice %s", devsym);
-		goto errout;
-	}
-
-	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_RX, devsym);
-	snprintf(prod_or_cons_sym, sizeof(prod_or_cons_sym), __PATTERN_PROD_SERVICE, servsym);
-
-	struct vnodeman_attach_desc * attach_rxd;
-	attach_rxd = mr_vnodeman_producer_attach(vnodesym, prod_or_cons_sym);
-	if (unlikely(attach_rxd == NULL))
-	{
-		MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceServOpen, "
-			"Cannot attach vnode(sym=%s) producer=(%s). \n",
-			vnodesym, prod_or_cons_sym);
-		goto errout;
-	}
-
-	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_TX, devsym);
-	snprintf(prod_or_cons_sym, sizeof(prod_or_cons_sym), __PATTERN_CONS_SERVICE, servsym);
-
-	struct vnodeman_attach_desc * attach_txd;
-	attach_txd = mr_vnodeman_consumer_attach(vnodesym, prod_or_cons_sym);
-	if (unlikely(attach_txd == NULL))
-	{
-		MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceServOpen, "
-			"Cannot attach vnode(sym=%s) consumer=(%s). \n",
-			vnodesym, prod_or_cons_sym);
-		goto errout;
-	}
-
-	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_FTX, devsym);
-	snprintf(prod_or_cons_sym, sizeof(prod_or_cons_sym), __PATTERN_CONS_SERVICE, servsym);
+	// ��������ʱ�豸
+	struct rtdev_desc * dev_desc = mr_rtdev_lookup(instance, devsym);
+	RETURN_IF_ERROR(WARNING, BASE , dev_desc == NULL, NULL, "Rtdevice %s does not existed. \n", devsym);
+
+	// �����������ڴ�
+	struct rtdev_app_desc * desc = rte_zmalloc(NULL, sizeof(struct rtdev_app_desc), 0);
+	RETURN_IF_ERROR(WARNING, BASE, desc == NULL, NULL, "Cannot alloc memory for rtdev-app-desc %s", devsym);
+
+	snprintf(desc->symbol, sizeof(desc->symbol), "%s", appsym);
+	desc->nr_rx_stream = nr_rx_stream;
+	desc->nr_tx_stream = nr_tx_stream;
+	desc->dev_desc = dev_desc;
+		
+	// ���Ʋ�������ָ�룬��ͬ���̵ĺ�����ַ���ܲ�ͬ��������Դ��ַ��ͬ
+	desc->ops = _rtdev_vnode_ops;
+	desc->ops.pool_dup_object = dev_desc->ops.pool_dup_object;
+	desc->ops.pool_new_object = dev_desc->ops.pool_new_object;
+
+	// ΪRX����ע��������
+	char vnodesym[MR_SYMBOL_MAX];
+	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_CONS_APP, appsym);
+	desc->vnode_cons_rx = vnode_create_cons(dev_desc->vnode_rx, &desc->ops, vnodesym, nr_rx_stream);
+	if (desc->vnode_cons_rx == NULL) goto prod_cons_create_failed;
+
+	// ΪTXע��������
+	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_CONS_APP, appsym);
+	desc->vnode_prod_tx = vnode_create_prod(dev_desc->vnode_tx, &desc->ops, vnodesym, nr_tx_stream);
+	if (desc->vnode_prod_tx == NULL) goto prod_cons_create_failed;
+
+	// ΪFTXע��������
+	snprintf(vnodesym, sizeof(vnodesym), __PATTERN_CONS_APP, appsym);
+	desc->vnode_prod_ftx = vnode_create_prod(dev_desc->vnode_ftx, &desc->ops, vnodesym, nr_tx_stream);
+	if (desc->vnode_prod_ftx == NULL) goto prod_cons_create_failed;
+
+	// ����ע���б�
+	rte_rwlock_write_lock(&dev_desc->app_desc_lock);
+	TAILQ_INSERT_TAIL(&dev_desc->app_desc_list, desc, next);
+	rte_rwlock_write_unlock(&dev_desc->app_desc_lock);
+	
+	MR_LOG(INFO, BASE, "Rtdevice %s(appsym=%s, nr_rx_stream=%d, nr_tx_stream=%d) opened.",
+		dev_desc->symbol, desc->symbol, nr_rx_stream, nr_tx_stream);
 
-	struct vnodeman_attach_desc * attach_ftxd;
-	attach_ftxd = mr_vnodeman_consumer_attach(vnodesym, prod_or_cons_sym);
-	if (unlikely(attach_ftxd == NULL))
-	{
-		MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceServOpen, "
-			"Cannot attach vnode(sym=%s) consumer=(%s). \n",
-			vnodesym, prod_or_cons_sym);
-		goto errout;
-	}
+	return desc;
 
-	rtdev_stream->rxd = attach_rxd;
-	rtdev_stream->txd = attach_txd;
-	rtdev_stream->fasttxd = attach_ftxd;
-	snprintf(rtdev_stream->symbol, sizeof(rtdev_stream->symbol), "%s", devsym);
-	return rtdev_stream;
+prod_cons_create_failed:
+	MR_LOG(WARNING, BASE, "Creating prod/cons %s (nr_rx_stream=%d, nr_tx_stream=%d) of rtdev %s failed. \n",
+		appsym, nr_rx_stream, nr_tx_stream, dev_desc->symbol);
+	goto clean;
 
-errout:
-	//TODO: ��׼ȷ���ͷš�
-	if (rtdev_stream != NULL) rte_free(rtdev_stream);
+clean:
+	if (desc->vnode_cons_rx != NULL) vnode_delete_cons(desc->vnode_cons_rx, &desc->ops);
+	if (desc->vnode_prod_tx != NULL) vnode_delete_prod(desc->vnode_prod_tx, &desc->ops);
+	if (desc->vnode_prod_ftx != NULL) vnode_delete_prod(desc->vnode_prod_ftx, &desc->ops);
 	return NULL;
 }
 
-// �ر��豸����û��ʵ���Ե��߼������򿪺�Ͳ��ܹرգ�����Ҫ�ر�����
-// Ӧ���ر������豸Ȼ�����´򿪡�
-int rt_dev_stream_close(struct mr_rtdev_stream * stream)
-{
-	rte_free(stream);
-	return 0;
-}
-
-// ���豸����ÿ���̵߳���һ�Σ���ȡ��ǰ�̵߳���������
-struct mr_rtdev_stream * rt_dev_open_stream(const char * devsym,
-	const char * appsym, flags_t flags)
+// �ر��豸
+int mr_rt_device_close(struct rtdev_app_desc * desc)
 {
-	char vnodesym[MR_STRING_MAX];
-	char prod_or_cons_sym[MR_STRING_MAX];
-
-	struct vnodeman_attach_desc * attach_rxd = NULL;
-	struct vnodeman_attach_desc * attach_txd = NULL;
-	struct vnodeman_attach_desc * attach_ftxd = NULL;
-	
-	// �����������ռ�
-	struct mr_rtdev_stream * rtdev_stream;
-	rtdev_stream = rte_zmalloc(NULL, sizeof(struct mr_rtdev_stream), 0);
-	if(unlikely(rtdev_stream == NULL))
-	{
-		MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceOpen, "
-			"Cannot alloc rtdev_stream for rtdevice %s", devsym);
-		goto errout;
-	}
+	struct rtdev_desc * dev_desc = desc->dev_desc;
+	if (desc->vnode_cons_rx != NULL) vnode_delete_cons(desc->vnode_cons_rx, &desc->ops);
+	if (desc->vnode_prod_tx != NULL) vnode_delete_prod(desc->vnode_prod_tx, &desc->ops);
+	if (desc->vnode_prod_ftx != NULL) vnode_delete_prod(desc->vnode_prod_ftx, &desc->ops);
 	
-	// �����򿪣����ձ���
-	if (flags & RTDEV_FLAGS_OPEN_STREAM_RX)
-	{
-		snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_RX, devsym);
-		snprintf(prod_or_cons_sym, sizeof(prod_or_cons_sym), __PATTERN_CONS_APP, appsym);
-
-		attach_rxd = mr_vnodeman_consumer_attach(vnodesym, prod_or_cons_sym);
-		if (unlikely(attach_rxd == NULL))
-		{
-			MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceOpen, "
-				"Cannot attach vnode(sym=%s) consumer=(%s). \n",
-				vnodesym, prod_or_cons_sym);
-			goto errout;
-		}
-	}
+	rte_rwlock_write_lock(&dev_desc->app_desc_lock);
+	TAILQ_REMOVE(&dev_desc->app_desc_list, desc, next);
+	rte_rwlock_write_unlock(&dev_desc->app_desc_lock);
 
-	// �����򿪣���������
-	if (flags & RTDEV_FLAGS_OPEN_STREAM_TX)
-	{
-		snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_TX, devsym);
-		snprintf(prod_or_cons_sym, sizeof(prod_or_cons_sym), __PATTERN_PROD_APP, appsym);
-
-		attach_txd = mr_vnodeman_producer_attach(vnodesym, prod_or_cons_sym);
-		if (unlikely(attach_txd == NULL))
-		{
-			MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceOpen, "
-				"Cannot attach vnode(sym=%s) producer=(%s). \n",
-				vnodesym, prod_or_cons_sym);
-			goto errout;
-		}
-
-		snprintf(vnodesym, sizeof(vnodesym), __PATTERN_DEV_FTX, devsym);
-		snprintf(prod_or_cons_sym, sizeof(prod_or_cons_sym), __PATTERN_PROD_APP, appsym);
-
-		attach_ftxd = mr_vnodeman_producer_attach(vnodesym, prod_or_cons_sym);
-		if (unlikely(attach_ftxd == NULL))
-		{
-			MR_LOG(WARNING, BASE, "Rtdevice, RtdeviceOpen, "
-				"Cannot attach vnode(sym=%s) producer=(%s). \n",
-				vnodesym, prod_or_cons_sym);
-			goto errout;
-		}
-	}
-	
-	rtdev_stream->rxd = attach_rxd;
-	rtdev_stream->txd = attach_txd;
-	rtdev_stream->fasttxd = attach_ftxd;
-	snprintf(rtdev_stream->symbol, sizeof(rtdev_stream->symbol), "%s", devsym);
-	return rtdev_stream;
-
-errout:
-	//TODO: ��׼ȷ���ͷš�
-	if (rtdev_stream != NULL) rte_free(rtdev_stream);
-	return NULL;
+	rte_free(desc);
+	return 0;
 }
\ No newline at end of file
diff --git a/core/src/vman.c b/core/src/vman.c
index 2df521b..243727b 100644
--- a/core/src/vman.c
+++ b/core/src/vman.c
@@ -14,12 +14,11 @@
 #include <string.h>
 #include <rte_log.h>
 #include <rte_malloc.h>
+#include <rte_mbuf.h>
 
 #include <mr_common.h>
 #include <mr_vnode.h>
 #include <mr_vman.h>
-#include <mr_mrbuf.h>
-#include <mr_runtime.h>
 #include <mr_core.h>
 
 struct vnode_record
diff --git a/core/src/vnode.c b/core/src/vnode.c
index 9a57040..1d147da 100644
--- a/core/src/vnode.c
+++ b/core/src/vnode.c
@@ -50,7 +50,7 @@
 
 #define VNODE_STAT_UPDATE(desc, queue, item, value)					\
 do {																\
-	rte_atomic64_add(&desc->stat_per_queue[queue].item,value);		\
+	rte_atomic64_add(&desc->stat[queue].item,value);				\
 } while(0)															\
 
 /* Tunnel Description Structure */
@@ -827,7 +827,7 @@ int vnode_enqueue_burst_with_hash(struct vnode_prod * prod, struct vnode_ops * o
 		for (int i = 0; i < nr_objects; i++)
 		{
 			assert(i < RTE_DIM(dup_objects));
-			dup_objects[nr_dup_objects] = ops->op_object_dup(objects[i]);
+			dup_objects[nr_dup_objects] = ops->op_object_dup(objects[i], ops->pool_dup_object);
 			if (likely(dup_objects[nr_dup_objects] != NULL))
 			{
 				nr_dup_objects++;
diff --git a/include/mr_buffer.h b/include/mr_buffer.h
deleted file mode 100644
index 4837e37..0000000
--- a/include/mr_buffer.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#ifndef _MARSIO_BUFFER_FOR_DRIVER_H_
-#define _MARSIO_BUFFER_FOR_DRIVER_H_
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include <stdint.h>
-
-struct mrb_pool_t
-{
-	unsigned int pool_num;
-	struct rte_mempool ** mr_pkt_pool;
-	struct rte_mempool ** mr_indirect_pool;
-};
-enum MRB_para_type_t
-{
-	MRB_PARA_DATA_SIZE,
-	MRB_PARA_USR_POOL_SIZE
-};
-struct mrb_pool_t* MRB_create_pool_handle(void);
-int MRB_set_pool_handle(struct mrb_pool_t *handle,enum MRB_para_type_t type,uint32_t value);
-int MRB_pool_produce(struct mrb_pool_t* handle,unsigned int socket_id,unsigned int pool_size);
-int MRB_ctrlzone_register(struct mrb_pool_t * handle,uint8_t id,uint8_t size);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
diff --git a/include/mr_common.h b/include/mr_common.h
index 88a2140..667cbf9 100644
--- a/include/mr_common.h
+++ b/include/mr_common.h
@@ -83,6 +83,10 @@ typedef uint32_t hash_t;
 #define MR_LOG(level, module, ...)						\
 		RTE_LOG(level, module, ##__VA_ARGS__)
 
+#define RETURN_IF_ERROR(module, level, cond, rtv, ...)				do {    \
+	if(cond) { MR_LOG(module, level, ##__VA_ARGS__); return rtv; }			\
+} while(0)
+
 /* TODO: support pthread read/write lock */
 typedef rte_rwlock_t mr_spin_rwlock_t;
 #define mr_spin_rwlock_read_lock(x)	rte_rwlock_read_lock(x)
diff --git a/service/include/sc_common.h b/service/include/sc_common.h
index bf45036..d73507b 100644
--- a/service/include/sc_common.h
+++ b/service/include/sc_common.h
@@ -17,35 +17,27 @@ struct sc_device
 	char symbol[MR_STRING_MAX];
 	/* �������  */
 	struct mr_dev * dev;
-	/* ����ʹ�� */
-	unsigned int en_mr_dev;
-	/* �������� */
-	struct mr_dev_param mr_dev_param;
 	/* Э��ջ�豸��� */
 	struct sk_dev_desc * sk_dev;
-	/* Э��ջ�豸ʹ�� */
-	unsigned int en_sk_dev;
+	/* ����ʱ�豸������ */
+	struct rtdev_desc * rt_dev;
+	/* �������� */
+	struct mr_dev_param mr_dev_param;
 	/* Э��ջ�豸���� */
 	struct sk_dev_param sk_dev_param;
+	/* Э��ջ�豸ʹ�� */
+	unsigned int en_sk_dev;
+	/* ����ʹ�� */
+	unsigned int en_mr_dev;
+	/* ����ʱ�豸ʹ�� */
+	unsigned int en_rt_dev;
+	/* ����ʱ����������Դ */
+	struct mr_dev_q * rx_devq[MR_SID_MAX];
+	struct mr_dev_q * tx_devq[MR_SID_MAX];
 };
 
 TAILQ_HEAD(sc_device_list, sc_device);
 
-struct sc_app
-{
-	TAILQ_ENTRY(sc_app) next;
-	char symbol[MR_STRING_MAX];
-	cpu_mask_t cpu_mask;
-	unsigned int rxstream;
-	unsigned int txstream;
-	
-	//TODO: ÿ��Ӧ�ÿ��Է��ʲ�ͬ���豸
-	//TODO: ��κ�Socket���
-	struct sc_device_list device_list;
-};
-
-TAILQ_HEAD(sc_app_list, sc_app);
-
 // ���طֵ���ʽ
 enum _e_dist_mode
 {
@@ -69,6 +61,22 @@ static inline const char * str_dist_mode(unsigned int distmode)
 	return NULL;
 }
 
+struct sc_param
+{
+	/* SC���������߳����� */
+	unsigned int nr_serv_thread;
+	/* ���Ĵ���·����С */
+	unsigned int sz_tunnel;
+	/* ���Ĵ��ݻ�������С */
+	unsigned int sz_buffer;
+	/* �������Ĵ������� */
+	unsigned int sz_burst;
+	/* ���طֵ���ʽ */
+	unsigned int distmode;
+	/* Ӳ��RSS��ʽ */
+	unsigned int rssmode;
+};
+
 /* Service Instance */
 struct sc_instance
 {
@@ -84,48 +92,12 @@ struct sc_instance
 	struct sc_device_list device_list;
 	/* ���õ��豸���� */
 	unsigned int nr_devs;
-	/* Ӧ���б� */
-	struct sc_app_list app_list;
-	/* �ձ���·��VNode����С */
-	unsigned int sz_rxvnode_ring;
-	/* ������·��VNode����С */
-	unsigned int sz_txvnode_ring;
-	/* �ձ���·��VNode��������С */
-	unsigned int sz_rxvnode_buffer;
-	/* ������·��VNode��������С */
-	unsigned int sz_txvnode_buffer;
-	/* �ձ���·��Burst��С*/
-	unsigned int sz_rx_burst;
-	/* ������·��Burst��С*/
-	unsigned int sz_tx_burst;
-	/* ���طֵ���ʽ */
-	unsigned int distmode;
-	/* Ӳ��RSS��ʽ */
-	unsigned int rssmode;
+	/* ������� */
+	struct sc_param sc_param;
 	/* Э��ջ���� */
 	struct sk_param sk_param;
-
 	/* ���Ŀ�ȫ�־�� */
 	struct mr_core_instance * core_instance;
 	/* Э��ջȫ�־�� */
 	struct sk_instance * sk_instance;
-};
-
-// �й��豸������ʱ��Դ��ÿ���̣߳�ÿ���豸һ���ṹ��
-struct sc_rt_device
-{
-	/* ��ʵ�豸������ */
-	struct mr_dev_q * rx_devq;
-	struct mr_dev_q * tx_devq;
-
-	/* ��Ӧ������ʱ�豸������ */
-	struct mr_rtdev_stream * rtstream;
-	/* ��Ӧ��Э��ջ�豸������ */
-	struct sk_dev_desc * sk_dev;
-};
-
-struct sc_thread_instance
-{
-	unsigned int nr_devices;
-	struct sc_rt_device * rt_dev;
 };
\ No newline at end of file
diff --git a/service/src/config.c b/service/src/config.c
index fab8af6..57e3ec0 100644
--- a/service/src/config.c
+++ b/service/src/config.c
@@ -14,40 +14,24 @@
 #include <mr_runtime.h>
 #include <arpa/inet.h>
 
-#ifndef MR_SERVICE_DEFAULT_SZ_RXVNODE_RING
-#define MR_SERVICE_DEFAULT_SZ_RXVNODE_RING		1024
+#ifndef MR_SERVICE_DEFAULT_SZ_BUFFER
+#define MR_SERVICE_DEFAULT_SZ_BUFFER		128
 #endif
 
-#ifndef MR_SERVICE_DEFAULT_SZ_TXVNODE_RING
-#define MR_SERVICE_DEFAULT_SZ_TXVNODE_RING		1024
-#endif
-
-#ifndef MR_SERVICE_DEFAULT_SZ_RXVNODE_BUFFER
-#define MR_SERVICE_DEFAULT_SZ_RXVNODE_BUFFER	128
-#endif
-
-#ifndef MR_SERVICE_DEFAULT_SZ_TXVNODE_BUFFER
-#define MR_SERVICE_DEFAULT_SZ_TXVNODE_BUFFER	128
-#endif
-
-#ifndef MR_SERVICE_DEFAULT_SZ_RX_BURST
-#define MR_SERVICE_DEFAULT_SZ_RX_BURST	128
-#endif
-
-#ifndef MR_SERVICE_DEFAULT_SZ_TX_BURST
-#define MR_SERVICE_DEFAULT_SZ_TX_BURST	128
+#ifndef MR_SERVICE_DEFAULT_SZ_TUNNEL
+#define MR_SERVICE_DEFAULT_SZ_TUNNEL		1024
 #endif
 
 #ifndef MR_SERVICE_DEFAULT_DIST_MODE
 #define MR_SERVICE_DEFAULT_DIST_MODE	LDBC_DIST_OUTER_TUPLE2
 #endif
 
-#if MR_SERVICE_DEFAULT_SZ_RX_BURST > MR_BURST_MAX
-#error("MR_SERVICE_DEFAULT_SZ_BURST is large than MR_BURST_MAX")
+#ifndef MR_SERVICE_DEFAULT_SZ_BURST
+#define MR_SERVICE_DEFAULT_SZ_BURST			32
 #endif
 
-#if MR_SERVICE_DEFAULT_SZ_TX_BURST > MR_BURST_MAX
-#error("MR_SERVICE_DEFAULT_TX_BURST is large than MR_BURST_MAX")
+#if MR_SERVICE_DEFAULT_SZ_BURST > MR_BURST_MAX
+#error("MR_SERVICE_DEFAULT_SZ_BURST is large than MR_BURST_MAX")
 #endif
 
 static int __parser_uint(const char * str)
@@ -118,89 +102,14 @@ int sc_config_thread_info(const char * cfg, struct sc_instance * instance)
 
 	ret = __parser_str_core(str_thread_info, sizeof(str_thread_info),
 		&instance->cpu_mask, ',');
+
 	if(ret < 0)
 		return __errlog_invaild_format("LoadThreadInfo", "service", "iocore");
 
+	instance->sc_param.nr_serv_thread = mask_popcnt(instance->cpu_mask);
 	return 0;
 }
 
-#if 0
-static int __parse_app_info(const char * cfg, const char * appsym, 
-	struct sc_instance * instance)
-{
-	int ret = 0;
-	char str_section[MR_STRING_MAX];
-	snprintf(str_section, sizeof(str_section), "app:%s", appsym);
-
-	// 读核心掩码
-	char str_core[MR_STRING_MAX];
-	ret = MESA_load_profile_string_nodef(cfg, str_section, "core",
-		str_core, sizeof(str_core));
-
-	if (ret < 0)
-		return __errlog_lost_key("LoadAppInfo", str_section, "core");
-
-	// 解析核心掩码
-	cpu_mask_t coremask;
-	ret = __parser_str_core(str_core, sizeof(str_core), &coremask, ',');
-	if (ret < 0)
-		return __errlog_invaild_format("LoadAppInfo", str_section, "core");
-
-	// 读RX队列数
-	unsigned int rxstream;
-	ret = MESA_load_profile_uint_nodef(cfg, str_section, "rxstream", &rxstream);
-	if (ret < 0) return __errlog_invaild_format("LoadAppInfo", str_section, "rxstream");
-
-	// 读TX队列数
-	unsigned int txstream;
-	ret = MESA_load_profile_uint_nodef(cfg, str_section, "txstream", &txstream);
-	if (ret < 0) return __errlog_invaild_format("LoadAppInfo", str_section, "txstream");
-
-	// 生成App结构体，插入到链表中
-	struct sc_app * appinfo;
-	appinfo = rte_zmalloc(NULL, sizeof(struct sc_app), 0);
-	assert(appinfo != NULL);
-	
-	snprintf(appinfo->symbol, sizeof(appinfo->symbol), "%s", appsym);
-	appinfo->cpu_mask = coremask;
-	appinfo->rxstream = rxstream;
-	appinfo->txstream = txstream;
-	TAILQ_INSERT_TAIL(&instance->app_list, appinfo, next);
-	return 0;
-}
-
-int sc_config_app_info(const char * cfg, struct sc_instance * instance)
-{
-	char str_app_info[MR_STRING_MAX];
-
-	// 读APP汇总信息：[app]symbols=XXX,YYY,ZZZ
-	int ret = MESA_load_profile_string_nodef(cfg, "app", "symbols",
-		str_app_info, sizeof(str_app_info));
-
-	if (ret < 0) return __errlog_lost_key("LoadAppInfo", "app","symbols");
-	
-	// 切分APP汇总信息
-	char * app_info_tokens[MR_TOKENS_MAX];
-	int nr_app_info_tokens = rte_strsplit(str_app_info, sizeof(str_app_info),
-		app_info_tokens, MR_TOKENS_MAX, ',');
-
-	if (nr_app_info_tokens < 0)
-		return __errlog_invaild_format("LoadAppInfo", "app","symbols");
-	
-	TAILQ_INIT(&instance->app_list);
-	for(int i = 0; i < nr_app_info_tokens; i++)
-	{
-		// 生成section的名字
-		const char * appsym = app_info_tokens[i];
-		ret = __parse_app_info(cfg, appsym, instance);
-		if (ret < 0) return ret;
-	}
-	
-	return 0;
-}
-
-#endif
-
 // 读协议栈运行参数
 static int sc_config_stack_info(const char * cfg, struct sc_instance * instance)
 {
@@ -368,73 +277,46 @@ _err_fmt:
 	return __errlog_invaild_format("LoadDeviceInfo", "device", "device");
 }
 
-int sc_config_vnode_info(const char * cfg, struct sc_instance * instance)
-{
-	MESA_load_profile_uint_def(cfg, "vnode", "sz_rxvnode_ring",
-		&instance->sz_rxvnode_ring, MR_SERVICE_DEFAULT_SZ_RXVNODE_RING);
-	MESA_load_profile_uint_def(cfg, "vnode", "sz_txvnode_ring",
-		&instance->sz_txvnode_ring, MR_SERVICE_DEFAULT_SZ_TXVNODE_RING);
-	MESA_load_profile_uint_def(cfg, "vnode", "sz_rxvnode_buffer",
-		&instance->sz_rxvnode_buffer, MR_SERVICE_DEFAULT_SZ_RXVNODE_BUFFER);
-	MESA_load_profile_uint_def(cfg, "vnode", "sz_txvnode_buffer",
-		&instance->sz_txvnode_buffer, MR_SERVICE_DEFAULT_SZ_TXVNODE_BUFFER);
-	
-	MR_LOG(INFO, SERVICE, "ServiceConfig, LoadVnodeInfo, "
-		"sz_rxvnode_ring=%d, sz_txvnode_ring=%d, "
-		"sz_rxvnode_buffer=%d, sz_txvnode_buffer=%d \n",
-		instance->sz_rxvnode_ring, instance->sz_txvnode_ring,
-		instance->sz_rxvnode_buffer, instance->sz_txvnode_buffer);
-	
-	return 0;
-}
-
 int sc_config_burst_info(const char * cfg, struct sc_instance * instance)
 {
-	MESA_load_profile_uint_def(cfg, "burst", "sz_rx_burst",
-		&instance->sz_rx_burst, MR_SERVICE_DEFAULT_SZ_RX_BURST);
-	MESA_load_profile_uint_def(cfg, "burst", "sz_tx_burst",
-		&instance->sz_tx_burst, MR_SERVICE_DEFAULT_SZ_TX_BURST);
+	struct sc_param * sc_param = &instance->sc_param;
+	
+	MESA_load_profile_uint_def(cfg, "tunnel", "sz_tunnel",
+		&sc_param->sz_tunnel, MR_SERVICE_DEFAULT_SZ_TUNNEL);
+	MESA_load_profile_uint_def(cfg, "tunnel", "sz_buffer",
+		&sc_param->sz_tunnel, MR_SERVICE_DEFAULT_SZ_TUNNEL);
+	MESA_load_profile_uint_def(cfg, "tunnel", "sz_burst",
+		&sc_param->sz_burst, MR_SERVICE_DEFAULT_SZ_BURST);
 	
 	//参数校验，不能大于MR_BURST_MAX
-	if(instance->sz_rx_burst > MR_BURST_MAX)
+	if(sc_param->sz_burst > MR_BURST_MAX)
 	{
-		MR_LOG(WARNING, SERVICE, "ServiceConfig, LoadBurstInfo, "
-			"Configure File Error, Invalid value(in key [%s]%s), "
+		MR_LOG(WARNING, SERVICE, "Configure File Error, Invalid value(in key [%s]%s), "
 			"should be less than MR_BURST_MAX=%d.\n", "burst", "sz_rx_burst",
 			MR_BURST_MAX);
 		return -1;
 	}
 
-	if(instance->sz_tx_burst > MR_BURST_MAX)
-	{
-		MR_LOG(WARNING, SERVICE, "ServiceConfig, LoadBurstInfo, "
-			"Configure File Error, Invalid value(in key [%s]%s), "
-			"should be less than MR_BURST_MAX=%d.\n", "burst", "sz_tx_burst",
-			MR_BURST_MAX);
-		return -1;
-	}
-
-	MR_LOG(INFO, SERVICE, "ServiceConfig, LoadBurstInfo, "
-		"sz_rx_burst=%d, sz_tx_burst=%d. \n", instance->sz_rx_burst, instance->sz_tx_burst);
-	
+	MR_LOG(INFO, SERVICE, "TunnelBurstInfo: sz_tunnel=%d, sz_buffer=%d, sz_burst=%d. \n",
+		sc_param->sz_tunnel, sc_param->sz_buffer, sc_param->sz_burst);
+		
 	return 0;
 }
 
 int sc_config_ldbc_dist_mode(const char * cfgfile, struct sc_instance * instance)
 {
+	struct sc_param * sc_param = &instance->sc_param;
 	MESA_load_profile_uint_def(cfgfile, "service","distmode", 
-		&instance->distmode, MR_SERVICE_DEFAULT_DIST_MODE);
-	
-	MR_LOG(INFO, SERVICE, "ServiceConfig, LoadDistMode"
-		"DistMode=(%d)%s\n", instance->distmode, str_dist_mode(instance->distmode));
+		&sc_param->distmode, MR_SERVICE_DEFAULT_DIST_MODE);
+
+	MR_LOG(INFO, SERVICE, "LoadDistMode : %s\n", str_dist_mode(sc_param->distmode));
 	return 0;
 }
 
 int sc_config_check_cfgfile(const char * cfg, struct sc_instance * instance)
 {
 	if (access(cfg, R_OK) == 0) return 0;
-	MR_LOG(WARNING, SERVICE, "ServiceConfig, CheckConfigFile, "
-		"Configure file %s cannot be read. \n", cfg);
+	MR_LOG(WARNING, SERVICE, "Configure file %s cannot be read. \n", cfg);
 	return -1;
 }
 
@@ -450,8 +332,6 @@ void sc_stage_config(struct sc_instance * instance)
 		"Please check configure file %s, Failed. ", cfgfile);
 	MR_CHECK(sc_config_device_info(cfgfile, instance) >= 0,
 		"Please check configure file %s, Failed. ", cfgfile);
-	MR_CHECK(sc_config_vnode_info(cfgfile, instance) >= 0,
-		"Please check configure file %s, Failed. ", cfgfile);
 	MR_CHECK(sc_config_burst_info(cfgfile, instance) >= 0,
 		"Please check configure file %s, Failed. ", cfgfile);
 	MR_CHECK(sc_config_ldbc_dist_mode(cfgfile, instance) >= 0,
diff --git a/service/src/register.c b/service/src/register.c
index c78eb17..8c02a90 100644
--- a/service/src/register.c
+++ b/service/src/register.c
@@ -16,12 +16,11 @@
 #include <mr_common.h>
 #include <sc_common.h>
 #include <mr_device.h>
-#include <mr_vman.h>
 #include <mr_mask.h>
+#include <mr_rtdev.h>
 #include <assert.h>
 #include <mr_runtime.h>
 #include <mr_rtdev.h>
-#include "mr_mrbuf.h"
 
 static int sc_core_instance_register(struct sc_instance * instance)
 {
@@ -49,7 +48,7 @@ static int sc_stack_instance_register(struct sc_instance * instance)
 	assert(g_cfg != NULL && g_ctx != NULL);
 
 	// 初始化协议栈全局句柄
-	instance->sk_instance = sk_instance_create(&instance->sk_param);
+	instance->sk_instance = sk_instance_create(&instance->sk_param, instance->core_instance);
 	g_ctx->ctx_stack = instance->sk_instance;
 	return 0;
 }
@@ -57,15 +56,14 @@ static int sc_stack_instance_register(struct sc_instance * instance)
 static int __mr_dev_register(struct sc_instance * instance, 
 	struct sc_device * sc_dev)
 {
-	// 计算默认队列数，队列数等于IO核心数
-	int nr_queues = mask_popcnt(instance->cpu_mask);
+	struct sc_param * sc_param = &instance->sc_param;
 
 	// 没有指定队列数，采用默认的队列数
 	if (sc_dev->mr_dev_param.nr_rss_rxq == 0)
-		sc_dev->mr_dev_param.nr_rss_rxq = nr_queues;
+		sc_dev->mr_dev_param.nr_rss_rxq = sc_param->nr_serv_thread;
 
 	if (sc_dev->mr_dev_param.nr_rss_txq == 0)
-		sc_dev->mr_dev_param.nr_rss_txq = nr_queues;
+		sc_dev->mr_dev_param.nr_rss_txq = sc_param->nr_serv_thread;
 
 	// 打开设备
 	struct mr_dev * dev = mr_device_open(&sc_dev->mr_dev_param);
@@ -79,6 +77,14 @@ static int __mr_dev_register(struct sc_instance * instance,
 		return -1;
 	}
 
+	// 打开设备队列
+	for (int i = 0; i < sc_param->nr_serv_thread; i++)
+	{
+		sc_dev->rx_devq[i] = mr_device_attach(dev, DEVQ_TYPE_RSS_RX);
+		sc_dev->tx_devq[i] = mr_device_attach(dev, DEVQ_TYPE_RSS_TX);
+		assert(sc_dev->rx_devq[i] != NULL && sc_dev->tx_devq[i] != NULL);
+	}
+	
 	sc_dev->dev = dev;
 	return 0;
 }
@@ -86,26 +92,27 @@ static int __mr_dev_register(struct sc_instance * instance,
 static int __rt_dev_register(struct sc_instance * instance,
 	struct sc_device * sc_dev)
 {
-	// 计算默认队列数，队列数等于IO核心数
-	int nr_queues = mask_popcnt(instance->cpu_mask);
-
+	struct sc_param * sc_param = &instance->sc_param;
+	
+	// 获取mempool指针
+	struct rte_mempool * direct_pool = mr_device_direct_pool_get(sc_dev->dev);
+	assert(direct_pool != NULL);
+	
 	// 创建运行时设备
-	int ret = rt_device_serv_create(sc_dev->symbol, instance->procsym,
-		nr_queues, instance->sz_rxvnode_ring, instance->sz_rxvnode_buffer);
-
-	if (unlikely(ret < 0))
+	struct rtdev_desc * rtdev = mr_rtdev_create(instance->core_instance, sc_dev->symbol,
+		direct_pool, sc_param->nr_serv_thread, sc_param->sz_tunnel,
+		sc_param->sz_buffer);
+	
+	if (unlikely(rtdev == NULL))
 	{
-		MR_LOG(WARNING, SERVICE, "Service, RtdeviceRegister, "
-			"Rtdevice %s(nr_queue=%d, sz_tunnel=%d, sz_buffer=%d) create failed. \n",
-			sc_dev->symbol, nr_queues, instance->sz_rxvnode_ring, 
-			instance->sz_rxvnode_buffer);
-		return ret;
+		MR_LOG(ERR, SERVICE, "Rtdevice %s(nr_queue=%d, sz_tunnel=%d, sz_buffer=%d) create failed. \n",
+			sc_dev->symbol, sc_param->nr_serv_thread, sc_param->sz_tunnel, sc_param->sz_buffer);
+		return -1;
 	}
 
-	MR_LOG(INFO, SERVICE, "Service, RtdeviceRegister, "
-		"Rtdevice %s(nr_queue=%d, sz_tunnel=%d, sz_buffer=%d) created. \n",
-		sc_dev->symbol, nr_queues, instance->sz_rxvnode_ring, 
-		instance->sz_rxvnode_buffer);
+	sc_dev->rt_dev = rtdev;
+	MR_LOG(INFO, SERVICE, "Rtdevice %s(nr_queue=%d, sz_tunnel=%d, sz_buffer=%d) created. \n",
+		sc_dev->symbol, sc_param->nr_serv_thread, sc_param->sz_tunnel, sc_param->sz_buffer);
 
 	return 0;
 }
@@ -113,35 +120,28 @@ static int __rt_dev_register(struct sc_instance * instance,
 static int __sk_dev_register(struct sc_instance * instance,
 	struct sc_device * sc_dev)
 {
-	// 计算默认队列数，队列数等于IO核心数
-	int nr_queues = mask_popcnt(instance->cpu_mask);
-
 	// 跳过没有启用协议栈的设备
 	if(!(sc_dev->en_mr_dev && sc_dev->en_sk_dev))
 	{
-		MR_LOG(INFO, SERVICE, "Service, StackDeviceRegister, "
-			"StackDevice %s is disable, ignore. \n", sc_dev->symbol);
+		MR_LOG(INFO, SERVICE, "Device %s user-mode stack is disable, ignore. \n", sc_dev->symbol);
 		return 0;
 	}
 
+	struct sc_param * sc_param = &instance->sc_param;
 	struct rte_mempool * direct_pool = mr_device_direct_pool_get(sc_dev->dev);
 	struct rte_mempool * indirect_pool = mr_device_direct_pool_get(sc_dev->dev);
-
-	// TODO:错误处理
 	assert(direct_pool != NULL && indirect_pool != NULL);
 	
 	sc_dev->sk_dev = sk_device_create(instance->sk_instance, &sc_dev->sk_dev_param,
-	                                  direct_pool, indirect_pool, nr_queues);
+	                                  direct_pool, indirect_pool, sc_param->nr_serv_thread);
 	
 	if(unlikely(sc_dev->sk_dev == NULL))
 	{
-		MR_LOG(WARNING, SERVICE, "Service, StackDeviceRegister, "
-			"StackDevice %s create failed. \n", sc_dev->sk_dev_param.symbol);
+		MR_LOG(WARNING, SERVICE, "StackDevice %s create failed. \n", sc_dev->sk_dev_param.symbol);
 		return -1;
 	}
 
-	MR_LOG(WARNING, SERVICE, "Service, StackDeviceRegister, "
-		"StackDevice %s created. \n", sc_dev->sk_dev_param.symbol);
+	MR_LOG(WARNING, SERVICE, "StackDevice %s created. \n", sc_dev->sk_dev_param.symbol);
 	return 0;
 }
 
@@ -167,8 +167,7 @@ static int sc_device_register(struct sc_instance * instance)
 
 		// 打开失败，移除设备链表
 device_open_fail:
-		MR_LOG(ERR, SERVICE, "ServiceDeviceRegister, "
-			"Device %s register failed. Disabled. \n", device_iter->symbol);
+		MR_LOG(ERR, SERVICE, "Device %s register failed. Disabled. \n", device_iter->symbol);
 		TAILQ_REMOVE(&instance->device_list, device_iter, next);
 	}
 	
@@ -181,14 +180,12 @@ int sc_app_register(struct sc_instance * instance)
 	int ret = mr_app_manager_appinfo_register(instance->procsym, instance->cpu_mask);
 	if(ret < 0)
 	{
-		MR_LOG(ERR, SERVICE, "Service, AppRegister, "
-			"Cannot register service application(sym=%s, cpu_mask=%"PRIx64")",
+		MR_LOG(ERR, SERVICE, "Cannot register service application(sym=%s, cpu_mask=%"PRIx64")",
 			instance->procsym, instance->cpu_mask);
 		return ret;
 	}
 
-	MR_LOG(INFO, SERVICE, "Service, AppRegister, "
-		"App(symbol=%s) Process(cpu_mask=%"PRIx64") registered.\n",
+	MR_LOG(INFO, SERVICE, "App(symbol=%s) Process(cpu_mask=%"PRIx64") registered.\n",
 		instance->procsym, instance->cpu_mask);
 	
 	return 0;
diff --git a/service/src/runtime.c b/service/src/runtime.c
deleted file mode 100644
index 28887a7..0000000
--- a/service/src/runtime.c
+++ /dev/null
@@ -1,114 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <assert.h>
-#include <rte_malloc.h>
-#include <rte_log.h>
-#include <mr_common.h>
-#include <mr_runtime.h>
-#include <mr_device.h>
-#include <sc_common.h>
-
-
-void sc_thread_instance_init(struct sc_instance * instance,
-	struct sc_thread_instance * tinstance)
-{
-	tinstance->rt_dev = rte_zmalloc(NULL, sizeof(struct sc_rt_device) * instance->nr_devs, 0);
-	tinstance->nr_devices = 0;
-	assert(tinstance->rt_dev != NULL);
-	return;
-}
-
-void sc_thread_device_attach(struct sc_instance * instance, 
-	struct sc_thread_instance * tinstance)
-{
-	struct sc_device * sc_dev_iter;
-	int nr_devices = 0;
-
-	TAILQ_FOREACH(sc_dev_iter, &instance->device_list, next)
-	{
-		struct mr_dev_q * rx_devq = mr_device_attach(sc_dev_iter->dev, DEVQ_TYPE_RSS_RX);
-		if (rx_devq == NULL)
-		{
-			MR_LOG(WARNING, SERVICE, "Service, RuntimeThread, "
-				"Cannot attach device %s for thread %d, Ignore the device.\n",
-				sc_dev_iter->symbol, mr_thread_id());
-			continue;
-		}
-
-		struct mr_dev_q * tx_devq = mr_device_attach(sc_dev_iter->dev, DEVQ_TYPE_RSS_TX);
-		if (tx_devq == NULL)
-		{
-			MR_LOG(WARNING, SERVICE, "Service, RuntimeThread, "
-				"Cannot attach device %s for thread %d, Ignore the device.\n",
-				sc_dev_iter->symbol, mr_thread_id());
-			continue;
-		}
-
-		// 附着运行时设备
-		struct mr_rtdev_stream * rtstream;
-		rtstream = rt_dev_serv_open_stream(sc_dev_iter->symbol,
-			instance->procsym);
-
-		if (rtstream == NULL)
-		{
-			MR_LOG(WARNING, SERVICE, "Service, RuntimeThread, "
-				"Cannot attach rtdevice %s for thread %d, Ignore the device.\n",
-				sc_dev_iter->symbol, mr_thread_id());
-			continue;
-		}
-
-		MR_LOG(INFO, SERVICE, "Service, RuntimeThread, "
-			"Attach Device %s for thread %d success.\n",
-			sc_dev_iter->symbol, mr_thread_id());
-
-		// 存储句柄到私有存储空间，下面收发包时使用
-		tinstance->rt_dev[nr_devices].rx_devq = rx_devq;
-		tinstance->rt_dev[nr_devices].tx_devq = tx_devq;
-		tinstance->rt_dev[nr_devices].rtstream = rtstream;
-		tinstance->rt_dev[nr_devices].sk_dev = sc_dev_iter->sk_dev;
-		nr_devices++;
-	}
-
-	tinstance->nr_devices = nr_devices;
-	return;
-}
-
-extern void sc_thread_rx_loop(struct sc_instance * instance,
-	struct sc_thread_instance * tinstance);
-
-extern void sc_thread_tx_loop(struct sc_instance * instance,
-	struct sc_thread_instance * tinstance);
-
-extern void sc_thread_timer_loop(struct sc_instance * instance,
-	struct sc_thread_instance * tinstance);
-
-void * sc_runtime_thread(void * args)
-{
-	mr_app_manager_thread_register();
-	struct sc_instance * instance = (struct sc_instance *)args;
-
-	MR_LOG(INFO, SERVICE, "Service, RuntimeThread, "
-		"Thread ID %d Running, CPU_ID=%d, Socket_ID=%d\n",
-		mr_thread_id(), mr_cpu_id(), mr_socket_id());
-
-	/* 分配线程私有存储空间 */
-	struct sc_thread_instance * tinstance;
-	tinstance = rte_zmalloc(NULL, sizeof(struct sc_thread_instance), 0);
-	MR_CHECK(tinstance != NULL, "Service, RuntimeThread, "
-		"Cannot alloc memory for thread private instance, Failed.\n");
-
-	/* 初始化线程私有存储空间 */
-	sc_thread_instance_init(instance, tinstance);
-	/* 线程Attach设备操作 */
-	sc_thread_device_attach(instance, tinstance);
-				
-	while(1)
-	{
-		sc_thread_rx_loop(instance, tinstance);
-		sc_thread_tx_loop(instance, tinstance);
-		sc_thread_timer_loop(instance, tinstance);
-	}
-
-	return NULL;
-}
\ No newline at end of file
diff --git a/service/src/rxtx.c b/service/src/rxtx.c
index bcba6e1..919717b 100644
--- a/service/src/rxtx.c
+++ b/service/src/rxtx.c
@@ -15,89 +15,120 @@ void __free_mbufs(struct rte_mbuf * bufs[], int nr_bufs)
 	return;
 }
 
-static inline void __rx_loop_one_device(struct sc_instance * instance,
-	struct sc_thread_instance * tinstance, struct sc_rt_device * rtdev,
-	unsigned int nr_rx_burst)
+int rt_serv_device_rx_bulk(struct rtdev_desc * dev_desc, thread_id_t sid,
+	struct rte_mbuf * mbufs_in[], struct rte_mbuf * mbufs_out[], int nr_mbufs_in, int * nr_mbufs_out)
 {
-	struct rte_mbuf * rx_bufs_in[MR_BURST_MAX];
-	hash_t hash_result[MR_BURST_MAX];
-	int ret;
+	hash_t hash[MR_BURST_MAX];	*nr_mbufs_out = 0;
+	for (int i = 0; i < nr_mbufs_in; i++) hash[i] = mbufs_in[i]->hash.usr;
+	vnode_enqueue_burst_with_hash(dev_desc->vnode_prod_rx, &dev_desc->ops, sid, (void **)mbufs_in, hash, nr_mbufs_in);
+	return 0;
+}
 
-	struct mr_dev_q * devq = rtdev->rx_devq;
-	struct mr_rtdev_stream * rtstream = rtdev->rtstream;
+int rt_serv_device_tx_bulk(struct rtdev_desc * dev_desc, thread_id_t sid,
+	struct rte_mbuf * mbufs_out[], int nr_mbufs, int * nr_mbufs_out)
+{
+	int __nr_mbufs_out = 0; int __nr_mbufs_left = nr_mbufs;
+	struct rte_mbuf ** mbufs_out_curser = mbufs_out;
 
-	uint16_t nr_rx_bufs = rte_eth_rx_burst(devq->port_id,
-		devq->queue_id, rx_bufs_in, nr_rx_burst);
+	// ��FTXͨ��ȡ��
+	int ret = vnode_dequeue_burst(dev_desc->vnode_cons_ftx, &dev_desc->ops, sid,
+		(void **)mbufs_out_curser, __nr_mbufs_left);
+	
+	__nr_mbufs_out += ret;
+	__nr_mbufs_left -= __nr_mbufs_out;
+	mbufs_out_curser += __nr_mbufs_out;
+	
+	// ʣ�����������TXͨ��ȡ
+	ret = vnode_dequeue_burst(dev_desc->vnode_cons_tx, &dev_desc->ops, sid,
+		(void **)mbufs_out_curser, __nr_mbufs_left);
 
-	// û�����ݰ�ֱ������
-	if (unlikely(nr_rx_bufs == 0)) return;
+	__nr_mbufs_out += ret;
+	*nr_mbufs_out = __nr_mbufs_out;
+	return 0;
+}
 
-	int nr_rx_bufs_len = pktslen(rx_bufs_in, nr_rx_bufs);
-	UPDATE_DEV_STAT(dev_rx_frame, devq->port_id, nr_rx_bufs);
-	UPDATE_DEV_STAT(dev_rx_bit, devq->port_id, nr_rx_bufs_len);
-	UPDATE_APP_STAT(rx_frame, nr_rx_bufs);
-	UPDATE_APP_STAT(rx_byte, nr_rx_bufs_len);
+static inline void __tx_loop_one_device(struct sc_instance * instance, thread_id_t tid,
+	struct sc_device * sc_dev, unsigned int nr_rx_burst)
+{
+	return;
+}
 
+static inline void __rx_loop_one_device(struct sc_instance * instance, thread_id_t tid,
+	struct sc_device * sc_dev, unsigned int nr_rx_burst)
+{
+	struct rte_mbuf * rx_bufs_in[MR_BURST_MAX];
+	struct rte_mbuf * rx_bufs_out[MR_BURST_MAX];
+	hash_t hash_result[MR_BURST_MAX];
 
-#if 0
-	// �������ݰ����طֵ�ʹ�õ�Hashֵ
-	ret = distributer_hash_caculate(instance->distmode,
-		rx_bufs, nr_rx_bufs, hash_result);
-	if (unlikely(ret < 0)) goto err_free_mbufs;
+	int nr_rx_bufs_in;
+	int nr_rx_bufs_out;
+	struct mr_dev_q * devq = sc_dev->rx_devq[tid];
+	assert(devq != NULL);
+	
+	nr_rx_bufs_in = rte_eth_rx_burst(devq->port_id, devq->queue_id, rx_bufs_in, nr_rx_burst);
+	if (unlikely(nr_rx_bufs_in == 0)) return;
 
-	// ����VNode�У��ַ�����Ӧ��
-	struct vnodeman_attach_desc * attach_desc = rtstream->rxd;
-	ret = vnode_enqueue_burst_with_hash(attach_desc->prod, &vnodeman_ops,
-		attach_desc->queue_id, (void **)rx_bufs, hash_result, nr_rx_bufs);
-	if (unlikely(ret < 0)) goto err_free_mbufs;
+	int nr_rx_bufs_len = pktslen(rx_bufs_in, nr_rx_bufs_in);
+	UPDATE_DEV_STAT(dev_rx_frame, devq->port_id, nr_rx_bufs_in);
+	UPDATE_DEV_STAT(dev_rx_bit, devq->port_id, nr_rx_bufs_len);
+	UPDATE_APP_STAT(rx_frame, nr_rx_bufs_in);
+	UPDATE_APP_STAT(rx_byte, nr_rx_bufs_len);
 
-#endif
+	int ret = distributer_hash_caculate(instance->sc_param.distmode,
+		rx_bufs_in, nr_rx_bufs_in, hash_result);
 
-	thread_id_t sid = mr_thread_id();
+	if (unlikely(ret < 0)) goto clean;
+	for (int i = 0; i < nr_rx_bufs_in; i++) rx_bufs_in[i]->hash.usr = hash_result[i];
 
-	struct rte_mbuf * rx_bufs_out[MR_BURST_MAX];
-	int nr_rx_bufs_out;
-	
-	sk_serv_device_rx_bulk(rtdev->sk_dev, sid, rx_bufs_in, rx_bufs_out,
-		nr_rx_bufs, &nr_rx_bufs_out);
-	
-	for (int i = 0; i < nr_rx_bufs_out; i++)
-		rte_pktmbuf_free(rx_bufs_out[i]);
-	
-	return;
+	sk_serv_device_rx_bulk(sc_dev->sk_dev, tid, rx_bufs_in, rx_bufs_out, nr_rx_bufs_in
+		, &nr_rx_bufs_out);
 
-err_free_mbufs:
-	for (int i = 0; i < nr_rx_bufs; i++)
+	rt_serv_device_rx_bulk(sc_dev->rt_dev, tid, rx_bufs_out, rx_bufs_in, nr_rx_bufs_out, 
+		&nr_rx_bufs_in);
+			
+clean:
+	for (int i = 0; i < nr_rx_bufs_in; i++)
 		rte_pktmbuf_free(rx_bufs_in[i]);
-
-	UPDATE_APP_STAT(drop_frame, nr_rx_bufs);
+	
 	return;
 }
 
 
-void sc_thread_rx_loop(struct sc_instance * instance,
-	struct sc_thread_instance * tinstance)
+void sc_thread_rxtx_loop(struct sc_instance * instance, thread_id_t tid)
 {
 	PERF_BEGIN(sc_rx_loop_all);
+	unsigned int sz_burst = instance->sc_param.sz_burst;
 
-	for (unsigned int i = 0; i < tinstance->nr_devices; i++)
+	struct sc_device * device_iter;
+	TAILQ_FOREACH(device_iter, &instance->device_list, next)
 	{
-		__rx_loop_one_device(instance, tinstance,
-			&tinstance->rt_dev[i], instance->sz_rx_burst);
+		__rx_loop_one_device(instance, tid, device_iter, sz_burst);
+		__tx_loop_one_device(instance, tid, device_iter, sz_burst);
 	}
 	
 	PERF_END(sc_rx_loop_all);
 	return;
 }
 
-void sc_thread_tx_loop(struct sc_instance * instance,
-	struct sc_thread_instance * tinstance)
+void sc_thread_timer_loop(struct sc_instance * instance, thread_id_t tid)
 {
 	return;
 }
 
-void sc_thread_timer_loop(struct sc_instance * instance,
-	struct sc_thread_instance * tinstance)
+void * sc_runtime_thread(void * args)
 {
-	return;
+	mr_app_manager_thread_register();
+	struct sc_instance * instance = (struct sc_instance *)args;
+	thread_id_t tid = mr_thread_id();
+	
+	MR_LOG(INFO, SERVICE, "Thread ID=%d Running, CPU_ID=%d, Socket_ID=%d\n",
+		mr_thread_id(), mr_cpu_id(), mr_socket_id());
+
+	while (1)
+	{
+		sc_thread_rxtx_loop(instance, tid);
+		sc_thread_timer_loop(instance, tid);
+	}
+
+	return NULL;
 }
\ No newline at end of file
diff --git a/stack/CMakeLists.txt b/stack/CMakeLists.txt
index 345e8b4..6b37830 100644
--- a/stack/CMakeLists.txt
+++ b/stack/CMakeLists.txt
@@ -7,7 +7,7 @@ include_directories(${DPDK_INCLUDE_DIR})
 add_definitions(${DPDK_C_PREDEFINED})

 include_directories(include)

 add_library(stack src/stack.c src/device.c src/neigh.c src/rxtx.c src/protocol-common.c

-	src/protocol-arp.c src/protocol-tcp.c src/protocol-udp.c src/protocol-raw.c)

+	src/protocol-arp.c src/protocol-tcp.c src/protocol-udp.c)

 target_link_libraries(stack MESA_prof_load_static mruntime core)

 target_link_libraries(stack rt pthread dl)

 target_include_directories(stack INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include/")
\ No newline at end of file
diff --git a/stack/include/sk_device.h b/stack/include/sk_device.h
index a06947e..4119c09 100644
--- a/stack/include/sk_device.h
+++ b/stack/include/sk_device.h
@@ -124,18 +124,14 @@ struct sk_dev_desc
 	struct rte_ring * rx_loop_buffer[MR_SID_MAX];
 	// ��ѭ�����Ļ��������ڷ����������д�����
 	struct rte_ring * tx_loop_buffer[MR_SID_MAX];
-	// Raw�� Rt-Device Stream
-	struct mr_rtdev_stream * raw_rtdev_rxstream[MR_SID_MAX];
-	// Raw�� Rt-Device Stream
-	struct mr_rtdev_stream * raw_rtdev_txstream[MR_SID_MAX];
-	// TCP�� Rt-Device Stream
-	struct mr_rtdev_stream * tcp_rtdev_rxstream[MR_SID_MAX];
-	// TCP�� Rt-Device Stream
-	struct mr_rtdev_stream * tcp_rtdev_txstream[MR_SID_MAX];
-	// UDP�� Rt-Device Stream
-	struct mr_rtdev_stream * udp_rtdev_rxstream[MR_SID_MAX];
-	// UDP�� Rt-Device Stream
-	struct mr_rtdev_stream * udp_rtdev_txstream[MR_SID_MAX];
+	// tcpЭ�����豸
+	struct rtdev_desc * tcp_device;
+	// udpЭ�����豸
+	struct rtdev_desc * udp_device;
+	// tcpЭ��Ӧ�����豸
+	struct rtdev_app_desc * tcp_app_device;
+	// udpЭ��Ӧ�����豸
+	struct rtdev_app_desc * udp_app_device;
 
 	// SID��������
 	rte_spinlock_t sid_alloc_lock;
diff --git a/stack/include/sk_protocol_common.h b/stack/include/sk_protocol_common.h
index 8a02ac4..f6fd553 100644
--- a/stack/include/sk_protocol_common.h
+++ b/stack/include/sk_protocol_common.h
@@ -3,19 +3,9 @@
 #include <mr_rtdev.h>

 #include <sk_device.h>

 

-// ����Э��ӽ��̳�ʼ�����������ٶ�Ӧ������ʱ�豸��

-void protocol_common_dev_desc_slave_deinit(struct sk_slave_instance * slave_instance,

-	struct sk_dev_desc * dev_desc, const char * protosym,

-	struct mr_rtdev_stream ** ptr_rxstream, struct mr_rtdev_stream ** ptr_txstream,

-	unsigned int nr_rxstream, unsigned int nr_txstream);

-

-// ����Э���ʼ��������������Ӧ������ʱ�豸��

 int protocol_common_dev_desc_init(struct sk_instance * instance,

-	struct sk_dev_desc * dev_desc, const char * protosym,

-	struct mr_rtdev_stream ** ptr_rxstream, struct mr_rtdev_stream ** ptr_txstream);

+	struct sk_dev_desc * dev_desc, const char * protosym, struct rtdev_desc ** rtdev_desc);

 

-// ����Э��ӽ��̳�ʼ��������������Ӧ������ʱ�豸��

 int protocol_common_dev_desc_slave_init(struct sk_slave_instance * slave_instance,

-	struct sk_dev_desc * dev_desc, const char * protosym,

-	struct mr_rtdev_stream ** ptr_rxstream, struct mr_rtdev_stream ** ptr_txstream,

+	struct sk_dev_desc * dev_desc, const char * protosym, struct rtdev_app_desc ** rtdev_app_desc,

 	unsigned int nr_rxstream, unsigned int nr_txstream);
\ No newline at end of file
diff --git a/stack/include/sk_stack.h b/stack/include/sk_stack.h
index 72ac9b3..9012459 100644
--- a/stack/include/sk_stack.h
+++ b/stack/include/sk_stack.h
@@ -51,6 +51,8 @@ struct sk_instance
 {
 	// Э��ջ���в���
 	struct sk_param param;
+	// Coreָ��
+	struct mr_core_instance * core_instance;
 	// Э��ջ�豸��Ϣ
 	struct sk_dev_info_list dev_info_list;
 	// Э��ջ�豸���
@@ -69,7 +71,7 @@ struct sk_slave_instance
 	struct sk_dev_desc_list dev_desc_list;
 };
 
-struct sk_instance * sk_instance_create(struct sk_param * param);
+struct sk_instance * sk_instance_create(struct sk_param * param, struct mr_core_instance * core_instance);
 
 struct sk_slave_instance * sk_slave_instance_create(const char* appsym, struct sk_instance * instance);
 
diff --git a/stack/src/device.c b/stack/src/device.c
index 15f568c..e2634cb 100644
--- a/stack/src/device.c
+++ b/stack/src/device.c
@@ -184,10 +184,6 @@ struct sk_dev_desc * sk_device_create(struct sk_instance* instance, struct sk_de
 	int ret = __sk_device_create_loop_buffer(instance, param, dev_info, dev_desc);
 	if (unlikely(ret < 0)) goto err_out;
 
-	ret = protocol_raw_dev_desc_init(instance, dev_desc);
-	if (unlikely(ret < 0)) goto err_out;
-	
-	
 	// 加入到协议栈设备链表中
 	TAILQ_INSERT_TAIL(&instance->dev_info_list, dev_info, next);
 	// 加入协议栈描述符列表
@@ -224,9 +220,6 @@ int sk_device_open(struct sk_slave_instance * slave_instance,
 		return -ENOMEM;
 	}
 
-	int ret = protocol_raw_dev_desc_slave_init(slave_instance, dev_desc);
-	if (ret < 0) goto err_out;
-
 	TAILQ_INSERT_TAIL(&slave_instance->dev_desc_list, dev_desc, next);
 	
 	MR_LOG(ERR, STACK, "Sk-device %s opened. \n", devinfo->symbol);
diff --git a/stack/src/protocol-common.c b/stack/src/protocol-common.c
index 41a0681..5295c8a 100644
--- a/stack/src/protocol-common.c
+++ b/stack/src/protocol-common.c
@@ -4,51 +4,22 @@
 #include <sk_stack.h>

 #include <sk_protocol_common.h>

 

-void protocol_common_dev_desc_slave_deinit(struct sk_slave_instance * slave_instance, 

-	struct sk_dev_desc * dev_desc, const char * protosym, 

-	struct mr_rtdev_stream ** ptr_rxstream, struct mr_rtdev_stream ** ptr_txstream,

-	unsigned int nr_rxstream, unsigned int nr_txstream)

-{

-	char rtdevsym[MR_SYMBOL_MAX];

-	snprintf(rtdevsym, sizeof(rtdevsym), "%s-%s", dev_desc->dev_info->symbol, protosym);

-

-	// �ر��Ѿ��򿪵�rx��

-	for (unsigned int stream_id = 0; stream_id < nr_rxstream; stream_id++)

-	{

-		if (ptr_rxstream[stream_id] == NULL) continue;

-		rt_dev_stream_close(ptr_rxstream[stream_id]);

-		ptr_rxstream[stream_id] = NULL;

-	}

-

-	// �ر��Ѿ��򿪵�tx��

-	for (unsigned int stream_id = 0; stream_id < nr_txstream; stream_id++)

-	{

-		if (ptr_txstream[stream_id] == NULL) continue;

-		rt_dev_stream_close(ptr_txstream[stream_id]);

-		ptr_txstream[stream_id] = NULL;

-	}

-

-	// �ر�����ʱ�豸

-	rt_device_close(rtdevsym, slave_instance->appsym);

-	return;

-}

-

 // ����Э���ʼ��������������Ӧ������ʱ�豸��

 int protocol_common_dev_desc_init(struct sk_instance * instance, 

-	struct sk_dev_desc * dev_desc, const char * protosym, 

-	struct mr_rtdev_stream ** ptr_rxstream, struct mr_rtdev_stream ** ptr_txstream)

+	struct sk_dev_desc * dev_desc, const char * protosym, struct rtdev_desc ** rtdev_desc)

 {

 	struct sk_param * param = &instance->param;

+	struct rtdev_desc * _rtdev_desc;

 

 	char rtdevsym[MR_SYMBOL_MAX];

 	snprintf(rtdevsym, sizeof(rtdevsym), "%s-%s", dev_desc->dev_info->symbol, protosym);

 

 	// ��������ʱ�豸

-	int ret = rt_device_serv_create(rtdevsym, param->servsym, param->nr_serv_thread,

-		param->sz_deliver_ring, param->sz_deliver_buffer);

+	_rtdev_desc = mr_rtdev_create(instance->core_instance, rtdevsym,

+		dev_desc->direct_pool, param->nr_serv_thread, param->sz_deliver_ring, param->sz_deliver_buffer);

 

 	// ����ʧ��

-	if (ret < 0)

+	if (_rtdev_desc == NULL)

 	{

 		MR_LOG(WARNING, STACK, "Create rt-device(protosym=%s) for sk-dev %s"

 			"(serv_sym=%s, nr_thread=%d, sz_ring=%d, sz_buffer=%d) failed. \n",

@@ -56,41 +27,25 @@ int protocol_common_dev_desc_init(struct sk_instance * instance,
 			param->sz_deliver_ring, param->sz_deliver_buffer);

 		return -1;

 	}

-

-	// ÿ���߳�һ�����򿪣�rx����tx������

-	for (int i = 0; i < param->nr_serv_thread; i++)

-	{

-		struct mr_rtdev_stream * stream;

-		stream = rt_dev_serv_open_stream(rtdevsym, param->servsym);

-		if (stream == NULL) goto err_stream;

-

-		ptr_rxstream[i] = stream;

-		ptr_txstream[i] = stream;

-	}

-

+	

+	*rtdev_desc = _rtdev_desc;

 	return 0;

-

-err_stream:

-	MR_LOG(WARNING, STACK, "Open rt-device stream for sk-dev %s(protocol=%s) failed. \n",

-		rtdevsym, protosym);

-	rt_device_serv_destory(rtdevsym);

-	return -2;

 }

 

 int protocol_common_dev_desc_slave_init(struct sk_slave_instance * slave_instance, 

-	struct sk_dev_desc * dev_desc, const char * protosym, 

-	struct mr_rtdev_stream ** ptr_rxstream, struct mr_rtdev_stream ** ptr_txstream,

-	unsigned int nr_rxstream, unsigned int nr_txstream)

+	struct sk_dev_desc * dev_desc, const char * protosym, struct rtdev_app_desc ** rtdev_app_desc,

+		unsigned int nr_rxstream, unsigned int nr_txstream)

 {

 	char rtdevsym[MR_SYMBOL_MAX];

 	snprintf(rtdevsym, sizeof(rtdevsym), "%s-%s", dev_desc->dev_info->symbol, protosym);

+	struct rtdev_app_desc * _rtdev_app_desc;

 

 	// ��������ʱ�豸

-	int ret = rt_device_open(dev_desc->dev_info->symbol, slave_instance->appsym,

-		nr_rxstream, nr_txstream);

+	_rtdev_app_desc = mr_rt_device_open(slave_instance->instance->core_instance,

+		dev_desc->dev_info->symbol, slave_instance->appsym,	nr_rxstream, nr_txstream);

 

 	// ����ʧ��

-	if (ret < 0)

+	if (_rtdev_app_desc == NULL)

 	{

 		MR_LOG(WARNING, STACK, "Open rt-device(protosym=%s) for sk-dev %s"

 			"(nr_rxstream=%d, nr_txstream=%d) failed. \n", protosym, 

@@ -98,34 +53,6 @@ int protocol_common_dev_desc_slave_init(struct sk_slave_instance * slave_instanc
 		return -1;

 	}

 

-	// ��rx��

-	for (unsigned int stream_id = 0; stream_id < nr_rxstream; stream_id++)

-	{

-		ptr_rxstream[stream_id] = rt_dev_open_stream(dev_desc->dev_info->symbol,

-			slave_instance->appsym, RTDEV_FLAGS_OPEN_STREAM_RX);

-

-		if (ptr_rxstream[stream_id] != NULL) continue;

-		MR_LOG(WARNING, STACK, "Open rt-device rxstream failed(sk_dev=%s, stream_id=%d)\n",

-			dev_desc->dev_info->symbol, stream_id);

-		goto err_stream;

-	}

-

-	// ��tx��

-	for (unsigned int stream_id = 0; stream_id < nr_txstream; stream_id++)

-	{

-		ptr_txstream[stream_id] = rt_dev_open_stream(dev_desc->dev_info->symbol,

-			slave_instance->appsym, RTDEV_FLAGS_OPEN_STREAM_TX);

-

-		if (ptr_txstream[stream_id] != NULL) continue;

-		MR_LOG(WARNING, STACK, "Open rt-device txstream failed(sk_dev=%s, stream_id=%d)\n",

-			dev_desc->dev_info->symbol, stream_id);

-		goto err_stream;

-	}

-

+	*rtdev_app_desc = _rtdev_app_desc;

 	return 0;

-

-err_stream:

-	protocol_common_dev_desc_slave_deinit(slave_instance, dev_desc, protosym,

-		ptr_rxstream, ptr_rxstream, nr_rxstream, nr_txstream);

-	return -2;

 }
\ No newline at end of file
diff --git a/stack/src/protocol-raw.c b/stack/src/protocol-raw.c
deleted file mode 100644
index e96befe..0000000
--- a/stack/src/protocol-raw.c
+++ /dev/null
@@ -1,40 +0,0 @@
-

-#include <mr_rtdev.h>

-#include <sk_device.h>

-#include <sk_stack.h>

-#include <sk_protocol_common.h>

-

-int protocol_raw_dev_desc_init(struct sk_instance * instance, struct sk_dev_desc * dev_desc)

-{

-	int ret = protocol_common_dev_desc_init(instance, dev_desc, "raw", 

-		dev_desc->raw_rtdev_rxstream, dev_desc->raw_rtdev_txstream);

-

-	if(ret >= 0)

-		MR_LOG(NOTICE, STACK, "Sk-device %s protocol raw ready. \n", dev_desc->dev_info->symbol);

-

-	return ret;

-}

-

-int protocol_raw_dev_desc_slave_init(struct sk_slave_instance * slave_instance,

-	struct sk_dev_desc * dev_desc)

-{

-	int ret = protocol_common_dev_desc_slave_init(slave_instance, dev_desc, "raw",

-		dev_desc->raw_rtdev_rxstream, dev_desc->raw_rtdev_txstream,

-		dev_desc->open_param.nr_raw_rxstream, dev_desc->open_param.nr_raw_txstream);

-

-	if (ret >= 0)

-		MR_LOG(NOTICE, STACK, "Sk-device %s protocol raw ready. \n", dev_desc->dev_info->symbol);

-	

-	return 0;

-}

-

-int protocol_raw_dev_desc_slave_deinit(struct sk_slave_instance * slave_instance,

-	struct sk_dev_desc * dev_desc)

-{

-	protocol_common_dev_desc_slave_deinit(slave_instance, dev_desc, "raw",

-		dev_desc->raw_rtdev_rxstream, dev_desc->raw_rtdev_txstream,

-		dev_desc->open_param.nr_raw_rxstream, dev_desc->open_param.nr_raw_txstream);

-

-	MR_LOG(NOTICE, STACK, "Sk-device %s protocol raw deinited. \n", dev_desc->dev_info->symbol);

-	return 0;

-}
\ No newline at end of file
diff --git a/stack/src/stack.c b/stack/src/stack.c
index 9b8cdb8..05f6b2b 100644
--- a/stack/src/stack.c
+++ b/stack/src/stack.c
@@ -33,8 +33,7 @@ int sk_instance_init(struct sk_instance * instance)
 	return 0;
 }
 
-
-struct sk_instance * sk_instance_create(struct sk_param * param)
+struct sk_instance * sk_instance_create(struct sk_param * param, struct mr_core_instance * core_instance)
 {
 	struct sk_instance * instance;
 
@@ -49,12 +48,14 @@ struct sk_instance * sk_instance_create(struct sk_param * param)
 
 	// 初始化参数
 	instance->param = *param;
+	instance->core_instance = core_instance;
 	TAILQ_INIT(&instance->dev_info_list);
 	TAILQ_INIT(&instance->dev_desc_list);
 
 	// 初始化邻居管理器
 	struct neighbour_manager * neigh_manager;
 	neigh_manager = rte_zmalloc(NULL, sizeof(struct neighbour_manager), 0);
+
 	if(unlikely(neigh_manager == NULL))
 	{
 		MR_LOG(WARNING, STACK, "StackInstanceCreate, "