ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.c
(Generate patch)

Comparing libev/ev.c (file contents):
Revision 1.476 by root, Fri May 1 17:23:34 2015 UTC vs.
Revision 1.480 by root, Thu Feb 18 04:48:05 2016 UTC

… …
532 532
533#ifndef ECB_H 533#ifndef ECB_H
534#define ECB_H 534#define ECB_H
535 535
536/* 16 bits major, 16 bits minor */ 536/* 16 bits major, 16 bits minor */
537#define ECB_VERSION 0x00010004 537#define ECB_VERSION 0x00010005
538 538
539#ifdef _WIN32 539#ifdef _WIN32
540 typedef signed char int8_t; 540 typedef signed char int8_t;
541 typedef unsigned char uint8_t; 541 typedef unsigned char uint8_t;
542 typedef signed short int16_t; 542 typedef signed short int16_t;
… …
559 typedef uint32_t uintptr_t; 559 typedef uint32_t uintptr_t;
560 typedef int32_t intptr_t; 560 typedef int32_t intptr_t;
561 #endif 561 #endif
562#else 562#else
563 #include <inttypes.h> 563 #include <inttypes.h>
564 #if UINTMAX_MAX > 0xffffffffU 564 #if (defined INTPTR_MAX ? INTPTR_MAX : ULONG_MAX) > 0xffffffffU
565 #define ECB_PTRSIZE 8 565 #define ECB_PTRSIZE 8
566 #else 566 #else
567 #define ECB_PTRSIZE 4 567 #define ECB_PTRSIZE 4
568 #endif 568 #endif
569#endif 569#endif
… …
645#endif 645#endif
646 646
647/* http://www-01.ibm.com/support/knowledgecenter/SSGH3R_13.1.0/com.ibm.xlcpp131.aix.doc/compiler_ref/compiler_builtins.html */ 647/* http://www-01.ibm.com/support/knowledgecenter/SSGH3R_13.1.0/com.ibm.xlcpp131.aix.doc/compiler_ref/compiler_builtins.html */
648#if __xlC__ && ECB_CPP 648#if __xlC__ && ECB_CPP
649 #include <builtins.h> 649 #include <builtins.h>
650#endif
651
652#if 1400 <= _MSC_VER
653 #include <intrin.h> /* fence functions _ReadBarrier, also bit search functions _BitScanReverse */
650#endif 654#endif
651 655
652#ifndef ECB_MEMORY_FENCE 656#ifndef ECB_MEMORY_FENCE
653 #if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110 657 #if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
654 #if __i386 || __i386__ 658 #if __i386 || __i386__
… …
659 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory") 663 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")
660 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory") 664 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
661 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("") 665 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
662 #elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__ 666 #elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__
663 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory") 667 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
668 #elif defined __ARM_ARCH_2__ \
669 || defined __ARM_ARCH_3__ || defined __ARM_ARCH_3M__ \
670 || defined __ARM_ARCH_4__ || defined __ARM_ARCH_4T__ \
671 || defined __ARM_ARCH_5__ || defined __ARM_ARCH_5E__ \
672 || defined __ARM_ARCH_5T__ || defined __ARM_ARCH_5TE__ \
673 || defined __ARM_ARCH_5TEJ__
674 /* should not need any, unless running old code on newer cpu - arm doesn't support that */
664 #elif defined __ARM_ARCH_6__ || defined __ARM_ARCH_6J__ \ 675 #elif defined __ARM_ARCH_6__ || defined __ARM_ARCH_6J__ \
665 || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__ 676 || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__ \
677 || defined __ARM_ARCH_6T2__
666 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory") 678 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")
667 #elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \ 679 #elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \
668 || defined __ARM_ARCH_7M__ || defined __ARM_ARCH_7R__ 680 || defined __ARM_ARCH_7R__ || defined __ARM_ARCH_7M__
669 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory") 681 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")
670 #elif __aarch64__ 682 #elif __aarch64__
671 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb ish" : : : "memory") 683 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb ish" : : : "memory")
672 #elif (__sparc || __sparc__) && !__sparcv8 684 #elif (__sparc || __sparc__) && !(__sparc_v8__ || defined __sparcv8)
673 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory") 685 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory")
674 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory") 686 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory")
675 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore") 687 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore")
676 #elif defined __s390__ || defined __s390x__ 688 #elif defined __s390__ || defined __s390x__
677 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory") 689 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")
… …
915#else 927#else
916 ecb_function_ ecb_const int ecb_ctz32 (uint32_t x); 928 ecb_function_ ecb_const int ecb_ctz32 (uint32_t x);
917 ecb_function_ ecb_const int 929 ecb_function_ ecb_const int
918 ecb_ctz32 (uint32_t x) 930 ecb_ctz32 (uint32_t x)
919 { 931 {
932#if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
933 unsigned long r;
934 _BitScanForward (&r, x);
935 return (int)r;
936#else
920 int r = 0; 937 int r = 0;
921 938
922 x &= ~x + 1; /* this isolates the lowest bit */ 939 x &= ~x + 1; /* this isolates the lowest bit */
923 940
924#if ECB_branchless_on_i386 941#if ECB_branchless_on_i386
… …
934 if (x & 0xff00ff00) r += 8; 951 if (x & 0xff00ff00) r += 8;
935 if (x & 0xffff0000) r += 16; 952 if (x & 0xffff0000) r += 16;
936#endif 953#endif
937 954
938 return r; 955 return r;
956#endif
939 } 957 }
940 958
941 ecb_function_ ecb_const int ecb_ctz64 (uint64_t x); 959 ecb_function_ ecb_const int ecb_ctz64 (uint64_t x);
942 ecb_function_ ecb_const int 960 ecb_function_ ecb_const int
943 ecb_ctz64 (uint64_t x) 961 ecb_ctz64 (uint64_t x)
944 { 962 {
963#if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
964 unsigned long r;
965 _BitScanForward64 (&r, x);
966 return (int)r;
967#else
945 int shift = x & 0xffffffffU ? 0 : 32; 968 int shift = x & 0xffffffff ? 0 : 32;
946 return ecb_ctz32 (x >> shift) + shift; 969 return ecb_ctz32 (x >> shift) + shift;
970#endif
947 } 971 }
948 972
949 ecb_function_ ecb_const int ecb_popcount32 (uint32_t x); 973 ecb_function_ ecb_const int ecb_popcount32 (uint32_t x);
950 ecb_function_ ecb_const int 974 ecb_function_ ecb_const int
951 ecb_popcount32 (uint32_t x) 975 ecb_popcount32 (uint32_t x)
… …
959 } 983 }
960 984
961 ecb_function_ ecb_const int ecb_ld32 (uint32_t x); 985 ecb_function_ ecb_const int ecb_ld32 (uint32_t x);
962 ecb_function_ ecb_const int ecb_ld32 (uint32_t x) 986 ecb_function_ ecb_const int ecb_ld32 (uint32_t x)
963 { 987 {
988#if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
989 unsigned long r;
990 _BitScanReverse (&r, x);
991 return (int)r;
992#else
964 int r = 0; 993 int r = 0;
965 994
966 if (x >> 16) { x >>= 16; r += 16; } 995 if (x >> 16) { x >>= 16; r += 16; }
967 if (x >> 8) { x >>= 8; r += 8; } 996 if (x >> 8) { x >>= 8; r += 8; }
968 if (x >> 4) { x >>= 4; r += 4; } 997 if (x >> 4) { x >>= 4; r += 4; }
969 if (x >> 2) { x >>= 2; r += 2; } 998 if (x >> 2) { x >>= 2; r += 2; }
970 if (x >> 1) { r += 1; } 999 if (x >> 1) { r += 1; }
971 1000
972 return r; 1001 return r;
1002#endif
973 } 1003 }
974 1004
975 ecb_function_ ecb_const int ecb_ld64 (uint64_t x); 1005 ecb_function_ ecb_const int ecb_ld64 (uint64_t x);
976 ecb_function_ ecb_const int ecb_ld64 (uint64_t x) 1006 ecb_function_ ecb_const int ecb_ld64 (uint64_t x)
977 { 1007 {
1008#if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
1009 unsigned long r;
1010 _BitScanReverse64 (&r, x);
1011 return (int)r;
1012#else
978 int r = 0; 1013 int r = 0;
979 1014
980 if (x >> 32) { x >>= 32; r += 32; } 1015 if (x >> 32) { x >>= 32; r += 32; }
981 1016
982 return r + ecb_ld32 (x); 1017 return r + ecb_ld32 (x);
1018#endif
983 } 1019 }
984#endif 1020#endif
985 1021
986ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x); 1022ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x);
987ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); } 1023ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); }
… …
1090#endif 1126#endif
1091 1127
1092/* try to tell the compiler that some condition is definitely true */ 1128/* try to tell the compiler that some condition is definitely true */
1093#define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0 1129#define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
1094 1130
1095ecb_inline ecb_const unsigned char ecb_byteorder_helper (void); 1131ecb_inline ecb_const uint32_t ecb_byteorder_helper (void);
1096ecb_inline ecb_const unsigned char 1132ecb_inline ecb_const uint32_t
1097ecb_byteorder_helper (void) 1133ecb_byteorder_helper (void)
1098{ 1134{
1099 /* the union code still generates code under pressure in gcc, */ 1135 /* the union code still generates code under pressure in gcc, */
1100 /* but less than using pointers, and always seems to */ 1136 /* but less than using pointers, and always seems to */
1101 /* successfully return a constant. */ 1137 /* successfully return a constant. */
1102 /* the reason why we have this horrible preprocessor mess */ 1138 /* the reason why we have this horrible preprocessor mess */
1103 /* is to avoid it in all cases, at least on common architectures */ 1139 /* is to avoid it in all cases, at least on common architectures */
1104 /* or when using a recent enough gcc version (>= 4.6) */ 1140 /* or when using a recent enough gcc version (>= 4.6) */
1105#if ((__i386 || __i386__) && !__VOS__) || _M_IX86 || ECB_GCC_AMD64 || ECB_MSVC_AMD64
1106 return 0x44;
1107#elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 1141#if (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) \
1142 || ((__i386 || __i386__ || _M_IX86 || ECB_GCC_AMD64 || ECB_MSVC_AMD64) && !__VOS__)
1143 #define ECB_LITTLE_ENDIAN 1
1108 return 0x44; 1144 return 0x44332211;
1109#elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ 1145#elif (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) \
1146 || ((__AARCH64EB__ || __MIPSEB__ || __ARMEB__) && !__VOS__)
1147 #define ECB_BIG_ENDIAN 1
1110 return 0x11; 1148 return 0x11223344;
1111#else 1149#else
1112 union 1150 union
1113 { 1151 {
1152 uint8_t c[4];
1114 uint32_t i; 1153 uint32_t u;
1115 uint8_t c;
1116 } u = { 0x11223344 }; 1154 } u = { 0x11, 0x22, 0x33, 0x44 };
1117 return u.c; 1155 return u.u;
1118#endif 1156#endif
1119} 1157}
1120 1158
1121ecb_inline ecb_const ecb_bool ecb_big_endian (void); 1159ecb_inline ecb_const ecb_bool ecb_big_endian (void);
1122ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; } 1160ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11223344; }
1123ecb_inline ecb_const ecb_bool ecb_little_endian (void); 1161ecb_inline ecb_const ecb_bool ecb_little_endian (void);
1124ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; } 1162ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44332211; }
1125 1163
1126#if ECB_GCC_VERSION(3,0) || ECB_C99 1164#if ECB_GCC_VERSION(3,0) || ECB_C99
1127 #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0)) 1165 #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
1128#else 1166#else
1129 #define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n))) 1167 #define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
… …
1153 return N; 1191 return N;
1154 } 1192 }
1155#else 1193#else
1156 #define ecb_array_length(name) (sizeof (name) / sizeof (name [0])) 1194 #define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
1157#endif 1195#endif
1196
1197ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);
1198ecb_function_ ecb_const uint32_t
1199ecb_binary16_to_binary32 (uint32_t x)
1200{
1201 unsigned int s = (x & 0x8000) << (31 - 15);
1202 int e = (x >> 10) & 0x001f;
1203 unsigned int m = x & 0x03ff;
1204
1205 if (ecb_expect_false (e == 31))
1206 /* infinity or NaN */
1207 e = 255 - (127 - 15);
1208 else if (ecb_expect_false (!e))
1209 {
1210 if (ecb_expect_true (!m))
1211 /* zero, handled by code below by forcing e to 0 */
1212 e = 0 - (127 - 15);
1213 else
1214 {
1215 /* subnormal, renormalise */
1216 unsigned int s = 10 - ecb_ld32 (m);
1217
1218 m = (m << s) & 0x3ff; /* mask implicit bit */
1219 e -= s - 1;
1220 }
1221 }
1222
1223 /* e and m now are normalised, or zero, (or inf or nan) */
1224 e += 127 - 15;
1225
1226 return s | (e << 23) | (m << (23 - 10));
1227}
1228
1229ecb_function_ ecb_const uint16_t ecb_binary32_to_binary16 (uint32_t x);
1230ecb_function_ ecb_const uint16_t
1231ecb_binary32_to_binary16 (uint32_t x)
1232{
1233 unsigned int s = (x >> 16) & 0x00008000; /* sign bit, the easy part */
1234 unsigned int e = ((x >> 23) & 0x000000ff) - (127 - 15); /* the desired exponent */
1235 unsigned int m = x & 0x007fffff;
1236
1237 x &= 0x7fffffff;
1238
1239 /* if it's within range of binary16 normals, use fast path */
1240 if (ecb_expect_true (0x38800000 <= x && x <= 0x477fefff))
1241 {
1242 /* mantissa round-to-even */
1243 m += 0x00000fff + ((m >> (23 - 10)) & 1);
1244
1245 /* handle overflow */
1246 if (ecb_expect_false (m >= 0x00800000))
1247 {
1248 m >>= 1;
1249 e += 1;
1250 }
1251
1252 return s | (e << 10) | (m >> (23 - 10));
1253 }
1254
1255 /* handle large numbers and infinity */
1256 if (ecb_expect_true (0x477fefff < x && x <= 0x7f800000))
1257 return s | 0x7c00;
1258
1259 /* handle zero, subnormals and small numbers */
1260 if (ecb_expect_true (x < 0x38800000))
1261 {
1262 /* zero */
1263 if (ecb_expect_true (!x))
1264 return s;
1265
1266 /* handle subnormals */
1267
1268 /* too small, will be zero */
1269 if (e < (14 - 24)) /* might not be sharp, but is good enough */
1270 return s;
1271
1272 m |= 0x00800000; /* make implicit bit explicit */
1273
1274 /* very tricky - we need to round to the nearest e (+10) bit value */
1275 {
1276 unsigned int bits = 14 - e;
1277 unsigned int half = (1 << (bits - 1)) - 1;
1278 unsigned int even = (m >> bits) & 1;
1279
1280 /* if this overflows, we will end up with a normalised number */
1281 m = (m + half + even) >> bits;
1282 }
1283
1284 return s | m;
1285 }
1286
1287 /* handle NaNs, preserve leftmost nan bits, but make sure we don't turn them into infinities */
1288 m >>= 13;
1289
1290 return s | 0x7c00 | m | !m;
1291}
1158 1292
1159/*******************************************************************************/ 1293/*******************************************************************************/
1160/* floating point stuff, can be disabled by defining ECB_NO_LIBM */ 1294/* floating point stuff, can be disabled by defining ECB_NO_LIBM */
1161 1295
1162/* basically, everything uses "ieee pure-endian" floating point numbers */ 1296/* basically, everything uses "ieee pure-endian" floating point numbers */
… …
1205 #else 1339 #else
1206 #define ecb_ldexpf(x,e) (float) ldexp ((double) (x), (e)) 1340 #define ecb_ldexpf(x,e) (float) ldexp ((double) (x), (e))
1207 #define ecb_frexpf(x,e) (float) frexp ((double) (x), (e)) 1341 #define ecb_frexpf(x,e) (float) frexp ((double) (x), (e))
1208 #endif 1342 #endif
1209 1343
1210 /* converts an ieee half/binary16 to a float */
1211 ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x);
1212 ecb_function_ ecb_const float
1213 ecb_binary16_to_float (uint16_t x)
1214 {
1215 int e = (x >> 10) & 0x1f;
1216 int m = x & 0x3ff;
1217 float r;
1218
1219 if (!e ) r = ecb_ldexpf (m , -24);
1220 else if (e != 31) r = ecb_ldexpf (m + 0x400, e - 25);
1221 else if (m ) r = ECB_NAN;
1222 else r = ECB_INFINITY;
1223
1224 return x & 0x8000 ? -r : r;
1225 }
1226
1227 /* convert a float to ieee single/binary32 */ 1344 /* convert a float to ieee single/binary32 */
1228 ecb_function_ ecb_const uint32_t ecb_float_to_binary32 (float x); 1345 ecb_function_ ecb_const uint32_t ecb_float_to_binary32 (float x);
1229 ecb_function_ ecb_const uint32_t 1346 ecb_function_ ecb_const uint32_t
1230 ecb_float_to_binary32 (float x) 1347 ecb_float_to_binary32 (float x)
1231 { 1348 {
… …
1360 1477
1361 r = neg ? -r : r; 1478 r = neg ? -r : r;
1362 #endif 1479 #endif
1363 1480
1364 return r; 1481 return r;
1482 }
1483
1484 /* convert a float to ieee half/binary16 */
1485 ecb_function_ ecb_const uint16_t ecb_float_to_binary16 (float x);
1486 ecb_function_ ecb_const uint16_t
1487 ecb_float_to_binary16 (float x)
1488 {
1489 return ecb_binary32_to_binary16 (ecb_float_to_binary32 (x));
1490 }
1491
1492 /* convert an ieee half/binary16 to float */
1493 ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x);
1494 ecb_function_ ecb_const float
1495 ecb_binary16_to_float (uint16_t x)
1496 {
1497 return ecb_binary32_to_float (ecb_binary16_to_binary32 (x));
1365 } 1498 }
1366 1499
1367#endif 1500#endif
1368 1501
1369#endif 1502#endif
… …
1394#define inline_size ecb_inline 1527#define inline_size ecb_inline
1395 1528
1396#if EV_FEATURE_CODE 1529#if EV_FEATURE_CODE
1397# define inline_speed ecb_inline 1530# define inline_speed ecb_inline
1398#else 1531#else
1399# define inline_speed static noinline 1532# define inline_speed noinline static
1400#endif 1533#endif
1401 1534
1402#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1) 1535#define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
1403 1536
1404#if EV_MINPRI == EV_MAXPRI 1537#if EV_MINPRI == EV_MAXPRI
… …
1451#else 1584#else
1452 1585
1453#include <float.h> 1586#include <float.h>
1454 1587
1455/* a floor() replacement function, should be independent of ev_tstamp type */ 1588/* a floor() replacement function, should be independent of ev_tstamp type */
1589noinline
1456static ev_tstamp noinline 1590static ev_tstamp
1457ev_floor (ev_tstamp v) 1591ev_floor (ev_tstamp v)
1458{ 1592{
1459 /* the choice of shift factor is not terribly important */ 1593 /* the choice of shift factor is not terribly important */
1460#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */ 1594#if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */
1461 const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.; 1595 const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;
… …
1493 1627
1494#ifdef __linux 1628#ifdef __linux
1495# include <sys/utsname.h> 1629# include <sys/utsname.h>
1496#endif 1630#endif
1497 1631
1498static unsigned int noinline ecb_cold 1632noinline ecb_cold
1633static unsigned int
1499ev_linux_version (void) 1634ev_linux_version (void)
1500{ 1635{
1501#ifdef __linux 1636#ifdef __linux
1502 unsigned int v = 0; 1637 unsigned int v = 0;
1503 struct utsname buf; 1638 struct utsname buf;
… …
1532} 1667}
1533 1668
1534/*****************************************************************************/ 1669/*****************************************************************************/
1535 1670
1536#if EV_AVOID_STDIO 1671#if EV_AVOID_STDIO
1537static void noinline ecb_cold 1672noinline ecb_cold
1673static void
1538ev_printerr (const char *msg) 1674ev_printerr (const char *msg)
1539{ 1675{
1540 write (STDERR_FILENO, msg, strlen (msg)); 1676 write (STDERR_FILENO, msg, strlen (msg));
1541} 1677}
1542#endif 1678#endif
1543 1679
1544static void (*syserr_cb)(const char *msg) EV_THROW; 1680static void (*syserr_cb)(const char *msg) EV_THROW;
1545 1681
1546void ecb_cold 1682ecb_cold
1683void
1547ev_set_syserr_cb (void (*cb)(const char *msg) EV_THROW) EV_THROW 1684ev_set_syserr_cb (void (*cb)(const char *msg) EV_THROW) EV_THROW
1548{ 1685{
1549 syserr_cb = cb; 1686 syserr_cb = cb;
1550} 1687}
1551 1688
1552static void noinline ecb_cold 1689noinline ecb_cold
1690static void
1553ev_syserr (const char *msg) 1691ev_syserr (const char *msg)
1554{ 1692{
1555 if (!msg) 1693 if (!msg)
1556 msg = "(libev) system error"; 1694 msg = "(libev) system error";
1557 1695
… …
1588 return 0; 1726 return 0;
1589} 1727}
1590 1728
1591static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul; 1729static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul;
1592 1730
1593void ecb_cold 1731ecb_cold
1732void
1594ev_set_allocator (void *(*cb)(void *ptr, long size) EV_THROW) EV_THROW 1733ev_set_allocator (void *(*cb)(void *ptr, long size) EV_THROW) EV_THROW
1595{ 1734{
1596 alloc = cb; 1735 alloc = cb;
1597} 1736}
1598 1737
… …
1807 } 1946 }
1808 1947
1809 return ncur; 1948 return ncur;
1810} 1949}
1811 1950
1812static void * noinline ecb_cold 1951noinline ecb_cold
1952static void *
1813array_realloc (int elem, void *base, int *cur, int cnt) 1953array_realloc (int elem, void *base, int *cur, int cnt)
1814{ 1954{
1815 *cur = array_nextsize (elem, *cur, cnt); 1955 *cur = array_nextsize (elem, *cur, cnt);
1816 return ev_realloc (base, elem * *cur); 1956 return ev_realloc (base, elem * *cur);
1817} 1957}
… …
1820 memset ((void *)(base), 0, sizeof (*(base)) * (count)) 1960 memset ((void *)(base), 0, sizeof (*(base)) * (count))
1821 1961
1822#define array_needsize(type,base,cur,cnt,init) \ 1962#define array_needsize(type,base,cur,cnt,init) \
1823 if (expect_false ((cnt) > (cur))) \ 1963 if (expect_false ((cnt) > (cur))) \
1824 { \ 1964 { \
1825 int ecb_unused ocur_ = (cur); \ 1965 ecb_unused int ocur_ = (cur); \
1826 (base) = (type *)array_realloc \ 1966 (base) = (type *)array_realloc \
1827 (sizeof (type), (base), &(cur), (cnt)); \ 1967 (sizeof (type), (base), &(cur), (cnt)); \
1828 init ((base) + (ocur_), (cur) - ocur_); \ 1968 init ((base) + (ocur_), (cur) - ocur_); \
1829 } 1969 }
1830 1970
… …
1842 ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0 1982 ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0
1843 1983
1844/*****************************************************************************/ 1984/*****************************************************************************/
1845 1985
1846/* dummy callback for pending events */ 1986/* dummy callback for pending events */
1847static void noinline 1987noinline
1988static void
1848pendingcb (EV_P_ ev_prepare *w, int revents) 1989pendingcb (EV_P_ ev_prepare *w, int revents)
1849{ 1990{
1850} 1991}
1851 1992
1852void noinline 1993noinline
1994void
1853ev_feed_event (EV_P_ void *w, int revents) EV_THROW 1995ev_feed_event (EV_P_ void *w, int revents) EV_THROW
1854{ 1996{
1855 W w_ = (W)w; 1997 W w_ = (W)w;
1856 int pri = ABSPRI (w_); 1998 int pri = ABSPRI (w_);
1857 1999
… …
1987 2129
1988 fdchangecnt = 0; 2130 fdchangecnt = 0;
1989} 2131}
1990 2132
1991/* something about the given fd changed */ 2133/* something about the given fd changed */
1992inline_size void 2134inline_size
2135void
1993fd_change (EV_P_ int fd, int flags) 2136fd_change (EV_P_ int fd, int flags)
1994{ 2137{
1995 unsigned char reify = anfds [fd].reify; 2138 unsigned char reify = anfds [fd].reify;
1996 anfds [fd].reify |= flags; 2139 anfds [fd].reify |= flags;
1997 2140
… …
2002 fdchanges [fdchangecnt - 1] = fd; 2145 fdchanges [fdchangecnt - 1] = fd;
2003 } 2146 }
2004} 2147}
2005 2148
2006/* the given fd is invalid/unusable, so make sure it doesn't hurt us anymore */ 2149/* the given fd is invalid/unusable, so make sure it doesn't hurt us anymore */
2007inline_speed void ecb_cold 2150inline_speed ecb_cold void
2008fd_kill (EV_P_ int fd) 2151fd_kill (EV_P_ int fd)
2009{ 2152{
2010 ev_io *w; 2153 ev_io *w;
2011 2154
2012 while ((w = (ev_io *)anfds [fd].head)) 2155 while ((w = (ev_io *)anfds [fd].head))
… …
2015 ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE); 2158 ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
2016 } 2159 }
2017} 2160}
2018 2161
2019/* check whether the given fd is actually valid, for error recovery */ 2162/* check whether the given fd is actually valid, for error recovery */
2020inline_size int ecb_cold 2163inline_size ecb_cold int
2021fd_valid (int fd) 2164fd_valid (int fd)
2022{ 2165{
2023#ifdef _WIN32 2166#ifdef _WIN32
2024 return EV_FD_TO_WIN32_HANDLE (fd) != -1; 2167 return EV_FD_TO_WIN32_HANDLE (fd) != -1;
2025#else 2168#else
2026 return fcntl (fd, F_GETFD) != -1; 2169 return fcntl (fd, F_GETFD) != -1;
2027#endif 2170#endif
2028} 2171}
2029 2172
2030/* called on EBADF to verify fds */ 2173/* called on EBADF to verify fds */
2031static void noinline ecb_cold 2174noinline ecb_cold
2175static void
2032fd_ebadf (EV_P) 2176fd_ebadf (EV_P)
2033{ 2177{
2034 int fd; 2178 int fd;
2035 2179
2036 for (fd = 0; fd < anfdmax; ++fd) 2180 for (fd = 0; fd < anfdmax; ++fd)
… …
2038 if (!fd_valid (fd) && errno == EBADF) 2182 if (!fd_valid (fd) && errno == EBADF)
2039 fd_kill (EV_A_ fd); 2183 fd_kill (EV_A_ fd);
2040} 2184}
2041 2185
2042/* called on ENOMEM in select/poll to kill some fds and retry */ 2186/* called on ENOMEM in select/poll to kill some fds and retry */
2043static void noinline ecb_cold 2187noinline ecb_cold
2188static void
2044fd_enomem (EV_P) 2189fd_enomem (EV_P)
2045{ 2190{
2046 int fd; 2191 int fd;
2047 2192
2048 for (fd = anfdmax; fd--; ) 2193 for (fd = anfdmax; fd--; )
… …
2052 break; 2197 break;
2053 } 2198 }
2054} 2199}
2055 2200
2056/* usually called after fork if backend needs to re-arm all fds from scratch */ 2201/* usually called after fork if backend needs to re-arm all fds from scratch */
2057static void noinline 2202noinline
2203static void
2058fd_rearm_all (EV_P) 2204fd_rearm_all (EV_P)
2059{ 2205{
2060 int fd; 2206 int fd;
2061 2207
2062 for (fd = 0; fd < anfdmax; ++fd) 2208 for (fd = 0; fd < anfdmax; ++fd)
… …
2243 2389
2244/*****************************************************************************/ 2390/*****************************************************************************/
2245 2391
2246#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE 2392#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2247 2393
2248static void noinline ecb_cold 2394noinline ecb_cold
2395static void
2249evpipe_init (EV_P) 2396evpipe_init (EV_P)
2250{ 2397{
2251 if (!ev_is_active (&pipe_w)) 2398 if (!ev_is_active (&pipe_w))
2252 { 2399 {
2253 int fds [2]; 2400 int fds [2];
… …
2431#endif 2578#endif
2432 2579
2433 ev_feed_signal (signum); 2580 ev_feed_signal (signum);
2434} 2581}
2435 2582
2436void noinline 2583noinline
2584void
2437ev_feed_signal_event (EV_P_ int signum) EV_THROW 2585ev_feed_signal_event (EV_P_ int signum) EV_THROW
2438{ 2586{
2439 WL w; 2587 WL w;
2440 2588
2441 if (expect_false (signum <= 0 || signum >= EV_NSIG)) 2589 if (expect_false (signum <= 0 || signum >= EV_NSIG))
… …
2558#endif 2706#endif
2559#if EV_USE_SELECT 2707#if EV_USE_SELECT
2560# include "ev_select.c" 2708# include "ev_select.c"
2561#endif 2709#endif
2562 2710
2563int ecb_cold 2711ecb_cold int
2564ev_version_major (void) EV_THROW 2712ev_version_major (void) EV_THROW
2565{ 2713{
2566 return EV_VERSION_MAJOR; 2714 return EV_VERSION_MAJOR;
2567} 2715}
2568 2716
2569int ecb_cold 2717ecb_cold int
2570ev_version_minor (void) EV_THROW 2718ev_version_minor (void) EV_THROW
2571{ 2719{
2572 return EV_VERSION_MINOR; 2720 return EV_VERSION_MINOR;
2573} 2721}
2574 2722
2575/* return true if we are running with elevated privileges and should ignore env variables */ 2723/* return true if we are running with elevated privileges and should ignore env variables */
2576int inline_size ecb_cold 2724inline_size ecb_cold int
2577enable_secure (void) 2725enable_secure (void)
2578{ 2726{
2579#ifdef _WIN32 2727#ifdef _WIN32
2580 return 0; 2728 return 0;
2581#else 2729#else
2582 return getuid () != geteuid () 2730 return getuid () != geteuid ()
2583 || getgid () != getegid (); 2731 || getgid () != getegid ();
2584#endif 2732#endif
2585} 2733}
2586 2734
2587unsigned int ecb_cold 2735ecb_cold
2736unsigned int
2588ev_supported_backends (void) EV_THROW 2737ev_supported_backends (void) EV_THROW
2589{ 2738{
2590 unsigned int flags = 0; 2739 unsigned int flags = 0;
2591 2740
2592 if (EV_USE_PORT ) flags |= EVBACKEND_PORT; 2741 if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
… …
2596 if (EV_USE_SELECT) flags |= EVBACKEND_SELECT; 2745 if (EV_USE_SELECT) flags |= EVBACKEND_SELECT;
2597 2746
2598 return flags; 2747 return flags;
2599} 2748}
2600 2749
2601unsigned int ecb_cold 2750ecb_cold
2751unsigned int
2602ev_recommended_backends (void) EV_THROW 2752ev_recommended_backends (void) EV_THROW
2603{ 2753{
2604 unsigned int flags = ev_supported_backends (); 2754 unsigned int flags = ev_supported_backends ();
2605 2755
2606#ifndef __NetBSD__ 2756#ifndef __NetBSD__
… …
2618#endif 2768#endif
2619 2769
2620 return flags; 2770 return flags;
2621} 2771}
2622 2772
2623unsigned int ecb_cold 2773ecb_cold
2774unsigned int
2624ev_embeddable_backends (void) EV_THROW 2775ev_embeddable_backends (void) EV_THROW
2625{ 2776{
2626 int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT; 2777 int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;
2627 2778
2628 /* epoll embeddability broken on all linux versions up to at least 2.6.23 */ 2779 /* epoll embeddability broken on all linux versions up to at least 2.6.23 */
… …
2688 acquire_cb = acquire; 2839 acquire_cb = acquire;
2689} 2840}
2690#endif 2841#endif
2691 2842
2692/* initialise a loop structure, must be zero-initialised */ 2843/* initialise a loop structure, must be zero-initialised */
2693static void noinline ecb_cold 2844noinline ecb_cold
2845static void
2694loop_init (EV_P_ unsigned int flags) EV_THROW 2846loop_init (EV_P_ unsigned int flags) EV_THROW
2695{ 2847{
2696 if (!backend) 2848 if (!backend)
2697 { 2849 {
2698 origflags = flags; 2850 origflags = flags;
… …
2785#endif 2937#endif
2786 } 2938 }
2787} 2939}
2788 2940
2789/* free up a loop structure */ 2941/* free up a loop structure */
2790void ecb_cold 2942ecb_cold
2943void
2791ev_loop_destroy (EV_P) 2944ev_loop_destroy (EV_P)
2792{ 2945{
2793 int i; 2946 int i;
2794 2947
2795#if EV_MULTIPLICITY 2948#if EV_MULTIPLICITY
… …
2916#if EV_USE_INOTIFY 3069#if EV_USE_INOTIFY
2917 infy_fork (EV_A); 3070 infy_fork (EV_A);
2918#endif 3071#endif
2919 3072
2920#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE 3073#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2921 if (ev_is_active (&pipe_w)) 3074 if (ev_is_active (&pipe_w) && postfork != 2)
2922 { 3075 {
2923 /* pipe_write_wanted must be false now, so modifying fd vars should be safe */ 3076 /* pipe_write_wanted must be false now, so modifying fd vars should be safe */
2924 3077
2925 ev_ref (EV_A); 3078 ev_ref (EV_A);
2926 ev_io_stop (EV_A_ &pipe_w); 3079 ev_io_stop (EV_A_ &pipe_w);
… …
2937 postfork = 0; 3090 postfork = 0;
2938} 3091}
2939 3092
2940#if EV_MULTIPLICITY 3093#if EV_MULTIPLICITY
2941 3094
3095ecb_cold
2942struct ev_loop * ecb_cold 3096struct ev_loop *
2943ev_loop_new (unsigned int flags) EV_THROW 3097ev_loop_new (unsigned int flags) EV_THROW
2944{ 3098{
2945 EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop)); 3099 EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
2946 3100
2947 memset (EV_A, 0, sizeof (struct ev_loop)); 3101 memset (EV_A, 0, sizeof (struct ev_loop));
… …
2955} 3109}
2956 3110
2957#endif /* multiplicity */ 3111#endif /* multiplicity */
2958 3112
2959#if EV_VERIFY 3113#if EV_VERIFY
2960static void noinline ecb_cold 3114noinline ecb_cold
3115static void
2961verify_watcher (EV_P_ W w) 3116verify_watcher (EV_P_ W w)
2962{ 3117{
2963 assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI)); 3118 assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));
2964 3119
2965 if (w->pending) 3120 if (w->pending)
2966 assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w)); 3121 assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));
2967} 3122}
2968 3123
2969static void noinline ecb_cold 3124noinline ecb_cold
3125static void
2970verify_heap (EV_P_ ANHE *heap, int N) 3126verify_heap (EV_P_ ANHE *heap, int N)
2971{ 3127{
2972 int i; 3128 int i;
2973 3129
2974 for (i = HEAP0; i < N + HEAP0; ++i) 3130 for (i = HEAP0; i < N + HEAP0; ++i)
… …
2979 3135
2980 verify_watcher (EV_A_ (W)ANHE_w (heap [i])); 3136 verify_watcher (EV_A_ (W)ANHE_w (heap [i]));
2981 } 3137 }
2982} 3138}
2983 3139
2984static void noinline ecb_cold 3140noinline ecb_cold
3141static void
2985array_verify (EV_P_ W *ws, int cnt) 3142array_verify (EV_P_ W *ws, int cnt)
2986{ 3143{
2987 while (cnt--) 3144 while (cnt--)
2988 { 3145 {
2989 assert (("libev: active index mismatch", ev_active (ws [cnt]) == cnt + 1)); 3146 assert (("libev: active index mismatch", ev_active (ws [cnt]) == cnt + 1));
… …
3078#endif 3235#endif
3079} 3236}
3080#endif 3237#endif
3081 3238
3082#if EV_MULTIPLICITY 3239#if EV_MULTIPLICITY
3240ecb_cold
3083struct ev_loop * ecb_cold 3241struct ev_loop *
3084#else 3242#else
3085int 3243int
3086#endif 3244#endif
3087ev_default_loop (unsigned int flags) EV_THROW 3245ev_default_loop (unsigned int flags) EV_THROW
3088{ 3246{
… …
3136 count += pendingcnt [pri]; 3294 count += pendingcnt [pri];
3137 3295
3138 return count; 3296 return count;
3139} 3297}
3140 3298
3141void noinline 3299noinline
3300void
3142ev_invoke_pending (EV_P) 3301ev_invoke_pending (EV_P)
3143{ 3302{
3144 pendingpri = NUMPRI; 3303 pendingpri = NUMPRI;
3145 3304
3146 while (pendingpri) /* pendingpri possibly gets modified in the inner loop */ 3305 while (pendingpri) /* pendingpri possibly gets modified in the inner loop */
… …
3221 } 3380 }
3222} 3381}
3223 3382
3224#if EV_PERIODIC_ENABLE 3383#if EV_PERIODIC_ENABLE
3225 3384
3226static void noinline 3385noinline
3386static void
3227periodic_recalc (EV_P_ ev_periodic *w) 3387periodic_recalc (EV_P_ ev_periodic *w)
3228{ 3388{
3229 ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL; 3389 ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;
3230 ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval); 3390 ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval);
3231 3391
… …
3289 } 3449 }
3290} 3450}
3291 3451
3292/* simply recalculate all periodics */ 3452/* simply recalculate all periodics */
3293/* TODO: maybe ensure that at least one event happens when jumping forward? */ 3453/* TODO: maybe ensure that at least one event happens when jumping forward? */
3294static void noinline ecb_cold 3454noinline ecb_cold
3455static void
3295periodics_reschedule (EV_P) 3456periodics_reschedule (EV_P)
3296{ 3457{
3297 int i; 3458 int i;
3298 3459
3299 /* adjust periodics after time jump */ 3460 /* adjust periodics after time jump */
… …
3312 reheap (periodics, periodiccnt); 3473 reheap (periodics, periodiccnt);
3313} 3474}
3314#endif 3475#endif
3315 3476
3316/* adjust all timers by a given offset */ 3477/* adjust all timers by a given offset */
3317static void noinline ecb_cold 3478noinline ecb_cold
3479static void
3318timers_reschedule (EV_P_ ev_tstamp adjust) 3480timers_reschedule (EV_P_ ev_tstamp adjust)
3319{ 3481{
3320 int i; 3482 int i;
3321 3483
3322 for (i = 0; i < timercnt; ++i) 3484 for (i = 0; i < timercnt; ++i)
… …
3690 w->active = 0; 3852 w->active = 0;
3691} 3853}
3692 3854
3693/*****************************************************************************/ 3855/*****************************************************************************/
3694 3856
3695void noinline 3857noinline
3858void
3696ev_io_start (EV_P_ ev_io *w) EV_THROW 3859ev_io_start (EV_P_ ev_io *w) EV_THROW
3697{ 3860{
3698 int fd = w->fd; 3861 int fd = w->fd;
3699 3862
3700 if (expect_false (ev_is_active (w))) 3863 if (expect_false (ev_is_active (w)))
… …
3716 w->events &= ~EV__IOFDSET; 3879 w->events &= ~EV__IOFDSET;
3717 3880
3718 EV_FREQUENT_CHECK; 3881 EV_FREQUENT_CHECK;
3719} 3882}
3720 3883
3721void noinline 3884noinline
3885void
3722ev_io_stop (EV_P_ ev_io *w) EV_THROW 3886ev_io_stop (EV_P_ ev_io *w) EV_THROW
3723{ 3887{
3724 clear_pending (EV_A_ (W)w); 3888 clear_pending (EV_A_ (W)w);
3725 if (expect_false (!ev_is_active (w))) 3889 if (expect_false (!ev_is_active (w)))
3726 return; 3890 return;
… …
3735 fd_change (EV_A_ w->fd, EV_ANFD_REIFY); 3899 fd_change (EV_A_ w->fd, EV_ANFD_REIFY);
3736 3900
3737 EV_FREQUENT_CHECK; 3901 EV_FREQUENT_CHECK;
3738} 3902}
3739 3903
3740void noinline 3904noinline
3905void
3741ev_timer_start (EV_P_ ev_timer *w) EV_THROW 3906ev_timer_start (EV_P_ ev_timer *w) EV_THROW
3742{ 3907{
3743 if (expect_false (ev_is_active (w))) 3908 if (expect_false (ev_is_active (w)))
3744 return; 3909 return;
3745 3910
… …
3759 EV_FREQUENT_CHECK; 3924 EV_FREQUENT_CHECK;
3760 3925
3761 /*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/ 3926 /*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
3762} 3927}
3763 3928
3764void noinline 3929noinline
3930void
3765ev_timer_stop (EV_P_ ev_timer *w) EV_THROW 3931ev_timer_stop (EV_P_ ev_timer *w) EV_THROW
3766{ 3932{
3767 clear_pending (EV_A_ (W)w); 3933 clear_pending (EV_A_ (W)w);
3768 if (expect_false (!ev_is_active (w))) 3934 if (expect_false (!ev_is_active (w)))
3769 return; 3935 return;
… …
3789 ev_stop (EV_A_ (W)w); 3955 ev_stop (EV_A_ (W)w);
3790 3956
3791 EV_FREQUENT_CHECK; 3957 EV_FREQUENT_CHECK;
3792} 3958}
3793 3959
3794void noinline 3960noinline
3961void
3795ev_timer_again (EV_P_ ev_timer *w) EV_THROW 3962ev_timer_again (EV_P_ ev_timer *w) EV_THROW
3796{ 3963{
3797 EV_FREQUENT_CHECK; 3964 EV_FREQUENT_CHECK;
3798 3965
3799 clear_pending (EV_A_ (W)w); 3966 clear_pending (EV_A_ (W)w);
… …
3823{ 3990{
3824 return ev_at (w) - (ev_is_active (w) ? mn_now : 0.); 3991 return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);
3825} 3992}
3826 3993
3827#if EV_PERIODIC_ENABLE 3994#if EV_PERIODIC_ENABLE
3828void noinline 3995noinline
3996void
3829ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW 3997ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW
3830{ 3998{
3831 if (expect_false (ev_is_active (w))) 3999 if (expect_false (ev_is_active (w)))
3832 return; 4000 return;
3833 4001
… …
3853 EV_FREQUENT_CHECK; 4021 EV_FREQUENT_CHECK;
3854 4022
3855 /*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/ 4023 /*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
3856} 4024}
3857 4025
3858void noinline 4026noinline
4027void
3859ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW 4028ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW
3860{ 4029{
3861 clear_pending (EV_A_ (W)w); 4030 clear_pending (EV_A_ (W)w);
3862 if (expect_false (!ev_is_active (w))) 4031 if (expect_false (!ev_is_active (w)))
3863 return; 4032 return;
… …
3881 ev_stop (EV_A_ (W)w); 4050 ev_stop (EV_A_ (W)w);
3882 4051
3883 EV_FREQUENT_CHECK; 4052 EV_FREQUENT_CHECK;
3884} 4053}
3885 4054
3886void noinline 4055noinline
4056void
3887ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW 4057ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW
3888{ 4058{
3889 /* TODO: use adjustheap and recalculation */ 4059 /* TODO: use adjustheap and recalculation */
3890 ev_periodic_stop (EV_A_ w); 4060 ev_periodic_stop (EV_A_ w);
3891 ev_periodic_start (EV_A_ w); 4061 ev_periodic_start (EV_A_ w);
… …
3896# define SA_RESTART 0 4066# define SA_RESTART 0
3897#endif 4067#endif
3898 4068
3899#if EV_SIGNAL_ENABLE 4069#if EV_SIGNAL_ENABLE
3900 4070
3901void noinline 4071noinline
4072void
3902ev_signal_start (EV_P_ ev_signal *w) EV_THROW 4073ev_signal_start (EV_P_ ev_signal *w) EV_THROW
3903{ 4074{
3904 if (expect_false (ev_is_active (w))) 4075 if (expect_false (ev_is_active (w)))
3905 return; 4076 return;
3906 4077
… …
3978 } 4149 }
3979 4150
3980 EV_FREQUENT_CHECK; 4151 EV_FREQUENT_CHECK;
3981} 4152}
3982 4153
3983void noinline 4154noinline
4155void
3984ev_signal_stop (EV_P_ ev_signal *w) EV_THROW 4156ev_signal_stop (EV_P_ ev_signal *w) EV_THROW
3985{ 4157{
3986 clear_pending (EV_A_ (W)w); 4158 clear_pending (EV_A_ (W)w);
3987 if (expect_false (!ev_is_active (w))) 4159 if (expect_false (!ev_is_active (w)))
3988 return; 4160 return;
… …
4064 4236
4065#define DEF_STAT_INTERVAL 5.0074891 4237#define DEF_STAT_INTERVAL 5.0074891
4066#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */ 4238#define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */
4067#define MIN_STAT_INTERVAL 0.1074891 4239#define MIN_STAT_INTERVAL 0.1074891
4068 4240
4069static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents); 4241noinline static void stat_timer_cb (EV_P_ ev_timer *w_, int revents);
4070 4242
4071#if EV_USE_INOTIFY 4243#if EV_USE_INOTIFY
4072 4244
4073/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */ 4245/* the * 2 is to allow for alignment padding, which for some reason is >> 8 */
4074# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX) 4246# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
4075 4247
4076static void noinline 4248noinline
4249static void
4077infy_add (EV_P_ ev_stat *w) 4250infy_add (EV_P_ ev_stat *w)
4078{ 4251{
4079 w->wd = inotify_add_watch (fs_fd, w->path, 4252 w->wd = inotify_add_watch (fs_fd, w->path,
4080 IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY 4253 IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY
4081 | IN_CREATE | IN_DELETE | IN_MOVED_FROM | IN_MOVED_TO 4254 | IN_CREATE | IN_DELETE | IN_MOVED_FROM | IN_MOVED_TO
… …
4145 if (ev_is_active (&w->timer)) ev_ref (EV_A); 4318 if (ev_is_active (&w->timer)) ev_ref (EV_A);
4146 ev_timer_again (EV_A_ &w->timer); 4319 ev_timer_again (EV_A_ &w->timer);
4147 if (ev_is_active (&w->timer)) ev_unref (EV_A); 4320 if (ev_is_active (&w->timer)) ev_unref (EV_A);
4148} 4321}
4149 4322
4150static void noinline 4323noinline
4324static void
4151infy_del (EV_P_ ev_stat *w) 4325infy_del (EV_P_ ev_stat *w)
4152{ 4326{
4153 int slot; 4327 int slot;
4154 int wd = w->wd; 4328 int wd = w->wd;
4155 4329
… …
4162 4336
4163 /* remove this watcher, if others are watching it, they will rearm */ 4337 /* remove this watcher, if others are watching it, they will rearm */
4164 inotify_rm_watch (fs_fd, wd); 4338 inotify_rm_watch (fs_fd, wd);
4165} 4339}
4166 4340
4167static void noinline 4341noinline
4342static void
4168infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev) 4343infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
4169{ 4344{
4170 if (slot < 0) 4345 if (slot < 0)
4171 /* overflow, need to check for all hash slots */ 4346 /* overflow, need to check for all hash slots */
4172 for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot) 4347 for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)
… …
4208 infy_wd (EV_A_ ev->wd, ev->wd, ev); 4383 infy_wd (EV_A_ ev->wd, ev->wd, ev);
4209 ofs += sizeof (struct inotify_event) + ev->len; 4384 ofs += sizeof (struct inotify_event) + ev->len;
4210 } 4385 }
4211} 4386}
4212 4387
4213inline_size void ecb_cold 4388inline_size ecb_cold
4389void
4214ev_check_2625 (EV_P) 4390ev_check_2625 (EV_P)
4215{ 4391{
4216 /* kernels < 2.6.25 are borked 4392 /* kernels < 2.6.25 are borked
4217 * http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html 4393 * http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html
4218 */ 4394 */
… …
4316 w->attr.st_nlink = 0; 4492 w->attr.st_nlink = 0;
4317 else if (!w->attr.st_nlink) 4493 else if (!w->attr.st_nlink)
4318 w->attr.st_nlink = 1; 4494 w->attr.st_nlink = 1;
4319} 4495}
4320 4496
4321static void noinline 4497noinline
4498static void
4322stat_timer_cb (EV_P_ ev_timer *w_, int revents) 4499stat_timer_cb (EV_P_ ev_timer *w_, int revents)
4323{ 4500{
4324 ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer)); 4501 ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
4325 4502
4326 ev_statdata prev = w->attr; 4503 ev_statdata prev = w->attr;
… …
4536 EV_FREQUENT_CHECK; 4713 EV_FREQUENT_CHECK;
4537} 4714}
4538#endif 4715#endif
4539 4716
4540#if EV_EMBED_ENABLE 4717#if EV_EMBED_ENABLE
4541void noinline 4718noinline
4719void
4542ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW 4720ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW
4543{ 4721{
4544 ev_run (w->other, EVRUN_NOWAIT); 4722 ev_run (w->other, EVRUN_NOWAIT);
4545} 4723}
4546 4724
… …
4843} 5021}
4844 5022
4845/*****************************************************************************/ 5023/*****************************************************************************/
4846 5024
4847#if EV_WALK_ENABLE 5025#if EV_WALK_ENABLE
4848void ecb_cold 5026ecb_cold
5027void
4849ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW 5028ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW
4850{ 5029{
4851 int i, j; 5030 int i, j;
4852 ev_watcher_list *wl, *wn; 5031 ev_watcher_list *wl, *wn;
4853 5032

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines