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;
genesis               113 extern char pszSetDataDir[MAX_PATH];
genesis               114 extern bool fRequestShutdown;
genesis               115 extern bool fShutdown;
genesis               116 extern bool fDaemon;
genesis               117 extern bool fServer;
genesis               118 extern bool fCommandLine;
genesis               119 extern std::string strMiscWarning;
genesis               120 extern bool fTestNet;
genesis               121 extern bool fNoListen;
genesis               122 extern bool fLogTimestamps;
genesis               123 
genesis               124 void RandAddSeed();
genesis               125 void RandAddSeedPerfmon();
genesis               126 int OutputDebugStringF(const char* pszFormat, ...);
genesis               127 int my_snprintf(char* buffer, size_t limit, const char* format, ...);
genesis               128 std::string strprintf(const std::string &format, ...);
genesis               129 bool error(const std::string &format, ...);
genesis               130 void LogException(std::exception* pex, const char* pszThread);
genesis               131 void PrintException(std::exception* pex, const char* pszThread);
genesis               132 void PrintExceptionContinue(std::exception* pex, const char* pszThread);
genesis               133 void ParseString(const std::string& str, char c, std::vector<std::string>& v);
genesis               134 std::string FormatMoney(int64 n, bool fPlus=false);
genesis               135 bool ParseMoney(const std::string& str, int64& nRet);
genesis               136 bool ParseMoney(const char* pszIn, int64& nRet);
genesis               137 std::vector<unsigned char> ParseHex(const char* psz);
genesis               138 std::vector<unsigned char> ParseHex(const std::string& str);
genesis               139 std::vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid = NULL);
genesis               140 std::string DecodeBase64(const std::string& str);
genesis               141 std::string EncodeBase64(const unsigned char* pch, size_t len);
genesis               142 std::string EncodeBase64(const std::string& str);
genesis               143 void ParseParameters(int argc, char* argv[]);
genesis               144 const char* wxGetTranslation(const char* psz);
genesis               145 bool WildcardMatch(const char* psz, const char* mask);
genesis               146 bool WildcardMatch(const std::string& str, const std::string& mask);
genesis               147 int GetFilesize(FILE* file);
genesis               148 void GetDataDir(char* pszDirRet);
genesis               149 std::string GetConfigFile();
genesis               150 std::string GetPidFile();
genesis               151 void CreatePidFile(std::string pidFile, pid_t pid);
genesis               152 void ReadConfigFile(std::map<std::string, std::string>& mapSettingsRet, std::map<std::string, std::vector<std::string> >& mapMultiSettingsRet);
genesis               153 std::string GetDefaultDataDir();
genesis               154 std::string GetDataDir();
genesis               155 void ShrinkDebugFile();
genesis               156 int GetRandInt(int nMax);
genesis               157 uint64 GetRand(uint64 nMax);
genesis               158 int64 GetTime();
genesis               159 void SetMockTime(int64 nMockTimeIn);
genesis               160 int64 GetAdjustedTime();
genesis               161 void AddTimeData(unsigned int ip, int64 nTime);
genesis               162 std::string FormatFullVersion();
genesis               163 
genesis               164 
genesis               165 
genesis               166 
genesis               167 
genesis               168 
genesis               169 
genesis               170 
genesis               171 
genesis               172 
genesis               173 
genesis               174 
genesis               175 
genesis               176 // Wrapper to automatically initialize mutex
genesis               177 class CCriticalSection
genesis               178 {
genesis               179 protected:
genesis               180     boost::interprocess::interprocess_recursive_mutex mutex;
genesis               181 public:
genesis               182     explicit CCriticalSection() { }
genesis               183     ~CCriticalSection() { }
genesis               184     void Enter(const char* pszName, const char* pszFile, int nLine);
genesis               185     void Leave();
genesis               186     bool TryEnter(const char* pszName, const char* pszFile, int nLine);
genesis               187 };
genesis               188 
genesis               189 // Automatically leave critical section when leaving block, needed for exception safety
genesis               190 class CCriticalBlock
genesis               191 {
genesis               192 protected:
genesis               193     CCriticalSection* pcs;
genesis               194 
genesis               195 public:
genesis               196     CCriticalBlock(CCriticalSection& csIn, const char* pszName, const char* pszFile, int nLine)
genesis               197     {
genesis               198         pcs = &csIn;
genesis               199         pcs->Enter(pszName, pszFile, nLine);
genesis               200     }
genesis               201 
genesis               202     operator bool() const
genesis               203     {
genesis               204         return true;
genesis               205     }
genesis               206 
genesis               207     ~CCriticalBlock()
genesis               208     {
genesis               209         pcs->Leave();
genesis               210     }
genesis               211 };
genesis               212 
genesis               213 #define CRITICAL_BLOCK(cs)     \
genesis               214     if (CCriticalBlock criticalblock = CCriticalBlock(cs, #cs, __FILE__, __LINE__))
genesis               215 
genesis               216 #define ENTER_CRITICAL_SECTION(cs) \
genesis               217     (cs).Enter(#cs, __FILE__, __LINE__)
genesis               218 
genesis               219 #define LEAVE_CRITICAL_SECTION(cs) \
genesis               220     (cs).Leave()
genesis               221 
genesis               222 class CTryCriticalBlock
genesis               223 {
genesis               224 protected:
genesis               225     CCriticalSection* pcs;
genesis               226 
genesis               227 public:
genesis               228     CTryCriticalBlock(CCriticalSection& csIn, const char* pszName, const char* pszFile, int nLine)
genesis               229     {
genesis               230         pcs = (csIn.TryEnter(pszName, pszFile, nLine) ? &csIn : NULL);
genesis               231     }
genesis               232 
genesis               233     operator bool() const
genesis               234     {
genesis               235         return Entered();
genesis               236     }
genesis               237 
genesis               238     ~CTryCriticalBlock()
genesis               239     {
genesis               240         if (pcs)
genesis               241         {
genesis               242             pcs->Leave();
genesis               243         }
genesis               244     }
genesis               245     bool Entered() const { return pcs != NULL; }
genesis               246 };
genesis               247 
genesis               248 #define TRY_CRITICAL_BLOCK(cs)     \
genesis               249     if (CTryCriticalBlock criticalblock = CTryCriticalBlock(cs, #cs, __FILE__, __LINE__))
genesis               250 
genesis               251 
genesis               252 
genesis               253 
genesis               254 
genesis               255 
genesis               256 // This is exactly like std::string, but with a custom allocator.
genesis               257 // (secure_allocator<> is defined in serialize.h)
genesis               258 typedef std::basic_string<char, std::char_traits<char>, secure_allocator<char> > SecureString;
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 
genesis               265 
genesis               266 
genesis               267 
genesis               268 inline std::string i64tostr(int64 n)
genesis               269 {
genesis               270     return strprintf("%"PRI64d, n);
genesis               271 }
genesis               272 
genesis               273 inline std::string itostr(int n)
genesis               274 {
genesis               275     return strprintf("%d", n);
genesis               276 }
genesis               277 
genesis               278 inline int64 atoi64(const char* psz)
genesis               279 {
genesis               280     return strtoll(psz, NULL, 10);
genesis               281 }
genesis               282 
genesis               283 inline int64 atoi64(const std::string& str)
genesis               284 {
genesis               285     return strtoll(str.c_str(), NULL, 10);
genesis               286 }
genesis               287 
genesis               288 inline int atoi(const std::string& str)
genesis               289 {
genesis               290     return atoi(str.c_str());
genesis               291 }
genesis               292 
genesis               293 inline int roundint(double d)
genesis               294 {
genesis               295     return (int)(d > 0 ? d + 0.5 : d - 0.5);
genesis               296 }
genesis               297 
genesis               298 inline int64 roundint64(double d)
genesis               299 {
genesis               300     return (int64)(d > 0 ? d + 0.5 : d - 0.5);
genesis               301 }
genesis               302 
genesis               303 inline int64 abs64(int64 n)
genesis               304 {
genesis               305     return (n >= 0 ? n : -n);
genesis               306 }
genesis               307 
genesis               308 template<typename T>
genesis               309 std::string HexStr(const T itbegin, const T itend, bool fSpaces=false)
genesis               310 {
genesis               311     if (itbegin == itend)
genesis               312         return "";
genesis               313     const unsigned char* pbegin = (const unsigned char*)&itbegin[0];
genesis               314     const unsigned char* pend = pbegin + (itend - itbegin) * sizeof(itbegin[0]);
genesis               315     std::string str;
genesis               316     str.reserve((pend-pbegin) * (fSpaces ? 3 : 2));
genesis               317     for (const unsigned char* p = pbegin; p != pend; p++)
genesis               318         str += strprintf((fSpaces && p != pend-1 ? "%02x " : "%02x"), *p);
genesis               319     return str;
genesis               320 }
genesis               321 
genesis               322 inline std::string HexStr(const std::vector<unsigned char>& vch, bool fSpaces=false)
genesis               323 {
genesis               324     return HexStr(vch.begin(), vch.end(), fSpaces);
genesis               325 }
genesis               326 
genesis               327 template<typename T>
genesis               328 std::string HexNumStr(const T itbegin, const T itend, bool f0x=true)
genesis               329 {
genesis               330     if (itbegin == itend)
genesis               331         return "";
genesis               332     const unsigned char* pbegin = (const unsigned char*)&itbegin[0];
genesis               333     const unsigned char* pend = pbegin + (itend - itbegin) * sizeof(itbegin[0]);
genesis               334     std::string str = (f0x ? "0x" : "");
genesis               335     str.reserve(str.size() + (pend-pbegin) * 2);
genesis               336     for (const unsigned char* p = pend-1; p >= pbegin; p--)
genesis               337         str += strprintf("%02x", *p);
genesis               338     return str;
genesis               339 }
genesis               340 
genesis               341 inline std::string HexNumStr(const std::vector<unsigned char>& vch, bool f0x=true)
genesis               342 {
genesis               343     return HexNumStr(vch.begin(), vch.end(), f0x);
genesis               344 }
genesis               345 
genesis               346 template<typename T>
genesis               347 void PrintHex(const T pbegin, const T pend, const char* pszFormat="%s", bool fSpaces=true)
genesis               348 {
genesis               349     printf(pszFormat, HexStr(pbegin, pend, fSpaces).c_str());
genesis               350 }
genesis               351 
genesis               352 inline void PrintHex(const std::vector<unsigned char>& vch, const char* pszFormat="%s", bool fSpaces=true)
genesis               353 {
genesis               354     printf(pszFormat, HexStr(vch, fSpaces).c_str());
genesis               355 }
genesis               356 
genesis               357 inline int64 GetPerformanceCounter()
genesis               358 {
genesis               359     int64 nCounter = 0;
genesis               360     timeval t;
genesis               361     gettimeofday(&t, NULL);
genesis               362     nCounter = t.tv_sec * 1000000 + t.tv_usec;
genesis               363     return nCounter;
genesis               364 }
genesis               365 
genesis               366 inline int64 GetTimeMillis()
genesis               367 {
genesis               368     return (boost::posix_time::ptime(boost::posix_time::microsec_clock::universal_time()) -
genesis               369             boost::posix_time::ptime(boost::gregorian::date(1970,1,1))).total_milliseconds();
genesis               370 }
genesis               371 
genesis               372 inline std::string DateTimeStrFormat(const char* pszFormat, int64 nTime)
genesis               373 {
genesis               374     time_t n = nTime;
genesis               375     struct tm* ptmTime = gmtime(&n);
genesis               376     char pszTime[200];
genesis               377     strftime(pszTime, sizeof(pszTime), pszFormat, ptmTime);
genesis               378     return pszTime;
genesis               379 }
genesis               380 
genesis               381 template<typename T>
genesis               382 void skipspaces(T& it)
genesis               383 {
genesis               384     while (isspace(*it))
genesis               385         ++it;
genesis               386 }
genesis               387 
genesis               388 inline bool IsSwitchChar(char c)
genesis               389 {
genesis               390     return c == '-';
genesis               391 }
genesis               392 
genesis               393 inline std::string GetArg(const std::string& strArg, const std::string& strDefault)
genesis               394 {
genesis               395     if (mapArgs.count(strArg))
genesis               396         return mapArgs[strArg];
genesis               397     return strDefault;
genesis               398 }
genesis               399 
genesis               400 inline int64 GetArg(const std::string& strArg, int64 nDefault)
genesis               401 {
genesis               402     if (mapArgs.count(strArg))
genesis               403         return atoi64(mapArgs[strArg]);
genesis               404     return nDefault;
genesis               405 }
genesis               406 
genesis               407 inline bool GetBoolArg(const std::string& strArg, bool fDefault=false)
genesis               408 {
genesis               409     if (mapArgs.count(strArg))
genesis               410     {
genesis               411         if (mapArgs[strArg].empty())
genesis               412             return true;
genesis               413         return (atoi(mapArgs[strArg]) != 0);
genesis               414     }
genesis               415     return fDefault;
genesis               416 }
genesis               417 
genesis               418 /**
genesis               419  * Set an argument if it doesn't already have a value
genesis               420  *
genesis               421  * @param strArg Argument to set (e.g. "-foo")
genesis               422  * @param strValue Value (e.g. "1")
genesis               423  * @return true if argument gets set, false if it already had a value
genesis               424  */
genesis               425 bool SoftSetArg(const std::string& strArg, const std::string& strValue);
genesis               426 
genesis               427 /**
genesis               428  * Set a boolean argument if it doesn't already have a value
genesis               429  *
genesis               430  * @param strArg Argument to set (e.g. "-foo")
genesis               431  * @param fValue Value (e.g. false)
genesis               432  * @return true if argument gets set, false if it already had a value
genesis               433  */
genesis               434 bool SoftSetArg(const std::string& strArg, bool fValue);
genesis               435 
genesis               436 
genesis               437 
genesis               438 
genesis               439 
genesis               440 
genesis               441 
genesis               442 
genesis               443 
genesis               444 inline void heapchk()
genesis               445 {
genesis               446 }
genesis               447 
genesis               448 // Randomize the stack to help protect against buffer overrun exploits
genesis               449 #define IMPLEMENT_RANDOMIZE_STACK(ThreadFn)     \
genesis               450     {                                           \
genesis               451         static char nLoops;                     \
genesis               452         if (nLoops <= 0)                        \
genesis               453             nLoops = GetRand(20) + 1;           \
genesis               454         if (nLoops-- > 1)                       \
genesis               455         {                                       \
genesis               456             ThreadFn;                           \
genesis               457             return;                             \
genesis               458         }                                       \
genesis               459     }
genesis               460 
genesis               461 #define CATCH_PRINT_EXCEPTION(pszFn)     \
genesis               462     catch (std::exception& e) {          \
genesis               463         PrintException(&e, (pszFn));     \
genesis               464     } catch (...) {                      \
genesis               465         PrintException(NULL, (pszFn));   \
genesis               466     }
genesis               467 
genesis               468 
genesis               469 
genesis               470 
genesis               471 
genesis               472 
genesis               473 
genesis               474 
genesis               475 
genesis               476 
genesis               477 template<typename T1>
genesis               478 inline uint256 Hash(const T1 pbegin, const T1 pend)
genesis               479 {
genesis               480     static unsigned char pblank[1];
genesis               481     uint256 hash1;
genesis               482     SHA256((pbegin == pend ? pblank : (unsigned char*)&pbegin[0]), (pend - pbegin) * sizeof(pbegin[0]), (unsigned char*)&hash1);
genesis               483     uint256 hash2;
genesis               484     SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
genesis               485     return hash2;
genesis               486 }
genesis               487 
genesis               488 template<typename T1, typename T2>
genesis               489 inline uint256 Hash(const T1 p1begin, const T1 p1end,
genesis               490                     const T2 p2begin, const T2 p2end)
genesis               491 {
genesis               492     static unsigned char pblank[1];
genesis               493     uint256 hash1;
genesis               494     SHA256_CTX ctx;
genesis               495     SHA256_Init(&ctx);
genesis               496     SHA256_Update(&ctx, (p1begin == p1end ? pblank : (unsigned char*)&p1begin[0]), (p1end - p1begin) * sizeof(p1begin[0]));
genesis               497     SHA256_Update(&ctx, (p2begin == p2end ? pblank : (unsigned char*)&p2begin[0]), (p2end - p2begin) * sizeof(p2begin[0]));
genesis               498     SHA256_Final((unsigned char*)&hash1, &ctx);
genesis               499     uint256 hash2;
genesis               500     SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
genesis               501     return hash2;
genesis               502 }
genesis               503 
genesis               504 template<typename T1, typename T2, typename T3>
genesis               505 inline uint256 Hash(const T1 p1begin, const T1 p1end,
genesis               506                     const T2 p2begin, const T2 p2end,
genesis               507                     const T3 p3begin, const T3 p3end)
genesis               508 {
genesis               509     static unsigned char pblank[1];
genesis               510     uint256 hash1;
genesis               511     SHA256_CTX ctx;
genesis               512     SHA256_Init(&ctx);
genesis               513     SHA256_Update(&ctx, (p1begin == p1end ? pblank : (unsigned char*)&p1begin[0]), (p1end - p1begin) * sizeof(p1begin[0]));
genesis               514     SHA256_Update(&ctx, (p2begin == p2end ? pblank : (unsigned char*)&p2begin[0]), (p2end - p2begin) * sizeof(p2begin[0]));
genesis               515     SHA256_Update(&ctx, (p3begin == p3end ? pblank : (unsigned char*)&p3begin[0]), (p3end - p3begin) * sizeof(p3begin[0]));
genesis               516     SHA256_Final((unsigned char*)&hash1, &ctx);
genesis               517     uint256 hash2;
genesis               518     SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
genesis               519     return hash2;
genesis               520 }
genesis               521 
genesis               522 template<typename T>
genesis               523 uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=VERSION)
genesis               524 {
genesis               525     // Most of the time is spent allocating and deallocating CDataStream's
genesis               526     // buffer.  If this ever needs to be optimized further, make a CStaticStream
genesis               527     // class with its buffer on the stack.
genesis               528     CDataStream ss(nType, nVersion);
genesis               529     ss.reserve(10000);
genesis               530     ss << obj;
genesis               531     return Hash(ss.begin(), ss.end());
genesis               532 }
genesis               533 
genesis               534 inline uint160 Hash160(const std::vector<unsigned char>& vch)
genesis               535 {
genesis               536     uint256 hash1;
genesis               537     SHA256(&vch[0], vch.size(), (unsigned char*)&hash1);
genesis               538     uint160 hash2;
genesis               539     RIPEMD160((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
genesis               540     return hash2;
genesis               541 }
genesis               542 
genesis               543 
genesis               544 // Median filter over a stream of values
genesis               545 // Returns the median of the last N numbers
genesis               546 template <typename T> class CMedianFilter
genesis               547 {
genesis               548 private:
genesis               549     std::vector<T> vValues;
genesis               550     std::vector<T> vSorted;
genesis               551     int nSize;
genesis               552 public:
genesis               553     CMedianFilter(int size, T initial_value):
genesis               554         nSize(size)
genesis               555     {
genesis               556         vValues.reserve(size);
genesis               557         vValues.push_back(initial_value);
genesis               558         vSorted = vValues;
genesis               559     }
genesis               560     
genesis               561     void input(T value)
genesis               562     {
genesis               563         if(vValues.size() == nSize)
genesis               564         {
genesis               565             vValues.erase(vValues.begin());
genesis               566         }
genesis               567         vValues.push_back(value);
genesis               568 
genesis               569         vSorted.resize(vValues.size());
genesis               570         std::copy(vValues.begin(), vValues.end(), vSorted.begin());
genesis               571         std::sort(vSorted.begin(), vSorted.end());
genesis               572     }
genesis               573 
genesis               574     T median() const
genesis               575     {
genesis               576         int size = vSorted.size();
genesis               577         assert(size>0);
genesis               578         if(size & 1) // Odd number of elements
genesis               579         {
genesis               580             return vSorted[size/2];
genesis               581         }
genesis               582         else // Even number of elements
genesis               583         {
genesis               584             return (vSorted[size/2-1] + vSorted[size/2]) / 2;
genesis               585         }
genesis               586     }
genesis               587 };
genesis               588 
genesis               589 
genesis               590 
genesis               591 
genesis               592 
genesis               593 
genesis               594 
genesis               595 
genesis               596 
genesis               597 
genesis               598 // Note: It turns out we might have been able to use boost::thread
genesis               599 // by using TerminateThread(boost::thread.native_handle(), 0);
genesis               600 inline pthread_t CreateThread(void(*pfn)(void*), void* parg, bool fWantHandle=false)
genesis               601 {
genesis               602     pthread_t hthread = 0;
genesis               603     int ret = pthread_create(&hthread, NULL, (void*(*)(void*))pfn, parg);
genesis               604     if (ret != 0)
genesis               605     {
genesis               606         printf("Error: pthread_create() returned %d\n", ret);
genesis               607         return (pthread_t)0;
genesis               608     }
genesis               609     if (!fWantHandle)
genesis               610     {
genesis               611         pthread_detach(hthread);
genesis               612         return (pthread_t)-1;
genesis               613     }
genesis               614     return hthread;
genesis               615 }
genesis               616 
genesis               617 #define THREAD_PRIORITY_LOWEST          PRIO_MAX
genesis               618 #define THREAD_PRIORITY_BELOW_NORMAL    2
genesis               619 #define THREAD_PRIORITY_NORMAL          0
genesis               620 #define THREAD_PRIORITY_ABOVE_NORMAL    0
genesis               621 
genesis               622 inline void SetThreadPriority(int nPriority)
genesis               623 {
genesis               624     // It's unclear if it's even possible to change thread priorities on Linux,
genesis               625     // but we really and truly need it for the generation threads.
genesis               626 #ifdef PRIO_THREAD
genesis               627     setpriority(PRIO_THREAD, 0, nPriority);
genesis               628 #else
genesis               629     setpriority(PRIO_PROCESS, 0, nPriority);
genesis               630 #endif
genesis               631 }
genesis               632 
genesis               633 inline bool TerminateThread(pthread_t hthread, unsigned int nExitCode)
genesis               634 {
genesis               635     return (pthread_cancel(hthread) == 0);
genesis               636 }
genesis               637 
genesis               638 inline void ExitThread(size_t nExitCode)
genesis               639 {
genesis               640     pthread_exit((void*)nExitCode);
genesis               641 }
genesis               642 
genesis               643 
genesis               644 
genesis               645 inline bool AffinityBugWorkaround(void(*pfn)(void*))
genesis               646 {
genesis               647     return false;
genesis               648 }
genesis               649 
genesis               650 inline uint32_t ByteReverse(uint32_t value)
genesis               651 {
genesis               652     value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8);
genesis               653     return (value<<16) | (value>>16);
genesis               654 }
genesis               655 
genesis               656 #endif