From 0ef44329ef30de2a7ea40f51a9748d797ec660e9 Mon Sep 17 00:00:00 2001
From: toddouska <todd@wolfssl.com>
Date: Mon, 11 Nov 2013 17:00:35 -0800
Subject: [PATCH] add thread local storage to ecc fp cache, no locking required
 but cache is per thread, higher conncurrent performance but more memory
 needed

---
 configure.ac             |  2 ++
 ctaocrypt/src/ecc.c      | 39 +++++++++++++++------
 cyassl/ctaocrypt/types.h | 12 +++++++
 m4/ax_tls.m4             | 76 ++++++++++++++++++++++++++++++++++++++++
 4 files changed, 118 insertions(+), 11 deletions(-)
 create mode 100644 m4/ax_tls.m4

diff --git a/configure.ac b/configure.ac
index 55169de1b..6fda6da9f 100644
--- a/configure.ac
+++ b/configure.ac
@@ -103,6 +103,8 @@ OPTIMIZE_FAST_CFLAGS="-O2 -fomit-frame-pointer"
 OPTIMIZE_HUGE_CFLAGS="-funroll-loops -DTFM_SMALL_SET -DTFM_HUGE_SET"
 DEBUG_CFLAGS="-g -DDEBUG -DDEBUG_CYASSL"
 
+# Thread local storage
+AX_TLS([AM_CFLAGS="$AM_CFLAGS -DHAVE_THREAD_LS"])
 
 # DEBUG
 AX_DEBUG
diff --git a/ctaocrypt/src/ecc.c b/ctaocrypt/src/ecc.c
index 0a87e00cb..c0d4d4334 100644
--- a/ctaocrypt/src/ecc.c
+++ b/ctaocrypt/src/ecc.c
@@ -2144,17 +2144,22 @@ int ecc_sig_size(ecc_key* key)
 
 
 /** Our FP cache */
-static struct {
+typedef struct {
    ecc_point* g;               /* cached COPY of base point */
    ecc_point* LUT[1U<<FP_LUT]; /* fixed point lookup */ 
    mp_int     mu;              /* copy of the montgomery constant */
    int        lru_count;       /* amount of times this entry has been used */
    int        lock;            /* flag to indicate cache eviction */
                                /* permitted (0) or not (1) */
-} fp_cache[FP_ENTRIES];
+} fp_cache_t;
 
-static volatile int initMutex = 0;  /* prevent multiple mutex inits */
-static CyaSSL_Mutex ecc_fp_lock;
+/* if HAVE_THREAD_LS this cache is per thread, no locking needed */
+static THREAD_LS_T fp_cache_t fp_cache[FP_ENTRIES];
+
+#ifndef HAVE_THREAD_LS
+    static volatile int initMutex = 0;  /* prevent multiple mutex inits */
+    static CyaSSL_Mutex ecc_fp_lock;
+#endif /* HAVE_THREAD_LS */
 
 /* simple table to help direct the generation of the LUT */
 static const struct {
@@ -3267,17 +3272,18 @@ int ecc_mul2add(ecc_point* A, mp_int* kA,
    mp_digit mp;
    mp_int   mu;
   
-   if (initMutex == 0) {
-        InitMutex(&ecc_fp_lock);
-        initMutex = 1;
-   }
-   
    err = mp_init(&mu);
    if (err != MP_OKAY)
        return err;
 
+#ifndef HAVE_THREAD_LS
+   if (initMutex == 0) {
+        InitMutex(&ecc_fp_lock);
+        initMutex = 1;
+   }
    if (LockMutex(&ecc_fp_lock) != 0)
       return BAD_MUTEX_E;
+#endif /* HAVE_THREAD_LS */
 
       /* find point */
       idx1 = find_base(A);
@@ -3362,7 +3368,9 @@ int ecc_mul2add(ecc_point* A, mp_int* kA,
         }
     }
 
+#ifndef HAVE_THREAD_LS
     UnLockMutex(&ecc_fp_lock);
+#endif /* HAVE_THREAD_LS */
     mp_clear(&mu);
 
     return err;
@@ -3389,6 +3397,7 @@ int ecc_mulmod(mp_int* k, ecc_point *G, ecc_point *R, mp_int* modulus,
    if (mp_init(&mu) != MP_OKAY)
        return MP_INIT_E;
    
+#ifndef HAVE_THREAD_LS
    if (initMutex == 0) {
         InitMutex(&ecc_fp_lock);
         initMutex = 1;
@@ -3396,6 +3405,7 @@ int ecc_mulmod(mp_int* k, ecc_point *G, ecc_point *R, mp_int* modulus,
    
    if (LockMutex(&ecc_fp_lock) != 0)
       return BAD_MUTEX_E;
+#endif /* HAVE_THREAD_LS */
 
       /* find point */
       idx = find_base(G);
@@ -3445,7 +3455,9 @@ int ecc_mulmod(mp_int* k, ecc_point *G, ecc_point *R, mp_int* modulus,
         }
      }
 
+#ifndef HAVE_THREAD_LS
     UnLockMutex(&ecc_fp_lock);
+#endif /* HAVE_THREAD_LS */
     mp_clear(&mu);
 
     return err;
@@ -3474,18 +3486,23 @@ static void ecc_fp_free_cache(void)
 /** Free the Fixed Point cache */
 void ecc_fp_free(void)
 {
+#ifndef HAVE_THREAD_LS
    if (initMutex == 0) {
         InitMutex(&ecc_fp_lock);
         initMutex = 1;
    }
    
    if (LockMutex(&ecc_fp_lock) == 0) {
-       ecc_fp_free_cache();
-       UnLockMutex(&ecc_fp_lock);
+#endif /* HAVE_THREAD_LS */
 
+       ecc_fp_free_cache();
+
+#ifndef HAVE_THREAD_LS
+       UnLockMutex(&ecc_fp_lock);
        FreeMutex(&ecc_fp_lock);
        initMutex = 0;
    }
+#endif /* HAVE_THREAD_LS */
 }
 
 
diff --git a/cyassl/ctaocrypt/types.h b/cyassl/ctaocrypt/types.h
index 8c44bb89f..f873592e3 100644
--- a/cyassl/ctaocrypt/types.h
+++ b/cyassl/ctaocrypt/types.h
@@ -139,6 +139,18 @@ enum {
 #endif
 
 
+/* set up thread local storage if available */
+#ifdef HAVE_THREAD_LS
+    #if defined(_MSC_VER)
+        #define THREAD_LS_T __declspec(thread)
+    #else
+        #define THREAD_LS_T __thread
+    #endif
+#else
+    #define THREAD_LS_T
+#endif
+
+
 /* Micrium will use Visual Studio for compilation but not the Win32 API */
 #if defined(_WIN32) && !defined(MICRIUM) && !defined(FREERTOS) \
         && !defined(EBSNET)
diff --git a/m4/ax_tls.m4 b/m4/ax_tls.m4
new file mode 100644
index 000000000..033e3b135
--- /dev/null
+++ b/m4/ax_tls.m4
@@ -0,0 +1,76 @@
+# ===========================================================================
+#          http://www.gnu.org/software/autoconf-archive/ax_tls.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_TLS([action-if-found], [action-if-not-found])
+#
+# DESCRIPTION
+#
+#   Provides a test for the compiler support of thread local storage (TLS)
+#   extensions. Defines TLS if it is found. Currently knows about GCC/ICC
+#   and MSVC. I think SunPro uses the same as GCC, and Borland apparently
+#   supports either.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Alan Woodland <ajw05@aber.ac.uk>
+#   Copyright (c) 2010 Diego Elio Petteno` <flameeyes@gmail.com>
+#
+#   This program is free software: you can redistribute it and/or modify it
+#   under the terms of the GNU General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   This program is distributed in the hope that it will be useful, but
+#   WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+#   Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+#   As a special exception, the respective Autoconf Macro's copyright owner
+#   gives unlimited permission to copy, distribute and modify the configure
+#   scripts that are the output of Autoconf when processing the Macro. You
+#   need not follow the terms of the GNU General Public License when using
+#   or distributing such scripts, even though portions of the text of the
+#   Macro appear in them. The GNU General Public License (GPL) does govern
+#   all other use of the material that constitutes the Autoconf Macro.
+#
+#   This special exception to the GPL applies to versions of the Autoconf
+#   Macro released by the Autoconf Archive. When you make and distribute a
+#   modified version of the Autoconf Macro, you may extend this special
+#   exception to the GPL to apply to your modified version as well.
+
+#serial 10
+
+AC_DEFUN([AX_TLS], [
+  AC_MSG_CHECKING(for thread local storage (TLS) class)
+  AC_CACHE_VAL(ac_cv_tls, [
+    ax_tls_keywords="__thread __declspec(thread) none"
+    for ax_tls_keyword in $ax_tls_keywords; do
+       AS_CASE([$ax_tls_keyword],
+          [none], [ac_cv_tls=none ; break],
+          [AC_TRY_COMPILE(
+              [#include <stdlib.h>
+               static void
+               foo(void) {
+               static ] $ax_tls_keyword [ int bar;
+               exit(1);
+               }],
+               [],
+               [ac_cv_tls=$ax_tls_keyword ; break],
+               ac_cv_tls=none
+           )])
+    done
+  ])
+  AC_MSG_RESULT($ac_cv_tls)
+
+  AS_IF([test "$ac_cv_tls" != "none"],
+    AC_DEFINE_UNQUOTED([TLS], $ac_cv_tls, [If the compiler supports a TLS storage class define it to that here])
+      m4_ifnblank([$1], [$1]),
+    m4_ifnblank([$2], [$2])
+  )
+])