prt_callback.c

Go to the documentation of this file.

#include "prt_callback.h"


prt_callback_finish_t *prt_callback_finish_new(
    struct prt_packet_s *src_packet,
    struct prt_packet_s *dst_packet,
    struct prt_channel_s *channel)
{
    prt_callback_finish_t *callback =
        (prt_callback_finish_t*)malloc(sizeof(prt_callback_finish_t));
    prt_assert(callback != NULL, "malloc failed");
    callback->src_packet = src_packet;
    callback->dst_packet = dst_packet;
    callback->channel = channel;
    return callback;
}


void prt_callback_finish_delete(prt_callback_finish_t *callback)
{
    free(callback);
}


void CUDART_CB prt_callback_finish_handler(
    cudaStream_t stream, cudaError_t status, void *clbck)
{
    // Cast the void pointer to the callback data.
    prt_callback_finish_t *callback = (prt_callback_finish_t*)clbck;

    // Put the destination packet in the channel.
    icl_deque_append(callback->channel->packets, (void*)callback->dst_packet);

    // Check for NULL packet.
    // (dev -> same device communication).
    if (callback->src_packet != NULL) {
        if (callback->src_packet->location == PRT_LOCATION_HOST) {
            prt_packet_release_host(callback->src_packet);
        }
        else {
            // Create a packet release request.
            prt_transfer_t *transfer =
                prt_transfer_new(
                    callback->src_packet, NULL, PRT_DEVICE_PACKET_RELEASE, -1);
            // Queue the packet release request.
            icl_deque_append(
                callback->channel->proxy->transfers, (void*)transfer);
        }
    }
    // Decrement the number of pending callbacks.
    __sync_fetch_and_sub(&callback->channel->proxy->num_callbacks, 1);

    // Delete the callback data structure.
    prt_callback_finish_delete(callback);
}


prt_callback_queue_t *prt_callback_queue_new(
    struct prt_packet_s *old_packet,
    struct prt_packet_s *src_packet,
    struct prt_channel_s *channel,
    prt_direction_t direction,
    int agent)
{
    prt_callback_queue_t *callback =
        (prt_callback_queue_t*)malloc(sizeof(prt_callback_queue_t));
    prt_assert(callback != NULL, "malloc failed");
    callback->old_packet = old_packet;
    callback->src_packet = src_packet;
    callback->channel = channel;
    callback->direction = direction;
    callback->agent = agent;
    return callback;
}


void prt_callback_queue_delete(prt_callback_queue_t *callback)
{
    free(callback);
}


void CUDART_CB prt_callback_queue_handler(
    cudaStream_t stream, cudaError_t status, void *clbck)
{
    // Cast the void pointer to the callback data.
    prt_callback_queue_t *callback = (prt_callback_queue_t*)clbck;

    // Initialize the local transfer request.
    prt_transfer_t *transfer = 
        prt_transfer_new(
            callback->src_packet,
            callback->channel,
            callback->direction,
            callback->agent);
    // Queue the local transfer request.
    icl_deque_append(callback->channel->proxy->transfers, (void*)transfer);

    // IF old_packet not NULL.
    if (callback->old_packet != NULL) {
        if (callback->old_packet->location == PRT_LOCATION_HOST) {
            prt_packet_release_host(callback->old_packet);
        }
        else {
            // Create a packet release request.
            prt_transfer_t *transfer =
                prt_transfer_new(
                    callback->old_packet, NULL, PRT_DEVICE_PACKET_RELEASE, -1);
            // Queue the packet release request.
            icl_deque_append(
                callback->channel->proxy->transfers, (void*)transfer);
        }
    }
    // Decrement the number of pending callbacks.
    __sync_fetch_and_sub(&callback->channel->proxy->num_callbacks, 1);

    // Delete the callback data structure.
    prt_callback_queue_delete(callback);
}


prt_callback_release_t *prt_callback_release_new(
    struct prt_vdp_s *vdp,
    struct prt_packet_s *packet)
{
    prt_callback_release_t *callback =
        (prt_callback_release_t*)malloc(sizeof(prt_callback_release_t));
    prt_assert(callback != NULL, "malloc failed");
    callback->vdp = vdp;
    callback->packet = packet;
    return callback;
}


void prt_callback_release_delete(prt_callback_release_t *callback)
{
    free(callback);
}


void CUDART_CB prt_callback_release_handler(
    cudaStream_t stream, cudaError_t status, void *clbck)
{
    // Cast the void pointer to the callback data.
    prt_callback_release_t *callback = (prt_callback_release_t*)clbck;

    // Create the packet release request.
    prt_transfer_t *transfer =
        prt_transfer_new(
            callback->packet, NULL, PRT_DEVICE_PACKET_RELEASE, -1);
    // Queue the packet release request.
    icl_deque_append(callback->vdp->vsa->proxy->transfers, (void*)transfer);

    // Decrement the number of pending callbacks.
    __sync_fetch_and_sub(&callback->vdp->vsa->proxy->num_callbacks, 1);

    // Delete the callback data structure.
    prt_callback_release_delete(callback);
}