Merged branch multithreaded into trunk.

Author: FrancescAlted

README.txt

@@ -147,7 +147,14 @@ General routines
 
   * test():  Run all the tests in the test suite.
 
-  * print_versions():  Print the versions of software that numexpr relies on.
+  * print_versions():  Print the versions of software that numexpr
+    relies on.
+
+  * set_num_threads(nthreads): Suggests a maximum number of threads to
+    be used in operations.
+
+  * detect_number_of_cores(): Detects the number of cores on a system.
+
 
 
 Intel's VML specific support routines
@@ -231,10 +238,10 @@ Authors
 
 Numexpr was initially written by David Cooke, and extended to more
 types by Tim Hochberg.  Francesc Alted contributed support for
-booleans and simple-precision floating point types and for efficient
-strided and unaligned array operations.  Ivan Vilata contributed
-support for strings.  Gregor Thalhammer implemented the support for
-Intel VML (Vector Math Library).
+booleans and simple-precision floating point types, efficient strided
+and unaligned array operations and multi-threading code.  Ivan Vilata
+contributed support for strings.  Gregor Thalhammer implemented the
+support for Intel VML (Vector Math Library).
 
 
 License

RELEASE_NOTES.txt

@@ -5,6 +5,10 @@
 Changes from 1.3.1 to development
 =================================
 
+- Added support for multi-threading in pure C.  This is to avoid the
+  GIL and allows to squeeze the best performance in both multi-core
+  machines.
+
 - Fix negation of `int64` numbers. Closes #25.
 
 - Using a `npy_intp` datatype (instead of plain `int`) so as to be

bench/poly.c

@@ -0,0 +1,106 @@
+/* ####################################################################### */
+/* This script compares the speed of the computation of a polynomial       */
+/* in C in a couple of different ways.                                     */
+/*                                                                         */
+/* Author: Francesc Alted                                                  */
+/* Date: 2010-02-05                                                        */
+/* ####################################################################### */
+
+
+#include <stdio.h>
+#include <math.h>
+#if defined(_WIN32) && !defined(__MINGW32__)
+  #include <time.h>
+  #include <windows.h>
+#else
+  #include <unistd.h>
+  #include <sys/time.h>
+#endif
+
+
+#define N  10*1000*1000
+
+double x[N];
+double y[N];
+
+
+#if defined(_WIN32) && !defined(__MINGW32__)
+
+#if defined(_MSC_VER) || defined(_MSC_EXTENSIONS)
+  #define DELTA_EPOCH_IN_MICROSECS  11644473600000000Ui64
+#else
+  #define DELTA_EPOCH_IN_MICROSECS  11644473600000000ULL
+#endif
+
+struct timezone
+{
+  int  tz_minuteswest; /* minutes W of Greenwich */
+  int  tz_dsttime;     /* type of dst correction */
+};
+
+int gettimeofday(struct timeval *tv, struct timezone *tz)
+{
+  FILETIME ft;
+  unsigned __int64 tmpres = 0;
+  static int tzflag;
+
+  if (NULL != tv)
+  {
+    GetSystemTimeAsFileTime(&ft);
+
+    tmpres |= ft.dwHighDateTime;
+    tmpres <<= 32;
+    tmpres |= ft.dwLowDateTime;
+
+    /*converting file time to unix epoch*/
+    tmpres -= DELTA_EPOCH_IN_MICROSECS;
+    tmpres /= 10;  /*convert into microseconds*/
+    tv->tv_sec = (long)(tmpres / 1000000UL);
+    tv->tv_usec = (long)(tmpres % 1000000UL);
+  }
+
+  if (NULL != tz)
+  {
+    if (!tzflag)
+    {
+      _tzset();
+      tzflag++;
+    }
+    tz->tz_minuteswest = _timezone / 60;
+    tz->tz_dsttime = _daylight;
+  }
+
+  return 0;
+}
+#endif   /* _WIN32 */
+
+
+/* Given two timeval stamps, return the difference in seconds */
+float getseconds(struct timeval last, struct timeval current) {
+  int sec, usec;
+
+  sec = current.tv_sec - last.tv_sec;
+  usec = current.tv_usec - last.tv_usec;
+  return (float)(((double)sec + usec*1e-6));
+}
+
+int main(void) {
+  int i;
+  double inf = -1;
+  struct timeval last, current;
+  float tspend;
+
+  for(i=0; i<N; i++) {
+    x[i] = inf+(2.*i)/N;
+  }
+
+  gettimeofday(&last, NULL);
+  for(i=0; i<N; i++) {
+    //y[i] = .25*pow(x[i],3.) + .75*pow(x[i],2.) - 1.5*x[i] - 2;
+    y[i] = ((.25*x[i] + .75)*x[i] - 1.5)*x[i] - 2;
+  }
+  gettimeofday(&current, NULL);
+  tspend = getseconds(last, current);
+  printf("Compute time:\t %.3fs\n", tspend);
+
+}

bench/poly.py

@@ -0,0 +1,46 @@
+#######################################################################
+# This script compares the speed of the computation of a polynomial
+# for different (numpy and numexpr) in-memory paradigms.
+#
+# Author: Francesc Alted
+# Date: 2010-07-06
+#######################################################################
+
+import sys
+from time import time
+import numpy as np
+import numexpr as ne
+
+
+expr = ".25*x**3 + .75*x**2 - 1.5*x - 2"  # the polynomial to compute
+expr = "((.25*x + .75)*x - 1.5)*x - 2"  # a computer-friendly polynomial
+N = 10*1000*1000               # the number of points to compute expression
+x = np.linspace(-1, 1, N)   # the x in range [-1, 1]
+
+#what = "numpy"              # uses numpy for computations
+what = "numexpr"           # uses numexpr for computations
+
+def compute():
+    """Compute the polynomial."""
+    if what == "numpy":
+        y = eval(expr)
+    else:
+        y = ne.evaluate(expr)
+    return len(y)
+
+
+if __name__ == '__main__':
+    if len(sys.argv) > 1:  # first arg is the package to use
+        what = sys.argv[1]
+    if len(sys.argv) > 2:  # second arg is the number of threads to use
+        nthreads = int(sys.argv[2])
+        if "ncores" in dir(ne):
+            ne.set_num_threads(nthreads)
+    if what not in ("numpy", "numexpr"):
+        print "Unrecognized module:", what
+        sys.exit(0)
+    print "Computing: '%s' using %s with %d points" % (expr, what, N)
+    t0 = time()
+    result = compute()
+    ts = round(time() - t0, 3)
+    print "*** Time elapsed:", ts

numexpr/__init__.py

@@ -29,13 +29,16 @@
 from numexpr.necompiler import NumExpr, disassemble, evaluate
 from numexpr.tests import test, print_versions
 from numexpr.utils import (
-    get_vml_version, set_vml_accuracy_mode, set_vml_num_threads)
+    get_vml_version, set_vml_accuracy_mode, set_vml_num_threads,
+    set_num_threads, detect_number_of_cores)
 
+# Initialize the number of threads to be used
+ncores = detect_number_of_cores()
+set_num_threads(ncores)
 
 import version
 
 dirname = os.path.dirname(__file__)
 
 __version__ = version.version
 
-