Since another user already commented on alpha-beta and the importance of good heuristics for move ordering, I will focus on a different aspect of your question.
You specifically asked about forced mates rather than general board position evaluation, which makes the question somewhat easier to answer because it does not depend on the strength and cost of some evaluation function heuristic.
There is a family of related tree search algorithms collectively known as PN or proof number search (distant cousins of the general alpha-beta pruned search) which are particularly efficient at solving binary subproblems in computer games, such as whether or not there is a forced mate in <=N moves in chess (rather than the more abstract question of which board position is "better").
The algorithm proceeds by visiting each node and trying to either prove or disprove the initial query by checking which conditions must be satisfied for that branch to contain a solution (or a countersolution) and evaluating them in a "good" order such that proof failures can be detected early. The search quits as soon as it finds the first solution to the query (unlike ab- search, which keeps going until it finds the optimal minimax sequence).
In general, the "deepest" searching algorithms based on PN combine two searches, the "top" half running some PN variant sped up by transposition tables, and after some critical depth which depends on the amount of memory available for the tables, a second search algorithm without TT is launched, for some maximum depth of plies. It is the case that large enough searches will far exceed in number of nodes any reasonable amount of memory, so the TT can only help skip redundant branches at the lowest depths.
If we assume we can build a TT in memory with something like 10^9 positions (for a memory in the order of several Gb), we will in theory fill it with the surviving search candidates from a search in theory twice as deep (10^18 positions), the vast majority of which will have been ruled out by the algorithm without further analysis. Stockfish can run in the order of 70 million plies per second on a high-end computer, which means a "regular" computer can fill the top half of the search in the order of 10s of seconds to a few minutes. This top part of the search roughly corresponds to 11.6 plies already.
The expensive work however is to launch a search at each one of the leaves, which can fortunately be done in parallel using as much hardware as you can throw at it. The point here is not so much how many "computations" can be done per second but whether or not you want to check the table (memory accesses are costly, but narrow the search), build a local TT of just a few Mb to speed up purely the local search, or just use CPU power as means of tree exploration.
Tianhe-2 has something like 10^7 cores, so we are talking about assigning ~100 subproblems to each for maximum parallelism. So two minutes of thinking time will roughly translate into 1 second of unbounded exploration for each of the 10^9 leafs. Now assume each core visits 5 million (pruned) positions in this second and we get in theory an extra 8.7 plies of depth for a total of 20.3 plies of depth.
HOWEVER, the true number will be much higher because we ignored the effect of transpositions. Since we are considering ALL legal moves each turn, we can approximate the number of transpositions as roughly (M!^2) with M=2P the number of moves. This is because most moves outside of a strategy do not interfere with other legal moves elsewhere on the board.
So visiting 10^9 nodes in the first half actually implies solving 30 ^ P = (10^9)^2 (P/2)!^2, which gives a (possibly too optimistic) bound of P~24, and similarly the bottom half gives P~14 for a total depth of 38 plies.
Now of course in reality moves will end up not commuting, and the children nodes are not always visited in optimal order, but on the other hand we are using all legal moves as branching factor, which is a very pessimistic selection choice .