日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產(chǎn)品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
通過Handle理解V8的代碼設計（基于V0.1.5）

本文轉(zhuǎn)載自微信公眾號「編程雜技」，作者theanarkh。轉(zhuǎn)載本文請聯(lián)系編程雜技公眾號。

目前創(chuàng)新互聯(lián)建站已為上千的企業(yè)提供了網(wǎng)站建設、域名、網(wǎng)頁空間、網(wǎng)站托管、服務器租用、企業(yè)網(wǎng)站設計、舒城網(wǎng)站維護等服務，公司將堅持客戶導向、應用為本的策略，正道將秉承"和諧、參與、激情"的文化，與客戶和合作伙伴齊心協(xié)力一起成長，共同發(fā)展。

前言：Handle在V8里是一個非常重要的概念，本文從早期的源碼分析Handle的原理，在分析的過程中我們還可以看到V8在代碼設計上的一些細節(jié)。

假設我們有以下代碼

 
 
 
 
    
  
  
  
  
  1. HandleScope scope; 
    2. 
  
  
  
  
  2. Local hello = String::New(參數(shù)); 
    3.

這個看起來很簡單的過程，其實在V8的內(nèi)部實現(xiàn)起來比較復雜。

HandleScope

我們從創(chuàng)建一個HandleScope對象開始分析。HandleScope是負責管理多個Handle的對象，主要是為了方便管理Handle的分配和釋放。

 
 
 
 
    
  
  
  
  
  1. class HandleScope { 
    2. 
  
  
  
  
  2.  public: 
    3. 
  
  
  
  
  3.   HandleScope() : previous_(current_), is_closed_(false) { 
    4. 
  
  
  
  
  4.     current_.extensions = 0; 
    5. 
  
  
  
  
  5.   } 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7.   static void** CreateHandle(void* value); 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.  private: 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.   class Data { 
    12. 
  
  
  
  
  12.    public: 
    13. 
  
  
  
  
  13.     // 分配了一塊內(nèi)存后，又額外分配的塊數(shù) 
    14. 
  
  
  
  
  14.     int extensions; 
    15. 
  
  
  
  
  15.     // 下一個可用的位置 
    16. 
  
  
  
  
  16.     void** next; 
    17. 
  
  
  
  
  17.     // 達到limit執(zhí)行的地址后說明當前內(nèi)存塊用完了 
    18. 
  
  
  
  
  18.     void** limit; 
    19. 
  
  
  
  
  19.     inline void Initialize() { 
    20. 
  
  
  
  
  20.       extensions = -1; 
    21. 
  
  
  
  
  21.       next = limit = NULL; 
    22. 
  
  
  
  
  22.     } 
    23. 
  
  
  
  
  23.   }; 
    24. 
  
  
  
  
  24.   // 當前的HandleScope 
    25. 
  
  
  
  
  25.   static Data current_; 
    26. 
  
  
  
  
  26.   // 上一個HandleScope 
    27. 
  
  
  
  
  27.   const Data previous_; 
    28. 
  
  
  
  
  28. }; 
    29. 
  
  
  
  
  29.  
    30. 
  
  
  
  
  30. HandleScope::Data HandleScope::current_ = { -1, NULL, NULL }; 
    31.

通過HandleScope的構(gòu)造函數(shù)我們知道每次定義一個HandleScope對象的時候，previous就會指向前一個HandleScope的數(shù)據(jù)(但是current_除了第一次創(chuàng)建HandleScope的時候更新了(見CreateHandle)，后續(xù)似乎沒有更新?后續(xù)詳細看一下)，從HandleScope的定義中我們知道他的布局如下。

接著我們看HandleScope的CreateHandle方法。

 
 
 
 
    
  
  
  
  
  1. void** v8::HandleScope::CreateHandle(void* value) { 
    2. 
  
  
  
  
  2.   // 獲取下一個可用的地址 
    3. 
  
  
  
  
  3.   void** result = current_.next; 
    4. 
  
  
  
  
  4.   // 到達limit的地址了或者為空（初始化的時候）則獲取新的內(nèi)存 
    5. 
  
  
  
  
  5.   if (result == current_.limit) { 
    6. 
  
  
  
  
  6.     // Block是二維數(shù)組，每個元素指向一個可以存儲數(shù)據(jù)的數(shù)組。非空說明可能有可用的內(nèi)存空間 
    7. 
  
  
  
  
  7.     if (!thread_local.Blocks()->is_empty()) { 
    8. 
  
  
  
  
  8.       // 拿到list中最后一個元素，得到一個數(shù)組首地址，然后再獲取他的limit地址，即末地址 
    9. 
  
  
  
  
  9.       void** limit = &thread_local.Blocks()->last()[i::kHandleBlockSize]; 
    10. 
  
  
  
  
  10.       if (current_.limit != limit) { 
    11. 
  
  
  
  
  11.         current_.limit = limit; 
    12. 
  
  
  
  
  12.         // v8里少了這一句，看起來是需要修改result的值的 
    13. 
  
  
  
  
  13.         // result = limit - i::kHandleBlockSize;  
    14. 
  
  
  
  
  14.       } 
    15. 
  
  
  
  
  15.     } 
    16. 
  
  
  
  
  16.   } 
    17. 
  
  
  
  
  17.   // 下一個可用的地址 
    18. 
  
  
  
  
  18.   current_.next = result + 1; 
    19. 
  
  
  
  
  19.   *result = value; 
    20. 
  
  
  
  
  20.   return result; 
    21. 
  
  
  
  
  21. } 
    22.

我們看到CreateHandle會首先獲取一片內(nèi)存，然后把入?yún)alue的值保存到該內(nèi)存中。

String::New

了解了HandleScope后，我們繼續(xù)分析String::New。

 
 
 
 
    
  
  
  
  
  1. Local v8::String::New(const char* data, int length) { 
    2. 
  
  
  
  
  2.   i::Handle result = 
    3. 
  
  
  
  
  3.       i::Factory::NewStringFromUtf8(i::Vector(data, length)); 
    4. 
  
  
  
  
  4.   return Utils::ToLocal(result); 
    5. 
  
  
  
  
  5. } 
    6.

我們接著看NewStringFromUtf8。

 
 
 
 
    
  
  
  
  
  1. Handle Factory::NewStringFromUtf8(Vector string,PretenureFlag pretenure) { 
    2. 
  
  
  
  
  2.   CALL_HEAP_FUNCTION(Heap::AllocateStringFromUtf8(string,  
    3. 
  
  
  
  
  3.                     pretenure),  
    4. 
  
  
  
  
  4.                     String); 
    5. 
  
  
  
  
  5. } 
    6.

我們先看一下AllocateStringFromUtf8的實現(xiàn)，然后再看CALL_HEAP_FUNCTION。

 
 
 
 
    
  
  
  
  
  1. Object* Heap::AllocateStringFromUtf8(Vector string,PretenureFlag pretenure) { 
    2. 
  
  
  
  
  2.   return AllocateStringFromAscii(string, pretenure); 
    3. 
  
  
  
  
  3. } 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. Object* Heap::AllocateStringFromAscii(Vector string,PretenureFlag pretenure) { 
    6. 
  
  
  
  
  6.   // 從堆中分配一塊內(nèi)存 
    7. 
  
  
  
  
  7.   Object* result = AllocateRawAsciiString(string.length(), pretenure); 
    8. 
  
  
  
  
  8.   // 設置堆對象的內(nèi)容 
    9. 
  
  
  
  
  9.   AsciiString* string_result = AsciiString::cast(result); 
    10. 
  
  
  
  
  10.   for (int i = 0; i < string.length(); i++) { 
    11. 
  
  
  
  
  11.     string_result->AsciiStringSet(i, string[i]); 
    12. 
  
  
  
  
  12.   } 
    13. 
  
  
  
  
  13.   return result; 
    14. 
  
  
  
  
  14. } 
    15.

我們看到AllocateStringFromUtf8最后返回了一個堆內(nèi)存地址。接著我們看下CALL_HEAP_FUNCTION這個宏。

 
 
 
 
    
  
  
  
  
  1. #define CALL_HEAP_FUNCTION(FUNCTION_CALL, TYPE)         
    2. 
  
  
  
  
  2.   do {                  
    3. 
  
  
  
  
  3.     Object* __object__ = FUNCTION_CALL;                                       
    4. 
  
  
  
  
  4.     return Handle(TYPE::cast(__object__));    
    5. 
  
  
  
  
  5.   } while (false) 
    6.

CALL_HEAP_FUNCTION的作用是把函數(shù)FUNCTION_CALL執(zhí)行的結(jié)果轉(zhuǎn)成Handle對象。我們知道FUNCTION_CALL函數(shù)返回的結(jié)果是一個堆內(nèi)存指針。接下來我們看看是如何轉(zhuǎn)成Handle的。這個Handle不是我們在代碼里使用的Handle。而是V8內(nèi)部使用的Handle(代碼在handles.h)，我們看看實現(xiàn)。

 
 
 
 
    
  
  
  
  
  1. template 
    2. 
  
  
  
  
  2. class Handle { 
    3. 
  
  
  
  
  3.  public: 
    4. 
  
  
  
  
  4.   explicit Handle(T* obj); 
    5. 
  
  
  
  
  5.  private: 
    6. 
  
  
  
  
  6.   T** location_; 
    7. 
  
  
  
  
  7. }; 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. template 
    10. 
  
  
  
  
  10. Handle::Handle(T* obj) { 
    11. 
  
  
  
  
  11.   location_ = reinterpret_cast(HandleScope::CreateHandle(obj)); 
    12. 
  
  
  
  
  12. } 
    13.

我們看到Handle內(nèi)部使用的是T**二級指針，而我們剛才拿到堆內(nèi)存地址是一級指針，自然不能直接賦值，而是通過CreateHandle又處理了一下。HandleScope::CreateHandle我們剛才已經(jīng)分析過了。執(zhí)行CreateHandle后布局如下。

所以NewStringFromUtf8最后返回了一個Handle對象(里面維護了一個二級指針location_)，接著V8調(diào)用Utils::ToLocal把他轉(zhuǎn)成外部使用的Handle。接著賦值給Handle hello。這里的Handle是外部使用的Handle。

 
 
 
 
    
  
  
  
  
  1. Local Utils::ToLocal(v8::internal::Handle obj) {  
    2. 
  
  
  
  
  2.     return Local(reinterpret_cast(obj.location()));  
    3. 
  
  
  
  
  3. } 
    4.

首先通過obj.location()拿到一個二級指針。然后轉(zhuǎn)成一個String *指針。接著構(gòu)造一個Local對象。ToLocal是V8代碼的分水嶺，我們看看Local的定義。

 
 
 
 
    
  
  
  
  
  1. template  class Local : public Handle { 
    2. 
  
  
  
  
  2.  public: 
    3. 
  
  
  
  
  3.   template  inline Local(S* that) : Handle(that) { } 
    4. 
  
  
  
  
  4. }; 
    5.

直接調(diào)用Handle類的函數(shù)

 
 
 
 
    
  
  
  
  
  1. template  class Handle { 
    2. 
  
  
  
  
  2.   explicit Handle(T* val) : val_(val) { } 
    3. 
  
  
  
  
  3.   private: 
    4. 
  
  
  
  
  4.     T* val_; 
    5. 
  
  
  
  
  5. } 
    6.

這時候的結(jié)構(gòu)圖如下

 
 
 
 
    
  
  
  
  
  1. template  class Handle { 
    2. 
  
  
  
  
  2.   explicit Handle(T* val) : val_(val) { } 
    3. 
  
  
  
  
  3.   private: 
    4. 
  
  
  
  
  4.     T* val_; 
    5. 
  
  
  
  
  5. } 
    6.

所以最后通過ToLocal返回一個外部Handle對象給用戶。當執(zhí)行

 
 
 
 
    
  
  
  
  
  1. Local  xxx = Local對象 
    2.

時就會調(diào)用Local的拷貝函數(shù)。

 
 
 
 
    
  
  
  
  
  1. template   
    2. 
  
  
  
  
  2.       inline Local(Local that) 
    3. 
  
  
  
  
  3.       // *that即取得他底層對象的地址 
    4. 
  
  
  
  
  4.       : Handle(reinterpret_cast(*that)) {} 
    5.

我們首先看一下that。Handle類重載了運算符。

 
 
 
 
    
  
  
  
  
  1. template  
    2. 
  
  
  
  
  2. T* Handle::operator*() { 
    3. 
  
  
  
  
  3.   return val_; 
    4. 
  
  
  
  
  4. } 
    5.

所以reinterpret_cast(that)拿到了Handle底層指針的值并轉(zhuǎn)成String 類型。接著執(zhí)行

 
 
 
 
    
  
  
  
  
  1. explicit Handle(T* val) : val_(val) { } 
    2.

整個過程下來，其實就是把被復制對象的底層指針復制過來。=

通過Handle訪問一個函數(shù)

當我們使用Handle hello這個對象的方法時是怎樣的，比如hello->Length()。Handle重載了->運算符。

 
 
 
 
    
  
  
  
  
  1. template  
    2. 
  
  
  
  
  2. T* Handle::operator->() { 
    3. 
  
  
  
  
  3.   return val_; 
    4. 
  
  
  
  
  4. } 
    5.

我們看到執(zhí)行hello->Length()的時候首先會拿到一個String *。然后調(diào)用Length方法。其實就是調(diào)用String對象(在v8.h中定義)的Length方法。我們看看Length方法的實現(xiàn)。

 
 
 
 
    
  
  
  
  
  1. int String::Length() { 
    2. 
  
  
  
  
  2.   return Utils::OpenHandle(this)->length(); 
    3. 
  
  
  
  
  3. } 
    4.

首先通過傳入this調(diào)用OpenHandle拿到內(nèi)部Handle。從前面的架構(gòu)圖中我們知道this(即val_和location_指向的值)本質(zhì)上是一個String **，即二級指針。

 
 
 
 
    
  
  
  
  
  1. v8: :internal: :Handle < v8: :internal: :String >  
    2. 
  
  
  
  
  2. Utils: :OpenHandle(v8: :String * that) { 
    3. 
  
  
  
  
  3.     return v8: :internal: :Handle < v8: :internal: :String > (reinterpret_cast < v8: :internal: :String * *>(that)); 
    4. 
  
  
  
  
  4. } 
    5.

OpenHandle就是首先把外部的表示轉(zhuǎn)成一個二級指針。然后再構(gòu)造一個內(nèi)部Handle。在內(nèi)部Handle里保存了這個二級指針。接著訪問這個Handle對象的length方法。而Handle重載了->運算符。

 
 
 
 
    
  
  
  
  
  1. INLINE(T* operator ->() const)  { return operator*(); } 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. template inline T* Handle::operator*() const { 
    4. 
  
  
  
  
  4.   return *location_; 
    5. 
  
  
  
  
  5. } 
    6.

我們看到->的操作最終會被解引用一次變成String *，然后訪問函數(shù)length，也就是訪問String對象的length函數(shù)。

后記：從上面的分析中我們不僅看到了Handle的實現(xiàn)原理，也看到了V8代碼的一些設計細節(jié)，V8在內(nèi)部實現(xiàn)了一類對象，然后把內(nèi)部對象轉(zhuǎn)成外部使用的類型后返回給用戶，當用戶使用該返回的對象時，V8又會轉(zhuǎn)成內(nèi)部的對象再操作這個對象。核心的數(shù)據(jù)結(jié)構(gòu)是兩個Handle族的類。因為他們是維護了真實對象的句柄。其他的一些類，比如String，同樣分為外部和內(nèi)部類，內(nèi)部類是實現(xiàn)了String的細節(jié)，而外部類只是一個殼子，他負責給用戶暴露API，而不負責實現(xiàn)細節(jié)，但用戶操作這些類時，V8會會轉(zhuǎn)成內(nèi)部類再進行操作。外部類的定義在v8.h中，這是我們使用V8時需要了解的最好文檔。內(nèi)部類的實現(xiàn)根據(jù)版本不同而不同，比如早期版本都是在object.h里實現(xiàn)的，而實現(xiàn)內(nèi)外部對象轉(zhuǎn)換的方法在api.c中定義。


本文標題：通過Handle理解V8的代碼設計（基于V0.1.5）
網(wǎng)站鏈接：http://m.5511xx.com/article/ccscpsh.html