rwlock.c

Go to the documentation of this file.

 
#include <ascii-chat/platform/rwlock.h>
#include <ascii-chat/platform/thread.h>
#include <ascii-chat/util/time.h>
#include <ascii-chat/atomic.h>
#include <ascii-chat/log/log.h>
#include <stdio.h>
 
#ifndef NDEBUG
 
void rwlock_on_rdlock(rwlock_t *rwlock) {
  if (!rwlock)
    return;
  rwlock->last_rdlock_time_ns = time_get_ns();
  atomic_fetch_add_u64(&rwlock->read_lock_count, 1);
  rwlock->rdlock_count++;
}
 
void rwlock_on_wrlock(rwlock_t *rwlock) {
  if (!rwlock)
    return;
  rwlock->last_wrlock_time_ns = time_get_ns();
  asciichat_thread_t current_thread = (asciichat_thread_t)asciichat_thread_current_id();
  rwlock->write_held_by_key = asciichat_thread_to_key(current_thread);
  rwlock->wrlock_count++;
}
 
void rwlock_on_unlock(rwlock_t *rwlock) {
  if (!rwlock)
    return;
  rwlock->last_unlock_time_ns = time_get_ns();
  rwlock->unlock_count++;
  asciichat_thread_t current_thread = (asciichat_thread_t)asciichat_thread_current_id();
  uintptr_t current_key = asciichat_thread_to_key(current_thread);
  if (rwlock->write_held_by_key == current_key) {
    rwlock->write_held_by_key = 0;
  } else if (atomic_load_u64(&rwlock->read_lock_count) > 0) {
    atomic_fetch_sub_u64(&rwlock->read_lock_count, 1);
  }
}
 
int rwlock_format_state(const rwlock_t *rwlock, char *buffer, size_t size) {
  if (!rwlock || !buffer || size == 0)
    return 0;
 
  int offset = 0;
  uint64_t now_ns = time_get_ns();
 
  char rdlock_str[64] = "";
  char wrlock_str[64] = "";
  char unlock_str[64] = "";
  char held_str[64] = "";
  char count_str[256] = "";
 
  if (rwlock->last_rdlock_time_ns > 0 && rwlock->last_rdlock_time_ns <= now_ns) {
    char elapsed_str[64];
    time_pretty(now_ns - rwlock->last_rdlock_time_ns, -1, elapsed_str, sizeof(elapsed_str));
    snprintf(rdlock_str, sizeof(rdlock_str), "rdlock=%s", elapsed_str);
  }
 
  if (rwlock->last_wrlock_time_ns > 0 && rwlock->last_wrlock_time_ns <= now_ns) {
    char elapsed_str[64];
    time_pretty(now_ns - rwlock->last_wrlock_time_ns, -1, elapsed_str, sizeof(elapsed_str));
    snprintf(wrlock_str, sizeof(wrlock_str), "wrlock=%s", elapsed_str);
  }
 
  if (rwlock->last_unlock_time_ns > 0 && rwlock->last_unlock_time_ns <= now_ns) {
    char elapsed_str[64];
    time_pretty(now_ns - rwlock->last_unlock_time_ns, -1, elapsed_str, sizeof(elapsed_str));
    snprintf(unlock_str, sizeof(unlock_str), "unlock=%s", elapsed_str);
  }
 
  uint64_t read_count = atomic_load_u64(&rwlock->read_lock_count);
  if (rwlock->write_held_by_key != 0) {
    snprintf(held_str, sizeof(held_str), "[WRITE_LOCKED_BY=thread.%lu]", (unsigned long)rwlock->write_held_by_key);
  } else if (read_count > 0) {
    snprintf(held_str, sizeof(held_str), "[READ_LOCKED=%llu]", (unsigned long long)read_count);
  }
 
  if (rwlock->rdlock_count > 0 || rwlock->wrlock_count > 0 || rwlock->unlock_count > 0) {
    snprintf(count_str, sizeof(count_str), "[ops: rdlock=%llu wrlock=%llu unlock=%llu]",
             (unsigned long long)rwlock->rdlock_count, (unsigned long long)rwlock->wrlock_count,
             (unsigned long long)rwlock->unlock_count);
  }
 
  offset += snprintf(buffer + offset, size - offset, "%s %s %s %s %s", rdlock_str, wrlock_str, unlock_str, held_str,
                     count_str);
  return offset;
}
 
void rwlock_log_state(const rwlock_t *rwlock, const char *file, int line, const char *func) {
  if (!rwlock)
    return;
  char buf[512];
  rwlock_format_state(rwlock, buf, sizeof(buf));
  log_msg(LOG_DEBUG, file, line, func, "rwlock/state %p: %s", (const void *)rwlock, buf);
}
 
#endif // !NDEBUG