Rename event queue functions [2/2]
authorBarret Rhoden <brho@cs.berkeley.edu>
Thu, 13 Aug 2015 17:40:47 +0000 (13:40 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Mon, 28 Sep 2015 19:14:00 +0000 (15:14 -0400)
The common event queue is one with a mailbox, even if it is bigger.  So
the slim (no mailbox) is the special case.  Likewise, a raw eventq has a
mailbox, but the mailbox has not been initialized yet (used for UCQs and
later for CEQs).  And finally, the vcpd option remains a special case
(it's slim btw).

Nasty Awk for the function prototypes:

{
gsub(/get_event_q_vcpd/, "get_eventq_vcpd")
gsub(/get_event_q/, "get_eventq_slim")
gsub(/get_big_event_q_raw/, "get_eventq_raw")
gsub(/get_big_event_q/, "get_eventq")
gsub(/put_event_q_vcpd/, "put_eventq_vcpd")
gsub(/put_event_q/, "put_eventq_slim")
gsub(/put_big_event_q_raw/, "put_eventq_raw")
gsub(/put_big_event_q/, "put_eventq")
print
}

And spatch for the function calls.  I couldn't get spatch to change the
prototypes.

@@
@@
-get_event_q
+get_eventq_slim
 (...)

@@
@@
-get_big_event_q
+get_eventq
 (...)

@@
@@
-get_big_event_q_raw
+get_eventq_raw
 (...)

@@
@@
-get_event_q_vcpd
+get_eventq_vcpd
 (...)

@@
@@
-put_event_q
+put_eventq_slim
 (...)

@@
@@
-put_big_event_q
+put_eventq
 (...)

@@
@@
-put_big_event_q_raw
+put_eventq_raw
 (...)

@@
@@
-put_event_q_vcpd
+put_eventq_vcpd
 (...)

13 files changed:
tests/alarm.c
tests/evq_block.c
tests/mhello.c
tests/old/msr_nice_while.c
tests/old/syscall.c
user/benchutil/alarm.c
user/benchutil/pvcalarm.c
user/parlib/event.c
user/parlib/include/event.h
user/parlib/signal.c
user/parlib/thread0_sched.c
user/parlib/uthread.c
user/pthread/pthread.c

index 44e0c2a..dae7be6 100644 (file)
@@ -62,7 +62,7 @@ int main(int argc, char **argv)
        /* Since we're doing SPAM_PUBLIC later, we actually don't need a big ev_q.
         * But someone might copy/paste this and change a flag. */
        register_ev_handler(EV_ALARM, handle_alarm, 0);
-       if (!(ev_q = get_big_event_q(EV_MBOX_UCQ))) {
+       if (!(ev_q = get_eventq(EV_MBOX_UCQ))) {
                perror("Failed ev_q");  /* it'll actually PF if malloc fails */
                exit(-1);
        }
index 3a97b99..553181c 100644 (file)
@@ -13,7 +13,7 @@
 
 static struct event_queue *get_ectlr_evq(void)
 {
-       struct event_queue *ev_q = get_big_event_q(EV_MBOX_UCQ);
+       struct event_queue *ev_q = get_eventq(EV_MBOX_UCQ);
        evq_attach_wakeup_ctlr(ev_q);
        return ev_q;
 }
index a0c1bce..5af9b52 100644 (file)
@@ -48,7 +48,7 @@ int main(int argc, char** argv)
        assert(!in_vcore_context());
        
        /* prep indirect ev_q.  Note we grab a big one */
-       indirect_q = get_big_event_q(EV_MBOX_UCQ);
+       indirect_q = get_eventq(EV_MBOX_UCQ);
        indirect_q->ev_flags = EVENT_IPI;
        indirect_q->ev_vcore = 1;                       /* IPI core 1 */
        indirect_q->ev_handler = 0;
@@ -69,7 +69,7 @@ int main(int argc, char** argv)
         * yourself with sys_self_notify(). */
        enable_kevent(EV_USER_IPI, 0, EVENT_IPI | EVENT_VCORE_PRIVATE);
        /* Receive pending preemption events.  (though there's no PP handler) */
-       struct event_queue *ev_q = get_event_q_vcpd(0, EVENT_VCORE_PRIVATE);
+       struct event_queue *ev_q = get_eventq_vcpd(0, EVENT_VCORE_PRIVATE);
        ev_q->ev_flags = EVENT_IPI | EVENT_VCORE_APPRO;
        register_kevent_q(ev_q, EV_PREEMPT_PENDING);
        /* We also receive preemption events, it is set up in uthread.c */
index dbefb70..a10b090 100644 (file)
@@ -23,7 +23,7 @@ int main(int argc, char** argv)
        /* set up to receive the PREEMPT_PENDING event.  EVENT_VCORE_APPRO tells the
         * kernel to send the msg to whichever vcore is appropriate.  Pthread code
         * will see the preemption and yield. */
-       struct event_queue *ev_q = get_event_q_vcpd(0, EVENT_VCORE_PRIVATE);
+       struct event_queue *ev_q = get_eventq_vcpd(0, EVENT_VCORE_PRIVATE);
        ev_q->ev_flags = EVENT_IPI | EVENT_VCORE_APPRO;
        register_kevent_q(ev_q, EV_PREEMPT_PENDING);
 
index c7a7eb0..3833308 100644 (file)
@@ -29,7 +29,7 @@ int main(int argc, char** argv)
 
        printf("Trying to block\n");
        /* Not doing anything else to it: no EVENT_IPI yet, etc. */
-       ev_q = get_big_event_q();
+       ev_q = get_eventq();
        /* issue the diagnostic block syscall */
        sysc.num = SYS_block;
        sysc.arg0 = 5000;       /* 5ms */
@@ -84,7 +84,7 @@ int main(int argc, char** argv)
        printf("Syscall unblocked, IPI broke me out of the loop.\n");
 
        /* done */
-       put_big_event_q(ev_q);
+       put_eventq(ev_q);
        printf("Syscall test exiting\n");
        return 0;
 }
index e20909f..87d690e 100644 (file)
@@ -168,7 +168,7 @@ static void init_alarm_service(void)
        /* Since we're doing SPAM_PUBLIC later, we actually don't need a big ev_q.
         * But someone might copy/paste this and change a flag. */
        register_ev_handler(EV_ALARM, handle_user_alarm, 0);
-       if (!(ev_q = get_big_event_q(EV_MBOX_UCQ))) {
+       if (!(ev_q = get_eventq(EV_MBOX_UCQ))) {
                perror("Useralarm: Failed ev_q");
                return;
        }
index 3ba5b99..59c7812 100644 (file)
@@ -205,7 +205,7 @@ static void init_pvcalarm(struct pvcalarm_data *pvcalarm_data, int vcoreid)
        }
        register_ev_handler(EV_ALARM, handle_pvcalarm, 0);
        ev_flags = EVENT_IPI | EVENT_VCORE_PRIVATE;
-       ev_q = get_event_q_vcpd(vcoreid, ev_flags);
+       ev_q = get_eventq_vcpd(vcoreid, ev_flags);
        if (!ev_q) {
                perror("Pvcalarm: Failed ev_q");
                return;
index 250a62d..e269b4e 100644 (file)
@@ -41,7 +41,7 @@ __thread uint32_t __vc_rem_vcoreid;
  *
  * Use the 'regular' one for big_qs if you don't want to worry about the mbox
  * initalization */
-struct event_queue *get_big_event_q_raw(void)
+struct event_queue *get_eventq_raw(void)
 {
        /* TODO: (PIN) should be pinned memory */
        struct event_queue_big *big_q = malloc(sizeof(struct event_queue_big));
@@ -50,9 +50,9 @@ struct event_queue *get_big_event_q_raw(void)
        return (struct event_queue*)big_q;
 }
 
-struct event_queue *get_big_event_q(int mbox_type)
+struct event_queue *get_eventq(int mbox_type)
 {
-       struct event_queue *big_q = get_big_event_q_raw();
+       struct event_queue *big_q = get_eventq_raw();
        event_mbox_init(big_q->ev_mbox, mbox_type);
        return big_q;
 }
@@ -79,7 +79,7 @@ void event_mbox_init(struct event_mbox *ev_mbox, int mbox_type)
 
 /* Give it up.  I don't recommend calling these unless you're sure the queues
  * aren't in use (unregistered, etc). (TODO: consider some checks for this) */
-void put_big_event_q_raw(struct event_queue *ev_q)
+void put_eventq_raw(struct event_queue *ev_q)
 {
        /* if we use something other than malloc, we'll need to be aware that ev_q
         * is actually an event_queue_big.  One option is to use the flags, though
@@ -87,10 +87,10 @@ void put_big_event_q_raw(struct event_queue *ev_q)
        free(ev_q);
 }
 
-void put_big_event_q(struct event_queue *ev_q)
+void put_eventq(struct event_queue *ev_q)
 {
        event_mbox_cleanup(ev_q->ev_mbox);
-       put_big_event_q_raw(ev_q);
+       put_eventq_raw(ev_q);
 }
 
 void event_mbox_cleanup(struct event_mbox *ev_mbox)
@@ -109,7 +109,7 @@ void event_mbox_cleanup(struct event_mbox *ev_mbox)
 }
 
 /* Need to point this event_q to an mbox - usually to a vcpd */
-struct event_queue *get_event_q(void)
+struct event_queue *get_eventq_slim(void)
 {
        /* TODO: (PIN) should be pinned memory */
        struct event_queue *ev_q = malloc(sizeof(struct event_queue));
@@ -120,9 +120,9 @@ struct event_queue *get_event_q(void)
 /* Gets a small ev_q, with ev_mbox pointing to the vcpd mbox of vcoreid.  If
  * ev_flags has EVENT_VCORE_PRIVATE set, it'll give you the private mbox.  o/w,
  * you'll get the public one. */
-struct event_queue *get_event_q_vcpd(uint32_t vcoreid, int ev_flags)
+struct event_queue *get_eventq_vcpd(uint32_t vcoreid, int ev_flags)
 {
-       struct event_queue *ev_q = get_event_q();
+       struct event_queue *ev_q = get_eventq_slim();
        if (ev_flags & EVENT_VCORE_PRIVATE)
                ev_q->ev_mbox = &vcpd_of(vcoreid)->ev_mbox_private;
        else
@@ -130,16 +130,16 @@ struct event_queue *get_event_q_vcpd(uint32_t vcoreid, int ev_flags)
        return ev_q;
 }
 
-void put_event_q(struct event_queue *ev_q)
+void put_eventq_slim(struct event_queue *ev_q)
 {
        /* if we use something other than malloc, we'll need to be aware that ev_q
         * is not an event_queue_big. */
        free(ev_q);
 }
 
-void put_event_q_vcpd(struct event_queue *ev_q)
+void put_eventq_vcpd(struct event_queue *ev_q)
 {
-       put_event_q(ev_q);
+       put_eventq_slim(ev_q);
 }
 
 /* Sets ev_q to be the receiving end for kernel event ev_type */
@@ -166,7 +166,7 @@ struct event_queue *clear_kevent_q(unsigned int ev_type)
  * the other event functions together to get similar things done. */
 void enable_kevent(unsigned int ev_type, uint32_t vcoreid, int ev_flags)
 {
-       struct event_queue *ev_q = get_event_q_vcpd(vcoreid, ev_flags);
+       struct event_queue *ev_q = get_eventq_vcpd(vcoreid, ev_flags);
        ev_q->ev_flags = ev_flags;
        ev_q->ev_vcore = vcoreid;
        ev_q->ev_handler = 0;
index 02a4930..fd76a59 100644 (file)
 __BEGIN_DECLS
 
 /********* Event_q Setup / Registration  ***********/
-struct event_queue *get_big_event_q(int mbox_type);
-struct event_queue *get_big_event_q_raw(void);
-struct event_queue *get_event_q(void);
-struct event_queue *get_event_q_vcpd(uint32_t vcoreid, int ev_flags);
-void put_big_event_q(struct event_queue *ev_q);
-void put_big_event_q_raw(struct event_queue *ev_q);
-void put_event_q(struct event_queue *ev_q);
-void put_event_q_vcpd(struct event_queue *ev_q);
+struct event_queue *get_eventq(int mbox_type);
+struct event_queue *get_eventq_raw(void);
+struct event_queue *get_eventq_slim(void);
+struct event_queue *get_eventq_vcpd(uint32_t vcoreid, int ev_flags);
+void put_eventq(struct event_queue *ev_q);
+void put_eventq_raw(struct event_queue *ev_q);
+void put_eventq_slim(struct event_queue *ev_q);
+void put_eventq_vcpd(struct event_queue *ev_q);
 
 void event_mbox_init(struct event_mbox *ev_mbox, int mbox_type);
 void event_mbox_cleanup(struct event_mbox *ev_mbox);
index 2e661dd..23f2f65 100644 (file)
@@ -225,7 +225,7 @@ void init_posix_signals(void)
 {
        struct event_queue *posix_sig_ev_q;
        register_ev_handler(EV_POSIX_SIGNAL, handle_event, 0);
-       posix_sig_ev_q = get_big_event_q(EV_MBOX_UCQ);
+       posix_sig_ev_q = get_eventq(EV_MBOX_UCQ);
        assert(posix_sig_ev_q);
        posix_sig_ev_q->ev_flags = EVENT_IPI | EVENT_INDIR | EVENT_SPAM_INDIR |
                                   EVENT_WAKEUP;
index a2d61af..a1525b5 100644 (file)
@@ -54,7 +54,7 @@ void thread0_lib_init(void)
 {
        memset(&thread0_info, 0, sizeof(thread0_info));
        /* we don't care about the message, so don't bother with a UCQ */
-       sysc_evq = get_big_event_q(EV_MBOX_BITMAP);
+       sysc_evq = get_eventq(EV_MBOX_BITMAP);
        sysc_evq->ev_flags = EVENT_INDIR | EVENT_WAKEUP;
        register_ev_handler(EV_SYSCALL, thread0_handle_syscall, 0);
 }
index 645317e..7bb8c62 100644 (file)
@@ -113,7 +113,7 @@ void uthread_mcp_init()
         * that yielding vcores do not miss the preemption messages. */
        register_ev_handler(EV_VCORE_PREEMPT, handle_vc_preempt, 0);
        register_ev_handler(EV_CHECK_MSGS, handle_vc_indir, 0);
-       preempt_ev_q = get_event_q();   /* small ev_q, mostly a vehicle for flags */
+       preempt_ev_q = get_eventq_slim();       /* small ev_q, mostly a vehicle for flags */
        preempt_ev_q->ev_flags = EVENT_IPI | EVENT_SPAM_PUBLIC | EVENT_VCORE_APPRO |
                                                         EVENT_VCORE_MUST_RUN | EVENT_WAKEUP;
        /* Tell the kernel to use the ev_q (it's settings) for the two types.  Note
index b52554c..ba38dd8 100644 (file)
@@ -636,7 +636,7 @@ void __attribute__((constructor)) pthread_lib_init(void)
         * max_vcores()). */
        for (int i = 0; i < max_vcores(); i++) {
                /* Each vcore needs to point to a non-VCPD ev_q */
-               sysc_mgmt[i].ev_q = get_big_event_q_raw();
+               sysc_mgmt[i].ev_q = get_eventq_raw();
                sysc_mgmt[i].ev_q->ev_flags = EVENT_IPI | EVENT_INDIR |
                                              EVENT_SPAM_INDIR | EVENT_WAKEUP;
                sysc_mgmt[i].ev_q->ev_vcore = i;
@@ -659,7 +659,7 @@ void __attribute__((constructor)) pthread_lib_init(void)
        sysc_mbox->type = EV_MBOX_UCQ;
        ucq_init_raw(&sysc_mbox->ucq, two_pages, two_pages + PGSIZE);
        for (int i = 0; i < max_vcores(); i++) {
-               sysc_mgmt[i].ev_q = get_event_q();
+               sysc_mgmt[i].ev_q = get_eventq_slim();
                sysc_mgmt[i].ev_q->ev_flags = EVENT_IPI | EVENT_INDIR |
                                              EVENT_SPAM_INDIR | EVENT_WAKEUP;
                sysc_mgmt[i].ev_q->ev_vcore = i;