test_file_helper.c   [plain text]

#include "test_file_helper.h"
#include "fail.h"
#include <stdlib.h>
#include <fcntl.h>
#include <sys/param.h>
#include <assert.h>
#include <stdio.h>
#include <strings.h>
#include <unistd.h>
#include <pthread.h>

static char readbuff[4096];
static char writebuff[4096];
static int* fds = NULL;

char* setup_tempdir(char* buf) {
    strcpy(buf, "/tmp/perfindex.XXXXXX");
    return mkdtemp(buf);
}

int cleanup_tempdir(char* path) {
    return rmdir(path);
}

int test_file_create(char* path, int thread_id, int num_threads, long long length) {
  long long i;
  int fd;
  int retval;
  char filepath[MAXPATHLEN];

  for(i=0; i<length; i++) {
    snprintf(filepath, MAXPATHLEN, "%s/file_create-%d-%lld", path, thread_id, i);
    fd = open(filepath, O_CREAT | O_EXCL | O_WRONLY, 0644);
    VERIFY(fd >= 0, "open failed");

    close(fd);
  }

  for(i=0; i<length; i++) {
    snprintf(filepath, MAXPATHLEN, "%s/file_create-%d-%lld", path, thread_id, i);
    retval = unlink(filepath);
    VERIFY(retval == 0, "unlink failed");
  }

  return PERFINDEX_SUCCESS;
}

int test_file_read_setup(char* path, int num_threads, long long length, long long max_file_size) {
    int fd;
    char filepath[MAXPATHLEN];
    long long left;
    int retval;
    size_t writelen;

    if(max_file_size == 0)
        max_file_size = MAXFILESIZE;

    left = MIN(length, max_file_size/num_threads);

    snprintf(filepath, sizeof(filepath), "%s/file_read", path);
    fd = open(filepath, O_CREAT | O_EXCL | O_WRONLY, 0644);
    printf("%d\n", fd);
    VERIFY(fd >= 0, "open failed");

    bzero(readbuff, sizeof(readbuff));

    while(left > 0) {
        writelen = sizeof(readbuff) < left ? sizeof(readbuff) : left;
        retval = write(fd, readbuff, writelen);
        VERIFY(retval == writelen, "write failed");
        left -= writelen;
    }

    return PERFINDEX_SUCCESS;
}

int test_file_read(char* path, int thread_id, int num_threads, long long length, long long max_file_size) {
    long long left;
    size_t file_offset = 0;
    int readlen;
    int fd;
    int retval;
    char filepath[MAXPATHLEN];
    long long filesize;


    if(max_file_size == 0)
        max_file_size = MAXFILESIZE;
    filesize =  MIN(length, max_file_size/num_threads);

    snprintf(filepath, sizeof(filepath), "%s/file_read", path);
    fd = open(filepath, O_RDONLY);
    VERIFY(fd >= 0, "open failed");

    for(left=length; left>0;) {
        readlen = sizeof(readbuff) < left ? sizeof(readbuff) : left;
        if(file_offset+readlen > filesize) {
            retval = lseek(fd, 0, SEEK_SET);


            VERIFY(retval >= 0, "lseek failed");

            file_offset = 0;
            continue;
        }
        retval = read(fd, readbuff, readlen);
        VERIFY(retval == readlen, "read failed");
        left -= readlen;
        file_offset += readlen;
    }
    return PERFINDEX_SUCCESS;
}

int test_file_read_cleanup(char* path, int num_threads, long long length) {
    char filepath[MAXPATHLEN];
    int retval;

    snprintf(filepath, sizeof(filepath), "%s/file_read", path);
    retval = unlink(filepath);
    VERIFY(retval == 0, "unlink failed");

    return PERFINDEX_SUCCESS;
}

int test_file_write_setup(char* path, int num_threads, long long length) {
    int i;
    char filepath[MAXPATHLEN];

    if(fds == NULL) {
        fds = (int*)malloc(sizeof(int)*num_threads);
        VERIFY(fds, "malloc failed");
    }

    for(i=0; i<num_threads; i++) {
        snprintf(filepath, sizeof(filepath), "%s/file_write-%d", path, i);
        fds[i] = open(filepath, O_CREAT | O_EXCL | O_WRONLY, 0644);
        if(fds[i] < 0) {
            free(fds);
            fds = NULL;
            FAIL("open failed");
        }
    }

    bzero(writebuff, sizeof(writebuff));

    return PERFINDEX_SUCCESS;
}

int test_file_write(char* path, int thread_id, int num_threads, long long length, long long max_file_size) {
    long long left;
    size_t file_offset = 0;
    int writelen;
    int retval;
    int fd = fds[thread_id];

    if(max_file_size == 0)
        max_file_size = MAXFILESIZE;

    for(left=length; left>0;) {
        writelen = sizeof(writebuff) < left ? sizeof(writebuff) : left;
        retval = write(fd, writebuff, writelen);
        VERIFY(retval == writelen, "write failed");

        left -= writelen;
        file_offset += writelen;
        if(file_offset>max_file_size/num_threads) {
            retval = lseek(fd, 0, SEEK_SET);
            VERIFY(retval >= 0, "leeks failed");
            file_offset = 0;
        }
    }

    return PERFINDEX_SUCCESS;
}


int test_file_write_cleanup(char* path, int num_threads, long long length) {
    int i;
    char filepath[MAXPATHLEN];
    int retval;

    for(i=0; i<num_threads; i++) {
        snprintf(filepath, sizeof(filepath), "%s/file_write-%d", path, i);
        retval = unlink(filepath);
        VERIFY(retval == 0, "unlink failed");
    }

    return PERFINDEX_SUCCESS;
}