cpusched.c

   1 #define _GNU_SOURCE
   2 #include <search.h>
   3 #include <limits.h>
   4 #include <errno.h>
   5 #include <string.h>
   6
   7 #include "locking.h"
   8 #include "cpusched.h"
   9 #include "xmalloc.h"
  10 #include "hash.h"
  11
  12 struct map_entry {
  13         int fd;
  14         unsigned int cpu;
  15         struct map_entry *next;
  16 };
  17
  18 static struct hash_table mapper;
  19 static unsigned int *cpu_work_map = NULL;
  20 static unsigned int cpu_len = 0;
  21 static struct rwlock map_lock;
  22
  23 static unsigned int get_appropriate_cpu(void)
  24 {
  25         unsigned int i, cpu = 0;
  26         unsigned int work = UINT_MAX;
  27
  28         for (i = 0; i < cpu_len; ++i) {
  29                 if (cpu_work_map[i] < work) {
  30                         work = cpu_work_map[i];
  31                         cpu = i;
  32                 }
  33         }
  34
  35         return cpu;
  36 }
  37
  38 unsigned int socket_to_cpu(int fd)
  39 {
  40         int cpu = 0;
  41         struct map_entry *entry;
  42
  43         rwlock_rd_lock(&map_lock);
  44
  45         entry = lookup_hash(fd, &mapper);
  46         while (entry && fd != entry->fd)
  47                 entry = entry->next;
  48
  49         if (entry && fd == entry->fd)
  50                 cpu = entry->cpu;
  51
  52         rwlock_unlock(&map_lock);
  53         return cpu;
  54 }
  55
  56 unsigned int register_socket(int fd)
  57 {
  58         void **pos;
  59         struct map_entry *entry;
  60
  61         rwlock_wr_lock(&map_lock);
  62
  63         entry = xzmalloc(sizeof(*entry));
  64         entry->fd = fd;
  65         entry->cpu = get_appropriate_cpu();
  66
  67         cpu_work_map[entry->cpu]++;
  68
  69         pos = insert_hash(entry->fd, entry, &mapper);
  70         if (pos) {
  71                 entry->next = (*pos);
  72                 (*pos) = entry;
  73         }
  74
  75         rwlock_unlock(&map_lock);
  76         return entry->cpu;
  77 }
  78
  79 static struct map_entry *socket_to_map_entry(int fd)
  80 {
  81         struct map_entry *entry, *ret = NULL;
  82
  83         rwlock_rd_lock(&map_lock);
  84
  85         entry = lookup_hash(fd, &mapper);
  86         while (entry && fd != entry->fd)
  87                 entry = entry->next;
  88
  89         if (entry && fd == entry->fd)
  90                 ret = entry;
  91
  92         rwlock_unlock(&map_lock);
  93         return ret;
  94 }
  95
  96 void unregister_socket(int fd)
  97 {
  98         struct map_entry *pos;
  99         struct map_entry *entry = socket_to_map_entry(fd);
 100
 101         if (entry == NULL)
 102                 return;
 103
 104         rwlock_wr_lock(&map_lock);
 105
 106         cpu_work_map[entry->cpu]--;
 107
 108         pos = remove_hash(entry->fd, entry, entry->next, &mapper);
 109         while (pos && pos->next && pos->next != entry)
 110                 pos = pos->next;
 111
 112         if (pos && pos->next && pos->next == entry)
 113                 pos->next = entry->next;
 114
 115         entry->next = NULL;
 116         xfree(entry);
 117
 118         rwlock_unlock(&map_lock);
 119 }
 120
 121 static int cleanup_cpusched_batch(void *ptr)
 122 {
 123         struct map_entry *next;
 124         struct map_entry *entry = ptr;
 125
 126         if (!entry)
 127                 return 0;
 128
 129         while ((next = entry->next)) {
 130                 entry->next = NULL;
 131
 132                 xfree(entry);
 133                 entry = next;
 134         }
 135
 136         xfree(entry);
 137         return 0;
 138 }
 139
 140 void init_cpusched(unsigned int cpus)
 141 {
 142         rwlock_init(&map_lock);
 143         cpu_len = cpus;
 144         cpu_work_map = xcalloc(cpu_len, sizeof(*cpu_work_map));
 145         init_hash(&mapper);
 146 }
 147
 148 void destroy_cpusched(void)
 149 {
 150         xfree(cpu_work_map);
 151         for_each_hash(&mapper, cleanup_cpusched_batch);
 152         free_hash(&mapper);
 153         rwlock_destroy(&map_lock);
 154 }