引言 – 有的时候心起, libuv linux 搭建
引言 – 一切才刚刚起头
有一天忽地想起来想写个动画. 找了一晃 ui 库太大. 后面想起以前弄过的
libuv. 但意识 libuv 相关材质也相当少.
structc 是 C 结构基础库. 轻便可复用.
为此就有了那个内容.
structc –
libuv –
以前也陈述过三次 structc, 文字多代码风格少. 方今加班相当的少,
盘算详细表达哈其思维初志.
libuv 在 linux 上边运用相比轻松, 一从头 从 linux hello 跑起来
0.0 全体结构
libuv linux 安装
structc├── extern├── LICENSE├── Makefile├── README.md├── structc└── structc.sln
率先假定你和本身一样用的是Ubuntu去做开拓. 在云平台上边测验过, Ubuntu
Server 版本比 CentOS 版本少个十几兆.
structc.sln : winds 项目管理文件visual studio
风乐趣朋友能够详细比较数据, 也得以品味跑跑 Ubuntu Server .
structc : 项目全体源码和材质文件目录
# libuv 安装
cd
wget https://github.com/libuv/libuv/archive/v1.18.0.tar.gz
tar -zxvf v1.18.0.tar.gz
cd libuv-1.18.0
sh autogen.sh
./configure
make -j4
sudo make install
sudo ldconfig
cd ../
rm -rf libuv-1.18.0 v1.18.0.tar.gz
```
README.md : 项目介绍 马克down
举办上边命令操作, 我们的系统中就曾经有了 libuv 开垦蒙受.
Makefile : linux 编写翻译文件make
有有个别急需注意的是当大家要动用 libuv时候推荐用静态库.
LICENSE : MIT 开源左券
gcc -l:libuv.a
extern : 项目引入的表面库目录
到这里 linux 安装 libuv 已经完工了.
extern├── jemalloc├── jemalloc-vc141-Release-static.lib├── libuv.lib├── pthread.h├── pthread_lib.lib├── sched.h├── semaphore.h├── strings.h├── uv└── uv.h
无妨写个 hello world demo
以上正是我们看来 structc 项目全体结构.
#include <uv.h>
#include <assext.h>
//
// 测试 libuv tty 操作控制台
// 输出一段有颜色的文字
//
void uv_tty_test(void) {
uv_tty_t tty;
uv_buf_t buf[3];
unsigned i, len = sizeof buf / sizeof *buf;
uv_loop_t * loop = uv_default_loop();
// 目前只对 tty 控制台处理
if (uv_guess_handle(1) != UV_TTY) {
fprintf(stderr, "uv_guess_handle(1) != UV_TTY!\n");
exit(EXIT_FAILURE);
}
uv_tty_init(loop, &tty, 1, 0);
uv_tty_set_mode(&tty, UV_TTY_MODE_NORMAL);
// 开始发送消息
buf[0].base = "\033[46;37m";
buf[1].base = u8"(✿◡‿◡) 喵酱 ((●'-'●)) 比 ♥ 里~ \n";
buf[2].base = "\033[0m";
for (i = 0; i < len; ++i)
buf[i].len = (int)strlen(buf[i].base);
uv_try_write((uv_stream_t *)&tty, buf, len);
// 重置终端行为
uv_tty_reset_mode();
uv_run(loop, UV_RUN_DEFAULT);
}
0.1 外部库
代码运转效果是, 输出一段话, 何况设置背景观. 对于 uv_tty_test
能够清楚为 main (本质是 structc 一种单元测量检验函数约束写法)
当前一点都不大心的引入多个半表面库. 最大程度会静态库编译链接运营.
荣作者逐步细说.
到那容小编安利一个小东西, 感兴趣的能够品尝一下, 从零起头搭建四个 c 的
struct 小框架. 五脏逐步全了.
- jemalloc –
structc –
jemalloc 是 c 创设底层高品质 malloc 库.
也被喻为系统一编写程末尾时期最终免费午饭.整个structc
简短说一下libuv中动用的多少个函数, 第四个是 uv_try_write
尝试即刻发送音讯数组. 不像 uv_write 写入到音讯队列中.
malloc全权交给 je_malloc 抗压.当中 winds 编写翻译静态库部分,
项目自个儿也许有细说 –
int uv_try_write(uv_stream_t* handle, const uv_buf_t bufs[], unsigned int nbufs)
Same as uv_write(), but won’t queue a write request if it can’t be completed immediately.
Will return either:
> 0: number of bytes written (can be less than the supplied buffer size).
< 0: negative error code (UV_EAGAIN is returned if no data can be sent immediately).
现阶段大家是用 tty 输出到荧屏方面, 能够用这几个 api . 假使单纯是走 TCP,
不要过度注重这几个 api.
How to build jemalloc for Windows=================================1. Install Cygwin with at least the following packages: * autoconf * autogen * gawk * grep * sed2. Install Visual Studio 2015 or 2017 with Visual C++3. Add Cygwin\bin to the PATH environment variable4. Open "x64 Native Tools Command Prompt for VS 2017" (note: x86/x64 doesn't matter at this point)5. Generate header files: sh -c "CC=cl ./autogen.sh"6. Now the project can be opened and built in Visual Studio: msvc\jemalloc_vc2017.sln
简短为了稳定依然别用 uv_try_write.
( 注: vs 使用新型版本. 网站打不开那就FQ. 前面其也长久以来, 时刻保险最新
2018/10/10 ~ )
第三个要说的是 uv_run
对于 linux 编写翻译安装参照下边脚本
int uv_run(uv_loop_t* loop, uv_run_mode mode)
This function runs the event loop. It will act differently depending on the specified mode:
UV_RUN_DEFAULT: Runs the event loop until there are no more active and referenced handles or requests.
Returns non-zero if uv_stop() was called and there are still active handles or requests.
Returns zero in all other cases.
UV_RUN_ONCE: Poll for i/o once. Note that this function blocks if there are no pending callbacks.
Returns zero when done (no active handles or requests left),
or non-zero if more callbacks are expected
(meaning you should run the event loop again sometime in the future).
UV_RUN_NOWAIT: Poll for i/o once but don’t block if there are no pending callbacks.
Returns zero if done (no active handles or requests left),
or non-zero if more callbacks are expected
(meaning you should run the event loop again sometime in the future).
# 开发环境安装sudo apt install gcc gdb autogen autoconf# jemalloc 安装cdwget https://github.com/jemalloc/jemalloc/releases/download/5.1.0/jemalloc-5.1.0.tar.bz2tar -jxvf jemalloc-5.1.0.tar.bz2cd jemalloc-5.1.0sh autogen.shmake -j4sudo make installsudo ldconfigcdrm -rf jemalloc-5.1.0 jemalloc-5.1.0.tar.bz2
其中 UV_RUN_DEFAULT 表示 uv_run
会一贯不通运行, 只到未有职业要管理的时候, 才会有重临值.
当 jemalloc 构建好了. 设计 alloc 层引进到 structc 框架中, 客商替代系统
malloc…
而 UV_RUN_ONCE 表示实行 poll 二遍.
类比你写代码只调用三回 select 阻塞, 直到事件激活大概逾期触发.
alloc.h
–
相似的 UV_RUN_NOWAIT 也是只 poll
轮询壹回, 然而未有要拍卖专门的职业是不会阻塞.
#ifndef _H_ALLOC#define _H_ALLOC#include <stdlib.h>#include <string.h>// :) 高效内存分配, 莫名伤感 ~// _MSC_VER -> Winds CL// __GNUC__ -> Linux GCC//#ifdef _MSC_VER//// CPU 检测 x64 or x86// ISX64 defined 表示 x64 否则 x86//# if defined || defined# define ISX64# endif//// _M_PPC 为 PowerPC 平台定义, 现在已不支持// so winds 可以认为都是小端平台//# if defined# define ISBENIAN# endif#elif __GNUC__# if defined(__x86_64__)# define ISX64# endif//// 大小端检测 : ISBENIAN defined 表示大端//# if defined(__BIG_ENDIAN__) || defined(__BIG_ENDIAN_BITFIELD)# define ISBENIAN# endif#else# error BUILD S#endif// OFF_ALLOC - 关闭全局 free / malloc 配置#ifndef OFF_ALLOC# undef free# define free free_# undef strdup# define strdup strdup_# undef malloc# define malloc malloc_# undef calloc# define calloc calloc_# undef realloc# define realloc realloc_#endif//OFF_ALLOC//// free_ - free 包装函数// ptr : 内存首地址// return : void//extern void free_(void * ptr);//// malloc_ - malloc 包装, 封装一些特殊业务// size : 分配的内存字节// return : 返回可使用的内存地址.//extern void * malloc_(size_t size);//// strdup_ - strdup 包装函数// s : '\0' 结尾 C 字符串// return : 拷贝后新的 C 字符串//extern char * strdup_(const char * s);//// calloc_ - calloc 包装, 封装一些特殊业务// num : 数量// size : 大小// return : 返回可用内存地址, 并且置0//extern void * calloc_(size_t num, size_t size);//// realloc_ - realoc 包装函数, 封装一些特殊业务// ptr : 内存首地址, NULL 等同于 malloc// size : 重新分配的内存大小// return : 返回重新分配好的新地址内容//extern void * realloc_(void * ptr, size_t size);#endif//_H_STDEXIT
到此处, 差不离 linux libuv 的 hello world 应该也算起来了.
alloc.c
–
#include <stdio.h>#define OFF_ALLOC#include "alloc.h"#define JEMALLOC_NO_DEMANGLE#include <jemalloc/jemalloc.h>//// free_ - free 包装函数// ptr : 内存首地址// return : void//inline void free_(void * ptr) { je_free;}// 简单内存不足检测处理static inline void * mcheck(void * ptr, size_t size) { if (NULL == ptr) { fprintf(stderr, "out of memory trying to allocate %zu\n", size); fflush; abort(); } return ptr;}//// malloc_ - malloc 包装, 封装一些特殊业务// size : 分配的内存字节// return : 返回可使用的内存地址.//inline void * malloc_(size_t size) { void * ptr = je_malloc; return mcheck(ptr, size);}//// strdup_ - strdup 包装函数// s : '\0' 结尾 C 字符串// return : 拷贝后新的 C 字符串//inline char * strdup_(const char * s) { if { size_t n = strlen + 1; char * ptr = malloc_; return memcpy(ptr, s, n); } return NULL;}//// calloc_ - calloc 包装, 封装一些特殊业务// num : 数量// size : 大小// return : 返回可用内存地址, 并且置0//inline void * calloc_(size_t num, size_t size) { void * ptr = je_calloc(num, size); return mcheck(ptr, size);}//// realloc_ - realoc 包装函数, 封装一些特殊业务// ptr : 内存首地址, NULL 等同于 malloc// size : 重新分配的内存大小// return : 返回重新分配好的新地址内容//inline void * realloc_(void * ptr, size_t size) { void * ntr = je_realloc(ptr, size); return mcheck(ntr, size);}
前言 – winds 跑起 libuv
装进了一层. 从 alloc.h 中 OFF_ALLOC 宏能够见到, 具有支持插拔技术 ~
上边开首带我们, 在 winds 编写翻译最新版本 libuv. 同样在 github 上 下载
libuv 最新的揭橥版本.
2.libuv -
libuv-1.18.0
libuv 用 c 写的高品质单线程互连网 io 库. 希望经过它来援助互联网层.winds
编写翻译静态库
参谋 libuv 项目首页燥起来就行. 当中 gyp 安装了这么些版本, 其余与世浮沉 ~
解压操作实现后, 会是底下那样的
gyp –
linux 编写翻译安装脚本
此刻候先参照一下官方网址的 libuv 首页 README.md 表达.
# libuv 安装cdwget https://github.com/libuv/libuv/archive/v1.23.1.zipunzip v1.23.1.zipcd libuv-1.23.1sh autogen.sh./configuremake -j4sudo make installsudo ldconfigcd## 注意 uv 头文件, 全部导入到系统 include 目录下面#rm -rf libuv-1.23.1 v1.23.1.zip
先安装 Python 2.7 . 扯一点. 近年来 python 好虎 (二零一七年三月二十日),
不过依然不知底为什么 2.7 和 3.x 版本不包容.
注意要将编写翻译后 include 完整拷贝到安装目录 include下. 那样 uv
头文件全, 日后会用到.
就当下来讲依然多用 Python 2.7 感到. 随后安装 gyp google
推出的跨平台编写翻译遭受.
libuv 开箱即用, 不太急需怎样基础封装.
gyp
–
3.pthread –
出于选拔的是 VS2017, 原始版本 gyp 不帮助, 请参照小编提的这一个提交,
举办修改让其支持 VS2017 版本
那是最后那半个, 为 winds 引进 POSIX thread
模型.编写翻译起来很简短(前提大家 VS 玩的熟).
gyp-vs2017
version
–
扯点闲篇. linux 和 winds 相反相成, 对立而统一. 叁个是整整从头码,
三个早先就已经登记以后.
ok winds 10 + VS2017 + libuv-1.18.0 + python2.7 + gyp + gyp vs2017
version 编写翻译意况搭建完成.
汇报相当的粗, 但大致那意思. (七个都不 eary, 玩非常久才敢入门见伯伯岳母) .
这里包装了一层
开端走起, 先踏入 gyp 目录实施
thread.h
–
python .\setup.py install
#ifndef _H_THREAD#define _H_THREAD#include "struct.h"#include <pthread.h>#include <semaphore.h>//// pthread_end - 等待启动线程结束// tid : 线程id// return : void//inline void pthread_end(pthread_t tid) { pthread_join(tid, NULL);}//// pthread_run - 异步启动线程// id : &tid 线程id地址// frun : 运行的主体// arg : 运行参数// return : 返回线程构建结果, 0 is success//#define pthread_run(id, frun, arg) \pthread_run_(&(id), , (void *)inline int pthread_run_(pthread_t * id, node_f frun, void * arg) { return pthread_create(id, NULL, frun, arg);}//// pthread_async - 异步启动分离线程// frun : 运行的主体// arg : 运行参数// return : 返回 0 is success// #define pthread_async(frun, arg) \pthread_async_, (void *)inline int pthread_async_(node_f frun, void * arg) { int ret; pthread_t tid; pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); ret = pthread_create(&tid, &attr, frun, arg); pthread_attr_destroy(&attr); return ret;}#endif//_H_THREAD
利用今世编写翻译器包容性创设了 pthread 三种运维宏, 后续写 pthread create
相关代码会百步穿杨!
做到后, 开端营造 uv.sln 工程. 先步向 libuv-1.18.0 最早目录,
实行上面命令
到此大家大学一年级统治线程模型就定下来了. 还附带引出了三个很要紧支持头文件.
.\vcbuild.bat release vs2017 x64 static
struct.h
–
随着可以望见 uv.sln 和 Release\lib\libuv.lib 生成文件. 编写翻译进程中
x64版本警告非常多. 你完全能够尝尝消除,
#ifndef _H_STRUCT#define _H_STRUCT#include <math.h>#include "alloc.h"#include <ctype.h>#include <float.h>#include <stdio.h>#include <errno.h>#include <assert.h>#include <stdarg.h>#include <stdint.h>#include <stddef.h>#include <limits.h>#include <stdbool.h>#include <inttypes.h>//// enum Flag int - 函数返回值全局状态码// >= 0 标识 Success 状态, < 0 标识 Error 状态//enum { SBase = +0, // 正确基础类型 EBase = -1, // 错误基础类型 EParam = -2, // 输入参数错误 EFd = -3, // 文件打开失败 EClose = -4, // 文件操作关闭 EAccess = -5, // 没有操作权限 EAlloc = -6, // 内存操作错误 EParse = -7, // 协议解析错误 ESmall = -8, // 过小基础错误 EBig = -9, // 过大基础错误 ETimeout = -10, // 操作超时错误};//// DCODE - DEBUG 模式下的测试宏// DCODE({// puts("debug start...");// });//#ifndef DCODE# ifdef _DEBUG# define DCODE do code while(0)# else# define DCODE # endif // ! _DEBUG#endif // ! DCODE//// icmp_f - 比较行为的类型// : int add_cmp(const void * now, const void * node)//typedef int (* icmp_f)();//// vnew_f - 根据规则构建对象// : void * rtree_new(void * node)//typedef void * (* vnew_f)();//// node_f - 销毁当前对象节点// : void list_die(void * node); //typedef void (void * node);//// start_f - pthread create func// : int * run(int * arg)//typedef void * (* start_f)(void * arg);//// each_f - each 循环操作, arg 外部参数, node 是内部结点// : int dict_echo(struct dict * node, void * arg) { return 0; }//typedef int (void * node, void * arg);//// CERR - 打印错误信息// EXIT - 打印错误信息, 并 exit// IF - 条件判断异常退出的辅助宏//#define CERR \fprintf(stderr, "[%s:%s:%d][%d:%s]" fmt "\n", \ __FILE__, __func__, __LINE__, errno, strerror, ##__VA_ARGS__)#define EXIT \do { \ CERR(fmt, ##__VA_ARGS__); \ exit(EXIT_FAILURE); \} while(0)#define IF \if EXIT//// RETURN - 打印错误信息, 并 return 返回指定结果// val : return的东西, 当需要 return void; 时候填 ',' 就过 or NIL// fmt : 双引号包裹的格式化字符串// ... : fmt中对应的参数// return : val// #define RETURN(val, fmt, ...) \do { \ CERR(fmt, ##__VA_ARGS__); \ return val; \} while(0)#define NIL#define RETNIL \RETURN(NIL , fmt, ##__VA_ARGS__)#define RETNUL \RETURN(NULL, fmt, ##__VA_ARGS__)#endif//_H_STRUCT
首假使 linux 和 winds 对于 POSIX socket writev
批量读写完结的布局用了不均等类型导致的.
小编尝试写 structc 项目时首先个源文件 : )
协和改了它某些源码和测量试验代码, 化解了方方面面警告. 详细 libuv 在 VS2017
上面运用无外乎 include + lib
0.2 IDE 弱议
带上 libuv.h 下面的 include 头文件
winds 没得选, 最新最全的 visual studio best version 有工夫统治一切.
这边首要说
的是linux 上面大家的采用. 最先叶笔者是 vi + make + gcc + gdb 开拓和编写翻译的.
再增多项目工程中程导弹入下边库
Makefile –
advapi32.lib
iphlpapi.lib
psapi.lib
shell32.lib
user32.lib
userenv.lib
ws2_32.lib
# 编译的目录结构# Release : make # Debug : make D=-D_DEBUG# Clean : make clean
头文件什么的简练导入下边就可以了
make 是编写翻译宣布,make D=-D_DEBUG 是编写翻译 Debug, make clean 项目清理.
手工操作.
WIN32_LEAN_AND_MEAN
_CRT_SECURE_NO_WARNINGS
_CRT_NONSTDC_NO_DEPRECATE
_WINSOCK_DEPRECATED_NO_WARNINGS
这么搞对自己都万幸, 什么都行.
到那基本上 libuv winds 就水到渠成了.
但不要紧越来越精进一步 [vi + make + gcc + gdb] -> [code + F5 + F10 +
F11] 是或不是更妙.
那边写了个示范 demo, 有意思味的能够品尝演习一下
微软当作桌面软件霸主, code(VSCode 简称)不用自身多说, 不得不服. 那开搞
#include <uv.h>
#include <assext.h>
// 继承 uv_timer_t 结构
struct gravity {
uv_timer_t tick;
uv_tty_t tty;
int width;
int height;
int pos;
char * msg;
};
// _update - 更新图片内容
static void _update(struct gravity * grav) {
char data[BUFSIZ];
uv_buf_t buf;
buf.base = data;
//
// \033[2J : 清屏
// \033[H : 光标移到(0, 0)
// \033[%dB : 光标下移 %d 行
// \033[%dC : 光标右移 %d 行
// \033[42;37m : 底色 41 绿底, 字色 37 白字
//
// \033[0m : 关闭所有属性
//
buf.len = sprintf(data, "\033[2J\033[H\033[%dB\033[%dC\033[42;37m%s",
grav->pos,
(grav->width - (int)strlen(grav->msg)) / 2,
grav->msg);
assert(buf.len < BUFSIZ);
if (grav->pos == grav->height) {
// 关闭屏幕额外属性
const char * resets = "\033[0m";
strcat(data, resets);
buf.len += (int)strlen(resets);
}
// 写入消息
uv_try_write((uv_stream_t *)&grav->tty, &buf, 1);
// 当超过当前屏幕, 退出定时器
if (++grav->pos > grav->height) {
// 重置tty
uv_tty_reset_mode();
uv_timer_stop(&grav->tick);
}
}
//
// uv_timer_test - 测试 timer 使用
//
void uv_timer_test(void) {
uv_loop_t * loop = uv_default_loop();
struct gravity grav = { { 0 } };
uv_tty_init(loop, &grav.tty, 1, 0);
uv_tty_set_mode(&grav.tty, UV_TTY_MODE_NORMAL);
// 获取当前屏幕宽高信息
if (uv_tty_get_winsize(&grav.tty, &grav.width, &grav.height)) {
fprintf(stderr, "Could not get TTY information\n");
uv_tty_reset_mode();
return;
}
fprintf(stderr, "Width %d, height %d\n", grav.width, grav.height);
// 启动 timer 刷新屏幕信息
grav.msg = u8"我不甘心 ~";
uv_timer_init(loop, &grav.tick);
uv_timer_start(&grav.tick, (uv_timer_cb)_update, 200, 200);
uv_run(loop, UV_RUN_DEFAULT);
}
- 安装软件
那么些荧屏音讯会动 哈哈, : )
ubuntu best version
vscode
(二傻子 入场 ~ )
安装好 vscode 后, 在其内部安装插件 Microsoft C/C++ for Visual Studio
Code
2.F1 -> Edit Configurations -> c_cpp_properties.json
正文 – 稍加演习
设置如下内容和VS配置很一般
通过上述对libuv情形的搭建和总结先入为主的概念性描述,.
此时完全能够动用 libuv tty 轻便做个
{ "configurations": [ { "name": "Linux", "includePath": [ "/usr/include/c++/7", "/usr/include/x86_64-linux-gnu/c++/7", "/usr/include/c++/7/backward", "/usr/lib/gcc/x86_64-linux-gnu/7/include", "/usr/local/include", "/usr/lib/gcc/x86_64-linux-gnu/7/include-fixed", "/usr/include/x86_64-linux-gnu", "/usr/include", "${workspaceRoot}", "${workspaceRoot}/structc/base", "${workspaceRoot}/structc/struct", "${workspaceRoot}/structc/system" ], "defines": [ "_DEBUG", "__GNUC__" ], "intelliSenseMode": "clang-x64", "browse": { "path": [ "/usr/include/c++/7", "/usr/include/x86_64-linux-gnu/c++/7", "/usr/include/c++/7/backward", "/usr/lib/gcc/x86_64-linux-gnu/7/include", "/usr/local/include", "/usr/lib/gcc/x86_64-linux-gnu/7/include-fixed", "/usr/include/x86_64-linux-gnu", "/usr/include", "${workspaceRoot}" ], "limitSymbolsToIncludedHeaders": true, "databaseFilename": "" }, "compilerPath": "/usr/bin/clang", "cStandard": "c11", "cppStandard": "c++17" } ], "version": 4}
跨平台的小动画了. 笔者先写个, 推荐大家参照他事他说加以考察例子抄写叁遍, 作育手感.
扯一点网络手艺有七个方向
3.F5 -> launch.json
架构师和技艺术专科高校家. 有一点点像在此以前游戏支付中服务器架设和客商端引擎.
不过C技术员依旧重申手感,
遵守规律改 program 项不熟悉成 和 preLaunchTask 前置职责
弱化架构, 追求极致的统一. (说白点, 代码更关键, 能说更加好.)
{ // 使用 IntelliSense 了解相关属性。 // 悬停以查看现有属性的描述。 // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387 "version": "0.2.0", "configurations": [ { "name": " Launch", "type": "cppdbg", "request": "launch", "program": "${workspaceFolder}/Out/main.exe", "args": [], "stopAtEntry": false, "cwd": "${workspaceFolder}", "environment": [], "externalConsole": true, "preLaunchTask": "Debug", "MIMode": "gdb", "setupCommands": [ { "description": "Enable pretty-printing for gdb", "text": "-enable-pretty-printing", "ignoreFailures": true } ] } ]}
#include <uv.h>
#include <chead.h>
#include <assext.h>
struct love {
uv_timer_t tick;
uv_tty_t tty;
int width;
int height;
int pos;
char ** msgs;
int len;
};
static char * _figure[] = {
u8" 背影 :- 汪国真\n",
u8" \n",
u8" 背影\n",
u8" 总是很简单\n",
u8" 简单\n",
u8" 是一种风景\n",
u8" \n",
u8" 背影\n",
u8" 总是很年轻\n",
u8" 年轻\n",
u8" 是一种清明\n",
u8" \n",
u8" 背影\n",
u8" 总是很含蓄\n",
u8" 含蓄\n",
u8" 是一种魅力\n",
u8" \n",
u8" 背影\n",
u8" 总是很孤零\n",
u8" 孤零\n",
u8" 更让人记得清\n"
};
// _love_stty : 内部发送消息
static inline void _love_stty(struct love * love, const char * msg) {
uv_buf_t buf;
buf.base = (char *)msg;
buf.len = (int)strlen(buf.base);
uv_try_write((uv_stream_t *)&love->tty, &buf, 1);
}
// _love_init : 初始化当前 tty 结构
static void _love_init(struct love * love) {
uv_loop_t * loop = uv_default_loop();
memset(love, 0, sizeof *love);
// 初始化 tty 环境
uv_tty_init(loop, &love->tty, 1, 0);
uv_tty_set_mode(&love->tty, UV_TTY_MODE_NORMAL);
// 只对 tty 输出处理
if (uv_guess_handle(1) != UV_TTY)
CERR_EXIT("uv_guess_handle(1) != UV_TTY!");
// 获取当前屏幕宽高信息
if (uv_tty_get_winsize(&love->tty, &love->width, &love->height)) {
uv_tty_reset_mode();
CERR_EXIT("Could not get TTY information");
}
// 设置具体内容
love->msgs = _figure;
love->len = LEN(_figure);
// 初始化定时器
uv_timer_init(loop, &love->tick);
}
// _love_screem : 屏幕绘制内容
static void _love_screem(struct love * love) {
char buf[BUFSIZ];
int cnt = love->pos < love->len ? love->pos : love->len;
// 重置索引位置
int idx = love->height - love->pos;
snprintf(buf, LEN(buf), "\033[2J\033[H\033[%dB", idx);
_love_stty(love, buf);
// 全部显示
for (idx = 0; idx < cnt; idx++)
_love_stty(love, love->msgs[idx]);
}
// _update - 更新刷新事件
static void _love_update(struct love * love) {
++love->pos;
// 开始绘制内容
_love_screem(love);
// 运行结束直接返回
if (love->pos >= love->height) {
// 重置tty
uv_tty_reset_mode();
uv_timer_stop(&love->tick);
}
}
//
// uv_love_test - 情怀 ~
//
void uv_love_test(void) {
struct love love;
_love_init(&love);
// 开始初始化, 定时器刷新事件
uv_timer_start(&love.tick, (uv_timer_cb)_love_update, 200, 200);
// 事件启动起来
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
}
4.F5 -> tasks.json
作用是从上到下输出了汪国真先生诗词背影~ 🙂
树立上边职务, 方今只行使了 Debug
背影 –
{ // See https://go.microsoft.com/fwlink/?LinkId=733558 // for the documentation about the tasks.json format "version": "2.0.0", "tasks": [ { "type" : "shell", "label" : "Debug", "command" : "make D=-D_DEBUG" } ]}
背景, 总是很简短, 更令人记得清
那儿大家就能够 F5 搞起来 ~
男士们是还是不是很亲昵, 这么复杂定制化项目都足以可视化调节和测量检验. 还应该有哪个人 ~当然 IDE
有没有
后记 – 好久没扯淡了
都好说,难说的是你是不是耐的下心去感悟工夫的系统,可无法学京东技艺,
对开源缺点和失误敬畏
卓殊招待调换, 错误是在所无免的, 开掘再改吧 ~ O_O
之心, 手艺不见得多厉害, 节操提前贷款没了 ~最后成为奥义之梗 : )
只为你活一天
–
前言 – 无妨说点安顿
步入 structc/structc 看到以下项目结构
wzhi@wzc:~/structc/structc$ tree -L 1.├── base├── conf├── main├── README.md├── struct├── structc.vcxproj├── structc.vcxproj.filters├── structc.vcxproj.user├── system└── test
base : 基础接口封装目录
conf : 配置文件目录
main : 主函数目录
struct : 数据结构接口目录
system : 系统库包装目录
test : 单元测量试验目录
1.0 main 主函数设计
wzhi@wzc:~/structc/structc/main$ tree.├── main.c├── main_init.c├── main_run.c└── main_test.c
最首要关心下入口 mian 主函数设计 main.c
#include "head.h"//// main - 程序的总入口, 从扯开始// argc : 输入参数个数// argv : 参数集// return : 返回程序退出的状态码//int main(int argc, char * argv[]) { // // 初始化 ... ... // ... ... EXTERN_RUN(main_init); // // make D=-D_DEBUG // main_test 单元测试才会启动 //#ifdef _DEBUG EXTERN_RUN(main_test);#endif // ... // ... 启动当前项目运行的主函数 // EXTERN_RUN(main_run, argc, argv); return EXIT_SUCCESS;}
其中 EXTERN_RUN 也很精密
//// EXTERN_RUN - 简单的声明, 并立即使用的宏// ftest : 需要执行的函数名称// ... : 可变参数, 保留//#define EXTERN_RUN(ftest, ...) \do { \ extern void ftest(); \ ftest (__VA_ARGS__); \} while(0)
穿过注解直接动用的宏注解. structc 中 main 函数一共做了二件半事情.
main_init 初步化函数, main_run 业务运转函数, 还会有半个 main_test
运转单元测量试验.
随之大家好赏心悦目看那些单元测量试验套路.
1.1 test 单元测验套路设计
先看看 main_test.c
#include "head.h"//// TEST - 用于单元测试函数, 执行并输出运行时间// ftest : 需要执行的测试函数名称// ... : 可变参数, 保留//#define TEST(ftest, ...) \do { \ extern void ftest(); \ clock_t $s = clock(); \ ftest (##__VA_ARGS__); \ double $e = (double)clock(); \ printf(STR" run time:%lfs\n", /CLOCKS_PER_SEC);\} while(0)//// main_test - *_test is here run// return : void//void main_test(void) { // // 开始你的表演, 单元测试 // EXTERN_RUN(uv_tty_test);}
上述只授予了政工测量试验的本事. 个中 uv_tty_test
函数便是单元测量检验目录下里面二个的单元测量试验函数体.
而大家每一个职业测量检验函数, 顺带会创设贰个同名的 .c 文件.
举例这里是uv_tty_test.c
#include <uv.h>#include <stdio.h>#include <stdlib.h>#include <string.h>//// 测试 libuv tty 操作控制台// 输出一段有颜色的文字//void uv_tty_test(void) { uv_tty_t tty; uv_buf_t buf[3]; unsigned i, len = sizeof buf / sizeof *buf; uv_loop_t * loop = uv_default_loop(); // 目前只对 tty 控制台处理 if (uv_guess_handle(1) != UV_TTY) { fprintf(stderr, "uv_guess_handle != UV_TTY!\n"); exit(EXIT_FAILURE); } uv_tty_init(loop, &tty, 1, 0); uv_tty_set_mode(&tty, UV_TTY_MODE_NORMAL); // 开始发送消息 buf[0].base = "\033[46;37m"; buf[1].base = u8" 喵酱 比 ♥ 里~ \n"; buf[2].base = "\033[0m"; for (i = 0; i < len; ++i) buf[i].len = (int)strlen(buf[i].base); uv_try_write((uv_stream_t *)&tty, buf, len); // 重置终端行为 uv_tty_reset_mode(); uv_run(loop, UV_RUN_DEFAULT);}
思路很直白. 那个就是单元测量试验的真相… . 相比明晰的显示
1.2 system 系统库设计
这当中设计东东广大, 只挑一些特出的供人看看. 代码即注释 ~
socket.h
–
#ifndef _H_SOCKET#define _H_SOCKET#include <time.h>#include <fcntl.h>#include "struct.h"#include <signal.h>#include <sys/types.h>#ifdef __GNUC__#include <netdb.h>#include <unistd.h>#include <sys/un.h>#include <sys/uio.h>#include <sys/time.h>#include <arpa/inet.h>#include <sys/socket.h>#include <netinet/tcp.h>#include <sys/resource.h>//// This is used instead of -1, since the. by WinSock// On now linux EAGAIN and EWOULDBLOCK may be the same value // connect 链接中, linux 是 EINPROGRESS，winds 是 WSAEWOULDBLOCK//typedef int socket_t;#define INVALID_SOCKET #define SOCKET_ERROR // socket_init - 初始化 socket 库初始化方法inline void socket_init(void) { // 管道破裂, 忽略 SIGPIPE 信号 signal(SIGPIPE, SIG_IGN);}inline int socket_close(socket_t s) { return close;}// socket_set_block - 设置套接字是阻塞// socket_set_nonblock - 设置套接字是非阻塞inline int socket_set_block(socket_t s) { int mode = fcntl(s, F_GETFL, 0); return fcntl(s, F_SETFL, mode & ~O_NONBLOCK);}inline int socket_set_nonblock(socket_t s) { int mode = fcntl(s, F_GETFL, 0); return fcntl(s, F_SETFL, mode | O_NONBLOCK);}// socket_recv - 读取数据// socket_send - 写入数据inline int socket_recv(socket_t s, void * buf, int sz) { return (int)read(s, buf, sz);}inline int socket_send(socket_t s, const void * buf, int sz) { return (int)write(s, buf, sz);}#endif#ifdef _MSC_VER#include <ws2tcpip.h>#undef errno#define errno WSAGetLastError()#undef strerror#define strerror ((char * strerr)#undef EINTR#define EINTR WSAEINTR#undef EAGAIN#define EAGAIN WSAEWOULDBLOCK#undef EINPROGRESS#define EINPROGRESS WSAEWOULDBLOCK/* * WinSock 2 extension -- manifest constants for shutdown() */#define SHUT_RD SD_RECEIVE#define SHUT_WR SD_SEND#define SHUT_RDWR SD_BOTH#define SO_REUSEPORT SO_REUSEADDRtypedef SOCKET socket_t;typedef int socklen_t;//// gettimeofday - Linux sys/time.h 中得到微秒时间实现// tv : 返回结果包含秒数和微秒数// tz : 包含的时区, winds 上这个变量没有作用// return : 默认返回 0//extern int gettimeofday(struct timeval * tv, void * tz);//// strerr - linux 上替代 strerror, winds 替代 FormatMessage // error : linux 是 errno, winds 可以是 WSAGetLastError() ... // return : system os 拔下来的提示常量字符串//extern const char * strerr(int err);// socket_init - 初始化 socket 库初始化方法inline void socket_init(void) { WSADATA wsad; WSAStartup(WINSOCK_VERSION, &wsad);}// socket_close - 关闭上面创建后的句柄inline int socket_close(socket_t s) { return closesocket;}// socket_set_block - 设置套接字是阻塞// socket_set_nonblock - 设置套接字是非阻塞inline int socket_set_block(socket_t s) { u_long mode = 0; return ioctlsocket(s, FIONBIO, &mode);}inline int socket_set_nonblock(socket_t s) { u_long mode = 1; return ioctlsocket(s, FIONBIO, &mode);}// socket_recv - 读取数据// socket_send - 写入数据inline int socket_recv(socket_t s, void * buf, int sz) { return sz > 0 ? recv(s, buf, sz, 0) : 0;}inline int socket_send(socket_t s, const void * buf, int sz) { return send(s, buf, sz, 0);}#endif//// 通用 sockaddr_in ipv4 地址//typedef struct sockaddr_in sockaddr_t[1];// socket_dgram - 创建 UDP socket// socket_stream - 创建 TCP socketinline socket_t socket_dgram(void) { return socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);}inline socket_t socket_stream(void) { return socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);}// socket_set_reuse - 开启端口和地址复用// socket_set_keepalive - 开启心跳包检测, 默认2h 5次inline int socket_set_enable(socket_t s, int optname) { int ov = 1; return setsockopt(s, SOL_SOCKET, optname, (void *)&ov, sizeof ov);}inline int socket_set_reuse(socket_t s) { return socket_set_enable(s, SO_REUSEPORT);}inline int socket_set_keepalive(socket_t s) { return socket_set_enable(s, SO_KEEPALIVE);}// socket_set_rcvtimeo - 设置接收数据毫秒超时时间// socket_set_sndtimeo - 设置发送数据毫秒超时时间inline int socket_set_time(socket_t s, int ms, int optname) { struct timeval ov = { 0,0 }; if (ms > 0) { ov.tv_sec = ms / 1000; ov.tv_usec = (ms % 1000) * 1000; } return setsockopt(s, SOL_SOCKET, optname, (void *)&ov, sizeof ov);}inline int socket_set_rcvtimeo(socket_t s, int ms) { return socket_set_time(s, ms, SO_RCVTIMEO);}inline int socket_set_sndtimeo(socket_t s, int ms) { return socket_set_time(s, ms, SO_SNDTIMEO);}// socket_get_error - 得到当前socket error 值, 0 表示正确, 其它都是错误inline int socket_get_error(socket_t s) { int err; socklen_t len = sizeof; int r = getsockopt(s, SOL_SOCKET, SO_ERROR, (void *)&err, &len); return r < 0 ? errno : err;}// socket_recvfrom - recvfrom 接受函数// socket_sendto - sendto 发送函数inline int socket_recvfrom(socket_t s, void * buf, int len, int flags, sockaddr_t in) { socklen_t inlen = sizeof (sockaddr_t); return recvfrom(s, buf, len, flags, (struct sockaddr *)in, &inlen);}inline int socket_sendto(socket_t s, const void * buf, int len, int flags, const sockaddr_t to) { return sendto(s, buf, len, flags, (const struct sockaddr *)to, sizeof(sockaddr_t));}//// socket_recvn - socket 接受 sz 个字节// socket_sendn - socket 发送 sz 个字节//extern int socket_recvn(socket_t s, void * buf, int sz);extern int socket_sendn(socket_t s, const void * buf, int sz);// socket_bind - bind 绑定函数// socket_listen - listen 监听函数// socket_accept - accept 等接函数// socket_connect - connect 链接函数inline int socket_bind(socket_t s, const sockaddr_t addr) { return bind(s, (const struct sockaddr *)addr, sizeof(sockaddr_t));}inline int socket_listen(socket_t s) { return listen(s, SOMAXCONN);}inline socket_t socket_accept(socket_t s, sockaddr_t addr) { socklen_t len = sizeof (sockaddr_t); return accept(s, (struct sockaddr *)addr, &len);}inline int socket_connect(socket_t s, const sockaddr_t addr) { return connect(s, (const struct sockaddr *)addr, sizeof(sockaddr_t));}//// socket_binds - 端口绑定返回绑定好的 socket fd, 返回 INVALID_SOCKET or PF_INET PF_INET6// socket_listens - 端口监听返回监听好的 socket fd.//extern socket_t socket_binds(const char * ip, uint16_t port, uint8_t protocol, int * family);extern socket_t socket_listens(const char * ip, uint16_t port, int backlog);//// socket_addr -socket_recv 通过 ip, port 构造 ipv4 结构//extern int socket_addr(const char * ip, uint16_t port, sockaddr_t addr);// socket_pton - 返回 ip 串inline char * socket_pton(sockaddr_t addr, char ip[INET_ADDRSTRLEN]) { return (char *)inet_ntop(AF_INET, &addr->sin_addr, ip, INET_ADDRSTRLEN);}//// socket_host - 通过 ip:port 串得到 socket addr 结构// host : ip:port 串// addr : 返回最终生成的地址// return : >= EBase 表示成功//extern int socket_host(const char * host, sockaddr_t addr);//// socket_tcp - 创建 TCP 详细套接字// host : ip:port 串 // return : 返回监听后套接字//extern socket_t socket_tcp(const char * host);//// socket_udp - 创建 UDP 详细套接字// host : ip:port 串 // return : 返回绑定后套接字//extern socket_t socket_udp(const char * host);//// socket_connects - 返回链接后的阻塞套接字// host : ip:port 串 // return : 返回链接后阻塞套接字//extern socket_t socket_connects(const char * host);//// socket_connectos - 返回链接后的非阻塞套接字// host : ip:port 串 // ms : 链接过程中毫秒数// return : 返回链接后非阻塞套接字//extern socket_t socket_connectos(const char * host, int ms);#endif//_H_SOCKET
socket.c
–
#include "socket.h"#ifdef _MSC_VER//// gettimeofday - Linux sys/time.h 中得到微秒时间实现// tv : 返回结果包含秒数和微秒数// tz : 包含的时区, winds 上这个变量没有作用// return : 默认返回 0//int gettimeofday(struct timeval * tv, void * tz) { struct tm m; SYSTEMTIME se; GetLocalTime(&se); m.tm_year = se.wYear - 1900; m.tm_mon = se.wMonth - 1; m.tm_mday = se.wDay; m.tm_hour = se.wHour; m.tm_min = se.wMinute; m.tm_sec = se.wSecond; m.tm_isdst = -1; // 不考虑夏令时 tv->tv_sec = (long)mktime(&m); tv->tv_usec = se.wMilliseconds * 1000; return 0;}#endif//// socket_recvn - socket 接受 sz 个字节// socket_sendn - socket 发送 sz 个字节//int socket_recvn(socket_t s, void * buf, int sz) { int r, n = sz; while (n > 0) { r = recv(s, buf, n, 0); if (r == 0) break; if (r == SOCKET_ERROR) { if (errno == EINTR) continue; return SOCKET_ERROR; } n -= r; buf = (char *)buf + r; } return sz - n;}int socket_sendn(socket_t s, const void * buf, int sz) { int r, n = sz; while (n > 0) { r = send(s, buf, n, 0); if (r == 0) break; if (r == SOCKET_ERROR) { if (errno == EINTR) continue; return SOCKET_ERROR; } n -= r; buf = (char *)buf + r; } return sz - n;}//// socket_addr - 通过 ip, port 构造 ipv4 结构//int socket_addr(const char * ip, uint16_t port, sockaddr_t addr) { addr->sin_family = AF_INET; addr->sin_port = htons; addr->sin_addr.s_addr = inet_addr; if (addr->sin_addr.s_addr == INADDR_NONE) { struct hostent * host = gethostbyname; if (!host || !host->h_addr) return EParam; // 尝试一种, 默认 ipv4 memcpy(&addr->sin_addr, host->h_addr, host->h_length); } memset(addr->sin_zero, 0, sizeof addr->sin_zero); return SBase;}//// socket_binds - 端口绑定返回绑定好的 socket fd, 返回 INVALID_SOCKET or PF_INET PF_INET6// socket_listens - 端口监听返回监听好的 socket fd.//socket_t socket_binds(const char * ip, uint16_t port, uint8_t protocol, int * family) { socket_t fd; char ports[sizeof "65535"]; struct addrinfo * addr = NULL, hint = { 0 }; if (NULL == ip || *ip == '\0') ip = "0.0.0.0"; // default INADDR_ANY sprintf(ports, "%hu", port); hint.ai_family = AF_UNSPEC; if (protocol == IPPROTO_TCP) hint.ai_socktype = SOCK_STREAM; else { assert(protocol == IPPROTO_UDP); hint.ai_socktype = SOCK_DGRAM; } hint.ai_protocol = protocol; if (getaddrinfo(ip, ports, &hint, &addr)) return INVALID_SOCKET; fd = socket(addr->ai_family, addr->ai_socktype, 0); if (fd == INVALID_SOCKET) goto err_free; if (socket_set_reuse goto err_close; if (bind(fd, addr->ai_addr, (int)addr->ai_addrlen)) goto err_close; // Success return ip family if *family = addr->ai_family; freeaddrinfo; return fd;err_close: socket_close;err_free: freeaddrinfo; return INVALID_SOCKET;}socket_t socket_listens(const char * ip, uint16_t port, int backlog) { socket_t fd = socket_binds(ip, port, IPPROTO_TCP, NULL); if (INVALID_SOCKET != fd && listen(fd, backlog)) { socket_close; return INVALID_SOCKET; } return fd;}// host_parse - 解析 host 内容static int host_parse(const char * host, char ip[BUFSIZ], uint16_t * pprt) { int port = 0; char * st = ip; if (!host || !*host || *host == ':') strcpy(ip, "0.0.0.0"); else { char c; // 简单检查字符串是否合法 size_t n = strlen; if (n >= BUFSIZ) RETURN(EParam, "host err %s", host); // 寻找分号 while ((c = *host++) != ':' && c) *ip++ = c; *ip = '\0'; if (c == ':') { if (n > ip - st + sizeof "65535") RETURN(EParam, "host port err %s", host); port = atoi; // 有些常识数字, 不一定是魔法 ... :) if (port <= 1024 || port > 65535) RETURN(EParam, "host port err %s, %d", host, port); } } *pprt = port; return SBase;}//// socket_host - 通过 ip:port 串得到 socket addr 结构// host : ip:port 串// addr : 返回最终生成的地址// return : >= EBase 表示成功//int socket_host(const char * host, sockaddr_t addr) { uint16_t port; char ip[BUFSIZ]; if (host_parse(host, ip, &port) < SBase) return EParam; // 开始构造 addr if (NULL == addr) { sockaddr_t nddr; return socket_addr(ip, port, nddr); } return socket_addr(ip, port, addr);}//// socket_tcp - 创建 TCP 详细套接字// host : ip:port 串 // return : 返回监听后套接字//socket_t socket_tcp(const char * host) { uint16_t port; char ip[BUFSIZ]; if (host_parse(host, ip, &port) < SBase) return EParam; return socket_listens(ip, port, SOMAXCONN);}//// socket_udp - 创建 UDP 详细套接字// host : ip:port 串 // return : 返回绑定后套接字//socket_t socket_udp(const char * host) { uint16_t port; char ip[BUFSIZ]; if (host_parse(host, ip, &port) < SBase) return EParam; return socket_binds(ip, port, IPPROTO_UDP, NULL);}//// socket_connects - 返回链接后的阻塞套接字// host : ip:port 串 // return : 返回链接后阻塞套接字//socket_t socket_connects(const char * host) { sockaddr_t addr; socket_t s = socket_stream(); if (INVALID_SOCKET == s) { RETURN(s, "socket_stream is error"); } // 解析配置成功后尝试链接 if (socket_host(host, addr) >= SBase) if (socket_connect >= SBase) return s; socket_close; RETURN(INVALID_SOCKET, "socket_connects %s", host);}//// socket_connecto - connect 超时链接, 返回非阻塞 socket//static int socket_connecto(socket_t s, const sockaddr_t addr, int ms) { int n, r; struct timeval to; fd_set rset, wset, eset; // 还是阻塞的connect if (ms < 0) return socket_connect; // 非阻塞登录, 先设置非阻塞模式 r = socket_set_nonblock; if (r < SBase) return r; // 尝试连接, connect 返回 -1 并且 errno == EINPROGRESS 表示正在建立链接 r = socket_connect; // connect 链接中, linux 是 EINPROGRESS，winds 是 WSAEWOULDBLOCK if (r >= SBase || errno != EINPROGRESS) { socket_set_block; return r; } // 超时 timeout, 直接返回结果 EBase = -1 错误 if (ms == 0) { socket_set_block; return EBase; } FD_ZERO(&rset); FD_SET(s, &rset); FD_ZERO(&wset); FD_SET(s, &wset); FD_ZERO(&eset); FD_SET(s, &eset); to.tv_sec = ms / 1000; to.tv_usec = (ms % 1000) * 1000; n = select((int)s + 1, &rset, &wset, &eset, &to); // 超时直接滚 if (n <= 0) { socket_set_block; return EBase; } // 当连接成功时候,描述符会变成可写 if (n == 1 && FD_ISSET(s, &wset)){ socket_set_block; return SBase; } // 当连接建立遇到错误时候, 描述符变为即可读又可写 if (FD_ISSET(s, &eset) || n == 2) { socklen_t len = sizeof n; // 只要最后没有 error 那就 链接成功 if (!getsockopt(s, SOL_SOCKET, SO_ERROR, (char *)&n, &len) && !n) r = SBase; } socket_set_block; return r;}//// socket_connectos - 返回链接后的非阻塞套接字// host : ip:port 串 // ms : 链接过程中毫秒数// return : 返回链接后非阻塞套接字//socket_t socket_connectos(const char * host, int ms) { sockaddr_t addr; socket_t s = socket_stream(); if (INVALID_SOCKET == s) { RETURN(s, "socket_stream is error"); } // 解析配置成功后尝试链接 if (socket_host(host, addr) >= SBase) if (socket_connecto(s, addr, ms) >= SBase) return s; socket_close; RETURN(INVALID_SOCKET, "socket_connectos %s", host);}
即使 winds, 设计思路也是模仿 linux socket 套路. 营造 socket 接口,
希望下边代码能印证什么是少林
拳法,千锤百练. 前面 base structsystem 代码量十分多, 难一一说.
喜欢的能够一而再抄袭二回. (笔者也是
抄袭外人而步向了编制程序的世界, 掌握那分形的人生呢)
正文 – 风吹草动
通过引言和前言认知了 structc 是怎么样项目, 项目构建,
代码风格等. 这里盘算说一下设计 structc
类型初志. 相当久前写 C 代码, 开采数据结构明确后, 基本全数系统就定下了.
所以想用 C创设多个通用
简短的数据结构库. 所以有了那个项目.
扯一点, 驾驭 structc 项目后可以为何以技艺加点. 举个例子学完 struct 目录,
数据结构能够轻巧结课.
抄完system操作系统能够结课.base 清楚后, 框架中间件设计也算入门了.
通晓全体布局后, 实战中的
脚手架设计也不过尔尔.但缺点也可能有, 见效慢.C 太老了, 想通过 C 看清编程源头,
不下时间是不具体的,
幸运的是终极获得 -> 哈哈-> 怎么脱发又严重了 ….
比如 atom.h
–
#ifndef _H_ATOM#define _H_ATOM#include "atomic.h"//// atom_t 自旋锁类型// [static] atom_t o = 0;// atom_lock;// - One Man RPG// atom_unlock;//typedef volatile long atom_t;// atom_acquire - 维护优化后读写代码不在其前#define atom_acquire() atomic_fence(ATOMIC_ACQUIRE)// atom_release - 维护优化后读写代码不在其后#define atom_release() atomic_fence(ATOMIC_RELEASE)// atom_seq_cst - 维护优化后读写代码前后不动#define atom_seq_cst() atomic_fence(ATOMIC_SEQ_CST)#ifdef __GNUC__#define atom_trylock (!__sync_lock_test_and_set, 1))#define atom_lock while(__sync_lock_test_and_set, 1))#define atom_unlock __sync_lock_release// 内存屏障, 维持代码顺序#define atom_sync() __sync_synchronize()// v += a ; return v;#define atom_add __sync_add_and_fetch, // type tmp = v ; v = a; return tmp;#define atom_set __sync_lock_test_and_set, // v &= a; return v;#define atom_and __sync_and_and_fetch, // return ++v;#define atom_inc __sync_add_and_fetch, 1)// return --v;#define atom_dec __sync_sub_and_fetch, 1)// bool b = v == c; b ? v=a : ; return b;#define atom_cas __sync_bool_compare_and_swap, #endif#ifdef _MSC_VER#include <intrin.h>#include <intrin0.h>/* Interlocked intrinsic mapping for _nf/_acq/_rel */#if defined || defined#define _ACQUIRE ATOMIC_CONCAT#else /* defined || defined */#define _ACQUIRE x#endif /* defined || defined */#define atom_trylock (!_ACQUIRE(_interlockedbittestandset), 0))#define atom_lock while(_ACQUIRE(_interlockedbittestandset), 0))inline void store_release(atom_t * x) { /* store _Value atomically with release memory order */#if defined || defined __dmb(0xB /* _ARM_BARRIER_ISH or _ARM64_BARRIER_ISH*/); __iso_volatile_store32((volatile int *)x, 0);#else _ReadWriteBarrier(); *x = 0;#endif}#define atom_unlock store_release// 保证代码优化后不乱序执行#define atom_sync() MemoryBarrier()// v 和 a 都是 long 这样数据#define atom_add InterlockedAdd((volatile LONG *)&, #define atom_set InterlockedExchange((volatile LONG *)&, #define atom_and InterlockedAnd((volatile LONG *)&, #define atom_inc InterlockedIncrement((volatile LONG *)&#define atom_dec InterlockedDecrement((volatile LONG *)&//// 对于 InterlockedCompareExchange 等价于下面// long tmp = v ; v == a ? v = c : ; return tmp;//// 咱们的 atom_cas 等价于下面// long tmp = v ; v == c ? v = a : ; return tmp;//#define atom_cas == InterlockedCompareExchange((volatile LONG *)&, , )#endif#endif//_H_ATOM
代码在改中变的有意味, 有态度. 当然更迎接同行给予补偿, 共同升高升高 ~
追根究底错误是免不了的 : )
后记 – 江湖再会
金子陵-
