diff options
Diffstat (limited to 'zen')
| -rwxr-xr-x | zen/crc.h | 89 | ||||
| -rwxr-xr-x | zen/file_access.cpp | 17 | ||||
| -rwxr-xr-x | zen/file_io.cpp | 8 | ||||
| -rwxr-xr-x | zen/guid.h | 55 | ||||
| -rwxr-xr-x | zen/perf.h | 51 | ||||
| -rwxr-xr-x | zen/ring_buffer.h | 12 | ||||
| -rwxr-xr-x | zen/serialize.h | 2 | ||||
| -rwxr-xr-x | zen/stl_tools.h | 10 | ||||
| -rwxr-xr-x | zen/string_tools.h | 8 | ||||
| -rwxr-xr-x | zen/string_traits.h | 8 | ||||
| -rwxr-xr-x | zen/thread.h | 56 | ||||
| -rwxr-xr-x | zen/warn_static.h | 2 | ||||
| -rwxr-xr-x | zen/zstring.h | 18 |
13 files changed, 256 insertions, 80 deletions
@@ -7,8 +7,7 @@ #ifndef CRC_H_23489275827847235 #define CRC_H_23489275827847235 -//boost, clean this mess up! -#include <boost/crc.hpp> +#include "type_traits.h" namespace zen @@ -27,28 +26,86 @@ inline uint32_t getCrc32(const std::string& str) { return getCrc32(str.begin(), template <class ByteIterator> inline -uint16_t getCrc16(ByteIterator first, ByteIterator last) +uint16_t getCrc16(ByteIterator first, ByteIterator last) //http://www.sunshine2k.de/articles/coding/crc/understanding_crc.html { + constexpr uint16_t crcTable[] = + { + 0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241, 0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440, + 0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40, 0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841, + 0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40, 0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41, + 0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641, 0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040, + 0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240, 0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441, + 0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41, 0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840, + 0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41, 0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40, + 0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640, 0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041, + 0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240, 0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441, + 0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41, 0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840, + 0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41, 0xbe01, 0x7ec0, 0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40, + 0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640, 0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041, + 0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241, 0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440, + 0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40, 0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841, + 0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40, 0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41, + 0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040 + }; + static_assert(arraySize(crcTable) == 256 && arrayAccumulate<uint32_t>(crcTable) == 8380544); static_assert(sizeof(typename std::iterator_traits<ByteIterator>::value_type) == 1); - boost::crc_16_type result; - if (first != last) - result.process_bytes(&*first, last - first); - auto rv = result.checksum(); - static_assert(sizeof(rv) == sizeof(uint16_t)); - return rv; + + uint16_t crc = 0; + std::for_each(first, last, [&](unsigned char b) + { + crc = (crc >> 8) ^ crcTable[(crc ^ b) & 0xFF]; + }); + return crc; } template <class ByteIterator> inline -uint32_t getCrc32(ByteIterator first, ByteIterator last) +uint32_t getCrc32(ByteIterator first, ByteIterator last) //https://en.wikipedia.org/wiki/Cyclic_redundancy_check { + constexpr uint32_t crcTable[] = + { + 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, + 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, + 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, + 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, + 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, + 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, + 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, + 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, + 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, + 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, + 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, + 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, + 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, + 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, + 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, + 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, + 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, + 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, + 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, + 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, + 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, + 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, + 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, + 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, + 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, + 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, + 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, + 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, + 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, + 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, + 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, + 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d + }; + static_assert(arraySize(crcTable) == 256 && arrayAccumulate<uint64_t>(crcTable) == 549755813760); static_assert(sizeof(typename std::iterator_traits<ByteIterator>::value_type) == 1); - boost::crc_32_type result; - if (first != last) - result.process_bytes(&*first, last - first); - auto rv = result.checksum(); - static_assert(sizeof(rv) == sizeof(uint32_t)); - return rv; + + uint32_t crc = 0xFFFFFFFF; + std::for_each(first, last, [&](unsigned char b) + { + crc = (crc >> 8) ^ crcTable[(crc ^ b) & 0xFF]; + }); + return crc ^ 0xFFFFFFFF; } } diff --git a/zen/file_access.cpp b/zen/file_access.cpp index fca1e3d8..9c351e25 100755 --- a/zen/file_access.cpp +++ b/zen/file_access.cpp @@ -14,8 +14,8 @@ #include "symlink_target.h" #include "file_id_def.h" #include "file_io.h" -#include "crc.h" //boost dependency! -#include "guid.h" // +#include "crc.h" +#include "guid.h" #include <sys/vfs.h> //statfs #include <sys/time.h> //lutimes @@ -34,7 +34,7 @@ Opt<PathComponents> zen::parsePathComponents(const Zstring& itemPath) { auto doParse = [&](int sepCountVolumeRoot, bool rootWithSep) -> Opt<PathComponents> { - const Zstring itemPathFmt = appendSeparator(itemPath); //simplify analysis of root without seperator, e.g. \\server-name\share + const Zstring itemPathFmt = appendSeparator(itemPath); //simplify analysis of root without separator, e.g. \\server-name\share int sepCount = 0; for (auto it = itemPathFmt.begin(); it != itemPathFmt.end(); ++it) if (*it == FILE_NAME_SEPARATOR) @@ -347,8 +347,11 @@ void renameFile_sub(const Zstring& pathSource, const Zstring& pathTarget) //thro if (!equalFilePath(pathSource, pathTarget)) //exception for OS X: changing file name case is not an "already exists" situation! { - bool alreadyExists = true; - try { /*ItemType type = */getItemType(pathTarget); } /*throw FileError*/ catch (FileError&) { alreadyExists = false; } + const bool alreadyExists = [&] + { + try { /*ItemType type = */getItemType(pathTarget); return true; } /*throw FileError*/ + catch (FileError&) { return false; } + }(); if (alreadyExists) throwException(EEXIST); @@ -422,7 +425,7 @@ void setWriteTimeNative(const Zstring& itemPath, const struct ::timespec& modTim return; //in other cases utimensat() returns EINVAL for CIFS/NTFS drives, but open+futimens works: https://freefilesync.org/forum/viewtopic.php?t=387 - const int fdFile = ::open(itemPath.c_str(), O_WRONLY | O_APPEND); //2017-07-04: O_WRONLY | O_APPEND seems to avoid EOPNOTSUPP on gvfs SFTP! + const int fdFile = ::open(itemPath.c_str(), O_WRONLY | O_APPEND | O_CLOEXEC); //2017-07-04: O_WRONLY | O_APPEND seems to avoid EOPNOTSUPP on gvfs SFTP! if (fdFile == -1) THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot write modification time of %x."), L"%x", fmtPath(itemPath)), L"open"); ZEN_ON_SCOPE_EXIT(::close(fdFile)); @@ -636,7 +639,7 @@ FileCopyResult copyFileOsSpecific(const Zstring& sourceFile, //throw FileError, //it seems we don't need S_IWUSR, not even for the setFileTime() below! (tested with source file having different user/group!) //=> need copyItemPermissions() only for "chown" and umask-agnostic permissions - const int fdTarget = ::open(targetFile.c_str(), O_WRONLY | O_CREAT | O_EXCL, mode); + const int fdTarget = ::open(targetFile.c_str(), O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC, mode); if (fdTarget == -1) { const int ec = errno; //copy before making other system calls! diff --git a/zen/file_io.cpp b/zen/file_io.cpp index 25dc93ce..df47e4c5 100755 --- a/zen/file_io.cpp +++ b/zen/file_io.cpp @@ -8,8 +8,8 @@ #include "file_access.h" #include <sys/stat.h> - #include <fcntl.h> //open, close - #include <unistd.h> //read, write + #include <fcntl.h> //open + #include <unistd.h> //close, read, write using namespace zen; @@ -80,7 +80,7 @@ FileBase::FileHandle openHandleForRead(const Zstring& filePath) //throw FileErro checkForUnsupportedType(filePath); //throw FileError; opening a named pipe would block forever! //don't use O_DIRECT: http://yarchive.net/comp/linux/o_direct.html - const FileBase::FileHandle fileHandle = ::open(filePath.c_str(), O_RDONLY); + const FileBase::FileHandle fileHandle = ::open(filePath.c_str(), O_RDONLY | O_CLOEXEC); if (fileHandle == -1) //don't check "< 0" -> docu seems to allow "-2" to be a valid file handle THROW_LAST_FILE_ERROR(replaceCpy(_("Cannot open file %x."), L"%x", fmtPath(filePath)), L"open"); return fileHandle; //pass ownership @@ -180,7 +180,7 @@ FileBase::FileHandle openHandleForWrite(const Zstring& filePath, FileOutput::Acc { //checkForUnsupportedType(filePath); -> not needed, open() + O_WRONLY should fail fast - const FileBase::FileHandle fileHandle = ::open(filePath.c_str(), O_WRONLY | O_CREAT | (access == FileOutput::ACC_CREATE_NEW ? O_EXCL : O_TRUNC), + const FileBase::FileHandle fileHandle = ::open(filePath.c_str(), O_WRONLY | O_CREAT | O_CLOEXEC | (access == FileOutput::ACC_CREATE_NEW ? O_EXCL : O_TRUNC), S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH); //0666 if (fileHandle == -1) { @@ -7,21 +7,58 @@ #ifndef GUID_H_80425780237502345 #define GUID_H_80425780237502345 -#include <string> - #include <boost/uuid/uuid_generators.hpp> + #include <fcntl.h> //open + #include <unistd.h> //close + //#include <uuid/uuid.h> -> uuid_generate(), uuid_unparse(); avoid additional dependency for "sudo apt-get install uuid-dev" + namespace zen { inline std::string generateGUID() //creates a 16-byte GUID { - //perf: generator: 0.38ms per creation; - // retrieve GUID: 0.13µs per call - //generator is only thread-safe like an int => keep thread-local - thread_local boost::uuids::random_generator gen; - static_assert(boost::uuids::uuid::static_size() == 16); - const boost::uuids::uuid nativeRep = gen(); - return std::string(nativeRep.begin(), nativeRep.end()); +#if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 25) //getentropy() requires glibc 2.25 (ldd --version) PS: Centos 7 is on 2.17 + std::string guid(16, '\0'); + if (::getentropy(&guid[0], 16) != 0) //"The maximum permitted value for the length argument is 256" + throw std::runtime_error(std::string(__FILE__) + "[" + numberTo<std::string>(__LINE__) + "] Failed to generate GUID." + + "\n" + utfTo<std::string>(formatSystemError(L"getentropy", errno))); + return guid; + +#else + class RandomGeneratorPosix + { + public: + RandomGeneratorPosix() + { + if (fd_ == -1) + throw std::runtime_error(std::string(__FILE__) + "[" + numberTo<std::string>(__LINE__) + "] Failed to generate GUID." + + "\n" + utfTo<std::string>(formatSystemError(L"open", errno))); + } + + ~RandomGeneratorPosix() { ::close(fd_); } + + void getBytes(void* buf, size_t size) + { + for (size_t offset = 0; offset < size; ) + { + const ssize_t bytesRead = ::read(fd_, static_cast<char*>(buf) + offset, size - offset); + if (bytesRead < 1) //0 means EOF => error in this context (should check for buffer overflow, too?) + throw std::runtime_error(std::string(__FILE__) + "[" + numberTo<std::string>(__LINE__) + "] Failed to generate GUID." + + "\n" + utfTo<std::string>(formatSystemError(L"read", bytesRead < 0 ? errno : EIO))); + offset += bytesRead; + assert(offset <= size); + } + } + + private: + const int fd_ = ::open("/dev/urandom", O_RDONLY | O_CLOEXEC); + }; + thread_local RandomGeneratorPosix gen; + std::string guid(16, '\0'); + gen.getBytes(&guid[0], 16); + return guid; +#endif + } } @@ -28,19 +28,28 @@ namespace zen { -class PerfTimer + +//issue with wxStopWatch? https://freefilesync.org/forum/viewtopic.php?t=1426 +// => wxStopWatch implementation uses QueryPerformanceCounter: https://github.com/wxWidgets/wxWidgets/blob/17d72a48ffd4d8ff42eed070ac48ee2de50ceabd/src/common/stopwatch.cpp +// => whatever the problem was, it's almost certainly not caused by QueryPerformanceCounter(): +// MSDN: "How often does QPC roll over? Not less than 100 years from the most recent system boot" +// https://msdn.microsoft.com/en-us/library/windows/desktop/dn553408#How_often_does_QPC_roll_over_ +// +// => using the system clock is problematic: https://freefilesync.org/forum/viewtopic.php?t=5280 +// +// std::chrono::system_clock wraps ::GetSystemTimePreciseAsFileTime() +// std::chrono::steady_clock wraps ::QueryPerformanceCounter() +class StopWatch { public: - [[deprecated]] PerfTimer() {} - - ~PerfTimer() { if (!resultShown_) showResult(); } + bool isPaused() const { return paused_; } void pause() { if (!paused_) { paused_ = true; - elapsedUntilPause_ += std::chrono::steady_clock::now() - startTime_; //ignore potential ::QueryPerformanceCounter() wrap-around! + elapsedUntilPause_ += std::chrono::steady_clock::now() - startTime_; } } @@ -60,31 +69,43 @@ public: elapsedUntilPause_ = std::chrono::nanoseconds::zero(); } - int64_t timeMs() const + std::chrono::nanoseconds elapsed() const { auto elapsedTotal = elapsedUntilPause_; if (!paused_) elapsedTotal += std::chrono::steady_clock::now() - startTime_; - - return std::chrono::duration_cast<std::chrono::milliseconds>(elapsedTotal).count(); + return elapsedTotal; } +private: + bool paused_ = false; + std::chrono::steady_clock::time_point startTime_ = std::chrono::steady_clock::now(); + std::chrono::nanoseconds elapsedUntilPause_{}; //std::chrono::duration is uninitialized by default! WTF! When will this stupidity end??? +}; + + +class PerfTimer +{ +public: + [[deprecated]] PerfTimer() {} + + ~PerfTimer() { if (!resultShown_) showResult(); } + void showResult() { - const bool wasRunning = !paused_; - if (wasRunning) pause(); //don't include call to MessageBox()! - ZEN_ON_SCOPE_EXIT(if (wasRunning) resume()); + const bool wasRunning = !watch_.isPaused(); + if (wasRunning) watch_.pause(); //don't include call to MessageBox()! + ZEN_ON_SCOPE_EXIT(if (wasRunning) watch_.resume()); - const std::string msg = numberTo<std::string>(timeMs()) + " ms"; + const int64_t timeMs = std::chrono::duration_cast<std::chrono::milliseconds>(watch_.elapsed()).count(); + const std::string msg = numberTo<std::string>(timeMs) + " ms"; std::clog << "Perf: duration: " << msg << "\n"; resultShown_ = true; } private: + StopWatch watch_; bool resultShown_ = false; - bool paused_ = false; - std::chrono::steady_clock::time_point startTime_ = std::chrono::steady_clock::now(); //uses ::QueryPerformanceCounter() - std::chrono::nanoseconds elapsedUntilPause_{}; //std::chrono::duration is uninitialized by default! WTF! When will this stupidity end??? }; } diff --git a/zen/ring_buffer.h b/zen/ring_buffer.h index 1a67c452..6debd84e 100755 --- a/zen/ring_buffer.h +++ b/zen/ring_buffer.h @@ -163,16 +163,26 @@ public: class Iterator { public: + using iterator_category = std::random_access_iterator_tag; + using value_type = Value; + using difference_type = ptrdiff_t; + using pointer = Value*; + using reference = Value&; + Iterator(Container& container, size_t offset) : container_(&container), offset_(offset) {} Iterator& operator++() { ++offset_; return *this; } + Iterator& operator+=(ptrdiff_t offset) { offset_ += offset; } inline friend bool operator==(const Iterator& lhs, const Iterator& rhs) { assert(lhs.container_ == rhs.container_); return lhs.offset_ == rhs.offset_; } inline friend bool operator!=(const Iterator& lhs, const Iterator& rhs) { return !(lhs == rhs); } + inline friend ptrdiff_t operator-(const Iterator& lhs, const Iterator& rhs) { return lhs.offset_ - rhs.offset_; } + inline friend Iterator operator+(const Iterator& lhs, ptrdiff_t offset) { Iterator tmp(lhs); return tmp += offset; } Value& operator* () const { return (*container_)[offset_]; } Value* operator->() const { return &(*container_)[offset_]; } private: Container* container_ = nullptr; - size_t offset_ = 0; + ptrdiff_t offset_ = 0; }; + using iterator = Iterator< RingBuffer, T>; using const_iterator = Iterator<const RingBuffer, const T>; diff --git a/zen/serialize.h b/zen/serialize.h index 16375cff..d34b61b2 100755 --- a/zen/serialize.h +++ b/zen/serialize.h @@ -90,7 +90,7 @@ template <class BinContainer, class BufferedInputStream> BinContainer bufferedLoad(BufferedInputStream& streamIn); //throw X template <class N, class BufferedOutputStream> void writeNumber (BufferedOutputStream& stream, const N& num); // -template <class C, class BufferedOutputStream> void writeContainer(BufferedOutputStream& stream, const C& str); //throw () +template <class C, class BufferedOutputStream> void writeContainer(BufferedOutputStream& stream, const C& str); //noexcept template < class BufferedOutputStream> void writeArray (BufferedOutputStream& stream, const void* buffer, size_t len); // //---------------------------------------------------------------------- class UnexpectedEndOfStreamError {}; diff --git a/zen/stl_tools.h b/zen/stl_tools.h index 2ce2cf33..7365392f 100755 --- a/zen/stl_tools.h +++ b/zen/stl_tools.h @@ -43,8 +43,8 @@ template <class T, class Alloc> void removeDuplicates(std::vector<T, Alloc>& v); //binary search returning an iterator -template <class ForwardIterator, class T, typename CompLess> -ForwardIterator binary_search(ForwardIterator first, ForwardIterator last, const T& value, CompLess less); +template <class Iterator, class T, typename CompLess> +Iterator binary_search(Iterator first, Iterator last, const T& value, CompLess less); template <class BidirectionalIterator, class T> BidirectionalIterator find_last(BidirectionalIterator first, BidirectionalIterator last, const T& value); @@ -125,9 +125,11 @@ void removeDuplicates(std::vector<T, Alloc>& v) } -template <class ForwardIterator, class T, typename CompLess> inline -ForwardIterator binary_search(ForwardIterator first, ForwardIterator last, const T& value, CompLess less) +template <class Iterator, class T, typename CompLess> inline +Iterator binary_search(Iterator first, Iterator last, const T& value, CompLess less) { + static_assert(std::is_same_v<typename std::iterator_traits<Iterator>::iterator_category, std::random_access_iterator_tag>); + first = std::lower_bound(first, last, value, less); if (first != last && !less(value, *first)) return first; diff --git a/zen/string_tools.h b/zen/string_tools.h index 58cb6ea6..e09cb61f 100755 --- a/zen/string_tools.h +++ b/zen/string_tools.h @@ -14,7 +14,7 @@ #include <algorithm> #include <cassert> #include <vector> -#include <sstream> +#include <sstream> //std::basic_ostringstream #include "stl_tools.h" #include "string_traits.h" @@ -446,7 +446,11 @@ namespace impl template <class S, class T> struct CopyStringToString { - T copy(const S& src) const { return T(strBegin(src), strLength(src)); } + T copy(const S& src) const + { + static_assert(!std::is_same_v<std::decay_t<S>, std::decay_t<T>>); + return T(strBegin(src), strLength(src)); + } }; template <class T> diff --git a/zen/string_traits.h b/zen/string_traits.h index 8187126d..cd7dbf1b 100755 --- a/zen/string_traits.h +++ b/zen/string_traits.h @@ -41,10 +41,14 @@ class StringRef { public: template <class Iterator> - StringRef(Iterator first, Iterator last) : len_(last - first), str_(first != last ? &*first : nullptr) {} + StringRef(Iterator first, Iterator last) : len_(last - first), + str_(first != last ? &*first : reinterpret_cast<Char*>(this) /*Win32 APIs like CompareStringOrdinal() choke on nullptr!*/) + { + static_assert(alignof(StringRef) % alignof(Char) == 0); //even though str_ is never dereferenced, make sure the pointer value respects alignment (why? because we can) + } //StringRef(const Char* str, size_t len) : str_(str), len_(len) {} -> needless constraint! Char* not available for empty range! - Char* data () const { return str_; } //1. no null-termination! 2. may be nullptr! + Char* data () const { return str_; } //no null-termination! size_t length() const { return len_; } private: diff --git a/zen/thread.h b/zen/thread.h index ee36f305..5828d07a 100755 --- a/zen/thread.h +++ b/zen/thread.h @@ -119,7 +119,7 @@ class Protected { public: Protected() {} - Protected(const T& value) : value_(value) {} + Protected(T& value) : value_(value) {} //Protected( T&& tmp ) : value_(std::move(tmp)) {} <- wait until needed template <class Function> @@ -161,28 +161,46 @@ public: ThreadGroup& operator=(ThreadGroup&& tmp) noexcept { swap(tmp); return *this; } //noexcept *required* to support move for reallocations in std::vector and std::swap!!! - //context of controlling thread, non-blocking: - void run(Function&& wi) + //context of controlling OR worker thread, non-blocking: + void run(Function&& wi /*should throw ThreadInterruption when needed*/) { - size_t tasksPending = 0; { std::lock_guard<std::mutex> dummy(workLoad_->lock); + workLoad_->tasks.push_back(std::move(wi)); - tasksPending = ++(workLoad_->tasksPending); + const size_t tasksPending = ++(workLoad_->tasksPending); + + if (worker_.size() < std::min(tasksPending, threadCountMax_)) + addWorkerThread(); } workLoad_->conditionNewTask.notify_all(); - - if (worker_.size() < std::min(tasksPending, threadCountMax_)) - addWorkerThread(); } //context of controlling thread, blocking: void wait() { - std::unique_lock<std::mutex> dummy(workLoad_->lock); - workLoad_->conditionTasksDone.wait(dummy, [&tasksPending = workLoad_->tasksPending] { return tasksPending == 0; }); + //perf: no difference in xBRZ test case compared to std::condition_variable-based implementation + auto promiseDone = std::make_shared<std::promise<void>>(); // + std::future<void> allDone = promiseDone->get_future(); + + notifyWhenDone([promiseDone] { promiseDone->set_value(); }); //std::function doesn't support construction involving move-only types! + //use reference? => not guaranteed safe, e.g. promise object theoretically might be accessed inside set_value() after future gets signalled + + allDone.get(); + } + + //non-blocking wait()-alternative: context of controlling thread: + void notifyWhenDone(const std::function<void()>& onCompletion /*noexcept! runs on worker thread!*/) + { + std::lock_guard<std::mutex> dummy(workLoad_->lock); + + if (workLoad_->tasksPending == 0) + onCompletion(); + else + workLoad_->onCompletionCallbacks.push_back(onCompletion); } + //context of controlling thread: void detach() { detach_ = true; } //not expected to also interrupt! private: @@ -204,13 +222,21 @@ private: Function task = std::move(wl->tasks. front()); //noexcept thanks to move /**/ wl->tasks.pop_front(); // - dummy.unlock(); - - task(); + dummy.unlock(); + task(); //throw ThreadInterruption? dummy.lock(); + if (--(wl->tasksPending) == 0) - wl->conditionTasksDone.notify_all(); //too difficult to notify outside the lock + if (!wl->onCompletionCallbacks.empty()) + { + std::vector<std::function<void()>> callbacks; + callbacks.swap(wl->onCompletionCallbacks); + + dummy.unlock(); + for (const auto& cb : callbacks) cb(); //noexcept! + dummy.lock(); + } } }); } @@ -230,7 +256,7 @@ private: RingBuffer<Function> tasks; //FIFO! :) size_t tasksPending = 0; std::condition_variable conditionNewTask; - std::condition_variable conditionTasksDone; + std::vector<std::function<void()>> onCompletionCallbacks; }; std::vector<InterruptibleThread> worker_; diff --git a/zen/warn_static.h b/zen/warn_static.h index 6f0a2691..fb8fbb95 100755 --- a/zen/warn_static.h +++ b/zen/warn_static.h @@ -18,7 +18,7 @@ Usage: #if defined __GNUC__ //Clang also defines __GNUC__! #define warn_static(MSG) \ - _Pragma(ZEN_STATIC_WARNING_STRINGIZE(GCC warning MSG)) + _Pragma(ZEN_STATIC_WARNING_STRINGIZE(GCC warning MSG)) #endif #endif //WARN_STATIC_H_08724567834560832745 diff --git a/zen/zstring.h b/zen/zstring.h index cb19318c..026737da 100755 --- a/zen/zstring.h +++ b/zen/zstring.h @@ -18,7 +18,7 @@ //a high-performance string for interfacing with native OS APIs in multithreaded contexts using Zstring = zen::Zbase<Zchar>; - //for special UI-contexts: guaranteed exponential growth + ref-counting +//for special UI-contexts: guaranteed exponential growth + ref-counting using Zstringw = zen::Zbase<wchar_t>; @@ -65,8 +65,20 @@ Zstring appendSeparator(Zstring path) //support rvalue references! inline Zstring getFileExtension(const Zstring& filePath) { - const Zstring shortName = afterLast(filePath, FILE_NAME_SEPARATOR, zen::IF_MISSING_RETURN_ALL); - return afterLast(shortName, Zchar('.'), zen::IF_MISSING_RETURN_NONE); + //const Zstring fileName = afterLast(filePath, FILE_NAME_SEPARATOR, zen::IF_MISSING_RETURN_ALL); + //return afterLast(fileName, Zstr('.'), zen::IF_MISSING_RETURN_NONE); + + auto it = zen::find_last(filePath.begin(), filePath.end(), FILE_NAME_SEPARATOR); + if (it == filePath.end()) + it = filePath.begin(); + else + ++it; + + auto it2 = zen::find_last(it, filePath.end(), Zstr('.')); + if (it2 != filePath.end()) + ++it2; + + return Zstring(it2, filePath.end()); } |