Context Navigation

source: libcfa/src/concurrency/io/call.cfa.in @ 481ee28

ADTarm-ehast-experimentalenumforall-pointer-decayjacob/cs343-translationnew-ast-unique-exprpthread-emulationqualifiedEnum

Last change on this file since 481ee28 was 426f60c, checked in by Thierry Delisle <tdelisle@…>, 3 years ago
Web server seems to work
Property mode set to `100644`
File size: 15.2 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
17	Header = """//
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
31	Prelude = """#define __cforall_thread__
32
33	#include "bits/defs.hfa"
34	#include "kernel.hfa"
35	#include "io/types.hfa"
36
37	//=============================================================================================
38	// I/O uring backend
39	//=============================================================================================
40
41	#if defined(CFA_HAVE_LINUX_IO_URING_H)
42	#include <assert.h>
43	#include <stdint.h>
44	#include <errno.h>
45	#include <linux/io_uring.h>
46
47	#include "kernel/fwd.hfa"
48
49	static const __u8 REGULAR_FLAGS = 0
50	#if defined(CFA_HAVE_IOSQE_FIXED_FILE)
51	\| IOSQE_FIXED_FILE
52	#endif
53	#if defined(CFA_HAVE_IOSQE_IO_DRAIN)
54	\| IOSQE_IO_DRAIN
55	#endif
56	#if defined(CFA_HAVE_IOSQE_ASYNC)
57	\| IOSQE_ASYNC
58	#endif
59	;
60
61	static const __u32 LINK_FLAGS = 0
62	#if defined(CFA_HAVE_IOSQE_IO_LINK)
63	\| IOSQE_IO_LINK
64	#endif
65	#if defined(CFA_HAVE_IOSQE_IO_HARDLINK)
66	\| IOSQE_IO_HARDLINK
67	#endif
68	;
69
70	static const __u32 SPLICE_FLAGS = 0
71	#if defined(CFA_HAVE_SPLICE_F_FD_IN_FIXED)
72	\| SPLICE_F_FD_IN_FIXED
73	#endif
74	;
75
76	extern [* volatile struct io_uring_sqe, __u32] __submit_alloc( struct __io_data & ring, __u64 data );
77	extern void __submit( struct io_context * ctx, __u32 idx ) __attribute__((nonnull (1)));
78
79	static inline io_context * __get_io_context( void ) {
80	cluster * cltr = active_cluster();
81
82	/* paranoid */ verifyf( cltr, "No active cluster for io operation\\n");
83	assertf( cltr->io.cnt > 0, "Cluster %p has no default io contexts and no context was specified\\n", cltr );
84
85	/* paranoid */ verifyf( cltr->io.ctxs, "default io contexts for cluster %p are missing\\n", cltr);
86	return &cltr->io.ctxs[ thread_rand() % cltr->io.cnt ];
87	}
88	#endif
89
90	//=============================================================================================
91	// I/O Forwards
92	//=============================================================================================
93	#include <time.hfa>
94
95	// Some forward declarations
96	#include <errno.h>
97	#include <unistd.h>
98
99	extern "C" {
100	#include <sys/types.h>
101	#include <sys/socket.h>
102	#include <sys/syscall.h>
103
104	#if defined(CFA_HAVE_PREADV2)
105	struct iovec;
106	extern ssize_t preadv2 (int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
107	#endif
108	#if defined(CFA_HAVE_PWRITEV2)
109	struct iovec;
110	extern ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
111	#endif
112
113	extern int fsync(int fd);
114
115	#if __OFF_T_MATCHES_OFF64_T
116	typedef __off64_t off_t;
117	#else
118	typedef __off_t off_t;
119	#endif
120	typedef __off64_t off64_t;
121	extern int sync_file_range(int fd, off64_t offset, off64_t nbytes, unsigned int flags);
122
123	struct msghdr;
124	struct sockaddr;
125	extern ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
126	extern ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
127	extern ssize_t send(int sockfd, const void *buf, size_t len, int flags);
128	extern ssize_t recv(int sockfd, void *buf, size_t len, int flags);
129	extern int accept4(int sockfd, struct sockaddr addr, socklen_t addrlen, int flags);
130	extern int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
131
132	extern int fallocate(int fd, int mode, off_t offset, off_t len);
133	extern int posix_fadvise(int fd, off_t offset, off_t len, int advice);
134	extern int madvise(void *addr, size_t length, int advice);
135
136	extern int openat(int dirfd, const char *pathname, int flags, mode_t mode);
137	extern int close(int fd);
138
139	extern ssize_t read (int fd, void *buf, size_t count);
140
141	struct epoll_event;
142	extern int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
143
144	extern ssize_t splice(int fd_in, loff_t off_in, int fd_out, loff_t off_out, size_t len, unsigned int flags);
145	extern ssize_t tee(int fd_in, int fd_out, size_t len, unsigned int flags);
146	}
147
148	//=============================================================================================
149	// I/O Interface
150	//=============================================================================================
151	"""
152
153	print(Header.format("A Date"))
154	print(Prelude)
155
156	import re
157	import sys
158	class Call:
159	def __init__(self, op, signature, body, define=None):
160	sig = re.search("(.) (.)\((.*)\)", signature)
161	if not sig:
162	print("OP '{}' has invalid signature {}".format(op, signature), file=sys.stderr)
163	sys.exit(1)
164
165	self.op = op
166	self.ret = sig.group(1)
167	self.name = sig.group(2)
168	self.params = sig.group(3)
169	self.define = define
170	self.body = ""
171
172	accepted_keys = [ 'ioprio', 'fd', 'off', 'addr2','addr', 'splice_off_in','len',
173	'rw_flags', 'fsync_flags', 'poll_events', 'poll32_events',
174	'sync_range_flags', 'msg_flags', 'timeout_flags', 'accept_flags',
175	'cancel_flags', 'open_flags', 'statx_flags', 'fadvise_advice',
176	'splice_flags', 'buf_index' ,'buf_group' 'personality',
177	'splice_fd_in' ]
178
179	for k, v in body.items():
180	if not k in accepted_keys:
181	print("OP '{}' has invalid body kew {}".format(op, k), file=sys.stderr)
182	sys.exit(1)
183
184	self.body += "\n sqe->{key} = {value};".format(key=k, value=v)
185
186
187	def args(self):
188	param_a = self.params.split(',')
189	args_a = [p.replace('*', ' ').split()[-1] for p in param_a]
190	for a in args_a:
191	if '*' in a:
192	print("OP '{}' has invalid * in argument {}".format(self.op, a), file=sys.stderr)
193	sys.exit(1)
194
195	return ', '.join(args_a)
196
197	AsyncTemplate = """inline void async_{name}(io_future_t & future, {params}, int submit_flags, io_cancellation * cancellation, io_context * context) {{
198	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_{op})
199	ssize_t res = {name}({args});
200	if (res >= 0) {{
201	fulfil(future, res);
202	}}
203	else {{
204	fulfil(future, -errno);
205	}}
206	#else
207	// we don't support LINK yet
208	if( 0 != (submit_flags & LINK_FLAGS) ) {{
209	errno = ENOTSUP; return -1;
210	}}
211
212	if( !context ) {{
213	context = __get_io_context();
214	}}
215	if(cancellation) {{
216	cancellation->target = (__u64)(uintptr_t)&future;
217	}}
218
219	__u8 sflags = REGULAR_FLAGS & submit_flags;
220	struct __io_data & ring = *context->thrd.ring;
221
222	__u32 idx;
223	volatile struct io_uring_sqe * sqe;
224	[sqe, idx] = __submit_alloc( ring, (__u64)(uintptr_t)&future );
225
226	sqe->__pad2[0] = sqe->__pad2[1] = sqe->__pad2[2] = 0;
227	sqe->opcode = IORING_OP_{op};
228	sqe->flags = sflags;{body}
229
230	verify( sqe->user_data == (__u64)(uintptr_t)&future );
231	__submit( context, idx );
232	#endif
233	}}"""
234
235	SyncTemplate = """{ret} cfa_{name}({params}, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context) {{
236	if( timeout >= 0 ) {{
237	errno = ENOTSUP;
238	return -1;
239	}}
240	io_future_t future;
241
242	async_{name}( future, {args}, submit_flags, cancellation, context );
243
244	wait( future );
245	if( future.result < 0 ) {{
246	errno = -future.result;
247	return -1;
248	}}
249	return future.result;
250	}}"""
251
252	calls = [
253	# CFA_HAVE_IORING_OP_READV
254	Call('READV', 'ssize_t preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags)', {
255	'fd' : 'fd',
256	'off' : 'offset',
257	'addr': '(__u64)iov',
258	'len' : 'iovcnt',
259	}, define = 'CFA_HAVE_PREADV2'),
260	# CFA_HAVE_IORING_OP_WRITEV
261	Call('WRITEV', 'ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags)', {
262	'fd' : 'fd',
263	'off' : 'offset',
264	'addr': '(__u64)iov',
265	'len' : 'iovcnt'
266	}, define = 'CFA_HAVE_PWRITEV2'),
267	# CFA_HAVE_IORING_OP_FSYNC
268	Call('FSYNC', 'int fsync(int fd)', {
269	'fd': 'fd'
270	}),
271	# CFA_HAVE_IORING_OP_EPOLL_CTL
272	Call('EPOLL_CTL', 'int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)', {
273	'fd': 'epfd',
274	'addr': 'fd',
275	'len': 'op',
276	'off': '(__u64)event'
277	}),
278	# CFA_HAVE_IORING_OP_SYNC_FILE_RANGE
279	Call('SYNC_FILE_RANGE', 'int sync_file_range(int fd, off64_t offset, off64_t nbytes, unsigned int flags)', {
280	'fd': 'fd',
281	'off': 'offset',
282	'len': 'nbytes',
283	'sync_range_flags': 'flags'
284	}),
285	# CFA_HAVE_IORING_OP_SENDMSG
286	Call('SENDMSG', 'ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags)', {
287	'fd': 'sockfd',
288	'addr': '(__u64)(struct msghdr *)msg',
289	'len': '1',
290	'msg_flags': 'flags'
291	}),
292	# CFA_HAVE_IORING_OP_RECVMSG
293	Call('RECVMSG', 'ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags)', {
294	'fd': 'sockfd',
295	'addr': '(__u64)(struct msghdr *)msg',
296	'len': '1',
297	'msg_flags': 'flags'
298	}),
299	# CFA_HAVE_IORING_OP_SEND
300	Call('SEND', 'ssize_t send(int sockfd, const void *buf, size_t len, int flags)', {
301	'fd': 'sockfd',
302	'addr': '(__u64)buf',
303	'len': 'len',
304	'msg_flags': 'flags'
305	}),
306	# CFA_HAVE_IORING_OP_RECV
307	Call('RECV', 'ssize_t recv(int sockfd, void *buf, size_t len, int flags)', {
308	'fd': 'sockfd',
309	'addr': '(__u64)buf',
310	'len': 'len',
311	'msg_flags': 'flags'
312	}),
313	# CFA_HAVE_IORING_OP_ACCEPT
314	Call('ACCEPT', 'int accept4(int sockfd, struct sockaddr addr, socklen_t addrlen, int flags)', {
315	'fd': 'sockfd',
316	'ioprio': '0',
317	'addr': '(__u64)addr',
318	'addr2': '(__u64)addrlen',
319	'accept_flags': 'flags'
320	}),
321	# CFA_HAVE_IORING_OP_CONNECT
322	Call('CONNECT', 'int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)', {
323	'fd': 'sockfd',
324	'addr': '(__u64)addr',
325	'off': 'addrlen'
326	}),
327	# CFA_HAVE_IORING_OP_FALLOCATE
328	Call('FALLOCATE', 'int fallocate(int fd, int mode, off_t offset, off_t len)', {
329	'fd': 'fd',
330	'addr': '(__u64)len',
331	'len': 'mode',
332	'off': 'offset'
333	}),
334	# CFA_HAVE_IORING_OP_FADVISE
335	Call('FADVISE', 'int posix_fadvise(int fd, off_t offset, off_t len, int advice)', {
336	'fd': 'fd',
337	'off': 'offset',
338	'len': 'len',
339	'fadvise_advice': 'advice'
340	}),
341	# CFA_HAVE_IORING_OP_MADVISE
342	Call('MADVISE', 'int madvise(void *addr, size_t length, int advice)', {
343	'addr': '(__u64)addr',
344	'len': 'length',
345	'fadvise_advice': 'advice'
346	}),
347	# CFA_HAVE_IORING_OP_OPENAT
348	Call('OPENAT', 'int openat(int dirfd, const char *pathname, int flags, mode_t mode)', {
349	'fd': 'dirfd',
350	'addr': '(__u64)pathname',
351	'len': 'mode',
352	'open_flags': 'flags;'
353	}),
354	# CFA_HAVE_IORING_OP_OPENAT2
355	Call('OPENAT2', 'int openat2(int dirfd, const char pathname, struct open_how how, size_t size)', {
356	'fd': 'dirfd',
357	'addr': 'pathname',
358	'len': 'sizeof(*how)',
359	'off': '(__u64)how',
360	}, define = 'CFA_HAVE_OPENAT2'),
361	# CFA_HAVE_IORING_OP_CLOSE
362	Call('CLOSE', 'int close(int fd)', {
363	'fd': 'fd'
364	}),
365	# CFA_HAVE_IORING_OP_STATX
366	Call('STATX', 'int statx(int dirfd, const char pathname, int flags, unsigned int mask, struct statx statxbuf)', {
367	'fd': 'dirfd',
368	'off': '(__u64)statxbuf',
369	'addr': 'pathname',
370	'len': 'mask',
371	'statx_flags': 'flags'
372	}, define = 'CFA_HAVE_STATX'),
373	# CFA_HAVE_IORING_OP_READ
374	Call('READ', 'ssize_t read(int fd, void * buf, size_t count)', {
375	'fd': 'fd',
376	'off': '0',
377	'addr': '(__u64)buf',
378	'len': 'count'
379	}),
380	# CFA_HAVE_IORING_OP_WRITE
381	Call('WRITE', 'ssize_t write(int fd, void * buf, size_t count)', {
382	'fd': 'fd',
383	'off': '0',
384	'addr': '(__u64)buf',
385	'len': 'count'
386	}),
387	# CFA_HAVE_IORING_OP_SPLICE
388	Call('SPLICE', 'ssize_t splice(int fd_in, loff_t off_in, int fd_out, loff_t off_out, size_t len, unsigned int flags)', {
389	'splice_fd_in': 'fd_in',
390	'splice_off_in': 'off_in ? (__u64)*off_in : (__u64)-1',
391	'fd': 'fd_out',
392	'off': 'off_out ? (__u64)*off_out : (__u64)-1',
393	'len': 'len',
394	'splice_flags': 'flags'
395	}),
396	# CFA_HAVE_IORING_OP_TEE
397	Call('TEE', 'ssize_t tee(int fd_in, int fd_out, size_t len, unsigned int flags)', {
398	'splice_fd_in': 'fd_in',
399	'fd': 'fd_out',
400	'len': 'len',
401	'splice_flags': 'flags'
402	})
403	]
404
405	print("//----------")
406	print("// synchronous calls")
407	for c in calls:
408	if c.define:
409	print("""#if defined({define})
410	{ret} cfa_{name}({params}, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
411	#endif""".format(define=c.define,ret=c.ret, name=c.name, params=c.params))
412	else:
413	print("{ret} cfa_{name}({params}, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);"
414	.format(ret=c.ret, name=c.name, params=c.params))
415
416	print("\n//----------")
417	print("// asynchronous calls")
418	for c in calls:
419	if c.define:
420	print("""#if defined({define})
421	void async_{name}(io_future_t & future, {params}, int submit_flags, io_cancellation * cancellation, io_context * context);
422	#endif""".format(define=c.define,name=c.name, params=c.params))
423	else:
424	print("void async_{name}(io_future_t & future, {params}, int submit_flags, io_cancellation * cancellation, io_context * context);"
425	.format(name=c.name, params=c.params))
426	print("\n")
427
428	for c in calls:
429	print("//-----------------------------------------------------------------------------")
430	print("// {}".format(c.name))
431	Async = AsyncTemplate.format(
432	name = c.name,
433	ret = c.ret,
434	params = c.params,
435	args = c.args(),
436	op = c.op,
437	body = c.body
438
439	)
440	Sync = SyncTemplate.format(
441	name = c.name,
442	ret = c.ret,
443	params = c.params,
444	args = c.args()
445	)
446
447	if c.define:
448	print("""#if defined({})
449	//----------
450	// asynchronous call
451	{}
452
453	//----------
454	// synchronous call
455	{}
456	#endif
457	""".format(c.define, "\n\t".join( Async.splitlines() ), "\n\t".join( Sync.splitlines() )))
458	else :
459	print("""//----------
460	// asynchronous call
461	{}
462
463	//----------
464	// synchronous call
465	{}
466	""".format(Async, Sync))
467
468	print("""
469	//-----------------------------------------------------------------------------
470	bool cancel(io_cancellation & this) {
471	#if !defined(CFA_HAVE_LINUX_IO_URING_H) \|\| !defined(CFA_HAVE_IORING_OP_ASYNC_CANCEL)
472	return false;
473	#else
474	io_future_t future;
475
476	io_context * context = __get_io_context();
477
478	__u8 sflags = 0;
479	struct __io_data & ring = *context->thrd.ring;
480
481	__u32 idx;
482	volatile struct io_uring_sqe * sqe;
483	[sqe, idx] = __submit_alloc( ring, (__u64)(uintptr_t)&future );
484
485	sqe->__pad2[0] = sqe->__pad2[1] = sqe->__pad2[2] = 0;
486	sqe->opcode = IORING_OP_ASYNC_CANCEL;
487	sqe->flags = sflags;
488	sqe->addr = this.target;
489
490	verify( sqe->user_data == (__u64)(uintptr_t)&future );
491	__submit( context, idx );
492
493	wait(future);
494
495	if( future.result == 0 ) return true; // Entry found
496	if( future.result == -EALREADY) return true; // Entry found but in progress
497	if( future.result == -ENOENT ) return false; // Entry not found
498	return false;
499	#endif
500	}
501
502	//-----------------------------------------------------------------------------
503	// Check if a function is has asynchronous
504	bool has_user_level_blocking( fptr_t func ) {
505	#if defined(CFA_HAVE_LINUX_IO_URING_H)""")
506
507	for c in calls:
508	if c.define:
509	print(""" #if defined({define})
510	if( /func == (fptr_t)preadv2 \|\| /
511	func == (fptr_t)cfa_{name} \|\|
512	func == (fptr_t)async_{name} ) {{
513	#if defined(CFA_HAVE_IORING_OP_{op})
514	return true;
515	#else
516	return false;
517	#endif
518	}}
519	#endif""".format(define=c.define, name=c.name, op=c.op))
520	else:
521	print(""" if( /func == (fptr_t)preadv2 \|\| /
522	func == (fptr_t)cfa_{name} \|\|
523	func == (fptr_t)async_{name} ) {{
524	#if defined(CFA_HAVE_IORING_OP_{op})
525	return true;
526	#else
527	return false;
528	#endif
529	}}""".format(name=c.name, op=c.op))
530
531	print(""" #endif
532
533	return false;
534	}""")

Note: See TracBrowser for help on using the repository browser.

Download in other formats: