天泣記

IP_PKTINFO を試してみたい。

のだが、こいつを試すには recvmesg を使う必要があり、ruby では使えないので面倒くさい。

さて、C で直接書くか、Ruby に sendmsg/recvmesg を実装するか。

後者でやってみよう... やってみた。

で、試してみた。

% ./ruby -rsocket -rpp -e '
u = UDPSocket.new
u.setsockopt(Socket::IPPROTO_IP, Socket::IP_PKTINFO, 1)
u.bind("0.0.0.0", 2222)

v = UDPSocket.new
v.send("foo", 0, "127.0.0.1", 2222)
pp x = u.recvmsg
p Socket.unpack_sockaddr_in(x.last)
puts

v.send("bar", 0, "192.168.0.128", 2222)
pp x = u.recvmsg
p Socket.unpack_sockaddr_in(x.last)
puts
'
["foo",
 [[0, 8, "\x01\x00\x00\x00\x7F\x00\x00\x01\x7F\x00\x00\x01"]],
 0,
 "\x02\x00\x8E\xBE\x7F\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"]
[36542, "127.0.0.1"]

["bar",
 [[0, 8, "\x01\x00\x00\x00\xC0\xA8\x00\x80\xC0\xA8\x00\x80"]],
 0,
 "\x02\x00\x8E\xBE\xC0\xA8\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00"]
[36542, "192.168.0.128"]

補助データの level, type の 0, 8 というのは IPPROTO_IP, IP_PKTINFO である。

で、中身の "\x01\x00\x00\x00\x7F\x00\x00\x01\x7F\x00\x00\x01" の中の、\x7F\x00\x00\x01 が 127.0.0.1 で宛先を意味している、のだろう。ふたつあるのだが、どういう違いがあるのかはよくわからない。(マニュアル ip(7) に書いてあるのだが読んでもいまひとつよくわからない)

とりあえずの実装:

% svn diff --diff-cmd diff -x '-u -p'
Index: ext/socket/mkconstants.rb
===================================================================
--- ext/socket/mkconstants.rb   (revision 21217)
+++ ext/socket/mkconstants.rb   (working copy)
@@ -191,6 +191,36 @@ IP_DROP_MEMBERSHIP
 IP_DEFAULT_MULTICAST_TTL
 IP_DEFAULT_MULTICAST_LOOP
 IP_MAX_MEMBERSHIPS
+IP_ROUTER_ALERT
+IP_PKTINFO
+IP_PKTOPTIONS
+IP_MTU_DISCOVER
+IP_RECVERR
+IP_RECVTTL
+IP_RECVTOS
+IP_MTU
+IP_FREEBIND
+IP_IPSEC_POLICY
+IP_XFRM_POLICY
+IP_PASSSEC
+IP_PMTUDISC_DONT
+IP_PMTUDISC_WANT
+IP_PMTUDISC_DO
+IP_UNBLOCK_SOURCE
+IP_BLOCK_SOURCE
+IP_ADD_SOURCE_MEMBERSHIP
+IP_DROP_SOURCE_MEMBERSHIP
+IP_MSFILTER
+
+MCAST_JOIN_GROUP
+MCAST_BLOCK_SOURCE
+MCAST_UNBLOCK_SOURCE
+MCAST_LEAVE_GROUP
+MCAST_JOIN_SOURCE_GROUP
+MCAST_LEAVE_SOURCE_GROUP
+MCAST_MSFILTER
+MCAST_EXCLUDE
+MCAST_INCLUDE

 SO_DEBUG
 SO_REUSEADDR
@@ -308,3 +338,6 @@ IPV6_USE_MIN_MTU

 INET_ADDRSTRLEN
 INET6_ADDRSTRLEN
+
+SCM_RIGHTS
+SCM_CREDENTIALS
Index: ext/socket/socket.c
===================================================================
--- ext/socket/socket.c (revision 21217)
+++ ext/socket/socket.c (working copy)
@@ -789,6 +789,390 @@ bsock_recv_nonblock(int argc, VALUE *arg
     return s_recvfrom_nonblock(sock, argc, argv, RECV_RECV);
 }

+#if defined(HAVE_SENDMSG) && defined(HAVE_ST_MSG_CONTROL)
+struct sendmsg_args_struct {
+    int fd;
+    const struct msghdr *msg;
+    int flags;
+};
+
+static VALUE
+internal_sendmsg_func(void *ptr)
+{
+    struct sendmsg_args_struct *args = ptr;
+    return sendmsg(args->fd, args->msg, args->flags);
+}
+
+static ssize_t
+rb_sendmsg(int fd, const struct msghdr *msg, int flags)
+{
+    struct sendmsg_args_struct args;
+    args.fd = fd;
+    args.msg = msg;
+    args.flags = flags;
+    return rb_thread_blocking_region(internal_sendmsg_func, &args, RUBY_UBF_IO, 0);
+}
+
+static VALUE
+bsock_sendmsg_internal(int argc, VALUE *argv, VALUE sock, int nonblock)
+{
+    rb_io_t *fptr;
+    VALUE data, controls, vflags, dest_sockaddr;
+    struct msghdr mh;
+    struct iovec iov;
+    long i;
+    volatile VALUE controls_str = 0;
+    int flags;
+    ssize_t ss;
+
+    rb_secure(4);
+
+    rb_scan_args(argc, argv, "13", &data, &controls, &vflags, &dest_sockaddr);
+
+    StringValue(data);
+
+    if (!NIL_P(controls)) {
+        controls_str = rb_str_tmp_new(0);
+        controls = rb_convert_type(controls, T_ARRAY, "Array", "to_ary");
+        for (i = 0; i < RARRAY_LEN(controls); i++) {
+            VALUE elt = RARRAY_PTR(controls)[i];
+            int level, type;
+            VALUE cdata;
+            long oldlen;
+            struct cmsghdr *cmh;
+            size_t cspace;
+            elt = rb_convert_type(elt, T_ARRAY, "Array", "to_ary");
+            if (RARRAY_LEN(elt) != 3)
+                rb_raise(rb_eArgError, "an element of controls should be 3-elements array");
+            level = NUM2INT(rb_ary_entry(elt, 0));
+            type = NUM2INT(rb_ary_entry(elt, 1));
+            cdata = rb_ary_entry(elt, 2);
+            StringValue(cdata);
+            oldlen = RSTRING_LEN(controls_str);
+            cspace = CMSG_SPACE(RSTRING_LEN(cdata));
+            rb_str_resize(controls_str, oldlen + cspace);
+            cmh = (struct cmsghdr *)(RSTRING_PTR(controls_str)+oldlen);
+            memset((char *)cmh, 0, cspace);
+            cmh->cmsg_level = level;
+            cmh->cmsg_type = type;
+            cmh->cmsg_len = CMSG_DATA(cmh) + RSTRING_LEN(cdata) - (unsigned char *)cmh;
+            MEMCPY(CMSG_DATA(cmh), RSTRING_PTR(cdata), char, RSTRING_LEN(cdata));
+        }
+    }
+
+    flags = NIL_P(vflags) ? 0 : NUM2INT(vflags);
+
+    if (!NIL_P(dest_sockaddr))
+        StringValue(dest_sockaddr);
+
+    GetOpenFile(sock, fptr);
+
+  retry:
+    memset(&mh, 0, sizeof(mh));
+    mh.msg_iovlen = 1;
+    mh.msg_iov = &iov;
+    iov.iov_base = RSTRING_PTR(data);
+    iov.iov_len = RSTRING_LEN(data);
+    if (controls_str) {
+        mh.msg_control = RSTRING_PTR(controls_str);
+        mh.msg_controllen = RSTRING_LEN(controls_str);
+    }
+    else {
+        mh.msg_control = NULL;
+        mh.msg_controllen = 0;
+    }
+
+    if (nonblock)
+        rb_io_set_nonblock(fptr);
+
+    ss = rb_sendmsg(fptr->fd, &mh, flags);
+
+    if (!nonblock && rb_io_wait_writable(fptr->fd)) {
+        rb_io_check_closed(fptr);
+        goto retry;
+    }
+
+    if (ss == -1)
+       rb_sys_fail("sendmsg(2)");
+
+    return SSIZET2NUM(ss);
+}
+#else
+static VALUE
+bsock_sendmsg_internal(int argc, VALUE *argv, VALUE sock, int nonblock)
+{
+    rb_notimplement();
+}
+#endif
+
+/*
+ * call-seq:
+ *    basicsocket.sendmsg(str, controls=nil, flags=0, dest_sockaddr=nil) => sent_len
+ *
+ * sendmsg sends a message using sendmsg(2) system call in blocking manner.
+ *
+ * str is data to send.
+ *
+ * controls is ancillary data which is an array of 3-elements arrays such as:
+ *
+ *   controls = [[Socket::SOL_SOCKET, Socket::SCM_RIGHTS, [io.fileno].pack("i!")]]
+ *
+ * flags is bitwise OR of MSG_* constants such as Socket::MSG_OOB.
+ *
+ * dest_sockaddr is a destination socket address for connection-less socket.
+ * It should be a sockaddr such as a result of Socket.sockaddr_in.
+ *
+ * The return value, sent_len, is an integer which is the number of bytes sent.
+ *
+ * sendmsg can be used to implement send_io as follows:
+ *
+ *   sock.sendmsg("\0", [[Socket::SOL_SOCKET, Socket::SCM_RIGHTS, [io.fileno].pack("i!")]])
+ *
+ */
+static VALUE
+bsock_sendmsg(int argc, VALUE *argv, VALUE sock)
+{
+    return bsock_sendmsg_internal(argc, argv, sock, 0);
+}
+
+/*
+ * call-seq:
+ *    basicsocket.sendmsg_nonblock(str, controls=nil, flags=0, dest_sockaddr=nil) => sent_len
+ *
+ * sendmsg sends a message using sendmsg(2) system call in non-blocking manner.
+ *
+ * It is similar to BasicSocket#sendmsg
+ * but non-blocking flag is set before the system call
+ * and it doesn't retry the system call.
+ *
+ */
+static VALUE
+bsock_sendmsg_nonblock(int argc, VALUE *argv, VALUE sock)
+{
+    return bsock_sendmsg_internal(argc, argv, sock, 1);
+}
+
+#if defined(HAVE_RECVMSG) && defined(HAVE_ST_MSG_CONTROL)
+struct recvmsg_args_struct {
+    int fd;
+    struct msghdr *msg;
+    int flags;
+};
+
+static VALUE
+internal_recvmsg_func(void *ptr)
+{
+    struct recvmsg_args_struct *args = ptr;
+    return recvmsg(args->fd, args->msg, args->flags);
+}
+
+static ssize_t
+rb_recvmsg(int fd, struct msghdr *msg, int flags)
+{
+    struct recvmsg_args_struct args;
+    args.fd = fd;
+    args.msg = msg;
+    args.flags = flags;
+    return rb_thread_blocking_region(internal_recvmsg_func, &args, RUBY_UBF_IO, 0);
+}
+
+static VALUE
+bsock_recvmsg_internal(int argc, VALUE *argv, VALUE sock, int nonblock)
+{
+    rb_io_t *fptr;
+    VALUE vmaxdatlen, vmaxctllen, vflags;
+    int grow_buffer;
+    size_t maxdatlen, maxctllen;
+    int flags, orig_flags;
+    struct msghdr mh;
+    struct iovec iov;
+    struct cmsghdr *cmh;
+    char namebuf[1024];
+    char datbuf0[4096], *datbuf;
+    char ctlbuf0[4096], *ctlbuf;
+    VALUE dat_str = Qnil;
+    VALUE ctl_str = Qnil;
+    VALUE controls;
+    ssize_t ss;
+
+    rb_secure(4);
+
+    rb_scan_args(argc, argv, "03", &vmaxdatlen, &vmaxctllen, &vflags);
+
+    maxdatlen = NIL_P(vmaxdatlen) ? sizeof(datbuf0) : NUM2SIZET(vmaxdatlen);
+    maxctllen = NIL_P(vmaxctllen) ? sizeof(ctlbuf0) : NUM2SIZET(vmaxctllen);
+    orig_flags = flags = NIL_P(vflags) ? 0 : NUM2INT(vflags);
+
+    grow_buffer = NIL_P(vmaxdatlen) || NIL_P(vmaxctllen);
+
+    GetOpenFile(sock, fptr);
+
+  retry:
+    if (maxdatlen <= sizeof(datbuf0))
+        datbuf = datbuf0;
+    else {
+        if (NIL_P(dat_str))
+            dat_str = rb_str_tmp_new(maxdatlen);
+        else
+            rb_str_resize(dat_str, maxdatlen);
+        datbuf = RSTRING_PTR(dat_str);
+    }
+
+    if (maxctllen <= sizeof(ctlbuf0))
+        ctlbuf = ctlbuf0;
+    else {
+        if (NIL_P(ctl_str))
+            ctl_str = rb_str_tmp_new(maxctllen);
+        else
+            rb_str_resize(ctl_str, maxctllen);
+        ctlbuf = RSTRING_PTR(ctl_str);
+    }
+
+    memset(&mh, 0, sizeof(mh));
+
+    memset(namebuf, 0, sizeof(namebuf));
+    mh.msg_name = namebuf;
+    mh.msg_namelen = sizeof(namebuf);
+
+    mh.msg_iov = &iov;
+    mh.msg_iovlen = 1;
+    iov.iov_base = datbuf;
+    iov.iov_len = maxdatlen;
+
+    mh.msg_control = ctlbuf;
+    mh.msg_controllen = maxctllen;
+
+    if (grow_buffer)
+        flags |= MSG_PEEK;
+
+    if (nonblock)
+        rb_io_set_nonblock(fptr);
+
+    ss = rb_recvmsg(fptr->fd, &mh, flags);
+
+    if (!nonblock && rb_io_wait_readable(fptr->fd)) {
+        rb_io_check_closed(fptr);
+        goto retry;
+    }
+
+    if (grow_buffer) {
+        if ((NIL_P(vmaxdatlen) && (mh.msg_flags & MSG_TRUNC)) ||
+            (NIL_P(vmaxctllen) && (mh.msg_flags & MSG_CTRUNC))) {
+            if (NIL_P(vmaxdatlen) && (mh.msg_flags & MSG_TRUNC))
+                maxdatlen *= 2;
+            if (NIL_P(vmaxctllen) && (mh.msg_flags & MSG_CTRUNC))
+                maxctllen *= 2;
+            goto retry;
+        }
+        else {
+            grow_buffer = 0;
+            if (flags != orig_flags) {
+                flags = orig_flags;
+                goto retry;
+            }
+        }
+    }
+
+    if (ss == -1)
+       rb_sys_fail("recvmsg(2)");
+
+    controls = rb_ary_new();
+    for (cmh = CMSG_FIRSTHDR(&mh); cmh != NULL; cmh = CMSG_NXTHDR(&mh, cmh)) {
+        VALUE ctl;
+        size_t clen = (char*)cmh + cmh->cmsg_len - (char*)CMSG_DATA(cmh);
+        ctl = rb_ary_new3(3, INT2NUM(cmh->cmsg_level),
+                             INT2NUM(cmh->cmsg_type), 
+                             rb_str_new((char*)CMSG_DATA(cmh), clen));
+        rb_ary_push(controls, ctl);
+    }
+
+    if (NIL_P(dat_str))
+        dat_str = rb_str_new(datbuf, ss);
+    else {
+        rb_str_resize(dat_str, ss);
+        RBASIC(dat_str)->klass = rb_cString;
+    }
+
+    return rb_ary_new3(4, dat_str,
+                          controls,
+                          INT2NUM(mh.msg_flags),
+                          rb_str_new(mh.msg_name, mh.msg_namelen));
+}
+#else
+static VALUE
+bsock_recvmsg_internal(int argc, VALUE *argv, VALUE sock, int nonblock)
+{
+    rb_notimplement();
+}
+#endif
+
+/*
+ * call-seq:
+ *    basicsocket.recvmsg(maxdatalen=nil, maxcontrollen=nil, flags=0) => [data, controls, rflags, sender_sockaddr]
+ *
+ * recvmsg receives a message using recvmsg(2) system call in blocking manner.
+ *
+ * maxdatalen is the maximum length of data to receive.
+ *
+ * maxcontrolslen is the maximum length of controls (ancillary data) to receive.
+ *
+ * flags is bitwise OR of MSG_* constants such as Socket::MSG_PEEK.
+ *
+ * The return value is 4-elements array.
+ *
+ * data is a string.
+ *
+ * controls is ancillary data which is an array of 3-elements arrays such as:
+ *
+ *   [[1, 1, "\a\x00\x00\x00"]]
+ *   # Socket::SOL_SOCKET = 1
+ *   # Socket::SCM_RIGHTS = 1
+ *   # "\a\x00\x00\x00".unpack("i!") = 7
+ *
+ * rflags is a flags on received message which is bitwise OR of MSG_* constants such as Socket::MSG_TRUNC.
+ *
+ * sender_sockaddr is a sender socket address for connection-less socket.
+ * It is a sockaddr such as a result of Socket.sockaddr_in.
+ * For connection-oriented socket, sender_sockaddr is unspecified.
+ *
+ * maxdatalen and maxcontrolslen can be nil.
+ * In that case, the buffer will be grown until the message is not truncated.
+ * Internally, MSG_PEEK is used and MSG_TRUNC/MSG_CTRUNC are checked.
+ *
+ * sendmsg can be used to implement recv_io as follows:
+ *
+ *   data, controls, rflags, sender_sockaddr = sock.recvmsg
+ *   controls.each {|level, type, cdata|
+ *     if level == Socket::SOL_SOCKET && Socket::SCM_RIGHTS
+ *       fd = cdata.unpack("i!")
+ *       return IO.new(fd)
+ *     end
+ *   }
+ *
+ */
+static VALUE
+bsock_recvmsg(int argc, VALUE *argv, VALUE sock)
+{
+    return bsock_recvmsg_internal(argc, argv, sock, 0);
+}
+
+/*
+ * call-seq:
+ *    basicsocket.recvmsg_nonblock(maxdatalen=nil, maxcontrollen=nil, flags=0) => [data, controls, rflags, sender_sockaddr]
+ *
+ * recvmsg receives a message using recvmsg(2) system call in non-blocking manner.
+ *
+ * It is similar to BasicSocket#recvmsg
+ * but non-blocking flag is set before the system call
+ * and it doesn't retry the system call.
+ *
+ */
+static VALUE
+bsock_recvmsg_nonblock(int argc, VALUE *argv, VALUE sock)
+{
+    return bsock_recvmsg_internal(argc, argv, sock, 1);
+}
+
 static VALUE
 bsock_do_not_rev_lookup(void)
 {
@@ -3646,6 +4030,11 @@ Init_socket()
     rb_define_method(rb_cBasicSocket, "do_not_reverse_lookup", bsock_do_not_reverse_lookup, 0);
     rb_define_method(rb_cBasicSocket, "do_not_reverse_lookup=", bsock_do_not_reverse_lookup_set, 1);

+    rb_define_method(rb_cBasicSocket, "sendmsg", bsock_sendmsg, -1);
+    rb_define_method(rb_cBasicSocket, "sendmsg_nonblock", bsock_sendmsg_nonblock, -1);
+    rb_define_method(rb_cBasicSocket, "recvmsg", bsock_recvmsg, -1);
+    rb_define_method(rb_cBasicSocket, "recvmsg_nonblock", bsock_recvmsg_nonblock, -1);
+
     rb_cIPSocket = rb_define_class("IPSocket", rb_cBasicSocket);
     rb_define_method(rb_cIPSocket, "addr", ip_addr, 0);
     rb_define_method(rb_cIPSocket, "peeraddr", ip_peeraddr, 0);
Index: test/socket/test_unix.rb
===================================================================
--- test/socket/test_unix.rb    (revision 21217)
+++ test/socket/test_unix.rb    (working copy)
@@ -30,6 +30,52 @@ class TestUNIXSocket < Test::Unit::TestC
     end
   end

+  def test_sendmsg
+    return if !Socket.const_defined?(:SCM_RIGHTS)
+    IO.pipe {|r1, w|
+      UNIXSocket.pair {|s1, s2|
+        begin
+          ret = s1.sendmsg("\0", [[Socket::SOL_SOCKET, Socket::SCM_RIGHTS, [r1.fileno].pack("i!")]])
+        rescue NotImplementedError
+          return
+        end
+        assert_equal(1, ret)
+        r2 = s2.recv_io
+        begin
+          assert(File.identical?(r1, r2))
+        ensure
+          r2.close
+        end
+      }
+    }
+  end
+
+  def test_recvmsg
+    return if !Socket.const_defined?(:SCM_RIGHTS)
+    IO.pipe {|r1, w|
+      UNIXSocket.pair {|s1, s2|
+        s1.send_io(r1)
+        data, ctls, flags, srcaddr = s2.recvmsg
+        assert_equal("\0", data)
+        assert_instance_of(Array, ctls)
+        assert_equal(1, ctls.length)
+        assert_equal(3, ctls[0].length)
+        assert_equal(Socket::SOL_SOCKET, ctls[0][0])
+        assert_equal(Socket::SCM_RIGHTS, ctls[0][1])
+        assert_instance_of(String, ctls[0][2])
+        fd, rest = ctls[0][2].unpack("i!a*")
+        assert_equal("", rest)
+        assert_equal(0, flags)
+        r2 = IO.new(fd)
+        begin
+          assert(File.identical?(r1, r2))
+        ensure
+          r2.close
+        end
+      }
+    }
+  end
+
   def bound_unix_socket(klass)
     tmpfile = Tempfile.new("testrubysock")
     path = tmpfile.path

実装して気がついたのだが、recvmsg を使うと、パケットの長さを事前に知らなくてもどうにかなるな。

MSG_PEEK で試して、MSG_TRUNC/MSG_CTRUNC が出なくなるまでバッファを大きくしていけばいい。

listen の backlog というのはよくわからない引数である。

まぁ、キューの長さであるという説明はよくあるが、いまひとつふにおちない。

というわけで、試してみよう。

まず、サーバを用意する。

TCP で接続を受け付けて、送られてきたデータを読み捨てるだけのサーバである。ただし、並行処理はせず、ひとつの接続からデータを読み終わるまでは次の接続は accept しない。

listen の引数の backlog は 30 にしてある。

server% ruby -rsocket -e '
AddrInfo.tcp("0.0.0.0", 8888).bind {|s|
  s.listen(30)
  loop {
    t, addr = s.accept
    begin
      t.read
    rescue Errno::ECONNRESET
      puts $!
    end
    t.close
  }
}'

これに対して、クライアントは並行にやる。

0.1秒間隔でスレッドを起動し、各スレッドはサーバにつないで 3秒接続を保持した後に終了する。で、connect, sleep, close のプログラム開始時からの相対時刻を測る。

client% ruby -rsocket -e '
ts = []
t0 = Time.now
100.times {|i|
  ts << Thread.new {
    begin
      t1 = Time.now - t0
      AddrInfo.tcp("127.0.0.1", 8888).connect {|s|
        t2 = Time.now - t0
        sleep 3
        t3 = Time.now - t0
        s.close
        t4 = Time.now - t0
        line = " " * t4.ceil
        line[t1.ceil, (t2-t1).ceil] = "c"*(t2-t1).ceil
        line[t2.ceil, (t3-t2).ceil] = "s"*(t3-t2).ceil
        line[t4.ceil, (t4-t3).ceil] = "x"*(t4-t3).ceil
        printf "%02d %s\n", i, line
      }
    rescue
      p [i, $!]
    end
  }
  sleep 0.1
}
ts.each {|t| t.join }
'
00  sssx
01  sssx
02  sssx
03  sssx
04  sssx
05  sssx
06  sssx
07  sssx
08  sssx
09  sssx
10   sssx
11   sssx
12   sssx
13   sssx
14   sssx
15   sssx
16   sssx
17   sssx
18   sssx
19   sssx
20    sssx
21    sssx
22    sssx
23    sssx
24    sssx
25    sssx
26    sssx
27    sssx
28    sssx
29     sssx
30     sssx
31     sssx
32     sssx
33     sssx
34     sssx
35     sssx
36     sssx
37     sssx
38     sssx
39      sssx
40      sssx
41      sssx
42      sssx
43      sssx
44      sssx
45      sssx
46      sssx
47      sssx
48      sssx
49       sssx
50       sssx
51       sssx
52       sssx
53       sssx
54       sssx
55       sssx
56       sssx
57       sssx
58        sssx
59        sssx
60        sssx
61        sssx
62        sssx
63        sssx
64        sssx
65        sssx
66        sssx
67        sssx
68         sssx
69         sssx
70         sssx
71         sssx
72         sssx
73         sssx
74         sssx
75         sssx
76         sssx
77          sssx
78          sssx
79          sssx
80          sssx
81          sssx
82          sssx
83          sssx
84          sssx
85          sssx
86          sssx
87           sssx
88           sssx
89           sssx
90           sssx
91           sssx
92           sssx
93           sssx
94           sssx
95           sssx
96           sssx
97            sssx
98            sssx
99            sssx

結果の、先頭の数値は何番目に開始したスレッドかを示しており、結果を表示するのはスレッドが終わるときである。00 から 99 まで順に表示されているので、スレッドが始まった順番に終わったことを意味している。

s と x は sleep と close をやっていたタイミングである。1文字1秒。(ceil しているので、一瞬で終わっても 1文字にはなる)

connect のタイミングは c だが、この例では s に書きつぶされて出ていない。

ところで、この結果を見ると、クライアント側からはサーバが並行動作しているように見える。クライアントはいくつものスレッドが同時に接続を開いて sleep している。まぁ、アプリケーションが accept しなくても、接続を確立するところまではカーネルがやってくれるのであろう。(GNU/Linux)

さて、backlog を 10 にすると、結果は次のようになる。

00  sssx
01  sssx
02  sssx
03  sssx
04  sssx
05  sssx
06  sssx
07  sssx
08  sssx
09  sssx
10   sssx
11   sssx
12   sssx
13   sssx
29     sssx
30     sssx
31     sssx
32     sssx
33     sssx
34     sssx
35     sssx
36     sssx
37     sssx
38     sssx
39      sssx
40      sssx
20    cccsssx
24    cccsssx
58        sssx
59        sssx
60        sssx
61        sssx
62        sssx
63        sssx
64        sssx
65        sssx
66        sssx
67        sssx
68         sssx
69         sssx
87           sssx
88           sssx
89           sssx
90           sssx
91           sssx
92           sssx
93           sssx
94           sssx
95           sssx
96           sssx
97            sssx
98            sssx
70         cccsssx
99            sssx
41      cccccccccsssx
42      cccccccccsssx
43      cccccccccsssx
44      cccccccccsssx
45      cccccccccsssx
46      cccccccccsssx
47      cccccccccsssx
48      cccccccccsssx
49       cccccccccsssx
50       cccccccccsssx
51       cccccccccsssx
52       cccccccccsssx
71         cccccccccsssx
72         cccccccccsssx
73         cccccccccsssx
74         cccccccccsssx
75         cccccccccsssx
76         cccccccccsssx
77          cccccccccsssx
78          cccccccccsssx
79          cccccccccsssx
80          cccccccccsssx
81          cccccccccsssx
82          cccccccccsssx
14   cccccccccccccccccccccsssx
15   cccccccccccccccccccccsssx
16   cccccccccccccccccccccsssx
17   cccccccccccccccccccccsssx
18   cccccccccccccccccccccsssx
19   cccccccccccccccccccccsssx
21    cccccccccccccccccccccsssx
22    cccccccccccccccccccccsssx
23    cccccccccccccccccccccsssx
25    cccccccccccccccccccccsssx
26    cccccccccccccccccccccsssx
27    cccccccccccccccccccccsssx
53       cccccccccccccccccccccsssx
54       cccccccccccccccccccccsssx
55       cccccccccccccccccccccsssx
56       cccccccccccccccccccccsssx
57       cccccccccccccccccccccsssx
83          cccccccccccccccccccccsssx
84          cccccccccccccccccccccsssx
85          cccccccccccccccccccccsssx
86          cccccccccccccccccccccsssx
28    cccccccccccccccccccccccccccccccccccccccccccccsssx

今度は、後ろにいくにしたがって connect にかかる時間が増えていき、また、スレッドが終わる順番も変わっている。

スレッドが始まった順番にソートしてみよう。

00  sssx
01  sssx
02  sssx
03  sssx
04  sssx
05  sssx
06  sssx
07  sssx
08  sssx
09  sssx
10   sssx
11   sssx
12   sssx
13   sssx
14   cccccccccccccccccccccsssx
15   cccccccccccccccccccccsssx
16   cccccccccccccccccccccsssx
17   cccccccccccccccccccccsssx
18   cccccccccccccccccccccsssx
19   cccccccccccccccccccccsssx
20    cccsssx
21    cccccccccccccccccccccsssx
22    cccccccccccccccccccccsssx
23    cccccccccccccccccccccsssx
24    cccsssx
25    cccccccccccccccccccccsssx
26    cccccccccccccccccccccsssx
27    cccccccccccccccccccccsssx
28    cccccccccccccccccccccccccccccccccccccccccccccsssx
29     sssx
30     sssx
31     sssx
32     sssx
33     sssx
34     sssx
35     sssx
36     sssx
37     sssx
38     sssx
39      sssx
40      sssx
41      cccccccccsssx
42      cccccccccsssx
43      cccccccccsssx
44      cccccccccsssx
45      cccccccccsssx
46      cccccccccsssx
47      cccccccccsssx
48      cccccccccsssx
49       cccccccccsssx
50       cccccccccsssx
51       cccccccccsssx
52       cccccccccsssx
53       cccccccccccccccccccccsssx
54       cccccccccccccccccccccsssx
55       cccccccccccccccccccccsssx
56       cccccccccccccccccccccsssx
57       cccccccccccccccccccccsssx
58        sssx
59        sssx
60        sssx
61        sssx
62        sssx
63        sssx
64        sssx
65        sssx
66        sssx
67        sssx
68         sssx
69         sssx
70         cccsssx
71         cccccccccsssx
72         cccccccccsssx
73         cccccccccsssx
74         cccccccccsssx
75         cccccccccsssx
76         cccccccccsssx
77          cccccccccsssx
78          cccccccccsssx
79          cccccccccsssx
80          cccccccccsssx
81          cccccccccsssx
82          cccccccccsssx
83          cccccccccccccccccccccsssx
84          cccccccccccccccccccccsssx
85          cccccccccccccccccccccsssx
86          cccccccccccccccccccccsssx
87           sssx
88           sssx
89           sssx
90           sssx
91           sssx
92           sssx
93           sssx
94           sssx
95           sssx
96           sssx
97            sssx
98            sssx
99            sssx

これをみると、最初のうちはすぐに connect は終わるが、接続が増えてくると、connect に時間がかかるようになる。

おそらく、これが「キューが溢れた」状況なのであろう。

この結果では、その状態からしばらく経過すると、またすぐに connect が終わるようになる。

これは、3秒経過すると、接続中のクライアントが (sleep が終わって) 終了するので、キューに入っているのが accept され、キューに空きができるからであろう。キューに空きがあれば、connect はすぐに終了する。その時に、どの接続要求がキューに入るかは connect を始めた時刻とは関係無く、これが処理の順序が崩れる理由だろう。

天泣記

2009-01-01 (Thu)

2009-01-02 (Fri)

2009-01-05 (Mon)

2009-01-06 (Tue)

2009-01-09 (Fri)

2009-01-12 (Mon)

2009-01-13 (Tue)

2009-01-14 (Wed)

2009-01-15 (Thu)

2009-01-16 (Fri)

2009-01-17 (Sat)

2009-01-18 (Sun)

2009-01-19 (Mon)

2009-01-20 (Tue)

2009-01-21 (Wed)

2009-01-23 (Fri)

2009-01-25 (Sun)

2009-01-26 (Mon)

2009-01-27 (Tue)

2009-01-28 (Wed)

2009-01-31 (Sat)