raw
genesis                 1 // Copyright (c) 2009-2010 Satoshi Nakamoto
genesis                 2 // Copyright (c) 2009-2012 The Bitcoin developers
genesis                 3 // Distributed under the MIT/X11 software license, see the accompanying
genesis                 4 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
genesis                 5 #ifndef BITCOIN_UTIL_H
genesis                 6 #define BITCOIN_UTIL_H
genesis                 7 
genesis                 8 #include "uint256.h"
genesis                 9 
asciilifeform-kil...   10 #include <stdint.h>
genesis                11 #include <sys/types.h>
genesis                12 #include <sys/time.h>
genesis                13 #include <sys/resource.h>
genesis                14 #include <map>
genesis                15 #include <vector>
genesis                16 #include <string>
genesis                17 
genesis                18 #include <boost/thread.hpp>
genesis                19 #include <boost/interprocess/sync/interprocess_recursive_mutex.hpp>
genesis                20 #include <boost/date_time/gregorian/gregorian_types.hpp>
genesis                21 #include <boost/date_time/posix_time/posix_time_types.hpp>
genesis                22 
genesis                23 #include <openssl/sha.h>
genesis                24 #include <openssl/ripemd.h>
genesis                25 
genesis                26 
genesis                27 typedef long long  int64;
genesis                28 typedef unsigned long long  uint64;
bitcoin-asciilife...   29 
genesis                30 #define __forceinline  inline
genesis                31 
genesis                32 #define loop                for (;;)
genesis                33 #define BEGIN(a)            ((char*)&(a))
genesis                34 #define END(a)              ((char*)&((&(a))[1]))
genesis                35 #define UBEGIN(a)           ((unsigned char*)&(a))
genesis                36 #define UEND(a)             ((unsigned char*)&((&(a))[1]))
genesis                37 #define ARRAYLEN(array)     (sizeof(array)/sizeof((array)[0]))
genesis                38 #define printf              OutputDebugStringF
genesis                39 
genesis                40 #ifdef snprintf
genesis                41 #undef snprintf
genesis                42 #endif
genesis                43 #define snprintf my_snprintf
genesis                44 
genesis                45 #ifndef PRI64d
genesis                46 #define PRI64d  "lld"
genesis                47 #define PRI64u  "llu"
genesis                48 #define PRI64x  "llx"
genesis                49 #endif
genesis                50 
genesis                51 // This is needed because the foreach macro can't get over the comma in pair<t1, t2>
genesis                52 #define PAIRTYPE(t1, t2)    std::pair<t1, t2>
genesis                53 
genesis                54 // Align by increasing pointer, must have extra space at end of buffer
genesis                55 template <size_t nBytes, typename T>
genesis                56 T* alignup(T* p)
genesis                57 {
genesis                58     union
genesis                59     {
genesis                60         T* ptr;
genesis                61         size_t n;
genesis                62     } u;
genesis                63     u.ptr = p;
genesis                64     u.n = (u.n + (nBytes-1)) & ~(nBytes-1);
genesis                65     return u.ptr;
genesis                66 }
genesis                67 
genesis                68 #define WSAGetLastError()   errno
genesis                69 #define WSAEINVAL           EINVAL
genesis                70 #define WSAEALREADY         EALREADY
genesis                71 #define WSAEWOULDBLOCK      EWOULDBLOCK
genesis                72 #define WSAEMSGSIZE         EMSGSIZE
genesis                73 #define WSAEINTR            EINTR
genesis                74 #define WSAEINPROGRESS      EINPROGRESS
genesis                75 #define WSAEADDRINUSE       EADDRINUSE
genesis                76 #define WSAENOTSOCK         EBADF
genesis                77 #define INVALID_SOCKET      (SOCKET)(~0)
genesis                78 #define SOCKET_ERROR        -1
genesis                79 typedef u_int SOCKET;
genesis                80 #define _vsnprintf(a,b,c,d) vsnprintf(a,b,c,d)
genesis                81 #define strlwr(psz)         to_lower(psz)
genesis                82 #define _strlwr(psz)        to_lower(psz)
genesis                83 #define MAX_PATH            1024
genesis                84 #define Beep(n1,n2)         (0)
genesis                85 inline void Sleep(int64 n)
genesis                86 {
genesis                87     /*Boost has a year 2038 problem— if the request sleep time is past epoch+2^31 seconds the sleep returns instantly.
genesis                88       So we clamp our sleeps here to 10 years and hope that boost is fixed by 2028.*/
genesis                89     boost::thread::sleep(boost::get_system_time() + boost::posix_time::milliseconds(n>315576000000LL?315576000000LL:n));
genesis                90 }
bitcoin-asciilife...   91 
genesis                92 
genesis                93 inline int myclosesocket(SOCKET& hSocket)
genesis                94 {
genesis                95     if (hSocket == INVALID_SOCKET)
genesis                96         return WSAENOTSOCK;
genesis                97     int ret = close(hSocket);
genesis                98     hSocket = INVALID_SOCKET;
genesis                99     return ret;
genesis               100 }
genesis               101 #define closesocket(s)      myclosesocket(s)
genesis               102 inline const char* _(const char* psz)
genesis               103 {
genesis               104     return psz;
genesis               105 }
bitcoin-asciilife...  106 
genesis               107 
genesis               108 extern std::map<std::string, std::string> mapArgs;
genesis               109 extern std::map<std::string, std::vector<std::string> > mapMultiArgs;
genesis               110 extern bool fDebug;
genesis               111 extern bool fPrintToConsole;
genesis               112 extern bool fPrintToDebugger;
asciilifeform_and...  113 extern bool fCanEat;
asciilifeform_add...  114 extern bool fVerifyAll;
genesis               115 extern char pszSetDataDir[MAX_PATH];
genesis               116 extern bool fRequestShutdown;
genesis               117 extern bool fShutdown;
genesis               118 extern bool fDaemon;
genesis               119 extern bool fServer;
genesis               120 extern bool fCommandLine;
genesis               121 extern std::string strMiscWarning;
genesis               122 extern bool fNoListen;
genesis               123 extern bool fLogTimestamps;
programmable-vers...  124 extern std::string CLIENT_NAME;
mod6_der_high_low_s   125 extern bool fLowS;
mod6_der_high_low_s   126 extern bool fHighS;
genesis               127 
genesis               128 void RandAddSeed();
genesis               129 void RandAddSeedPerfmon();
genesis               130 int OutputDebugStringF(const char* pszFormat, ...);
genesis               131 int my_snprintf(char* buffer, size_t limit, const char* format, ...);
genesis               132 std::string strprintf(const std::string &format, ...);
genesis               133 bool error(const std::string &format, ...);
genesis               134 void LogException(std::exception* pex, const char* pszThread);
genesis               135 void PrintException(std::exception* pex, const char* pszThread);
genesis               136 void PrintExceptionContinue(std::exception* pex, const char* pszThread);
genesis               137 void ParseString(const std::string& str, char c, std::vector<std::string>& v);
genesis               138 std::string FormatMoney(int64 n, bool fPlus=false);
genesis               139 bool ParseMoney(const std::string& str, int64& nRet);
genesis               140 bool ParseMoney(const char* pszIn, int64& nRet);
genesis               141 std::vector<unsigned char> ParseHex(const char* psz);
genesis               142 std::vector<unsigned char> ParseHex(const std::string& str);
genesis               143 std::vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid = NULL);
genesis               144 std::string DecodeBase64(const std::string& str);
genesis               145 std::string EncodeBase64(const unsigned char* pch, size_t len);
genesis               146 std::string EncodeBase64(const std::string& str);
genesis               147 void ParseParameters(int argc, char* argv[]);
genesis               148 const char* wxGetTranslation(const char* psz);
genesis               149 bool WildcardMatch(const char* psz, const char* mask);
genesis               150 bool WildcardMatch(const std::string& str, const std::string& mask);
genesis               151 int GetFilesize(FILE* file);
genesis               152 void GetDataDir(char* pszDirRet);
genesis               153 std::string GetConfigFile();
genesis               154 std::string GetPidFile();
genesis               155 void CreatePidFile(std::string pidFile, pid_t pid);
genesis               156 void ReadConfigFile(std::map<std::string, std::string>& mapSettingsRet, std::map<std::string, std::vector<std::string> >& mapMultiSettingsRet);
genesis               157 std::string GetDefaultDataDir();
genesis               158 std::string GetDataDir();
genesis               159 int GetRandInt(int nMax);
genesis               160 uint64 GetRand(uint64 nMax);
genesis               161 int64 GetTime();
genesis               162 void SetMockTime(int64 nMockTimeIn);
genesis               163 int64 GetAdjustedTime();
genesis               164 void AddTimeData(unsigned int ip, int64 nTime);
genesis               165 std::string FormatFullVersion();
programmable-vers...  166 std::string FormatSubVersion(const std::string& name, int nClientVersion);
genesis               167 
genesis               168 
genesis               169 
genesis               170 
genesis               171 
genesis               172 
genesis               173 
genesis               174 
genesis               175 
genesis               176 
genesis               177 
genesis               178 
genesis               179 
genesis               180 // Wrapper to automatically initialize mutex
genesis               181 class CCriticalSection
genesis               182 {
genesis               183 protected:
genesis               184     boost::interprocess::interprocess_recursive_mutex mutex;
genesis               185 public:
genesis               186     explicit CCriticalSection() { }
genesis               187     ~CCriticalSection() { }
genesis               188     void Enter(const char* pszName, const char* pszFile, int nLine);
genesis               189     void Leave();
genesis               190     bool TryEnter(const char* pszName, const char* pszFile, int nLine);
genesis               191 };
genesis               192 
genesis               193 // Automatically leave critical section when leaving block, needed for exception safety
genesis               194 class CCriticalBlock
genesis               195 {
genesis               196 protected:
genesis               197     CCriticalSection* pcs;
genesis               198 
genesis               199 public:
genesis               200     CCriticalBlock(CCriticalSection& csIn, const char* pszName, const char* pszFile, int nLine)
genesis               201     {
genesis               202         pcs = &csIn;
genesis               203         pcs->Enter(pszName, pszFile, nLine);
genesis               204     }
genesis               205 
genesis               206     operator bool() const
genesis               207     {
genesis               208         return true;
genesis               209     }
genesis               210 
genesis               211     ~CCriticalBlock()
genesis               212     {
genesis               213         pcs->Leave();
genesis               214     }
genesis               215 };
genesis               216 
genesis               217 #define CRITICAL_BLOCK(cs)     \
genesis               218     if (CCriticalBlock criticalblock = CCriticalBlock(cs, #cs, __FILE__, __LINE__))
genesis               219 
genesis               220 #define ENTER_CRITICAL_SECTION(cs) \
genesis               221     (cs).Enter(#cs, __FILE__, __LINE__)
genesis               222 
genesis               223 #define LEAVE_CRITICAL_SECTION(cs) \
genesis               224     (cs).Leave()
genesis               225 
genesis               226 class CTryCriticalBlock
genesis               227 {
genesis               228 protected:
genesis               229     CCriticalSection* pcs;
genesis               230 
genesis               231 public:
genesis               232     CTryCriticalBlock(CCriticalSection& csIn, const char* pszName, const char* pszFile, int nLine)
genesis               233     {
genesis               234         pcs = (csIn.TryEnter(pszName, pszFile, nLine) ? &csIn : NULL);
genesis               235     }
genesis               236 
genesis               237     operator bool() const
genesis               238     {
genesis               239         return Entered();
genesis               240     }
genesis               241 
genesis               242     ~CTryCriticalBlock()
genesis               243     {
genesis               244         if (pcs)
genesis               245         {
genesis               246             pcs->Leave();
genesis               247         }
genesis               248     }
genesis               249     bool Entered() const { return pcs != NULL; }
genesis               250 };
genesis               251 
genesis               252 #define TRY_CRITICAL_BLOCK(cs)     \
genesis               253     if (CTryCriticalBlock criticalblock = CTryCriticalBlock(cs, #cs, __FILE__, __LINE__))
genesis               254 
genesis               255 
genesis               256 
genesis               257 
genesis               258 
genesis               259 
genesis               260 // This is exactly like std::string, but with a custom allocator.
genesis               261 // (secure_allocator<> is defined in serialize.h)
genesis               262 typedef std::basic_string<char, std::char_traits<char>, secure_allocator<char> > SecureString;
genesis               263 
genesis               264 // This is exactly like std::string, but with a custom allocator.
genesis               265 // (secure_allocator<> is defined in serialize.h)
genesis               266 typedef std::basic_string<char, std::char_traits<char>, secure_allocator<char> > SecureString;
genesis               267 
genesis               268 
genesis               269 
genesis               270 
genesis               271 
genesis               272 inline std::string i64tostr(int64 n)
genesis               273 {
genesis               274     return strprintf("%"PRI64d, n);
genesis               275 }
genesis               276 
genesis               277 inline std::string itostr(int n)
genesis               278 {
genesis               279     return strprintf("%d", n);
genesis               280 }
genesis               281 
genesis               282 inline int64 atoi64(const char* psz)
genesis               283 {
genesis               284     return strtoll(psz, NULL, 10);
genesis               285 }
genesis               286 
genesis               287 inline int64 atoi64(const std::string& str)
genesis               288 {
genesis               289     return strtoll(str.c_str(), NULL, 10);
genesis               290 }
genesis               291 
genesis               292 inline int atoi(const std::string& str)
genesis               293 {
genesis               294     return atoi(str.c_str());
genesis               295 }
genesis               296 
genesis               297 inline int roundint(double d)
genesis               298 {
genesis               299     return (int)(d > 0 ? d + 0.5 : d - 0.5);
genesis               300 }
genesis               301 
genesis               302 inline int64 roundint64(double d)
genesis               303 {
genesis               304     return (int64)(d > 0 ? d + 0.5 : d - 0.5);
genesis               305 }
genesis               306 
genesis               307 inline int64 abs64(int64 n)
genesis               308 {
genesis               309     return (n >= 0 ? n : -n);
genesis               310 }
genesis               311 
genesis               312 template<typename T>
genesis               313 std::string HexStr(const T itbegin, const T itend, bool fSpaces=false)
genesis               314 {
genesis               315     if (itbegin == itend)
genesis               316         return "";
genesis               317     const unsigned char* pbegin = (const unsigned char*)&itbegin[0];
genesis               318     const unsigned char* pend = pbegin + (itend - itbegin) * sizeof(itbegin[0]);
genesis               319     std::string str;
genesis               320     str.reserve((pend-pbegin) * (fSpaces ? 3 : 2));
genesis               321     for (const unsigned char* p = pbegin; p != pend; p++)
genesis               322         str += strprintf((fSpaces && p != pend-1 ? "%02x " : "%02x"), *p);
genesis               323     return str;
genesis               324 }
genesis               325 
genesis               326 inline std::string HexStr(const std::vector<unsigned char>& vch, bool fSpaces=false)
genesis               327 {
genesis               328     return HexStr(vch.begin(), vch.end(), fSpaces);
genesis               329 }
genesis               330 
genesis               331 template<typename T>
genesis               332 std::string HexNumStr(const T itbegin, const T itend, bool f0x=true)
genesis               333 {
genesis               334     if (itbegin == itend)
genesis               335         return "";
genesis               336     const unsigned char* pbegin = (const unsigned char*)&itbegin[0];
genesis               337     const unsigned char* pend = pbegin + (itend - itbegin) * sizeof(itbegin[0]);
genesis               338     std::string str = (f0x ? "0x" : "");
genesis               339     str.reserve(str.size() + (pend-pbegin) * 2);
genesis               340     for (const unsigned char* p = pend-1; p >= pbegin; p--)
genesis               341         str += strprintf("%02x", *p);
genesis               342     return str;
genesis               343 }
genesis               344 
genesis               345 inline std::string HexNumStr(const std::vector<unsigned char>& vch, bool f0x=true)
genesis               346 {
genesis               347     return HexNumStr(vch.begin(), vch.end(), f0x);
genesis               348 }
genesis               349 
genesis               350 template<typename T>
genesis               351 void PrintHex(const T pbegin, const T pend, const char* pszFormat="%s", bool fSpaces=true)
genesis               352 {
genesis               353     printf(pszFormat, HexStr(pbegin, pend, fSpaces).c_str());
genesis               354 }
genesis               355 
genesis               356 inline void PrintHex(const std::vector<unsigned char>& vch, const char* pszFormat="%s", bool fSpaces=true)
genesis               357 {
genesis               358     printf(pszFormat, HexStr(vch, fSpaces).c_str());
genesis               359 }
genesis               360 
genesis               361 inline int64 GetPerformanceCounter()
genesis               362 {
genesis               363     int64 nCounter = 0;
genesis               364     timeval t;
genesis               365     gettimeofday(&t, NULL);
genesis               366     nCounter = t.tv_sec * 1000000 + t.tv_usec;
genesis               367     return nCounter;
genesis               368 }
genesis               369 
genesis               370 inline int64 GetTimeMillis()
genesis               371 {
genesis               372     return (boost::posix_time::ptime(boost::posix_time::microsec_clock::universal_time()) -
genesis               373             boost::posix_time::ptime(boost::gregorian::date(1970,1,1))).total_milliseconds();
genesis               374 }
genesis               375 
genesis               376 inline std::string DateTimeStrFormat(const char* pszFormat, int64 nTime)
genesis               377 {
genesis               378     time_t n = nTime;
genesis               379     struct tm* ptmTime = gmtime(&n);
genesis               380     char pszTime[200];
genesis               381     strftime(pszTime, sizeof(pszTime), pszFormat, ptmTime);
genesis               382     return pszTime;
genesis               383 }
genesis               384 
genesis               385 template<typename T>
genesis               386 void skipspaces(T& it)
genesis               387 {
genesis               388     while (isspace(*it))
genesis               389         ++it;
genesis               390 }
genesis               391 
genesis               392 inline bool IsSwitchChar(char c)
genesis               393 {
genesis               394     return c == '-';
genesis               395 }
genesis               396 
genesis               397 inline std::string GetArg(const std::string& strArg, const std::string& strDefault)
genesis               398 {
genesis               399     if (mapArgs.count(strArg))
genesis               400         return mapArgs[strArg];
genesis               401     return strDefault;
genesis               402 }
genesis               403 
genesis               404 inline int64 GetArg(const std::string& strArg, int64 nDefault)
genesis               405 {
genesis               406     if (mapArgs.count(strArg))
genesis               407         return atoi64(mapArgs[strArg]);
genesis               408     return nDefault;
genesis               409 }
genesis               410 
genesis               411 inline bool GetBoolArg(const std::string& strArg, bool fDefault=false)
genesis               412 {
genesis               413     if (mapArgs.count(strArg))
genesis               414     {
genesis               415         if (mapArgs[strArg].empty())
genesis               416             return true;
genesis               417         return (atoi(mapArgs[strArg]) != 0);
genesis               418     }
genesis               419     return fDefault;
genesis               420 }
genesis               421 
genesis               422 /**
genesis               423  * Set an argument if it doesn't already have a value
genesis               424  *
genesis               425  * @param strArg Argument to set (e.g. "-foo")
genesis               426  * @param strValue Value (e.g. "1")
genesis               427  * @return true if argument gets set, false if it already had a value
genesis               428  */
genesis               429 bool SoftSetArg(const std::string& strArg, const std::string& strValue);
genesis               430 
genesis               431 /**
genesis               432  * Set a boolean argument if it doesn't already have a value
genesis               433  *
genesis               434  * @param strArg Argument to set (e.g. "-foo")
genesis               435  * @param fValue Value (e.g. false)
genesis               436  * @return true if argument gets set, false if it already had a value
genesis               437  */
genesis               438 bool SoftSetArg(const std::string& strArg, bool fValue);
genesis               439 
genesis               440 
genesis               441 
genesis               442 
genesis               443 
genesis               444 
genesis               445 
genesis               446 
genesis               447 
genesis               448 inline void heapchk()
genesis               449 {
genesis               450 }
genesis               451 
genesis               452 // Randomize the stack to help protect against buffer overrun exploits
genesis               453 #define IMPLEMENT_RANDOMIZE_STACK(ThreadFn)     \
genesis               454     {                                           \
genesis               455         static char nLoops;                     \
genesis               456         if (nLoops <= 0)                        \
genesis               457             nLoops = GetRand(20) + 1;           \
genesis               458         if (nLoops-- > 1)                       \
genesis               459         {                                       \
genesis               460             ThreadFn;                           \
genesis               461             return;                             \
genesis               462         }                                       \
genesis               463     }
genesis               464 
genesis               465 #define CATCH_PRINT_EXCEPTION(pszFn)     \
genesis               466     catch (std::exception& e) {          \
genesis               467         PrintException(&e, (pszFn));     \
genesis               468     } catch (...) {                      \
genesis               469         PrintException(NULL, (pszFn));   \
genesis               470     }
genesis               471 
genesis               472 
genesis               473 
genesis               474 
genesis               475 
genesis               476 
genesis               477 
genesis               478 
genesis               479 
genesis               480 
genesis               481 template<typename T1>
genesis               482 inline uint256 Hash(const T1 pbegin, const T1 pend)
genesis               483 {
genesis               484     static unsigned char pblank[1];
genesis               485     uint256 hash1;
genesis               486     SHA256((pbegin == pend ? pblank : (unsigned char*)&pbegin[0]), (pend - pbegin) * sizeof(pbegin[0]), (unsigned char*)&hash1);
genesis               487     uint256 hash2;
genesis               488     SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
genesis               489     return hash2;
genesis               490 }
genesis               491 
genesis               492 template<typename T1, typename T2>
genesis               493 inline uint256 Hash(const T1 p1begin, const T1 p1end,
genesis               494                     const T2 p2begin, const T2 p2end)
genesis               495 {
genesis               496     static unsigned char pblank[1];
genesis               497     uint256 hash1;
genesis               498     SHA256_CTX ctx;
genesis               499     SHA256_Init(&ctx);
genesis               500     SHA256_Update(&ctx, (p1begin == p1end ? pblank : (unsigned char*)&p1begin[0]), (p1end - p1begin) * sizeof(p1begin[0]));
genesis               501     SHA256_Update(&ctx, (p2begin == p2end ? pblank : (unsigned char*)&p2begin[0]), (p2end - p2begin) * sizeof(p2begin[0]));
genesis               502     SHA256_Final((unsigned char*)&hash1, &ctx);
genesis               503     uint256 hash2;
genesis               504     SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
genesis               505     return hash2;
genesis               506 }
genesis               507 
genesis               508 template<typename T1, typename T2, typename T3>
genesis               509 inline uint256 Hash(const T1 p1begin, const T1 p1end,
genesis               510                     const T2 p2begin, const T2 p2end,
genesis               511                     const T3 p3begin, const T3 p3end)
genesis               512 {
genesis               513     static unsigned char pblank[1];
genesis               514     uint256 hash1;
genesis               515     SHA256_CTX ctx;
genesis               516     SHA256_Init(&ctx);
genesis               517     SHA256_Update(&ctx, (p1begin == p1end ? pblank : (unsigned char*)&p1begin[0]), (p1end - p1begin) * sizeof(p1begin[0]));
genesis               518     SHA256_Update(&ctx, (p2begin == p2end ? pblank : (unsigned char*)&p2begin[0]), (p2end - p2begin) * sizeof(p2begin[0]));
genesis               519     SHA256_Update(&ctx, (p3begin == p3end ? pblank : (unsigned char*)&p3begin[0]), (p3end - p3begin) * sizeof(p3begin[0]));
genesis               520     SHA256_Final((unsigned char*)&hash1, &ctx);
genesis               521     uint256 hash2;
genesis               522     SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
genesis               523     return hash2;
genesis               524 }
genesis               525 
genesis               526 template<typename T>
genesis               527 uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=VERSION)
genesis               528 {
genesis               529     // Most of the time is spent allocating and deallocating CDataStream's
genesis               530     // buffer.  If this ever needs to be optimized further, make a CStaticStream
genesis               531     // class with its buffer on the stack.
genesis               532     CDataStream ss(nType, nVersion);
genesis               533     ss.reserve(10000);
genesis               534     ss << obj;
genesis               535     return Hash(ss.begin(), ss.end());
genesis               536 }
genesis               537 
genesis               538 inline uint160 Hash160(const std::vector<unsigned char>& vch)
genesis               539 {
genesis               540     uint256 hash1;
genesis               541     SHA256(&vch[0], vch.size(), (unsigned char*)&hash1);
genesis               542     uint160 hash2;
genesis               543     RIPEMD160((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
genesis               544     return hash2;
genesis               545 }
genesis               546 
genesis               547 
genesis               548 // Median filter over a stream of values
genesis               549 // Returns the median of the last N numbers
genesis               550 template <typename T> class CMedianFilter
genesis               551 {
genesis               552 private:
genesis               553     std::vector<T> vValues;
genesis               554     std::vector<T> vSorted;
genesis               555     int nSize;
genesis               556 public:
genesis               557     CMedianFilter(int size, T initial_value):
genesis               558         nSize(size)
genesis               559     {
genesis               560         vValues.reserve(size);
genesis               561         vValues.push_back(initial_value);
genesis               562         vSorted = vValues;
genesis               563     }
genesis               564     
genesis               565     void input(T value)
genesis               566     {
genesis               567         if(vValues.size() == nSize)
genesis               568         {
genesis               569             vValues.erase(vValues.begin());
genesis               570         }
genesis               571         vValues.push_back(value);
genesis               572 
genesis               573         vSorted.resize(vValues.size());
genesis               574         std::copy(vValues.begin(), vValues.end(), vSorted.begin());
genesis               575         std::sort(vSorted.begin(), vSorted.end());
genesis               576     }
genesis               577 
genesis               578     T median() const
genesis               579     {
genesis               580         int size = vSorted.size();
genesis               581         assert(size>0);
genesis               582         if(size & 1) // Odd number of elements
genesis               583         {
genesis               584             return vSorted[size/2];
genesis               585         }
genesis               586         else // Even number of elements
genesis               587         {
genesis               588             return (vSorted[size/2-1] + vSorted[size/2]) / 2;
genesis               589         }
genesis               590     }
genesis               591 };
genesis               592 
genesis               593 
genesis               594 
genesis               595 
genesis               596 
genesis               597 
genesis               598 
genesis               599 
genesis               600 
genesis               601 
genesis               602 // Note: It turns out we might have been able to use boost::thread
genesis               603 // by using TerminateThread(boost::thread.native_handle(), 0);
genesis               604 inline pthread_t CreateThread(void(*pfn)(void*), void* parg, bool fWantHandle=false)
genesis               605 {
genesis               606     pthread_t hthread = 0;
genesis               607     int ret = pthread_create(&hthread, NULL, (void*(*)(void*))pfn, parg);
genesis               608     if (ret != 0)
genesis               609     {
genesis               610         printf("Error: pthread_create() returned %d\n", ret);
genesis               611         return (pthread_t)0;
genesis               612     }
genesis               613     if (!fWantHandle)
genesis               614     {
genesis               615         pthread_detach(hthread);
genesis               616         return (pthread_t)-1;
genesis               617     }
genesis               618     return hthread;
genesis               619 }
genesis               620 
genesis               621 #define THREAD_PRIORITY_LOWEST          PRIO_MAX
genesis               622 #define THREAD_PRIORITY_BELOW_NORMAL    2
genesis               623 #define THREAD_PRIORITY_NORMAL          0
genesis               624 #define THREAD_PRIORITY_ABOVE_NORMAL    0
genesis               625 
genesis               626 inline void SetThreadPriority(int nPriority)
genesis               627 {
genesis               628     // It's unclear if it's even possible to change thread priorities on Linux,
genesis               629     // but we really and truly need it for the generation threads.
genesis               630 #ifdef PRIO_THREAD
genesis               631     setpriority(PRIO_THREAD, 0, nPriority);
genesis               632 #else
genesis               633     setpriority(PRIO_PROCESS, 0, nPriority);
genesis               634 #endif
genesis               635 }
genesis               636 
genesis               637 inline bool TerminateThread(pthread_t hthread, unsigned int nExitCode)
genesis               638 {
genesis               639     return (pthread_cancel(hthread) == 0);
genesis               640 }
genesis               641 
genesis               642 inline void ExitThread(size_t nExitCode)
genesis               643 {
genesis               644     pthread_exit((void*)nExitCode);
genesis               645 }
genesis               646 
genesis               647 
genesis               648 
genesis               649 inline bool AffinityBugWorkaround(void(*pfn)(void*))
genesis               650 {
genesis               651     return false;
genesis               652 }
genesis               653 
genesis               654 inline uint32_t ByteReverse(uint32_t value)
genesis               655 {
genesis               656     value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8);
genesis               657     return (value<<16) | (value>>16);
genesis               658 }
genesis               659 
genesis               660 #endif