#include "postgres_fe.h"
#include <sys/stat.h>
#include <sys/time.h>
#include <unistd.h>
#include <signal.h>
#include "getopt_long.h"
#include "access/xlogdefs.h"

Include dependency graph for pg_test_fsync.c:

Defines
#define	FSYNC_FILENAME "./pg_test_fsync.out"
#define	XLOG_BLCKSZ_K (XLOG_BLCKSZ / 1024)
#define	LABEL_FORMAT " %-32s"
#define	NA_FORMAT "%18s"
#define	OPS_FORMAT "%9.3f ops/sec %6.0f usecs/op"
#define	USECS_SEC 1000000
#define	START_TIMER
#define	STOP_TIMER
Functions
static void	handle_args (int argc, char *argv[])
static void	prepare_buf (void)
static void	test_open (void)
static void	test_non_sync (void)
static void	test_sync (int writes_per_op)
static void	test_open_syncs (void)
static void	test_open_sync (const char *msg, int writes_size)
static void	test_file_descriptor_sync (void)
static void	process_alarm (int sig)
static void	signal_cleanup (int sig)
static void	print_elapse (struct timeval start_t, struct timeval stop_t, int ops)
static void	die (const char *str)
int	main (int argc, char *argv[])
Variables
static const char *	progname
static int	secs_per_test = 5
static int	needs_unlink = 0
static char	full_buf [XLOG_SEG_SIZE]
static char *	buf
static char *	filename = FSYNC_FILENAME
static struct timeval start_t	stop_t
static bool	alarm_triggered = false

Define Documentation

#define FSYNC_FILENAME "./pg_test_fsync.out"

Definition at line 22 of file pg_test_fsync.c.

#define LABEL_FORMAT " %-32s"

Definition at line 26 of file pg_test_fsync.c.

Referenced by test_file_descriptor_sync(), test_non_sync(), test_open_sync(), and test_sync().

#define NA_FORMAT "%18s"

Definition at line 27 of file pg_test_fsync.c.

Referenced by test_open_sync(), and test_sync().

#define OPS_FORMAT "%9.3f ops/sec %6.0f usecs/op"

Definition at line 28 of file pg_test_fsync.c.

Referenced by print_elapse().

#define START_TIMER

Value:

do { \
    alarm_triggered = false; \
    alarm(secs_per_test); \
    gettimeofday(&start_t, NULL); \
} while (0)

Definition at line 33 of file pg_test_fsync.c.

#define STOP_TIMER

Value:

do { \
    gettimeofday(&stop_t, NULL); \
    print_elapse(start_t, stop_t, ops); \
} while (0)

Definition at line 54 of file pg_test_fsync.c.

#define USECS_SEC 1000000

Definition at line 29 of file pg_test_fsync.c.

Referenced by print_elapse().

#define XLOG_BLCKSZ_K (XLOG_BLCKSZ / 1024)

Definition at line 24 of file pg_test_fsync.c.

Referenced by test_non_sync(), and test_sync().

Function Documentation

static void die ( const char * str ) [static]

Definition at line 596 of file pg_test_fsync.c.

References strerror().

Referenced by AutoVacWorkerMain(), bootstrap_signals(), PostgresMain(), test_file_descriptor_sync(), test_non_sync(), test_open(), test_open_sync(), test_sync(), and WalSndSignals().

{
    fprintf(stderr, "%s: %s\n", str, strerror(errno));
    exit(1);
}

static void handle_args	(	int	argc,
		char *	argv[]
	)			`[static]`

Definition at line 136 of file pg_test_fsync.c.

References filename, getopt_long(), optarg, optind, progname, and secs_per_test.

Referenced by main().

{
    static struct option long_options[] = {
        {"filename", required_argument, NULL, 'f'},
        {"secs-per-test", required_argument, NULL, 's'},
        {NULL, 0, NULL, 0}
    };

    int         option;         /* Command line option */
    int         optindex = 0;   /* used by getopt_long */

    if (argc > 1)
    {
        if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0 ||
            strcmp(argv[1], "-?") == 0)
        {
            printf("Usage: %s [-f FILENAME] [-s SECS-PER-TEST]\n", progname);
            exit(0);
        }
        if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
        {
            puts("pg_test_fsync (PostgreSQL) " PG_VERSION);
            exit(0);
        }
    }

    while ((option = getopt_long(argc, argv, "f:s:",
                                 long_options, &optindex)) != -1)
    {
        switch (option)
        {
            case 'f':
                filename = strdup(optarg);
                break;

            case 's':
                secs_per_test = atoi(optarg);
                break;

            default:
                fprintf(stderr, "Try \"%s --help\" for more information.\n",
                        progname);
                exit(1);
                break;
        }
    }

    if (argc > optind)
    {
        fprintf(stderr,
                "%s: too many command-line arguments (first is \"%s\")\n",
                progname, argv[optind]);
        fprintf(stderr, "Try \"%s --help\" for more information.\n",
                progname);
        exit(1);
    }

    printf("%d seconds per test\n", secs_per_test);
#if PG_O_DIRECT != 0
    printf("O_DIRECT supported on this platform for open_datasync and open_sync.\n");
#else
    printf("Direct I/O is not supported on this platform.\n");
#endif
}

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 97 of file pg_test_fsync.c.

References filename, get_progname(), handle_args(), pqsignal(), prepare_buf(), process_alarm(), progname, SIGALRM, SIGHUP, signal_cleanup(), test_file_descriptor_sync(), test_non_sync(), test_open(), test_open_syncs(), test_sync(), and unlink().

{
    progname = get_progname(argv[0]);

    handle_args(argc, argv);

    /* Prevent leaving behind the test file */
    pqsignal(SIGINT, signal_cleanup);
    pqsignal(SIGTERM, signal_cleanup);
#ifndef WIN32
    pqsignal(SIGALRM, process_alarm);
#endif
#ifdef SIGHUP
    /* Not defined on win32 */
    pqsignal(SIGHUP, signal_cleanup);
#endif

    prepare_buf();

    test_open();

    /* Test using 1 XLOG_BLCKSZ write */
    test_sync(1);

    /* Test using 2 XLOG_BLCKSZ writes */
    test_sync(2);

    test_open_syncs();

    test_file_descriptor_sync();

    test_non_sync();

    unlink(filename);

    return 0;
}

static void prepare_buf ( void ) [static]

Definition at line 202 of file pg_test_fsync.c.

References ALIGNOF_XLOG_BUFFER, buf, full_buf, random(), and TYPEALIGN.

Referenced by main().

{
    int         ops;

    /* write random data into buffer */
    for (ops = 0; ops < XLOG_SEG_SIZE; ops++)
        full_buf[ops] = random();

    buf = (char *) TYPEALIGN(ALIGNOF_XLOG_BUFFER, full_buf);
}

static void print_elapse	(	struct timeval	start_t,
		struct timeval	stop_t,
		int	ops
	)			`[static]`

Definition at line 568 of file pg_test_fsync.c.

References OPS_FORMAT, and USECS_SEC.

{
    double      total_time = (stop_t.tv_sec - start_t.tv_sec) +
    (stop_t.tv_usec - start_t.tv_usec) * 0.000001;
    double      per_second = ops / total_time;
    double      avg_op_time_us = (total_time / ops) * USECS_SEC;

    printf(OPS_FORMAT "\n", per_second, avg_op_time_us);
}

static void process_alarm ( int sig ) [static]

Definition at line 580 of file pg_test_fsync.c.

References alarm_triggered.

Referenced by main().

{
    alarm_triggered = true;
}

static void signal_cleanup ( int sig ) [static]

Definition at line 538 of file pg_test_fsync.c.

References filename, needs_unlink, and unlink().

Referenced by main().

{
    /* Delete the file if it exists. Ignore errors */
    if (needs_unlink)
        unlink(filename);
    /* Finish incomplete line on stdout */
    puts("");
    exit(signum);
}

static void test_file_descriptor_sync ( void ) [static]

Definition at line 444 of file pg_test_fsync.c.

References alarm_triggered, buf, close, die(), filename, fsync, LABEL_FORMAT, and write.

Referenced by main().

{
    int         tmpfile,
                ops;

    /*
     * Test whether fsync can sync data written on a different descriptor for
     * the same file.  This checks the efficiency of multi-process fsyncs
     * against the same file. Possibly this should be done with writethrough
     * on platforms which support it.
     */
    printf("\nTest if fsync on non-write file descriptor is honored:\n");
    printf("(If the times are similar, fsync() can sync data written\n");
    printf("on a different descriptor.)\n");

    /*
     * first write, fsync and close, which is the normal behavior without
     * multiple descriptors
     */
    printf(LABEL_FORMAT, "write, fsync, close");
    fflush(stdout);

    START_TIMER;
    for (ops = 0; alarm_triggered == false; ops++)
    {
        if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
            die("could not open output file");
        if (write(tmpfile, buf, XLOG_BLCKSZ) != XLOG_BLCKSZ)
            die("write failed");
        if (fsync(tmpfile) != 0)
            die("fsync failed");
        close(tmpfile);

        /*
         * open and close the file again to be consistent with the following
         * test
         */
        if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
            die("could not open output file");
        close(tmpfile);
    }
    STOP_TIMER;

    /*
     * Now open, write, close, open again and fsync This simulates processes
     * fsyncing each other's writes.
     */
    printf(LABEL_FORMAT, "write, close, fsync");
    fflush(stdout);

    START_TIMER;
    for (ops = 0; alarm_triggered == false; ops++)
    {
        if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
            die("could not open output file");
        if (write(tmpfile, buf, XLOG_BLCKSZ) != XLOG_BLCKSZ)
            die("write failed");
        close(tmpfile);
        /* reopen file */
        if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
            die("could not open output file");
        if (fsync(tmpfile) != 0)
            die("fsync failed");
        close(tmpfile);
    }
    STOP_TIMER;
}

static void test_non_sync ( void ) [static]

Definition at line 513 of file pg_test_fsync.c.

References alarm_triggered, buf, close, die(), filename, LABEL_FORMAT, write, and XLOG_BLCKSZ_K.

Referenced by main().

{
    int         tmpfile,
                ops;

    /*
     * Test a simple write without fsync
     */
    printf("\nNon-Sync'ed %dkB writes:\n", XLOG_BLCKSZ_K);
    printf(LABEL_FORMAT, "write");
    fflush(stdout);

    START_TIMER;
    for (ops = 0; alarm_triggered == false; ops++)
    {
        if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
            die("could not open output file");
        if (write(tmpfile, buf, XLOG_BLCKSZ) != XLOG_BLCKSZ)
            die("write failed");
        close(tmpfile);
    }
    STOP_TIMER;
}

static void test_open ( void ) [static]

Definition at line 214 of file pg_test_fsync.c.

References close, die(), filename, fsync, full_buf, needs_unlink, and write.

Referenced by main().

{
    int         tmpfile;

    /*
     * test if we can open the target file
     */
    if ((tmpfile = open(filename, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR)) == -1)
        die("could not open output file");
    needs_unlink = 1;
    if (write(tmpfile, full_buf, XLOG_SEG_SIZE) != XLOG_SEG_SIZE)
        die("write failed");

    /* fsync now so that dirty buffers don't skew later tests */
    if (fsync(tmpfile) != 0)
        die("fsync failed");

    close(tmpfile);
}

static void test_open_sync	(	const char *	msg,
		int	writes_size
	)			`[static]`

Definition at line 409 of file pg_test_fsync.c.

References alarm_triggered, buf, close, die(), filename, LABEL_FORMAT, NA_FORMAT, PG_O_DIRECT, and write.

Referenced by test_open_syncs().

{
#ifdef OPEN_SYNC_FLAG
    int         tmpfile,
                ops,
                writes;
#endif

    printf(LABEL_FORMAT, msg);
    fflush(stdout);

#ifdef OPEN_SYNC_FLAG
    if ((tmpfile = open(filename, O_RDWR | OPEN_SYNC_FLAG | PG_O_DIRECT, 0)) == -1)
        printf(NA_FORMAT, "n/a*\n");
    else
    {
        START_TIMER;
        for (ops = 0; alarm_triggered == false; ops++)
        {
            for (writes = 0; writes < 16 / writes_size; writes++)
                if (write(tmpfile, buf, writes_size * 1024) !=
                    writes_size * 1024)
                    die("write failed");
            if (lseek(tmpfile, 0, SEEK_SET) == -1)
                die("seek failed");
        }
        STOP_TIMER;
        close(tmpfile);
    }
#else
    printf(NA_FORMAT, "n/a\n");
#endif
}

static void test_open_syncs ( void ) [static]

Definition at line 392 of file pg_test_fsync.c.

References test_open_sync().

Referenced by main().

{
    printf("\nCompare open_sync with different write sizes:\n");
    printf("(This is designed to compare the cost of writing 16kB\n");
    printf("in different write open_sync sizes.)\n");

    test_open_sync(" 1 * 16kB open_sync write", 16);
    test_open_sync(" 2 *  8kB open_sync writes", 8);
    test_open_sync(" 4 *  4kB open_sync writes", 4);
    test_open_sync(" 8 *  2kB open_sync writes", 2);
    test_open_sync("16 *  1kB open_sync writes", 1);
}

static void test_sync ( int writes_per_op ) [static]

Definition at line 235 of file pg_test_fsync.c.

References alarm_triggered, buf, close, die(), filename, fsync, LABEL_FORMAT, NA_FORMAT, O_DSYNC, pg_fsync_writethrough(), PG_O_DIRECT, write, and XLOG_BLCKSZ_K.

Referenced by main().

{
    int         tmpfile,
                ops,
                writes;
    bool        fs_warning = false;

    if (writes_per_op == 1)
        printf("\nCompare file sync methods using one %dkB write:\n", XLOG_BLCKSZ_K);
    else
        printf("\nCompare file sync methods using two %dkB writes:\n", XLOG_BLCKSZ_K);
    printf("(in wal_sync_method preference order, except fdatasync\n");
    printf("is Linux's default)\n");

    /*
     * Test open_datasync if available
     */
    printf(LABEL_FORMAT, "open_datasync");
    fflush(stdout);

#ifdef OPEN_DATASYNC_FLAG
    if ((tmpfile = open(filename, O_RDWR | O_DSYNC | PG_O_DIRECT, 0)) == -1)
    {
        printf(NA_FORMAT, "n/a*\n");
        fs_warning = true;
    }
    else
    {
        if ((tmpfile = open(filename, O_RDWR | O_DSYNC | PG_O_DIRECT, 0)) == -1)
            die("could not open output file");
        START_TIMER;
        for (ops = 0; alarm_triggered == false; ops++)
        {
            for (writes = 0; writes < writes_per_op; writes++)
                if (write(tmpfile, buf, XLOG_BLCKSZ) != XLOG_BLCKSZ)
                    die("write failed");
            if (lseek(tmpfile, 0, SEEK_SET) == -1)
                die("seek failed");
        }
        STOP_TIMER;
        close(tmpfile);
    }
#else
    printf(NA_FORMAT, "n/a\n");
#endif

/*
 * Test fdatasync if available
 */
    printf(LABEL_FORMAT, "fdatasync");
    fflush(stdout);

#ifdef HAVE_FDATASYNC
    if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
        die("could not open output file");
    START_TIMER;
    for (ops = 0; alarm_triggered == false; ops++)
    {
        for (writes = 0; writes < writes_per_op; writes++)
            if (write(tmpfile, buf, XLOG_BLCKSZ) != XLOG_BLCKSZ)
                die("write failed");
        fdatasync(tmpfile);
        if (lseek(tmpfile, 0, SEEK_SET) == -1)
            die("seek failed");
    }
    STOP_TIMER;
    close(tmpfile);
#else
    printf(NA_FORMAT, "n/a\n");
#endif

/*
 * Test fsync
 */
    printf(LABEL_FORMAT, "fsync");
    fflush(stdout);

    if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
        die("could not open output file");
    START_TIMER;
    for (ops = 0; alarm_triggered == false; ops++)
    {
        for (writes = 0; writes < writes_per_op; writes++)
            if (write(tmpfile, buf, XLOG_BLCKSZ) != XLOG_BLCKSZ)
                die("write failed");
        if (fsync(tmpfile) != 0)
            die("fsync failed");
        if (lseek(tmpfile, 0, SEEK_SET) == -1)
            die("seek failed");
    }
    STOP_TIMER;
    close(tmpfile);

/*
 * If fsync_writethrough is available, test as well
 */
    printf(LABEL_FORMAT, "fsync_writethrough");
    fflush(stdout);

#ifdef HAVE_FSYNC_WRITETHROUGH
    if ((tmpfile = open(filename, O_RDWR, 0)) == -1)
        die("could not open output file");
    START_TIMER;
    for (ops = 0; alarm_triggered == false; ops++)
    {
        for (writes = 0; writes < writes_per_op; writes++)
            if (write(tmpfile, buf, XLOG_BLCKSZ) != XLOG_BLCKSZ)
                die("write failed");
        if (pg_fsync_writethrough(tmpfile) != 0)
            die("fsync failed");
        if (lseek(tmpfile, 0, SEEK_SET) == -1)
            die("seek failed");
    }
    STOP_TIMER;
    close(tmpfile);
#else
    printf(NA_FORMAT, "n/a\n");
#endif

/*
 * Test open_sync if available
 */
    printf(LABEL_FORMAT, "open_sync");
    fflush(stdout);

#ifdef OPEN_SYNC_FLAG
    if ((tmpfile = open(filename, O_RDWR | OPEN_SYNC_FLAG | PG_O_DIRECT, 0)) == -1)
    {
        printf(NA_FORMAT, "n/a*\n");
        fs_warning = true;
    }
    else
    {
        START_TIMER;
        for (ops = 0; alarm_triggered == false; ops++)
        {
            for (writes = 0; writes < writes_per_op; writes++)
                if (write(tmpfile, buf, XLOG_BLCKSZ) != XLOG_BLCKSZ)
                    die("write failed");
            if (lseek(tmpfile, 0, SEEK_SET) == -1)
                die("seek failed");
        }
        STOP_TIMER;
        close(tmpfile);
    }
#else
    printf(NA_FORMAT, "n/a\n");
#endif

    if (fs_warning)
    {
        printf("* This file system and its mount options do not support direct\n");
        printf("I/O, e.g. ext4 in journaled mode.\n");
    }
}