#include <spu_intrinsics.h>
#include <spu_mfcio.h> /* constant declarations for the MFC */
typedef unsigned long long uint64;
typedef unsigned int uint32;

void convert_buffer_to_upper(char *conversion_buffer, int current_transfer_size);

#define MAX_TRANSFER_SIZE 16384
char conversion_buffer[MAX_TRANSFER_SIZE];

typedef struct {
uint32 length __attribute__((aligned(16)));
uint64 data __attribute__((aligned(16)));
} conversion_structure;

int main(uint64 spe_id, uint64 conversion_info_ea) {
conversion_structure conversion_info; /* Information about the data from the PPE */

/* New variables to keep track of where we are in the data */
uint32 remaining_data; /* How much data is left in the whole string */
uint64 current_ea_pointer; /* Where we are in system memory */
uint32 current_transfer_size; /* How big the current transfer is (may
* be smaller than MAX_TRANSFER_SIZE) */

/* We are only using one tag in this program */
mfc_write_tag_mask(1<<0);

/* Grab the conversion information */
mfc_get(&conversion_info, conversion_info_ea, sizeof(conversion_info), 0, 0, 0);
spu_mfcstat(MFC_TAG_UPDATE_ALL); /* Wait for Completion */

/* Setup the loop */
remaining_data = conversion_info.length;
current_ea_pointer = conversion_info.data;

while(remaining_data > 0) {
/* Determine how much data is left to transfer */
if(remaining_data < MAX_TRANSFER_SIZE)
current_transfer_size = remaining_data;
else
current_transfer_size = MAX_TRANSFER_SIZE;

/* Get the actual data */
mfc_getb(conversion_buffer, current_ea_pointer, current_transfer_size, 0, 0, 0);
spu_mfcstat(MFC_TAG_UPDATE_ALL);

/* Perform the conversion */
convert_buffer_to_upper(conversion_buffer, current_transfer_size);

/* Put the data back into system storage */
mfc_putb(conversion_buffer, current_ea_pointer, current_transfer_size, 0, 0, 0);

/* Advance to the next segment of data */
remaining_data -= current_transfer_size;
current_ea_pointer += current_transfer_size;
}
spu_mfcstat(MFC_TAG_UPDATE_ALL); /* Wait for Completion */
}

spu-gcc convert_buffer_c.c convert_driver_c.c -o spe_convert
embedspu -m64 convert_to_upper_handle spe_convert spe_convert_csf.o
gcc -m64 spe_convert_csf.o ppu_dma_main.c -lspe -o dma_convert
./dma_convert

struct {
uint64 effective_address __attribute__((aligned(16)));
uint32 size __attribute__((aligned(16)));
char data[MAX_TRANSFER_SIZE] __attribute__((aligned(16)));
} buffer;

buffer buffers[2];

                

#include <spu_intrinsics.h>
#include <spu_mfcio.h>

/* Constants */
#define MAX_TRANSFER_SIZE 16384

/* Data Structures */
typedef unsigned long long uint64;
typedef unsigned int uint32;
typedef struct {
uint32 length __attribute__((aligned(16)));
uint64 data __attribute__((aligned(16)));
} conversion_structure;

typedef struct {
uint32 size __attribute__((aligned(16)));
uint64 effective_address __attribute__((aligned(16)));
char data[MAX_TRANSFER_SIZE] __attribute__((aligned(16)));
} buffer;

/* Global Variables */
buffer buffers[2];

/* Utility Functions */
inline uint32 MIN(uint32 a, uint32 b) {
return a < b ? a : b;
}

inline void wait_for_completion(uint32 mask) {
mfc_write_tag_mask(mask);
spu_mfcstat(MFC_TAG_UPDATE_ALL);
}

inline void load_conversion_info(uint64 cinfo_ea, uint64 *data_ea, uint32 *data_size) {
conversion_structure cinfo;
mfc_get(&cinfo, cinfo_ea, sizeof(cinfo), 0, 0, 0);
wait_for_completion(1<<0);
*data_size = cinfo.length;
*data_ea = cinfo.data;
}

/* Processing Functions */
inline void initiate_transfer(uint32 buf_idx, uint64 *current_ea_pointer,
uint32 *remaining_data) {
/* Setup buffer information */
buffers[buf_idx].size = MIN(*remaining_data, MAX_TRANSFER_SIZE);
buffers[buf_idx].effective_address = *current_ea_pointer;
/* Initiate transfer using the buffer index as the DMA tag */
mfc_getb(buffers[buf_idx].data, buffers[buf_idx].effective_address,
buffers[buf_idx].size, buf_idx, 0, 0);
/* Move the data pointers */
*remaining_data -= buffers[buf_idx].size;
*current_ea_pointer += buffers[buf_idx].size;
}

inline void process_and_put_back(uint32 buf_idx) {
wait_for_completion(1<<buf_idx);
/* Perform conversion */
convert_buffer_to_upper(buffers[buf_idx].data, buffers[buf_idx].size);
/* Initiate the DMA transfer back using the buffer index as the DMA tag */
mfc_putb(buffers[buf_idx].data, buffers[buf_idx].effective_address,
buffers[buf_idx].size, buf_idx, 0, 0);
}

/* Main Code */
int main(uint64 spe_id, uint64 conversion_info_ea) {
uint32 remaining_data;
uint64 current_ea_pointer;

load_conversion_info(conversion_info_ea, &current_ea_pointer, &remaining_data);

/* Start filling buffers to prepare for loop (loop assumes both buffers have
* data coming in) */
initiate_transfer(0, &current_ea_pointer, &remaining_data);
initiate_transfer(1, &current_ea_pointer, &remaining_data);

do {
/* Process buffer 0 */
process_and_put_back(0);
initiate_transfer(0, &current_ea_pointer, &remaining_data);

/* Process buffer 1 */
process_and_put_back(1);
initiate_transfer(1, &current_ea_pointer, &remaining_data);
} while(buffers[0].size != 0);

wait_for_completion(1<<0|1<<1);
}

#assume the mask is in $10
#Count the leading zeroes
clz $11, $10
#Subtract that from 31
sfi $12, $11, 31
#$12 now has the index of the buffer we want to use.

/* buffers_completed holds the mask */
spu_extract(
        spu_sub(
                (int32)31,
                spu_cntlz(
                        spu_promote(
                                (uint32)buffers_completed, 0
                        )
                )
        ),
        0
);

#$10 holds our buffer mask
#$11 holds the size of the last transfer
#$12 holds the index of the current buffer

#Convert the current buffer index to a bit for a bit mask (stored in $14)
il $13, 1
shl $14, $13, $12

#Turn the bit off in the original mask
xor $10, $10, $14

#is the last transfer greater than zero? (answer stored in $15)
cgti $15, $11, 0

#Turn the bit on or off based the previous result (answer stored in $14)
and $14, $14, $15

#Turn the bit on based on our existing results
or $10, $10, $14

/* clear the bit */
*buffers_with_data &= ~(1<<buf_idx);
/* Set the bit conditionally */
*buffers_with_data |= (buffers[buf_idx].size > 0 ? (1<<buf_idx) : 0);

                

#include <spu_intrinsics.h>
#include <spu_mfcio.h>
typedef unsigned long long uint64;
typedef unsigned int uint32;
typedef int int32;

/* Constants */
#define MAX_TRANSFER_SIZE 16384
#define NUM_BUFFERS 8 /* The MFC supports only 16 queued transfers,
* and we have up to two active per buffer */

/* Data Structures */
typedef struct {
uint32 length __attribute__((aligned(16)));
uint64 data __attribute__((aligned(16)));
} conversion_structure;

typedef struct {
uint32 size __attribute__((aligned(16)));
uint64 effective_address __attribute__((aligned(16)));
char data[MAX_TRANSFER_SIZE] __attribute__((aligned(16)));
} buffer;

buffer buffers[NUM_BUFFERS];

/* Utility functions */
inline uint32 MIN(uint32 a, uint32 b) {
return a < b ? a : b;
}

/* Processes the buffer, queues a DMA transfer to put the data back, and clears out
* the "waiting for data" bit in buffers_with_data */
inline void process_and_put_back(uint32 buf_idx, uint32 *buffers_with_data) {
convert_buffer_to_upper(buffers[buf_idx].data, buffers[buf_idx].size);
mfc_putb(buffers[buf_idx].data, buffers[buf_idx].effective_address,
buffers[buf_idx].size, buf_idx, 0, 0);
*buffers_with_data &= ~(1<<buf_idx); /* Clear out bit for this buffer */
}

/* Queues up a DMA GET transfer, ad, if there is any data to transfer, sets
* the appropriate bit in buffers_with_data to indicate that we are waiting
* for data in this buffer */
inline void initiate_transfer(uint32 buf_idx, uint32 *buffers_with_data,
uint64 *current_ea_pointer, uint32 *remaining_data) {
/* Setup buffer */
buffers[buf_idx].size = MIN(*remaining_data, MAX_TRANSFER_SIZE);
buffers[buf_idx].effective_address = *current_ea_pointer;

/* Move Data Pointers */
*remaining_data -= buffers[buf_idx].size;
*current_ea_pointer += buffers[buf_idx].size;

/* Initiate transfer (does nothing if there is no data) */
mfc_get(buffers[buf_idx].data, buffers[buf_idx].effective_address,
buffers[buf_idx].size, buf_idx, 0, 0);

/* Set the "Buffer Waiting for Data" bit only if there is data to read */
*buffers_with_data |= (buffers[buf_idx].size > 0 ? (1<<buf_idx) : 0);
}

/* Waits for all of the given buffers to complete */
inline void wait_for_completion(uint32 mask) {
mfc_write_tag_mask(mask);
spu_mfcstat(MFC_TAG_UPDATE_ALL);
}

/* Loads information about the whole conversion process */
inline void load_conversion_info(uint64 conversion_info_ea, uint64 *current_ea_pointer,
uint32 *remaining_data) {
conversion_structure conversion_info;

mfc_get(&conversion_info, conversion_info_ea, sizeof(conversion_info), 0, 0, 0);
wait_for_completion(1<<0);

*remaining_data = conversion_info.length;
*current_ea_pointer = conversion_info.data;
}

/* Returns the index of the first buffer with data available*/
inline uint32 get_next_buffer(uint32 buffers_with_data) {
uint32 buffers_completed; /* This will contain a mask of buffers whose
* transfers have completed */

/* These are the buffers to look for */
mfc_write_tag_mask(buffers_with_data);

/* Wait for at least one buffer to come available */
buffers_completed = spu_mfcstat(MFC_TAG_UPDATE_ANY);

/* Use "count leading zeros" to determine the buffer index from
* the buffers_completed mask */
return spu_extract(
spu_sub(
(int32)31,
spu_cntlz(
spu_promote((uint32)buffers_completed, 0)
)
),
0
);
}

/* Steps are numbered according to the description in this section */
int main(uint64 spe_id, uint64 conversion_info_ea) {
uint32 remaining_data;
uint64 current_ea_pointer;
uint32 buffers_with_data = 0; /* This is the bit mask for each buffer waiting on data,
* used for spu_mfcstat in the main loop */
uint32 all_buffers = 0; /* This is used to wait on all remaining transfers at
* the end of the program*/
uint32 current_buffer_idx;

load_conversion_info(conversion_info_ea, &current_ea_pointer, &remaining_data);

/* Step 1: Get all buffers loading (because NUM_BUFFERS is a constant, the compiler
*         should unroll the loop all the way) */
for(current_buffer_idx = 0; current_buffer_idx < NUM_BUFFERS; current_buffer_idx++) {
initiate_transfer(current_buffer_idx, &buffers_with_data,
&current_ea_pointer, &remaining_data);
all_buffers |= 1<<current_buffer_idx;
}

/* Step 2: Continue while there are still buffers pending */
while(buffers_with_data != 0) {
/* Step 3: Get the next buffer that gets filled */
current_buffer_idx = get_next_buffer(buffers_with_data);
/* Steps 4 and 5: Process the buffer and queue up a DMA transfer back to main memory */
process_and_put_back(current_buffer_idx, &buffers_with_data);
/* Steps 6 and 7: Queue up a buffer reload, and mark the buffer as "filling"
*                (by setting the appropriate bit in remaining_data) */
initiate_transfer(current_buffer_idx, &buffers_with_data,
&current_ea_pointer, &remaining_data);
}

/* Wait for all PUTs to complete */
wait_for_completion(all_buffers);
}

                

#include <stdio.h>
#include <libspe.h>
#include <errno.h>
#include <string.h>
#include <sys/time.h>
#include <malloc.h>

/* Size of Buffer -- MUST be a multiple of 16 */
#define BUF_SIZE (16 * 200000)

/* embedspu actually defines this in the generated object file, 
we only need an extern reference here */
extern spe_program_handle_t convert_to_upper_handle;

/* This is the parameter structure that our SPE code expects */
/* Note the alignment on all of the data that will be passed to the SPE is 16-bytes */
typedef struct {
int length __attribute__((aligned(16)));
unsigned long long data __attribute__((aligned(16)));
} conversion_structure;

int main() {
int status = 0;
int i;
struct timeval initial_time, final_time;

/* Create the string on an aligned boundary */
char *str = memalign(16, BUF_SIZE);

/* Fill the string with data */
for(i = 0; i < BUF_SIZE - 1 ; i++) {
str[i] = 'a' + i % 26;
}

/* Null-terminate string */
str[BUF_SIZE - 1] = '\0';

/* Create conversion structure on an aligned boundary */
conversion_structure conversion_info __attribute__((aligned(16)));

/* Set the data elements in the parameter structure */
conversion_info.length = BUF_SIZE; /* add one for null byte */
conversion_info.data = (unsigned long long)str;

/* Check starting time */
gettimeofday(&initial_time, NULL);

/* Create the thread and check for errors */
speid_t spe_id = spe_create_thread(0, &convert_to_upper_handle, 
&conversion_info, NULL, -1, 0);
if(spe_id == 0) {
fprintf(stderr, "Unable to create SPE thread: errno=%d\n", errno);
return 1;
}

/* Wait for SPE thread completion */
spe_wait(spe_id, &status, 0);

/* Check final time */
gettimeofday(&final_time, NULL);

/* Print SPU execution time */
fprintf(stderr, "%llu microseconds\n",
((long long)final_time.tv_sec * 1000000 + final_time.tv_usec) -
((long long) initial_time.tv_sec * 1000000 + initial_time.tv_usec));

/* Print out result - uncomment if you really want to see it*/
//printf("The converted string is: %s\n", str);

return 0;
}