[sync] 1.5

Author: kindy

cvs-vers

@@ -1,15 +1,15 @@
-Changes:1.54
+Changes:1.55
 LICENSE:1.1
 Makefile.am:1.4
 aclocal.m4:1.3
 autogen.sh:1.4
 configure.ac:1.10
 demo.c:1.4
-ecb.h:1.26
+ecb.h:1.27
 eio.3:1.1
-eio.c:1.139
-eio.h:1.56
-eio.pod:1.35
+eio.c:1.141
+eio.h:1.57
+eio.pod:1.36
 etp.c:1.1
 libeio.m4:1.23
 xthread.h:1.18

src/Changes

@@ -75,5 +75,6 @@ TODO: maybe work around 3.996gb barrier in pread/pwrite as well, maybe readahead
  (cygwin) provides them for a while now.
  - provide pread/pwrite implementations for win32.
  - implement aio_realpath for windows.
- - add EIO_FALLOC_FL_COLLAPSE_RANGE anbd EIO_FALLOC_FL_ZERO_RANGE.
+ - add EIO_FALLOC_FL_COLLAPSE_RANGE and EIO_FALLOC_FL_ZERO_RANGE.
+ - add EIO_FCNTL, EIO_IOCTL.
 

src/ecb.h

@@ -42,7 +42,7 @@
 #define ECB_H
 
 /* 16 bits major, 16 bits minor */
-#define ECB_VERSION 0x00010004
+#define ECB_VERSION 0x00010005
 
 #ifdef _WIN32
  typedef signed char int8_t;
@@ -69,7 +69,7 @@
  #endif
 #else
  #include <inttypes.h>
- #if UINTMAX_MAX > 0xffffffffU
+ #if (defined INTPTR_MAX ? INTPTR_MAX : ULONG_MAX) > 0xffffffffU
  #define ECB_PTRSIZE 8
  #else
  #define ECB_PTRSIZE 4
@@ -157,6 +157,10 @@
  #include <builtins.h>
 #endif
 
+#if 1400 <= _MSC_VER
+ #include <intrin.h> /* fence functions _ReadBarrier, also bit search functions _BitScanReverse */
+#endif
+
 #ifndef ECB_MEMORY_FENCE
  #if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
  #if __i386 || __i386__
@@ -169,11 +173,19 @@
  #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
  #elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__
  #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
+ #elif defined __ARM_ARCH_2__ \
+ || defined __ARM_ARCH_3__ || defined __ARM_ARCH_3M__ \
+ || defined __ARM_ARCH_4__ || defined __ARM_ARCH_4T__ \
+ || defined __ARM_ARCH_5__ || defined __ARM_ARCH_5E__ \
+ || defined __ARM_ARCH_5T__ || defined __ARM_ARCH_5TE__ \
+ || defined __ARM_ARCH_5TEJ__
+ /* should not need any, unless running old code on newer cpu - arm doesn't support that */
  #elif defined __ARM_ARCH_6__ || defined __ARM_ARCH_6J__ \
- || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__
+ || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__ \
+ || defined __ARM_ARCH_6T2__
  #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")
  #elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \
- || defined __ARM_ARCH_7M__ || defined __ARM_ARCH_7R__
+ || defined __ARM_ARCH_7R__ || defined __ARM_ARCH_7M__
  #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")
  #elif __aarch64__
  #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb ish" : : : "memory")
@@ -425,6 +437,11 @@ typedef int ecb_bool;
  ecb_function_ ecb_const int
  ecb_ctz32 (uint32_t x)
  {
+#if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
+ unsigned long r;
+ _BitScanForward (&r, x);
+ return (int)r;
+#else
  int r = 0;
 
  x &= ~x + 1; /* this isolates the lowest bit */
@@ -444,14 +461,21 @@ typedef int ecb_bool;
 #endif
 
  return r;
+#endif
  }
 
  ecb_function_ ecb_const int ecb_ctz64 (uint64_t x);
  ecb_function_ ecb_const int
  ecb_ctz64 (uint64_t x)
  {
- int shift = x & 0xffffffffU ? 0 : 32;
+#if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
+ unsigned long r;
+ _BitScanForward64 (&r, x);
+ return (int)r;
+#else
+ int shift = x & 0xffffffff ? 0 : 32;
  return ecb_ctz32 (x >> shift) + shift;
+#endif
  }
 
  ecb_function_ ecb_const int ecb_popcount32 (uint32_t x);
@@ -469,6 +493,11 @@ typedef int ecb_bool;
  ecb_function_ ecb_const int ecb_ld32 (uint32_t x);
  ecb_function_ ecb_const int ecb_ld32 (uint32_t x)
  {
+#if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
+ unsigned long r;
+ _BitScanReverse (&r, x);
+ return (int)r;
+#else
  int r = 0;
 
  if (x >> 16) { x >>= 16; r += 16; }
@@ -478,16 +507,23 @@ typedef int ecb_bool;
  if (x >> 1) { r += 1; }
 
  return r;
+#endif
  }
 
  ecb_function_ ecb_const int ecb_ld64 (uint64_t x);
  ecb_function_ ecb_const int ecb_ld64 (uint64_t x)
  {
+#if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
+ unsigned long r;
+ _BitScanReverse64 (&r, x);
+ return (int)r;
+#else
  int r = 0;
 
  if (x >> 32) { x >>= 32; r += 32; }
 
  return r + ecb_ld32 (x);
+#endif
  }
 #endif
 
@@ -600,8 +636,8 @@ ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { retu
 /* try to tell the compiler that some condition is definitely true */
 #define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
 
-ecb_inline ecb_const unsigned char ecb_byteorder_helper (void);
-ecb_inline ecb_const unsigned char
+ecb_inline ecb_const uint32_t ecb_byteorder_helper (void);
+ecb_inline ecb_const uint32_t
 ecb_byteorder_helper (void)
 {
  /* the union code still generates code under pressure in gcc, */
@@ -610,26 +646,28 @@ ecb_byteorder_helper (void)
  /* the reason why we have this horrible preprocessor mess */
  /* is to avoid it in all cases, at least on common architectures */
  /* or when using a recent enough gcc version (>= 4.6) */
-#if ((__i386 || __i386__) && !__VOS__) || _M_IX86 || ECB_GCC_AMD64 || ECB_MSVC_AMD64
- return 0x44;
-#elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
- return 0x44;
-#elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
- return 0x11;
+#if (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) \
+ || ((__i386 || __i386__ || _M_IX86 || ECB_GCC_AMD64 || ECB_MSVC_AMD64) && !__VOS__)
+ #define ECB_LITTLE_ENDIAN 1
+ return 0x44332211;
+#elif (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) \
+ || ((__AARCH64EB__ || __MIPSEB__ || __ARMEB__) && !__VOS__)
+ #define ECB_BIG_ENDIAN 1
+ return 0x11223344;
 #else
  union
  {
- uint32_t i;
- uint8_t c;
- } u = { 0x11223344 };
- return u.c;
+ uint8_t c[4];
+ uint32_t u;
+ } u = { 0x11, 0x22, 0x33, 0x44 };
+ return u.u;
 #endif
 }
 
 ecb_inline ecb_const ecb_bool ecb_big_endian (void);
-ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }
+ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11223344; }
 ecb_inline ecb_const ecb_bool ecb_little_endian (void);
-ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; }
+ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44332211; }
 
 #if ECB_GCC_VERSION(3,0) || ECB_C99
  #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
@@ -664,6 +702,102 @@ ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_he
  #define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
 #endif
 
+ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);
+ecb_function_ ecb_const uint32_t
+ecb_binary16_to_binary32 (uint32_t x)
+{
+ unsigned int s = (x & 0x8000) << (31 - 15);
+ int e = (x >> 10) & 0x001f;
+ unsigned int m = x & 0x03ff;
+
+ if (ecb_expect_false (e == 31))
+ /* infinity or NaN */
+ e = 255 - (127 - 15);
+ else if (ecb_expect_false (!e))
+ {
+ if (ecb_expect_true (!m))
+ /* zero, handled by code below by forcing e to 0 */
+ e = 0 - (127 - 15);
+ else
+ {
+ /* subnormal, renormalise */
+ unsigned int s = 10 - ecb_ld32 (m);
+
+ m = (m << s) & 0x3ff; /* mask implicit bit */
+ e -= s - 1;
+ }
+ }
+
+ /* e and m now are normalised, or zero, (or inf or nan) */
+ e += 127 - 15;
+
+ return s | (e << 23) | (m << (23 - 10));
+}
+
+ecb_function_ ecb_const uint16_t ecb_binary32_to_binary16 (uint32_t x);
+ecb_function_ ecb_const uint16_t
+ecb_binary32_to_binary16 (uint32_t x)
+{
+ unsigned int s = (x >> 16) & 0x00008000; /* sign bit, the easy part */
+ unsigned int e = ((x >> 23) & 0x000000ff) - (127 - 15); /* the desired exponent */
+ unsigned int m = x & 0x007fffff;
+
+ x &= 0x7fffffff;
+
+ /* if it's within range of binary16 normals, use fast path */
+ if (ecb_expect_true (0x38800000 <= x && x <= 0x477fefff))
+ {
+ /* mantissa round-to-even */
+ m += 0x00000fff + ((m >> (23 - 10)) & 1);
+
+ /* handle overflow */
+ if (ecb_expect_false (m >= 0x00800000))
+ {
+ m >>= 1;
+ e += 1;
+ }
+
+ return s | (e << 10) | (m >> (23 - 10));
+ }
+
+ /* handle large numbers and infinity */
+ if (ecb_expect_true (0x477fefff < x && x <= 0x7f800000))
+ return s | 0x7c00;
+
+ /* handle zero, subnormals and small numbers */
+ if (ecb_expect_true (x < 0x38800000))
+ {
+ /* zero */
+ if (ecb_expect_true (!x))
+ return s;
+
+ /* handle subnormals */
+
+ /* too small, will be zero */
+ if (e < (14 - 24)) /* might not be sharp, but is good enough */
+ return s;
+
+ m |= 0x00800000; /* make implicit bit explicit */
+
+ /* very tricky - we need to round to the nearest e (+10) bit value */
+ {
+ unsigned int bits = 14 - e;
+ unsigned int half = (1 << (bits - 1)) - 1;
+ unsigned int even = (m >> bits) & 1;
+
+ /* if this overflows, we will end up with a normalised number */
+ m = (m + half + even) >> bits;
+ }
+
+ return s | m;
+ }
+
+ /* handle NaNs, preserve leftmost nan bits, but make sure we don't turn them into infinities */
+ m >>= 13;
+
+ return s | 0x7c00 | m | !m;
+}
+
 /*******************************************************************************/
 /* floating point stuff, can be disabled by defining ECB_NO_LIBM */
 
@@ -715,23 +849,6 @@ ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_he
  #define ecb_frexpf(x,e) (float) frexp ((double) (x), (e))
  #endif
 
- /* converts an ieee half/binary16 to a float */
- ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x);
- ecb_function_ ecb_const float
- ecb_binary16_to_float (uint16_t x)
- {
- int e = (x >> 10) & 0x1f;
- int m = x & 0x3ff;
- float r;
-
- if (!e ) r = ecb_ldexpf (m , -24);
- else if (e != 31) r = ecb_ldexpf (m + 0x400, e - 25);
- else if (m ) r = ECB_NAN;
- else r = ECB_INFINITY;
-
- return x & 0x8000 ? -r : r;
- }
-
  /* convert a float to ieee single/binary32 */
  ecb_function_ ecb_const uint32_t ecb_float_to_binary32 (float x);
  ecb_function_ ecb_const uint32_t
@@ -872,6 +989,22 @@ ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_he
  return r;
  }
 
+ /* convert a float to ieee half/binary16 */
+ ecb_function_ ecb_const uint16_t ecb_float_to_binary16 (float x);
+ ecb_function_ ecb_const uint16_t
+ ecb_float_to_binary16 (float x)
+ {
+ return ecb_binary32_to_binary16 (ecb_float_to_binary32 (x));
+ }
+
+ /* convert an ieee half/binary16 to float */
+ ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x);
+ ecb_function_ ecb_const float
+ ecb_binary16_to_float (uint16_t x)
+ {
+ return ecb_binary32_to_float (ecb_binary16_to_binary32 (x));
+ }
+
 #endif
 
 #endif

src/eio.c

@@ -1,7 +1,7 @@
 /*
  * libeio implementation
  *
- * Copyright (c) 2007,2008,2009,2010,2011,2012,2013 Marc Alexander Lehmann <libeio@schmorp.de>
+ * Copyright (c) 2007,2008,2009,2010,2011,2012,2013,2016 Marc Alexander Lehmann <libeio@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
@@ -124,6 +124,8 @@ static void eio_destroy (eio_req *req);
  #define dup2(fd1,fd2) _dup2 (fd1, fd2)
  #define pipe(fds) _pipe (fds, 4096, O_BINARY)
 
+ #define fcntl(fd,cmd,arg) EIO_ENOSYS ()
+ #define ioctl(fd,cmd,arg) EIO_ENOSYS ()
  #define fchmod(fd,mode) EIO_ENOSYS ()
  #define chown(path,uid,gid) EIO_ENOSYS ()
  #define fchown(fd,uid,gid) EIO_ENOSYS ()
@@ -1818,6 +1820,9 @@ eio_execute (etp_worker *self, eio_req *req)
  ? pwrite (req->int1, req->ptr2, req->size, req->offs)
  : write (req->int1, req->ptr2, req->size); break;
 
+ case EIO_FCNTL: req->result = fcntl (req->int1, (int) req->int2, req->ptr2); break;
+ case EIO_IOCTL: req->result = ioctl (req->int1, (unsigned long)req->int2, req->ptr2); break;
+
  case EIO_READAHEAD: req->result = readahead (req->int1, req->offs, req->size); break;
  case EIO_SENDFILE: req->result = eio__sendfile (req->int1, req->int2, req->offs, req->size); break;
 
@@ -2087,6 +2092,16 @@ eio_req *eio_write (int fd, void *buf, size_t length, off_t offset, int pri, eio
  REQ (EIO_WRITE); req->int1 = fd; req->offs = offset; req->size = length; req->ptr2 = buf; SEND;
 }
 
+eio_req *eio_fcntl (int fd, int cmd, void *arg, int pri, eio_cb cb, void *data)
+{
+ REQ (EIO_IOCTL); req->int1 = fd; req->int2 = cmd; req->ptr2 = arg; SEND;
+}
+
+eio_req *eio_ioctl (int fd, unsigned long request, void *buf, int pri, eio_cb cb, void *data)
+{
+ REQ (EIO_IOCTL); req->int1 = fd; req->int2 = request; req->ptr2 = buf; SEND;
+}
+
 eio_req *eio_fstat (int fd, int pri, eio_cb cb, void *data)
 {
  REQ (EIO_FSTAT); req->int1 = fd; SEND;