darshan-pnetcdf-logutils.c 8.72 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
 * Copyright (C) 2015 University of Chicago.
 * See COPYRIGHT notice in top-level directory.
 *
 */

#define _GNU_SOURCE
#include "darshan-util-config.h"
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <unistd.h>
#include <inttypes.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

20
#include "darshan-logutils.h"
21 22 23 24 25 26 27 28 29 30 31 32

/* counter name strings for the PNETCDF module */
#define X(a) #a,
char *pnetcdf_counter_names[] = {
    PNETCDF_COUNTERS
};

char *pnetcdf_f_counter_names[] = {
    PNETCDF_F_COUNTERS
};
#undef X

33
static int darshan_log_get_pnetcdf_file(darshan_fd fd, void** pnetcdf_buf_p);
34
static int darshan_log_put_pnetcdf_file(darshan_fd fd, void* pnetcdf_buf);
35
static void darshan_log_print_pnetcdf_file(void *file_rec,
36
    char *file_name, char *mnt_pt, char *fs_type);
37
static void darshan_log_print_pnetcdf_description(int ver);
38 39
static void darshan_log_print_pnetcdf_file_diff(void *file_rec1, char *file_name1,
    void *file_rec2, char *file_name2);
40
static void darshan_log_agg_pnetcdf_files(void *rec, void *agg_rec, int init_flag);
41

42 43 44
struct darshan_mod_logutil_funcs pnetcdf_logutils =
{
    .log_get_record = &darshan_log_get_pnetcdf_file,
45
    .log_put_record = &darshan_log_put_pnetcdf_file,
46
    .log_print_record = &darshan_log_print_pnetcdf_file,
47
    .log_print_description = &darshan_log_print_pnetcdf_description,
48
    .log_print_diff = &darshan_log_print_pnetcdf_file_diff,
49
    .log_agg_records = &darshan_log_agg_pnetcdf_files
50 51
};

52
static int darshan_log_get_pnetcdf_file(darshan_fd fd, void** pnetcdf_buf_p)
53
{
54
    struct darshan_pnetcdf_file *file = *((struct darshan_pnetcdf_file **)pnetcdf_buf_p);
55
    int i;
56
    int ret;
57

58 59 60 61 62 63 64 65 66 67 68
    if(fd->mod_map[DARSHAN_PNETCDF_MOD].len == 0)
        return(0);

    if(*pnetcdf_buf_p == NULL)
    {
        file = malloc(sizeof(*file));
        if(!file)
            return(-1);
    }

    ret = darshan_log_get_mod(fd, DARSHAN_PNETCDF_MOD, file,
69
        sizeof(struct darshan_pnetcdf_file));
70 71 72 73 74 75 76 77 78

    if(*pnetcdf_buf_p == NULL)
    {
        if(ret == sizeof(struct darshan_pnetcdf_file))
            *pnetcdf_buf_p = file;
        else
            free(file);
    }

79
    if(ret < 0)
80
        return(-1);
81 82 83
    else if(ret < sizeof(struct darshan_pnetcdf_file))
        return(0);
    else
84
    {
85
        /* if the read was successful, do any necessary byte-swapping */
86 87
        if(fd->swap_flag)
        {
88 89
            DARSHAN_BSWAP64(&(file->base_rec.id));
            DARSHAN_BSWAP64(&(file->base_rec.rank));
90 91 92 93 94 95 96
            for(i=0; i<PNETCDF_NUM_INDICES; i++)
                DARSHAN_BSWAP64(&file->counters[i]);
            for(i=0; i<PNETCDF_F_NUM_INDICES; i++)
                DARSHAN_BSWAP64(&file->fcounters[i]);
        }

        return(1);
97
    }
98
}
99

100
static int darshan_log_put_pnetcdf_file(darshan_fd fd, void* pnetcdf_buf)
101 102 103 104
{
    struct darshan_pnetcdf_file *file = (struct darshan_pnetcdf_file *)pnetcdf_buf;
    int ret;

105
    ret = darshan_log_put_mod(fd, DARSHAN_PNETCDF_MOD, file,
106
        sizeof(struct darshan_pnetcdf_file), DARSHAN_PNETCDF_VER);
107 108
    if(ret < 0)
        return(-1);
109 110

    return(0);
111 112
}

113
static void darshan_log_print_pnetcdf_file(void *file_rec, char *file_name,
114
    char *mnt_pt, char *fs_type)
115 116 117 118 119 120 121 122
{
    int i;
    struct darshan_pnetcdf_file *pnetcdf_file_rec =
        (struct darshan_pnetcdf_file *)file_rec;

    for(i=0; i<PNETCDF_NUM_INDICES; i++)
    {
        DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_PNETCDF_MOD],
123 124 125
            pnetcdf_file_rec->base_rec.rank, pnetcdf_file_rec->base_rec.id,
            pnetcdf_counter_names[i], pnetcdf_file_rec->counters[i],
            file_name, mnt_pt, fs_type);
126 127 128 129 130
    }

    for(i=0; i<PNETCDF_F_NUM_INDICES; i++)
    {
        DARSHAN_F_COUNTER_PRINT(darshan_module_names[DARSHAN_PNETCDF_MOD],
131 132 133
            pnetcdf_file_rec->base_rec.rank, pnetcdf_file_rec->base_rec.id,
            pnetcdf_f_counter_names[i], pnetcdf_file_rec->fcounters[i],
            file_name, mnt_pt, fs_type);
134 135 136 137 138
    }

    return;
}

139
static void darshan_log_print_pnetcdf_description(int ver)
140
{
141
    printf("\n# description of PNETCDF counters:\n");
142 143 144 145 146 147 148 149
    printf("#   PNETCDF_INDEP_OPENS: PNETCDF independent file open operation counts.\n");
    printf("#   PNETCDF_COLL_OPENS: PNETCDF collective file open operation counts.\n");
    printf("#   PNETCDF_F_OPEN_TIMESTAMP: timestamp of first PNETCDF file open.\n");
    printf("#   PNETCDF_F_CLOSE_TIMESTAMP: timestamp of last PNETCDF file close.\n");

    return;
}

150 151
static void darshan_log_print_pnetcdf_file_diff(void *file_rec1, char *file_name1,
    void *file_rec2, char *file_name2)
152
{
153 154 155 156 157
    struct darshan_pnetcdf_file *file1 = (struct darshan_pnetcdf_file *)file_rec1;
    struct darshan_pnetcdf_file *file2 = (struct darshan_pnetcdf_file *)file_rec2;
    int i;

    /* NOTE: we assume that both input records are the same module format version */
158

159 160 161 162 163 164
    for(i=0; i<PNETCDF_NUM_INDICES; i++)
    {
        if(!file2)
        {
            printf("- ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_PNETCDF_MOD],
165
                file1->base_rec.rank, file1->base_rec.id, pnetcdf_counter_names[i],
166 167 168 169 170 171 172
                file1->counters[i], file_name1, "", "");

        }
        else if(!file1)
        {
            printf("+ ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_PNETCDF_MOD],
173
                file2->base_rec.rank, file2->base_rec.id, pnetcdf_counter_names[i],
174 175 176 177 178 179
                file2->counters[i], file_name2, "", "");
        }
        else if(file1->counters[i] != file2->counters[i])
        {
            printf("- ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_PNETCDF_MOD],
180
                file1->base_rec.rank, file1->base_rec.id, pnetcdf_counter_names[i],
181 182 183
                file1->counters[i], file_name1, "", "");
            printf("+ ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_PNETCDF_MOD],
184
                file2->base_rec.rank, file2->base_rec.id, pnetcdf_counter_names[i],
185 186 187 188 189 190 191 192 193 194
                file2->counters[i], file_name2, "", "");
        }
    }

    for(i=0; i<PNETCDF_F_NUM_INDICES; i++)
    {
        if(!file2)
        {
            printf("- ");
            DARSHAN_F_COUNTER_PRINT(darshan_module_names[DARSHAN_PNETCDF_MOD],
195
                file1->base_rec.rank, file1->base_rec.id, pnetcdf_f_counter_names[i],
196 197 198 199 200 201 202
                file1->fcounters[i], file_name1, "", "");

        }
        else if(!file1)
        {
            printf("+ ");
            DARSHAN_F_COUNTER_PRINT(darshan_module_names[DARSHAN_PNETCDF_MOD],
203
                file2->base_rec.rank, file2->base_rec.id, pnetcdf_f_counter_names[i],
204 205 206 207 208 209
                file2->fcounters[i], file_name2, "", "");
        }
        else if(file1->fcounters[i] != file2->fcounters[i])
        {
            printf("- ");
            DARSHAN_F_COUNTER_PRINT(darshan_module_names[DARSHAN_PNETCDF_MOD],
210
                file1->base_rec.rank, file1->base_rec.id, pnetcdf_f_counter_names[i],
211 212 213
                file1->fcounters[i], file_name1, "", "");
            printf("+ ");
            DARSHAN_F_COUNTER_PRINT(darshan_module_names[DARSHAN_PNETCDF_MOD],
214
                file2->base_rec.rank, file2->base_rec.id, pnetcdf_f_counter_names[i],
215 216 217 218 219 220 221
                file2->fcounters[i], file_name2, "", "");
        }
    }

    return;
}

222 223
static void darshan_log_agg_pnetcdf_files(void *rec, void *agg_rec, int init_flag)
{
224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
    struct darshan_pnetcdf_file *pnc_rec = (struct darshan_pnetcdf_file *)rec;
    struct darshan_pnetcdf_file *agg_pnc_rec = (struct darshan_pnetcdf_file *)agg_rec;
    int i;

    for(i = 0; i < PNETCDF_NUM_INDICES; i++)
    {
        switch(i)
        {
            case PNETCDF_INDEP_OPENS:
            case PNETCDF_COLL_OPENS:
                /* sum */
                agg_pnc_rec->counters[i] += pnc_rec->counters[i];
                break;
            default:
                agg_pnc_rec->counters[i] = -1;
                break;
        }
    }

    for(i = 0; i < PNETCDF_F_NUM_INDICES; i++)
    {
        switch(i)
        {
            case PNETCDF_F_OPEN_TIMESTAMP:
                /* minimum non-zero */
                if((pnc_rec->fcounters[i] > 0)  &&
                    ((agg_pnc_rec->fcounters[i] == 0) ||
                    (pnc_rec->fcounters[i] < agg_pnc_rec->fcounters[i])))
                {
                    agg_pnc_rec->fcounters[i] = pnc_rec->fcounters[i];
                }
                break;
            case PNETCDF_F_CLOSE_TIMESTAMP:
                /* maximum */
                if(pnc_rec->fcounters[i] > agg_pnc_rec->fcounters[i])
                {
                    agg_pnc_rec->fcounters[i] = pnc_rec->fcounters[i];
                }
                break;
            default:
                agg_pnc_rec->fcounters[i] = -1;
                break;
        }
    }

269 270 271
    return;
}

272 273 274 275 276 277 278 279
/*
 * Local variables:
 *  c-indent-level: 4
 *  c-basic-offset: 4
 * End:
 *
 * vim: ts=8 sts=4 sw=4 expandtab
 */