How to perform concurrent operation on a data structure that is shared by multiple goroutines

I was solving a puzzle in Go, that finds a string in 2D byte array by rotating the ASCII byte values to match the string either row wise (left->right) or column-wise (top->bottom). I was able to solve it sequentially and when it came to solving it concurrently I tried to launch one go-routine to work on a particular combination of input, to see if any of the possible 25 rotations could find a match. The abstract of the code as follows

The FindByConcurrentRot is the method that takes a 2D char array input and tries to find a match of the string in various combinations of input possible.

Question is - Is the below used concurrent method performant? How could it be improved? Is the approach to convert the sequential routine "as-is" as to a concurrent program wrong? i.e. should the whole program be re-written for making best use of the concurrent features?

// searchResult defines the information needed to pass to identify if a match has been identified during concurrent search
type searchResult struct {
	row   int
	col   int
	rot   int
	found bool
}

// processSearchResults runs the gorotuine to perform the search for a particular rotation of input
func processSearchResults(wg *sync.WaitGroup, iter int, resultChan chan searchResult, table [][]byte, word string) {
	// call goroutine end when the function returns
	defer wg.Done()
	if iter >= 1 {
		rotate(table, iter)
	}
	x, y, match := present(table, word)
	if match {
		resultChan <- searchResult{row: x, col: y, rot: iter, found: true}
		return
	}
	resultChan <- searchResult{found: false}
}

// doCopy creates a copy of the original table to passed for each iteration of the concurrent search
// This is an EXPENSIVE operation on a goroutine, because of memory copy operations
// The copy is needed for the goroutines to have their own control of data and not run into data
// races by passing the original data to each of them
func doCopy(table [][]byte) [][]byte {
	copyTable := make([][]byte, len(table))
	for i := range table {
		copyTable[i] = make([]byte, len(table[i]))
		copy(copyTable[i], table[i])
	}
	return copyTable
}

// FindByConcurrentRot searches for the string in the ASCII character array by using concurrency primitives
// The function spawns goroutines by rotating all combinations of the input table possible and passing them
// their own copy of original table and processes the results back in a channel
func FindByConcurrentRot(table [][]byte, word string) (int, int, int, bool) {
	iter := 0
	resultChan := make(chan searchResult, maxIteration)
	var wg sync.WaitGroup

	for iter <= maxIteration {
		wg.Add(1)
		go processSearchResults(&wg, iter, resultChan, doCopy(table), word)
		iter++
	}

	// Stop the range channel, when we finish waiting for all the goroutines
	go func() {
		wg.Wait()
		close(resultChan)
	}()

	resultCount := 0
	// process result from each goroutine on the channel
	for result := range resultChan {
		resultCount++
		if result.found {
			return result.row, result.col, result.rot, result.found
		}
	}

	return 0, 0, 0, false
}

Full MVCE at this Go playground link - https://go.dev/play/p/7YFAsAlFRUw

Note: The results from benchmarking indicated the sequential version outperfomed the concurrent one by a lot

go test -bench=.
goos: darwin
goarch: amd64
pkg: github.com/inianv/go-wordsearchpuzzle/wordsearch
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
BenchmarkTestSequentialSearch-12    	11003130	       106.4 ns/op
BenchmarkTestConcurrentSearch-12    	   38865	     32031 ns/op
PASS
ok  	github.com/inianv/go-wordsearchpuzzle/wordsearch	3.339s

It is likely that this approach is suffering from too many cycles spent on copying tables. Since each goroutine is modifying the table, each goroutine has to get a separate copy.

Another approach to that would be to add a layer on top of a read-only table that gives a modified view for each goroutine. That does not guarantee better performance, but it is likely to perform better than copying with multiple goroutines.

The approach would be to have a table view:

type tableView struct {
inc int
table [][]byte
}
func (t tableView) get(row,col int) byte {
v:=t.table[row][col]
v+=t.inc
if v>'z' {...}
return v
}

Then, you initialize and pass an instance of tableView around.

Again: this may not perform as fast as you expect, but it is likely to perform better than multiple copies of the table. You have to test and see.