We had a serious (lack of) performance issue today with a Linux NFSclient machine, so I spent some time delving into the underdocumentedworld of kernel parameters that affect the Linux NFS client (not the NFSserver, which has better documented stuff).

(I am going to use sysctl(8) notation for kernel tunables.)

The major tunable is sunrpc.udp_slot_table_entries and/or tcp_slot_table_entries . These are the maximum number of outstandingNFS RPC requests

In a previous entry I mentioned that Sun'saddition of mmap() basically forced their hand on having a unifiedbuffer cache. Today I feel like elaborating on that.

The problem with having mmap() and not a unified buffer cache is pagecoherence. If you have some programs using mmap() and some usingregular read() and write() , you will wind up with two copies ofpages, one mapped into process memory and one in the buffer cache.Because virtual memory and the buffer

It's common to say bad things about the GIL (a round of GIL bashing happened recently, for example). I have acontrarian view: I think that the GIL is the right thing for Python.

Python needs some concurrency support, if only so that it can makeinherently blocking operations into non-blocking ones. At the sametime, the thread and shared memory based concurrent programmingmodel is a terrible one that programmers should avoid as much aspossible.

The GIL is good enough and simple enough to

This week, we:

• got 11,963 messages from 272 different IP addresses.
• handled 20,658 sessions from 1,625 different IP addresses.
• received 433,498 connections from at least 123,409 different IPaddresses.
• hit a highwater of 8 connections being checked at once.

Volume is down a fair bit from last week ,although it is nowhere near the levels I would like it to be at.The daily

In thinking about the whole subject of how languages deal with types recently , it struck me that calling something anuntyped language is usually somewhat of a misnomer.

Most things that get called untyped languages, such as assembly code,actually have types; it's just that they are attached to operationsinstead of to values (and variables, and storage locations). Arguablyassembly language has stronger typing for arithmetic operations thanmost high level languages, since there isn't any silent conversionbetween different types of numbers.

Thinking

Due to recent events I have become interested inthis issue, so I have been poking around and doing some experiments.Unfortunately, while Linux has a bewildering variety of memory relatedper-process resource limits that you can set, most of them don't work ordon't do you any good.

What you have, in theory and practice:

• ulimit -m , the maximum RSS, doesn't do anything; the kernelmaintains the number but never seems to use it for anything.

• ulimit -d

For our backwards compatibility sins, we have plain POP3 exposed tothe general Internet. This morning, we discovered that our POP3 serverhad more or less locked up around 6:30 am, apparently because someonedecided to open up hundreds of connections to it and perform a bruteforce mass account/password attempt.

(In fact it took down our IMAP server too, because we're runningDovecot. This is one of the annoying limitations of Dovecot; there is acentral server process that has a

Courtesy of a nice little thunderstorm, I lost power for a bit, whichreminded me of why ATX power supplies are not my favorite thing. Theproblem is that they are too smart yet not smart enough.

In the old days of simple power supplies, when you turned a machine offit would stay off and if you turned a machine on it stayed on, and powerfailures didn't change this; after the power came back, the off machinestayed off and the on machine powered back up. In

It used to be that on a large memory 32-bit compute server, no singleprocess could run away and exhaust all of the machine's memory. On aneight or sixteen gigabyte machine, processes ran into the 3 gigabyte(max) or so limit on per-process virtual address space well before theycould run the machine itself into the ground.

(On a large enough machine you could survive a couple of suchprocesses.)

This is no longer true on 64-bit large memory compute