# 2021q1 Homework4 (quiz4) contributed by < `secminhr` > # 題目 ## FFF = ? ```c /** * Return the result when it becomes available. * If @seconds is non-zero and the result does not arrive within specified time, * NULL is returned. Each tpool_future_get() resets the timeout status on * @future. */ void *tpool_future_get(struct __tpool_future *future, unsigned int seconds) { pthread_mutex_lock(&future->mutex); /* turn off the timeout bit set previously */ future->flag &= ~__FUTURE_TIMEOUT; while ((future->flag & __FUTURE_FINISHED) == 0) { if (seconds) { struct timespec expire_time; clock_gettime(CLOCK_MONOTONIC, &expire_time); expire_time.tv_sec += seconds; int status = pthread_cond_timedwait(&future->cond_finished, &future->mutex, &expire_time); if (status == ETIMEDOUT) { future->flag |= __FUTURE_TIMEOUT; pthread_mutex_unlock(&future->mutex); return NULL; } } else FFF; } pthread_mutex_unlock(&future->mutex); return future->result; } ``` `tpool_future_get` 的職責是當 `future` 有結果時將其回傳，或者 timeout 的情況回傳 NULL 。 在 FFF 所在的位置是 `seconds` 為零，也就是沒有限制時間的情況。所以要做的事是等待結果，也就是 `pthread_cond_wait(&future->cond_finished, &future->mutex)` 答案為 `(a)` ## GGG = ? ```c static void *jobqueue_fetch(void *queue) { jobqueue_t *jobqueue = (jobqueue_t *) queue; threadtask_t *task; int old_state; pthread_cleanup_push(__jobqueue_fetch_cleanup, (void *) &jobqueue->rwlock); while (1) { pthread_mutex_lock(&jobqueue->rwlock); pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &old_state); pthread_testcancel(); GGG; pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_state); if (jobqueue->head == jobqueue->tail) { task = jobqueue->tail; jobqueue->head = jobqueue->tail = NULL; } else { threadtask_t *tmp; for (tmp = jobqueue->head; tmp->next != jobqueue->tail; tmp = tmp->next) ; task = tmp->next; tmp->next = NULL; jobqueue->tail = tmp; } pthread_mutex_unlock(&jobqueue->rwlock); ... } ``` `jobqueue_fetch` 是作為 thread 的內容。 而靠近 GGG 這一段的工作是把 `task` 從 `jobqueue` 裡取出來。 因為下面就要對 `jobqueue` 做操作的關係，因此這裡 GGG 要確保 `jobqueue` 非空，反過來說就是如果為空則等待： `while (!jobqueue->tail) pthread_cond_wait(&jobqueue->cond_nonempty, &jobqueue->rwlock)` 答案為 `(c)` ## HHH = ? ```c /** * Schedules the specific function to be executed. * If successful, a future object representing the execution of * the task is returned. Otherwise, it returns NULL. */ struct __tpool_future *tpool_apply(struct __threadpool *pool, void *(*func)(void *), void *arg) { jobqueue_t *jobqueue = pool->jobqueue; threadtask_t *new_head = malloc(sizeof(threadtask_t)); struct __tpool_future *future = tpool_future_create(); if (new_head && future) { new_head->func = func, new_head->arg = arg, new_head->future = future; pthread_mutex_lock(&jobqueue->rwlock); if (jobqueue->head) { new_head->next = jobqueue->head; jobqueue->head = new_head; } else { jobqueue->head = jobqueue->tail = new_head; HHH; } pthread_mutex_unlock(&jobqueue->rwlock); } else if (new_head) { free(new_head); return NULL; } else if (future) { tpool_future_destroy(future); return NULL; } return future; } ``` `tpool_apply` 的用處是把 `func` 包進 `thread_task_t *new_head` 並將 `new_head` 排進 `jobqueue` 裡面。 HHH 所在的地方 `jobqueue->head` 為 NULL ，代表此時 `jobqueue` 為空。 因此在 `new_head` 排進去之後： `jobqueue->head = jobqueue->tail = new_head;` 要發消息讓在等待 `jobqueue->cond_nonempty` 的地方 (GGG) 可以繼續，因此這裡使用： `pthread_cond_broadcast(&jobqueue->cond_nonempty)` 答案為 `(b)` ## KKK = ?, LLL = ? ```c static void *jobqueue_fetch(void *queue) { ... if (task->func) { pthread_mutex_lock(&task->future->mutex); if (task->future->flag & __FUTURE_CANCELLED) { pthread_mutex_unlock(&task->future->mutex); free(task); continue; } else { task->future->flag |= __FUTURE_RUNNING; pthread_mutex_unlock(&task->future->mutex); } void *ret_value = task->func(task->arg); pthread_mutex_lock(&task->future->mutex); if (task->future->flag & __FUTURE_DESTROYED) { pthread_mutex_unlock(&task->future->mutex); pthread_mutex_destroy(&task->future->mutex); pthread_cond_destroy(&task->future->cond_finished); free(task->future); } else { task->future->flag |= KKK; task->future->result = ret_value; LLL; pthread_mutex_unlock(&task->future->mutex); } free(task); } else { pthread_mutex_destroy(&task->future->mutex); pthread_cond_destroy(&task->future->cond_finished); free(task->future); free(task); break; } } ``` KKK 所在的情況是 `func` 的回傳值已經取得而且 `task->future` 不是在 `__FUTURE_DESTROYED` 的狀態，代表這個 `task->future` 已經完成，所以 KKK 應為 `__FUTURE_FINISHED` 答案為 `(b)` LLL 所在位置是 KKK 下面第二行。這時已經將 `future->flag` 標成 FINISHED ，也已經得到結果。所以這裡應該發消息讓在等待 `cond_finished` 的地方 (`tpool_future_get`) 可以繼續，因此： `pthread_cond_broadcast(&task->future->cond_finished)` 答案為 `(a)` # 運作原理 ## 型態與結構 ### __future_flags #### __FUTURE_RUNNING-00001 **設定時機:** `jobqueue_fetch` ， `func` 執行前 #### __FUTURE_FINISHED-00010 **設定時機:** `jobqueue_fetch` ， `func` 執行後 **使用處:** `tpool_future_destroy`, 若 FINISHED 則釋放該 future `tpool_future_get`, 若還沒 FINISHED 則等待 #### __FUTURE_TIMEOUT-00100 **設定時機:** `tpool_future_get`, 超時後 **取消時機:** `tpool_future_get`, 計時前 #### __FUTURE_CANCELLED-01010 (8 | __FUTURE_FINISHED) **設定時機:** `jobqueue_destroy`, 當沒有設定 DESTROYED **使用處:** `tpool_future_destroy`, 若 CANCELLED 則釋放該 future `jobqueue_fetch`, 若 CANCELLED 則不執行 `func` 並釋放 `task` 。 `tpool_future_get`, 若還沒 FINISHED 則等待愛 #### __FUTURE_DESTROYED-10100 (16 | __FUTURE_TIMEOUT) **設定時機:** `tpool_future_destroy`, 當 future 不是 FINISHED 也不是 CANCELLED 。 **使用處:** `jobqueue_destroy`, 若 DESTROYED 則釋放該該future `jobqueue_fetch`, 若 DESTROYED 則釋放該 future #### Freeing path (驗證中) ```graphviz digraph { future[shape=box, label="future\n00000"] future->jobqueue_fetch future->tpool_future_destroy tpool_future_destroy->future2 future2[shape=box label="future\n10100"] future1[shape=box label="future\n00011"] jobqueue_fetch->future1 future1->tpool_future_destroy1 future2->jobqueue_destroy jobqueue_destroy[label="jobqueue_destroy (freed)"] future2->jobqueue_fetch1 jobqueue_fetch1[label="jobqueue_fetch (freed)"] tpool_future_destroy1[label="tpool_future_destroy (freed)"] } ``` ### __threadtask (threadtask_t) 放在 jobqueue 裡面，每個 worker 每次執行一個 task 。 ```c typedef struct __threadtask { void *(*func)(void *); void *arg; struct __tpool_future *future; struct __threadtask *next; } threadtask_t; ``` - `func`: 這個 task 要執行的函式 - `arg`: `func` 的參數 - `future`: 與這個 task 關聯的 future 物件 - `next`: 在 jobqueue 中下一個 task `next` 方向由新到舊 ```graphviz digraph { rankdir=LR newer_task -> older_task [label="next"] } ``` 在程式中有一種特殊的 task ，其 `func` 為 NULL ，用來提示 worker 該停止了。 下面遇到這種 `func` 為 NULL 的 task 時，將直接以 **終止 task** 稱之。 ### __jobqueue (jobqueue_t) 放著 `threadtask_t` 的 queue ，裡面的 task 將會被 worker 執行。 ```c typedef struct __jobqueue { threadtask_t *head, *tail; pthread_cond_t cond_nonempty; pthread_mutex_t rwlock; } jobqueue_t; ``` - `head`, `tail`: 管理這個 queue 的 head ( 最新 task ) 與 tail ( 最舊 task ) - `cond_nonempty`: 對應「這個 jobqueue 非空」的條件變數 - `rwlock`: 對 jobqueue 操作 ( 加入/取出 task ) 時的鎖 ### __tpool_future 對應一個 task 的執行結果 ```c struct __tpool_future { int flag; void *result; pthread_mutex_t mutex; pthread_cond_t cond_finished; }; ``` - `flag`: 五種 __future_flags ，標示目前此 future 的狀況 - `result`: task 被執行完畢後的結果 - `mutex`: 對這個 future 做修改 (`flag` 或 `result`) 時的鎖 - `cond_finished`: 對應「這個 future 已被完成」的條件變數 ### __threadpool ```c struct __threadpool { size_t count; pthread_t *workers; jobqueue_t *jobqueue; }; ``` - `count`: workers 數量 - `workers`: `pthread_t` 的陣列，這些 worker 將執行 `jobqueue` 中的 task - `jobqueue`: 存放著 task 的 queue ## 運作 ## Part A: initialization and task dispatch ### main: 1~9 ```c int main() { int bpp_args[PRECISION + 1]; double bpp_sum = 0; tpool_t pool = tpool_create(4); tpool_future_t futures[PRECISION + 1]; for (int i = 0; i <= PRECISION; i++) { bpp_args[i] = i; futures[i] = tpool_apply(pool, bpp, (void *) &bpp_args[i]); } ... } ``` `bpp_args` 是每個 `bpp` 函式的參數。 `bpp_sum` 是每個 `bpp` 函式回傳結果的相加。 `t_pool_create(4)` 會建立一個 `tpool_t` 並在裡面裡建立4個 worker 。 `futures` 放著每個 future 物件。索引跟 `bpp_args` 對應。 `for` 迴圈設定 `bpp_args` 跟 `futures` ， `futures[i]` 由 `tpool_apply` 建立。 `tpool_apply` 會將傳進來的函式跟參數包裝成 `threadtask_t` 、將其放進 `pool` 的 `jobqueue` 裡並回傳相關的 future 。 ### 使用函式 #### tpool_create ```c struct __threadpool *tpool_create(size_t count) { jobqueue_t *jobqueue = jobqueue_create(); struct __threadpool *pool = malloc(sizeof(struct __threadpool)); if (!jobqueue || !pool) { if (jobqueue) jobqueue_destroy(jobqueue); free(pool); return NULL; } pool->count = count, pool->jobqueue = jobqueue; if ((pool->workers = malloc(count * sizeof(pthread_t)))) { for (int i = 0; i < count; i++) { if (pthread_create(&pool->workers[i], NULL, jobqueue_fetch, (void *) jobqueue)) { for (int j = 0; j < i; j++) pthread_cancel(pool->workers[j]); for (int j = 0; j < i; j++) pthread_join(pool->workers[j], NULL); free(pool->workers); jobqueue_destroy(jobqueue); free(pool); return NULL; } } return pool; } jobqueue_destroy(jobqueue); free(pool); return NULL; } ``` 前段部分（第一個空行前面）是建立 `jobqueue` 跟 `pool` ，如果失敗了就會清除然後回傳 NULL 。 中段部份是在使用 `pthread_create` 建立 `workers` 。每個 worker 都是一個 `pthread_t` 。 worker 要執行的是 `jobqueue_fetch` ，而 `jobqueue` 將被作為 `jobqueue_fetch` 的參數。 一旦有 worker 建立失敗（進入 `if` ），就會取消所有 worker ，並且清理完後回傳 NULL 。 後段部分（第二個空行之後）是 `pool->workers` 的 `malloc` 失敗的情況，會清理後回傳 NULL 。 `tpool_create` 中最重要的部分在 `pthread_create` ，是 **Part B 的啟動處**。 #### jobqueue_create ```c static jobqueue_t *jobqueue_create(void) { jobqueue_t *jobqueue = malloc(sizeof(jobqueue_t)); if (jobqueue) { jobqueue->head = jobqueue->tail = NULL; pthread_cond_init(&jobqueue->cond_nonempty, NULL); pthread_mutex_init(&jobqueue->rwlock, NULL); } return jobqueue; } ``` 這個函式比較單純，就是 `malloc` 出 `jobqueue` 的空間並設定好 `jobqueue` 內部的成員。 成功就回傳 `jobqueue` ，失敗則是 NULL 。 #### jobqueue_destroy ```c static void jobqueue_destroy(jobqueue_t *jobqueue) { threadtask_t *tmp = jobqueue->head; while (tmp) { jobqueue->head = jobqueue->head->next; pthread_mutex_lock(&tmp->future->mutex); if (tmp->future->flag & __FUTURE_DESTROYED) { pthread_mutex_unlock(&tmp->future->mutex); pthread_mutex_destroy(&tmp->future->mutex); pthread_cond_destroy(&tmp->future->cond_finished); free(tmp->future); } else { tmp->future->flag |= __FUTURE_CANCELLED; pthread_mutex_unlock(&tmp->future->mutex); } free(tmp); tmp = jobqueue->head; } pthread_mutex_destroy(&jobqueue->rwlock); pthread_cond_destroy(&jobqueue->cond_nonempty); free(jobqueue); } ``` `jobqueue_destroy` 的最後三行就是資源的釋放。 `while` 迴圈意圖將還在 `jobqueue` 裡面的 `threadtask_t` 清空，但是 while 這段程式不會執行到。 原因是 `jobqueue_destroy` 只在這些情況呼叫： 1. `tpool_create` 在 `malloc` 失敗或 `pthread_create` 失敗的情況 這時候還沒有任何的 `threadtask_t` 在 `jobqueue` 裡面。 2. `tpool_join` `tpool_join` 是在最後結束的時候被呼叫，用來釋放資源。 ```c int tpool_join(struct __threadpool *pool) { size_t num_threads = pool->count; for (int i = 0; i < num_threads; i++) tpool_apply(pool, NULL, NULL); for (int i = 0; i < num_threads; i++) pthread_join(pool->workers[i], NULL); free(pool->workers); jobqueue_destroy(pool->jobqueue); free(pool); return 0; } ``` 因為 `jobqueue_dentroy` 在 `pthread_join` 之後呼叫的關係，而 `pool` 裡面的 `workers` 只會在收到 `func` 為 NULL 的 `threadtask_t` 後停止，所以執行到 `jobqueue_destroy` 時 `jobqueue` 裡面就已經沒有 `threadtask_t` 了。 #### tpool_apply ```c struct __tpool_future *tpool_apply(struct __threadpool *pool, void *(*func)(void *), void *arg) { jobqueue_t *jobqueue = pool->jobqueue; threadtask_t *new_head = malloc(sizeof(threadtask_t)); struct __tpool_future *future = tpool_future_create(); if (new_head && future) { new_head->func = func, new_head->arg = arg, new_head->future = future; pthread_mutex_lock(&jobqueue->rwlock); if (jobqueue->head) { new_head->next = jobqueue->head; jobqueue->head = new_head; } else { jobqueue->head = jobqueue->tail = new_head; pthread_cond_broadcast(&jobqueue->cond_nonempty); } pthread_mutex_unlock(&jobqueue->rwlock); } else if (new_head) { free(new_head); return NULL; } else if (future) { tpool_future_destroy(future); return NULL; } return future; } ``` 這個函式將 `func` 和 `arg` 包進 `new_head` 裡，將 `new_head` 放到 `jobqueue` 的頭部並回傳和 `new_head` 相關的 `future` 。 在 `new_head` 和 `future` 都建立成功的情況，會將 `new_head` 加在 `jobqueue` 的頭部，如果 `jobqueue` 原本是空的還會發訊息 `pthread_cond_broadcast(&jobqueue->cond_nonempty);` 讓在等的 worker 可以繼續。 如果 `new_head` 或者 `future` 失敗的話則會釋放資源，並回傳 NULL 。 中間 `if (jobqueue->head)` 跟他的 else 是 Part A 的重要目標：**將 task 放進 `jobqueue`** 。 #### tpool_future_create ```c static struct __tpool_future *tpool_future_create(void) { struct __tpool_future *future = malloc(sizeof(struct __tpool_future)); if (future) { future->flag = 0; future->result = NULL; pthread_mutex_init(&future->mutex, NULL); pthread_condattr_t attr; pthread_condattr_init(&attr); pthread_cond_init(&future->cond_finished, &attr); pthread_condattr_destroy(&attr); } return future; } ``` 比較單純的函式， `malloc` 出 `future` 並設定其成員。 成功就回傳 `future` ，失敗則是 NULL 。 #### tpool_future_destroy ```c int tpool_future_destroy(struct __tpool_future *future) { if (future) { pthread_mutex_lock(&future->mutex); if (future->flag & __FUTURE_FINISHED || future->flag & __FUTURE_CANCELLED) { pthread_mutex_unlock(&future->mutex); pthread_mutex_destroy(&future->mutex); pthread_cond_destroy(&future->cond_finished); free(future); } else { future->flag |= __FUTURE_DESTROYED; pthread_mutex_unlock(&future->mutex); } } return 0; } ``` 作用是釋放 `future` ，但當 `future` 沒有 FINISHED 或者 CANCELLED 時（也就是沒有被 worker 處理過的話），只將 `flag` 標示成 `__FUTURE_DESTROYED` 。釋放將由之後的 `jobqueue_fetch` 或者 `jobqueue_destroy` 進行。 這次的程式中， else 的情況只發生在 `tpool_apply` 中 `malloc` 失敗時。 ## Part B: fetch and execute tasks Part A 將 task 放進 jobqueue 後，由 Part B 執行這些 task 。 ### jobqueue_fetch ```c static void *jobqueue_fetch(void *queue) { jobqueue_t *jobqueue = (jobqueue_t *) queue; threadtask_t *task; int old_state; pthread_cleanup_push(__jobqueue_fetch_cleanup, (void *) &jobqueue->rwlock); while (1) { pthread_mutex_lock(&jobqueue->rwlock); pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &old_state); pthread_testcancel(); while (!jobqueue->tail) pthread_cond_wait(&jobqueue->cond_nonempty, &jobqueue->rwlock); pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_state); if (jobqueue->head == jobqueue->tail) { task = jobqueue->tail; jobqueue->head = jobqueue->tail = NULL; } else { threadtask_t *tmp; for (tmp = jobqueue->head; tmp->next != jobqueue->tail; tmp = tmp->next) ; task = tmp->next; tmp->next = NULL; jobqueue->tail = tmp; } pthread_mutex_unlock(&jobqueue->rwlock); if (task->func) { pthread_mutex_lock(&task->future->mutex); if (task->future->flag & __FUTURE_CANCELLED) { pthread_mutex_unlock(&task->future->mutex); free(task); continue; } else { task->future->flag |= __FUTURE_RUNNING; pthread_mutex_unlock(&task->future->mutex); } void *ret_value = task->func(task->arg); pthread_mutex_lock(&task->future->mutex); if (task->future->flag & __FUTURE_DESTROYED) { pthread_mutex_unlock(&task->future->mutex); pthread_mutex_destroy(&task->future->mutex); pthread_cond_destroy(&task->future->cond_finished); free(task->future); } else { task->future->flag |= __FUTURE_FINISHED; task->future->result = ret_value; pthread_cond_broadcast(&task->future->cond_finished); pthread_mutex_unlock(&task->future->mutex); } free(task); } else { pthread_mutex_destroy(&task->future->mutex); pthread_cond_destroy(&task->future->cond_finished); free(task->future); free(task); break; } } pthread_cleanup_pop(0); pthread_exit(NULL); } ``` 中間 `while(1)` 是主要獲取和執行 task 的部分。 `while (!jobqueue->tail)` 適當 `jobqueue` 是空著的情況，會等待 `jobqueue->cond_nonempty` 。 接下來的 `if(jobqueue->head == jobqueue->tail){ ... } else { ... }` 取出最尾部 （最舊）的 task ，並維護 jobqueue 的成員 (head/tail) 。 再來 `if (task->func) { ... } else { .... }` 用來判斷是否為[終止 task](https://hackmd.io/dJpJXy59QAasqrRMmB7orQ?both#__threadtask-threadtask_t) 。 如果不是 ( if 判斷為真 ) 則會執行這個 task ，如果是終止 task 則在釋放這個 task 之後跳出迴圈結束 `jobqueue_fetch` 。 #### task 執行 因為裡面還有邏輯，所以再挑出來 ```c pthread_mutex_lock(&task->future->mutex); if (task->future->flag & __FUTURE_CANCELLED) { pthread_mutex_unlock(&task->future->mutex); free(task); continue; } else { task->future->flag |= __FUTURE_RUNNING; pthread_mutex_unlock(&task->future->mutex); } void *ret_value = task->func(task->arg); pthread_mutex_lock(&task->future->mutex); if (task->future->flag & __FUTURE_DESTROYED) { pthread_mutex_unlock(&task->future->mutex); pthread_mutex_destroy(&task->future->mutex); pthread_cond_destroy(&task->future->cond_finished); free(task->future); } else { task->future->flag |= __FUTURE_FINISHED; task->future->result = ret_value; pthread_cond_broadcast(&task->future->cond_finished); pthread_mutex_unlock(&task->future->mutex); } free(task); ``` 如果 future 已經被標 CANCELLED ，則直接不執行 `func`。 如果標 DESTROYED ，則釋放 future 。 剩下的狀況就是要執行且要結果。所以執行完後標 FINISHED 、將結果放進 future 中並 broadcast `cond_finished` 。 這裡的 broadcast 銜接 Part C 。 ## Part C: getting results and exit 這是最後一部分：拿到 Part B 中的執行結果以及退出程式。 ### main: 11~20 ```c int main() { ... for (int i = 0; i <= PRECISION; i++) { double *result = tpool_future_get(futures[i], 0 /* blocking wait */); bpp_sum += *result; tpool_future_destroy(futures[i]); free(result); } tpool_join(pool); printf("PI calculated with %d terms: %.15f\n", PRECISION + 1, bpp_sum); return 0; } ``` 使用 `tpool_future_get` 和設定秒數 0 來等待結果 `result` 。 `bpp_sum += *result` 是公式的一部分。 每次計算完之後將 `futures[i]` 和 `result` 釋放。 最後使用 `tpool_join` 來釋放 `pool` 跟他的成員，並印出計算結果。 ### 使用函式 #### tpool_future_get ```c void *tpool_future_get(struct __tpool_future *future, unsigned int seconds) { pthread_mutex_lock(&future->mutex); /* turn off the timeout bit set previously */ future->flag &= ~__FUTURE_TIMEOUT; while ((future->flag & __FUTURE_FINISHED) == 0) { if (seconds) { struct timespec expire_time; clock_gettime(CLOCK_MONOTONIC, &expire_time); expire_time.tv_sec += seconds; int status = pthread_cond_timedwait(&future->cond_finished, &future->mutex, &expire_time); if (status == ETIMEDOUT) { future->flag |= __FUTURE_TIMEOUT; pthread_mutex_unlock(&future->mutex); return NULL; } } else pthread_cond_wait(&future->cond_finished, &future->mutex); } pthread_mutex_unlock(&future->mutex); return future->result; } ``` 若 `second` 為 0 則等待結果。 反之在時間內 `future` 沒有完成則標示 TIMEOUT 並回傳 NULL 。 #### tpool_join ```c int tpool_join(struct __threadpool *pool) { size_t num_threads = pool->count; for (int i = 0; i < num_threads; i++) tpool_apply(pool, NULL, NULL); for (int i = 0; i < num_threads; i++) pthread_join(pool->workers[i], NULL); free(pool->workers); jobqueue_destroy(pool->jobqueue); free(pool); return 0; } ``` 第一個 for 迴圈發送終止 task 。 第二個 for 迴圈等待所有 worker 終止（此時 jobqueue 也應清空，因為終止 task 在 jobqueue 最頭部）。 `jobqueue_destroy` 釋放 jobqueue，最後釋放 `pool` 。
Last changed by  
 
secminhr
339

Read more

quiz7B - multi-threaded web server

contributed by < secminhr > github repo 進度表 [x] http [x] gain full understand of current codes (including request parsing and response) [ ] 並行與多執行緒程式設計講座 [ ] io_uring

7/16/2021
2021q1 Homework2 (quiz2)

contributed by < secminhr > 題目 問題 1. COND1 = ? 出現在這個函式裡面： static list_ele_t *get_middle(struct list_head *list) {

6/28/2021
2021q1 Homework6 (quiz6)

contributed by < secminhr > Test1 Structure We can tell how number is stored in bn by observing the function bn_from_int. static inline void bn_from_int(struct bn *n, UTYPE_TMP i) { bn_init(n); /* FIXME: what if machine is not little-endian? */

4/18/2021
2021q1 Homework5 (quiz5)

contributed by < secminhr > Quiz Problems VV1 = ? #define NEXT_POWER_OF_2(s) \ VV1 ? s : (size_t) 1 << (64 - __builtin_clzl(s)) We can see that if VV1 is true then s will be returned, which indicates that s is a power of 2. Since a power of 2 has only a bit set, we can easily see that s & (s-1) must be 0, so VV1 is !(s & (s-1)). The answer is (e).

4/12/2021
Read more from secminhr
Published on HackMD