开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
NdbPoolImpl.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：14k
源码类别：

MySQL数据库

开发平台：

Visual C++

NdbPoolImpl.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #include "NdbPoolImpl.hpp"
  19. NdbMutex *NdbPool::pool_mutex = NULL;
  20. NdbPool *the_pool = NULL;
  22. NdbPool*
  23. NdbPool::create_instance(Uint32 max_ndb_obj,
  24.                          Uint32 no_conn_obj,
  25.                          Uint32 init_no_ndb_objects)
  26. {
  27.   if (!initPoolMutex()) {
  28.     return NULL;
  29.   }
  30.   NdbMutex_Lock(pool_mutex);
  31.   NdbPool* a_pool;
  32.   if (the_pool != NULL) {
  33.     a_pool = NULL;
  34.   } else {
  35.     the_pool = new NdbPool(max_ndb_obj, no_conn_obj);
  36.     if (!the_pool->init(init_no_ndb_objects)) {
  37.       delete the_pool;
  38.       the_pool = NULL;
  39.     }
  40.     a_pool = the_pool;
  41.   }
  42.   NdbMutex* temp = pool_mutex;
  43.   if (a_pool == NULL) {
  44.     pool_mutex = NULL;
  45.   }
  46.   NdbMutex_Unlock(pool_mutex);
  47.   if (a_pool == NULL) {
  48.     NdbMutex_Destroy(temp);
  49.   }
  50.   return a_pool;
  51. }
  53. void
  54. NdbPool::drop_instance()
  55. {
  56.   if (pool_mutex == NULL) {
  57.     return;
  58.   }
  59.   NdbMutex_Lock(pool_mutex);
  60.   the_pool->release_all();
  61.   delete the_pool;
  62.   the_pool = NULL;
  63.   NdbMutex* temp = pool_mutex;
  64.   NdbMutex_Unlock(temp);
  65.   NdbMutex_Destroy(temp);
  66. }
  68. bool
  69. NdbPool::initPoolMutex()
  70. {
  71.   bool ret_result = false;
  72.   if (pool_mutex == NULL) {
  73.     pool_mutex = NdbMutex_Create();
  74.     ret_result = ((pool_mutex == NULL) ? false : true);
  75.   }
  76.   return ret_result;
  77. }
  79. NdbPool::NdbPool(Uint32 max_no_objects,
  80.                  Uint32 no_conn_objects)
  81. {
  82.   if (no_conn_objects > 1024) {
  83.     no_conn_objects = 1024;
  84.   }
  85.   if (max_no_objects > MAX_NDB_OBJECTS) {
  86.     max_no_objects = MAX_NDB_OBJECTS;
  87.   } else if (max_no_objects == 0) {
  88.     max_no_objects = 1;
  89.   }
  90.   m_max_ndb_objects = max_no_objects;
  91.   m_no_of_conn_objects = no_conn_objects;
  92.   m_no_of_objects = 0;
  93.   m_waiting = 0;
  94.   m_pool_reference = NULL;
  95.   m_hash_entry = NULL;
  96.   m_first_free = NULL_POOL;
  97.   m_first_not_in_use = NULL_POOL;
  98.   m_last_free = NULL_POOL;
  99.   input_pool_cond = NULL;
  100.   output_pool_cond = NULL;
  101.   m_output_queue = 0;
  102.   m_input_queue = 0;
  103.   m_signal_count = 0;
  104. }
  106. NdbPool::~NdbPool()
  107. {
  108.   NdbCondition_Destroy(input_pool_cond);
  109.   NdbCondition_Destroy(output_pool_cond);
  110. }
  112. void
  113. NdbPool::release_all()
  114. {
  115.   int i;
  116.   for (i = 0; i < m_max_ndb_objects + 1; i++) {
  117.     if (m_pool_reference[i].ndb_reference != NULL) {
  118.       assert(m_pool_reference[i].in_use);
  119.       assert(m_pool_reference[i].free_entry);
  120.       delete m_pool_reference[i].ndb_reference;
  121.     }
  122.   }
  123.   delete [] m_pool_reference;
  124.   delete [] m_hash_entry;
  125.   m_pool_reference = NULL;
  126.   m_hash_entry = NULL;
  127. }
  129. bool
  130. NdbPool::init(Uint32 init_no_objects)
  131. {
  132.   bool ret_result = false;
  133.   int i;
  134.   do {
  135.     input_pool_cond = NdbCondition_Create();
  136.     output_pool_cond = NdbCondition_Create();
  137.     if (input_pool_cond == NULL || output_pool_cond == NULL) {
  138.       break;
  139.     }
  140.     if (init_no_objects > m_max_ndb_objects) {
  141.       init_no_objects = m_max_ndb_objects;
  142.     }
  143.     if (init_no_objects == 0) {
  144.       init_no_objects = 1;
  145.     }
  146.     m_pool_reference = new NdbPool::POOL_STRUCT[m_max_ndb_objects + 1];
  147.     m_hash_entry     = new Uint8[POOL_HASH_TABLE_SIZE];
  149.     if ((m_pool_reference == NULL) || (m_hash_entry == NULL)) {
  150.       delete [] m_pool_reference;
  151.       delete [] m_hash_entry;
  152.       break;
  153.     }
  154.     for (i = 0; i < m_max_ndb_objects + 1; i++) {
  155.       m_pool_reference[i].ndb_reference = NULL;
  156.       m_pool_reference[i].in_use = false;
  157.       m_pool_reference[i].next_free_object = i+1;
  158.       m_pool_reference[i].prev_free_object = i-1;
  159.       m_pool_reference[i].next_db_object = NULL_POOL;
  160.       m_pool_reference[i].prev_db_object = NULL_POOL;
  161.     }
  162.     for (i = 0; i < POOL_HASH_TABLE_SIZE; i++) {
  163.       m_hash_entry[i] = NULL_HASH;
  164.     }
  165.     m_pool_reference[m_max_ndb_objects].next_free_object = NULL_POOL;
  166.     m_pool_reference[1].prev_free_object = NULL_POOL;
  167.     m_first_not_in_use = 1;
  168.     m_no_of_objects = init_no_objects;
  169.     for (i = init_no_objects; i > 0 ; i--) {
  170.       Uint32 fake_id;
  171.       if (!allocate_ndb(fake_id, (const char*)NULL, (const char*)NULL)) {
  172.         release_all();
  173.         break;
  174.       }
  175.     }
  176.     ret_result = true;
  177.     break;
  178.   } while (1);
  179.   return ret_result;
  180. }
  182. /*
  183. Get an Ndb object.
  184. Input:
  185. hint_id: 0 = no hint, otherwise a hint of which Ndb object the thread
  186.          used the last time.
  187. a_db_name: NULL = don't check for database specific Ndb  object, otherwise
  188.            a hint of which database is preferred.
  189. Output:
  190. hint_id: Returns id of Ndb object returned
  191. Return value: Ndb object pointer
  192. */
  193. Ndb*
  194. NdbPool::get_ndb_object(Uint32 &hint_id,
  195.                         const char* a_catalog_name,
  196.                         const char* a_schema_name)
  197. {
  198.   Ndb* ret_ndb = NULL;
  199.   Uint32 hash_entry = compute_hash(a_schema_name);
  200.   NdbMutex_Lock(pool_mutex);
  201.   while (1) {
  202.     /*
  203.     We start by checking if we can use the hinted Ndb object.
  204.     */
  205.     if ((ret_ndb = get_hint_ndb(hint_id, hash_entry)) != NULL) {
  206.       break;
  207.     }
  208.     /*
  209.     The hinted Ndb object was not free. We need to allocate another object.
  210.     We start by checking for a free Ndb object connected to the same database.
  211.     */
  212.     if (a_schema_name && (ret_ndb = get_db_hash(hint_id,
  213.                                                 hash_entry,
  214.                                                 a_catalog_name,
  215.                                                 a_schema_name))) {
  216.       break;
  217.     }
  218.     /*
  219.     No Ndb object connected to the preferred database was found.
  220.     We look for a free Ndb object in general.
  221.     */
  222.     if ((ret_ndb = get_free_list(hint_id, hash_entry)) != NULL) {
  223.       break;
  224.     }
  225.     /*
  226.     No free Ndb object was found. If we haven't allocated objects up until the
  227.     maximum number yet then we can allocate a new Ndb object here.
  228.     */
  229.     if (m_no_of_objects < m_max_ndb_objects) {
  230.       if (allocate_ndb(hint_id, a_catalog_name, a_schema_name)) {
  231.         assert((ret_ndb = get_hint_ndb(hint_id, hash_entry)) != NULL);
  232.         break;
  233.       }
  234.     }
  235.     /*
  236.     We need to wait until an Ndb object becomes
  237.     available.
  238.     */
  239.     if ((ret_ndb = wait_free_ndb(hint_id)) != NULL) {
  240.       break;
  241.     }
  242.     /*
  243.     Not even after waiting were we able to get hold of an Ndb object. We 
  244.     return NULL to indicate this problem.
  245.     */
  246.     ret_ndb = NULL;
  247.     break;
  248.   }
  249.   NdbMutex_Unlock(pool_mutex);
  250.   if (ret_ndb != NULL) {
  251.     /*
  252.     We need to set the catalog and schema name of the Ndb object before
  253.     returning it to the caller.
  254.     */
  255.     ret_ndb->setCatalogName(a_catalog_name);
  256.     ret_ndb->setSchemaName(a_schema_name);
  257.   }
  258.   return ret_ndb;
  259. }
  261. void
  262. NdbPool::return_ndb_object(Ndb* returned_ndb, Uint32 id)
  263. {
  264.   NdbMutex_Lock(pool_mutex);
  265.   assert(id <= m_max_ndb_objects);
  266.   assert(id != 0);
  267.   assert(returned_ndb == m_pool_reference[id].ndb_reference);
  268.   bool wait_cond = m_waiting;
  269.   if (wait_cond) {
  270.     NdbCondition* pool_cond;
  271.     if (m_signal_count > 0) {
  272.       pool_cond = output_pool_cond;
  273.       m_signal_count--;
  274.     } else {
  275.       pool_cond = input_pool_cond;
  276.     }
  277.     add_wait_list(id);
  278.     NdbMutex_Unlock(pool_mutex);
  279.     NdbCondition_Signal(pool_cond);
  280.   } else {
  281.     add_free_list(id);
  282.     add_db_hash(id);
  283.     NdbMutex_Unlock(pool_mutex);
  284.   }
  285. }
  287. bool
  288. NdbPool::allocate_ndb(Uint32 &id,
  289.                       const char* a_catalog_name,
  290.                       const char* a_schema_name)
  291. {
  292.   Ndb* a_ndb;
  293.   if (m_first_not_in_use == NULL_POOL) {
  294.     return false;
  295.   }
  296.   if (a_schema_name) {
  297.     a_ndb = new Ndb(a_schema_name, a_catalog_name);
  298.   } else {
  299.     a_ndb = new Ndb("");
  300.   }
  301.   if (a_ndb == NULL) {
  302.     return false;
  303.   }
  304.   a_ndb->init(m_no_of_conn_objects);
  305.   m_no_of_objects++;
  307.   id = m_first_not_in_use;
  308.   Uint32 allocated_id = m_first_not_in_use;
  309.   m_first_not_in_use = m_pool_reference[allocated_id].next_free_object;
  311.   m_pool_reference[allocated_id].ndb_reference = a_ndb;
  312.   m_pool_reference[allocated_id].in_use = true;
  313.   m_pool_reference[allocated_id].free_entry = false;
  315.   add_free_list(allocated_id);
  316.   add_db_hash(allocated_id);
  317.   return true;
  318. }
  320. void
  321. NdbPool::add_free_list(Uint32 id)
  322. {
  323.   assert(!m_pool_reference[id].free_entry);
  324.   assert(m_pool_reference[id].in_use);
  325.   m_pool_reference[id].free_entry = true;
  326.   m_pool_reference[id].next_free_object = m_first_free;
  327.   m_pool_reference[id].prev_free_object = (Uint8)NULL_POOL;
  328.   m_first_free = (Uint8)id;
  329.   if (m_last_free == (Uint8)NULL_POOL) {
  330.     m_last_free = (Uint8)id;
  331.   }
  332. }
  334. void
  335. NdbPool::add_db_hash(Uint32 id)
  336. {
  337.   Ndb* t_ndb = m_pool_reference[id].ndb_reference;
  338.   const char* schema_name = t_ndb->getSchemaName();
  339.   Uint32 hash_entry = compute_hash(schema_name);
  340.   Uint8 next_db_entry = m_hash_entry[hash_entry];
  341.   m_pool_reference[id].next_db_object = next_db_entry;
  342.   m_pool_reference[id].prev_db_object = (Uint8)NULL_HASH;
  343.   m_hash_entry[hash_entry] = (Uint8)id;
  344. }
  346. Ndb*
  347. NdbPool::get_free_list(Uint32 &id, Uint32 hash_entry)
  348. {
  349.   if (m_first_free == NULL_POOL) {
  350.     return NULL;
  351.   }
  352.   id = m_first_free;
  353.   Ndb* ret_ndb = get_hint_ndb(m_first_free, hash_entry);
  354.   assert(ret_ndb != NULL);
  355.   return ret_ndb;
  356. }
  358. Ndb*
  359. NdbPool::get_db_hash(Uint32 &id,
  360.                      Uint32 hash_entry,
  361.                      const char *a_catalog_name,
  362.                      const char *a_schema_name)
  363. {
  364.   Uint32 entry_id = m_hash_entry[hash_entry];
  365.   bool found = false;
  366.   while (entry_id != NULL_HASH) {
  367.     Ndb* t_ndb = m_pool_reference[entry_id].ndb_reference;
  368.     const char *a_ndb_catalog_name = t_ndb->getCatalogName();
  369.     if (strcmp(a_catalog_name, a_ndb_catalog_name) == 0) {
  370.       const char *a_ndb_schema_name = t_ndb->getSchemaName();
  371.       if (strcmp(a_schema_name, a_ndb_schema_name) == 0) {
  372.         found = true;
  373.         break;
  374.       }
  375.     }
  376.     entry_id = m_pool_reference[entry_id].next_db_object;
  377.   }
  378.   if (found) {
  379.     id = entry_id;
  380.     Ndb* ret_ndb = get_hint_ndb(entry_id, hash_entry);
  381.     assert(ret_ndb != NULL);
  382.     return ret_ndb;
  383.   }
  384.   return NULL;
  385. }
  387. Ndb*
  388. NdbPool::get_hint_ndb(Uint32 hint_id, Uint32 hash_entry)
  389. {
  390.   Ndb* ret_ndb = NULL;
  391.   do {
  392.     if ((hint_id != 0) &&
  393.         (hint_id <= m_max_ndb_objects) &&
  394.         (m_pool_reference[hint_id].in_use) &&
  395.         (m_pool_reference[hint_id].free_entry)) {
  396.       ret_ndb = m_pool_reference[hint_id].ndb_reference;
  397.       if (ret_ndb != NULL) {
  398.         break;
  399.       } else {
  400.         assert(false);
  401.       }
  402.     }
  403.     return NULL;
  404.   } while (1);
  405.   /*
  406.   This is where we remove the entry from the free list and from the db hash
  407.   table.
  408.   */
  409.   remove_free_list(hint_id);
  410.   remove_db_hash(hint_id, hash_entry);
  411.   return ret_ndb;
  412. }
  414. void
  415. NdbPool::remove_free_list(Uint32 id)
  416. {
  417.   Uint8 next_free_entry = m_pool_reference[id].next_free_object;
  418.   Uint8 prev_free_entry = m_pool_reference[id].prev_free_object;
  419.   if (prev_free_entry == (Uint8)NULL_POOL) {
  420.     m_first_free = next_free_entry;
  421.   } else {
  422.     m_pool_reference[prev_free_entry].next_free_object = next_free_entry;
  423.   }
  424.   if (next_free_entry == (Uint8)NULL_POOL) {
  425.     m_last_free = prev_free_entry;
  426.   } else {
  427.     m_pool_reference[next_free_entry].prev_free_object = prev_free_entry;
  428.   }
  429.   m_pool_reference[id].next_free_object = NULL_POOL;
  430.   m_pool_reference[id].prev_free_object = NULL_POOL;
  431.   m_pool_reference[id].free_entry = false;
  432. }
  434. void
  435. NdbPool::remove_db_hash(Uint32 id, Uint32 hash_entry)
  436. {
  437.   Uint8 next_free_entry = m_pool_reference[id].next_db_object;
  438.   Uint8 prev_free_entry = m_pool_reference[id].prev_db_object;
  439.   if (prev_free_entry == (Uint8)NULL_HASH) {
  440.     m_hash_entry[hash_entry] = next_free_entry;
  441.   } else {
  442.     m_pool_reference[prev_free_entry].next_db_object = next_free_entry;
  443.   }
  444.   if (next_free_entry == (Uint8)NULL_HASH) {
  445.     ;
  446.   } else {
  447.     m_pool_reference[next_free_entry].prev_db_object = prev_free_entry;
  448.   }
  449.   m_pool_reference[id].next_db_object = NULL_HASH;
  450.   m_pool_reference[id].prev_db_object = NULL_HASH;
  451. }
  453. Uint32
  454. NdbPool::compute_hash(const char *a_schema_name)
  455. {
  456.   Uint32 len = strlen(a_schema_name);
  457.   Uint32 h = 147;
  458.   for (Uint32 i = 0; i < len; i++) {
  459.     Uint32 c = a_schema_name[i];
  460.     h = (h << 5) + h + c;
  461.   }
  462.   h &= (POOL_HASH_TABLE_SIZE - 1);
  463.   return h;
  464. }
  466. Ndb*
  467. NdbPool::wait_free_ndb(Uint32 &id)
  468. {
  469.   int res;
  470.   int time_out = 3500;
  471.   do {
  472.     NdbCondition* tmp = input_pool_cond;
  473.     m_waiting++;
  474.     m_input_queue++;
  475.     time_out -= 500;
  476.     res = NdbCondition_WaitTimeout(input_pool_cond, pool_mutex, time_out);
  477.     if (tmp == input_pool_cond) {
  478.       m_input_queue--;
  479.     } else {
  480.       m_output_queue--;
  481.       if (m_output_queue == 0) {
  482.         switch_condition_queue();
  483.       }
  484.     }
  485.     m_waiting--;
  486.   } while (res == 0 && m_first_wait == NULL_POOL);
  487.   if (res != 0 && m_first_wait == NULL_POOL) {
  488.     return NULL;
  489.   }
  490.   id = m_first_wait;
  491.   remove_wait_list();
  492.   assert(m_waiting != 0 || m_first_wait == NULL_POOL);
  493.   return m_pool_reference[id].ndb_reference;
  494. }
  496. void
  497. NdbPool::remove_wait_list()
  498. {
  499.   Uint32 id = m_first_wait;
  500.   m_first_wait = m_pool_reference[id].next_free_object;
  501.   m_pool_reference[id].next_free_object = NULL_POOL;
  502.   m_pool_reference[id].prev_free_object = NULL_POOL;
  503.   m_pool_reference[id].free_entry = false;
  504. }
  506. void
  507. NdbPool::add_wait_list(Uint32 id)
  508. {
  509.   m_pool_reference[id].next_free_object = m_first_wait;
  510.   m_first_wait = id;
  511. }
  513. void
  514. NdbPool::switch_condition_queue()
  515. {
  516.   m_signal_count = m_input_queue;
  517.   Uint8 move_queue = m_input_queue;
  518.   m_input_queue = m_output_queue;
  519.   m_output_queue = move_queue;
  521.   NdbCondition* move_cond = input_pool_cond;
  522.   input_pool_cond = output_pool_cond;
  523.   output_pool_cond = move_cond;
  524. }