Changeset 2489d31

Timestamp:

Apr 23, 2020, 4:21:49 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

ecf6b46

Parents:

8962722

Message:

Removed the async_ prefix of I/O functions

Files:

• benchmark/io/readv.cfa (modified) (2 diffs)
• examples/io/simple/server.cfa (modified) (5 diffs)
• libcfa/src/concurrency/io.cfa (modified) (20 diffs)

benchmark/io/readv.cfa

@@ -18 +18 @@
 
 extern bool traceHeapOn();
-extern ssize_t async_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
+extern ssize_t cfa_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags);
 
 int fd;
@@ -34 +34 @@
 
         while(__atomic_load_n(&run, __ATOMIC_RELAXED)) {
-                async_preadv2(fd, &iov, 1, 0, 0);
+                cfa_preadv2(fd, &iov, 1, 0, 0);
                 __atomic_fetch_add( &count, 1, __ATOMIC_SEQ_CST );
         }

examples/io/simple/server.cfa

@@ -51 +51 @@
 
 //----------
-extern ssize_t async_recvmsg(int sockfd, struct msghdr *msg, int flags);
-extern int async_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
-extern int async_close(int fd);
+extern ssize_t cfa_recvmsg(int sockfd, struct msghdr *msg, int flags);
+extern int cfa_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
+extern int cfa_close(int fd);
 
 //----------
@@ -88 +88 @@
         struct sockaddr_in cli_addr;
         __socklen_t clilen = sizeof(cli_addr);
-        int newsock = async_accept4(sock, (struct sockaddr *) &cli_addr, &clilen, 0);
+        int newsock = cfa_accept4(sock, (struct sockaddr *) &cli_addr, &clilen, 0);
         if (newsock < 0) {
                 error( printer, "accept", -newsock);
@@ -97 +97 @@
 
         while(1) {
-                int res = async_recvmsg(newsock, &msg, 0);
+                int res = cfa_recvmsg(newsock, &msg, 0);
                 if(res == 0) break;
                 if(res < 0) {
@@ -107 +107 @@
         }
 
-        ret = async_close(newsock);
+        ret = cfa_close(newsock);
       if(ret < 0) {
             error( printer, "close new", -ret);
@@ -113 +113 @@
       }
 
-        ret = async_close(sock);
+        ret = cfa_close(sock);
       if(ret < 0) {
             error( printer, "close old", -ret);

libcfa/src/concurrency/io.cfa

@@ -293 +293 @@
 //
 
-static inline [* struct io_uring_sqe, uint32_t] __submit_alloc( struct io_ring & ring ) {
-        // Wait for a spot to be available
-        P(ring.submit);
-
-        // Allocate the sqe
-        uint32_t idx = __atomic_fetch_add(&ring.submit_q.alloc, 1ul32, __ATOMIC_SEQ_CST);
-
-        // Validate that we didn't overflow anything
-        // Check that nothing overflowed
-        /* paranoid */ verify( true );
-
-        // Check that it goes head -> tail -> alloc and never head -> alloc -> tail
-        /* paranoid */ verify( true );
-
-        // Return the sqe
-        return [&ring.submit_q.sqes[ idx & (*ring.submit_q.mask)], idx];
-}
-
-static inline void __submit( struct io_ring & ring, uint32_t idx ) {
-        // get mutual exclusion
-        lock(ring.submit_q.lock __cfaabi_dbg_ctx2);
-
-        // Append to the list of ready entries
-        uint32_t * tail = ring.submit_q.tail;
-        const uint32_t mask = *ring.submit_q.mask;
-
-        ring.submit_q.array[ (*tail) & mask ] = idx & mask;
-        __atomic_fetch_add(tail, 1ul32, __ATOMIC_SEQ_CST);
-
-        // Submit however, many entries need to be submitted
-        int ret = syscall( __NR_io_uring_enter, ring.fd, 1, 0, 0, 0p, 0);
-        // __cfaabi_bits_print_safe( STDERR_FILENO, "Performed io_submit, returned %d\n", ret );
-        if( ret < 0 ) {
-                switch((int)errno) {
-                default:
-                        abort( "KERNEL ERROR: IO_URING SUBMIT - %s\n", strerror(errno) );
+        static inline [* struct io_uring_sqe, uint32_t] __submit_alloc( struct io_ring & ring ) {
+                // Wait for a spot to be available
+                P(ring.submit);
+
+                // Allocate the sqe
+                uint32_t idx = __atomic_fetch_add(&ring.submit_q.alloc, 1ul32, __ATOMIC_SEQ_CST);
+
+                // Validate that we didn't overflow anything
+                // Check that nothing overflowed
+                /* paranoid */ verify( true );
+
+                // Check that it goes head -> tail -> alloc and never head -> alloc -> tail
+                /* paranoid */ verify( true );
+
+                // Return the sqe
+                return [&ring.submit_q.sqes[ idx & (*ring.submit_q.mask)], idx];
+        }
+
+        static inline void __submit( struct io_ring & ring, uint32_t idx ) {
+                // get mutual exclusion
+                lock(ring.submit_q.lock __cfaabi_dbg_ctx2);
+
+                // Append to the list of ready entries
+                uint32_t * tail = ring.submit_q.tail;
+                const uint32_t mask = *ring.submit_q.mask;
+
+                ring.submit_q.array[ (*tail) & mask ] = idx & mask;
+                __atomic_fetch_add(tail, 1ul32, __ATOMIC_SEQ_CST);
+
+                // Submit however, many entries need to be submitted
+                int ret = syscall( __NR_io_uring_enter, ring.fd, 1, 0, 0, 0p, 0);
+                // __cfaabi_bits_print_safe( STDERR_FILENO, "Performed io_submit, returned %d\n", ret );
+                if( ret < 0 ) {
+                        switch((int)errno) {
+                        default:
+                                abort( "KERNEL ERROR: IO_URING SUBMIT - %s\n", strerror(errno) );
+                        }
                 }
-        }
-
-        unlock(ring.submit_q.lock);
-        // Make sure that idx was submitted
-        // Be careful to not get false positive if we cycled the entire list or that someone else submitted for us
-}
-
-static inline void ?{}(struct io_uring_sqe & this, uint8_t opcode, int fd) {
-        this.opcode = opcode;
-        #if !defined(IOSQE_ASYNC)
-                this.flags = 0;
-        #else
-                this.flags = IOSQE_ASYNC;
-        #endif
-        this.ioprio = 0;
-        this.fd = fd;
-        this.off = 0;
-        this.addr = 0;
-        this.len = 0;
-        this.rw_flags = 0;
-        this.__pad2[0] = this.__pad2[1] = this.__pad2[2] = 0;
-}
-
-static inline void ?{}(struct io_uring_sqe & this, uint8_t opcode, int fd, void * addr, uint32_t len, uint64_t off ) {
-        (this){ opcode, fd };
-        this.off = off;
-        this.addr = (uint64_t)addr;
-        this.len = len;
-}
+
+                unlock(ring.submit_q.lock);
+                // Make sure that idx was submitted
+                // Be careful to not get false positive if we cycled the entire list or that someone else submitted for us
+        }
+
+        static inline void ?{}(struct io_uring_sqe & this, uint8_t opcode, int fd) {
+                this.opcode = opcode;
+                #if !defined(IOSQE_ASYNC)
+                        this.flags = 0;
+                #else
+                        this.flags = IOSQE_ASYNC;
+                #endif
+                this.ioprio = 0;
+                this.fd = fd;
+                this.off = 0;
+                this.addr = 0;
+                this.len = 0;
+                this.rw_flags = 0;
+                this.__pad2[0] = this.__pad2[1] = this.__pad2[2] = 0;
+        }
+
+        static inline void ?{}(struct io_uring_sqe & this, uint8_t opcode, int fd, void * addr, uint32_t len, uint64_t off ) {
+                (this){ opcode, fd };
+                this.off = off;
+                this.addr = (uint64_t)addr;
+                this.len = len;
+        }
 
 //=============================================================================================
@@ -388 +388 @@
 //-----------------------------------------------------------------------------
 // Asynchronous operations
-        ssize_t async_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags) {
+        ssize_t cfa_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags) {
                 #if !defined(IORING_OP_READV)
                         return preadv2(fd, iov, iovcnt, offset, flags);
@@ -400 +400 @@
         }
 
-        ssize_t async_pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags) {
+        ssize_t cfa_pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags) {
                 #if !defined(IORING_OP_WRITEV)
                         return pwritev2(fd, iov, iovcnt, offset, flags);
@@ -412 +412 @@
         }
 
-        int async_fsync(int fd) {
+        int cfa_fsync(int fd) {
                 #if !defined(IORING_OP_FSYNC)
                         return fsync(fd);
@@ -424 +424 @@
         }
 
-        int async_sync_file_range(int fd, int64_t offset, int64_t nbytes, unsigned int flags) {
+        int cfa_sync_file_range(int fd, int64_t offset, int64_t nbytes, unsigned int flags) {
                 #if !defined(IORING_OP_SYNC_FILE_RANGE)
                         return sync_file_range(fd, offset, nbytes, flags);
@@ -440 +440 @@
 
 
-        ssize_t async_sendmsg(int sockfd, const struct msghdr *msg, int flags) {
+        ssize_t cfa_sendmsg(int sockfd, const struct msghdr *msg, int flags) {
                 #if !defined(IORING_OP_SENDMSG)
                         return recv(sockfd, msg, flags);
@@ -453 +453 @@
         }
 
-        ssize_t async_recvmsg(int sockfd, struct msghdr *msg, int flags) {
+        ssize_t cfa_recvmsg(int sockfd, struct msghdr *msg, int flags) {
                 #if !defined(IORING_OP_RECVMSG)
                         return recv(sockfd, msg, flags);
@@ -466 +466 @@
         }
 
-        ssize_t async_send(int sockfd, const void *buf, size_t len, int flags) {
+        ssize_t cfa_send(int sockfd, const void *buf, size_t len, int flags) {
                 #if !defined(IORING_OP_SEND)
                         return send( sockfd, buf, len, flags );
@@ -481 +481 @@
         }
 
-        ssize_t async_recv(int sockfd, void *buf, size_t len, int flags) {
+        ssize_t cfa_recv(int sockfd, void *buf, size_t len, int flags) {
                 #if !defined(IORING_OP_RECV)
                         return recv( sockfd, buf, len, flags );
@@ -496 +496 @@
         }
 
-        int async_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags) {
+        int cfa_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags) {
                 #if !defined(IORING_OP_ACCEPT)
                         __SOCKADDR_ARG _addr;
@@ -513 +513 @@
         }
 
-        int async_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
+        int cfa_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
                 #if !defined(IORING_OP_CONNECT)
                         __CONST_SOCKADDR_ARG _addr;
@@ -529 +529 @@
         }
 
-        int async_fallocate(int fd, int mode, uint64_t offset, uint64_t len) {
+        int cfa_fallocate(int fd, int mode, uint64_t offset, uint64_t len) {
                 #if !defined(IORING_OP_FALLOCATE)
                         return fallocate( fd, mode, offset, len );
@@ -544 +544 @@
         }
 
-        int async_fadvise(int fd, uint64_t offset, uint64_t len, int advice) {
+        int cfa_fadvise(int fd, uint64_t offset, uint64_t len, int advice) {
                 #if !defined(IORING_OP_FADVISE)
                         return posix_fadvise( fd, offset, len, advice );
@@ -559 +559 @@
         }
 
-        int async_madvise(void *addr, size_t length, int advice) {
+        int cfa_madvise(void *addr, size_t length, int advice) {
                 #if !defined(IORING_OP_MADVISE)
                         return madvise( addr, length, advice );
@@ -574 +574 @@
         }
 
-        int async_openat(int dirfd, const char *pathname, int flags, mode_t mode) {
+        int cfa_openat(int dirfd, const char *pathname, int flags, mode_t mode) {
                 #if !defined(IORING_OP_OPENAT)
                         return openat( dirfd, pathname, flags, mode );
@@ -589 +589 @@
         }
 
-        int async_close(int fd) {
+        int cfa_close(int fd) {
                 #if !defined(IORING_OP_CLOSE)
                         return close( fd );
@@ -601 +601 @@
         }
 
-        int async_statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf) {
+        int cfa_statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf) {
                 #if !defined(IORING_OP_STATX)
                         //return statx( dirfd, pathname, flags, mask, statxbuf );
@@ -619 +619 @@
 
 
-        ssize_t async_read(int fd, void *buf, size_t count) {
+        ssize_t cfa_read(int fd, void *buf, size_t count) {
                 #if !defined(IORING_OP_READ)
                         return read( fd, buf, count );
@@ -631 +631 @@
         }
 
-        ssize_t async_write(int fd, void *buf, size_t count) {
+        ssize_t cfa_write(int fd, void *buf, size_t count) {
                 #if !defined(IORING_OP_WRITE)
                         return read( fd, buf, count );
@@ -655 +655 @@
 
                 if( /*func == (fptr_t)preadv2 || */
-                        func == (fptr_t)async_preadv2 )
+                        func == (fptr_t)cfa_preadv2 )
                         #define _CFA_IO_FEATURE_IORING_OP_READV ,
                         return IS_DEFINED(IORING_OP_READV);
 
                 if( /*func == (fptr_t)pwritev2 || */
-                      func == (fptr_t)async_pwritev2 )
+                      func == (fptr_t)cfa_pwritev2 )
                         #define _CFA_IO_FEATURE_IORING_OP_WRITEV ,
                         return IS_DEFINED(IORING_OP_WRITEV);
 
                 if( /*func == (fptr_t)fsync || */
-                      func == (fptr_t)async_fsync )
+                      func == (fptr_t)cfa_fsync )
                         #define _CFA_IO_FEATURE_IORING_OP_FSYNC ,
                         return IS_DEFINED(IORING_OP_FSYNC);
 
                 if( /*func == (fptr_t)ync_file_range || */
-                      func == (fptr_t)async_sync_file_range )
+                      func == (fptr_t)cfa_sync_file_range )
                         #define _CFA_IO_FEATURE_IORING_OP_SYNC_FILE_RANGE ,
                         return IS_DEFINED(IORING_OP_SYNC_FILE_RANGE);
 
                 if( /*func == (fptr_t)sendmsg || */
-                      func == (fptr_t)async_sendmsg )
+                      func == (fptr_t)cfa_sendmsg )
                         #define _CFA_IO_FEATURE_IORING_OP_SENDMSG ,
                         return IS_DEFINED(IORING_OP_SENDMSG);
 
                 if( /*func == (fptr_t)recvmsg || */
-                      func == (fptr_t)async_recvmsg )
+                      func == (fptr_t)cfa_recvmsg )
                         #define _CFA_IO_FEATURE_IORING_OP_RECVMSG ,
                         return IS_DEFINED(IORING_OP_RECVMSG);
 
                 if( /*func == (fptr_t)send || */
-                        func == (fptr_t)async_send )
+                        func == (fptr_t)cfa_send )
                         #define _CFA_IO_FEATURE_IORING_OP_SEND ,
                         return IS_DEFINED(IORING_OP_SEND);
 
                 if( /*func == (fptr_t)recv || */
-                        func == (fptr_t)async_recv )
+                        func == (fptr_t)cfa_recv )
                         #define _CFA_IO_FEATURE_IORING_OP_RECV ,
                         return IS_DEFINED(IORING_OP_RECV);
 
                 if( /*func == (fptr_t)accept4 || */
-                        func == (fptr_t)async_accept4 )
+                        func == (fptr_t)cfa_accept4 )
                         #define _CFA_IO_FEATURE_IORING_OP_ACCEPT ,
                         return IS_DEFINED(IORING_OP_ACCEPT);
 
                 if( /*func == (fptr_t)connect || */
-                        func == (fptr_t)async_connect )
+                        func == (fptr_t)cfa_connect )
                         #define _CFA_IO_FEATURE_IORING_OP_CONNECT ,
                         return IS_DEFINED(IORING_OP_CONNECT);
 
                 if( /*func == (fptr_t)fallocate || */
-                        func == (fptr_t)async_fallocate )
+                        func == (fptr_t)cfa_fallocate )
                         #define _CFA_IO_FEATURE_IORING_OP_FALLOCATE ,
                         return IS_DEFINED(IORING_OP_FALLOCATE);
 
                 if( /*func == (fptr_t)fadvise || */
-                        func == (fptr_t)async_fadvise )
+                        func == (fptr_t)cfa_fadvise )
                         #define _CFA_IO_FEATURE_IORING_OP_FADVISE ,
                         return IS_DEFINED(IORING_OP_FADVISE);
 
                 if( /*func == (fptr_t)madvise || */
-                        func == (fptr_t)async_madvise )
+                        func == (fptr_t)cfa_madvise )
                         #define _CFA_IO_FEATURE_IORING_OP_MADVISE ,
                         return IS_DEFINED(IORING_OP_MADVISE);
 
                 if( /*func == (fptr_t)openat || */
-                        func == (fptr_t)async_openat )
+                        func == (fptr_t)cfa_openat )
                         #define _CFA_IO_FEATURE_IORING_OP_OPENAT ,
                         return IS_DEFINED(IORING_OP_OPENAT);
 
                 if( /*func == (fptr_t)close || */
-                        func == (fptr_t)async_close )
+                        func == (fptr_t)cfa_close )
                         #define _CFA_IO_FEATURE_IORING_OP_CLOSE ,
                         return IS_DEFINED(IORING_OP_CLOSE);
 
                 if( /*func == (fptr_t)statx || */
-                        func == (fptr_t)async_statx )
+                        func == (fptr_t)cfa_statx )
                         #define _CFA_IO_FEATURE_IORING_OP_STATX ,
                         return IS_DEFINED(IORING_OP_STATX);
 
                 if( /*func == (fptr_t)read || */
-                      func == (fptr_t)async_read )
+                      func == (fptr_t)cfa_read )
                         #define _CFA_IO_FEATURE_IORING_OP_READ ,
                         return IS_DEFINED(IORING_OP_READ);
 
                 if( /*func == (fptr_t)write || */
-                      func == (fptr_t)async_write )
+                      func == (fptr_t)cfa_write )
                         #define _CFA_IO_FEATURE_IORING_OP_WRITE ,
                         return IS_DEFINED(IORING_OP_WRITE);