江南人物的博客

Link

Free English Class! Topic: Hair! 🧔🏽💇✂️ (Lesson Only)

Words/Phrases

eyelashes
makeup
hairstyle/hairdo
get my hair done
hair gel
buzz cut
helmet
When you have a lot of hair, the helmet makes your hair flat.
hair colouring

From ChatGPT:

In general, when a program enters a signal handler in a multi-threaded environment, the behavior regarding other threads depends on how the signal handler is set up and the specific signal that is being handled.

1. Default Behavior: By default, when a signal is delivered to a process, it interrupt the thread that is currently running and executes the signal handler in the context of that thread. Other threads in the process continue running unless they are also interrupted by signals.
2. Thread-Specific Signal Handling: Some signals, such as SIGINT (interrupt signal), SIGTERM (termination signal), or SIGABRT (abort signal), are typically delivered to the entire process, which means they can interrupt any thread. However, other signals, like SIGSEGV (segmentation fault) or SIGILL (illegal signal), are usually delivered to the specific thread that caused the signal.
3. Signal Masking: In a multi-threaded program, you can use signal masking (sigprocmask in POSIX systems) to block certain signals in specific threads. This can affect whether a signal handler interrupts a particular thread or not.
4. Asynchronous-Signal-Safe Functions: Signal handlers should only execute functions are considered “asynchronous-signal-safe” according to POSIX standards. These functions are designed to be safe to call from within a signal handler. Using non-safe functions in a signal handler can lead to undefined behavior.

安装

使用脚本一键监查系统是否安装了 TBB

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

#!/bin/bash
echo "==== 检查 Intel TBB (oneTBB) 安装情况 ===="

# 1. 包管理器检查
if command -v dpkg >/dev/null 2>&1; then
    echo "[dpkg] 检查:"
    dpkg -l | grep tbb || echo "  未找到 tbb 包 (Debian/Ubuntu)"
elif command -v rpm >/dev/null 2>&1; then
    echo "[rpm] 检查:"
    rpm -qa | grep tbb || echo "  未找到 tbb 包 (CentOS/RHEL)"
fi

# 2. pkg-config 检查
echo "[pkg-config] 检查:"
if command -v pkg-config >/dev/null 2>&1; then
    if pkg-config --exists tbb; then
        echo "  版本: $(pkg-config --modversion tbb)"
        echo "  CFLAGS: $(pkg-config --cflags tbb)"
        echo "  LIBS: $(pkg-config --libs tbb)"
    else
        echo "  未检测到 pkg-config 中的 tbb"
    fi
else
    echo "  系统未安装 pkg-config"
fi

# 3. 文件检查
echo "[文件] 检查:"
HEADER_PATH=$(find /usr/include /usr/local/include -type d -name tbb 2>/dev/null | head -n 1)
LIB_PATH=$(find /usr/lib /usr/local/lib /usr/lib64 -name "libtbb.*" 2>/dev/null | head -n 1)

if [ -n "$HEADER_PATH" ]; then
    echo "  头文件目录: $HEADER_PATH"
else
    echo "  未找到 tbb 头文件"
fi

if [ -n "$LIB_PATH" ]; then
    echo "  库文件: $LIB_PATH"
else
    echo "  未找到 tbb 库文件"
fi

# 4. 测试编译
echo "[编译测试] 尝试编译一个 TBB 示例..."
TMP_CODE=$(mktemp /tmp/test_tbb.XXXXXX.cpp)
cat > $TMP_CODE <<'EOF'
#include <tbb/tbb.h>
#include <iostream>
int main() {
    tbb::parallel_for(0, 5, [](int i){ std::cout << i << " "; });
    std::cout << std::endl;
    return 0;
}
EOF

g++ $TMP_CODE -o /tmp/test_tbb -ltbb -std=c++17 2>/tmp/tbb_err.log
if [ $? -eq 0 ]; then
    echo "  ✅ 编译成功，可以使用 TBB"
    /tmp/test_tbb
else
    echo "  ❌ 编译失败，错误信息如下："
    cat /tmp/tbb_err.log
fi

rm -f $TMP_CODE /tmp/test_tbb /tmp/tbb_err.log

从包管理器安装：

1
2

sudo apt update
sudo apt install libtbb-dev

用源码安装

如果需要最新版本，可以从 GitHub 获取 oneTBB

1
2
3
4
5
6

git clone https://github.com/oneapi-src/oneTBB.git
cd oneTBB
mkdir build && cd build
cmake ..
make -j$(nproc)
sudo make install

默认会安装到 /usr/local/include/ 和 /usr/local/lib/。

文档

官方文档：https://uxlfoundation.github.io/oneTBB/

1. TBB 调度原理

1.1. TBB 的任务调度模型

a. 线程池 + 任务队列

• TBB 不让你直接创建线程去执行任务，而是维护一个 固定大小的线程池（数量通常 = CPU 核心数）。
• 所有并行任务都被封装成 task，放入 任务队列。
• 每个工作线程从队列里取任务执行，执行完就取下一个任务。
• 这种模式叫 工作窃取（work-stealing）调度。

b. 工作窃取机制

• 每个线程有自己的双端队列（deque），优先从自己队列尾部取任务执行。
• 当线程自己的队列空了，会从别的线程队列头部 “窃取” 任务。

优点：

• 动态负载均衡：核心利用率高
• 减少锁竞争：线程多操作自己队列，窃取少量访问其他队列

1.2. 与直接使用 std::thread 的区别

1.3. 总结

TBB 高效的核心原因：

• 固定线程池：避免频繁创建销毁线程带来的开销
• 任务化设计：粒度灵活，任务比线程轻量
• 工作窃取：自动负载均衡，提高 CPU 利用率
• 减少锁竞争：每个线程大部分时间只操作自己的队列

所以，用 TBB 写 parallel_for 或 flow::graph 时，即使任务非常小，CPU 核心也能被充分利用，而直接 std::thread 很可能线程创建成本比任务本身还高，性能反而下降。

2. task_group

task_group 的本质

• tbb::task_group 是一种 轻量级任务管理器，用来组织一组并行任务。
• 它本身 不创建线程池，也不维护独立线程。
• 当你调用 task_group.run() 或 task_group.wait() 时：
• 任务会被 提交到当前上下文的线程池，通常是 全局线程池
• 由线程池中的工作线程去调度和执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#include <tbb/tbb.h>
#include <unistd.h>

#include <iostream>
#include <mutex>
#include <thread>
#include <vector>

using namespace std;

std::mutex mtx;

void task_group_function() {
    tbb::task_group tg;
    int max_concurrency = tbb::this_task_arena::max_concurrency();
    {
        std::lock_guard<std::mutex> lock(mtx);
        cout << "Task group max concurrency: " << max_concurrency << endl;
    }
    for (int i = 0; i < 16; ++i) {
        tg.run([i] {
            {
                std::lock_guard<std::mutex> lock(mtx);
                std::cout << "Task group thread " << std::this_thread::get_id() << " is running." << std::endl;
            }
            sleep(1);
        });
    }
    tg.wait();
}

void task_arena_function() {
    tbb::task_arena arena(4);
    int max_concurrency = arena.max_concurrency();
    {
        std::lock_guard<std::mutex> lock(mtx);
        cout << "Task arena max concurrency: " << max_concurrency << endl;
    }
    arena.execute([max_concurrency] {
        tbb::parallel_for(0, 16, [](int i) {
            {
                std::lock_guard<std::mutex> lock(mtx);
                std::cout << "Task arena thread " << std::this_thread::get_id() << " is running." << std::endl;
            }
            sleep(2);
        });
    });
}

int main() {
    // 获取默认task_arena的最大并发线程数
    int arena_max_concurrency = tbb::this_task_arena::max_concurrency();
    std::cout << "Default task_arena max concurrency: " << arena_max_concurrency << std::endl;

    // 创建两个线程
    std::thread tg_thread(task_group_function);
    std::thread ta_thread(task_arena_function);

    // 等待两个线程完成
    tg_thread.join();
    ta_thread.join();

    return 0;
}

测试：

1
2
3
4
5
6
7
8
9
10
11
12
13

$ mkdir build && cd build && cmake .. && make
$ ./tbb_thread_pool > result.txt
$ cat result.txt | grep running | sort | uniq
Task arena thread 140667163379264 is running.
Task arena thread 140667167639104 is running.
Task arena thread 140667184678464 is running.
Task arena thread 140667201848896 is running.
Task group thread 140667167639104 is running.
Task group thread 140667171898944 is running.
Task group thread 140667176158784 is running.
Task group thread 140667180418624 is running.
Task group thread 140667188938304 is running.
Task group thread 140667210303040 is running.

从这两行日志可以看出，arena 和 group 重用了同一个线程 ID ，说明它们同属于同一个全局线程池。

1
2

Task arena thread 140667167639104 is running.
Task group thread 140667167639104 is running.

进一步，我们发现全局线程池中的线程总数是自适应的，比如本例就是 10 个，既不是 task_group 的 8 个，
也不是 task_arena 的 4 个：

TODO

1
2

$ cat result.txt | grep running | sort | uniq | wc -l
10

3. task_arena

TBB 是基于任务，不是基于线程。但是如果你想修改 TBB 的线程数，有两种方法：

• 方法一：使用环境变量 TBB_NUM_THREADS 进行全局设置：

1

export TBB_NUM_THREADS=4

TODO: It doesn’t seem to work!

• 方法二：使用 tbb::task_arena or tbb::task_scheduler_init (Deprecated) 进行线程隔离。

TBB will use this setting locally within the scope of the tbb::task_arena.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <tbb/pipeline.h>
// Deprecated:
// #include <tbb/task_scheduler_init.h>
#include <tbb/task_arena.h>

// Define your pipeline body
class MyPipeline {
public:
    void operator() (tbb::flow_control& fc) const {
        // Your pipeline logic here
        // ...
        // Inform the pipeline that there is no more data
        fc.stop();
    }
};

int main() {
    // Deprecated: tbb::task_scheduler_init init(1);
    tbb::task_arena arena(4); // 4 threads
    // Do some tasks:
    tbb::parallel_pipeline(/* max_number_of_live_tokens */ 4, MyPipeline); // FIXME: 似乎需要放入 arena 的 execute 函数中

    return 0;
}

task_arena 默认 不会去窃取全局线程池的线程

1. task_arena 的线程隔离

tbb::task_arena 是 局部线程池的抽象，可以指定线程数量和优先级。

在 arena.execute(…) 里执行的任务：

优先使用 task_arena 自己的线程（如果 arena 里有空闲线程）

不会去窃取全局线程池的线程

也就是说，task_arena 内的任务和全局线程池是相对隔离的。

2. 嵌套并行和空闲线程利用

如果 task_arena 内的线程空闲不足，默认不会去全局线程池窃取线程。

但是 TBB 内部可能会将一些未使用的线程调度给 arena，但这属于内部优化，不等同于直接窃取整个全局线程池。

总体原则：arena 控制自己的线程数，不影响全局线程池。

3. 全局线程池 vs task_arena 总结

4. 小结

• 默认情况下，全局线程池是唯一的，TBB 所有普通并行调用都会复用它。
• task_arena 提供局部线程池，在其作用域内执行的任务主要使用 arena 的线程，不去抢全局线程池。
• 用 task_arena 可以做局部限制（比如 GUI 线程或限制 CPU 核心占用），对全局线程池影响很小。

4. parallel_for

API: parallel_for

1. 用 my_parallel_for 模拟 parallel_for 的实现：

2. 发出任务的线程也会成为工作线程之一，并参与任务的执行，测试代码如下：

测试结果：

1
2
3
4
5
6
7

$ ./test_parallel_for
Main thread ID: 140220582070080
Processing data: 2 on thread 140220582070080
Processing data: 6 on thread 140220557755968
Processing data: 4 on thread 140220574795328
Processing data: 8 on thread 140220566275648
Processing data: 10 on thread 140220562015808

可见，data 2 是由主线程处理的。也就是说，parallel_for 虽然被称为 a blocking parallel construt，但线程等待所有任务完成期间是非阻塞的，它还可以充当工作线程执行任务池中的任务。

代码模拟 parallel_for 的 wait ：

5. 任务调度器（Task Scheduler）

The Task Scheduler

5.1. 基于任务编程（Task-Based Programming）

当追求性能时，推荐以逻辑任务（logical tasks）而不是线程（threads）来编程，有以下原因：

• 将并行性与可用资源匹配
• 更快的任务启动和关闭
• 更有效的评估顺序
• 改进负载均衡
• 更高层的思考

TODO

5.2. 任务调度器（Task Scheduler）如何工作

How Task Scheduler Works

5.2.1. 深度优先（depth-first）

每个线程都有自己的双端队列，头部称为 top （也称顶部），尾部称为 bottom （也称底部）。
队列的底部是队列的最深处（最末处），底部任务是最新的，顶部任务是最旧的。

深度优先有以下好处：

• 热点缓存命中：最新的任务的缓存是最热的，所以优先执行新任务。
• 最小化空间：广度优先会同时创建指数级数量的共存节点，而深度优先虽然也会创建相同数量的节点，但是只有线性数目的节点会同时共存，因为它创建了其他就绪任务的栈。

生产：当线程产生一个任务时，将其放置到线程自身所有的 deque 的尾部。

消费：当线程执行任务时，根据以下规则顺序选取一个任务：

• 规则 1：获取上一个任务返回的任务，如果有；
• 规则 2：从线程自己所有的 deque 尾部选取一个任务（即深度优先），如果有；
• 规则 3：随机选择一个其他线程的 deque ，从其头部窃取一个任务（即广度优先）。如果被选 deque 为空，则重复本条规则直至成功。

规则 1 被称为 “任务调度绕行（Task Scheduler Bypass）”。

规则 2 是深度优先，这使得当前线程得以不断执行最新的任务直至其完成所有工作。

规则 3 是临时的广度优先，它将潜在的并行转化为实际的并行。

5.2.2. 任务调度绕行（Task Scheduler Bypass）技术

一个任务从产生到被执行涉及以下步骤：

• 将新任务加入线程的 deque 。
• 执行当前任务直至完成。
• 从线程 deque 获取一个任务执行，除非该任务被其他线程窃取走了。

其中，步骤 1 和 步骤 3 会引入不必要的 deque 操作，甚至更糟的是，允许窃取会损害局部性而不会增加显著的并行性。
任务调度器绕行技术可以直接指向下一个要被执行的任务，而不是生产该任务，从而避免了上述问题。
因为根据 “规则 1”，上一个任务产生的新任务会称为第一个备选任务。
此外，该技术几乎保证了该新任务被当前线程执行，而不是其他线程。

注意：当前唯一能使用该优化技术的是使用 tbb::task_group 。

5.3. 指导任务调度器的执行（Guiding Task Scheduler Execution）

Guiding Task Scheduler Execution

默认情况下，任务计划程序会尝试使用所有可用的计算资源。在某些情况下，您可能希望将任务计划程序配置为仅使用其中的一些资源。

注意：指导任务调度程序的执行可能会导致可组合性问题。

TBB 提供 task_arena 接口，通过以下方式指导任务在 arena （竞技场）内被执行:

• 设置首选计算单元；
• 限制部分计算单元。

5.4. 工作隔离（Work Isolation）

Work Isolation

如果当前线程被 parallel_for “阻塞”（不是真正的阻塞，只能称为 a blocking parallel construct），那么该线程被允许拿取第一个循环的任务来执行。这会导致即使是同一个线程内，也可出现乱序执行的情况。在大多数情况下，这没有什么危害。

但是少数情况可能出现错误，例如一个 thread-local 变量可能会在嵌套并行构造之外意外被更改：

在其它场景下，这种行为可能会导致死锁或其他问题。在这些情况下，需要更有力地保证线程内的执行次序。为此，TBB 提供了一些隔离并行构造的执行的方法，以使其任务不会干扰其他同时运行的任务。

其中一种方法是在单独的 task_arena 中执行内层循环：

然而，使用单独的 arena 进行工作隔离并不总是方便的，并且可能会产生明显的开销。为了解决这些缺点，TBB 提供 this_task_arena::isolate 函数，通过限制调用线程仅处理在函数对象范围内（也称为隔离区域）安排的任务，来隔离地运行一个用户提供的函数对象。

当一个线程进入一个任务等待调用或（等待）在一个隔离区域内的阻塞并行结构时，该线程只能执行在该隔离区域内生成的任务及其由其他线程生成的子任务（换句话说，即使子任务是由其他线程生成的，只要属于当前隔离区域，当前线程也可以执行这些任务）。线程被禁止执行任何外层任务或属于其他隔离区域的任务。

下面的示例展示了 this_task_arena::isolate 的使用，以保证在嵌套的并行结构调用时， thread-local 变量不会被意外修改：

** 补充：** 让我们通过一个简单的例子来说明隔离区域内其他线程如何生成子任务，并且这些子任务可以由当前线程执行。

假设我们有一个隔离区域，其中有两个线程：线程 A 和线程 B。我们在这个隔离区域内生成了一些任务，并且这些任务可能会生成子任务。

在这个例子中：

taskA 和 taskB 是在隔离区域内生成的任务。
taskA 生成了两个子任务 Subtask A1 和 Subtask A2。
taskB 生成了两个子任务 Subtask B1 和 Subtask B2。
假设线程 A 执行了 taskA，线程 B 执行了 taskB。在隔离区域内，线程 A 和线程 B 可以执行彼此生成的子任务。例如，线程 A 可以执行 Subtask B1 或 Subtask B2，而线程 B 可以执行 Subtask A1 或 Subtask A2，只要这些子任务属于同一个隔离区域。

6. TBB 的无锁设计

严格来说，TBB 并不是完全无锁，但它尽量采用 无锁（lock-free）设计 来提高性能。下面详细说明：

a. 无锁设计的部分

• 工作窃取双端队列（deque）

  • 线程自己的尾部操作（push/pop）通常是 无锁
  • 窃取线程从头部 steal 任务使用 原子 CAS（Compare-And-Swap），也是无锁操作

• 并行算法（parallel_for, parallel_reduce）

  • 内部任务调度和分割通常用无锁队列 + 原子操作

• 轻量级任务对象（task）引用计数

  • 使用原子操作维护任务生命周期，不依赖互斥锁

总结：TBB 在任务调度和工作窃取上，尽量用无锁和原子操作，保证高性能并发执行。

b. 仍然存在锁的场景

• 队列扩容（grow）

  • 当线程队列满，需要扩容底层数组时会使用轻量锁保护

• 某些并行容器

  • concurrent_hash_map, concurrent_vector 等在处理极端并发情况时会使用锁（有时是读写锁）

• 全局管理或 arena 初始化

  • 初始化线程池、任务调度器时可能使用锁，通常只在启动阶段发生

6.1. 总结

7. TBB 的线程生命期

是的，即使你只调用一次 TBB 并行函数，线程池创建后在整个程序运行期间也不会自动销毁或减少线程数。具体说明如下：

1. 全局线程池生命周期

TBB 默认全局线程池是在 第一次使用 TBB 并行接口时创建的。
线程数固定（通常等于 CPU 核心数），整个程序运行期间一直存在。
不会因为你长时间没有提交任务而销毁线程，也不会自动减少线程数。

2. 线程状态

长时间不使用 TBB 时，线程 处于空闲等待状态，不会占用 CPU。
内存占用仍然存在，因为线程堆栈和线程管理结构仍在。
一旦再次调用 TBB 并行函数，线程立即复用，无需重新创建。

3. 可控策略

如果希望线程在长时间不使用时释放资源，可以：
手动控制线程池生命周期（较复杂，需深入 TBB 内部 API，不推荐）
程序设计上在长时间空闲时退出进程，释放所有线程和内存
一般服务器程序会让线程池持续存在，利用 TBB 的工作窃取和线程复用优势，提高后续任务性能。

✅ 总结

TBB 线程池线程数固定，不会因长时间不使用而减少。
线程空闲时不占用 CPU，但占用内存和线程管理资源。
这种设计是为了 提高任务再次执行的响应速度，适合服务器或长期运行的高性能程序。

8. TBB 是 CPU 密集型的

如果你的程序有大量 I/O 操作，使用 TBB 的一些特点和注意事项需要特别留意，因为 TBB 是为 CPU 密集型任务 和 任务并行化 设计的。具体分析如下：

1. TBB 对 I/O 的特点

• 线程池固定，线程数通常 = CPU 核心数
• 每个线程会被用来执行任务，如果任务中 发生阻塞 I/O（如文件读写、网络请求）：
• 阻塞线程会占用线程池的一个线程
• 其他任务可能因为线程不足而等待

结论：TBB 默认不适合大量阻塞 I/O 的场景

2. 常见问题

3. 解决方法

a. 分离 I/O 线程

不要在 TBB 线程池中直接做阻塞 I/O
可以开独立线程或线程池专门处理 I/O
TBB 线程只处理 CPU 密集型任务

b. 使用异步 I/O

对网络 / 文件 I/O 使用非阻塞或异步 API（如 asio、io_uring）
任务提交给 TBB 时 立即返回，I/O 完成通过回调或 future 处理

c. task_arena + 限制线程

如果必须在 TBB 线程里做少量阻塞 I/O，可以创建一个 局部 task_arena，限制线程数，避免阻塞全局线程池

d. 混合模型

CPU 密集任务用 TBB
阻塞 I/O 用专门线程池 / 异步框架
最后用 future/promise 或 task_group 协调结果

4. 总结

TBB 是 CPU 密集型并行框架，不适合大量阻塞 I/O
阻塞 I/O 会占用线程池线程，降低并行度

建议：

分离 I/O 线程或线程池
使用异步 I/O
TBB 只处理计算任务

9. 推荐阅读

1. Intel Building Blocks 编程指南. James Reinders.
2. Patterns for Parallel Pragramming. Timothy Mattson 等.
3. 设计模式：Design Patterns of Reusable Object-Oriented Software (Addison Wesley). Gamma, Helm, Johnson 和 Vlissides.

gcc

gcc是一个编译套件，包含c、c++、Fortran语言的编译器。

glibc

glibc是一个library，为C程序提供基础公共功能，包括系统调用、数学函数和其他核心组件。
Linux平台和vscode似乎都依赖glibc，如果擅自将LD_LIBRARY_PATH更改为其他版本的glibc路径，则bash会直接crash。

glibc包含以下bin和lib：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

$ cd glibc-v2.34/Linux/RHEL7.0-2017-x86_64/bin && ls
catchsegv  getconf  iconv  locale     makedb  pcprofiledump  sotruss  tzselect  zdump
gencat     getent   ldd    localedef  mtrace  pldd           sprof    xtrace

# 进入其他版本的glibc/lib目录执行ls命令会报错，大概原因可能是因为当前路径的glibc的lib和系统的lib冲突。
$ cd ../lib && ls
ls: relocation error: ./libc.so.6: symbol __tunable_get_val, version GLIBC_PRIVATE not defined in file ld-linux-x86-64.so.2 with link time reference

$ cd .. && ls lib
Mcrt1.o               libanl.so.1             libm.so             libnss_hesiod.so.2
Scrt1.o               libc.a                  libm.so.6           libpcprofile.so
audit                 libc.so                 libmcheck.a         libpthread.a
crt1.o                libc.so.6               libmemusage.so      libpthread.so.0
crti.o                libc_malloc_debug.so    libmvec.a           libresolv.a
crtn.o                libc_malloc_debug.so.0  libmvec.so          libresolv.so
gconv                 libc_nonshared.a        libmvec.so.1        libresolv.so.2
gcrt1.o               libcrypt.a              libnsl.so.1         librt.a
ld-linux-x86-64.so.2  libcrypt.so             libnss_compat.so    librt.so.1
libBrokenLocale.a     libcrypt.so.1           libnss_compat.so.2  libthread_db.so
libBrokenLocale.so    libdl.a                 libnss_db.so        libthread_db.so.1
libBrokenLocale.so.1  libdl.so.2              libnss_db.so.2      libutil.a
libSegFault.so        libg.a                  libnss_dns.so.2     libutil.so.1
libanl.a              libm-2.34.a             libnss_files.so.2
libanl.so             libm.a                  libnss_hesiod.so

查看glibc的版本：

1
2

# 从上可知，ldd是glibc的核心组件之一
$ ldd --version

寻找libc.so的路径：

1
2
3
4
5
6
7
8

$ locate libc.so
/usr/lib/x86_64-linux-gnu/libc.so
/usr/lib/x86_64-linux-gnu/libc.so.6
$ locate libstdc++.so
/usr/lib/gcc/x86_64-linux-gnu/11/libstdc++.so
/usr/lib/x86_64-linux-gnu/libstdc++.so.6
/usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.30
/usr/share/gdb/auto-load/usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.30-gdb.py

安装glibc：

Ubuntu平台

1

sudo apt-get install lib6

RedHat平台

1

sudo yum install glibc

检查GNC C++ Library (libstdc++)的版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

$ strings /usr/lib/libstdc++.so.* | grep LIBCXX
[sjcvl-zhigaoz ] /lan/cva_rel/vxe_main/24.02.650.d000/tools.lnx86/lib/64bit % strings /usr/lib/libstdc++.so.* | grep LIBCXX
GLIBCXX_3.4
GLIBCXX_3.4.1
GLIBCXX_3.4.2
...
GLIBCXX_3.4.19
GLIBCXX_DEBUG_MESSAGE_LENGTH

$ strings /usr/lib/libc.so.* | grep GLIBC
GLIBC_2.0
GLIBC_2.1
GLIBC_2.1.1
...
GLIBC_2.17
GLIBC_PRIVATE

如果你有一个使用了libstdc++的特定的binary或application，可以用下面的命令来检查其版本：

1

$ ldd <your_binary_or_application> | grep libstdc++

使用vscode的“Remote SSH”工具试图连接到Linux时，可能会报错如下：

Warning: Missing GLIBCXX >= 3.4.25! from /usr/lib64/libstdc++.so.6.0.19
Warning: Missing GLIBC >= 2.28! from /usr/lib64/libc-2.17.so
Error: Missing required dependencies. Please refer to our FAQ https://aka.ms/vscode-remote/faq/old-linux for additional information.

这是因为Linux系统上的glibc版本中不包含GLIBCXX_3.4.25及以上的版本。此时需要降级vscode（建议做法）或升级glibc（似乎很难）。

times

1. bash built-in

1

times

2. function

1
2
3

#include <sys/times.h>

clock_t times(struct tms *buf);

malloc/free

See this example

1

char ** backtrace_symbols (void *const *buffer, int size) 

The return value of backtrace_symbols is a pointer obtained via the malloc function, and it is the responsibility of the caller to free that pointer. Note that only the return value need be freed, not the individual strings.

Question: Why does it say “only the return value need be freed, not the individual strings”?

Let us observe the defintion of the malloc/free functions first:

1
2

void *malloc( size_t size );
void free( void *ptr );

free takes a void* pointer to deallocate the memory, it doesn’t care what type it is, even if it is a multi-level pointer. It means that malloc has stored the memory size in some place and free will find it beforing deallocate the memory.

Let us return the question. The memory pointer returned by backtrace_symbols is the char** type, it must be a whole block contigunous memory using malloc and might be enforced to be transformed as char** pointer when returing. So when we free the memory block, the Linux kernel find its actual memory size and deallocate it.

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    char** strings = (char**)malloc(3 * sizeof(char*) + 3 * 50); // assuming a maximum 50 characters per sentence
    char* block = (char*)(strings + 3);
    char* s1 = strcpy(block, "The first sentence"); block += strlen(s1) + 1;
    char* s2 = strcpy(block, "The second sentence"); block += strlen(s2) + 1;
    char* s3 = strcpy(block, "The third sentence");
    strings[0] = s1;
    strings[1] = s2;
    strings[2] = s3;
    for(int i = 0; i < 3; ++i) {
        printf("%s\n", strings[i]);
    }
    free(strings); // deallocate all memory at once

    return 0;
}

More elegant but less economical code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    char** strings = (char**)malloc(3 * sizeof(char*) + 3 * 50);
    char* block = (char*)(strings + 3);
    for(int i = 0; i < 3; ++i) {
        strings[i] = block + i * 50; // Assuming a maximum of 50 characters per sentence
    }
    strcpy(strings[0], "The first sentence");
    strcpy(strings[1], "The second sentence");
    strcpy(strings[2], "The third sentence");

    for(int i = 0; i < 3; ++i) {
        printf("%s\n", strings[i]);
    }

    free(strings); // deallocate all memory at once

    return 0;
}

Reference

• The GNU C Library (glibc) manual: 13.8 Memory-mapped I/O
• The GNU C Library (glibc) manual: 3.4 Memory Protection

Reference

1. 认识UML类关系——依赖、关联、聚合、组合、泛化

shuf

cut

tr

lp

sort

Options:

-t, --field-separator=SEP
    use SEP instead of non-blank to blank transition

-k, --key=POS1[,POS2]
    start a key at POS1 (origin 1), end it at POS2 (default end of line)

-h, --human-numeric-sort
    compare human readable numbers (e.g., 2K 1G)

-n, --numeric-sort
    compare according to string numerical value

nproc

print the number of processing units avaiable.

od / xxd / hexdump

read the binary file.

Notes: byte order

1
2
3
4
5

$ echo -n "ABCD" | xxd
00000000: 4142 4344                                ABCD
$ echo -n "ABCD" | hexdump
0000000 4241 4443                              
0000004

Reference

comm / diff / tkdiff / cmp

Can be used to compare binary or non-binary files.

comm

compare two sorted files line by line.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

$ cat file1.txt 
apple
banana
cherry

$ cat file2.txt 
banana
cherry
date
erase

$ comm file1.txt file2.txt 
apple
                banana
                cherry
        date
        erase

The file must be sorted before using the comm command. Otherwise it will complain that:

comm: file 1 is not in sorted order

and cannot work correctly. For example,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

$ cat file1.txt 
apple
cherry
banana

$ cat file2.txt 
banana
cherry
date
erase

$ comm file1.txt file2.txt 
apple
        banana
                cherry
comm: file 1 is not in sorted order
banana
        date
        erase
comm: input is not in sorted order

diff

Syntax:

diff -u file1 file2

Options:

-e, --ed
    output an ed script

-u, -U NUM, --unified[=NUM]
    output NUM (default 3) lines of unified context
    (that is, print NUM lines before and after the difference line)

tkdiff

Use a GUI to display the differences.

cmp

Prints less information comparing to diff.

Syntax:

cmp file1 file2

ed/vim/sed/awk

列表初始化

struct/union/array默认支持列表初始化。

Struct and union initialization
Array initialization

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

#include <bits/stdc++.h>
// #include <initializer_list>
using namespace std;

class A {
public:
    int x, y, z; // 注意：数据成员必须是public的。
    void print() {
        cout << x << " " << y << " " << z << endl;
    }
};

class B {
public:
    vector<int> vec_;
    int x_;
    void print() {
        cout << "vec_={ ";
        for (int x : vec_) {
            cout << x << " ";
        }
        cout << "}, x_=" << x_ << endl;
    }
};

class C {
public:
    vector<int> vec_;
    void print() {
        cout << "vec_={ ";
        for (int x : vec_) {
            cout << x << " ";
        }
        cout << "}" << endl;
    }
};

int main() {
    // C++会构造一个列表初始化的默认构造函数，
    // 以下(1)和(2)都是调用这个默认构造函数。
    A a1{1,2,3}; // (1) 列表初始化
    A a2({4,5,6}); // (2) 同(1)
    a1.print();
    a2.print();

    B b1{{1,2,3}, 4}; // 内部的"{1,2,3}"用于构造vec_，"4"用于初始化x_
    b1.print();

    // C C1{1,2,3}; // (1) 这里会报错"error: too many initializers for ‘C’"，
    //              //     因为C只有一个数据成员vec_，这里却传入了3个参数
    C c2{{1,2,3}}; // (2) 其中，内部的"{1,2,3}"用于构造vec_，外层的"{}"用于对c2本身进行构造
    c2.print();

    return 0;
}

std::initializer_list

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#include <bits/stdc++.h>
#include <initializer_list>
using namespace std;

struct A {
    int x, y, z;

    A(initializer_list<int> il) {
        initializer_list<int>::iterator it = il.begin();
        x = *it++;
        y = *it++;
        z = *it++;
    }

    void print() {
        cout << x << " " << y << " " << z << endl;
    }
};

struct B {
    vector<int> vec;

    B(initializer_list<int> il) {
        vec = il; // 用initializer_list初始化vector
    }

    void print() {
        cout << "{ ";
        for (int x : vec) {
            cout << x << " ";
        }
        cout << "}" << endl;
    }
};

int main() {
    A a{1,2,3};
    a.print();

    B b{4,5,6};
    b.print();

    return 0;
}

中括号

1. [ ]和test是bash的内部命令，[[ ]]是shell的条件判断关键字。

   1 2 3 4 5 6

   $ type [ [ is a shell builtin $ type test test is a shell builtin $ type [[ [[ is a shell keyword

2. [ ]和test是等价的，用于评估条件表达式。可以使用man [或help [查阅帮助文档。

   1 2 3 4 5 6

   $ help [ [: [ arg... ] Evaluate conditional expression. This is a synonym for the "test" builtin, but the last argument must be a literal `]', to match the opening `['.

3. [[ ]]关键字可以屏蔽shell特殊符号，比如&&、||、>和<可以被认为是条件判断符而不是重定向符。

4. [ ]中使用-a和-o表示逻辑与和逻辑或，[[ ]]中则使用&&和||。

小括号

1. $()用于命令替换。
2. 双小括号(( ))：在比较过程中使用高级数学表达式。

大括号

请阅读：All about {Curly Braces} in Bash

1. ${}用于引用变量。

   与$var相比，${var}是一种消除歧义的措施，比如：

   1 2 3 4 5 6 7 8 9 10 11

   $ var=abc $ vartest=ABC # $var引用变量'var' $ echo $var abc # 引用变量'vartest' $ echo $vartest ABC # 引用变量'var'并在其后加上'test'字符 $ echo ${var}test abctest

2. {}表示分组。

Reference

• Shell中test、单中括号、双中括号的区别
• Differences Between Single and Double Brackets in Bash
• Shell中的括号、双括号、方括号和双方括号