Changeset 03daabd in mainline for uspace/srv/sysman


Ignore:
Timestamp:
2019-10-06T19:47:36Z (6 years ago)
Author:
Matthieu Riolo <matthieu.riolo@…>
Children:
5be6361
Parents:
9559cf8
git-author:
Matthieu Riolo <matthieu.riolo@…> (2019-09-17 07:50:03)
git-committer:
Matthieu Riolo <matthieu.riolo@…> (2019-10-06 19:47:36)
Message:

Renaming dyn_array to array

The term dyn_array is redunant and has therefore been replaced
with the shorter term array

Location:
uspace/srv/sysman
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/sysman/job.c

    r9559cf8 r03daabd  
    7070        job->unit = u;
    7171
    72         dyn_array_initialize(&job->blocked_jobs, job_t *);
     72        array_initialize(&job->blocked_jobs, job_t *);
    7373        job->blocking_jobs = 0;
    7474        job->blocking_job_failed = false;
    … …  
    120120        assert(!link_used(&job->job_queue));
    121121
    122         dyn_array_foreach(job->blocked_jobs, job_t *, job_it) {
     122        array_foreach(job->blocked_jobs, job_t *, job_it) {
    123123                job_del_ref(&(*job_it));
    124124        }
    125         dyn_array_destroy(&job->blocked_jobs);
     125        array_destroy(&job->blocked_jobs);
    126126
    127127        free(job);
    … …  
    257257        /* First remove references, then clear the array */
    258258        assert(job->blocked_jobs.size == job->blocked_jobs_count);
    259         dyn_array_foreach(job->blocked_jobs, job_t *, job_it) {
     259        array_foreach(job->blocked_jobs, job_t *, job_it) {
    260260                job_unblock(*job_it, job);
    261261        }
    262         dyn_array_clear(&job->blocked_jobs);
     262        array_clear(&job->blocked_jobs);
    263263
    264264        /* Add reference for event handler */

  • uspace/srv/sysman/job.h

    r9559cf8 r03daabd  
    3030#define SYSMAN_JOB_H
    3131
    32 #include <adt/dyn_array.h>
     32#include <adt/array.h>
    3333#include <adt/list.h>
    3434#include <stdatomic.h>
    … …  
    6464
    6565        /** Jobs that this job is preventing from running */
    66         dyn_array_t blocked_jobs;
     66        array_t blocked_jobs;
    6767        /**
    6868         * No. of jobs that the job is actually blocking (may differ from size

  • uspace/srv/sysman/job_closure.c

    r9559cf8 r03daabd  
    6666            blocking_job->blocked_jobs_count);
    6767
    68         errno_t rc = dyn_array_append(&blocking_job->blocked_jobs, job_t *,
     68        errno_t rc = array_append(&blocking_job->blocked_jobs, job_t *,
    6969            blocked_job);
    7070        if (rc != EOK) {
    … …  
    9797                        goto finish;
    9898                }
    99                 job_t *first_job = dyn_array_last(closure, job_t *);
     99                job_t *first_job = array_last(closure, job_t *);
    100100
    101101                job_add_ref(first_job);
    … …  
    119119
    120120                /* Pass job reference to closure and add one for unit */
    121                 rc = dyn_array_append(closure, job_t *, created_job);
     121                rc = array_append(closure, job_t *, created_job);
    122122                if (rc != EOK) {
    123123                        goto finish;
    … …  
    165165
    166166                /* Pass job reference to closure and add one for unit */
    167                 rc = dyn_array_append(closure, job_t *, created_job);
     167                rc = array_append(closure, job_t *, created_job);
    168168                if (rc != EOK) {
    169169                        goto finish;
    … …  
    308308        }
    309309
    310         errno_t rc = dyn_array_append(job_closure, job_t *, main_job);
     310        errno_t rc = array_append(job_closure, job_t *, main_job);
    311311        if (rc != EOK) {
    312312                return rc;
    … …  
    343343
    344344        if (rc == EOK) {
    345                 dyn_array_foreach(*job_closure, job_t *, job_it) {
     345                array_foreach(*job_closure, job_t *, job_it) {
    346346                        sysman_log(LVL_DEBUG2, "%s\t%s, refs: %u", __func__,
    347347                            unit_name((*job_it)->unit), atomic_load(&(*job_it)->refcnt));
    … …  
    350350
    351351        /* Clean after ourselves (BFS tag jobs) */
    352         dyn_array_foreach(*job_closure, job_t *, job_it) {
     352        array_foreach(*job_closure, job_t *, job_it) {
    353353                job_t *j = (*job_it)->unit->bfs_data;
    354354                assert(*job_it == j);

  • uspace/srv/sysman/job_closure.h

    r9559cf8 r03daabd  
    3030#define SYSMAN_JOB_CLOSURE_H
    3131
    32 #include <adt/dyn_array.h>
     32#include <adt/array.h>
    3333
    3434#include "job.h"
    … …  
    3636#define CLOSURE_ISOLATE 0x1
    3737
    38 typedef dyn_array_t job_closure_t;
     38typedef array_t job_closure_t;
    3939
    4040extern errno_t job_create_closure(job_t *, job_closure_t *, int);

  • uspace/srv/sysman/job_queue.c

    r9559cf8 r03daabd  
    110110        assert(other->merged_into == NULL);
    111111
    112         errno_t rc = dyn_array_concat(&trunk->blocked_jobs, &other->blocked_jobs);
     112        errno_t rc = array_concat(&trunk->blocked_jobs, &other->blocked_jobs);
    113113        if (rc != EOK) {
    114114                return rc;
    115115        }
    116         dyn_array_clear(&other->blocked_jobs);
     116        array_clear(&other->blocked_jobs);
    117117
    118118        // TODO allocate observed object
    … …  
    145145{
    146146        assert(trunk->blocked_jobs.size >= trunk->blocked_jobs_count);
    147         dyn_array_clear_range(&trunk->blocked_jobs,
     147        array_clear_range(&trunk->blocked_jobs,
    148148            trunk->blocked_jobs_count, trunk->blocked_jobs.size);
    149149}
    … …  
    172172
    173173        /* Check consistency with existing jobs. */
    174         dyn_array_foreach(*closure, job_t *, job_it) {
     174        array_foreach(*closure, job_t *, job_it) {
    175175                job_t *job = *job_it;
    176176                job_t *other_job = job->unit->job;
    … …  
    214214        /* Aggregate merged jobs, or rollback any changes in existing jobs */
    215215        bool finish_merge = (rc == EOK) && !has_error;
    216         dyn_array_foreach(*closure, job_t *, job_it) {
     216        array_foreach(*closure, job_t *, job_it) {
    217217                if ((*job_it)->merged_into == NULL) {
    218218                        continue;
    … …  
    236236         *      in their blocked_jobs array.
    237237         */
    238         dyn_array_foreach(*closure, job_t *, job_it) {
     238        array_foreach(*closure, job_t *, job_it) {
    239239                job_t *job = (*job_it);
    240240                if (job->merged_into != NULL) {
    … …  
    255255
    256256        /* We've stolen references from the closure, so erase it */
    257         dyn_array_clear(closure);
     257        array_clear(closure);
    258258
    259259        return EOK;

  • uspace/srv/sysman/sysman.c

    r9559cf8 r03daabd  
    366366        job_t *job = job_args->job;
    367367        int flags = job_args->flags;
    368         dyn_array_t job_closure;
    369         dyn_array_initialize(&job_closure, job_t *);
     368        array_t job_closure;
     369        array_initialize(&job_closure, job_t *);
    370370
    371371        if (job_args->callback != NULL) {
    … …  
    402402        job_del_ref(&job);
    403403
    404         dyn_array_foreach(job_closure, job_t *, closure_job) {
     404        array_foreach(job_closure, job_t *, closure_job) {
    405405                job_del_ref(&(*closure_job));
    406406        }
    407         dyn_array_destroy(&job_closure);
     407        array_destroy(&job_closure);
    408408}
    409409

  • uspace/srv/sysman/test/job_closure.c

    r9559cf8 r03daabd  
    4040PCUT_TEST_SUITE(job_closure);
    4141
    42 static dyn_array_t exp_closure;
    43 static dyn_array_t act_closure;
     42static array_t exp_closure;
     43static array_t act_closure;
    4444
    4545static bool same_job(job_t *expected, job_t *actual)
    … …  
    4949}
    5050
    51 static bool same_jobs(dyn_array_t *expected, dyn_array_t *actual)
     51static bool same_jobs(array_t *expected, array_t *actual)
    5252{
    5353        if (expected->size != actual->size) {
    … …  
    5858
    5959        /* Verify expected \subseteq actual (we've compared sizes) */
    60         dyn_array_foreach(*expected, job_t *, it_exp) {
     60        array_foreach(*expected, job_t *, it_exp) {
    6161                bool found = false;
    62                 dyn_array_foreach(*actual, job_t *, it_act) {
     62                array_foreach(*actual, job_t *, it_act) {
    6363                        if (same_job(*it_exp, *it_act)) {
    6464                                found = true;
    … …  
    7979{
    8080        bool found = false;
    81         dyn_array_foreach(blocking_job->blocked_jobs, job_t *, it) {
     81        array_foreach(blocking_job->blocked_jobs, job_t *, it) {
    8282                if (*it == blocked_job) {
    8383                        found = true;
    … …  
    9494}
    9595
    96 static void dummy_add_closure(dyn_array_t *closure)
    97 {
    98         dyn_array_foreach(*closure, job_t *, it) {
     96static void dummy_add_closure(array_t *closure)
     97{
     98        array_foreach(*closure, job_t *, it) {
    9999                (*it)->unit->job = *it;
    100100        }
    101101}
    102102
    103 static void destroy_job_closure(dyn_array_t *closure)
    104 {
    105         dyn_array_foreach(*closure, job_t *, it) {
     103static void destroy_job_closure(array_t *closure)
     104{
     105        array_foreach(*closure, job_t *, it) {
    106106                job_del_ref(&(*it));
    107107        }
    … …  
    113113        mock_set_units_state(STATE_STOPPED);
    114114
    115         dyn_array_initialize(&exp_closure, job_t *);
    116         errno_t rc = dyn_array_reserve(&exp_closure, MAX_TYPES * MAX_UNITS);
     115        array_initialize(&exp_closure, job_t *);
     116        errno_t rc = array_reserve(&exp_closure, MAX_TYPES * MAX_UNITS);
    117117        assert(rc == EOK);
    118118
    119         dyn_array_initialize(&act_closure, job_t *);
    120         rc = dyn_array_reserve(&act_closure, MAX_TYPES * MAX_UNITS);
     119        array_initialize(&act_closure, job_t *);
     120        rc = array_reserve(&act_closure, MAX_TYPES * MAX_UNITS);
    121121        assert(rc == EOK);
    122122
    … …  
    127127{
    128128        destroy_job_closure(&act_closure);
    129         dyn_array_destroy(&act_closure);
     129        array_destroy(&act_closure);
    130130
    131131        destroy_job_closure(&exp_closure);
    132         dyn_array_destroy(&exp_closure);
     132        array_destroy(&exp_closure);
    133133
    134134        mock_destroy_units();
    … …  
    156156        PCUT_ASSERT_INT_EQUALS(EOK, rc);
    157157
    158         dyn_array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
    159         dyn_array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
    160         dyn_array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED));
     158        array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
     159        array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
     160        array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED));
    161161
    162162        dummy_add_closure(&act_closure);
    … …  
    188188        PCUT_ASSERT_INT_EQUALS(EOK, rc);
    189189
    190         dyn_array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
    191         dyn_array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
    192         dyn_array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED));
     190        array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
     191        array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
     192        array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED));
    193193
    194194        dummy_add_closure(&act_closure);
    … …  
    222222        PCUT_ASSERT_INT_EQUALS(EOK, rc);
    223223
    224         dyn_array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
    225         dyn_array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
    226         dyn_array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED));
     224        array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
     225        array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
     226        array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STARTED));
    227227
    228228        dummy_add_closure(&act_closure);
    … …  
    269269        PCUT_ASSERT_INT_EQUALS(EOK, rc);
    270270
    271         dyn_array_append(&exp_closure, job_t *, dummy_job(u0, STATE_STOPPED));
    272         dyn_array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
    273         dyn_array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
    274         dyn_array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STOPPED));
    275         dyn_array_append(&exp_closure, job_t *, dummy_job(u4, STATE_STOPPED));
    276         dyn_array_append(&exp_closure, job_t *, dummy_job(u5, STATE_STOPPED));
    277         dyn_array_append(&exp_closure, job_t *, dummy_job(u6, STATE_STOPPED));
     271        array_append(&exp_closure, job_t *, dummy_job(u0, STATE_STOPPED));
     272        array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
     273        array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
     274        array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STOPPED));
     275        array_append(&exp_closure, job_t *, dummy_job(u4, STATE_STOPPED));
     276        array_append(&exp_closure, job_t *, dummy_job(u5, STATE_STOPPED));
     277        array_append(&exp_closure, job_t *, dummy_job(u6, STATE_STOPPED));
    278278
    279279        dummy_add_closure(&act_closure);
Note: See TracChangeset for help on using the changeset viewer.