In Project 1, the process was straightforward: you generated the operand matrices, and they were shared across all threads. However, in Project 2, we may need to broadcast the operands to different processes, at least partially. Is this what we're expected to do? I've heard some students are generating parts of the random matrices within separate processes, but I'm not sure if that's the correct approach. Personally, I believe that for an actually useful multiplication algorithm, the parameters should be generated in a single process and then broadcasted to other processes. Since the staff isn't likely to provide clarification, I'd appreciate any insights from fellow students.

Or, should we just assume every process shares the same input data, but only does their own parts of computation

ANONYMOUS wrote: This can be done if they follow the same generation sequence.

Deciding how to handle this is part of the point of the project. You need to weigh the pros and cons of each approach and justify which you have chosen in your report. Broadly, you have two options: - You generate the matrix only at the root process. This may make your code simpler, e.g. implementing writing the matrix to a file is trivial (writing does not have to be done in parallel), but your other processes will be sitting idle until you finished generating the matrices. - You can generate parts of the matrix in different processes. You may have to design your program more carefully, but your worker processes won't be sitting idle while a single process generates the matrix.

Thank you for your response; I appreciate it. I didn’t expect to see staff available on such a weekend. I believe I have a third option: fully generating the operands for all processes while ensuring that the results are consistent across them. This approach is similar to option two but eliminates the communication cost by avoiding the need to broadcast to other processes. Is this allowed?

Sure, it is up to you to design your program and justify it, so in that sense it is allowed. But be careful -- while you do eliminate the communication overhead, all your processes are just redundantly generating the same matrix. Even though your processes aren't technically sitting idle, they are just duplicating the same work as the root. The only benefit you gain is avoiding the communication costs, you aren't really getting true parallel matrix generation.