user28013: I was hoping to parallelize the chess engine I was currently working on. I have done some research on some of the various types of algorithms such as YBWC, ABDADA, and LazySMP which is currently used in stockfish. I was hoping to implement LazySMP into my engine and I have since taken a look at some sites such as https://www.chessprogramming.org/Lazy_SMP as well as https://www.duo.uio.no/bitstream/handle/10852/53769/1/master.pdf. As of now I am unsure of my understanding which is the following...

Each iteration, during iterative deepening, you initialize N threads
to search from the root to the same depth for that iteration. During their search, they
use the same transposition table and it is a race to see which of
those threads are the "first to complete". Each thread mantain's its own AB values, PV, heuristics, etc...

I want to know if this is correct. If it is correct, I am also curious in knowing how/why it improves search speed. It seems like a lot of redundant searching of nodes.

user30079: Yes, it's true... :)
There can be a lot of redundant search, but Lazy SMP works. Currently, it is a mystery why, but it has been verified with any engines that the simple, basic implementation works, regardless of how counter-intuitive this seems...
To clarify a little bit, you don't need to setup different initial conditions (like different depth, etc.); what makes threads de-synchronize is a history table used for move ordering.

28013: <p>I was hoping to parallelize the chess engine I was currently working on. I have done some research on some of the various types of algorithms such as YBWC, ABDADA, and LazySMP which is currently used in stockfish. I was hoping to implement LazySMP into my engine and I have since taken a look at some sites such as <a href="https://www.chessprogramming.org/Lazy_SMP" rel="nofollow noreferrer">https://www.chessprogramming.org/Lazy_SMP</a> as well as <a href="https://www.duo.uio.no/bitstream/handle/10852/53769/1/master.pdf" rel="nofollow noreferrer">https://www.duo.uio.no/bitstream/handle/10852/53769/1/master.pdf</a>. As of now I am unsure of my understanding which is the following...</p>
<blockquote>
<p>Each iteration, during iterative deepening, you initialize N threads
to search from the root to the same depth for that iteration. During their search, they
use the same transposition table and it is a race to see which of
those threads are the &quot;first to complete&quot;. Each thread mantain's its own AB values, PV, heuristics, etc...</p>
</blockquote>
<p><strong>I want to know if this is correct. If it is correct, I am also curious in knowing how/why it improves search speed. It seems like a lot of redundant searching of nodes.</strong></p>
 30079: <p>Yes, it's true... :)</p>
<p>There can be <em>a lot</em> of redundant search, but Lazy SMP works. Currently, it is a mystery why, but it has been verified with <em>any</em> engines that the simple, basic implementation works, regardless of how counter-intuitive this seems...</p>
<p>To clarify a little bit, you don't need to setup different initial conditions (like different depth, etc.); what makes threads de-synchronize is a history table used for move ordering.</p>
