[blowekamp]

PoolMultiThreader stores work-unit state in a growable vector, so its work-unit count is no longer capped by ITK_MAX_THREADS. ProcessObject and DomainThreader drop the matching upper clamp. PlatformMultiThreader keeps its limit.

Behavior and scope

• PoolMultiThreader::SetNumberOfWorkUnits only enforces a minimum of one; the array grows before each dispatch, never while tasks hold pointers into it.
• The global maximum number of threads and the thread pool size are unchanged.
• Work units above the cap can now be requested through ProcessObject and DomainThreader; PlatformMultiThreader still clamps them.
• The first commit renames m_ThreadInfoArray to m_WorkUnitInfoArray (no logic change).

AI assistance

• Tool: GitHub Copilot in VS Code
• Role: analysis of the work-unit limit, implementation, and local build/test runs
• All changes were reviewed by the author; a regression found during testing (progress events) was traced and fixed before committing.

Test results

Clean configure (release preset) and full rebuild with no errors, then ctest -j30 with ITK_GLOBAL_DEFAULT_NUMBER_OF_THREADS=4: 5314/5314 passed.
itkMultiThreaderBaseTest now covers ParallelizeArray and SingleMethodExecute with ITK_MAX_THREADS + 1 work units on the pool; itkDataObjectAndProcessObjectTest covers the unclamped setter.

PR Checklist

• No API changes were made (or the changes have been approved)
• No major design changes were made (or the changes have been approved)
• Added test (or behavior not changed)
• Updated API documentation (or API not changed)
• Added license to new files (if any)
• Added Python wrapping to new files (if any) as described in ITK Software Guide Section 9.5
• Added ITK examples for all new major features (if any)

Refer to the ITK Software Guide for
further development details if necessary.

[Copilot]

🟡 Changes recommended

The setter change breaks downstream overrides and virtual dispatch, while removing the clamp can cause backend work-unit count mismatches that leave per-work-unit results unfilled.

2 open issues

• Preserve virtual dispatch on the work-unit setter · New
• Align reported work units with backend thread limits · New

What changed in this PR

This PR lets ITK’s pool backend use more work units than ITK_MAX_THREADS, without increasing the thread pool size or removing the platform backend’s limit.

Changes:

• Replace fixed pool work-unit storage with a vector grown before dispatch.
• Remove upper work-unit clamps from ProcessObject and DomainThreader.
• Add above-cap regression coverage and update thread-limit assertions.

File	Description
Modules/​Core/​Common/​test/​itkTimeStampGTest.cxx	Check the global thread limit without assuming work units are capped.
Modules/​Core/​Common/​test/​itkMultiThreaderBaseTest.cxx	Test above-cap pool execution and calling-thread participation.
Modules/​Core/​Common/​test/​itkDataObjectAndProcessObjectTest.cxx	Test above-cap work-unit requests.
Modules/​Core/​Common/​src/​itkPoolMultiThreader.cxx	Grow work-unit storage before dispatch and remove the work-unit cap.
Modules/​Core/​Common/​include/​itkProcessObject.h	Retain only the setter’s minimum bound.
Modules/​Core/​Common/​include/​itkPoolMultiThreader.h	Declare vector storage, resizing helper, and setter override.
Modules/​Core/​Common/​include/​itkDomainThreader.h	Remove the upper setter bound and clarify backend clamping.

_{Review effort: Balanced}

[greptile-apps]

Confidence Score: 4/5

[Medium impact] The change reaches shared ITK parallel-work settings and pool-based execution.

Restore the virtual DomainThreader setter before merging so existing subclass overrides keep working.

Findings

1.  Subclass overrides stop working ▶
2.  Image path lacks limit coverage ▶

Summary

PoolMultiThreader now uses growable storage and accepts work-unit counts above ITK_MAX_THREADS.

• Pool work can use more units than the fixed thread limit.
• Process objects and domain threaders keep larger work-unit requests.

Diagram

%%{init: {'theme': 'neutral'}}%%
flowchart TD
  A[Work-unit request] --> B[ProcessObject or DomainThreader]
  B --> C{Selected threader}
  C --> D[PoolMultiThreader]
  C --> E[PlatformMultiThreader]
  D --> F[Grow storage before dispatch]
  F --> G[Queue work units on existing pool]
  E --> H[Clamp work units to thread limit]

Loading

_{Reviews (1) · Last reviewed commit: "ENH: Allow PoolMultiThreader work units ..." · Reviewed by Greptile}

[greptile-apps]

Subclass overrides stop working

DomainThreader::SetNumberOfWorkUnits is no longer virtual. The replaced itkSetClampMacro declared a virtual setter, so downstream subclasses that declare this method with override now fail to compile. Subclasses without override also stop receiving calls made through a DomainThreader pointer. Keep virtual on the replacement setter.

Suggested change

	void
	SetNumberOfWorkUnits(ThreadIdType numberOfWorkUnits)
	virtual void
	SetNumberOfWorkUnits(ThreadIdType numberOfWorkUnits)

[greptile-apps]

Image path lacks limit coverage

The new tests cross ITK_MAX_THREADS through ParallelizeArray and SingleMethodExecute, but not ParallelizeImageRegion. That method has its own new allocation based on splitCount, so a regression there could pass both tests. Add a pool test with an image region that produces more than ITK_MAX_THREADS splits, and check that every part is visited exactly once.

Note: If this suggestion doesn't match your team's coding style, reply to this and let me know. I'll remember it for next time!