ruby_nacl 0.1.0

data/ext/ruby_nacl/NaCl/cpucycles/osfreq.c

@@ -0,0 +1,65 @@
+static double osfreq(void)
+{
+  FILE *f;
+  double result;
+  int s;
+
+  f = fopen("/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq", "r");
+  if (f) {
+    s = fscanf(f,"%lf",&result);
+    fclose(f);
+    if (s > 0) return 1000.0 * result;
+  }
+
+  f = fopen("/sys/devices/system/cpu/cpu0/clock_tick", "r");
+  if (f) {
+    s = fscanf(f,"%lf",&result);
+    fclose(f);
+    if (s > 0) return result;
+  }
+
+  f = fopen("/proc/cpuinfo","r");
+  if (f) {
+    for (;;) {
+      s = fscanf(f,"cpu MHz : %lf",&result);
+      if (s > 0) break;
+      if (s == 0) s = fscanf(f,"%*[^\n]\n");
+      if (s < 0) { result = 0; break; }
+    }
+    fclose(f);
+    if (result) return 1000000.0 * result;
+  }
+
+  f = fopen("/proc/cpuinfo","r");
+  if (f) {
+    for (;;) {
+      s = fscanf(f,"clock : %lf",&result);
+      if (s > 0) break;
+      if (s == 0) s = fscanf(f,"%*[^\n]\n");
+      if (s < 0) { result = 0; break; }
+    }
+    fclose(f);
+    if (result) return 1000000.0 * result;
+  }
+
+  f = popen("/usr/sbin/lsattr -E -l proc0 -a frequency 2>/dev/null","r");
+  if (f) {
+    s = fscanf(f,"frequency %lf",&result);
+    pclose(f);
+    if (s > 0) return result;
+  }
+
+  f = popen("/usr/sbin/psrinfo -v 2>/dev/null","r");
+  if (f) {
+    for (;;) {
+      s = fscanf(f," The %*s processor operates at %lf MHz",&result);
+      if (s > 0) break;
+      if (s == 0) s = fscanf(f,"%*[^\n]\n");
+      if (s < 0) { result = 0; break; }
+    }
+    pclose(f);
+    if (result) return 1000000.0 * result;
+  }
+
+  return 0;
+}

data/ext/ruby_nacl/NaCl/cpucycles/powerpccpuinfo.c

@@ -0,0 +1,95 @@
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include "osfreq.c"
+
+static long myround(double u)
+{
+  long result = u;
+  while (result + 0.5 < u) result += 1;
+  while (result - 0.5 > u) result -= 1;
+  return result;
+}
+
+static long long microseconds(void)
+{
+  struct timeval t;
+  gettimeofday(&t,(struct timezone *) 0);
+  return t.tv_sec * (long long) 1000000 + t.tv_usec;
+}
+
+static int tbshift = 0;
+
+static long long timebase(void)
+{
+  unsigned long high;
+  unsigned long low;
+  unsigned long newhigh;
+  unsigned long long result;
+  asm volatile(
+    "7:mftbu %0;mftb %1;mftbu %2;cmpw %0,%2;bne 7b"
+    : "=r" (high), "=r" (low), "=r" (newhigh)
+  );
+  result = high;
+  result <<= 32;
+  result |= low;
+  return result >> tbshift;
+}
+
+static double cpufrequency = 0;
+static long tbcycles = 0;
+
+static double guesstbcycles(void)
+{
+  long long tb0; long long us0;
+  long long tb1; long long us1;
+
+  tb0 = timebase();
+  us0 = microseconds();
+  do {
+    tb1 = timebase();
+    us1 = microseconds();
+  } while (us1 - us0 < 10000 || tb1 - tb0 < 1000);
+  if (tb1 <= tb0) return 0;
+  tb1 -= tb0;
+  us1 -= us0;
+  return (cpufrequency * 0.000001 * (double) us1) / (double) tb1;
+}
+
+static void init(void)
+{
+  int loop;
+  double guess1;
+  double guess2;
+
+  cpufrequency = osfreq();
+  if (!cpufrequency) return;
+
+  for (tbshift = 0;tbshift < 10;++tbshift) {
+    for (loop = 0;loop < 100;++loop) {
+      guess1 = guesstbcycles();
+      guess2 = guesstbcycles();
+      tbcycles = myround(guess1);
+      if (guess1 - tbcycles > 0.1) continue;
+      if (tbcycles - guess1 > 0.1) continue;
+      if (guess2 - tbcycles > 0.1) continue;
+      if (tbcycles - guess2 > 0.1) continue;
+      return;
+    }
+  }
+  tbcycles = 0;
+}
+
+long long cpucycles_powerpccpuinfo(void)
+{
+  if (!tbcycles) init();
+  return timebase() * tbcycles;
+}
+
+long long cpucycles_powerpccpuinfo_persecond(void)
+{
+  if (!tbcycles) init();
+  return cpufrequency;
+}

data/ext/ruby_nacl/NaCl/cpucycles/powerpccpuinfo.h

@@ -0,0 +1,27 @@
+/*
+cpucycles powerpccpuinfo.h version 20100803
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_powerpccpuinfo_h
+#define CPUCYCLES_powerpccpuinfo_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_powerpccpuinfo(void);
+extern long long cpucycles_powerpccpuinfo_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "powerpccpuinfo"
+#define cpucycles cpucycles_powerpccpuinfo
+#define cpucycles_persecond cpucycles_powerpccpuinfo_persecond
+#endif
+
+#endif

data/ext/ruby_nacl/NaCl/cpucycles/powerpcmacos.c

@@ -0,0 +1,42 @@
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <mach/mach_time.h>
+
+#define timebase mach_absolute_time
+
+static int cpumib[2] = { CTL_HW, HW_CPU_FREQ } ;
+static int tbmib[2] = { CTL_HW, HW_TB_FREQ } ;
+
+static long myround(double u)
+{
+  long result = u;
+  while (result + 0.5 < u) result += 1;
+  while (result - 0.5 > u) result -= 1;
+  return result;
+}
+
+static long tbcycles = 0;
+
+static void init(void)
+{
+  unsigned int cpufrequency = 0; size_t cpufrequencylen = sizeof(unsigned int);
+  unsigned int tbfrequency = 0; size_t tbfrequencylen = sizeof(unsigned int);
+  sysctl(cpumib,2,&cpufrequency,&cpufrequencylen,0,0);
+  sysctl(tbmib,2,&tbfrequency,&tbfrequencylen,0,0);
+  if (tbfrequency > 0)
+    tbcycles = myround((double) (unsigned long long) cpufrequency
+                     / (double) (unsigned long long) tbfrequency);
+}
+
+long long cpucycles_powerpcmacos(void)
+{
+  if (!tbcycles) init();
+  return timebase() * tbcycles;
+}
+
+long long cpucycles_powerpcmacos_persecond(void)
+{
+  unsigned int result = 0; size_t resultlen = sizeof(unsigned int);
+  sysctl(cpumib,2,&result,&resultlen,0,0);
+  return (unsigned long long) result;
+}

data/ext/ruby_nacl/NaCl/cpucycles/powerpcmacos.h

@@ -0,0 +1,27 @@
+/*
+cpucycles powerpcmacos.h version 20060319
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_powerpcmacos_h
+#define CPUCYCLES_powerpcmacos_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_powerpcmacos(void);
+extern long long cpucycles_powerpcmacos_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "powerpcmacos"
+#define cpucycles cpucycles_powerpcmacos
+#define cpucycles_persecond cpucycles_powerpcmacos_persecond
+#endif
+
+#endif

data/ext/ruby_nacl/NaCl/cpucycles/sgi.c

@@ -0,0 +1,38 @@
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+
+static double cpufrequency = 0;
+
+static void init(void)
+{
+  FILE *f;
+
+  f = popen("hinv -c processor | awk '{if ($3==\"MHZ\") print $2*1000000}'","r");
+  if (!f) return;
+  if (fscanf(f,"%lf",&cpufrequency) < 1) cpufrequency = 0;
+  pclose(f);
+  if (!cpufrequency) return;
+}
+
+long long cpucycles_sgi(void)
+{
+  double result;
+  struct timespec t;
+  if (!cpufrequency) init();
+  clock_gettime(CLOCK_SGI_CYCLE,&t);
+  result = t.tv_nsec;
+  result *= 0.000000001;
+  result += (double) t.tv_sec;
+  result *= cpufrequency;
+  return result;
+}
+
+long long cpucycles_sgi_persecond(void)
+{
+  if (!cpufrequency) init();
+  return cpufrequency;
+}

data/ext/ruby_nacl/NaCl/cpucycles/sgi.h

@@ -0,0 +1,27 @@
+/*
+cpucycles sgi.h version 20070916
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_sgi_h
+#define CPUCYCLES_sgi_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_sgi(void);
+extern long long cpucycles_sgi_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "sgi"
+#define cpucycles cpucycles_sgi
+#define cpucycles_persecond cpucycles_sgi_persecond
+#endif
+
+#endif

data/ext/ruby_nacl/NaCl/cpucycles/sparc32cpuinfo.c

@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include "osfreq.c"
+
+long long cpucycles_sparc32cpuinfo(void)
+{
+  long long result;
+  asm volatile(".word 2202075136; .word 2570088480; srl %%g1,0,%L0; mov %%o4,%H0"
+    : "=r" (result) : : "g1","o4");
+  return result;
+}
+
+long long cpucycles_sparc32cpuinfo_persecond(void)
+{
+  return osfreq();
+}

data/ext/ruby_nacl/NaCl/cpucycles/sparc32cpuinfo.h

@@ -0,0 +1,27 @@
+/*
+cpucycles sparc32cpuinfo.h version 20100804
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_sparc32cpuinfo_h
+#define CPUCYCLES_sparc32cpuinfo_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_sparc32cpuinfo(void);
+extern long long cpucycles_sparc32cpuinfo_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "sparc32cpuinfo"
+#define cpucycles cpucycles_sparc32cpuinfo
+#define cpucycles_persecond cpucycles_sparc32cpuinfo_persecond
+#endif
+
+#endif

data/ext/ruby_nacl/NaCl/cpucycles/sparccpuinfo.c

@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include "osfreq.c"
+
+long long cpucycles_sparccpuinfo(void)
+{
+  long long result;
+  asm volatile("rd %%tick,%0" : "=r" (result));
+  return result;
+}
+
+long long cpucycles_sparccpuinfo_persecond(void)
+{
+  return osfreq();
+}

data/ext/ruby_nacl/NaCl/cpucycles/sparccpuinfo.h

@@ -0,0 +1,27 @@
+/*
+cpucycles sparccpuinfo.h version 20100803
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_sparccpuinfo_h
+#define CPUCYCLES_sparccpuinfo_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_sparccpuinfo(void);
+extern long long cpucycles_sparccpuinfo_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "sparccpuinfo"
+#define cpucycles cpucycles_sparccpuinfo
+#define cpucycles_persecond cpucycles_sparccpuinfo_persecond
+#endif
+
+#endif

data/ext/ruby_nacl/NaCl/cpucycles/test.c

@@ -0,0 +1,77 @@
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include "cpucycles-impl.h"
+
+static long long tod(void)
+{
+  struct timeval t;
+  gettimeofday(&t,(struct timezone *) 0);
+  return t.tv_sec * (long long) 1000000 + t.tv_usec;
+}
+
+long long todstart;
+long long todend;
+long long cpustart;
+long long cpuend;
+
+long long cyclespersecond;
+long long cyclespertod;
+
+long long t[1001];
+
+int main()
+{
+  int j;
+  int i;
+
+  if (!cpucycles()) {
+    fprintf(stderr,"cpucycles() = %lld\n",cpucycles());
+    return 100;
+  }
+  for (i = 0;i <= 1000;++i) t[i] = cpucycles();
+  for (i = 0;i < 1000;++i) if (t[i] > t[i + 1]) {
+    fprintf(stderr,"t[%d] = %lld\n",i,t[i]);
+    fprintf(stderr,"t[%d] = %lld\n",i + 1,t[i + 1]);
+    fprintf(stderr,"cpucycles_persecond() = %lld\n",cpucycles_persecond());
+    return 100;
+  }
+  if (t[0] == t[1000]) {
+    fprintf(stderr,"t[%d] = %lld\n",0,t[0]);
+    fprintf(stderr,"t[%d] = %lld\n",1000,t[1000]);
+    fprintf(stderr,"cpucycles_persecond() = %lld\n",cpucycles_persecond());
+    return 100;
+  } 
+
+  cyclespersecond = cpucycles_persecond();
+
+  if (cyclespersecond <= 0) {
+    fprintf(stderr,"cpucycles_persecond() = %lld\n",cyclespersecond);
+    return 100;
+  }
+
+  todstart = tod();
+  cpustart = cpucycles();
+  for (j = 0;j < 1000;++j) for (i = 0;i <= 1000;++i) t[i] = t[i] + i + j;
+  todend = tod();
+  cpuend = cpucycles();
+
+  todend -= todstart;
+  cpuend -= cpustart;
+
+  cyclespertod = (long long) (((double) cpuend) * 1000000.0 / (double) todend);
+
+  if (cyclespertod > 10 * cyclespersecond) {
+    fprintf(stderr,"cyclespertod = %lld, cyclespersecond = %lld\n",cyclespertod,cyclespersecond);
+    return 100;
+  }
+
+  for (i = 0;i <= 1000;++i) t[i] = cpucycles();
+  printf("%s",cpucycles_implementation);
+  printf(" %lld",cyclespersecond);
+  printf(" %lld",cyclespertod);
+  for (i = 0;i < 64;++i) printf(" %lld",t[i + 1] - t[i]);
+  printf("\n");
+  return 0;
+}

data/ext/ruby_nacl/NaCl/cpucycles/x86cpuinfo.c

@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include "osfreq.c"
+
+long long cpucycles_x86cpuinfo(void)
+{
+  long long result;
+  asm volatile(".byte 15;.byte 49" : "=A" (result));
+  return result;
+}
+
+long long cpucycles_x86cpuinfo_persecond(void)
+{
+  return osfreq();
+}

data/ext/ruby_nacl/NaCl/cpucycles/x86cpuinfo.h

@@ -0,0 +1,27 @@
+/*
+cpucycles x86cpuinfo.h version 20100803
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_x86cpuinfo_h
+#define CPUCYCLES_x86cpuinfo_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_x86cpuinfo(void);
+extern long long cpucycles_x86cpuinfo_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "x86cpuinfo"
+#define cpucycles cpucycles_x86cpuinfo
+#define cpucycles_persecond cpucycles_x86cpuinfo_persecond
+#endif
+
+#endif

data/ext/ruby_nacl/NaCl/cpucycles/x86cpuspeed.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/sysctl.h>
+
+long long cpucycles_x86cpuspeed(void)
+{
+  long long result;
+  asm volatile(".byte 15;.byte 49" : "=A" (result));
+  return result;
+}
+
+long long cpucycles_x86cpuspeed_persecond(void)
+{
+  int oid[2];
+  int val;
+  size_t size;
+  oid[0] = CTL_HW;
+  oid[1] = HW_CPUSPEED;
+  size = sizeof val;
+  if (sysctl(oid,2,&val,&size,0,0) == -1) return 0;
+  if (size != sizeof val) return 0;
+  return val * 1000000LL;
+}

data/ext/ruby_nacl/NaCl/cpucycles/x86cpuspeed.h

@@ -0,0 +1,27 @@
+/*
+cpucycles x86cpuspeed.h version 20090716
+Matthew Dempsky
+Public domain.
+*/
+
+#ifndef CPUCYCLES_x86cpuspeed_h
+#define CPUCYCLES_x86cpuspeed_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_x86cpuspeed(void);
+extern long long cpucycles_x86cpuspeed_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "x86cpuspeed"
+#define cpucycles cpucycles_x86cpuspeed
+#define cpucycles_persecond cpucycles_x86cpuspeed_persecond
+#endif
+
+#endif

data/ext/ruby_nacl/NaCl/cpucycles/x86estimate.c

@@ -0,0 +1,59 @@
+#include <time.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+
+long long cpucycles_x86estimate(void)
+{
+  long long result;
+  asm volatile(".byte 15;.byte 49" : "=A" (result));
+  return result;
+}
+
+static long long microseconds(void)
+{
+  struct timeval t;
+  gettimeofday(&t,(struct timezone *) 0);
+  return t.tv_sec * (long long) 1000000 + t.tv_usec;
+}
+
+static double guessfreq(void)
+{
+  long long tb0; long long us0;
+  long long tb1; long long us1;
+
+  tb0 = cpucycles_x86estimate();
+  us0 = microseconds();
+  do {
+    tb1 = cpucycles_x86estimate();
+    us1 = microseconds();
+  } while (us1 - us0 < 10000 || tb1 - tb0 < 1000);
+  if (tb1 <= tb0) return 0;
+  tb1 -= tb0;
+  us1 -= us0;
+  return ((double) tb1) / (0.000001 * (double) us1);
+}
+
+static double cpufrequency = 0;
+
+static void init(void)
+{
+  double guess1;
+  double guess2;
+  int loop;
+
+  for (loop = 0;loop < 100;++loop) {
+    guess1 = guessfreq();
+    guess2 = guessfreq();
+    if (guess1 > 1.01 * guess2) continue;
+    if (guess2 > 1.01 * guess1) continue;
+    cpufrequency = 0.5 * (guess1 + guess2);
+    break;
+  }
+}
+
+long long cpucycles_x86estimate_persecond(void)
+{
+  if (!cpufrequency) init();
+  return cpufrequency;
+}

data/ext/ruby_nacl/NaCl/cpucycles/x86estimate.h

@@ -0,0 +1,27 @@
+/*
+cpucycles x86estimate.h version 20070121
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_x86estimate_h
+#define CPUCYCLES_x86estimate_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_x86estimate(void);
+extern long long cpucycles_x86estimate_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "x86estimate"
+#define cpucycles cpucycles_x86estimate
+#define cpucycles_persecond cpucycles_x86estimate_persecond
+#endif
+
+#endif

data/ext/ruby_nacl/NaCl/cpucycles/x86tscfreq.c

@@ -0,0 +1,17 @@
+#include <sys/types.h>
+#include <sys/sysctl.h>
+
+long long cpucycles_x86tscfreq(void)
+{
+  long long result;
+  asm volatile(".byte 15;.byte 49" : "=A" (result));
+  return result;
+}
+
+long long cpucycles_x86tscfreq_persecond(void)
+{
+  long result = 0;
+  size_t resultlen = sizeof(long);
+  sysctlbyname("machdep.tsc_freq",&result,&resultlen,0,0);
+  return result;
+}