第十三號艦隊

這種技巧很常在Open Source的專案中看到，看了Arrays of Length Zero原本以為是GCC獨有Extensionm，後來發現Clang跟VC都能使用，記錄一下。

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

struct datapacket
{
    int size;
    int data[0];
];
void f()
{
struct datapacket *pkt =
    malloc( sizeof(struct datapacket) +
        sizeof(int)*9 );
/* further code . . . */
}

這邊的data[0]不佔記憶體空間，因此sizeof(struct datapacket)大小相當於sizeof(int)，而data就是一個記憶體指標，指向一塊連續的記憶體。

一直想寫一篇關於LLVM的文章，想了好久終於下筆了。 同樣從Hello world開始下手

1
2
3
4
5
6

#include <stdio.h>
int main()
{
        puts("Hello world!\n");
        return 0;
}

編譯成 LLVM的IR中間形式，利用lli來執行IR Code。

1
2

$ clang hello.c -S -emit-llvm -o hello.lli
$ lli hello.lli

刪除hello.lli的Meta data之後，一個Hello world的最小部分掌這個樣子

1
2
3
4
5
6
7
8

@.str = private unnamed_addr constant [14 x i8] c"Hello world!\0A\00", align 1
define i32 @main() #0 {
  %1 = alloca i32, align 4
  store i32 0, i32* %1
  %2 = call i32 @puts(i8* getelementptr inbounds ([14 x i8]* @.str, i32 0, i32 0))
  ret i32 0
}
declare i32 @puts(i8*) #1

在StackExchange有人問了一個問題。在實際產品中常用的資料結構跟演算法有哪些。

把這當做一個參考，有空的時候可以研究一下。

這篇文章正好是上一篇的相反行為。為了加速某些特殊運算，有時需要呼叫C/C++的程式碼。使用Python內建的ctypes可以幫助完成這件事。

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

#include <iostream>

class Foo {
public:
        void bar() {
            std::cout << "Hello" << std::endl;
        }
};

extern "C" {
    Foo* Foo_new(){ return new Foo(); }
    void Foo_bar(Foo* foo) { foo->bar(); }
}

將其編譯成Shared Library / DLL。

1
2

$ g++ -c -fPIC foo.cpp -o foo.o
$ g++ -shared -Wl,-soname,libfoo.so -o libfoo.so  foo.o

接著就是Python code上場了

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

from ctypes import cdll
lib = cdll.LoadLibrary('./libfoo.so')

class Foo(object):
    def __init__(self):
        self.obj = lib.Foo_new()

    def bar(self):
        lib.Foo_bar(self.obj)

f = Foo()
f.bar() #and you will see "Hello" on the screen

Windows版跟Linux版大同小異，最大的差別在於Windows可以寫 ./libfoo 而不用寫 ./libfoo.dll：而 Linux沒有附檔名的話會發生錯誤。

當然，swig跟Boost Python一樣可以幫忙完成這件事。

在Mint 15下測試，Python版本2.7.3。以下的操作步驟跟Python相關，有需要的話需要修改。
首先，先安裝python-dev。

1

$ apt-get install python-dev

測試的Python code cal.py

1
2
3
4

def mix(a, b) :  
    r1 = a + b  
    r2 = a - b  
    return (r1, r2)

C語言本體：

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

#include "Python.h"
#include <string>
using namespace std;

int main(int argc, char * argv[])
{
        string filename = "cal"; // cal.py
        string methodname_mix = "mix"; // function name

        Py_Initialize();
        PyRun_SimpleString ("import sys; sys.path.insert(0, '.')");

        // load the module
        PyObject * pyFileName = PyString_FromString(filename.c_str());
        PyObject * pyMod = PyImport_Import(pyFileName);

        // load the function
        PyObject * pyFunc_mix = PyObject_GetAttrString(pyMod, methodname_mix.c_str());

        // test the function is callable
        if (pyFunc_mix && PyCallable_Check(pyFunc_mix))
        {
               PyObject * pyParams = PyTuple_New(2);
                PyTuple_SetItem(pyParams, 0, Py_BuildValue("i", 5));
                PyTuple_SetItem(pyParams, 1, Py_BuildValue("i", 2));

                // ok, call the function
                int r1 = 0, r2 = 0;
                PyObject * pyValue = PyObject_CallObject(pyFunc_mix, pyParams);
                PyArg_ParseTuple(pyValue, "i|i", &r1, &r2);
                if (pyValue)
                {
                        printf("%d,%d\n", r1, r2); //output is 7,3
                }
        }

				// Clean up
				Py_DECREF(pyMod);
				Py_DECREF(pyFileName);
        
        Py_Finalize();

        return 0;
}

編譯他

1

$ g++ pythontest.cpp -o pythontest -I/usr/include/python2.7 -lpython2.7

其中值得注意的是PyRun_SimpleString ("import sys; sys.path.insert(0, '.')");這行。這樣的話他才會在目前目錄下找cal.py這個檔案，不然會尋找/usr/lib/python2.7這個目錄。找不到會Segmentation fault。
cal.py會先被編譯成cal.pyc，之後只需要這檔案即可。

而在Visual Studio使用的時候，要注意以下情況

• 假設你是用x86版的Python，只能使用Win32版的Setting，不然就只能使用x64版。
• 在Windows下需要PyRun_SimpleString ("import sys; sys.path.insert(0, '.')");即可找到目錄下的cal.py。當然，放到Python27\Lib也是可以。

如果要讓事情變得更簡單，SWIG或是Boost.Python都是不錯的解決方案。

參考文章

• Supercharging C++ Code With Embedded Python
• Embedding Python in Your C Programs

同樣是在網路上看到的
The Language ⇔ Language Matrix
可以看到很多程式語言互轉的解決方案，這年頭已經不是一個語言能解決所有問題的年代了。

在網路上看到，隨手記錄起來。

– explainshell，在搜尋框輸入Linux command，接會parsing command，從Ubuntu的manpage library中找出說明文件。 GitHub找得到Source code。 類似的服務還有cdecl將C語言的宣告樣式翻譯成白話英文。以及Regexper將Regular Expression轉化成圖形表示式。

• commandlinefu記錄網路上常用的command pattern，
• Linux commands Examples
• ShellCheck 檢查 Shell Script 的線上程式 ，About ShellCheck，將此程式於 Command Line Interface， 作者的Website和Blog

在gdb 7.0之後加入的Reverse debugging，終於有時間可以玩玩看了。
同樣的，來個程式範例。

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

#include <stdio.h>

void foo() {
     printf("inside foo()");
     int x = 6;
     x += 2;
}

int main() {
     int x = 0;
     x = x + 2;
     foo();
     printf("x = %d\n", x);
     x = 4;
     return 0;
}

編譯它

1

gdb -g -o test test.c

使用gdb來玩玩看，最簡單的用法

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

$ gdb test
(gdb) start
Temporary breakpoint 1, main () at test.c:10
10	     int x = 0;
(gdb) record
(gdb) next
11	     x = x + 2;
(gdb) disp x
1: x = 0
(gdb) next
12	     foo();
1: x = 2
(gdb) reverse-next
11	     x = x + 2;
1: x = 0

在使用之前，要先用record記錄操作順序，才有機會還原狀態。不用的時候可以使用record stop停止。
接著常用的step, next, stepi跟nexti都有逆向版。可以參考GDB and Reverse Debugging。

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

(gdb) b 15
Breakpoint 2 at 0x400578: file test.c, line 15.
(gdb) continue
Continuing.
inside foo()x = 2

Breakpoint 2, main () at test.c:15
15	     return 0;
(gdb) b foo
Breakpoint 3 at 0x400524: file test.c, line 4.
(gdb) reverse-continue
Continuing.

Breakpoint 3, foo () at test.c:4
4	     printf("inside foo()");

想要追蹤之前執行過的中斷點該怎麼辦？ 使用reverse-continue。
也可以用watchpointer來追蹤到底如何被修改的

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

(gdb) set can-use-hw-watchpoints 0
(gdb) watch x
Watchpoint 3: x
(gdb) continue
Continuing.
Watchpoint 3: x

Old value = 0
New value = 2
(gdb) reverse-continue
Continuing.
Watchpoint 3: x

Old value = 2
New value = 0
main () at test.c:11
11	     x = x + 2;

更多的gdb使用教學，可以參考

• 快快樂樂學 GNU Debugger Part I
• 快快樂樂學 GNU Debugger Part II
• GDB Rocks

volatile最早出現在C語言。之後C++，Java，C#都沿用了這個關鍵字，不過語義大不相同。

C / C++

volatile一開始的用途就是用來作Memory Mapped I/O用的。看看以下程式碼

1
2
3
4
5

static int foo;
void bar(void) {
    foo = 0;
    while (foo != 255)  ;
}

聰明的Compiler在做最佳化的時候，大概會變成這個樣子。

1
2
3
4

void bar_optimized(void) {
    foo = 0;
    while (true)  ;
}

Compiler跟CPU只會保證執行上下文結果是正確的，foo在這邊沒有被改變，所以foo != 255永遠為true，所以就變成無窮迴圈了。如果外界改變了foo的值，整個迴圈也有可能不會結束。 因此volatile因此而生。
自從Multithread跟Multiore programming逐漸風行之後，大家都想找到一個比lok跟輕量化的解決方案。因此valatile又被考慮了。
至於這方面晚點在說，先來說Java的volatile。

Java / C Sharp

Java由於是跑在Virtual Machine上，所以所設計理念必須超越特定硬體規格。 Java Memory Model定義，一個Thread讀取一個變數時，會存在Thread的Local Spaee上運作，等到運算過後，找到是當實機再將值寫為全域空間。因此如果兩個Thread對同一個變數操作的話，可能有不可預期的結果。

以下這段Code哪裡有問題？

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

public class RedPimple extends Thread {
	private boolean done;
	private int value;
	@Override
	public void run() {
		while (!done) //A
			Thread.yield();
		System.out.println(value); // D
	}
	public void done() {
		done = true;
	}
	public void setValue(int value) {
		this.value = value;
	}
	public static void main(String[] args) {
		RedPimple r = new RedPimple();
		r.start();
		r.setValue(1);  // B
		r.done(); // C
	}
}

上面Code有兩個Thread，Main Thread跟r。在Main Thread那邊進行value跟done的修改，不一定會被r thread所看到。因此可能會無法結束，或是value為0的情況發生。不過這樣子在寫MultiThread的時候還是有所欠缺。拿最多人討論的https://www.youtube.com/watch?v=1j_mpwKmlJg來說，因此改變了JDK5之嘔的Memory Model，也跟著啟發了C/C++11的Memory Model。
為什麼以下這段Code是錯的

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

class Foo { 
  private Helper helper = null;
  public Helper getHelper() {
    if (helper == null) // A
      synchronized(this) {
        if (helper == null) 
          helper = new Helper();
      }    
    return helper;
    }
  // other functions and members...
  }

其中的helper = new Helper()其實是以下述句組成。

1
2
3

Allocate memory to tmp  // B
Invoke Helper constructor from tmp // C
Assin helper to tmp; // D

在JDK5之前，沒有任何保證以上的述句會按照想像的順序執行，就算編譯器繞路避掉，CPU也有本事做同樣的事，可能C的執行順序在D之後。當一個Thread先執行D，卻捱沒初始化完成，另一個Thread剛好跑到’A’的點，拿到一個可能有問題的物件。就出事了。
因此語言創造者提出了Happens-Before Relation Model。主要的兩點是，每個語言的作法不盡相同，不過大都依循Acquire and Release Semantics來發展。 Java的volatile就擁有Acquire and Release Semantics。而兩者的定義如下：

A read-acquire executes before all reads and writes the same thread that follow it in program order
A write-release executes after all reads and writes by the same thread that precede it in program order

也就是兩種特殊的Memory Fence，看圖比較容易理解。

依照Program Order來看，在Read-acquire Fence後的讀寫不允許在Fence之前執行，不過在此之前的讀寫允許放到Fence之後進行。
依照Program Order來看，在Write-acquire Fence後的讀寫不允許在Fence之後執行，不過在此之後嘔讀寫允許放到Fence之前進行。

Java修改了Memory model，因此可以保證上面的B和C一定會在D之前執行完畢。而在另一個Thread執行到A時，所拿到的helper是正確初始化的。

Visual C++從2005之後對volatile加上了Acquire and Release Semantics，不過這編有個VC失敗的範例，未來可能會修正吧。

Visual C++對volatile做了語義上的拓展，不過GCC跟Clang沒有，所以你不能保證任哦東西。
至於C11跟C++11，則是另起爐灶，用之前介紹的Atomic funtions來做，可以參考這篇。

C#的用法就跟Java差不多了，有興趣的襪可以參考Volatile keyword in C# – memory model explained。

寫道這邊已經語無倫次了，搞懂這些還真是複雜。

Referene:

• Volatile variable – Wiki
• Acquire and Release Semantics
• 剖析为什么在多核多线程程序中要慎用volatile关键字？
• Java theory and practice: Fixing the Java Memory Model, Part 1
• Java theory and practice: Fixing the Java Memory Model, Part 2
• Volatile keyword in C# – memory model explained

在關注C++11的食嘔，發現C11標準也在2011年同時發佈。
目前C11的支持肚兜不太夠，因此我是用Pelles C測試。
C11的寫法，相關的資料可以參考[Threads in the new ISO C Standard from 2011](Threads in the new ISO C Standard from 2011)。

1
2
3
4
5
6
7

#include <stdatomic.h>
int main(int argc, char *argv[])
{
	_Atomic(int) i = ATOMIC_VAR_INIT(0); //	atomic_init(&i, 0);
	atomic_fetch_add_explicit(&i, 1, memory_order_relaxed);
	return 0;
}

C++11的寫法，可以參考Atomic operations library

1
2
3
4
5
6
7
8

#include <atomic>
std::atomic<int> sharedValue(0); // std::atomic_init(&sharedValue, 0);
// std::atomic<int> sharedValue = ATOMIC_VAR_INIT(0); 跟上面效果一樣
int main()
{
	sharedValue.fetch_add(1, memory_order_relaxed);
  return 0;
}

看起來峎像，只是C++11的寫法是使用template來表示。不過更具彈性，如果你有一個HugeObject的類別，你可以透過atomi<HugeObject>來達成Atomic operation，裡面用個Mutex來保護。

至於C11跟C++11的Memory Model從Java那邊得到啟發而修改，那就是另外一個大故事了。有空在寫。