From 63c7cb74cf1daf7bf4cc68d753e8908287704730 Mon Sep 17 00:00:00 2001 From: Alcaro Date: Fri, 23 Dec 2016 21:03:12 +0100 Subject: [PATCH] Update Arlib --- arlib/Makefile | 2 +- arlib/arlib.h | 2 +- arlib/array.h | 61 +++++++++++++++++++++++++----- arlib/crc32.cpp | 56 ++++++++++++++++++++++++--- arlib/file.h | 4 +- arlib/global.h | 4 +- arlib/{intsafe.cpp => safeint.cpp} | 12 +++--- arlib/{intsafe.h => safeint.h} | 58 ++++++++++++++-------------- arlib/thread/atomic.h | 4 +- 9 files changed, 145 insertions(+), 58 deletions(-) rename arlib/{intsafe.cpp => safeint.cpp} (76%) rename arlib/{intsafe.h => safeint.h} (80%) diff --git a/arlib/Makefile b/arlib/Makefile index a600055..64a4bff 100644 --- a/arlib/Makefile +++ b/arlib/Makefile @@ -227,7 +227,7 @@ ifeq ($(ARSOCKET),1) endif endif -SOURCES_ARLIB += arlib/deps/miniz.c +SOURCES_NOWARN += arlib/deps/miniz.c TRUE_CFLAGS = -std=c99 $(CCXXFLAGS) $(CFLAGS) $(CONF_CFLAGS) TRUE_CXXFLAGS =-std=c++11 -fno-rtti $(CCXXFLAGS) $(CXXFLAGS) $(CONF_CXXFLAGS) diff --git a/arlib/arlib.h b/arlib/arlib.h index 90dd3c9..649e8b8 100644 --- a/arlib/arlib.h +++ b/arlib/arlib.h @@ -17,9 +17,9 @@ #include "endian.h" #include "file.h" #include "function.h" -#include "intsafe.h" #include "intwrap.h" #include "os.h" +#include "safeint.h" #include "serialize.h" #include "string.h" #include "stringconv.h" diff --git a/arlib/array.h b/arlib/array.h index c1931e1..5b86e3d 100644 --- a/arlib/array.h +++ b/arlib/array.h @@ -2,8 +2,7 @@ #include "global.h" #include #include - -//as much fun as it is to optimize the hell out of random stuff, I want to get things done as well +#include //size: two pointers //this object does not own its storage, it's just a pointer wrapper @@ -149,11 +148,34 @@ template class array : public arrayvieww { //T * items; //size_t count; + //My requirements: + //- all fields initialized by the default constructor are initialized to 0 + //- all copy/move constructors are equivalent to memcpy() + //- there is no destructor + //I believe that is equivalent to (possibly slightly looser than) std::is_trivial. + //If true, constructor calls are replaced with memset. (Destructor is still called; it'll get optimized out anyways.) + static const bool trivial_cons = std::is_trivial::value; +#if __GNUC__ >= 5 + static const bool trivial_copy = std::is_trivially_copyable::value; +#else + static const bool trivial_copy = trivial_cons; +#endif + void clone(const arrayview& other) { - this->count = other.size(); // I can somehow not access non-this instances of my base class, so let's just use the public interface. + this->count = other.size(); // I can't access non-this instances of my base class, so let's just use the public interface. this->items = malloc(sizeof(T)*bitround(this->count)); - for (size_t i=0;icount;i++) new(&this->items[i]) T(other.ptr()[i]); + if (trivial_copy) + { + memcpy(this->items, other.ptr(), sizeof(T)*this->count); + } + else + { + for (size_t i=0;icount;i++) + { + new(&this->items[i]) T(other.ptr()[i]); + } + } } void swap(array& other) @@ -186,11 +208,19 @@ template class array : public arrayvieww { void resize_grow(size_t count) { + if (this->count >= count) return; size_t prevcount = this->count; resize_grow_noinit(count); - for (size_t i=prevcount;iitems[i]) T(); + memset(this->items+prevcount, 0, sizeof(T)*(count-prevcount)); + } + else + { + for (size_t i=prevcount;iitems[i]) T(); + } } } @@ -217,6 +247,11 @@ public: T& operator[](size_t n) { resize_grow(n+1); return this->items[n]; } void resize(size_t len) { resize_to(len); } + void resize_noinit(size_t len) + { + if (trivial_cons && len > this->size()) resize_grow_noinit(len); + else resize_to(len); + } void reserve(size_t len) { resize_grow(len); } void append(const T& item) { size_t pos = this->count; resize_grow(pos+1); this->items[pos] = item; } @@ -302,14 +337,22 @@ public: array& operator+=(arrayview other) { + //TODO: x+=x doesn't work size_t prevcount = this->count; - size_t othercount = other.size(); // in case this==other + size_t othercount = other.size(); resize_grow_noinit(prevcount + othercount); - for (size_t i=0;iitems[prevcount + i]) T(other[i]); + memcpy(this->items+prevcount, other.ptr(), sizeof(T)*othercount); + } + else + { + for (size_t i=0;iitems[prevcount + i]) T(other[i]); + } } return *this; diff --git a/arlib/crc32.cpp b/arlib/crc32.cpp index dcf3c0a..9dc032b 100644 --- a/arlib/crc32.cpp +++ b/arlib/crc32.cpp @@ -1,8 +1,38 @@ #include "crc32.h" -static const uint32_t crctable_4bits[]={ - 0x00000000, 0x1DB71064, 0x3B6E20C8, 0x26D930AC, 0x76DC4190, 0x6B6B51F4, 0x4DB26158, 0x5005713C, - 0xEDB88320, 0xF00F9344, 0xD6D6A3E8, 0xCB61B38C, 0x9B64C2B0, 0x86D3D2D4, 0xA00AE278, 0xBDBDF21C, +static const uint32_t crctable[256]={ + 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, }; uint32_t crc32_update(arrayview data, uint32_t crc) { @@ -11,8 +41,24 @@ uint32_t crc32_update(arrayview data, uint32_t crc) crc = ~crc; for (size_t i=0;i>4); - crc = crctable_4bits[(crc^(ptr[i]>>4))&0x0F] ^ (crc>>4); + crc = crctable[(crc & 0xFF) ^ ptr[i]] ^ (crc>>8); } return ~crc; } + +//static const uint32_t crctable_4bits[]={ +// 0x00000000, 0x1DB71064, 0x3B6E20C8, 0x26D930AC, 0x76DC4190, 0x6B6B51F4, 0x4DB26158, 0x5005713C, +// 0xEDB88320, 0xF00F9344, 0xD6D6A3E8, 0xCB61B38C, 0x9B64C2B0, 0x86D3D2D4, 0xA00AE278, 0xBDBDF21C, +//}; +//uint32_t crc32_update(arrayview data, uint32_t crc) +//{ +// const uint8_t* ptr = data.ptr(); +// size_t len = data.size(); +// crc = ~crc; +// for (size_t i=0;i>4); +// crc = crctable_4bits[(crc^(ptr[i]>>4))&0x0F] ^ (crc>>4); +// } +// return ~crc; +//} diff --git a/arlib/file.h b/arlib/file.h index ac57c7f..a474aaa 100644 --- a/arlib/file.h +++ b/arlib/file.h @@ -85,9 +85,9 @@ public: array read() const { array ret; - ret.resize(this->size()); + ret.resize_noinit(this->size()); size_t actual = this->read(ret, 0); - ret.resize(actual); + ret.resize_noinit(actual); return ret; } static array read(cstring path) diff --git a/arlib/global.h b/arlib/global.h index de6b585..ab4ea0b 100644 --- a/arlib/global.h +++ b/arlib/global.h @@ -64,15 +64,13 @@ typedef void(*funcptr)(); #define STR_(x) #x #define STR(x) STR_(x) -#define GCC_VER(ma,mi,pa) (ma*10000 + mi*100 + pa) #ifdef __GNUC__ -#define GCC_VERSION GCC_VER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) #define LIKELY(expr) __builtin_expect(!!(expr), true) #define UNLIKELY(expr) __builtin_expect(!!(expr), false) #else -#define GCC_VERSION 0 #define LIKELY(expr) (expr) #define UNLIKELY(expr) (expr) +#define __GNUC__ 0 #endif //some magic stolen from http://blogs.msdn.com/b/the1/archive/2004/05/07/128242.aspx diff --git a/arlib/intsafe.cpp b/arlib/safeint.cpp similarity index 76% rename from arlib/intsafe.cpp rename to arlib/safeint.cpp index 26bc1f0..e81b029 100644 --- a/arlib/intsafe.cpp +++ b/arlib/safeint.cpp @@ -1,5 +1,5 @@ -#define INTSAFE_SELFTEST -#include "intsafe.h" +#define safeint_SELFTEST +#include "safeint.h" #include "test.h" #if 0 // apparently running 65536 iterations of anything under Valgrind takes a while @@ -9,12 +9,12 @@ { \ int au = (t)a; \ int bu = (t)b; \ - intsafe as = au; \ - intsafe bs = bu; \ + safeint as = au; \ + safeint bs = bu; \ if (as.valid() && bs.valid()) \ { \ - intsafe cs1 = (1 op 8 == 256/*if op == <<*/ && b>7 ? 999 : au op bu); \ - intsafe cs2 = as op bs; \ + safeint cs1 = (1 op 8 == 256/*if op == <<*/ && b>7 ? 999 : au op bu); \ + safeint cs2 = as op bs; \ if (cs1.val() != cs2.val()) \ { \ assert_msg(false, tostring(au)+#op+tostring(bu)+": expected "+tostring(cs1.val())+", got "+tostring(cs2.val())); \ diff --git a/arlib/intsafe.h b/arlib/safeint.h similarity index 80% rename from arlib/intsafe.h rename to arlib/safeint.h index 8950619..19d2286 100644 --- a/arlib/intsafe.h +++ b/arlib/safeint.h @@ -7,7 +7,7 @@ //Overflow-safe integer class. //If an operation would overflow, it gets a special sentinel value instead, and all further operations return that. -template class intsafe { +template class safeint { T data; #define HANDLE_BASE(stype, utype) \ @@ -64,7 +64,7 @@ template class intsafe { HANDLE_BASE(signed long, unsigned long) HANDLE_BASE(signed long long, unsigned long long) -#ifndef INTSAFE_SELFTEST +#ifndef safeint_SELFTEST #define HANDLE_EXT(name, op, type, ext) \ static inline bool name(type a, type b, type* c) \ { \ @@ -98,7 +98,7 @@ HANDLE_EXT(lslov,<<, unsigned char, unsigned int) #undef HANDLE_BASE -#if GCC_VERSION>=50000 && !defined(INTSAFE_SELFTEST) +#if __GNUC__>=5 #define addov __builtin_add_overflow #define subov __builtin_sub_overflow #define mulov __builtin_mul_overflow @@ -109,115 +109,115 @@ public: //static const T min = T(-1)<0 ? invalid+1 : 0; //static const T max = T(-1)<0 ? -min : T(-2); - intsafe() : data(0) {} - template intsafe(U val) { if (T(val)==val) data=val; else data=invalid; } + safeint() : data(0) {} + template safeint(U val) { if (T(val)==val) data=val; else data=invalid; } bool valid() { return data!=invalid; } T val() { return data; } - intsafe& operator=(intsafe i) { data=i.val(); return *this; } + safeint& operator=(safeint i) { data=i.val(); return *this; } - intsafe operator++(int) { intsafe r = *this; *this+=1; return r; } - intsafe operator--(int) { intsafe r = *this; *this-=1; return r; } - intsafe& operator++() { *this+=1; return *this; } - intsafe& operator--() { *this+=1; return *this; } + safeint operator++(int) { safeint r = *this; *this+=1; return r; } + safeint operator--(int) { safeint r = *this; *this-=1; return r; } + safeint& operator++() { *this+=1; return *this; } + safeint& operator--() { *this+=1; return *this; } #define OP(op, ope) \ - intsafe& operator ope(intsafe i) { *this = *this op i; return *this; } + safeint& operator ope(safeint i) { *this = *this op i; return *this; } ALLOPER(OP) #undef OP - intsafe operator+(intsafe b) + safeint operator+(safeint b) { if (!valid() || !b.valid()) return invalid; T ret; if (addov(val(), b.val(), &ret)) return invalid; else return ret; } - intsafe operator-(intsafe b) + safeint operator-(safeint b) { if (!valid() || !b.valid()) return invalid; T ret; if (subov(val(), b.val(), &ret)) return invalid; else return ret; } - intsafe operator*(intsafe b) + safeint operator*(safeint b) { if (!valid() || !b.valid()) return invalid; T ret; if (mulov(val(), b.val(), &ret)) return invalid; else return ret; } - intsafe operator/(intsafe b) + safeint operator/(safeint b) { if (!valid() || !b.valid()) return invalid; //overflows in division throw SIGFPE rather than truncating return val()/b.val(); } - intsafe operator%(intsafe b) + safeint operator%(safeint b) { if (!valid() || !b.valid()) return invalid; //like division, overflow doesn't truncate return val()%b.val(); } - intsafe operator&(intsafe b) + safeint operator&(safeint b) { if (!valid() || !b.valid()) return invalid; //can't overflow return val()&b.val(); } - intsafe operator|(intsafe b) + safeint operator|(safeint b) { if (!valid() || !b.valid()) return invalid; //can't overflow (okay, it can become ::invalid, but that's fine) return val()|b.val(); } - intsafe operator^(intsafe b) + safeint operator^(safeint b) { if (!valid() || !b.valid()) return invalid; //can't overflow return val()^b.val(); } - intsafe operator<<(intsafe b) + safeint operator<<(safeint b) { if (!valid() || !b.valid()) return invalid; T ret; if (lslov(val(), b.val(), &ret)) return invalid; else return ret; } - intsafe operator>>(intsafe b) + safeint operator>>(safeint b) { if (!valid() || !b.valid()) return invalid; //can't overflow return val()>>b.val(); } - bool operator==(intsafe b) + bool operator==(safeint b) { if (!valid() || !b.valid()) return false; return val()==b.val(); } - bool operator!=(intsafe b) + bool operator!=(safeint b) { if (!valid() || !b.valid()) return true; // match NaN return val()!=b.val(); } - bool operator<(intsafe b) + bool operator<(safeint b) { if (!valid() || !b.valid()) return false; return val() b) + bool operator<=(safeint b) { if (!valid() || !b.valid()) return false; return val()<=b.val(); } - bool operator>(intsafe b) + bool operator>(safeint b) { if (!valid() || !b.valid()) return false; return val()>b.val(); } - bool operator>=(intsafe b) + bool operator>=(safeint b) { if (!valid() || !b.valid()) return false; return val()>=b.val(); @@ -225,8 +225,8 @@ ALLOPER(OP) }; #define OP(op, ope) \ - template intsafe operator op(T a, intsafe b) { return intsafe(a) op b; } \ - template intsafe operator op(intsafe a, T b) { return b op intsafe(a); } + template safeint operator op(U a, safeint b) { return safeint(a) op b; } \ + template safeint operator op(safeint a, U b) { return b op safeint(a); } ALLOPER(OP) OP(==, _) OP(!=, _) diff --git a/arlib/thread/atomic.h b/arlib/thread/atomic.h index f01dd98..60aa733 100644 --- a/arlib/thread/atomic.h +++ b/arlib/thread/atomic.h @@ -13,8 +13,8 @@ //All of these functions (except store) return the value before the operation. //(cmp)xchg obviously does, so to ease memorization, the others do too. -#if GCC_VERSION > 0 -#if GCC_VERSION >= 40700 +#if __GNUC__ > 0 +#if __GNUC__*10+__GNUC_MINOR__ >= 47 //https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/_005f_005fatomic-Builtins.html #define LOCKD_LOCKS_MODEL(type, model, modelname) \ inline type lock_incr ## modelname(type * val) { return __atomic_fetch_add(val, 1, model); } \