sync0arr.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:26k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. The wait array used in synchronization primitives
  3. (c) 1995 Innobase Oy
  4. Created 9/5/1995 Heikki Tuuri
  5. *******************************************************/
  6. #include "sync0arr.h"
  7. #ifdef UNIV_NONINL
  8. #include "sync0arr.ic"
  9. #endif
  10. #include "sync0sync.h"
  11. #include "sync0rw.h"
  12. #include "os0sync.h"
  13. #include "os0file.h"
  14. #include "srv0srv.h"
  15. /*
  16. WAIT ARRAY
  17. ==========
  18. The wait array consists of cells each of which has an
  19. an operating system event object created for it. The threads
  20. waiting for a mutex, for example, can reserve a cell
  21. in the array and suspend themselves to wait for the event
  22. to become signaled. When using the wait array, remember to make
  23. sure that some thread holding the synchronization object
  24. will eventually know that there is a waiter in the array and
  25. signal the object, to prevent infinite wait.
  26. Why we chose to implement a wait array? First, to make
  27. mutexes fast, we had to code our own implementation of them,
  28. which only in usually uncommon cases resorts to using
  29. slow operating system primitives. Then we had the choice of
  30. assigning a unique OS event for each mutex, which would
  31. be simpler, or using a global wait array. In some operating systems,
  32. the global wait array solution is more efficient and flexible,
  33. because we can do with a very small number of OS events,
  34. say 200. In NT 3.51, allocating events seems to be a quadratic
  35. algorithm, because 10 000 events are created fast, but
  36. 100 000 events takes a couple of minutes to create.
  37. */
  38. /* A cell where an individual thread may wait suspended
  39. until a resource is released. The suspending is implemented
  40. using an operating system event semaphore. */
  41. struct sync_cell_struct {
  42.         void*           wait_object;    /* pointer to the object the
  43.                                         thread is waiting for; if NULL
  44.                                         the cell is free for use */
  45. mutex_t* old_wait_mutex; /* the latest wait mutex in cell */
  46. rw_lock_t* old_wait_rw_lock;/* the latest wait rw-lock in cell */
  47.         ulint request_type; /* lock type requested on the
  48.          object */
  49. const char* file; /* in debug version file where
  50. requested */
  51. ulint line; /* in debug version line where
  52. requested */
  53. os_thread_id_t thread; /* thread id of this waiting
  54. thread */
  55. ibool waiting; /* TRUE if the thread has already
  56. called sync_array_event_wait
  57. on this cell */
  58. ibool event_set; /* TRUE if the event is set */
  59.         os_event_t  event;    /* operating system event
  60.                                         semaphore handle */
  61. time_t reservation_time;/* time when the thread reserved
  62. the wait cell */
  63. };
  64. /* NOTE: It is allowed for a thread to wait
  65. for an event allocated for the array without owning the
  66. protecting mutex (depending on the case: OS or database mutex), but
  67. all changes (set or reset) to the state of the event must be made
  68. while owning the mutex. */
  69. struct sync_array_struct {
  70. ulint n_reserved; /* number of currently reserved
  71. cells in the wait array */
  72. ulint n_cells; /* number of cells in the
  73. wait array */
  74. sync_cell_t* array; /* pointer to wait array */
  75. ulint protection; /* this flag tells which
  76. mutex protects the data */
  77. mutex_t mutex; /* possible database mutex
  78. protecting this data structure */
  79. os_mutex_t os_mutex; /* Possible operating system mutex
  80. protecting the data structure.
  81. As this data structure is used in
  82. constructing the database mutex,
  83. to prevent infinite recursion
  84. in implementation, we fall back to
  85. an OS mutex. */
  86. ulint sg_count; /* count of how many times an
  87. object has been signalled */
  88. ulint res_count; /* count of cell reservations
  89. since creation of the array */
  90. };
  91. #ifdef UNIV_SYNC_DEBUG
  92. /**********************************************************************
  93. This function is called only in the debug version. Detects a deadlock
  94. of one or more threads because of waits of semaphores. */
  95. static
  96. ibool
  97. sync_array_detect_deadlock(
  98. /*=======================*/
  99. /* out: TRUE if deadlock detected */
  100.         sync_array_t* arr, /* in: wait array; NOTE! the caller must
  101.          own the mutex to array */
  102. sync_cell_t* start, /* in: cell where recursive search started */
  103. sync_cell_t* cell, /* in: cell to search */
  104. ulint depth); /* in: recursion depth */
  105. #endif /* UNIV_SYNC_DEBUG */
  106. /*********************************************************************
  107. Gets the nth cell in array. */
  108. static
  109. sync_cell_t*
  110. sync_array_get_nth_cell(
  111. /*====================*/
  112. /* out: cell */
  113. sync_array_t* arr, /* in: sync array */
  114. ulint n) /* in: index */
  115. {
  116. ut_a(arr);
  117. ut_a(n < arr->n_cells);
  118. return(arr->array + n);
  119. }
  120. /**********************************************************************
  121. Reserves the mutex semaphore protecting a sync array. */
  122. static
  123. void
  124. sync_array_enter(
  125. /*=============*/
  126. sync_array_t* arr) /* in: sync wait array */
  127. {
  128. ulint protection;
  129. protection = arr->protection;
  130. if (protection == SYNC_ARRAY_OS_MUTEX) {
  131. os_mutex_enter(arr->os_mutex);
  132. } else if (protection == SYNC_ARRAY_MUTEX) {
  133. mutex_enter(&(arr->mutex));
  134. } else {
  135. ut_error;
  136. }
  137. }
  138. /**********************************************************************
  139. Releases the mutex semaphore protecting a sync array. */
  140. static
  141. void
  142. sync_array_exit(
  143. /*============*/
  144. sync_array_t* arr) /* in: sync wait array */
  145. {
  146. ulint protection;
  147. protection = arr->protection;
  148. if (protection == SYNC_ARRAY_OS_MUTEX) {
  149. os_mutex_exit(arr->os_mutex);
  150. } else if (protection == SYNC_ARRAY_MUTEX) {
  151. mutex_exit(&(arr->mutex));
  152. } else {
  153. ut_error;
  154. }
  155. }
  156. /***********************************************************************
  157. Creates a synchronization wait array. It is protected by a mutex
  158. which is automatically reserved when the functions operating on it
  159. are called. */
  160. sync_array_t*
  161. sync_array_create(
  162. /*==============*/
  163. /* out, own: created wait array */
  164. ulint n_cells, /* in: number of cells in the array
  165. to create */
  166. ulint protection) /* in: either SYNC_ARRAY_OS_MUTEX or
  167. SYNC_ARRAY_MUTEX: determines the type
  168. of mutex protecting the data structure */
  169. {
  170. sync_array_t* arr;
  171. sync_cell_t* cell_array;
  172. sync_cell_t* cell;
  173. ulint i;
  174. ut_a(n_cells > 0);
  175. /* Allocate memory for the data structures */
  176. arr = ut_malloc(sizeof(sync_array_t));
  177. cell_array = ut_malloc(sizeof(sync_cell_t) * n_cells);
  178. arr->n_cells = n_cells;
  179. arr->n_reserved = 0;
  180. arr->array = cell_array;
  181. arr->protection = protection;
  182. arr->sg_count = 0;
  183. arr->res_count = 0;
  184.         /* Then create the mutex to protect the wait array complex */
  185. if (protection == SYNC_ARRAY_OS_MUTEX) {
  186. arr->os_mutex = os_mutex_create(NULL);
  187. } else if (protection == SYNC_ARRAY_MUTEX) {
  188. mutex_create(&(arr->mutex));
  189. mutex_set_level(&(arr->mutex), SYNC_NO_ORDER_CHECK);
  190. } else {
  191. ut_error;
  192. }
  193.         for (i = 0; i < n_cells; i++) {
  194. cell = sync_array_get_nth_cell(arr, i);        
  195.                 cell->wait_object = NULL;
  196.                 /* Create an operating system event semaphore with no name */
  197.                 cell->event = os_event_create(NULL);
  198. cell->event_set = FALSE; /* it is created in reset state */
  199. }
  200. return(arr);
  201. }
  202. /**********************************************************************
  203. Frees the resources in a wait array. */
  204. void
  205. sync_array_free(
  206. /*============*/
  207. sync_array_t* arr) /* in, own: sync wait array */
  208. {
  209.         ulint           i;
  210.         sync_cell_t*    cell;
  211. ulint protection;
  212.         ut_a(arr->n_reserved == 0);
  213.         
  214. sync_array_validate(arr);
  215.         
  216.         for (i = 0; i < arr->n_cells; i++) {
  217. cell = sync_array_get_nth_cell(arr, i);        
  218. os_event_free(cell->event);
  219.         }
  220. protection = arr->protection;
  221.         /* Release the mutex protecting the wait array complex */
  222. if (protection == SYNC_ARRAY_OS_MUTEX) {
  223. os_mutex_free(arr->os_mutex);
  224. } else if (protection == SYNC_ARRAY_MUTEX) {
  225. mutex_free(&(arr->mutex));
  226. } else {
  227. ut_error;
  228. }
  229. ut_free(arr->array);
  230. ut_free(arr);
  231. }
  232. /************************************************************************
  233. Validates the integrity of the wait array. Checks
  234. that the number of reserved cells equals the count variable. */
  235. void
  236. sync_array_validate(
  237. /*================*/
  238. sync_array_t* arr) /* in: sync wait array */
  239. {
  240.         ulint           i;
  241.         sync_cell_t*    cell;
  242.         ulint           count           = 0;
  243.         
  244.         sync_array_enter(arr);
  245.         for (i = 0; i < arr->n_cells; i++) {
  246. cell = sync_array_get_nth_cell(arr, i);        
  247.                 if (cell->wait_object != NULL) {
  248.                         count++;
  249.                 }
  250.         }
  251.         ut_a(count == arr->n_reserved);
  252.         sync_array_exit(arr);
  253. }
  254. /***********************************************************************
  255. Puts the cell event in set state. */
  256. static
  257. void
  258. sync_cell_event_set(
  259. /*================*/
  260. sync_cell_t* cell) /* in: array cell */
  261. {
  262. os_event_set(cell->event);
  263. cell->event_set = TRUE;
  264. }
  265. /***********************************************************************
  266. Puts the cell event in reset state. */
  267. static
  268. void
  269. sync_cell_event_reset(
  270. /*==================*/
  271. sync_cell_t* cell) /* in: array cell */
  272. {
  273. os_event_reset(cell->event);
  274. cell->event_set = FALSE;
  275. }
  276. /**********************************************************************
  277. Reserves a wait array cell for waiting for an object.
  278. The event of the cell is reset to nonsignalled state. */
  279. void
  280. sync_array_reserve_cell(
  281. /*====================*/
  282.         sync_array_t* arr, /* in: wait array */
  283.         void*    object, /* in: pointer to the object to wait for */
  284.         ulint type, /* in: lock request type */
  285. const char* file, /* in: file where requested */
  286.         ulint line, /* in: line where requested */
  287.         ulint*    index)  /* out: index of the reserved cell */
  288. {
  289.         sync_cell_t*    cell;
  290.         ulint           i;
  291.         
  292.         ut_a(object);
  293.         ut_a(index);
  294.         sync_array_enter(arr);
  295.         arr->res_count++;
  296. /* Reserve a new cell. */
  297.         for (i = 0; i < arr->n_cells; i++) {
  298. cell = sync_array_get_nth_cell(arr, i);        
  299.                 if (cell->wait_object == NULL) {
  300.                         /* Make sure the event is reset */
  301. if (cell->event_set) {
  302.                          sync_cell_event_reset(cell);
  303. }
  304. cell->reservation_time = time(NULL);
  305. cell->thread = os_thread_get_curr_id();
  306. cell->wait_object = object;
  307. if (type == SYNC_MUTEX) {
  308. cell->old_wait_mutex = object;
  309. } else {
  310. cell->old_wait_rw_lock = object;
  311. }
  312. cell->request_type = type;
  313. cell->waiting = FALSE;
  314. cell->file = file;
  315. cell->line = line;
  316. arr->n_reserved++;
  317. *index = i;
  318. sync_array_exit(arr);
  319.                         
  320.                         return;
  321.                 }
  322.         }
  323.         ut_error; /* No free cell found */
  324. return;
  325. }
  326. /**********************************************************************
  327. This function should be called when a thread starts to wait on
  328. a wait array cell. In the debug version this function checks
  329. if the wait for a semaphore will result in a deadlock, in which
  330. case prints info and asserts. */
  331. void
  332. sync_array_wait_event(
  333. /*==================*/
  334.         sync_array_t* arr, /* in: wait array */
  335.         ulint    index)  /* in: index of the reserved cell */
  336. {
  337.         sync_cell_t*    cell;
  338.         os_event_t  event;
  339.         
  340.         ut_a(arr);
  341.         sync_array_enter(arr);
  342. cell = sync_array_get_nth_cell(arr, index);        
  343. ut_a(cell->wait_object);
  344. ut_a(!cell->waiting);
  345. ut_ad(os_thread_get_curr_id() == cell->thread);
  346.         event = cell->event;
  347.         cell->waiting = TRUE;
  348. #ifdef UNIV_SYNC_DEBUG
  349.        
  350. /* We use simple enter to the mutex below, because if
  351. we cannot acquire it at once, mutex_enter would call
  352. recursively sync_array routines, leading to trouble.
  353. rw_lock_debug_mutex freezes the debug lists. */
  354. rw_lock_debug_mutex_enter();
  355. if (TRUE == sync_array_detect_deadlock(arr, cell, cell, 0)) {
  356. fputs("########################################n", stderr);
  357. ut_error;
  358. }
  359. rw_lock_debug_mutex_exit();
  360. #endif
  361.         sync_array_exit(arr);
  362.         os_event_wait(event);
  363.         sync_array_free_cell(arr, index);
  364. }
  365. /**********************************************************************
  366. Reports info of a wait array cell. */
  367. static
  368. void
  369. sync_array_cell_print(
  370. /*==================*/
  371. FILE* file, /* in: file where to print */
  372. sync_cell_t* cell) /* in: sync cell */
  373. {
  374. mutex_t* mutex;
  375. rw_lock_t* rwlock;
  376. ulint type;
  377. type = cell->request_type;
  378. fprintf(file,
  379. "--Thread %lu has waited at %s line %lu for %.2f seconds the semaphore:n",
  380. (ulong) os_thread_pf(cell->thread), cell->file,
  381.        (ulong) cell->line,
  382.        difftime(time(NULL), cell->reservation_time));
  383. if (type == SYNC_MUTEX) {
  384. /* We use old_wait_mutex in case the cell has already
  385. been freed meanwhile */
  386. mutex = cell->old_wait_mutex;
  387. fprintf(file,
  388. "Mutex at %p created file %s line %lu, lock var %lun"
  389. #ifdef UNIV_SYNC_DEBUG
  390. "Last time reserved in file %s line %lu, "
  391. #endif /* UNIV_SYNC_DEBUG */
  392. "waiters flag %lun",
  393. mutex, mutex->cfile_name, (ulong) mutex->cline,
  394. (ulong) mutex->lock_word,
  395. #ifdef UNIV_SYNC_DEBUG
  396. mutex->file_name, (ulong) mutex->line,
  397. #endif /* UNIV_SYNC_DEBUG */
  398. (ulong) mutex->waiters);
  399. } else if (type == RW_LOCK_EX || type == RW_LOCK_SHARED) {
  400. fputs(type == RW_LOCK_EX ? "X-lock on" : "S-lock on", file);
  401. rwlock = cell->old_wait_rw_lock;
  402. fprintf(file,
  403. " RW-latch at %p created in file %s line %lun",
  404. rwlock, rwlock->cfile_name,
  405. (ulong) rwlock->cline);
  406. if (rwlock->writer != RW_LOCK_NOT_LOCKED) {
  407. fprintf(file,
  408. "a writer (thread id %lu) has reserved it in mode %s",
  409. (ulong) os_thread_pf(rwlock->writer_thread),
  410. rwlock->writer == RW_LOCK_EX
  411. ? " exclusiven"
  412. : " wait exclusiven");
  413. }
  414. fprintf(file,
  415. "number of readers %lu, waiters flag %lun"
  416. "Last time read locked in file %s line %lun"
  417. "Last time write locked in file %s line %lun",
  418. (ulong) rwlock->reader_count,
  419. (ulong) rwlock->waiters,
  420. rwlock->last_s_file_name,
  421. (ulong) rwlock->last_s_line,
  422. rwlock->last_x_file_name,
  423. (ulong) rwlock->last_x_line);
  424. } else {
  425. ut_error;
  426. }
  427.         if (!cell->waiting) {
  428. fputs("wait has endedn", file);
  429. }
  430.         if (cell->event_set) {
  431. fputs("wait is endingn", file);
  432. }
  433. }
  434. #ifdef UNIV_SYNC_DEBUG
  435. /**********************************************************************
  436. Looks for a cell with the given thread id. */
  437. static
  438. sync_cell_t*
  439. sync_array_find_thread(
  440. /*===================*/
  441. /* out: pointer to cell or NULL
  442. if not found */
  443.         sync_array_t* arr, /* in: wait array */
  444. os_thread_id_t thread) /* in: thread id */
  445. {
  446.         ulint           i;
  447.         sync_cell_t*    cell;
  448.         for (i = 0; i < arr->n_cells; i++) {
  449. cell = sync_array_get_nth_cell(arr, i);        
  450.                 if (cell->wait_object != NULL
  451.     && os_thread_eq(cell->thread, thread)) {
  452.      return(cell); /* Found */
  453.                 }
  454.         }
  455. return(NULL); /* Not found */
  456. }
  457. /**********************************************************************
  458. Recursion step for deadlock detection. */
  459. static
  460. ibool
  461. sync_array_deadlock_step(
  462. /*=====================*/
  463. /* out: TRUE if deadlock detected */
  464.         sync_array_t* arr, /* in: wait array; NOTE! the caller must
  465.          own the mutex to array */
  466. sync_cell_t* start, /* in: cell where recursive search
  467. started */
  468. os_thread_id_t thread, /* in: thread to look at */
  469. ulint pass, /* in: pass value */
  470. ulint depth) /* in: recursion depth */
  471. {
  472. sync_cell_t* new;
  473. ibool ret;
  474. depth++;
  475. if (pass != 0) {
  476. /* If pass != 0, then we do not know which threads are
  477. responsible of releasing the lock, and no deadlock can
  478. be detected. */
  479. return(FALSE);
  480. }
  481.     
  482. new = sync_array_find_thread(arr, thread);
  483. if (new == start) {
  484. /* Stop running of other threads */
  485. ut_dbg_stop_threads = TRUE;
  486. /* Deadlock */
  487. fputs("########################################n"
  488. "DEADLOCK of threads detected!n", stderr);
  489. return(TRUE);
  490. } else if (new) {
  491. ret = sync_array_detect_deadlock(arr, start, new, depth);
  492. if (ret) {
  493. return(TRUE);
  494. }
  495. }
  496. return(FALSE);
  497. }
  498. /**********************************************************************
  499. This function is called only in the debug version. Detects a deadlock
  500. of one or more threads because of waits of semaphores. */
  501. static
  502. ibool
  503. sync_array_detect_deadlock(
  504. /*=======================*/
  505. /* out: TRUE if deadlock detected */
  506.         sync_array_t* arr, /* in: wait array; NOTE! the caller must
  507.          own the mutex to array */
  508. sync_cell_t* start, /* in: cell where recursive search started */
  509. sync_cell_t* cell, /* in: cell to search */
  510. ulint depth) /* in: recursion depth */
  511. {
  512. mutex_t* mutex;
  513. rw_lock_t* lock;
  514. os_thread_id_t thread;
  515. ibool ret;
  516. rw_lock_debug_t*debug;
  517.         ut_a(arr && start && cell);
  518. ut_ad(cell->wait_object);
  519. ut_ad(os_thread_get_curr_id() == start->thread);
  520. ut_ad(depth < 100);
  521. depth++;
  522. if (cell->event_set || !cell->waiting) {
  523. return(FALSE); /* No deadlock here */
  524. }
  525. if (cell->request_type == SYNC_MUTEX) {
  526. mutex = cell->wait_object;
  527. if (mutex_get_lock_word(mutex) != 0) {
  528. thread = mutex->thread_id;
  529. /* Note that mutex->thread_id above may be
  530. also OS_THREAD_ID_UNDEFINED, because the
  531. thread which held the mutex maybe has not
  532. yet updated the value, or it has already
  533. released the mutex: in this case no deadlock
  534. can occur, as the wait array cannot contain
  535. a thread with ID_UNDEFINED value. */
  536. ret = sync_array_deadlock_step(arr, start, thread, 0,
  537. depth);
  538. if (ret) {
  539. fprintf(stderr,
  540. "Mutex %p owned by thread %lu file %s line %lun",
  541. mutex, (ulong) os_thread_pf(mutex->thread_id),
  542. mutex->file_name, (ulong) mutex->line);
  543. sync_array_cell_print(stderr, cell);
  544. return(TRUE);
  545. }
  546. }
  547. return(FALSE); /* No deadlock */
  548. } else if (cell->request_type == RW_LOCK_EX) {
  549.     lock = cell->wait_object;
  550.     debug = UT_LIST_GET_FIRST(lock->debug_list);
  551.     while (debug != NULL) {
  552. thread = debug->thread_id;
  553. if (((debug->lock_type == RW_LOCK_EX)
  554.              && !os_thread_eq(thread, cell->thread))
  555.             || ((debug->lock_type == RW_LOCK_WAIT_EX)
  556. && !os_thread_eq(thread, cell->thread))
  557.             || (debug->lock_type == RW_LOCK_SHARED)) {
  558. /* The (wait) x-lock request can block infinitely
  559. only if someone (can be also cell thread) is holding
  560. s-lock, or someone (cannot be cell thread) (wait)
  561. x-lock, and he is blocked by start thread */
  562. ret = sync_array_deadlock_step(arr, start, thread,
  563. debug->pass,
  564. depth);
  565. if (ret) {
  566. print:
  567. fprintf(stderr, "rw-lock %p ", lock);
  568. sync_array_cell_print(stderr, cell);
  569. rw_lock_debug_print(debug);
  570. return(TRUE);
  571. }
  572. }
  573. debug = UT_LIST_GET_NEXT(list, debug);
  574.     }
  575.     return(FALSE);
  576. } else if (cell->request_type == RW_LOCK_SHARED) {
  577.     lock = cell->wait_object;
  578.     debug = UT_LIST_GET_FIRST(lock->debug_list);
  579.     while (debug != NULL) {
  580. thread = debug->thread_id;
  581. if ((debug->lock_type == RW_LOCK_EX)
  582.             || (debug->lock_type == RW_LOCK_WAIT_EX)) {
  583. /* The s-lock request can block infinitely only if
  584. someone (can also be cell thread) is holding (wait)
  585. x-lock, and he is blocked by start thread */
  586. ret = sync_array_deadlock_step(arr, start, thread,
  587. debug->pass,
  588. depth);
  589. if (ret) {
  590. goto print;
  591. }
  592. }
  593. debug = UT_LIST_GET_NEXT(list, debug);
  594.     }
  595.     return(FALSE);
  596. } else {
  597. ut_error;
  598. }
  599. return(TRUE);  /* Execution never reaches this line: for compiler
  600. fooling only */
  601. }
  602. #endif /* UNIV_SYNC_DEBUG */
  603. /**********************************************************************
  604. Determines if we can wake up the thread waiting for a sempahore. */
  605. static
  606. ibool
  607. sync_arr_cell_can_wake_up(
  608. /*======================*/
  609. sync_cell_t* cell) /* in: cell to search */
  610. {
  611. mutex_t* mutex;
  612. rw_lock_t* lock;
  613. if (cell->request_type == SYNC_MUTEX) {
  614. mutex = cell->wait_object;
  615. if (mutex_get_lock_word(mutex) == 0) {
  616. return(TRUE);
  617. }
  618. } else if (cell->request_type == RW_LOCK_EX) {
  619.      lock = cell->wait_object;
  620.      if (rw_lock_get_reader_count(lock) == 0
  621.     && rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED) {
  622. return(TRUE);
  623. }
  624.      if (rw_lock_get_reader_count(lock) == 0
  625.     && rw_lock_get_writer(lock) == RW_LOCK_WAIT_EX
  626.     && os_thread_eq(lock->writer_thread, cell->thread)) {
  627. return(TRUE);
  628. }
  629. } else if (cell->request_type == RW_LOCK_SHARED) {
  630.      lock = cell->wait_object;
  631. if (rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED) {
  632. return(TRUE);
  633. }
  634. }
  635. return(FALSE);
  636. }
  637. /**********************************************************************
  638. Frees the cell. NOTE! sync_array_wait_event frees the cell
  639. automatically! */
  640. void
  641. sync_array_free_cell(
  642. /*=================*/
  643. sync_array_t* arr, /* in: wait array */
  644.         ulint     index)  /* in: index of the cell in array */
  645. {
  646.         sync_cell_t*    cell;
  647.         
  648.         sync_array_enter(arr);
  649.         cell = sync_array_get_nth_cell(arr, index);
  650.         ut_a(cell->wait_object != NULL);
  651. cell->wait_object =  NULL;
  652. ut_a(arr->n_reserved > 0);
  653. arr->n_reserved--;
  654.         sync_array_exit(arr);
  655. }
  656. /**************************************************************************
  657. Looks for the cells in the wait array which refer to the wait object
  658. specified, and sets their corresponding events to the signaled state. In this
  659. way releases the threads waiting for the object to contend for the object.
  660. It is possible that no such cell is found, in which case does nothing. */
  661. void
  662. sync_array_signal_object(
  663. /*=====================*/
  664. sync_array_t* arr, /* in: wait array */
  665. void* object) /* in: wait object */
  666. {
  667.         sync_cell_t*    cell;
  668.         ulint           count;
  669.         ulint           i;
  670.         sync_array_enter(arr);
  671. arr->sg_count++;
  672. i = 0;
  673. count = 0;
  674.         while (count < arr->n_reserved) {
  675.          cell = sync_array_get_nth_cell(arr, i);
  676.                 if (cell->wait_object != NULL) {
  677.                         count++;
  678.                         if (cell->wait_object == object) {
  679.                          sync_cell_event_set(cell);
  680.                         }
  681.                 }
  682.                 i++;
  683.         }
  684.         sync_array_exit(arr);
  685. }
  686. /**************************************************************************
  687. If the wakeup algorithm does not work perfectly at semaphore relases,
  688. this function will do the waking (see the comment in mutex_exit). This
  689. function should be called about every 1 second in the server. */
  690. void
  691. sync_arr_wake_threads_if_sema_free(void)
  692. /*====================================*/
  693. {
  694. sync_array_t* arr  = sync_primary_wait_array;
  695.         sync_cell_t*    cell;
  696.         ulint           count;
  697.         ulint           i;
  698.         sync_array_enter(arr);
  699. i = 0;
  700. count = 0;
  701.         while (count < arr->n_reserved) {
  702.          cell = sync_array_get_nth_cell(arr, i);
  703.                 if (cell->wait_object != NULL) {
  704.                         count++;
  705.                         if (sync_arr_cell_can_wake_up(cell)) {
  706.                          sync_cell_event_set(cell);
  707.                         }
  708.                 }
  709.                 i++;
  710.         }
  711.         sync_array_exit(arr);
  712. }
  713. /**************************************************************************
  714. Prints warnings of long semaphore waits to stderr. */
  715. ibool
  716. sync_array_print_long_waits(void)
  717. /*=============================*/
  718. /* out: TRUE if fatal semaphore wait threshold
  719. was exceeded */
  720. {
  721.         sync_cell_t*    cell;
  722.         ibool old_val;
  723. ibool noticed = FALSE;
  724. ulint           i;
  725. ulint fatal_timeout = srv_fatal_semaphore_wait_threshold;
  726. ibool fatal = FALSE;
  727.         for (i = 0; i < sync_primary_wait_array->n_cells; i++) {
  728.          cell = sync_array_get_nth_cell(sync_primary_wait_array, i);
  729.                 if (cell->wait_object != NULL
  730.     && difftime(time(NULL), cell->reservation_time) > 240) {
  731. fputs("InnoDB: Warning: a long semaphore wait:n",
  732. stderr);
  733. sync_array_cell_print(stderr, cell);
  734. noticed = TRUE;
  735.                 }
  736.                 if (cell->wait_object != NULL
  737.     && difftime(time(NULL), cell->reservation_time)
  738.     > fatal_timeout) {
  739. fatal = TRUE;
  740.                 }
  741.         }
  742. if (noticed) {
  743. fprintf(stderr,
  744. "InnoDB: ###### Starts InnoDB Monitor for 30 secs to print diagnostic info:n");
  745.          old_val = srv_print_innodb_monitor;
  746. /* If some crucial semaphore is reserved, then also the InnoDB
  747. Monitor can hang, and we do not get diagnostics. Since in
  748. many cases an InnoDB hang is caused by a pwrite() or a pread()
  749. call hanging inside the operating system, let us print right
  750. now the values of pending calls of these. */
  751. fprintf(stderr,
  752. "InnoDB: Pending preads %lu, pwrites %lun", (ulong)os_file_n_pending_preads,
  753. (ulong)os_file_n_pending_pwrites);
  754.          srv_print_innodb_monitor = TRUE;
  755. os_event_set(srv_lock_timeout_thread_event);
  756.          os_thread_sleep(30000000);
  757.          srv_print_innodb_monitor = old_val;
  758. fprintf(stderr,
  759. "InnoDB: ###### Diagnostic info printed to the standard error streamn");
  760. }
  761. return(fatal);
  762. }
  763. /**************************************************************************
  764. Prints info of the wait array. */
  765. static
  766. void
  767. sync_array_output_info(
  768. /*===================*/
  769. FILE* file, /* in: file where to print */
  770. sync_array_t* arr) /* in: wait array; NOTE! caller must own the
  771. mutex */
  772. {
  773.         sync_cell_t*    cell;
  774.         ulint           count;
  775. ulint           i;
  776. fprintf(file,
  777. "OS WAIT ARRAY INFO: reservation count %ld, signal count %ldn",
  778. (long) arr->res_count, (long) arr->sg_count);
  779. i = 0;
  780. count = 0;
  781.         while (count < arr->n_reserved) {
  782.          cell = sync_array_get_nth_cell(arr, i);
  783.                 if (cell->wait_object != NULL) {
  784.                         count++;
  785. sync_array_cell_print(file, cell);
  786.                 }
  787.                 i++;
  788.         }
  789. }
  790. /**************************************************************************
  791. Prints info of the wait array. */
  792. void
  793. sync_array_print_info(
  794. /*==================*/
  795. FILE* file, /* in: file where to print */
  796. sync_array_t* arr) /* in: wait array */
  797. {
  798.         sync_array_enter(arr);
  799. sync_array_output_info(file, arr);
  800.         
  801.         sync_array_exit(arr);
  802. }