random inserts/removes

343ef749 · Nickolai Zeldovich · 224c53b4 · 343ef749 · 343ef749
--- a/user/crange_arch.hh
+++ b/user/crange_arch.hh
@@ -99,11 +99,13 @@ struct proc {
  u32 cpuid;
  u32 pid;
  char name[32];
+
+  void (*f) (void*);
+  void *farg;
 };

 struct cpu {
  u32 id;
-  u32 ncli;
 };

 extern pthread_key_t myproc_key;
@@ -124,22 +126,8 @@ mycpu()
  return (cpu*) &cpus[myproc()->cpuid];
 }

-void cli();
-void sti();
-
-static inline void
-pushcli()
-{
-  cli();
-  mycpu()->ncli++;
-}
-
-static inline void
-popcli()
-{
-  if (--mycpu()->ncli == 0)
-    sti();
-}
+static inline void pushcli() {}
+static inline void popcli()  {}

 void threadpin(void (*fn)(void*), void *arg, const char *name, int cpu);

--- a/user/umain.cc
+++ b/user/umain.cc
 #include <unistd.h>
+#include <signal.h>
+#include <getopt.h>

 #include "crange_arch.hh"
 #include "gc.hh"
 #include "crange.hh"
 #include "atomic_util.hh"
 #include "ns.hh"
+#include "rnd.hh"

 u64
 proc_hash(const u32 &pid)
@@ -18,69 +21,137 @@ u32 ncpu;
 u64 ticks;
 xns<u32, proc*, proc_hash> *xnspid;

-struct makeproc_info {
-  void (*f) (void*);
-  void *farg;
-  const char *name;
-  int cpu;
-};
-
-void
-cli()
-{
-  /* suspend all threads with the same cpuid */
-}
-
-void
-sti()
-{
-  /* resume all threads with the same cpuid */
-}
-
 static void*
-makeproc_start(void *arg)
+proc_start(void *arg)
 {
-  makeproc_info *mpi = (makeproc_info *) arg;
+  proc *p = (proc *) arg;

-  proc *p = new proc();
  pthread_setspecific(myproc_key, p);
  p->pid = pthread_self();
-  p->cpuid = mpi->cpu;
-  snprintf(p->name, sizeof(p->name), "%s", mpi->name);
  initprocgc(p);
  xnspid->insert(p->pid, p);

-  mpi->f(mpi->farg);
-  delete mpi;
+  p->f(p->farg);
  return 0;
 }

 void
-makeproc(makeproc_info *mpi)
+makeproc(proc *p)
 {
  pthread_t tid;
-  makeproc_info *mcopy = new makeproc_info(*mpi);
-  pthread_create(&tid, 0, &makeproc_start, mcopy);
+  pthread_create(&tid, 0, &proc_start, p);
 }

 void
 threadpin(void (*fn)(void*), void *arg, const char *name, int cpu)
 {
-  makeproc_info mpi = { fn, arg, name, cpu };
-  makeproc(&mpi);
+  proc *p = new proc();
+  memset(p, 0, sizeof(*p));
+  p->f = fn;
+  p->farg = arg;
+  snprintf(p->name, sizeof(p->name), "%s", name);
+  p->cpuid = cpu;
+
+  makeproc(p);
+}
+
+static pthread_barrier_t worker_b, populate_b;
+
+enum { iter_total = 10000000 };
+enum { crange_items = 1024 };
+
+static void
+worker(void *arg)
+{
+  crange *cr = (crange*) arg;
+
+  for (u32 i = 0; i < iter_total / ncpu; i++) {
+    u64 k = 1 + rnd() % (crange_items * 2);
+    auto span = cr->search_lock(k, 1);
+    if (rnd() & 1)
+      span.replace(0);
+    else
+      span.replace(new range(cr, k, 1));
+  }
+
+  pthread_barrier_wait(&worker_b);
+}
+
+static void
+populate(void *arg)
+{
+  crange *cr = (crange*) arg;
+  for (u32 i = 0; i < crange_items; i++)
+    cr->search_lock(1 + 2*i, 1).replace(new range(cr, 1+2*i, 1));
+  pthread_barrier_wait(&populate_b);
+}
+
+static const struct option long_opts[] = {
+  { "ncpu", required_argument, 0, 'n' },
+  { 0, no_argument, 0, 0 }
+};
+
+static u32
+l2(u64 v)
+{
+  u32 l = 0;
+
+  while (v) {
+    v = v>>1;
+    l++;
+  }
+
+  return l;
 }

 int
 main(int ac, char **av)
 {
+  ncpu = NCPU;
+
+  for (;;) {
+    int long_idx;
+    int opt = getopt_long(ac, av, "n:", long_opts, &long_idx);
+    if (opt == -1)
+      break;
+
+    switch (opt) {
+    case 'n':
+      ncpu = atoi(optarg);
+      assert(ncpu <= NCPU);
+      break;
+
+    case '?':
+      printf("Options:\n");
+      for (u32 i = 0; long_opts[i].name; i++)
+        printf("  -%c / --%s%s\n",
+               long_opts[i].val,
+               long_opts[i].name,
+               long_opts[i].has_arg == required_argument ? " ARG" :
+               long_opts[i].has_arg == optional_argument ? " [ARG]" : "");
+      exit(-1);
+    }
+  }
+
  assert(0 == pthread_key_create(&myproc_key, 0));
  for (u32 i = 0; i < NCPU; i++)
    cpus[i].id = i;
-  ncpu = NCPU;
-  xnspid = new xns<u32, proc*, proc_hash>(false);

+  xnspid = new xns<u32, proc*, proc_hash>(false);
  initgc();

-  printf("Hello world!\n");
-  sleep(100);
+  pthread_barrier_init(&populate_b, 0, 2);
+  crange cr(l2(crange_items));
+  threadpin(populate, &cr, "populate", 0);
+  pthread_barrier_wait(&populate_b);
+
+  pthread_barrier_init(&worker_b, 0, ncpu+1);
+  for (u32 i = 0; i < ncpu; i++) {
+    char buf[32];
+    sprintf(buf, "worker%d", i);
+    threadpin(worker, &cr, buf, i);
+  }
+  pthread_barrier_wait(&worker_b);
+
+  printf("exiting\n");
 }