cudadl/dpstream.cu

/*
 *  cudadl version 0.9: Compute discrete logs in smooth group orders
 *                      using CUDA
 *  Copyright (C) 2012 by Ryan Henry and Ian Goldberg
 *                        {rhenry,iang}@cs.uwaterloo.ca
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of version 3 of the GNU General Public License as
 *  published by the Free Software Foundation.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef __DPSTREAM_H__
#define __DPSTREAM_H__

#include <sm_11_atomic_functions.h>

/* Routines to allow CUDA threads to write distinguished points into
   a buffer that will be read by the host */

__constant__ static unsigned int *DPbuffer = NULL;
__constant__ static unsigned int DPbuffersize = 0;  // in words
static unsigned int *DPbuffer_device = NULL;
__device__ volatile static unsigned int DPbuffertail = 0;  // in words

static const unsigned int DPrecordsize = (1+WORDS+6); // in words
static unsigned int DPbufsize = 0;

cudaError_t DPstreamInit(size_t numrecords)
{
    // Allocate the buffer
    DPbufsize = DPrecordsize * numrecords;

    if (cudaMalloc((void **)&DPbuffer_device, DPbufsize * sizeof(unsigned int))
	    != cudaSuccess) {
	return cudaErrorInitializationError;
    }
    // Zero it
    cudaMemset(DPbuffer_device, 0, DPbufsize * sizeof(unsigned int));
    // Initialize the device-visible pointers
    unsigned int zero = 0;
    cudaMemcpyToSymbol(DPbuffer, &DPbuffer_device, sizeof(unsigned int*));
    cudaMemcpyToSymbol(DPbuffersize, &DPbufsize, sizeof(unsigned int));
    cudaMemcpyToSymbol(DPbuffertail, &zero, sizeof(unsigned int));

    return cudaSuccess;
}

void DPstreamEnd(void)
{
    if (DPbuffer_device) {
	cudaFree(DPbuffer_device);
    }
    DPbuffer_device = NULL;
}

// Call this from the device to write the following into the buffer:
//   block and thread indices (1 word total)
//   x (WORDS words)
//   a (2 words)
//   b (2 words)
__device__ inline unsigned int *DPstreamAlloc()
{
    if (!DPbuffer) return NULL;

    // Atomically increment the DPbuffertail
    if (DPbuffertail >= DPbuffersize) return NULL;
    unsigned int ouroffset = atomicAdd((unsigned int *)&DPbuffertail,
		(unsigned int) (DPrecordsize));
    if (ouroffset + DPrecordsize > DPbuffersize) {
	atomicSub((unsigned int *)&DPbuffertail, (unsigned int)DPrecordsize);
	return NULL;
    }
    unsigned int *ourbuffer = DPbuffer + ouroffset;
    return ourbuffer;
}

extern bool dpcallback(void *data, unsigned short threadId,
    unsigned short blockId, unsigned int demux, string x,
    unsigned int a_0, unsigned int a_1, unsigned int a_2,
    unsigned int b_0, unsigned int b_1, unsigned int b_2);

#if WORDS > 1
#define DEMUXWORD 1
#else
#define DEMUXWORD 0
#endif

// Return true if we should stop computing
bool DPstreamParse(void *data)
{
    // Get the number of words in the buffer
    unsigned int bufsize;
    cudaMemcpyFromSymbol(&bufsize, DPbuffertail, sizeof(unsigned int));
    cerr << getpid() << " " << bufsize / DPrecordsize << " DPs\n";
    unsigned int *dpbuf = (unsigned int*)calloc(bufsize, sizeof(unsigned int));
    bool stop_computing = false;
    if (dpbuf) {
	cudaMemcpy(dpbuf, DPbuffer_device, bufsize * sizeof(unsigned int),
	    cudaMemcpyDeviceToHost);

	for (unsigned int *dp=dpbuf; dp < dpbuf+bufsize; dp += DPrecordsize) {
	    unsigned short threadId = (unsigned short)(dp[0]);
	    unsigned short blockId = dp[0]>>16;
	    unsigned int a_0 = dp[WORDS+1];
	    unsigned int a_1 = dp[WORDS+2];
	    unsigned int a_2 = dp[WORDS+3];
	    unsigned int b_0 = dp[WORDS+4];
	    unsigned int b_1 = dp[WORDS+5];
	    unsigned int b_2 = dp[WORDS+6];
	    string x((const char *)(dp+1), WORDS*sizeof(unsigned int));

	    if (dpcallback(data, threadId, blockId, dp[DEMUXWORD], x, a_0, a_1, a_2, b_0, b_1, b_2)) {
		stop_computing = true;
	    }
	}
    }
    free(dpbuf);
    // Reset the buffer
    unsigned int zero = 0;
    cudaMemcpyToSymbol(DPbuffertail, &zero, sizeof(unsigned int));

    return stop_computing;
}
#endif