loadgen.c

来自「lustre 1.6.5 source code」· C语言 代码 · 共 1,038 行 · 第 1/3 页

        pthread_mutex_lock(&m_config);

        args[0] = cmdname;

        /* OSC */
        /* attach "osc" oscname oscuuid */
        args[1] = "osc";
        args[2] = args[3] = oname;
        rc = jt_lcfg_attach(4, args);
        if (rc) {
                fprintf(stderr, "%s: can't attach osc '%s' (%d)\n",
                        cmdname, oname, rc);
                /* Assume we want e.g. an old one cleaned anyhow. */
                goto clean;
        }
        /* setup ostname "OSS_UUID" */
        args[1] = target;
        args[2] = "OSS_UUID";
        rc = jt_lcfg_setup(3, args);
        if (rc) {
                fprintf(stderr, "%s: can't setup osc '%s' (%d)\n",
                        cmdname, oname, rc);
                goto clean;
        }

        /* Large grants cause ENOSPC to be reported, even though
           there's space left.  We can reduce the grant size by
           minimizing these */
        sprintf(proc_path, "/proc/fs/lustre/osc/%s/max_dirty_mb", oname);
        rc = write_proc(proc_path, "1");
        sprintf(proc_path, "/proc/fs/lustre/osc/%s/max_rpcs_in_flight", oname);
        rc = write_proc(proc_path, "1");

        /* ECHO CLI */
        /* attach "echo_client" echoname echouuid */
        args[1] = "echo_client";
        args[2] = args[3] = ename;
        rc = jt_lcfg_attach(4, args);
        if (rc) {
                fprintf(stderr, "%s: can't attach '%s' (%d)\n",
                        cmdname, ename, rc);
                if (rc == ENODEV)
                        fprintf(stderr, "%s: is the obdecho module loaded?\n",
                                cmdname);
                goto clean;
        }
        /* setup oscname */
        args[1] = oname;
        rc = jt_lcfg_setup(2, args);
        if (rc) {
                fprintf(stderr, "%s: can't setup '%s' (%d)\n",
                        cmdname, ename, rc);
                goto clean;
        }

        args[1] = ename;
        rc = jt_obd_device(2, args);
        if (rc) {
                fprintf(stderr, "%s: can't set device '%s' (%d)\n",
                        cmdname, ename, rc);
                goto clean;
        }

        if (!rc)
                *dev = jt_obd_get_device();
        pthread_mutex_unlock(&m_config);
        return rc;

clean:
        pthread_mutex_unlock(&m_config);
        cleanup(ename, 1);
        cleanup(oname, 1);
        return rc;
}

/* We can't use the libptlctl library fns because they are not shared-memory
   safe with respect to the ioctl device (cur_dev) */
static int obj_ioctl(int cmd, struct obd_ioctl_data *data, int unpack)
{
        char *buf = NULL;
        int rc;

        //IOC_PACK(cmdname, data);
        if (obd_ioctl_pack(data, &buf, sizeof(*data))) {
                fprintf(stderr, "dev %d invalid ioctl\n", data->ioc_dev);
                rc = EINVAL;
                goto out;
        }

        rc = l_ioctl(OBD_DEV_ID, cmd, buf);

        if (unpack) {
                //IOC_UNPACK(argv[0], data);
                if (obd_ioctl_unpack(data, buf, sizeof(*data))) {
                        fprintf(stderr, "dev %d invalid reply\n", data->ioc_dev);
                        rc = EINVAL;
                        goto out;
                }
        }

out:
        if (buf)
                free(buf);
        return rc;
}

/* See jt_obd_create */
static int obj_create(struct kid_t *kid)
{
        struct obd_ioctl_data data;
        int rc;

        memset(&data, 0, sizeof(data));
        data.ioc_dev = kid->k_dev;
        data.ioc_obdo1.o_mode = 0100644;
        data.ioc_obdo1.o_id = 0;
        data.ioc_obdo1.o_uid = 0;
        data.ioc_obdo1.o_gid = 0;
        data.ioc_obdo1.o_valid = OBD_MD_FLTYPE | OBD_MD_FLMODE |
                OBD_MD_FLID | OBD_MD_FLUID | OBD_MD_FLGID;

        rc = obj_ioctl(OBD_IOC_CREATE, &data, 1);
        if (rc) {
                fprintf(stderr, "%d: create (%d) %s\n",
                        kid->k_id, rc, strerror(errno));
                return rc;
        }

        if (!(data.ioc_obdo1.o_valid & OBD_MD_FLID)) {
                fprintf(stderr, "%d: create oid not valid "LPX64"\n",
                        kid->k_id, data.ioc_obdo1.o_valid);
                return rc;
        }

        kid->k_objid = data.ioc_obdo1.o_id;

        if (o_verbose > 4)
                printf("%d: cr "LPX64"\n", kid->k_id, kid->k_objid);

        return rc;
}

/* See jt_obd_destroy */
static int obj_delete(struct kid_t *kid)
{
        struct obd_ioctl_data data;
        int rc;

        if (o_verbose > 4)
                printf("%d: del "LPX64"\n", kid->k_id, kid->k_objid);

        memset(&data, 0, sizeof(data));
        data.ioc_dev = kid->k_dev;
        data.ioc_obdo1.o_id = kid->k_objid;
        data.ioc_obdo1.o_mode = S_IFREG | 0644;
        data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLMODE;

        rc = obj_ioctl(OBD_IOC_DESTROY, &data, 1);
        if (rc)
                fprintf(stderr, "%s-%d: can't destroy obj "LPX64" (%d)\n",
                        cmdname, kid->k_id, kid->k_objid, rc);

        kid->k_objid = 0;
        return rc;
}

#define difftime(a, b)                                  \
        ((a)->tv_sec - (b)->tv_sec +                    \
         ((a)->tv_usec - (b)->tv_usec) / 1000000.0)

/* See jt_obd_test_brw */
static int obj_write(struct kid_t *kid)
{
        struct obd_ioctl_data data;
        struct timeval start;
        __u64 count, len;
        int rc = 0, i, pages = 0;

        if (o_verbose > 4)
                printf("%d: wr "LPX64"\n", kid->k_id, kid->k_objid);

        count = 10;
        pages = 32;
        len = pages * getpagesize();

        memset(&data, 0, sizeof(data));
        data.ioc_dev = kid->k_dev;
        /* communicate the 'type' of brw test and batching to echo_client.
         * don't start.  we'd love to refactor this lctl->echo_client
         * interface */
        data.ioc_pbuf1 = (void *)1;
        data.ioc_plen1 = 1;

        data.ioc_obdo1.o_id = kid->k_objid;
        data.ioc_obdo1.o_mode = S_IFREG;
        data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMODE |
                OBD_MD_FLFLAGS;
        data.ioc_obdo1.o_flags = OBD_FL_DEBUG_CHECK;
        data.ioc_count = len;
        data.ioc_offset = 0;

        gettimeofday(&start, NULL);

        for (i = 1; i <= count; i++) {
                data.ioc_obdo1.o_valid &= ~(OBD_MD_FLBLOCKS|OBD_MD_FLGRANT);
                rc = obj_ioctl(OBD_IOC_BRW_WRITE, &data, 0);
                if (rc) {
                        fprintf(stderr, "%d: write %s\n", kid->k_id,
                                strerror(rc = errno));
                        break;
                }

                data.ioc_offset += len;
        }

        if (!rc) {
                struct timeval end;
                double diff;

                gettimeofday(&end, NULL);
                diff = difftime(&end, &start);

                --i;

                pthread_mutex_lock(&m_count);
                write_bytes += i * len;
                pthread_mutex_unlock(&m_count);

                if (o_verbose > 4)
                        printf("%d: wrote %dx%d pages in %.3fs (%.3f MB/s): %s",
                               kid->k_id, i, pages, diff,
                               ((double)i * len) / (diff * 1048576.0),
                               ctime(&end.tv_sec));
        }

        if (rc)
                fprintf(stderr, "%s-%d: err test_brw obj "LPX64" (%d)\n",
                        cmdname, kid->k_id, kid->k_objid, rc);
        return rc;
}

static int do_work(struct kid_t *kid)
{
        int rc = 0, err, iter = 0;

        if (!(kid->k_cmd.c_flags & C_CREATE_EVERY))
                rc = obj_create(kid);

        for (iter = 0; iter < kid->k_cmd.c_rpt; iter++) {
                if (rc || sig_received)
                        break;

                if (kid->k_cmd.c_flags & C_CREATE_EVERY) {
                        rc = obj_create(kid);
                        if (rc)
                                break;
                }

                if (kid->k_cmd.c_flags & C_WRITE) {
                        rc = obj_write(kid);
                        grant_estimate(kid->k_id);
                }

                if (kid->k_cmd.c_flags & C_CREATE_EVERY) {
                        err = obj_delete(kid);
                        if (!rc) rc = err;
                }

                if ((o_verbose > 3) && (iter % 10 == 0))
                        printf("%d: i%d\n", kid->k_id, iter);
                if (!rc)
                        sleep(kid->k_cmd.c_delay);
        }

        if (!(kid->k_cmd.c_flags & C_CREATE_EVERY)) {
                err = obj_delete(kid);
                if (!rc) rc = err;
        }

        if (o_verbose > 2)
                printf("%d: done (%d)\n", kid->k_id, rc);

        return rc;
}

static void report_perf()
{
        struct timeval end;
        double diff;

        gettimeofday(&end, NULL);
        diff = difftime(&end, &trigger_start);
        if (o_verbose > 2) {
                pthread_mutex_lock(&m_count);
                printf("wrote %lluMB in %.3fs (%.3f MB/s)\n",
                       write_bytes >> 20, diff,
                       (write_bytes >> 20) / diff);
                pthread_mutex_unlock(&m_count);
        }
}

static void *run_one_child(void *threadvp)
{
        struct kid_t *kid;
        char oname[10], ename[10];
        int thread = (long)threadvp, dev;
        int rc = 0, err;

        if (o_verbose > 2)
                printf("%s: running thread #%d\n", cmdname, thread);

        sprintf(oname, "o%.5d", thread);
        sprintf(ename, "e%.5d", thread);
        rc = echocli_setup(oname, ename, &dev);
        if (rc) {
                fprintf(stderr, "%s: can't setup '%s/%s' (%d)\n",
                        cmdname, oname, ename, rc);
                pthread_exit((void *)(long)rc);
        }

        kid = push_kid(thread);
        if (!kid) {
                rc = -ENOMEM;
                goto out;
        }
        kid->k_dev = dev;

        while(!(rc || sig_received)) {
                pthread_mutex_lock(&m_trigger);
                waiting_count++;
                if ((waiting_count == live_threads) && timer_on) {
                        report_perf();
                        timer_on = 0;
                        all_done = 1;
                }
                pthread_cond_wait(&cv_trigger, &m_trigger);
                waiting_count--;
                all_done = 0;

                /* First trigger_count threads will do the work, the rest
                   will block again */
                if (trigger_count) {
                        if (o_verbose > 4)
                                printf("%d: trigger %d cmd %x\n",
                                       kid->k_id, trigger_count,