【筆記】Linux核心中的迴圈緩衝區

標籤：

1. 有關ring buffer的理解

1)  ring buffer位首尾相接的buffer，即類似生活中的圓形跑道；

2)  空閑空間+資料空間=ring buffer大小

3)  ring buffer的讀寫，類似生活中在圓形跑道上的追趕遊戲，領跑者位write，追趕著為read

4)  如果read跑的太快，追上write，追趕者read要停下來，否則遊戲結束。即保證沒有資料空間時，不再從ring buffer中讀取資料；

5)  如果write跑的太快，反過來套圈要超過read，此時領跑者write也要停下來。即保證沒有空閑空間時，不再往ring buffer中寫入資料；

6) 所以，read和write之間的距離總是介於開區間(0, buffer大小)

2. linux2.6核心，kfifo的理解

假設buffer的大小為size，讀指標為in，寫指標為out

1) 在電腦中，整型資料加到最大值後溢出會回卷到0，從頭開始）

2)buffer的長度必須是2的n次冪

3) buffer空閑空間和資料空間的大小

1> 空閑空間的大小=size-in+out

2> 空閑空間的大小=in-out

2.2 對資料空間大小計算的理解

本設計總能保證in前out前面的，in跑出unsigned int邊界溢出後回卷。

因為buffer的大小是2的n次冪，而unsigned int也是2的n次冪（32位機器上，n=32），一般buffer大小不會超過unsigned int大小，即unsigned int被分成m個整塊(m>=1)

 

第1種情況：

out+資料空間=in

空閑空間=size-資料控制項=size-(in-out)=size-in+out

第2種情況：(in跑到unsigned int的邊界後，溢出了)

out+資料空間=in，這個等式仍然成立。

所以：空閑空間=size-in+out，亦成立

2.3 寫操作分析（讀操作類似，不再贅述）

2.3.1 基本情況

設落在ring buffer內寫指標為__in，讀指標為__out，需要寫入的空間大小為len, 其中

1. __in = fifo->in % (fifo->size - 1)  (讀寫指標都是從0開始算起)

2. __out = fifo->out % (fifo->size - 1)

3. __size = fifo->size

4.  len <= 空閑空間大小

2.3.2 寫指標沒有回卷

這種情況下，需要寫兩塊buffer，做兩次拷貝動作，設需要寫入的大小為len，第一塊空閑空間大小為left1，第二塊為left2，需要第一次拷貝的大小為len1，第二次拷貝的大小為len2，len1 + len2 = len：

1. left1 = _size-__in;

2. len1 = min(len, left1) = min(len, _size-__in);

3. left2 = __out;

4. len2 = len - len1

2.3.3 寫指標回卷

這種情況下，需要寫一塊buffer，做一次拷貝動作：

1. left1 = __out - __in <= __size - __in;

2. 而寫入長度len <= 空閑空間大小，所以len <= left1 <= __size - __in，所以len1 = len, len1 = min(len, __size - __in)仍然成立

3. left2 = 0;

4. len2 = 0 = len -len1

2.3.4 兩種特殊情況一般化

總結以上兩種情形，第一塊空閑空間大小為left1，第二塊為left2，需要第一次拷貝的大小為len1，第二次拷貝的大小為len2，len1 + len2 = len，則通用情況如下：

1. len <= 空閑空間大小

2. len1 = min(len, _size-__in);

3. len2 = len -len1

 附：linux2.6核心，kfifo的實現代碼

點擊(此處)摺疊或開啟

1. unsigned int __kfifo_put(struct kfifo *fifo, 
2.              unsigned char *buffer, unsigned int len) 
3. { 
4.     unsigned int l; 
6.     len = min(len, fifo->size - fifo->in + fifo->out); 
8.     /* 前提條件寫入大小len不超過空閑空間大小 */ 
10.     smp_mb(); 
12.     /* 第一塊寫入空閑空間，大小為min(len, size-in) */ 
13.     l = min(len, fifo->size - (fifo->in & (fifo->size - 1))); 
14.     memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), buffer, l); 
16.     /* 第二塊寫入空閑空間，大小為len-min(len, size-in) */ 
17.     memcpy(fifo->buffer, buffer + l, len - l); 
19.     /* 
20.      * Ensure that we add the bytes to the kfifo -before- 
21.      * we update the fifo->in index. 
22.      */ 
24.     smp_wmb(); 
26.     fifo->in += len; 
28.     return len; 
29. }
31. unsigned int __kfifo_get(struct kfifo *fifo, 
32.              unsigned char *buffer, unsigned int len) 
33. { 
34.     unsigned int l; 
36.     len = min(len, fifo->in - fifo->out); 
38.     /* 
39.      * Ensure that we sample the fifo->in index -before- we 
40.      * start removing bytes from the kfifo. 
41.      */ 
43.     smp_rmb(); 
45.     /* first get the data from fifo->out until the end of the buffer */ 
46.     l = min(len, fifo->size - (fifo->out & (fifo->size - 1))); 
47.     memcpy(buffer, fifo->buffer + (fifo->out & (fifo->size - 1)), l); 
49.     /* then get the rest (if any) from the beginning of the buffer */ 
50.     memcpy(buffer + l, fifo->buffer, len - l); 
52.     /* 
53.      * Ensure that we remove the bytes from the kfifo -before- 
54.      * we update the fifo->out index. 
55.      */ 
57.     smp_mb(); 
59.     fifo->out += len; 
61.     return len; 
62. }

【筆記】Linux核心中的迴圈緩衝區