runtime/spe/ctrump-libspe2.h

Go to the documentation of this file.

/* -*- coding:utf-8 -*- 
 Copyright (c) 2009, Fixstars Corporation
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification, 
 are permitted provided that the following conditions are met:
 
   * Redistributions of source code must retain the above copyright notice,
     this list of conditions and the following disclaimer.
 
   * Redistributions in binary form must reproduce the above copyright notice,
     this list of conditions and the following disclaimer in the documentation
     and/or other materials provided with the distribution.
 
   * Neither the name of Fixstars Corporation nor the names of its contributors
     may be used to endorse or promote products derived from this software
     without specific prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#ifndef CTRUMP_LIBSPE2_SPE_H
#define CTRUMP_LIBSPE2_SPE_H

#include <stdint.h>
#include <string.h>
#include <spu_mfcio.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifndef _ELF_H
typedef uint32_t Elf32_Word;
typedef uint16_t Elf32_Half;
typedef uint32_t Elf32_Off;
typedef uint32_t Elf32_Addr;
#define PT_LOAD 1
#endif

#ifdef ADDR64
typedef uint64_t ctrump_ea_t;
#else
typedef uint32_t ctrump_ea_t;
#endif

struct ctrump_ehdr{
    unsigned char e_ident[16];
    Elf32_Half e_type;
    Elf32_Half e_machine;
    Elf32_Word e_version;
    Elf32_Addr e_entry;
    Elf32_Off  e_phoff;
    Elf32_Off  e_shoff;
    Elf32_Word e_flags;
    Elf32_Half e_ehsize;
    Elf32_Half e_phentsize;
    Elf32_Half e_phnum;
};

struct ctrump_phdr {
    Elf32_Word p_type;
    Elf32_Off  p_offset;
    Elf32_Addr p_vaddr;
    Elf32_Addr p_paddr;
    Elf32_Word p_filesz;
    Elf32_Word p_memsz;
    Elf32_Word p_flags;
    Elf32_Word p_align;
};

typedef struct ctrump_ehdr ehdr;

extern char ctrump_begin;
extern char ctrump_end;

static void
ctrump_libspe2_program_boot(ctrump_ea_t prog_handle,
                            unsigned long long argp, unsigned long long envp) __attribute__((noinline,noreturn));

static void
ctrump_libspe2_program_boot(ctrump_ea_t prog_handle,
                            register unsigned long long argp,
                            register unsigned long long envp)
{
    struct ctrump_ehdr *ehdr;
    unsigned int mod128 = ((int)prog_handle)&127;
    ctrump_ea_t addr;
    ctrump_ea_t ph_ea;
    int phnum, phentsize, i;
    unsigned char *phdr_ls;
    unsigned char *prog_buf;
    void (*entry)(void);

    unsigned char tmp_buf_una[1024+128];
    unsigned int this_size = &ctrump_end - &ctrump_begin;

    unsigned char *tmp_buf = (unsigned char*)(((int)(tmp_buf_una + 127))&~127);

    prog_buf = tmp_buf + 256;

    mfc_get(tmp_buf, prog_handle-mod128, 256, 0, 0, 0);
    mfc_write_tag_mask(1);
    mfc_read_tag_status_all();

    /* extract from spe_program_handle
     * struct spe_program_handle {
     *   uint32_t handle_size;
     * #if ADDR_SIZE == 64
     *   uint32_t pad;
     *   ctrump_ea_t elf_addr; // aligned to 8
     * #else
     *   ctrump_ea_t elf_addr; // aligned to 4
     * #endif
     * }
     */
    addr = *(ctrump_ea_t*)(tmp_buf + mod128 + sizeof(ctrump_ea_t));

    mod128 = ((int)addr) & 127;

    mfc_get(tmp_buf, addr-mod128, 256, 0, 0, 0);
    mfc_write_tag_mask(1);
    mfc_read_tag_status_all();

    ehdr = (struct ctrump_ehdr*)(tmp_buf + mod128);

    ph_ea = addr + ehdr->e_phoff;
    mod128 = ((int)ph_ea) & 127;

    phnum = ehdr->e_phnum;
    phentsize = ehdr->e_phentsize;
    entry = (void (*)())ehdr->e_entry;

    mfc_get(tmp_buf, ph_ea-mod128, 256, 0, 0, 0);
    mfc_write_tag_mask(1);
    mfc_read_tag_status_all();

    phdr_ls = tmp_buf + mod128;

    memcpy(prog_buf, &ctrump_begin, this_size);

    spu_sync();

    __asm__ volatile ("bi %0\n\t.align 4\n\tctrump_begin:"::"r"(prog_buf));

    for (i=0; i<phnum; i++) {
        register struct ctrump_phdr *ph = (struct ctrump_phdr*)phdr_ls;
        if (ph->p_type == PT_LOAD) {
            register unsigned int paddr = ph->p_paddr;
            register unsigned int off = ph->p_offset;
            register unsigned int memsz = ph->p_memsz;
            register unsigned int fsz = ph->p_filesz;
            register int clear_size = memsz - fsz;
            register vector unsigned char *bss = (vector unsigned char*)(paddr + fsz);
            register unsigned int paddr_off = 0;
            phdr_ls += phentsize;

            while (fsz > 0) {
                register int get_size = fsz>16384?16384:fsz;
                mfc_get((unsigned char*)paddr + paddr_off, addr+off, get_size, 0, 0, 0);
                paddr_off += get_size;
                off += get_size;
                fsz -= get_size;
            }

            /* clear bss */
            while (clear_size > 0) {
                *bss = spu_splats((unsigned char)0);
                bss++;
                clear_size -= 16;
            }
        }
    }

    mfc_write_tag_mask(~0);
    mfc_read_tag_status_all();

    spu_sync();

    __asm__ volatile ("ori $4, %0, 0\n\t"::"r"(argp):"4");
    __asm__ volatile ("ori $5, %0, 0\n\t"::"r"(envp):"5");
    __asm__ volatile ("bi %0\n\t"
                      "ctrump_end:":: "r"(entry));
    while(1);
}


static inline int
ctrump_spe_fini(int spe_id, int is_last_spe, unsigned long long sync_ea)
{
    static unsigned int sync_buffer[32] __attribute__((aligned(128)));
    unsigned int prog_lo, prog_hi;
    unsigned int param_lo, param_hi;
    unsigned long long prog_ea;
    unsigned long long param;
    int r, ev;

    if (is_last_spe) {
        /* 最後のSPEはカウンタがSPE数揃ったら終了する */
        spu_write_event_mask(MFC_LLR_LOST_EVENT);

        while (1) {
            mfc_getllar(sync_buffer, sync_ea, 0, 0);
            mfc_read_atomic_status();

            if (sync_buffer[0] == spe_id)
                break;

            ev = spu_readch(SPU_RdEventStat);
            spu_write_event_ack(ev & MFC_LLR_LOST_EVENT);
        }

        spu_write_out_intr_mbox(0);
    } else {
        /* 最後のSPE以外はカウンタを1上げて終了する */
        while (1) {
            mfc_getllar(sync_buffer, sync_ea, 0, 0);
            mfc_read_atomic_status();

            sync_buffer[0]++;

            mfc_putllc(sync_buffer, sync_ea, 0, 0);
            r = mfc_read_atomic_status();

            if (__builtin_expect((r & MFC_PUTLLC_STATUS) == 0, 1) ) {
                break;
            }
        }
    }

    prog_lo = spu_read_in_mbox();
    if (prog_lo == 0xffffffff)
        return -1;

    prog_hi = spu_read_in_mbox();

    param_lo = spu_read_in_mbox();
    param_hi = spu_read_in_mbox();

    prog_ea = (((unsigned long long)prog_hi)<<32) | prog_lo;
    param = (((unsigned long long)param_hi)<<32) | param_lo;

    ctrump_libspe2_program_boot(prog_ea, param, 0);
    return 0;
}

static inline void
ctrump_spe_wait_ppe(void)
{
    unsigned int prog_lo, prog_hi;
    unsigned int param_lo, param_hi;
    unsigned long long prog_ea;
    unsigned long long param;
    spu_write_out_intr_mbox(0);
    prog_lo = spu_read_in_mbox();
    if (prog_lo == 0xffffffff)
        return;

    prog_hi = spu_read_in_mbox();

    param_lo = spu_read_in_mbox();
    param_hi = spu_read_in_mbox();

    prog_ea = (((unsigned long long)prog_hi)<<32) | prog_lo;
    param = (((unsigned long long)param_hi)<<32) | param_lo;

    ctrump_libspe2_program_boot(prog_ea, param, 0);
}


#ifdef __cplusplus
}
#endif
#endif

---