1. Multicore experiment: Plurality Hypercore Processor Performed by: Anton Fulman Ze’ev Zilberman Supervised by: Mony Orbach Final presentation Winter 2008

2. Reminder – the system Plurality has developed a 256 Hypercore processor with unique architecture and programming model, suited for parallel algorithms The main project goal is to build and optimise algorithms for Plurality system, that will later be used for lab multicore experiment

3. Reminder - programming model Task oriented programming model (TOP) The algorithm is partitioned to regular and duplicable tasks The algorithm can be described by a task map, with dependencies between the tasks Resource synchronization between tasks is managed automatically (unlike common multithread programming)

4. Project goals Build parallel algorithms Write documentation Provide the knowledge base for the multicore experiment

5. Algorithms Build parallel algorithms: – Simple Vector multiplication - done Matrix multiplication – done Array search - done – Medium White balance - done Mean filtering - done Array sort - done – Complex DCT - done Matrix inversion – done Error correction - done

6. Documentation Inline documentation for algorithms already finished - done System manual - done Documentation of system usage for lab experiment – done Algorithm explanation document - done

7. White balance algorithm Build LUT tasks build 3 look up tables, Each one contain multiplication of correction index with intensity(0-255) Balance tasks assign new values from LUT that match to original values of intensity

8. White balance algorithm - partitioning Every one of rbuildlut, gbuildlut and bbuildlut tasks is divided to 256 subtasks (as the number of intensity levels), each subtask is responsible for multiplication of the original intensity level by the factor defined Every one of rbalance, gbalance and bbalance tasks is divided to DIM subtasks (image dimensions are DIMxDIM), each subtask looks up for a matching level in the LUT and places it in the corresponding result matrix

9. Performance charts – White balance

10. Matrix Inverse algorithm Calc minor task defines minors of the matrix. Result of calc_det1 and calc_det2 are determinants of all minors in the matrix. Calc_gdet calculate determinant of original matrix. And calc_inv task return inverse matrix

11. Matrix Inverse algorithm - partitioning 4x4 matrix inversion is implemented Calc_minors is divided to 16 subtasks, each one finds a minor for a source matrix member and puts the result in temporary array Calc_det1 is divided to 16x3 subtasks, each one does one step of 3x3 determinant calculation, step example: a 11 *(a 22 * a 33 -a 23* a 32 ) Calc_det2 is divided to 16 subtasks, each one sums 3 results of Calc_det1 to calculate a determinant in the adjoint matrix Calc_gdet is a normal task which calculates the global determinant using the results of Calc_det2 Calc_inv is divided to 16 subtasks, each one divides a determinant in the adjoint matrix by the global determinant

12. Performance charts – Matrix Inverse

13. Error correction algorithm Encoding algorithm – encode each 7 bits word to 11 bits word according to “Hamming algorithm” Decode algorithm check each word by parity bits and correct errors

14. Error correction algorithm - partitioning The encode task is divided to WORDS*4 subtasks; WORDS is the number of 7 bit words in the input stream, 4 is the number of parity bits calculated for each word, each subtask calculates a parity bit for the encoding The decode task is divided to subtasks with the same logic as the encode task, each subtask checks the parity bits and updates the “check” array if there’s an error The fix task is divided to WORDS subtasks, each one is responsible for fixing a word according to “check” array, if there’s an error

15. Performance charts – Error correction

17. Conclusions We gained experience working with multi core systems Measurements showed significant performance improvement with increasing the number of cores We recommend implementing more complicated algorithms in future projects