Loop Transforms to Increase Parallelism
This is an incomplete question because you have no base case; A[-3, -3] is not defined, for example. But let's assume we're looking at a window into a larger array, so those values have some consistent, distinct and independent value.

Denote those predetermined values with #, and look at the top-left corner. The values we can fill in are those three topmost rows and three leftmost columns, denoted by ·.

# # # # # # # # # # # # # #
# # # # # # # # # # # # # #
# # # # # # # # # # # # # #
# # # # # # # # # # # # # #
# # # # · · · · · · · · · ·
# # # # · · · · · · · · · ·
# # # # · · · · · · · · · ·
# # # # · · ·
# # # # · · ·
# # # # · · ·
# # # # · · ·
# # # # · · ·
# # # # · · ·
# # # # · · ·


Doing those in parallel means that you need to take n / 3 sequential steps. Since the matrix is square, exclusively going down balances the costs better, but still gives you n / 3 sequential steps with parallelism of 3n.

This is remarkably excessive for a typical CPU for significantly sized n; rather you should be streaming memory into SIMD operations as fast as possible. You can do a straightforward N-wide SIMD loop over the x-axis.

A[i:i+N, j] = A[i-4:i-4+N, j-4] + A[i-3:i-3+N, j-3] + B[i:i+N, j]


This probably won't max out your bandwidth entirely, but it will get pretty darn close and it's unlikely you can get more from a multicore algorithm, though you are free to try partitioning the work along diagonals.