|
Prakash - what was the patch you pulled in previously?
|
|
And here is the patch we pulled in for the issue we saw with the old Orion code: http://review.whamcloud.com/3047
|
|
LU-1164, master version of patch is 2246.
|
|
And a link to the previous issue we saw: ORI-768
|
|
Liang, can you please revisit this?
|
|
Liang,
I don't think change 2246 to add a tunable for the number of kib threads is really a "fix" for this problem on master (nor 2.1.x either, IMHO).
There should be some default upper limit of kib threads (possibly based on the number of IB HCAs) if there are too many cores on the system. Given that the number of cores on each node is continually increasing, we don't want every user to have to specify the module parameter to limit the number of threads, but rather have Lustre pick a sane default that can be configured differently if someone needs it.
|
|
Andreas, 2.3 and later version already have upper limit of o2iblnd threads number. I think this probably is a different issue because threads are contending on import::imp_lock, not any lock of LNet/LND, I'm looking into it right now.
|
|
I just posted a patch: http://review.whamcloud.com/#change,4486
|
|
We hit what I think is this issue again when testing at scale yesterday on Sequoia using our 2.3.56-3chaos tag (which has Liang's ptlrpc patch).
Some example stacks are:
I believe Chris's IOR test was using the "fsync on close" option, so it looks like it completed the write phase and was now trying to fsync and close the open files. The fact that the stacks are all down in fsync call paths, and then 40+ minutes later I see some stacks down the close call path lead me to believe the node wasn't deadlocked (per se), and would have "eventually" cleared up. Either way, it looks like there is far too much contention on a obd_import::imp_lock lock which needs to be addressed. About five minutes after the "close" stacks were printed the node was rebooted.
It is also worth noting that we were unable to login to the node(s) during this time. Are the threads spinning with interrupts disabled? That would unfortunately disable interrupts for the entire system for a really long time in our configuration.
|
|
I think it's just because imp_lock is under high contention if it's eventually cleared up  , I don't have very good idea to improve this so far, but I will see want I can do.
this spinlock will not disable interrupts, but soft lockup will dump stack to console which is extremely slow and system might not responding .
|
|
Well, careful, I'm not sure that I believe that seeing the processes soft lockup in close() a few minutes before the reboot means what you think it means.
This was a 98,304 process ior running on Sequoia. That means 128 MPI tasks writing to lustre through one I/O Node (ION). Each ION has 68 "cpus" from Linux's perspective, 17 real cores, and 4-way SMP threading.
In the incident on ION R01-ID-J06, between the times of 2012-11-28 11:06:10.548123 and 2012-11-28 11:08:34.717051 (just over two minutes of time), I count at least 51 tasks that trigger soft lockup messages.
Then, nearly 40 minutes later and only 5 minutes before the node is shut down, I see only two new process that show soft lockups in new processes under the file close. But you'll note that these are not the same processes that were stuck in the fsync() earlier. Also note that these processes that get hung under close have their backtraces start at "do_signal".
I believe what is happening is that some, but not all, of the 128 processes get stuck in fsync. Perhaps around 50 in this instance. Some of the processes actually completed their fsync and are just sitting with the file descriptor open, doing nothing.
Then IBM's control system comes along and tries to shutdown the ION at the system administrator's request. One thing it likely did was send a signal to the sysiod tasks to shut them down. During the signal handling to kill the process, the kernel is going to clean up open file descriptors. When it tries to close the open lustre file descriptor, some processes now get stuck on the same lock as the others, but in the close() path rather than the fsync() path.
After some timeout (5 minutes probably), IBM's system stops waiting for there daemons to exit, and starts a shutdown of the whole node.
So I suspect that the processes really are stuck, and will never make progress.
|
|
I attached an excerpt from the console log, file R01-ID-J06.log, for the time in question. Mostly there are sysiod processes stuck, but there is one ptlrpcd_rcv process in there at the beginning of the incident as well. Unfortunately, the backtrace of ptlrpcd_rcv is interleaved with a couple of other sysiod backtraces, so it is difficult to see where it was. But perhaps we can find the culprit in there somewhere.
|
|
I have checked code and log again, but still didn't find any possible deadlock. Lustre only have very few cases will disable interrupt (I remember we used to take spin_lock_bh for imp_lock, but we have changed that a few years ago). However, CDEBUG will definitely disable interrupt, any we did call CDEBUG_REQ many times with hold of imp_lock, CDEBUG_REQ has complex format which makes it a little expensive, so one thing might be worth a try is, disable D_HA and D_IOCTL on clients to see if it can make any difference, at the meanwhile, I will check code again.
|
|
I was wrong in previous comment, CDEBUG will not disable interrupt if it's in thread context, but I still suggest to disable D_HA and D_IOCTL to see if it can help before we find any other clue, I remember a couple of years ago I saw some tests hit soft lockup while enabling D_INFO.
|
|
Christopher, Prakash, could you describe the workload and/or estimate it in RPC/second please ?
we usually limit number of RPCs in flight to 8 (per import). to achieve 1GB/s per OST with 1MB RPC we'd need 1024 RPC/second. say, we're grabbing imp_lock roughly 10 times for every processed RPC, which gives us to ~10K/sec lock instances. but this is in the case of 1GB/s going to a single OST.
I think it'd be helpful to collect data on CONFIG_LOCK_STAT-enabled kernel.
if this is not a deadlock, then I'd consider few possible contributors:
1) CDEBUG() overhead while imp_lock is held
2) cache ping-pong if OST_WRITE go to different partitions
3) a lot of non-committed requests making ptlrpc_free_committed() slow (which is running with imp_lock held)
4) lack of need_resched() in ptlrpc_check_set() (though in all listed cases it was in _spin_lock())
|
|
When I had problems, I was running an ior something like this:
The ior was 98,304 MPI tasks in size.
Under normal conditions, each Sequoia I/O Node (ION) handles I/O for 128 compute nodes. So a given ION will handle 128 files. We have currently left the filesystem default at 1-stripe per file, so each ION will be writing to up to 128 different OSTs at more-or-less the same time.
|
|
On writes, we currently see about 850 GB/s, so with 768 IONs that is roughly 1.1 GB/s per ION (the ION is the lustre client).
|
|
so, it's roughly 1.1/128 or ~9MB/s per OST on an average ION and actually very few RPC/second/import...
|
|
And just to be clear, I believe that this WAS a deadlock situation, as detailed in this comment.
|
|
I did find a deadlock....
ptlrpc_at_recv_early_reply() calls ptlrpc_at_set_req_timeout() with hold of ptlrpc_request::rq_lock, and ptlrpc_at_set_req_timeout()->import_at_get_index() requires imp_lock, it violates locking-order rule of Lustre, which assumes rq_lock can nest in imp_lock.
This is introduced by BZ16999
Path is here: http://review.whamcloud.com/#change,4880
|
|
interesting.. in the traces above can you find one holding rq_lock ?
|
|
No I can't, those traces look like someone forgot to unlock imp_lock, but I have already looked through all use-cases of imp_lock for three times and can't find any case of that. This is the only buggy code I can find so far.
|
|
yes... OK. lets see how it does at LLNL.
|
|
Patch landed to master.
|
Generated at Sat Feb 10 01:23:44 UTC 2024 using Jira 9.4.14#940014-sha1:734e6822bbf0d45eff9af51f82432957f73aa32c.
R01-ID-J06.log