phpとmemcachedサーバのインタラクティブな分散実装ソース分析[memcache版]

66873 ワード
PHP サーバ
この間、あるプロジェクトの関係でphpがmemcacheとmemcached PECL拡張ライブラリを呼び出すインタフェースを通じて分散キャッシュサーバに格納されるメカニズムを研究しました.ここでは、それぞれのソースコードに基づいて分析し、興味のある人に役立つことを望んでいます.
この文章ではphpとmemcache拡張ライブラリのインタラクションについてソースコードに基づいて分析を展開します.
PHPがmemcacheを呼び出すインタフェースは、通常、次の手順に従います.
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="php"] 
    2. 
    
    
    
    
  2. $mmc = new Memcache(); 
    3. 
    
    
    
    
  3. $mmc->addServer(‘node1′, 11211); 
    4. 
    
    
    
    
  4. $mmc->addServer(‘node2′, 11211, MemcacheConfig::MEMCACHE_PERSISTENT, 2); 
    5. 
    
    
    
    
  5. $mmc->set(‘key’, ‘value’); 
    6. 
    
    
    
    
  6. echo $mmc->get(‘key’); 
    7. 
    
    
    
    
  7. $mmc->delete(‘key’); 
    8. 
    
    
    
    
  8. [/cc] 
    9.

わずか数行のコードで、キャッシュキーのライフサイクルが完全に表示されます.Memcacheの初期化からaddServerに2つのサーバノードを追加し、1つのkeyをサーバにセットし、getをこのkeyに出力し、最後にdeleteというkeyにします.このライフサイクルの中で、Memcacheは底層でいったいどんなことをして、データストレージサーバーの均一な分布、データの完全性を保証しましたか?
次に、上記のライフサイクルの順序に従って、逐次漸進的に分析します(テーマは分布式アルゴリズムの分析なので、次に関係のないコードは省略します.多くの分析はソースコードに直接注釈します).
1.Memcacheの初期化
PHP対応コード:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="php"] 
    2. 
    
    
    
    
  2. $mmc = new Memcache(); 
    3. 
    
    
    
    
  3. [/cc] 
    4.

Cに対応するコード:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. // Memcache            c         ，           。          。 
    3. 
    
    
    
    
  3. static zend_function_entry php_memcache_class_functions[] = { 
    4. 
    
    
    
    
  4. PHP_FALIAS(addserver, memcache_add_server, NULL) 
    5. 
    
    
    
    
  5. PHP_FALIAS(set, memcache_set, NULL) 
    6. 
    
    
    
    
  6. PHP_FALIAS(get, memcache_get, NULL) 
    7. 
    
    
    
    
  7. PHP_FALIAS(delete, memcache_delete, NULL) 
    8. 
    
    
    
    
  8. …… 
    9. 
    
    
    
    
  9. }; 
    10. 
    
    
    
    
  10. PHP_MINIT_FUNCTION(memcache) 
    11. 
    
    
    
    
  11. { 
    12. 
    
    
    
    
  12. //    Memcache   ，    php                  
    13. 
    
    
    
    
  13. zend_class_entry memcache_class_entry; 
    14. 
    
    
    
    
  14. INIT_CLASS_ENTRY(memcache_class_entry, "Memcache", php_memcache_class_functions); 
    15. 
    
    
    
    
  15. memcache_class_entry_ptr = zend_register_internal_class(&memcache_class_entry TSRMLS_CC); 
    16. 
    
    
    
    
  16. …… 
    17. 
    
    
    
    
  17. } 
    18. 
    
    
    
    
  18. [/cc] 
    19.

以上の過程はModule Initializationの一環ですでに完成しており,newの過程では残りの処理はない.
2.分散型ストレージとなるようにキャッシュサーバを追加
PHP対応コード:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="php"] 
    2. 
    
    
    
    
  2. $mmc->addServer(‘node1′, 11211); 
    3. 
    
    
    
    
  3. $mmc->addServer(‘node2′, 11211, MemcacheConfig::MEMCACHE_PERSISTENT, 2); 
    4. 
    
    
    
    
  4. [/cc] 
    5.

上のphp_からmemcache_class_functions構造からaddServerメソッドはmemcache_に対応していることがわかる.add_server関数ですので、Cのコードに対応します.
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. PHP_FUNCTION(memcache_add_server) 
    3. 
    
    
    
    
  3. { 
    4. 
    
    
    
    
  4. zval **connection, *mmc_object = getThis(), *failure_callback = NULL; 
    5. 
    
    
    
    
  5. //   Memcache         mmc_pool_t 
    6. 
    
    
    
    
  6. mmc_pool_t *pool; 
    7. 
    
    
    
    
  7. //              
    8. 
    
    
    
    
  8. mmc_t *mmc; 
    9. 
    
    
    
    
  9. …… 
    10. 
    
    
    
    
  10. //   pool        ，     
    11. 
    
    
    
    
  11. if (zend_hash_find(Z_OBJPROP_P(mmc_object), "connection", sizeof("connection"), (void **) &connection) == FAILURE) { 
    12. 
    
    
    
    
  12. //   mmp_pool_new      
    13. 
    
    
    
    
  13. pool = mmc_pool_new(TSRMLS_C); 
    14. 
    
    
    
    
  14. …… 
    15. 
    
    
    
    
  15. } 
    16. 
    
    
    
    
  16. else { 
    17. 
    
    
    
    
  17. …… 
    18. 
    
    
    
    
  18. } 
    19. 
    
    
    
    
  19. //         pool  
    20. 
    
    
    
    
  20. mmc_pool_add(pool, mmc, weight); 
    21. 
    
    
    
    
  21. RETURN_TRUE; 
    22. 
    
    
    
    
  22. } 
    23. 
    
    
    
    
  23. [/cc] 
    24. 
    
    
    
    
  24.    mmc_pool_t     ： 
    25. 
    
    
    
    
  25. [cc lang="c"] 
    26. 
    
    
    
    
  26. typedef struct mmc_pool { 
    27. 
    
    
    
    
  27. mmc_t **servers; //          
    28. 
    
    
    
    
  28. int num_servers; //       
    29. 
    
    
    
    
  29. mmc_t **requests; //   get array key               
    30. 
    
    
    
    
  30. int compress_threshold; //              
    31. 
    
    
    
    
  31. double min_compress_savings; //                
    32. 
    
    
    
    
  32. zend_bool in_free; //    pool      
    33. 
    
    
    
    
  33. mmc_hash_t *hash; // hash     
    34. 
    
    
    
    
  34. void *hash_state; // hash   
    35. 
    
    
    
    
  35. } mmc_pool_t; 
    36. 
    
    
    
    
  36. [/cc] 
    37. 
    
    
    
    
  37.       mmc_hash_t   ，           ： 
    38. 
    
    
    
    
  38. [cc lang="c"] 
    39. 
    
    
    
    
  39. //               ，      ，        
    40. 
    
    
    
    
  40. typedef struct mmc_hash { 
    41. 
    
    
    
    
  41. mmc_hash_create_state create_state; //   hash    ，      hash     
    42. 
    
    
    
    
  42. mmc_hash_free_state free_state; //   hash     
    43. 
    
    
    
    
  43. mmc_hash_find_server find_server; //   key               
    44. 
    
    
    
    
  44. mmc_hash_add_server add_server; //   hash  、               
    45. 
    
    
    
    
  45. } mmc_hash_t; 
    46. 
    
    
    
    
  46. [/cc] 
    47.

次にmemcacheを追跡しますadd_server関数のmmc_pool_new関数呼び出し方法:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. mmc_pool_t *mmc_pool_new(TSRMLS_D) /* {{{ */ 
    3. 
    
    
    
    
  3. { 
    4. 
    
    
    
    
  4. //            
    5. 
    
    
    
    
  5. mmc_pool_t *pool = emalloc(sizeof(mmc_pool_t)); 
    6. 
    
    
    
    
  6. pool->num_servers = 0; 
    7. 
    
    
    
    
  7. pool->compress_threshold = 0; 
    8. 
    
    
    
    
  8. pool->in_free = 0; 
    9. 
    
    
    
    
  9. pool->min_compress_savings = MMC_DEFAULT_SAVINGS; 
    10. 
    
    
    
    
  10. //            
    11. 
    
    
    
    
  11. mmc_pool_init_hash(pool TSRMLS_CC); 
    12. 
    
    
    
    
  12. return pool; 
    13. 
    
    
    
    
  13. } 
    14. 
    
    
    
    
  14. [/cc] 
    15.

初期化hashアルゴリズムが徐々に現れ、mmc_を追跡し続けている.pool_init_hash関数:

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. static void mmc_pool_init_hash(mmc_pool_t *pool TSRMLS_DC) /* {{{ */ 
    3. 
    
    
    
    
  3. { 
    4. 
    
    
    
    
  4. mmc_hash_function hash; //    hash   
    5. 
    
    
    
    
  5. //   php.ini  memcache.hash_strategy    hash    ，     hash     
    6. 
    
    
    
    
  6. switch (MEMCACHE_G(hash_strategy)) { 
    7. 
    
    
    
    
  7. case MMC_CONSISTENT_HASH: 
    8. 
    
    
    
    
  8. pool->hash = &mmc_consistent_hash; //      hash     
    9. 
    
    
    
    
  9. break; 
    10. 
    
    
    
    
  10. default: 
    11. 
    
    
    
    
  11. pool->hash = &mmc_standard_hash; //     hash     
    12. 
    
    
    
    
  12. } 
    13. 
    
    
    
    
  13. //   php.ini  memcache.hash_function    hash  ，   crc32   
    14. 
    
    
    
    
  14. switch (MEMCACHE_G(hash_function)) { 
    15. 
    
    
    
    
  15. case MMC_HASH_FNV1A: 
    16. 
    
    
    
    
  16. hash = &mmc_hash_fnv1a; //   fnv1a   
    17. 
    
    
    
    
  17. break; 
    18. 
    
    
    
    
  18. default: 
    19. 
    
    
    
    
  19. hash = &mmc_hash_crc32; //   crc32   
    20. 
    
    
    
    
  20. } 
    21. 
    
    
    
    
  21. // hash        hash          
    22. 
    
    
    
    
  22. pool->hash_state = pool->hash->create_state(hash); 
    23. 
    
    
    
    
  23. } 
    24. 
    
    
    
    
  24. [/cc] 
    25.

上の2つのswitchから分かるようにcreate_stateの場合、2つのポリシーが選択される可能性があり、次に入力されるhashパラメータにも2つの可能性があります.ここでは、標準hashストレージポリシーと対応する2つのhashアルゴリズムを分析してから、永続化hashポリシーを分析します.
まずmmc_を見てみましょうconsistent_hash構造:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. //   mmc_hash_t               
    3. 
    
    
    
    
  3. mmc_hash_t mmc_standard_hash = { 
    4. 
    
    
    
    
  4. mmc_standard_create_state, 
    5. 
    
    
    
    
  5. mmc_standard_free_state, 
    6. 
    
    
    
    
  6. mmc_standard_find_server, 
    7. 
    
    
    
    
  7. mmc_standard_add_server 
    8. 
    
    
    
    
  8. }; 
    9. 
    
    
    
    
  9. [/cc] 
    10.

上から分かるようにpool->hash->create_stateの関数呼び出しは実際にはmmc_standard_create_stateの関数呼び出し、mmc_を見続けますstandard_create_state関数コードの実装:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. // hash     
    3. 
    
    
    
    
  3. typedef struct mmc_standard_state { 
    4. 
    
    
    
    
  4. int num_servers; //       
    5. 
    
    
    
    
  5. mmc_t **buckets; //    ，       
    6. 
    
    
    
    
  6. int num_buckets; //        
    7. 
    
    
    
    
  7. mmc_hash_function hash; // hash   
    8. 
    
    
    
    
  8. } mmc_standard_state_t; 
    9. 
    
    
    
    
  9. void *mmc_standard_create_state(mmc_hash_function hash) /* {{{ */ 
    10. 
    
    
    
    
  10. { 
    11. 
    
    
    
    
  11. //       
    12. 
    
    
    
    
  12. mmc_standard_state_t *state = emalloc(sizeof(mmc_standard_state_t)); 
    13. 
    
    
    
    
  13. memset(state, 0, sizeof(mmc_standard_state_t)); 
    14. 
    
    
    
    
  14. //    hash    hash   
    15. 
    
    
    
    
  15. state->hash = hash; 
    16. 
    
    
    
    
  16. return state; 
    17. 
    
    
    
    
  17. } 
    18. 
    
    
    
    
  18. [/cc] 
    19. 
    
    
    
    
  19. crc     ： 
    20. 
    
    
    
    
  20. [cc lang="c"] 
    21. 
    
    
    
    
  21. static unsigned int mmc_hash_crc32(const char *key, int key_len) /* CRC32 hash {{{ */ 
    22. 
    
    
    
    
  22. { 
    23. 
    
    
    
    
  23. unsigned int crc = ~0; 
    24. 
    
    
    
    
  24. int i; 
    25. 
    
    
    
    
  25. for (i=0; i CRC32(crc, key[i]); 
    26. 
    
    
    
    
  26. } 
    27. 
    
    
    
    
  27. return ~crc; 
    28. 
    
    
    
    
  28. } 
    29. 
    
    
    
    
  29. [/cc] 
    30. 
    
    
    
    
  30.   CRC32          Cyclic redundancy check 
    31. 
    
    
    
    
  31.      fnv    ： 
    32. 
    
    
    
    
  32. [cc lang="c"] 
    33. 
    
    
    
    
  33. /* 32 bit magic FNV-1a prime and init */ 
    34. 
    
    
    
    
  34. #define FNV_32_PRIME 0×01000193 
    35. 
    
    
    
    
  35. #define FNV_32_INIT 0x811c9dc5 
    36. 
    
    
    
    
  36. static unsigned int mmc_hash_fnv1a(const char *key, int key_len) /* FNV-1a hash {{{ */ 
    37. 
    
    
    
    
  37. { 
    38. 
    
    
    
    
  38. unsigned int hval = FNV_32_INIT; 
    39. 
    
    
    
    
  39. int i; 
    40. 
    
    
    
    
  40. for (i=0; i hval ^= (unsigned int)key[i]; 
    41. 
    
    
    
    
  41. hval *= FNV_32_PRIME; 
    42. 
    
    
    
    
  42. } 
    43. 
    
    
    
    
  43. return hval; 
    44. 
    
    
    
    
  44. } 
    45. 
    
    
    
    
  45. [/cc] 
    46.

具体的なfnvアルゴリズムの深い実現は参考にすることができる
Fowler–Noll–Vo hash function
 
最後にmmc_を見てみましょうconsistent_hash構造:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. mmc_hash_t mmc_consistent_hash = { 
    3. 
    
    
    
    
  3. mmc_consistent_create_state, 
    4. 
    
    
    
    
  4. mmc_consistent_free_state, 
    5. 
    
    
    
    
  5. mmc_consistent_find_server, 
    6. 
    
    
    
    
  6. mmc_consistent_add_server 
    7. 
    
    
    
    
  7. }; 
    8. 
    
    
    
    
  8. [/cc] 
    9.

同じ4つの関数で、対応するcreateを見てみましょう.stateのmmc_consistent_create_stateの実装:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. /* number of precomputed buckets, should be power of 2 */ 
    3. 
    
    
    
    
  3. #define MMC_CONSISTENT_BUCKETS 1024 
    4. 
    
    
    
    
  4. typedef struct mmc_consistent_point { 
    5. 
    
    
    
    
  5. mmc_t *server; //       
    6. 
    
    
    
    
  6. unsigned int point; //       
    7. 
    
    
    
    
  7. } mmc_consistent_point_t; 
    8. 
    
    
    
    
  8. typedef struct mmc_consistent_state { 
    9. 
    
    
    
    
  9. int num_servers; //       
    10. 
    
    
    
    
  10. mmc_consistent_point_t *points; //          
    11. 
    
    
    
    
  11. int num_points; //      
    12. 
    
    
    
    
  12. mmc_t *buckets[MMC_CONSISTENT_BUCKETS]; //     
    13. 
    
    
    
    
  13. int buckets_populated; //            
    14. 
    
    
    
    
  14. mmc_hash_function hash; // hash   
    15. 
    
    
    
    
  15. } mmc_consistent_state_t; 
    16. 
    
    
    
    
  16. void *mmc_consistent_create_state(mmc_hash_function hash) /* {{{ */ 
    17. 
    
    
    
    
  17. { 
    18. 
    
    
    
    
  18. //    state 
    19. 
    
    
    
    
  19. mmc_consistent_state_t *state = emalloc(sizeof(mmc_consistent_state_t)); 
    20. 
    
    
    
    
  20. memset(state, 0, sizeof(mmc_consistent_state_t)); 
    21. 
    
    
    
    
  21. //  hash     hash   
    22. 
    
    
    
    
  22. state->hash = hash; 
    23. 
    
    
    
    
  23. return state; 
    24. 
    
    
    
    
  24. } 
    25. 
    
    
    
    
  25. [/cc] 
    26.

これでmemcache_add_server中mmc_pool_new関数の流れが終わり、次にmmc_を見てみましょう.pool_add関数:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. void mmc_pool_add(mmc_pool_t *pool, mmc_t *mmc, unsigned int weight) /* {{{ */ 
    3. 
    
    
    
    
  3. { 
    4. 
    
    
    
    
  4. /* add server and a preallocated request pointer */ 
    5. 
    
    
    
    
  5. if (pool->num_servers) { 
    6. 
    
    
    
    
  6. pool->servers = erealloc(pool->servers, sizeof(mmc_t *) * (pool->num_servers + 1)); 
    7. 
    
    
    
    
  7. pool->requests = erealloc(pool->requests, sizeof(mmc_t *) * (pool->num_servers + 1)); 
    8. 
    
    
    
    
  8. } 
    9. 
    
    
    
    
  9. else { 
    10. 
    
    
    
    
  10. pool->servers = emalloc(sizeof(mmc_t *)); 
    11. 
    
    
    
    
  11. pool->requests = emalloc(sizeof(mmc_t *)); 
    12. 
    
    
    
    
  12. } 
    13. 
    
    
    
    
  13. pool->servers[pool->num_servers] = mmc; 
    14. 
    
    
    
    
  14. pool->num_servers++; 
    15. 
    
    
    
    
  15. //   pool  ，                add_server   
    16. 
    
    
    
    
  16. pool->hash->add_server(pool->hash_state, mmc, weight); 
    17. 
    
    
    
    
  17. } 
    18. 
    
    
    
    
  18. [/cc] 
    19. 
    
    
    
    
  19.         add_server   hash     mmc_standard_add_server  ： 
    20. 
    
    
    
    
  20. [cc lang="c"] 
    21. 
    
    
    
    
  21. void mmc_standard_add_server(void *s, mmc_t *mmc, unsigned int weight) /* {{{ */ 
    22. 
    
    
    
    
  22. { 
    23. 
    
    
    
    
  23. mmc_standard_state_t *state = s; 
    24. 
    
    
    
    
  24. int i; 
    25. 
    
    
    
    
  25. //                         
    26. 
    
    
    
    
  26. if (state->num_buckets) { 
    27. 
    
    
    
    
  27. state->buckets = erealloc(state->buckets, sizeof(mmc_t *) * (state->num_buckets + weight)); 
    28. 
    
    
    
    
  28. } 
    29. 
    
    
    
    
  29. else { 
    30. 
    
    
    
    
  30. state->buckets = emalloc(sizeof(mmc_t *) * (weight)); 
    31. 
    
    
    
    
  31. } 
    32. 
    
    
    
    
  32. //                   
    33. 
    
    
    
    
  33. for (i=0; i buckets[state->num_buckets + i] = mmc; 
    34. 
    
    
    
    
  34. } 
    35. 
    
    
    
    
  35. state->num_buckets += weight; 
    36. 
    
    
    
    
  36. state->num_servers++; 
    37. 
    
    
    
    
  37. } 
    38. 
    
    
    
    
  38. [/cc] 
    39.

永続化hashモードではmmc_に対応するconsistent_add_server関数:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. #define MMC_CONSISTENT_POINTS 160 /* points per server */ 
    3. 
    
    
    
    
  3. void mmc_consistent_add_server(void *s, mmc_t *mmc, unsigned int weight) /* {{{ */ 
    4. 
    
    
    
    
  4. { 
    5. 
    
    
    
    
  5. mmc_consistent_state_t *state = s; 
    6. 
    
    
    
    
  6. int i, key_len, points = weight * MMC_CONSISTENT_POINTS; 
    7. 
    
    
    
    
  7. /* buffer for "host:port-i\0" */ 
    8. 
    
    
    
    
  8. char *key = emalloc(strlen(mmc->host) + MAX_LENGTH_OF_LONG * 2 + 3); 
    9. 
    
    
    
    
  9. /* add weight * MMC_CONSISTENT_POINTS number of points for this server */ 
    10. 
    
    
    
    
  10. state->points = erealloc(state->points, sizeof(mmc_consistent_point_t) * (state->num_points + points)); 
    11. 
    
    
    
    
  11. //      server         ，point  hash        
    12. 
    
    
    
    
  12. for (i=0; i key_len = sprintf(key, "%s:%d-%d", mmc->host, mmc->port, i); 
    13. 
    
    
    
    
  13. state->points[state->num_points + i].server = mmc; 
    14. 
    
    
    
    
  14. state->points[state->num_points + i].point = state->hash(key, key_len); 
    15. 
    
    
    
    
  15. MMC_DEBUG(("mmc_consistent_add_server: key %s, point %lu", key, state->points[state->num_points + i].point)); 
    16. 
    
    
    
    
  16. } 
    17. 
    
    
    
    
  17. state->num_points += points; 
    18. 
    
    
    
    
  18. state->num_servers++; 
    19. 
    
    
    
    
  19. //             buckets   
    20. 
    
    
    
    
  20. state->buckets_populated = 0; 
    21. 
    
    
    
    
  21. efree(key); 
    22. 
    
    
    
    
  22. } 
    23. 
    
    
    
    
  23. [/cc] 
    24.

以上のコードは永続化hashアルゴリズムの賦値実現があり、具体的にはConsistent hashingと国内の大侠charlee翻訳の小日本の文章memcached全面剖析–PDF総括編を参照してください.
Consistent hashingアルゴリズムの最大の特徴は、キャッシュ・サーバの数が変更された場合、既存のキャッシュを再分散する必要がなく、既存のキャッシュをそのまま保持できることです.
これでmemcache全体がadd_serverプロセスが終了しました.
3.キャッシュサーバへのデータ保存
PHP対応コード:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="php"] 
    2. 
    
    
    
    
  2. $mmc->set(‘key’, ‘value’); 
    3. 
    
    
    
    
  3. [/cc] 
    4. 
    
    
    
    
  4.         ，set      memcache_set  ： 
    5. 
    
    
    
    
  5. [cc lang="c"] 
    6. 
    
    
    
    
  6. /* {{{ proto bool memcache_set( object memcache, string key, mixed var [, int flag [, int expire ] ] ) 
    7. 
    
    
    
    
  7. Sets the value of an item. Item may exist or not */ 
    8. 
    
    
    
    
  8. PHP_FUNCTION(memcache_set) 
    9. 
    
    
    
    
  9. { 
    10. 
    
    
    
    
  10. // Memcache    add，set replace       
    11. 
    
    
    
    
  11. php_mmc_store(INTERNAL_FUNCTION_PARAM_PASSTHRU, "set", sizeof("set") – 1); 
    12. 
    
    
    
    
  12. } 
    13. 
    
    
    
    
  13. [/cc] 
    14.

php_を見てmmc_store関数:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. static void php_mmc_store(INTERNAL_FUNCTION_PARAMETERS, char *command, int command_len) /* {{{ */ 
    3. 
    
    
    
    
  3. { 
    4. 
    
    
    
    
  4. mmc_pool_t *pool; 
    5. 
    
    
    
    
  5. …… 
    6. 
    
    
    
    
  6. //   pool 
    7. 
    
    
    
    
  7. if (!mmc_get_pool(mmc_object, &pool TSRMLS_CC) || !pool->num_servers) { 
    8. 
    
    
    
    
  8. RETURN_FALSE; 
    9. 
    
    
    
    
  9. } 
    10. 
    
    
    
    
  10. //                   
    11. 
    
    
    
    
  11. switch (Z_TYPE_P(value)) { 
    12. 
    
    
    
    
  12. //       
    13. 
    
    
    
    
  13. case IS_STRING: 
    14. 
    
    
    
    
  14. result = mmc_pool_store( 
    15. 
    
    
    
    
  15. pool, command, command_len, key_tmp, key_tmp_len, flags, expire, 
    16. 
    
    
    
    
  16. Z_STRVAL_P(value), Z_STRLEN_P(value) TSRMLS_CC); 
    17. 
    
    
    
    
  17. break; 
    18. 
    
    
    
    
  18. //    ，   ，    
    19. 
    
    
    
    
  19. case IS_LONG: 
    20. 
    
    
    
    
  20. case IS_DOUBLE: 
    21. 
    
    
    
    
  21. case IS_BOOL: { 
    22. 
    
    
    
    
  22. …… 
    23. 
    
    
    
    
  23. result = mmc_pool_store( 
    24. 
    
    
    
    
  24. pool, command, command_len, key_tmp, key_tmp_len, flags, expire, 
    25. 
    
    
    
    
  25. Z_STRVAL(value_copy), Z_STRLEN(value_copy) TSRMLS_CC); 
    26. 
    
    
    
    
  26. zval_dtor(&value_copy); 
    27. 
    
    
    
    
  27. break; 
    28. 
    
    
    
    
  28. } 
    29. 
    
    
    
    
  29. //         
    30. 
    
    
    
    
  30. default: { 
    31. 
    
    
    
    
  31. …… 
    32. 
    
    
    
    
  32. result = mmc_pool_store( 
    33. 
    
    
    
    
  33. pool, command, command_len, key_tmp, key_tmp_len, flags, expire, 
    34. 
    
    
    
    
  34. buf.c, buf.len TSRMLS_CC); 
    35. 
    
    
    
    
  35. } 
    36. 
    
    
    
    
  36. } 
    37. 
    
    
    
    
  37. …… 
    38. 
    
    
    
    
  38. } 
    39. 
    
    
    
    
  39. [/cc] 
    40.

上のコードから分かるように、格納データは主にmmc_に渡されている.pool_store処理:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. int mmc_pool_store(mmc_pool_t *pool, const char *command, int command_len, const char *key, int key_len, int flags, int expire, const char *value, int value_len TSRMLS_DC) /* {{{ */ 
    3. 
    
    
    
    
  3. { 
    4. 
    
    
    
    
  4. /*            ，           */ 
    5. 
    
    
    
    
  5. …… 
    6. 
    
    
    
    
  6. //   key          
    7. 
    
    
    
    
  7. while (result < 0 && (mmc = mmc_pool_find(pool, key, key_len TSRMLS_CC)) != NULL) { 
    8. 
    
    
    
    
  8. //           ，     
    9. 
    
    
    
    
  9. if ((result = mmc_server_store(mmc, request, request_len TSRMLS_CC)) < 0) { 
    10. 
    
    
    
    
  10. mmc_server_failure(mmc TSRMLS_CC); 
    11. 
    
    
    
    
  11. } 
    12. 
    
    
    
    
  12. } 
    13. 
    
    
    
    
  13. if (key_copy != NULL) { 
    14. 
    
    
    
    
  14. efree(key_copy); 
    15. 
    
    
    
    
  15. } 
    16. 
    
    
    
    
  16. if (data != NULL) { 
    17. 
    
    
    
    
  17. efree(data); 
    18. 
    
    
    
    
  18. } 
    19. 
    
    
    
    
  19. efree(request); 
    20. 
    
    
    
    
  20. return result; 
    21. 
    
    
    
    
  21. } 
    22. 
    
    
    
    
  22. [/cc] 
    23.

次にmmc_を見てみましょうpool_findは処理されています
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. #define mmc_pool_find(pool, key, key_len) \ 
    3. 
    
    
    
    
  3. pool->hash->find_server(pool->hash_state, key, key_len) 
    4. 
    
    
    
    
  4. [/cc] 
    5.

再びマルチステート呼び出しfind_server関数、前の分析からfind_がわかりますserverの標準hashモードでの関数はmmc_standard_find_server、持続化hashモードでの関数はmmc_consistent_find_server、同じようにmmc_を先に見ますstandard_find_server
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. mmc_t *mmc_standard_find_server(void *s, const char *key, int key_len TSRMLS_DC) /* {{{ */ 
    3. 
    
    
    
    
  3. { 
    4. 
    
    
    
    
  4. mmc_standard_state_t *state = s; 
    5. 
    
    
    
    
  5. mmc_t *mmc; 
    6. 
    
    
    
    
  6. if (state->num_servers > 1) { 
    7. 
    
    
    
    
  7. //     hash    ，         
    8. 
    
    
    
    
  8. unsigned int hash = mmc_hash(state, key, key_len), i; 
    9. 
    
    
    
    
  9. mmc = state->buckets[hash % state->num_buckets]; 
    10. 
    
    
    
    
  10. //               ，   hash                
    11. 
    
    
    
    
  11. for (i=0; !mmc_open(mmc, 0, NULL, NULL TSRMLS_CC) && MEMCACHE_G(allow_failover) && i char *next_key = emalloc(key_len + MAX_LENGTH_OF_LONG + 1); 
    12. 
    
    
    
    
  12. int next_len = sprintf(next_key, "%d%s", i+1, key); 
    13. 
    
    
    
    
  13. MMC_DEBUG(("mmc_standard_find_server: failed to connect to server '%s:%d' status %d, trying next", mmc->host, mmc->port, mmc->status)); 
    14. 
    
    
    
    
  14. hash += mmc_hash(state, next_key, next_len); 
    15. 
    
    
    
    
  15. mmc = state->buckets[hash % state->num_buckets]; 
    16. 
    
    
    
    
  16. efree(next_key); 
    17. 
    
    
    
    
  17. } 
    18. 
    
    
    
    
  18. } 
    19. 
    
    
    
    
  19. else { 
    20. 
    
    
    
    
  20. mmc = state->buckets[0]; 
    21. 
    
    
    
    
  21. mmc_open(mmc, 0, NULL, NULL TSRMLS_CC); 
    22. 
    
    
    
    
  22. } 
    23. 
    
    
    
    
  23. return mmc->status != MMC_STATUS_FAILED ? mmc : NULL; 
    24. 
    
    
    
    
  24. } 
    25. 
    
    
    
    
  25. [/cc] 
    26.

mmc_を見てconsistent_find_server
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. mmc_t *mmc_consistent_find_server(void *s, const char *key, int key_len TSRMLS_DC) /* {{{ */ 
    3. 
    
    
    
    
  3. { 
    4. 
    
    
    
    
  4. mmc_consistent_state_t *state = s; 
    5. 
    
    
    
    
  5. mmc_t *mmc; 
    6. 
    
    
    
    
  6. if (state->num_servers > 1) { 
    7. 
    
    
    
    
  7. unsigned int i, hash = state->hash(key, key_len); 
    8. 
    
    
    
    
  8. //             ，          
    9. 
    
    
    
    
  9. if (!state->buckets_populated) { 
    10. 
    
    
    
    
  10. mmc_consistent_populate_buckets(state); 
    11. 
    
    
    
    
  11. } 
    12. 
    
    
    
    
  12. mmc = state->buckets[hash % MMC_CONSISTENT_BUCKETS]; 
    13. 
    
    
    
    
  13. //               ，   hash                
    14. 
    
    
    
    
  14. for (i=0; !mmc_open(mmc, 0, NULL, NULL TSRMLS_CC) && MEMCACHE_G(allow_failover) && i char *next_key = emalloc(key_len + MAX_LENGTH_OF_LONG + 1); 
    15. 
    
    
    
    
  15. int next_len = sprintf(next_key, "%s-%d", key, i); 
    16. 
    
    
    
    
  16. MMC_DEBUG(("mmc_consistent_find_server: failed to connect to server '%s:%d' status %d, trying next", mmc->host, mmc->port, mmc->status)); 
    17. 
    
    
    
    
  17. hash = state->hash(next_key, next_len); 
    18. 
    
    
    
    
  18. mmc = state->buckets[hash % MMC_CONSISTENT_BUCKETS]; 
    19. 
    
    
    
    
  19. efree(next_key); 
    20. 
    
    
    
    
  20. } 
    21. 
    
    
    
    
  21. } 
    22. 
    
    
    
    
  22. else { 
    23. 
    
    
    
    
  23. mmc = state->points[0].server; 
    24. 
    
    
    
    
  24. mmc_open(mmc, 0, NULL, NULL TSRMLS_CC); 
    25. 
    
    
    
    
  25. } 
    26. 
    
    
    
    
  26. return mmc->status != MMC_STATUS_FAILED ? mmc : NULL; 
    27. 
    
    
    
    
  27. } 
    28. 
    
    
    
    
  28. //              
    29. 
    
    
    
    
  29. static void mmc_consistent_populate_buckets(mmc_consistent_state_t *state) /* {{{ */ 
    30. 
    
    
    
    
  30. { 
    31. 
    
    
    
    
  31. unsigned int i, step = 0xffffffff / MMC_CONSISTENT_BUCKETS; 
    32. 
    
    
    
    
  32. qsort((void *)state->points, state->num_points, sizeof(mmc_consistent_point_t), mmc_consistent_compare); 
    33. 
    
    
    
    
  33. for (i=0; i state->buckets[i] = mmc_consistent_find(state, step * i); 
    34. 
    
    
    
    
  34. } 
    35. 
    
    
    
    
  35. state->buckets_populated = 1; 
    36. 
    
    
    
    
  36. } 
    37. 
    
    
    
    
  37. static int mmc_consistent_compare(const void *a, const void *b) /* {{{ */ 
    38. 
    
    
    
    
  38. { 
    39. 
    
    
    
    
  39. if (((mmc_consistent_point_t *)a)->point < ((mmc_consistent_point_t *)b)->point) { 
    40. 
    
    
    
    
  40. return -1; 
    41. 
    
    
    
    
  41. } 
    42. 
    
    
    
    
  42. if (((mmc_consistent_point_t *)a)->point > ((mmc_consistent_point_t *)b)->point) { 
    43. 
    
    
    
    
  43. return 1; 
    44. 
    
    
    
    
  44. } 
    45. 
    
    
    
    
  45. return 0; 
    46. 
    
    
    
    
  46. } 
    47. 
    
    
    
    
  47. static mmc_t *mmc_consistent_find(mmc_consistent_state_t *state, unsigned int point) /* {{{ */ 
    48. 
    
    
    
    
  48. { 
    49. 
    
    
    
    
  49. int lo = 0, hi = state->num_points – 1, mid; 
    50. 
    
    
    
    
  50. while (1) { 
    51. 
    
    
    
    
  51. /* point is outside interval or lo >= hi, wrap-around */ 
    52. 
    
    
    
    
  52. if (point <= state->points[lo].point || point > state->points[hi].point) { 
    53. 
    
    
    
    
  53. return state->points[lo].server; 
    54. 
    
    
    
    
  54. } 
    55. 
    
    
    
    
  55. /* test middle point */ 
    56. 
    
    
    
    
  56. mid = lo + (hi – lo) / 2; 
    57. 
    
    
    
    
  57. MMC_DEBUG(("mmc_consistent_find: lo %d, hi %d, mid %d, point %u, midpoint %u", lo, hi, mid, point, state->points[mid].point)); 
    58. 
    
    
    
    
  58. /* perfect match */ 
    59. 
    
    
    
    
  59. if (point <= state->points[mid].point && point > (mid ? state->points[mid-1].point : 0)) { 
    60. 
    
    
    
    
  60. return state->points[mid].server; 
    61. 
    
    
    
    
  61. } 
    62. 
    
    
    
    
  62. /* too low, go up */ 
    63. 
    
    
    
    
  63. if (state->points[mid].point < point) { 
    64. 
    
    
    
    
  64. lo = mid + 1; 
    65. 
    
    
    
    
  65. } 
    66. 
    
    
    
    
  66. else { 
    67. 
    
    
    
    
  67. hi = mid - 1; 
    68. 
    
    
    
    
  68. } 
    69. 
    
    
    
    
  69. } 
    70. 
    
    
    
    
  70. } 
    71. 
    
    
    
    
  71. [/cc] 
    72.

これでmemcache_setプロセスが終了します.
4.保存したデータをキャッシュサーバに取得する
PHP対応コード:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="php"] 
    2. 
    
    
    
    
  2. echo $mmc->get(‘key’); 
    3. 
    
    
    
    
  3. [/cc] 
    4.

以上の解析から,getメソッドはmemcache_に対応することが分かった.get関数:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="php"] 
    2. 
    
    
    
    
  2. PHP_FUNCTION(memcache_get) 
    3. 
    
    
    
    
  3. { 
    4. 
    
    
    
    
  4. …… 
    5. 
    
    
    
    
  5. //   pool 
    6. 
    
    
    
    
  6. if (!mmc_get_pool(mmc_object, &pool TSRMLS_CC) || !pool->num_servers) { 
    7. 
    
    
    
    
  7. RETURN_FALSE; 
    8. 
    
    
    
    
  8. } 
    9. 
    
    
    
    
  9. //  key           
    10. 
    
    
    
    
  10. if (Z_TYPE_P(zkey) != IS_ARRAY) { 
    11. 
    
    
    
    
  11. //   key     
    12. 
    
    
    
    
  12. if (mmc_prepare_key(zkey, key, &key_len TSRMLS_CC) == MMC_OK) { 
    13. 
    
    
    
    
  13. //   key  value 
    14. 
    
    
    
    
  14. if (mmc_exec_retrieval_cmd(pool, key, key_len, &return_value, flags TSRMLS_CC) < 0) { 
    15. 
    
    
    
    
  15. zval_dtor(return_value); 
    16. 
    
    
    
    
  16. RETVAL_FALSE; 
    17. 
    
    
    
    
  17. } 
    18. 
    
    
    
    
  18. } 
    19. 
    
    
    
    
  19. else { 
    20. 
    
    
    
    
  20. RETVAL_FALSE; 
    21. 
    
    
    
    
  21. } 
    22. 
    
    
    
    
  22. //           
    23. 
    
    
    
    
  23. } else if (zend_hash_num_elements(Z_ARRVAL_P(zkey))){ 
    24. 
    
    
    
    
  24. //    key      
    25. 
    
    
    
    
  25. if (mmc_exec_retrieval_cmd_multi(pool, zkey, &return_value, flags TSRMLS_CC) < 0) { 
    26. 
    
    
    
    
  26. zval_dtor(return_value); 
    27. 
    
    
    
    
  27. RETVAL_FALSE; 
    28. 
    
    
    
    
  28. } 
    29. 
    
    
    
    
  29. } else { 
    30. 
    
    
    
    
  30. RETVAL_FALSE; 
    31. 
    
    
    
    
  31. } 
    32. 
    
    
    
    
  32. } 
    33. 
    
    
    
    
  33. [/cc] 
    34.

次にmmc_を見てexec_retrieval_cmdとmmc_exec_retrieval_cmd_Multi関数:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. int mmc_exec_retrieval_cmd(mmc_pool_t *pool, const char *key, int key_len, zval **return_value, zval *return_flags TSRMLS_DC) /* {{{ */ 
    3. 
    
    
    
    
  3. { 
    4. 
    
    
    
    
  4. mmc_t *mmc; 
    5. 
    
    
    
    
  5. char *command, *value; 
    6. 
    
    
    
    
  6. int result = -1, command_len, response_len, value_len, flags = 0; 
    7. 
    
    
    
    
  7. MMC_DEBUG(("mmc_exec_retrieval_cmd: key '%s'", key)); 
    8. 
    
    
    
    
  8. command_len = spprintf(&command, 0, "get %s", key); 
    9. 
    
    
    
    
  9. //      key   value  
    10. 
    
    
    
    
  10. while (result < 0 && (mmc = mmc_pool_find(pool, key, key_len TSRMLS_CC)) != NULL) { 
    11. 
    
    
    
    
  11. ...... 
    12. 
    
    
    
    
  12. } 
    13. 
    
    
    
    
  13. if (return_flags != NULL) { 
    14. 
    
    
    
    
  14. zval_dtor(return_flags); 
    15. 
    
    
    
    
  15. ZVAL_LONG(return_flags, flags); 
    16. 
    
    
    
    
  16. } 
    17. 
    
    
    
    
  17. efree(command); 
    18. 
    
    
    
    
  18. return result; 
    19. 
    
    
    
    
  19. } 
    20. 
    
    
    
    
  20. static int mmc_exec_retrieval_cmd_multi(mmc_pool_t *pool, zval *keys, zval **return_value, zval *return_flags TSRMLS_DC) /* {{{ */ 
    21. 
    
    
    
    
  21. { 
    22. 
    
    
    
    
  22. ...... 
    23. 
    
    
    
    
  23. do { 
    24. 
    
    
    
    
  24. result_status = num_requests = 0; 
    25. 
    
    
    
    
  25. zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(keys), &pos); 
    26. 
    
    
    
    
  26. //   key    key          pool->requests  
    27. 
    
    
    
    
  27. while (zend_hash_get_current_data_ex(Z_ARRVAL_P(keys), (void **)&zkey, &pos) == SUCCESS) { 
    28. 
    
    
    
    
  28. if (mmc_prepare_key(*zkey, key, &key_len TSRMLS_CC) == MMC_OK) { 
    29. 
    
    
    
    
  29. /* schedule key if first round or if missing from result */ 
    30. 
    
    
    
    
  30. if ((!i || !zend_hash_exists(Z_ARRVAL_PP(return_value), key, key_len)) && 
    31. 
    
    
    
    
  31. //   key       
    32. 
    
    
    
    
  32. (mmc = mmc_pool_find(pool, key, key_len TSRMLS_CC)) != NULL) { 
    33. 
    
    
    
    
  33. if (!(mmc->outbuf.len)) { 
    34. 
    
    
    
    
  34. smart_str_appendl(&(mmc->outbuf), "get", sizeof("get")-1); 
    35. 
    
    
    
    
  35. pool->requests[num_requests++] = mmc; 
    36. 
    
    
    
    
  36. } 
    37. 
    
    
    
    
  37. smart_str_appendl(&(mmc->outbuf), " ", 1); 
    38. 
    
    
    
    
  38. smart_str_appendl(&(mmc->outbuf), key, key_len); 
    39. 
    
    
    
    
  39. MMC_DEBUG(("mmc_exec_retrieval_cmd_multi: scheduled key ‘%s’ for ‘%s:%d’ request length ‘%d’", key, mmc->host, mmc->port, mmc->outbuf.len)); 
    40. 
    
    
    
    
  40. } 
    41. 
    
    
    
    
  41. } 
    42. 
    
    
    
    
  42. zend_hash_move_forward_ex(Z_ARRVAL_P(keys), &pos); 
    43. 
    
    
    
    
  43. } 
    44. 
    
    
    
    
  44. …… 
    45. 
    
    
    
    
  45. } while (result_status < 0 && MEMCACHE_G(allow_failover) && i++ < MEMCACHE_G(max_failover_attempts)); 
    46. 
    
    
    
    
  46. ...... 
    47. 
    
    
    
    
  47. return result_status; 
    48. 
    
    
    
    
  48. } 
    49. 
    
    
    
    
  49. [/cc] 
    50.

上から見える分布式hashのコア関数はすべてmmc_pool_findは、まずkeyに対応するサーバリソースを見つけ、サーバリソースに基づいてデータを要求します.
これでmemcache_getのプロセスは終了します.
5.保存したデータをキャッシュサーバに削除する
対応するphpコード:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="php"] 
    2. 
    
    
    
    
  2. $mmc->delete(‘key’); 
    3. 
    
    
    
    
  3. [/cc] 
    4.

以前の解析からdeleteはmemcache_に対応することが分かった.delete:
  

   
   
   
   
    
    
    
    
    
  1. [cc lang="c"] 
    2. 
    
    
    
    
  2. /* {{{ proto bool memcache_delete( object memcache, string key [, int expire ]) 
    3. 
    
    
    
    
  3. Deletes existing item */ 
    4. 
    
    
    
    
  4. PHP_FUNCTION(memcache_delete) 
    5. 
    
    
    
    
  5. { 
    6. 
    
    
    
    
  6. mmc_t *mmc; 
    7. 
    
    
    
    
  7. mmc_pool_t *pool; 
    8. 
    
    
    
    
  8. int result = -1, key_len; 
    9. 
    
    
    
    
  9. zval *mmc_object = getThis(); 
    10. 
    
    
    
    
  10. char *key; 
    11. 
    
    
    
    
  11. long time = 0; 
    12. 
    
    
    
    
  12. char key_tmp[MMC_KEY_MAX_SIZE]; 
    13. 
    
    
    
    
  13. unsigned int key_tmp_len; 
    14. 
    
    
    
    
  14. if (mmc_object == NULL) { 
    15. 
    
    
    
    
  15. if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os|l", &mmc_object, memcache_class_entry_ptr, &key, &key_len, &time) == FAILURE) { 
    16. 
    
    
    
    
  16. return; 
    17. 
    
    
    
    
  17. } 
    18. 
    
    
    
    
  18. } 
    19. 
    
    
    
    
  19. else { 
    20. 
    
    
    
    
  20. if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &key, &key_len, &time) == FAILURE) { 
    21. 
    
    
    
    
  21. return; 
    22. 
    
    
    
    
  22. } 
    23. 
    
    
    
    
  23. } 
    24. 
    
    
    
    
  24. if (!mmc_get_pool(mmc_object, &pool TSRMLS_CC) || !pool->num_servers) { 
    25. 
    
    
    
    
  25. RETURN_FALSE; 
    26. 
    
    
    
    
  26. } 
    27. 
    
    
    
    
  27. if (mmc_prepare_key_ex(key, key_len, key_tmp, &key_tmp_len TSRMLS_CC) != MMC_OK) { 
    28. 
    
    
    
    
  28. RETURN_FALSE; 
    29. 
    
    
    
    
  29. } 
    30. 
    
    
    
    
  30. //          
    31. 
    
    
    
    
  31. while (result < 0 && (mmc = mmc_pool_find(pool, key_tmp, key_tmp_len TSRMLS_CC)) != NULL) { 
    32. 
    
    
    
    
  32. //                       
    33. 
    
    
    
    
  33. if ((result = mmc_delete(mmc, key_tmp, key_tmp_len, time TSRMLS_CC)) < 0) { 
    34. 
    
    
    
    
  34. mmc_server_failure(mmc TSRMLS_CC); 
    35. 
    
    
    
    
  35. } 
    36. 
    
    
    
    
  36. } 
    37. 
    
    
    
    
  37. if (result > 0) { 
    38. 
    
    
    
    
  38. RETURN_TRUE; 
    39. 
    
    
    
    
  39. } 
    40. 
    
    
    
    
  40. RETURN_FALSE; 
    41. 
    
    
    
    
  41. } 
    42. 
    
    
    
    
  42. /* }}} */ 
    43. 
    
    
    
    
  43. [/cc] 
    44.

これでmemcache_deleteプロセスが終了しました.
当サイトの文章はすべて転載して、出典:http://blog.liubijian.com/php_memcache_code_analysis.html
... other posts by lbj
Tripwireを使用してUbuntu VPSサーバの侵入を検出する方法
挿入されたUディスク、メモリースティック、SDカードなどのデバイスが読み取り専用デバイスになった理由と処理方法