Changes in / [6a33e40:d3261710]

Files:

• benchmark/io/http/Makefile.am (modified) (1 diff)
• benchmark/io/http/main.cfa (modified) (4 diffs)
• libcfa/src/concurrency/kernel_private.hfa (modified) (1 diff)
• libcfa/src/concurrency/ready_queue.cfa (modified) (2 diffs)

benchmark/io/http/Makefile.am

@@ -21 +21 @@
 include $(top_srcdir)/tools/build/cfa.make
 
-AM_CFLAGS = -O2 -Wall -Wextra -I$(srcdir) -lrt -pthread # -Werror
+AM_CFLAGS = -O3 -Wall -Wextra -I$(srcdir) -lrt -pthread # -Werror
 AM_CFAFLAGS = -quiet -nodebug
 AM_LDFLAGS = -quiet -nodebug

benchmark/io/http/main.cfa

@@ -1 @@
-#define __USE_GNU
+#define _GNU_SOURCE
 
 #include <errno.h>
@@ -6 +6 @@
 #include <unistd.h>
 extern "C" {
+        #include <sched.h>
         #include <signal.h>
         #include <sys/socket.h>
@@ -67 +68 @@
         (this.self){ "Server Cluster", options.clopts.params };
 
+        cpu_set_t fullset;
+        CPU_ZERO(&fullset);
+        int ret = sched_getaffinity(getpid(), sizeof(fullset), &fullset);
+        if( ret != 0 ) abort | "sched_getaffinity failed with" | errno | strerror( errno );
+        int cnt = CPU_COUNT(&fullset);
+
         this.procs = alloc(options.clopts.nprocs);
         for(i; options.clopts.nprocs) {
                 (this.procs[i]){ "Benchmark Processor", this.self };
+
+                int c = 0;
+                int n = 1 + (i % cnt);
+                for(int j = 0; j < CPU_SETSIZE; j++) {
+                        if(CPU_ISSET(j, &fullset)) n--;
+                        if(n == 0) {
+                                c = j;
+                                break;
+                        }
+                }
+                cpu_set_t localset;
+                CPU_ZERO(&localset);
+                CPU_SET(c, &localset);
+                ret = pthread_setaffinity_np(this.procs[i].kernel_thread, sizeof(localset), &localset);
+                if( ret != 0 ) abort | "sched_getaffinity failed with" | ret | strerror( ret );
 
                 #if !defined(__CFA_NO_STATISTICS__)
@@ -146 +168 @@
         int waited = 0;
         for() {
-                ret = bind( server_fd, (struct sockaddr *)&address, sizeof(address) );
+                int sockfd = server_fd;
+                __CONST_SOCKADDR_ARG addr;
+                addr.__sockaddr__ = (struct sockaddr *)&address;
+                socklen_t addrlen = sizeof(address);
+                ret = bind( sockfd, addr, addrlen );
                 if(ret < 0) {
                         if(errno == EADDRINUSE) {

libcfa/src/concurrency/kernel_private.hfa

@@ -219 +219 @@
 
         // Step 2 : acquire our local lock
+        /*paranoid*/ verify(!kernelTLS().sched_lock);
         __atomic_acquire( &kernelTLS().sched_lock );
         /*paranoid*/ verify(kernelTLS().sched_lock);

libcfa/src/concurrency/ready_queue.cfa

@@ -201 +201 @@
 uint_fast32_t ready_mutate_lock( void ) with(*__scheduler_lock) {
         /* paranoid */ verify( ! __preemption_enabled() );
-        /* paranoid */ verify( ! kernelTLS().sched_lock );
 
         // Step 1 : lock global lock
@@ -207 +206 @@
         //   to simply lock their own lock and enter.
         __atomic_acquire( &write_lock );
+
+        // Make sure we won't deadlock ourself
+        // Checking before acquiring the writer lock isn't safe
+        // because someone else could have locked us.
+        /* paranoid */ verify( ! kernelTLS().sched_lock );
 
         // Step 2 : lock per-proc lock