benlib.h

GPU实现的MapReduce framework,对于学习并行编程和cuda平台的编程方面有着极好的参考价值

/*
 *System-independent library.
 *Written by Wenbin FANG ([e-mail])
 *
 *COMPILE MACROS:
 *1, __UNIX__ or __WIN32__
 *2, __TIMER__
 *3, __DEBUG__
 *4, __CUDA__
 *5, __MEM__
 *6, __ALLOC__
 */
#ifndef __BENLIB_H__
#define __BENLIB_H__

//#define __TIMER__
#define __DEBUG__
#define __CUDA__
//#define __MEM__
//#define __ALLOC__

#ifdef __UNIX__
#	include <unistd.h>
#	include <arpa/inet.h>
#	include <sys/types.h>
#	include <sys/socket.h>
#	include <sys/stat.h>
#	include <netinet/in.h>
#	include <fcntl.h>
#	include <netinet/in.h>
#	include <stdbool.h>
#	include <sys/mman.h>
#	include <sys/time.h>
#	include <pthread.h>
#else // __UNIX__
#	include <windows.h>
#	pragma warning(disable: 4267)
#	pragma warning(disable: 4996)
#	pragma warning(disable: 4311)
#	pragma warning(disable: 4312)
#	pragma warning(disable: 4244)
#	pragma warning(disable: 4018)
#	pragma warning(disable: 4309)
#endif // __WIN32__

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <stdarg.h>
#include <math.h>

#ifdef __CUDA__
#	include <cutil.h>
#	include <cuda.h>
#	include <cuda_runtime.h>
#endif //__CUDA__
//----------------------------------------
//BenLog
//----------------------------------------
extern "C"
void BenLog(char *, ...);

//----------------------------------------
//BenTime
//----------------------------------------
#ifdef __UNIX__
	typedef long long i64;
#else //__UNIX__
	typedef __int64 i64 ;
#endif //__WIN32__

typedef struct CPerfCounterRec
{
    i64 _freq;
    i64 _clocks;
    i64 _start;
} CPerfCounter;

extern "C"
void BenSetup(int);
extern "C"
void BenStart(int);
extern "C"
void BenStop(int);
extern "C"
void BenReset(int);
extern "C"
double BenGetElapsedTime(int);
extern "C"
void BenPrintTime(char *, int);

#ifdef __UNIX__
typedef struct timeval BenTimeVal_t;
#else //__unix__
typedef LARGE_INTEGER BenTimeVal_t;
#endif //__WIN32__

extern "C"
void BenStartTimer(BenTimeVal_t *start_tv);
extern "C"
double BenEndTimer(BenTimeVal_t *start_tv);

//----------------------------------------
//BenAssert
//----------------------------------------
#ifdef __DEBUG__
#define BEN_ASSERT(x) \
do{if (!(x)) { \
            fprintf(stdout, "\nASSERT FAILED in file %s, line %d\n\n", __FILE__, __LINE__); \
            fflush(stdout); \
			exit(-1); \
}}while(0)
#else //__DEBUG__
#define BEN_ASSERT(x) do{(x);}while(0)/* do nothing */
#endif

//----------------------------------------
//BenMem
//----------------------------------------
#ifdef __DEBUG__
extern size_t d_memUsage;
extern size_t d_memTransfer;
#endif //__DEBUG__

extern "C"
void *BenMalloc(size_t size);
extern "C"
void BenFree(char **buf, size_t size);
extern "C"
void BenMemset(void *buf, int c, size_t size);
extern "C"
void BenMemcpy(void *dest, void *src, size_t size);
extern "C"
void *BenRealloc(void *buf, size_t oldSize, size_t newSize);
extern "C"
char *BenStrDup(char *str);
extern "C"
int BenStrLen(char *str);
extern "C"
void EnterFunc(char *funcName);
extern "C"
void LeaveFunc(char *funcName);

//--------------------------------------------------
//BenThread
//--------------------------------------------------
#ifdef __UNIX__
typedef pthread_t BenThread_t;
#else //__UNIX__
typedef HANDLE BenThread_t;
#endif //__WIN32__

extern "C"
BenThread_t BenNewThread(void *(*start_routine)(void*),  void *arg);
extern "C"
void BenExitThread(void *status);
extern "C"
void BenWaitForSingle(BenThread_t id);
extern "C"
void BenWaitForMul(BenThread_t* ids, int num);

//--------------------------------------------------
//BenFile
//--------------------------------------------------
typedef struct
{
	char *addr;
#ifndef __UNIX__
	HANDLE hMap;
	__int64 fileSize;
#endif
} BenMM_t;

extern "C"
void BenWriteFile(char *fileName, void *buf, size_t size);
extern "C"
void BenAppendFile(char *fileName, void *buf, size_t size);
extern "C"
char *BenReadFile(char *fileName, size_t offset, size_t size);
extern "C"
BenMM_t *BenStartMMap(char *fileName);
extern "C"
void BenEndMMap(BenMM_t *fileName);

typedef struct
{
#ifndef __UNIX__
	HANDLE hDir;
	WIN32_FIND_DATA wfd;
#endif //__UNIX__
} BenDir_t;

typedef struct
{
	char *filename;
	int fileId;
	size_t fileSize;
	char *h_fileBuf;
	char *d_fileBuf;
#ifndef __UNIX__
#endif //__UNIX__
} BenFileInDir_t;
extern "C"
BenDir_t *BenEnterDir(char *dirname);
extern "C"
char BenFindDir(BenDir_t *dir, BenFileInDir_t *file);
extern "C"
void BenLeaveDir(BenDir_t *dir);

#ifdef __UNIX__
typedef FILE File_t 
#else
typedef HANDLE File_t;
#endif //__UNIX__
#define R	0x00	//read
#define W	0x01	//write
#define A	0x02	//append
extern "C"
File_t BenOpen(char *fileName);
extern "C"
size_t BenRead(File_t handle, char *buf, size_t fileOffset, size_t size);
extern "C"
size_t BenWrite(File_t handle, char *buf, size_t size);
//---------------------------------------------------
//BenCUDAMem
//---------------------------------------------------
#ifdef __CUDA__
extern "C"
char *D_MALLOC(size_t size);
extern "C"
void D_FREE(void *buf, size_t size);
extern "C"
void D_MEMCPY_H2D(void *des, void *src, size_t size);
extern "C"
void D_MEMCPY_D2H(void *des, void *src, size_t size);
extern "C"
void D_ENTER_FUNC(char *func);
extern "C"
void D_LEAVE_FUNC(char *func);
extern "C"
void D_ANYDEVICE();
#endif //__CUDA__

//---------------------------------------------------
//BenCUDAFile
//---------------------------------------------------
#ifdef __CUDA__

typedef struct
{
	char *filename;
#ifndef __UNIX__
	HANDLE hFile;
#endif //__UNIX__
	size_t fileSize;
	size_t offset;
} FStream_t;

extern "C"
FStream_t *D_OPEN_FILE(char *filename);
extern "C"
size_t D_ITERATE_CHUNK(FStream_t *fs, char *gpubuf, size_t chunkSize);
extern "C"
char D_READ_CHUNK(FStream_t *fs, char *gpubuf, 
				  size_t offset, size_t size, size_t *read_size);
extern "C"
char D_WRITE_CHUNK(FStream_t *fs, char *gpubuf, size_t size);
extern "C"
char D_APPEND_CHUNK(FStream_t *fs, char *gpubuf, size_t size);
extern "C"
void D_RESET_ITERATOR(FStream_t *fs);
extern "C"
void D_CLOSE_FILE(FStream_t *fs);
#endif
//---------------------------------------------------
//BenArg
//---------------------------------------------------
extern "C"
bool BenCheckArg(int argc, char **argvs, char *arg);
extern "C"
bool BenGetArgInt(int argc, char **argvs, char *argv, int *val);
extern "C"
bool BenGetArgFloat(int argc, char **argvs, char *argv, float *val);
extern "C"
bool BenGetArgStr(int argc, char **argvs, char *argv, char **val);
extern "C"
bool BenGetArgStrs(int argc, char **argvs, char *argv, char **val, int *len);
extern "C"
void BenPrintUsage(char *fmt, ...);

//-------------------------------------------------
//BenMath
//-------------------------------------------------
extern "C"
float *BenGenMatrixf(int rowNum, int colNum);
extern "C"
double *BenGenMatrixd(int rowNum, int colNum);

#endif //__BENLIB_H__