Changeset 8565a42 in mainline for kernel/test


Ignore:
Timestamp:
2018-03-02T20:34:50Z (8 years ago)
Author:
GitHub <noreply@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a1a81f69, d5e5fd1
Parents:
3061bc1 (diff), 34e1206 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:34:50)
git-committer:
GitHub <noreply@…> (2018-03-02 20:34:50)
Message:

Remove all trailing whitespace, everywhere.

See individual commit messages for details.

Location:
kernel/test
Files:
26 edited

Legend:

Unmodified
Added
Removed

  • kernel/test/atomic/atomic1.c

    r3061bc1 r8565a42  
    3535{
    3636        atomic_t a;
    37        
     37
    3838        atomic_set(&a, 10);
    3939        if (atomic_get(&a) != 10)
    4040                return "Failed atomic_set()/atomic_get()";
    41        
     41
    4242        if (atomic_postinc(&a) != 10)
    4343                return "Failed atomic_postinc()";
    4444        if (atomic_get(&a) != 11)
    4545                return "Failed atomic_get() after atomic_postinc()";
    46        
     46
    4747        if (atomic_postdec(&a) != 11)
    4848                return "Failed atomic_postdec()";
    4949        if (atomic_get(&a) != 10)
    5050                return "Failed atomic_get() after atomic_postdec()";
    51        
     51
    5252        if (atomic_preinc(&a) != 11)
    5353                return "Failed atomic_preinc()";
    5454        if (atomic_get(&a) != 11)
    5555                return "Failed atomic_get() after atomic_preinc()";
    56        
     56
    5757        if (atomic_predec(&a) != 10)
    5858                return "Failed atomic_predec()";
    5959        if (atomic_get(&a) != 10)
    6060                return "Failed atomic_get() after atomic_predec()";
    61        
     61
    6262        return NULL;
    6363}

  • kernel/test/avltree/avltree1.c

    r3061bc1 r8565a42  
    5656{
    5757        avltree_node_t *tmp;
    58        
     58
    5959        if (!node)
    6060                return NULL;
    61        
     61
    6262        if (node->lft) {
    6363                tmp = test_tree_parents(node->lft);
    … …  
    8181{
    8282        int h1, h2, diff;
    83        
     83
    8484        if (!node)
    8585                return 0;
    86        
     86
    8787        h1 = test_tree_balance(node->lft);
    8888        h2 = test_tree_balance(node->rgt);
    8989        diff = h2 - h1;
    90        
     90
    9191        if ((diff != node->balance) || ((diff != -1) && (diff != 0) && (diff != 1)))
    9292                TPRINTF("Bad balance\n");
    93        
     93
    9494        return ((h1 > h2) ? (h1 + 1) : (h2 + 1));
    9595}
    … …  
    110110                return;
    111111        }
    112        
     112
    113113        if (node == NULL)
    114114                return;
    115        
     115
    116116        TPRINTF("%" PRIu64 "[%" PRIu8 "]", node->key, node->balance);
    117117        if (node->lft != NULL || node->rgt != NULL) {
    118118                TPRINTF("(");
    119                
     119
    120120                print_tree_structure_flat(node->lft, level + 1);
    121121                if (node->rgt != NULL) {
    … …  
    123123                        print_tree_structure_flat(node->rgt, level + 1);
    124124                }
    125                
     125
    126126                TPRINTF(")");
    127127        }
    … …  
    131131{
    132132        int i;
    133        
     133
    134134        for (i = 0; i < NODE_COUNT - 1; i++)
    135135                avltree_nodes[i].par = &avltree_nodes[i + 1];
    136        
     136
    137137        avltree_nodes[i].par = NULL;
    138        
     138
    139139        /*
    140140         * Node keys which will be used for insertion. Up to NODE_COUNT size of
    141141         * array.
    142142         */
    143        
     143
    144144        /* First tree node and same key */
    145145        avltree_nodes[0].key = 60;
    146146        avltree_nodes[1].key = 60;
    147147        avltree_nodes[2].key = 60;
    148        
     148
    149149        /* LL rotation */
    150150        avltree_nodes[3].key = 50;
    151151        avltree_nodes[4].key = 40;
    152152        avltree_nodes[5].key = 30;
    153        
     153
    154154        /* LR rotation */
    155155        avltree_nodes[6].key = 20;
    … …  
    157157        avltree_nodes[8].key = 25;
    158158        avltree_nodes[9].key = 25;
    159        
     159
    160160        /* LL rotation in lower floor */
    161161        avltree_nodes[10].key = 35;
    162        
     162
    163163        /* RR rotation */
    164164        avltree_nodes[11].key = 70;
    165165        avltree_nodes[12].key = 80;
    166        
     166
    167167        /* RL rotation */
    168168        avltree_nodes[13].key = 90;
    169169        avltree_nodes[14].key = 85;
    170        
     170
    171171        /* Insert 0 key */
    172172        avltree_nodes[15].key = 0;
    173173        avltree_nodes[16].key = 0;
    174        
     174
    175175        /* Insert reverse */
    176176        avltree_nodes[17].key = 600;
    … …  
    178178        avltree_nodes[19].key = 400;
    179179        avltree_nodes[20].key = 300;
    180        
     180
    181181        for (i = 21; i < NODE_COUNT; i++)
    182182                avltree_nodes[i].key = i * 3;
    183        
     183
    184184        first_free_node = &avltree_nodes[0];
    185185}
    … …  
    188188{
    189189        avltree_node_t *node;
    190        
     190
    191191        node = first_free_node;
    192192        first_free_node = first_free_node->par;
    193        
     193
    194194        return node;
    195195}
    … …  
    199199        unsigned int i;
    200200        avltree_node_t *newnode;
    201        
     201
    202202        avltree_create(tree);
    203        
     203
    204204        TPRINTF("Inserting %zu nodes...", node_count);
    205        
     205
    206206        for (i = 0; i < node_count; i++) {
    207207                newnode = alloc_avltree_node();
    208                
     208
    209209                avltree_insert(tree, newnode);
    210210                test_tree_parents(tree->root);
    211211                test_tree_balance(tree->root);
    212212        }
    213        
     213
    214214        TPRINTF("done.\n");
    215215}
    … …  
    220220        avltree_node_t *delnode;
    221221        unsigned int i;
    222        
     222
    223223        switch (node_position) {
    224224        case 0:
    225225                TPRINTF("Deleting root nodes...");
    226                
     226
    227227                while (tree->root != NULL) {
    228228                        delnode = tree->root;
    … …  
    234234        case 1:
    235235                TPRINTF("Deleting nodes according to creation time...");
    236                
     236
    237237                for (i = 0; i < node_count; i++) {
    238238                        avltree_delete(tree, &avltree_nodes[i]);
    … …  
    242242                break;
    243243        }
    244        
     244
    245245        TPRINTF("done.\n");
    246246}
    … …  
    249249{
    250250        unsigned int i = 0;
    251        
     251
    252252        TPRINTF("Deleting minimum nodes...");
    253        
     253
    254254        while (tree->root != NULL) {
    255255                i++;
    … …  
    258258                test_tree_balance(tree->root);
    259259        }
    260        
     260
    261261        if (i != node_count)
    262262                TPRINTF("Bad node count. Some nodes have been lost!\n");
    263        
     263
    264264        TPRINTF("done.\n");
    265265}
    … …  
    270270        test_tree_insert(&avltree, NODE_COUNT);
    271271        test_tree_delete(&avltree, NODE_COUNT, 0);
    272        
     272
    273273        alloc_avltree_node_prepare();
    274274        test_tree_insert(&avltree, NODE_COUNT);
    275275        test_tree_delete(&avltree, NODE_COUNT, 1);
    276        
     276
    277277        alloc_avltree_node_prepare();
    278278        test_tree_insert(&avltree, NODE_COUNT);
    279279        test_tree_delmin(&avltree, NODE_COUNT);
    280        
     280
    281281        return NULL;
    282282}

  • kernel/test/btree/btree1.c

    r3061bc1 r8565a42  
    3838        btree_t t;
    3939        int i;
    40        
     40
    4141        btree_create(&t);
    42        
     42
    4343        TPRINTF("Inserting keys.\n");
    4444        btree_insert(&t, 19, data, NULL);
    … …  
    7777        for (i = 100; i >= 50; i--)
    7878                btree_insert(&t, i, data, NULL);
    79        
     79
    8080        if (!test_quiet)
    8181                btree_print(&t);
    82        
     82
    8383        TPRINTF("Removing keys.\n");
    8484        btree_remove(&t, 50, NULL);
    … …  
    156156        btree_remove(&t, 35, NULL);
    157157        btree_remove(&t, 36, NULL);
    158        
     158
    159159        if (!test_quiet)
    160160                btree_print(&t);
    161        
     161
    162162        return NULL;
    163163}

  • kernel/test/cht/cht1.c

    r3061bc1 r8565a42  
    9999        if (cht_find_lazy(h, (void*)0))
    100100                return "Found lazy in empty table.";
    101        
     101
    102102        if (cht_find(h, (void*)0))
    103103                return "Found in empty table.";
    104        
     104
    105105        if (cht_remove_key(h, (void*)0))
    106106                return "Removed from empty table.";
    107        
     107
    108108        const int val_cnt = 6;
    109109        val_t *v[6] = { NULL };
    110        
     110
    111111        for (int i = 0; i < val_cnt; ++i)
    112112                v[i] = malloc(sizeof(val_t), 0);
    113        
     113
    114114        size_t key[] = { 1, 1, 1, 11, 12, 13 };
    115        
     115
    116116        /* First three are identical */
    117117        for (int i = 0; i < 3; ++i)
    118118                set_val(v[i], 1, key[i]);
    119        
     119
    120120        /* Same hash, different key.*/
    121121        set_val(v[3], 1, key[3]);
    122        
     122
    123123        /* Different hashes and keys. */
    124124        set_val(v[4], 2, key[4]);
    125125        set_val(v[5], 3, key[5]);
    126        
     126
    127127        cht_link_t *dup;
    128                        
     128
    129129        if (!cht_insert_unique(h, &v[0]->link, &dup))
    130130                return "Duplicates in empty";
    … …  
    132132        if (cht_insert_unique(h, &v[1]->link, &dup))
    133133                return "Inserted a duplicate";
    134        
     134
    135135        if (dup != &v[0]->link)
    136136                return "Returned wrong duplicate";
    … …  
    138138        if (!cht_insert_unique(h, &v[3]->link, &dup))
    139139                return "Refused non-equal item but with a hash in table.";
    140        
     140
    141141        cht_insert(h, &v[1]->link);
    142142        cht_insert(h, &v[2]->link);
    143        
     143
    144144        bool ok = true;
    145145        ok = ok && cht_insert_unique(h, &v[4]->link, &dup);
    146146        ok = ok && cht_insert_unique(h, &v[5]->link, &dup);
    147        
     147
    148148        if (!ok)
    149149                return "Refused unique ins 4, 5.";
    150        
     150
    151151        if (cht_find(h, (void*)0))
    152152                return "Phantom find.";
    153        
     153
    154154        cht_link_t *item = cht_find(h, (void*)v[5]->unique_id);
    155155        if (!item || item != &v[5]->link)
    … …  
    159159        if (item)
    160160                return "Found nonexisting duplicate 5";
    161        
     161
    162162        item = cht_find(h, (void*)v[3]->unique_id);
    163163        if (!item || item != &v[3]->link)
    … …  
    167167        if (item)
    168168                return "Found nonexisting duplicate 3, same hash as others.";
    169        
     169
    170170        item = cht_find(h, (void*)v[0]->unique_id);
    171171        ((val_t*)item)->mark = true;
    172        
     172
    173173        for (int k = 1; k < 3; ++k) {
    174174                item = cht_find_next(h, item);
    175175                if (!item)
    176176                        return "Did not find an inserted duplicate";
    177                
     177
    178178                val_t *val = ((val_t*)item);
    179                
     179
    180180                if (val->unique_id != v[0]->unique_id)
    181181                        return "Found item with a different key.";
    … …  
    184184                val->mark = true;
    185185        }
    186        
     186
    187187        for (int i = 0; i < 3; ++i) {
    188188                if (!v[i]->mark)
    189189                        return "Did not find all duplicates";
    190                
     190
    191191                v[i]->mark = false;
    192192        }
    … …  
    196196
    197197        item = cht_find_next(h, cht_find(h, (void*)key[0]));
    198        
     198
    199199        ((val_t*)item)->mark = true;
    200200        if (!cht_remove_item(h, item))
    201201                return "Failed to remove inserted item";
    202        
     202
    203203        item = cht_find(h, (void*)key[0]);
    204204        if (!item || ((val_t*)item)->mark)
    205205                return "Did not find proper item.";
    206        
     206
    207207        item = cht_find_next(h, item);
    208208        if (!item || ((val_t*)item)->mark)
    … …  
    212212        if (item)
    213213                return "Found removed duplicate";
    214        
     214
    215215        if (2 != cht_remove_key(h, (void*)key[0]))
    216216                return "Failed to remove all duplicates";
    217        
     217
    218218        if (cht_find(h, (void*)key[0]))
    219219                return "Found removed key";
    220        
     220
    221221        if (!cht_find(h, (void*)key[3]))
    222222                return "Removed incorrect key";
    223        
     223
    224224        for (size_t k = 0; k < sizeof(v) / sizeof(v[0]); ++k) {
    225225                cht_remove_key(h, (void*)key[k]);
    226226        }
    227        
     227
    228228        for (size_t k = 0; k < sizeof(v) / sizeof(v[0]); ++k) {
    229229                if (cht_find(h, (void*)key[k]))
    … …  
    239239        if (!cht_create_simple(&h, &val_ops))
    240240                return "Could not create the table.";
    241        
     241
    242242        rcu_read_lock();
    243243        const char *err = do_sanity_test(&h);
    244244        rcu_read_unlock();
    245        
     245
    246246        cht_destroy(&h);
    247247
    … …  
    321321                                goto out_of_mem;
    322322                        }
    323                        
     323
    324324                        s->free = true;
    325325                        s->key = (i << 8) + work->id;
    326                        
     326
    327327                        cht_insert(work->h, &s->link);
    328328                }
    329329                TPRINTF("}");
    330                
     330
    331331                thread_sleep(2);
    332332
    … …  
    334334                for (size_t i = 0; i < work->wave_elems; ++i) {
    335335                        size_t key = (i << 8) + work->id;
    336                        
     336
    337337                        if (1 != cht_remove_key(work->h, (void*)key)) {
    338338                                TPRINTF("Err: Failed to remove inserted item\n");
    … …  
    342342                TPRINTF(">");
    343343        }
    344        
     344
    345345        /* Request that others stop. */
    346346        *work->stop = 1;
    … …  
    365365        stress_work_t *work = (stress_work_t *)arg;
    366366        assert(0 == *work->stop);
    367        
     367
    368368        size_t loops = 0;
    369369        size_t seed = work->id;
    370                
     370
    371371        while (0 == *work->stop && !work->failed) {
    372372                seed = next_rand(seed);
    … …  
    374374                seed = next_rand(seed);
    375375                size_t elem_idx = seed % work->elem_cnt;
    376                
     376
    377377                ++loops;
    378378                if (0 == loops % (1024 * 1024)) {
    … …  
    381381                        TPRINTF("*");
    382382                }
    383                        
     383
    384384                if (upd) {
    385385                        seed = next_rand(seed);
    386386                        bool item_op = seed & 1;
    387                        
     387
    388388                        if (work->elem[elem_idx].inserted) {
    389389                                if (item_op) {
    … …  
    401401                        } else if (work->elem[elem_idx].deleted) {
    402402                                work->elem[elem_idx].deleted = false;
    403                                
     403
    404404                                if (item_op) {
    405405                                        rcu_read_lock();
    … …  
    414414                                        cht_insert(work->h, &work->elem[elem_idx].link);
    415415                                }
    416                                
     416
    417417                                work->elem[elem_idx].inserted = true;
    418418                        }
    … …  
    452452{
    453453        cht_t h;
    454        
     454
    455455        if (!cht_create_simple(&h, &stress_ops)) {
    456456                TPRINTF("Failed to create the table\n");
    … …  
    464464        size_t total_thr_cnt = op_thread_cnt + resize_thread_cnt;
    465465        size_t items_per_thread = 1024;
    466        
     466
    467467        size_t work_cnt = op_thread_cnt + resize_thread_cnt;
    468468        size_t item_cnt = op_thread_cnt * items_per_thread;
    469        
     469
    470470        /* Alloc hash table items. */
    471471        size_t size = item_cnt * sizeof(stress_t) + work_cnt * sizeof(stress_work_t)
    472472                + sizeof(int);
    473                
     473
    474474        TPRINTF("Alloc and init table items. \n");
    475475        void *p = malloc(size, FRAME_ATOMIC);
    … …  
    479479                return false;
    480480        }
    481        
     481
    482482        stress_t *pitem = p + work_cnt * sizeof(stress_work_t);
    483483        stress_work_t *pwork = p;
    484484        int *pstop = (int*)(pitem + item_cnt);
    485        
     485
    486486        *pstop = 0;
    487        
     487
    488488        /* Init work items. */
    489489        for (size_t i = 0; i < op_thread_cnt; ++i) {
    … …  
    496496                pwork[i].failed = false;
    497497        }
    498        
     498
    499499        for (size_t i = op_thread_cnt; i < op_thread_cnt + resize_thread_cnt; ++i) {
    500500                pwork[i].h = &h;
    … …  
    505505                pwork[i].failed = false;
    506506        }
    507        
     507
    508508        /* Init table elements. */
    509509        for (size_t k = 0; k < op_thread_cnt; ++k) {
    … …  
    515515                }
    516516        }
    517        
     517
    518518        TPRINTF("Running %zu ins/del/find stress threads + %zu resizers.\n",
    519519                op_thread_cnt, resize_thread_cnt);
    520        
     520
    521521        /* Create and run threads. */
    522522        thread_t *thr[max_thread_cnt + resize_thread_cnt];
    523        
     523
    524524        for (size_t i = 0; i < total_thr_cnt; ++i) {
    525525                if (i < op_thread_cnt)
    … …  
    527527                else
    528528                        thr[i] = thread_create(resize_stresser, &pwork[i], TASK, 0, "cht-resize");
    529                
     529
    530530                assert(thr[i]);
    531531                thread_wire(thr[i], &cpus[i % config.cpu_active]);
    532532                thread_ready(thr[i]);
    533533        }
    534        
     534
    535535        bool failed = false;
    536        
     536
    537537        /* Wait for all threads to return. */
    538538        TPRINTF("Joining resize stressers.\n");
    … …  
    542542                failed = pwork[i].failed || failed;
    543543        }
    544        
     544
    545545        TPRINTF("Joining op stressers.\n");
    546546        for (int i = (int)op_thread_cnt - 1; i >= 0; --i) {
    … …  
    550550                failed = pwork[i].failed || failed;
    551551        }
    552        
     552
    553553        cht_destroy(&h);
    554554        free(p);
    … …  
    566566                return err;
    567567        printf("Basic sanity test: ok.\n");
    568        
     568
    569569        if (!do_stress())
    570570                return "CHT stress test failed.";

  • kernel/test/debug/mips1.c

    r3061bc1 r8565a42  
    4040{
    4141        TPRINTF("If kconsole is compiled in, you should enter debug mode now.\n");
    42        
     42
    4343        asm volatile (
    4444                "break\n"
    4545        );
    46        
     46
    4747        return "Back from debug mode";
    4848}

  • kernel/test/fault/fault1.c

    r3061bc1 r8565a42  
    4040{
    4141        ((int *)(0))[1] = 0;
    42        
     42
    4343        return "Written to NULL";
    4444}

  • kernel/test/mm/falloc1.c

    r3061bc1 r8565a42  
    4545        if (TEST_RUNS < 2)
    4646                return "Test is compiled with TEST_RUNS < 2";
    47        
     47
    4848        uintptr_t *frames = (uintptr_t *)
    4949            malloc(MAX_FRAMES * sizeof(uintptr_t), 0);
    5050        if (frames == NULL)
    5151                return "Unable to allocate frames";
    52        
     52
    5353        unsigned int results[MAX_FRAMES + 1];
    54        
     54
    5555        for (unsigned int run = 0; run < TEST_RUNS; run++) {
    5656                for (size_t count = 1; count <= MAX_FRAMES; count++) {
    5757                        size_t bytes = FRAMES2SIZE(count);
    58                        
     58
    5959                        TPRINTF("Allocating %zu frames blocks (%zu bytes) ... ",
    6060                            count, bytes);
    61                        
     61
    6262                        unsigned int allocated = 0;
    6363                        for (unsigned int i = 0; i < (MAX_FRAMES / count); i++) {
    … …  
    7070                                }
    7171                        }
    72                        
     72
    7373                        TPRINTF("%d blocks allocated.\n", allocated);
    74                        
     74
    7575                        if (run > 0) {
    7676                                if (results[count] != allocated)
    … …  
    7878                        } else
    7979                                results[count] = allocated;
    80                        
     80
    8181                        TPRINTF("Deallocating ... ");
    82                        
     82
    8383                        for (unsigned int i = 0; i < allocated; i++)
    8484                                frame_free(frames[i], count);
    85                        
     85
    8686                        TPRINTF("done.\n");
    8787                }
    8888        }
    89        
     89
    9090        free(frames);
    91        
     91
    9292        return NULL;
    9393}

  • kernel/test/mm/falloc2.c

    r3061bc1 r8565a42  
    5151{
    5252        uint8_t val = THREAD->tid % THREADS;
    53        
     53
    5454        uintptr_t *frames = (uintptr_t *)
    5555            malloc(MAX_FRAMES * sizeof(uintptr_t), FRAME_ATOMIC);
    … …  
    6161                return;
    6262        }
    63        
     63
    6464        thread_detach(THREAD);
    65        
     65
    6666        for (unsigned int run = 0; run < THREAD_RUNS; run++) {
    6767                for (size_t count = 1; count <= MAX_FRAMES; count++) {
    6868                        size_t bytes = FRAMES2SIZE(count);
    69                        
     69
    7070                        TPRINTF("Thread #%" PRIu64 " (cpu%u): "
    7171                            "Allocating %zu frames blocks (%zu bytes) ... \n", THREAD->tid,
    7272                            CPU->id, count, bytes);
    73                        
     73
    7474                        unsigned int allocated = 0;
    7575                        for (unsigned int i = 0; i < (MAX_FRAMES / count); i++) {
    … …  
    8181                                        break;
    8282                        }
    83                        
     83
    8484                        TPRINTF("Thread #%" PRIu64 " (cpu%u): "
    8585                            "%u blocks allocated.\n", THREAD->tid, CPU->id,
    … …  
    8787                        TPRINTF("Thread #%" PRIu64 " (cpu%u): "
    8888                            "Deallocating ... \n", THREAD->tid, CPU->id);
    89                        
     89
    9090                        for (unsigned int i = 0; i < allocated; i++) {
    9191                                for (size_t k = 0; k < bytes; k++) {
    … …  
    101101                                frame_free(frames[i], count);
    102102                        }
    103                        
     103
    104104                        TPRINTF("Thread #%" PRIu64 " (cpu%u): "
    105105                            "Finished run.\n", THREAD->tid, CPU->id);
    106106                }
    107107        }
    108        
     108
    109109cleanup:
    110110        free(frames);
    111        
     111
    112112        TPRINTF("Thread #%" PRIu64 " (cpu%u): Exiting\n",
    113113            THREAD->tid, CPU->id);
    … …  
    119119        atomic_set(&thread_count, THREADS);
    120120        atomic_set(&thread_fail, 0);
    121        
     121
    122122        for (unsigned int i = 0; i < THREADS; i++) {
    123123                thread_t *thrd = thread_create(falloc, NULL, TASK,
    … …  
    129129                thread_ready(thrd);
    130130        }
    131        
     131
    132132        while (atomic_get(&thread_count) > 0) {
    133133                TPRINTF("Threads left: %" PRIua "\n",
    … …  
    135135                thread_sleep(1);
    136136        }
    137        
     137
    138138        if (atomic_get(&thread_fail) == 0)
    139139                return NULL;
    140        
     140
    141141        return "Test failed";
    142142}

  • kernel/test/mm/mapping1.c

    r3061bc1 r8565a42  
    4242{
    4343        uintptr_t frame = frame_alloc(1, FRAME_NONE, 0);
    44        
     44
    4545        uintptr_t page0 = km_map(frame, FRAME_SIZE,
    4646            PAGE_READ | PAGE_WRITE | PAGE_CACHEABLE);
    4747        TPRINTF("Virtual address %p mapped to physical address %p.\n",
    4848            (void *) page0, (void *) frame);
    49        
     49
    5050        uintptr_t page1 = km_map(frame, FRAME_SIZE,
    5151            PAGE_READ | PAGE_WRITE | PAGE_CACHEABLE);
    5252        TPRINTF("Virtual address %p mapped to physical address %p.\n",
    5353            (void *) page1, (void *) frame);
    54        
     54
    5555        for (unsigned int i = 0; i < 2; i++) {
    5656                TPRINTF("Writing magic using the first virtual address.\n");
    57                
     57
    5858                *((uint32_t *) page0) = TEST_MAGIC;
    59                
     59
    6060                TPRINTF("Reading magic using the second virtual address.\n");
    61                
     61
    6262                uint32_t v = *((uint32_t *) page1);
    63                
     63
    6464                if (v != TEST_MAGIC) {
    6565                        km_unmap(page0, PAGE_SIZE);
    … …  
    6868                        return "Criss-cross read does not match the value written.";
    6969                }
    70                
     70
    7171                TPRINTF("Writing zero using the second virtual address.\n");
    72                
     72
    7373                *((uint32_t *) page1) = 0;
    74                
     74
    7575                TPRINTF("Reading zero using the first virtual address.\n");
    76                
     76
    7777                v = *((uint32_t *) page0);
    78                
     78
    7979                if (v != 0) {
    8080                        km_unmap(page0, PAGE_SIZE);
    … …  
    8484                }
    8585        }
    86        
     86
    8787        km_unmap(page0, PAGE_SIZE);
    8888        km_unmap(page1, PAGE_SIZE);
    8989        frame_free(frame, 1);
    90        
     90
    9191        return NULL;
    9292}

  • kernel/test/mm/purge1.c

    r3061bc1 r8565a42  
    4444        tlb_entry_t entryi;
    4545        tlb_entry_t entryd;
    46        
     46
    4747        int i;
    48        
     48
    4949        entryd.word[0] = 0;
    5050        entryd.word[1] = 0;
    51        
     51
    5252        entryd.p = true;                 /* present */
    5353        entryd.ma = MA_WRITEBACK;
    … …  
    5858        entryd.ppn = 0;
    5959        entryd.ps = PAGE_WIDTH;
    60        
     60
    6161        entryi.word[0] = 0;
    6262        entryi.word[1] = 0;
    63        
     63
    6464        entryi.p = true;                 /* present */
    6565        entryi.ma = MA_WRITEBACK;
    … …  
    7070        entryi.ppn = 0;
    7171        entryi.ps = PAGE_WIDTH;
    72        
     72
    7373        for (i = 0; i < 100; i++) {
    7474                itc_mapping_insert(0 + i * (1 << PAGE_WIDTH), 8, entryi);
    7575                dtc_mapping_insert(0 + i * (1 << PAGE_WIDTH), 9, entryd);
    7676        }
    77        
     77
    7878        tlb_invalidate_pages(8, 0x0c000, 14);
    79        
     79
    8080        /* tlb_invalidate_all(); */
    81        
     81
    8282        return NULL;
    8383}

  • kernel/test/mm/slab1.c

    r3061bc1 r8565a42  
    4242        slab_cache_t *cache;
    4343        int i;
    44        
     44
    4545        TPRINTF("Creating cache, object size: %d.\n", size);
    46        
     46
    4747        cache = slab_cache_create("test_cache", size, 0, NULL, NULL,
    4848            SLAB_CACHE_NOMAGAZINE);
    49        
     49
    5050        TPRINTF("Allocating %d items...", count);
    51        
     51
    5252        for (i = 0; i < count; i++) {
    5353                data[i] = slab_alloc(cache, 0);
    5454                memsetb(data[i], size, 0);
    5555        }
    56        
     56
    5757        TPRINTF("done.\n");
    58        
     58
    5959        TPRINTF("Freeing %d items...", count);
    60        
     60
    6161        for (i = 0; i < count; i++)
    6262                slab_free(cache, data[i]);
    63        
     63
    6464        TPRINTF("done.\n");
    65        
     65
    6666        TPRINTF("Allocating %d items...", count);
    67        
     67
    6868        for (i = 0; i < count; i++) {
    6969                data[i] = slab_alloc(cache, 0);
    7070                memsetb(data[i], size, 0);
    7171        }
    72        
     72
    7373        TPRINTF("done.\n");
    74        
     74
    7575        TPRINTF("Freeing %d items...", count / 2);
    76        
     76
    7777        for (i = count - 1; i >= count / 2; i--)
    7878                slab_free(cache, data[i]);
    79        
     79
    8080        TPRINTF("done.\n");
    81        
     81
    8282        TPRINTF("Allocating %d items...", count / 2);
    83        
     83
    8484        for (i = count / 2; i < count; i++) {
    8585                data[i] = slab_alloc(cache, 0);
    8686                memsetb(data[i], size, 0);
    8787        }
    88        
     88
    8989        TPRINTF("done.\n");
    90        
     90
    9191        TPRINTF("Freeing %d items...", count);
    92        
     92
    9393        for (i = 0; i < count; i++)
    9494                slab_free(cache, data[i]);
    95        
     95
    9696        TPRINTF("done.\n");
    97        
     97
    9898        slab_cache_destroy(cache);
    99        
     99
    100100        TPRINTF("Test complete.\n");
    101101}
    … …  
    125125        int offs = (int) (sysarg_t) data;
    126126        int i, j;
    127        
     127
    128128        thread_detach(THREAD);
    129        
     129
    130130        TPRINTF("Starting thread #%" PRIu64 "...\n", THREAD->tid);
    131        
     131
    132132        for (j = 0; j < 10; j++) {
    133133                for (i = 0; i < THR_MEM_COUNT; i++)
    … …  
    140140                        slab_free(thr_cache, thr_data[offs][i]);
    141141        }
    142        
     142
    143143        TPRINTF("Thread #%" PRIu64 " finished\n", THREAD->tid);
    144        
     144
    145145        semaphore_up(&thr_sem);
    146146}
    … …  
    150150        thread_t *t;
    151151        int i;
    152        
     152
    153153        thr_cache = slab_cache_create("thread_cache", THR_MEM_SIZE, 0, NULL, NULL,
    154154            SLAB_CACHE_NOMAGAZINE);
    155        
     155
    156156        semaphore_initialize(&thr_sem, 0);
    157157        for (i = 0; i < THREADS; i++) {
    … …  
    164164        for (i = 0; i < THREADS; i++)
    165165                semaphore_down(&thr_sem);
    166        
     166
    167167        slab_cache_destroy(thr_cache);
    168        
     168
    169169        TPRINTF("Test complete.\n");
    170170}
    … …  
    174174        testsimple();
    175175        testthreads();
    176        
     176
    177177        return NULL;
    178178}

  • kernel/test/mm/slab2.c

    r3061bc1 r8565a42  
    4848        slab_cache_t *cache2;
    4949        int i;
    50        
     50
    5151        void *data1, *data2;
    5252        void *olddata1 = NULL, *olddata2 = NULL;
    53        
     53
    5454        cache1 = slab_cache_create("test_cache1", ITEM_SIZE, 0, NULL, NULL, 0);
    5555        cache2 = slab_cache_create("test_cache2", ITEM_SIZE, 0, NULL, NULL, 0);
    56        
     56
    5757        TPRINTF("Allocating...");
    58        
     58
    5959        /* Use atomic alloc, so that we find end of memory */
    6060        do {
    … …  
    7575                olddata2 = data2;
    7676        } while (true);
    77        
     77
    7878        TPRINTF("done.\n");
    79        
     79
    8080        TPRINTF("Deallocating cache2...");
    81        
     81
    8282        /* We do not have memory - now deallocate cache2 */
    8383        while (olddata2) {
    … …  
    8686                olddata2 = data2;
    8787        }
    88        
     88
    8989        TPRINTF("done.\n");
    90        
     90
    9191        TPRINTF("Allocating to cache1...\n");
    92        
     92
    9393        for (i = 0; i < 30; i++) {
    9494                data1 = slab_alloc(cache1, FRAME_ATOMIC);
    … …  
    109109                olddata1 = data1;
    110110        }
    111        
     111
    112112        TPRINTF("Deallocating cache1...");
    113        
     113
    114114        while (olddata1) {
    115115                data1 = *((void **) olddata1);
    … …  
    117117                olddata1 = data1;
    118118        }
    119        
     119
    120120        TPRINTF("done.\n");
    121        
     121
    122122        if (!test_quiet)
    123123                slab_print_list();
    124        
     124
    125125        slab_cache_destroy(cache1);
    126126        slab_cache_destroy(cache2);
    … …  
    137137{
    138138        void *data = NULL, *new;
    139        
     139
    140140        thread_detach(THREAD);
    141        
     141
    142142        mutex_lock(&starter_mutex);
    143143        condvar_wait(&thread_starter,&starter_mutex);
    144144        mutex_unlock(&starter_mutex);
    145        
     145
    146146        TPRINTF("Starting thread #%" PRIu64 "...\n", THREAD->tid);
    147147
    148148        /* Alloc all */
    149149        TPRINTF("Thread #%" PRIu64 " allocating...\n", THREAD->tid);
    150        
     150
    151151        while (true) {
    152152                /* Call with atomic to detect end of memory */
    … …  
    157157                data = new;
    158158        }
    159        
     159
    160160        TPRINTF("Thread #%" PRIu64 " releasing...\n", THREAD->tid);
    161        
     161
    162162        while (data) {
    163163                new = *((void **)data);
    … …  
    166166                data = new;
    167167        }
    168        
     168
    169169        TPRINTF("Thread #%" PRIu64 " allocating...\n", THREAD->tid);
    170        
     170
    171171        while (true) {
    172172                /* Call with atomic to detect end of memory */
    … …  
    177177                data = new;
    178178        }
    179        
     179
    180180        TPRINTF("Thread #%" PRIu64 " releasing...\n", THREAD->tid);
    181        
     181
    182182        while (data) {
    183183                new = *((void **)data);
    … …  
    186186                data = new;
    187187        }
    188        
     188
    189189        TPRINTF("Thread #%" PRIu64 " finished\n", THREAD->tid);
    190        
     190
    191191        if (!test_quiet)
    192192                slab_print_list();
    193        
     193
    194194        semaphore_up(&thr_sem);
    195195}
    … …  
    202202        thread_t *t;
    203203        int i;
    204        
     204
    205205        TPRINTF("Running stress test with size %d\n", size);
    206        
     206
    207207        condvar_initialize(&thread_starter);
    208208        mutex_initialize(&starter_mutex, MUTEX_PASSIVE);
    209        
     209
    210210        thr_cache = slab_cache_create("thread_cache", size, 0, NULL, NULL, 0);
    211211        semaphore_initialize(&thr_sem,0);
    … …  
    218218        thread_sleep(1);
    219219        condvar_broadcast(&thread_starter);
    220        
     220
    221221        for (i = 0; i < THREADS; i++)
    222222                semaphore_down(&thr_sem);
    223        
     223
    224224        slab_cache_destroy(thr_cache);
    225225        TPRINTF("Stress test complete.\n");
    … …  
    230230        TPRINTF("Running reclaim single-thread test .. pass 1\n");
    231231        totalmemtest();
    232        
     232
    233233        TPRINTF("Running reclaim single-thread test .. pass 2\n");
    234234        totalmemtest();
    235        
     235
    236236        TPRINTF("Reclaim test OK.\n");
    237        
     237
    238238        multitest(128);
    239239        multitest(2048);
    240240        multitest(8192);
    241        
     241
    242242        return NULL;
    243243}

  • kernel/test/print/print1.c

    r3061bc1 r8565a42  
    3636        TPRINTF("Expected output: \"  tex\"\n");
    3737        TPRINTF("Real output:     \"%*.*s\"\n\n", 5, 3, "text");
    38        
     38
    3939        TPRINTF("Testing printf(\"%%10.8s\", \"very long text\"):\n");
    4040        TPRINTF("Expected output: \"  very lon\"\n");
    4141        TPRINTF("Real output:     \"%10.8s\"\n\n", "very long text");
    42        
     42
    4343        TPRINTF("Testing printf(\"%%8.10s\", \"text\"):\n");
    4444        TPRINTF("Expected output: \"    text\"\n");
    4545        TPRINTF("Real output:     \"%8.10s\"\n\n", "text");
    46        
     46
    4747        TPRINTF("Testing printf(\"%%8.10s\", \"very long text\"):\n");
    4848        TPRINTF("Expected output: \"very long \"\n");
    4949        TPRINTF("Real output:     \"%8.10s\"\n\n", "very long text");
    50        
     50
    5151        TPRINTF("Testing printf(\"%%-*.*s\", 7, 7, \"text\"):\n");
    5252        TPRINTF("Expected output: \"text   \"\n");
    5353        TPRINTF("Real output:     \"%-*.*s\"\n\n", 7, 7, "text");
    54        
     54
    5555        return NULL;
    5656}

  • kernel/test/print/print2.c

    r3061bc1 r8565a42  
    3636        TPRINTF("Expected output: [a]\n");
    3737        TPRINTF("Real output:     [%c]\n\n", 'a');
    38        
     38
    3939        TPRINTF("Testing printf(\"%%d %%3.2d %%-3.2d %%2.3d %%-2.3d\", 1, 2, 3, 4, 5):\n");
    4040        TPRINTF("Expected output: [1] [ 02] [03 ] [004] [005]\n");
    4141        TPRINTF("Real output:     [%d] [%3.2d] [%-3.2d] [%2.3d] [%-2.3d]\n\n", 1, 2, 3, 4, 5);
    42        
     42
    4343        TPRINTF("Testing printf(\"%%d %%3.2d %%-3.2d %%2.3d %%-2.3d\", -1, -2, -3, -4, -5):\n");
    4444        TPRINTF("Expected output: [-1] [-02] [-03] [-004] [-005]\n");
    4545        TPRINTF("Real output:     [%d] [%3.2d] [%-3.2d] [%2.3d] [%-2.3d]\n\n", -1, -2, -3, -4, -5);
    46        
     46
    4747        TPRINTF("Testing printf(\"%%lld %%3.2lld %%-3.2lld %%2.3lld %%-2.3lld\", (long long) -1, (long long) -2, (long long) -3, (long long) -4, (long long) -5):\n");
    4848        TPRINTF("Expected output: [-1] [-02] [-03] [-004] [-005]\n");
    4949        TPRINTF("Real output:     [%lld] [%3.2lld] [%-3.2lld] [%2.3lld] [%-2.3lld]\n\n", (long long) -1, (long long) -2, (long long) -3, (long long) -4, (long long) -5);
    50        
     50
    5151        TPRINTF("Testing printf(\"%%#x %%5.3#x %%-5.3#x %%3.5#x %%-3.5#x\", 17, 18, 19, 20, 21):\n");
    5252        TPRINTF("Expected output: [0x11] [0x012] [0x013] [0x00014] [0x00015]\n");
    5353        TPRINTF("Real output:     [%#x] [%#5.3x] [%#-5.3x] [%#3.5x] [%#-3.5x]\n\n", 17, 18, 19, 20, 21);
    54        
     54
    5555        char ch[12];
    5656        ptrdiff_t d, neg_d;
    57        
     57
    5858        d = &ch[0] - &ch[12];
    5959        neg_d = (unsigned)(-d);
    … …  
    6161        TPRINTF("Expected output: [-12] [12] [c] [-12] [14]\n");
    6262        TPRINTF("Real output:     [%td] [%tu] [%tx] [%ti] [%to]\n\n", d, neg_d, neg_d, d, neg_d);
    63        
     63
    6464        sysarg_t nat = 0x12345678;
    65        
     65
    6666        TPRINTF("Testing printf(\"%%#" PRIx64 " %%#" PRIx32 " %%#" PRIx16 " %%#" PRIx8 " %%#" PRIxn " %%#" PRIx64 " %%s\", (uint64_t) UINT64_C(0x1234567887654321), (uint32_t) UINT32_C(0x12345678), (uint16_t) UINT16_C(0x1234), (uint8_t) UINT8_C(0x12), nat, (uint64_t) UINT64_C(0x1234567887654321), \"Lovely string\"):\n");
    6767        TPRINTF("Expected output: [0x1234567887654321] [0x12345678] [0x1234] [0x12] [0x12345678] [0x1234567887654321] \"Lovely string\"\n");
    6868        TPRINTF("Real output:     [%#" PRIx64 "] [%#" PRIx32 "] [%#" PRIx16 "] [%#" PRIx8 "] [%#" PRIxn "] [%#" PRIx64 "] \"%s\"\n\n", (uint64_t) UINT64_C(0x1234567887654321), (uint32_t) UINT32_C(0x12345678), (uint16_t) UINT16_C(0x1234), (uint8_t) UINT8_C(0x12), nat, (uint64_t) UINT64_C(0x1234567887654321), "Lovely string");
    69        
     69
    7070        return NULL;
    7171}

  • kernel/test/print/print3.c

    r3061bc1 r8565a42  
    3838        char buffer[BUFFER_SIZE];
    3939        int retval;
    40        
     40
    4141        TPRINTF("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Short text without parameters.\"):\n");
    4242        TPRINTF("Expected result: retval=30 buffer=\"Short text without parameters.\"\n");
    4343        retval = snprintf(buffer, BUFFER_SIZE, "Short text without parameters.");
    4444        TPRINTF("Real result:     retval=%d buffer=\"%s\"\n\n", retval, buffer);
    45        
     45
    4646        TPRINTF("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Very very very long text without parameters.\"):\n");
    4747        TPRINTF("Expected result: retval=44 buffer=\"Very very very long text withou\"\n");
    4848        retval = snprintf(buffer, BUFFER_SIZE, "Very very very long text without parameters.");
    4949        TPRINTF("Real result:     retval=%d buffer=\"%s\"\n\n", retval, buffer);
    50        
     50
    5151        TPRINTF("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Short %%s.\", \"text\"):\n");
    5252        TPRINTF("Expected result: retval=11 buffer=\"Short text.\"\n");
    5353        retval = snprintf(buffer, BUFFER_SIZE, "Short %s.", "text");
    5454        TPRINTF("Real result:     retval=%d buffer=\"%s\"\n\n", retval, buffer);
    55        
     55
    5656        TPRINTF("Testing snprintf(buffer, " STRING(BUFFER_SIZE) ", \"Very long %%s. This text's length is more than %%d. We are interested in the result.\", \"text\", " STRING(BUFFER_SIZE) "):\n");
    5757        TPRINTF("Expected result: retval=84 buffer=\"Very long text. This text's len\"\n");
    5858        retval = snprintf(buffer, BUFFER_SIZE, "Very long %s. This text's length is more than %d. We are interested in the result.", "text", BUFFER_SIZE);
    5959        TPRINTF("Real result:     retval=%d buffer=\"%s\"\n\n", retval, buffer);
    60        
     60
    6161        return NULL;
    6262}

  • kernel/test/print/print4.c

    r3061bc1 r8565a42  
    3434{
    3535        TPRINTF("ASCII printable characters (32 - 127) using printf(\"%%c\") and printf(\"%%lc\"):\n");
    36        
     36
    3737        uint8_t group;
    3838        for (group = 1; group < 4; group++) {
    3939                TPRINTF("%#x: ", group << 5);
    40                
     40
    4141                uint8_t index;
    4242                for (index = 0; index < 32; index++)
    4343                        TPRINTF("%c", (char) ((group << 5) + index));
    44                
     44
    4545                TPRINTF("  ");
    4646                for (index = 0; index < 32; index++)
    4747                        TPRINTF("%lc", (wint_t) ((group << 5) + index));
    48                
     48
    4949                TPRINTF("\n");
    5050        }
    51        
     51
    5252        TPRINTF("\nExtended ASCII characters (128 - 255) using printf(\"%%lc\"):\n");
    53        
     53
    5454        for (group = 4; group < 8; group++) {
    5555                TPRINTF("%#x: ", group << 5);
    56                
     56
    5757                uint8_t index;
    5858                for (index = 0; index < 32; index++)
    5959                        TPRINTF("%lc", (wint_t) ((group << 5) + index));
    60                
     60
    6161                TPRINTF("\n");
    6262        }
    63        
     63
    6464        TPRINTF("\nUTF-8 strings using printf(\"%%s\"):\n");
    6565        TPRINTF("English:  %s\n", "Quick brown fox jumps over the lazy dog");
    … …  
    7070        TPRINTF("Russian:  %s\n", "Леннон познакомился с художницей-авангардисткой");
    7171        TPRINTF("Armenian: %s\n", "Սկսեց հրատարակվել Երուսաղեմի հայկական");
    72        
     72
    7373        TPRINTF("\nUTF-32 strings using printf(\"%%ls\"):\n");
    7474        TPRINTF("English:  %ls\n", L"Quick brown fox jumps over the lazy dog");
    … …  
    7979        TPRINTF("Russian:  %ls\n", L"Леннон познакомился с художницей-авангардисткой");
    8080        TPRINTF("Armenian: %ls\n", L"Սկսեց հրատարակվել Երուսաղեմի հայկական");
    81        
     81
    8282        return NULL;
    8383}

  • kernel/test/print/print5.c

    r3061bc1 r8565a42  
    4848        TPRINTF("Expected output: \"(NULL)\"\n");
    4949        TPRINTF("Real output:     \"%s\"\n\n", (char *) NULL);
    50        
     50
    5151        TPRINTF("Testing printf(\"%%c %%3.2c %%-3.2c %%2.3c %%-2.3c\", 'a', 'b', 'c', 'd', 'e'):\n");
    5252        TPRINTF("Expected output: [a] [  b] [c  ] [ d] [e ]\n");
    5353        TPRINTF("Real output:     [%c] [%3.2c] [%-3.2c] [%2.3c] [%-2.3c]\n\n", 'a', 'b', 'c', 'd', 'e');
    54        
     54
    5555        return NULL;
    5656}

  • kernel/test/smpcall/smpcall1.c

    r3061bc1 r8565a42  
    6666        size_t *pcall_cnt = (size_t*)p;
    6767        smp_call_t call_info[MAX_CPUS];
    68        
     68
    6969        unsigned int cpu_count = min(config.cpu_active, MAX_CPUS);
    70        
     70
    7171        for (int iter = 0; iter < ITERATIONS; ++iter) {
    7272                /* Synchronous version. */
    … …  
    7979                        smp_call(cpu_id, inc, pcall_cnt);
    8080                }
    81                
     81
    8282                /*
    8383                 * Async calls run in parallel on different cpus, so passing the
    … …  
    8585                 */
    8686                size_t local_cnt[MAX_CPUS] = {0};
    87                
     87
    8888                /* Now start asynchronous calls. */
    8989                for (unsigned cpu_id = 0; cpu_id < cpu_count; ++cpu_id) {
    9090                        smp_call_async(cpu_id, inc, &local_cnt[cpu_id], &call_info[cpu_id]);
    9191                }
    92                
     92
    9393                /* And wait for all async calls to complete. */
    9494                for (unsigned cpu_id = 0; cpu_id < cpu_count; ++cpu_id) {
    … …  
    112112        size_t call_cnt[MAX_CPUS] = {0};
    113113        thread_t *thread[MAX_CPUS] = { NULL };
    114        
     114
    115115        unsigned int cpu_count = min(config.cpu_active, MAX_CPUS);
    116116        size_t running_thread_cnt = 0;
    117117
    118118        TPRINTF("Spawning threads on %u cpus.\n", cpu_count);
    119        
     119
    120120        /* Create a wired thread on each cpu. */
    121121        for (unsigned int id = 0; id < cpu_count; ++id) {
    122122                thread[id] = thread_create(test_thread, &call_cnt[id], TASK,
    123123                        THREAD_FLAG_NONE, "smp-call-test");
    124                
     124
    125125                if (thread[id]) {
    126126                        thread_wire(thread[id], &cpus[id]);
    … …  
    133133        size_t exp_calls = calc_exp_calls(running_thread_cnt);
    134134        size_t exp_calls_sum = exp_calls * cpu_count;
    135        
     135
    136136        TPRINTF("Running %zu wired threads. Expecting %zu calls. Be patient.\n",
    137137                running_thread_cnt, exp_calls_sum);
    … …  
    142142                }
    143143        }
    144        
     144
    145145        /* Wait for threads to complete. */
    146146        for (unsigned int i = 0; i < cpu_count; ++i) {
    … …  
    152152
    153153        TPRINTF("Threads finished. Checking number of smp_call()s.\n");
    154        
     154
    155155        bool ok = true;
    156156        size_t calls_sum = 0;
    157        
     157
    158158        for (size_t i = 0; i < cpu_count; ++i) {
    159159                if (thread[i] != NULL) {
    … …  
    164164                        }
    165165                }
    166                
     166
    167167                calls_sum += call_cnt[i];
    168168        }
    169        
     169
    170170        if (calls_sum != exp_calls_sum) {
    171171                TPRINTF("Error: total acknowledged sum: %zu instead of %zu.\n",
    172172                        calls_sum, exp_calls_sum);
    173                
     173
    174174                ok = false;
    175175        }
    176        
     176
    177177        if (ok) {
    178178                TPRINTF("Success: number of received smp_calls is as expected (%zu).\n",
    … …  
    181181        } else
    182182                return "Failed: incorrect acknowledged smp_calls.\n";
    183        
     183
    184184}

  • kernel/test/synch/rcu1.c

    r3061bc1 r8565a42  
    6767                TPRINTF(".");
    6868        }
    69        
     69
    7070        if (!p->exited) {
    7171                *presult = ETIMEOUT;
    … …  
    8181{
    8282        assert(thread[k] == NULL);
    83        
     83
    8484        thread[k] = thread_create(func, arg, TASK, THREAD_FLAG_NONE,
    8585                "test-rcu-thread");
    86                
     86
    8787        if(thread[k]) {
    8888                /* Distribute evenly. */
    … …  
    9595{
    9696        size_t thread_cnt = get_thread_cnt();
    97        
     97
    9898        one_idx = 0;
    99        
     99
    100100        for (size_t i = 0; i < thread_cnt; ++i) {
    101101                run_thread(i, func, NULL);
    … …  
    106106{
    107107        size_t thread_cnt = get_thread_cnt();
    108        
     108
    109109        one_idx = 0;
    110        
     110
    111111        for (size_t i = 0; i < thread_cnt; ++i) {
    112112                if (thread[i]) {
    … …  
    115115                                errno_t ret = thread_join_timeout(thread[i], 5 * 1000 * 1000, 0);
    116116                                joined = (ret != ETIMEOUT);
    117                                
     117
    118118                                if (ret == EOK) {
    119119                                        TPRINTF("%zu threads remain\n", thread_cnt - i - 1);
    120120                                }
    121121                        } while (!joined);
    122                        
     122
    123123                        thread_detach(thread[i]);
    124124                        thread[i] = NULL;
    … …  
    140140
    141141        --one_idx;
    142        
     142
    143143        if (thread[one_idx]) {
    144144                thread_join(thread[one_idx]);
    … …  
    154154{
    155155        size_t nop_iters = (size_t)arg;
    156        
     156
    157157        TPRINTF("Enter nop-reader\n");
    158        
     158
    159159        for (size_t i = 0; i < nop_iters; ++i) {
    160160                rcu_read_lock();
    161161                rcu_read_unlock();
    162162        }
    163        
     163
    164164        TPRINTF("Exit nop-reader\n");
    165165}
    … …  
    169169        assert(0 < steps && from <= to && 0 < to);
    170170        size_t inc = (to - from) / (steps - 1);
    171        
     171
    172172        for (size_t i = 0; i < steps - 1; ++i) {
    173173                seq[i] = i * inc + from;
    174174        }
    175        
     175
    176176        seq[steps - 1] = to;
    177177}
    … …  
    181181        size_t seq[MAX_THREADS] = {0};
    182182        get_seq(100, 100000, get_thread_cnt(), seq);
    183        
     183
    184184        TPRINTF("\nRun %zu thr: repeat empty no-op reader sections\n", get_thread_cnt());
    185        
     185
    186186        for (size_t k = 0; k < get_thread_cnt(); ++k)
    187187                run_one(nop_reader, (void*)seq[k]);
    188        
     188
    189189        TPRINTF("\nJoining %zu no-op readers\n", get_thread_cnt());
    190190        join_all();
    191        
     191
    192192        return true;
    193193}
    … …  
    202202        size_t nop_iters = (size_t)arg;
    203203        size_t outer_iters = iter_cnt / nop_iters;
    204        
     204
    205205        TPRINTF("Enter long-reader\n");
    206        
     206
    207207        for (size_t i = 0; i < outer_iters; ++i) {
    208208                rcu_read_lock();
    209                
     209
    210210                for (volatile size_t k = 0; k < nop_iters; ++k) {
    211211                        /* nop, but increment volatile k */
    212212                }
    213                
     213
    214214                rcu_read_unlock();
    215215        }
    216        
     216
    217217        TPRINTF("Exit long-reader\n");
    218218}
    … …  
    222222        size_t seq[MAX_THREADS] = {0};
    223223        get_seq(10, 1000 * 1000, get_thread_cnt(), seq);
    224        
     224
    225225        TPRINTF("\nRun %zu thr: repeat long reader sections, will preempt, no cbs.\n",
    226226                get_thread_cnt());
    227        
     227
    228228        for (size_t k = 0; k < get_thread_cnt(); ++k)
    229229                run_one(long_reader, (void*)seq[k]);
    230        
     230
    231231        TPRINTF("\nJoining %zu readers with long reader sections.\n", get_thread_cnt());
    232232        join_all();
    233        
     233
    234234        return true;
    235235}
    … …  
    253253                rcu_item_t *a = malloc(sizeof(rcu_item_t), FRAME_ATOMIC);
    254254                rcu_item_t *b = malloc(sizeof(rcu_item_t), FRAME_ATOMIC);
    255                
     255
    256256                if (a && b) {
    257257                        rcu_call(a, count_cb);
    … …  
    272272        size_t exp_cnt = nop_updater_iters * get_thread_cnt();
    273273        size_t max_used_mem = sizeof(rcu_item_t) * exp_cnt;
    274        
     274
    275275        TPRINTF("\nRun %zu thr: post %zu no-op callbacks (%zu B used), no readers.\n",
    276276                get_thread_cnt(), exp_cnt, max_used_mem);
    277        
     277
    278278        run_all(nop_updater);
    279279        TPRINTF("\nJoining %zu no-op callback threads\n", get_thread_cnt());
    280280        join_all();
    281        
     281
    282282        size_t loop_cnt = 0, max_loops = 15;
    283283
    … …  
    287287                thread_sleep(1);
    288288        }
    289        
     289
    290290        return loop_cnt < max_loops;
    291291}
    … …  
    312312{
    313313        TPRINTF("Enter one-cb-reader\n");
    314        
    315         rcu_read_lock();
    316        
     314
     315        rcu_read_lock();
     316
    317317        item_w_cookie_t *item = malloc(sizeof(item_w_cookie_t), FRAME_ATOMIC);
    318        
     318
    319319        if (item) {
    320320                item->cookie = magic_cookie;
    … …  
    323323                TPRINTF("\n[out-of-mem]\n");
    324324        }
    325        
     325
    326326        thread_sleep(1);
    327        
     327
    328328        rcu_read_unlock();
    329        
     329
    330330        TPRINTF("Exit one-cb-reader\n");
    331331}
    … …  
    334334{
    335335        one_cb_is_done = 0;
    336        
     336
    337337        TPRINTF("\nRun a single reader that posts one callback.\n");
    338338        run_one(one_cb_reader, NULL);
    339339        join_one();
    340        
     340
    341341        TPRINTF("\nJoined one-cb reader, wait for callback.\n");
    342342        size_t loop_cnt = 0;
    343343        size_t max_loops = 4; /* 200 ms total */
    344        
     344
    345345        while (!one_cb_is_done && loop_cnt < max_loops) {
    346346                thread_usleep(50 * 1000);
    347347                ++loop_cnt;
    348348        }
    349        
     349
    350350        return one_cb_is_done;
    351351}
    … …  
    373373{
    374374        seq_item_t *item = member_to_inst(rcu_item, seq_item_t, rcu);
    375        
     375
    376376        /* Racy but errs to the conservative side, so it is ok. */
    377377        if (max_upd_done_time < item->start_time) {
    378378                max_upd_done_time = item->start_time;
    379                
     379
    380380                /* Make updated time visible */
    381381                memory_barrier();
    … …  
    393393#ifndef KARCH_riscv64
    394394        seq_work_t *work = (seq_work_t*)arg;
    395        
     395
    396396        /* Alternate between reader and updater roles. */
    397397        for (size_t k = 0; k < work->iters; ++k) {
    … …  
    400400                        rcu_read_lock();
    401401                        atomic_count_t start_time = atomic_postinc(&cur_time);
    402                        
     402
    403403                        for (volatile size_t d = 0; d < 10 * i; ++d ){
    404404                                /* no-op */
    405405                        }
    406                        
     406
    407407                        /* Get most recent max_upd_done_time. */
    408408                        memory_barrier();
    409                        
     409
    410410                        if (start_time < max_upd_done_time) {
    411411                                seq_test_result = ERACE;
    412412                        }
    413                        
     413
    414414                        rcu_read_unlock();
    415                        
     415
    416416                        if (seq_test_result != EOK)
    417417                                return;
    418418                }
    419                
     419
    420420                /* Updater */
    421421                for (size_t i = 0; i < work->update_cnt; ++i) {
    422422                        seq_item_t *a = malloc(sizeof(seq_item_t), FRAME_ATOMIC);
    423423                        seq_item_t *b = malloc(sizeof(seq_item_t), FRAME_ATOMIC);
    424                        
     424
    425425                        if (a && b) {
    426426                                a->start_time = atomic_postinc(&cur_time);
    427427                                rcu_call(&a->rcu, seq_cb);
    428                                
     428
    429429                                b->start_time = atomic_postinc(&cur_time);
    430430                                rcu_call(&b->rcu, seq_cb);
    … …  
    437437                        }
    438438                }
    439                
     439
    440440        }
    441441#else
    … …  
    454454        size_t read_cnt[MAX_THREADS] = {0};
    455455        seq_work_t item[MAX_THREADS];
    456        
     456
    457457        size_t total_cbs = 0;
    458458        size_t max_used_mem = 0;
    459        
     459
    460460        get_seq(0, total_cnt, get_thread_cnt(), read_cnt);
    461        
     461
    462462
    463463        for (size_t i = 0; i < get_thread_cnt(); ++i) {
    … …  
    465465                item[i].read_cnt = read_cnt[i];
    466466                item[i].iters = iters;
    467                
     467
    468468                total_cbs += 2 * iters * item[i].update_cnt;
    469469        }
    470        
     470
    471471        max_used_mem = total_cbs * sizeof(seq_item_t);
    472472
    … …  
    474474        uint64_t mem_units;
    475475        bin_order_suffix(max_used_mem, &mem_units, &mem_suffix, false);
    476        
     476
    477477        TPRINTF("\nRun %zu th: check callback completion time in readers. "
    478478                "%zu callbacks total (max %" PRIu64 " %s used). Be patient.\n",
    479479                get_thread_cnt(), total_cbs, mem_units, mem_suffix);
    480        
     480
    481481        for (size_t i = 0; i < get_thread_cnt(); ++i) {
    482482                run_one(seq_func, &item[i]);
    483483        }
    484        
     484
    485485        TPRINTF("\nJoining %zu seq-threads\n", get_thread_cnt());
    486486        join_all();
    487        
     487
    488488        if (seq_test_result == ENOMEM) {
    489489                TPRINTF("\nErr: out-of mem\n");
    … …  
    491491                TPRINTF("\nERROR: race detected!!\n");
    492492        }
    493        
     493
    494494        return seq_test_result == EOK;
    495495}
    … …  
    510510        rcu_read_lock();
    511511        rcu_read_unlock();
    512        
     512
    513513        rcu_call((rcu_item_t*)arg, reader_unlocked);
    514        
    515         rcu_read_lock();
    516         rcu_read_lock();
    517        
     514
     515        rcu_read_lock();
     516        rcu_read_lock();
     517
    518518        /* Exit without unlocking the rcu reader section. */
    519519}
    … …  
    522522{
    523523        TPRINTF("\nReader exits thread with rcu_lock\n");
    524        
     524
    525525        exited_t *p = malloc(sizeof(exited_t), FRAME_ATOMIC);
    526526        if (!p) {
    … …  
    528528                return false;
    529529        }
    530                
     530
    531531        p->exited = false;
    532        
     532
    533533        run_one(reader_exit, p);
    534534        join_one();
    535        
     535
    536536        errno_t result = EOK;
    537537        wait_for_cb_exit(2 /* secs */, p, &result);
    538        
     538
    539539        if (result != EOK) {
    540540                TPRINTF("Err: RCU locked up after exiting from within a reader\n");
    … …  
    543543                free(p);
    544544        }
    545        
     545
    546546        return result == EOK;
    547547}
    … …  
    570570
    571571        TPRINTF("reader_prev{ ");
    572        
     572
    573573        rcu_read_lock();
    574574        scheduler();
    … …  
    588588        preempt_t *p = (preempt_t*)arg;
    589589        assert(!p->e.exited);
    590        
     590
    591591        TPRINTF("reader_inside_cur{ ");
    592592        /*
    … …  
    613613        preempt_t *p = (preempt_t*)arg;
    614614        assert(!p->e.exited);
    615        
     615
    616616        TPRINTF("reader_cur{ ");
    617617        rcu_read_lock();
    … …  
    622622        /* Preempt while cur GP detection is running */
    623623        thread_sleep(1);
    624        
     624
    625625        /* Err: exited before this reader completed. */
    626626        if (p->e.exited)
    … …  
    635635        preempt_t *p = (preempt_t*)arg;
    636636        assert(!p->e.exited);
    637        
     637
    638638        TPRINTF("reader_next1{ ");
    639639        rcu_read_lock();
    … …  
    641641        /* Preempt before cur GP detection starts. */
    642642        scheduler();
    643        
     643
    644644        /* Start GP. */
    645645        rcu_call(&p->e.rcu, preempted_unlocked);
    … …  
    657657        preempt_t *p = (preempt_t*)arg;
    658658        assert(!p->e.exited);
    659        
     659
    660660        TPRINTF("reader_next2{ ");
    661661        rcu_read_lock();
    … …  
    663663        /* Preempt before cur GP detection starts. */
    664664        scheduler();
    665        
     665
    666666        /* Start GP. */
    667667        rcu_call(&p->e.rcu, preempted_unlocked);
    … …  
    691691                return false;
    692692        }
    693        
     693
    694694        p->e.exited = false;
    695695        p->result = EOK;
    696        
     696
    697697        run_one(f, p);
    698698        join_one();
    699        
     699
    700700        /* Wait at most 4 secs. */
    701701        wait_for_cb_exit(4, &p->e, &p->result);
    702        
     702
    703703        if (p->result == EOK) {
    704704                free(p);
    … …  
    714714{
    715715        TPRINTF("\nReaders will be preempted.\n");
    716        
     716
    717717        bool success = true;
    718718        bool ok = true;
    719        
     719
    720720        ok = do_one_reader_preempt(preempted_reader_prev,
    721721                "Err: preempted_reader_prev()\n");
    722722        success = success && ok;
    723        
     723
    724724        ok = do_one_reader_preempt(preempted_reader_inside_cur,
    725725                "Err: preempted_reader_inside_cur()\n");
    726726        success = success && ok;
    727        
     727
    728728        ok = do_one_reader_preempt(preempted_reader_cur,
    729729                "Err: preempted_reader_cur()\n");
    730730        success = success && ok;
    731        
     731
    732732        ok = do_one_reader_preempt(preempted_reader_next1,
    733733                "Err: preempted_reader_next1()\n");
    … …  
    737737                "Err: preempted_reader_next2()\n");
    738738        success = success && ok;
    739        
     739
    740740        return success;
    741741}
    … …  
    751751{
    752752        synch_t *synch = (synch_t *) arg;
    753        
     753
    754754        rcu_read_lock();
    755755
    756756        /* Order accesses of synch after the reader section begins. */
    757757        memory_barrier();
    758        
     758
    759759        synch->reader_running = true;
    760        
     760
    761761        while (!synch->synch_running) {
    762762                /* 0.5 sec */
    763763                delay(500 * 1000);
    764764        }
    765        
     765
    766766        /* Run for 1 sec */
    767767        delay(1000 * 1000);
    768768        /* thread_join() propagates done to do_synch() */
    769769        synch->reader_done = true;
    770        
     770
    771771        rcu_read_unlock();
    772772}
    … …  
    776776{
    777777        TPRINTF("\nSynchronize with long reader\n");
    778        
     778
    779779        synch_t *synch = malloc(sizeof(synch_t), FRAME_ATOMIC);
    780        
     780
    781781        if (!synch) {
    782782                TPRINTF("[out-of-mem]\n");
    783783                return false;
    784784        }
    785        
     785
    786786        synch->reader_done = false;
    787787        synch->reader_running = false;
    788788        synch->synch_running = false;
    789        
     789
    790790        run_one(synch_reader, synch);
    791        
     791
    792792        /* Wait for the reader to enter its critical section. */
    793793        scheduler();
    … …  
    795795                thread_usleep(500 * 1000);
    796796        }
    797        
     797
    798798        synch->synch_running = true;
    799        
     799
    800800        rcu_synchronize();
    801801        join_one();
    802        
    803        
     802
     803
    804804        if (synch->reader_done) {
    805805                free(synch);
    … …  
    827827{
    828828        TPRINTF("\nrcu_barrier: Wait for outstanding rcu callbacks to complete\n");
    829        
     829
    830830        barrier_t *barrier = malloc(sizeof(barrier_t), FRAME_ATOMIC);
    831        
     831
    832832        if (!barrier) {
    833833                TPRINTF("[out-of-mem]\n");
    834834                return false;
    835835        }
    836        
     836
    837837        atomic_set(&barrier->done, 0);
    838        
     838
    839839        rcu_call(&barrier->rcu_item, barrier_callback);
    840840        rcu_barrier();
    841        
     841
    842842        if (1 == atomic_get(&barrier->done)) {
    843843                free(barrier);
    … …  
    861861{
    862862        bool *done = (bool*) arg;
    863        
     863
    864864        while (!*done) {
    865865                rcu_read_lock();
    866866                rcu_read_unlock();
    867                
     867
    868868                /*
    869869                 * Do some work outside of the reader section so we are not always
    … …  
    884884{
    885885        stress_t *s = (stress_t *)arg;
    886        
     886
    887887        for (size_t i = 0; i < s->iters; ++i) {
    888888                rcu_item_t *item = malloc(sizeof(rcu_item_t), FRAME_ATOMIC);
    889                
     889
    890890                if (item) {
    891891                        rcu_call(item, stress_cb);
    … …  
    894894                        return;
    895895                }
    896                
     896
    897897                /* Print a dot if we make a progress of 1% */
    898898                if (s->master && 0 == (i % (s->iters/100)))
    … …  
    907907        stress_t master = { .iters = cb_per_thread, .master = true };
    908908        stress_t worker = { .iters = cb_per_thread, .master = false };
    909        
     909
    910910        size_t thread_cnt = min(MAX_THREADS / 2, config.cpu_active);
    911911        /* Each cpu has one reader and one updater. */
    912912        size_t reader_cnt = thread_cnt;
    913913        size_t updater_cnt = thread_cnt;
    914        
     914
    915915        size_t exp_upd_calls = updater_cnt * cb_per_thread;
    916916        size_t max_used_mem = exp_upd_calls * sizeof(rcu_item_t);
    917        
     917
    918918        const char *mem_suffix;
    919919        uint64_t mem_units;
    … …  
    923923                " total (max %" PRIu64 " %s used). Be very patient.\n",
    924924                reader_cnt, updater_cnt, exp_upd_calls, mem_units, mem_suffix);
    925        
     925
    926926        for (size_t k = 0; k < reader_cnt; ++k) {
    927927                run_one(stress_reader, &done);
    … …  
    931931                run_one(stress_updater, k > 0 ? &worker : &master);
    932932        }
    933        
     933
    934934        TPRINTF("\nJoining %zu stress updaters.\n", updater_cnt);
    935        
     935
    936936        for (size_t k = 0; k < updater_cnt; ++k) {
    937937                join_one();
    938938        }
    939        
     939
    940940        done = true;
    941941
    942942        TPRINTF("\nJoining %zu stress nop-readers.\n", reader_cnt);
    943        
     943
    944944        join_all();
    945945        return true;
    … …  
    957957{
    958958        expedite_t *e = (expedite_t *)arg;
    959        
     959
    960960        if (1 < e->count_down) {
    961961                --e->count_down;
    962                
     962
    963963                if (0 == (e->count_down % (e->total_cnt/100))) {
    964964                        TPRINTF("*");
    965965                }
    966                
     966
    967967                _rcu_call(e->expedite, &e->r, expedite_cb);
    968968        } else {
    … …  
    979979        e.count_down = cnt;
    980980        e.expedite = exp;
    981        
     981
    982982        _rcu_call(e.expedite, &e.r, expedite_cb);
    983        
     983
    984984        while (0 < e.count_down) {
    985985                thread_sleep(1);
    … …  
    992992        size_t exp_cnt = 1000 * 1000;
    993993        size_t normal_cnt = 1 * 1000;
    994        
     994
    995995        TPRINTF("Expedited: sequence of %zu rcu_calls\n", exp_cnt);
    996996        run_expedite(true, exp_cnt);
    … …  
    10241024                { 0, NULL, NULL }
    10251025        };
    1026        
     1026
    10271027        bool success = true;
    10281028        bool ok = true;
    10291029        uint64_t completed_gps = rcu_completed_gps();
    10301030        uint64_t delta_gps = 0;
    1031        
     1031
    10321032        for (int i = 0; test_func[i].func; ++i) {
    10331033                if (!test_func[i].include) {
    … …  
    10371037                        TPRINTF("\nRunning subtest %s.\n", test_func[i].desc);
    10381038                }
    1039                
     1039
    10401040                ok = test_func[i].func();
    10411041                success = success && ok;
    1042                
     1042
    10431043                delta_gps = rcu_completed_gps() - completed_gps;
    10441044                completed_gps += delta_gps;

  • kernel/test/synch/semaphore1.c

    r3061bc1 r8565a42  
    4949{
    5050        thread_detach(THREAD);
    51        
     51
    5252        waitq_sleep(&can_start);
    53        
     53
    5454        semaphore_down(&sem);
    5555        atomic_inc(&items_produced);
    … …  
    6161{
    6262        thread_detach(THREAD);
    63        
     63
    6464        waitq_sleep(&can_start);
    65        
     65
    6666        semaphore_down(&sem);
    6767        atomic_inc(&items_consumed);
    … …  
    7575        atomic_count_t consumers;
    7676        atomic_count_t producers;
    77        
     77
    7878        waitq_initialize(&can_start);
    7979        semaphore_initialize(&sem, AT_ONCE);
    80        
     80
    8181        for (i = 1; i <= 3; i++) {
    8282                thread_t *thrd;
    83                
     83
    8484                atomic_set(&items_produced, 0);
    8585                atomic_set(&items_consumed, 0);
    86                
     86
    8787                consumers = i * CONSUMERS;
    8888                producers = (4 - i) * PRODUCERS;
    89                
     89
    9090                TPRINTF("Creating %" PRIua " consumers and %" PRIua " producers...",
    9191                    consumers, producers);
    92                
     92
    9393                for (j = 0; j < (CONSUMERS + PRODUCERS) / 2; j++) {
    9494                        for (k = 0; k < i; k++) {
    … …  
    109109                        }
    110110                }
    111                
     111
    112112                TPRINTF("ok\n");
    113                
     113
    114114                thread_sleep(1);
    115115                waitq_wakeup(&can_start, WAKEUP_ALL);
    116                
     116
    117117                while ((items_consumed.count != consumers) || (items_produced.count != producers)) {
    118118                        TPRINTF("%" PRIua " consumers remaining, %" PRIua " producers remaining\n",
    … …  
    121121                }
    122122        }
    123        
     123
    124124        return NULL;
    125125}

  • kernel/test/synch/semaphore2.c

    r3061bc1 r8565a42  
    5050{
    5151        uint32_t rc;
    52        
     52
    5353        spinlock_lock(&sem_lock);
    5454        rc = seed % max;
    … …  
    6262        errno_t rc;
    6363        int to;
    64        
     64
    6565        thread_detach(THREAD);
    66        
     66
    6767        waitq_sleep(&can_start);
    68        
     68
    6969        to = random(20000);
    7070        TPRINTF("cpu%u, tid %" PRIu64 " down+ (%d)\n", CPU->id, THREAD->tid, to);
    … …  
    7474                return;
    7575        }
    76        
     76
    7777        TPRINTF("cpu%u, tid %" PRIu64 " down=\n", CPU->id, THREAD->tid);
    7878        thread_usleep(random(30000));
    79        
     79
    8080        semaphore_up(&sem);
    8181        TPRINTF("cpu%u, tid %" PRIu64 " up\n", CPU->id, THREAD->tid);
    … …  
    8585{
    8686        uint32_t i, k;
    87        
     87
    8888        waitq_initialize(&can_start);
    8989        semaphore_initialize(&sem, 5);
    90        
     90
    9191        thread_t *thrd;
    92        
     92
    9393        k = random(7) + 1;
    9494        TPRINTF("Creating %" PRIu32 " consumers\n", k);
    … …  
    101101                        TPRINTF("Error creating thread\n");
    102102        }
    103        
     103
    104104        thread_usleep(20000);
    105105        waitq_wakeup(&can_start, WAKEUP_ALL);
    106        
     106
    107107        return NULL;
    108108}

  • kernel/test/synch/workq-test-core.h

    r3061bc1 r8565a42  
    5454{
    5555        ++work->wave;
    56        
     56
    5757        if (work->wave < WAVES) {
    5858                work->count_down = COUNT;
    … …  
    7979                child->count_down = work->count_down;
    8080        }
    81        
     81
    8282        return child;
    8383}
    … …  
    9393        /* Ensure work_item is ours for the taking. */
    9494        memsetb(work_item, sizeof(work_t), 0xec);
    95        
     95
    9696        test_work_t *work = (test_work_t *)work_item;
    97        
     97
    9898        atomic_inc(&call_cnt[work->wave]);
    99        
     99
    100100        if (0 < work->count_down) {
    101101                /* Sleep right before creating the last generation. */
    … …  
    108108                        }
    109109                }
    110                
     110
    111111                --work->count_down;
    112112
    … …  
    122122                        }
    123123                }
    124                
     124
    125125                if (!core_workq_enqueue(work_item, reproduce)) {
    126126                        if (work->master)
    … …  
    131131        } else {
    132132                /* We're done with this wave - only the master survives. */
    133                
     133
    134134                if (work->master && new_wave(work)) {
    135135                        if (!core_workq_enqueue(work_item, reproduce)) {
    … …  
    140140                        if (work->master)
    141141                                TPRINTF("\nMaster work item done.\n");
    142                                
     142
    143143                        free_work(work);
    144144                }
    … …  
    157157        work->wave = 0;
    158158        work->count_down = COUNT;
    159        
     159
    160160        /*
    161161         * k == COUNT_POW
    … …  
    166166         */
    167167        size_t exp_call_cnt = (COUNT_POW + 2) * (1 << (COUNT_POW - 1));
    168        
     168
    169169        TPRINTF("waves: %d, count_down: %d, total expected calls: %zu\n",
    170170                WAVES, COUNT, exp_call_cnt * WAVES);
    171        
     171
    172172
    173173        core_workq_enqueue(&work->work_item, reproduce);
    174        
     174
    175175        size_t sleep_cnt = 0;
    176176        /* At least 40 seconds total (or 2 sec to end while there's work). */
    177177        size_t max_sleep_secs = end_prematurely ? 2 : MAIN_MAX_SLEEP_SEC;
    178178        size_t max_sleep_cnt = (max_sleep_secs * 1000) / MAIN_POLL_SLEEP_MS;
    179        
     179
    180180        for (int i = 0; i < WAVES; ++i) {
    181181                while (atomic_get(&call_cnt[i]) < exp_call_cnt
    … …  
    186186                }
    187187        }
    188        
     188
    189189        bool success = true;
    190        
     190
    191191        for (int i = 0; i < WAVES; ++i) {
    192192                if (atomic_get(&call_cnt[i]) == exp_call_cnt) {
    … …  
    199199                }
    200200        }
    201        
    202        
     201
     202
    203203        if (success)
    204204                return NULL;

  • kernel/test/synch/workqueue2.c

    r3061bc1 r8565a42  
    6363        basic_done = 0;
    6464        workq_global_enqueue(&basic_work, basic_test_work);
    65        
     65
    6666        while (!basic_done) {
    6767                TPRINTF(".");
    … …  
    8787{
    8888        workq = workq_create(qname);
    89        
     89
    9090        if (!workq) {
    9191                return "Failed to create a work queue.\n";
    9292        }
    93        
     93
    9494        const char *ret = run_workq_core(stop);
    95        
     95
    9696        TPRINTF("Stopping work queue...\n");
    9797        workq_stop(workq);
    98        
     98
    9999        TPRINTF("Destroying work queue...\n");
    100100        workq_destroy(workq);
    … …  
    123123        const char *err = NULL;
    124124        const char *res;
    125        
     125
    126126        basic_test();
    127        
     127
    128128        res = test_custom_workq();
    129129        if (res) {
    … …  
    131131                err = res;
    132132        }
    133        
     133
    134134        res = test_custom_workq_stop();
    135135        if (res) {
    … …  
    137137                err = res;
    138138        }
    139        
     139
    140140        res = test_workqueue3();
    141141        if (res) {

  • kernel/test/synch/workqueue3.c

    r3061bc1 r8565a42  
    6666
    6767        TPRINTF("Done.\n");
    68        
     68
    6969        return err;
    7070}

  • kernel/test/test.c

    r3061bc1 r8565a42  
    7575        size_t len = str_length(input);
    7676        test_t **test = (test_t **) ctx;
    77        
     77
    7878        if (*test == NULL)
    7979                *test = tests;
    80        
     80
    8181        for (; (*test)->name; (*test)++) {
    8282                const char *curname = (*test)->name;
    83                
     83
    8484                if (str_length(curname) < len)
    8585                        continue;
    86                
     86
    8787                if (str_lcmp(input, curname, len) == 0) {
    8888                        (*test)++;
    … …  
    9292                }
    9393        }
    94        
     94
    9595        return NULL;
    9696}

  • kernel/test/thread/thread1.c

    r3061bc1 r8565a42  
    4545{
    4646        thread_detach(THREAD);
    47        
     47
    4848        while (atomic_get(&finish)) {
    4949                TPRINTF("%" PRIu64 " ", THREAD->tid);
    … …  
    5757        unsigned int i;
    5858        atomic_count_t total = 0;
    59        
     59
    6060        atomic_set(&finish, 1);
    6161        atomic_set(&threads_finished, 0);
    62        
     62
    6363        for (i = 0; i < THREADS; i++) {
    6464                thread_t *t;
    … …  
    7171                total++;
    7272        }
    73        
     73
    7474        TPRINTF("Running threads for 10 seconds...\n");
    7575        thread_sleep(10);
    76        
     76
    7777        atomic_set(&finish, 0);
    7878        while (atomic_get(&threads_finished) < total) {
    … …  
    8080                thread_sleep(1);
    8181        }
    82        
     82
    8383        return NULL;
    8484}
Note: See TracChangeset for help on using the changeset viewer.