通過Handle理解V8的代碼設計（基于V0.1.5）
本文轉載自微信公眾號「編程雜技」，作者theanarkh。轉載本文請聯系編程雜技公眾號。
前言：Handle在V8里是一個非常重要的概念，本文從早期的源碼分析Handle的原理，在分析的過程中我們還可以看到V8在代碼設計上的一些細節。
假設我們有以下代碼
- HandleScope scope;
- Local<String> hello = String::New(參數);
這個看起來很簡單的過程，其實在V8的內部實現起來比較復雜。
HandleScope
我們從創建一個HandleScope對象開始分析。HandleScope是負責管理多個Handle的對象，主要是為了方便管理Handle的分配和釋放。
- class HandleScope {
- public:
- HandleScope() : previous_(current_), is_closed_(false) {
- current_.extensions = 0;
- }
- static void** CreateHandle(void* value);
- private:
- class Data {
- public:
- // 分配了一塊內存后，又額外分配的塊數
- int extensions;
- // 下一個可用的位置
- void** next;
- // 達到limit執行的地址后說明當前內存塊用完了
- void** limit;
- inline void Initialize() {
- extensions = -1;
- next = limit = NULL;
- }
- };
- // 當前的HandleScope
- static Data current_;
- // 上一個HandleScope
- const Data previous_;
- };
- HandleScope::Data HandleScope::current_ = { -1, NULL, NULL };
通過HandleScope的構造函數我們知道每次定義一個HandleScope對象的時候，previous就會指向前一個HandleScope的數據(但是current_除了第一次創建HandleScope的時候更新了(見CreateHandle)，后續似乎沒有更新?后續詳細看一下)，從HandleScope的定義中我們知道他的布局如下。
接著我們看HandleScope的CreateHandle方法。
- void** v8::HandleScope::CreateHandle(void* value) {
- // 獲取下一個可用的地址
- void** result = current_.next;
- // 到達limit的地址了或者為空（初始化的時候）則獲取新的內存
- if (result == current_.limit) {
- // Block是二維數組，每個元素指向一個可以存儲數據的數組。非空說明可能有可用的內存空間
- if (!thread_local.Blocks()->is_empty()) {
- // 拿到list中最后一個元素，得到一個數組首地址，然后再獲取他的limit地址，即末地址
- void** limit = &thread_local.Blocks()->last()[i::kHandleBlockSize];
- if (current_.limit != limit) {
- current_.limit = limit;
- // v8里少了這一句，看起來是需要修改result的值的
- // result = limit - i::kHandleBlockSize;
- }
- }
- }
- // 下一個可用的地址
- current_.next = result + 1;
- *result = value;
- return result;
- }
我們看到CreateHandle會首先獲取一片內存，然后把入參value的值保存到該內存中。
String::New
了解了HandleScope后，我們繼續分析String::New。
- Local<String> v8::String::New(const char* data, int length) {
- i::Handle<i::String> result =
- i::Factory::NewStringFromUtf8(i::Vector<const char>(data, length));
- return Utils::ToLocal(result);
- }
我們接著看NewStringFromUtf8。
- Handle<String> Factory::NewStringFromUtf8(Vector<const char> string,PretenureFlag pretenure) {
- CALL_HEAP_FUNCTION(Heap::AllocateStringFromUtf8(string,
- pretenure),
- String);
- }
我們先看一下AllocateStringFromUtf8的實現，然后再看CALL_HEAP_FUNCTION。
- Object* Heap::AllocateStringFromUtf8(Vector<const char> string,PretenureFlag pretenure) {
- return AllocateStringFromAscii(string, pretenure);
- }
- Object* Heap::AllocateStringFromAscii(Vector<const char> string,PretenureFlag pretenure) {
- // 從堆中分配一塊內存
- Object* result = AllocateRawAsciiString(string.length(), pretenure);
- // 設置堆對象的內容
- AsciiString* string_result = AsciiString::cast(result);
- for (int i = 0; i < string.length(); i++) {
- string_result->AsciiStringSet(i, string[i]);
- }
- return result;
- }
我們看到AllocateStringFromUtf8最后返回了一個堆內存地址。接著我們看下CALL_HEAP_FUNCTION這個宏。
- #define CALL_HEAP_FUNCTION(FUNCTION_CALL, TYPE)
- do {
- Object* __object__ = FUNCTION_CALL;
- return Handle<TYPE>(TYPE::cast(__object__));
- } while (false)
CALL_HEAP_FUNCTION的作用是把函數FUNCTION_CALL執行的結果轉成Handle對象。我們知道FUNCTION_CALL函數返回的結果是一個堆內存指針。接下來我們看看是如何轉成Handle的。這個Handle不是我們在代碼里使用的Handle。而是V8內部使用的Handle(代碼在handles.h)，我們看看實現。
- template<class T>
- class Handle {
- public:
- explicit Handle(T* obj);
- private:
- T** location_;
- };
- template<class T>
- Handle<T>::Handle(T* obj) {
- location_ = reinterpret_cast<T**>(HandleScope::CreateHandle(obj));
- }
我們看到Handle內部使用的是T**二級指針，而我們剛才拿到堆內存地址是一級指針，自然不能直接賦值，而是通過CreateHandle又處理了一下。HandleScope::CreateHandle我們剛才已經分析過了。執行CreateHandle后布局如下。
所以NewStringFromUtf8最后返回了一個Handle對象(里面維護了一個二級指針location_)，接著V8調用Utils::ToLocal把他轉成外部使用的Handle。接著賦值給Handle hello。這里的Handle是外部使用的Handle。
- Local<v8::String> Utils::ToLocal(v8::internal::Handle<v8::internal::String> obj) {
- return Local<String>(reinterpret_cast<String*>(obj.location()));
- }
首先通過obj.location()拿到一個二級指針。然后轉成一個String *指針。接著構造一個Local對象。ToLocal是V8代碼的分水嶺，我們看看Local的定義。
- template <class T> class Local : public Handle<T> {
- public:
- template <class S> inline Local(S* that) : Handle<T>(that) { }
- };
直接調用Handle類的函數
- template <class T> class Handle {
- explicit Handle(T* val) : val_(val) { }
- private:
- T* val_;
- }
這時候的結構圖如下
- template <class T> class Handle {
- explicit Handle(T* val) : val_(val) { }
- private:
- T* val_;
- }
所以最后通過ToLocal返回一個外部Handle對象給用戶。當執行
- Local <String> xxx = Local對象
時就會調用Local的拷貝函數。
- template <class S>
- inline Local(Local<S> that)
- // *that即取得他底層對象的地址
- : Handle<T>(reinterpret_cast<T*>(*that)) {}
我們首先看一下that。Handle類重載了運算符。
- template <class T>
- T* Handle<T>::operator*() {
- return val_;
- }
所以reinterpret_cast(that)拿到了Handle底層指針的值并轉成String 類型。接著執行
- explicit Handle(T* val) : val_(val) { }
整個過程下來，其實就是把被復制對象的底層指針復制過來。=
通過Handle訪問一個函數
當我們使用Handle hello這個對象的方法時是怎樣的，比如hello->Length()。Handle重載了->運算符。
- template <class T>
- T* Handle<T>::operator->() {
- return val_;
- }
我們看到執行hello->Length()的時候首先會拿到一個String *。然后調用Length方法。其實就是調用String對象(在v8.h中定義)的Length方法。我們看看Length方法的實現。
- int String::Length() {
- return Utils::OpenHandle(this)->length();
- }
首先通過傳入this調用OpenHandle拿到內部Handle。從前面的架構圖中我們知道this(即val_和location_指向的值)本質上是一個String **，即二級指針。
- v8: :internal: :Handle < v8: :internal: :String >
- Utils: :OpenHandle(v8: :String * that) {
- return v8: :internal: :Handle < v8: :internal: :String > (reinterpret_cast < v8: :internal: :String * *>(that));
- }
OpenHandle就是首先把外部的表示轉成一個二級指針。然后再構造一個內部Handle。在內部Handle里保存了這個二級指針。接著訪問這個Handle對象的length方法。而Handle重載了->運算符。
- INLINE(T* operator ->() const) { return operator*(); }
- template <class T>inline T* Handle<T>::operator*() const {
- return *location_;
- }
我們看到->的操作最終會被解引用一次變成String *，然后訪問函數length，也就是訪問String對象的length函數。
后記：從上面的分析中我們不僅看到了Handle的實現原理，也看到了V8代碼的一些設計細節，V8在內部實現了一類對象，然后把內部對象轉成外部使用的類型后返回給用戶，當用戶使用該返回的對象時，V8又會轉成內部的對象再操作這個對象。核心的數據結構是兩個Handle族的類。因為他們是維護了真實對象的句柄。其他的一些類，比如String，同樣分為外部和內部類，內部類是實現了String的細節，而外部類只是一個殼子，他負責給用戶暴露API，而不負責實現細節，但用戶操作這些類時，V8會會轉成內部類再進行操作。外部類的定義在v8.h中，這是我們使用V8時需要了解的最好文檔。內部類的實現根據版本不同而不同，比如早期版本都是在object.h里實現的，而實現內外部對象轉換的方法在api.c中定義。
