Katkat
Back

Design a Parallel Image Processor

AnthropicSoftware Engineer · Technical Screen
MediumSoftware EngineerTechnical ScreenSoftware Engineering Fundamentals

Last updated

This problem tests your ability to design a thread-safe, parallelized image processing framework that handles neighborhood-based pixel operations without race conditions.

Parallel Image Processor

Design a software component capable of applying a kernel-based image filter (e.g., a 3x3 blur or edge detection) to an image represented as a 2D grid of pixels. The system should support multi-threaded execution to speed up the processing of high-resolution images.

Your design must address:

  1. Thread Safety: Ensure that multiple threads can process different regions of the image simultaneously without data races.
  2. Boundary Handling: Define how the filter should behave at the edges of the image (e.g., padding with zeros, clamping to edge values, or shrinking the output).
  3. Deterministic Output: The result must be consistent regardless of the order or number of threads processing the image.

Requirements

  • Provide a class structure for the ImageProcessor.
  • Implement a method apply_filter(image, kernel) that returns the processed image.
  • Assume image is a 2D array of integers and kernel is an N x N matrix.

Example

Input: 3x3 Image, 3x3 Kernel Output: A new 3x3 Image where each pixel at (i, j) is the sum of products of the kernel and the neighboring pixels.

Considerations

  • How will you partition the image across threads?
  • How do you handle the read-only dependency of the input image versus the write-only target of the output image?
  • Constraints: Image size up to 10k x 10k pixels; Kernel size typically 3x3 to 7x7.

Hints

Hint 1

To avoid race conditions, do not modify the input image in-place while reading from it for the kernel calculation.

Hint 2

Consider dividing the image into horizontal strips or rectangular tiles, assigning each to a different thread.

Hint 3

Use a thread-safe synchronization primitive or a barrier if you need to perform multiple passes, but strive for an architecture where independent chunks can be computed entirely in parallel.

Follow-up questions

  • How would your architecture change if the image size exceeds the available RAM?
  • What would be the bottleneck if you were to move this processing to a GPU using CUDA?
  • How would you optimize the memory access pattern to improve cache locality during the convolution operation?