src/ppu/system/moc_init_ppu.c

Go to the documentation of this file.

#include <malloc_align.h>
#include <free_align.h>
#include <stdlib.h>
#include <string.h>

#include <moc.h>
#include <ppu/moc.h>
#include <internal/imoc.h>
#include <internal/ppu/imoc_core_ppu.h>

int MOC_Init(int *argc __attribute__((unused)), char ***argv __attribute__((unused)) )
    {
    int i;
    char temp[16];
    uint32_t temp2[1];
    /* create own node-handle and data-structures */
    node_handle.rank = 0;
    node_handle.comm_size = moc_spu_thread_count + 1;
    node_handle.queue_size = moc_spu_queue_size;
    node_handle.message_queue_base = _malloc_align(
            sizeof(moc_message_envelope_t) * (node_handle.comm_size - 1)
                    * node_handle.queue_size, 4);
    if (node_handle.message_queue_base == 0)
        return MOC_ERR_NO_MEMORY;
    node_handle.status_array_base = _malloc_align(sizeof(moc_message_status_t)
            * (node_handle.comm_size - 1) * node_handle.queue_size, 4);
    if (node_handle.status_array_base == 0)
        return MOC_ERR_NO_MEMORY;
    node_handle.buffer_base = _malloc_align(moc_spu_buffer_size, 4);
    if (node_handle.buffer_base == 0)
        return MOC_ERR_NO_MEMORY;
    node_handle.buffer_size = moc_spu_buffer_size;
    node_handle.signal_area = _malloc_align(16, 4);
    if (node_handle.signal_area == 0)
        return MOC_ERR_NO_MEMORY;
    /* create prozess list*/
    node_handle.moc_process_list = _malloc_align(sizeof(moc_process_t)
            * node_handle.comm_size, 7);
    if (node_handle.moc_process_list == 0)
        return MOC_ERR_NO_MEMORY;
    node_handle.moc_process_list[0].type = MOC_PPU_PROCESS;
    node_handle.moc_process_list[0].inbox_queue_base
            = (uint64_t) node_handle.message_queue_base;
    node_handle.moc_process_list[0].stat_array_base
            = (uint64_t) node_handle.status_array_base;
    node_handle.moc_process_list[0].ps_base
            = (uint64_t) node_handle.signal_area;
    moc_ppu_thread_count = 1;
    /* start SPU-Threads */
    for (i = 0; i < moc_spu_thread_count; i++)
        {
        moc_spu_thread_list[i].envp = NULL;
        moc_spu_thread_list[i].rank = i + moc_ppu_thread_count;
        /* start pthread */
        if (pthread_create(&moc_spu_thread_list[i].pthread, NULL,
                &moc_spe_pthread_func, &moc_spu_thread_list[i]) != 0)
            return MOC_ERR_INTERN;
        /* create buffer-space for thread */
        moc_spu_thread_list[i].buffer_base = _malloc_align(moc_spu_buffer_size,
                4);
        if (moc_spu_thread_list[i].buffer_base == 0)
            return MOC_ERR_NO_MEMORY;
        moc_spu_thread_list[i].buffer_size = moc_spu_buffer_size;
        /* prefill entry of prozess-list */
        node_handle.moc_process_list[i + moc_ppu_thread_count].type
                = MOC_SPU_PROCESS;
        node_handle.moc_process_list[i + moc_ppu_thread_count].ps_base
                = (uint64_t) spe_ps_area_get(moc_spu_thread_list[i].speid,
                        SPE_MSSYNC_AREA);
        if (node_handle.moc_process_list[i + moc_ppu_thread_count].ps_base == 0)
            return MOC_ERR_INTERN;
        moc_spu_thread_list[i].ls_base = (uint64_t) spe_ls_area_get(
                moc_spu_thread_list[i].speid);
        if (moc_spu_thread_list[i].ls_base == 0)
            return MOC_ERR_INTERN;
        node_handle.moc_process_list[i + moc_ppu_thread_count].inbox_queue_base
                = (uint64_t) moc_spu_thread_list[i].ls_base;
        node_handle.moc_process_list[i + moc_ppu_thread_count].stat_array_base
                = (uint64_t) moc_spu_thread_list[i].ls_base;

        /* send rank, overall prozess-count, queue-size, buffer_size
         * and memory-adress of buffer to SPU via mailbox */
        temp[0] = i + moc_ppu_thread_count;
        temp[1] = node_handle.comm_size;
        temp[2] = node_handle.queue_size;
        *((uint32_t*) &temp[4]) = moc_spu_thread_list[i].buffer_size;
        *((uint64_t*) &temp[8]) = (uint64_t) moc_spu_thread_list[i].buffer_base;
        if (spe_in_mbox_write(moc_spu_thread_list[i].speid, (uint32_t*) temp,
                4, SPE_MBOX_ALL_BLOCKING) != 4)
            return MOC_ERR_INTERN;
        /* send SPU-thread's local-store base-address to SPU */
        *((uint64_t*) temp) = (uint64_t) spe_ls_area_get(
                moc_spu_thread_list[i].speid);
        if (spe_in_mbox_write(moc_spu_thread_list[i].speid, (uint32_t*) temp,
                2, SPE_MBOX_ALL_BLOCKING) != 2)
            return MOC_ERR_INTERN;
        /* wait till incoming mailbox-message from SPU */
        while (spe_out_mbox_status(moc_spu_thread_list[i].speid) < 1)
            ;
        if (spe_out_mbox_read(moc_spu_thread_list[i].speid, temp2, 1) != 1)
            return MOC_ERR_INTERN;
        /* write base addresses of SPU's message-queues into prozess-list */
        node_handle.moc_process_list[i + moc_ppu_thread_count].inbox_queue_base
                += temp2[0];
        moc_spu_thread_list[i].queue_base_in_ls = temp2[0];
        /* wait till incoming mailbox-message from SPU */
        while (spe_out_mbox_status(moc_spu_thread_list[i].speid) < 1)
            ;
        if (spe_out_mbox_read(moc_spu_thread_list[i].speid, temp2, 1) != 1)
            return MOC_ERR_INTERN;
        /* write base addresses of SPU's status-array into prozess-list */
        node_handle.moc_process_list[i + moc_ppu_thread_count].stat_array_base
                += temp2[0];
        moc_spu_thread_list[i].status_base_in_ls = temp2[0];
        }
    /* send memory address of prozess list to all SPU-processes */
    for (i = 0; i < moc_spu_thread_count; i++)
        {
        *((uint64_t*) temp2) = (uint64_t) node_handle.moc_process_list;
        if (spe_in_mbox_write(moc_spu_thread_list[i].speid, temp2, 2,
                SPE_MBOX_ALL_BLOCKING) != 2)
            return MOC_ERR_INTERN;
        }
    return 0;
    }

---