Changeset 43114c5 in mainline for src/proc/scheduler.c


Ignore:
Timestamp:
2005-04-09T18:22:53Z (20 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
8262010
Parents:
e6ba9a3f
Message:

Introduce macros CPU, THREAD, TASK and use them to replace the→cpu, the→thread, the→task.
Later on, this will make it possible to reference *current* cpu, thread and/or task without the aid from virtual memory.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/proc/scheduler.c

    re6ba9a3f r43114c5  
    7070        cpu_priority_high();
    7171
    72         spinlock_lock(&the->cpu->lock);
    73         n = the->cpu->nrdy;
    74         spinlock_unlock(&the->cpu->lock);
     72        spinlock_lock(&CPU->lock);
     73        n = CPU->nrdy;
     74        spinlock_unlock(&CPU->lock);
    7575
    7676        cpu_priority_low();
    … …  
    8282                 * set CPU-private flag that the kcpulb has been started.
    8383                 */
    84                 if (test_and_set(&the->cpu->kcpulbstarted) == 0) {
    85                         waitq_wakeup(&the->cpu->kcpulb_wq, 0);
     84                if (test_and_set(&CPU->kcpulbstarted) == 0) {
     85                        waitq_wakeup(&CPU->kcpulb_wq, 0);
    8686                        goto loop;
    8787                }
    … …  
    101101
    102102        for (i = 0; i<RQ_COUNT; i++) {
    103                 r = &the->cpu->rq[i];
     103                r = &CPU->rq[i];
    104104                spinlock_lock(&r->lock);
    105105                if (r->n == 0) {
    … …  
    115115                spinlock_unlock(&nrdylock);             
    116116
    117                 spinlock_lock(&the->cpu->lock);
    118                 the->cpu->nrdy--;
    119                 spinlock_unlock(&the->cpu->lock);
     117                spinlock_lock(&CPU->lock);
     118                CPU->nrdy--;
     119                spinlock_unlock(&CPU->lock);
    120120
    121121                r->n--;
    … …  
    130130
    131131                spinlock_lock(&t->lock);
    132                 t->cpu = the->cpu;
     132                t->cpu = CPU;
    133133
    134134                t->ticks = us2ticks((i+1)*10000);
    … …  
    160160
    161161        list_initialize(&head);
    162         spinlock_lock(&the->cpu->lock);
    163         if (the->cpu->needs_relink > NEEDS_RELINK_MAX) {
     162        spinlock_lock(&CPU->lock);
     163        if (CPU->needs_relink > NEEDS_RELINK_MAX) {
    164164                for (i = start; i<RQ_COUNT-1; i++) {
    165165                        /* remember and empty rq[i + 1] */
    166                         r = &the->cpu->rq[i + 1];
     166                        r = &CPU->rq[i + 1];
    167167                        spinlock_lock(&r->lock);
    168168                        list_concat(&head, &r->rq_head);
    … …  
    172172               
    173173                        /* append rq[i + 1] to rq[i] */
    174                         r = &the->cpu->rq[i];
     174                        r = &CPU->rq[i];
    175175                        spinlock_lock(&r->lock);
    176176                        list_concat(&r->rq_head, &head);
    … …  
    178178                        spinlock_unlock(&r->lock);
    179179                }
    180                 the->cpu->needs_relink = 0;
    181         }
    182         spinlock_unlock(&the->cpu->lock);                               
     180                CPU->needs_relink = 0;
     181        }
     182        spinlock_unlock(&CPU->lock);                           
    183183
    184184}
    … …  
    196196                halt();
    197197
    198         if (the->thread) {
    199                 spinlock_lock(&the->thread->lock);
    200                 if (!context_save(&the->thread->saved_context)) {
     198        if (THREAD) {
     199                spinlock_lock(&THREAD->lock);
     200                if (!context_save(&THREAD->saved_context)) {
    201201                        /*
    202202                         * This is the place where threads leave scheduler();
    203203                         */
    204                         spinlock_unlock(&the->thread->lock);
    205                         cpu_priority_restore(the->thread->saved_context.pri);
     204                        spinlock_unlock(&THREAD->lock);
     205                        cpu_priority_restore(THREAD->saved_context.pri);
    206206                        return;
    207207                }
    208                 the->thread->saved_context.pri = pri;
     208                THREAD->saved_context.pri = pri;
    209209        }
    210210
    … …  
    221221         * scheduler_separated_stack().
    222222         */
    223         context_save(&the->cpu->saved_context);
    224         the->cpu->saved_context.sp = (__address) &the->cpu->stack[CPU_STACK_SIZE-8];
    225         the->cpu->saved_context.pc = (__address) scheduler_separated_stack;
    226         context_restore(&the->cpu->saved_context);
     223        context_save(&CPU->saved_context);
     224        CPU->saved_context.sp = (__address) &CPU->stack[CPU_STACK_SIZE-8];
     225        CPU->saved_context.pc = (__address) scheduler_separated_stack;
     226        context_restore(&CPU->saved_context);
    227227        /* not reached */
    228228}
    … …  
    232232        int priority;
    233233
    234         if (the->thread) {
    235                 switch (the->thread->state) {
     234        if (THREAD) {
     235                switch (THREAD->state) {
    236236                    case Running:
    237                             the->thread->state = Ready;
    238                             spinlock_unlock(&the->thread->lock);
    239                             thread_ready(the->thread);
     237                            THREAD->state = Ready;
     238                            spinlock_unlock(&THREAD->lock);
     239                            thread_ready(THREAD);
    240240                            break;
    241241
    242242                    case Exiting:
    243                             frame_free((__address) the->thread->kstack);
    244                             if (the->thread->ustack) {
    245                                     frame_free((__address) the->thread->ustack);
     243                            frame_free((__address) THREAD->kstack);
     244                            if (THREAD->ustack) {
     245                                    frame_free((__address) THREAD->ustack);
    246246                            }
    247247                           
    … …  
    249249                             * Detach from the containing task.
    250250                             */
    251                             spinlock_lock(&the->task->lock);
    252                             list_remove(&the->thread->th_link);
    253                             spinlock_unlock(&the->task->lock);
    254 
    255                             spinlock_unlock(&the->thread->lock);
     251                            spinlock_lock(&TASK->lock);
     252                            list_remove(&THREAD->th_link);
     253                            spinlock_unlock(&TASK->lock);
     254
     255                            spinlock_unlock(&THREAD->lock);
    256256                           
    257257                            spinlock_lock(&threads_lock);
    258                             list_remove(&the->thread->threads_link);
     258                            list_remove(&THREAD->threads_link);
    259259                            spinlock_unlock(&threads_lock);
    260260                           
    261                             free(the->thread);
     261                            free(THREAD);
    262262                           
    263263                            break;
    … …  
    267267                             * Prefer the thread after it's woken up.
    268268                             */
    269                             the->thread->pri = -1;
     269                            THREAD->pri = -1;
    270270
    271271                            /*
    272272                             * We need to release wq->lock which we locked in waitq_sleep().
    273                              * Address of wq->lock is kept in the->thread->sleep_queue.
     273                             * Address of wq->lock is kept in THREAD->sleep_queue.
    274274                             */
    275                             spinlock_unlock(&the->thread->sleep_queue->lock);
     275                            spinlock_unlock(&THREAD->sleep_queue->lock);
    276276
    277277                            /*
    278278                             * Check for possible requests for out-of-context invocation.
    279279                             */
    280                             if (the->thread->call_me) {
    281                                     the->thread->call_me(the->thread->call_me_with);
    282                                     the->thread->call_me = NULL;
    283                                     the->thread->call_me_with = NULL;
     280                            if (THREAD->call_me) {
     281                                    THREAD->call_me(THREAD->call_me_with);
     282                                    THREAD->call_me = NULL;
     283                                    THREAD->call_me_with = NULL;
    284284                            }
    285285
    286                             spinlock_unlock(&the->thread->lock);
     286                            spinlock_unlock(&THREAD->lock);
    287287                           
    288288                            break;
    … …  
    292292                             * Entering state is unexpected.
    293293                             */
    294                             panic("tid%d: unexpected state %s\n", the->thread->tid, thread_states[the->thread->state]);
     294                            panic("tid%d: unexpected state %s\n", THREAD->tid, thread_states[THREAD->state]);
    295295                            break;
    296296                }
    297                 the->thread = NULL;
     297                THREAD = NULL;
    298298        }
    299299   
    300         the->thread = find_best_thread();
     300        THREAD = find_best_thread();
    301301       
    302         spinlock_lock(&the->thread->lock);
    303         priority = the->thread->pri;
    304         spinlock_unlock(&the->thread->lock);   
     302        spinlock_lock(&THREAD->lock);
     303        priority = THREAD->pri;
     304        spinlock_unlock(&THREAD->lock);
    305305       
    306306        relink_rq(priority);           
    307307
    308         spinlock_lock(&the->thread->lock);     
     308        spinlock_lock(&THREAD->lock);   
    309309
    310310        /*
    311311         * If both the old and the new task are the same, lots of work is avoided.
    312312         */
    313         if (the->task != the->thread->task) {
     313        if (TASK != THREAD->task) {
    314314                vm_t *m1 = NULL;
    315315                vm_t *m2;
    316316
    317                 if (the->task) {
    318                         spinlock_lock(&the->task->lock);
    319                         m1 = the->task->vm;
    320                         spinlock_unlock(&the->task->lock);
    321                 }
    322 
    323                 spinlock_lock(&the->thread->task->lock);
    324                 m2 = the->thread->task->vm;
    325                 spinlock_unlock(&the->thread->task->lock);
     317                if (TASK) {
     318                        spinlock_lock(&TASK->lock);
     319                        m1 = TASK->vm;
     320                        spinlock_unlock(&TASK->lock);
     321                }
     322
     323                spinlock_lock(&THREAD->task->lock);
     324                m2 = THREAD->task->vm;
     325                spinlock_unlock(&THREAD->task->lock);
    326326               
    327327                /*
    … …  
    338338                        vm_install(m2);
    339339                }
    340                 the->task = the->thread->task; 
    341         }
    342 
    343         the->thread->state = Running;
     340                TASK = THREAD->task;   
     341        }
     342
     343        THREAD->state = Running;
    344344
    345345        #ifdef SCHEDULER_VERBOSE
    346         printf("cpu%d: tid %d (pri=%d,ticks=%d,nrdy=%d)\n", the->cpu->id, the->thread->tid, the->thread->pri, the->thread->ticks, the->cpu->nrdy);
     346        printf("cpu%d: tid %d (pri=%d,ticks=%d,nrdy=%d)\n", CPU->id, THREAD->tid, THREAD->pri, THREAD->ticks, CPU->nrdy);
    347347        #endif 
    348348
    349         context_restore(&the->thread->saved_context);
     349        context_restore(&THREAD->saved_context);
    350350        /* not reached */
    351351}
    … …  
    366366         * Sleep until there's some work to do.
    367367         */
    368         waitq_sleep(&the->cpu->kcpulb_wq);
     368        waitq_sleep(&CPU->kcpulb_wq);
    369369
    370370not_satisfied:
    … …  
    375375         */
    376376        pri = cpu_priority_high();
    377         spinlock_lock(&the->cpu->lock);
     377        spinlock_lock(&CPU->lock);
    378378        count = nrdy / config.cpu_active;
    379         count -= the->cpu->nrdy;
    380         spinlock_unlock(&the->cpu->lock);
     379        count -= CPU->nrdy;
     380        spinlock_unlock(&CPU->lock);
    381381        cpu_priority_restore(pri);
    382382
    … …  
    400400                         * Doesn't require interrupt disabling for kcpulb is X_WIRED.
    401401                         */
    402                         if (the->cpu == cpu)
     402                        if (CPU == cpu)
    403403                                continue;
    404404
    … …  
    461461                                spinlock_lock(&t->lock);
    462462                                #ifdef KCPULB_VERBOSE
    463                                 printf("kcpulb%d: TID %d -> cpu%d, nrdy=%d, avg=%d\n", the->cpu->id, t->tid, the->cpu->id, the->cpu->nrdy, nrdy / config.cpu_active);
     463                                printf("kcpulb%d: TID %d -> cpu%d, nrdy=%d, avg=%d\n", CPU->id, t->tid, CPU->id, CPU->nrdy, nrdy / config.cpu_active);
    464464                                #endif
    465465                                t->flags |= X_STOLEN;
    … …  
    484484        }
    485485
    486         if (the->cpu->nrdy) {
     486        if (CPU->nrdy) {
    487487                /*
    488488                 * Be a little bit light-weight and let migrated threads run.
    … …  
    504504         * Tell find_best_thread() to wake us up later again.
    505505         */
    506         the->cpu->kcpulbstarted = 0;
     506        CPU->kcpulbstarted = 0;
    507507        goto loop;
    508508}
Note: See TracChangeset for help on using the changeset viewer.