ruby_nacl 0.1.0

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

@@ -0,0 +1,73 @@
+/*
+cpucycles/cortex.c version 20101203
+D. J. Bernstein
+Public domain.
+*/
+
+#define SCALE 1
+#include <time.h>
+#include <unistd.h>
+#include <sys/time.h>
+
+static int enabled = 0;
+
+static int prev[3];
+static unsigned long long prevcycles = 0;
+static int now[3];
+static long long cyclespersec = 0;
+
+static void readticks(unsigned int *result)
+{
+  struct timeval t;
+  unsigned int cc;
+  if (!enabled) {
+    asm volatile("mcr p15, 0, %0, c9, c12, 0" :: "r"(17));
+    asm volatile("mcr p15, 0, %0, c9, c12, 1" :: "r"(0x8000000f));
+    asm volatile("mcr p15, 0, %0, c9, c12, 3" :: "r"(0x8000000f));
+    enabled = 1;
+  }
+  asm volatile("mrc p15, 0, %0, c9, c13, 0" : "=r"(cc));
+  gettimeofday(&t,(struct timezone *) 0);
+  result[0] = cc;
+  result[1] = t.tv_usec;
+  result[2] = t.tv_sec;
+}
+
+long long cpucycles_cortex(void)
+{
+  unsigned long long delta4;
+  int deltan;
+  int deltas;
+  unsigned long long guesscycles;
+  
+  readticks(now);
+  delta4 = (unsigned int) (now[0] - prev[0]); /* unsigned change in number of cycles mod 2^32 */
+  deltan = now[1] - prev[1]; /* signed change in number of nanoseconds mod 10^9 */
+  deltas = now[2] - prev[2]; /* signed change in number of seconds */
+  if ((deltas == 0 && deltan < 200000) || (deltas == 1 && deltan < -800000))
+    return (prevcycles + delta4) * SCALE;
+
+  prev[0] = now[0];
+  prev[1] = now[1];
+  prev[2] = now[2];
+
+  if ((deltas == 0 && deltan < 300000) || (deltas == 1 && deltan < -700000)) {
+    // actual number of cycles cannot have increased by 2^32 in <0.3ms
+    cyclespersec = 1000000 * (unsigned long long) delta4;
+    cyclespersec /= deltan + 1000000 * (long long) deltas;
+  } else {
+    guesscycles = deltas * cyclespersec;
+    guesscycles += (deltan * cyclespersec) / 1000000;
+    while (delta4 + 2147483648ULL < guesscycles) delta4 += 4294967296ULL;
+    /* XXX: could do longer-term extrapolation here */
+  }
+
+  prevcycles += delta4;
+  return prevcycles * SCALE;
+}
+
+long long cpucycles_cortex_persecond(void)
+{
+  while (!cyclespersec) cpucycles_cortex();
+  return cyclespersec * SCALE;
+}

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

@@ -0,0 +1,27 @@
+/*
+cpucycles cortex.h version 20100912
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_cortex_h
+#define CPUCYCLES_cortex_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_cortex(void);
+extern long long cpucycles_cortex_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "cortex"
+#define cpucycles cpucycles_cortex
+#define cpucycles_persecond cpucycles_cortex_persecond
+#endif
+
+#endif

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

@@ -0,0 +1,62 @@
+#include <sys/types.h>
+#include <fcntl.h>
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+
+static int fddev = -1;
+static int prev[3];
+static unsigned long long prevcycles = 0;
+static int now[3];
+static long long cyclespersec = 0;
+
+static void readdev(unsigned int *result)
+{
+  if (read(fddev,result,12) == 12) return;
+  result[0] = result[1] = result[2] = 0;
+}
+
+long long cpucycles_dev4ns(void)
+{
+  unsigned long long delta4;
+  int deltan;
+  int deltas;
+  unsigned long long guesscycles;
+
+  if (fddev == -1) {
+    fddev = open("/dev/cpucycles4ns",O_RDONLY);
+    readdev(prev);
+  }
+  
+  readdev(now);
+  delta4 = (unsigned int) (now[0] - prev[0]); /* unsigned change in number of cycles mod 2^32 */
+  deltan = now[1] - prev[1]; /* signed change in number of nanoseconds mod 10^9 */
+  deltas = now[2] - prev[2]; /* signed change in number of seconds */
+  if ((deltas == 0 && deltan < 200000000) || (deltas == 1 && deltan < -800000000))
+    return prevcycles + delta4;
+
+  prev[0] = now[0];
+  prev[1] = now[1];
+  prev[2] = now[2];
+
+  if ((deltas == 0 && deltan < 300000000) || (deltas == 1 && deltan < -700000000)) {
+    // actual number of cycles cannot have increased by 2^32 in <0.3ms
+    cyclespersec = 1000000000 * (unsigned long long) delta4;
+    cyclespersec /= deltan + 1000000000 * (long long) deltas;
+  } else {
+    guesscycles = deltas * cyclespersec;
+    guesscycles += (deltan * cyclespersec) / 1000000000;
+    while (delta4 + 2147483648ULL < guesscycles) delta4 += 4294967296ULL;
+    /* XXX: could do longer-term extrapolation here */
+  }
+
+  prevcycles += delta4;
+  return prevcycles;
+}
+
+long long cpucycles_dev4ns_persecond(void)
+{
+  while (!cyclespersec) cpucycles_dev4ns();
+  return cyclespersec;
+}

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

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

data/ext/ruby_nacl/NaCl/cpucycles/do

@@ -0,0 +1,105 @@
+#!/bin/sh -e
+
+okabi | (
+  while read abi
+  do
+
+    rm -f cpucycles.o cpucycles.h
+    
+    (
+      case "$abi" in
+        ppc*)
+          echo powerpccpuinfo
+          echo powerpcmacos
+	  ;;
+        amd64*)
+          echo amd64tscfreq
+          echo amd64cpuinfo
+          echo amd64cpuspeed
+	  ;;
+        x86*)
+          echo x86tscfreq
+          echo x86cpuinfo
+          echo x86cpuspeed
+          echo x86estimate
+	  ;;
+	cell*)
+          echo celllinux
+	  ;;
+	sparc*)
+          echo sparccpuinfo
+          echo sparc32cpuinfo
+	  ;;
+	mips*)
+          echo mips
+	  ;;
+	hppa*)
+          echo hppapstat
+	  ;;
+	alpha*)
+          echo alpha
+	  ;;
+	sgi*)
+          echo sgi
+	  ;;
+	arm*)
+	  echo cortex
+          echo dev4ns
+	  ;;
+      esac
+
+      echo amd64tscfreq
+      echo amd64cpuinfo
+      echo amd64cpuspeed
+      echo x86tscfreq
+      echo x86cpuinfo
+      echo x86cpuspeed
+      echo x86estimate
+      echo ia64cpuinfo
+      echo powerpccpuinfo
+      echo powerpcmacos
+      echo celllinux
+      echo sparccpuinfo
+      echo sparc32cpuinfo
+      echo mips
+      echo hppapstat
+      echo alpha
+      echo sgi
+      echo cortex
+      echo dev4ns
+      echo monotoniccpuinfo
+      echo monotonic
+      echo gettimeofday
+    ) | (
+      while read n
+      do
+        okc-$abi | (
+          while read c
+          do
+            echo "=== `date` === Trying $n.c with $c..." >&2
+            rm -f test cpucycles-impl.o cpucycles-impl.h cpucycles-impl.c
+            cp $n.c cpucycles-impl.c || continue
+            cp $n.h cpucycles-impl.h || continue
+            $c -c cpucycles-impl.c || continue
+            $c -o test test.c cpucycles-impl.o || continue
+            ./test || continue
+            echo "=== `date` === Success. Using $n.c." >&2
+            mkdir -p lib/$abi
+            mv cpucycles-impl.o lib/$abi/cpucycles.o
+            mkdir -p include/$abi
+            mv cpucycles-impl.h include/$abi/cpucycles.h
+            exit 0
+          done
+          exit 111
+        ) && exit 0
+      done
+      exit 111
+    ) || (
+      echo ===== Giving up. >&2
+      rm -f test cpucycles-impl.o cpucycles-impl.h cpucycles-impl.c
+      exit 111
+    ) || exit 0
+
+  done
+  exit 0
+) || exit 111

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

@@ -0,0 +1,32 @@
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include "osfreq.c"
+
+static double cpufrequency = 0;
+
+static void init(void)
+{
+  cpufrequency = osfreq();
+}
+
+long long cpucycles_gettimeofday(void)
+{
+  double result;
+  struct timeval t;
+  if (!cpufrequency) init();
+  gettimeofday(&t,(struct timezone *) 0);
+  result = t.tv_usec;
+  result *= 0.000001;
+  result += (double) t.tv_sec;
+  result *= cpufrequency;
+  return result;
+}
+
+long long cpucycles_gettimeofday_persecond(void)
+{
+  if (!cpufrequency) init();
+  return cpufrequency;
+}

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

@@ -0,0 +1,27 @@
+/*
+cpucycles gettimeofday.h version 20060318
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_gettimeofday_h
+#define CPUCYCLES_gettimeofday_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_gettimeofday(void);
+extern long long cpucycles_gettimeofday_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "gettimeofday"
+#define cpucycles cpucycles_gettimeofday
+#define cpucycles_persecond cpucycles_gettimeofday_persecond
+#endif
+
+#endif

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

@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/pstat.h>
+#include <machine/inline.h>
+
+long long cpucycles_hppapstat(void)
+{
+  register long long result;
+  _MFCTL(16,result);
+  return result;
+}
+
+long long cpucycles_hppapstat_persecond(void)
+{
+  struct pst_processor pst;
+  union pstun pu;
+  double result;
+
+  pu.pst_processor = &pst;
+  if (pstat(PSTAT_PROCESSOR,pu,sizeof(pst),1,0) < 0) return 0;
+  result = pst.psp_iticksperclktick;
+  result *= (double) sysconf(_SC_CLK_TCK);
+  return result;
+}

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

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

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

@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <sys/types.h>
+#include "osfreq.c"
+
+long long cpucycles_ia64cpuinfo(void)
+{
+  long long result;
+  asm volatile("mov %0=ar.itc" : "=r"(result));
+  return result;
+}
+
+long long cpucycles_ia64cpuinfo_persecond(void)
+{
+  return osfreq();
+}

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

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

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

@@ -0,0 +1,65 @@
+/*
+cpucycles/mips.c version 20100803
+D. J. Bernstein
+Public domain.
+*/
+
+#define SCALE 2
+#include <time.h>
+#include <unistd.h>
+#include <sys/time.h>
+
+static int prev[3];
+static unsigned long long prevcycles = 0;
+static int now[3];
+static long long cyclespersec = 0;
+
+static void readticks(unsigned int *result)
+{
+  struct timeval t;
+  unsigned int cc;
+  asm volatile(".byte 59; .byte 16; .byte 2; .byte 124; move %0,$2" : "=r"(cc) : : "$2");
+  gettimeofday(&t,(struct timezone *) 0);
+  result[0] = cc;
+  result[1] = t.tv_usec;
+  result[2] = t.tv_sec;
+}
+
+long long cpucycles_mips(void)
+{
+  unsigned long long delta4;
+  int deltan;
+  int deltas;
+  unsigned long long guesscycles;
+  
+  readticks(now);
+  delta4 = (unsigned int) (now[0] - prev[0]); /* unsigned change in number of cycles mod 2^32 */
+  deltan = now[1] - prev[1]; /* signed change in number of nanoseconds mod 10^9 */
+  deltas = now[2] - prev[2]; /* signed change in number of seconds */
+  if ((deltas == 0 && deltan < 200000) || (deltas == 1 && deltan < -800000))
+    return (prevcycles + delta4) * SCALE;
+
+  prev[0] = now[0];
+  prev[1] = now[1];
+  prev[2] = now[2];
+
+  if ((deltas == 0 && deltan < 300000) || (deltas == 1 && deltan < -700000)) {
+    // actual number of cycles cannot have increased by 2^32 in <0.3ms
+    cyclespersec = 1000000 * (unsigned long long) delta4;
+    cyclespersec /= deltan + 1000000 * (long long) deltas;
+  } else {
+    guesscycles = deltas * cyclespersec;
+    guesscycles += (deltan * cyclespersec) / 1000000;
+    while (delta4 + 2147483648ULL < guesscycles) delta4 += 4294967296ULL;
+    /* XXX: could do longer-term extrapolation here */
+  }
+
+  prevcycles += delta4;
+  return prevcycles * SCALE;
+}
+
+long long cpucycles_mips_persecond(void)
+{
+  while (!cyclespersec) cpucycles_mips();
+  return cyclespersec * SCALE;
+}

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

@@ -0,0 +1,27 @@
+/*
+cpucycles mips.h version 20100802
+D. J. Bernstein
+Public domain.
+*/
+
+#ifndef CPUCYCLES_mips_h
+#define CPUCYCLES_mips_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long long cpucycles_mips(void);
+extern long long cpucycles_mips_persecond(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#ifndef cpucycles_implementation
+#define cpucycles_implementation "mips"
+#define cpucycles cpucycles_mips
+#define cpucycles_persecond cpucycles_mips_persecond
+#endif
+
+#endif

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

@@ -0,0 +1,34 @@
+#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)
+{
+  long result = 0; size_t resultlen = sizeof(long);
+  sysctlbyname("machdep.tsc_freq",&result,&resultlen,0,0);
+  cpufrequency = result;
+}
+
+long long cpucycles_monotonic(void)
+{
+  double result;
+  struct timespec t;
+  if (!cpufrequency) init();
+  clock_gettime(CLOCK_MONOTONIC,&t);
+  result = t.tv_nsec;
+  result *= 0.000000001;
+  result += (double) t.tv_sec;
+  result *= cpufrequency;
+  return result;
+}
+
+long long cpucycles_monotonic_persecond(void)
+{
+  if (!cpufrequency) init();
+  return cpufrequency;
+}

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

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

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

@@ -0,0 +1,33 @@
+#include <time.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include "osfreq.c"
+
+static double cpufrequency = 0;
+
+static void init(void)
+{
+  cpufrequency = osfreq();
+}
+
+long long cpucycles_monotoniccpuinfo(void)
+{
+  double result;
+  struct timespec t;
+  if (!cpufrequency) init();
+  clock_gettime(CLOCK_MONOTONIC,&t);
+  result = t.tv_nsec;
+  result *= 0.000000001;
+  result += (double) t.tv_sec;
+  result *= cpufrequency;
+  return result;
+}
+
+long long cpucycles_monotoniccpuinfo_persecond(void)
+{
+  if (!cpufrequency) init();
+  return cpufrequency;
+}

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

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