1 files changed, 145 insertions, 153 deletions
diff --git a/gnuradio-runtime/lib/vmcircbuf.cc b/gnuradio-runtime/lib/vmcircbuf.cc
index 05f08ceed4..59e6187b27 100644
--- a/gnuradio-runtime/lib/vmcircbuf.cc
+++ b/gnuradio-runtime/lib/vmcircbuf.cc
@@ -44,64 +44,59 @@ gr::thread::mutex s_vm_mutex;
 
 namespace gr {
 
-  static const char *FACTORY_PREF_KEY = "vmcircbuf_default_factory";
+static const char* FACTORY_PREF_KEY = "vmcircbuf_default_factory";
 
-  vmcircbuf::~vmcircbuf()
-  {
-  }
+vmcircbuf::~vmcircbuf() {}
 
-  vmcircbuf_factory::~vmcircbuf_factory()
-  {
-  }
+vmcircbuf_factory::~vmcircbuf_factory() {}
 
-  // ----------------------------------------------------------------
+// ----------------------------------------------------------------
 
-  static vmcircbuf_factory *s_default_factory = 0;
+static vmcircbuf_factory* s_default_factory = 0;
 
-  vmcircbuf_factory *
-  vmcircbuf_sysconfig::get_default_factory()
-  {
-    if(s_default_factory)
-      return s_default_factory;
+vmcircbuf_factory* vmcircbuf_sysconfig::get_default_factory()
+{
+    if (s_default_factory)
+        return s_default_factory;
 
     bool verbose = false;
 
-    std::vector<gr::vmcircbuf_factory *> all = all_factories ();
+    std::vector<gr::vmcircbuf_factory*> all = all_factories();
 
     char name[1024];
     if (gr::vmcircbuf_prefs::get(FACTORY_PREF_KEY, name, sizeof(name)) >= 0) {
-      for(unsigned int i = 0; i < all.size (); i++) {
-        if(strncmp(name, all[i]->name(), strlen(all[i]->name())) == 0) {
-          s_default_factory = all[i];
-          if(verbose)
-            fprintf(stderr, "gr::vmcircbuf_sysconfig: using %s\n",
-                    s_default_factory->name());
-          return s_default_factory;
+        for (unsigned int i = 0; i < all.size(); i++) {
+            if (strncmp(name, all[i]->name(), strlen(all[i]->name())) == 0) {
+                s_default_factory = all[i];
+                if (verbose)
+                    fprintf(stderr,
+                            "gr::vmcircbuf_sysconfig: using %s\n",
+                            s_default_factory->name());
+                return s_default_factory;
+            }
         }
-      }
     }
 
     // either we don't have a default, or the default named is not in our
     // list of factories.  Find the first factory that works.
 
-    if(verbose)
-      fprintf(stderr, "gr::vmcircbuf_sysconfig: finding a working factory...\n");
+    if (verbose)
+        fprintf(stderr, "gr::vmcircbuf_sysconfig: finding a working factory...\n");
 
-    for(unsigned int i = 0; i < all.size (); i++) {
-      if(test_factory(all[i], verbose)) {
-        set_default_factory(all[i]);
-        return s_default_factory;
-      }
+    for (unsigned int i = 0; i < all.size(); i++) {
+        if (test_factory(all[i], verbose)) {
+            set_default_factory(all[i]);
+            return s_default_factory;
+        }
     }
 
     // We're screwed!
     fprintf(stderr, "gr::vmcircbuf_sysconfig: unable to find a working factory!\n");
     throw std::runtime_error("gr::vmcircbuf_sysconfig");
-  }
+}
 
-  std::vector<vmcircbuf_factory *>
-  vmcircbuf_sysconfig::all_factories()
-  {
+std::vector<vmcircbuf_factory*> vmcircbuf_sysconfig::all_factories()
+{
     std::vector<vmcircbuf_factory*> result;
 
     result.push_back(gr::vmcircbuf_createfilemapping_factory::singleton());
@@ -109,192 +104,189 @@ namespace gr {
     result.push_back(gr::vmcircbuf_sysv_shm_factory::singleton());
     result.push_back(gr::vmcircbuf_mmap_shm_open_factory::singleton());
 #endif
-    result.push_back (gr::vmcircbuf_mmap_tmpfile_factory::singleton());
+    result.push_back(gr::vmcircbuf_mmap_tmpfile_factory::singleton());
 
     return result;
-  }
+}
 
-  void
-  vmcircbuf_sysconfig::set_default_factory(vmcircbuf_factory *f)
-  {
+void vmcircbuf_sysconfig::set_default_factory(vmcircbuf_factory* f)
+{
     gr::vmcircbuf_prefs::set(FACTORY_PREF_KEY, f->name());
     s_default_factory = f;
-  }
+}
 
 
-  // ------------------------------------------------------------------------
-  //		    test code for vmcircbuf factories
-  // ------------------------------------------------------------------------
+// ------------------------------------------------------------------------
+//		    test code for vmcircbuf factories
+// ------------------------------------------------------------------------
 
-  static void
-  init_buffer(vmcircbuf *c, int counter, int size)
-  {
-    unsigned int *p = (unsigned int*)c->pointer_to_first_copy();
-    for(unsigned int i = 0; i < size / sizeof(int); i++)
-      p[i] = counter + i;
-  }
+static void init_buffer(vmcircbuf* c, int counter, int size)
+{
+    unsigned int* p = (unsigned int*)c->pointer_to_first_copy();
+    for (unsigned int i = 0; i < size / sizeof(int); i++)
+        p[i] = counter + i;
+}
 
-  static bool
-  check_mapping(vmcircbuf *c, int counter, int size, const char *msg, bool verbose)
-  {
+static bool
+check_mapping(vmcircbuf* c, int counter, int size, const char* msg, bool verbose)
+{
     bool ok = true;
 
-    if(verbose)
-      fprintf(stderr, "... %s", msg);
+    if (verbose)
+        fprintf(stderr, "... %s", msg);
 
-    unsigned int *p1 = (unsigned int *)c->pointer_to_first_copy();
-    unsigned int *p2 = (unsigned int *)c->pointer_to_second_copy();
+    unsigned int* p1 = (unsigned int*)c->pointer_to_first_copy();
+    unsigned int* p2 = (unsigned int*)c->pointer_to_second_copy();
 
     // fprintf(stderr, "p1 = %p, p2 = %p\n", p1, p2);
 
-    for(unsigned int i = 0; i < size / sizeof (int); i++) {
-      if(p1[i] != counter + i) {
-        ok = false;
-        if(verbose)
-          fprintf(stderr, "  p1[%d] == %u, expected %u\n", i, p1[i], counter + i);
-        break;
-      }
-      if(p2[i] != counter + i) {
-        if(verbose)
-          fprintf(stderr, "  p2[%d] == %u, expected %u\n", i, p2[i], counter + i);
-        ok = false;
-        break;
-      }
+    for (unsigned int i = 0; i < size / sizeof(int); i++) {
+        if (p1[i] != counter + i) {
+            ok = false;
+            if (verbose)
+                fprintf(stderr, "  p1[%d] == %u, expected %u\n", i, p1[i], counter + i);
+            break;
+        }
+        if (p2[i] != counter + i) {
+            if (verbose)
+                fprintf(stderr, "  p2[%d] == %u, expected %u\n", i, p2[i], counter + i);
+            ok = false;
+            break;
+        }
     }
 
-    if(ok && verbose) {
-      fprintf(stderr, "  OK\n");
+    if (ok && verbose) {
+        fprintf(stderr, "  OK\n");
     }
     return ok;
-  }
+}
 
-  static const char *
-  memsize(int size)
-  {
+static const char* memsize(int size)
+{
     static std::string buf;
-    if(size >= (1 << 20)) {
-      buf = str(boost::format("%dMB") % (size / (1 << 20)));
-    }
-    else if(size >= (1 << 10)){
-      buf = str(boost::format("%dKB") % (size / (1 << 10)));
-    }
-    else {
-      buf = str(boost::format("%d") % size);
+    if (size >= (1 << 20)) {
+        buf = str(boost::format("%dMB") % (size / (1 << 20)));
+    } else if (size >= (1 << 10)) {
+        buf = str(boost::format("%dKB") % (size / (1 << 10)));
+    } else {
+        buf = str(boost::format("%d") % size);
     }
     return buf.c_str();
-  }
+}
 
-  static bool
-  test_a_bunch(vmcircbuf_factory *factory, int n, int size, int *start_ptr, bool verbose)
-  {
+static bool
+test_a_bunch(vmcircbuf_factory* factory, int n, int size, int* start_ptr, bool verbose)
+{
     bool ok = true;
     std::vector<int> counter(n);
     std::vector<vmcircbuf*> c(n);
     int cum_size = 0;
 
-    for(int i = 0; i < n; i++) {
-      counter[i] = *start_ptr;
-      *start_ptr += size;
-      if((c[i] = factory->make (size)) == 0) {
-        if(verbose)
-          fprintf(stderr,
-                  "Failed to allocate gr::vmcircbuf number %d of size %d (cum = %s)\n",
-                  i + 1, size, memsize(cum_size));
-        return false;
-      }
-      init_buffer(c[i], counter[i], size);
-      cum_size += size;
+    for (int i = 0; i < n; i++) {
+        counter[i] = *start_ptr;
+        *start_ptr += size;
+        if ((c[i] = factory->make(size)) == 0) {
+            if (verbose)
+                fprintf(
+                    stderr,
+                    "Failed to allocate gr::vmcircbuf number %d of size %d (cum = %s)\n",
+                    i + 1,
+                    size,
+                    memsize(cum_size));
+            return false;
+        }
+        init_buffer(c[i], counter[i], size);
+        cum_size += size;
     }
 
-    for(int i = 0; i < n; i++) {
-      std::string msg = str(boost::format("test_a_bunch_%dx%s[%d]") % n % memsize(size) % i);
-      ok &= check_mapping(c[i], counter[i], size, msg.c_str(), verbose);
+    for (int i = 0; i < n; i++) {
+        std::string msg =
+            str(boost::format("test_a_bunch_%dx%s[%d]") % n % memsize(size) % i);
+        ok &= check_mapping(c[i], counter[i], size, msg.c_str(), verbose);
     }
 
-    for(int i = 0; i < n; i++) {
-      delete c[i];
-      c[i] = 0;
+    for (int i = 0; i < n; i++) {
+        delete c[i];
+        c[i] = 0;
     }
 
     return ok;
-  }
+}
 
-  static bool
-  standard_tests(vmcircbuf_factory *f, int verbose)
-  {
-    if(verbose >= 1)
-      fprintf(stderr, "Testing %s...\n", f->name());
+static bool standard_tests(vmcircbuf_factory* f, int verbose)
+{
+    if (verbose >= 1)
+        fprintf(stderr, "Testing %s...\n", f->name());
 
     bool v = verbose >= 2;
     int granularity = f->granularity();
     int start = 0;
     bool ok = true;
 
-    ok &= test_a_bunch(f,   1,   1 * granularity, &start,  v);   //   1 x   4KB =   4KB
+    ok &= test_a_bunch(f, 1, 1 * granularity, &start, v); //   1 x   4KB =   4KB
 
-    if(ok) {
-      ok &= test_a_bunch(f,  64,   4 * granularity, &start, v);  //  64 x  16KB =   1MB
-      ok &= test_a_bunch(f,   4,   4 * (1L << 20),  &start, v);  //   4 x   4MB =  16MB
-      //  ok &= test_a_bunch(f, 256, 256 * (1L << 10),  &start, v);  // 256 x 256KB =  64MB
+    if (ok) {
+        ok &= test_a_bunch(f, 64, 4 * granularity, &start, v); //  64 x  16KB =   1MB
+        ok &= test_a_bunch(f, 4, 4 * (1L << 20), &start, v);   //   4 x   4MB =  16MB
+        //  ok &= test_a_bunch(f, 256, 256 * (1L << 10),  &start, v);  // 256 x 256KB =
+        //  64MB
     }
 
-    if(verbose >= 1)
-      fprintf(stderr, "....... %s: %s", f->name(), ok ? "OK\n" : "Doesn't work\n");
+    if (verbose >= 1)
+        fprintf(stderr, "....... %s: %s", f->name(), ok ? "OK\n" : "Doesn't work\n");
 
     return ok;
-  }
+}
 
-  bool
-  vmcircbuf_sysconfig::test_factory(vmcircbuf_factory *f, int verbose)
-  {
+bool vmcircbuf_sysconfig::test_factory(vmcircbuf_factory* f, int verbose)
+{
     // Install local signal handlers for SIGSEGV and SIGBUS.
     // If something goes wrong, these signals may be invoked.
 
 #ifdef SIGSEGV
-    gr::local_sighandler sigsegv (SIGSEGV, gr::local_sighandler::throw_signal);
+    gr::local_sighandler sigsegv(SIGSEGV, gr::local_sighandler::throw_signal);
 #endif
 #ifdef SIGBUS
-    gr::local_sighandler sigbus (SIGBUS, gr::local_sighandler::throw_signal);
+    gr::local_sighandler sigbus(SIGBUS, gr::local_sighandler::throw_signal);
 #endif
 #ifdef SIGSYS
-    gr::local_sighandler sigsys (SIGSYS, gr::local_sighandler::throw_signal);
+    gr::local_sighandler sigsys(SIGSYS, gr::local_sighandler::throw_signal);
 #endif
 
     try {
-      return standard_tests (f, verbose);
-    }
-    catch(gr::signal &sig) {
-      if(verbose) {
-        fprintf(stderr, "....... %s: %s", f->name(), "Doesn't work\n");
-        fprintf(stderr,
-                "gr::vmcircbuf_factory::test_factory (%s): caught %s\n",
-                f->name(), sig.name().c_str());
+        return standard_tests(f, verbose);
+    } catch (gr::signal& sig) {
+        if (verbose) {
+            fprintf(stderr, "....... %s: %s", f->name(), "Doesn't work\n");
+            fprintf(stderr,
+                    "gr::vmcircbuf_factory::test_factory (%s): caught %s\n",
+                    f->name(),
+                    sig.name().c_str());
+            return false;
+        }
+    } catch (...) {
+        if (verbose) {
+            fprintf(stderr, "....... %s: %s", f->name(), "Doesn't work\n");
+            fprintf(stderr,
+                    "gr::vmcircbuf_factory::test_factory (%s): some kind of uncaught "
+                    "exception\n",
+                    f->name());
+        }
         return false;
-      }
-    }
-    catch (...) {
-      if(verbose) {
-        fprintf(stderr, "....... %s: %s", f->name(), "Doesn't work\n");
-        fprintf(stderr,
-                "gr::vmcircbuf_factory::test_factory (%s): some kind of uncaught exception\n",
-                f->name());
-      }
-      return false;
     }
-    return false;    // never gets here.  shut compiler up.
-  }
+    return false; // never gets here.  shut compiler up.
+}
 
-  bool
-  vmcircbuf_sysconfig::test_all_factories(int verbose)
-  {
+bool vmcircbuf_sysconfig::test_all_factories(int verbose)
+{
     bool ok = false;
 
-    std::vector<vmcircbuf_factory *> all = all_factories();
+    std::vector<vmcircbuf_factory*> all = all_factories();
 
-    for(unsigned int i = 0; i < all.size (); i++)
-      ok |= test_factory(all[i], verbose);
+    for (unsigned int i = 0; i < all.size(); i++)
+        ok |= test_factory(all[i], verbose);
 
     return ok;
-  }
+}
 
 } /* namespace gr */