003 File Manager
Current Path:
/usr/src/contrib/ntp/sntp/libevent
usr
/
src
/
contrib
/
ntp
/
sntp
/
libevent
/
📁
..
📄
ChangeLog
(69.13 KB)
📄
ChangeLog-1.4
(16.96 KB)
📄
ChangeLog-2.0
(81.39 KB)
📄
Doxyfile
(9.97 KB)
📄
LICENSE
(4.42 KB)
📄
Makefile.am
(8.43 KB)
📄
Makefile.in
(130.03 KB)
📄
Makefile.nmake
(2.29 KB)
📁
WIN32-Code
📄
aclocal.m4
(41.45 KB)
📄
arc4random.c
(12.83 KB)
📄
autogen.sh
(308 B)
📄
buffer.c
(80.17 KB)
📄
buffer_iocp.c
(8.44 KB)
📄
bufferevent-internal.h
(17.1 KB)
📄
bufferevent.c
(24.78 KB)
📄
bufferevent_async.c
(17.75 KB)
📄
bufferevent_filter.c
(15.47 KB)
📄
bufferevent_openssl.c
(38.39 KB)
📄
bufferevent_pair.c
(9.48 KB)
📄
bufferevent_ratelim.c
(29.51 KB)
📄
bufferevent_sock.c
(17.78 KB)
📁
build-aux
📄
changelist-internal.h
(4.52 KB)
📁
compat
📄
config.h.in
(13.78 KB)
📄
configure
(521.57 KB)
📄
configure.ac
(23.07 KB)
📄
defer-internal.h
(2.7 KB)
📄
devpoll.c
(7.7 KB)
📄
epoll.c
(14.22 KB)
📄
epoll_sub.c
(2.33 KB)
📄
epolltable-internal.h
(40.4 KB)
📄
evbuffer-internal.h
(12.51 KB)
📄
evconfig-private.h
(1.33 KB)
📄
evconfig-private.h.in
(1.21 KB)
📄
evdns.c
(127.11 KB)
📄
event-internal.h
(16.74 KB)
📄
event.c
(99.03 KB)
📄
event_iocp.c
(7.52 KB)
📄
event_rpcgen.py
(54.3 KB)
📄
event_tagging.c
(14.27 KB)
📄
evmap-internal.h
(4.78 KB)
📄
evmap.c
(28.2 KB)
📄
evport.c
(11.72 KB)
📄
evrpc-internal.h
(5.58 KB)
📄
evrpc.c
(28.68 KB)
📄
evsignal-internal.h
(2.57 KB)
📄
evthread-internal.h
(13.99 KB)
📄
evthread.c
(12.61 KB)
📄
evthread_pthread.c
(4.84 KB)
📄
evthread_win32.c
(8.39 KB)
📄
evutil.c
(68.14 KB)
📄
evutil_rand.c
(5.08 KB)
📄
evutil_time.c
(15.82 KB)
📄
ht-internal.h
(28.5 KB)
📄
http-internal.h
(5.82 KB)
📄
http.c
(117.24 KB)
📁
include
📄
iocp-internal.h
(7.52 KB)
📄
ipv6-internal.h
(2.46 KB)
📄
kqueue-internal.h
(1.94 KB)
📄
kqueue.c
(14.33 KB)
📄
libevent.pc.in
(317 B)
📄
libevent_openssl.pc.in
(372 B)
📄
libevent_pthreads.pc.in
(384 B)
📄
listener.c
(20.81 KB)
📄
log-internal.h
(3.14 KB)
📄
log.c
(5.51 KB)
📁
m4
📄
make-event-config.sed
(588 B)
📄
minheap-internal.h
(6.78 KB)
📄
mm-internal.h
(3.32 KB)
📄
poll.c
(7.98 KB)
📄
ratelim-internal.h
(4 KB)
📄
select.c
(8.5 KB)
📄
signal.c
(12.22 KB)
📄
strlcpy-internal.h
(366 B)
📄
strlcpy.c
(2.52 KB)
📁
test
📄
time-internal.h
(3 KB)
📄
util-internal.h
(15.18 KB)
📄
whatsnew-2.0.txt
(25.73 KB)
📄
whatsnew-2.1.txt
(29.51 KB)
📄
win32select.c
(10.29 KB)
Editing: whatsnew-2.1.txt
What's new in Libevent 2.1 Nick Mathewson 0. Before we start 0.1. About this document This document describes the key differences between Libevent 2.0 and Libevent 2.1, from a user's point of view. It's a work in progress. For better documentation about libevent, see the links at http://libevent.org/ Libevent 2.1 would not be possible without the generous help of numerous volunteers. For a list of who did what in Libevent 2.1, please see the ChangeLog! NOTE: I am very sure that I missed some thing on this list. Caveat haxxor. 0.2. Where to get help Try looking at the other documentation too. All of the header files have documentation in the doxygen format; this gets turned into nice HTML and linked to from the libevent.org website. There is a work-in-progress book with reference manual at http://www.wangafu.net/~nickm/libevent-book/ . You can ask questions on the #libevent IRC channel at irc.oftc.net or on the mailing list at libevent-users@freehaven.net. The mailing list is subscribers-only, so you will need to subscribe before you post. 0.3. Compatibility Our source-compatibility policy is that correct code (that is to say, code that uses public interfaces of Libevent and relies only on their documented behavior) should have forward source compatibility: any such code that worked with a previous version of Libevent should work with this version too. We don't try to do binary compatibility except within stable release series, so binaries linked against any version of Libevent 2.0 will probably need to be recompiled against Libevent 2.1.4-alpha if you want to use it. It is probable that we'll break binary compatibility again before Libevent 2.1 is stable. 1. New APIs and features 1.1. New ways to build libevent We now provide an --enable-gcc-hardening configure option to turn on GCC features designed for increased code security. There is also an --enable-silent-rules configure option to make compilation run more quietly with automake 1.11 or later. You no longer need to use the --enable-gcc-warnings option to turn on all of the GCC warnings that Libevent uses. The only change from using that option now is to turn warnings into errors. For IDE users, files that are not supposed to be built are now surrounded with appropriate #ifdef lines to keep your IDE from getting upset. There is now an alternative cmake-based build process; cmake users should see the relevant sections in the README. 1.2. New functions for events and the event loop If you're running Libevent with multiple event priorities, you might want to make sure that Libevent checks for new events frequently, so that time-consuming or numerous low-priority events don't keep it from checking for new high-priority events. You can now use the event_config_set_max_dispatch_interval() interface to ensure that the loop checks for new events either every N microseconds, every M callbacks, or both. When configuring an event base, you can now choose whether you want timers to be more efficient, or more precise. (This only has effect on Linux for now.) Timers are efficient by default: to select more precise timers, use the EVENT_BASE_FLAG_PRECISE_TIMER flag when constructing the event_config, or set the EVENT_PRECISE_TIMER environment variable to a non-empty string. There is an EVLOOP_NO_EXIT_ON_EMPTY flag that tells event_base_loop() to keep looping even when there are no pending events. (Ordinarily, event_base_loop() will exit as soon as no events are pending.) Past versions of Libevent have been annoying to use with some memory-leak-checking tools, because Libevent allocated some global singletons but provided no means to free them. There is now a function, libevent_global_shutdown(), that you can use to free all globally held resources before exiting, so that your leak-check tools don't complain. (Note: this function doesn't free non-global things like events, bufferevents, and so on; and it doesn't free anything that wouldn't otherwise get cleaned up by the operating system when your process exit()s. If you aren't using a leak-checking tool, there is not much reason to call libevent_global_shutdown().) There is a new event_base_get_npriorities() function to return the number of priorities set in the event base. Libevent 2.0 added an event_new() function to construct a new struct event on the heap. Unfortunately, with event_new(), there was no equivalent for: struct event ev; event_assign(&ev, base, fd, EV_READ, callback, &ev); In other words, there was no easy way for event_new() to set up an event so that the event itself would be its callback argument. Libevent 2.1 lets you do this by passing "event_self_cbarg()" as the callback argument: struct event *evp; evp = event_new(base, fd, EV_READ, callback, event_self_cbarg()); There's also a new event_base_get_running_event() function you can call from within a Libevent callback to get a pointer to the current event. This should never be strictly necessary, but it's sometimes convenient. The event_base_once() function used to leak some memory if the event that it added was never actually triggered. Now, its memory is tracked in the event_base and freed when the event_base is freed. Note however that Libevent doesn't know how to free any information passed as the callback argument to event_base_once is still something you'll might need a way to de-allocate yourself. There is an event_get_priority() function to return an event's priority. By analogy to event_base_loopbreak(), there is now an event_base_loopcontinue() that tells Libevent to stop processing active event callbacks, and re-scan for new events right away. There's a function, event_base_foreach_event(), that can iterate over every event currently pending or active on an event base, and invoke a user-supplied callback on each. The callback must not alter the events or add or remove anything to the event base. We now have an event_remove_timer() function to remove the timeout on an event while leaving its socket and/or signal triggers unchanged. (If we were designing the API from scratch, this would be the behavior of "event_add(ev, NULL)" on an already-added event with a timeout. But that's a no-op in past versions of Libevent, and we don't want to break compatibility.) You can use the new event_base_get_num_events() function to find the number of events active or pending on an event_base. To find the largest number of events that there have been since the last call, use event_base_get_max_events(). You can now activate all the events waiting for a given fd or signal using the event_base_active_by_fd() and event_base_active_by_signal() APIs. On backends that support it (currently epoll), there is now an EV_CLOSED flag that programs can use to detect when a socket has closed without having to read all the bytes until receiving an EOF. 1.3. Event finalization [NOTE: This is an experimental feature in Libevent 2.1.3-alpha. Though it seems solid so far, its API might change between now and the first release candidate for Libevent 2.1.] 1.3.1. Why event finalization? Libevent 2.1 now supports an API for safely "finalizing" events that might be running in multiple threads, and provides a way to slightly change the semantics of event_del() to prevent deadlocks in multithreaded programs. To motivate this feature, consider the following code, in the context of a mulithreaded Libevent application: struct connection *conn = event_get_callback_arg(ev); event_del(ev); connection_free(conn); Suppose that the event's callback might be running in another thread, and using the value of "conn" concurrently. We wouldn't want to execute the connection_free() call until "conn" is no longer in use. How can we make this code safe? Libevent 2.0 answered that question by saying that the event_del() call should block if the event's callback is running in another thread. That way, we can be sure that event_del() has canceled the callback (if the callback hadn't started running yet), or has waited for the callback to finish. But now suppose that the data structure is protected by a lock, and we have the following code: void check_disable(struct connection *connection) { lock(connection); if (should_stop_reading(connection)) event_del(connection->read_event); unlock(connection); } What happens when we call check_disable() from a callback and from another thread? Let's say that the other thread gets the lock first. If it decides to call event_del(), it will wait for the callback to finish. But meanwhile, the callback will be waiting for the lock on the connection. Since each threads is waiting for the other one to release a resource, the program will deadlock. This bug showed up in multithreaded bufferevent programs in 2.1, particularly when freeing bufferevents. (For more information, see the "Deadlock when calling bufferevent_free from an other thread" thread on libevent-users starting on 6 August 2012 and running through February of 2013. You might also like to read my earlier writeup at http://archives.seul.org/libevent/users/Feb-2012/msg00053.html and the ensuing discussion.) 1.3.2. The EV_FINALIZE flag and avoiding deadlock To prevent the deadlock condition described above, Libevent 2.1.3-alpha adds a new flag, "EV_FINALIZE". You can pass it to event_new() and event_assign() along with EV_READ, EV_WRITE, and the other event flags. When an event is constructed with the EV_FINALIZE flag, event_del() will not block on that event, even when the event's callback is running in another thread. By using EV_FINALIZE, you are therefore promising not to use the "event_del(ev); free(event_get_callback_arg(ev));" pattern, but rather to use one of the finalization functions below to clean up the event. EV_FINALIZE has no effect on a single-threaded program, or on a program where events are only used from one thread. There are also two new variants of event_del() that you can use for more fine-grained control: event_del_noblock(ev) event_del_block(ev) The event_del_noblock() function will never block, even if the event callback is running in another thread and doesn't have the EV_FINALIZE flag. The event_del_block() function will _always_ block if the event callback is running in another thread, even if the event _does_ have the EV_FINALIZE flag. [A future version of Libevent may have a way to make the EV_FINALIZE flag the default.] 1.3.3. Safely finalizing events To safely tear down an event that may be running, Libevent 2.1.3-alpha introduces event_finalize() and event_free_finalize(). You call them on an event, and provide a finalizer callback to be run on the event and its callback argument once the event is definitely no longer running. With event_free_finalize(), the event is also freed once the finalizer callback has been invoked. A finalized event cannot be re-added or activated. The finalizer callback must not add events, activate events, or attempt to "resucitate" the event being finalized in any way. If any finalizer callbacks are pending as the event_base is being freed, they will be invoked. You can override this behavior with the new function event_base_free_nofinalize(). 1.4. New debugging features You can now turn on debug logs at runtime using a new function, event_enable_debug_logging(). The event_enable_lock_debugging() function is now spelled correctly. You can still use the old "event_enable_lock_debuging" name, though, so your old programs shouldnt' break. There's also been some work done to try to make the debugging logs more generally useful. 1.5. New evbuffer functions In Libevent 2.0, we introduced evbuffer_add_file() to add an entire file's contents to an evbuffer, and then send them using sendfile() or mmap() as appropriate. This API had some drawbacks, however. Notably, it created one mapping or fd for every instance of the same file added to any evbuffer. Also, adding a file to an evbuffer could make that buffer unusable with SSL bufferevents, filtering bufferevents, and any code that tried to read the contents of the evbuffer. Libevent 2.1 adds a new evbuffer_file_segment API to solve these problems. Now, you can use evbuffer_file_segment_new() to construct a file-segment object, and evbuffer_add_file_segment() to insert it (or part of it) into an evbuffer. These segments avoid creating redundant maps or fds. Better still, the code is smart enough (when the OS supports sendfile) to map the file when that's necessary, and use sendfile() otherwise. File segments can receive callback functions that are invoked when the file segments are freed. The evbuffer_ptr interface has been extended so that an evbuffer_ptr can now yield a point just after the end of the buffer. This makes many algorithms simpler to implement. There's a new evbuffer_add_buffer() interface that you can use to add one buffer to another nondestructively. When you say evbuffer_add_buffer_reference(outbuf, inbuf), outbuf now contains a reference to the contents of inbuf. To aid in adding data in bulk while minimizing evbuffer calls, there is an evbuffer_add_iovec() function. There's a new evbuffer_copyout_from() variant function to enable copying data nondestructively from the middle of a buffer. evbuffer_readln() now supports an EVBUFFER_EOL_NUL argument to fetch NUL-terminated strings from buffers. 1.6. New functions and features: bufferevents You can now use the bufferevent_getcb() function to find out a bufferevent's callbacks. Previously, there was no supported way to do that. The largest chunk readable or writeable in a single bufferevent callback is no longer hardcoded; it's now configurable with the new functions bufferevent_set_max_single_read() and bufferevent_set_max_single_write(). For consistency, OpenSSL bufferevents now make sure to always set one of BEV_EVENT_READING or BEV_EVENT_WRITING when invoking an event callback. Calling bufferevent_set_timeouts(bev, NULL, NULL) now removes the timeouts from socket and ssl bufferevents correctly. You can find the priority at which a bufferevent runs with bufferevent_get_priority(). The function bufferevent_get_token_bucket_cfg() can retrieve the rate-limit settings for a bufferevent; bufferevent_getwatermark() can return a bufferevent's current watermark settings. You can manually trigger a bufferevent's callbacks via bufferevent_trigger() and bufferevent_trigger_event(). 1.7. New functions and features: evdns The previous evdns interface used an "open a test UDP socket" trick in order to detect IPv6 support. This was a hack, since it would sometimes badly confuse people's firewall software, even though no packets were sent. The current evdns interface-detection code uses the appropriate OS functions to see which interfaces are configured. The evdns_base_new() function now has multiple possible values for its second (flags) argument. Using 1 and 0 have their old meanings, though the 1 flag now has a symbolic name of EVDNS_BASE_INITIALIZE_NAMESERVERS. A second flag is now supported too: the EVDNS_BASE_DISABLE_WHEN_INACTIVE flag, which tells the evdns_base that it should not prevent Libevent from exiting while it has no DNS requests in progress. There is a new evdns_base_clear_host_addresses() function to remove all the /etc/hosts addresses registered with an evdns instance. 1.8. New functions and features: evconnlistener Libevent 2.1 adds the following evconnlistener flags: LEV_OPT_DEFERRED_ACCEPT -- Tells the OS that it doesn't need to report sockets as having arrived until the initiator has sent some data too. This can greatly improve performance with protocols like HTTP where the client always speaks first. On operating systems that don't support this functionality, this option has no effect. LEV_OPT_DISABLED -- Creates an evconnlistener in the disabled (not listening) state. Libevent 2.1 changes the behavior of the LEV_OPT_CLOSE_ON_EXEC flag. Previously, it would apply to the listener sockets, but not to the accepted sockets themselves. That's almost never what you want. Now, it applies both to the listener and the accepted sockets. 1.9. New functions and features: evhttp ********************************************************************** NOTE: The evhttp module will eventually be deprecated in favor of Mark Ellzey's libevhtp library. Don't worry -- this won't happen until libevhtp provides every feature that evhttp does, and provides a compatible interface that applications can use to migrate. ********************************************************************** Previously, you could only set evhttp timeouts in increments of one second. Now, you can use evhttp_set_timeout_tv() and evhttp_connection_set_timeout_tv() to configure microsecond-granularity timeouts. There are a new pair of functions: evhttp_set_bevcb() and evhttp_connection_base_bufferevent_new(), that you can use to configure which bufferevents will be used for incoming and outgoing http connections respectively. These functions, combined with SSL bufferevents, should enable HTTPS support. There's a new evhttp_foreach_bound_socket() function to iterate over every listener on an evhttp object. Whitespace between lines in headers is now folded into a single space; whitespace at the end of a header is now removed. The socket errno value is now preserved when invoking an http error callback. There's a new kind of request callback for errors; you can set it with evhttp_request_set_error_cb(). It gets called when there's a request error, and actually reports the error code and lets you figure out which request failed. You can navigate from an evhttp_connection back to its evhttp with the new evhttp_connection_get_server() function. You can override the default HTTP Content-Type with the new evhttp_set_default_content_type() function There's a new evhttp_connection_get_addr() API to return the peer address of an evhttp_connection. The new evhttp_send_reply_chunk_with_cb() is a variant of evhttp_send_reply_chunk() with a callback to be invoked when the chunk is sent. The evhttp_request_set_header_cb() facility adds a callback to be invoked while parsing headers. The evhttp_request_set_on_complete_cb() facility adds a callback to be invoked on request completion. 1.10. New functions and features: evutil There's a function "evutil_secure_rng_set_urandom_device_file()" that you can use to override the default file that Libevent uses to seed its (sort-of) secure RNG. 2. Cross-platform performance improvements 2.1. Better data structures We replaced several users of the sys/queue.h "TAILQ" data structure with the "LIST" data structure. Because this data type doesn't require FIFO access, it requires fewer pointer checks and manipulations to keep it in line. All previous versions of Libevent have kept every pending (added) event in an "eventqueue" data structure. Starting in Libevent 2.0, however, this structure became redundant: every pending timeout event is stored in the timeout heap or in one of the common_timeout queues, and every pending fd or signal event is stored in an evmap. Libevent 2.1 removes this data structure, and thereby saves all of the code that we'd been using to keep it updated. 2.2. Faster activations and timeouts It's a common pattern in older code to use event_base_once() with a 0-second timeout to ensure that a callback will get run 'as soon as possible' in the current iteration of the Libevent loop. We optimize this case by calling event_active() directly, and bypassing the timeout pool. (People who are using this pattern should also consider using event_active() themselves.) Libevent 2.0 would wake up a polling event loop whenever the first timeout in the event loop was adjusted--whether it had become earlier or later. We now only notify the event loop when a change causes the expiration time to become _sooner_ than it would have been otherwise. The timeout heap code is now optimized to perform fewer comparisons and shifts when changing or removing a timeout. Instead of checking for a wall-clock time jump every time we call clock_gettime(), we now check only every 5 seconds. This should save a huge number of gettimeofday() calls. 2.3. Microoptimizations Internal event list maintainance no longer use the antipattern where we have one function with multiple totally independent behaviors depending on an argument: #define OP1 1 #define OP2 2 #define OP3 3 void func(int operation, struct event *ev) { switch (op) { ... } } Instead, these functions are now split into separate functions for each operation: void func_op1(struct event *ev) { ... } void func_op2(struct event *ev) { ... } void func_op3(struct event *ev) { ... } This produces better code generation and inlining decisions on some compilers, and makes the code easier to read and check. 2.4. Evbuffer performance improvements The EVBUFFER_EOL_CRLF line-ending type is now much faster, thanks to smart optimizations. 2.5. HTTP performance improvements o Performance tweak to evhttp_parse_request_line. (aee1a97 Mark Ellzey) o Add missing break to evhttp_parse_request_line (0fcc536) 2.6. Coarse timers by default on Linux Due to limitations of the epoll interface, Libevent programs using epoll have not previously been able to wait for timeouts with accuracy smaller than 1 millisecond. But Libevent had been using CLOCK_MONOTONIC for timekeeping on Linux, which is needlessly expensive: CLOCK_MONOTONIC_COARSE has approximately the resolution corresponding to epoll, and is much faster to invoke than CLOCK_MONOTONIC. To disable coarse timers, and get a more plausible precision, use the new EVENT_BASE_FLAG_PRECISE_TIMER flag when setting up your event base. 3. Backend/OS-specific improvements 3.1. Linux-specific improvements The logic for deciding which arguements to use with epoll_ctl() is now a table-driven lookup, rather than the previous pile of cascading branches. This should minimize epoll_ctl() calls and make the epoll code run a little faster on change-heavy loads. Libevent now takes advantage of Linux's support for enhanced APIs (e.g., SOCK_CLOEXEC, SOCK_NONBLOCK, accept4, pipe2) that allow us to simultaneously create a socket, make it nonblocking, and make it close-on-exec. This should save syscalls throughout our codebase, and avoid race-conditions if an exec() occurs after a socket is socket is created but before we can make it close-on-execute on it. 3.2. Windows-specific improvements We now use GetSystemTimeAsFileTime to implement gettimeofday. It's significantly faster and more accurate than our old ftime()-based approach. 3.3. Improvements in the solaris evport backend. The evport backend has been updated to use many of the infrastructure improvements from Libevent 2.0. Notably, it keeps track of per-fd information using the evmap infrastructure, and removes a number of linear scans over recently-added events. This last change makes it efficient to receive many more events per evport_getn() call, thereby reducing evport overhead in general. 3.4. OSX backend improvements The OSX select backend doesn't like to have more than a certain number of fds set unless an "unlimited select" option has been set. Therefore, we now set it. 3.5. Monotonic clocks on even more platforms Libevent previously used a monotonic clock for its internal timekeeping only on platforms supporting the POSIX clock_gettime() interface. Now, Libevent has support for monotonic clocks on OSX and Windows too, and a fallback implementation for systems without monotonic clocks that will at least keep time running forwards. Using monotonic timers makes Libevent more resilient to changes in the system time, as can happen in small amounts due to clock adjustments from NTP, or in large amounts due to users who move their system clocks all over the timeline in order to keep nagware from nagging them. 3.6. Faster cross-thread notification on kqueue When a thread other than the one in which the main event loop is running needs to wake the thread running the main event loop, Libevent usually writes to a socketpair in order to force the main event loop to wake up. On Linux, we've been able to use eventfd() instead. Now on BSD and OSX systems (any anywhere else that has kqueue with the EVFILT_USER extension), we can use EVFILT_USER to wake up the main thread from kqueue. This should be a tiny bit faster than the previous approach. 4. Infrastructure improvements 4.1. Faster tests I've spent some time to try to make the unit tests run faster in Libevent 2.1. Nearly all of this was a matter of searching slow tests for unreasonably long timeouts, and cutting them down to reasonably long delays, though on one or two cases I actually had to parallelize an operation or improve an algorithm. On my desktop, a full "make verify" run of Libevent 2.0.18-stable requires about 218 seconds. Libevent 2.1.1-alpha cuts this down to about 78 seconds. Faster unit tests are great, since they let programmers test their changes without losing their train of thought. 4.2. Finicky tests are now off-by-default The Tinytest unit testing framework now supports optional tests, and Libevent uses them. By default, Libevent's unit testing framework does not run tests that require a working network, and does not run tests that tend to fail on heavily loaded systems because of timing issues. To re-enable all tests, run ./test/regress using the "@all" alias. 4.3. Modernized use of autotools Our autotools-based build system has been updated to build without warnings on recent autoconf/automake versions. Libevent's autotools makefiles are no longer recursive. This allows make to use the maximum possible parallelism to do the minimally necessary amount of work. See Peter Miller's "Recursive Make Considered Harmful" at http://miller.emu.id.au/pmiller/books/rmch/ for more information here. We now use the "quiet build" option to suppress distracting messages about which commandlines are running. You can get them back with "make V=1". 4.4. Portability Libevent now uses large-file support internally on platforms where it matters. You shouldn't need to set _LARGEFILE or OFFSET_BITS or anything magic before including the Libevent headers, either, since Libevent now sets the size of ev_off_t to the size of off_t that it received at compile time, not to some (possibly different) size based on current macro definitions when your program is building. We now also use the Autoconf AC_USE_SYSTEM_EXTENSIONS mechanism to enable per-system macros needed to enable not-on-by-default features. Unlike the rest of the autoconf macros, we output these to an internal-use-only evconfig-private.h header, since their names need to survive unmangled. This lets us build correctly on more platforms, and avoid inconsistencies when some files define _GNU_SOURCE and others don't. Libevent now tries to detect OpenSSL via pkg-config. 4.5. Standards conformance Previous Libevent versions had no consistent convention for internal vs external identifiers, and used identifiers starting with the "_" character throughout the codebase. That's no good, since the C standard says that identifiers beginning with _ are reserved. I'm not aware of having any collisions with system identifiers, but it's best to fix these things before they cause trouble. We now avoid all use of the _identifiers in the Libevent source code. These changes were made *mainly* through the use of automated scripts, so there shouldn't be any mistakes, but you never know. As an exception, the names _EVENT_LOG_DEBUG, _EVENT_LOG_MSG_, _EVENT_LOG_WARN, and _EVENT_LOG_ERR are still exposed in event.h: they are now deprecated, but to support older code, they will need to stay around for a while. New code should use EVENT_LOG_DEBUG, EVENT_LOG_MSG, EVENT_LOG_WARN, and EVENT_LOG_ERR instead. 4.6. Event and callback refactoring As a simplification and optimization to Libevent's "deferred callback" logic (introduced in 2.0 to avoid callback recursion), Libevent now treats all of its deferrable callback types using the same logic it uses for active events. Now deferred events no longer cause priority inversion, no longer require special code to cancel them, and so on. Regular events and deferred callbacks now both descend from an internal light-weight event_callback supertype, and both support priorities and take part in the other anti-priority-inversion mechanisms in Libevent. To avoid starvation from callback recursion (which was the reason we introduced "deferred callbacks" in the first place) the implementation now allows an event callback to be scheduled as "active later": instead of running in the current iteration of the event loop, it runs in the next one. 5. Testing Libevent's test coverage level is more or less unchanged since before: we still have over 80% line coverage in our tests on Linux and OSX. There are some under-tested modules, though: we need to fix those.
Upload File
Create Folder