File: seek_sh.c

package info (click to toggle)
openmpi 5.0.8-4
  • links: PTS, VCS
  • area: main
  • in suites:
  • size: 201,684 kB
  • sloc: ansic: 613,078; makefile: 42,353; sh: 11,194; javascript: 9,244; f90: 7,052; java: 6,404; perl: 5,179; python: 1,859; lex: 740; fortran: 61; cpp: 20; tcl: 12
file content (168 lines) | stat: -rw-r--r-- 6,554 bytes parent folder | download | duplicates (9)
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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
/*
 * Copyright (C) by Argonne National Laboratory
 *     See COPYRIGHT in top-level directory
 */

#include "mpioimpl.h"

#ifdef HAVE_WEAK_SYMBOLS

#if defined(HAVE_PRAGMA_WEAK)
#pragma weak MPI_File_seek_shared = PMPI_File_seek_shared
#elif defined(HAVE_PRAGMA_HP_SEC_DEF)
#pragma _HP_SECONDARY_DEF PMPI_File_seek_shared MPI_File_seek_shared
#elif defined(HAVE_PRAGMA_CRI_DUP)
#pragma _CRI duplicate MPI_File_seek_shared as PMPI_File_seek_shared
/* end of weak pragmas */
#elif defined(HAVE_WEAK_ATTRIBUTE)
int MPI_File_seek_shared(MPI_File fh, MPI_Offset offset, int whence)
    __attribute__ ((weak, alias("PMPI_File_seek_shared")));
#endif

/* Include mapping from MPI->PMPI */
#define MPIO_BUILD_PROFILING
#include "mpioprof.h"
#endif

/*@
    MPI_File_seek_shared - Updates the shared file pointer

Input Parameters:
. fh - file handle (handle)
. offset - file offset (integer)
. whence - update mode (state)

.N fortran
@*/
int MPI_File_seek_shared(MPI_File fh, MPI_Offset offset, int whence)
{
    int error_code = MPI_SUCCESS, tmp_whence, myrank;
    static char myname[] = "MPI_FILE_SEEK_SHARED";
    MPI_Offset curr_offset, eof_offset, tmp_offset;
    ADIO_File adio_fh;

    ROMIO_THREAD_CS_ENTER();

    adio_fh = MPIO_File_resolve(fh);

    /* --BEGIN ERROR HANDLING-- */
    MPIO_CHECK_FILE_HANDLE(adio_fh, myname, error_code);
    MPIO_CHECK_NOT_SEQUENTIAL_MODE(adio_fh, myname, error_code);
    MPIO_CHECK_FS_SUPPORTS_SHARED(adio_fh, myname, error_code);
    /* --END ERROR HANDLING-- */

    tmp_offset = offset;
    MPI_Bcast(&tmp_offset, 1, ADIO_OFFSET, 0, adio_fh->comm);
    /* --BEGIN ERROR HANDLING-- */
    if (tmp_offset != offset) {
        error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
                                          myname, __LINE__, MPI_ERR_ARG, "**notsame", 0);
        error_code = MPIO_Err_return_file(adio_fh, error_code);
        goto fn_exit;
    }
    /* --END ERROR HANDLING-- */

    tmp_whence = whence;
    MPI_Bcast(&tmp_whence, 1, MPI_INT, 0, adio_fh->comm);
    /* --BEGIN ERROR HANDLING-- */
    if (tmp_whence != whence) {
        error_code = MPIO_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
                                          myname, __LINE__, MPI_ERR_ARG, "**iobadwhence", 0);
        error_code = MPIO_Err_return_file(adio_fh, error_code);
        goto fn_exit;
    }
    /* --END ERROR HANDLING-- */

    ADIOI_TEST_DEFERRED(adio_fh, "MPI_File_seek_shared", &error_code);

    MPI_Comm_rank(adio_fh->comm, &myrank);

    if (!myrank) {
        switch (whence) {
            case MPI_SEEK_SET:
                /* --BEGIN ERROR HANDLING-- */
                if (offset < 0) {
                    error_code = MPIO_Err_create_code(MPI_SUCCESS,
                                                      MPIR_ERR_RECOVERABLE,
                                                      myname, __LINE__,
                                                      MPI_ERR_ARG, "**iobadoffset", 0);
                    error_code = MPIO_Err_return_file(adio_fh, error_code);
                    goto fn_exit;
                }
                /* --END ERROR HANDLING-- */
                break;
            case MPI_SEEK_CUR:
                /* get current location of shared file pointer */
                ADIO_Get_shared_fp(adio_fh, 0, &curr_offset, &error_code);
                /* --BEGIN ERROR HANDLING-- */
                if (error_code != MPI_SUCCESS) {
                    error_code = MPIO_Err_create_code(MPI_SUCCESS,
                                                      MPIR_ERR_FATAL,
                                                      myname, __LINE__,
                                                      MPI_ERR_INTERN, "**iosharedfailed", 0);
                    error_code = MPIO_Err_return_file(adio_fh, error_code);
                    goto fn_exit;
                }
                /* --END ERROR HANDLING-- */
                offset += curr_offset;
                /* --BEGIN ERROR HANDLING-- */
                if (offset < 0) {
                    error_code = MPIO_Err_create_code(MPI_SUCCESS,
                                                      MPIR_ERR_RECOVERABLE,
                                                      myname, __LINE__,
                                                      MPI_ERR_ARG, "**ionegoffset", 0);
                    error_code = MPIO_Err_return_file(adio_fh, error_code);
                    goto fn_exit;
                }
                /* --END ERROR HANDLING-- */
                break;
            case MPI_SEEK_END:
                /* find offset corr. to end of file */
                ADIOI_Get_eof_offset(adio_fh, &eof_offset);
                offset += eof_offset;
                /* --BEGIN ERROR HANDLING-- */
                if (offset < 0) {
                    error_code = MPIO_Err_create_code(MPI_SUCCESS,
                                                      MPIR_ERR_RECOVERABLE,
                                                      myname, __LINE__,
                                                      MPI_ERR_ARG, "**ionegoffset", 0);
                    error_code = MPIO_Err_return_file(adio_fh, error_code);
                    goto fn_exit;
                }
                /* --END ERROR HANDLING-- */
                break;
            default:
                /* --BEGIN ERROR HANDLING-- */
                error_code = MPIO_Err_create_code(MPI_SUCCESS,
                                                  MPIR_ERR_RECOVERABLE,
                                                  myname, __LINE__, MPI_ERR_ARG,
                                                  "**iobadwhence", 0);
                error_code = MPIO_Err_return_file(adio_fh, error_code);
                goto fn_exit;
                /* --END ERROR HANDLING-- */
        }

        ADIO_Set_shared_fp(adio_fh, offset, &error_code);
        /* --BEGIN ERROR HANDLING-- */
        if (error_code != MPI_SUCCESS) {
            error_code = MPIO_Err_create_code(MPI_SUCCESS,
                                              MPIR_ERR_FATAL,
                                              myname, __LINE__,
                                              MPI_ERR_INTERN, "**iosharedfailed", 0);
            error_code = MPIO_Err_return_file(adio_fh, error_code);
            goto fn_exit;
        }
        /* --END ERROR HANDLING-- */

    }

    /* FIXME: explain why the barrier is necessary */
    MPI_Barrier(adio_fh->comm);

    error_code = MPI_SUCCESS;

  fn_exit:
    ROMIO_THREAD_CS_EXIT();

    return error_code;
}