int test_async_coroutine(int /*argc*/, char * /*argv*/[])
{
int ret = 0;
const unsigned int CMD_1 = 10001;
const unsigned int CMD_2 = 10002;
//const unsigned int CMD_3 = 10003;
ZCE_Timer_Queue_Base *time_queue = new ZCE_Timer_Wheel();
ZCE_Async_CoroutineMgr *mgr = new ZCE_Async_CoroutineMgr();
mgr->initialize(time_queue, 100, 2000);
mgr->register_asyncobj(CMD_1, new Coroutine_1(mgr, CMD_1));
mgr->register_asyncobj(CMD_2, new Coroutine_2(mgr, CMD_2));
unsigned int fsm1_async_id1;
ret = mgr->create_asyncobj(CMD_1, NULL,&fsm1_async_id1);
unsigned int fsm1_async_id2;
ret = mgr->create_asyncobj(CMD_1, NULL, &fsm1_async_id2);
ret = mgr->active_asyncobj(fsm1_async_id1,NULL);
ret = mgr->active_asyncobj(fsm1_async_id2, NULL);
ret = mgr->active_asyncobj(fsm1_async_id1, NULL);
ret = mgr->active_asyncobj(fsm1_async_id2, NULL);
ZCE_ASSERT(ret == 0);
return 0;
}
int NotifyTrans_Manger<ZCE_NULL_SYNCH>::active_notify_task(NotifyTrans_TaskBase * /*clone_task*/,
size_t /*task_num*/,
size_t /*task_stack_size*/ )
{
ZCE_ASSERT(false);
return 0;
}
//构造函数,
ZCE_Process_Semaphore::ZCE_Process_Semaphore(unsigned int init_value,
const char *sem_name):
lock_(NULL)
{
ZCE_ASSERT(sem_name);
int ret = 0;
sema_name_[0] = '\0';
sema_name_[sizeof(sema_name_) - 1] = '\0';
//玩有名的信号灯,名字可以考虑用unique_name函数获得
strncpy(sema_name_, sem_name, PATH_MAX);
lock_ = ZCE_OS::sem_open(sem_name, O_CREAT, ZCE_DEFAULT_FILE_PERMS, init_value);
if (!lock_)
{
ret = -1;
ZCE_TRACE_FAIL_RETURN(RS_ERROR, "ZCE_OS::sem_open fail.", ret);
}
}
//以时间为基数产生UUID64
ZCE_UUID64 ZCE_UUID64_Generator::timeradix_gen()
{
ZCE_ASSERT(UUID64_GENERATOR_TIME == generator_type_);
++time_radix_seed_.u_16_48_.data2_;
return time_radix_seed_;
}
//以时间为基数产生UUID64
ZCE_UUID128 ZCE_UUID128_Generator::timeradix_gen()
{
ZCE_ASSERT(UUID128_GENERATOR_TIME == generator_type_);
++time_radix_seed_.u_32_32_64_.data3_;
return time_radix_seed_;
}
virtual void on_run(void *outer_data, bool &continue_run)
{
ZCE_UNUSED_ARG(outer_data);
switch (get_stage())
{
case FMS1_STAGE_1:
std::cout << "FSM1 stage " << get_stage() << " start."<< std::endl;
continue_run = true;
set_stage(FMS1_STAGE_2);
break;
case FMS1_STAGE_2:
std::cout << "FSM1 stage " << get_stage() << std::endl;
continue_run = true;
set_stage(FSM1_STAGE_3);
break;
case FSM1_STAGE_3:
std::cout << "FSM1 stage " << get_stage() << std::endl;
continue_run = true;
set_stage(FSM1_STAGE_4);
break;
case FSM1_STAGE_4:
std::cout << "FSM1 stage " << get_stage() << " end."<<std::endl;
continue_run = false;
break;
default:
//一个无法识别的状态
ZCE_ASSERT(false);
break;
}
return;
}
/******************************************************************************************
Author : Sail(ZENGXING) Date Of Creation: 2008年9月22日
Function : MallocSendQueueFrame 请在使用这个函数之前明确你要干什么，
Return : void
Parameter List :
Param1: size_t frame_len 你要分配的FRAME的长度
Description : 分配一个想发送队列发送FRAME
Calls :
Called By :
Other : 这个函数仅仅提供给希望避免大量FRAME拷贝的地方,不要改变FRAME的头部数据,
Modify Record : 和GetSendQueueFrame,pushbak_mgr_sendqueue一起使用
******************************************************************************************/
void Notify_Trans_Abnormal_Base::malloc_abnormalframe(size_t frame_len)
{
//不能重复调用这个函数
ZCE_ASSERT (abnormal_frame_ == NULL);
abnormal_frame_ = trans_notify_mgr_->alloc_appframe(frame_len);
return ;
}
//设置SQL Command语句,为BIN型的SQL语句准备,用于要帮定变量的SQL,结果
int ZCE_Mysql_STMT_Command::set_stmt_command(const char *sqlcmd, size_t szsql, ZCE_Mysql_STMT_Bind *bindparam, ZCE_Mysql_STMT_Bind *bindresult)
{
ZCE_ASSERT(sqlcmd != NULL);
//
stmt_command_.assign(sqlcmd, szsql);
return stmt_prepare_bind(bindparam, bindresult);
}
/****************************************************************************************************
class OgreTCPAcceptHandler TCP Accept 处理的EventHandler,
****************************************************************************************************/
Ogre_TCPAccept_Hdl::Ogre_TCPAccept_Hdl(const TCP_PEER_CONFIG_INFO &config_info,
ZCE_Reactor *reactor):
ZCE_Event_Handler(reactor),
ip_restrict_(Ogre_IPRestrict_Mgr::instance())
{
peer_module_info_.peer_info_ = config_info;
ZCE_ASSERT(peer_module_info_.fp_judge_whole_frame_);
}
//构造函数
ZCE_WFMO_Reactor::ZCE_WFMO_Reactor()
{
initialize();
#if defined ZCE_OS_LINUX
ZCE_ASSERT(false);
#endif
}
int Comm_Stat_Monitor::get_svr_info_from_stat_fname(const char *stat_file_name,
SERVICES_ID *service_info,
bool *if_zerg)
{
ZCE_ASSERT(stat_file_name != NULL);
ZCE_ASSERT(service_info != NULL);
bool tmp_if_zerg = false;
const char *scan_format = NULL;
SERVICES_ID tmp_service_info;
if (strncmp(stat_file_name, "ZERG", 4) == 0)
{
tmp_if_zerg = true;
scan_format = "ZERG_%d_%d.STAT";
}
else if (strncmp(stat_file_name, "TSS", 3) == 0)
{
tmp_if_zerg = false;
scan_format = "TSS_%d_%d.STAT";
}
else
{
// 错误的文件名嘛
return SOAR_RET::ERROR_BAD_STAT_FILE_NAME;
}
int ret = sscanf(stat_file_name, scan_format, &tmp_service_info.services_type_,
&tmp_service_info.services_id_);
if (ret != 2)
{
// 文件名不对
return SOAR_RET::ERROR_BAD_STAT_FILE_NAME;
}
if (if_zerg != NULL)
{
*if_zerg = tmp_if_zerg;
}
*service_info = tmp_service_info;
return SOAR_RET::SOAR_RET_SUCC;
}
//增加一个APP的定时器
void Server_Timer_Base::add_app_timer(const ZCE_Time_Value &interval, const void *act)
{
ZCE_ASSERT(zan_timer_num_ + 1 >= MAX_APP_TIMER_NUMBER);
zan_timer_internal_[zan_timer_num_] = interval;
zan_timer_act_[zan_timer_num_] = act;
++zan_timer_num_;
}
//根据地址(整数)，端口号初始化构造
ZCE_Sockaddr_In::ZCE_Sockaddr_In (uint32_t ip_addr,
uint16_t port_number):
ZCE_Sockaddr(reinterpret_cast<sockaddr *>(&in4_addr_), sizeof(sockaddr_in))
{
int ret = ZCE_LIB::set_sockaddr_in(&in4_addr_, ip_addr, port_number);
if (ret != 0)
{
ZCE_ASSERT(false);
}
}
//计算消耗的时间(us)
double ZCE_HR_Progress_Timer::elapsed_usec() const
{
#if defined ZCE_OS_WINDOWS
ZCE_ASSERT(end_time_.QuadPart >= start_time_.QuadPart);
const double USEC_PER_SEC = 1000000.0;
return double(end_time_.QuadPart - start_time_.QuadPart + addup_time_.QuadPart ) * USEC_PER_SEC / frequency_.QuadPart;
#elif defined ZCE_OS_LINUX
const uint64_t NSEC_PER_SEC = 1000000000ULL;
ZCE_ASSERT((end_time_.tv_sec * NSEC_PER_SEC + end_time_.tv_nsec ) >
(start_time_.tv_sec * NSEC_PER_SEC + start_time_.tv_nsec ));
const double NSEC_PER_USEC = 1000.0;
return ((end_time_.tv_sec * NSEC_PER_SEC + end_time_.tv_nsec ) -
(start_time_.tv_sec * NSEC_PER_SEC + start_time_.tv_nsec ) + addup_time_) / NSEC_PER_USEC ;
#endif
}
int
Comm_Timer_Handler::init(unsigned int game_id, bool is_app, ZCE_Server_Toolkit *toolkit)
{
time_provider_ = Comm_Time_Provider::instance();
ZCE_ASSERT(time_provider_ != NULL);
stat_monitor_ = Comm_Stat_Monitor::instance();
ZCE_ASSERT(stat_monitor_ != NULL);
svrd_app_ = toolkit;
last_check_ = time(NULL);
// Timer handle init时要保证cfgsdk已经得到gameid了
game_id_ = game_id;
// 获取服务器的classify_id
classify_id_ = (is_app ? COMM_STAT_APP_CID : COMM_STAT_ZERG_CID);
return SOAR_RET::SOAR_RET_SUCC;
}
//产生一个UUID64
ZCE_UUID64 ZCE_UUID64_Generator::random_gen()
{
ZCE_ASSERT(UUID64_GENERATOR_RANDOM == generator_type_);
//分别用2个随机数发生器得到随机数
ZCE_UUID64 uuid64_ret;
uuid64_ret.u_2uint32_[0] = mt_19937_random_.rand();
uuid64_ret.u_2uint32_[1] = mt_11213b_random_.rand();
return uuid64_ret;
}
int NotifyTrans_Manger<ZCE_MT_SYNCH>::active_notify_task(NotifyTrans_TaskBase *clone_task,
size_t task_num,
size_t task_stack_size)
{
int ret = 0;
//这个函数只用进来一次
ZCE_ASSERT(task_list_ == NULL);
task_number_ = task_num;
clone_task_ = clone_task;
task_list_ = new NotifyTrans_TaskBase*[task_number_];
//初始化
for (size_t i = 0; i < task_number_; ++i)
{
task_list_[i] = clone_task_->task_clone();
ret = task_list_[i]->initialize(this);
//任何一个不成功，都返回错误
if (ret != 0)
{
return ret;
}
}
//每个对象启动一个线程实例，这样是偷懒但是，可以很容易实现线程池子
for (size_t i = 0; i < task_number_; ++i)
{
//使用一个特殊的日期做完GROUP ID
const size_t ACTIVATE_TASK_GROUP = 2011105;
//注意下面的参数1active
ZCE_THREAD_ID threadid;
ret = task_list_[i]->activate(ACTIVATE_TASK_GROUP,
&threadid,
PTHREAD_CREATE_JOINABLE,
task_stack_size);
if (ret != 0)
{
ZCE_LOG(RS_ALERT, "[framework] Activate Thread fail.Please check system config.id [%u] Stack size [%u].",
static_cast<unsigned int>(i),
static_cast<unsigned int>(task_stack_size));
return -1;
}
}
return 0;
}
//计算消耗的时间
double ZCE_Progress_Timer::elapsed_sec() const
{
//暂时去掉这个断言，在WINDOWS平台，即使你使用正确，也可能出现这个断言,在类的说明写清楚了，自己阅读
//ZCE_ASSERT(end_time_ > start_time_);
ZCE_ASSERT(end_time_ > 0);
if (end_time_ > start_time_)
{
return (double(end_time_) - start_time_ + addup_time_) / CLOCKS_PER_SEC;
}
else
{
return ( addup_time_) / CLOCKS_PER_SEC;
}
}
int ZCE_Mysql_Process::connect_mysql_server( )
{
int ret = 0;
//连接数据库
if (db_connect_.is_connected() == false)
{
//如果设置过HOST，用HOST NAME进行连接
if (db_hostname_.length() > 0)
{
ret = db_connect_.connect_by_host(db_hostname_.c_str(),
db_user_name_.c_str(),
db_password_.c_str(),
NULL,
db_port_);
}
else if (db_socket_file_.length() > 0)
{
ret = db_connect_.connect_by_socketfile(db_socket_file_.c_str(),
db_user_name_.c_str(),
db_password_.c_str());
}
else
{
ZCE_ASSERT(false);
}
//如果错误
if (ret != 0)
{
ZCE_LOG(RS_ERROR, "[zcelib] DB Error : [%u]:%s.",
db_connect_.get_error_no(),
db_connect_.get_error_message()
);
return -1;
}
//
db_command_.set_connection(&db_connect_);
}
return 0;
}
// 得到SQL 语句. 类型数据,传入的char buf长度是否足够自己保证
int ZCE_Mysql_Command::get_sql_command( char *cmdbuf, size_t &szbuf) const
{
if (cmdbuf == NULL )
{
ZCE_ASSERT(false);
return -1;
}
size_t size_sql = mysql_command_.length();
if (size_sql + 1 > szbuf)
{
return -1;
}
szbuf = size_sql;
memcpy(cmdbuf, mysql_command_.c_str(), szbuf);
return 0;
}
//文件锁初始化zce_flock_t,打开文件，得到FD
int ZCE_OS::flock_init (zce_flock_t *lock,
const char *file_name,
int flags,
mode_t perms)
{
//
ZCE_ASSERT(file_name && lock);
ZCE_HANDLE fd = ZCE_OS::open (file_name, flags, perms);
if (fd == ZCE_INVALID_HANDLE)
{
return -1;
}
//调整打开的标志
lock->open_by_self_ = true;
return ZCE_OS::flock_init(lock, fd);
}
//初始化
int ZCE_Epoll_Reactor::initialize(size_t max_event_number,
bool edge_triggered,
int once_max_events )
{
//如果是非Linux操作系统，直接完蛋算了。
#if !defined (ZCE_OS_LINUX)
ZCE_ASSERT(false);
#endif
int ret = 0;
ret = ZCE_Reactor::initialize(max_event_number);
if (0 != ret)
{
ZCE_LOG(RS_ERROR, "[zcelib] Epoll reactor ZCE_Reactor::initialize fail.please check code. ret = %u.", ret);
return ret;
}
edge_triggered_ = edge_triggered;
//这个只有LINUX下才有
#if defined (ZCE_OS_LINUX)
epoll_fd_ = ::epoll_create(max_event_number_ + 64);
#endif
if (epoll_fd_ < 0)
{
ZCE_LOG(RS_ERROR, "[zcelib] Epoll reactor ::epoll_create fail.please check code. error = [%u|%u]",
ZCE_LIB::last_error(),
strerror(ZCE_LIB::last_error()));
return -1;
}
once_max_events_ = once_max_events;
once_events_ary_ = new epoll_event [once_max_events_];
return 0;
}
//构造函数,
//mutex_name 互斥量的名称，必选参数，在WIN下是互斥量的名称，在LINUX，是共享内存的文件名称，
//（如果是WIN下的非递归锁，是个信号灯的名称）
//WINDOWS的核心对象的名称被用于标识一个核心对象（互斥量，信号灯），而LINUX下的pthread_xxx同步对象，如果对象在共享内存里面，
//那么就是进程间同步对象，当然还要注意属性PTHREAD_PROCESS_SHARED的设置
ZCE_Process_Mutex::ZCE_Process_Mutex (const char *mutex_name, bool recursive):
lock_(NULL)
{
ZCE_ASSERT( mutex_name);
int ret = 0;
#if defined ZCE_OS_WINDOWS
//第一次发现Windows 下居然还简单一点
lock_ = new pthread_mutex_t();
#elif defined ZCE_OS_LINUX
//
ret = posix_sharemem_.open(mutex_name, sizeof(pthread_mutex_t), false);
if (0 != ret)
{
ZCE_TRACE_FAIL_RETURN(RS_ERROR, "ZCE_ShareMem_Posix::open", ret);
return;
}
lock_ = reinterpret_cast<pthread_mutex_t *>( posix_sharemem_.addr());
#endif
ret = ZCE_LIB::pthread_mutex_initex(lock_,
true,
recursive,
true,
mutex_name);
if (0 != ret)
{
ZCE_TRACE_FAIL_RETURN(RS_ERROR, "ZCE_LIB::pthread_mutex_initex", ret);
return;
}
}
int test_async_fsm(int /*argc*/, char * /*argv*/[])
{
int ret = 0;
const unsigned int CMD_1 = 10001;
const unsigned int CMD_2 = 10002;
const unsigned int CMD_3 = 10003;
ZCE_Timer_Queue_Base *time_queue = new ZCE_Timer_Wheel();
ZCE_Async_FSMMgr *mgr = new ZCE_Async_FSMMgr();
mgr->initialize(time_queue,100,200);
mgr->register_asyncobj(CMD_1, new FSM_1(mgr, CMD_1));
mgr->register_asyncobj(CMD_2, new FSM_2(mgr, CMD_2));
unsigned int fsm1_async_id1;
ret = mgr->create_asyncobj(CMD_1,NULL,&fsm1_async_id1);
unsigned int fsm1_async_id2;
ret = mgr->create_asyncobj(CMD_1,NULL,&fsm1_async_id2);
unsigned int fsm2_async_id1;
ret = mgr->create_asyncobj(CMD_2, NULL,&fsm2_async_id1);
unsigned int nouse_fsm3_id;
ret = mgr->create_asyncobj(CMD_3, NULL, &nouse_fsm3_id);
ZCE_ASSERT(ret != 0);
ret = mgr->active_asyncobj(fsm1_async_id1, NULL);
ret = mgr->active_asyncobj(fsm2_async_id1, NULL);
ret = mgr->active_asyncobj(fsm1_async_id1, NULL);
ret = mgr->active_asyncobj(fsm2_async_id1, NULL);
ret = mgr->active_asyncobj(fsm1_async_id1, NULL);
ret = mgr->active_asyncobj(fsm2_async_id1, NULL);
ret = mgr->active_asyncobj(fsm1_async_id1, NULL);
ret = mgr->active_asyncobj(fsm2_async_id1, NULL);
return 0;
}
//替换src字符串中的sub字符串为replace，保存到dst字符串中
const char *ZCE_LIB::str_replace(const char *src, char *dst, const char *sub, const char *replace)
{
ZCE_ASSERT(src && dst && sub && replace);
//记录当前指针位置,偏移
size_t dst_offset = 0, src_offset = 0;
//求得各字符串长度
size_t src_len = strlen(src);
size_t sub_len = strlen(sub);
size_t replace_len = strlen(replace);
const char *find_pos = NULL;
//strstr查找sub字符串出现的指针
while ( 0 != (find_pos = strstr(src + src_offset, sub)) )
{
//拷贝src字符串，从首地址开始，pos个字符。
memcpy(dst + dst_offset, src + src_offset, find_pos - (src + src_offset));
dst_offset += find_pos - (src + src_offset);
src_offset = find_pos - src + sub_len;
memcpy(dst + dst_offset, replace, replace_len);
dst_offset += replace_len;
}
//把sub字符串后面的字符串到dst中
memcpy(dst + dst_offset, src + src_offset, src_len - src_offset);
dst_offset += src_len - src_offset;
//最后添加字符串结尾标记'\0'
*(dst + dst_offset) = '\0';
//返回dst
return dst;
}
static size_t nearest_prime(const size_t node_num)
{
ZCE_ASSERT(node_num > 3);
size_t test_num = node_num;
for (;; ++test_num)
{
size_t test_max = static_cast<size_t>(::sqrt(static_cast<double>(test_num)));
bool bool_prime = true;
for (size_t i = 2; i <= test_max + 1; ++i)
{
if (test_num % i == 0)
{
bool_prime = false;
break;
}
}
if (bool_prime)
{
break;
}
}
return test_num;
}
//添加监控
int ZCE_Event_INotify::add_watch(const char *pathname,
uint32_t mask,
ZCE_HANDLE *watch_handle,
bool watch_sub_dir)
{
//检查参数是否有效，
ZCE_ASSERT( pathname && mask);
if ( pathname == NULL || mask == 0)
{
errno = EINVAL;
return -1;
}
#if defined (ZCE_OS_LINUX)
//Linux的Inotify没法监控子目录
ZCE_ASSERT(watch_sub_dir == false);
*watch_handle = ZCE_INVALID_HANDLE;
EVENT_INOTIFY_NODE watch_note;
ZCE_HANDLE hdl_dir = ZCE_INVALID_HANDLE;
hdl_dir = ::inotify_add_watch(inotify_handle_, pathname, mask);
if (hdl_dir == ZCE_INVALID_HANDLE )
{
ZCE_LOG(RS_ERROR, "[%s] invoke ::inotify_add_watch fail,error [%u].",
__ZCE_FUNC__,
ZCE_LIB::last_error());
return -1;
}
watch_note.watch_handle_ = hdl_dir;
watch_note.watch_mask_ = mask;
strncpy(watch_note.watch_path_, pathname, MAX_PATH);
std::pair<HDL_TO_EIN_MAP::iterator, bool>
ins_ret = watch_event_map_.insert(HDL_TO_EIN_MAP::value_type(hdl_dir, watch_note));
//如果插入不成功，进行各种难过清理工作
if (ins_ret.second == false)
{
//下面这段代码屏蔽的原因是，而LInux下，如果inotify_add_watch 同一个目录，handle是一样的。
//::inotify_rm_watch(inotify_handle_, hdl_dir);
ZCE_LOG(RS_ERROR, "[%s] insert code node to map fail. code error or map already haved one equal HANDLE[%u].",
__ZCE_FUNC__,
hdl_dir);
return -1;
}
*watch_handle = hdl_dir;
return 0;
#elif defined (ZCE_OS_WINDOWS)
int ret = 0;
*watch_handle = ZCE_INVALID_HANDLE;
//已经监控了一个目录，Windows的一个ZCE_Event_INotify不能同时监控两个目录
if (watch_handle_ != ZCE_INVALID_HANDLE)
{
ZCE_LOG(RS_ERROR, "[zcelib][%s]add_watch fail handle[%lu]. Windows one ZCE_Event_INotify only watch one dir.",
__ZCE_FUNC__,
watch_handle_);
return -1;
}
//采用OVERLAPPED的方式打开文件，注意FILE_LIST_DIRECTORY和FILE_FLAG_OVERLAPPED
watch_handle_ = ::CreateFileA(pathname, // pointer to the file name
FILE_LIST_DIRECTORY, // access (read/write) mode
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, // share mode
NULL, // security descriptor
OPEN_EXISTING, // how to create
FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, // file attributes
NULL // file with attributes to copy
);
if (watch_handle_ == ZCE_INVALID_HANDLE)
{
ZCE_LOG(RS_ERROR, "[zcelib][%s] invoke ::CreateFile [%s] inotify fail,error [%u].",
__ZCE_FUNC__,
pathname,
ZCE_LIB::last_error());
return -1;
}
read_buffer_ = new char[READ_BUFFER_LEN + 1];
read_buffer_[READ_BUFFER_LEN] = '\0';
watch_sub_dir_ = watch_sub_dir;
watch_mask_ = mask;
strncpy(watch_path_, pathname, MAX_PATH);
DWORD bytes_returned = 0;
BOOL bret = ::ReadDirectoryChangesW(
watch_handle_, // handle to directory
read_buffer_, // read results buffer
READ_BUFFER_LEN, // length of buffer
watch_sub_dir_, // monitoring option
FILE_NOTIFY_CHANGE_SECURITY |
FILE_NOTIFY_CHANGE_CREATION |
FILE_NOTIFY_CHANGE_LAST_ACCESS |
FILE_NOTIFY_CHANGE_LAST_WRITE |
FILE_NOTIFY_CHANGE_SIZE |
FILE_NOTIFY_CHANGE_ATTRIBUTES |
FILE_NOTIFY_CHANGE_DIR_NAME |
FILE_NOTIFY_CHANGE_FILE_NAME, // filter conditions
&bytes_returned, // bytes returned
&over_lapped_, // overlapped buffer
NULL // completion routine
);
//如果读取失败，一般而言，这是这段代码有问题
if (bret == FALSE)
{
ZCE_LOG(RS_ERROR, "[%s] ::ReadDirectoryChangesW fail,error [%u|%s].",
__ZCE_FUNC__,
ZCE_LIB::last_error(),
strerror(ZCE_LIB::last_error()));
::CloseHandle(watch_handle_);
return -1;
}
ret = reactor()->register_handler(this, INOTIFY_MASK);
if (ret != 0)
{
::CloseHandle(watch_handle_);
return ret;
}
*watch_handle = watch_handle_;
return 0;
#endif
}
int NotifyTrans_Manger<ZCE_NULL_SYNCH>::stop_notify_task()
{
ZCE_ASSERT(false);
//
return 0;
}
int benchmark_compress(int /*argc*/, char * /*argv*/[])
{
ZCE_HR_Progress_Timer hr_timer;
const size_t TEST_NUMBER = 512;
unsigned char *file_buffer = new unsigned char [40 * 1024 * 1024];
size_t file_len;
int ret = 0;
ret = ZCE_LIB::read_file_data("D:\\TestDir\\compress\\5.txt", (char *)file_buffer, 40 * 1024 * 1024, &file_len);
if (ret != 0)
{
delete []file_buffer;
return -1;
}
size_t compressbuf_len = 0, decompress_len = 0;
size_t source_len = file_len;
ret = ZCE_LIB::LZ4_Compress::need_compressed_bufsize(file_len, &compressbuf_len);
ZCE_ASSERT(compressbuf_len <40 * 1024 * 1024 );
ret = ZCE_LIB::ZLZ_Compress::need_compressed_bufsize(file_len, &compressbuf_len);
ZCE_ASSERT(compressbuf_len <40 * 1024 * 1024 );
unsigned char *compress_buf = new unsigned char [40 * 1024 * 1024];
unsigned char *decompress_buf = new unsigned char [40 * 1024 * 1024];
ZCE_LIB::sleep(1);
double compress_use = 0.0 , decompress_use = 0.0;
/*
decompress_len = 40 * 1024 * 1024;
compressbuf_len = 40 * 1024 * 1024;
compress_use = 0.0 , decompress_use = 0.0;
for (size_t i = 0; i < TEST_NUMBER; ++i)
{
file_buffer[0] += (unsigned char)i;
compressbuf_len = 40 * 1024 * 1024;
hr_timer.restart();
compressbuf_len = LZ4_compress((const char *)file_buffer, (char *)compress_buf, (int)source_len);
hr_timer.end();
compress_use += hr_timer.elapsed_usec();
decompress_len = 40 * 1024 * 1024;
hr_timer.restart();
LZ4_decompress_safe((const char *)compress_buf, (char *)decompress_buf, (int)compressbuf_len, 40 * 1024 * 1024);
hr_timer.end();
decompress_use += hr_timer.elapsed_usec();
}
printf ("RAW LZ4 [%10lu] compress use us[%15.3f]us [%15.3f]Mb/s decompress use [%15.3f]us [%15.3f]Mb/s.\n",
compressbuf_len,
compress_use,
double (file_len)*TEST_NUMBER * 1000000.0 / (1024 * 1024 * compress_use),
decompress_use,
double (file_len)*TEST_NUMBER * 1000000.0 / (1024 * 1024 * decompress_use) );
*/
compress_use = 0.0 , decompress_use = 0.0;
for (size_t i = 0; i < TEST_NUMBER; ++i)
{
file_buffer[0] += (unsigned char)i;
compressbuf_len = 40 * 1024 * 1024;
hr_timer.restart();
ret = ZCE_LIB::ZLZ_Compress::compress(file_buffer, source_len, compress_buf, &compressbuf_len);
hr_timer.end();
compress_use += hr_timer.elapsed_usec();
decompress_len = 40 * 1024 * 1024;
hr_timer.restart();
ret = ZCE_LIB::ZLZ_Compress::decompress(compress_buf, compressbuf_len, decompress_buf, &decompress_len);
hr_timer.end();
decompress_use += hr_timer.elapsed_usec();
}
printf ("ZCE ZLZ [%10lu] compress use us[%15.3f]us [%15.3f]Mb/s decompress use [%15.3f]us [%15.3f]Mb/s.\n",
compressbuf_len,
compress_use,
double (file_len)*TEST_NUMBER * 1000000.0 / (1024 * 1024 * compress_use),
decompress_use,
double (file_len)*TEST_NUMBER * 1000000.0 / (1024 * 1024 * decompress_use) );
compress_use = 0.0 , decompress_use = 0.0;
for (size_t i = 0; i < TEST_NUMBER; ++i)
{
file_buffer[0] += (unsigned char)i;
compressbuf_len = 40 * 1024 * 1024;
hr_timer.restart();
ret = ZCE_LIB::LZ4_Compress::compress(file_buffer, source_len, compress_buf, &compressbuf_len);
hr_timer.end();
compress_use += hr_timer.elapsed_usec();
decompress_len = 40 * 1024 * 1024;
hr_timer.restart();
ret = ZCE_LIB::LZ4_Compress::decompress(compress_buf, compressbuf_len, decompress_buf, &decompress_len);
hr_timer.end();
decompress_use += hr_timer.elapsed_usec();
}
printf ("ZCE LZ4 [%10lu] compress use us[%15.3f]us [%15.3f]Mb/s decompress use [%15.3f]us [%15.3f]Mb/s.\n",
compressbuf_len,
compress_use,
double (file_len)*TEST_NUMBER * 1000000.0 / (1024 * 1024 * compress_use),
decompress_use,
double (file_len)*TEST_NUMBER * 1000000.0 / (1024 * 1024 * decompress_use) );
hr_timer.restart();
for (size_t i = 0; i < TEST_NUMBER; ++i)
{
file_buffer[0] += (unsigned char)i;
ZCE_LZ_FAST_COPY(decompress_buf, file_buffer, file_len);
}
hr_timer.end();
double memcpy_use = hr_timer.elapsed_usec();
printf ("MEMCPY [%10lu] memcpy use us[%15.3f]us [%15.3f]Mb/s .\n",
file_len,
memcpy_use,
double (file_len)*TEST_NUMBER * 1000000.0 / (1024 * 1024 * memcpy_use)
);
delete[] compress_buf;
delete[] decompress_buf;
delete []file_buffer;
return 0;
}
//将所有的队列中的数据发送，从SEND管道找到所有的数据去发送,
//想了想，还是加了一个最多发送的帧的限额
int Ogre_Comm_Manger::get_all_senddata_to_write(size_t &procframe)
{
int ret = 0;
//
for (procframe = 0;
Soar_MMAP_BusPipe::instance()->is_empty_bus(Soar_MMAP_BusPipe::SEND_PIPE_ID) == false &&
procframe < MAX_ONCE_SEND_FRAME; ++procframe)
{
Ogre4a_App_Frame *send_frame = Ogre_Buffer_Storage::instance()->allocate_byte_buffer();
//
ret = Soar_MMAP_BusPipe::instance()->pop_front_bus(Soar_MMAP_BusPipe::SEND_PIPE_ID,
reinterpret_cast< ZCE_LIB::dequechunk_node* &>(send_frame));
if (ret != 0)
{
//归还缓存
Ogre_Buffer_Storage::instance()->free_byte_buffer(send_frame);
continue;
}
//如果FRAME的长度
if (send_frame->ogre_frame_len_ > Ogre4a_App_Frame::MAX_OF_OGRE_FRAME_LEN)
{
ZCE_LOG(RS_ALERT, "Ogre_Comm_Manger::get_all_senddata_to_write len %u\n",
send_frame->ogre_frame_len_);
DEBUGDUMP_OGRE_HEAD(send_frame, "Ogre_Comm_Manger::get_all_senddata_to_write", RS_ALERT);
ZCE_ASSERT(false);
return SOAR_RET::ERR_OGRE_SEND_FRAME_TOO_LEN;
}
//如果是TCP
if (send_frame->ogre_frame_option_ & Ogre4a_App_Frame::OGREDESC_PEER_TCP )
{
ret = Ogre_TCP_Svc_Handler::process_send_data(send_frame);
if (ret != 0)
{
//归还缓存
Ogre_Buffer_Storage::instance()->free_byte_buffer(send_frame);
continue;
}
}
//如果是UDP
else if (send_frame->ogre_frame_option_ & Ogre4a_App_Frame::OGREDESC_PEER_UDP )
{
//不检查错误
Ogre_UDPSvc_Hdl::send_alldata_to_udp(send_frame);
Ogre_Buffer_Storage::instance()->free_byte_buffer(send_frame);
}
//你都不填写，我如何发送？
else
{
ZCE_LOG(RS_ERROR, "Ogre frame have not send option,Please Check you code.\n");
Ogre_Buffer_Storage::instance()->free_byte_buffer(send_frame);
}
}
return 0;
}
