runtime/ctrump-libspe2.c

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.
*/

#define _ATFILE_SOURCE

#include "ctrump-libspe2.h"
#include <stdint.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>

enum {
    COMMAND_NONE,
    COMMAND_RUN,
    COMMAND_QUIT
};

struct ctrump_runtime_spe_context ctrump_runtime_spes[16];
extern spe_program_handle_t ctrump_libspe2_boot;
int ctrump_spe_num = 0;

static void *
spe_thread(void *spe_ptr)
{
    struct ctrump_runtime_spe_context *self = (struct ctrump_runtime_spe_context*)spe_ptr;
    spe_context_ptr_t spe = self->spe_context;
    unsigned int entry;

    entry = SPE_DEFAULT_ENTRY;
    spe_program_load(spe, &ctrump_libspe2_boot);
    spe_context_run(spe, &entry, 0, 0, NULL, NULL);

    return NULL;
}

extern void  __spe_context_update_event(void);
void
ctrump_runtime_spe_program_load(spe_context_ptr_t spe, const spe_program_handle_t *prog)
{
    unsigned int mbox;
    int objfd;
    int i, n = ctrump_spe_num;

    for (i=0; i<n; i++) {
        if (ctrump_runtime_spes[i].spe_context == spe)
            break;
    }

    if (i == n)
        return;

    /* for ppu-gdb */

    if (ctrump_runtime_spes[i].enable_debugger) {
        objfd = openat(ctrump_runtime_spes[i].dir_fd, "object-id", O_RDWR);
        if (objfd >= 0) {
            char buf[100];
            sprintf(buf, "%p", prog->elf_image);
            write(objfd, buf, strlen(buf)+1);
            close(objfd);
            __spe_context_update_event();
        }
    }

    mbox = (uint32_t)(uintptr_t)prog;
    spe_in_mbox_write(spe, &mbox, 1, SPE_MBOX_ALL_BLOCKING);
    mbox = ((uint64_t)(uintptr_t)prog)>>32;
    spe_in_mbox_write(spe, &mbox, 1, SPE_MBOX_ALL_BLOCKING);

}

void
ctrump_runtime_spe_start(spe_context_ptr_t spe, void *param)
{
    unsigned int mbox;
    mbox = (uint32_t)(uintptr_t)param;
    spe_in_mbox_write(spe, &mbox, 1, SPE_MBOX_ALL_BLOCKING);
    mbox = ((uint64_t)(uintptr_t)param)>>32;
    spe_in_mbox_write(spe, &mbox, 1, SPE_MBOX_ALL_BLOCKING);
}

void
ctrump_runtime_spe_wait(spe_context_ptr_t spe)
{
    unsigned int data;
    spe_out_intr_mbox_read(spe, &data, 1, SPE_MBOX_ALL_BLOCKING);
}

void
ctrump_runtime_append_spe(spe_context_ptr_t spe, int enable_debugger)
{
    int cur_spe = ctrump_spe_num;
    unsigned int mbox;
    char dir_buffer[256];
    int pid, dir_fd;
    struct ctrump_runtime_spe_context *s = &ctrump_runtime_spes[cur_spe];

    pid = getpid();
    sprintf(dir_buffer, "/spu/spethread-%d-%lld", pid, (unsigned long long) (uintptr_t)spe);
    dir_fd = open(dir_buffer, O_RDONLY);

    ctrump_spe_num = cur_spe+1;

    s->spe_context = spe;
    s->dir_fd = dir_fd;
    s->enable_debugger = enable_debugger;

    pthread_create(&s->thread, NULL, spe_thread, s);
    spe_out_intr_mbox_read(spe, &mbox, 1, SPE_MBOX_ALL_BLOCKING);
}

void
ctrump_runtime_remove_spe(spe_context_ptr_t spe)
{
    int i;
    int n = ctrump_spe_num;
    unsigned int quit = 0xffffffffU;

    for (i=0; i<n; i++) {
        if (ctrump_runtime_spes[i].spe_context == spe)
            break;
    }

    if (i == n) {
        /* not found */
        return;
    }

    ctrump_spe_num = n-1;

    spe_in_mbox_write(spe, &quit, 1, SPE_MBOX_ALL_BLOCKING);
    pthread_join(ctrump_runtime_spes[i].thread, NULL);
    close(ctrump_runtime_spes[i].dir_fd);
    for (; i<n-1; i++) {
        ctrump_runtime_spes[i] = ctrump_runtime_spes[i+1];
    }
}

void
ctrump_runtime_initialize(int num_spe)
{
    int i;
    for (i=0; i<num_spe; i++) {
        ctrump_runtime_append_spe(spe_context_create(SPE_MAP_PS,0), 1);
    }
}

void
ctrump_runtime_finalize(void)
{
    while (ctrump_spe_num) {
        ctrump_runtime_remove_spe(ctrump_runtime_spes[0].spe_context);
    }
}

---