Data Structures

Critical section

The thread between the parts that require mutual exclusion (lock table, page buffer, and access / modification of the operation) was designated as a critical section.

The critical section has been defined as follows.

The critical section with the following data structures and operations has been implemented.

typedef struct css_critical_section
{
  const char *name;
  MUTEX_T lock;                           /* read/write monitor lock */
  int rwlock;                             /* >0 = # readers, <0 = writer, 0 = none */
  unsigned int waiting_writers;           /* # of waiting writers */
  COND_T readers_ok;                      /* start waiting readers */
  THREAD_ENTRY *waiting_writers_queue;    /* queue of waiting writers */
  THREAD_ENTRY *waiting_promoters_queue;  /* queue of waiting promoters */
  THREAD_T owner;                         /* CS owner writer */
  int tran_index;                         /* transaction id acquiring CS */
  unsigned int total_enter;
  unsigned int total_nwaits;              /* total # of waiters */
  struct timeval max_wait;
  struct timeval total_wait;
} CSS_CRITICAL_SECTION;
 
CSS_CRITICAL_SECTION css_Csect_array[CRITICAL_SECTION_COUNT];

int csect_initialize (void)

Initializes all the critical section lock structures. Initializes a mutex with the condition variable.

Called when server starts.

int csect_finalize (void)

Frees all the critical section lock structures. mutex and condition variable are destroyed.

int csect_enter (THREAD_ENTRY * thread_p, int cs_index, int wait_secs)

Locks out other threads from concurrent execution through a critical section of a code.

cs_index (in): the identifier of the section to lock.

wait_secs (in): timeout in seconds.

If the thread is already an owner of the resource then it could reenter this section as a writer. rwlock needs to be decremented.

Otherwise, if wait_secs = INF_WAIT, the thread will wait until others send a signal to wake it up.

If wait_secs = NOT_WAIT, TIMEOUT error is returned immediately without waiting.

If wait_secs > 0, the thread will wait until the time is out.

Related functions:

Int csect_enter_critical_section (THREAD_ENTRY * thread_p, CSS_CRITICAL_SECTION * cs_ptr, int wait_secs);

Int csect_enter_critical_section_as_reader (THREAD_ENTRY * thread_p, CSS_CRITICAL_SECTION * cs_ptr, int wait_secs);

Note: writer’s priority is higher than reader’s.

int csect_exit (int cs_index)

Unlocks the critical section, which may restart another thread that is suspended and is waiting for the critical section.

cs_index: identifier of the section to unlock

Wake up one of the following groups by priority: promoter, writer, readers.

int csect_demote (THREAD_ENTRY * thread_p, int cs_index, int wait_secs);

Acquires a read lock when it has a write lock. If the thread is not an owner, it acts like a normal reader request.

int csect_promote (THREAD_ENTRY * thread_p, int cs_index, int wait_secs);

Acquires a write lock when it has a read lock. If thread is not an owner, then it waits as a writer.