This source file includes following definitions.
- ADIOI_LUSTRE_Aligned_Mem_File_Write
- ADIOI_LUSTRE_Aligned_Mem_File_Read
- ADIOI_LUSTRE_Directio
- ADIOI_LUSTRE_IOContig
- ADIOI_LUSTRE_WriteContig
- ADIOI_LUSTRE_ReadContig
1
2
3
4
5
6
7
8
9
10
11 #include <unistd.h>
12
13 #include <stdlib.h>
14 #include <malloc.h>
15 #include "ad_lustre.h"
16
17 #define LUSTRE_MEMALIGN (1<<12)
18
19 static void ADIOI_LUSTRE_Aligned_Mem_File_Write(ADIO_File fd, const void *buf, int len,
20 ADIO_Offset offset, int *err);
21 static void ADIOI_LUSTRE_Aligned_Mem_File_Write(ADIO_File fd, const void *buf, int len,
22 ADIO_Offset offset, int *err)
23 {
24 int rem, size, nbytes;
25 if (!(len % fd->d_miniosz) && (len >= fd->d_miniosz)) {
26 *err = pwrite(fd->fd_direct, buf, len, offset);
27 } else if (len < fd->d_miniosz) {
28 *err = pwrite(fd->fd_sys, buf, len, offset);
29 } else {
30 rem = len % fd->d_miniosz;
31 size = len - rem;
32 nbytes = pwrite(fd->fd_direct, buf, size, offset);
33 nbytes += pwrite(fd->fd_sys, ((char *)buf) + size, rem, offset+size);
34 *err = nbytes;
35 }
36 }
37
38 static void ADIOI_LUSTRE_Aligned_Mem_File_Read(ADIO_File fd, const void *buf, int len,
39 ADIO_Offset offset, int *err);
40 static void ADIOI_LUSTRE_Aligned_Mem_File_Read(ADIO_File fd, const void *buf, int len,
41 ADIO_Offset offset, int *err)
42 {
43 int rem, size, nbytes;
44 if (!(len % fd->d_miniosz) && (len >= fd->d_miniosz))
45 *err = pread(fd->fd_direct, (void *)buf, len, offset);
46 else if (len < fd->d_miniosz)
47 *err = pread(fd->fd_sys, (void *)buf, len, offset);
48 else {
49 rem = len % fd->d_miniosz;
50 size = len - rem;
51 nbytes = pread(fd->fd_direct, (void *)buf, size, offset);
52 nbytes += pread(fd->fd_sys, ((char *)buf) + size, rem, offset+size);
53 *err = nbytes;
54 }
55 }
56
57
58 static int ADIOI_LUSTRE_Directio(ADIO_File fd, const void *buf, int len,
59 off_t offset, int rw);
60 static int ADIOI_LUSTRE_Directio(ADIO_File fd, const void *buf, int len,
61 off_t offset, int rw)
62 {
63 int err=-1, diff, size=len, nbytes = 0;
64 void *newbuf;
65
66 if (offset % fd->d_miniosz) {
67 diff = fd->d_miniosz - (offset % fd->d_miniosz);
68 diff = ADIOI_MIN(diff, len);
69 if (rw)
70 nbytes = pwrite(fd->fd_sys, (void *)buf, diff, offset);
71 else
72 nbytes = pread(fd->fd_sys, (void *)buf, diff, offset);
73 buf = ((char *) buf) + diff;
74 offset += diff;
75 size = len - diff;
76 }
77
78 if (!size) {
79 return diff;
80 }
81
82 if (rw) {
83 if (!(((long) buf) % fd->d_mem)) {
84 ADIOI_LUSTRE_Aligned_Mem_File_Write(fd, buf, size, offset, &err);
85 nbytes += err;
86 } else {
87 newbuf = (void *) memalign(LUSTRE_MEMALIGN, size);
88 if (newbuf) {
89 memcpy(newbuf, buf, size);
90 ADIOI_LUSTRE_Aligned_Mem_File_Write(fd, newbuf, size, offset, &err);
91 nbytes += err;
92 ADIOI_Free(newbuf);
93 }
94 else nbytes += pwrite(fd->fd_sys, buf, size, offset);
95 }
96 err = nbytes;
97 } else {
98 if (!(((long) buf) % fd->d_mem)) {
99 ADIOI_LUSTRE_Aligned_Mem_File_Read(fd, buf, size, offset, &err);
100 nbytes += err;
101 } else {
102 newbuf = (void *) memalign(LUSTRE_MEMALIGN, size);
103 if (newbuf) {
104 ADIOI_LUSTRE_Aligned_Mem_File_Read(fd, newbuf, size, offset, &err);
105 if (err > 0) memcpy((void *)buf, newbuf, err);
106 nbytes += err;
107 ADIOI_Free(newbuf);
108 }
109 else nbytes += pread(fd->fd_sys, (void *)buf, size, offset);
110 }
111 err = nbytes;
112 }
113 return err;
114 }
115
116 static void ADIOI_LUSTRE_IOContig(ADIO_File fd, const void *buf, int count,
117 MPI_Datatype datatype, int file_ptr_type,
118 ADIO_Offset offset, ADIO_Status *status,
119 int io_mode, int *error_code);
120 static void ADIOI_LUSTRE_IOContig(ADIO_File fd, const void *buf, int count,
121 MPI_Datatype datatype, int file_ptr_type,
122 ADIO_Offset offset, ADIO_Status *status,
123 int io_mode, int *error_code)
124 {
125 int err=-1;
126 MPI_Count datatype_size, len;
127 static char myname[] = "ADIOI_LUSTRE_IOCONTIG";
128
129 MPI_Type_size_x(datatype, &datatype_size);
130 len = datatype_size * count;
131
132 if (file_ptr_type == ADIO_INDIVIDUAL) {
133 offset = fd->fp_ind;
134 }
135
136 if (!(fd->direct_read || fd->direct_write)) {
137 if (fd->fp_sys_posn != offset) {
138 err = lseek(fd->fd_sys, offset, SEEK_SET);
139 if (err == -1) goto ioerr;
140 }
141
142 if (io_mode) {
143 #ifdef ADIOI_MPE_LOGGING
144 MPE_Log_event(ADIOI_MPE_write_a, 0, NULL);
145 #endif
146 err = write(fd->fd_sys, buf, len);
147 #ifdef ADIOI_MPE_LOGGING
148 MPE_Log_event(ADIOI_MPE_write_b, 0, NULL);
149 #endif
150 } else {
151 #ifdef ADIOI_MPE_LOGGING
152 MPE_Log_event(ADIOI_MPE_read_a, 0, NULL);
153 #endif
154 err = read(fd->fd_sys, (void *)buf, len);
155 #ifdef ADIOI_MPE_LOGGING
156 MPE_Log_event(ADIOI_MPE_read_b, 0, NULL);
157 #endif
158 }
159 } else {
160 err = ADIOI_LUSTRE_Directio(fd, buf, len, offset, io_mode);
161 }
162
163 if (err == -1) goto ioerr;
164 fd->fp_sys_posn = offset + err;
165
166 if (file_ptr_type == ADIO_INDIVIDUAL) {
167 fd->fp_ind += err;
168 }
169
170 #ifdef HAVE_STATUS_SET_BYTES
171 if (status) MPIR_Status_set_bytes(status, datatype, err);
172 #endif
173 *error_code = MPI_SUCCESS;
174
175 ioerr:
176
177 if (err == -1) {
178 *error_code = MPIO_Err_create_code(MPI_SUCCESS,
179 MPIR_ERR_RECOVERABLE,
180 myname, __LINE__,
181 MPI_ERR_IO, "**io",
182 "**io %s", strerror(errno));
183 fd->fp_sys_posn = -1;
184 return;
185 }
186
187 }
188
189 void ADIOI_LUSTRE_WriteContig(ADIO_File fd, const void *buf, int count,
190 MPI_Datatype datatype, int file_ptr_type,
191 ADIO_Offset offset, ADIO_Status *status, int *error_code)
192 {
193 ADIOI_LUSTRE_IOContig(fd, buf, count, datatype, file_ptr_type,
194 offset, status, 1, error_code);
195 }
196
197 void ADIOI_LUSTRE_ReadContig(ADIO_File fd, void *buf, int count,
198 MPI_Datatype datatype, int file_ptr_type,
199 ADIO_Offset offset, ADIO_Status *status, int *error_code)
200 {
201 ADIOI_LUSTRE_IOContig(fd, buf, count, datatype, file_ptr_type,
202 offset, status, 0, error_code);
203 }