mirror of https://github.com/F-Stack/f-stack.git
926 lines
23 KiB
C++
926 lines
23 KiB
C++
|
|
/**
|
|
* Tencent is pleased to support the open source community by making MSEC available.
|
|
*
|
|
* Copyright (C) 2016 THL A29 Limited, a Tencent company. All rights reserved.
|
|
*
|
|
* Licensed under the GNU General Public License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License. You may
|
|
* obtain a copy of the License at
|
|
*
|
|
* https://opensource.org/licenses/GPL-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software distributed under the
|
|
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
|
|
* either express or implied. See the License for the specific language governing permissions
|
|
* and limitations under the License.
|
|
*/
|
|
|
|
|
|
/**
|
|
* @filename micro_thread.h
|
|
* @info micro thread manager
|
|
*/
|
|
|
|
#ifndef ___MICRO_THREAD_H__
|
|
#define ___MICRO_THREAD_H__
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/uio.h>
|
|
#include <sys/time.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/resource.h>
|
|
#include <sys/queue.h>
|
|
#include <fcntl.h>
|
|
#include <signal.h>
|
|
#include <errno.h>
|
|
#include <setjmp.h>
|
|
|
|
#include <set>
|
|
#include <vector>
|
|
#include <queue>
|
|
#include "heap.h"
|
|
#include "kqueue_proxy.h"
|
|
#include "heap_timer.h"
|
|
|
|
using std::vector;
|
|
using std::set;
|
|
using std::queue;
|
|
|
|
namespace NS_MICRO_THREAD {
|
|
|
|
#define STACK_PAD_SIZE 128 ///< 栈上下隔离区域的大小
|
|
#define MEM_PAGE_SIZE 4096 ///< 内存页默认大小
|
|
#define DEFAULT_STACK_SIZE 128*1024 ///< 默认栈大小128K
|
|
#define DEFAULT_THREAD_NUM 2000 ///< 默认2000个初始线程
|
|
|
|
typedef unsigned long long utime64_t; ///< 64位的时间定义
|
|
typedef void (*ThreadStart)(void*); ///< 微线程入口函数定义
|
|
|
|
/**
|
|
* @brief 线程调度的适配对象定义, 框架类最小接口封装
|
|
*/
|
|
class ScheduleObj
|
|
{
|
|
public:
|
|
|
|
/**
|
|
* @brief 单例类访问句柄入口
|
|
*/
|
|
static ScheduleObj* Instance (void);
|
|
|
|
/**
|
|
* @brief 获取全局的时间戳, 毫秒单位
|
|
*/
|
|
utime64_t ScheduleGetTime(void);
|
|
|
|
/**
|
|
* @brief 调度其它微线程来运行
|
|
*/
|
|
void ScheduleThread(void);
|
|
|
|
/**
|
|
* @brief 线程调度主动进入sleep状态
|
|
*/
|
|
void ScheduleSleep(void);
|
|
|
|
/**
|
|
* @brief 线程调度主动进入pend状态
|
|
*/
|
|
void SchedulePend(void);
|
|
|
|
/**
|
|
* @brief 线程调度取消pend状态, 外部调度取消
|
|
*/
|
|
void ScheduleUnpend(void* thread);
|
|
|
|
/**
|
|
* @brief 线程执行完毕后, 回收处理
|
|
*/
|
|
void ScheduleReclaim(void);
|
|
|
|
/**
|
|
* @brief 调度器调度初始执行
|
|
*/
|
|
void ScheduleStartRun(void);
|
|
|
|
private:
|
|
static ScheduleObj* _instance; // 私有句柄
|
|
};
|
|
|
|
|
|
/**
|
|
* @brief 线程通用的栈帧结构定义
|
|
*/
|
|
struct MtStack
|
|
{
|
|
int _stk_size; ///< 栈的大小, 有效使用空间
|
|
int _vaddr_size; ///< 申请的buff总大小
|
|
char *_vaddr; ///< 申请的内存基地址
|
|
void *_esp; ///< 栈的esp寄存器
|
|
char *_stk_bottom; ///< 栈最低的地址空间
|
|
char *_stk_top; ///< 栈最高的地址空间
|
|
void *_private; ///< 线程私有数据
|
|
int valgrind_id; ///< valgrind id
|
|
};
|
|
|
|
|
|
/**
|
|
* @brief 通用的线程模型定义
|
|
*/
|
|
class Thread : public HeapEntry
|
|
{
|
|
public:
|
|
|
|
/**
|
|
* @brief 构造与析构函数
|
|
*/
|
|
explicit Thread(int stack_size = 0);
|
|
virtual ~Thread(){};
|
|
|
|
/**
|
|
* @brief 线程的实际工作函数
|
|
*/
|
|
virtual void Run(void){};
|
|
|
|
/**
|
|
* @brief 初始化线程,如堆栈与上下文初始化
|
|
*/
|
|
bool Initial(void);
|
|
|
|
/**
|
|
* @brief 终止线程,如堆栈与上下文释放
|
|
*/
|
|
void Destroy(void);
|
|
|
|
/**
|
|
* @brief 线程状态重置, 可复用状态
|
|
*/
|
|
void Reset(void);
|
|
|
|
/**
|
|
* @brief 线程主动进入睡眠, 单位毫秒
|
|
* @param ms 睡眠毫秒数
|
|
*/
|
|
void sleep(int ms);
|
|
|
|
/**
|
|
* @brief 线程主动进入等待, 让二级线程先运行
|
|
*/
|
|
void Wait();
|
|
|
|
/**
|
|
* @brief 主动切换, 保存状态, 触发调度
|
|
*/
|
|
void SwitchContext(void);
|
|
|
|
/**
|
|
* @brief 恢复上下文, 切换运行
|
|
*/
|
|
void RestoreContext(void);
|
|
|
|
/**
|
|
* @brief 获取最后唤醒时间
|
|
* @return 线程的唤醒时间点
|
|
*/
|
|
utime64_t GetWakeupTime(void) {
|
|
return _wakeup_time;
|
|
};
|
|
|
|
/**
|
|
* @brief 设置最后唤醒时间
|
|
* @param waketime 线程的唤醒时间点
|
|
*/
|
|
void SetWakeupTime(utime64_t waketime) {
|
|
_wakeup_time = waketime;
|
|
};
|
|
|
|
/**
|
|
* @brief 设置线程私有数据
|
|
* @param data 线程私有数据指针，使用者需自己申请内存，这里只保存指针
|
|
*/
|
|
void SetPrivate(void *data)
|
|
{
|
|
_stack->_private = data;
|
|
}
|
|
|
|
/**
|
|
* @brief 获取线程私有数据
|
|
*/
|
|
void* GetPrivate()
|
|
{
|
|
return _stack->_private;
|
|
}
|
|
|
|
/**
|
|
* @brief 初始化上下文,设置寄存器,堆栈
|
|
*/
|
|
bool CheckStackHealth(char *esp);
|
|
|
|
protected:
|
|
|
|
/**
|
|
* @brief 清理线程处理状态, 准备复用
|
|
*/
|
|
virtual void CleanState(void){};
|
|
|
|
/**
|
|
* @brief 初始化堆栈信息
|
|
*/
|
|
virtual bool InitStack(void);
|
|
|
|
/**
|
|
* @brief 释放堆栈信息
|
|
*/
|
|
virtual void FreeStack(void);
|
|
|
|
/**
|
|
* @brief 初始化上下文,设置寄存器,堆栈
|
|
*/
|
|
virtual void InitContext(void);
|
|
|
|
private:
|
|
MtStack* _stack; ///< 私有栈指针
|
|
jmp_buf _jmpbuf; ///< 上下文jmpbuff
|
|
int _stack_size; ///< 栈大小字段
|
|
utime64_t _wakeup_time; ///< 睡眠唤醒时间
|
|
};
|
|
|
|
|
|
/**
|
|
* @brief 微线程数据结构定义
|
|
*/
|
|
class MicroThread : public Thread
|
|
{
|
|
public:
|
|
enum ThreadType
|
|
{
|
|
NORMAL = 0, ///< 默认普通线程, 没有动态申请的栈信息
|
|
PRIMORDIAL = 1, ///< 原生线程, main函数开启
|
|
DAEMON = 2, ///< 守护线程, 底层IO EPOLL管理与调度触发
|
|
SUB_THREAD = 3, ///< 二级线程, 仅执行简单工作
|
|
};
|
|
|
|
enum ThreadFlag
|
|
{
|
|
NOT_INLIST = 0x0, ///< 无队列状态
|
|
FREE_LIST = 0x1, ///< 空闲队列中
|
|
IO_LIST = 0x2, ///< IO等待队列中
|
|
SLEEP_LIST = 0x4, ///< 主动SLEEP中
|
|
RUN_LIST = 0x8, ///< 可运行队列中
|
|
PEND_LIST = 0x10, ///< 阻塞队列中
|
|
SUB_LIST = 0x20, ///< 二级线程队列中
|
|
|
|
};
|
|
|
|
enum ThreadState
|
|
{
|
|
INITIAL = 0, ///< 初始化状态
|
|
RUNABLE = 1, ///< 可运行状态
|
|
RUNNING = 2, ///< 正在运行中
|
|
SLEEPING = 3, ///< IO等待或SLEEP中
|
|
PENDING = 4, ///< 阻塞状态中, 等待子线程OK等
|
|
};
|
|
|
|
typedef TAILQ_ENTRY(MicroThread) ThreadLink; ///< 微线程链接
|
|
typedef TAILQ_HEAD(__ThreadSubTailq, MicroThread) SubThreadList; ///< 微线程队列定义
|
|
|
|
public:
|
|
|
|
/**
|
|
* @brief 微线程构造与析构
|
|
*/
|
|
MicroThread(ThreadType type = NORMAL);
|
|
~MicroThread(){};
|
|
|
|
ThreadLink _entry; ///< 状态队列入口
|
|
ThreadLink _sub_entry; ///< 子线程队列入口
|
|
|
|
/**
|
|
* @brief 微线程堆排序函数实现,按唤醒时间从早到晚排序
|
|
* @return 线程的实际唤醒时间
|
|
*/
|
|
virtual utime64_t HeapValue() {
|
|
return GetWakeupTime();
|
|
};
|
|
|
|
/**
|
|
* @brief 线程的实际工作函数
|
|
*/
|
|
virtual void Run(void);
|
|
|
|
/**
|
|
* @breif fd侦听管理对列操作
|
|
*/
|
|
void ClearAllFd(void) {
|
|
TAILQ_INIT(&_fdset);
|
|
};
|
|
void AddFd(KqueuerObj* efpd) {
|
|
TAILQ_INSERT_TAIL(&_fdset, efpd, _entry);
|
|
};
|
|
void AddFdList(KqObjList* fdset) {
|
|
TAILQ_CONCAT(&_fdset, fdset, _entry);
|
|
};
|
|
KqObjList& GetFdSet(void) {
|
|
return _fdset;
|
|
};
|
|
|
|
/**
|
|
* @breif 微线程类型管理操作
|
|
*/
|
|
void SetType(ThreadType type) {
|
|
_type = type;
|
|
};
|
|
ThreadType GetType(void) {
|
|
return _type;
|
|
};
|
|
|
|
/**
|
|
* @breif 微线程类型检查接口
|
|
*/
|
|
bool IsDaemon(void) {
|
|
return (DAEMON == _type);
|
|
};
|
|
bool IsPrimo(void) {
|
|
return (PRIMORDIAL == _type);
|
|
};
|
|
bool IsSubThread(void) {
|
|
return (SUB_THREAD == _type);
|
|
};
|
|
|
|
/**
|
|
* @brief 父线程设置与更新
|
|
*/
|
|
void SetParent(MicroThread* parent) {
|
|
_parent = parent;
|
|
};
|
|
MicroThread* GetParent() {
|
|
return _parent;
|
|
};
|
|
void WakeupParent();
|
|
|
|
/**
|
|
* @brief 子线程的管理
|
|
*/
|
|
void AddSubThread(MicroThread* sub);
|
|
void RemoveSubThread(MicroThread* sub);
|
|
bool HasNoSubThread();
|
|
|
|
/**
|
|
* @brief 微线程类型状态操作
|
|
*/
|
|
void SetState(ThreadState state) {
|
|
_state = state;
|
|
};
|
|
ThreadState GetState(void) {
|
|
return _state;
|
|
}
|
|
|
|
/**
|
|
* @breif 微线程标记位处理
|
|
*/
|
|
void SetFlag(ThreadFlag flag) {
|
|
_flag = (ThreadFlag)(_flag | flag);
|
|
};
|
|
void UnsetFlag(ThreadFlag flag) {
|
|
_flag = (ThreadFlag)(_flag & ~flag);
|
|
};
|
|
bool HasFlag(ThreadFlag flag) {
|
|
return _flag & flag;
|
|
};
|
|
ThreadFlag GetFlag() {
|
|
return _flag;
|
|
};
|
|
|
|
/**
|
|
* @breif 微线程入口函数管理注册
|
|
*/
|
|
void SetSartFunc(ThreadStart func, void* args) {
|
|
_start = func;
|
|
_args = args;
|
|
};
|
|
|
|
void* GetThreadArgs() {
|
|
return _args;
|
|
}
|
|
|
|
protected:
|
|
|
|
/**
|
|
* @breif 微线程复用状态清理
|
|
*/
|
|
virtual void CleanState(void);
|
|
|
|
private:
|
|
ThreadState _state; ///< 微线程当前状态
|
|
ThreadType _type; ///< 微线程类型
|
|
ThreadFlag _flag; ///< 微线程标记位
|
|
KqObjList _fdset; ///< 微线程关注的socket列表
|
|
SubThreadList _sub_list; ///< 二级线程的队列
|
|
MicroThread* _parent; ///< 二级线程的父线程
|
|
ThreadStart _start; ///< 微线程注册函数
|
|
void* _args; ///< 微线程注册参数
|
|
|
|
};
|
|
typedef std::set<MicroThread*> ThreadSet; ///< 微线程set管理结构
|
|
typedef std::queue<MicroThread*> ThreadList; ///< 微线程queue管理结构
|
|
|
|
|
|
/**
|
|
* @brief 微线程日志接口, 底层库, 日志由调用者注入
|
|
*/
|
|
class LogAdapter
|
|
{
|
|
public:
|
|
|
|
/**
|
|
* @brief 日志构造与析构
|
|
*/
|
|
LogAdapter(){};
|
|
virtual ~LogAdapter(){};
|
|
|
|
/**
|
|
* @brief 日志优先按等级过滤, 减少解析参数的开销
|
|
* @return true 可以打印该级别, false 跳过不打印该级别
|
|
*/
|
|
virtual bool CheckDebug(){ return true;};
|
|
virtual bool CheckTrace(){ return true;};
|
|
virtual bool CheckError(){ return true;};
|
|
|
|
/**
|
|
* @brief 日志分级记录接口
|
|
*/
|
|
virtual void LogDebug(char* fmt, ...){};
|
|
virtual void LogTrace(char* fmt, ...){};
|
|
virtual void LogError(char* fmt, ...){};
|
|
|
|
/**
|
|
* @brief 属性上报接口
|
|
*/
|
|
virtual void AttrReportAdd(int attr, int iValue){};
|
|
virtual void AttrReportSet(int attr, int iValue){};
|
|
|
|
};
|
|
|
|
|
|
/**
|
|
* @brief 微线程池简单实现
|
|
*/
|
|
class ThreadPool
|
|
{
|
|
public:
|
|
|
|
static unsigned int default_thread_num; ///< 默认2000微线程待命
|
|
static unsigned int default_stack_size; ///< 默认128K栈大小
|
|
|
|
/**
|
|
* @brief 设置微线程的最小保留数目
|
|
*/
|
|
static void SetDefaultThreadNum(unsigned int num) {
|
|
default_thread_num = num;
|
|
};
|
|
|
|
/**
|
|
* @brief 设置微线程的默认栈大小, 需初始化前设置
|
|
*/
|
|
static void SetDefaultStackSize(unsigned int size) {
|
|
default_stack_size = (size + MEM_PAGE_SIZE - 1) / MEM_PAGE_SIZE * MEM_PAGE_SIZE;
|
|
};
|
|
|
|
/**
|
|
* @brief 微线程池初始化
|
|
*/
|
|
bool InitialPool(int max_num);
|
|
|
|
/**
|
|
* @brief 微线程池反初始化
|
|
*/
|
|
void DestroyPool (void);
|
|
|
|
/**
|
|
* @brief 微线程分配接口
|
|
* @return 微线程对象
|
|
*/
|
|
MicroThread* AllocThread(void);
|
|
|
|
/**
|
|
* @brief 微线程释放接口
|
|
* @param thread 微线程对象
|
|
*/
|
|
void FreeThread(MicroThread* thread);
|
|
|
|
/**
|
|
* @brief 获取当前微线程数量
|
|
* @param thread 微线程对象
|
|
*/
|
|
int GetUsedNum(void);
|
|
|
|
private:
|
|
ThreadList _freelist; ///< 空闲待命的微线程队列
|
|
int _total_num; ///< 目前总的微线程数目，后续按需控制上限
|
|
int _use_num; ///< 当前正在使用的微线程数目
|
|
int _max_num; ///< 最大并发限制数, 放置内存过度使用
|
|
};
|
|
|
|
typedef TAILQ_HEAD(__ThreadTailq, MicroThread) ThreadTailq; ///< 微线程队列定义
|
|
|
|
/**
|
|
* @brief 微线程框架类, 全局的单例类
|
|
*/
|
|
class MtFrame : public KqueueProxy, public ThreadPool
|
|
{
|
|
private:
|
|
static MtFrame* _instance; ///< 单例指针
|
|
LogAdapter* _log_adpt; ///< 日志接口
|
|
ThreadList _runlist; ///< 可运行queue, 无优先级
|
|
ThreadTailq _iolist; ///< 等待队列，可随机脱离队列
|
|
ThreadTailq _pend_list; ///< 等待队列，可随机脱离队列
|
|
HeapList _sleeplist; ///< 等待超时的堆, 可随机脱离, 且随时获取最小堆首
|
|
MicroThread* _daemon; ///< 守护线程, 执行epoll wait, 超时检测
|
|
MicroThread* _primo; ///< 原生线程, 使用的是原生堆栈
|
|
MicroThread* _curr_thread; ///< 当前运行线程
|
|
utime64_t _last_clock; ///< 全局时间戳, 每次idle获取一次
|
|
int _waitnum; ///< 等待运行的总线程数, 可调节调度的节奏
|
|
CTimerMng* _timer; ///< TCP保活专用的timer定时器
|
|
int _realtime; /// < 使用实时时间0, 未设置
|
|
|
|
public:
|
|
friend class ScheduleObj; ///< 调度器对象, 是框架类的门面模式, 友元处理
|
|
|
|
public:
|
|
|
|
/**
|
|
* @brief 微线程框架类, 全局实例获取
|
|
*/
|
|
static MtFrame* Instance (void);
|
|
|
|
/**
|
|
* @brief 微线程包裹的系统IO函数 sendto
|
|
* @param fd 系统socket信息
|
|
* @param msg 待发送的消息指针
|
|
* @param len 待发送的消息长度
|
|
* @param to 目的地址的指针
|
|
* @param tolen 目的地址的结构长度
|
|
* @param timeout 最长等待时间, 毫秒
|
|
* @return >0 成功发送长度, <0 失败
|
|
*/
|
|
static int sendto(int fd, const void *msg, int len, int flags, const struct sockaddr *to, int tolen, int timeout);
|
|
|
|
/**
|
|
* @brief 微线程包裹的系统IO函数 recvfrom
|
|
* @param fd 系统socket信息
|
|
* @param buf 接收消息缓冲区指针
|
|
* @param len 接收消息缓冲区长度
|
|
* @param from 来源地址的指针
|
|
* @param fromlen 来源地址的结构长度
|
|
* @param timeout 最长等待时间, 毫秒
|
|
* @return >0 成功接收长度, <0 失败
|
|
*/
|
|
static int recvfrom(int fd, void *buf, int len, int flags, struct sockaddr *from, socklen_t *fromlen, int timeout);
|
|
|
|
/**
|
|
* @brief 微线程包裹的系统IO函数 connect
|
|
* @param fd 系统socket信息
|
|
* @param addr 指定server的目的地址
|
|
* @param addrlen 地址的长度
|
|
* @param timeout 最长等待时间, 毫秒
|
|
* @return >0 成功发送长度, <0 失败
|
|
*/
|
|
static int connect(int fd, const struct sockaddr *addr, int addrlen, int timeout);
|
|
|
|
/**
|
|
* @brief 微线程包裹的系统IO函数 accept
|
|
* @param fd 监听套接字
|
|
* @param addr 客户端地址
|
|
* @param addrlen 地址的长度
|
|
* @param timeout 最长等待时间, 毫秒
|
|
* @return >=0 accept的socket描述符, <0 失败
|
|
*/
|
|
static int accept(int fd, struct sockaddr *addr, socklen_t *addrlen, int timeout);
|
|
|
|
/**
|
|
* @brief 微线程包裹的系统IO函数 read
|
|
* @param fd 系统socket信息
|
|
* @param buf 接收消息缓冲区指针
|
|
* @param nbyte 接收消息缓冲区长度
|
|
* @param timeout 最长等待时间, 毫秒
|
|
* @return >0 成功接收长度, <0 失败
|
|
*/
|
|
static ssize_t read(int fd, void *buf, size_t nbyte, int timeout);
|
|
|
|
/**
|
|
* @brief 微线程包裹的系统IO函数 write
|
|
* @param fd 系统socket信息
|
|
* @param buf 发送消息缓冲区指针
|
|
* @param nbyte 发送消息缓冲区长度
|
|
* @param timeout 最长等待时间, 毫秒
|
|
* @return >0 成功发送长度, <0 失败
|
|
*/
|
|
static ssize_t write(int fd, const void *buf, size_t nbyte, int timeout);
|
|
|
|
/**
|
|
* @brief 微线程包裹的系统IO函数 recv
|
|
* @param fd 系统socket信息
|
|
* @param buf 接收消息缓冲区指针
|
|
* @param len 接收消息缓冲区长度
|
|
* @param timeout 最长等待时间, 毫秒
|
|
* @return >0 成功接收长度, <0 失败
|
|
*/
|
|
static int recv(int fd, void *buf, int len, int flags, int timeout);
|
|
|
|
/**
|
|
* @brief 微线程包裹的系统IO函数 send
|
|
* @param fd 系统socket信息
|
|
* @param buf 待发送的消息指针
|
|
* @param nbyte 待发送的消息长度
|
|
* @param timeout 最长等待时间, 毫秒
|
|
* @return >0 成功发送长度, <0 失败
|
|
*/
|
|
static ssize_t send(int fd, const void *buf, size_t nbyte, int flags, int timeout);
|
|
|
|
|
|
/**
|
|
* @brief 微线程主动sleep接口, 单位ms
|
|
*/
|
|
static void sleep(int ms);
|
|
|
|
/**
|
|
* @brief 微线程仅等待事件,不做额外的操作
|
|
* @param fd 系统socket信息
|
|
* @param events 事件类型 EPOLLIN or EPOLLOUT
|
|
* @param timeout 最长等待时间, 毫秒
|
|
* @return >0 成功接收长度, <0 失败
|
|
*/
|
|
static int WaitEvents(int fd, int events, int timeout);
|
|
|
|
/**
|
|
* @brief 微线程创建接口
|
|
* @param entry 线程入口函数
|
|
* @param args 线程入口参数
|
|
* @return 微线程指针, NULL表示失败
|
|
*/
|
|
static MicroThread* CreateThread(ThreadStart entry, void *args, bool runable = true);
|
|
|
|
/**
|
|
* @brief 守护线程入口函数, 函数指针要求static类型
|
|
* @param args 线程入口参数
|
|
*/
|
|
static void DaemonRun(void* args);
|
|
static int Loop(void* args);
|
|
|
|
/**
|
|
* @brief 获取当前线程的根线程
|
|
*/
|
|
MicroThread *GetRootThread();
|
|
|
|
/**
|
|
* @brief 框架初始化, 默认不带日志运行
|
|
*/
|
|
bool InitFrame(LogAdapter* logadpt = NULL, int max_thread_num = 50000);
|
|
|
|
/**
|
|
* @brief HOOK系统api的设置
|
|
*/
|
|
void SetHookFlag();
|
|
|
|
/**
|
|
* @brief 框架反初始化
|
|
*/
|
|
void Destroy (void);
|
|
|
|
/**
|
|
* @brief 微线程框架版本获取
|
|
*/
|
|
char* Version(void);
|
|
|
|
/**
|
|
* @brief 框架获取全局时间戳
|
|
*/
|
|
utime64_t GetLastClock(void) {
|
|
if(_realtime)
|
|
{
|
|
return GetSystemMS();
|
|
}
|
|
return _last_clock;
|
|
};
|
|
|
|
|
|
/**
|
|
* @brief 框架获取当前线程
|
|
*/
|
|
MicroThread* GetActiveThread(void) {
|
|
return _curr_thread;
|
|
};
|
|
|
|
/**
|
|
* @brief 返回当前待运行的线程数, 直接计数, 效率高
|
|
* @return 等待线程数
|
|
*/
|
|
int RunWaitNum(void) {
|
|
return _waitnum;
|
|
};
|
|
|
|
/**
|
|
* @brief 框架被注入的日志句柄访问
|
|
*/
|
|
LogAdapter* GetLogAdpt(void) {
|
|
return _log_adpt;
|
|
};
|
|
|
|
/**
|
|
* @brief 获取框架保活定时器指针
|
|
*/
|
|
CTimerMng* GetTimerMng(void) {
|
|
return _timer;
|
|
};
|
|
|
|
/**
|
|
* @brief 框架调用epoll wait前, 判定等待时间信息
|
|
*/
|
|
virtual int KqueueGetTimeout(void);
|
|
|
|
/**
|
|
* @brief 微线程触发切换函数,调用成功 则让出cpu, 内部接口
|
|
* @param fdlist 多路并发的socket列表
|
|
* @param fd 单个请求的fd信息
|
|
* @param timeout 最长等待时间, 毫秒
|
|
* @return true 成功, false 失败
|
|
*/
|
|
virtual bool KqueueSchedule(KqObjList* fdlist, KqueuerObj* fd, int timeout);
|
|
|
|
|
|
/**
|
|
* @brief 微线程主动切换, 等待其它线程的唤醒
|
|
* @param timeout 最长等待时间, 毫秒
|
|
*/
|
|
void WaitNotify(utime64_t timeout);
|
|
|
|
/**
|
|
* @brief 框架管理线程单元, 移除IO等待状态, 内部接口
|
|
* @param thread 微线程对象
|
|
*/
|
|
void RemoveIoWait(MicroThread* thread);
|
|
|
|
/**
|
|
* @brief 框架管理线程单元, 插入可运行队列, 内部接口
|
|
* @param thread 微线程对象
|
|
*/
|
|
void InsertRunable(MicroThread* thread);
|
|
|
|
/**
|
|
* @brief 框架管理线程单元, 执行pend等待状态
|
|
* @param thread 微线程对象
|
|
*/
|
|
void InsertPend(MicroThread* thread);
|
|
|
|
/**
|
|
* @brief 框架管理线程单元, 移除PEND等待状态
|
|
* @param thread 微线程对象
|
|
*/
|
|
void RemovePend(MicroThread* thread);
|
|
|
|
void SetRealTime(int realtime_)
|
|
{
|
|
_realtime =realtime_;
|
|
}
|
|
private:
|
|
|
|
/**
|
|
* @brief 微线程私有构造
|
|
*/
|
|
MtFrame():_realtime(1){ _curr_thread = NULL; };
|
|
|
|
/**
|
|
* @brief 微线程私有获取守护线程
|
|
*/
|
|
MicroThread* DaemonThread(void){
|
|
return _daemon;
|
|
};
|
|
|
|
/**
|
|
* @brief 框架调度线程运行
|
|
*/
|
|
void ThreadSchdule(void);
|
|
|
|
/**
|
|
* @brief 框架处理定时回调函数
|
|
*/
|
|
void CheckExpired();
|
|
|
|
/**
|
|
* @brief 框架检测到超时, 唤醒所有的超时线程
|
|
*/
|
|
void WakeupTimeout(void);
|
|
|
|
/**
|
|
* @brief 框架更新全局时间戳
|
|
*/
|
|
void SetLastClock(utime64_t clock) {
|
|
_last_clock = clock;
|
|
};
|
|
|
|
/**
|
|
* @brief 框架设置当前线程
|
|
*/
|
|
void SetActiveThread(MicroThread* thread) {
|
|
_curr_thread = thread;
|
|
};
|
|
|
|
/**
|
|
* @brief 框架的时钟源接口, 返回毫秒级别时钟
|
|
*/
|
|
utime64_t GetSystemMS(void) {
|
|
struct timeval tv;
|
|
gettimeofday(&tv, NULL);
|
|
return (tv.tv_sec * 1000ULL + tv.tv_usec / 1000ULL);
|
|
};
|
|
|
|
/**
|
|
* @brief 框架管理线程单元, 执行IO等待状态
|
|
* @param thread 微线程对象
|
|
*/
|
|
void InsertSleep(MicroThread* thread);
|
|
|
|
/**
|
|
* @brief 框架管理线程单元, 移除IO等待状态
|
|
* @param thread 微线程对象
|
|
*/
|
|
void RemoveSleep(MicroThread* thread);
|
|
|
|
/**
|
|
* @brief 框架管理线程单元, 执行IO等待状态
|
|
* @param thread 微线程对象
|
|
*/
|
|
void InsertIoWait(MicroThread* thread);
|
|
|
|
/**
|
|
* @brief 框架管理线程单元, 移出可运行队列
|
|
* @param thread 微线程对象
|
|
*/
|
|
void RemoveRunable(MicroThread* thread);
|
|
|
|
};
|
|
|
|
/**
|
|
* @brief 日志宏的定义部分
|
|
*/
|
|
#define MTLOG_DEBUG(fmt, args...) \
|
|
do { \
|
|
register NS_MICRO_THREAD::MtFrame *fm = NS_MICRO_THREAD::MtFrame::Instance(); \
|
|
if (fm && fm->GetLogAdpt() && fm->GetLogAdpt()->CheckDebug()) \
|
|
{ \
|
|
fm->GetLogAdpt()->LogDebug((char*)"[%-10s][%-4d][%-10s]"fmt, \
|
|
__FILE__, __LINE__, __FUNCTION__, ##args); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define MTLOG_TRACE(fmt, args...) \
|
|
do { \
|
|
register NS_MICRO_THREAD::MtFrame *fm = NS_MICRO_THREAD::MtFrame::Instance(); \
|
|
if (fm && fm->GetLogAdpt() && fm->GetLogAdpt()->CheckTrace()) \
|
|
{ \
|
|
fm->GetLogAdpt()->LogTrace((char*)"[%-10s][%-4d][%-10s]"fmt, \
|
|
__FILE__, __LINE__, __FUNCTION__, ##args); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define MTLOG_ERROR(fmt, args...) \
|
|
do { \
|
|
register NS_MICRO_THREAD::MtFrame *fm = NS_MICRO_THREAD::MtFrame::Instance(); \
|
|
if (fm && fm->GetLogAdpt() && fm->GetLogAdpt()->CheckError()) \
|
|
{ \
|
|
fm->GetLogAdpt()->LogError((char*)"[%-10s][%-4d][%-10s]"fmt, \
|
|
__FILE__, __LINE__, __FUNCTION__, ##args); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define MT_ATTR_API(ATTR, VALUE) \
|
|
do { \
|
|
register NS_MICRO_THREAD::MtFrame *fm = NS_MICRO_THREAD::MtFrame::Instance(); \
|
|
if (fm && fm->GetLogAdpt()) \
|
|
{ \
|
|
fm->GetLogAdpt()->AttrReportAdd(ATTR, VALUE); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define MT_ATTR_API_SET(ATTR, VALUE) \
|
|
do { \
|
|
register NS_MICRO_THREAD::MtFrame *fm = NS_MICRO_THREAD::MtFrame::Instance(); \
|
|
if (fm && fm->GetLogAdpt()) \
|
|
{ \
|
|
fm->GetLogAdpt()->AttrReportSet(ATTR, VALUE); \
|
|
} \
|
|
} while (0)
|
|
|
|
|
|
|
|
}// NAMESPACE NS_MICRO_THREAD
|
|
|
|
#endif
|
|
|