Merge remote-tracking branch 'upstream/develop' into with-http-parser

6f526b3a · freemine · e55a55a6 · 4ca1ca2c · 6f526b3a · 6f526b3a
201 changed file
--- a/.travis.yml
+++ b/.travis.yml
@@ -190,7 +190,7 @@ matrix:
    script:
      - cmake .. > /dev/null
-      - make > /dev/null
+      - make  > /dev/null
  - os: linux
    arch: arm64

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
 CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
-PROJECT(TDengine)
+IF (CMAKE_VERSION VERSION_LESS 3.0)
+  PROJECT(TDengine CXX)
+  SET(PROJECT_VERSION_MAJOR "${LIB_MAJOR_VERSION}")
+  SET(PROJECT_VERSION_MINOR "${LIB_MINOR_VERSION}")
+  SET(PROJECT_VERSION_PATCH"${LIB_PATCH_VERSION}")
+  SET(PROJECT_VERSION "${LIB_VERSION_STRING}")
+ELSE ()
+  CMAKE_POLICY(SET CMP0048 NEW)
+  PROJECT(TDengine VERSION "${LIB_VERSION_STRING}" LANGUAGES CXX)
+ENDIF ()
 SET(TD_ACCOUNT FALSE)
 SET(TD_ADMIN FALSE)

--- a/cmake/define.inc
+++ b/cmake/define.inc
@@ -53,14 +53,18 @@ IF (TD_LINUX_64)
  ADD_DEFINITIONS(-D_M_X64)
  ADD_DEFINITIONS(-D_TD_LINUX_64)
  IF (NOT TD_ARM)
-    IF (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
+    #IF ((${CMAKE_CXX_COMPILER_ID} MATCHES "Clang") OR (${CMAKE_CXX_COMPILER_ID} MATCHES "clang"))
-      SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -Wno-missing-braces -fPIC -g3 -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+    #  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -Wno-missing-braces -fPIC -g3 -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
-    ELSE ()
+    #ELSE ()
-      SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -malign-double -g3 -gdwarf-2 -malign-stringops -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+    #  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -malign-double -g3 -gdwarf-2 -malign-stringops -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
-    ENDIF ()
+    #ENDIF ()
+    SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -g3 -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
  ELSE ()
    SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -g -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
  ENDIF ()
+  MESSAGE(STATUS "CMAKE_CXX_COMPILER_ID: " ${CMAKE_CXX_COMPILER_ID})
+  MESSAGE(STATUS "COMMON_FLAGS: " ${COMMON_FLAGS})
  FIND_PATH(ICONV_INCLUDE_EXIST iconv.h /usr/include/ /usr/local/include/)
  IF (ICONV_INCLUDE_EXIST)
    ADD_DEFINITIONS(-DUSE_LIBICONV)

--- a/cmake/platform.inc
+++ b/cmake/platform.inc
@@ -52,14 +52,16 @@ ELSE ()
  MESSAGE(STATUS "input cpuType unknown " ${CPUTYPE})
 ENDIF ()
-#
-# Get OS information and store in variable TD_OS_INFO.
-#
-execute_process(COMMAND chmod 777 ${TD_COMMUNITY_DIR}/packaging/tools/get_os.sh)
-execute_process(COMMAND ${TD_COMMUNITY_DIR}/packaging/tools/get_os.sh "" OUTPUT_VARIABLE TD_OS_INFO)
-MESSAGE(STATUS "The current os is " ${TD_OS_INFO})
 IF (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+  #
+  # Get OS information and store in variable TD_OS_INFO.
+  #
+  execute_process(COMMAND chmod 777 ${TD_COMMUNITY_DIR}/packaging/tools/get_os.sh)
+  execute_process(COMMAND ${TD_COMMUNITY_DIR}/packaging/tools/get_os.sh "" OUTPUT_VARIABLE TD_OS_INFO)
+  MESSAGE(STATUS "The current os is " ${TD_OS_INFO})
  SET(TD_LINUX TRUE)
  IF (${CMAKE_SIZEOF_VOID_P} MATCHES 8)
    SET(TD_LINUX_64 TRUE)

--- a/documentation20/webdocs/assets/dnode.png
+++ b/documentation20/webdocs/assets/dnode.png
--- a/documentation20/webdocs/assets/modules.png
+++ b/documentation20/webdocs/assets/modules.png
--- a/documentation20/webdocs/assets/replica-forward.jpg
+++ b/documentation20/webdocs/assets/replica-forward.jpg
--- a/documentation20/webdocs/assets/replica-master.png
+++ b/documentation20/webdocs/assets/replica-master.png
--- a/documentation20/webdocs/assets/replica-restore.jpg
+++ b/documentation20/webdocs/assets/replica-restore.jpg
--- a/documentation20/webdocs/assets/vnode.png
+++ b/documentation20/webdocs/assets/vnode.png
--- a/documentation20/webdocs/markdowndocs/Documentation-ch.md
+++ b/documentation20/webdocs/markdowndocs/Documentation-ch.md
-#TDengine文档
+# TDengine文档
-TDengine是一个高效的存储、查询、分析时序大数据的平台，专为物联网、车联网、工业互联网、运维监测等优化而设计。您可以像使用关系型数据库MySQL一样来使用它，但建议您在使用前仔细阅读一遍下面的文档，特别是[数据模型](data-model-and-architecture)与数据建模一节。除本文档之外，欢迎[下载产品白皮书](https://www.taosdata.com/downloads/TDengine%20White%20Paper.pdf)。
+TDengine是一个高效的存储、查询、分析时序大数据的平台，专为物联网、车联网、工业互联网、运维监测等优化而设计。您可以像使用关系型数据库MySQL一样来使用它，但建议您在使用前仔细阅读一遍下面的文档，特别是[数据模型](https://www.taosdata.com/cn/documentation20/data-model-and-architecture)与[数据建模](https://www.taosdata.com/cn/documentation20/model)一节。除本文档之外，欢迎[下载产品白皮书](https://www.taosdata.com/downloads/TDengine White Paper.pdf)。如需查阅TDengine 1.6 文档，请点击[这里](https://www.taosdata.com/cn/documentation16/)访问。
+## TDengine介绍
-##TDengine 介绍
 - TDengine 简介及特色
 - TDengine 适用场景
- TDengine 性能指标介绍和验证方法
+## [立即开始](https://www.taosdata.com/cn/getting-started)
-##立即开始
- 快捷安装：可通过源码、安装包或docker安装，三秒钟搞定
+- [快捷安装](https://www.taosdata.com/cn/documentation20/getting-started/#快捷安装)：可通过源码、安装包或docker安装，三秒钟搞定
- 轻松启动：使用systemctl 启停TDengine
+- [轻松启动](https://www.taosdata.com/cn/documentation20/getting-started/#轻松启动)：使用systemctl 启停TDengine
- 命令行程序TAOS：访问TDengine的简便方式 
+- [命令行程序TAOS](https://www.taosdata.com/cn/documentation20/getting-started/#TDengine命令行程序)：访问TDengine的简便方式
- [极速体验](https://www.taosdata.com/cn/getting-started/#TDengine-极速体验)：运行示例程序，快速体验高效的数据插入、查询
+- [极速体验](https://www.taosdata.com/cn/documentation20/getting-started/#TDengine-极速体验)：运行示例程序，快速体验高效的数据插入、查询
-##数据模型和整体架构
+## [数据模型和整体架构](https://www.taosdata.com/cn/documentation20/architecture)
- 数据模型：关系型数据库模型，但要求每个采集点单独建表  
- 集群与基本逻辑单元：吸取NoSQL优点，支持水平扩展，支持高可靠
+- [数据模型](https://www.taosdata.com/cn/documentation20/architecture/#数据模型)：关系型数据库模型，但要求每个采集点单独建表
- 存储模型与数据分区：标签数据与时序数据完全分离，按vnode和时间两个维度对数据切分
+- [集群与基本逻辑单元](https://www.taosdata.com/cn/documentation20/architecture/#集群与基本逻辑单元)：吸取NoSQL优点，支持水平扩展，支持高可靠
- 数据写入与复制流程：先写入WAL、之后写入缓存，再给应用确认，支持多副本
+- [存储模型与数据分区、分片](https://www.taosdata.com/cn/documentation20/architecture/#存储模型与数据分区、分片)：标签数据与时序数据完全分离，按vnode和时间两个维度对数据切分
- 缓存与持久化：最新数据缓存在内存中，但落盘时采用列式存储、超高压缩比 
+- [数据写入与复制流程](https://www.taosdata.com/cn/documentation20/architecture/#数据写入与复制流程)：先写入WAL、之后写入缓存，再给应用确认，支持多副本
- 高效查询：支持各种函数、时间轴聚合、插值、多表聚合
+- [缓存与持久化](https://www.taosdata.com/cn/documentation20/architecture/#缓存与持久化)：最新数据缓存在内存中，但落盘时采用列式存储、超高压缩比
+- [数据查询](https://www.taosdata.com/cn/documentation20/architecture/#数据查询)：支持各种函数、时间轴聚合、插值、多表聚合
-##数据建模
- 创建库：为具有相似数据特征的数据采集点创建一个库
+## [数据建模](https://www.taosdata.com/cn/documentation20/model)
- 创建超级表：为同一类型的数据采集点创建一个超级表
- 创建表：使用超级表做模板，为每一个具体的数据采集点单独建表
+- [创建库](https://www.taosdata.com/cn/documentation20/model/#创建库)：为具有相似数据特征的数据采集点创建一个库
+- [创建超级表](https://www.taosdata.com/cn/documentation20/model/#创建超级表)：为同一类型的数据采集点创建一个超级表
-##高效写入数据
+- [创建表](https://www.taosdata.com/cn/documentation20/model/#创建表)：使用超级表做模板，为每一个具体的数据采集点单独建表
- SQL写入：使用SQL insert命令向一张或多张表写入单条或多条记录
- Telegraf 写入：配置Telegraf, 不用任何代码，将采集数据直接写入
+## [高效写入数据](https://www.taosdata.com/cn/documentation20/insert)
- Prometheus写入：配置Prometheus, 不用任何代码，将数据直接写入
- EMQ X Broker：配置EMQ X，不用任何代码，就可将MQTT数据直接写入
+- [SQL写入](https://www.taosdata.com/cn/documentation20/insert/#SQL写入)：使用SQL insert命令向一张或多张表写入单条或多条记录
+- [Telegraf写入](https://www.taosdata.com/cn/documentation20/insert/#Telegraf直接写入)：配置Telegraf, 不用任何代码，将采集数据直接写入
-##高效查询数据
+- [Prometheus写入](https://www.taosdata.com/cn/documentation20/insert/#Prometheus直接写入)：配置Prometheus, 不用任何代码，将数据直接写入
- 主要查询功能：支持各种标准函数，设置过滤条件，时间段查询
+- [EMQ X Broker](https://www.taosdata.com/cn/documentation20/insert/#EMQ-X-Broker直接写入)：配置EMQ X，不用任何代码，就可将MQTT数据直接写入
- 多表聚合查询：使用超级表，设置标签过滤条件，进行高效聚合查询
- 降采样查询：按时间段分段聚合，支持插值
+## [高效查询数据](https://www.taosdata.com/cn/documentation20/queries)
-##高级功能
+- [主要查询功能](https://www.taosdata.com/cn/documentation20/queries/#主要查询功能)：支持各种标准函数，设置过滤条件，时间段查询
- 连续查询(Continuous Query)：基于滑动窗口，定时自动的对数据流进行查询计算
+- [多表聚合查询](https://www.taosdata.com/cn/documentation20/queries/#多表聚合查询)：使用超级表，设置标签过滤条件，进行高效聚合查询
- 数据订阅(Publisher/Subscriber)：象典型的消息队列，应用可订阅接收到的最新数据
+- [降采样查询值](https://www.taosdata.com/cn/documentation20/queries/#降采样查询、插值)：按时间段分段聚合，支持插值
- [缓存 (Cache)](https://www.taosdata.com/cn/documentation/advanced-features/#缓存-(Cache))：每个设备最新的数据都会缓存在内存中，可快速获取
- [报警监测(Alarm monitoring)](https://www.taosdata.com/blog/2020/04/14/1438.html/)：根据配置规则，自动监测超限行为数据，并主动推送
+## [高级功能](https://www.taosdata.com/cn/documentation20/advanced-features)
-##连接器
+- [连续查询(Continuous Query)](https://www.taosdata.com/cn/documentation20/advanced-features/#连续查询(Continuous-Query))：基于滑动窗口，定时自动的对数据流进行查询计算
- C/C++ Connector：通过libtaos客户端的库，连接TDengine服务器的主要方法
+- [数据订阅(Publisher/Subscriber)](https://www.taosdata.com/cn/documentation20/advanced-features/#数据订阅(Publisher/Subscriber))：象典型的消息队列，应用可订阅接收到的最新数据
- Java Connector(JDBC)：通过标准的JDBC API，给Java应用提供到TDengine的连接
+- [缓存(Cache)](https://www.taosdata.com/cn/documentation20/advanced-features/#缓存(Cache))：每个设备最新的数据都会缓存在内存中，可快速获取
- Python Connector：给Python应用提供一个连接TDengine服务器的驱动 
+- [报警监测](https://www.taosdata.com/cn/documentation20/advanced-features/#报警监测(Alert))：根据配置规则，自动监测超限行为数据，并主动推送
- RESTful Connector：提供一最简单的连接TDengine服务器的方式
- Go Connector：给Go应用提供一个连接TDengine服务器的驱动
+## [连接器](https://www.taosdata.com/cn/documentation20/connector)
- Node.js Connector：给node应用提供一个链接TDengine服务器的驱动
+- [C/C++ Connector](https://www.taosdata.com/cn/documentation20/connector/#C/C++-Connector)：通过libtaos客户端的库，连接TDengine服务器的主要方法
-##与其他工具的连接
+- [Java Connector(JDBC)](https://www.taosdata.com/cn/documentation20/connector/#Java-Connector)：通过标准的JDBC API，给Java应用提供到TDengine的连接
- Grafana：获取并可视化保存在TDengine的数据
+- [Python Connector](https://www.taosdata.com/cn/documentation20/connector/#Python-Connector)：给Python应用提供一个连接TDengine服务器的驱动
- Matlab：通过配置Matlab的JDBC数据源访问保存在TDengine的数据
+- [RESTful Connector](https://www.taosdata.com/cn/documentation20/connector/#RESTful-Connector)：提供一最简单的连接TDengine服务器的方式
- R：通过配置R的JDBC数据源访问保存在TDengine的数据 
+- [Go Connector](https://www.taosdata.com/cn/documentation20/connector/#Go-Connector)：给Go应用提供一个连接TDengine服务器的驱动
+- [Node.js Connector](https://www.taosdata.com/cn/documentation20/connector/#Node.js-Connector)：给node应用提供一个链接TDengine服务器的驱动
-## TDengine集群的安装、管理
+## [与其他工具的连接](https://www.taosdata.com/cn/documentation20/connections-with-other-tools)
- 安装：与单节点的安装一样，但要设好配置文件里的参数first
- 节点管理：增加、删除、查看集群的节点
+- [Grafana](https://www.taosdata.com/cn/documentation20/connections-with-other-tools/#Grafana)：获取并可视化保存在TDengine的数据
- mnode的管理：系统自动创建、无需任何人工干预
+- [Matlab](https://www.taosdata.com/cn/documentation20/connections-with-other-tools/#Matlab)：通过配置Matlab的JDBC数据源访问保存在TDengine的数据
- 负载均衡：一旦节点个数或负载有变化，自动进行
+- [R](https://www.taosdata.com/cn/documentation20/connections-with-other-tools/#R)：通过配置R的JDBC数据源访问保存在TDengine的数据
- 节点离线处理：节点离线超过一定时长，将从集群中剔除
- Arbitrator：对于偶数个副本的情形，使用它可以防止split brain。
+## [TDengine集群的安装、管理](https://www.taosdata.com/cn/documentation20/cluster)
-##TDengine的运营和维护
+- [安装](https://www.taosdata.com/cn/documentation20/cluster/#创建第一个节点)：与单节点的安装一样，但要设好配置文件里的参数first
+- [节点管理](https://www.taosdata.com/cn/documentation20/cluster/#节点管理)：增加、删除、查看集群的节点
- 容量规划：根据场景，估算硬件资源
+- [mnode的管理](https://www.taosdata.com/cn/documentation20/cluster/#Mnode的高可用)：系统自动创建、无需任何人工干预
- 容错和灾备：设置正确的WAL和数据副本数 
+- [负载均衡](https://www.taosdata.com/cn/documentation20/cluster/#负载均衡)：一旦节点个数或负载有变化，自动进行
- 系统配置：端口，缓存大小，文件块大小和其他系统配置
+- [节点离线处理](https://www.taosdata.com/cn/documentation20/cluster/#节点离线处理)：节点离线超过一定时长，将从集群中剔除
- 用户管理：添加、删除TDengine用户，修改用户密码
+- [Arbitrator](https://www.taosdata.com/cn/documentation20/cluster/#Arbitrator的使用)：对于偶数个副本的情形，使用它可以防止split brain
- 数据导入：可按脚本文件导入，也可按数据文件导入
- 数据导出：从shell按表导出，也可用taosdump工具做各种导出
+## [TDengine的运营和维护](https://www.taosdata.com/cn/documentation20/administrator)
- 系统监控：检查系统现有的连接、查询、流式计算，日志和事件等
- 文件目录结构：TDengine数据文件、配置文件等所在目录 Hui Li
+- [容量规划](https://www.taosdata.com/cn/documentation20/administrator/#容量规划)：根据场景，估算硬件资源
+- [容错和灾备](https://www.taosdata.com/cn/documentation20/administrator/#容错和灾备)：设置正确的WAL和数据副本数
-##TAOS SQL 
+- [系统配置](https://www.taosdata.com/cn/documentation20/administrator/#服务端配置)：端口，缓存大小，文件块大小和其他系统配置
- 支持的数据类型：支持时间戳、整型、浮点型、布尔型、字符型等多种数据类型 
+- [用户管理](https://www.taosdata.com/cn/documentation20/administrator/#用户管理)：添加、删除TDengine用户，修改用户密码
- 数据库管理：添加、删除、查看数据库
+- [数据导入](https://www.taosdata.com/cn/documentation20/administrator/#数据导入)：可按脚本文件导入，也可按数据文件导入
- 表管理：添加、删除、查看、修改表
+- [数据导出](https://www.taosdata.com/cn/documentation20/administrator/#数据导出)：从shell按表导出，也可用taosdump工具做各种导出
- 超级表管理：添加、删除、查看、修改超级表
+- [系统监控](https://www.taosdata.com/cn/documentation20/administrator/#系统监控)：检查系统现有的连接、查询、流式计算，日志和事件等
- 标签管理：增加、删除、修改标签
+- [文件目录结构](https://www.taosdata.com/cn/documentation20/administrator/#文件目录结构)：TDengine数据文件、配置文件等所在目录
- 数据写入：支持单表单条、多条、多表多条写入，支持历史数据写入
- 数据查询：支持时间段、值过滤、排序、查询结果手动分页等
+## [TAOS SQL](https://www.taosdata.com/cn/documentation20/taos-sql)
- SQL函数：支持各种聚合函数、选择函数、计算函数，如avg, min, diff等
- 时间维度聚合：将表中数据按照时间段进行切割后聚合，降维处理
+- [支持的数据类型](https://www.taosdata.com/cn/documentation20/taos-sql/#支持的数据类型)：支持时间戳、整型、浮点型、布尔型、字符型等多种数据类型
+- [数据库管理](https://www.taosdata.com/cn/documentation20/taos-sql/#数据库管理)：添加、删除、查看数据库
-##TDengine的技术设计
+- [表管理](https://www.taosdata.com/cn/documentation20/taos-sql/#表管理)：添加、删除、查看、修改表
+- [超级表管理](https://www.taosdata.com/cn/documentation20/taos-sql/#超级表STable管理)：添加、删除、查看、修改超级表
+- [标签管理](https://www.taosdata.com/cn/documentation20/taos-sql/#超级表-STable-中-TAG-管理)：增加、删除、修改标签
+- [数据写入](https://www.taosdata.com/cn/documentation20/taos-sql/#数据写入)：支持单表单条、多条、多表多条写入，支持历史数据写入
+- [数据查询](https://www.taosdata.com/cn/documentation20/taos-sql/#数据查询)：支持时间段、值过滤、排序、查询结果手动分页等
+- [SQL函数](https://www.taosdata.com/cn/documentation20/taos-sql/#SQL函数)：支持各种聚合函数、选择函数、计算函数，如avg, min, diff等
+- [时间维度聚合](https://www.taosdata.com/cn/documentation20/taos-sql/#时间维度聚合)：将表中数据按照时间段进行切割后聚合，降维处理
+## TDengine的技术设计
 - 系统模块：taosd的功能和模块划分
- 技术博客：更多的技术分析和架构设计文章
+- 数据复制：支持实时同步、异步复制，保证系统的High Availibility
+- [技术博客](https://www.taosdata.com/cn/blog/?categories=3)：更多的技术分析和架构设计文章
 ## 常用工具
- [TDengine样例数据导入工具](https://www.taosdata.com/cn/documentation/blog/2020/01/18/如何快速验证性能和主要功能？tdengine样例数据导入工/)
+- [TDengine样例导入工具](https://www.taosdata.com/blog/2020/01/18/1166.html)
- [TDengine性能对比测试工具](https://www.taosdata.com/cn/documentation/blog/2020/01/13/用influxdb开源的性能测试工具对比influxdb和tdengine/)
+- [TDengine性能对比测试工具](https://www.taosdata.com/blog/2020/01/18/1166.html)
-##TDengine与其他数据库的对比测试
+## TDengine与其他数据库的对比测试
- [用InfluxDB开源的性能测试工具对比InfluxDB和TDengine](https://www.taosdata.com/cn/documentation/blog/2020/01/13/用influxdb开源的性能测试工具对比influxdb和tdengine/)
+- [用InfluxDB开源的性能测试工具对比InfluxDB和TDengine](https://www.taosdata.com/blog/2020/01/13/1105.html)
- [TDengine与OpenTSDB对比测试](https://www.taosdata.com/cn/documentation/blog/2019/08/21/tdengine与opentsdb对比测试/)
+- [TDengine与OpenTSDB对比测试](https://www.taosdata.com/blog/2019/08/21/621.html)
- [TDengine与Cassandra对比测试](https://www.taosdata.com/cn/documentation/blog/2019/08/14/tdengine与cassandra对比测试/)
+- [TDengine与Cassandra对比测试](https://www.taosdata.com/blog/2019/08/14/573.html)
- [TDengine与InfluxDB对比测试](https://www.taosdata.com/cn/documentation/blog/2019/07/19/tdengine与influxdb对比测试/)
+- [TDengine与InfluxDB对比测试](https://www.taosdata.com/blog/2019/07/19/419.html)
 - [TDengine与InfluxDB、OpenTSDB、Cassandra、MySQL、ClickHouse等数据库的对比测试报告](https://www.taosdata.com/downloads/TDengine_Testing_Report_cn.pdf)
 ##物联网大数据
- [物联网、工业互联网大数据的特点](https://www.taosdata.com/blog/2019/07/09/物联网、工业互联网大数据的特点/)
- [物联网大数据平台应具备的功能和特点](https://www.taosdata.com/blog/2019/07/29/物联网大数据平台应具备的功能和特点/)
- [通用大数据架构为什么不适合处理物联网数据？](https://www.taosdata.com/blog/2019/07/09/通用互联网大数据处理架构为什么不适合处理物联/)
- [物联网、车联网、工业互联网大数据平台，为什么推荐使用TDengine？](https://www.taosdata.com/blog/2019/07/09/物联网、车联网、工业互联网大数据平台，为什么/)
-##培训和FAQ
+- [物联网、工业互联网大数据的特点](https://www.taosdata.com/blog/2019/07/09/105.html)
- <a href='https://www.taosdata.com/en/faq'>FAQ</a>：常见问题与答案
+- [物联网大数据平台应具备的功能和特点](https://www.taosdata.com/blog/2019/07/29/542.html)
- <a href='https://www.taosdata.com/en/blog/?categories=4'>应用案列</a>：一些使用实例来解释如何使用TDengine
+- [通用大数据架构为什么不适合处理物联网数据？](https://www.taosdata.com/blog/2019/07/09/107.html)
+- [物联网、车联网、工业互联网大数据平台，为什么推荐使用TDengine？](https://www.taosdata.com/blog/2019/07/09/109.html)
+## [培训和FAQ](https://www.taosdata.com/cn/faq)
+- [FAQ](https://www.taosdata.com/cn/documentation20/faq)：常见问题与答案
\ No newline at end of file
+- [应用案列](https://www.taosdata.com/cn/blog/?categories=4)：一些使用实例来解释如何使用TDengine
\ No newline at end of file
--- a/documentation20/webdocs/markdowndocs/Evaluation-ch.md
+++ b/documentation20/webdocs/markdowndocs/Evaluation-ch.md
 # TDengine 介绍
 ## TDengine 简介
 TDengine是涛思数据面对高速增长的物联网大数据市场和技术挑战推出的创新性的大数据处理产品，它不依赖任何第三方软件，也不是优化或包装了一个开源的数据库或流式计算产品，而是在吸取众多传统关系型数据库、NoSQL数据库、流式计算引擎、消息队列等软件的优点之后自主开发的产品，在时序空间大数据处理上，有着自己独到的优势。
 TDengine的模块之一是时序数据库。但除此之外，为减少研发的复杂度、系统维护的难度，TDengine还提供缓存、消息队列、订阅、流式计算等功能，为物联网、工业互联网大数据的处理提供全栈的技术方案，是一个高效易用的物联网大数据平台。与Hadoop等典型的大数据平台相比，它具有如下鲜明的特点：
@@ -15,46 +16,45 @@ TDengine的模块之一是时序数据库。但除此之外，为减少研发的
 采用TDengine，可将典型的物联网、车联网、工业互联网大数据平台的总拥有成本大幅降低。但需要指出的是，因充分利用了物联网时序数据的特点，它无法用来处理网络爬虫、微博、微信、电商、ERP、CRM等通用型数据。
 ## TDengine 总体适用场景
-作为一个IoT大数据平台，TDengine的典型适用场景是在IoT范畴，而且用户有一定的数据量。本文后续的介绍主要针对这个范畴里面的系统。范畴之外的系统，比如CRM，ERP等，不在本文讨论范围内。
+作为一个IOT大数据平台，TDengine的典型适用场景是在IOT范畴，而且用户有一定的数据量。本文后续的介绍主要针对这个范畴里面的系统。范畴之外的系统，比如CRM，ERP等，不在本文讨论范围内。
 ### 数据源特点和需求
-从数据源角度，设计人员可以从如下几个角度分析TDengine在目标应用系统里面的适用性。
+从数据源角度，设计人员可以从已经角度分析TDengine在目标应用系统里面的适用性。
 |数据源特点和需求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
-|总体数据量巨大|  |  | ✅ |TDengine在容量方面提供出色的水平扩展功能，并且具备匹配高压缩的存储结构和多级存储，达到业界最优的存储效率。|
+|总体数据量巨大|  |  | √ |TDengine在容量方面提供出色的水平扩展功能，并且具备匹配高压缩的存储结构，达到业界最优的存储效率。|
-|数据输入速度偶尔或者持续巨大|   |   | ✅  | TDengine的性能大大超过同类产品，可以在同样的硬件环境下持续处理大量的输入数据，并且提供很容易在用户环境里面运行的性能评估工具。|
+|数据输入速度偶尔或者持续巨大|   |   | √ | TDengine的性能大大超过同类产品，可以在同样的硬件环境下持续处理大量的输入数据，并且提供很容易在用户环境里面运行的性能评估工具。|
-|数据源数目巨大|   |   | ✅ |TDengine设计中包含专门针对大量数据源的优化，包括数据的写入和查询，尤其适合高效处理海量（千万或者更多量级）的数据源。|
+|数据源数目巨大|   |   | √ |TDengine设计中包含专门针对大量数据源的优化，包括数据的写入和查询，尤其适合高效处理海量（千万或者更多量级）的数据源。|
-###系统架构要求
+### 系统架构要求
 |系统架构要求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
-|要求简单可靠的系统架构|  |  | ✅ |TDengine的系统架构非常简单可靠，自带消息队列，缓存，流式计算，监控等功能，无需集成额外的第三方产品。|
+|要求简单可靠的系统架构|  |  | √ |TDengine的系统架构非常简单可靠，自带消息队列，缓存，流式计算，监控等功能，无需集成额外的第三方产品。|
-|要求容错和高可靠|  |  | ✅ |TDengine的集群功能，自动提供容错灾备等高可靠功能|
+|要求容错和高可靠|  |  | √ |TDengine的集群功能，自动提供容错灾备等高可靠功能|
-|标准化规范|  |  | ✅ |TDengine使用标准的SQL语言提供主要功能，遵守标准化规范|
+|标准化规范|  |  | √ |TDengine使用标准的SQL语言提供主要功能，遵守标准化规范|
-###系统功能需求
+### 系统功能需求
 |系统功能需求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
-|要求完整的内置数据处理算法|  | ✅ |  |TDengine的实现了通用的数据处理算法，但是还没有做到妥善处理各行各业的所有要求，因此特殊类型的处理还需要应用层面处理。|
+|要求完整的内置数据处理算法|  | √ |  |TDengine的实现了通用的数据处理算法，但是还没有做到妥善处理各行各业的所有要求，因此特殊类型的处理还需要应用层面处理。|
-|需要大量的交叉查询处理|  | ✅ |  |这种类型的处理更多应该用关系型数据系统处理，或者应该考虑TDengine和关系型数据系统配合实现系统功能|
+|需要大量的交叉查询处理|  | √ |  |这种类型的处理更多应该用关系型数据系统处理，或者应该考虑TDengine和关系型数据系统配合实现系统功能|
-###系统性能需求
+### 系统性能需求
 |系统性能需求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
-|要求较大的总体处理能力|  |  | ✅ |TDengine的集群功能可以轻松地让多服务器配合达成处理能力的提升。|
+|要求较大的总体处理能力|  |  | √ |TDengine的集群功能可以轻松地让多服务器配合达成处理能力的提升。|
-|要求高速处理数据  | | | ✅ |TDengine的专门为IOT优化的存储和数据处理的设计，一般可以让系统得到超出同类产品多倍数的处理速度提升。|
+|要求高速处理数据  | | | √ |TDengine的专门为IOT优化的存储和数据处理的设计，一般可以让系统得到超出同类产品多倍数的处理速度提升。|
-|要求快速处理小粒度数据|  |  | ✅ |这方面TDengine性能可以完全对标关系型和NoSQL型数据处理系统。|
+|要求快速处理小粒度数据|  |  | √ |这方面TDengine性能可以完全对标关系型和NoSQL型数据处理系统。|
-###系统维护需求
+### 系统维护需求
 |系统维护需求|不适用|可能适用|非常适用|简单说明|
 |---|---|---|---|---|
-|要求系统可靠运行|  |  | ✅ |TDengine的系统架构非常稳定可靠，日常维护也简单便捷，对维护人员的要求简洁明了，最大程度上杜绝人为错误和事故。|
+|要求系统可靠运行|  |  | √ |TDengine的系统架构非常稳定可靠，日常维护也简单便捷，对维护人员的要求简洁明了，最大程度上杜绝人为错误和事故。|
-|要求运维学习成本可控|  |  | ✅ |同上|
+|要求运维学习成本可控|  |  | √ |同上|
-|要求市场有大量人才储备| ✅ |  |  |TDengine作为新一代产品，目前人才市场里面有经验的人员还有限。但是学习成本低，我们作为厂家也提供运维的培训和辅助服务|
+|要求市场有大量人才储备| √ |  |  |TDengine作为新一代产品，目前人才市场里面有经验的人员还有限。但是学习成本低，我们作为厂家也提供运维的培训和辅助服务|
-##TDengine 性能指标介绍和验证方法
+## TDengine 性能指标介绍和验证方法
--- a/documentation20/webdocs/markdowndocs/Getting Started-ch.md
+++ b/documentation20/webdocs/markdowndocs/Getting Started-ch.md
@@ -38,7 +38,7 @@ which systemd
 如果系统中不存在`systemd`命令，请考虑[通过源码安装](#通过源码安装)TDengine。
-具体的安装过程，请参见[`TDengine多种安装包的安装和卸载`](https://www.taosdata.com/blog/2019/08/09/566.html)
+具体的安装过程，请参见<a href="https://www.taosdata.com/blog/2019/08/09/566.html">TDengine多种安装包的安装和卸载</a>。
 ## 轻松启动

--- a/documentation20/webdocs/markdowndocs/Model-ch.md
+++ b/documentation20/webdocs/markdowndocs/Model-ch.md
@@ -4,14 +4,14 @@
 TDengine采用关系型数据模型，需要建库、建表。因此对于一个具体的应用场景，需要考虑库的设计，超级表和普通表的设计。本节不讨论细致的语法规则，只介绍概念。
-##创建库
+## 创建库
 不同类型的数据采集点往往具有不同的数据特征，包括数据采集频率的高低，数据保留时间的长短，副本的数目，数据块的大小等等。为让各种场景下TDengine都能最大效率的工作，TDengine建议将不同数据特征的表创建在不同的库里，因为每个库可以配置不同的存储策略。创建一个库时，除SQL标准的选项外，应用还可以指定保留时长、副本数、内存块个数、时间精度、文件块里最大最小记录条数、是否压缩、一个数据文件覆盖的天数等多种参数。比如：
 ```cmd
 CREATE DATABASE power KEEP 365 DAYS 10 REPLICA 3 BLOCKS 4;
 ```
-上述语句将创建一个名为power的库，这个库的数据将保留365天（超过365天将被自动删除），每10天一个数据文件，副本数为3, 内存块数为4。详细的语法及参数请见TAOS SQL。
+上述语句将创建一个名为power的库，这个库的数据将保留365天（超过365天将被自动删除），每10天一个数据文件，副本数为3, 内存块数为4。详细的语法及参数请见<a href="https://www.taosdata.com/cn/documentation20/taos-sql/">TAOS SQL </a>
 注意：任何一张表或超级表是属于一个库的，在创建表之前，必须先创建库。
@@ -20,7 +20,7 @@ CREATE DATABASE power KEEP 365 DAYS 10 REPLICA 3 BLOCKS 4;
 ```cmd
 CREATE TABLE meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupdId int);
 ```
-与创建普通表一样，创建表时，需要提供表名（示例中为meters），表结构Schema，即数据列的定义，为采集的物理量（示例中为ts, current, voltage, phase)，数据类型可以为整型、浮点型、字符串等。除此之外，还需要提供标签的schema (示例中为location, groupId)，标签的数据类型可以为整型、浮点型、字符串等。采集点的静态属性往往可以作为标签，比如采集点的地理位置、设备型号、设备组ID、管理员ID等等。标签的schema可以事后增加、删除、修改。具体定义以及细节请见 TAOS SQL一节。
+与创建普通表一样，创建表时，需要提供表名（示例中为meters），表结构Schema，即数据列的定义，为采集的物理量（示例中为ts, current, voltage, phase)，数据类型可以为整型、浮点型、字符串等。除此之外，还需要提供标签的schema (示例中为location, groupId)，标签的数据类型可以为整型、浮点型、字符串等。采集点的静态属性往往可以作为标签，比如采集点的地理位置、设备型号、设备组ID、管理员ID等等。标签的schema可以事后增加、删除、修改。具体定义以及细节请见 <a href="https://www.taosdata.com/cn/documentation20/taos-sql/">TAOS SQL </a>一节。
 每一种类型的数据采集点需要建立一个超级表，因此一个物联网系统，往往会有多个超级表。一个系统可以有多个DB，一个DB里可以有一到多个超级表。
@@ -31,7 +31,7 @@ CREATE TABLE d1001 USING meters TAGS ("Beijing.Chaoyang", 2);
 ```
 其中d1001是表名，meters是超级表的表名，后面紧跟标签Location的具体标签值”Beijing.Chaoyang"，标签groupId的具体标签值2。虽然在创建表时，需要指定标签值，但可以事后修改。详细细则请见 TAOS SQL。
-TDengine建议将数据采集点的全局唯一ID作为表名。但对于有的场景，并没有唯一的ID，可以将多个ID组合成一个唯一的ID。不建议将具有唯一性的ID作为标签值。
+TDengine建议将数据采集点的全局唯一ID作为表名(比如设备序列号）。但对于有的场景，并没有唯一的ID，可以将多个ID组合成一个唯一的ID。不建议将具有唯一性的ID作为标签值。
 **自动建表**：在某些特殊场景中，用户在写数据时并不确定某个数据采集点的表是否存在，此时可在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表。比如：
@@ -40,4 +40,5 @@ INSERT INTO d1001 USING METERS TAGS ("Beijng.Chaoyang", 2) VALUES (now, 10.2, 21
 ```
 上述SQL语句将记录(now, 10.2, 219, 0.32) 插入进表d1001。如果表d1001还未创建，则使用超级表meters做模板自动创建，同时打上标签值“Beijing.Chaoyang", 2。
 **多列模型**：TDengine支持多列模型，只要这些物理量是同时采集的，这些量就可以作为不同列放在同一张表里。有的数据采集点有多组采集量，每一组的数据采集时间是不一样的，这时需要对同一个采集点建多张表。但还有一种极限的设计，单列模型，无论是否同时采集，每个采集的物理量单独建表。TDengine建议，只要采集时间一致，就采用多列模型，因为插入效率以及存储效率更高。
\ No newline at end of file
--- a/documentation20/webdocs/markdowndocs/Queries-ch.md
+++ b/documentation20/webdocs/markdowndocs/Queries-ch.md
@@ -6,17 +6,16 @@
 ## 主要查询功能
-TDengine采用SQL作为查询语言，应用程序可以通过C/C++, JDBC, GO, Python连接器发送SQL查询语句，用户还可以通过TAOS Shell直接手动执行SQL即席查询，十分方便。支持如下查询功能：
+TDengine 采用 SQL 作为查询语言。应用程序可以通过 C/C++, Java, Go, Python 连接器发送 SQL 语句，用户可以通过 TDengine 提供的命令行（Command Line Interface, CLI）工具 TAOS Shell 手动执行 SQL 即席查询（Ad-Hoc Query）。TDengine 支持如下查询功能：
- 查询单列、或多列查询
+- 单列、多列数据查询
- 支持值过滤条件：\>, \<,  =, \<> 大于，小于，等于，不等于等等
+- 标签和数值的多种过滤条件：\>, \<,  =, \<>, like 等
- 支持对标签的模糊匹配
+- 聚合结果的分组（Group by）、排序（Order by）、约束输出（Limit/Offset）
- 支持Group by, Order by, Limit, Offset
+- 数值列及聚合结果的四则运算
- 支持列之间的四则运算
+- 时间戳对齐的连接查询（Join Query）操作
- 支持时间戳对齐的JOIN操作
+- 多种聚合/计算函数: count, max, min, avg, sum, twa, stddev, leastsquares, top, bottom, first, last, percentile, apercentile, last_row, spread, diff等
- 支持多种函数: count, max, min, avg, sum, twa, stddev, leastsquares, top, bottom, first, last, percentile, apercentile, last_row, spread, diff
-例如：在TAOS Shell中，从表d1001中查询出vlotage >215的记录，按时间降序排列，仅仅输出2条。
+例如：在TAOS Shell中，从表d1001中查询出vlotage > 215的记录，按时间降序排列，仅仅输出2条。
 ```mysql
 taos> select * from d1001 where voltage > 215 order by ts desc limit 2;
           ts            |       current        |   voltage   |        phase         |
@@ -27,11 +26,11 @@ Query OK, 2 row(s) in set (0.001100s)
 ```
 为满足物联网场景的需求，TDengine支持几个特殊的函数，比如twa(时间加权平均)，spread (最大值与最小值的差)，last_row(最后一条记录)等，更多与物联网场景相关的函数将添加进来。TDengine还支持连续查询。
-具体的查询语法请看TAOS SQL。
+具体的查询语法请看<a href="https://www.taosdata.com/cn/documentation20/taos-sql/">TAOS SQL </a>。
 ## 多表聚合查询
-TDengine对每个数据采集点单独建表，但应用经常需要对数据点之间进行聚合。为高效的进行聚合操作，TDengine引入超级表（STable）的概念。超级表用来代表一特定类型的数据采集点，它是表的集合，包含多张表。这集合里每张表的Schema是一样的，但每张表都带有自己的静态标签，标签可以多个，可以随时增加、删除和修改。
+TDengine对每个数据采集点单独建表，但在实际应用中经常需要对不同的采集点数据进行聚合。为高效的进行聚合操作，TDengine引入超级表（STable）的概念。超级表用来代表一特定类型的数据采集点，它是包含多张表的表集合，集合里每张表的模式（schema）完全一致，但每张表都带有自己的静态标签，标签可以多个，可以随时增加、删除和修改。
 应用可通过指定标签的过滤条件，对一个STable下的全部或部分表进行聚合或统计操作，这样大大简化应用的开发。其具体流程如下图所示：
@@ -39,16 +38,16 @@ TDengine对每个数据采集点单独建表，但应用经常需要对数据点
 <center> 多表聚合查询原理图  </center>
-1：应用将一个查询条件发往系统；2: taosc将超级表的名字发往Meta Node（管理节点)；3：管理节点将超级表所拥有的vnode列表发回taosc；4：taosc将计算的请求连同标签过滤条件发往这些vnode对应的多个数据节点；5：每个vnode先在内存里查找出自己节点里符合标签过滤条件的表的集合，然后扫描存储的时序数据，完成相应的聚合计算，将结果返回给taosc；6：taosc将多个数据节点返回的结果做最后的聚合，将其返回给应用。
+1：应用将一个查询条件发往系统；2: taosc将超级表的名字发往 Meta Node（管理节点)；3：管理节点将超级表所拥有的 vnode 列表发回 taosc；4：taosc将计算的请求连同标签过滤条件发往这些vnode对应的多个数据节点；5：每个vnode先在内存里查找出自己节点里符合标签过滤条件的表的集合，然后扫描存储的时序数据，完成相应的聚合计算，将结果返回给taosc；6：taosc将多个数据节点返回的结果做最后的聚合，将其返回给应用。
-由于TDengine在vnode内将标签数据与时序数据分离存储，通过先在内存里过滤标签数据，将需要扫描的数据集大幅减少，大幅提升了聚合计算速度。同时，由于数据分布在多个vnode/dnode，聚合计算操作在多个vnode里并发进行，又进一步提升了聚合的速度。
+由于TDengine在vnode内将标签数据与时序数据分离存储，通过先在内存里过滤标签数据，将需要扫描的数据集大幅减少，大幅提升聚合计算速度。同时，由于数据分布在多个vnode/dnode，聚合计算操作在多个vnode里并发进行，又进一步提升了聚合的速度。
-对普通表的聚合函数以及绝大部分操作都适用于超级表，语法完全一样，细节请看TAOS SQL。
+对普通表的聚合函数以及绝大部分操作都适用于超级表，语法完全一样，细节请看 TAOS SQL。
 比如：在TAOS Shell，查找所有智能电表采集的电压平均值，并按照location分组
 ```mysql
-taos> select avg(voltage) from meters group by location;
+taos> SELECT AVG(voltage) FROM meters GROUP BY location;
       avg(voltage)        |            location            |
 =============================================================
             222.000000000 | Beijing.Haidian                |
@@ -58,18 +57,18 @@ Query OK, 2 row(s) in set (0.002136s)
 ## 降采样查询、插值
-物联网场景里，经常需要做down sampling，需要将采集的数据按时间段进行聚合。TDengine提供了一个简便的关键词interval让操作变得极为简单。比如：将智能电表d1001采集的电流值每10秒钟求和
+物联网场景里，经常需要通过降采样（down sampling）将采集的数据按时间段进行聚合。TDengine 提供了一个简便的关键词 interval 让按照时间窗口的查询操作变得极为简单。比如，将智能电表 d1001 采集的电流值每10秒钟求和
 ```mysql
-taos> SELECT sum(current) FROM d1001 interval(10s) ;
+taos> SELECT sum(current) FROM d1001 INTERVAL(10s) ;
           ts            |       sum(current)        |
 ======================================================
 2018-10-03 14:38:00.000 |              10.300000191 |
 2018-10-03 14:38:10.000 |              24.900000572 |
 Query OK, 2 row(s) in set (0.000883s)
 ```
-降采样操作还适用于超级表，比如：将所有智能电表采集的电流值每秒钟求和
+降采样操作也适用于超级表，比如：将所有智能电表采集的电流值每秒钟求和
 ```mysql
-taos> SELECT sum(current) FROM meters interval(1s) ;
+taos> SELECT SUM(current) FROM meters INTERVAL(1s) ;
           ts            |       sum(current)        |
 ======================================================
 2018-10-03 14:38:04.000 |              10.199999809 |
@@ -82,5 +81,5 @@ Query OK, 5 row(s) in set (0.001538s)
 物联网场景里，每个数据采集点采集数据的时间是难同步的，但很多分析算法(比如FFT)需要把采集的数据严格按照时间等间隔的对齐，在很多系统里，需要应用自己写程序来处理，但使用TDengine的降采样操作就轻松解决。如果一个时间间隔里，没有采集的数据，TDengine还提供插值计算的功能。
-语法规则细节请见TAOS SQL。
+语法规则细节请见<a href="https://www.taosdata.com/cn/documentation20/taos-sql/">TAOS SQL </a>。
--- a/documentation20/webdocs/markdowndocs/administrator-ch.md
+++ b/documentation20/webdocs/markdowndocs/administrator-ch.md
-#系统管理
+# TDengine的运营与维护
 ## 容量规划
-一个系统的处理能力是有限的，但通过对TDengine配置参数的调整，可以做到资源的最佳配置。
+使用TDengine来搭建一个物联网大数据平台，计算资源、存储资源需要根据业务场景进行规划。下面分别讨论系统运行所需要的内存、CPU以及硬盘空间。
-###内存需求
+### 内存需求
-每个Database可以创建固定数目的Vnode，默认与CPU核数相同，可通过maxVgroupsPerDb配置；每个vnode会占用固定大小的内存（大小与数据库的配置参数blocks和cache有关)；每个Table会占用与Tag总大小有关的内存；此外，系统会有一些固定的内存开销。因此，每个Database需要的系统内存可通过如下公式计算：
+每个DB可以创建固定数目的vnode，默认与CPU核数相同，可通过maxVgroupsPerDb配置；每个vnode会占用固定大小的内存（大小与数据库的配置参数blocks和cache有关)；每个Table会占用与标签总长度有关的内存；此外，系统会有一些固定的内存开销。因此，每个DB需要的系统内存可通过如下公式计算：
 ```
 Memory Size = maxVgroupsPerDb * (blocks * cache + 10Mb) + numOfTables * (tagSizePerTable + 0.5Kb)
 ```
-示例：假设是4核机器，cache是缺省大小16M, blocks是缺省值6，假设有10万张表，标签总长度是256字节，则从的内存需求为：4\*(16\*6+10) + 100000*(0.25+0.5)/1000 = 499M 
+示例：假设是4核机器，cache是缺省大小16M, blocks是缺省值6，假设有10万张表，标签总长度是256字节，则总的内存需求为：4\*(16\*6+10) + 100000*(0.25+0.5)/1000 = 499M。 
+实际运行的系统往往会根据数据特点的不同，将数据存放在不同的DB里。因此做规划时，也需要考虑。
 如果内存充裕，可以加大Blocks的配置，这样更多数据将保存在内存里，提高查询速度。
-###CPU需求
+### CPU需求
 CPU的需求取决于如下两方面：
- 数据插入：TDengine单核每秒能至少处理一万个插入请求。每个插入请求可以带多条记录。条数越大，插入效率越高。但对前端数据采集的要求越高，因为需要缓存记录，然后一批插入。
+* __数据插入__ TDengine单核每秒能至少处理一万个插入请求。每个插入请求可以带多条记录，一次插入一条记录与插入10条记录，消耗的计算资源差别很小。因此每次插入，条数越大，插入效率越高。如果一个插入请求带200条以上记录，单核就能达到每秒插入100万条记录的速度。但对前端数据采集的要求越高，因为需要缓存记录，然后一批插入。
- 查询需求：TDengine提供高效的查询，但是每个场景的查询差异很大，查询频次变化也很大，难以给出客观数字。需要用户针对自己的场景，写一些查询语句，才能确定。
+* __查询需求__ TDengine提供高效的查询，但是每个场景的查询差异很大，查询频次变化也很大，难以给出客观数字。需要用户针对自己的场景，写一些查询语句，才能确定。
 因此仅对数据插入而言，CPU是可以估算出来的，但查询所耗的计算资源无法估算。在实际运营过程中，不建议CPU使用率超过50%，超过后，需要增加新的节点，以获得更多计算资源。
-###存储需求
+### 存储需求
-TDengine相对于通用数据库，有超高的压缩比，在绝大多数场景下，TDengine的压缩比不会低于5倍，有的场合，压缩比可达到10倍以上，取决于数据特征。压缩前的原始数据大小可通过如下方式计算：
+TDengine相对于通用数据库，有超高的压缩比，在绝大多数场景下，TDengine的压缩比不会低于5倍，有的场合，压缩比可达到10倍以上，取决于实际场景的数据特征。压缩前的原始数据大小可通过如下方式计算：
 ```
 Raw DataSize = numOfTables * rowSizePerTable * rowsPerTable
@@ -39,6 +41,12 @@ Raw DataSize = numOfTables * rowSizePerTable * rowsPerTable
 为提高速度，可以配置多快硬盘，这样可以并发写入或读取数据。
+### 物理机或虚拟机台数
+根据上面的内存、CPU、存储的预估，就可以知道整个系统需要多少核、多少内存、多少存储空间。如果数据副本数不为1，总需求量需要再乘以副本数。
+因为TDengine具有很好的水平扩展能力，根据总量，再根据单个物理机或虚拟机的资源，就可以轻松决定需要购置多少台物理机或虚拟机了。
 ## 容错和灾备
 ### 容错
@@ -47,15 +55,16 @@ TDengine支持**WAL**（Write Ahead Log）机制，实现数据的容错能力
 TDengine接收到应用的请求数据包时，先将请求的原始数据包写入数据库日志文件，等数据成功写入数据库数据文件后，再删除相应的WAL。这样保证了TDengine能够在断电等因素导致的服务重启时从数据库日志文件中恢复数据，避免数据的丢失。
-涉及的系统配置参数有两个.
+涉及的系统配置参数有两个：
-walLevel：WAL级别，0：不写wal; 1：写wal, 但不执行fsync; 2：写wal, 而且执行fsync。
+- walLevel：WAL级别，0：不写wal; 1：写wal, 但不执行fsync; 2：写wal, 而且执行fsync。
+- fsync：当walLevel设置为2时，执行fsync的周期。设置为0，表示每次写入，立即执行fsync。
-fsync：当walLevel设置为2时，执行fsync的周期。设置为0，表示每次写入，立即执行fsync。
+如果要100%的保证数据不丢失，需要将walLevel设置为2，fsync设置为0。这时写入速度将会下降。但如果应用侧启动的写数据的线程数达到一定的数量(超过50)，那么写入数据的性能也会很不错，只会比fsync设置为3000毫秒下降30%左右。
-**灾备**
+### 灾备
-TDengine的集群通过多个副本的机制，来提供系统的高可靠性，实现灾备能力。
+TDengine的集群通过多个副本的机制，来提供系统的高可用性，实现灾备能力。
 TDengine集群是由mnode负责管理的，为保证mnode的高可靠，可以配置多个mnode副本，副本数由系统配置参数numOfMnodes决定，为了支持高可靠，需要设置大于1。为保证元数据的强一致性，mnode副本之间通过同步方式进行数据复制，保证了元数据的强一致性。
@@ -63,33 +72,7 @@ TDengine集群中的时序数据的副本数是与数据库关联的，一个集
 TDengine集群的节点数必须大于等于副本数，否则创建表时将报错。
-当TDengine集群中的节点部署在不同的物理机上（比如不同的机架、或不同的IDC），并设置多个副本数时，就实现了异地容灾，从而提供系统的高可靠性，无需再使用其他软件或工具。
+当TDengine集群中的节点部署在不同的物理机上，并设置多个副本数时，就实现了系统的高可靠性，无需再使用其他软件或工具。TDengine企业版还可以将副本部署在不同机房，从而实现异地容灾。
-## 文件目录结构
-安装TDengine后，默认会在操作系统中生成下列目录或文件：
-| 目录/文件               | 说明                                              |
-| ---------------------- | :------------------------------------------------|
-| /usr/local/taos/bin | TDengine可执行文件目录。其中的执行文件都会软链接到/usr/bin目录下。 |
-| /usr/local/taos/connector | TDengine各种连接器目录。 |
-| /usr/local/taos/driver | TDengine动态链接库目录。会软链接到/usr/lib目录下。 |
-| /usr/local/taos/examples | TDengine各种语言应用示例目录。 |
-| /usr/local/taos/include | TDengine对外提供的C语言接口的头文件。 |
-| /etc/taos/taos.cfg     | TDengine默认[配置文件]                            |
-| /var/lib/taos          | TDengine默认数据文件目录,可通过[配置文件]修改位置.    |
-| /var/log/taos          | TDengine默认日志文件目录,可通过[配置文件]修改位置     |
-**可执行文件**
-TDengine的所有可执行文件默认存放在 _/usr/local/taos/bin_ 目录下。其中包括：
- _taosd_：TDengine服务端可执行文件
- _taos_： TDengine Shell可执行文件
- _taosdump_：数据导入导出工具
- remove.sh：卸载TDengine的脚本, 请谨慎执行，链接到/usr/bin目录下的rmtaos命令。会删除TDengine的安装目录/usr/local/taos，但会保留/etc/taos、/var/lib/taos、/var/log/taos。
-您可以通过修改系统配置文件taos.cfg来配置不同的数据目录和日志目录。
 ## 服务端配置
@@ -97,8 +80,8 @@ TDengine系统后台服务由taosd提供，可以在配置文件taos.cfg里修
 下面仅仅列出一些重要的配置参数，更多的参数请看配置文件里的说明。各个参数的详细介绍及作用请看前述章节。**注意：配置修改后，需要重启*taosd*服务才能生效。**
- first: taosd启动时，主动连接的集群中第一个dnode的end point, 缺省值为 localhost:6030。
+- firstEp: taosd启动时，主动连接的集群中第一个dnode的end point, 缺省值为 localhost:6030。
- second: taosd启动时，如果first连接不上，尝试连接集群中第二个dnode的end point, 缺省值为空。
+- secondEp: taosd启动时，如果first连接不上，尝试连接集群中第二个dnode的end point, 缺省值为空。
 - fqdn：数据节点的FQDN。如果为空，将自动获取操作系统配置的第一个, 缺省值为空。
 - serverPort：taosd启动后，对外服务的端口号，默认值为6030。
 - httpPort: RESTful服务使用的端口号，所有的HTTP请求（TCP）都需要向该接口发起查询/写入请求。
@@ -142,7 +125,7 @@ TDengine集群中加入一个新的dnode时，涉及集群相关的一些参数
 - statusInterval: dnode向mnode报告状态时长。单位为秒，默认值：1。
 - maxTablesPerVnode: 每个vnode中能够创建的最大表个数。默认值：1000000。
 - maxVgroupsPerDb: 每个数据库中能够使用的最大vnode个数。
- arbitrator: 系统中裁决器的end point。
+- arbitrator: 系统中裁决器的end point，缺省为空
 - timezone：时区。从系统中动态获取当前的时区设置。
 - locale：系统区位信息及编码格式。系统中动态获取，如果自动获取失败，需要用户在配置文件设置或通过API设置。
 - charset：字符集编码。系统中动态获取，如果自动获取失败，需要用户在配置文件设置或通过API设置。
@@ -153,8 +136,8 @@ TDengine系统的前台交互客户端应用程序为taos，它与taosd共享同
 客户端配置参数列表及解释
- first: taos启动时，主动连接的集群中第一个taosd实例的end point, 缺省值为 localhost:6030。
+- firstEp: taos启动时，主动连接的集群中第一个taosd实例的end point, 缺省值为 localhost:6030。
- second: taos启动时，如果first连接不上，尝试连接集群中第二个taosd实例的end point, 缺省值为空。
+- secondEp: taos启动时，如果first连接不上，尝试连接集群中第二个taosd实例的end point, 缺省值为空。
 - charset：字符集编码。系统中动态获取，如果自动获取失败，需要用户在配置文件设置或通过API设置。
 - locale：系统区位信息及编码格式。系统中动态获取，如果自动获取失败，需要用户在配置文件设置或通过API设置。
@@ -243,9 +226,7 @@ Query OK, 9 row(s) affected (0.004763s)
 **taosdump工具导入**
-TDengine提供了方便的数据库导入导出工具taosdump。用户可以将taosdump从一个系统导出的数据，导入到其他系统中。具体使用方法，请参见博客：
+TDengine提供了方便的数据库导入导出工具taosdump。用户可以将taosdump从一个系统导出的数据，导入到其他系统中。具体使用方法，请参见博客：<a href='https://www.taosdata.com/blog/2020/03/09/1334.html'>TDengine DUMP工具使用指南</a>
-[TDengine DUMP工具使用指南]: https://www.taosdata.com/blog/2020/03/09/1334.html
 ## 数据导出
@@ -263,9 +244,7 @@ select * from <tb_name> >> data.csv
 **用taosdump导出数据**
-TDengine提供了方便的数据库导出工具taosdump。用户可以根据需要选择导出所有数据库、一个数据库或者数据库中的一张表,所有数据或一时间段的数据，甚至仅仅表的定义。具体使用方法，请参见博客：
+TDengine提供了方便的数据库导出工具taosdump。用户可以根据需要选择导出所有数据库、一个数据库或者数据库中的一张表,所有数据或一时间段的数据，甚至仅仅表的定义。具体使用方法，请参见博客：<a href='https://www.taosdata.com/blog/2020/03/09/1334.html'>TDengine DUMP工具使用指南</a>
-[TDengine DUMP工具使用指南]: https://www.taosdata.com/blog/2020/03/09/1334.html
 ## 系统连接、任务查询管理
@@ -313,3 +292,31 @@ TDengine启动后，会自动创建一个监测数据库SYS，并自动将服务
 这些监测信息的采集缺省是打开的，但可以修改配置文件里的选项enableMonitor将其关闭或打开。
+## 文件目录结构
+安装TDengine后，默认会在操作系统中生成下列目录或文件：
+| 目录/文件                 | 说明                                                         |
+| ------------------------- | :----------------------------------------------------------- |
+| /usr/local/taos/bin       | TDengine可执行文件目录。其中的执行文件都会软链接到/usr/bin目录下。 |
+| /usr/local/taos/connector | TDengine各种连接器目录。                                     |
+| /usr/local/taos/driver    | TDengine动态链接库目录。会软链接到/usr/lib目录下。           |
+| /usr/local/taos/examples  | TDengine各种语言应用示例目录。                               |
+| /usr/local/taos/include   | TDengine对外提供的C语言接口的头文件。                        |
+| /etc/taos/taos.cfg        | TDengine默认[配置文件]                                       |
+| /var/lib/taos             | TDengine默认数据文件目录,可通过[配置文件]修改位置.           |
+| /var/log/taos             | TDengine默认日志文件目录,可通过[配置文件]修改位置            |
+**可执行文件**
+TDengine的所有可执行文件默认存放在 _/usr/local/taos/bin_ 目录下。其中包括：
+- _taosd_：TDengine服务端可执行文件
+- _taos_： TDengine Shell可执行文件
+- _taosdump_：数据导入导出工具
+- remove.sh：卸载TDengine的脚本, 请谨慎执行，链接到/usr/bin目录下的rmtaos命令。会删除TDengine的安装目录/usr/local/taos，但会保留/etc/taos、/var/lib/taos、/var/log/taos。
+您可以通过修改系统配置文件taos.cfg来配置不同的数据目录和日志目录。
--- a/documentation20/webdocs/markdowndocs/advanced features-ch.md
+++ b/documentation20/webdocs/markdowndocs/advanced features-ch.md
@@ -119,9 +119,9 @@ taos_consume
 taos_unsubscribe
 ```
-这些API的文档请见 [C/C++ 数据订阅接口](TODO: update link)，
+这些API的文档请见 [C/C++ 数据订阅接口](connector/#C/C++-Connector)，
 下面仍以智能电表场景为例介绍一下它们的具体用法（超级表和子表结构请参考上一节“连续查询”），
-完整的示例代码可以在[这里](TODO: update link)找到。
+完整的示例代码可以在 [这里](https://github.com/taosdata/TDengine/blob/master/tests/examples/c/subscribe.c) 找到。
 如果我们希望当某个电表的电流超过一定限制（比如10A）后能得到通知并进行一些处理， 有两种方法：
 一是分别对每张子表进行查询，每次查询后记录最后一条数据的时间戳，后续只查询这个时间戳之后的数据：

--- a/documentation20/webdocs/markdowndocs/architecture-ch.md
+++ b/documentation20/webdocs/markdowndocs/architecture-ch.md
--- a/documentation20/webdocs/markdowndocs/cluster-ch.md
+++ b/documentation20/webdocs/markdowndocs/cluster-ch.md
+#TDengine 集群安装、管理
+多个taosd的运行实例可以组成一个集群，以保证TDengine的高可靠运行，并提供水平扩展能力。要了解TDengine 2.0的集群管理，需要对集群的基本概念有所了解，请看TDengine 2.0整体架构一章。
+集群的每个节点是由End Point来唯一标识的，End Point是由FQDN(Fully Qualified Domain Name)外加Port组成，比如 h1.taosdata.com:6030。一般FQDN就是服务器的hostname，可通过Linux命令“hostname"获取。端口是这个节点对外服务的端口号，缺省是6030，但可以通过taos.cfg里配置参数serverPort进行修改。
+TDengine的集群管理极其简单，除添加和删除节点需要人工干预之外，其他全部是自动完成，最大程度的降低了运维的工作量。本章对集群管理的操作做详细的描述。
+##安装、创建第一个节点
+集群是由一个一个dnode组成的，是从一个dnode的创建开始的。创建第一个节点很简单，就按照["立即开始“](https://www.taosdata.com/cn/getting-started/)一章的方法进行安装、启动即可。
+启动后，请执行taos, 启动taos shell，从shell里执行命令"show dnodes;"，如下所示：
+   ```
+Welcome to the TDengine shell from Linux, Client Version:2.0.0.0
+Copyright (c) 2017 by TAOS Data, Inc. All rights reserved.
+taos> show dnodes;
+ id |       end_point    | vnodes | cores | status | role |      create_time        |
+=====================================================================================
+  1 |  h1.taos.com:6030  |      0 |     2 |  ready |  any | 2020-07-31 03:49:29.202 |
+Query OK, 1 row(s) in set (0.006385s)
+taos>
+   ```
+上述命令里，可以看到这个刚启动的这个节点的End Point是：h1.taos.com:6030
+## 安装、创建后续节点
+将新的节点添加到现有集群，具体有以下几步：
+1. 按照["立即开始“](https://www.taosdata.com/cn/getting-started/)一章的方法进行安装，**但不要启动taosd**
+2. 如果是使用涛思数据的官方安装包进行安装，在安装结束时，会询问集群的End Port, 输入第一个节点的End Point即可。如果是源码安装，请编辑配置文件taos.cfg(缺省是在/etc/taos/目录)，增加一行：
+    ```
+    firstEp  h1.taos.com:6030
+    ```
+    请注意将示例的“h1.taos.com:6030" 替换为你自己第一个节点的End Point
+3. 按照["立即开始“](https://www.taosdata.com/cn/getting-started/)一章的方法启动taosd
+4. 在Linux shell里执行命令"hostname"找出本机的FQDN, 假设为h2.taos.com。如果无法找到，可以查看taosd日志文件taosdlog.0里前面几行日志(一般在/var/log/taos目录)，fqdn以及port都会打印出来。
+5. 在第一个节点，使用CLI程序taos, 登录进TDengine系统, 使用命令:
+    ```
+    CREATE DNODE "h2.taos.com:6030"； 
+    ```
+    将新节点的End Point添加进集群的EP列表。**"fqdn:port"需要用双引号引起来**，否则出错。请注意将示例的“h2.taos.com:6030" 替换为你自己第一个节点的End Point
+6. 使用命令
+    ```
+    SHOW DNODES；
+    ```
+    查看新节点是否被成功加入。
+按照上述步骤可以源源不断的将新的节点加入到集群。
+**提示：**
+- firstEp, secondEp这两个参数仅仅在该节点第一次加入集群时有作用，加入集群后，该节点会保存最新的mnode的End Point列表，不再依赖这两个参数。
+- 两个没有配置firstEp, secondEp参数的dnode启动后，会独立运行起来。这个时候，无法将其中一个节点加入到另外一个节点，形成集群。**无法将两个独立的集群合并成为新的集群**。
+##节点管理
+###添加节点
+执行CLI程序taos, 使用root账号登录进系统, 执行:
+```
+CREATE DNODE "fqdn:port"； 
+```
+将新节点的End Point添加进集群的EP列表。**"fqdn:port"需要用双引号引起来**，否则出错。一个节点对外服务的fqdn和port可以通过配置文件taos.cfg进行配置，缺省是自动获取。
+###删除节点
+执行CLI程序taos, 使用root账号登录进TDengine系统，执行：
+```
+DROP DNODE "fqdn:port";
+```
+其中fqdn是被删除的节点的FQDN，port是其对外服务器的端口号
+###查看节点
+执行CLI程序taos,使用root账号登录进TDengine系统，执行：
+```
+SHOW DNODES;
+```
+它将列出集群中所有的dnode,每个dnode的fqdn:port, 状态(ready, offline等），vnode数目，还未使用的vnode数目等信息。在添加或删除一个节点后，可以使用该命令查看。
+###查看虚拟节点组
+为充分利用多核技术，并提供scalability，数据需要分片处理。因此TDengine会将一个DB的数据切分成多份，存放在多个vnode里。这些vnode可能分布在多个dnode里，这样就实现了水平扩展。一个vnode仅仅属于一个DB，但一个DB可以有多个vnode。vnode的是mnode根据当前系统资源的情况，自动进行分配的，无需任何人工干预。
+执行CLI程序taos,使用root账号登录进TDengine系统，执行：
+```
+SHOW VGROUPS;
+```
+##高可用性
+TDengine通过多副本的机制来提供系统的高可用性。副本数是与DB关联的，一个集群里可以有多个DB，根据运营的需求，每个DB可以配置不同的副本数。创建数据库时，通过参数replica 指定副本数（缺省为1）。如果副本数为1，系统的可靠性无法保证，只要数据所在的节点宕机，就将无法提供服务。集群的节点数必须大于等于副本数，否则创建表时将返回错误“more dnodes are needed"。比如下面的命令将创建副本数为3的数据库demo：
+```
+CREATE DATABASE demo replica 3;
+```
+一个DB里的数据会被切片分到多个vnode group，vnode group里的vnode数目就是DB的副本数，同一个vnode group里各vnode的数据是完全一致的。为保证高可用性，vnode group里的vnode一定要分布在不同的dnode里（实际部署时，需要在不同的物理机上），只要一个vgroup里超过半数的vnode处于工作状态，这个vgroup就能正常的对外服务。
+一个dnode里可能有多个DB的数据，因此一个dnode离线时，可能会影响到多个DB。如果一个vnode group里的一半或一半以上的vnode不工作，那么该vnode group就无法对外服务，无法插入或读取数据，这样会影响到它所属的DB的一部分表的d读写操作。
+因为vnode的引入，无法简单的给出结论：“集群中过半dnode工作，集群就应该工作”。但是对于简单的情形，很好下结论。比如副本数为3，只有三个dnode，那如果仅有一个节点不工作，整个集群还是可以正常工作的，但如果有两个节点不工作，那整个集群就无法正常工作了。
+##Mnode的高可用
+TDengine集群是由mnode (taosd的一个模块，逻辑节点) 负责管理的，为保证mnode的高可用，可以配置多个mnode副本，副本数由系统配置参数numOfMnodes决定，有效范围为1-3。为保证元数据的强一致性，mnode副本之间是通过同步的方式进行数据复制的。
+一个集群有多个dnode, 但一个dnode至多运行一个mnode实例。多个dnode情况下，哪个dnode可以作为mnode呢？这是完全由系统根据整个系统资源情况，自动指定的。用户可通过CLI程序taos，在TDengine的console里，执行如下命令：
+```
+SHOW MNODES;
+```
+来查看mnode列表，该列表将列出mnode所处的dnode的End Point和角色(master, slave, unsynced 或offline)。
+当集群中第一个节点启动时，该节点一定会运行一个mnode实例，否则该dnode无法正常工作，因为一个系统是必须有至少一个mnode的。如果numOfMnodes配置为2，启动第二个dnode时，该dnode也将运行一个mnode实例。
+为保证mnode服务的高可用性，numOfMnodes必须设置为2或更大。因为mnode保存的元数据必须是强一致的，如果numOfMnodes大于2，复制参数quorum自动设为2，也就是说，至少要保证有两个副本写入数据成功，才通知客户端应用写入成功。
+##负载均衡
+有三种情况，将触发负载均衡，而且都无需人工干预。
+- 当一个新节点添加进集群时，系统将自动触发负载均衡，一些节点上的数据将被自动转移到新节点上，无需任何人工干预。
+- 当一个节点从集群中移除时，系统将自动把该节点上的数据转移到其他节点，无需任何人工干预。
+- 如果一个节点过热（数据量过大），系统将自动进行负载均衡，将该节点的一些vnode自动挪到其他节点。
+当上述三种情况发生时，系统将启动一各个节点的负载计算，从而决定如何挪动。
+##节点离线处理
+如果一个节点离线，TDengine集群将自动检测到。有如下两种情况：
+- 改节点离线超过一定时间（taos.cfg里配置参数offlineThreshold控制时长)，系统将自动把该节点删除，产生系统报警信息，触发负载均衡流程。如果该被删除的节点重现上线时，它将无法加入集群，需要系统管理员重新将其添加进集群才会开始工作。
+- 离线后，在offlineThreshold的时长内重新上线，系统将自动启动数据恢复流程，等数据完全恢复后，该节点将开始正常工作。
+**注意：**如果一个虚拟节点组（包括mnode组）里每个节点都处于离线或unsynced状态，必须等该虚拟节点组里的所有节点都上线、都能交换状态信息后，才能选出Master，该虚拟节点组才能对外提供服务。比如整个集群有3个节点，副本数为3，如果3个节点都宕机，然后2个节点重启，是无法工作的，只有等3个节点都重启成功，才能对外服务。
+##Arbitrator的使用
+如果副本数为偶数，当一个vnode group里一半或超过一半的vnode不工作时，是无法从中选出master的。同理，一半或超过一半的mnode不工作时，是无法选出mnode的master的，因为存在“split brain”问题。为解决这个问题，TDengine引入了arbitrator的概念。Arbitrator模拟一个vnode或mnode在工作，但只简单的负责网络连接，不处理任何数据插入或访问。只要包含arbitrator在内，超过半数的vnode或mnode工作，那么该vnode group或mnode组就可以正常的提供数据插入或查询服务。比如对于副本数为2的情形，如果一个节点A离线，但另外一个节点B正常，而且能连接到arbitrator, 那么节点B就能正常工作。
+TDengine安装包里带有一个执行程序tarbitrator, 找任何一台Linux服务器运行它即可。该程序对系统资源几乎没有要求，只需要保证有网络连接即可。该应用的命令行参数`-p`可以指定其对外服务的端口号，缺省是6030。配置每个taosd实例时，可以在配置文件taos.cfg里将参数arbitrator设置为arbitrator的End Point。如果该参数配置了，当副本数为偶数数，系统将自动连接配置的arbitrator。
--- a/documentation20/webdocs/markdowndocs/connector-ch.md
+++ b/documentation20/webdocs/markdowndocs/connector-ch.md
@@ -45,11 +45,11 @@ C/C++的API类似于MySQL的C API。应用程序使用时，需要包含TDengine
  创建数据库连接，初始化连接上下文。其中需要用户提供的参数包含：
-  * ip：TDengine管理主节点的IP地址
+  - ip：TDengine管理主节点的IP地址
-  * user：用户名
+  - user：用户名
-  * pass：密码
+  - pass：密码
-  * db：数据库名字，如果用户没有提供，也可以正常连接，用户可以通过该连接创建新的数据库，如果用户提供了数据库名字，则说明该数据库用户已经创建好，缺省使用该数据库
+  - db：数据库名字，如果用户没有提供，也可以正常连接，用户可以通过该连接创建新的数据库，如果用户提供了数据库名字，则说明该数据库用户已经创建好，缺省使用该数据库
-  * port：端口号
+  - port：端口号
  返回值为空表示失败。应用程序需要保存返回的参数，以便后续API调用。

--- a/documentation20/webdocs/markdowndocs/faq-ch.md
+++ b/documentation20/webdocs/markdowndocs/faq-ch.md
@@ -5,19 +5,19 @@
 2.0版本在之前版本的基础上，进行了完全的重构，配置文件和数据文件是不兼容的。在升级之前务必进行如下操作：
 1. 删除配置文件，执行 <code> sudo rm -rf /etc/taos/taos.cfg </code>
 2. 删除日志文件，执行 <code> sudo rm -rf /var/log/taos/ </code>
 3. 确保数据已经不再需要的前提下，删除数据文件，执行 <code> sudo rm -rf /var/lib/taos/ </code>
 4. 安装最新稳定版本的TDengine
-5.  如果数据需要迁移数据或者数据文件损坏，请联系涛思数据官方技术支持团队，进行协助解决
+5. 如果数据需要迁移数据或者数据文件损坏，请联系涛思数据官方技术支持团队，进行协助解决
-#### 2. <a href='blog/2019/12/03/jdbcdriver找不到动态链接库/'>Windows平台下JDBCDriver找不到动态链接库</a>
+#### 2. Windows平台下JDBCDriver找不到动态链接库，怎么办？
+请看为此问题撰写的<a href='blog/2019/12/03/jdbcdriver找不到动态链接库/'>技术博客 </a>
-#### 3. <a href='blog/2019/12/03/创建数据表时提示more-dnodes-are-needed/'>创建数据表时提示more dnodes are needed</a>
+#### 3. 创建数据表时提示more dnodes are needed
+请看为此问题撰写的<a href='blog/2019/12/03/创建数据表时提示more-dnodes-are-needed/'>技术博客</a>
-#### 4. <a href='blog/2019/12/06/tdengine-crash时生成core文件的方法/'>TDengine crash时生成core文件的方法</a>
+#### 4. 如何让TDengine crash时生成core文件？
+请看为此问题撰写的<a href='blog/2019/12/06/tdengine-crash时生成core文件的方法/'>技术博客</a>
 #### 5. 遇到错误"failed to connect to server", 我怎么办？
@@ -68,7 +68,8 @@ windows下插入nchar类的数据中如果有中文，请先确认系统的地
      Connection = DriverManager.getConnection(url, properties);
-#### 12. <a href='blog/2020/01/06/tdengine-go-windows驱动的编译/'>TDengine GO windows驱动的编译</a>
+#### 12.TDengine GO windows驱动的如何编译？
+请看为此问题撰写的<a href='blog/2020/01/06/tdengine-go-windows驱动的编译/'>技术博客 
--- a/documentation20/webdocs/markdowndocs/insert-ch.md
+++ b/documentation20/webdocs/markdowndocs/insert-ch.md
@@ -18,9 +18,12 @@ TDengine也支持一次向多个表写入数据，比如下面这条命令就向
 INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6, 218, 0.33) d1002 VALUES (1538548696800, 12.3, 221, 0.31);
 ```
-**Tips:** 要提高写入效率，需要批量写入。一批写入的记录条数越多，插入效率就越高。但一条记录不能超过16K，一条SQL语句总长度不能超过64K（可通过参数maxSQLLength配置）。
+详细的SQL INSERT语法规则请见<a href="https://www.taosdata.com/cn/documentation20/taos-sql/">TAOS SQL </a>
-详细的SQL INSERT语法规则请见TAOS SQL
+**Tips:** 
+- 要提高写入效率，需要批量写入。一批写入的记录条数越多，插入效率就越高。但一条记录不能超过16K，一条SQL语句总长度不能超过64K（可通过参数maxSQLLength配置）。
+- TDengine支持多线程同时写入，要进一步提高写入速度，一个客户端需要打开20个以上的线程同时写。但线程数达到一定数量后，无法再提高，甚至还会下降，因为线程切频繁切换，带来额外开销。
 ## Prometheus直接写入
 [Prometheus](https://www.prometheus.io/)作为Cloud Native Computing Fundation毕业的项目，在性能监控以及K8S性能监控领域有着非常广泛的应用。TDengine提供一个小工具[Bailongma](https://github.com/taosdata/Bailongma)，只需在Prometheus做简单配置，无需任何代码，就可将Prometheus采集的数据直接写入TDengine，并按规则在TDengine自动创建库和相关表项。博文[用Docker容器快速搭建一个Devops监控Demo](https://www.taosdata.com/blog/2020/02/03/1189.html)即是采用bailongma将Prometheus和Telegraf的数据写入TDengine中的示例，可以参考。

--- a/documentation20/webdocs/markdowndocs/replica-ch.md
+++ b/documentation20/webdocs/markdowndocs/replica-ch.md
--- a/documentation20/webdocs/markdowndocs/taosd-ch.md
+++ b/documentation20/webdocs/markdowndocs/taosd-ch.md
+#  TDengine 2.0 执行代码taosd的设计
+逻辑上，TDengine系统包含dnode, taosc和App，dnode是服务器侧执行代码taosd的一个运行实例，因此taosd是TDengine的核心，本文对taosd的设计做一简单的介绍，模块内的实现细节请见其他文档。
+## 系统模块图
+taosd包含rpc, dnode, vnode, tsdb, query, cq, sync, wal, mnode, http, monitor等模块，具体如下图：
+<center> <img src="../assets/modules.png"> </center>
+taosd的启动入口是dnode模块，dnode然后启动其他模块，包括可选配置的http, monitor模块。taosc或dnode之间交互的消息都是通过rpc模块进行，dnode模块根据接收到的消息类型，将消息分发到vnode或mnode的消息队列，或由dnode模块自己消费。dnode的工作线程(worker)消费消息队列里的消息，交给mnode或vnode进行处理。下面对各个模块做简要说明。
+## RPC模块
+该模块负责taosd与taosc, 以及其他数据节点之间的通讯。TDengine没有采取标准的HTTP或gRPC等第三方工具，而是实现了自己的通讯模块RPC。
+考虑到物联网场景下，数据写入的包一般不大，因此除支持TCP链接之外，RPC还支持UDP链接。当数据包小于15K时，RPC将采用UDP方式进行链接，否则将采用TCP链接。对于查询类的消息，RPC不管包的大小，总是采取TCP链接。对于UDP链接，RPC实现了自己的超时、重传、顺序检查等机制，以保证数据可靠传输。
+RPC模块还提供数据压缩功能，如果数据包的字节数超过系统配置参数compressMsgSize, RPC在传输中将自动压缩数据，以节省带宽。
+为保证数据的安全和数据的integrity, RPC模块采用MD5做数字签名，对数据的真实性和完整性进行认证。
+## DNODE模块
+该模块是整个taosd的入口，它具体负责如下任务：
+- 系统的初始化，包括
+  - 从文件taos.cfg读取系统配置参数，从文件dnodeCfg.json读取数据节点的配置参数；
+  - 启动RPC模块，并建立起与taosc通讯的server链接，与其他数据节点通讯的server链接；
+  - 启动并初始化dnode的内部管理, 该模块将扫描该数据节点已有的vnode，并打开它们；
+  - 初始化可配置的模块，如mnode, http, monitor等。
+- 数据节点的管理，包括
+  - 定时的向mnode发送status消息，报告自己的状态；
+  - 根据mnode的指示，创建、改变、删除vnode；
+  - 根据mnode的指示，修改自己的配置参数；
+- 消息的分发、消费，包括
+  - 为每一个vnode和mnode的创建并维护一个读队列、一个写队列；
+  - 将从taosc或其他数据节点来的消息，根据消息类型，将其直接分发到不同的消息队列，或由自己的管理模块直接消费；
+  - 维护一个读的线程池，消费读队列的消息，交给vnode或mnode处理。为支持高并发，一个读线程(Worker)可以消费多个队列的消息，一个读队列可以由多个worker消费；
+  - 维护一个写的线程池，消费写队列的消息，交给vnode或mnode处理。为保证写操作的序列化，一个写队列只能由一个写线程负责，但一个写线程可以负责多个写队列。
+taosd的消息消费由dnode通过读写线程池进行控制，是系统的中枢。该模块内的结构体图如下：
+<center> <img src="../assets/dnode.png"> </center>
+## VNODE模块
+vnode是一独立的数据存储查询逻辑单元，但因为一个vnode只能容许一个DB，因此vnode内部没有account, DB, user等概念。为实现更好的模块化、封装以及未来的扩展，它有很多子模块，包括负责存储的TSDB，负责查询的Query, 负责数据复制的sync，负责数据库日志的的wal, 负责连续查询的cq(continuous query), 负责事件触发的流计算的event等模块，这些子模块只与vnode模块发生关系，与其他模块没有任何调用关系。模块图如下：
+<center> <img src="../assets/vnode.png"> </center>
+vnode模块向下，与dnodeVRead，dnodeVWrite发生互动，向上，与子模块发生互动。它主要的功能有：
+- 协调各个子模块的互动。各个子模块之间都不直接调用，都需要通过vnode模块进行；
+- 对于来自taosc或mnode的写操作，vnode模块将其分解为写日志(wal), 转发(sync), 本地存储(tsdb)子模块的操作；
+- 对于查询操作，分发到query模块进行。
+一个数据节点里有多个vnode, 因此vnode模块是有多个运行实例的。每个运行实例是完全独立的。
+vnode与其子模块是通过API直接调用，而不是通过消息队列传递。而且各个子模块只与vnode模块有交互，不与dnode, rpc等模块发生任何直接关联。
+## MNODE模块
+mnode是整个系统的大脑，负责整个系统的资源调度，负责meta data的管理与存储。
+一个运行的系统里，只有一个mnode，但它有多个副本（由系统配置参数numOfMpeers控制）。这些副本分布在不同的dnode里，目的是保证系统的高可靠运行。副本之间的数据复制是采用同步而非异步的方式，以确保数据的一致性，确保数据不会丢失。这些副本会自动选举一个Master，其他副本是slave。所有数据更新类的操作，都只能在master上进行，而查询类的可以在slave节点上进行。代码实现上，同步模块与vnode共享，但mnode被分配一个特殊的vgroup ID: 1，而且quorum大于1。整个集群系统是由多个dnode组成的，运行的mnode的副本数不可能超过dnode的个数，但不会超过配置的副本数。如果某个mnode副本宕机一段时间，只要超过半数的mnode副本仍在运行，运行的mnode会自动根据整个系统的资源情况，在其他dnode里再启动一个mnode, 以保证运行的副本数。
+各个dnode通过信息交换，保存有mnode各个副本的End Point列表，并向其中的master节点定时（间隔由系统配置参数statusInterval控制）发送status消息，消息体里包含该dnode的CPU、内存、剩余存储空间、vnode个数，以及各个vnode的状态(存储空间、原始数据大小、记录条数、角色等）。这样mnode就了解整个系统的资源情况，如果用户创建新的表，就可以决定需要在哪个dnode创建；如果增加或删除dnode, 或者监测到某dnode数据过热、或离线太长，就可以决定需要挪动那些vnode，以实现负载均衡。
+mnode里还负责account, user, DB, stable, table, vgroup, dnode的创建、删除与更新。mnode不仅把这些entity的meta data保存在内存，还做持久化存储。但为节省内存，各个表的标签值不保存在mnode（保存在vnode)，而且子表不维护自己的schema, 而是与stable共享。为减小mnode的查询压力，taosc会缓存table、stable的schema。对于查询类的操作，各个slave mnode也可以提供，以减轻master压力。
+## TSDB模块
+TSDB模块是VNODE中的负责快速高并发地存储和读取属于该VNODE的表的元数据及采集的时序数据的引擎。除此之外，TSDB还提供了表结构的修改、表标签值的修改等功能。TSDB提供API供VNODE和Query等模块调用。TSDB中存储了两类数据，1：元数据信息；2：时序数据
+### 元数据信息
+TSDB中存储的元数据包含属于其所在的VNODE中表的类型，schema的定义等。对于超级表和超级表下的子表而言，又包含了tag的schema定义以及子表的tag值等。对于元数据信息而言，TSDB就相当于一个全内存的KV型数据库，属于该VNODE的表对象全部在内存中，方便快速查询表的信息。除此之外，TSDB还对其中的子表，按照tag的第一列取值做了全内存的索引，大大加快了对于标签的过滤查询。TSDB中的元数据的最新状态在落盘时，会以追加（append-only）的形式，写入到meta文件中。meta文件只进行追加操作，即便是元数据的删除，也会以一条记录的形式写入到文件末尾。TSDB也提供了对于元数据的修改操作，如表schema的修改，tag schema的修改以及tag值的修改等。
+### 时序数据
+每个TSDB在创建时，都会事先分配一定量的内存缓冲区，且内存缓冲区的大小可配可修改。表采集的时序数据，在写入TSDB时，首先以追加的方式写入到分配的内存缓冲区中，同时建立基于时间戳的内存索引，方便快速查询。当内存缓冲区的数据积累到一定的程度时（达到内存缓冲区总大小的1/3），则会触发落盘操作，将缓冲区中的数据持久化到硬盘文件上。时序数据在内存缓冲区中是以行（row）的形式存储的。
+而时序数据在写入到TSDB的数据文件时，是以列（column）的形式存储的。TSDB中的数据文件包含多个数据文件组，每个数据文件组中又包含.head、.data和.last三个文件，如（v2f1801.head、v2f1801.data、v2f1801.last）数据文件组。TSDB中的数据文件组是按照时间跨度进行分片的，默认是10天一个文件组，且可通过配置文件及建库选项进行配置。分片的数据文件组又按照编号递增排列，方便快速定位某一时间段的时序数据，高效定位数据文件组。时序数据在TSDB的数据文件中是以块的形式进行列式存储的，每个块中只包含一张表的数据，且数据在一个块中是按照时间顺序递增排列的。在一个数据文件组中，.head文件负责存储数据块的索引及统计信息，如每个块的位置，压缩算法，时间戳范围等。存储在.head文件中一张表的索引信息是按照数据块中存储的数据的时间递增排列的，方便进行折半查找等工作。.head和.last文件是存储真实数据块的文件，若数据块中的数据累计到一定程度，则会写入.data文件中，否则，会写入.last文件中，等待下次落盘时合并数据写入.data文件中，从而大大减少文件中块的个数，避免数据的过度碎片化。
+## Query模块
+该模块负责整体系统的查询处理。客户端调用该该模块进行SQL语法解析，并将查询或写入请求发送到vnode，同时负责针对超级表的查询进行二阶段的聚合操作。在Vnode端，该模块调用TSDB模块读取系统中存储的数据进行查询处理。Query模块还定义了系统能够支持的全部查询函数，查询函数的实现机制与查询框架无耦合，可以在不修改查询流程的情况下动态增加查询函数。详细的设计请参见《TDengine 2.0查询模块设计》。
+## SYNC模块
+该模块实现数据的多副本复制，包括vnode与mnode的数据复制，支持异步和同步两种复制方式，以满足meta data与时序数据不同复制的需求。因为它为mnode与vnode共享，系统为mnode副本预留了一个特殊的vgroup ID:1。因此vnode group的ID是从2开始的。
+每个vnode/mnode模块实例会有一对应的sync模块实例，他们是一一对应的。详细设计请见<a href="https://www.taosdata.com/cn/documentation20/replica/">TDengine 2.0 数据复制模块设计</a>
+## WAL模块
+该模块负责将新插入的数据写入write ahead log(WAL), 为vnode, mnode共享。以保证服务器crash或其他故障，能从WAL中恢复数据。
+每个vnode/mnode模块实例会有一对应的wal模块实例，是完全一一对应的。WAL的落盘操作由两个参数walLevel, fsync控制。看具体场景，如果要100%保证数据不会丢失，需要将walLevel配置为2，fsync设置为0，每条数据插入请求，都会实时落盘后，才会给应用确认
+## HTTP模块
+该模块负责处理系统对外的RESTful接口，可以通过配置，由dnode启动或停止。
+该模块将接收到的RESTful请求，做了各种合法性检查后，将其变成标准的SQL语句，通过taosc的异步接口，将请求发往整个系统中的任一dnode。收到处理后的结果后，再翻译成HTTP协议，返回给应用。
+如果HTTP模块启动，就意味着启动了一个taosc的实例。任一一个dnode都可以启动该模块，以实现对RESTful请求的分布式处理。
+## Monitor模块
+该模块负责检测一个dnode的运行状态，可以通过配置，由dnode启动或停止。原则上，每个dnode都应该启动一个monitor实例。
+Monitor采集TDengine里的关键操作，比如创建、删除、更新账号、表、库等，而且周期性的收集CPU、内存、网络等资源的使用情况（采集周期由系统配置参数monitorInterval控制）。获得这些数据后，monitor模块将采集的数据写入系统的日志库(DB名字由系统配置参数monitorDbName控制）。
+Monitor模块使用taosc来将采集的数据写入系统，因此每个monitor实例，都有一个taosc运行实例。
--- a/packaging/tools/install.sh
+++ b/packaging/tools/install.sh
@@ -79,19 +79,19 @@ osinfo=$(cat /etc/os-release | grep "NAME" | cut -d '"' -f2)
 #echo "osinfo: ${osinfo}"
 os_type=0
 if echo $osinfo | grep -qwi "ubuntu" ; then
-  echo "This is ubuntu system"
+#  echo "This is ubuntu system"
  os_type=1
 elif echo $osinfo | grep -qwi "debian" ; then
-  echo "This is debian system"
+#  echo "This is debian system"
  os_type=1
 elif echo $osinfo | grep -qwi "Kylin" ; then
-  echo "This is Kylin system"
+#  echo "This is Kylin system"
  os_type=1
 elif  echo $osinfo | grep -qwi "centos" ; then
-  echo "This is centos system"
+#  echo "This is centos system"
  os_type=2
 elif echo $osinfo | grep -qwi "fedora" ; then
-  echo "This is fedora system"
+#  echo "This is fedora system"
  os_type=2
 else
  echo "${osinfo}: This is an officially unverified linux system, If there are any problems with the installation and operation, "
@@ -135,7 +135,7 @@ do
  esac
 done
-echo "verType=${verType} interactiveFqdn=${interactiveFqdn}"
+#echo "verType=${verType} interactiveFqdn=${interactiveFqdn}"
 function kill_taosd() {
  pid=$(ps -ef | grep "taosd" | grep -v "grep" | awk '{print $2}')
@@ -240,7 +240,9 @@ function install_config() {
    # first full-qualified domain name (FQDN) for TDengine cluster system
    echo
-    echo -e -n "${GREEN}Enter FQDN:port (like h1.taosdata.com:6030) of an existing TDengine cluster node to join OR leave it blank to build one${NC} :"
+    echo -e -n "${GREEN}Enter FQDN:port (like h1.taosdata.com:6030) of an existing TDengine cluster node to join${NC}"
+    echo
+    echo -e -n "${GREEN}OR leave it blank to build one${NC}:"
    read firstEp
    while true; do
        if [ ! -z "$firstEp" ]; then
@@ -670,10 +672,11 @@ function install_TDengine() {
             echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell${NC}"
        fi
-		    if [ ! -z "$firstEp" ]; then
+        if [ ! -z "$firstEp" ]; then
-		      echo		    
+	    echo		    
-		      echo -e "${GREEN_DARK}Please run${NC}: taos -h $firstEp ${GREEN_DARK} to login into cluster, then execute ${NC}: create dnode 'newDnodeFQDN:port'; ${GREEN_DARK}in TAOS shell to add this new node into the clsuter${NC}"
+	    echo -e "${GREEN_DARK}Please run${NC}: taos -h $firstEp${GREEN_DARK} to login into cluster, then${NC}"
-          echo
+	    echo -e "${GREEN_DARK}execute ${NC}: create dnode 'newDnodeFQDN:port'; ${GREEN_DARK}to add this new node${NC}"
+            echo
        fi
        echo -e "\033[44;32;1mTDengine is installed successfully!${NC}"
        echo       

--- a/packaging/tools/post.sh
+++ b/packaging/tools/post.sh
@@ -113,7 +113,9 @@ function install_config() {
    # first full-qualified domain name (FQDN) for TDengine cluster system
    echo
-    echo -e -n "${GREEN}Enter FQDN:port (like h1.taosdata.com:6030) of an existing TDengine cluster node to join OR leave it blank to build one${NC} :"
+    echo -e -n "${GREEN}Enter FQDN:port (like h1.taosdata.com:6030) of an existing TDengine cluster node to join${NC}"
+    echo
+    echo -e -n "${GREEN}OR leave it blank to build one${NC}:"
    read firstEp
    while true; do
        if [ ! -z "$firstEp" ]; then
@@ -265,10 +267,11 @@ function install_TDengine() {
    echo -e "${GREEN_DARK}To access TDengine    ${NC}: use ${GREEN_UNDERLINE}taos${NC} in shell${NC}"
-		if [ ! -z "$firstEp" ]; then
+    if [ ! -z "$firstEp" ]; then
-		  echo		    
+        echo		    
-		  echo -e "${GREEN_DARK}Please run${NC}: taos -h $firstEp ${GREEN_DARK} to login into cluster, then execute ${NC}: create dnode 'newDnodeFQDN:port'; ${GREEN_DARK}in TAOS shell to add this new node into the clsuter${NC}"
+	echo -e "${GREEN_DARK}Please run${NC}: taos -h $firstEp${GREEN_DARK} to login into cluster, then${NC}"
-      echo
+	echo -e "${GREEN_DARK}execute ${NC}: create dnode 'newDnodeFQDN:port'; ${GREEN_DARK}to add this new node${NC}"
+        echo
    fi
    echo
    echo -e "\033[44;32;1mTDengine is installed successfully!${NC}"

--- a/src/balance/src/balance.c
+++ b/src/balance/src/balance.c
@@ -14,10 +14,10 @@
 */
 #define _DEFAULT_SOURCE
+#include "os.h"
 #include "tutil.h"
 #include "tbalance.h"
 #include "tsync.h"
-#include "ttime.h"
 #include "ttimer.h"
 #include "tglobal.h"
 #include "tdataformat.h"

--- a/src/client/src/TSDBJNIConnector.c
+++ b/src/client/src/TSDBJNIConnector.c
@@ -18,7 +18,6 @@
 #include "tlog.h"
 #include "tscUtil.h"
 #include "tsclient.h"
-#include "ttime.h"
 #include "com_taosdata_jdbc_TSDBJNIConnector.h"

--- a/src/client/src/tscFunctionImpl.c
+++ b/src/client/src/tscFunctionImpl.c
@@ -27,7 +27,6 @@
 #include "tscSubquery.h"
 #include "tscompression.h"
 #include "tsqlfunction.h"
-#include "ttime.h"
 #include "tutil.h"
 #define GET_INPUT_CHAR(x) (((char *)((x)->aInputElemBuf)) + ((x)->startOffset) * ((x)->inputBytes))
@@ -2108,7 +2107,7 @@ static void copyTopBotRes(SQLFunctionCtx *pCtx, int32_t type) {
    }
  }
-  tfree(pData);
+  taosTFree(pData);
 }
 /*

--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -326,7 +326,7 @@ static void tscProcessServerVer(SSqlObj *pSql) {
  STR_WITH_SIZE_TO_VARSTR(vx, v, t);
  tscSetLocalQueryResult(pSql, vx, pExpr->aliasName, pExpr->resType, pExpr->resBytes);
-  tfree(vx);
+  taosTFree(vx);
 }
 static void tscProcessClientVer(SSqlObj *pSql) {
@@ -342,7 +342,7 @@ static void tscProcessClientVer(SSqlObj *pSql) {
  STR_WITH_SIZE_TO_VARSTR(v, version, t);
  tscSetLocalQueryResult(pSql, v, pExpr->aliasName, pExpr->resType, pExpr->resBytes);
-  tfree(v);
+  taosTFree(v);
 }
 static void tscProcessServStatus(SSqlObj *pSql) {

--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -230,7 +230,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
      if (ds == NULL) {
        tscError("%p failed to create merge structure", pSql);
        pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-        tfree(pReducer);
+        taosTFree(pReducer);
        return;
      }
@@ -257,7 +257,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
      if (ds->filePage.num == 0) {  // no data in this flush, the index does not increase
        tscDebug("%p flush data is empty, ignore %d flush record", pSql, idx);
-        tfree(ds);
+        taosTFree(ds);
        continue;
      }
@@ -267,7 +267,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
  // no data actually, no need to merge result.
  if (idx == 0) {
-    tfree(pReducer);
+    taosTFree(pReducer);
    return;
  }
@@ -275,7 +275,7 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
  SCompareParam *param = malloc(sizeof(SCompareParam));
  if (param == NULL) {
-    tfree(pReducer);
+    taosTFree(pReducer);
    return;
  }
  param->pLocalData = pReducer->pLocalDataSrc;
@@ -288,8 +288,8 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
  pRes->code = tLoserTreeCreate(&pReducer->pLoserTree, pReducer->numOfBuffer, param, treeComparator);
  if (pReducer->pLoserTree == NULL || pRes->code != 0) {
-    tfree(param);
+    taosTFree(param);
-    tfree(pReducer);
+    taosTFree(pReducer);
    return;
  }
@@ -332,14 +332,14 @@ void tscCreateLocalReducer(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrd
  if (pReducer->pTempBuffer == NULL || pReducer->discardData == NULL || pReducer->pResultBuf == NULL ||
      /*pReducer->pBufForInterpo == NULL || */pReducer->pFinalRes == NULL || pReducer->prevRowOfInput == NULL) {
-    tfree(pReducer->pTempBuffer);
+    taosTFree(pReducer->pTempBuffer);
-    tfree(pReducer->discardData);
+    taosTFree(pReducer->discardData);
-    tfree(pReducer->pResultBuf);
+    taosTFree(pReducer->pResultBuf);
-    tfree(pReducer->pFinalRes);
+    taosTFree(pReducer->pFinalRes);
-    tfree(pReducer->prevRowOfInput);
+    taosTFree(pReducer->prevRowOfInput);
-    tfree(pReducer->pLoserTree);
+    taosTFree(pReducer->pLoserTree);
-    tfree(param);
+    taosTFree(param);
-    tfree(pReducer);
+    taosTFree(pReducer);
    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
    return;
  }
@@ -516,38 +516,38 @@ void tscDestroyLocalReducer(SSqlObj *pSql) {
        tVariantDestroy(&pCtx->tag);
        if (pCtx->tagInfo.pTagCtxList != NULL) {
-          tfree(pCtx->tagInfo.pTagCtxList);
+          taosTFree(pCtx->tagInfo.pTagCtxList);
        }
      }
-      tfree(pLocalReducer->pCtx);
+      taosTFree(pLocalReducer->pCtx);
    }
-    tfree(pLocalReducer->prevRowOfInput);
+    taosTFree(pLocalReducer->prevRowOfInput);
-    tfree(pLocalReducer->pTempBuffer);
+    taosTFree(pLocalReducer->pTempBuffer);
-    tfree(pLocalReducer->pResultBuf);
+    taosTFree(pLocalReducer->pResultBuf);
    if (pLocalReducer->pResInfo != NULL) {
      for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
-        tfree(pLocalReducer->pResInfo[i].interResultBuf);
+        taosTFree(pLocalReducer->pResInfo[i].interResultBuf);
      }
-      tfree(pLocalReducer->pResInfo);
+      taosTFree(pLocalReducer->pResInfo);
    }
    if (pLocalReducer->pLoserTree) {
-      tfree(pLocalReducer->pLoserTree->param);
+      taosTFree(pLocalReducer->pLoserTree->param);
-      tfree(pLocalReducer->pLoserTree);
+      taosTFree(pLocalReducer->pLoserTree);
    }
-    tfree(pLocalReducer->pFinalRes);
+    taosTFree(pLocalReducer->pFinalRes);
-    tfree(pLocalReducer->discardData);
+    taosTFree(pLocalReducer->discardData);
    tscLocalReducerEnvDestroy(pLocalReducer->pExtMemBuffer, pLocalReducer->pDesc, pLocalReducer->resColModel,
                              pLocalReducer->numOfVnode);
    for (int32_t i = 0; i < pLocalReducer->numOfBuffer; ++i) {
-      tfree(pLocalReducer->pLocalDataSrc[i]);
+      taosTFree(pLocalReducer->pLocalDataSrc[i]);
    }
    pLocalReducer->numOfBuffer = 0;
@@ -593,7 +593,7 @@ static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SSqlCmd *pCm
  }
  *pOrderDesc = tOrderDesCreate(orderIdx, numOfGroupByCols, pModel, pQueryInfo->order.order);
-  tfree(orderIdx);
+  taosTFree(orderIdx);
  if (*pOrderDesc == NULL) {
    return TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -705,7 +705,7 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
  if (createOrderDescriptor(pOrderDesc, pCmd, pModel) != TSDB_CODE_SUCCESS) {
    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-    tfree(pSchema);
+    taosTFree(pSchema);
    return pRes->code;
  }
@@ -746,7 +746,7 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
  }
  *pFinalModel = createColumnModel(pSchema, size, capacity);
-  tfree(pSchema);
+  taosTFree(pSchema);
  return TSDB_CODE_SUCCESS;
 }
@@ -765,7 +765,7 @@ void tscLocalReducerEnvDestroy(tExtMemBuffer **pMemBuffer, tOrderDescriptor *pDe
    pMemBuffer[i] = destoryExtMemBuffer(pMemBuffer[i]);
  }
-  tfree(pMemBuffer);
+  taosTFree(pMemBuffer);
 }
 /**
@@ -1036,10 +1036,10 @@ static void doFillResult(SSqlObj *pSql, SLocalReducer *pLocalReducer, bool doneO
  pFinalDataPage->num = 0;
  for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
-    tfree(pResPages[i]);
+    taosTFree(pResPages[i]);
  }
-  tfree(pResPages);
+  taosTFree(pResPages);
 }
 static void savePreviousRow(SLocalReducer *pLocalReducer, tFilePage *tmpBuffer) {

--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -30,7 +30,6 @@
 #include "tscLog.h"
 #include "tscSubquery.h"
 #include "tstoken.h"
-#include "ttime.h"
 #include "tdataformat.h"
@@ -1388,7 +1387,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int code) {
    assert(taos_errno(pSql) == code);
    taos_free_result(pSql);
-    tfree(pSupporter);
+    taosTFree(pSupporter);
    fclose(fp);
    pParentSql->res.code = code;
@@ -1453,7 +1452,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int code) {
    }
  }
-  tfree(tokenBuf);
+  taosTFree(tokenBuf);
  free(line);
  if (count > 0) {
@@ -1466,7 +1465,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int code) {
  } else {
    taos_free_result(pSql);
-    tfree(pSupporter);
+    taosTFree(pSupporter);
    fclose(fp);
    pParentSql->fp = pParentSql->fetchFp;
@@ -1496,7 +1495,7 @@ void tscProcessMultiVnodesImportFromFile(SSqlObj *pSql) {
    pSql->res.code = TAOS_SYSTEM_ERROR(errno);
    tscError("%p failed to open file %s to load data from file, code:%s", pSql, pCmd->payload, tstrerror(pSql->res.code));
-    tfree(pSupporter)
+    taosTFree(pSupporter)
    tscQueueAsyncRes(pSql);
    return;

--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -613,7 +613,7 @@ int taos_stmt_execute(TAOS_STMT* stmt) {
    if (sql == NULL) {
      ret = TSDB_CODE_TSC_OUT_OF_MEMORY;
    } else {
-      tfree(pStmt->pSql->sqlstr);
+      taosTFree(pStmt->pSql->sqlstr);
      pStmt->pSql->sqlstr = sql;
      SSqlObj* pSql = taos_query((TAOS*)pStmt->taos, pStmt->pSql->sqlstr);
      ret = taos_errno(pSql);

--- a/src/client/src/tscProfile.c
+++ b/src/client/src/tscProfile.c
@@ -16,7 +16,6 @@
 #include "os.h"
 #include "tscLog.h"
 #include "tsclient.h"
-#include "ttime.h"
 #include "ttimer.h"
 #include "tutil.h"
 #include "taosmsg.h"

--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -29,7 +29,6 @@
 #include "tsclient.h"
 #include "tstoken.h"
 #include "tstrbuild.h"
-#include "ttime.h"
 #include "ttokendef.h"
 #define DEFAULT_PRIMARY_TIMESTAMP_COL_NAME "_c0"
@@ -737,7 +736,7 @@ int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SSQLToken* pzTableNa
    assert(pTableMetaInfo->pTableMeta == NULL);
  }
-  tfree(oldName);
+  taosTFree(oldName);
  return TSDB_CODE_SUCCESS;
 }
@@ -3648,7 +3647,7 @@ static int32_t setTableCondForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
    int32_t ret = setObjFullName(idBuf, account, &dbToken, &t, &xlen);
    if (ret != TSDB_CODE_SUCCESS) {
      taosStringBuilderDestroy(&sb1);
-      tfree(segments);
+      taosTFree(segments);
      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
      return ret;
@@ -3661,7 +3660,7 @@ static int32_t setTableCondForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
  pQueryInfo->tagCond.tbnameCond.cond = strdup(str);
  taosStringBuilderDestroy(&sb1);
-  tfree(segments);
+  taosTFree(segments);
  return TSDB_CODE_SUCCESS;
 }

--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -23,7 +23,6 @@
 #include "tscUtil.h"
 #include "tschemautil.h"
 #include "tsclient.h"
-#include "ttime.h"
 #include "ttimer.h"
 #include "tutil.h"
 #include "tlockfree.h"
@@ -196,7 +195,7 @@ void tscProcessActivityTimer(void *handle, void *tmrId) {
    pSql->cmd.command = TSDB_SQL_HB;
    if (TSDB_CODE_SUCCESS != tscAllocPayload(&(pSql->cmd), TSDB_DEFAULT_PAYLOAD_SIZE)) {
-      tfree(pSql);
+      taosTFree(pSql);
      return;
    }
@@ -1538,7 +1537,7 @@ int tscBuildTableMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
  pCmd->payloadLen = pMsg - (char*)pInfoMsg;
  pCmd->msgType = TSDB_MSG_TYPE_CM_TABLE_META;
-  tfree(tmpData);
+  taosTFree(tmpData);
  assert(msgLen + minMsgSize() <= pCmd->allocSize);
  return TSDB_CODE_SUCCESS;
@@ -1572,7 +1571,7 @@ int tscBuildMultiMeterMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
    memcpy(pInfoMsg->tableIds, tmpData, pCmd->payloadLen);
  }
-  tfree(tmpData);
+  taosTFree(tmpData);
  pCmd->payloadLen += sizeof(SMgmtHead) + sizeof(SCMMultiTableInfoMsg);
  pCmd->msgType = TSDB_MSG_TYPE_CM_TABLES_META;
@@ -1962,7 +1961,7 @@ int tscProcessShowRsp(SSqlObj *pSql) {
  pCmd->numOfCols = pQueryInfo->fieldsInfo.numOfOutput;
  tscFieldInfoUpdateOffset(pQueryInfo);
-  tfree(pTableMeta);
+  taosTFree(pTableMeta);
  return 0;
 }

--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -474,7 +474,7 @@ int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) {
    pRes->rspType = 0;
    pSql->numOfSubs = 0;
-    tfree(pSql->pSubs);
+    taosTFree(pSql->pSubs);
    assert(pSql->fp == NULL);
@@ -753,7 +753,7 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
  if (sqlLen > tsMaxSQLStringLen) {
    tscError("%p sql too long", pSql);
    pRes->code = TSDB_CODE_TSC_INVALID_SQL;
-    tfree(pSql);
+    taosTFree(pSql);
    return pRes->code;
  }
@@ -762,7 +762,7 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
    tscError("%p failed to malloc sql string buffer", pSql);
    tscDebug("%p Valid SQL result:%d, %s pObj:%p", pSql, pRes->code, taos_errstr(taos), pObj);
-    tfree(pSql);
+    taosTFree(pSql);
    return pRes->code;
  }
@@ -896,7 +896,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
  if (tblListLen > MAX_TABLE_NAME_LENGTH) {
    tscError("%p tableNameList too long, length:%d, maximum allowed:%d", pSql, tblListLen, MAX_TABLE_NAME_LENGTH);
    pRes->code = TSDB_CODE_TSC_INVALID_SQL;
-    tfree(pSql);
+    taosTFree(pSql);
    return pRes->code;
  }
@@ -904,7 +904,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
  if (str == NULL) {
    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
    tscError("%p failed to malloc sql string buffer", pSql);
-    tfree(pSql);
+    taosTFree(pSql);
    return pRes->code;
  }

--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -21,7 +21,6 @@
 #include "tsched.h"
 #include "tcache.h"
 #include "tsclient.h"
-#include "ttime.h"
 #include "ttimer.h"
 #include "tutil.h"
@@ -156,7 +155,7 @@ static void tscProcessStreamQueryCallback(void *param, TAOS_RES *tres, int numOf
    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pStream->pSql->cmd, 0, 0);
    taosCacheRelease(tscCacheHandle, (void**)&(pTableMetaInfo->pTableMeta), true);
-    tfree(pTableMetaInfo->vgroupList);
+    taosTFree(pTableMetaInfo->vgroupList);
    tscSetRetryTimer(pStream, pStream->pSql, retryDelay);
    return;
@@ -260,9 +259,9 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf
    taosCacheRelease(tscCacheHandle, (void**)&(pTableMetaInfo->pTableMeta), false);
    tscFreeSqlResult(pSql);
-    tfree(pSql->pSubs);
+    taosTFree(pSql->pSubs);
    pSql->numOfSubs = 0;
-    tfree(pTableMetaInfo->vgroupList);
+    taosTFree(pTableMetaInfo->vgroupList);
    tscSetNextLaunchTimer(pStream, pSql);
  }
 }
@@ -592,6 +591,6 @@ void taos_close_stream(TAOS_STREAM *handle) {
    tscFreeSqlObj(pSql);
    pStream->pSql = NULL;
-    tfree(pStream);
+    taosTFree(pStream);
  }
 }
--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@@ -18,7 +18,6 @@
 #include "trpc.h"
 #include "tsclient.h"
 #include "tsocket.h"
-#include "ttime.h"
 #include "ttimer.h"
 #include "tutil.h"
 #include "tscLog.h"

--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -183,7 +183,7 @@ SJoinSupporter* tscCreateJoinSupporter(SSqlObj* pSql, SSubqueryState* pState, in
  pSupporter->uid = pTableMetaInfo->pTableMeta->id.uid;
  assert (pSupporter->uid != 0);
-  getTmpfilePath("join-", pSupporter->path);
+  taosGetTmpfilePath("join-", pSupporter->path);
  pSupporter->f = fopen(pSupporter->path, "w");
  // todo handle error
@@ -215,7 +215,7 @@ static void tscDestroyJoinSupporter(SJoinSupporter* pSupporter) {
    pSupporter->f = NULL;
  }
-  tfree(pSupporter->pIdTagList);
+  taosTFree(pSupporter->pIdTagList);
  tscTagCondRelease(&pSupporter->tagCond);
  free(pSupporter);
 }
@@ -407,7 +407,7 @@ void freeJoinSubqueryObj(SSqlObj* pSql) {
    }
  }
-  tfree(pState);
+  taosTFree(pState);
  pSql->numOfSubs = 0;
 }
@@ -773,7 +773,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
    // continue to retrieve ts-comp data from vnode
    if (!pRes->completed) {
-      getTmpfilePath("ts-join", pSupporter->path);
+      taosGetTmpfilePath("ts-join", pSupporter->path);
      pSupporter->f = fopen(pSupporter->path, "w");
      pRes->row = pRes->numOfRows;
@@ -797,7 +797,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
    tscResetForNextRetrieve(&pSql->res);
    assert(pSupporter->f == NULL);
-    getTmpfilePath("ts-join", pSupporter->path);
+    taosGetTmpfilePath("ts-join", pSupporter->path);
    // TODO check for failure
    pSupporter->f = fopen(pSupporter->path, "w");
@@ -1317,12 +1317,12 @@ static void doCleanupSubqueries(SSqlObj *pSql, int32_t numOfSubs, SSubqueryState
    SRetrieveSupport* pSupport = pSub->param;
-    tfree(pSupport->localBuffer);
+    taosTFree(pSupport->localBuffer);
    pthread_mutex_unlock(&pSupport->queryMutex);
    pthread_mutex_destroy(&pSupport->queryMutex);
-    tfree(pSupport);
+    taosTFree(pSupport);
    tscFreeSqlObj(pSub);
  }
@@ -1358,7 +1358,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
  if (ret != 0) {
    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
    tscQueueAsyncRes(pSql);
-    tfree(pMemoryBuf);
+    taosTFree(pMemoryBuf);
    return ret;
  }
@@ -1386,7 +1386,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
    trs->localBuffer = (tFilePage *)calloc(1, nBufferSize + sizeof(tFilePage));
    if (trs->localBuffer == NULL) {
      tscError("%p failed to malloc buffer for local buffer, orderOfSub:%d, reason:%s", pSql, i, strerror(errno));
-      tfree(trs);
+      taosTFree(trs);
      break;
    }
@@ -1404,8 +1404,8 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
    SSqlObj *pNew = tscCreateSqlObjForSubquery(pSql, trs, NULL);
    if (pNew == NULL) {
      tscError("%p failed to malloc buffer for subObj, orderOfSub:%d, reason:%s", pSql, i, strerror(errno));
-      tfree(trs->localBuffer);
+      taosTFree(trs->localBuffer);
-      tfree(trs);
+      taosTFree(trs);
      break;
    }
@@ -1450,12 +1450,12 @@ static void tscFreeSubSqlObj(SRetrieveSupport *trsupport, SSqlObj *pSql) {
  taos_free_result(pSql);
-  tfree(trsupport->localBuffer);
+  taosTFree(trsupport->localBuffer);
  pthread_mutex_unlock(&trsupport->queryMutex);
  pthread_mutex_destroy(&trsupport->queryMutex);
-  tfree(trsupport);
+  taosTFree(trsupport);
 }
 static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfRows);
@@ -1572,7 +1572,7 @@ void tscHandleSubqueryError(SRetrieveSupport *trsupport, SSqlObj *pSql, int numO
  tscLocalReducerEnvDestroy(trsupport->pExtMemBuffer, trsupport->pOrderDescriptor, trsupport->pFinalColModel,
                            pState->numOfTotal);
-  tfree(trsupport->pState);
+  taosTFree(trsupport->pState);
  tscFreeSubSqlObj(trsupport, pSql);
  // in case of second stage join subquery, invoke its callback function instead of regular QueueAsyncRes
@@ -1651,7 +1651,7 @@ static void tscAllDataRetrievedFromDnode(SRetrieveSupport *trsupport, SSqlObj* p
  pParentSql->res.row = 0;
  // only free once
-  tfree(trsupport->pState);
+  taosTFree(trsupport->pState);
  tscFreeSubSqlObj(trsupport, pSql);
  // set the command flag must be after the semaphore been correctly set.
@@ -1855,7 +1855,7 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
  }
  taos_free_result(tres);
-  tfree(pSupporter);
+  taosTFree(pSupporter);
  if (atomic_sub_fetch_32(&pState->numOfRemain, 1) > 0) {
    return;
@@ -1864,7 +1864,7 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
  tscDebug("%p Async insertion completed, total inserted:%" PRId64, pParentObj, pParentObj->res.numOfRows);
  // release data block data
-  tfree(pState);
+  taosTFree(pState);
  // restore user defined fp
  pParentObj->fp = pParentObj->fetchFp;
@@ -1968,11 +1968,11 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql) {
  _error:
  for(int32_t j = 0; j < numOfSub; ++j) {
-    tfree(pSql->pSubs[j]->param);
+    taosTFree(pSql->pSubs[j]->param);
    taos_free_result(pSql->pSubs[j]);
  }
-  tfree(pState);
+  taosTFree(pState);
  return TSDB_CODE_TSC_OUT_OF_MEMORY;
 }
@@ -2143,7 +2143,7 @@ void **doSetResultRowData(SSqlObj *pSql, bool finalResult) {
  assert(pRes->row >= 0 && pRes->row <= pRes->numOfRows);
  if (pRes->row >= pRes->numOfRows) {  // all the results has returned to invoker
-    tfree(pRes->tsrow);
+    taosTFree(pRes->tsrow);
    return pRes->tsrow;
  }

--- a/src/client/src/tscSystem.c
+++ b/src/client/src/tscSystem.c
@@ -18,7 +18,6 @@
 #include "tcache.h"
 #include "trpc.h"
 #include "tsystem.h"
-#include "ttime.h"
 #include "ttimer.h"
 #include "tutil.h"
 #include "tsched.h"

--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -245,7 +245,7 @@ void tscClearInterpInfo(SQueryInfo* pQueryInfo) {
  }
  pQueryInfo->fillType = TSDB_FILL_NONE;
-  tfree(pQueryInfo->fillVal);
+  taosTFree(pQueryInfo->fillVal);
 }
 int32_t tscCreateResPointerInfo(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
@@ -259,9 +259,9 @@ int32_t tscCreateResPointerInfo(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
    // not enough memory
    if (pRes->tsrow == NULL || (pRes->buffer == NULL && pRes->numOfCols > 0)) {
-      tfree(pRes->tsrow);
+      taosTFree(pRes->tsrow);
-      tfree(pRes->buffer);
+      taosTFree(pRes->buffer);
-      tfree(pRes->length);
+      taosTFree(pRes->length);
      pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
      return pRes->code;
@@ -274,23 +274,23 @@ int32_t tscCreateResPointerInfo(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
 void tscDestroyResPointerInfo(SSqlRes* pRes) {
  if (pRes->buffer != NULL) { // free all buffers containing the multibyte string
    for (int i = 0; i < pRes->numOfCols; i++) {
-      tfree(pRes->buffer[i]);
+      taosTFree(pRes->buffer[i]);
    }
    pRes->numOfCols = 0;
  }
-  tfree(pRes->pRsp);
+  taosTFree(pRes->pRsp);
-  tfree(pRes->tsrow);
+  taosTFree(pRes->tsrow);
-  tfree(pRes->length);
+  taosTFree(pRes->length);
-  tfree(pRes->pGroupRec);
+  taosTFree(pRes->pGroupRec);
-  tfree(pRes->pColumnIndex);
+  taosTFree(pRes->pColumnIndex);
-  tfree(pRes->buffer);
+  taosTFree(pRes->buffer);
  if (pRes->pArithSup != NULL) {
-    tfree(pRes->pArithSup->data);
+    taosTFree(pRes->pArithSup->data);
-    tfree(pRes->pArithSup);
+    taosTFree(pRes->pArithSup);
  }
  pRes->data = NULL;  // pRes->data points to the buffer of pRsp, no need to free
@@ -307,11 +307,11 @@ static void tscFreeQueryInfo(SSqlCmd* pCmd) {
    freeQueryInfoImpl(pQueryInfo);
    clearAllTableMetaInfo(pQueryInfo, (const char*)addr, false);
-    tfree(pQueryInfo);
+    taosTFree(pQueryInfo);
  }
  pCmd->numOfClause = 0;
-  tfree(pCmd->pQueryInfo);
+  taosTFree(pCmd->pQueryInfo);
 }
 void tscResetSqlCmdObj(SSqlCmd* pCmd) {
@@ -357,13 +357,13 @@ void tscPartiallyFreeSqlObj(SSqlObj* pSql) {
  // pSql->sqlstr will be used by tscBuildQueryStreamDesc
  if (pObj->signature == pObj) {
    //pthread_mutex_lock(&pObj->mutex);
-    tfree(pSql->sqlstr);
+    taosTFree(pSql->sqlstr);
    //pthread_mutex_unlock(&pObj->mutex);
  }
  tscFreeSqlResult(pSql);
-  tfree(pSql->pSubs);
+  taosTFree(pSql->pSubs);
  pSql->numOfSubs = 0;
  tscResetSqlCmdObj(pCmd);
@@ -383,10 +383,10 @@ void tscFreeSqlObj(SSqlObj* pSql) {
  SSqlCmd* pCmd = &pSql->cmd;
  memset(pCmd->payload, 0, (size_t)pCmd->allocSize);
-  tfree(pCmd->payload);
+  taosTFree(pCmd->payload);
  pCmd->allocSize = 0;
-  tfree(pSql->sqlstr);
+  taosTFree(pSql->sqlstr);
  sem_destroy(&pSql->rspSem);
  free(pSql);
 }
@@ -396,12 +396,12 @@ void tscDestroyDataBlock(STableDataBlocks* pDataBlock) {
    return;
  }
-  tfree(pDataBlock->pData);
+  taosTFree(pDataBlock->pData);
-  tfree(pDataBlock->params);
+  taosTFree(pDataBlock->params);
  // free the refcount for metermeta
  taosCacheRelease(tscCacheHandle, (void**)&(pDataBlock->pTableMeta), false);
-  tfree(pDataBlock);
+  taosTFree(pDataBlock);
 }
 SParamInfo* tscAddParamToDataBlock(STableDataBlocks* pDataBlock, char type, uint8_t timePrec, short bytes,
@@ -679,7 +679,7 @@ int32_t tscMergeTableDataBlocks(SSqlObj* pSql, SArray* pTableDataBlockList) {
        taosHashCleanup(pVnodeDataBlockHashList);
        tscDestroyBlockArrayList(pVnodeDataBlockList);
-        tfree(dataBuf->pData);
+        taosTFree(dataBuf->pData);
        return TSDB_CODE_TSC_OUT_OF_MEMORY;
      }
@@ -735,7 +735,7 @@ void tscCloseTscObj(STscObj* pObj) {
  }
  tscDebug("%p DB connection is closed, dnodeConn:%p", pObj, pObj->pDnodeConn);
-  tfree(pObj);
+  taosTFree(pObj);
 }
 bool tscIsInsertData(char* sqlstr) {
@@ -916,7 +916,7 @@ void tscFieldInfoClear(SFieldInfo* pFieldInfo) {
    if (pInfo->pArithExprInfo != NULL) {
      tExprTreeDestroy(&pInfo->pArithExprInfo->pExpr, NULL);
-      tfree(pInfo->pArithExprInfo);
+      taosTFree(pInfo->pArithExprInfo);
    }
  }
@@ -1029,7 +1029,7 @@ void* sqlExprDestroy(SSqlExpr* pExpr) {
    tVariantDestroy(&pExpr->param[i]);
  }
-  tfree(pExpr);
+  taosTFree(pExpr);
  return NULL;
 }
@@ -1116,11 +1116,11 @@ SColumn* tscColumnListInsert(SArray* pColumnList, SColumnIndex* pColIndex) {
 static void destroyFilterInfo(SColumnFilterInfo* pFilterInfo, int32_t numOfFilters) {
  for(int32_t i = 0; i < numOfFilters; ++i) {
    if (pFilterInfo[i].filterstr) {
-      tfree(pFilterInfo[i].pz);
+      taosTFree(pFilterInfo[i].pz);
    }
  }
-  tfree(pFilterInfo);
+  taosTFree(pFilterInfo);
 }
 SColumn* tscColumnClone(const SColumn* src) {
@@ -1351,7 +1351,7 @@ void tscTagCondRelease(STagCond* pTagCond) {
    size_t s = taosArrayGetSize(pTagCond->pCond);
    for (int32_t i = 0; i < s; ++i) {
      SCond* p = taosArrayGet(pTagCond->pCond, i);
-      tfree(p->cond);
+      taosTFree(p->cond);
    }
    taosArrayDestroy(pTagCond->pCond);
@@ -1546,7 +1546,7 @@ static void freeQueryInfoImpl(SQueryInfo* pQueryInfo) {
  pQueryInfo->tsBuf = tsBufDestroy(pQueryInfo->tsBuf);
-  tfree(pQueryInfo->fillVal);
+  taosTFree(pQueryInfo->fillVal);
 }
 void tscClearSubqueryInfo(SSqlCmd* pCmd) {
@@ -1566,7 +1566,7 @@ void clearAllTableMetaInfo(SQueryInfo* pQueryInfo, const char* address, bool rem
    free(pTableMetaInfo);
  }
-  tfree(pQueryInfo->pTableMetaInfo);
+  taosTFree(pQueryInfo->pTableMetaInfo);
 }
 STableMetaInfo* tscAddTableMetaInfo(SQueryInfo* pQueryInfo, const char* name, STableMeta* pTableMeta,
@@ -1613,7 +1613,7 @@ void tscClearTableMetaInfo(STableMetaInfo* pTableMetaInfo, bool removeFromCache)
  }
  taosCacheRelease(tscCacheHandle, (void**)&(pTableMetaInfo->pTableMeta), removeFromCache);
-  tfree(pTableMetaInfo->vgroupList);
+  taosTFree(pTableMetaInfo->vgroupList);
  tscColumnListDestroy(pTableMetaInfo->tagColList);
  pTableMetaInfo->tagColList = NULL;
@@ -2084,7 +2084,7 @@ void tscTryQueryNextClause(SSqlObj* pSql, __async_cb_func_t fp) {
  pRes->numOfTotal = num;
-  tfree(pSql->pSubs);
+  taosTFree(pSql->pSubs);
  pSql->numOfSubs = 0;
  pSql->fp = fp;

--- a/src/client/tests/timeParseTest.cpp
+++ b/src/client/tests/timeParseTest.cpp
+#include "os.h"
 #include <gtest/gtest.h>
 #include <cassert>
 #include <iostream>
 #include "taos.h"
 #include "tstoken.h"
-#include "ttime.h"
 #include "tutil.h"
 int main(int argc, char** argv) {

--- a/src/common/inc/tdataformat.h
+++ b/src/common/inc/tdataformat.h
@@ -80,7 +80,7 @@ typedef struct {
 #define schemaFLen(s) ((s)->flen)
 #define schemaVLen(s) ((s)->vlen)
 #define schemaColAt(s, i) ((s)->columns + i)
-#define tdFreeSchema(s) tfree((s))
+#define tdFreeSchema(s) taosTFree((s))
 STSchema *tdDupSchema(STSchema *pSchema);
 int       tdEncodeSchema(void **buf, STSchema *pSchema);
@@ -284,7 +284,7 @@ typedef struct {
 #define kvRowCpy(dst, r) memcpy((dst), (r), kvRowLen(r))
 #define kvRowColVal(r, colIdx) POINTER_SHIFT(kvRowValues(r), (colIdx)->offset)
 #define kvRowColIdxAt(r, i) (kvRowColIdx(r) + (i))
-#define kvRowFree(r) tfree(r)
+#define kvRowFree(r) taosTFree(r)
 #define kvRowEnd(r) POINTER_SHIFT(r, kvRowLen(r))
 SKVRow tdKVRowDup(SKVRow row);

--- a/src/common/src/tdataformat.c
+++ b/src/common/src/tdataformat.c
@@ -93,7 +93,7 @@ int tdInitTSchemaBuilder(STSchemaBuilder *pBuilder, int32_t version) {
 void tdDestroyTSchemaBuilder(STSchemaBuilder *pBuilder) {
  if (pBuilder) {
-    tfree(pBuilder->columns);
+    taosTFree(pBuilder->columns);
  }
 }
@@ -361,8 +361,8 @@ int tdInitDataCols(SDataCols *pCols, STSchema *pSchema) {
 void tdFreeDataCols(SDataCols *pCols) {
  if (pCols) {
-    tfree(pCols->buf);
+    taosTFree(pCols->buf);
-    tfree(pCols->cols);
+    taosTFree(pCols->cols);
    free(pCols);
  }
 }
@@ -685,8 +685,8 @@ int tdInitKVRowBuilder(SKVRowBuilder *pBuilder) {
 }
 void tdDestroyKVRowBuilder(SKVRowBuilder *pBuilder) {
-  tfree(pBuilder->pColIdx);
+  taosTFree(pBuilder->pColIdx);
-  tfree(pBuilder->buf);
+  taosTFree(pBuilder->buf);
 }
 void tdResetKVRowBuilder(SKVRowBuilder *pBuilder) {

--- a/src/common/src/tglobal.c
+++ b/src/common/src/tglobal.c
@@ -111,7 +111,7 @@ int32_t tsFsyncPeriod   = TSDB_DEFAULT_FSYNC_PERIOD;
 int32_t tsReplications  = TSDB_DEFAULT_DB_REPLICA_OPTION;
 int32_t tsQuorum        = TSDB_DEFAULT_DB_QUORUM_OPTION;
 int32_t tsMaxVgroupsPerDb  = 0;
-int32_t tsMinTablePerVnode = 100;
+int32_t tsMinTablePerVnode = TSDB_TABLES_STEP;
 int32_t tsMaxTablePerVnode = TSDB_DEFAULT_TABLES;
 int32_t tsTableIncStepPerVnode = TSDB_TABLES_STEP;

--- a/src/common/src/tvariant.c
+++ b/src/common/src/tvariant.c
@@ -128,7 +128,7 @@ void tVariantDestroy(tVariant *pVar) {
  if (pVar == NULL) return;
  if (pVar->nType == TSDB_DATA_TYPE_BINARY || pVar->nType == TSDB_DATA_TYPE_NCHAR) {
-    tfree(pVar->pz);
+    taosTFree(pVar->pz);
    pVar->nLen = 0;
  }

--- a/src/connector/jdbc/pom.xml
+++ b/src/connector/jdbc/pom.xml
@@ -52,12 +52,7 @@
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
      <version>${commons-lang3.version}</version>
-    </dependency>
+    </dependency>    
-    <dependency>
-      <groupId>org.jacoco</groupId>
-      <artifactId>jacoco-maven-plugin</artifactId>
-      <version>0.8.3</version>
-    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
@@ -105,32 +100,7 @@
        <configuration>
          <testFailureIgnore>true</testFailureIgnore>
        </configuration>
-      </plugin>
+      </plugin>      
-      <plugin>
-        <groupId>org.jacoco</groupId>
-        <artifactId>jacoco-maven-plugin</artifactId>
-        <version>0.8.3</version>
-        <configuration>
-          <includes>
-            <include>com/**/*</include>
-          </includes>
-        </configuration>
-        <executions>
-          <execution>
-            <id>pre-test</id>
-            <goals>
-              <goal>prepare-agent</goal>
-            </goals>
-          </execution>
-          <execution>
-            <id>post-test</id>
-            <phase>test</phase>
-            <goals>
-              <goal>report</goal>
-            </goals>
-          </execution>
-        </executions>
-      </plugin>
    </plugins>
  </build>
 </project>
--- a/src/cq/src/cqMain.c
+++ b/src/cq/src/cqMain.c
@@ -114,7 +114,7 @@ void cqClose(void *handle) {
    SCqObj *pTemp = pObj;
    pObj = pObj->next;
    tdFreeSchema(pTemp->pSchema);
-    tfree(pTemp->sqlStr);
+    taosTFree(pTemp->sqlStr);
    free(pTemp);
  } 

--- a/src/dnode/CMakeLists.txt
+++ b/src/dnode/CMakeLists.txt
@@ -16,7 +16,8 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
  AUX_SOURCE_DIRECTORY(src SRC)
  ADD_EXECUTABLE(taosd ${SRC})
-  TARGET_LINK_LIBRARIES(taosd mnode taos_static monitor http mqtt tsdb twal vnode cJson lz4 balance sync)
+#  TARGET_LINK_LIBRARIES(taosd mnode taos_static monitor http mqtt tsdb twal vnode cJson lz4 balance sync)
+  TARGET_LINK_LIBRARIES(taosd mnode taos monitor http mqtt tsdb twal vnode cJson lz4 balance sync)
  IF (TD_ACCOUNT)
    TARGET_LINK_LIBRARIES(taosd account)

--- a/src/dnode/src/dnodeMPeer.c
+++ b/src/dnode/src/dnodeMPeer.c
@@ -75,7 +75,7 @@ void dnodeCleanupMnodePeer() {
  }
  taosCloseQset(tsMPeerQset);
-  tfree(tsMPeerPool.peerWorker);
+  taosTFree(tsMPeerPool.peerWorker);
  dInfo("dnode mpeer is closed");
 }

--- a/src/dnode/src/dnodeMWrite.c
+++ b/src/dnode/src/dnodeMWrite.c
@@ -77,7 +77,7 @@ void dnodeCleanupMnodeWrite() {
  }
  taosCloseQset(tsMWriteQset);
-  tfree(tsMWritePool.writeWorker);
+  taosTFree(tsMWritePool.writeWorker);
  dInfo("dnode mwrite is closed");
 }

--- a/src/dnode/src/dnodeMgmt.c
+++ b/src/dnode/src/dnodeMgmt.c
@@ -18,13 +18,11 @@
 #include "cJSON.h"
 #include "taoserror.h"
 #include "taosmsg.h"
-#include "ttime.h"
 #include "ttimer.h"
 #include "tsdb.h"
 #include "twal.h"
 #include "tqueue.h"
 #include "tsync.h"
-#include "ttime.h"
 #include "ttimer.h"
 #include "tbalance.h"
 #include "tglobal.h"

--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
@@ -22,6 +22,7 @@ extern "C" {
 #include <stdint.h>
 #include <stdbool.h>
+#include "osDef.h"
 #include "taos.h"
 #define TSDB__packed
@@ -161,7 +162,7 @@ extern tDataTypeDescriptor tDataTypeDesc[11];
 bool isValidDataType(int32_t type);
 //bool isNull(const char *val, int32_t type);
-static inline __attribute__((always_inline)) bool isNull(const char *val, int32_t type) {
+static FORCE_INLINE bool isNull(const char *val, int32_t type) {
  switch (type) {
    case TSDB_DATA_TYPE_BOOL:
      return *(uint8_t *)val == TSDB_DATA_BOOL_NULL;

--- a/src/kit/shell/CMakeLists.txt
+++ b/src/kit/shell/CMakeLists.txt
@@ -15,11 +15,11 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
  LIST(REMOVE_ITEM SRC ./src/shellDarwin.c)
  ADD_EXECUTABLE(shell ${SRC})  
-  IF (TD_PAGMODE_LITE)
+#  IF (TD_PAGMODE_LITE)
    TARGET_LINK_LIBRARIES(shell taos)
-  ELSE ()
+#  ELSE ()
-    TARGET_LINK_LIBRARIES(shell taos_static)
+#    TARGET_LINK_LIBRARIES(shell taos_static)
-  ENDIF ()
+#  ENDIF ()
  SET_TARGET_PROPERTIES(shell PROPERTIES OUTPUT_NAME taos)
 ELSEIF (TD_WINDOWS_64)

--- a/src/kit/shell/src/shellDarwin.c
+++ b/src/kit/shell/src/shellDarwin.c
@@ -229,8 +229,8 @@ void shellReadCommand(TAOS *con, char *command) {
          printf("\n");
          if (isReadyGo(&cmd)) {
            sprintf(command, "%s%s", cmd.buffer, cmd.command);
-            tfree(cmd.buffer);
+            taosTFree(cmd.buffer);
-            tfree(cmd.command);
+            taosTFree(cmd.command);
            return;
          } else {
            updateBuffer(&cmd);

--- a/src/kit/shell/src/shellEngine.c
+++ b/src/kit/shell/src/shellEngine.c
@@ -21,7 +21,6 @@
 #include "os.h"
 #include "shell.h"
 #include "shellCommand.h"
-#include "ttime.h"
 #include "tutil.h"
 #include "taosdef.h"
 #include "taoserror.h"
@@ -176,7 +175,7 @@ int32_t shellRunCommand(TAOS* con, char* command) {
      history.hist[(history.hend + MAX_HISTORY_SIZE - 1) % MAX_HISTORY_SIZE] == NULL ||
      strcmp(command, history.hist[(history.hend + MAX_HISTORY_SIZE - 1) % MAX_HISTORY_SIZE]) != 0) {
    if (history.hist[history.hend] != NULL) {
-      tfree(history.hist[history.hend]);
+      taosTFree(history.hist[history.hend]);
    }
    history.hist[history.hend] = strdup(command);
@@ -770,7 +769,7 @@ void write_history() {
  for (int i = history.hstart; i != history.hend;) {
    if (history.hist[i] != NULL) {
      fprintf(f, "%s\n", history.hist[i]);
-      tfree(history.hist[i]);
+      taosTFree(history.hist[i]);
    }
    i = (i + 1) % MAX_HISTORY_SIZE;
  }

--- a/src/kit/shell/src/shellImport.c
+++ b/src/kit/shell/src/shellImport.c
@@ -21,7 +21,6 @@
 #include "shell.h"
 #include "shellCommand.h"
 #include "tglobal.h"
-#include "ttime.h"
 #include "tutil.h"
 static char **shellSQLFiles = NULL;

--- a/src/kit/shell/src/shellLinux.c
+++ b/src/kit/shell/src/shellLinux.c
@@ -201,8 +201,8 @@ void shellReadCommand(TAOS *con, char *command) {
          printf("\n");
          if (isReadyGo(&cmd)) {
            sprintf(command, "%s%s", cmd.buffer, cmd.command);
-            tfree(cmd.buffer);
+            taosTFree(cmd.buffer);
-            tfree(cmd.command);
+            taosTFree(cmd.command);
            return;
          } else {
            updateBuffer(&cmd);
@@ -320,7 +320,7 @@ void *shellLoopQuery(void *arg) {
    reset_terminal_mode();
  } while (shellRunCommand(con, command) == 0);
-  tfree(command);
+  taosTFree(command);
  exitShell();
  pthread_cleanup_pop(1);

--- a/src/kit/taosdemo/CMakeLists.txt
+++ b/src/kit/taosdemo/CMakeLists.txt
@@ -11,10 +11,10 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
  AUX_SOURCE_DIRECTORY(. SRC)
  ADD_EXECUTABLE(taosdemo ${SRC})
-  IF (TD_PAGMODE_LITE)
+#  IF (TD_PAGMODE_LITE)
    TARGET_LINK_LIBRARIES(taosdemo taos)
-  ELSE ()
+#  ELSE ()
-    TARGET_LINK_LIBRARIES(taosdemo taos_static)
+#    TARGET_LINK_LIBRARIES(taosdemo taos_static)
-  ENDIF ()
+#  ENDIF ()
 ENDIF ()
--- a/src/kit/taosdump/CMakeLists.txt
+++ b/src/kit/taosdump/CMakeLists.txt
@@ -13,11 +13,11 @@ IF ((TD_LINUX_64) OR (TD_LINUX_32 AND TD_ARM))
  AUX_SOURCE_DIRECTORY(. SRC)
  ADD_EXECUTABLE(taosdump ${SRC})
-  IF (TD_PAGMODE_LITE)
+#  IF (TD_PAGMODE_LITE)
    TARGET_LINK_LIBRARIES(taosdump taos)
-  ELSE ()
+#  ELSE ()
-    TARGET_LINK_LIBRARIES(taosdump taos_static)
+#    TARGET_LINK_LIBRARIES(taosdump taos_static)
-  ENDIF ()  
+#  ENDIF ()  
 ENDIF ()
--- a/src/kit/taosdump/taosdump.c
+++ b/src/kit/taosdump/taosdump.c
@@ -448,8 +448,8 @@ int main(int argc, char *argv[]) {
 void taosFreeDbInfos() {
  if (dbInfos == NULL) return;
-  for (int i = 0; i < 128; i++) tfree(dbInfos[i]);
+  for (int i = 0; i < 128; i++) taosTFree(dbInfos[i]);
-  tfree(dbInfos);
+  taosTFree(dbInfos);
 }
 // check table is normal table or super table
@@ -606,11 +606,11 @@ int32_t taosSaveTableOfMetricToTempFile(TAOS *taosCon, char* metric, struct argu
    if (numOfTable >= arguments->table_batch) {
      numOfTable = 0;
-      tclose(fd);
+      taosClose(fd);
      fd = -1;
    }
  }
-  tclose(fd);
+  taosClose(fd);
  fd = -1;
  taos_free_result(result);
@@ -780,14 +780,14 @@ int taosDumpOut(struct arguments *arguments) {
        if (retCode < 0) {
          if (-1 != normalTblFd){
-            tclose(normalTblFd);
+            taosClose(normalTblFd);
          }
          goto _clean_tmp_file;
        }
      }
      if (-1 != normalTblFd){
-        tclose(normalTblFd);
+        taosClose(normalTblFd);
      }
      // start multi threads to dumpout
@@ -806,7 +806,7 @@ int taosDumpOut(struct arguments *arguments) {
  fclose(fp);
  taos_close(taos);
  taos_free_result(result);
-  tfree(command);
+  taosTFree(command);
  taosFreeDbInfos();  
  fprintf(stderr, "dump out rows: %" PRId64 "\n", totalDumpOutRows);
  return 0;
@@ -815,7 +815,7 @@ _exit_failure:
  fclose(fp);
  taos_close(taos);
  taos_free_result(result);
-  tfree(command);
+  taosTFree(command);
  taosFreeDbInfos();
  fprintf(stderr, "dump out rows: %" PRId64 "\n", totalDumpOutRows);
  return -1;
@@ -1076,7 +1076,7 @@ void* taosDumpOutWorkThreadFp(void *arg)
  }
  taos_free_result(tmpResult);
-  tclose(fd);
+  taosClose(fd);
  fclose(fp);  
  return NULL;
@@ -1206,7 +1206,7 @@ int32_t taosDumpCreateSuperTableClause(TAOS* taosCon, char* dbName, FILE *fp)
    (void)taosDumpStable(tableRecord.name, fp, taosCon);
  }
-  tclose(fd);
+  taosClose(fd);
  remove(".stables.tmp");
  free(tmpCommand);
@@ -1288,11 +1288,11 @@ int taosDumpDb(SDbInfo *dbInfo, struct arguments *arguments, FILE *fp, TAOS *tao
    if (numOfTable >= arguments->table_batch) {
      numOfTable = 0;
-      tclose(fd);
+      taosClose(fd);
      fd = -1;
    }
  }
-  tclose(fd);
+  taosClose(fd);
  fd = -1;
  taos_free_result(tmpResult);
@@ -1760,13 +1760,13 @@ void taosLoadFileCharset(FILE *fp, char *fcharset) {
  }
  strcpy(fcharset, line + 2);
-  tfree(line);
+  taosTFree(line);
  return;
 _exit_no_charset:
  fseek(fp, 0, SEEK_SET);
  *fcharset = '\0';
-  tfree(line);
+  taosTFree(line);
  return;
 }
@@ -1860,9 +1860,9 @@ static void taosMallocSQLFiles()
 static void taosFreeSQLFiles()
 {
  for (int i = 0; i < tsSqlFileNum; i++) {
-    tfree(tsDumpInSqlFiles[i]);
+    taosTFree(tsDumpInSqlFiles[i]);
  }
-  tfree(tsDumpInSqlFiles);
+  taosTFree(tsDumpInSqlFiles);
 }
 static void taosGetDirectoryFileList(char *inputDir)
@@ -2063,17 +2063,17 @@ int taosDumpInOneFile_old(TAOS     * taos, FILE* fp, char* fcharset, char* encod
  }
  if (cd != ((iconv_t)(-1))) iconv_close(cd);
-  tfree(line);
+  taosTFree(line);
-  tfree(command);
+  taosTFree(command);
-  tfree(lcommand);
+  taosTFree(lcommand);
  taos_close(taos);
  fclose(fp);
  return 0;
 _dumpin_exit_failure:
  if (cd != ((iconv_t)(-1))) iconv_close(cd);
-  tfree(command);
+  taosTFree(command);
-  tfree(lcommand);
+  taosTFree(lcommand);
  taos_close(taos);
  fclose(fp);
  return -1;
@@ -2120,8 +2120,8 @@ int taosDumpInOneFile(TAOS     * taos, FILE* fp, char* fcharset, char* encode, c
    cmd_len = 0;
  }
-  tfree(cmd);
+  taosTFree(cmd);
-  tfree(line);
+  taosTFree(line);
  fclose(fp);
  return 0;
 }

--- a/src/kit/taosmigrate/taosmigrateVnodeCfg.c
+++ b/src/kit/taosmigrate/taosmigrateVnodeCfg.c
@@ -289,7 +289,7 @@ static int32_t readVnodeCfg(SVnodeObj *pVnode, char* cfgFile)
  //}
 PARSE_OVER:
-  tfree(content);
+  taosTFree(content);
  cJSON_Delete(root);
  if (fp) fclose(fp);
  return ret;

--- a/src/mnode/src/mnodeAcct.c
+++ b/src/mnode/src/mnodeAcct.c
@@ -16,7 +16,6 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 #include "taoserror.h"
-#include "ttime.h"
 #include "dnode.h"
 #include "mnodeDef.h"
 #include "mnodeInt.h"
@@ -34,7 +33,7 @@ static int32_t mnodeCreateRootAcct();
 static int32_t mnodeAcctActionDestroy(SSdbOper *pOper) {
  SAcctObj *pAcct = pOper->pObj;
  pthread_mutex_destroy(&pAcct->mutex);
-  tfree(pOper->pObj);
+  taosTFree(pOper->pObj);
  return TSDB_CODE_SUCCESS;
 }

--- a/src/mnode/src/mnodeCluster.c
+++ b/src/mnode/src/mnodeCluster.c
@@ -16,7 +16,6 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 #include "taoserror.h"
-#include "ttime.h"
 #include "dnode.h"
 #include "mnodeDef.h"
 #include "mnodeInt.h"
@@ -34,7 +33,7 @@ static int32_t mnodeGetClusterMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *
 static int32_t mnodeRetrieveClusters(SShowObj *pShow, char *data, int32_t rows, void *pConn);
 static int32_t mnodeClusterActionDestroy(SSdbOper *pOper) {
-  tfree(pOper->pObj);
+  taosTFree(pOper->pObj);
  return TSDB_CODE_SUCCESS;
 }

--- a/src/mnode/src/mnodeDb.c
+++ b/src/mnode/src/mnodeDb.c
@@ -19,7 +19,6 @@
 #include "tutil.h"
 #include "tgrant.h"
 #include "tglobal.h"
-#include "ttime.h"
 #include "tname.h"
 #include "tbalance.h"
 #include "tdataformat.h"
@@ -53,8 +52,8 @@ static int32_t mnodeProcessDropDbMsg(SMnodeMsg *pMsg);
 static void mnodeDestroyDb(SDbObj *pDb) {
  pthread_mutex_destroy(&pDb->mutex);
-  tfree(pDb->vgList);
+  taosTFree(pDb->vgList);
-  tfree(pDb);
+  taosTFree(pDb);
 }
 static int32_t mnodeDbActionDestroy(SSdbOper *pOper) {
@@ -386,7 +385,7 @@ static int32_t mnodeCreateDb(SAcctObj *pAcct, SCMCreateDbMsg *pCreate, void *pMs
  code = mnodeCheckDbCfg(&pDb->cfg);
  if (code != TSDB_CODE_SUCCESS) {
-    tfree(pDb);
+    taosTFree(pDb);
    return code;
  }

--- a/src/mnode/src/mnodeDnode.c
+++ b/src/mnode/src/mnodeDnode.c
@@ -19,7 +19,6 @@
 #include "tbalance.h"
 #include "tglobal.h"
 #include "tconfig.h"
-#include "ttime.h"
 #include "tutil.h"
 #include "tsocket.h"
 #include "tbalance.h"
@@ -62,7 +61,7 @@ static int32_t mnodeRetrieveDnodes(SShowObj *pShow, char *data, int32_t rows, vo
 static char*   mnodeGetDnodeAlternativeRoleStr(int32_t alternativeRole);
 static int32_t mnodeDnodeActionDestroy(SSdbOper *pOper) {
-  tfree(pOper->pObj);
+  taosTFree(pOper->pObj);
  return TSDB_CODE_SUCCESS;
 }
@@ -504,7 +503,7 @@ static int32_t mnodeCreateDnode(char *ep, SMnodeMsg *pMsg) {
  int32_t code = sdbInsertRow(&oper);
  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
    int dnodeId = pDnode->dnodeId;
-    tfree(pDnode);
+    taosTFree(pDnode);
    mError("failed to create dnode:%d, reason:%s", dnodeId, tstrerror(code));
  } else {
    mLInfo("dnode:%d is created", pDnode->dnodeId);

--- a/src/mnode/src/mnodeMnode.c
+++ b/src/mnode/src/mnodeMnode.c
@@ -21,7 +21,6 @@
 #include "tsync.h"
 #include "tbalance.h"
 #include "tutil.h"
-#include "ttime.h"
 #include "tsocket.h"
 #include "tdataformat.h"
 #include "mnodeDef.h"
@@ -57,7 +56,7 @@ static int32_t mnodeRetrieveMnodes(SShowObj *pShow, char *data, int32_t rows, vo
 #endif
 static int32_t mnodeMnodeActionDestroy(SSdbOper *pOper) {
-  tfree(pOper->pObj);
+  taosTFree(pOper->pObj);
  return TSDB_CODE_SUCCESS;
 }
@@ -279,7 +278,7 @@ int32_t mnodeAddMnode(int32_t dnodeId) {
  int32_t code = sdbInsertRow(&oper);
  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
-    tfree(pMnode);
+    taosTFree(pMnode);
  }
  mnodeUpdateMnodeEpSet();

--- a/src/mnode/src/mnodeProfile.c
+++ b/src/mnode/src/mnodeProfile.c
@@ -18,7 +18,6 @@
 #include "taosmsg.h"
 #include "taoserror.h"
 #include "tutil.h"
-#include "ttime.h"
 #include "tcache.h"
 #include "tglobal.h"
 #include "tdataformat.h"
@@ -133,8 +132,8 @@ SConnObj *mnodeAccquireConn(int32_t connId, char *user, uint32_t ip, uint16_t po
 static void mnodeFreeConn(void *data) {
  SConnObj *pConn = data;
-  tfree(pConn->pQueries);
+  taosTFree(pConn->pQueries);
-  tfree(pConn->pStreams);
+  taosTFree(pConn->pStreams);
  mDebug("connId:%d, is destroyed", pConn->connId);
 }

--- a/src/mnode/src/mnodeSdb.c
+++ b/src/mnode/src/mnodeSdb.c
@@ -934,7 +934,7 @@ void sdbCleanupWriteWorker() {
  }
  sdbFreeWritequeue();
-  tfree(tsSdbPool.writeWorker);
+  taosTFree(tsSdbPool.writeWorker);
  mInfo("sdb write is closed");
 }

--- a/src/mnode/src/mnodeShow.c
+++ b/src/mnode/src/mnodeShow.c
@@ -403,7 +403,7 @@ static void mnodeFreeShowObj(void *data) {
  sdbFreeIter(pShow->pIter);
  mDebug("%p, show is destroyed, data:%p index:%d", pShow, data, pShow->index);
-  tfree(pShow);
+  taosTFree(pShow);
 }
 static void mnodeReleaseShowObj(SShowObj *pShow, bool forceRemove) {

--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -16,7 +16,6 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 #include "taosmsg.h"
-#include "ttime.h"
 #include "tutil.h"
 #include "taoserror.h"
 #include "taosmsg.h"
@@ -90,10 +89,10 @@ static void    mnodeProcessAlterTableRsp(SRpcMsg *rpcMsg);
 static int32_t mnodeFindSuperTableColumnIndex(SSuperTableObj *pStable, char *colName);
 static void mnodeDestroyChildTable(SChildTableObj *pTable) {
-  tfree(pTable->info.tableId);
+  taosTFree(pTable->info.tableId);
-  tfree(pTable->schema);
+  taosTFree(pTable->schema);
-  tfree(pTable->sql);
+  taosTFree(pTable->sql);
-  tfree(pTable);
+  taosTFree(pTable);
 }
 static int32_t mnodeChildTableActionDestroy(SSdbOper *pOper) {
@@ -411,9 +410,9 @@ static void mnodeDestroySuperTable(SSuperTableObj *pStable) {
    taosHashCleanup(pStable->vgHash);
    pStable->vgHash = NULL;
  }
-  tfree(pStable->info.tableId);
+  taosTFree(pStable->info.tableId);
-  tfree(pStable->schema);
+  taosTFree(pStable->schema);
-  tfree(pStable);
+  taosTFree(pStable);
 }
 static int32_t mnodeSuperTableActionDestroy(SSdbOper *pOper) {

--- a/src/mnode/src/mnodeUser.c
+++ b/src/mnode/src/mnodeUser.c
@@ -16,7 +16,6 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 #include "trpc.h"
-#include "ttime.h"
 #include "tutil.h"
 #include "tglobal.h"
 #include "tgrant.h"
@@ -43,7 +42,7 @@ static int32_t mnodeProcessDropUserMsg(SMnodeMsg *pMsg);
 static int32_t mnodeProcessAuthMsg(SMnodeMsg *pMsg);
 static int32_t mnodeUserActionDestroy(SSdbOper *pOper) {
-  tfree(pOper->pObj);
+  taosTFree(pOper->pObj);
  return TSDB_CODE_SUCCESS;
 }
@@ -239,7 +238,7 @@ int32_t mnodeCreateUser(SAcctObj *pAcct, char *name, char *pass, void *pMsg) {
  code = sdbInsertRow(&oper);
  if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_MND_ACTION_IN_PROGRESS) {
    mError("user:%s, failed to create by %s, reason:%s", pUser->user, mnodeGetUserFromMsg(pMsg), tstrerror(code));
-    tfree(pUser);
+    taosTFree(pUser);
  } else {
    mLInfo("user:%s, is created by %s", pUser->user, mnodeGetUserFromMsg(pMsg));
  }

--- a/src/mnode/src/mnodeVgroup.c
+++ b/src/mnode/src/mnodeVgroup.c
@@ -20,7 +20,6 @@
 #include "tsocket.h"
 #include "tidpool.h"
 #include "tsync.h"
-#include "ttime.h"
 #include "tbalance.h"
 #include "tglobal.h"
 #include "tdataformat.h"
@@ -70,7 +69,7 @@ static void mnodeDestroyVgroup(SVgObj *pVgroup) {
    pVgroup->idPool = NULL;
  }
-  tfree(pVgroup);
+  taosTFree(pVgroup);
 }
 static int32_t mnodeVgroupActionDestroy(SSdbOper *pOper) {

--- a/src/os/CMakeLists.txt
+++ b/src/os/CMakeLists.txt
@@ -6,11 +6,11 @@ IF (TD_LINUX_64)
 ELSEIF (TD_LINUX_32)
  ADD_SUBDIRECTORY(src/linux32)
 ELSEIF (TD_DARWIN_64)
-  ADD_SUBDIRECTORY(src/darwin64)  
+  ADD_SUBDIRECTORY(src/darwin)  
 ELSEIF (TD_WINDOWS_64)
-  ADD_SUBDIRECTORY(src/windows64)
+  ADD_SUBDIRECTORY(src/windows)
 ELSEIF (TD_WINDOWS_32)
-  ADD_SUBDIRECTORY(src/windows32)
+  ADD_SUBDIRECTORY(src/windows)
 ENDIF ()
 ADD_SUBDIRECTORY(src/detail)
--- a/src/os/inc/os.h
+++ b/src/os/inc/os.h
@@ -21,7 +21,7 @@ extern "C" {
 #endif
 #ifdef _TD_DARWIN_64
-#include "osDarwin64.h"
+#include "osDarwin.h"
 #endif
 #ifdef _TD_LINUX_64
@@ -36,15 +36,26 @@ extern "C" {
 #include "osAlpine.h"
 #endif
-#ifdef _TD_WINDOWS_64
+#if defined(_TD_WINDOWS_64) || defined(_TD_WINDOWS_32)
-#include "osWindows64.h"
+#include "osWindows.h"
 #endif
-#ifdef _TD_WINDOWS_32
+#include "osAtomic.h"
-#include "osWindows32.h"
+#include "osDef.h"
-#endif
+#include "osDir.h"
+#include "osFile.h"
+#include "osLz4.h"
+#include "osMath.h"
+#include "osMemory.h"
+#include "osRand.h"
+#include "osSemphone.h"
+#include "osSocket.h"
+#include "osString.h"
+#include "osSysinfo.h"
+#include "osTime.h"
+#include "osTimer.h"
-#include "osSpec.h"
+void osInit();
 #ifdef __cplusplus
 }

--- a/src/os/inc/osSpec.h
+++ b/src/os/inc/osSpec.h
@@ -13,137 +13,13 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
-#ifndef TDENGINE_OS_SPEC_H
+#ifndef TDENGINE_OS_ATOMIC_H
-#define TDENGINE_OS_SPEC_H
+#define TDENGINE_OS_ATOMIC_H
 #ifdef __cplusplus
 extern "C" {
 #endif
-#define tclose(x) taosCloseSocket(x)
-#define tfree(x)         \
-  do {                   \
-    if (x) {             \
-      free((void *)(x)); \
-      x = 0;             \
-    }                    \
-  } while (0);
-#define tstrncpy(dst, src, size)   \
-  do {                             \
-    strncpy((dst), (src), (size)); \
-    (dst)[(size)-1] = 0;           \
-  } while (0);
-#ifndef STDERR_FILENO
-#define STDERR_FILENO (2)
-#endif
-#define FD_VALID(x) ((x) > STDERR_FILENO)
-#define FD_INITIALIZER  ((int32_t)-1)
-#define WCHAR wchar_t
-#define POINTER_SHIFT(p, b) ((void *)((char *)(p) + (b)))
-#define POINTER_DISTANCE(p1, p2) ((char *)(p1) - (char *)(p2)) 
-#ifndef NDEBUG
-#define ASSERT(x) assert(x)
-#else
-#define ASSERT(x)
-#endif
-#ifdef UNUSED
-#undefine UNUSED
-#endif
-#define UNUSED(x) ((void)(x))
-#ifdef UNUSED_FUNC
-#undefine UNUSED_FUNC
-#endif
-#ifdef UNUSED_PARAM
-#undef UNUSED_PARAM
-#endif
-#if defined(__GNUC__)
-#define UNUSED_PARAM(x) _UNUSED##x __attribute__((unused))
-#define UNUSED_FUNC __attribute__((unused))
-#else
-#define UNUSED_PARAM(x) x
-#define UNUSED_FUNC
-#endif
-#ifdef tListLen
-#undefine tListLen
-#endif
-#define tListLen(x) (sizeof(x) / sizeof((x)[0]))
-#if defined(__GNUC__)
-#define FORCE_INLINE inline __attribute__((always_inline))
-#else
-#define FORCE_INLINE
-#endif
-#define DEFAULT_UNICODE_ENCODEC "UCS-4LE"
-#define DEFAULT_COMP(x, y)       \
-  do {                           \
-    if ((x) == (y)) {            \
-      return 0;                  \
-    } else {                     \
-      return (x) < (y) ? -1 : 1; \
-    }                            \
-  } while (0)
-#define ALIGN_NUM(n, align) (((n) + ((align)-1)) & (~((align)-1)))
-// align to 8bytes
-#define ALIGN8(n) ALIGN_NUM(n, 8)
-#define POW2(x) ((x) * (x))
-#ifndef TAOS_OS_FUNC_MATH
-  #define SWAP(a, b, c)        \
-    do {                       \
-        typeof(a) __tmp = (a); \
-        (a) = (b);             \
-        (b) = __tmp;           \
-    } while (0)
-  #define MAX(a, b)              \
-    ({                           \
-        typeof(a) __a = (a);     \
-        typeof(b) __b = (b);     \
-        (__a > __b) ? __a : __b; \
-    })
-  #define MIN(a, b)              \
-    ({                           \
-        typeof(a) __a = (a);     \
-        typeof(b) __b = (b);     \
-        (__a < __b) ? __a : __b; \
-    })
-#endif
-#ifndef TAOS_OS_DEF_TIME
-  #define MILLISECOND_PER_SECOND ((int64_t)1000L)
-#endif
-#define MILLISECOND_PER_MINUTE (MILLISECOND_PER_SECOND * 60)
-#define MILLISECOND_PER_HOUR   (MILLISECOND_PER_MINUTE * 60)
-#define MILLISECOND_PER_DAY    (MILLISECOND_PER_HOUR * 24)
-#define MILLISECOND_PER_WEEK   (MILLISECOND_PER_DAY * 7)
-#define MILLISECOND_PER_MONTH  (MILLISECOND_PER_DAY * 30)
-#define MILLISECOND_PER_YEAR   (MILLISECOND_PER_DAY * 365)
-#ifndef TAOS_OS_FUNC_SEMPHONE
-  #define tsem_t sem_t
-  #define tsem_init sem_init
-  #define tsem_wait sem_wait
-  #define tsem_post sem_post
-  #define tsem_destroy sem_destroy
-#endif
 #ifndef TAOS_OS_FUNC_ATOMIC
  #define atomic_load_8(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
  #define atomic_load_16(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
@@ -230,160 +106,6 @@ extern "C" {
  #define atomic_fetch_xor_ptr(ptr, val) __atomic_fetch_xor((ptr), (val), __ATOMIC_SEQ_CST)
 #endif
-ssize_t taosTReadImp(int fd, void *buf, size_t count);
-ssize_t taosTWriteImp(int fd, void *buf, size_t count);
-ssize_t taosTSendFileImp(int dfd, int sfd, off_t *offset, size_t size);
-#ifndef TAOS_OS_FUNC_FILE_OP
-  #define taosTRead(fd, buf, count) taosTReadImp(fd, buf, count)
-  #define taosTWrite(fd, buf, count) taosTWriteImp(fd, buf, count)
-  #define taosLSeek(fd, offset, whence) lseek(fd, offset, whence)
-  #define taosTSendFile(dfd, sfd, offset, size) taosTSendFileImp(dfd, sfd, offset, size)
-#endif
-#ifndef TAOS_OS_FUNC_NETWORK
-  #define taosSend(sockfd, buf, len, flags) send(sockfd, buf, len, flags)
-  #define taosSendto(sockfd, buf, len, flags, dest_addr, addrlen) sendto(sockfd, buf, len, flags, dest_addr, addrlen)
-  #define taosReadSocket(fd, buf, len) read(fd, buf, len)
-  #define taosWriteSocket(fd, buf, len) write(fd, buf, len)
-  #define taosCloseSocket(x) \
-    {                        \
-      if (FD_VALID(x)) {     \
-        close(x);            \
-        x = FD_INITIALIZER;  \
-      }                      \
-    }
-#endif
-#ifndef TAOS_OS_FUNC_LZ4
-  #define BUILDIN_CLZL(val) __builtin_clzl(val)
-  #define BUILDIN_CTZL(val) __builtin_ctzl(val)
-  #define BUILDIN_CLZ(val) __builtin_clz(val)
-  #define BUILDIN_CTZ(val) __builtin_ctz(val)
-#endif
-#ifndef TAOS_OS_FUNC_WCHAR
-  #define twcslen wcslen
-#endif  
-#undef threadlocal
-#ifdef _ISOC11_SOURCE
-  #define threadlocal _Thread_local
-#elif defined(__APPLE__)
-  #define threadlocal
-#elif defined(__GNUC__) && !defined(threadlocal)
-  #define threadlocal __thread
-#else
-  #define threadlocal
-#endif
-void osInit();
-// TAOS_OS_FUNC_PTHREAD
-bool taosCheckPthreadValid(pthread_t thread);
-int64_t taosGetPthreadId();
-// TAOS_OS_FUNC_SOCKET
-int taosSetNonblocking(int sock, int on);
-int taosSetSockOpt(int socketfd, int level, int optname, void *optval, int optlen);
-void taosBlockSIGPIPE();
-// TAOS_OS_FUNC_SYSINFO
-void taosGetSystemInfo();
-void taosPrintOsInfo();
-void taosKillSystem();
-int tSystem(const char * cmd) ;
-// TAOS_OS_FUNC_CORE
-void taosSetCoreDump();
-// TAOS_OS_FUNC_UTIL
-int64_t tsosStr2int64(char *str);
-// TAOS_OS_FUNC_TIMER
-void taosMsleep(int mseconds);
-int taosInitTimer(void (*callback)(int), int ms);
-void taosUninitTimer();
-// TAOS_OS_FUNC_RAND
-uint32_t taosRand(void);
-void taosRandStr(char* str, int32_t size);
-uint32_t trand(void);
-// TAOS_OS_FUNC_FILE
-void getTmpfilePath(const char *fileNamePrefix, char *dstPath);
-int32_t taosFileRename(char *fullPath, char *suffix, char delimiter, char **dstPath);
-// USE_LIBICONV
-int32_t taosUcs4ToMbs(void *ucs4, int32_t ucs4_max_len, char *mbs);
-bool    taosMbsToUcs4(char *mbs, size_t mbs_len, char *ucs4, int32_t ucs4_max_len, size_t *len);
-int     tasoUcs4Compare(void *f1_ucs4, void *f2_ucs4, int bytes);
-bool    taosValidateEncodec(const char *encodec);
-char *  taosCharsetReplace(char *charsetstr);
-// TAOS_OS_FUNC_MALLOC
-#define TAOS_ALLOC_MODE_DEFAULT 0
-#define TAOS_ALLOC_MODE_RANDOM_FAIL 1
-#define TAOS_ALLOC_MODE_DETECT_LEAK 2
-void   taosSetAllocMode(int mode, const char *path, bool autoDump);
-void   taosDumpMemoryLeak();
-void * tmalloc(size_t size);
-void * tcalloc(size_t nmemb, size_t size);
-size_t tsizeof(void *ptr);
-void   tmemset(void *ptr, int c);
-void * trealloc(void *ptr, size_t size);
-void   tzfree(void *ptr);
-// TAOS_OS_FUNC_DIR
-void taosRemoveDir(char *rootDir);
-int  taosMkDir(const char *pathname, mode_t mode); 
-void taosMvDir(char* destDir, char *srcDir);
-#ifdef TAOS_RANDOM_FILE_FAIL
-  void taosSetRandomFileFailFactor(int factor);
-  void taosSetRandomFileFailOutput(const char *path);
-  ssize_t taosReadFileRandomFail(int fd, void *buf, size_t count, const char *file, uint32_t line);
-  ssize_t taosWriteFileRandomFail(int fd, void *buf, size_t count, const char *file, uint32_t line);
-  off_t taosLSeekRandomFail(int fd, off_t offset, int whence, const char *file, uint32_t line);
-  #undef taosTRead
-  #undef taosTWrite
-  #undef taosLSeek
-  #define taosTRead(fd, buf, count) taosReadFileRandomFail(fd, buf, count, __FILE__, __LINE__)
-  #define taosTWrite(fd, buf, count) taosWriteFileRandomFail(fd, buf, count, __FILE__, __LINE__)
-  #define taosLSeek(fd, offset, whence) taosLSeekRandomFail(fd, offset, whence, __FILE__, __LINE__)
-#endif
-#ifdef TAOS_RANDOM_NETWORK_FAIL
-  ssize_t taosSendRandomFail(int sockfd, const void *buf, size_t len, int flags);
-  ssize_t taosSendToRandomFail(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
-  ssize_t taosReadSocketRandomFail(int fd, void *buf, size_t count);
-  ssize_t taosWriteSocketRandomFail(int fd, const void *buf, size_t count);
-  #undef taosSend
-  #undef taosSendto
-  #undef taosReadSocket
-  #undef taosWriteSocket
-  #define taosSend(sockfd, buf, len, flags) taosSendRandomFail(sockfd, buf, len, flags)
-  #define taosSendto(sockfd, buf, len, flags, dest_addr, addrlen) taosSendToRandomFail(sockfd, buf, len, flags, dest_addr, addrlen)
-  #define taosReadSocket(fd, buf, len) taosReadSocketRandomFail(fd, buf, len)
-  #define taosWriteSocket(fd, buf, len) taosWriteSocketRandomFail(fd, buf, len)
-#endif
-#ifdef TAOS_MEM_CHECK
-  void *  taos_malloc(size_t size, const char *file, uint32_t line);
-  void *  taos_calloc(size_t num, size_t size, const char *file, uint32_t line);
-  void *  taos_realloc(void *ptr, size_t size, const char *file, uint32_t line);
-  void    taos_free(void *ptr, const char *file, uint32_t line);
-  char *  taos_strdup(const char *str, const char *file, uint32_t line);
-  char *  taos_strndup(const char *str, size_t size, const char *file, uint32_t line);
-  ssize_t taos_getline(char **lineptr, size_t *n, FILE *stream, const char *file, uint32_t line);
-  #define malloc(size) taos_malloc(size, __FILE__, __LINE__)
-  #define calloc(num, size) taos_calloc(num, size, __FILE__, __LINE__)
-  #define realloc(ptr, size) taos_realloc(ptr, size, __FILE__, __LINE__)
-  #define free(ptr) taos_free(ptr, __FILE__, __LINE__)
-  #define strdup(str) taos_strdup(str, __FILE__, __LINE__)
-  #define strndup(str, size) taos_strndup(str, size, __FILE__, __LINE__)
-  #define getline(lineptr, n, stream) taos_getline(lineptr, n, stream, __FILE__, __LINE__)
-#endif  // TAOS_MEM_CHECK
 #ifdef __cplusplus
 }
 #endif

--- a/src/os/inc/osDarwin.h
+++ b/src/os/inc/osDarwin.h
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TDENGINE_PLATFORM_LINUX_H
+#define TDENGINE_PLATFORM_LINUX_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <arpa/inet.h>
+#include <assert.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <float.h>
+#include <ifaddrs.h>
+#include <libgen.h>
+#include <limits.h>
+#include <locale.h>
+#include <math.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/tcp.h>
+#include <netinet/udp.h>
+#include <pthread.h>
+#include <pwd.h>
+#include <regex.h>
+#include <semaphore.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/file.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/statvfs.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <sys/un.h>
+#include <syslog.h>
+#include <termios.h>
+#include <unistd.h>
+#include <wchar.h>
+#include <wordexp.h>
+#include <wctype.h>
+#include <inttypes.h>
+#include <dispatch/dispatch.h>
+#include <fcntl.h>
+#include <sys/utsname.h>
+#define TAOS_OS_FUNC_FILE_SENDIFLE
+  #define taosFSendFile(outfile, infile, offset, count) taosFSendFileImp(outfile, infile, offset, size)
+  #define taosTSendFile(dfd, sfd, offset, size) taosTSendFileImp(dfd, sfd, offset, size)
+#define TAOS_OS_FUNC_SEMPHONE
+  #define tsem_t dispatch_semaphore_t
+  int tsem_init(dispatch_semaphore_t *sem, int pshared, unsigned int value);
+  int tsem_wait(dispatch_semaphore_t *sem);
+  int tsem_post(dispatch_semaphore_t *sem);
+  int tsem_destroy(dispatch_semaphore_t *sem);
+#define TAOS_OS_FUNC_SOCKET_SETSOCKETOPT
+#define TAOS_OS_FUNC_STRING_STR2INT64
+#define TAOS_OS_FUNC_SYSINFO
+#define TAOS_OS_FUNC_TIMER
+// specific
+#define htobe64 htonll
+typedef int(*__compar_fn_t)(const void *, const void *);
+// for send function in tsocket.c
+#define MSG_NOSIGNAL             0
+#define SO_NO_CHECK              0x1234
+#define SOL_TCP                  0x1234
+#define TCP_KEEPIDLE             0x1234
+#ifndef PTHREAD_MUTEX_RECURSIVE_NP
+  #define  PTHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
--- a/src/os/inc/osDarwin64.h
+++ b/src/os/inc/osDarwin64.h
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-#ifndef TDENGINE_PLATFORM_LINUX_H
-#define TDENGINE_PLATFORM_LINUX_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include <stdio.h>
-#include <stdlib.h>
-#include <arpa/inet.h>
-#include <assert.h>
-#include <ctype.h>
-#include <dirent.h>
-#include <errno.h>
-#include <float.h>
-#include <ifaddrs.h>
-#include <libgen.h>
-#include <limits.h>
-#include <locale.h>
-#include <math.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <netinet/ip.h>
-#include <netinet/tcp.h>
-#include <netinet/udp.h>
-#include <pthread.h>
-#include <pwd.h>
-#include <regex.h>
-#include <semaphore.h>
-#include <signal.h>
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-#include <strings.h>
-#include <sys/file.h>
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/syscall.h>
-#include <sys/statvfs.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/uio.h>
-#include <sys/un.h>
-#include <syslog.h>
-#include <termios.h>
-#include <unistd.h>
-#include <wchar.h>
-#include <wordexp.h>
-#include <wctype.h>
-#include <inttypes.h>
-#include <dispatch/dispatch.h>
-#include <fcntl.h>
-#include <sys/utsname.h>
-#define htobe64 htonll
-#define taosCloseSocket(x) \
-  {                        \
-    if (FD_VALID(x)) {     \
-      close(x);            \
-      x = FD_INITIALIZER;  \
-    }                      \
-  }
-#define taosWriteSocket(fd, buf, len) write(fd, buf, len)
-#define taosReadSocket(fd, buf, len) read(fd, buf, len)
-#define atomic_load_8(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
-#define atomic_load_16(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
-#define atomic_load_32(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
-#define atomic_load_64(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
-#define atomic_load_ptr(ptr) __atomic_load_n((ptr), __ATOMIC_SEQ_CST)
-#define atomic_store_8(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_store_16(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_store_32(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_store_64(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_store_ptr(ptr, val) __atomic_store_n((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_exchange_8(ptr, val) __atomic_exchange_n((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_exchange_16(ptr, val) __atomic_exchange_n((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_exchange_32(ptr, val) __atomic_exchange_n((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_exchange_64(ptr, val) __atomic_exchange_n((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_exchange_ptr(ptr, val) __atomic_exchange_n((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_val_compare_exchange_8 __sync_val_compare_and_swap
-#define atomic_val_compare_exchange_16 __sync_val_compare_and_swap
-#define atomic_val_compare_exchange_32 __sync_val_compare_and_swap
-#define atomic_val_compare_exchange_64 __sync_val_compare_and_swap
-#define atomic_val_compare_exchange_ptr __sync_val_compare_and_swap
-#define atomic_add_fetch_8(ptr, val) __atomic_add_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_add_fetch_16(ptr, val) __atomic_add_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_add_fetch_32(ptr, val) __atomic_add_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_add_fetch_64(ptr, val) __atomic_add_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_add_fetch_ptr(ptr, val) __atomic_add_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_add_8(ptr, val) __atomic_fetch_add((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_add_16(ptr, val) __atomic_fetch_add((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_add_32(ptr, val) __atomic_fetch_add((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_add_64(ptr, val) __atomic_fetch_add((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_add_ptr(ptr, val) __atomic_fetch_add((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_sub_fetch_8(ptr, val) __atomic_sub_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_sub_fetch_16(ptr, val) __atomic_sub_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_sub_fetch_32(ptr, val) __atomic_sub_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_sub_fetch_64(ptr, val) __atomic_sub_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_sub_fetch_ptr(ptr, val) __atomic_sub_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_sub_8(ptr, val) __atomic_fetch_sub((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_sub_16(ptr, val) __atomic_fetch_sub((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_sub_32(ptr, val) __atomic_fetch_sub((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_sub_64(ptr, val) __atomic_fetch_sub((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_sub_ptr(ptr, val) __atomic_fetch_sub((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_and_fetch_8(ptr, val) __atomic_and_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_and_fetch_16(ptr, val) __atomic_and_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_and_fetch_32(ptr, val) __atomic_and_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_and_fetch_64(ptr, val) __atomic_and_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_and_fetch_ptr(ptr, val) __atomic_and_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_and_8(ptr, val) __atomic_fetch_and((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_and_16(ptr, val) __atomic_fetch_and((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_and_32(ptr, val) __atomic_fetch_and((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_and_64(ptr, val) __atomic_fetch_and((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_and_ptr(ptr, val) __atomic_fetch_and((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_or_fetch_8(ptr, val) __atomic_or_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_or_fetch_16(ptr, val) __atomic_or_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_or_fetch_32(ptr, val) __atomic_or_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_or_fetch_64(ptr, val) __atomic_or_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_or_fetch_ptr(ptr, val) __atomic_or_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_or_8(ptr, val) __atomic_fetch_or((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_or_16(ptr, val) __atomic_fetch_or((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_or_32(ptr, val) __atomic_fetch_or((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_or_64(ptr, val) __atomic_fetch_or((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_or_ptr(ptr, val) __atomic_fetch_or((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_xor_fetch_8(ptr, val) __atomic_xor_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_xor_fetch_16(ptr, val) __atomic_xor_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_xor_fetch_32(ptr, val) __atomic_xor_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_xor_fetch_64(ptr, val) __atomic_xor_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_xor_fetch_ptr(ptr, val) __atomic_xor_fetch((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_xor_8(ptr, val) __atomic_fetch_xor((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_xor_16(ptr, val) __atomic_fetch_xor((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_xor_32(ptr, val) __atomic_fetch_xor((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_xor_64(ptr, val) __atomic_fetch_xor((ptr), (val), __ATOMIC_SEQ_CST)
-#define atomic_fetch_xor_ptr(ptr, val) __atomic_fetch_xor((ptr), (val), __ATOMIC_SEQ_CST)
-#define SWAP(a, b, c)      \
-  do {                     \
-    typeof(a) __tmp = (a); \
-    (a) = (b);             \
-    (b) = __tmp;           \
-  } while (0)
-#define MAX(a, b)            \
-  ({                         \
-    typeof(a) __a = (a);     \
-    typeof(b) __b = (b);     \
-    (__a > __b) ? __a : __b; \
-  })
-#define MIN(a, b)            \
-  ({                         \
-    typeof(a) __a = (a);     \
-    typeof(b) __b = (b);     \
-    (__a < __b) ? __a : __b; \
-  })
-#define MILLISECOND_PER_SECOND ((int64_t)1000L)
-#define tsem_t dispatch_semaphore_t
-int tsem_init(dispatch_semaphore_t *sem, int pshared, unsigned int value);
-int tsem_wait(dispatch_semaphore_t *sem);
-int tsem_post(dispatch_semaphore_t *sem);
-int tsem_destroy(dispatch_semaphore_t *sem);
-void osInit();
-ssize_t tread(int fd, void *buf, size_t count);
-ssize_t twrite(int fd, void *buf, size_t n);
-bool taosCheckPthreadValid(pthread_t thread);
-void taosResetPthread(pthread_t *thread);
-int64_t taosGetPthreadId();
-int taosSetNonblocking(int sock, int on);
-int taosSetSockOpt(int socketfd, int level, int optname, void *optval, int optlen);
-void taosPrintOsInfo();
-void taosPrintOsInfo();
-void taosGetSystemInfo();
-void taosKillSystem();
-bool taosSkipSocketCheck();
-bool taosGetDisk();
-int fsendfile(FILE* out_file, FILE* in_file, int64_t* offset, int32_t count);
-void taosSetCoreDump();
-int tSystem(const char * cmd);
-typedef int(*__compar_fn_t)(const void *, const void *);
-// for send function in tsocket.c
-#define MSG_NOSIGNAL             0
-#define SO_NO_CHECK              0x1234
-#define SOL_TCP                  0x1234
-#define TCP_KEEPIDLE             0x1234
-#ifndef PTHREAD_MUTEX_RECURSIVE_NP
-  #define  PTHREAD_MUTEX_RECURSIVE_NP PTHREAD_MUTEX_RECURSIVE
-#endif
-#ifndef _TD_ARM_32_
-#define BUILDIN_CLZL(val) __builtin_clzl(val)
-#define BUILDIN_CTZL(val) __builtin_ctzl(val)
-#else
-#define BUILDIN_CLZL(val) __builtin_clzll(val)
-#define BUILDIN_CTZL(val) __builtin_ctzll(val)
-#endif
-#define BUILDIN_CLZ(val)  __builtin_clz(val)
-#define BUILDIN_CTZ(val)  __builtin_ctz(val)
-#undef threadlocal
-#ifdef _ISOC11_SOURCE
-  #define threadlocal _Thread_local
-#elif defined(__APPLE__)
-  #define threadlocal
-#elif defined(__GNUC__) && !defined(threadlocal)
-  #define threadlocal __thread
-#else
-  #define threadlocal
-#endif
-#ifdef __cplusplus
-}
-#endif
-#endif
--- a/src/os/inc/osDef.h
+++ b/src/os/inc/osDef.h
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TDENGINE_OS_DEF_H
+#define TDENGINE_OS_DEF_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifndef STDERR_FILENO
+#define STDERR_FILENO (2)
+#endif
+#define FD_VALID(x) ((x) > STDERR_FILENO)
+#define FD_INITIALIZER  ((int32_t)-1)
+#define WCHAR wchar_t
+#define POINTER_SHIFT(p, b) ((void *)((char *)(p) + (b)))
+#define POINTER_DISTANCE(p1, p2) ((char *)(p1) - (char *)(p2)) 
+#ifndef NDEBUG
+#define ASSERT(x) assert(x)
+#else
+#define ASSERT(x)
+#endif
+#ifdef UNUSED
+#undefine UNUSED
+#endif
+#define UNUSED(x) ((void)(x))
+#ifdef UNUSED_FUNC
+#undefine UNUSED_FUNC
+#endif
+#ifdef UNUSED_PARAM
+#undef UNUSED_PARAM
+#endif
+#if defined(__GNUC__)
+#define UNUSED_PARAM(x) _UNUSED##x __attribute__((unused))
+#define UNUSED_FUNC __attribute__((unused))
+#else
+#define UNUSED_PARAM(x) x
+#define UNUSED_FUNC
+#endif
+#ifdef tListLen
+#undefine tListLen
+#endif
+#define tListLen(x) (sizeof(x) / sizeof((x)[0]))
+#if defined(__GNUC__)
+#define FORCE_INLINE inline __attribute__((always_inline))
+#else
+#define FORCE_INLINE
+#endif
+#define DEFAULT_UNICODE_ENCODEC "UCS-4LE"
+#define DEFAULT_COMP(x, y)       \
+  do {                           \
+    if ((x) == (y)) {            \
+      return 0;                  \
+    } else {                     \
+      return (x) < (y) ? -1 : 1; \
+    }                            \
+  } while (0)
+#define ALIGN_NUM(n, align) (((n) + ((align)-1)) & (~((align)-1)))
+// align to 8bytes
+#define ALIGN8(n) ALIGN_NUM(n, 8)
+#undef threadlocal
+#ifdef _ISOC11_SOURCE
+  #define threadlocal _Thread_local
+#elif defined(__APPLE__)
+  #define threadlocal
+#elif defined(__GNUC__) && !defined(threadlocal)
+  #define threadlocal __thread
+#else
+  #define threadlocal
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
--- a/src/os/inc/osDir.h
+++ b/src/os/inc/osDir.h
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TDENGINE_OS_DIR_H
+#define TDENGINE_OS_DIR_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+// TAOS_OS_FUNC_DIR
+void taosRemoveDir(char *rootDir);
+int  taosMkDir(const char *pathname, mode_t mode); 
+void taosMvDir(char* destDir, char *srcDir);
+#ifdef __cplusplus
+}
+#endif
+#endif
--- a/src/os/inc/osFile.h
+++ b/src/os/inc/osFile.h
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TDENGINE_OS_FILE_H
+#define TDENGINE_OS_FILE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+ssize_t taosTReadImp(int fd, void *buf, size_t count);
+ssize_t taosTWriteImp(int fd, void *buf, size_t count);
+ssize_t taosTSendFileImp(int dfd, int sfd, off_t *offset, size_t size);
+int     taosFSendFileImp(FILE* out_file, FILE* in_file, int64_t* offset, int32_t count);
+#ifndef TAOS_OS_FUNC_FILE_SENDIFLE
+  #define taosTSendFile(dfd, sfd, offset, size) taosTSendFileImp(dfd, sfd, offset, size)
+  #define taosFSendFile(outfile, infile, offset, count) taosTSendFileImp(fileno(outfile), fileno(infile), offset, size)
+#endif
+#define taosTRead(fd, buf, count) taosTReadImp(fd, buf, count)
+#define taosTWrite(fd, buf, count) taosTWriteImp(fd, buf, count)
+#define taosLSeek(fd, offset, whence) lseek(fd, offset, whence)
+#ifdef TAOS_RANDOM_FILE_FAIL
+  void taosSetRandomFileFailFactor(int factor);
+  void taosSetRandomFileFailOutput(const char *path);
+  #ifdef TAOS_RANDOM_FILE_FAIL_TEST
+    ssize_t taosReadFileRandomFail(int fd, void *buf, size_t count, const char *file, uint32_t line);
+    ssize_t taosWriteFileRandomFail(int fd, void *buf, size_t count, const char *file, uint32_t line);
+    off_t taosLSeekRandomFail(int fd, off_t offset, int whence, const char *file, uint32_t line);
+    #undef taosTRead
+    #undef taosTWrite
+    #undef taosLSeek
+    #define taosTRead(fd, buf, count) taosReadFileRandomFail(fd, buf, count, __FILE__, __LINE__)
+    #define taosTWrite(fd, buf, count) taosWriteFileRandomFail(fd, buf, count, __FILE__, __LINE__)
+    #define taosLSeek(fd, offset, whence) taosLSeekRandomFail(fd, offset, whence, __FILE__, __LINE__)
+  #endif  
+#endif 
+int32_t taosFileRename(char *fullPath, char *suffix, char delimiter, char **dstPath);
+// TAOS_OS_FUNC_FILE_GETTMPFILEPATH
+void taosGetTmpfilePath(const char *fileNamePrefix, char *dstPath);
+#ifdef __cplusplus
+}
+#endif
+#endif
--- a/src/os/inc/osLinux32.h
+++ b/src/os/inc/osLinux32.h
@@ -22,7 +22,6 @@ extern "C" {
 #include <stdio.h>
 #include <stdlib.h>
 #include <argp.h>
 #include <arpa/inet.h>
 #include <assert.h>
@@ -78,6 +77,12 @@ extern "C" {
 #include <sys/resource.h>
 #include <error.h>
+#define TAOS_OS_FUNC_LZ4
+#define BUILDIN_CLZL(val) __builtin_clzll(val)
+#define BUILDIN_CTZL(val) __builtin_ctzll(val)
+#define BUILDIN_CLZ(val) __builtin_clz(val)
+#define BUILDIN_CTZ(val) __builtin_ctz(val)
 #ifdef __cplusplus
 }
 #endif

--- a/src/os/inc/osLz4.h
+++ b/src/os/inc/osLz4.h
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TDENGINE_OS_LZ4_H
+#define TDENGINE_OS_LZ4_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifndef TAOS_OS_FUNC_LZ4
+  #define BUILDIN_CLZL(val) __builtin_clzl(val)
+  #define BUILDIN_CTZL(val) __builtin_ctzl(val)
+  #define BUILDIN_CLZ(val) __builtin_clz(val)
+  #define BUILDIN_CTZ(val) __builtin_ctz(val)
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
--- a/src/os/src/windows64/twintcpclient.c
+++ b/src/os/src/windows64/twintcpclient.c
@@ -13,27 +13,40 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
-#include "tulog.h"
+#ifndef TDENGINE_OS_MATH_H
+#define TDENGINE_OS_MATH_H
-void *taosInitTcpClient(char *ip, uint16_t port, char *label, int num, void *fp, void *shandle) {
+#ifdef __cplusplus
-  tError("InitTcpClient not support in windows");
+extern "C" {
-  return 0;
+#endif
-}
-void taosCloseTcpClientConnection(void *chandle) {
+#define POW2(x) ((x) * (x))
-  tError("CloseTcpClientConnection not support in windows");
-}
-void *taosOpenTcpClientConnection(void *shandle, void *thandle, char *ip, uint16_t port) {
+#ifndef TAOS_OS_FUNC_MATH
-  tError("OpenTcpClientConnection not support in windows");
+  #define SWAP(a, b, c)        \
-  return 0;
+    do {                       \
-}
+        typeof(a) __tmp = (a); \
+        (a) = (b);             \
+        (b) = __tmp;           \
+    } while (0)
-int taosSendTcpClientData(unsigned int ip, uint16_t port, char *data, int len, void *chandle) {
+  #define MAX(a, b)              \
-  tError("SendTcpClientData not support in windows");
+    ({                           \
-  return 0;
+        typeof(a) __a = (a);     \
-}
+        typeof(b) __b = (b);     \
+        (__a > __b) ? __a : __b; \
+    })
+  #define MIN(a, b)              \
+    ({                           \
+        typeof(a) __a = (a);     \
+        typeof(b) __b = (b);     \
+        (__a < __b) ? __a : __b; \
+    })
+#endif
-void taosCleanUpTcpClient(void *chandle) {
+#ifdef __cplusplus
-  tError("SendTcpClientData not support in windows");
 }
+#endif
+#endif
--- a/src/os/inc/osMemory.h
+++ b/src/os/inc/osMemory.h
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TDENGINE_OS_MEMORY_H
+#define TDENGINE_OS_MEMORY_H
+#include "osString.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef enum {
+  TAOS_ALLOC_MODE_DEFAULT = 0,
+  TAOS_ALLOC_MODE_RANDOM_FAIL = 1,
+  TAOS_ALLOC_MODE_DETECT_LEAK = 2
+} ETaosMemoryAllocMode;
+void   taosSetAllocMode(int mode, const char *path, bool autoDump);
+void   taosDumpMemoryLeak();
+void * taosTMalloc(size_t size);
+void * taosTCalloc(size_t nmemb, size_t size);
+void * taosTRealloc(void *ptr, size_t size);
+void   taosTZfree(void *ptr);
+size_t taosTSizeof(void *ptr);
+void   taosTMemset(void *ptr, int c);
+#define taosTFree(x)     \
+  do {                   \
+    if (x) {             \
+      free((void *)(x)); \
+      x = 0;             \
+    }                    \
+  } while (0);
+#define taosMalloc(size) malloc(size)
+#define taosCalloc(num, size) calloc(num, size)
+#define taosRealloc(ptr, size) realloc(ptr, size)
+#define taosFree(ptr) free(ptr)
+#define taosStrdup(str) taosStrdupImp(str)
+#define taosStrndup(str, size) taosStrndupImp(str, size)
+#define taosGetline(lineptr, n, stream) taosGetlineImp(lineptr, n, stream)
+#ifdef TAOS_MEM_CHECK
+  #ifdef TAOS_MEM_CHECK_TEST
+    void *  taos_malloc(size_t size, const char *file, uint32_t line);
+    void *  taos_calloc(size_t num, size_t size, const char *file, uint32_t line);
+    void *  taos_realloc(void *ptr, size_t size, const char *file, uint32_t line);
+    void    taos_free(void *ptr, const char *file, uint32_t line);
+    char *  taos_strdup(const char *str, const char *file, uint32_t line);
+    char *  taos_strndup(const char *str, size_t size, const char *file, uint32_t line);
+    ssize_t taos_getline(char **lineptr, size_t *n, FILE *stream, const char *file, uint32_t line);
+    #undef taosMalloc
+    #undef taosCalloc
+    #undef taosRealloc
+    #undef taosFree
+    #undef taosStrdup
+    #undef taosStrndup
+    #undef taosGetline
+    #define taosMalloc(size) taos_malloc(size, __FILE__, __LINE__)
+    #define taosCalloc(num, size) taos_calloc(num, size, __FILE__, __LINE__)
+    #define taosRealloc(ptr, size) taos_realloc(ptr, size, __FILE__, __LINE__)
+    #define taosFree(ptr) taos_free(ptr, __FILE__, __LINE__)
+    #define taosStrdup(str) taos_strdup(str, __FILE__, __LINE__)
+    #define taosStrndup(str, size) taos_strndup(str, size, __FILE__, __LINE__)
+    #define taosGetline(lineptr, n, stream) taos_getline(lineptr, n, stream, __FILE__, __LINE__)
+  #endif  
+#endif 
+#ifdef __cplusplus
+}
+#endif
+#endif
--- a/src/os/inc/osRand.h
+++ b/src/os/inc/osRand.h
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TDENGINE_OS_RAND_H
+#define TDENGINE_OS_RAND_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+// TAOS_OS_FUNC_RAND
+uint32_t taosRand(void);
+void taosRandStr(char* str, int32_t size);
+uint32_t taosSafeRand(void);
+#ifdef __cplusplus
+}
+#endif
+#endif
--- a/src/os/inc/osSemphone.h
+++ b/src/os/inc/osSemphone.h
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TDENGINE_OS_SEMPHONE_H
+#define TDENGINE_OS_SEMPHONE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifndef TAOS_OS_FUNC_SEMPHONE
+  #define tsem_t sem_t
+  #define tsem_init sem_init
+  #define tsem_wait sem_wait
+  #define tsem_post sem_post
+  #define tsem_destroy sem_destroy
+#endif
+// TAOS_OS_FUNC_SEMPHONE_PTHREAD
+bool taosCheckPthreadValid(pthread_t thread);
+int64_t taosGetPthreadId();
+#ifdef __cplusplus
+}
+#endif
+#endif
--- a/src/os/inc/osSocket.h
+++ b/src/os/inc/osSocket.h
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TDENGINE_OS_SOCKET_H
+#define TDENGINE_OS_SOCKET_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifndef TAOS_OS_FUNC_SOCKET_OP
+  #define taosSend(sockfd, buf, len, flags) send(sockfd, buf, len, flags)
+  #define taosSendto(sockfd, buf, len, flags, dest_addr, addrlen) sendto(sockfd, buf, len, flags, dest_addr, addrlen)
+  #define taosReadSocket(fd, buf, len) read(fd, buf, len)
+  #define taosWriteSocket(fd, buf, len) write(fd, buf, len)
+  #define taosCloseSocket(x) \
+    {                        \
+      if (FD_VALID(x)) {     \
+        close(x);            \
+        x = FD_INITIALIZER;  \
+      }                      \
+    }
+#endif    
+#define taosClose(x) taosCloseSocket(x)
+#ifdef TAOS_RANDOM_NETWORK_FAIL
+  #ifdef TAOS_RANDOM_NETWORK_FAIL_TEST
+    ssize_t taosSendRandomFail(int sockfd, const void *buf, size_t len, int flags);
+    ssize_t taosSendToRandomFail(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
+    ssize_t taosReadSocketRandomFail(int fd, void *buf, size_t count);
+    ssize_t taosWriteSocketRandomFail(int fd, const void *buf, size_t count);
+    #undef taosSend
+    #undef taosSendto
+    #undef taosReadSocket
+    #undef taosWriteSocket
+    #define taosSend(sockfd, buf, len, flags) taosSendRandomFail(sockfd, buf, len, flags)
+    #define taosSendto(sockfd, buf, len, flags, dest_addr, addrlen) taosSendToRandomFail(sockfd, buf, len, flags, dest_addr, addrlen)
+    #define taosReadSocket(fd, buf, len) taosReadSocketRandomFail(fd, buf, len)
+    #define taosWriteSocket(fd, buf, len) taosWriteSocketRandomFail(fd, buf, len)
+  #endif  
+#endif
+// TAOS_OS_FUNC_SOCKET
+int taosSetNonblocking(int sock, int on);
+void taosBlockSIGPIPE();
+// TAOS_OS_FUNC_SOCKET_SETSOCKETOPT
+int taosSetSockOpt(int socketfd, int level, int optname, void *optval, int optlen);
+#ifdef __cplusplus
+}
+#endif
+#endif
--- a/src/os/src/detail/osMalloc.c
+++ b/src/os/src/detail/osMalloc.c
@@ -13,54 +13,47 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
-#define _DEFAULT_SOURCE
+#ifndef TDENGINE_OS_STRING_H
-#include "os.h"
+#define TDENGINE_OS_STRING_H
-#ifndef TAOS_OS_FUNC_MALLOC
+#ifdef __cplusplus
+extern "C" {
-void *tmalloc(size_t size) {
+#endif
-  if (size <= 0) return NULL;
+#ifndef TAOS_OS_FUNC_STRING_STRDUP
-  void *ret = malloc(size + sizeof(size_t));
+  #define taosStrdupImp(str) strdup(str)
-  if (ret == NULL) return NULL;
+  #define taosStrndupImp(str, size) strndup(str, size)
+#endif
-  *(size_t *)ret = size;
+#ifndef TAOS_OS_FUNC_STRING_GETLINE
-  return (void *)((char *)ret + sizeof(size_t));
+  #define taosGetlineImp(lineptr, n, stream) getline(lineptr, n , stream)
-}
+#else 
+  int taosGetlineImp(char **lineptr, size_t *n, FILE *stream);
-void *tcalloc(size_t nmemb, size_t size) {
+#endif
-  size_t tsize = nmemb * size;
-  void * ret = tmalloc(tsize);
+#ifndef TAOS_OS_FUNC_STRING_WCHAR
-  if (ret == NULL) return NULL;
+  #define twcslen wcslen
+#endif  
-  tmemset(ret, 0);
-  return ret;
+#define tstrncpy(dst, src, size)   \
-}
+  do {                             \
+    strncpy((dst), (src), (size)); \
-size_t tsizeof(void *ptr) { return (ptr) ? (*(size_t *)((char *)ptr - sizeof(size_t))) : 0; }
+    (dst)[(size)-1] = 0;           \
+  } while (0);
-void tmemset(void *ptr, int c) { memset(ptr, c, tsizeof(ptr)); }
+#ifndef TAOS_OS_FUNC_STRING_STR2INT64
-void * trealloc(void *ptr, size_t size) {
+  int64_t tsosStr2int64(char *str);
-  if (ptr == NULL) return tmalloc(size);
+#endif  
-  if (size <= tsizeof(ptr)) return ptr;
+// USE_LIBICONV
+int32_t taosUcs4ToMbs(void *ucs4, int32_t ucs4_max_len, char *mbs);
-  void * tptr = (void *)((char *)ptr - sizeof(size_t));
+bool    taosMbsToUcs4(char *mbs, size_t mbs_len, char *ucs4, int32_t ucs4_max_len, size_t *len);
-  size_t tsize = size + sizeof(size_t);
+int     tasoUcs4Compare(void *f1_ucs4, void *f2_ucs4, int bytes);
-  tptr = realloc(tptr, tsize);
+bool    taosValidateEncodec(const char *encodec);
-  if (tptr == NULL) return NULL;
+char *  taosCharsetReplace(char *charsetstr);
-  *(size_t *)tptr = size;
+#ifdef __cplusplus
-  return (void *)((char *)tptr + sizeof(size_t));
-}
-void tzfree(void *ptr) {
-  if (ptr) {
-    free((void *)((char *)ptr - sizeof(size_t)));
-  }
 }
+#endif
 #endif
\ No newline at end of file
--- a/src/os/src/windows64/twintcpserver.c
+++ b/src/os/src/windows64/twintcpserver.c
@@ -13,22 +13,30 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
-#include "tulog.h"
+#ifndef TDENGINE_OS_SYSINFO_H
+#define TDENGINE_OS_SYSINFO_H
-void taosCloseTcpServerConnection(void *chandle) {
+#ifdef __cplusplus
-  tError("CloseTcpServerConnection not support in windows");
+extern "C" {
-}
+#endif
-void taosCleanUpTcpServer(void *handle) {
+// TAOS_OS_FUNC_SYSINFO
-  tError("CleanUpTcpServer not support in windows");
+void taosGetSystemInfo();
-}
+bool taosGetProcIO(float *readKB, float *writeKB);
+bool taosGetBandSpeed(float *bandSpeedKb);
+bool taosGetDisk();
+bool taosGetCpuUsage(float *sysCpuUsage, float *procCpuUsage) ;
+bool taosGetProcMemory(float *memoryUsedMB) ;
+bool taosGetSysMemory(float *memoryUsedMB);
+void taosPrintOsInfo();
+int  taosSystem(const char * cmd) ;
+void taosKillSystem();
-void *taosInitTcpServer(char *ip, uint16_t port, char *label, int numOfThreads, void *fp, void *shandle) {
+// TAOS_OS_FUNC_SYSINFO_CORE
-  tError("InitTcpServer not support in windows");
+void taosSetCoreDump();
-  return 0;
-}
-int taosSendTcpServerData(unsigned int ip, uint16_t port, char *data, int len, void *chandle) {
+#ifdef __cplusplus
-  tError("SendTcpServerData not support in windows");
-  return 0;
 }
+#endif
+#endif
--- a/src/util/inc/ttime.h
+++ b/src/util/inc/ttime.h
@@ -13,8 +13,8 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
-#ifndef TDENGINE_TTIME_H
+#ifndef TDENGINE_OS_TIME_H
-#define TDENGINE_TTIME_H
+#define TDENGINE_OS_TIME_H
 #ifdef __cplusplus
 extern "C" {
@@ -23,6 +23,16 @@ extern "C" {
 #include "os.h"
 #include "taosdef.h"
+#ifndef TAOS_OS_FUNC_TIME_DEF
+  #define MILLISECOND_PER_SECOND ((int64_t)1000L)
+#endif
+#define MILLISECOND_PER_MINUTE (MILLISECOND_PER_SECOND * 60)
+#define MILLISECOND_PER_HOUR   (MILLISECOND_PER_MINUTE * 60)
+#define MILLISECOND_PER_DAY    (MILLISECOND_PER_HOUR * 24)
+#define MILLISECOND_PER_WEEK   (MILLISECOND_PER_DAY * 7)
+#define MILLISECOND_PER_MONTH  (MILLISECOND_PER_DAY * 30)
+#define MILLISECOND_PER_YEAR   (MILLISECOND_PER_DAY * 365)
 //@return timestamp in second
 int32_t taosGetTimestampSec();

--- a/src/os/inc/osTimer.h
+++ b/src/os/inc/osTimer.h
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef TDENGINE_OS_TIMER_H
+#define TDENGINE_OS_TIMER_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+// TAOS_OS_FUNC_TIMER
+void taosMsleep(int mseconds);
+int taosInitTimer(void (*callback)(int), int ms);
+void taosUninitTimer();
+#ifdef __cplusplus
+}
+#endif
+#endif
--- a/src/os/inc/osWindows.h
+++ b/src/os/inc/osWindows.h
+/*
+* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+*
+* This program is free software: you can use, redistribute, and/or modify
+* it under the terms of the GNU Affero General Public License, version 3
+* or later ("AGPL"), as published by the Free Software Foundation.
+*
+* This program is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+#ifndef TDENGINE_PLATFORM_WINDOWS_H
+#define TDENGINE_PLATFORM_WINDOWS_H
+#include <assert.h>
+#include <ctype.h>
+#include <direct.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <float.h>
+#include <locale.h>
+#include <intrin.h>
+#include <io.h>
+#include <math.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+#include <inttypes.h>
+#include "winsock2.h"
+#include <WS2tcpip.h>
+#include <winbase.h>
+#include <Winsock2.h>
+#include <process.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define TAOS_OS_FUNC_ATOMIC
+#define TAOS_OS_FUNC_LZ4
+  int32_t BUILDIN_CLZL(uint64_t val);
+  int32_t BUILDIN_CLZ(uint32_t val);
+  int32_t BUILDIN_CTZL(uint64_t val);
+  int32_t BUILDIN_CTZ(uint32_t val);
+#define TAOS_OS_FUNC_DIR
+#define TAOS_OS_FUNC_FILE
+#define TAOS_OS_FUNC_FILE_SENDIFLE
+  #define taosFSendFile(outfile, infile, offset, count) taosFSendFileImp(outfile, infile, offset, size)
+  #define taosTSendFile(dfd, sfd, offset, size) taosTSendFileImp(dfd, sfd, offset, size)
+#define TAOS_OS_FUNC_FILE_GETTMPFILEPATH
+#define TAOS_OS_FUNC_MATH
+  #define SWAP(a, b, c)      \
+    do {                     \
+      c __tmp = (c)(a);      \
+      (a) = (c)(b);          \
+      (b) = __tmp;           \
+    } while (0)
+  #define MAX(a,b)  (((a)>(b))?(a):(b))
+  #define MIN(a,b)  (((a)<(b))?(a):(b))
+#define TAOS_OS_FUNC_SEMPHONE_PTHREAD
+#define TAOS_OS_FUNC_SOCKET
+#define TAOS_OS_FUNC_SOCKET_SETSOCKETOPT
+#define TAOS_OS_FUNC_SOCKET_OP
+  #define taosSend(sockfd, buf, len, flags) send(sockfd, buf, len, flags)
+  #define taosSendto(sockfd, buf, len, flags, dest_addr, addrlen) sendto(sockfd, buf, len, flags, dest_addr, addrlen)
+  #define taosWriteSocket(fd, buf, len) send(fd, buf, len, 0)
+  #define taosReadSocket(fd, buf, len) recv(fd, buf, len, 0)
+  #define taosCloseSocket(fd) closesocket(fd)
+#define TAOS_OS_FUNC_STRING_WCHAR
+#define TAOS_OS_FUNC_STRING_GETLINE
+#define TAOS_OS_FUNC_STRING_STR2INT64
+  #ifdef _TD_GO_DLL_
+    int64_t tsosStr2int64(char *str);
+    uint64_t htonll(uint64_t val);
+  #else
+    #define tsosStr2int64 _atoi64
+  #endif
+#define TAOS_OS_FUNC_STRING_STRDUP
+  #define taosStrdupImp(str) _strdup(str)
+  #define taosStrndupImp(str, size) _strndup(str, size)
+#define TAOS_OS_FUNC_SYSINFO
+#define TAOS_OS_FUNC_TIME_DEF
+  #ifdef _TD_GO_DLL_
+    #define MILLISECOND_PER_SECOND (1000LL)
+  #else
+    #define MILLISECOND_PER_SECOND (1000i64)
+  #endif
+#define TAOS_OS_FUNC_TIMER_SLEEP
+#define TAOS_OS_FUNC_TIMER
+// specific
+typedef int (*__compar_fn_t)(const void *, const void *);
+#define ssize_t int
+#define bzero(ptr, size) memset((ptr), 0, (size))
+#define mkdir(pathname, mode) _mkdir(pathname)
+#define strcasecmp  _stricmp
+#define strncasecmp _strnicmp
+#define wcsncasecmp _wcsnicmp
+#define strtok_r strtok_s
+#define snprintf _snprintf
+#define in_addr_t unsigned long
+#define socklen_t int
+#define htobe64 htonll
+#define twrite write
+#define getpid _getpid
+int        gettimeofday(struct timeval *tv, struct timezone *tz);
+struct tm *localtime_r(const time_t *timep, struct tm *result);
+char *     strptime(const char *buf, const char *fmt, struct tm *tm);
+char *     strsep(char **stringp, const char *delim);
+char *     getpass(const char *prefix);
+int        flock(int fd, int option);
+int        fsync(int filedes);
+char *     strndup(const char *s, size_t n);
+// for function open in stat.h 
+#define S_IRWXU                  _S_IREAD
+#define S_IRWXG                  _S_IWRITE
+#define S_IRWXO                  _S_IWRITE
+// for access function in io.h
+#define F_OK 00  //Existence only
+#define W_OK 02  //Write - only
+#define R_OK 04  //Read - only
+#define X_OK 06  //Read and write
+// for send function in tsocket.c
+#define MSG_NOSIGNAL             0
+#define SO_NO_CHECK              0x1234
+#define SOL_TCP                  0x1234
+#define TCP_KEEPCNT              0x1234
+#define TCP_KEEPIDLE             0x1234
+#define TCP_KEEPINTVL            0x1234
+#define LOCK_EX 1
+#define LOCK_NB 2
+#define LOCK_UN 3
+#ifndef PATH_MAX
+  #define PATH_MAX 256
+#endif
+//for signal, not dispose
+#define SIGALRM 1234
+typedef int sigset_t;
+struct sigaction {
+  void (*sa_handler)(int);
+};
+int sigaction(int, struct sigaction *, void *);
+typedef struct {
+  int    we_wordc;
+  char **we_wordv;
+  int    we_offs;
+  char   wordPos[20];
+} wordexp_t;
+int  wordexp(const char *words, wordexp_t *pwordexp, int flags);
+void wordfree(wordexp_t *pwordexp);
+#define TAOS_OS_FUNC_ATOMIC
+  #define atomic_load_8(ptr) (*(char volatile*)(ptr))
+  #define atomic_load_16(ptr) (*(short volatile*)(ptr))
+  #define atomic_load_32(ptr) (*(long volatile*)(ptr))
+  #define atomic_load_64(ptr) (*(__int64 volatile*)(ptr))
+  #define atomic_load_ptr(ptr) (*(void* volatile*)(ptr))
+  #define atomic_store_8(ptr, val) ((*(char volatile*)(ptr)) = (char)(val))
+  #define atomic_store_16(ptr, val) ((*(short volatile*)(ptr)) = (short)(val))
+  #define atomic_store_32(ptr, val) ((*(long volatile*)(ptr)) = (long)(val))
+  #define atomic_store_64(ptr, val) ((*(__int64 volatile*)(ptr)) = (__int64)(val))
+  #define atomic_store_ptr(ptr, val) ((*(void* volatile*)(ptr)) = (void*)(val))
+  #define atomic_exchange_8(ptr, val) _InterlockedExchange8((char volatile*)(ptr), (char)(val))
+  #define atomic_exchange_16(ptr, val) _InterlockedExchange16((short volatile*)(ptr), (short)(val))
+  #define atomic_exchange_32(ptr, val) _InterlockedExchange((long volatile*)(ptr), (long)(val))
+  #define atomic_exchange_64(ptr, val) _InterlockedExchange64((__int64 volatile*)(ptr), (__int64)(val))
+  #define atomic_exchange_ptr(ptr, val) _InterlockedExchangePointer((void* volatile*)(ptr), (void*)(val))
+  #ifdef _TD_GO_DLL_
+    #define atomic_val_compare_exchange_8 __sync_val_compare_and_swap
+  #else
+    #define atomic_val_compare_exchange_8(ptr, oldval, newval) _InterlockedCompareExchange8((char volatile*)(ptr), (char)(newval), (char)(oldval))
+  #endif
+  #define atomic_val_compare_exchange_16(ptr, oldval, newval) _InterlockedCompareExchange16((short volatile*)(ptr), (short)(newval), (short)(oldval))
+  #define atomic_val_compare_exchange_32(ptr, oldval, newval) _InterlockedCompareExchange((long volatile*)(ptr), (long)(newval), (long)(oldval))
+  #define atomic_val_compare_exchange_64(ptr, oldval, newval) _InterlockedCompareExchange64((__int64 volatile*)(ptr), (__int64)(newval), (__int64)(oldval))
+  #define atomic_val_compare_exchange_ptr(ptr, oldval, newval) _InterlockedCompareExchangePointer((void* volatile*)(ptr), (void*)(newval), (void*)(oldval))
+  char    interlocked_add_fetch_8(char volatile *ptr, char val);
+  short   interlocked_add_fetch_16(short volatile *ptr, short val);
+  long    interlocked_add_fetch_32(long volatile *ptr, long val);
+  __int64 interlocked_add_fetch_64(__int64 volatile *ptr, __int64 val);
+  #define atomic_add_fetch_8(ptr, val) interlocked_add_fetch_8((char volatile*)(ptr), (char)(val))
+  #define atomic_add_fetch_16(ptr, val) interlocked_add_fetch_16((short volatile*)(ptr), (short)(val))
+  #define atomic_add_fetch_32(ptr, val) interlocked_add_fetch_32((long volatile*)(ptr), (long)(val))
+  #define atomic_add_fetch_64(ptr, val) interlocked_add_fetch_64((__int64 volatile*)(ptr), (__int64)(val))
+  #ifdef _WIN64
+    #define atomic_add_fetch_ptr atomic_add_fetch_64
+  #else
+    #define atomic_add_fetch_ptr atomic_add_fetch_32
+  #endif
+  #ifdef _TD_GO_DLL_
+    #define atomic_fetch_add_8 __sync_fetch_and_ad
+    #define atomic_fetch_add_16 __sync_fetch_and_add
+  #else
+    #define atomic_fetch_add_8(ptr, val) _InterlockedExchangeAdd8((char volatile*)(ptr), (char)(val))
+    #define atomic_fetch_add_16(ptr, val) _InterlockedExchangeAdd16((short volatile*)(ptr), (short)(val))
+  #endif
+  #define atomic_fetch_add_32(ptr, val) _InterlockedExchangeAdd((long volatile*)(ptr), (long)(val))
+  #define atomic_fetch_add_64(ptr, val) _InterlockedExchangeAdd64((__int64 volatile*)(ptr), (__int64)(val))
+  #ifdef _WIN64
+    #define atomic_fetch_add_ptr atomic_fetch_add_64
+  #else
+    #define atomic_fetch_add_ptr atomic_fetch_add_32
+  #endif
+  #define atomic_sub_fetch_8(ptr, val) interlocked_add_fetch_8((char volatile*)(ptr), -(char)(val))
+  #define atomic_sub_fetch_16(ptr, val) interlocked_add_fetch_16((short volatile*)(ptr), -(short)(val))
+  #define atomic_sub_fetch_32(ptr, val) interlocked_add_fetch_32((long volatile*)(ptr), -(long)(val))
+  #define atomic_sub_fetch_64(ptr, val) interlocked_add_fetch_64((__int64 volatile*)(ptr), -(__int64)(val))
+  #ifdef _WIN64
+    #define atomic_sub_fetch_ptr atomic_sub_fetch_64
+  #else
+    #define atomic_sub_fetch_ptr atomic_sub_fetch_32
+  #endif
+  #define atomic_fetch_sub_8(ptr, val) _InterlockedExchangeAdd8((char volatile*)(ptr), -(char)(val))
+  #define atomic_fetch_sub_16(ptr, val) _InterlockedExchangeAdd16((short volatile*)(ptr), -(short)(val))
+  #define atomic_fetch_sub_32(ptr, val) _InterlockedExchangeAdd((long volatile*)(ptr), -(long)(val))
+  #define atomic_fetch_sub_64(ptr, val) _InterlockedExchangeAdd64((__int64 volatile*)(ptr), -(__int64)(val))
+  #ifdef _WIN64
+    #define atomic_fetch_sub_ptr atomic_fetch_sub_64
+  #else
+    #define atomic_fetch_sub_ptr atomic_fetch_sub_32
+  #endif
+  #ifndef _TD_GO_DLL_
+  char interlocked_and_fetch_8(char volatile* ptr, char val);
+  short interlocked_and_fetch_16(short volatile* ptr, short val);
+  #endif
+  long interlocked_and_fetch_32(long volatile* ptr, long val);
+  __int64 interlocked_and_fetch_64(__int64 volatile* ptr, __int64 val);
+  #ifndef _TD_GO_DLL_
+    #define atomic_and_fetch_8(ptr, val) interlocked_and_fetch_8((char volatile*)(ptr), (char)(val))
+    #define atomic_and_fetch_16(ptr, val) interlocked_and_fetch_16((short volatile*)(ptr), (short)(val))
+  #endif
+  #define atomic_and_fetch_32(ptr, val) interlocked_and_fetch_32((long volatile*)(ptr), (long)(val))
+  #define atomic_and_fetch_64(ptr, val) interlocked_and_fetch_64((__int64 volatile*)(ptr), (__int64)(val))
+  #ifdef _WIN64
+    #define atomic_and_fetch_ptr atomic_and_fetch_64
+  #else
+    #define atomic_and_fetch_ptr atomic_and_fetch_32
+  #endif
+  #ifndef _TD_GO_DLL_
+    #define atomic_fetch_and_8(ptr, val) _InterlockedAnd8((char volatile*)(ptr), (char)(val))
+    #define atomic_fetch_and_16(ptr, val) _InterlockedAnd16((short volatile*)(ptr), (short)(val))
+  #endif
+  #define atomic_fetch_and_32(ptr, val) _InterlockedAnd((long volatile*)(ptr), (long)(val))
+  #ifdef _M_IX86
+    __int64 interlocked_fetch_and_64(__int64 volatile* ptr, __int64 val);
+    #define atomic_fetch_and_64(ptr, val) interlocked_fetch_and_64((__int64 volatile*)(ptr), (__int64)(val))
+  #else
+    #define atomic_fetch_and_64(ptr, val) _InterlockedAnd64((__int64 volatile*)(ptr), (__int64)(val))
+  #endif
+  #ifdef _WIN64
+    #define atomic_fetch_and_ptr atomic_fetch_and_64
+  #else
+    #define atomic_fetch_and_ptr atomic_fetch_and_32
+  #endif
+  #ifndef _TD_GO_DLL_
+    char interlocked_or_fetch_8(char volatile* ptr, char val);
+    short interlocked_or_fetch_16(short volatile* ptr, short val);
+  #endif
+  long interlocked_or_fetch_32(long volatile* ptr, long val);
+  __int64 interlocked_or_fetch_64(__int64 volatile* ptr, __int64 val);
+  #ifndef _TD_GO_DLL_
+    #define atomic_or_fetch_8(ptr, val) interlocked_or_fetch_8((char volatile*)(ptr), (char)(val))
+    #define atomic_or_fetch_16(ptr, val) interlocked_or_fetch_16((short volatile*)(ptr), (short)(val))
+  #endif
+  #define atomic_or_fetch_32(ptr, val) interlocked_or_fetch_32((long volatile*)(ptr), (long)(val))
+  #define atomic_or_fetch_64(ptr, val) interlocked_or_fetch_64((__int64 volatile*)(ptr), (__int64)(val))
+  #ifdef _WIN64
+    #define atomic_or_fetch_ptr atomic_or_fetch_64
+  #else
+    #define atomic_or_fetch_ptr atomic_or_fetch_32
+  #endif
+  #ifndef _TD_GO_DLL_
+    #define atomic_fetch_or_8(ptr, val) _InterlockedOr8((char volatile*)(ptr), (char)(val))
+    #define atomic_fetch_or_16(ptr, val) _InterlockedOr16((short volatile*)(ptr), (short)(val))
+  #endif
+  #define atomic_fetch_or_32(ptr, val) _InterlockedOr((long volatile*)(ptr), (long)(val))
+  #ifdef _M_IX86
+    __int64 interlocked_fetch_or_64(__int64 volatile* ptr, __int64 val);
+    #define atomic_fetch_or_64(ptr, val) interlocked_fetch_or_64((__int64 volatile*)(ptr), (__int64)(val))
+  #else
+    #define atomic_fetch_or_64(ptr, val) _InterlockedOr64((__int64 volatile*)(ptr), (__int64)(val))
+  #endif
+  #ifdef _WIN64
+    #define atomic_fetch_or_ptr atomic_fetch_or_64
+  #else
+    #define atomic_fetch_or_ptr atomic_fetch_or_32
+  #endif
+  #ifndef _TD_GO_DLL_
+    char interlocked_xor_fetch_8(char volatile* ptr, char val);
+    short interlocked_xor_fetch_16(short volatile* ptr, short val);
+  #endif
+  long interlocked_xor_fetch_32(long volatile* ptr, long val);
+  __int64 interlocked_xor_fetch_64(__int64 volatile* ptr, __int64 val);
+  #ifndef _TD_GO_DLL_
+    #define atomic_xor_fetch_8(ptr, val) interlocked_xor_fetch_8((char volatile*)(ptr), (char)(val))
+    #define atomic_xor_fetch_16(ptr, val) interlocked_xor_fetch_16((short volatile*)(ptr), (short)(val))
+  #endif
+  #define atomic_xor_fetch_32(ptr, val) interlocked_xor_fetch_32((long volatile*)(ptr), (long)(val))
+  #define atomic_xor_fetch_64(ptr, val) interlocked_xor_fetch_64((__int64 volatile*)(ptr), (__int64)(val))
+  #ifdef _WIN64
+    #define atomic_xor_fetch_ptr atomic_xor_fetch_64
+  #else
+    #define atomic_xor_fetch_ptr atomic_xor_fetch_32
+  #endif
+  #ifndef _TD_GO_DLL_
+    #define atomic_fetch_xor_8(ptr, val) _InterlockedXor8((char volatile*)(ptr), (char)(val))
+    #define atomic_fetch_xor_16(ptr, val) _InterlockedXor16((short volatile*)(ptr), (short)(val))
+  #endif
+  #define atomic_fetch_xor_32(ptr, val) _InterlockedXor((long volatile*)(ptr), (long)(val))
+  #ifdef _M_IX86
+    __int64 interlocked_fetch_xor_64(__int64 volatile* ptr, __int64 val);
+    #define atomic_fetch_xor_64(ptr, val) interlocked_fetch_xor_64((__int64 volatile*)(ptr), (__int64)(val))
+  #else
+    #define atomic_fetch_xor_64(ptr, val) _InterlockedXor64((__int64 volatile*)(ptr), (__int64)(val))
+  #endif
+  #ifdef _WIN64
+    #define atomic_fetch_xor_ptr atomic_fetch_xor_64
+  #else
+    #define atomic_fetch_xor_ptr atomic_fetch_xor_32
+  #endif
+#ifdef __cplusplus
+}
+#endif
+#endif
\ No newline at end of file
--- a/src/os/inc/osWindows32.h
+++ b/src/os/inc/osWindows32.h
-/*
-* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
-*
-* This program is free software: you can use, redistribute, and/or modify
-* it under the terms of the GNU Affero General Public License, version 3
-* or later ("AGPL"), as published by the Free Software Foundation.
-*
-* This program is distributed in the hope that it will be useful, but WITHOUT
-* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-* FITNESS FOR A PARTICULAR PURPOSE.
-*
-* You should have received a copy of the GNU Affero General Public License
-* along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-#ifndef TDENGINE_PLATFORM_WINDOWS32_H
-#define TDENGINE_PLATFORM_WINDOWS32_H
-#include <assert.h>
-#include <ctype.h>
-#include <direct.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <float.h>
-#include <locale.h>
-#include <intrin.h>
-#include <io.h>
-#include <math.h>
-#include <pthread.h>
-#include <semaphore.h>
-#include <stdarg.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <signal.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <time.h>
-#include <inttypes.h>
-#include "winsock2.h"
-#include <WS2tcpip.h>
-#include <winbase.h>
-#include <Winsock2.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-#ifdef __cplusplus
-}
-#endif
-#endif
\ No newline at end of file
--- a/src/os/inc/osWindows64.h
+++ b/src/os/inc/osWindows64.h
--- a/src/os/src/alpine/alpineEnv.c
+++ b/src/os/src/alpine/alpineEnv.c
@@ -16,7 +16,6 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 #include "tglobal.h"
-#include "tulog.h"
 void osInit() {
  strcpy(configDir, "/etc/taos");

--- a/src/os/src/darwin/CMakeLists.txt
+++ b/src/os/src/darwin/CMakeLists.txt
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+PROJECT(TDengine)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/os/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/util/inc)
+INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/src/common/inc)
+AUX_SOURCE_DIRECTORY(. SRC)
+ADD_LIBRARY(os ${SRC})
--- a/src/os/src/darwin64/darwinEnv.c
+++ b/src/os/src/darwin64/darwinEnv.c
@@ -16,15 +16,14 @@
 #define _DEFAULT_SOURCE
 #include "os.h"
 #include "tglobal.h"
-#include "tulog.h"
 void osInit() {
-  strcpy(configDir, "/etc/taos");
+  strcpy(configDir, "~/TDengine/cfg");
  strcpy(tsVnodeDir, "");
  strcpy(tsDnodeDir, "");
  strcpy(tsMnodeDir, "");
-  strcpy(tsDataDir, "/var/lib/taos");
+  strcpy(tsDataDir, "~/TDengine/data");
-  strcpy(tsLogDir, "~/TDengineLog");
+  strcpy(tsLogDir, "~/TDengine/log");
-  strcpy(tsScriptDir, "/etc/taos");
+  strcpy(tsScriptDir, "~/TDengine/cfg");
  strcpy(tsOsName, "Darwin");
 }
--- a/src/os/src/darwin/darwinFile.c
+++ b/src/os/src/darwin/darwinFile.c
--- a/src/os/src/darwin/darwinSemphone.c
+++ b/src/os/src/darwin/darwinSemphone.c
--- a/src/os/src/darwin/darwinSocket.c
+++ b/src/os/src/darwin/darwinSocket.c
--- a/src/os/src/detail/osUtil.c
+++ b/src/os/src/detail/osUtil.c
--- a/src/os/src/darwin/darwinSysInfo.c
+++ b/src/os/src/darwin/darwinSysInfo.c
--- a/src/os/src/darwin/darwinTimer.c
+++ b/src/os/src/darwin/darwinTimer.c
--- a/src/os/src/darwin64/CMakeLists.txt
+++ b/src/os/src/darwin64/CMakeLists.txt
--- a/src/os/src/darwin64/darwinPlatform.c
+++ b/src/os/src/darwin64/darwinPlatform.c
--- a/src/os/src/detail/osCoredump.c
+++ b/src/os/src/detail/osCoredump.c
--- a/src/os/src/detail/osDir.c
+++ b/src/os/src/detail/osDir.c
--- a/src/os/src/detail/osFile.c
+++ b/src/os/src/detail/osFile.c
--- a/src/os/src/detail/osFileOp.c
+++ b/src/os/src/detail/osFileOp.c
--- a/src/os/src/detail/osMem.c
+++ b/src/os/src/detail/osMem.c
--- a/src/os/src/detail/osRand.c
+++ b/src/os/src/detail/osRand.c
--- a/src/os/src/detail/osPThread.c
+++ b/src/os/src/detail/osPThread.c
--- a/src/os/src/detail/osSocket.c
+++ b/src/os/src/detail/osSocket.c
--- a/src/os/src/detail/osWchar.c
+++ b/src/os/src/detail/osWchar.c
--- a/src/os/src/detail/osSysinfo.c
+++ b/src/os/src/detail/osSysinfo.c
--- a/src/util/src/ttime.c
+++ b/src/util/src/ttime.c
--- a/src/os/src/detail/osTimer.c
+++ b/src/os/src/detail/osTimer.c
--- a/src/os/src/linux64/CMakeLists.txt
+++ b/src/os/src/linux64/CMakeLists.txt
--- a/src/os/src/linux64/linuxEnv.c
+++ b/src/os/src/linux64/linuxEnv.c
--- a/src/os/src/windows/CMakeLists.txt
+++ b/src/os/src/windows/CMakeLists.txt
--- a/src/os/src/windows64/twindows.c
+++ b/src/os/src/windows64/twindows.c
--- a/src/os/src/windows64/twinenv.c
+++ b/src/os/src/windows64/twinenv.c
--- a/src/os/src/windows64/w64File.c
+++ b/src/os/src/windows64/w64File.c
--- a/src/os/src/windows64/twingetline.c
+++ b/src/os/src/windows64/twingetline.c
--- a/src/os/src/windows/w64Godll.c
+++ b/src/os/src/windows/w64Godll.c
--- a/src/os/src/windows/w64Lz4.c
+++ b/src/os/src/windows/w64Lz4.c
--- a/src/os/src/windows/w64Semphone.c
+++ b/src/os/src/windows/w64Semphone.c
--- a/src/os/src/windows/w64Socket.c
+++ b/src/os/src/windows/w64Socket.c
--- a/src/os/src/windows64/w64Wchar.c
+++ b/src/os/src/windows64/w64Wchar.c
--- a/src/os/src/windows64/twinstrptime.c
+++ b/src/os/src/windows64/twinstrptime.c
--- a/src/os/src/windows/w64Sysinfo.c
+++ b/src/os/src/windows/w64Sysinfo.c
--- a/src/os/src/windows64/twintime.c
+++ b/src/os/src/windows64/twintime.c
--- a/src/os/src/windows64/twintimer.c
+++ b/src/os/src/windows64/twintimer.c
--- a/src/os/src/windows/w64Wordexp.c
+++ b/src/os/src/windows/w64Wordexp.c
--- a/src/os/src/windows64/CMakeLists.txt
+++ b/src/os/src/windows64/CMakeLists.txt
--- a/src/os/src/windows64/twinmsghdr.c
+++ b/src/os/src/windows64/twinmsghdr.c
--- a/src/os/src/windows64/twinsocket.c
+++ b/src/os/src/windows64/twinsocket.c
--- a/src/plugins/http/CMakeLists.txt
+++ b/src/plugins/http/CMakeLists.txt
--- a/src/plugins/http/src/httpContext.c
+++ b/src/plugins/http/src/httpContext.c
--- a/src/plugins/http/src/httpServer.c
+++ b/src/plugins/http/src/httpServer.c
--- a/src/plugins/http/src/httpSession.c
+++ b/src/plugins/http/src/httpSession.c
--- a/src/plugins/http/src/httpSystem.c
+++ b/src/plugins/http/src/httpSystem.c
--- a/src/plugins/monitor/CMakeLists.txt
+++ b/src/plugins/monitor/CMakeLists.txt
--- a/src/plugins/monitor/src/monitorMain.c
+++ b/src/plugins/monitor/src/monitorMain.c
--- a/src/plugins/mqtt/CMakeLists.txt
+++ b/src/plugins/mqtt/CMakeLists.txt
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
--- a/src/query/src/qExtbuffer.c
+++ b/src/query/src/qExtbuffer.c
--- a/src/query/src/qFill.c
+++ b/src/query/src/qFill.c
--- a/src/query/src/qParserImpl.c
+++ b/src/query/src/qParserImpl.c
--- a/src/query/src/qPercentile.c
+++ b/src/query/src/qPercentile.c
--- a/src/query/src/qResultbuf.c
+++ b/src/query/src/qResultbuf.c
--- a/src/query/src/qTsbuf.c
+++ b/src/query/src/qTsbuf.c
--- a/src/query/src/qUtil.c
+++ b/src/query/src/qUtil.c
--- a/src/query/tests/tsBufTest.cpp
+++ b/src/query/tests/tsBufTest.cpp
--- a/src/query/tests/unitTest.cpp
+++ b/src/query/tests/unitTest.cpp
--- a/src/rpc/CMakeLists.txt
+++ b/src/rpc/CMakeLists.txt
--- a/src/rpc/src/rpcCache.c
+++ b/src/rpc/src/rpcCache.c
--- a/src/rpc/src/rpcMain.c
+++ b/src/rpc/src/rpcMain.c
--- a/src/rpc/src/rpcTcp.c
+++ b/src/rpc/src/rpcTcp.c
--- a/src/rpc/src/rpcUdp.c
+++ b/src/rpc/src/rpcUdp.c
--- a/src/sync/src/syncMain.c
+++ b/src/sync/src/syncMain.c
--- a/src/sync/src/syncRestore.c
+++ b/src/sync/src/syncRestore.c
--- a/src/sync/src/syncRetrieve.c
+++ b/src/sync/src/syncRetrieve.c
--- a/src/sync/src/taosTcpPool.c
+++ b/src/sync/src/taosTcpPool.c
--- a/src/sync/src/tarbitrator.c
+++ b/src/sync/src/tarbitrator.c
--- a/src/tsdb/inc/tsdbMain.h
+++ b/src/tsdb/inc/tsdbMain.h
--- a/src/tsdb/src/tsdbBuffer.c
+++ b/src/tsdb/src/tsdbBuffer.c
--- a/src/tsdb/src/tsdbFile.c
+++ b/src/tsdb/src/tsdbFile.c
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
--- a/src/tsdb/src/tsdbMemTable.c
+++ b/src/tsdb/src/tsdbMemTable.c
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
--- a/src/tsdb/src/tsdbRWHelper.c
+++ b/src/tsdb/src/tsdbRWHelper.c
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
--- a/src/tsdb/tests/tsdbTests.cpp
+++ b/src/tsdb/tests/tsdbTests.cpp
--- a/src/util/CMakeLists.txt
+++ b/src/util/CMakeLists.txt
--- a/src/util/inc/talgo.h
+++ b/src/util/inc/talgo.h
--- a/src/util/src/hash.c
+++ b/src/util/src/hash.c
--- a/src/util/src/talgo.c
+++ b/src/util/src/talgo.c
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
--- a/src/util/src/tconfig.c
+++ b/src/util/src/tconfig.c
--- a/src/util/src/tdes.c
+++ b/src/util/src/tdes.c
--- a/src/util/src/tkvstore.c
+++ b/src/util/src/tkvstore.c
--- a/src/util/src/tlog.c
+++ b/src/util/src/tlog.c
--- a/src/util/src/tmempool.c
+++ b/src/util/src/tmempool.c
--- a/src/util/src/tnote.c
+++ b/src/util/src/tnote.c
--- a/src/util/src/tskiplist.c
+++ b/src/util/src/tskiplist.c
--- a/src/util/src/ttimer.c
+++ b/src/util/src/ttimer.c
--- a/src/util/src/tutil.c
+++ b/src/util/src/tutil.c
--- a/src/util/tests/cacheTest.cpp
+++ b/src/util/tests/cacheTest.cpp
--- a/src/util/tests/hashTest.cpp
+++ b/src/util/tests/hashTest.cpp
--- a/src/util/tests/skiplistTest.cpp
+++ b/src/util/tests/skiplistTest.cpp
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
--- a/src/wal/src/walMain.c
+++ b/src/wal/src/walMain.c
--- a/tests/test/c/createTablePerformance.c
+++ b/tests/test/c/createTablePerformance.c
--- a/tests/test/c/hashPerformance.c
+++ b/tests/test/c/hashPerformance.c
--- a/tests/tsim/src/simExe.c
+++ b/tests/tsim/src/simExe.c
--- a/tests/tsim/src/simMain.c
+++ b/tests/tsim/src/simMain.c
--- a/tests/tsim/src/simParse.c
+++ b/tests/tsim/src/simParse.c
--- a/tests/tsim/src/simSystem.c
+++ b/tests/tsim/src/simSystem.c