darshan-lustre-logutils.c 9.79 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
 * 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 "darshan-logutils.h"

/* counter name strings for the LUSTRE module */
#define X(a) #a,
char *lustre_counter_names[] = {
    LUSTRE_COUNTERS
};
#undef X

27
static int darshan_log_get_lustre_record(darshan_fd fd, void** lustre_buf_p);
28
static int darshan_log_put_lustre_record(darshan_fd fd, void* lustre_buf);
29
static void darshan_log_print_lustre_record(void *file_rec,
30
    char *file_name, char *mnt_pt, char *fs_type);
31
static void darshan_log_print_lustre_description(int ver);
32
33
static void darshan_log_print_lustre_record_diff(void *rec1, char *file_name1,
    void *rec2, char *file_name2);
34
static void darshan_log_agg_lustre_records(void *rec, void *agg_rec, int init_flag);
35
36
37
38
39
40
41

struct darshan_mod_logutil_funcs lustre_logutils =
{
    .log_get_record = &darshan_log_get_lustre_record,
    .log_put_record = &darshan_log_put_lustre_record,
    .log_print_record = &darshan_log_print_lustre_record,
    .log_print_description = &darshan_log_print_lustre_description,
42
43
    .log_print_diff = &darshan_log_print_lustre_record_diff,
    .log_agg_records = &darshan_log_agg_lustre_records
44
45
};

46
static int darshan_log_get_lustre_record(darshan_fd fd, void** lustre_buf_p)
47
{
48
49
    struct darshan_lustre_record *rec = *((struct darshan_lustre_record **)lustre_buf_p);
    struct darshan_lustre_record tmp_rec;
50
51
52
    int i;
    int ret;

53
54
55
    if(fd->mod_map[DARSHAN_LUSTRE_MOD].len == 0)
        return(0);

56
    /* retrieve the fixed-size portion of the record */
57
    ret = darshan_log_get_mod(fd, DARSHAN_LUSTRE_MOD, &tmp_rec,
58
59
60
61
62
        sizeof(struct darshan_lustre_record));
    if(ret < 0)
        return(-1);
    else if(ret < sizeof(struct darshan_lustre_record))
        return(0);
63

64
65
66
67
68
69
70
    if(*lustre_buf_p == NULL)
    {
        rec = malloc(LUSTRE_RECORD_SIZE(tmp_rec.counters[LUSTRE_STRIPE_WIDTH]));
        if(!rec)
            return(-1);
    }
    memcpy(rec, &tmp_rec, sizeof(struct darshan_lustre_record));
71
72
73

    /* swap bytes if necessary */
    if(fd->swap_flag)
74
    {
75
76
        DARSHAN_BSWAP64(&rec->base_rec.id);
        DARSHAN_BSWAP64(&rec->base_rec.rank);
77
78
        for(i=0; i<LUSTRE_NUM_INDICES; i++)
            DARSHAN_BSWAP64(&rec->counters[i]);
79
        DARSHAN_BSWAP64(&(rec->ost_ids[0]));
80
    }
81

82
83
    /* now read the rest of the record */
    if ( rec->counters[LUSTRE_STRIPE_WIDTH] > 1 ) {
84
        ret = darshan_log_get_mod(
85
86
87
88
89
90
            fd,
            DARSHAN_LUSTRE_MOD,
            (void*)(&(rec->ost_ids[1])),
            (rec->counters[LUSTRE_STRIPE_WIDTH] - 1)*sizeof(OST_ID)
        );
        if(ret < 0)
91
            ret = -1;
92
        else if(ret < (rec->counters[LUSTRE_STRIPE_WIDTH] - 1)*sizeof(OST_ID))
93
94
95
            ret = 0;
        else
            ret = 1;
96
97
98
99
        /* swap bytes if necessary */
        if ( fd->swap_flag )
            for (i = 1; i < rec->counters[LUSTRE_STRIPE_WIDTH]; i++ )
                DARSHAN_BSWAP64(&(rec->ost_ids[i]));
100
    }
101
102
103
104
105
106
107
108
109
110
111
112
    else
    {
        ret = 1;
    }

    if(*lustre_buf_p == NULL)
    {
        if(ret == 1)
            *lustre_buf_p = rec;
        else
            free(rec);
    }
113

114
    return(ret);
115
116
}

117
static int darshan_log_put_lustre_record(darshan_fd fd, void* lustre_buf)
118
119
120
121
{
    struct darshan_lustre_record *rec = (struct darshan_lustre_record *)lustre_buf;
    int ret;

122
    ret = darshan_log_put_mod(fd, DARSHAN_LUSTRE_MOD, rec,
123
        LUSTRE_RECORD_SIZE(rec->counters[LUSTRE_STRIPE_WIDTH]), DARSHAN_LUSTRE_VER);
124
125
126
127
128
129
130
    if(ret < 0)
        return(-1);

    return(0);
}

static void darshan_log_print_lustre_record(void *rec, char *file_name,
131
    char *mnt_pt, char *fs_type)
132
133
134
135
136
137
138
139
{
    int i;
    struct darshan_lustre_record *lustre_rec =
        (struct darshan_lustre_record *)rec;

    for(i=0; i<LUSTRE_NUM_INDICES; i++)
    {
        DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_LUSTRE_MOD],
140
            lustre_rec->base_rec.rank, lustre_rec->base_rec.id, lustre_counter_names[i],
141
142
143
            lustre_rec->counters[i], file_name, mnt_pt, fs_type);
    }

144
145
146
147
148
    for (i = 0; i < lustre_rec->counters[LUSTRE_STRIPE_WIDTH]; i++ )
    {
        char strbuf[25];
        snprintf( strbuf, 25, "LUSTRE_OST_ID_%d", i );
        DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_LUSTRE_MOD],
149
150
            lustre_rec->base_rec.rank,
            lustre_rec->base_rec.id,
151
152
153
154
155
156
157
            strbuf,
            lustre_rec->ost_ids[i],
            file_name,
            mnt_pt,
            fs_type);
    }

158
159
160
    return;
}

161
static void darshan_log_print_lustre_description(int ver)
162
163
{
    printf("\n# description of LUSTRE counters:\n");
164
165
    printf("#   LUSTRE_OSTS: number of OSTs across the entire file system.\n");
    printf("#   LUSTRE_MDTS: number of MDTs across the entire file system.\n");
166
    printf("#   LUSTRE_STRIPE_OFFSET: OST ID offset specified when the file was created.\n");
167
168
    printf("#   LUSTRE_STRIPE_SIZE: stripe size for file in bytes.\n");
    printf("#   LUSTRE_STRIPE_WIDTH: number of OSTs over which file is striped.\n");
169
    printf("#   LUSTRE_OST_ID_*: indices of OSTs over which the file is striped.\n");
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

    return;
}

static void darshan_log_print_lustre_record_diff(void *rec1, char *file_name1,
    void *rec2, char *file_name2)
{
    struct darshan_lustre_record *lustre_rec1 = (struct darshan_lustre_record *)rec1;
    struct darshan_lustre_record *lustre_rec2 = (struct darshan_lustre_record *)rec2;
    int i;

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

    for(i=0; i<LUSTRE_NUM_INDICES; i++)
    {
        if(!lustre_rec2)
        {
            printf("- ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_LUSTRE_MOD],
189
190
                lustre_rec1->base_rec.rank, lustre_rec1->base_rec.id,
                lustre_counter_names[i], lustre_rec1->counters[i], file_name1, "", "");
191
192
193
194
195
196

        }
        else if(!lustre_rec1)
        {
            printf("+ ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_LUSTRE_MOD],
197
198
                lustre_rec2->base_rec.rank, lustre_rec2->base_rec.id,
                lustre_counter_names[i], lustre_rec2->counters[i], file_name2, "", "");
199
200
201
202
203
        }
        else if(lustre_rec1->counters[i] != lustre_rec2->counters[i])
        {
            printf("- ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_LUSTRE_MOD],
204
205
                lustre_rec1->base_rec.rank, lustre_rec1->base_rec.id,
                lustre_counter_names[i], lustre_rec1->counters[i], file_name1, "", "");
206
207
            printf("+ ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_LUSTRE_MOD],
208
209
                lustre_rec2->base_rec.rank, lustre_rec2->base_rec.id,
                lustre_counter_names[i], lustre_rec2->counters[i], file_name2, "", "");
210
211
212
        }
    }

213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
    /* TODO: would it be more or less useful to sort the OST IDs before comparing? */
    i = 0;
    while (1)
    {
        char strbuf[25];
        snprintf( strbuf, 25, "LUSTRE_OST_ID_%d", i );
        if (!lustre_rec2 || (i >= lustre_rec2->counters[LUSTRE_STRIPE_WIDTH]))
        {
            printf("- ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_LUSTRE_MOD],
                lustre_rec1->base_rec.rank,
                lustre_rec1->base_rec.id,
                strbuf,
                lustre_rec1->ost_ids[i],
                file_name1,
                "",
                "");
        }
        else if (!lustre_rec1 || (i >= lustre_rec1->counters[LUSTRE_STRIPE_WIDTH]))
        {
            printf("+ ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_LUSTRE_MOD],
                lustre_rec2->base_rec.rank,
                lustre_rec2->base_rec.id,
                strbuf,
                lustre_rec2->ost_ids[i],
                file_name2,
                "",
                "");
        }
        else if (lustre_rec1->ost_ids[i] != lustre_rec2->ost_ids[i])
244
        {
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
            printf("- ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_LUSTRE_MOD],
                lustre_rec1->base_rec.rank,
                lustre_rec1->base_rec.id,
                strbuf,
                lustre_rec1->ost_ids[i],
                file_name1,
                "",
                "");
            printf("+ ");
            DARSHAN_COUNTER_PRINT(darshan_module_names[DARSHAN_LUSTRE_MOD],
                lustre_rec2->base_rec.rank,
                lustre_rec2->base_rec.id,
                strbuf,
                lustre_rec2->ost_ids[i],
                file_name2,
                "",
                "");
263
        }
264
265
266
267
268

        i++;
        if ((!lustre_rec1 || (i >= lustre_rec1->counters[LUSTRE_STRIPE_WIDTH])) &&
            (!lustre_rec2 || (i >= lustre_rec2->counters[LUSTRE_STRIPE_WIDTH])))
            break;
269
270
    }

271
272
273
    return;
}

274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
static void darshan_log_agg_lustre_records(void *rec, void *agg_rec, int init_flag)
{
    struct darshan_lustre_record *lustre_rec = (struct darshan_lustre_record *)rec;
    struct darshan_lustre_record *agg_lustre_rec = (struct darshan_lustre_record *)agg_rec;
    int i;

    if(init_flag)
    {
        /* when initializing, just copy over the first record */
        memcpy(agg_lustre_rec, lustre_rec, LUSTRE_RECORD_SIZE(
            lustre_rec->counters[LUSTRE_STRIPE_WIDTH]));
    }
    else
    {
        /* for remaining records, just sanity check the records are identical */
        for(i = 0; i < LUSTRE_NUM_INDICES; i++)
        {
            assert(lustre_rec->counters[i] == agg_lustre_rec->counters[i]);
        }
        for(i = 0; i < agg_lustre_rec->counters[LUSTRE_STRIPE_WIDTH]; i++)
        {
            assert(lustre_rec->ost_ids[i] == agg_lustre_rec->ost_ids[i]);
        }
    }

    return;
}


303
304
305
306
307
308
309
310
/*
 * Local variables:
 *  c-indent-level: 4
 *  c-basic-offset: 4
 * End:
 *
 * vim: ts=8 sts=4 sw=4 expandtab
 */