AtomicDB

Sign in Register

The queue

Every analysis request waits in one shared queue until a worker picks it up. The queue is shared out fairly by account, so nobody can crowd everyone else out.

The queue page: a table with one row per account and the columns account, waiting, running, queued nodes, served in the last 60 minutes, and oldest wait.
The queue page: one row per account.

The queue is public at the queue page. Its rows are read from the same rules the ordering uses, so the page and the queue cannot disagree without it being a bug in one place.

Click an account to see only its requests (running now, waiting with their place, and served) at /atomicdb/queue/<name>/; requests made without an account are at /atomicdb/queue/anonymous/.

Who is served first

  • Each request waits behind the nodes its account already has queued ahead of it. So the first request of a newcomer is served before the thousandth of a flooder.
  • The unit is nodes (search effort), not requests. One 2B request weighs as much as about sixteen 128M requests, and a big batch interleaves with everyone else instead of walling off the queue.
  • Running a worker gives exactly one advantage: while it runs, your own worker serves your own requests first. It is affinity, not priority, and it scales with the CPU you are plugging in right now. You can give it up in Account settings: your workers then serve everyone else's requests first, and go back to yours when nobody else is waiting.
Three accounts: A has four 128M requests, B has a 2B request followed by a 128M one, C has one 128M request. Each request is placed by the nodes its own account has queued ahead of it, so the first request of each account is served first, A's later ones next, and B's second request, which waits behind 2B, last.nodes already queued ahead, same accountABC0128M256M384M…2B1st4th5th6th2nd7th3rd
Account A has four 128M requests, B one 2B request and then a 128M one, C a single 128M request. Every account's first request goes before anyone's second; B's second request waits behind its own 2B.

How much you can queue

  • The cap is per person: 5,000 queued requests, counting pending rows only.
  • Cancelled rows do not count, running rows do not count, and clearing your queue gives the allowance back immediately.

Asking for the same position as somebody else

  • Asking for a position somebody else already asked for joins their request instead of queueing a duplicate. This is called backing the request.
  • Every account that asked is notified when the analysis lands.
  • The more people waiting on one request, the sooner it is served: a backed request is charged to the best placed of its requesters. Authorship never moves; only the charge does.

Asking again: deeper searches

  • Repeated requests buy genuinely deeper searches, up the ladder of 128M, 512M and 2B nodes.
  • Once the 2B search of a position has run, the next request queues up to 78 searches of 128M on the lines below it instead, the best lines first.
  • The last stop of the depth slider buys the same searches without waiting for the ladder.
Which lines below a position get searched
  • Where the side the position favours is to move: its three best moves (eight when nothing ranks them yet).
  • Where the other side is to move: every reply.
  • A position that already has its 128M search is walked through, and its own replies are asked next.
  • Asking again while those searches are still waiting queues nothing new.

Requesting several moves at once

Signed in, you can tick several moves in the move list of a position and request them all with one button, up to 64 at a time. Each ticked move is one request, as if its own button had been clicked, with two differences:

  • If you may pick a depth for that button, the bar offers a depth of its own: any rung from 128M to 2B, whatever the depth of the position you are on. A depth picked there is a target. A move with no search that deep gets exactly that depth, and a move already searched that deep (as its depth column shows) is skipped.
  • With no depth picked, a move already searched to the top of the ladder is left as it is; open it to queue the searches below it.

Managing your own requests

While a request of yours is waiting, the position it was asked for offers two controls, and your contributor page lists all your waiting requests in one place.

  • Move to front serves that request before the rest of yours. It takes the place your own first request already held, so nobody else's request moves.
  • Withdraw takes back a request you have not been served yet. It sits beside Move to front on the position, and on every waiting row of your contributor page.
  • Clear my queue, at the foot of the waiting list, withdraws everything you have waiting at once.
Exact rules for withdrawing
  • Nothing has been spent on a waiting request, so withdrawing costs nothing and puts nothing on your record.
  • The ladder does not advance either, so the same rung is still there if you ask again.
  • It is one click, and the page you come back to offers to undo it.
  • If somebody else asked for the same position, withdrawing only takes your name off: the request stays in the queue under them.
  • A request a worker has already started cannot be withdrawn, because the search is already running.
  • Clear my queue follows the same rule for shared requests. It asks for confirmation and has no undo.

← Repetition Contributing →