From: Petri Savolainen <petri.savolai...@linaro.org>

Move stash variables into a struct. Use only 16 bits for thread id,
which is enough for 64k threads.

Signed-off-by: Petri Savolainen <petri.savolai...@linaro.org>
---
/** Email created from pull request 699 (psavol:master-sched-optim-clean-ups)
 ** https://github.com/Linaro/odp/pull/699
 ** Patch: https://github.com/Linaro/odp/pull/699.patch
 ** Base sha: 33fbc04b6373960ec3f84de4e7e7b34c49d71508
 ** Merge commit sha: 32d7a11f22e6f2e1e378b653993c5377d4116d8f
 **/
 platform/linux-generic/odp_schedule_basic.c | 62 ++++++++++++---------
 1 file changed, 35 insertions(+), 27 deletions(-)

diff --git a/platform/linux-generic/odp_schedule_basic.c 
b/platform/linux-generic/odp_schedule_basic.c
index e329a8e8c..89c0a5c42 100644
--- a/platform/linux-generic/odp_schedule_basic.c
+++ b/platform/linux-generic/odp_schedule_basic.c
@@ -84,6 +84,10 @@ ODP_STATIC_ASSERT(CHECK_IS_POWER2(ODP_CONFIG_QUEUES),
 ODP_STATIC_ASSERT(CHECK_IS_POWER2(MAX_RING_SIZE),
                  "Ring_size_is_not_power_of_two");
 
+/* Thread ID is saved into uint16_t variable */
+ODP_STATIC_ASSERT(ODP_THREAD_COUNT_MAX < (64 * 1024),
+                 "Max_64k_threads_supported");
+
 /* Mask of queues per priority */
 typedef uint8_t pri_mask_t;
 
@@ -118,19 +122,22 @@ ODP_STATIC_ASSERT(sizeof(lock_called_t) == 
sizeof(uint32_t),
                  "Lock_called_values_do_not_fit_in_uint32");
 
 /* Scheduler local data */
-typedef struct {
-       int thr;
-       uint16_t stash_num;
-       uint16_t stash_index;
+typedef struct ODP_ALIGNED_CACHE {
+       uint16_t thr;
+       uint16_t pause;
        uint16_t grp_round;
        uint16_t spread_round;
-       uint32_t stash_qi;
-       odp_queue_t stash_queue;
-       odp_event_t stash_ev[BURST_SIZE_MAX];
+
+       struct {
+               uint16_t    num_ev;
+               uint16_t    ev_index;
+               uint32_t    qi;
+               odp_queue_t queue;
+               odp_event_t ev[BURST_SIZE_MAX];
+       } stash;
 
        uint32_t grp_epoch;
        uint16_t num_grp;
-       uint16_t pause;
        uint8_t grp[NUM_SCHED_GRPS];
        uint8_t spread_tbl[SPREAD_TBL_SIZE];
        uint8_t grp_weight[GRP_WEIGHT_TBL_SIZE];
@@ -304,8 +311,8 @@ static void sched_local_init(void)
        memset(&sched_local, 0, sizeof(sched_local_t));
 
        sched_local.thr         = odp_thread_id();
-       sched_local.stash_queue = ODP_QUEUE_INVALID;
-       sched_local.stash_qi    = PRIO_QUEUE_EMPTY;
+       sched_local.stash.queue = ODP_QUEUE_INVALID;
+       sched_local.stash.qi    = PRIO_QUEUE_EMPTY;
        sched_local.ordered.src_queue = NULL_INDEX;
 
        spread = prio_spread_index(sched_local.thr);
@@ -445,7 +452,7 @@ static int schedule_init_local(void)
 
 static int schedule_term_local(void)
 {
-       if (sched_local.stash_num) {
+       if (sched_local.stash.num_ev) {
                ODP_ERR("Locally pre-scheduled events exist.\n");
                return -1;
        }
@@ -618,9 +625,9 @@ static void schedule_pktio_start(int pktio_index, int 
num_pktin,
 
 static void schedule_release_atomic(void)
 {
-       uint32_t qi = sched_local.stash_qi;
+       uint32_t qi = sched_local.stash.qi;
 
-       if (qi != PRIO_QUEUE_EMPTY && sched_local.stash_num  == 0) {
+       if (qi != PRIO_QUEUE_EMPTY && sched_local.stash.num_ev  == 0) {
                int grp      = sched->queue[qi].grp;
                int prio     = sched->queue[qi].prio;
                int spread   = sched->queue[qi].spread;
@@ -629,7 +636,7 @@ static void schedule_release_atomic(void)
                /* Release current atomic queue */
                ring_enq(ring, sched->ring_mask, qi);
 
-               sched_local.stash_qi = PRIO_QUEUE_EMPTY;
+               sched_local.stash.qi = PRIO_QUEUE_EMPTY;
        }
 }
 
@@ -717,7 +724,8 @@ static void schedule_release_ordered(void)
 
        queue_index = sched_local.ordered.src_queue;
 
-       if (odp_unlikely((queue_index == NULL_INDEX) || sched_local.stash_num))
+       if (odp_unlikely((queue_index == NULL_INDEX) ||
+                        sched_local.stash.num_ev))
                return;
 
        release_ordered();
@@ -735,10 +743,10 @@ static inline int copy_from_stash(odp_event_t out_ev[], 
unsigned int max)
 {
        int i = 0;
 
-       while (sched_local.stash_num && max) {
-               out_ev[i] = sched_local.stash_ev[sched_local.stash_index];
-               sched_local.stash_index++;
-               sched_local.stash_num--;
+       while (sched_local.stash.num_ev && max) {
+               out_ev[i] = sched_local.stash.ev[sched_local.stash.ev_index];
+               sched_local.stash.ev_index++;
+               sched_local.stash.num_ev--;
                max--;
                i++;
        }
@@ -889,7 +897,7 @@ static inline int do_schedule_grp(odp_queue_t *out_queue, 
odp_event_t out_ev[],
                        int pktin;
                        unsigned int max_deq = max_burst;
                        int stashed = 1;
-                       odp_event_t *ev_tbl = sched_local.stash_ev;
+                       odp_event_t *ev_tbl = sched_local.stash.ev;
 
                        if (id >= num_spread)
                                id = 0;
@@ -984,7 +992,7 @@ static inline int do_schedule_grp(odp_queue_t *out_queue, 
odp_event_t out_ev[],
 
                        } else if (queue_is_atomic(qi)) {
                                /* Hold queue during atomic access */
-                               sched_local.stash_qi = qi;
+                               sched_local.stash.qi = qi;
                        } else {
                                /* Continue scheduling the queue */
                                ring_enq(ring, ring_mask, qi);
@@ -993,12 +1001,12 @@ static inline int do_schedule_grp(odp_queue_t 
*out_queue, odp_event_t out_ev[],
                        handle = queue_from_index(qi);
 
                        if (stashed) {
-                               sched_local.stash_num   = num;
-                               sched_local.stash_index = 0;
-                               sched_local.stash_queue = handle;
+                               sched_local.stash.num_ev   = num;
+                               sched_local.stash.ev_index = 0;
+                               sched_local.stash.queue    = handle;
                                ret = copy_from_stash(out_ev, max_num);
                        } else {
-                               sched_local.stash_num = 0;
+                               sched_local.stash.num_ev = 0;
                                ret = num;
                        }
 
@@ -1025,11 +1033,11 @@ static inline int do_schedule(odp_queue_t *out_queue, 
odp_event_t out_ev[],
        uint16_t spread_round, grp_round;
        uint32_t epoch;
 
-       if (sched_local.stash_num) {
+       if (sched_local.stash.num_ev) {
                ret = copy_from_stash(out_ev, max_num);
 
                if (out_queue)
-                       *out_queue = sched_local.stash_queue;
+                       *out_queue = sched_local.stash.queue;
 
                return ret;
        }

Reply via email to