IndexWriter

    pub fn writer<D: Document>(
        &self,
        memory_budget_in_bytes: usize,
    ) -> crate::Result<IndexWriter<D>> {
        let mut num_threads = std::cmp::min(available_parallelism()?.get(), MAX_NUM_THREAD);
        let memory_budget_num_bytes_per_thread = memory_budget_in_bytes / num_threads;
        if memory_budget_num_bytes_per_thread < MEMORY_BUDGET_NUM_BYTES_MIN {
            num_threads = (memory_budget_in_bytes / MEMORY_BUDGET_NUM_BYTES_MIN).max(1);
        }
        self.writer_with_num_threads(num_threads, memory_budget_in_bytes)
    }

        if options.memory_budget_per_thread < MEMORY_BUDGET_NUM_BYTES_MIN {
            let err_msg = format!(
                "The memory arena in bytes per thread needs to be at least \
                 {MEMORY_BUDGET_NUM_BYTES_MIN}."
            );
            return Err(TantivyError::InvalidArgument(err_msg));
        }

0 worker threads: Err An invalid argument was passed: 'At least one worker thread is required, got 0'
u32::MAX per thread: Err An invalid argument was passed: 'The memory arena in bytes per thread cannot exceed 4293967295'

thread 'main' (6127582) panicked at ~/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tantivy-0.27.0/src/index/index.rs:725:48:
attempt to divide by zero

t1 pid=22645 threads=       1
t2 pid=22645 threads=       9
t3 pid=22645 threads=      12
t4 pid=22645 threads=       1

disk second (other Index handle): Err Display = Failed to acquire Lockfile: LockBusy. Some("Failed to acquire index lock. If you are using a regular directory, this means there is already an `IndexWriter` working on this `Directory`, in this process or in a different process.")
disk second (other Index handle): Err Debug   = LockFailure(LockBusy, Some("Failed to acquire index lock. If you are using a regular directory, this means there is already an `IndexWriter` working on this `Directory`, in this process or in a different process."))
disk second (other Index handle): LockError   = Could not acquire lock as it is already held, possibly by a different process.

files after drop: [(".managed.json", 14), (".tantivy-writer.lock", 0), ("meta.json", 917)]
disk after drop: Ok

    pub fn add_document(&self, document: D) -> crate::Result<Opstamp> {
        let opstamp = self.stamper.stamp();
        self.send_add_documents_batch(smallvec![AddOperation { opstamp, document }])?;
        Ok(opstamp)
    }

                loop {
                    let mut document_iterator = document_receiver_clone
                        .clone()
                        .into_iter()
                        .filter(|batch| !batch.is_empty())
                        .peekable();

                    // The peeking here is to avoid creating a new segment's files
                    // if no document are available.
                    // ...
                    if let Some(batch) = document_iterator.peek() {
                        assert!(!batch.is_empty());
                        delete_cursor.skip_to(batch[0].opstamp);
                    } else {
                        // No more documents.
                        // It happens when there is a commit, or if the `IndexWriter`
                        // was dropped.
                        index_writer_bomb.defuse();
                        return Ok(());
                    }

                    index_documents(
                        mem_budget,
                        index.new_segment(),
                        &mut document_iterator,
                        &segment_updater,
                        delete_cursor.clone(),
                    )?;
                }

impl<D: Document> Drop for IndexWriter<D> {
    fn drop(&mut self) {
        self.segment_updater.kill();
        self.drop_sender();
        for work in self.workers_join_handle.drain(..) {
            let _ = work.join();
        }
    }
}

add_document x20000 returned after 261.706125ms
before drop: 36 files
drop took 138.13325ms
after drop: 63 files
  .managed.json:2454
  .tantivy-writer.lock:0
  41da853245d74641b088a5d04db8cafa.fast:0
  41da853245d74641b088a5d04db8cafa.fieldnorm:0
  41da853245d74641b088a5d04db8cafa.idx:0
  41da853245d74641b088a5d04db8cafa.pos:0
  41da853245d74641b088a5d04db8cafa.store:123
  41da853245d74641b088a5d04db8cafa.term:0
  5ccf39a6b2fb4b3fb17a0b9e4a7d5a6e.fast:146
  5ccf39a6b2fb4b3fb17a0b9e4a7d5a6e.fieldnorm:8027
  5ccf39a6b2fb4b3fb17a0b9e4a7d5a6e.idx:515400
  5ccf39a6b2fb4b3fb17a0b9e4a7d5a6e.pos:612542
  5ccf39a6b2fb4b3fb17a0b9e4a7d5a6e.store:75666
  5ccf39a6b2fb4b3fb17a0b9e4a7d5a6e.term:247445
...
  meta.json:917
docs visible after reopen: 0

after an empty commit: [".managed.json:14", ".tantivy-meta.lock:0", ".tantivy-writer.lock:0", "meta.json:917"]

available_parallelism = 12
writer(10000000) -> Err: An invalid argument was passed: 'The memory arena in bytes per thread needs to be at least 15000000.'
  debug: InvalidArgument("The memory arena in bytes per thread needs to be at least 15000000.")
writer(14999999) -> Err: An invalid argument was passed: 'The memory arena in bytes per thread needs to be at least 15000000.'
  debug: InvalidArgument("The memory arena in bytes per thread needs to be at least 15000000.")
writer(15000000) -> 1 segments [20000]
writer(29999999) -> 1 segments [20000]
writer(30000000) -> 2 segments [10282, 9718]
writer(50000000) -> 3 segments [7172, 7122, 5706]
writer(100000000) -> 6 segments [5374, 4252, 3827, 2887, 2466, 1194]
writer(119999999) -> 7 segments [4839, 3993, 3941, 2839, 2500, 1222, 666]
writer(120000000) -> 8 segments [4322, 4231, 4131, 2290, 1838, 1551, 860, 777]
writer(400000000) -> 8 segments [4449, 4295, 3578, 2154, 1582, 1418, 1384, 1140]