Attachment 584900 Details for Bug 822067 – multi threaded program running on one of the fuse clients

multi threaded program running on one of the fuse clients

thread_fops.c (text/x-csrc), 20.73 KB, created by Raghavendra Bhat on 2012-05-16 09:00:43 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Raghavendra Bhat

Created: 2012-05-16 09:00:43 UTC

Size: 20.73 KB

patch

obsolete

>
>#include "thread_fops.h"
>
>static error_t
>thread_parse_opts (int key, char *arg,
>                   struct argp_state *_state);
>static void
>thread_default_config (void);
>
>static thread_config_t thread_config;
>
>static struct argp_option thread_options[] = {
>        { "dir", 'd', "DIRECTORY", 0, "absolute or relative path of the tests"},
>        { "time", 't', "TIME", 0, "time duration for which test should run"
>          " (defaults to 600 seconds)"},
>        {0, 0, 0, 0, 0}
>};
>
>static error_t
>thread_parse_opts (int key, char *arg,
>            struct argp_state *_state)
>{
>        switch (key) {
>        case 'd':
>        {
>                int len = 0;
>                int pathlen = 0;
>                int ret = -1;
>                int old_errno = 0;
>                struct stat stbuf = {0,};
>
>                len = strlen (arg) + strlen ("playground");
>                if (len > UNIX_PATH_MAX) {
>                        fprintf (stderr, "pathname is too long (%s)\n",
>                                 arg);
>                        return -1;
>                }
>
>                strcpy (thread_config.directory, arg);
>                pathlen = strlen (thread_config.directory);
>                if (thread_config.directory[pathlen - 1] != '/')
>                        thread_config.directory[pathlen] = '/';
>                thread_config.directory[pathlen+1] = '\0';
>
>                old_errno = errno;
>                errno = 0;
>                ret = stat (thread_config.directory, &stbuf);
>                if ((ret == -1) || !S_ISDIR (stbuf.st_mode)) {
>                        if (errno == ENOENT) {
>                                fprintf (stderr, "the directory %s does not "
>                                         "exist\n", thread_config.directory);
>                                return -1;
>                        } else {
>                                fprintf (stderr, "given path %s is not a "
>                                         "directory\n",
>                                         thread_config.directory);
>                                return -1;
>                        }
>                }
>                strcat (thread_config.directory, "playground");
>                errno = old_errno;
>        }
>        break;
>
>        case 't':
>        {
>                long long  time = 0;
>                char       *tail = NULL;
>
>                errno = 0;
>                time = strtoll (arg, &tail, 10);
>                if (errno == ERANGE || errno == EINVAL) {
>                        fprintf (stderr, "invalid time (%s)\n", arg);
>                        return -1;
>                }
>
>                if (tail[0] != '\0') {
>                        fprintf (stderr, "invalid time (%s)\n", arg);
>                        return -1;
>                }
>
>                if (time < 0) {
>                        fprintf (stderr, "time (%s) cannot be -ve\n", arg);
>                        return -1;
>                }
>
>                thread_config.time = time;
>        }
>        break;
>
>        case ARGP_KEY_NO_ARGS:
>                break;
>        case ARGP_KEY_ARG:
>                break;
>        case ARGP_KEY_END:
>                if (_state->argc == 1) {
>                        //argp_usage (_state);
>                        thread_default_config ();
>                }
>
>        }
>
>        return 0;
>}
>
>static struct argp argp = {
>        thread_options,
>        thread_parse_opts,
>        "",
>        "threaded-io - tool which spawns multiple threads, with each thread "
>        "opening the same file and doing different fops on their respective "
>        "fds"
>};
>
>static void
>thread_default_config (void)
>{
>        int ret = -1;
>        char playground[UNIX_PATH_MAX] = {0,};
>        struct stat stbuf = {0,};
>
>        getcwd (playground, sizeof (playground));
>
>        ret = stat (playground, &stbuf);
>        if (ret == -1) {
>                fprintf (stderr, "Error: %s: The playground directory %s "
>                         "seems to have an error (%s)", __FUNCTION__,
>                         playground, strerror (errno));
>                return;
>        }
>
>        strcat (playground, "/playground");
>        strcpy (thread_config.directory, playground);
>
>        thread_config.time = 600;
>}
>
>int
>main(int argc, char *argv[])
>{
>        int ret = -1;
>        pthread_t thread[10];
>        char *message [] = {"Thread0", "Thread1", "Thread2", "Thread3",
>                            "Thread4", "Thread5", "Thread6", "Thread7",
>                            "Thread8", "Thread9",};
>        char playground[1024] = {0,};
>        struct stat stbuf = {0,};
>        int  iter[10];
>        int  i = 0;
>
>        typedef void *(*thread_pointer)(void *);
>        thread_pointer pointers_thread [] = {open_thread, fstat_thread,
>                                             read_thread,
>                                             write_truncate_thread,
>                                             chown_thread,
>                                             write_truncate_thread,
>                                             open_lock_close,
>                                             opendir_and_readdir,
>                                             opendir_and_readdir,
>        };
>
>        thread_default_config ();
>
>        ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
>        if (ret != 0) {
>                ret = -1;
>                fprintf (stderr, "%s: argp_parse() failed\n", argv[0]);
>                goto err;
>        }
>
>        open_t *file = NULL;
>        file = (open_t *)calloc(1,sizeof(*file));
>        if (!file) {
>                fprintf (stderr, "%s:out of memory\n",
>                         strerror(errno));
>                goto out;
>        }
>
>        file->filename = "thread_file";
>        //file->dirname = "test_dir";
>        file->flags = O_CREAT | O_RDWR;
>        file->mode = 0755;
>
>        fstat_t *inode = NULL;
>        inode = (fstat_t *)calloc(1,sizeof(*inode));
>        if (!inode) {
>                fprintf (stderr, "%s:out of memory\n",
>                         strerror(errno));
>                goto out;
>        }
>
>        inode->buf = NULL;
>        inode->buf = (struct stat *)calloc(1,sizeof(struct stat));
>        if (!inode->buf) {
>                fprintf (stderr, "%s:Out of memory\n",
>                         strerror(errno));
>                goto out;
>        }
>
>        int fd_main = -1;
>
>        oft *both = NULL;
>        both = (oft *)calloc(1,sizeof(*both));
>        if (!both) {
>                fprintf (stderr, "%s:out of memory\n",
>                         strerror(errno));
>                goto out;
>        }
>
>        strcpy (playground, thread_config.directory);
>
>        ret = mkdir (playground, 0755);
>        if (ret == -1 && (errno != EEXIST) ) {
>                fprintf (stderr, "Error: Error creating the playground ",
>                         ": %s (%s)", playground, __FUNCTION__,
>                         strerror (errno));
>                goto out;
>        }
>
>        printf ("Switching over to the working directory %s time %llu\n",
>                playground, thread_config.time);
>        ret = chdir (playground);
>        if (ret == -1) {
>                fprintf (stderr, "Error changing directory to the playground %s",
>                         ". function (%s), %s", playground, __FUNCTION__,
>                         strerror (errno));
>                goto out;
>        }
>
>        mkdir ("test_dir", 0755);
>        pthread_mutex_init (&info.mutex, NULL);
>        /* Create independent threads each of which will execute function */
>
>        both->open = file;
>        both->fstat = inode;
>        for (i = 0; i <= 6; i++) {
>                iter[i] = pthread_create (&thread[i], NULL, pointers_thread[i],
>                                          (void *)both);
>        }
>
>        while (i < 9) {
>                iter[i] = pthread_create (&thread[i], NULL, pointers_thread[i],
>                                          NULL);
>                i++;
>        }
>
>        sleep (thread_config.time);
>
>        printf ("Total Statistics ======>\n");
>        printf ("Opens        : %llu/%llu\n", info.num_open_success,info.num_open);
>        printf ("Reads        : %llu/%llu\n", info.read_success, info.read);
>        printf ("Writes       : %llu/%llu\n", info.write_success, info.write);
>        printf ("Flocks       : %llu/%llu\n", info.flocks_success, info.flocks);
>        printf ("fcntl locks  : %llu/%llu\n", info.fcntl_locks_success,
>                info.fcntl_locks);
>        printf ("Truncates    : %llu/%llu\n", info.truncate_success, info.truncate);
>        printf ("Fstat        : %llu/%llu\n", info.fstat_success, info.fstat);
>        printf ("Chown        : %llu/%llu\n", info.chown_success, info.chown);
>        printf ("Opendir      : %llu/%llu\n", info.opendir_success, info.opendir);
>        printf ("Readdir      : %llu/%llu\n", info.readdir_success, info.readdir);
>
>        ret = 0;
>out:
>        if (file) {
>                free (file);
>                file = NULL;
>        }
>        if (inode) {
>                if (inode->buf) {
>                        free (inode->buf);
>                        inode->buf = NULL;
>                }
>                free (inode);
>                inode = NULL;
>        }
>        if (both) {
>                both->open = NULL;
>                both->fstat = NULL;
>                free(both);
>                both = NULL;
>        }
>
>        pthread_mutex_destroy (&info.mutex);
>
>err:
>        return ret;
>}
>
>void *
>open_lock_close (void *tmp)
>{
>        oft *all = (oft *)tmp;
>        open_t *file = NULL;
>        file = all->open;
>        fstat_t *inode = NULL;
>        inode = all->fstat;
>        int ret = 0;
>        int fd = -1;
>        struct flock lock;
>        char *data = "This is a line";
>
>        while (1) {
>                fd = open (file->filename, file->flags, file->mode);
>                if (fd == -1) {
>                        return;
>                } else {
>                        pthread_mutex_lock (&info.mutex);
>                        {
>                                info.num_open++;
>                        }
>                        pthread_mutex_unlock (&info.mutex);
>                }
>
>                lock.l_type = F_RDLCK;
>                lock.l_whence = SEEK_SET;
>                lock.l_start = 0;
>                lock.l_len = 0;
>                lock.l_pid = 0;
>
>                pthread_mutex_lock (&info.mutex);
>                {
>                        info.fcntl_locks++;
>                }
>                pthread_mutex_unlock (&info.mutex);
>
>                ret = fcntl (fd, F_SETLK, &lock);
>                if (ret == 0) {
>                        pthread_mutex_lock (&info.mutex);
>                        {
>                                info.fcntl_locks_success++;
>                        }
>                        pthread_mutex_unlock (&info.mutex);
>                }
>
>                pthread_mutex_lock (&info.mutex);
>                {
>                        info.flocks++;
>                }
>                pthread_mutex_unlock (&info.mutex);
>
>                ret = flock (fd, LOCK_SH);
>                if (ret == 0) {
>                        pthread_mutex_lock (&info.mutex);
>                        {
>                                info.flocks_success++;
>                        }
>                        pthread_mutex_unlock (&info.mutex);
>                }
>
>                pthread_mutex_lock (&info.mutex);
>                {
>                        info.write++;
>                }
>                pthread_mutex_unlock (&info.mutex);
>
>                ret = write (fd, data, strlen (data));
>                if (ret == 0) {
>                        pthread_mutex_lock (&info.mutex);
>                        {
>                                info.write_success++;
>                        }
>                        pthread_mutex_unlock (&info.mutex);
>                }
>
>                lock.l_type = F_UNLCK;
>                ret = fcntl (fd, F_SETLK, &lock);
>
>                ret = flock (fd, LOCK_UN);
>
>                close (fd);
>        }
>
>        return NULL;
>}
>
>void *
>open_thread(void *tmp)
>{
>        oft *all = (oft *)tmp;
>        open_t *file = NULL;
>        file = all->open;
>        fstat_t *inode = NULL;
>        inode = all->fstat;
>        int ret = 0;
>        int fd = -1;
>
>        while (1) {
>                pthread_mutex_lock (&info.mutex);
>                {
>                        info.num_open++;
>                }
>                pthread_mutex_unlock (&info.mutex);
>
>                if (fd = open (file->filename, file->flags, file->mode) == -1) {
>                        ret = -1;
>                        goto out;
>                } else {
>                        pthread_mutex_lock (&info.mutex);
>                        {
>                                info.num_open_success++;
>                        }
>                        pthread_mutex_unlock (&info.mutex);
>                }
>
>                close (fd);
>        }
>out:
>        return NULL;
>}
>
>void *
>fstat_thread(void *ptr)
>{
>        oft *all = (oft *)ptr;
>        fstat_t *inode = NULL;
>        open_t *file = NULL;
>        int ret = 0;
>        int fd = -1;
>
>        file = all->open;
>        inode = all->fstat;
>
>        pthread_mutex_lock (&info.mutex);
>        {
>                info.num_open++;
>        }
>        pthread_mutex_unlock (&info.mutex);
>
>        fd = open (file->filename, file->flags, file->mode);
>        if (fd == -1) {
>                ret = -1;
>                goto out;
>        } else {
>                pthread_mutex_lock (&info.mutex);
>                {
>                        info.num_open_success++;
>                }
>                pthread_mutex_unlock (&info.mutex);
>        }
>
>        while (1) {
>                pthread_mutex_lock (&info.mutex);
>                {
>                        info.fstat++;
>                }
>                pthread_mutex_unlock (&info.mutex);
>
>                if (fstat(fd, inode->buf) == -1) {
>                        ret = -1;
>                        goto out;
>                } else {
>                        pthread_mutex_lock (&info.mutex);
>                        {
>                                info.fstat_success++;
>                        }
>                        pthread_mutex_unlock (&info.mutex);
>                }
>        }
>
>out:
>        close (fd);
>        return NULL;
>}
>
>void *
>read_thread (void *ptr)
>{
>        oft *all = NULL;
>        int fd = -1;
>        int ret = -1;
>        fstat_t *stat = NULL;
>        open_t *file = NULL;
>        char buffer[4096];
>
>        all = (oft *)ptr;
>        stat = all->fstat;
>        file = all->open;
>
>        open_validate_error_goto(file->filename, file->flags, file->mode);
>
>        while (1) {
>                pthread_mutex_lock (&info.mutex);
>                {
>                        info.read++;
>                }
>                pthread_mutex_unlock (&info.mutex);
>
>                ret = read (fd, buffer, 22);
>                if (ret == -1) {
>                        goto out;
>                }
>
>                if (ret == EOF) {
>                        lseek (fd, 0, SEEK_SET);
>                } else {
>                        pthread_mutex_lock (&info.mutex);
>                        {
>                                info.read_success++;
>                        }
>                        pthread_mutex_unlock (&info.mutex);
>                }
>        }
>
>        ret = 0;
>out:
>        close (fd);
>        return NULL;
>}
>
>void *
>write_truncate_thread (void *ptr)
>{
>        oft *all = NULL;
>        open_t *file = NULL;
>        fstat_t *stat = NULL;
>        int fd = -1;
>        int ret = -1;
>        char *buffer = "This is a multithreaded environment";
>        unsigned int data = 0;
>        int bytes_written = -1;
>
>        all = (oft *)ptr;
>        file = all->open;
>        stat = all->fstat;
>
>        pthread_mutex_lock (&info.mutex);
>        {
>                info.num_open++;
>        }
>        pthread_mutex_unlock (&info.mutex);
>
>        fd = open (file->filename, file->flags | O_APPEND, file->mode);
>        if (fd == -1) {
>                ret = -1;
>                goto out;
>        } else {
>                pthread_mutex_lock (&info.mutex);
>                {
>                        info.num_open_success++;
>                }
>                pthread_mutex_unlock (&info.mutex);
>        }
>
>        while (1) {
>                pthread_mutex_lock (&info.mutex);
>                {
>                        info.write++;
>                }
>                pthread_mutex_unlock (&info.mutex);
>
>                ret = write (fd, buffer, strlen (buffer));
>                bytes_written = ret;
>                if (ret == -1) {
>                        goto out;
>                }
>
>                if ((data + bytes_written) >= 4096) {
>                        pthread_mutex_lock (&info.mutex);
>                        {
>                                info.truncate++;
>                        }
>                        pthread_mutex_unlock (&info.mutex);
>                        ret = ftruncate (fd, 0);
>                        if (ret == -1) {
>                                goto out;
>                        } else {
>                                pthread_mutex_lock (&info.mutex);
>                                {
>                                        info.truncate_success++;
>                                }
>                                pthread_mutex_unlock (&info.mutex);
>                        }
>                        data = 0;
>                } else {
>                        data = data + bytes_written;
>                         pthread_mutex_lock (&info.mutex);
>                         {
>                                 info.write_success++;
>                         }
>                         pthread_mutex_unlock (&info.mutex);
>                }
>        }
>
>out:
>        close (fd);
>        return NULL;
>}
>
>void *
>chown_thread (void *ptr)
>{
>        oft *all = NULL;
>        fstat_t *stat = NULL;
>        open_t *file = NULL;
>        int ret = -1;
>        int fd = -1;
>        struct stat stat_buf;
>
>        all = (oft *)ptr;
>        stat = all->fstat;
>        file = all->open;
>
>        open_validate_error_goto(file->filename, file->flags, file->mode);
>
>        while (1) {
>                pthread_mutex_lock (&info.mutex);
>                {
>                        info.fstat++;
>                }
>                pthread_mutex_unlock (&info.mutex);
>
>                ret = fstat (fd, &stat_buf);
>                if (ret == -1) {
>                        goto out;
>                } else {
>                        pthread_mutex_lock (&info.mutex);
>                        {
>                                info.fstat_success++;
>                        }
>                        pthread_mutex_unlock (&info.mutex);
>                }
>
>                pthread_mutex_lock (&info.mutex);
>                {
>                        info.chown++;
>                }
>                pthread_mutex_unlock (&info.mutex);
>                if (stat_buf.st_uid == 1315 && stat_buf.st_gid == 1315)
>                        ret = fchown (fd, 2222, 2222);
>                else
>                        ret = fchown (fd, 1315, 1315);
>
>                if (ret == -1) {
>                        goto out;
>                } else {
>                        pthread_mutex_lock (&info.mutex);
>                        {
>                                info.chown_success++;
>                        }
>                        pthread_mutex_unlock (&info.mutex);
>                }
>        }
>
>        ret = 0;
>out:
>        close (fd);
>        return NULL;
>}
>
>void *
>opendir_and_readdir ()
>{
>        DIR    *dir = NULL;
>        char   dir_to_open[1024] = {0,};
>        int    old_errno = 0;
>        struct dirent *entry = NULL;
>
>        getcwd (dir_to_open, sizeof (dir_to_open));
>        while (1) {
>                pthread_mutex_lock (&info.mutex);
>                {
>                        info.opendir++;
>                }
>                pthread_mutex_unlock (&info.mutex);
>                dir = opendir (dir_to_open);
>                if (!dir) {
>                        break;
>                }  else {
>                        pthread_mutex_lock (&info.mutex);
>                        {
>                                info.opendir_success++;
>                        }
>                        pthread_mutex_unlock (&info.mutex);
>                }
>
>                old_errno = errno;
>                errno = 0;
>
>                do {
>                        pthread_mutex_lock (&info.mutex);
>                        {
>                                info.readdir++;
>                        }
>                        pthread_mutex_unlock (&info.mutex);
>                        entry = readdir (dir);
>                        if (entry) {
>                                entry->d_off = telldir (dir);
>                                pthread_mutex_lock (&info.mutex);
>                                {
>                                        info.readdir_success++;
>                                }
>                                pthread_mutex_unlock (&info.mutex);
>                        }
>                } while (entry);
>
>                if (errno != 0)
>
>                closedir (dir);
>                dir = NULL;
>        }
>
>        return NULL;
>}

Actions: View

Attachments on bug 822067: 584900 | 584902