Trim 22 bytes from struct event on 32 bit platforms, more on 64-bit platforms.

svn:r1292

diff --git a/ChangeLog b/ChangeLog
index 2f1b28d035437a35f15a46591a563eaefc811fd4..baa2654c37ddb155071a998a72c2e0ba1cd49ed3 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -24,6 +24,8 @@ Changes in 2.0.2-alpha:
  o Move the EVBUFFER_INPUT and EVBUFFER_OUTPUT macros to bufferevent_compat.h
  o Add a bufferevent_getfd() function to mirror bufferevent_setfd()
  o Make bufferevent_setfd() return an error code if the operation is not successful.
+ o Shave 22 bytes off struct event on 32-bit platforms by shrinking and re-ordering fields.  The savings on 64-bit platforms is likely higher.
+ o Cap the maximum number of priorities at 256.
 
 Changes in 2.0.1-alpha:
  o free minheap on event_base_free(); from Christopher Layne

diff --git a/event-internal.h b/event-internal.h
index 03ccced5904c7a8a0f81dc65b0ddd9b36890ae0e..e41e5a321ed667caf1acc6d9ec0e5454c604edc1 100644 (file)
--- a/event-internal.h
+++ b/event-internal.h
@@ -50,6 +50,11 @@ extern "C" {
 #define ev_ncalls      _ev.ev_signal.ev_ncalls
 #define ev_pncalls     _ev.ev_signal.ev_pncalls
 
+/* Possible event closures. */
+#define EV_CLOSURE_NONE 0
+#define EV_CLOSURE_SIGNAL 1
+#define EV_CLOSURE_PERSIST 2
+
 /** Structure to define the backend of a given event_base. */
 struct eventop {
        /** The name of this backend. */

diff --git a/event.c b/event.c
index 23aba066925607cb5beeac3ae3167878ad452e97..6e67ece553ed4d7e8726ec95984cc335af4f3cc9 100644 (file)
--- a/event.c
+++ b/event.c
@@ -551,7 +551,8 @@ event_base_priority_init(struct event_base *base, int npriorities)
 {
        int i;
 
-       if (base->event_count_active || npriorities < 1)
+       if (base->event_count_active || npriorities < 1
+           || npriorities >= EVENT_MAX_PRIORITIES)
                return (-1);
 
        if (npriorities == base->nactivequeues)
@@ -648,11 +649,20 @@ event_process_active_single_queue(struct event_base *base,
                EVBASE_RELEASE_LOCK(base,
                    EVTHREAD_WRITE, th_base_lock);
 
-               if (ev->ev_closure != NULL)
-                       (*ev->ev_closure)(base, ev);
-               else
+               switch (ev->ev_closure) {
+               case EV_CLOSURE_SIGNAL:
+                       event_signal_closure(base, ev);
+                       break;
+               case EV_CLOSURE_PERSIST:
+                       event_persist_closure(base, ev);
+                       break;
+               default:
+               case EV_CLOSURE_NONE:
                        (*ev->ev_callback)(
                                (int)ev->ev_fd, ev->ev_res, ev->ev_arg);
+                       break;
+               }
+
                if (base->event_break)
                        return -1;
                EVBASE_ACQUIRE_LOCK(base, EVTHREAD_WRITE, th_base_lock);
@@ -969,13 +979,13 @@ event_set(struct event *ev, evutil_socket_t fd, short events,
                if ((events & (EV_READ|EV_WRITE)) != 0)
                        event_errx(1, "%s: EV_SIGNAL incompatible use",
                            __func__);
-               ev->ev_closure = event_signal_closure;
+               ev->ev_closure = EV_CLOSURE_SIGNAL;
        } else {
                if (events & EV_PERSIST) {
                        timerclear(&ev->ev_io_timeout);
-                       ev->ev_closure = event_persist_closure;
+                       ev->ev_closure = EV_CLOSURE_PERSIST;
                } else {
-                       ev->ev_closure = NULL;
+                       ev->ev_closure = EV_CLOSURE_NONE;
                }
        }
 
@@ -1198,7 +1208,7 @@ event_add_internal(struct event *ev, const struct timeval *tv)
                 * for persistent timeout events, we remember the
                 * timeout value and re-add the event.
                 */
-               if (ev->ev_closure == event_persist_closure)
+               if (ev->ev_closure == EV_CLOSURE_PERSIST)
                        ev->ev_io_timeout = *tv;
 
                /*

diff --git a/include/event2/event.h b/include/event2/event.h
index bb7a77043be46670b7c93b3caa26fad13cc500ea..47a77a363928d381e6be52bf824e52bb82984159 100644 (file)
--- a/include/event2/event.h
+++ b/include/event2/event.h
@@ -546,6 +546,7 @@ ev_uint32_t event_get_version_number(void);
  * headers. */
 #define LIBEVENT_VERSION_NUMBER _EVENT_NUMERIC_VERSION
 
+#define EVENT_MAX_PRIORITIES 256
 /**
   Set the number of different event priorities (threadsafe variant).
 

diff --git a/include/event2/event_struct.h b/include/event2/event_struct.h
index d0a4c234115aadf8d58d985d76fa78cc3ecbbd47..d55dbc6252b5c36389aec7bea54058bd23099130 100644 (file)
--- a/include/event2/event_struct.h
+++ b/include/event2/event_struct.h
@@ -80,10 +80,10 @@ struct event {
        TAILQ_ENTRY (event) (ev_active_next);
        TAILQ_ENTRY (event) (ev_next);
        int min_heap_idx;       /* for managing timeouts */
+       evutil_socket_t ev_fd;
 
        struct event_base *ev_base;
 
-       evutil_socket_t ev_fd;
        union {
                /* used for io events */
                struct {
@@ -101,18 +101,15 @@ struct event {
        } _ev;
 
        short ev_events;
-
+       short ev_res;           /* result passed to event callback */
+       short ev_flags;
+       ev_uint8_t ev_pri;      /* smaller numbers are higher priority */
+       ev_uint8_t ev_closure;
        struct timeval ev_timeout;
 
-       int ev_pri;             /* smaller numbers are higher priority */
-
        /* allows us to adopt for different types of events */
-       void (*ev_closure)(struct event_base *, struct event *);
        void (*ev_callback)(evutil_socket_t, short, void *arg);
        void *ev_arg;
-
-       int ev_res;             /* result passed to event callback */
-       int ev_flags;
 };
 
 #ifdef EVENT_FD