6.189 IAP Recitations 2-3. Cell Programming Hands-on. David Zhang, MIT IAP 2007 MIT
|
|
|
- Madeleine Wright
- 5 years ago
- Views:
Transcription
1 6.189 IAP 2007 Recitations 2-3 Cell Programming Hands-on IAP 2007 MIT
2 Transferring Data In/Out of SPU Local Store memory SPU needs data 1. SPU initiates DMA request for data data DMA local store SPU SPE IAP 2007 MIT
3 Transferring Data In/Out of SPU Local Store memory SPU needs data 1. SPU initiates DMA request for data 2. DMA requests data from memory DMA data local store SPU SPE IAP 2007 MIT
4 Transferring Data In/Out of SPU Local Store memory SPU needs data 1. SPU initiates DMA request for data 2. DMA requests data from memory 3. Data is copied to local store DMA data local store SPU SPE IAP 2007 MIT
5 Transferring Data In/Out of SPU Local Store memory SPU needs data 1. SPU initiates DMA request for data 2. DMA requests data from memory 3. Data is copied to local store 4. SPU can access data from local store DMA data local store data SPU SPE IAP 2007 MIT
6 Transferring Data In/Out of SPU Local Store memory SPU needs data 1. SPU initiates DMA request for data 2. DMA requests data from memory 3. Data is copied to local store 4. SPU can access data from local store SPU operates on data then copies data from local store back to memory in a similar process DMA data local store data SPU SPE IAP 2007 MIT
7 Recitation Plan Lab 1 solution SPE-SPE communication Patterns for mapping computation to SPEs Cell-ifying a sample program Hands on programming Optimizations Useful resources IAP 2007 MIT
8 rec2/lab1sol/ Lab 1 Solution Calculate distance from each point in a[...] to each point in b[...] and store result in c[...][...] y for (i = 0; i < NUM_POINTS; i++) { for (j = 0; j < NUM_POINTS; j++) { c[i][j] = distance(a[i], b[j]); b a x Divide work among 2 SPEs IAP 2007 MIT
9 rec2/lab1sol/ Lab 1 Solution a[i] b[j] Memory SPU 0 SPU 1 c[i][j] j i Same code for each SPU typedef struct { uintptr32_t a_addr; uintptr32_t b_addr; uintptr32_t c_addr; uint32_t padding; } CONTROL_BLOCK; IAP 2007 MIT
10 rec2/lab1sol/ Lab 1 Solution Can start multiple DMA transfers with the same tag and wait for all of them to complete mfc_get(a, cb.a_addr, HALF_POINTS, 5, 0, 0); mfc_write_tag_mask(1 << 5); mfc_read_tag_status_all(); mfc_get(b, cb.b_addr, NUM_POINTS, 5, 0, 0); mfc_write_tag_mask(1 << 5); mfc_read_tag_status_all(); mfc_get(a, cb.a_addr, HALF_POINTS, 5, 0, 0); mfc_get(b, cb.b_addr, NUM_POINTS, 5, 0, 0); mfc_write_tag_mask(1 << 5); mfc_read_tag_status_all(); Can wait for multiple transfers with different tags mfc_write_tag_mask((1 << 5) (1 << 6)); mfc_read_tag_status_all(); Don t allocate large buffers on the stack IAP 2007 MIT
11 Recitation Plan Lab 1 solution SPE-SPE communication Patterns for mapping computation to SPEs Cell-ifying a sample program Hands on programming Optimizations Useful resources IAP 2007 MIT
12 rec2/dma_2spe/ SPE-SPE DMA and Communication Streaming data from SPE to SPE Example from recitation 1: Divide up so one SPE does multiplication, another does addition Keep actual data transfer local store to local store How to handle synchronization messages? All messages go through PPE for (int i = 0; i < NUM_ELEMENTS; i++) { data[i] = data[i] * MUL_FACTOR + ADD_FACTOR; } SPEs talk to each other directly via mailboxes/signals IAP 2007 MIT
13 rec2/dma_2spe/ SPE-SPE Example SPEs that communicate with each other need to know: Addresses of local stores Addresses of MMIO registers Only PPU program (via libspe) has access to this information Create SPE threads Gather local store and MMIO register addresses spe_get_ls spe_get_ps_area Send addresses to all SPEs IAP 2007 MIT
14 rec2/dma_2spe/ SPE-SPE Example PPU SPU 0 SPU 1 PPU // Create SPE threads for multiplier and // adder id[0] = spe_create_thread(0, &dma_spu0, 0, NULL,...); id[1] = spe_create_thread(0, &dma_spu1, 1, NULL,...); IAP 2007 MIT
15 rec2/dma_2spe/ SPE-SPE Example PPU Initialization SPU 0 SPU 1 PPU typedef struct { uintptr32_t spu_ls[2]; uintptr32_t spu_control[2];... } CONTROL_BLOCK; // Fill in control block for (int i = 0; i < 2; i++) { cb.spu_ls[i] = spe_get_ls(id[i]); cb.spu_control[i] = spe_get_ps_area(id[i], SPE_CONTROL_AREA); }... // Send control block address to all SPUs for (int i = 0; i < 2; i++) { spe_write_in_mbox(id[i], &cb); } Both SPUs // Wait for control block address from PPU cb_addr = spu_read_in_mbox(); // DMA over control block and wait until done mfc_get(&cb, cb_addr, sizeof(cb), 5,...); mfc_write_tag_mask(1 << 5); mfc_read_tag_status_all(); IAP 2007 MIT
16 rec2/dma_2spe/ SPE-SPE Example PPU Initialization SPU 0 SPU 1 SPU 0 // DMA in data from memory and wait until // complete mfc_get(data, cb.data_addr, data_size,...); mfc_read_tag_status_all(); Data IAP 2007 MIT
17 rec2/dma_2spe/ SPE-SPE Example PPU Initialization // Process data... SPU 0 SPU 0 SPU 1 Data IAP 2007 MIT
18 rec2/dma_2spe/ SPE-SPE Example PPU Initialization SPU 0 SPU 1 Address SPU 0 // Temporary area used to store values to be // sent to mailboxes with proper alignment struct { uint32_t padding[3]; uint32_t value; } next_mbox attribute ((aligned(16))); // Notify SPU 1 that data is ready. Send over // virtual address so SPU 1 can copy it out. next_mbox.value = cb.spu_ls[0] + data; mfc_put(&next_mbox.value, cb.spu_control[1] + 12, 4,...); SPU 1 // Wait for mailbox message from SPU 0 // indicating data is ready data_addr = spu_read_in_mbox(); Data Mailbox IAP 2007 MIT
19 rec2/dma_2spe/ SPE-SPE Example PPU Initialization SPU 1 // DMA in data from SPU 0 local store and // wait until complete mfc_get(data, data_addr, data_size,...); mfc_read_tag_status_all(); SPU 0 SPU 1 Address Data Mailbox IAP 2007 MIT
20 rec2/dma_2spe/ SPE-SPE Example PPU Initialization SPU 0 SPU 1 // Notify SPU 0 that data has been read mfc_put(<garbage>, cb.spu_control[0] + 12, 4,...); // Process data... SPU 1 Address SPU 0 // Wait for acknowledgement from SPU 1 spu_read_in_mbox(); return 0; Data Mailbox IAP 2007 MIT
21 rec2/dma_2spe/ SPE-SPE Example PPU Initialization SPU 1 // DMA processed data back to memory and wait // until complete mfc_put(data, cb.data_addr, data_size,...); mfc_read_tag_status_all(); SPU 0 SPU 1 Address Data Mailbox IAP 2007 MIT
22 rec2/dma_2spe/ SPE-SPE Example PPU Initialization SPU 1 // Notify PPU spu_write_out_mbox(0); return 0; SPU 0 SPU 1 PPU // Wait for mailbox message from SPU 1 while (spe_stat_out_mbox(id[1]) == 0); spe_read_out_mbox(id[1]); Address Data Mailbox IAP 2007 MIT
23 Recitation Plan Lab 1 solution SPE-SPE communication Patterns for mapping computation to SPEs Cell-ifying a sample program Hands on programming Optimizations Useful resources IAP 2007 MIT
24 Mapping Computation to SPEs Original single-threaded program performs many computation stages on data Data in memory f1 f2 f3 How to map to SPEs? IAP 2007 MIT
25 Mapping Computation to SPEs Each SPE contains all computation stages Split up data and send to different SPEs SPU SPU SPU Data in memory f1 f1 f1 f2 f2 f2 f3 f3 f IAP 2007 MIT
26 Mapping Computation to SPEs Map computation stages to different SPEs Use DMA to transfer intermediate results from SPE to SPE in pipeline fashion Data in memory SPU f1 SPU f2 SPU f IAP 2007 MIT
27 Mapping Computation to SPEs Mixed approaches, other approaches are sible Depends on problem More detail in future lectures SPU SPU SPU f1 f2 f3 f1 f2 f3 f1 f2 f3 SPU f1 SPU f2 SPU f IAP 2007 MIT
28 Recitation Plan Lab 1 solution SPE-SPE communication Patterns for mapping computation to SPEs Cell-ifying a sample program Hands on programming Optimizations Useful resources IAP 2007 MIT
29 Cell-ifying a Program Simple 3D gravitational body simulator n objects, each with mass, initial ition, initial velocity float mass[num_bodies]; VEC3D [NUM_BODIES]; VEC3D vel[num_bodies]; Simulate motion using Euler integration IAP 2007 MIT
30 Single-threaded Version For each step in simulation Calculate acceleration of all objects For each pair of objects, calculate the force between them and update accelerations accordingly VEC3D acc[num_bodies] = 0; for (i = 0; i < NUM_BODIES - 1; i++) { for (j = i + 1; j < NUM_BODIES; j++) { // Displacement vector VEC3D d = [j] [i]; // Force t = 1 / sqr(length(d)); // Components of force along displacement d = t * (d / length(d)); } } acc[i] += d * mass[j]; acc[j] += -d * mass[i]; Update itions and velocities VEC3D acc[num_bodies] = 0; for (i = 0; i < NUM_BODIES; i++) { [i] += vel[i] * TIMESTEP; vel[i] += acc[i] * TIMESTEP; } IAP 2007 MIT
31 Exercise (5 minutes) Run single-threaded version Get the recitation 2 tarball wget tar zxf rec2.tar.gz Build the program cd rec2/sim make Run the program./sim Amount of time taken to perform each simulation step is printed n = 3072 objects Stop program by pressing Ctrl+C IAP 2007 MIT
32 Single-threaded Version Slow! Speed it up by using SPEs Linux on PS3 has 6 physical SPEs available Ideas? IAP 2007 MIT
33 rec2/sim2/ Cell-ified Version Divide objects into 6 sections (n = 3072 = 6 * 512) SPU 0 SPU 1 SPU 2 SPU 3 SPU 4 SPU 5 Each SPU is responsible for calculating the motion of one section of objects SPU still needs to know mass, ition of all objects to compute accelerations SPU only needs to know and update velocity of the objects it is responsible for Everything fits in local store Positions for 3072 objects take up 36 KB IAP 2007 MIT
34 rec2/sim2/ Cell-ified Version Initialization PPU tells SPU which section of objects it is responsible for // Pass id in envp id = envp; own_mass = mass[id]; own_ = [id]; PPU/Memory // Index [i] stores mass/ition of objects SPU i // is responsible for float mass[6][spu_bodies]; VEC3D [6][SPU_BODIES]; // The section of objects this SPU is responsible for int id; // Pointer to [id] VEC3D *own_; // Velocity for this SPU's objects VEC3D own_vel[spu_bodies]; mass initial vel mass SPU 2 vel IAP 2007 MIT
35 rec2/sim2/ Cell-ified Version SPU copies in mass of all objects mfc_get(mass, cb.mass_addr, sizeof(mass),...); SPU copies in initial ition, velocity of its objects mfc_get(own_, cb._addr + id * sizeof([0]), sizeof([0]),...); mfc_get(own_vel, cb.vel_addr + id * sizeof(own_vel), sizeof(own_vel),...); PPU/Memory mass SPU 2 initial vel mass vel IAP 2007 MIT
36 rec2/sim2/ Cell-ified Version Simulation step PPU sends message telling SPU to simulate one step spu_read_in_mbox(); PPU/Memory SPU 2 vel IAP 2007 MIT
37 rec2/sim2/ Cell-ified Version SPU copies in updated itions of other objects if (id!= 0) { mfc_get(, cb._addr + id * sizeof([0]), id * sizeof([0]),...); }; if (id!= 5) { mfc_get([id + 1], cb._addr + (id + 1) * sizeof([0]), (5 id) * sizeof([0]),...); } PPU/Memory SPU 2 vel IAP 2007 MIT
38 rec2/sim2/ Cell-ified Version SPU sends message to PPU indicating it has finished copying itions PPU waits for this message before it can tell other SPUs to write back itions at end of simulation step spu_write_out_mbox(0); PPU/Memory SPU 2 vel IAP 2007 MIT
39 rec2/sim2/ Cell-ified Version SPU calculates acceleration and updates ition and velocity of its objects // Process interactions between this SPU's objects process_own(); // Process interactions with other objects for (int i = 0; i < 6; i++) { if (i!= id) { process_other([i], mass[i]); } } PPU/Memory SPU 2 vel IAP 2007 MIT
40 rec2/sim2/ Cell-ified Version SPU waits for message from PPU indicating it can write back updated itions spu_read_in_mbox(); PPU/Memory SPU 2 vel IAP 2007 MIT
41 rec2/sim2/ Cell-ified Version SPU writes back updated itions to PPU mfc_put(own_, cb._addr + id * sizeof([0]), sizeof([0]),...); PPU/Memory SPU 2 vel IAP 2007 MIT
42 rec2/sim2/ Cell-ified Version SPU sends message to PPU indicating it is done simulation step spu_write_out_mbox(0); PPU/Memory SPU 2 vel IAP 2007 MIT
43 Cell-ified Version Acceleration calculation In single-threaded version, we calculate distance between each pair of objects once In Cell-ified version, if 2 SPUs are responsible for objects i and j, each SPU will calculate the distance separately With 6 SPEs, what speedup can we expect? IAP 2007 MIT
44 Exercise (15 minutes) Read over the code for the Cell-ified version rec2/sim2/spu/sim_spu.c rec2/sim2/sim.c Build and run the program cd rec2/sim2 make./sim What happened? DMA size limit exceeded Fix it Build and run it again IAP 2007 MIT
45 Overlapping DMA and Computation We are currently doing this: Get Data SPU is idle DMA engine is idle Compute Synchronization point We can use pipelining to achieve communication-computation concurrency Start DMA for next piece of data while processing current piece Get Data Compute IAP 2007 MIT
46 rec2/sim3/ Overlapping DMA and Computation // [i] stores itions of objects SPU i is // responsible for VEC3D [6][SPU_BODIES]; // Start transfer for first section of itions i = 0; tag = 0; mfc_get([i], cb._addr + i * sizeof([0]), sizeof([0]), tag,...); tag ^= 1; // Process interactions between objects this SPU // is responsible for process_own(); Get Data Compute PPU/Memory SPU IAP 2007 MIT
47 rec2/sim3/ Overlapping DMA and Computation while (!done) { // Start transfer for next section of itions mfc_get([next_i], cb._addr + next_i * sizeof([0]), sizeof([0]), tag,...); // Wait for current section of itions to // finish transferring tag ^= 1; mfc_write_tag_mask(1 << tag); mfc_read_tag_status_all(); // Process interactions process_other([i], mass[i]); Get Data Compute PPU/Memory } i = next_i; SPU IAP 2007 MIT
48 rec2/sim3/ Overlapping DMA and Computation while (!done) { // Start transfer for next section of itions mfc_get([next_i], cb._addr + next_i * sizeof([0]), sizeof([0]), tag,...); // Wait for current section of itions to // finish transferring tag ^= 1; mfc_write_tag_mask(1 << tag); mfc_read_tag_status_all(); // Process interactions process_other([i], mass[i]); Get Data Compute PPU/Memory } i = next_i; SPU IAP 2007 MIT
49 rec2/sim3/ Overlapping DMA and Computation while (!done) { // Start transfer for next section of itions mfc_get([next_i], cb._addr + next_i * sizeof([0]), sizeof([0]), tag,...); // Wait for current section of itions to // finish transferring tag ^= 1; mfc_write_tag_mask(1 << tag); mfc_read_tag_status_all(); // Process interactions process_other([i], mass[i]); Get Data Compute PPU/Memory } i = next_i; SPU IAP 2007 MIT
50 rec2/sim3/ Overlapping DMA and Computation while (!done) { // Start transfer for next section of itions mfc_get([next_i], cb._addr + next_i * sizeof([0]), sizeof([0]), tag,...); // Wait for current section of itions to // finish transferring tag ^= 1; mfc_write_tag_mask(1 << tag); mfc_read_tag_status_all(); // Process interactions process_other([i], mass[i]); Get Data Compute PPU/Memory } i = next_i; SPU IAP 2007 MIT
51 rec2/sim3/ Overlapping DMA and Computation // Wait for last section of itions to finish // transferring tag ^= 1; mfc_write_tag_mask(1 << tag); mfc_read_tag_status_all(); // Notify PPU that itions have been read spu_write_out_mbox(0); // Process interactions process_other([i], mass[i]); Get Data Compute PPU/Memory SPU IAP 2007 MIT
52 Overlapping DMA and Computation Performance improvement? For this program, computation >> communication O(n 2 ) computation, O(n) communication Get Data Compute Get Data Compute Pipelining can improve performance by a lot, or not by much Depends on specifics of program Can avoid optimizing parts that don t greatly affect performance IAP 2007 MIT
53 Double-buffering We re wasting local store space Keep 2 buffers Start data transfer into one Process data in other Swap buffers for next transfer PPU/Memory SPU IAP 2007 MIT
54 Double-buffering PPU/Memory SPU IAP 2007 MIT
55 Double-buffering PPU/Memory SPU IAP 2007 MIT
56 Double-buffering PPU/Memory SPU IAP 2007 MIT
57 Exercise (20 minutes) Read over the code for the pipelined version rec2/sim3/spu/sim_spu.c Implement double-buffering Start from the pipelined version IAP 2007 MIT
58 Recitation Plan Lab 1 solution SPE-SPE communication Patterns for mapping computation to SPEs Cell-ifying a sample program Hands on programming Optimizations Useful resources IAP 2007 MIT
59 Other Performance Optimizations Keep data transfer on-chip Copy updated itions of other objects from the local store of the SPU responsible for them instead of memory Most likely will not affect performance by much SIMD-ization Loop unrolling Future lectures and recitations IAP 2007 MIT
60 SPE Threads Not the same as normal threads SPE does not have protection, can only run one thread at a time PPU can forcibly context-switch a SPE by saving context, copying out old local store/context, copying in new Current SDK does not support context switching SPEs SPE threads are run on physical SPEs in FIFO order If more threads than SPEs, additional threads will wait for running threads to exit before starting Don t create more threads than physical SPEs Cell processor has 8 physical SPEs, 6 enabled on PS3 Linux IAP 2007 MIT
61 More Useful Functions PPU (libspe) SPE thread groups and events SPU Wait or poll for interrupting mailbox messages and other events from all threads in a group spe_create_group, spe_get_event SPE events Wait or poll for mailbox/signals/dma completion/other by mask spu_write_event_mask, spu_read_event_status, spu_stat_event_status, spu_write_event_ack SPU decrementer Register that counts down at a fixed rate Accurately time parts of SPU program spu_read_decrementer, spu_write_decrementer IAP 2007 MIT
62 List of Useful Functions PPU (libspe) spe_create_thread spe_wait spe_write_in_mbox spe_stat_in_mbox spe_read_out_mbox spe_stat_out_mbox spe_write_signal spe_get_ls spe_get_ps_area spe_mfc_get spe_mfc_put spe_mfc_read_tag_status spe_create_group spe_get_event mfc_get mfc_put mfc_stat_cmd_queue mfc_write_tag_mask mfc_read_tag_status_all/any/immediate spu_read_in_mbox spu_stat_in_mbox spu_write_out_mbox, spu_write_out_intr_mbox spu_stat_out_mbox, spu_stat_out_intr_mbox spu_read_signal1/2 spu_stat_signal1/2 spu_write_event_mask spu_read_event_status spu_stat_event_status spu_write_event_ack spu_read_decrementer spu_write_decrementer SPU IAP 2007 MIT
MIT OpenCourseWare Multicore Programming Primer, January (IAP) Please use the following citation format:
MIT OpenCourseWare http://ocw.mit.edu 6.189 Multicore Programming Primer, January (IAP) 2007 Please use the following citation format: David Zhang, 6.189 Multicore Programming Primer, January (IAP) 2007.
MIT OpenCourseWare Multicore Programming Primer, January (IAP) Please use the following citation format:
MIT OpenCourseWare http://ocw.mit.edu 6.189 Multicore Programming Primer, January (IAP) 2007 Please use the following citation format: Rodric Rabbah, 6.189 Multicore Programming Primer, January (IAP) 2007.
SPE Runtime Management Library. Version 1.1. CBEA JSRE Series Cell Broadband Engine Architecture Joint Software Reference Environment Series
SPE Runtime Management Library Version 1.1 CBEA JSRE Series Cell Broadband Engine Architecture Joint Software Reference Environment Series June 15, 2006 Copyright International Business Machines Corporation,
MIT OpenCourseWare Multicore Programming Primer, January (IAP) Please use the following citation format:
MIT OpenCourseWare http://ocw.mit.edu 6.189 Multicore Programming Primer, January (IAP) 2007 Please use the following citation format: Phil Sung, 6.189 Multicore Programming Primer, January (IAP) 2007.
Concurrent Programming with the Cell Processor. Dietmar Kühl Bloomberg L.P.
Concurrent Programming with the Cell Processor Dietmar Kühl Bloomberg L.P. dietmar.kuehl@gmail.com Copyright Notice 2009 Bloomberg L.P. Permission is granted to copy, distribute, and display this material,
PS3 Programming. Week 4. Events, Signals, Mailbox Chap 7 and Chap 13
PS3 Programming Week 4. Events, Signals, Mailbox Chap 7 and Chap 13 Outline Event PPU s event SPU s event Mailbox Signal Homework EVENT PPU s event PPU can enable events when creating SPE s context by
Developing Code for Cell - Mailboxes
Developing Code for Cell - Mailboxes Course Code: L3T2H1-55 Cell Ecosystem Solutions Enablement 1 Course Objectives Things you will learn Cell communication mechanisms mailboxes (this course) and DMA (another
Beyond Gaming: Programming the PS3 Cell Architecture for Cost-Effective Parallel Processing. IBM Watson Center. Rodric Rabbah, IBM
Beyond Gaming: Programming the PS3 Cell Architecture for Cost-Effective Parallel Processing Rodric Rabbah IBM Watson Center 1 Get a PS3, Add Linux The PS3 can boot user installed Operating Systems Dual
PS3 Programming. Week 2. PPE and SPE The SPE runtime management library (libspe)
PS3 Programming Week 2. PPE and SPE The SPE runtime management library (libspe) Outline Overview Hello World Pthread version Data transfer and DMA Homework PPE/SPE Architectural Differences The big picture
6.189 IAP Lecture 5. Parallel Programming Concepts. Dr. Rodric Rabbah, IBM IAP 2007 MIT
6.189 IAP 2007 Lecture 5 Parallel Programming Concepts 1 6.189 IAP 2007 MIT Recap Two primary patterns of multicore architecture design Shared memory Ex: Intel Core 2 Duo/Quad One copy of data shared among
Cell Programming Tutorial JHD
Cell Programming Tutorial Jeff Derby, Senior Technical Staff Member, IBM Corporation Outline 2 Program structure PPE code and SPE code SIMD and vectorization Communication between processing elements DMA,
CELL CULTURE. Sony Computer Entertainment, Application development for the Cell processor. Programming. Developing for the Cell. Programming the Cell
Dmitry Sunagatov, Fotolia Application development for the Cell processor CELL CULTURE The Cell architecπture is finding its way into a vast range of computer systems from huge supercomputers to inauspicious
MIT OpenCourseWare Multicore Programming Primer, January (IAP) Please use the following citation format:
MIT OpenCourseWare http://ocw.mit.edu 6.189 Multicore Programming Primer, January (IAP) 2007 Please use the following citation format: Rodric Rabbah, 6.189 Multicore Programming Primer, January (IAP) 2007.
Exercise Euler Particle System Simulation
Exercise Euler Particle System Simulation Course Code: L3T2H1-57 Cell Ecosystem Solutions Enablement 1 Course Objectives The student should get ideas of how to get in welldefined steps from scalar code
A Proposal to Extend the OpenMP Tasking Model for Heterogeneous Architectures
A Proposal to Extend the OpenMP Tasking Model for Heterogeneous Architectures E. Ayguade 1,2, R.M. Badia 2,4, D. Cabrera 2, A. Duran 2, M. Gonzalez 1,2, F. Igual 3, D. Jimenez 1, J. Labarta 1,2, X. Martorell
C/C++ Language Extensions for Cell Broadband Engine Architecture
C/C++ Language Extensions for Cell Broadband Engine Architecture Version 2.2.1 CBEA JSRE Series Cell Broadband Engine Architecture Joint Software Reference Environment Series November 27, 2006 Copyright
The Pennsylvania State University. The Graduate School. College of Engineering A NEURAL NETWORK BASED CLASSIFIER ON THE CELL BROADBAND ENGINE
The Pennsylvania State University The Graduate School College of Engineering A NEURAL NETWORK BASED CLASSIFIER ON THE CELL BROADBAND ENGINE A Thesis in Electrical Engineering by Srijith Rajamohan 2009
C/C++ Language Extensions for Cell Broadband Engine Architecture
C/C++ Language Extensions for Cell Broadband Engine Architecture Version 2.5 CBEA JSRE Series Cell Broadband Engine Architecture Joint Software Reference Environment Series September 14, 2007 Copyright
Cell Processor and Playstation 3
Cell Processor and Playstation 3 Guillem Borrell i Nogueras February 24, 2009 Cell systems Bad news More bad news Good news Q&A IBM Blades QS21 Cell BE based. 8 SPE 460 Gflops Float 20 GFLops Double QS22
Lesson 2 - SPU Communication and DMA
Lesson 2 - SPU Communication and DMA Summary This lesson will demonstrate basic SPU / PPU communication and SPU DMA, by showing how to send Square Matrices to the SPU to be multiplied together, and send
( ZIH ) Center for Information Services and High Performance Computing. Event Tracing and Visualization for Cell Broadband Engine Systems
( ZIH ) Center for Information Services and High Performance Computing Event Tracing and Visualization for Cell Broadband Engine Systems ( daniel.hackenberg@zih.tu-dresden.de ) Daniel Hackenberg Cell Broadband
Hands-on - DMA Transfer Using Control Block
IBM Systems & Technology Group Cell/Quasar Ecosystem & Solutions Enablement Hands-on - DMA Transfer Using Control Block Cell Programming Workshop Cell/Quasar Ecosystem & Solutions Enablement 1 Class Objectives
Spring 2011 Prof. Hyesoon Kim
Spring 2011 Prof. Hyesoon Kim PowerPC-base Core @3.2GHz 1 VMX vector unit per core 512KB L2 cache 7 x SPE @3.2GHz 7 x 128b 128 SIMD GPRs 7 x 256KB SRAM for SPE 1 of 8 SPEs reserved for redundancy total
Cell Programming Tips & Techniques
Cell Programming Tips & Techniques Course Code: L3T2H1-58 Cell Ecosystem Solutions Enablement 1 Class Objectives Things you will learn Key programming techniques to exploit cell hardware organization and
Introduction to CELL B.E. and GPU Programming. Agenda
Introduction to CELL B.E. and GPU Programming Department of Electrical & Computer Engineering Rutgers University Agenda Background CELL B.E. Architecture Overview CELL B.E. Programming Environment GPU
Programming IBM PowerXcell 8i / QS22 libspe2, ALF, DaCS
Programming IBM PowerXcell 8i / QS22 libspe2, ALF, DaCS Jordi Caubet. IBM Spain. IBM Innovation Initiative @ BSC-CNS ScicomP 15 18-22 May 2009, Barcelona, Spain 1 Overview SPE Runtime Management Library
high performance medical reconstruction using stream programming paradigms
high performance medical reconstruction using stream programming paradigms This Paper describes the implementation and results of CT reconstruction using Filtered Back Projection on various stream programming
Programming for Performance on the Cell BE processor & Experiences at SSSU. Sri Sathya Sai University
Programming for Performance on the Cell BE processor & Experiences at SSSU Sri Sathya Sai University THE STI CELL PROCESSOR The Inevitable Shift to the era of Multi-Core Computing The 9-core Cell Microprocessor
Blue-Steel Ray Tracer
MIT 6.189 IAP 2007 Student Project Blue-Steel Ray Tracer Natalia Chernenko Michael D'Ambrosio Scott Fisher Russel Ryan Brian Sweatt Leevar Williams Game Developers Conference March 7 2007 1 Imperative
Porting an MPEG-2 Decoder to the Cell Architecture
Porting an MPEG-2 Decoder to the Cell Architecture Troy Brant, Jonathan Clark, Brian Davidson, Nick Merryman Advisor: David Bader College of Computing Georgia Institute of Technology Atlanta, GA 30332-0250
The University of Texas at Austin
EE382N: Principles in Computer Architecture Parallelism and Locality Fall 2009 Lecture 24 Stream Processors Wrapup + Sony (/Toshiba/IBM) Cell Broadband Engine Mattan Erez The University of Texas at Austin
Copyright 2010, Elsevier Inc. All rights Reserved
An Introduction to Parallel Programming Peter Pacheco Chapter 6 Parallel Program Development 1 Roadmap Solving non-trivial problems. The n-body problem. The traveling salesman problem. Applying Foster
Chapter 3: Processes. Operating System Concepts Essentials 2 nd Edition
Chapter 3: Processes Silberschatz, Galvin and Gagne 2013 Chapter 3: Processes Process Concept Process Scheduling Operations on Processes Interprocess Communication Examples of IPC Systems Communication
SPE Runtime Management Library
SPE Runtime Management Library Version 2.0 CBEA JSRE Series Cell Broadband Engine Architecture Joint Software Reference Environment Series November 11, 2006 Table of Contents 2 Copyright International
Massively Parallel Architectures
Massively Parallel Architectures A Take on Cell Processor and GPU programming Joel Falcou - LRI joel.falcou@lri.fr Bat. 490 - Bureau 104 20 janvier 2009 Motivation The CELL processor Harder,Better,Faster,Stronger
Chapter 3: Processes
Chapter 3: Processes Silberschatz, Galvin and Gagne 2013 Chapter 3: Processes Process Concept Process Scheduling Operations on Processes Interprocess Communication Examples of IPC Systems Communication
Chapter 3: Process-Concept. Operating System Concepts 8 th Edition,
Chapter 3: Process-Concept, Silberschatz, Galvin and Gagne 2009 Chapter 3: Process-Concept Process Concept Process Scheduling Operations on Processes Interprocess Communication 3.2 Silberschatz, Galvin
Multicore Challenge in Vector Pascal. P Cockshott, Y Gdura
Multicore Challenge in Vector Pascal P Cockshott, Y Gdura N-body Problem Part 1 (Performance on Intel Nehalem ) Introduction Data Structures (1D and 2D layouts) Performance of single thread code Performance
PS3 programming basics. Week 1. SIMD programming on PPE Materials are adapted from the textbook
PS3 programming basics Week 1. SIMD programming on PPE Materials are adapted from the textbook Overview of the Cell Architecture XIO: Rambus Extreme Data Rate (XDR) I/O (XIO) memory channels The PowerPC
Production. Visual Effects. Fluids, RBD, Cloth. 2. Dynamics Simulation. 4. Compositing
Visual Effects Pr roduction on the Cell/BE Andrew Clinton, Side Effects Software Visual Effects Production 1. Animation Character, Keyframing 2. Dynamics Simulation Fluids, RBD, Cloth 3. Rendering Raytrac
Introduction to Computing and Systems Architecture
Introduction to Computing and Systems Architecture 1. Computability A task is computable if a sequence of instructions can be described which, when followed, will complete such a task. This says little
Cell-MPI. Mastering the Cell Broadband Engine architecture through a Boost based parallel communication library
Cell-MPI Mastering the Cell Broadband Engine architecture through a Boost based parallel communication library Sebastian Schaetz, Joel Falcou, Lionel Lacassagne Digiteo Foundation, LRI - University Paris
CellSs Making it easier to program the Cell Broadband Engine processor
Perez, Bellens, Badia, and Labarta CellSs Making it easier to program the Cell Broadband Engine processor Presented by: Mujahed Eleyat Outline Motivation Architecture of the cell processor Challenges of
Cell Programming Maciej Cytowski (ICM) PRACE Workshop New Languages & Future Technology Prototypes, March 1-2, LRZ, Germany
Cell Programming Maciej Cytowski (ICM) PRACE Workshop New Languages & Future Technology Prototypes, March 1-2, LRZ, Germany Agenda Introduction to technology Cell programming models SPE runtime management
Chapter 13: I/O Systems
COP 4610: Introduction to Operating Systems (Spring 2015) Chapter 13: I/O Systems Zhi Wang Florida State University Content I/O hardware Application I/O interface Kernel I/O subsystem I/O performance Objectives
Neil Costigan School of Computing, Dublin City University PhD student / 2 nd year of research.
Crypto On the Cell Neil Costigan School of Computing, Dublin City University. neil.costigan@computing.dcu.ie +353.1.700.6916 PhD student / 2 nd year of research. Supervisor : - Dr Michael Scott. IRCSET
Chapter 3 Processes. Process Concept. Process Concept. Process Concept (Cont.) Process Concept (Cont.) Process Concept (Cont.)
Process Concept Chapter 3 Processes Computers can do several activities at a time Executing user programs, reading from disks writing to a printer, etc. In multiprogramming: CPU switches from program to
Chapter 3: Process Concept
Chapter 3: Process Concept Chapter 3: Process Concept Process Concept Process Scheduling Operations on Processes Inter-Process Communication (IPC) Communication in Client-Server Systems Objectives 3.2
Chapter 3: Process Concept
Chapter 3: Process Concept Chapter 3: Process Concept Process Concept Process Scheduling Operations on Processes Inter-Process Communication (IPC) Communication in Client-Server Systems Objectives 3.2
Lecture 16. Introduction to Game Development IAP 2007 MIT
6.189 IAP 2007 Lecture 16 Introduction to Game Development Mike Acton, Insomiac Games. 6.189 IAP 2007 MIT Introduction to Game Development (on the Playstation 3 / Cell ) Mike Acton Engine Director, Insomniac
MIT OpenCourseWare Multicore Programming Primer, January (IAP) Please use the following citation format:
MIT OpenCourseWare http://ocw.mit.edu 6.189 Multicore Programming Primer, January (IAP) 2007 Please use the following citation format: Phil Sung, 6.189 Multicore Programming Primer, January (IAP) 2007.
Cell Based Servers for Next-Gen Games
Cell BE for Digital Animation and Visual F/X Cell Based Servers for Next-Gen Games Cell BE Online Game Prototype Bruce D Amora T.J. Watson Research Yorktown Heights, NY Karen Magerlein T.J. Watson Research
CS 43: Computer Networks. 07: Concurrency and Non-blocking I/O Sep 17, 2018
CS 43: Computer Networks 07: Concurrency and Non-blocking I/O Sep 17, 2018 Reading Quiz Lecture 5 - Slide 2 Today Under-the-hood look at system calls Data buffering and blocking Inter-process communication
Crypto On the Playstation 3
Crypto On the Playstation 3 Neil Costigan School of Computing, DCU. neil.costigan@computing.dcu.ie +353.1.700.6916 PhD student / 2 nd year of research. Supervisor : - Dr Michael Scott. IRCSET funded. Playstation
Chapter 3: Process Concept
Chapter 3: Process Concept Silberschatz, Galvin and Gagne 2013! Chapter 3: Process Concept Process Concept" Process Scheduling" Operations on Processes" Inter-Process Communication (IPC)" Communication
After a Cell Broadband Engine program executes without errors on the PPE and the SPEs, optimization through parameter-tuning can begin.
Performance Main topics: Performance analysis Performance issues Static analysis of SPE threads Dynamic analysis of SPE threads Optimizations Static analysis of optimization Dynamic analysis of optimizations
Low-Level C Programming. Memory map Pointers Arrays Structures
Low-Level C Programming Memory map Pointers Arrays Structures Memory Map 0x7FFF_FFFF Binaries load at 0x20000 by default Stack start set by binary when started Stack grows downwards You will need one stack
COP 4610: Introduction to Operating Systems (Spring 2016) Chapter 3: Process. Zhi Wang Florida State University
COP 4610: Introduction to Operating Systems (Spring 2016) Chapter 3: Process Zhi Wang Florida State University Contents Process concept Process scheduling Operations on processes Inter-process communication
Chapter 5: Processes & Process Concept. Objectives. Process Concept Process Scheduling Operations on Processes. Communication in Client-Server Systems
Chapter 5: Processes Chapter 5: Processes & Threads Process Concept Process Scheduling Operations on Processes Interprocess Communication Communication in Client-Server Systems, Silberschatz, Galvin and
CprE 288 Introduction to Embedded Systems Exam 1 Review. 1
CprE 288 Introduction to Embedded Systems Exam 1 Review http://class.ece.iastate.edu/cpre288 1 Overview of Today s Lecture Announcements Exam 1 Review http://class.ece.iastate.edu/cpre288 2 Announcements
CISC 879 Software Support for Multicore Architectures Spring Student Presentation 6: April 8. Presenter: Pujan Kafle, Deephan Mohan
CISC 879 Software Support for Multicore Architectures Spring 2008 Student Presentation 6: April 8 Presenter: Pujan Kafle, Deephan Mohan Scribe: Kanik Sem The following two papers were presented: A Synchronous
SPE Runtime Management Library Version 2.2
CBEA JSRE Series Cell Broadband Engine Architecture Joint Software Reference Environment Series SPE Runtime Management Library Version 2.2 SC33-8334-01 CBEA JSRE Series Cell Broadband Engine Architecture
Hands-on - DMA Transfer Using get and put Buffer
IBM Systems & Technology Group Cell/Quasar Ecosystem & Solutions Enablement Hands-on - DMA Transfer Using get and put Buffer Cell Programming Workshop Cell/Quasar Ecosystem & Solutions Enablement 1 Class
Parallel Exact Inference on the Cell Broadband Engine Processor
Parallel Exact Inference on the Cell Broadband Engine Processor Yinglong Xia and Viktor K. Prasanna {yinglonx, prasanna}@usc.edu University of Southern California http://ceng.usc.edu/~prasanna/ SC 08 Overview
OpenMP on the IBM Cell BE
OpenMP on the IBM Cell BE PRACE Barcelona Supercomputing Center (BSC) 21-23 October 2009 Marc Gonzalez Tallada Index OpenMP programming and code transformations Tiling and Software Cache transformations
Chapter 3: Processes
Chapter 3: Processes Silberschatz, Galvin and Gagne 2013 Chapter 3: Processes Process Concept Process Scheduling Operations on Processes Interprocess Communication 3.2 Silberschatz, Galvin and Gagne 2013
CS5460: Operating Systems
CS5460: Operating Systems Lecture 2: OS Hardware Interface (Chapter 2) Course web page: http://www.eng.utah.edu/~cs5460/ CADE lab: WEB L224 and L226 http://www.cade.utah.edu/ Projects will be on Linux
Evaluating the Portability of UPC to the Cell Broadband Engine
Evaluating the Portability of UPC to the Cell Broadband Engine Dipl. Inform. Ruben Niederhagen JSC Cell Meeting CHAIR FOR OPERATING SYSTEMS Outline Introduction UPC Cell UPC on Cell Mapping Compiler and
CS 471 Operating Systems. Yue Cheng. George Mason University Fall 2017
CS 471 Operating Systems Yue Cheng George Mason University Fall 2017 Outline o Process concept o Process creation o Process states and scheduling o Preemption and context switch o Inter-process communication
Chapter 5 - Input / Output
Chapter 5 - Input / Output Luis Tarrataca luis.tarrataca@gmail.com CEFET-RJ L. Tarrataca Chapter 5 - Input / Output 1 / 90 1 Motivation 2 Principle of I/O Hardware I/O Devices Device Controllers Memory-Mapped
Memory Architectures. Week 2, Lecture 1. Copyright 2009 by W. Feng. Based on material from Matthew Sottile.
Week 2, Lecture 1 Copyright 2009 by W. Feng. Based on material from Matthew Sottile. Directory-Based Coherence Idea Maintain pointers instead of simple states with each cache block. Ingredients Data owners
A Transport Kernel on the Cell Broadband Engine
A Transport Kernel on the Cell Broadband Engine Paul Henning Los Alamos National Laboratory LA-UR 06-7280 Cell Chip Overview Cell Broadband Engine * (Cell BE) Developed under Sony-Toshiba-IBM efforts Current
Process. Operating Systems (Fall/Winter 2018) Yajin Zhou ( Zhejiang University
Operating Systems (Fall/Winter 2018) Process Yajin Zhou (http://yajin.org) Zhejiang University Acknowledgement: some pages are based on the slides from Zhi Wang(fsu). Review System calls implementation
Cell Broadband Engine Architecture. Version 1.02
Copyright and Disclaimer Copyright International Business Machines Corporation, Sony Computer Entertainment Incorporated, Toshiba Corporation 2005, 2007 All Rights Reserved Printed in the United States
/INFOMOV/ Optimization & Vectorization. J. Bikker - Sep-Nov Lecture 4: Caching (2) Welcome!
/INFOMOV/ Optimization & Vectorization J. Bikker - Sep-Nov 2017 - Lecture 4: Caching (2) Welcome! Today s Agenda: Caching: Recap Data Locality Alignment False Sharing A Handy Guide (to Pleasing the Cache)
/INFOMOV/ Optimization & Vectorization. J. Bikker - Sep-Nov Lecture 5: Caching (2) Welcome!
/INFOMOV/ Optimization & Vectorization J. Bikker - Sep-Nov 2016 - Lecture 5: Caching (2) Welcome! Today s Agenda: Caching: Recap Data Locality Alignment False Sharing A Handy Guide (to Pleasing the Cache)
Process Concept Process Scheduling Operations On Process Inter-Process Communication Communication in Client-Server Systems
Process Concept Process Scheduling Operations On Process Inter-Process Communication Communication in Client-Server Systems Process Process VS Program Process in Memory Process State Process Control Block
ECE 550D Fundamentals of Computer Systems and Engineering. Fall 2017
ECE 550D Fundamentals of Computer Systems and Engineering Fall 2017 The Operating System (OS) Prof. John Board Duke University Slides are derived from work by Profs. Tyler Bletsch and Andrew Hilton (Duke)
The control of I/O devices is a major concern for OS designers
Lecture Overview I/O devices I/O hardware Interrupts Direct memory access Device dimensions Device drivers Kernel I/O subsystem Operating Systems - June 26, 2001 I/O Device Issues The control of I/O devices
Compiling Effectively for Cell B.E. with GCC
Compiling Effectively for Cell B.E. with GCC Ira Rosen David Edelsohn Ben Elliston Revital Eres Alan Modra Dorit Nuzman Ulrich Weigand Ayal Zaks IBM Haifa Research Lab IBM T.J.Watson Research Center IBM
SPU Render. Arseny Zeux Kapoulkine CREAT Studios
SPU Render Arseny Zeux Kapoulkine CREAT Studios arseny.kapoulkine@gmail.com http://zeuxcg.org/ Introduction Smash Cars 2 project Static scene of moderate size Many dynamic objects Multiple render passes
Optimising for the p690 memory system
Optimising for the p690 memory Introduction As with all performance optimisation it is important to understand what is limiting the performance of a code. The Power4 is a very powerful micro-processor
Parallel Computing: Parallel Architectures Jin, Hai
Parallel Computing: Parallel Architectures Jin, Hai School of Computer Science and Technology Huazhong University of Science and Technology Peripherals Computer Central Processing Unit Main Memory Computer
CSE 43: Computer Networks Structure, Threading, and Blocking. Kevin Webb Swarthmore College September 14, 2017
CSE 43: Computer Networks Structure, Threading, and Blocking Kevin Webb Swarthmore College September 14, 2017 1 Agenda Under-the-hood look at system calls Data buffering and blocking Processes, threads,
Cell SDK and Best Practices
Cell SDK and Best Practices Stefan Lutz Florian Braune Hardware-Software-Co-Design Universität Erlangen-Nürnberg siflbrau@mb.stud.uni-erlangen.de Stefan.b.lutz@mb.stud.uni-erlangen.de 1 Overview - Introduction
Multicore Programming Case Studies: Cell BE and NVIDIA Tesla Meeting on Parallel Routine Optimization and Applications
Multicore Programming Case Studies: Cell BE and NVIDIA Tesla Meeting on Parallel Routine Optimization and Applications May 26-27, 2008 Juan Fernández (juanf@ditec.um.es) Gregorio Bernabé Manuel E. Acacio
THREADS: (abstract CPUs)
CS 61 Scribe Notes (November 29, 2012) Mu, Nagler, Strominger TODAY: Threads, Synchronization - Pset 5! AT LONG LAST! Adversarial network pong handling dropped packets, server delays, overloads with connection
Chapter 3: Processes. Operating System Concepts 8 th Edition,
Chapter 3: Processes, Silberschatz, Galvin and Gagne 2009 Chapter 3: Processes Process Concept Process Scheduling Operations on Processes Interprocess Communication 3.2 Silberschatz, Galvin and Gagne 2009
Course: Operating Systems Instructor: M Umair. M Umair
Course: Operating Systems Instructor: M Umair Process The Process A process is a program in execution. A program is a passive entity, such as a file containing a list of instructions stored on disk (often
CSE 4/521 Introduction to Operating Systems. Lecture 24 I/O Systems (Overview, Application I/O Interface, Kernel I/O Subsystem) Summer 2018
CSE 4/521 Introduction to Operating Systems Lecture 24 I/O Systems (Overview, Application I/O Interface, Kernel I/O Subsystem) Summer 2018 Overview Objective: Explore the structure of an operating system
High Performance Computing. University questions with solution
High Performance Computing University questions with solution Q1) Explain the basic working principle of VLIW processor. (6 marks) The following points are basic working principle of VLIW processor. The
Discussion 4 Richard Guo SLAB, Buddy, Garbage Collection, and Intro to MIPS 01/30/09
Discussion 4 Richard Guo SLAB, Buddy, Garbage Collection, and Intro to MIPS 01/30/09 1. Answers to Last Time's Problems #include #include struct node int value; // or char or whatever
Input / Output. Kevin Webb Swarthmore College April 12, 2018
Input / Output Kevin Webb Swarthmore College April 12, 2018 xkcd #927 Fortunately, the charging one has been solved now that we've all standardized on mini-usb. Or is it micro-usb? Today s Goals Characterize
Processes & Threads. Process Management. Managing Concurrency in Computer Systems. The Process. What s in a Process?
Process Management Processes & Threads Managing Concurrency in Computer Systems Process management deals with several issues: what are the units of execution how are those units of execution represented
Operating Systems. 09. Memory Management Part 1. Paul Krzyzanowski. Rutgers University. Spring 2015
Operating Systems 09. Memory Management Part 1 Paul Krzyzanowski Rutgers University Spring 2015 March 9, 2015 2014-2015 Paul Krzyzanowski 1 CPU Access to Memory The CPU reads instructions and reads/write
CS61C Midterm Review on C & Memory Management
CS61C Midterm Review on C & Memory Management Fall 2006 Aaron Staley Some material taken from slides by: Michael Le Navtej Sadhal Overview C Array and Pointer Goodness! Memory Management The Three Three
Exploring different level of parallelism Instruction-level parallelism (ILP): how many of the operations/instructions in a computer program can be performed simultaneously 1. e = a + b 2. f = c + d 3.
Hands-on - DMA Transfer Using get Buffer
IBM Systems & Technology Group Cell/Quasar Ecosystem & Solutions Enablement Hands-on - DMA Transfer Using get Buffer Cell Programming Workshop Cell/Quasar Ecosystem & Solutions Enablement 1 Class Objectives
3/7/2018. Sometimes, Knowing Which Thing is Enough. ECE 220: Computer Systems & Programming. Often Want to Group Data Together Conceptually
University of Illinois at Urbana-Champaign Dept. of Electrical and Computer Engineering ECE 220: Computer Systems & Programming Structured Data in C Sometimes, Knowing Which Thing is Enough In MP6, we
CS 31: Introduction to Computer Systems : Threads & Synchronization April 16-18, 2019
CS 31: Introduction to Computer Systems 22-23: Threads & Synchronization April 16-18, 2019 Making Programs Run Faster We all like how fast computers are In the old days (1980 s - 2005): Algorithm too slow?