diff --git a/CHANGELOG b/CHANGELOG index 8d4dcdc..a8bac52 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,4 +1,4 @@ -Version 0.9.0 prerelease (2009.07.16): +Version 0.9.0 prerelease (2009.08.04): * added: support for wide characters (wchar_t) wide characters are used when macro TTMATH_USE_WCHAR is defined this macro is defined automatically when there is macro UNICODE or _UNICODE defined @@ -17,6 +17,9 @@ Version 0.9.0 prerelease (2009.07.16): * added: gamma() function to the parser * added: CGamma class is used with Gamma() and Factorial() in multithreaded environment + * added: multithread support for Big<> class + you should compile with TTMATH_MULTITHREADS + and use TTMATH_MULTITHREADS_HELPER macro somewhere in your *.cpp file * changed: Factorial() is using the Gamma() function now * removed: Parser<>::SetFactorialMax() method the factorial() is such a fast now that we don't need the method longer diff --git a/ttmath/ttmath.h b/ttmath/ttmath.h index ae68555..ddb4a17 100644 --- a/ttmath/ttmath.h +++ b/ttmath/ttmath.h @@ -2715,7 +2715,7 @@ namespace ttmath it's multithread safe, you should create a CGamma<> object and use it whenever you call the Factorial() e.g. typedef Big<1,2> MyBig; - MyBig x=234, y=345.53; + MyBig x=234, y=54345; CGamma cgamma; std::cout << Factorial(x, cgamma) << std::endl; std::cout << Factorial(y, cgamma) << std::endl; diff --git a/ttmath/ttmathbig.h b/ttmath/ttmathbig.h index 482aaf8..12eabc4 100644 --- a/ttmath/ttmathbig.h +++ b/ttmath/ttmathbig.h @@ -44,8 +44,10 @@ */ #include "ttmathint.h" +#include "ttmaththreads.h" #include +#include namespace ttmath { @@ -2961,43 +2963,71 @@ private: // (LnSurrounding1() will return one immediately) uint c = Ln(x); - // warning! this 'static' is not thread safe - static Big log_history[15] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; - uint index = base - 2; - - if( log_history[index].IsZero() ) - { - // we don't have 'base' in 'log_history' then we calculate it now - - if( base==10 && man<=TTMATH_BUILTIN_VARIABLES_SIZE ) - { - // for the base equal 10 we're using SelLn10() instead of calculating it - // (only if we have the constant sufficient big) - temp.SetLn10(); - } - else - { - Big base_(base); - c += temp.Ln(base_); - } - - // the next time we'll get the 'Ln(base)' from the history, - // this 'log_history' can have (16-2+1) items max - log_history[index] = temp; - - c += Div(temp); + if( base==10 && man<=TTMATH_BUILTIN_VARIABLES_SIZE ) + { + // for the base equal 10 we're using SelLn10() instead of calculating it + // (only if we have the constant sufficient big) + temp.SetLn10(); } else { - // we've calculated the 'Ln(base)' beforehand and we're getting it now - c += Div( log_history[index] ); + c += ToString_LogBase(base, temp); } + c += Div( temp ); + return (c==0)? 0 : 1; } + uint ToString_LogBase(uint base, Big & result) + { + TTMATH_ASSERT( base>=2 && base<=16 ) + + // this guardians are initialized before the program runs (static POD types) + volatile static sig_atomic_t guardians[15] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + static Big * plog_history; + uint index = base - 2; + uint c = 0; + + // double-checked locking + if( guardians[index] == 0 ) + { + ThreadLock thread_lock; + + // locking + if( thread_lock.Lock() ) + { + static Big log_history[15]; + + if( guardians[index] == 0 ) + { + plog_history = log_history; + + Big base_(base); + c += log_history[index].Ln(base_); + guardians[index] = 1; + } + } + else + { + // there was a problem with locking, we store the result directly in 'result' object + Big base_(base); + c += result.Ln(base_); + + return (c==0)? 0 : 1; + } + + // automatically unlocking + } + + result = plog_history[index]; + + return (c==0)? 0 : 1; + } + + /*! an auxiliary method for converting into the string (private) diff --git a/ttmath/ttmathobjects.h b/ttmath/ttmathobjects.h index ada60da..d30991e 100644 --- a/ttmath/ttmathobjects.h +++ b/ttmath/ttmathobjects.h @@ -428,7 +428,7 @@ public: /*! default constructor - default max size of the History's container is 10 items + default max size of the History's container is 15 items */ History() { @@ -591,8 +591,8 @@ struct CGamma you don't have to call this method, these coefficients will be automatically calculated when they are needed - you must note that calculating of the coefficients is a little time-consuming operation, - (especially when the mantissa is large) and first called to Gamma() or Factorial() + you must note that calculating these coefficients is a little time-consuming operation, + (especially when the mantissa is large) and first call to Gamma() or Factorial() can take more time than next calls, and in the end this is the point when InitAll() comes in handy: you can call this method somewhere at the beginning of your program */ diff --git a/ttmath/ttmaththreads.h b/ttmath/ttmaththreads.h new file mode 100644 index 0000000..586227f --- /dev/null +++ b/ttmath/ttmaththreads.h @@ -0,0 +1,250 @@ +/* + * This file is a part of TTMath Bignum Library + * and is distributed under the (new) BSD licence. + * Author: Tomasz Sowa + */ + +/* + * Copyright (c) 2006-2009, Tomasz Sowa + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name Tomasz Sowa nor the names of contributors to this + * project may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + + + +#ifndef headerfilettmaththreads +#define headerfilettmaththreads + +#include "ttmathtypes.h" + +#ifdef TTMATH_WIN32_THREADS +#include +#include +#endif + +#ifdef TTMATH_POSIX_THREADS +#include +#endif + + + +/*! + \file ttmaththreads.h + \brief Some objects used in multithreads environment +*/ + + +/* + this is a simple skeleton of a program in multithreads environment: + + #define TTMATH_MULTITHREADS + #include + + TTMATH_MULTITHREADS_HELPER + + int main() + { + [...] + } + + make sure that macro TTMATH_MULTITHREADS is defined and (somewhere in *.cpp file) + use TTMATH_MULTITHREADS_HELPER macro (outside of any classes/functions/namespaces scope) +*/ + + +namespace ttmath +{ + + +#ifdef TTMATH_WIN32_THREADS + + /* + we use win32 threads + */ + + + /*! + in multithreads environment you should use TTMATH_MULTITHREADS_HELPER macro + somewhere in *.cpp file + + (at the moment in win32 this macro does nothing) + */ + #define TTMATH_MULTITHREADS_HELPER + + + /*! + objects of this class are used to synchronize + */ + class ThreadLock + { + HANDLE mutex_handle; + + + void CreateName(char * buffer) const + { + #ifdef _MSC_VER + #pragma warning (disable : 4996) + // warning C4996: 'sprintf': This function or variable may be unsafe. Consider using sprintf_s instead. + #endif + + sprintf(buffer, "TTMATH_LOCK_%ul", (unsigned long)GetCurrentProcessId()); + + #ifdef _MSC_VER + #pragma warning (default : 4996) + #endif + } + + + public: + + bool Lock() + { + char buffer[50]; + + CreateName(buffer); + mutex_handle = CreateMutexA(0, false, buffer); + + if( mutex_handle == 0 ) + return false; + + WaitForSingleObject(mutex_handle, INFINITE); + + return true; + } + + + ThreadLock() + { + mutex_handle = 0; + } + + + ~ThreadLock() + { + if( mutex_handle != 0 ) + { + ReleaseMutex(mutex_handle); + CloseHandle(mutex_handle); + } + } + }; + +#endif // #ifdef TTMATH_WIN32_THREADS + + + + + +#ifdef TTMATH_POSIX_THREADS + + /* + we use posix threads + */ + + + /*! + in multithreads environment you should use TTMATH_MULTITHREADS_HELPER macro + somewhere in *.cpp file + (this macro defines a pthread_mutex_t object used by TTMath library) + */ + #define TTMATH_MULTITHREADS_HELPER \ + namespace ttmath \ + { \ + pthread_mutex_t ttmath_mutex = PTHREAD_MUTEX_INITIALIZER; \ + } + + + /*! + ttmath_mutex will be defined by TTMATH_MULTITHREADS_HELPER macro + */ + extern pthread_mutex_t ttmath_mutex; + + + /*! + objects of this class are used to synchronize + */ + class ThreadLock + { + public: + + bool Lock() + { + if( pthread_mutex_lock(&ttmath_mutex) != 0 ) + return false; + + return true; + } + + + ~ThreadLock() + { + pthread_mutex_unlock(&ttmath_mutex); + } + }; + +#endif // #ifdef TTMATH_POSIX_THREADS + + + + +#if !defined(TTMATH_POSIX_THREADS) && !defined(TTMATH_WIN32_THREADS) + + /*! + we don't use win32 and pthreads + */ + + /*! + */ + #define TTMATH_MULTITHREADS_HELPER + + + /*! + objects of this class are used to synchronize + actually we don't synchronize, the method Lock() returns always 'false' + */ + class ThreadLock + { + public: + + bool Lock() + { + return false; + } + }; + + +#endif // #if !defined(TTMATH_POSIX_THREADS) && !defined(TTMATH_WIN32_THREADS) + + + + + +} // namespace + +#endif + diff --git a/ttmath/ttmathtypes.h b/ttmath/ttmathtypes.h index 1bbc524..b69e4f6 100644 --- a/ttmath/ttmathtypes.h +++ b/ttmath/ttmathtypes.h @@ -229,8 +229,17 @@ namespace ttmath #define TTMATH_TEXT(txt) TTMATH_TEXT_HELPER(txt) +#if defined(TTMATH_MULTITHREADS) && !defined(TTMATH_MULTITHREADS_NOSYNC) + #if !defined(TTMATH_POSIX_THREADS) && !defined(TTMATH_WIN32_THREADS) + #if defined(_WIN32) + #define TTMATH_WIN32_THREADS + #elif defined(unix) || defined(__unix__) || defined(__unix) + #define TTMATH_POSIX_THREADS + #endif + #endif +#endif /*! characters which represent the comma operator @@ -510,7 +519,8 @@ namespace ttmath #endif - + + } // namespace