Changeset 62b6d17 in mainline


Ignore:
Timestamp:
2006-12-14T16:47:36Z (18 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
aeaebcc
Parents:
55cc9bc
Message:

introduce uncounted threads, whose accounting doesn't affect accumulated task accounting
run tests in kconsole thread again

Location:
kernel
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/include/proc/thread.h

    r55cc9bc r62b6d17  
    149149        uint64_t cycles;                        /**< Thread accounting. */
    150150        uint64_t last_cycle;            /**< Last sampled cycle. */
     151        bool uncounted;                         /**< Thread doesn't affect accumulated accounting. */
    151152
    152153        int priority;                           /**< Thread's priority. Implemented as index to CPU->rq */
    … …  
    169170
    170171extern void thread_init(void);
    171 extern thread_t *thread_create(void (* func)(void *), void *arg, task_t *task, int flags, char *name);
     172extern thread_t *thread_create(void (* func)(void *), void *arg, task_t *task, int flags, char *name, bool uncounted);
    172173extern void thread_ready(thread_t *t);
    173174extern void thread_exit(void) __attribute__((noreturn));

  • kernel/generic/src/console/cmd.c

    r55cc9bc r62b6d17  
    5757#include <mm/tlb.h>
    5858#include <arch/mm/tlb.h>
    59 #include <mm/as.h>
    6059#include <mm/frame.h>
    6160#include <main/version.h>
    … …  
    860859}
    861860
    862 static void test_wrapper(void *arg)
    863 {
    864         test_t *test = (test_t *) arg;
     861static bool run_test(const test_t *test)
     862{
     863        printf("%s\t\t%s\n", test->name, test->desc);
    865864       
    866865        /* Update and read thread accounting
    … …  
    886885        if (ret == NULL) {
    887886                printf("Test passed\n");
    888 //              return true;
    889                 return;
     887                return true;
    890888        }
    891889
    892890        printf("%s\n", ret);
    893 //      return false;
    894 }
    895 
    896 static bool run_test(const test_t *test)
    897 {
    898         printf("%s\t\t%s\n", test->name, test->desc);
    899        
    900         /* Create separate task and thread
    901            for the test */
    902         task_t *ta = task_create(AS_KERNEL, "test");
    903         if (ta == NULL) {
    904                 printf("Unable to create test task\n");
    905                 return false;
    906         }
    907        
    908         thread_t *t = thread_create(test_wrapper, (void *) test, ta, 0, "test_main");
    909         if (t == NULL) {
    910                 printf("Unable to create test main thread\n");
    911                 task_destroy(ta);
    912                 return false;
    913         }
    914        
    915         /* Run the test */
    916         thread_ready(t);
    917         thread_join(t);
    918         thread_detach(t);
    919        
    920         return true;
     891        return false;
    921892}
    922893

  • kernel/generic/src/main/kinit.c

    r55cc9bc r62b6d17  
    9999                 * Just a beautification.
    100100                 */
    101                 if ((t = thread_create(kmp, NULL, TASK, THREAD_FLAG_WIRED, "kmp"))) {
     101                if ((t = thread_create(kmp, NULL, TASK, THREAD_FLAG_WIRED, "kmp", true))) {
    102102                        spinlock_lock(&t->lock);
    103103                        t->cpu = &cpus[0];
    … …  
    124124                for (i = 0; i < config.cpu_count; i++) {
    125125
    126                         if ((t = thread_create(kcpulb, NULL, TASK, THREAD_FLAG_WIRED, "kcpulb"))) {
     126                        if ((t = thread_create(kcpulb, NULL, TASK, THREAD_FLAG_WIRED, "kcpulb", true))) {
    127127                                spinlock_lock(&t->lock);                       
    128128                                t->cpu = &cpus[i];
    … …  
    144144         * Create kernel console.
    145145         */
    146         if ((t = thread_create(kconsole, "kconsole", TASK, 0, "kconsole")))
     146        if ((t = thread_create(kconsole, "kconsole", TASK, 0, "kconsole", false)))
    147147                thread_ready(t);
    148148        else

  • kernel/generic/src/main/main.c

    r55cc9bc r62b6d17  
    267267         * Create the first thread.
    268268         */
    269         t = thread_create(kinit, NULL, k, 0, "kinit");
     269        t = thread_create(kinit, NULL, k, 0, "kinit", true);
    270270        if (!t)
    271271                panic("can't create kinit thread\n");

  • kernel/generic/src/proc/task.c

    r55cc9bc r62b6d17  
    221221         * Create the main thread.
    222222         */
    223         t1 = thread_create(uinit, kernel_uarg, task, THREAD_FLAG_USPACE, "uinit");
     223        t1 = thread_create(uinit, kernel_uarg, task, THREAD_FLAG_USPACE, "uinit", false);
    224224        ASSERT(t1);
    225225       
    … …  
    227227         * Create killer thread for the new task.
    228228         */
    229         t2 = thread_create(ktaskgc, t1, task, 0, "ktaskgc");
     229        t2 = thread_create(ktaskgc, t1, task, 0, "ktaskgc", true);
    230230        ASSERT(t2);
    231231        thread_ready(t2);
    … …  
    286286               
    287287                spinlock_lock(&thr->lock);
    288                
    289                 if (thr == THREAD) /* Update accounting of current thread */
    290                         thread_update_accounting();
    291                 ret += thr->cycles;
    292                
     288                /* Process only counted threads */
     289                if (!thr->uncounted) {
     290                        if (thr == THREAD) /* Update accounting of current thread */
     291                                thread_update_accounting();
     292                        ret += thr->cycles;
     293                }
    293294                spinlock_unlock(&thr->lock);
    294295        }
    … …  
    329330        spinlock_unlock(&tasks_lock);
    330331       
    331         t = thread_create(ktaskclnp, NULL, ta, 0, "ktaskclnp");
     332        t = thread_create(ktaskclnp, NULL, ta, 0, "ktaskclnp", true);
    332333       
    333334        spinlock_lock(&ta->lock);

  • kernel/generic/src/proc/thread.c

    r55cc9bc r62b6d17  
    124124       
    125125        spinlock_lock(&THREAD->lock);
    126         thread_update_accounting();
    127         uint64_t cycles = THREAD->cycles;
    128         THREAD->cycles = 0;
    129         spinlock_unlock(&THREAD->lock);
    130        
    131         spinlock_lock(&TASK->lock);
    132         TASK->cycles += cycles;
    133         spinlock_unlock(&TASK->lock);
     126        if (!THREAD->uncounted) {
     127                thread_update_accounting();
     128                uint64_t cycles = THREAD->cycles;
     129                THREAD->cycles = 0;
     130                spinlock_unlock(&THREAD->lock);
     131               
     132                spinlock_lock(&TASK->lock);
     133                TASK->cycles += cycles;
     134                spinlock_unlock(&TASK->lock);
     135        } else
     136                spinlock_unlock(&THREAD->lock);
    134137       
    135138        interrupts_restore(ipl);
    … …  
    303306 * Create a new thread.
    304307 *
    305  * @param func  Thread's implementing function.
    306  * @param arg   Thread's implementing function argument.
    307  * @param task  Task to which the thread belongs.
    308  * @param flags Thread flags.
    309  * @param name  Symbolic name.
     308 * @param func      Thread's implementing function.
     309 * @param arg       Thread's implementing function argument.
     310 * @param task      Task to which the thread belongs.
     311 * @param flags     Thread flags.
     312 * @param name      Symbolic name.
     313 * @param uncounted Thread's accounting doesn't affect accumulated task accounting.
    310314 *
    311315 * @return New thread's structure on success, NULL on failure.
    312316 *
    313317 */
    314 thread_t *thread_create(void (* func)(void *), void *arg, task_t *task, int flags, char *name)
     318thread_t *thread_create(void (* func)(void *), void *arg, task_t *task, int flags, char *name, bool uncounted)
    315319{
    316320        thread_t *t;
    … …  
    345349        t->ticks = -1;
    346350        t->cycles = 0;
     351        t->uncounted = uncounted;
    347352        t->priority = -1;               /* start in rq[0] */
    348353        t->cpu = NULL;
    … …  
    650655        }
    651656
    652         if ((t = thread_create(uinit, kernel_uarg, TASK, THREAD_FLAG_USPACE, namebuf))) {
     657        if ((t = thread_create(uinit, kernel_uarg, TASK, THREAD_FLAG_USPACE, namebuf, false))) {
    653658                tid = t->tid;
    654659                thread_ready(t);

  • kernel/test/fpu/fpu1.c

    r55cc9bc r62b6d17  
    186186                thread_t *t;
    187187               
    188                 if (!(t = thread_create(e, NULL, TASK, 0, "e"))) {
     188                if (!(t = thread_create(e, NULL, TASK, 0, "e", false))) {
    189189                        printf("could not create thread %d\n", 2 * i);
    190190                        break;
    … …  
    193193                total++;
    194194               
    195                 if (!(t = thread_create(pi, NULL, TASK, 0, "pi"))) {
     195                if (!(t = thread_create(pi, NULL, TASK, 0, "pi", false))) {
    196196                        printf("could not create thread %d\n", 2 * i + 1);
    197197                        break;

  • kernel/test/fpu/mips2.c

    r55cc9bc r62b6d17  
    123123                thread_t *t;
    124124               
    125                 if (!(t = thread_create(testit1, (void *) ((unative_t) 2 * i), TASK, 0, "testit1"))) {
     125                if (!(t = thread_create(testit1, (void *) ((unative_t) 2 * i), TASK, 0, "testit1", false))) {
    126126                        printf("could not create thread %d\n", 2 * i);
    127127                        break;
    … …  
    130130                total++;
    131131               
    132                 if (!(t = thread_create(testit2, (void *) ((unative_t) 2 * i + 1), TASK, 0, "testit2"))) {
     132                if (!(t = thread_create(testit2, (void *) ((unative_t) 2 * i + 1), TASK, 0, "testit2", false))) {
    133133                        printf("could not create thread %d\n", 2 * i + 1);
    134134                        break;

  • kernel/test/fpu/sse1.c

    r55cc9bc r62b6d17  
    122122                thread_t *t;
    123123               
    124                 if (!(t = thread_create(testit1, (void *) ((unative_t) 2 * i), TASK, 0, "testit1"))) {
     124                if (!(t = thread_create(testit1, (void *) ((unative_t) 2 * i), TASK, 0, "testit1", false))) {
    125125                        printf("could not create thread %d\n", 2 * i);
    126126                        break;
    … …  
    129129                total++;
    130130               
    131                 if (!(t = thread_create(testit2, (void *) ((unative_t) 2 * i + 1), TASK, 0, "testit2"))) {
     131                if (!(t = thread_create(testit2, (void *) ((unative_t) 2 * i + 1), TASK, 0, "testit2", false))) {
    132132                        printf("could not create thread %d\n", 2 * i + 1);
    133133                        break;

  • kernel/test/mm/falloc2.c

    r55cc9bc r62b6d17  
    108108               
    109109        for (i = 0; i < THREADS; i++) {
    110                 thread_t * thrd = thread_create(falloc, NULL, TASK, 0, "falloc");
     110                thread_t * thrd = thread_create(falloc, NULL, TASK, 0, "falloc", false);
    111111                if (!thrd) {
    112112                        printf("Could not create thread %d\n", i);

  • kernel/test/mm/slab1.c

    r55cc9bc r62b6d17  
    139139        semaphore_initialize(&thr_sem, 0);
    140140        for (i = 0; i < THREADS; i++) { 
    141                 if (!(t = thread_create(slabtest, (void *) (unative_t) i, TASK, 0, "slabtest")))
     141                if (!(t = thread_create(slabtest, (void *) (unative_t) i, TASK, 0, "slabtest", false)))
    142142                        printf("Could not create thread %d\n", i);
    143143                else

  • kernel/test/mm/slab2.c

    r55cc9bc r62b6d17  
    191191        semaphore_initialize(&thr_sem,0);
    192192        for (i = 0; i < THREADS; i++) { 
    193                 if (!(t = thread_create(slabtest, NULL, TASK, 0, "slabtest")))
     193                if (!(t = thread_create(slabtest, NULL, TASK, 0, "slabtest", false)))
    194194                        printf("Could not create thread %d\n", i);
    195195                else

  • kernel/test/synch/rwlock2.c

    r55cc9bc r62b6d17  
    6767        rwlock_read_lock(&rwlock);     
    6868       
    69         thrd = thread_create(writer, NULL, TASK, 0, "writer");
     69        thrd = thread_create(writer, NULL, TASK, 0, "writer", false);
    7070        if (thrd)
    7171                thread_ready(thrd);

  • kernel/test/synch/rwlock3.c

    r55cc9bc r62b6d17  
    6565       
    6666        for (i = 0; i < 4; i++) {
    67                 thrd = thread_create(reader, NULL, TASK, 0, "reader");
     67                thrd = thread_create(reader, NULL, TASK, 0, "reader", false);
    6868                if (thrd)
    6969                        thread_ready(thrd);

  • kernel/test/synch/rwlock4.c

    r55cc9bc r62b6d17  
    131131        printf("Creating %d readers\n", k);
    132132        for (i = 0; i < k; i++) {
    133                 thrd = thread_create(reader, NULL, TASK, 0, "reader");
     133                thrd = thread_create(reader, NULL, TASK, 0, "reader", false);
    134134                if (thrd)
    135135                        thread_ready(thrd);
    … …  
    141141        printf("Creating %d writers\n", k);
    142142        for (i = 0; i < k; i++) {
    143                 thrd = thread_create(writer, NULL, TASK, 0, "writer");
     143                thrd = thread_create(writer, NULL, TASK, 0, "writer", false);
    144144                if (thrd)
    145145                        thread_ready(thrd);

  • kernel/test/synch/rwlock5.c

    r55cc9bc r62b6d17  
    8888                for (j = 0; j < (READERS + WRITERS) / 2; j++) {
    8989                        for (k = 0; k < i; k++) {
    90                                 thrd = thread_create(reader, NULL, TASK, 0, "reader");
     90                                thrd = thread_create(reader, NULL, TASK, 0, "reader", false);
    9191                                if (thrd)
    9292                                        thread_ready(thrd);
    … …  
    9595                        }
    9696                        for (k = 0; k < (4 - i); k++) {
    97                                 thrd = thread_create(writer, NULL, TASK, 0, "writer");
     97                                thrd = thread_create(writer, NULL, TASK, 0, "writer", false);
    9898                                if (thrd)
    9999                                        thread_ready(thrd);

  • kernel/test/synch/semaphore1.c

    r55cc9bc r62b6d17  
    9191                for (j = 0; j < (CONSUMERS + PRODUCERS) / 2; j++) {
    9292                        for (k = 0; k < i; k++) {
    93                                 thrd = thread_create(consumer, NULL, TASK, 0, "consumer");
     93                                thrd = thread_create(consumer, NULL, TASK, 0, "consumer", false);
    9494                                if (thrd)
    9595                                        thread_ready(thrd);
    … …  
    9898                        }
    9999                        for (k = 0; k < (4 - i); k++) {
    100                                 thrd = thread_create(producer, NULL, TASK, 0, "producer");
     100                                thrd = thread_create(producer, NULL, TASK, 0, "producer", false);
    101101                                if (thrd)
    102102                                        thread_ready(thrd);

  • kernel/test/synch/semaphore2.c

    r55cc9bc r62b6d17  
    9494        printf("Creating %d consumers\n", k);
    9595        for (i = 0; i < k; i++) {
    96                 thrd = thread_create(consumer, NULL, TASK, 0, "consumer");
     96                thrd = thread_create(consumer, NULL, TASK, 0, "consumer", false);
    9797                if (thrd)
    9898                        thread_ready(thrd);

  • kernel/test/thread/thread1.c

    r55cc9bc r62b6d17  
    6262        for (i = 0; i < THREADS; i++) { 
    6363                thread_t *t;
    64                 if (!(t = thread_create(threadtest, NULL, TASK, 0, "threadtest"))) {
     64                if (!(t = thread_create(threadtest, NULL, TASK, 0, "threadtest", false))) {
    6565                        printf("Could not create thread %d\n", i);
    6666                        break;
Note: See TracChangeset for help on using the changeset viewer.