AHMASww’s Blog

workflow poller 理解

2023-06-26T09:50:00+00:00

workflow poller 理解

char data[0] 柔性数组

struct __poller_message
{
	int (*append)(const void *, size_t *, poller_message_t *);
	char data[0];
};

char data[0]从语法逻辑上来看是完全没有意义的，但在结构体中却能完成变长度的作用，即结构体的长度是不定的，可以用来构造缓冲区、数据包等等。对于编译器而言，长度为0的数组不占用空间，数组名本身不占用空间，只是一个偏移量。通过poll_message-> data可以定位到数据的开始。

#include <iostream>


struct buffer
{
    int32_t length;
    char data[0];
};

int main()
{
    buffer my_buffer = {
        .length = 10
    };
    
    // 输出地址
    std::cout << std::hex;
    std::cout << "&my_buffer.length : " << &my_buffer.length << std::endl;
    std::cout << "&my_buffer.data   : " << &my_buffer.data << std::endl;

    return 0;
}

&my_buffer.length : 0x7fffc83ade84
&my_buffer.data   : 0x7fffc83ade88

union

union 是一个用户定义类型，其中所有成员都共享同一个内存位置。此定义意味着在任何给定时间，union 都不能包含来自其成员列表的多个对象。这还意味着，无论 union 具有多少成员，它始终仅使用足以存储最大成员的内存。

timerfd

名称(NAME)

timerfd_create, timerfd_setting, timerfd_gettime - 使用文件描述符来通知的定时器

概要(SYNOPSIS)

#include <sys/timerfd.h>

    int timerfd_create(int clockid, int flags);

    int timerfd_settime(int fd, int flags,
                        const struct itimerspec *new_value,
                        struct itimerspec *old_value);

    int timerfd_gettime(int fd, struct itimerspec *curr_value);

描述(DESCRIPTION)

这些系统调用通过文件描述符来传递定时器失效通知。这些可作为settimer(2)和timer_create(2)的替代，同时文件描述符可以被 select(2)，poll(2), epoll(2)监视。

这些系统调用和timer_create(2), timer_settime(2), timer_gettime(2)是相似的。(并不和timer_getoverrun(2)相似)

`timerfd_create()`

timerfd_create()创建一个全新的定时器实例并将和该定时器相关联的文件描述符作为返回值。clockid参数表示该程序使用的时钟并且必须是下列值之一:

CLOCK_REALTIME: 一个可设定的系统级实时时钟。

CLOCK_MONOTONIC: 一个不可设置的单调递增时钟，用于测量过去某个未指定点的时间，该时间点在系统启动后不会改变。

CLOCK_BOOTTIME(Linux 3.15以后): 和CLOCK_MONOTONIC类似是一个单调递增时钟。CLOCK_MONOTONIC不能在系统挂起的时候使用， CLOCK_BOOTTIME却可以在系统挂起时使用。这在应用需要挂起唤醒时候是有用的。CLOCK_REALTIME在系统时钟是非实时计数是不可用的。

CLOCK_REALTIME_ALARM(Linux 3.11以后): 类似于CLOCK_REALTIME，但是当它挂起时会通知系统，调用系统必须有CAP_WAKE_ALARM能力去设置对应的定时器。

CLOCK_BOOTTIME_ALARM(Linux 3.11以后): 类似于CLOCK_BOOTTIME，但是当它挂起时会通知系统，调用系统必须有CAP_WAKE_ALARM能力去设置对应的定时器。

可以查看clock_getres(2)去获得更多关于时钟的细节。

每个时钟的当前值都可以通过使用clock_gettime(2)去检索。

从Linux2.6.27版本开始，timerfd_create中用以改变行为的参数flags是位宽的下述值。

TFD_NONBLOCK 在新打开的文件描述符设置O_NONBLOCK文件描述标识，使用该标识将节省额外的fcntl(2)调用来达到相同结果。

TFD_CLOEXEC 在新的文件描述符设置close-on-exec(FD_CLOEXEC)文件描述标识，查询设置O_CLOEXEC标识的理由可以查看open(2 )。

Linux版本2.6.26以前(包括2.6.26)，flag必须被设置为0。

`timerfd_settime()`

timerfd_settime()通过文件描述符开始或停止定时器。

定时器中的new_value参数用来表示失效时间和间隔时间。itimer结构体包含使用timespec结构体两部分。

struct timespec {
    time_t  tv_sec;                 /* Seconds */
    long    tv_nsec;                /* Nanoseconds */
};

struct itimerspec {
    struct timespec it_interval;    /* Interval for periodic timer */
    struct timespec it_value;       /* Initial expiration */
};

new_value.it_value用秒和纳秒来表示定时器初始失效时间。new_value.it_value任意一部分不为0值开始定时器，两部分都为0值停止定时器。

设置new_value.it_interval非0值用来表示自初始失效期后重复定时器的周期。如果该值为0，该定时器在new_value.it_value定时的时间上仅失效一次。通常来讲，初始失效时间是和调用定时器时钟的当前时间相关联(即new_value.it_value表示的时间适合当前的 clockid的值相关联)。可以通过flags参数选择一个绝对超时时间。

flags是一个下述值的位掩码：

TFD_TIMER_ABSTIME 将new_value.it_value解释为一个在定时器上的绝对值。该定时器将在到达这个值设定的值上失效。

TFD_TIMER_CANCEL_ON_SET 如果该标识同时伴有TFD_TIMER_ABSTIME和时钟是CLOCK_REALTIME或者CLOCK_REALTIME_ALARM，标记该定时器为可取消的如果实时时钟接口不连续的变化。当该变化产生，可用read(2)从文件描述符读出ECANCELED错误。

如果old_value参数非空，它itimerspec结构体返回之前定时器设置的失效值。后面timerfd_gettime()有描述。

`timerfd_gettime()`

timerfd_gettime()用curr_value参数返回和文件描述符fd相关的定时器设定的失效值。

it_value用来表示到下一次失效时的总时间。如果两项值都是0，则表明该定时器当前是停止的。这项永远包含一个相对时间，不论是否TFD_TIMER_ABSTIME是否被设置。

it_interval项用来返回定时器的间隔。如果值为0，说明定时器仅在curr_value.it_value表示的时间上失效一次。

时间文件描述符上的操作

使用timerfd_create()返回的文件描述符支持下述操作：

`read(2)`

如果该定时器已经失效过一次或者多次自使用timerfd_settime()修改或者上次成功read(2)，那么read(2)返回的buffer返回8位无符号整数表示发生失效的次数。

如果在使用read(2)没有定时器失效，将阻塞到下一个定时失效，或者返回错误EAGAIN当这些文件描述符被设置为非阻塞时。

如果提供的buffer小于8个字节，read(2)将返回EINVAL错误。

如果相关时钟是CLOCK_REALTIME或者CLOCK_REALTIME_ALARM，定时器是绝对的(TFD_TIMER_ABSTIME)并且标识是TFD_TIMER_CANCE L_ON_SET，read(2)将返回错误ECANCELED如果实时时钟接受不连续变化。如果标识不是TFD_TIMER_CANCEL_ON_SET，那么该始终拒绝不连续变化(即clock_settime(2)可能导致read(2)非阻塞，返回0值，if the clock change occurs after the time expired, but before the read(2) on the file descriptor)。

`poll(2), select(2)`

当一个或多个该类型文件描述符发生失效时是可读的。该类型文件描述符也支持其他文件描述符的操作：pselect(2) ppoll(2) epoll(2)。

`ioctl(2)`

下述定时器指定命令是支持的：

TFD_TOC_SET_TICKS(从Linux3.17开始) 调整已经发生定时器失效次数。这个参数指向一个非零8字节整数包含新的失效次数。一旦这个数字被设置，任何等待该定时器的将被唤醒。这个命令唯一的目的是还原过期以便完成还原点/还原的目的。这个操作应当内核被设置成CONFIG_CHECKPOINT_ RESTORE时才是生效的。

`close(2)`

当该文件描述符不再被需要的时候应当关闭。当定时器关联的所有文件描述符都已经关闭时，定时器会被停止并将资源还给内核。

`fork(2)`

在fork(2)后，子进程将拷贝timerfd_create()创建的文件描述符。该文件描述符和父进程指向相同的定时器，且子进程中read(2)将返回定时器的失效信息。

`execve(2)`

由timerfd_create()产生的文件描述符将被保留在execve(2)，并且当定时器启动时将继续尝试失效。

返回值(RETURN VALUE)

成功的情况下将返回一个新的文件描述符，错误的情况下将返回-1并在erron中表明错误。

timerfd_settime()和timerfd_gettime()成功的情况下返回0，错误的情况下返回-1并在errno中表明错误。

错误(ERRORS)

timerfd_create()错误有以下情况：

EINVAL clockid参数既不是CLOCK_MONOTONIC也不是CLOCK_REALTIME；

EINVAL flags参数非法或者在早于Linux2.6.26版本前该参数非0；

EMFILE 到达预先设置的文件描述符数量上限；

ENFILE 到达系统设置的文件描述符数量上限；

ENODEV 不能挂载到匿名索引节点设备；

ENOMEM 没有合适的内核内存来创造定时器。

timerfd_settime()和timerfd_gettime()错误有以下情况：

EBADF fd是非法的文件描述符；

EFAULT new_value old_value或者curr_value非法指向；

EINVAL fd是非法定时器文件描述符；

timerfd_settime()也可以引发下列错误：

EINVAL new_value没有正确设置;

EINVAL flags非法。

版本(VERSION)

这些系统调用自Linux核心2.6.25。glibc支持自2.8。

问题(BUGS)

当前timerfd_create()支持的时钟种类少于timerfd_create(2)。

例子(EXAMPLE)

下面程序创建一个定事情并监视自身。该程序接受最多三个命令行参数。第一个参数表示初始失效的秒数。第二个参数表示间隔的秒数。第三个参数表示程序允许定时器在停止前的失效次数。第二个和第三个参数是可选的。

下面是shell中调用程序的信息：

$ a.out 3 1 100
0.000: timer started
3.000: read: 1; total=1
4.000: read: 1; total=2
^Z                  # type control-Z to suspend the program
[1]+  Stopped                 ./timerfd3_demo 3 1 100
$ fg                # Resume execution after a few seconds
a.out 3 1 100
9.660: read: 5; total=7
10.000: read: 1; total=8
11.000: read: 1; total=9
^C                  # type control-C to suspend the program

源码

#include <sys/timerfd.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>        /* Definition of uint64_t */

#define handle_error(msg) \
        do { perror(msg); exit(EXIT_FAILURE); } while (0)

static void
print_elapsed_time(void)
{
    static struct timespec start;
    struct timespec curr;
    static int first_call = 1;
    int secs, nsecs;

    if (first_call) {
        first_call = 0;
        if (clock_gettime(CLOCK_MONOTONIC, &start) == -1)
            handle_error("clock_gettime");
    }

    if (clock_gettime(CLOCK_MONOTONIC, &curr) == -1)
        handle_error("clock_gettime");

    secs = curr.tv_sec - start.tv_sec;
    nsecs = curr.tv_nsec - start.tv_nsec;
    if (nsecs < 0) {
        secs--;
        nsecs += 1000000000;
    }
    printf("%d.%03d: ", secs, (nsecs + 500000) / 1000000);
}

int
main(int argc, char *argv[])
{
    struct itimerspec new_value;
    int max_exp, fd;
    struct timespec now;
    uint64_t exp, tot_exp;
    ssize_t s;

    if ((argc != 2) && (argc != 4)) {
        fprintf(stderr, "%s init-secs [interval-secs max-exp]\n",
                argv[0]);
        exit(EXIT_FAILURE);
    }

    if (clock_gettime(CLOCK_REALTIME, &now) == -1)
        handle_error("clock_gettime");

    /* Create a CLOCK_REALTIME absolute timer with initial
       expiration and interval as specified in command line */

    new_value.it_value.tv_sec = now.tv_sec + atoi(argv[1]);
    new_value.it_value.tv_nsec = now.tv_nsec;
    if (argc == 2) {
        new_value.it_interval.tv_sec = 0;
        max_exp = 1;
    } else {
        new_value.it_interval.tv_sec = atoi(argv[2]);
        max_exp = atoi(argv[3]);
    }
    new_value.it_interval.tv_nsec = 0;

    fd = timerfd_create(CLOCK_REALTIME, 0);
    if (fd == -1)
        handle_error("timerfd_create");

    if (timerfd_settime(fd, TFD_TIMER_ABSTIME, &new_value, NULL) == -1)
        handle_error("timerfd_settime");

    print_elapsed_time();
    printf("timer started\n");

    for (tot_exp = 0; tot_exp < max_exp;) {
        s = read(fd, &exp, sizeof(uint64_t));
        if (s != sizeof(uint64_t))
            handle_error("read");

        tot_exp += exp;
        print_elapsed_time();
        printf("read: %llu; total=%llu\n",
                (unsigned long long) exp,
                (unsigned long long) tot_exp);
    }

    exit(EXIT_SUCCESS);
}

workflow Executor 理解

2023-06-15T10:05:00+00:00

workflow Executor

Executor需要涉及到对线程池和链表的理解。

`ExecQueue` `ExecSession` `Executor`

class ExecQueue
{
...
private:
    // 给类提供了列表的头节点
    struct list_head session_list;
    // 作为该队列操作的唯一mutex来提供锁
    pthread_mutex_t mutex;
...
};

class ExecSession
{
private:
    // 实际操作处理
    virtual void execute() = 0;
    // 状态处理
    virtual void handle(int state, int error) = 0;

private:
    // 列表
    ExecQueue *queue;
...
};

class Executor
{
...
public:
    // 任务提出
    int request(ExecSession *session, ExecQueue *queue);
...
};

`Executor`函数理解

首先有一个重要的struct，是整个类串联起来的关键。

`ExecSessionEntry`

struct ExecSessionEntry
{
    struct list_head list;
    ExecSession *session;
    thrdpool_t *thrdpool;
};

`Executor::request`

int Executor::request(ExecSession *session, ExecQueue *queue)
{
    struct ExecSessionEntry *entry;

    session->queue = queue;
    // 开辟ExecSessionEntry空间
    entry = (struct ExecSessionEntry *)malloc(sizeof (struct ExecSessionEntry));
    if (entry)
    {
        entry->session = session;
        entry->thrdpool = this->thrdpool;
        pthread_mutex_lock(&queue->mutex);
        // 将entry挂载到queue末尾
        list_add_tail(&entry->list, &queue->session_list);
        // 如果queue下一个就是当前所挂载，则push到线程池中
        if (queue->session_list.next == &entry->list)
        {
            struct thrdpool_task task = {
                .routine = Executor::executor_thread_routine,
                .context = queue
            };
            if (thrdpool_schedule(&task, this->thrdpool) < 0)
            {
                list_del(&entry->list);
                free(entry);
                entry = NULL;
            }
        }

        pthread_mutex_unlock(&queue->mutex);
    }

    return -!entry;
}

`Executor::executor_thread_routine`

void Executor::executor_thread_routine(void *context)
{
    ExecQueue *queue = (ExecQueue *)context;
    struct ExecSessionEntry *entry;
    ExecSession *session;
    
    pthread_mutex_lock(&queue->mutex);
    // queue->session_list.nexts实际上就是ExecSessionEntry的list
    entry = list_entry(queue->session_list.next, struct ExecSessionEntry, list);
    // 去除当前节点
    list_del(&entry->list);
    // 获取要执行的session
    session = entry->session;
    // 判断链表上是否还有节点，有的话继续放入到线程池中
    if (!list_empty(&queue->session_list))
    {
        struct thrdpool_task task = {
            .routine = Executor::executor_thread_routine,
            .context = queue
        };
        __thrdpool_schedule(&task, entry, entry->thrdpool);
    }
    else
        free(entry);
    
    pthread_mutex_unlock(&queue->mutex);
    // 实际任务执行
    session->execute();
    // 状态处理
    session->handle(ES_STATE_FINISHED, 0);
}

`Executor::executor_cancel`

void Executor::executor_cancel(const struct thrdpool_task *task)
{
    ExecQueue *queue = (ExecQueue *)task->context;
    struct ExecSessionEntry *entry;
    struct list_head *pos, *tmp;
    ExecSession *session;

    // 遍历当前链表
    list_for_each_safe(pos, tmp, &queue->session_list)
    {
        // 找到每个任务的入口
        entry = list_entry(pos, struct ExecSessionEntry, list);
        // 删除当前节点
        list_del(pos);
        session = entry->session;
        free(entry);
        // 状态处理
        session->handle(ES_STATE_CANCELED, 0);
    }
}

Antlr4 C++ Visitor方法

2023-06-14T10:05:00+00:00

Antlr4 C++ Visitor方法

Expr.g4文件

grammar Expr;

prog
    :   stat+
    ;

stat
    :   expr NEWLINE            # printExpr
    |   ID '=' expr NEWLINE     # assign
    |   NEWLINE                 # blank
    |   'clear()'               # clear
    ;

expr
    :   expr ('*'|'/') expr     # MulDiv
    |   expr ('+'|'-') expr     # AddSub
    |   INT                     # int
    |   ID                      # id
    |   '(' expr ')'            # parens
    ;

ID
    :   [a-zA-Z]+
    ;

INT
    :   [0-9]+
    ;

NEWLINE
    :   '\r'* '\n'
    ;

MUL
    :   '*'
    ;

DIV 
    :   '/'
    ;

ADD 
    :   '+'
    ;

SUB 
    :   '-'
    ;

WS
    :   [ \t] -> skip
    ;

#表示标签，放置在一个备选分支的右侧，标签可以是任意标识符，但不能与规则冲突。

生成对应的CPP文件

antlr4 -no-listener -visitor -Dlanguage=Cpp Expr.g4

生成如下对应文件

-rw-rw-r-- 1    76  6月 14 16:12 ExprBaseVisitor.cpp
-rw-rw-r-- 1  1436  6月 14 16:12 ExprBaseVisitor.h
-rw-rw-r-- 1   642  6月 14 16:11 Expr.g4
-rw-rw-r-- 1  1531  6月 14 16:12 Expr.interp
-rw-rw-r-- 1  5830  6月 14 16:12 ExprLexer.cpp
-rw-rw-r-- 1  1200  6月 14 16:12 ExprLexer.h
-rw-rw-r-- 1  2385  6月 14 16:12 ExprLexer.interp
-rw-rw-r-- 1   137  6月 14 16:12 ExprLexer.tokens
-rw-rw-r-- 1 19082  6月 14 16:12 ExprParser.cpp
-rw-rw-r-- 1  4662  6月 14 16:12 ExprParser.h
-rw-rw-r-- 1   137  6月 14 16:12 Expr.tokens
-rw-rw-r-- 1    72  6月 14 16:12 ExprVisitor.cpp
-rw-rw-r-- 1  1084  6月 14 16:12 ExprVisitor.h

注意ExprBaseVisitor.h中的内容，会产生对应分支的visitor方法。

...
virtual std::any visitPrintExpr(ExprParser::PrintExprContext *ctx) override {
    return visitChildren(ctx);
  }
...

复写需要的方法

当前g4文件是来实现一个类似计算器的功能，需要复写遇到不同分支时对应的处理。MyVisitor是自己的一个实际操作的类。

#pragma once


#include "ExprBaseVisitor.h"


class MyVisitor : public ExprBaseVisitor
{
public:
    /// @brief visit assign (ID '=' expr NEWLINE)
    /// @param ctx 
    /// @return value 
    virtual std::any visitAssign(ExprParser::AssignContext *ctx) override;

    /// @brief visit print expr (expr NEWLINE)
    /// @param ctx 
    /// @return 0
    virtual std::any visitPrintExpr(ExprParser::PrintExprContext *ctx) override;

    /// @brief visit INT (INT)
    /// @param ctx 
    /// @return value
    virtual std::any visitInt(ExprParser::IntContext *ctx) override;

    /// @brief visit ID (ID)
    /// @param ctx 
    /// @return value or 0
    virtual std::any visitId(ExprParser::IdContext *ctx) override;

    /// @brief visit MulDiv (expr ('*'|'/') expr)
    /// @param ctx 
    /// @return value 
    virtual std::any visitMulDiv(ExprParser::MulDivContext *ctx) override;

    /// @brief visit AddSub (expr ('+'|'-') expr)
    /// @param ctx 
    /// @return value 
    virtual std::any visitAddSub(ExprParser::AddSubContext *ctx) override;

    /// @brief visit parens ('(' expr ')') 
    /// @param ctx 
    /// @return 
    virtual std::any visitParens(ExprParser::ParensContext *ctx) override;

    /// @brief visit clear (clear())
    /// @param ctx 
    /// @return 
    virtual std::any visitClear(ExprParser::ClearContext *ctx) override;

private:
    std::map<std::string, int> memory;

};

#include "MyVisitor.h"


std::any MyVisitor::visitAssign(ExprParser::AssignContext *ctx)
{
    std::string id = ctx->ID()->getText();
    int value = std::any_cast<int>(visit(ctx->expr()));

    memory[id] = value;

    return value;
}

std::any MyVisitor::visitPrintExpr(ExprParser::PrintExprContext *ctx)
{
    int value = std::any_cast<int>(visit(ctx->expr()));
    std::cout << value << std::endl;

    return 0;
}

std::any MyVisitor::visitInt(ExprParser::IntContext *ctx)
{
    return std::stoi(ctx->INT()->getText());
}

std::any MyVisitor::visitId(ExprParser::IdContext *ctx)
{
    std::string id = ctx->ID()->getText();
    if (memory.find(id) != memory.end())
        return memory.find(id)->second;
    else
        return 0;
}

std::any MyVisitor::visitMulDiv(ExprParser::MulDivContext *ctx)
{
    int left = std::any_cast<int>(visit(ctx->expr(0)));
    int right = std::any_cast<int>(visit(ctx->expr(1)));

    if (ctx->MUL() != nullptr)
        return left * right;
    else
        return left / right;
}

std::any MyVisitor::visitAddSub(ExprParser::AddSubContext *ctx)
{
    int left = std::any_cast<int>(visit(ctx->expr(0)));
    int right = std::any_cast<int>(visit(ctx->expr(1)));

    if (ctx->ADD() != nullptr)
        return left + right;
    else
        return left - right;
}

std::any MyVisitor::visitParens(ExprParser::ParensContext *ctx)
{
    return visit(ctx->expr());
}

std::any MyVisitor::visitClear(ExprParser::ClearContext *ctx)
{
    memory.clear();
    std::cout << "clear memory, size : " << memory.size() << std::endl;
    
    return 0;
}

main文件

main文件用来读取文件当中的表达式并用antlr来识别并计算。

#include <iostream>
#include <fstream>
#include <sstream>

#include "ExprLexer.h"
#include "ExprParser.h"
#include "MyVisitor.h"


bool ReadFile(std::string _filePath, std::string& _context)
{
    if (_filePath.empty())
        return false;

    std::ifstream in;
    
    in.open(_filePath, std::ios::in);
    if (in.is_open() == false)
    {
        return false;
    }
    else
    {
        std::stringstream buffer;
        buffer << in.rdbuf();
        _context = buffer.str();
    }

    return true;
}


int main(int argc, char** argv)
{
    if (argc != 2)
    {
        std::cout << "Usage : calc file" << std::endl;
        return -1;
    }
    
    std::string filePath = argv[1];
    std::string context;
    if (ReadFile(filePath, context) == false)
        return -1;
    std::cout << context << std::endl;

    antlr4::ANTLRInputStream input(context);
    ExprLexer lexer(&input);
    antlr4::CommonTokenStream tokens(&lexer);
    ExprParser parser(&tokens);

    antlr4::tree::ParseTree* tree = parser.prog();
    MyVisitor visitor;
    visitor.visit(tree);

    return 0;
}

编译

CMakeLists文件

cmake_minimum_required(VERSION 3.10)

project(calc)

set(CMAKE_CXX_STANDARD 17)

aux_source_directory(. DIR_SRCS)

add_executable(calc ${DIR_SRCS})

target_link_libraries(calc antlr4-runtime)

表达式文件

193
a = 5
b = 6
a+b*2
(1+2)*3
clear()

输出

193
a = 5
b = 6
a+b*2
(1+2)*3
clear()

193
17
9
clear memory, size : 0

Antlr4 C++ Linux 环境安装

2023-06-02T07:35:00+00:00

Antlr4 C++ Linux 环境安装

Antlr4简介

Antlr4是一个强大的开源语法分析工具。

antlr4-XX-complete.jar

Antlr4是有Java语言编写的，哪怕是使用Antlr4用来生成其他语言(C++, Python…)，也需要首先安装Java。

sudo apt install openjdk-19-jdk

需要下载antlr4-XX-complete.jar(本文写时安装的4.13.0版本)，该jar包包含了运行Antlr的工具和编译。如果使用Java语言，到此环境基本完成了。

antlr4-cpp-runtime-XX

如果使用C++语言，需要安装antlr4-cpp-runtime-XX的环境。在官网[https://www.anltr.org/download.html]找到C++ Target，下载源码antlr4-cpp-runtime-XX-source.zip。

编译安装

unzip antlr4-cpp-runtime-4.13.0-source.zip ./antlr-cpp-runtime/
cd antlr4-cpp-runtime-4.13.0-source
mkdir build
cd build
cmake ..
make
sudo make install

note需要注意的是，安装实在/usr/local/include/antlr4-runtime/下的，可能和后来antlr4生成后类文件找不到对应的头文件，可以将/usr/local/include/antlr4-runtime/的文件拷贝出来。

sudo cp -r /usr/local/include/antlr4-runtime/* /usr/local/include/

至此C++环境安装完成。

简单测试

编写g4文件

grammar Hello;

r
    : 'hello' ID
    ;

ID
    : [a-zA-z]+
    ;

WS
    : [ \t\r\n] -> skip
    ;

生成对应Cpp文件

java -jar antlr4-4.13.0-complete.jar -Dlanguage=Cpp Hello.g4

按照antl4-cpp-runtime/demo/Linux/下样例编写自己的main.cpp调用主文件。需要注意的是最后parser部分的调用的方法是自己定义的规则，不能照抄。写完编译，执行文件。

g++ ./*.cpp -lantlr4-runtime

c++ lua 部分调用接口

2023-05-19T05:30:00+00:00

c++调用lua部分接口说明

lua内容

MyGlobalVari1 = 1024
MyGlobalVari2 = 2048
MyTable = { first = 1, second = "second" }

`statckDump(lua_State* L)`

显示栈L中的值

static void statckDump(lua_State* L)
{
    std::cout << "\nbegin dump lua stack" << std::endl;
    int i = 0;
    int top = lua_gettop(L);
    for (i = 1; i <= top; ++i) {
        int t = lua_type(L, i);
        switch (t) {
            case LUA_TSTRING: {
                printf("'%s' ", lua_tostring(L, i));
            }
                break;
            case LUA_TBOOLEAN: {
                printf(lua_toboolean(L, i) ? "true " : "false ");
            }
                break;
            case LUA_TNUMBER: {
                printf("%g ", lua_tonumber(L, i));
            }
                break;
            default: {
                printf("%s ", lua_typename(L, t));
            }
                break;
        }
    }
    std::cout << "\nend dump lua stack" << std::endl;
}

编译

g++ target.cpp -llua -std=c++11

`int lua_getglobal(lua_State* L, const char* name)`

获取Lua程序中全局变量name的值并将其压入栈L中，返回值是该值的类型。

statckDump(L);
lua_getglobal(L, "MyGlobalVari2");
statckDump(L);

结果

begin dump lua stack

end dump lua stack

begin dump lua stack
2048 
end dump lua stack

`void lua_setglobal (lua_State L, const char name)`

将栈L顶的值赋值给name中，并弹出栈顶。

lua_pushnumber(L, 5096);
lua_setglobal(L, "MyGlobalVari1");
statckDump(L);
lua_getglobal(L, "MyGlobalVari1");
statckDump(L);

结果

begin dump lua stack

end dump lua stack

begin dump lua stack
5096 
end dump lua stack

`int lua_getfield (lua_State L, int index, const char k)`

获取栈L[index]所指的table中的key为k的值，并压入栈顶。

lua_getglobal(L, "MyTable");
statckDump(L);
lua_getfield(L, -1, "first");
statckDump(L);

结果

begin dump lua stack
table 
end dump lua stack

begin dump lua stack
table 1 
end dump lua stack

`void lua_setfield (lua_State L, int index, const char k)`

将栈L顶的值赋值给L[index]所指的table的key为k的值，并将栈顶弹出。

lua_pushnumber(L, 11);
lua_setfield(L, -2, "first");
lua_getfield(L, -1, "first");
statckDump(L);

结果

begin dump lua stack
table 11 
end dump lua stack

`void lua_sethook (lua_State *L, lua_Hook f, int mask, int count)`

设置一个调试用钩子函数。lua_Hook f是钩子函数。

workflow list

2023-05-17T07:12:00+00:00

简介

list是workflow中使用的具有头结点的单向链表和双向链表。无论是单项链表还是双向链表都是只有指针而没有具体的数据项，实际使用的时候都需要加上数据项，例如

struct test_node{
    struct slist_node;
    int test_node_data;
}

单向链表 Single-linked list

普通节点和头结点

struct slist_node {
    struct slist_node *next;
}

struct slist_head {
    struct slist_node first, *last;
}

`INIT_SLIST_HEAD`头结点初始化

`slist_add_after` `slist_add_head`和`slist_add_tail`

slist_add_after是一个通用函数，将node节点添加到prev节点后面。

slist_add_head是slist_add_after特例化，将node节点添加到head节点后面。

slist_add_tail将node节点添加到最后。似乎将slist_add_tail写成特例化应该也是可以:

static inline void slist_add_tail(struct slist_node *node
                                  struct slist_head *list)
{
    slist_add_after(node, list->last, list);
}

测试程序

#include <iostream>

#include "list.h"

// single list
struct myListNode
{
    struct slist_node node;
    int val;
    
    myListNode()
    {
        node.next = nullptr;
        val = -1;
    }

    myListNode(int _val)
    {
        node.next = nullptr;
        val = _val;
    }
};

void echoList(slist_head* head)
{
    slist_node* pos = nullptr;
    slist_for_each(pos, head)
        std::cout << ((myListNode*)pos)->val << " ";
    std::cout << std::endl;
}


int main(int argc, char** argv)
{
    slist_head head1, head2;
    INIT_SLIST_HEAD(&head1);
    INIT_SLIST_HEAD(&head2);

    // build head1
    for (int i = 0; i < 5; ++i)
    {
        myListNode* newNode = new myListNode(i);
        slist_add_head(&newNode->node, &head1);
    }
    // echo head1
    std::cout << "head1 : " << std::endl;
    echoList(&head1);

    // build head2
    for (int i = 5; i < 10; ++i)
    {
        myListNode* newNode = new myListNode(i);
        slist_add_tail(&newNode->node, &head2);
    }
    // echo head2
    std::cout << "head2 : " << std::endl;
    echoList(&head2);

    // TODO free memory

    return 0;
}

结果

head1 :
4 3 2 1 0
head2 :
5 6 7 8 9

`slist_del_afer`和`slist_del_head`

类似slist_add_after和slist_add_head

测试程序

#include <iostream>

#include "list.h"

// single list
struct myListNode
{
    struct slist_node node;
    int val;
    
    myListNode()
    {
        node.next = nullptr;
        val = -1;
    }

    myListNode(int _val)
    {
        node.next = nullptr;
        val = _val;
    }
};

void echoList(slist_head* head)
{
    slist_node* pos = nullptr;
    slist_for_each(pos, head)
        std::cout << ((myListNode*)pos)->val << " ";
    std::cout << std::endl;
}


int main(int argc, char** argv)
{
    ...
    // slist_del_after
    slist_node* pos = nullptr;
    slist_node* prev = nullptr;
    slist_for_each_safe(pos, prev, &head1)
    {
        if (((myListNode*)pos)->val == 2)
            slist_del_after(prev, &head1);
    }
    // echo head1
    std::cout << "slist_del_after head1 : " << std::endl;
    echoList(&head1);

    // slist_del_head
    slist_del_head(&head2);
    // echo head2
    std::cout << "slist_del_head head2 : " << std::endl;
    echoList(&head2);
    
    ...
}

结果

head1 : 
4 3 2 1 0 
head2 : 
5 6 7 8 9 
slist_del_after head1 : 
4 3 1 0 
slist_del_head head2 : 
6 7 8 9 

`__slist_splice` `slist_splice`

slist_splice调用__slist_splice，合并两个链表，合并后以head为头结点。

测试程序

    // slist_splice
    slist_splice(&head1, &head2.first, &head2);
    //echo head2
    std::cout << "slist_splice head1 head2 : " << std::endl;
    echoList(&head2);

结果

slist_splice head1 head2 : 
4 3 1 0 6 7 8 9 

双向链表 doubly linked list

结点

struct list_head {
    struct list_head *next, *prev;
}

`INIT_LIST_HEAD` 头结点初始化

`__list_add` `list_add`和`list_add_tail`

__list_add是通用添加节点的方式,list_add是特化在头结点后添加节点(即栈的模式)，list_add_tail是特化在末尾添加节点 (即队列的模式)。

测试程序

struct myDoubleLinkedListNode
{
    struct list_head node;
    int val;

    myDoubleLinkedListNode()
    {
        INIT_LIST_HEAD(&node);
        val = -1;
    }

    myDoubleLinkedListNode(int _val)
    {
        INIT_LIST_HEAD(&node);
        val = _val;
    }
};

void echoDoubleLinkedList(list_head* head)
{
    list_head* pos = nullptr;
    list_for_each(pos, head)
        std::cout << ((myDoubleLinkedListNode*)pos)->val << " ";
    std::cout << std::endl;
}


int main(int argc, char** argv)
{
    ...

    list_head dhead1;
    list_head dhead2;
    INIT_LIST_HEAD(&dhead1);
    INIT_LIST_HEAD(&dhead2);

    // list_add
    for (int i = 0; i < 5; ++i)
    {
        myDoubleLinkedListNode* newNode = new myDoubleLinkedListNode(i);
        list_add(&newNode->node, &dhead1);
    }
    // echo dhead1
    std::cout << "double linked list head1 : " << std::endl;
    echoDoubleLinkedList(&dhead1);

    // list_add_tail
    for (int i = 5; i < 10; ++i)
    {
        myDoubleLinkedListNode* newNode = new myDoubleLinkedListNode(i);
        list_add_tail(&newNode->node, &dhead2);
    }

    // echo dhead2
    std::cout << "double linked list head2 : " << std::endl;
    echoDoubleLinkedList(&dhead2);

    ...

    return 0;
}

结果

double linked list head1 : 
4 3 2 1 0 
double linked list head2 : 
5 6 7 8 9 

`list_del` `list_move`和`list_move_tail`

list_del是通用删除节点方式，删除前后两个节点之间的节点。list_move移除一个节点并将其加入到另外一个队列头结点后；list_move_tail 移除一个节点并将其加入到另一个队列末尾。

测试程序

    // list_del
    list_head* dpos = nullptr;
    list_head* dn = nullptr;
    list_for_each_safe(dpos, dn, &dhead1)
    {
        if (((myDoubleLinkedListNode*)dpos)->val == 2)
            list_del(dpos);
    }
    // echo dhead1
    std::cout << "double linked list head1 : " << std::endl;
    echoDoubleLinkedList(&dhead1);
    std::cout << "------------------------------------" << std::endl;

    // list_move
    dpos = nullptr;
    dn = nullptr;
    list_for_each_safe(dpos, dn, &dhead1)
    {
        if (((myDoubleLinkedListNode*)dpos)->val == 3)
            list_move(dpos, &dhead2);
    }
    // echo dhead1
    std::cout << "double linked list head1 : " << std::endl;
    echoDoubleLinkedList(&dhead1);
    // echo dhead2
    std::cout << "double linked list head2 : " << std::endl;
    echoDoubleLinkedList(&dhead2);
    std::cout << "------------------------------------" << std::endl;

    // list_move_tail
    dpos = nullptr;
    dn = nullptr;
    list_for_each_safe(dpos, dn, &dhead1)
    {
        if (((myDoubleLinkedListNode*)dpos)->val == 1)
            list_move_tail(dpos, &dhead2);
    }
    // echo dhead1
    std::cout << "double linked list head1 : " << std::endl;
    echoDoubleLinkedList(&dhead1);
    // echo dhead2
    std::cout << "double linked list head2 : " << std::endl;
    echoDoubleLinkedList(&dhead2);
    std::cout << "------------------------------------" << std::endl;

结果

------------------------------------
double linked list head1 : 
4 1 0 
double linked list head2 : 
3 5 6 7 8 9 
------------------------------------
double linked list head1 : 
4 0 
double linked list head2 : 
3 5 6 7 8 9 1 
------------------------------------

`__list_splice` `list_splice` `list_splice_init`

list_splice_init调用__list_splice和list_splice，和单链表类似，同样是合并链表。

测试程序

结果

`list_entry`

#define list_entry(prt, type, member) \
    (((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))

在Executor中有一处使用

struct ExecSessionEntry *entry;
...
entry = list_entry(queue->session_list.next, struct ExecSessionEntry, list);

struct内成员地址是连续的。

这里首先queue->session_list在传入时实际也是ExecSessionEntry，所以才能做地址转换；其次(unsigned long)(&((type*)0) ->member)))这里是计算出该member之前所有成员所占的地址，从而计算出整个指针的首地址，才能做后面的地址转换。

workflow msgqueue 个人理解

2023-05-08T09:53:00+00:00

简介

msgqueue是workflow中用于机器资源协调调度的队列实现，完整的介绍可以参照消息队列新实现：Workflow msgqueue代码详解，以下主要列出的是个人在理解过程的经历的一些疑惑。

`msgqueue_create()`

msgqueue_t *msgqueue_create(size_t maxlen, int linkoff)
{
    // 各种初始化，最后设置queue的成员变量如下：
    queue->msg_max = maxlen;
    queue->linkoff = linkoff;
    queue->head1 = NULL;
    queue->head2 = NULL;
    // 借助两个head分别作为两个内部队列的位置
    queue->get_head = &queue->head1;
    queue->put_head = &queue->head2;
    // 一开始队列为空，所以生产者队尾也等于队头
    queue->put_tail = &queue->head2;
    queue->msg_cnt = 0;
    queue->nonblock = 0;
    ...
}

这里的疑惑在于queue->get_headqueue->put_headqueue->put_tail对NULL取地址。在C中,NULL被定义为0，这就意味着 queue->head1 = 0queue->head2 = 0，但是内存中也要有地址来存储这个0值,并且这两个NULL的地址是不一样的。

测试程序:

int main(int argc, char** argv)
{
    void* head1 = NULL;
    void* head2 = NULL;

    printf("address of head1 : %p\naddress of head2 : %p\n", &head1, &head2);

    return 0;
}

结果:

address of head1 : 0x7ffe9eaf3608
address of head2 : 0x7ffe9eaf3610

`msgqueue_put()`

void msgqueue_put(void *msg, msgqueue_t *queue)
{
    // 1. 通过create的时候传进来的linkoffset，算出消息尾部的偏移量
    void **link = (void **)((char *)msg + queue->linkoff);

    // 2. 设置为空，用于表示生产者队列末尾的后面没有其他数据
    *link = NULL;
    // 3. 加生产者锁
    pthread_mutex_lock(&queue->put_mutex);
    // 4. 如果当前已经有msg_max个消息的话
    //    就要等待消费者通过put_cond来叫醒我
    while (queue->msg_cnt > queue->msg_max - 1 && !queue->nonblock)                
        pthread_cond_wait(&queue->put_cond, &queue->put_mutex);

    // 5. put_tail指向这条消息尾部，维护生产者队列的消息个数
    *queue->put_tail = link;
    queue->put_tail = link;
    queue->msg_cnt++;
    pthread_mutex_unlock(&queue->put_mutex);
    // 6. 如果有消费者在等，通过get_cond叫醒他～
    pthread_cond_signal(&queue->get_cond);
} 

`void link = (void )((char *)msg + queue->linkoff);`

link是一个二级指针，将(char*)msg + queue->linkoff转为二级指针，实际值还是一个地址，即*link指向的应该是数据的末尾，这也是后面msg = (char*)queue->get_head - queue->linkoff可以得到原本消息的原因。

`*link = NULL;`

*link实际上指的就是数据的末尾预留的指针的位置，作为next含义，如果该值不为NULL，则是下一个msg的末尾预留指针的位置。

`*queue->put_tail = link;`

`queue->put_tail = link;`

queue->put_tail是一个二级指针,存的是指向queue->head2的地址(初始情况)，*queue->put_tail就等于是queue->head2，这句话在开始时就可以看做queue->head2 = link，即队列的末尾指向下一个数据的预留指针的位置，这就是开发者所说的类似 queue_tail->next = msg的含义。 queue->put_tail = link是将二级指针的值存储为link的值，*queue->put_tail指向的就是最后一个数据预留指针的位置, 这也就是开发者所说的类似queue_tail = msg的含义。综上所述**put_tail实现的一个链表结构。

`signal/broadcast`在持有锁和不持有锁的情况下

在msgqueue_put()中signal在不持有锁的情况下唤醒线程，在__msgqueue_swap()中是在持有锁的情况下唤醒线程的，按照个人理解，先释放锁可能使得其他线程获得锁，而有条件锁的线程会进一步等待，直到获得其他线程释放的锁。似乎在可预测性上比较困难。

KMP算法中next数组求解理解

2021-11-08T00:00:00+00:00

KMP算法中next数组求解理解

next数组定义

对于模式串中当前位置j，next[j]表示此之前的字符串中最长相同前缀后缀长度。

next数组求解

void GetNext(char* str, int* next)
{
    int length = strlen(str);
    next[0] = -1;
    int k = -1;
    int j = 0;

    while (j < length - 1)
    {
        if (k == -1 || str[j] == str[k])
        {
            ++k;
            ++j;
            next[j] = next[k] + 1;
        }
        else
            k = next[k];
    }
}

个人理解

整体过程是顺序求解，利用过去的结果计算现在的结果，动态规划的思想。k就意味着在j位置是最长前缀后缀字符串之外需要比较的第一个字母(注意字符串起始位置从0开始)。

对于next[j]的结果有两个分支，若str[j] == str[k]则长度加1，比较容易理解；若str[j] != str[k]的情况下，为何k = next[k]? 假设此时已经有k长度的前缀后缀字符串，但str[j] != str[k]，k = next[k]意味着前缀中最长前缀后缀字符串之外需要比较的第一个字母(也是长度值)。由于之前k长度的前缀后缀是相同的字符串，所以此时对前缀所找出的次最长前缀后缀字符串必然等于后缀的次最长前缀后缀字符串，但此时需要比较的字符就变为str[j] = str[next[k]]了。即此时需要比较的为0,1,...,k和j-k,j-k+1,...,j两个字符串，并且其中0,1,...,k-1已经比较过了(过去的结果)，所以比较k和j位置的字符即可。

c++ std::thread调用方法

2021-02-03T00:00:00+00:00

c++11 std::thread调用方法

std::thread调用函数

// test.cpp

#include <iostream>
#include <thread>


void print_test(int _value)
{
	std::cout << _value << std::endl;
}

int main(int argc, char* argv[])
{
	std::thread threads[10];

	for (int i = 0; i < 10; i++)
		threads[i] = std::thread(print_test, i + 1);

	for (int i = 0; i < 10; i++)
		threads[i].join()

	return 0;
}

std::thread不在类中调用类的方法

// a.h

#pragma once


class a
{
private:
public:
	void print_test(int _value);
};

// a.cpp

#include <iostream>

#include "a.h"


void a::print_test(int _value)
{
	std::cout << _value << std::endl;
}

// test.cpp

#pragma once
#include <iostream>
#include <thread>

#include "a.h"

int main(int argc, char* argv[])
{
	std::thread threads[10];

	for (int i = 0; i < 10; i++)
	{
		a test;
		threads[i] = std::thread(&test::print_test, test, i + 1);
	}

	for (int i = 0; i < 10; i++)
		threads[i].join();

	return 0;
}

std::thread在类中调用类的方法

// a.h

#pragma once


class a
{
private:
public:
	void print_test(int _value);
	void thread_test();
};

// a.cpp

#include <iostream>
#include <thread>

#include "a.h"


void a::print_test(int _value)
{
	std::cout << _value << std::endl;
}

void a::thread_test()
{
	std::thread threads[10];

	for (int i = 0; i < 10; i++)
		threads[i] = std::thread(&a::print_test, this, i + 1);

	for (int i = 0; i < 10; i++)
		threads[i].join();
}

PEP 8 - Python编码风格指导

2021-01-26T00:00:00+00:00

PEP 8 - Python编码风格指导

声明

本篇文章翻译自PEP8。能力有限，翻译可能存在诸多意思不恰当甚至不正确的地方，还请谅解。如有侵权，立即删除。

介绍

本篇文档为现今主流python版本中代码编译标准库提供编码风格帮助。

本篇文档和PEP257都是受Guido原始python编码风格论文的启发，其中以包含一些来自Barry的编码风格指导。

此风格指导随着时间演变而被认定，过去的风格由于语言本身的变化而被舍弃。

许多项目拥有它们自己的编码风格。在项目中的任何冲突，为项目特定的指导应优先考虑。

A Foolish Consistency is the Hobgoblin of Little Minds(保持适当的一致性？)

Guido认为代码理解性重于书写。该指导手册致力于提升代码的可理解性并将一致性贯穿于Python代码的整个领域。正如PEP20所述，“可理解性第一”。

风格指引有关于一致性，一致性在指引中是重要的，一致性在项目中尤为重要，一致性在模块中是最重要的。

但是，需要知道什么时候去一致性——有时候风格指引推荐并不合适。当你陷入困难中，你应该自我判断。查询其他案例并决定哪种看起来最合适，不要犹豫去寻求帮助。

重要提醒：不要打破向后兼容性来适应此篇PEP。

一些其他好的理由去忽视特定的指引：

1.当采取指引时会导致代码可理解性下降，即使是使用本篇PEP来阅读代码的人。

2.为符合上下文代码风格而打破风格指引(可能是为了历史原因)——尽管这也是一个清除他人代码混乱的机会。

3.当有问题的代码早于准则的引入，没有其他理由修改该代码。

4.当代码需求保留旧版本Python一致性。

编码布局

缩排

使用4个空格作为缩进的等级。

# 与开始分隔符对齐
foo = long_function_name(var_one, var_two,
                         var_three, var_four)

# 更多的缩进
def long_function_name(
        var_one, var_two, var_three,
        var_four):
    print(var_one)

# 悬挂缩进应该增加一个等级
foo = lon_funtion_name(
    var_one, var_two,
    var_three, var_four)

当if-statement条件语句较长而需求被写成多行时:

# 没有额外缩进
if (this_is_one_thing and
    thia_is_another_thing):
    do_something()

# 添加额外缩进
if (this_is_one_thing
        and that_is_another_thing):
    do_something()

多行中结束的括号)、]等可以另起一行，在第一个非空格符的字符处书写，或者在另起一行第一个字符处：

my_list = [
    1, 2, 3,
    4, 5, 6,
    ]

my_list = [
    1, 2, 3,
    4, 5, 6,
]

制表符还是空格符

空格符在缩进中更受欢迎。

Python3中不允许混用制表符和空格符来表示缩进。

一行最长字符数

限制一行最长字符数为79个字符。

换行应在二元运算符前还是后

数十年前推荐的风格还是换行在二元运算符后面，但是这样不利于阅读。

# 不推荐的风格 
income = (gross_wages +
          taxable_interest +
          (dividends - qualified_dividends) -
          ira_deduction -
          student_loan_interest)

# 推荐的风格
income = (gross_wages
          + taxable_interest
          + (dividends - qualified_dividends)
          - ira_deduction
          - student_loan_interest)

空行

在top-level function(顶层函数？单独函数？)和类定义前后应空两行。

在方法定义前后应空一行。

方法内空行以区分逻辑。

Imports

导入通常是单独分开的行。

import os
import sys

导入永远在文件的顶层，只在模块叙述文档之后，但应在模块全局变量和常量之前。同时导入的数据应该如下： 1.标准库导入

2.相关第三方库导入

3.本地特定文件导入

同时，对于上面三组导入之间应插入一个空行。

绝对导入时推荐的，相对导入能多作为一种可选项。

类似from <module> import *应该避免，因为这样可能会引起命名空间中命名冲突，引发混乱。

语句和表达式中的空格符

避免无关的空格符

# 不推荐
spam( ham[ 1 ], { eggs: 2 } )

# 推荐
spam(han[1], {eggs: 2})

# 不推荐
bar = (0, )

# 推荐
foo = (0,)

# 不推荐
if x == 4 : print x , y ; x , y = y , x

# 推荐
if x == 4: print x, y; x, y = y, x

但是，在切片操作中，冒号更像是二元运算符，冒号两边应拥有相同的空格数

# 不推荐
ham[lower + offset:upper + offset]
ham[1: 9], ham[1 :9], ham[1:9 + 3]
ham[lower : : upper]
ham[ : upper]

# 推荐
ham[1:9], ham[1:9:3], ham[:9:3], ham[1::9]
ham[lower:upper], ham[lower:upper:], ham[lower::step]
ham[lower+offset : upper+offset]
ham[: upper_fn(x) : step_fn(x)], ham[:: step_fn(x)]
ham[lower + offset : upper + offset]

不要在方法关键值赋值或者默认参数值中等号两边使用空格符：

# 不推荐
def com(real, imag = 0.0):
    return magic(r = real, i = image)

# 推荐
def com(real, imag=0.0)：
    return magic(r=real, i=imag)

什么时候使用trailing commas(后置逗号？)

Trailing commas通常是可选的，除非是在表示单个元素的元组的时候才是强制的。为了语义清晰，推荐在后括号附近添加。

# 不推荐
FILES = 'setup.cfg',

# 推荐
FILES = ('setup.cfg',)

# 不推荐
FILES = ['setup.cfg', 'tox.ini',]
initialize(FILES, error=True,)

# 推荐
FILES = [
    'setup.cfg',
    'tox.ini',
    ]
initialzie(FILES,
           error=True,
           )

命名习惯

新的模块和包应该按照三个原则：

优先原则：

对用户而言，命名是可见的，所以API应该能表现出用途。

命名风格：

以下命名风格是具有区分性的：

b # 单个小写字母
B # 单个大写字母
lowercase
lower_case_with_underscores
UPPERCASE
UPPER_CASE_WITH_UNDERSCORES
CapitalizedWords
mixedCase
Capitalized_Words_With_Underscores # 丑陋的

约定俗成的命名风格

避免的命名

单独字符名称不要使用’l’，’O’，’i’。

包和模块命名

模块命名应当具有短的，全小写的名称。下划线可以使用在模块名称中如何这提升了可理解性。Python包也应当使用短的，全小写的名称，但不推荐使用下划线。

类命名

类命名通常应该使用CapWords的方式。方法函数的命名类似于函数。

异常命名

因为异常也是类，所以异常的命名类似于类。

全局变量名

此处全局变量名只用于该模块中单独模块中，命名方式类似于方法。

方法参数

类内方法永远将self作为第一个参数，类方法永远将cls作为第一个参数。当参数和保留关键字冲突的时候，加上一个后置下划线，这比缩略参数名要好。

常量

常量是定义在模块层面的，通常使用全大写字母和下划线组成。

AHMASww’s Blog

workflow poller 理解

workflow poller 理解

char data[0] 柔性数组

union

timerfd

名称(NAME)

概要(SYNOPSIS)

描述(DESCRIPTION)

timerfd_create()

timerfd_settime()

timerfd_gettime()

时间文件描述符上的操作

read(2)

poll(2), select(2)

ioctl(2)

close(2)

fork(2)

execve(2)

返回值(RETURN VALUE)

错误(ERRORS)

版本(VERSION)

问题(BUGS)

例子(EXAMPLE)

workflow Executor 理解

workflow Executor

ExecQueue ExecSession Executor

Executor函数理解

ExecSessionEntry

Executor::request

Executor::executor_thread_routine

Executor::executor_cancel

Antlr4 C++ Visitor方法

Antlr4 C++ Visitor方法

Expr.g4文件

生成对应的CPP文件

复写需要的方法

main文件

编译

表达式文件

输出

Antlr4 C++ Linux 环境安装

Antlr4 C++ Linux 环境安装

Antlr4简介

antlr4-XX-complete.jar

antlr4-cpp-runtime-XX

编译安装

简单测试

c++ lua 部分调用接口

c++调用lua部分接口说明

lua内容

statckDump(lua_State* L)

编译

int lua_getglobal(lua_State* L, const char* name)

void lua_setglobal (lua_State *L, const char *name)

int lua_getfield (lua_State *L, int index, const char *k)

void lua_setfield (lua_State *L, int index, const char *k)

void lua_sethook (lua_State *L, lua_Hook f, int mask, int count)

workflow list

简介

单向链表 Single-linked list

INIT_SLIST_HEAD头结点初始化

slist_add_after slist_add_head和slist_add_tail

slist_del_afer和slist_del_head

__slist_splice slist_splice

双向链表 doubly linked list

结点

INIT_LIST_HEAD 头结点初始化

__list_add list_add和list_add_tail

list_del list_move和list_move_tail

__list_splice list_splice list_splice_init

list_entry

workflow msgqueue 个人理解

简介

msgqueue_create()

msgqueue_put()

void **link = (void **)((char *)msg + queue->linkoff);

*link = NULL;

*queue->put_tail = link;

queue->put_tail = link;

`timerfd_create()`

`timerfd_settime()`

`timerfd_gettime()`

`read(2)`

`poll(2), select(2)`

`ioctl(2)`

`close(2)`

`fork(2)`

`execve(2)`

`ExecQueue` `ExecSession` `Executor`

`Executor`函数理解

`ExecSessionEntry`

`Executor::request`

`Executor::executor_thread_routine`

`Executor::executor_cancel`

`statckDump(lua_State* L)`

`int lua_getglobal(lua_State* L, const char* name)`

`void lua_setglobal (lua_State L, const char name)`

`int lua_getfield (lua_State L, int index, const char k)`

`void lua_setfield (lua_State L, int index, const char k)`

`void lua_sethook (lua_State *L, lua_Hook f, int mask, int count)`

`INIT_SLIST_HEAD`头结点初始化

`slist_add_after` `slist_add_head`和`slist_add_tail`

`slist_del_afer`和`slist_del_head`

`__slist_splice` `slist_splice`

`INIT_LIST_HEAD` 头结点初始化

`__list_add` `list_add`和`list_add_tail`

`list_del` `list_move`和`list_move_tail`

`__list_splice` `list_splice` `list_splice_init`

`list_entry`

`msgqueue_create()`

`msgqueue_put()`

`void link = (void )((char *)msg + queue->linkoff);`

`*link = NULL;`

`*queue->put_tail = link;`

`queue->put_tail = link;`

`signal/broadcast`在持有锁和不持有锁的情况下