source: libcfa/src/concurrency/io/call.cfa.in @ 8bee858

pthread-emulation
Last change on this file since 8bee858 was 8bee858, checked in by Thierry Delisle <tdelisle@…>, 5 months ago

Changed io types to have trailing $ instead of leading

  • Property mode set to 100644
File size: 13.6 KB
Line 
1#!python3
2#
3# Cforall Version 1.0.0 Copyright (C) 2020 University of Waterloo
4#
5# The contents of this file are covered under the licence agreement in the
6# file "LICENCE" distributed with Cforall.
7#
8# call.cfa.in -- Python script to generate io/call.cfa
9#
10# Author           : Thierry Delisle
11# Created On       : Fri Sep 11 12:41:16 2020
12# Last Modified By :
13# Last Modified On :
14# Update Count     :
15#
16
17Header = """//
18// Cforall Version 1.0.0 Copyright (C) 2020 University of Waterloo
19//
20// The contents of this file are covered under the licence agreement in the
21// file "LICENCE" distributed with Cforall.
22//
23// call.cfa -- Api for cforall
24//
25// Author           : Generated from call.cfa.in
26// Created On       : {}
27//
28
29"""
30
31Prelude = """#define __cforall_thread__
32
33#include "bits/defs.hfa"
34#include "kernel.hfa"
35#include "io/types.hfa"
36#include "stats.hfa"
37
38//=============================================================================================
39// I/O uring backend
40//=============================================================================================
41
42#if defined(CFA_HAVE_LINUX_IO_URING_H)
43        #include <assert.h>
44        #include <stdint.h>
45        #include <errno.h>
46        #include <linux/io_uring.h>
47
48        #include "kernel/fwd.hfa"
49
50        static const __u8 REGULAR_FLAGS = 0
51                #if defined(CFA_HAVE_IOSQE_FIXED_FILE)
52                        | IOSQE_FIXED_FILE
53                #endif
54                #if defined(CFA_HAVE_IOSQE_IO_DRAIN)
55                        | IOSQE_IO_DRAIN
56                #endif
57                #if defined(CFA_HAVE_IOSQE_IO_LINK)
58                        | IOSQE_IO_LINK
59                #endif
60                #if defined(CFA_HAVE_IOSQE_IO_HARDLINK)
61                        | IOSQE_IO_HARDLINK
62                #endif
63                #if defined(CFA_HAVE_IOSQE_ASYNC)
64                        | IOSQE_ASYNC
65                #endif
66                #if defined(CFA_HAVE_IOSQE_BUFFER_SELECTED)
67                        | IOSQE_BUFFER_SELECTED
68                #endif
69        ;
70
71        static const __u32 SPLICE_FLAGS = 0
72                #if defined(CFA_HAVE_SPLICE_F_FD_IN_FIXED)
73                        | SPLICE_F_FD_IN_FIXED
74                #endif
75        ;
76
77        extern struct io_context$ * cfa_io_allocate(struct io_uring_sqe * out_sqes[], __u32 out_idxs[], __u32 want)  __attribute__((nonnull (1,2)));
78        extern void cfa_io_submit( struct io_context$ * in_ctx, __u32 in_idxs[], __u32 have, bool lazy ) __attribute__((nonnull (1,2)));
79#endif
80
81//=============================================================================================
82// I/O Forwards
83//=============================================================================================
84#include <time.hfa>
85
86// Some forward declarations
87#include <errno.h>
88#include <unistd.h>
89
90extern "C" {
91        #include <asm/types.h>
92        #include <sys/socket.h>
93        #include <sys/syscall.h>
94
95#if defined(CFA_HAVE_PREADV2)
96        struct iovec;
97        extern ssize_t preadv2 (int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
98#endif
99#if defined(CFA_HAVE_PWRITEV2)
100        struct iovec;
101        extern ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
102#endif
103
104        extern int fsync(int fd);
105
106        #if __OFF_T_MATCHES_OFF64_T
107                typedef __off64_t off_t;
108        #else
109                typedef __off_t off_t;
110        #endif
111        typedef __off64_t off64_t;
112        extern int sync_file_range(int fd, off64_t offset, off64_t nbytes, unsigned int flags);
113
114        struct msghdr;
115        struct sockaddr;
116        extern ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
117        extern ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
118        extern ssize_t send(int sockfd, const void *buf, size_t len, int flags);
119        extern ssize_t recv(int sockfd, void *buf, size_t len, int flags);
120        extern int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
121        extern int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
122
123        extern int fallocate(int fd, int mode, off_t offset, off_t len);
124        extern int posix_fadvise(int fd, off_t offset, off_t len, int advice);
125        extern int madvise(void *addr, size_t length, int advice);
126
127        extern int openat(int dirfd, const char *pathname, int flags, mode_t mode);
128        extern int close(int fd);
129
130        extern ssize_t read (int fd, void *buf, size_t count);
131
132        struct epoll_event;
133        extern int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
134
135        extern ssize_t splice(int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags);
136        extern ssize_t tee(int fd_in, int fd_out, size_t len, unsigned int flags);
137}
138
139//=============================================================================================
140// I/O Interface
141//=============================================================================================
142#pragma GCC visibility push(default)
143"""
144
145print(Header.format("A Date"))
146print(Prelude)
147
148import re
149import sys
150class Call:
151        def __init__(self, op, signature, body, define=None):
152                sig = re.search("(.*) (.*)\((.*)\)", signature)
153                if not sig:
154                        print("OP '{}' has invalid signature {}".format(op, signature), file=sys.stderr)
155                        sys.exit(1)
156
157                self.op     = op
158                self.ret    = sig.group(1)
159                self.name   = sig.group(2)
160                self.params = sig.group(3)
161                self.define = define
162                self.body = ""
163
164                accepted_keys = [ 'ioprio', 'fd', 'off', 'addr2','addr', 'splice_off_in','len',
165                        'rw_flags', 'fsync_flags', 'poll_events', 'poll32_events',
166                        'sync_range_flags', 'msg_flags', 'timeout_flags', 'accept_flags',
167                        'cancel_flags', 'open_flags', 'statx_flags', 'fadvise_advice',
168                        'splice_flags', 'buf_index' ,'buf_group' 'personality',
169                        'splice_fd_in' ]
170
171                for k, v in body.items():
172                        if not k in accepted_keys:
173                                print("OP '{}' has invalid body kew {}".format(op, k), file=sys.stderr)
174                                sys.exit(1)
175
176                        self.body += "\n                sqe->{key} = {value};".format(key=k, value=v)
177
178
179        def args(self):
180                param_a = self.params.split(',')
181                args_a = [p.replace('*', ' ').split()[-1] for p in param_a]
182                for a in args_a:
183                        if '*' in a:
184                                print("OP '{}' has invalid * in argument {}".format(self.op, a), file=sys.stderr)
185                                sys.exit(1)
186
187                return ', '.join(args_a)
188
189AsyncTemplate = """inline void async_{name}(io_future_t & future, {params}, __u64 submit_flags) {{
190        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_{op})
191                ssize_t res = {name}({args});
192                if (res >= 0) {{
193                        fulfil(future, res);
194                }}
195                else {{
196                        fulfil(future, -errno);
197                }}
198        #else
199                __u8 sflags = REGULAR_FLAGS & submit_flags;
200                __u32 idx;
201                struct io_uring_sqe * sqe;
202                struct io_context$ * ctx = cfa_io_allocate( &sqe, &idx, 1 );
203
204                sqe->opcode = IORING_OP_{op};
205                sqe->user_data = (uintptr_t)&future;
206                sqe->flags = sflags;
207                sqe->ioprio = 0;
208                sqe->fd = 0;
209                sqe->off = 0;
210                sqe->addr = 0;
211                sqe->len = 0;
212                sqe->fsync_flags = 0;
213                sqe->__pad2[0] = 0;
214                sqe->__pad2[1] = 0;
215                sqe->__pad2[2] = 0;{body}
216
217                asm volatile("": : :"memory");
218
219                verify( sqe->user_data == (uintptr_t)&future );
220                cfa_io_submit( ctx, &idx, 1, 0 != (submit_flags & CFA_IO_LAZY) );
221        #endif
222}}"""
223
224SyncTemplate = """{ret} cfa_{name}({params}, __u64 submit_flags) {{
225        io_future_t future;
226
227        async_{name}( future, {args}, submit_flags );
228
229        __attribute__((unused)) bool parked;
230        parked = wait( future );
231        __STATS__(false, if(!parked) io.submit.nblk += 1; )
232        if( future.result < 0 ) {{
233                errno = -future.result;
234                return -1;
235        }}
236        return future.result;
237}}"""
238
239calls = [
240        # CFA_HAVE_IORING_OP_READV
241        Call('READV', 'ssize_t preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags)', {
242                'fd'  : 'fd',
243                'off' : 'offset',
244                'addr': '(uintptr_t)iov',
245                'len' : 'iovcnt',
246        }, define = 'CFA_HAVE_PREADV2'),
247        # CFA_HAVE_IORING_OP_WRITEV
248        Call('WRITEV', 'ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags)', {
249                'fd'  : 'fd',
250                'off' : 'offset',
251                'addr': '(uintptr_t)iov',
252                'len' : 'iovcnt'
253        }, define = 'CFA_HAVE_PWRITEV2'),
254        # CFA_HAVE_IORING_OP_FSYNC
255        Call('FSYNC', 'int fsync(int fd)', {
256                'fd': 'fd'
257        }),
258        # CFA_HAVE_IORING_OP_EPOLL_CTL
259        Call('EPOLL_CTL', 'int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)', {
260                'fd': 'epfd',
261                'addr': 'fd',
262                'len': 'op',
263                'off': '(uintptr_t)event'
264        }),
265        # CFA_HAVE_IORING_OP_SYNC_FILE_RANGE
266        Call('SYNC_FILE_RANGE', 'int sync_file_range(int fd, off64_t offset, off64_t nbytes, unsigned int flags)', {
267                'fd': 'fd',
268                'off': 'offset',
269                'len': 'nbytes',
270                'sync_range_flags': 'flags'
271        }),
272        # CFA_HAVE_IORING_OP_SENDMSG
273        Call('SENDMSG', 'ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags)', {
274                'fd': 'sockfd',
275                'addr': '(uintptr_t)(struct msghdr *)msg',
276                'len': '1',
277                'msg_flags': 'flags'
278        }),
279        # CFA_HAVE_IORING_OP_RECVMSG
280        Call('RECVMSG', 'ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags)', {
281                'fd': 'sockfd',
282                'addr': '(uintptr_t)(struct msghdr *)msg',
283                'len': '1',
284                'msg_flags': 'flags'
285        }),
286        # CFA_HAVE_IORING_OP_SEND
287        Call('SEND', 'ssize_t send(int sockfd, const void *buf, size_t len, int flags)', {
288                'fd': 'sockfd',
289                'addr': '(uintptr_t)buf',
290                'len': 'len',
291                'msg_flags': 'flags'
292        }),
293        # CFA_HAVE_IORING_OP_RECV
294        Call('RECV', 'ssize_t recv(int sockfd, void *buf, size_t len, int flags)', {
295                'fd': 'sockfd',
296                'addr': '(uintptr_t)buf',
297                'len': 'len',
298                'msg_flags': 'flags'
299        }),
300        # CFA_HAVE_IORING_OP_ACCEPT
301        Call('ACCEPT', 'int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags)', {
302                'fd': 'sockfd',
303                'addr': '(uintptr_t)addr',
304                'addr2': '(uintptr_t)addrlen',
305                'accept_flags': 'flags'
306        }),
307        # CFA_HAVE_IORING_OP_CONNECT
308        Call('CONNECT', 'int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)', {
309                'fd': 'sockfd',
310                'addr': '(uintptr_t)addr',
311                'off': 'addrlen'
312        }),
313        # CFA_HAVE_IORING_OP_FALLOCATE
314        Call('FALLOCATE', 'int fallocate(int fd, int mode, off_t offset, off_t len)', {
315                'fd': 'fd',
316                'addr': '(uintptr_t)len',
317                'len': 'mode',
318                'off': 'offset'
319        }),
320        # CFA_HAVE_IORING_OP_FADVISE
321        Call('FADVISE', 'int posix_fadvise(int fd, off_t offset, off_t len, int advice)', {
322                'fd': 'fd',
323                'off': 'offset',
324                'len': 'len',
325                'fadvise_advice': 'advice'
326        }),
327        # CFA_HAVE_IORING_OP_MADVISE
328        Call('MADVISE', 'int madvise(void *addr, size_t length, int advice)', {
329                'addr': '(uintptr_t)addr',
330                'len': 'length',
331                'fadvise_advice': 'advice'
332        }),
333        # CFA_HAVE_IORING_OP_OPENAT
334        Call('OPENAT', 'int openat(int dirfd, const char *pathname, int flags, mode_t mode)', {
335                'fd': 'dirfd',
336                'addr': '(uintptr_t)pathname',
337                'len': 'mode',
338                'open_flags': 'flags;'
339        }),
340        # CFA_HAVE_IORING_OP_OPENAT2
341        Call('OPENAT2', 'int openat2(int dirfd, const char *pathname, struct open_how * how, size_t size)', {
342                'fd': 'dirfd',
343                'addr': 'pathname',
344                'len': 'sizeof(*how)',
345                'off': '(uintptr_t)how',
346        }, define = 'CFA_HAVE_OPENAT2'),
347        # CFA_HAVE_IORING_OP_CLOSE
348        Call('CLOSE', 'int close(int fd)', {
349                'fd': 'fd'
350        }),
351        # CFA_HAVE_IORING_OP_STATX
352        Call('STATX', 'int statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf)', {
353                'fd': 'dirfd',
354                'off': '(uintptr_t)statxbuf',
355                'addr': 'pathname',
356                'len': 'mask',
357                'statx_flags': 'flags'
358        }, define = 'CFA_HAVE_STATX'),
359        # CFA_HAVE_IORING_OP_READ
360        Call('READ', 'ssize_t read(int fd, void * buf, size_t count)', {
361                'fd': 'fd',
362                'addr': '(uintptr_t)buf',
363                'len': 'count'
364        }),
365        # CFA_HAVE_IORING_OP_WRITE
366        Call('WRITE', 'ssize_t write(int fd, void * buf, size_t count)', {
367                'fd': 'fd',
368                'addr': '(uintptr_t)buf',
369                'len': 'count'
370        }),
371        # CFA_HAVE_IORING_OP_SPLICE
372        Call('SPLICE', 'ssize_t splice(int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags)', {
373                'splice_fd_in': 'fd_in',
374                'splice_off_in': 'off_in ? (__u64)*off_in : (__u64)-1',
375                'fd': 'fd_out',
376                'off': 'off_out ? (__u64)*off_out : (__u64)-1',
377                'len': 'len',
378                'splice_flags': 'flags'
379        }),
380        # CFA_HAVE_IORING_OP_TEE
381        Call('TEE', 'ssize_t tee(int fd_in, int fd_out, size_t len, unsigned int flags)', {
382                'splice_fd_in': 'fd_in',
383                'fd': 'fd_out',
384                'len': 'len',
385                'splice_flags': 'flags'
386        })
387]
388
389print("//----------")
390print("// synchronous calls")
391for c in calls:
392        if c.define:
393                print("""#if defined({define})
394        {ret} cfa_{name}({params}, __u64 submit_flags);
395#endif""".format(define=c.define,ret=c.ret, name=c.name, params=c.params))
396        else:
397                print("{ret} cfa_{name}({params}, __u64 submit_flags);"
398                .format(ret=c.ret, name=c.name, params=c.params))
399
400print("\n//----------")
401print("// asynchronous calls")
402for c in calls:
403        if c.define:
404                print("""#if defined({define})
405        void async_{name}(io_future_t & future, {params}, __u64 submit_flags);
406#endif""".format(define=c.define,name=c.name, params=c.params))
407        else:
408                print("void async_{name}(io_future_t & future, {params}, __u64 submit_flags);"
409                .format(name=c.name, params=c.params))
410print("\n")
411
412for c in calls:
413        print("//-----------------------------------------------------------------------------")
414        print("// {}".format(c.name))
415        Async = AsyncTemplate.format(
416                name   = c.name,
417                ret    = c.ret,
418                params = c.params,
419                args   = c.args(),
420                op     = c.op,
421                body   = c.body
422
423        )
424        Sync = SyncTemplate.format(
425                name   = c.name,
426                ret    = c.ret,
427                params = c.params,
428                args   = c.args()
429        )
430
431        if c.define:
432                print("""#if defined({})
433        //----------
434        // asynchronous call
435        {}
436
437        //----------
438        // synchronous call
439        {}
440#endif
441""".format(c.define, "\n\t".join( Async.splitlines() ), "\n\t".join( Sync.splitlines() )))
442        else :
443                print("""//----------
444// asynchronous call
445{}
446
447//----------
448// synchronous call
449{}
450""".format(Async, Sync))
451
452print("""
453//-----------------------------------------------------------------------------
454// Check if a function is has asynchronous
455bool has_user_level_blocking( fptr_t func ) {
456        #if defined(CFA_HAVE_LINUX_IO_URING_H)""")
457
458for c in calls:
459        if c.define:
460                print("""               #if defined({define})
461                        if( /*func == (fptr_t)preadv2 || */
462                                func == (fptr_t)cfa_{name} ||
463                                func == (fptr_t)async_{name} ) {{
464                                #if defined(CFA_HAVE_IORING_OP_{op})
465                                        return true;
466                                #else
467                                        return false;
468                                #endif
469                        }}
470                #endif""".format(define=c.define, name=c.name, op=c.op))
471        else:
472                print("""               if( /*func == (fptr_t)preadv2 || */
473                        func == (fptr_t)cfa_{name} ||
474                        func == (fptr_t)async_{name} ) {{
475                        #if defined(CFA_HAVE_IORING_OP_{op})
476                                return true;
477                        #else
478                                return false;
479                        #endif
480                }}""".format(name=c.name, op=c.op))
481
482print("""       #endif
483
484        return false;
485}""")
Note: See TracBrowser for help on using the repository browser.