예제 #1
0
파일: cu2.c 프로젝트: E-LLP/QuIP
static void init_cu2_devices(QSP_ARG_DECL  Compute_Platform *cpp)
{
	int n_devs,i;

	/* We don't get a proper error message if the cuda files in /dev
	 * are not readable...  So we check that first.
	 */

	check_file_access(QSP_ARG  "/dev/nvidiactl");

	cudaGetDeviceCount(&n_devs);

	if( n_devs == 0 ){
		WARN("No CUDA devices found!?");
		return;
	}

	if( verbose ){
		sprintf(ERROR_STRING,"%d cuda devices found...",n_devs);
		advise(ERROR_STRING);
	}

	default_cuda_dev_name = getenv(DEFAULT_CUDA_ENV_VAR);
	/* may be null */

	for(i=0;i<n_devs;i++){
		char s[32];

		sprintf(s,"/dev/nvidia%d",i);
		check_file_access(QSP_ARG  s);

		init_cu2_device(QSP_ARG  i, cpp);
	}

	if( default_cuda_dev_name == NULL ){
		/* Not specified in environment */
		// reserved var if set in environment?
		assign_var(QSP_ARG  DEFAULT_CUDA_DEV_VAR,first_cuda_dev_name);
		default_cuda_dev_found=1;	// not really necessary?
	} else if( ! default_cuda_dev_found ){
		/* specified incorrectly */
		sprintf(ERROR_STRING, "%s %s not found.\nUsing device %s.",
			DEFAULT_CUDA_DEV_VAR,default_cuda_dev_name,
			first_cuda_dev_name);
		WARN(ERROR_STRING);

		assign_var(QSP_ARG  DEFAULT_CUDA_DEV_VAR,first_cuda_dev_name);
		default_cuda_dev_found=1;	// not really necessary?
	}

	/* hopefully the vector library is already initialized - can we be sure? */

	SET_PLATFORM_FUNCTIONS(cpp,cu2)
	SET_PF_FUNC_TBL(cpp,cu2_vfa_tbl);
	//SET_PLATFORM_DISPATCH_TBL(cpp,cu2_func_tbl);

} // end init_cu2_devices
예제 #2
0
파일: parser.cpp 프로젝트: jsjtxietian/Cpp
void atom(int &value)
{
	int i;
	char temp[MAX_ID_LEN + 1];

	switch (token_type) {
	case IDENTIFIER:
		i = internal_func(token);
		if (i != -1) {
			// Call "standard library" function. 
			value = (*intern_func[i].p)();
		}
		else if (find_func(token)) {
			// Call programmer-created function. 
			call();
			value = ret_value;
		}
		else {
			value = find_var(token); // get var's value 
			strcpy(temp, token); // save variable name 

								 // Check for ++ or --. 
			get_token();
			if (*token == INC || *token == DEC) {
				if (*token == INC)
					assign_var(temp, find_var(temp) + 1);
				else
					assign_var(temp, find_var(temp) - 1);
			}
			else putback();
		}

		get_token();
		return;
	case NUMBER: // is numeric constant 
		value = atoi(token);
		get_token();

		return;
	case DELIMITER: // see if character constant 
		if (*token == '\'') {
			value = *prog;
			prog++;
			if (*prog != '\'')
				throw InterpExc(QUOTE_EXPECTED);

			prog++;
			get_token();

			return;
		}
		if (*token == ')') return; // process empty expression 
		else throw InterpExc(SYNTAX);  // otherwise, syntax error 
	default:
		throw InterpExc(SYNTAX); // syntax error 
	}
}
예제 #3
0
파일: rcfile.c 프로젝트: E-LLP/QuIP
static char *try_directory(QSP_ARG_DECL  const char *dir,const char* progname)
{
	FILE *fp;
	static char filename[MAXPATHLEN];

	if( *dir ){
		strcpy(filename,dir);
		strcat(filename,DIR_DELIM);
	} else strcpy(filename,"");

	strcat(filename,progname);
	strcat(filename,".scr");

	fp=fopen(filename,"r");

	if( fp!=NULL ) {
		redir(QSP_ARG  fp, filename );
		if( *dir ){
//sprintf(ERROR_STRING,"Setting %s to %s",STARTUP_DIRNAME,dir);
//advise(ERROR_STRING);
			// We should only set the variable here if
			// it doesn't already exist - vars defined
			// in the environment are reserved!
			Variable *vp;
			vp = VAR_OF(STARTUP_DIRNAME);
			if( vp == NO_VARIABLE ){
				assign_var(QSP_ARG  STARTUP_DIRNAME,dir);
			}
		}
		return(filename);
	} else {
		return(NULL);
	}
}
예제 #4
0
파일: parser.c 프로젝트: rrizun/littlec
/* Process an assignment expression */
void eval_exp0(int *value)
{
  char temp[ID_LEN];  /* holds name of var receiving
                         the assignment */
  register int temp_tok;
  if(token_type==IDENTIFIER) {
    if(is_var(token)) {  /* if a var, see if assignment */
      strcpy(temp, token);
      temp_tok = token_type;
      get_token();
      if(*token=='=') {  /* is an assignment */
   get_token();
   eval_exp0(value);  /* get value to assign */
   assign_var(temp, *value);  /* assign the value */
       return;
      }
      else {  /* not an assignment */
   putback();  /* restore original token */
   strcpy(token, temp);
   token_type = temp_tok;
      }
    }
  }
  eval_exp1(value);
}
예제 #5
0
파일: rcfile.c 프로젝트: jbmulligan/quip
static char *_try_directory(QSP_ARG_DECL  const char *dir,const char* progname)
{
	FILE *fp;
	static char filename[MAXPATHLEN];

	if( *dir ){
		strcpy(filename,dir);
		strcat(filename,DIR_DELIM);
	} else strcpy(filename,"");

	strcat(filename,progname);
	strcat(filename,".scr");

	fp=fopen(filename,"r");

	if( fp!=NULL ) {
		redir(fp, filename );
		if( *dir ){
			// We should only set the variable here if
			// it doesn't already exist - vars defined
			// in the environment are reserved!
			Variable *vp;
			vp = var_of(STARTUP_DIRNAME);
			if( vp == NULL ){
				assign_var(STARTUP_DIRNAME,dir);
			}
		}
		return(filename);
	} else {
		return(NULL);
	}
}
예제 #6
0
파일: parser.cpp 프로젝트: jsjtxietian/Cpp
void eval_exp0(int &value)
{
	char temp[MAX_ID_LEN + 1];

	tok_types temp_tok;

	if (token_type == IDENTIFIER) 
	{
		if (is_var(token)) 
		{
			strcpy(temp, token);
			temp_tok = token_type;
			get_token();
			if (*token == '=') 
			{ 
				get_token();
				eval_exp0(value); 
				assign_var(temp, value); 
				return;
			}
			else 
			{ 
				putback(); 
				strcpy(token, temp);
				token_type = temp_tok;
			}
		}
	}
	eval_exp1(value);
}
예제 #7
0
파일: dobj_menu.c 프로젝트: nasa/QuIP
static COMMAND_FUNC( do_tellprec )
{
	Data_Obj *dp;
	const char *s;

	dp = get_obj( QSP_ARG NAMEOF("data object") );
	s = NAMEOF("variable name");
	if( dp == NULL ) return;
	assign_var(s,OBJ_PREC_NAME(dp));
}
예제 #8
0
파일: dobj_menu.c 프로젝트: nasa/QuIP
static COMMAND_FUNC( do_get_area )
{
	const char *s;

	s=NAMEOF("script variable for area name");

	assert( curr_ap != NULL );

	assign_var(s, AREA_NAME(curr_ap));
}
예제 #9
0
파일: pgr.c 프로젝트: jbmulligan/quip
Data_Obj * grab_newest_firewire_frame( QSP_ARG_DECL  PGR_Cam * pgcp )
{
	dc1394video_frame_t *framep, *prev_framep=NULL;
	//int i=0;
	int n_dequeued=0;

	if( ! ready_to_grab( QSP_ARG  pgcp ) )
		return NULL;

	// We might want to release all of the frames we have now, in case we
	// need to automatically release any that we grab in the meantime,
	// so that we release in order...

	// We get the newest by dequeueing in POLL mode, until we come up empty.
	// If we have at least one frame at that time, then that's the frame.
	// If we don't have any, then we WAIT.  If at any time we have
	// more than 1, then we release the older.

	while( 1 ){
		if ( dc1394_capture_dequeue( pgcp->pc_cam_p, DC1394_CAPTURE_POLICY_POLL,
				&framep ) != DC1394_SUCCESS) {
			fprintf( stderr, "Unable to capture a frame\n" );
			return(NULL);
		}
		if( framep == NULL ){	// No frame to fetch?
			if( n_dequeued > 0 ){	// already have something?
				// The last one is the newest!
				sprintf(msg_str,"%d",prev_framep->id);
				assign_var("newest",msg_str);
				note_frame_usage(pgcp,prev_framep);
				return dobj_for_frame(QSP_ARG  prev_framep);
			} else {		// No frames yet...
				// We don't want to call the WAIT version here, because
				// we might have multiple cameras...
				return NULL;
			}
		} else {	// We have a new frame
			if( prev_framep != NULL ){	// already have one?
				if( dc1394_capture_enqueue(pgcp->pc_cam_p,prev_framep)
						!= DC1394_SUCCESS ){
					WARN("error enqueueing frame");
				}
			} else {
				// This counts the frame we dequeued.
				// We don't bother if we just enqueued
				// the previous one.
				pgcp->pc_n_avail--;
			}
			prev_framep = framep;
			n_dequeued++;
		}
	}
	// NOTREACHED
}
예제 #10
0
파일: parser.cpp 프로젝트: jsjtxietian/Cpp
// Is a unary +, -, ++, or --. 
void eval_exp4(int &value)
{
	char  op;
	char temp;

	op = '\0';
	if (*token == '+' || *token == '-' ||
		*token == INC || *token == DEC)
	{
		temp = *token;
		op = *token;
		get_token();
		if (temp == INC)
			assign_var(token, find_var(token) + 1);
		if (temp == DEC)
			assign_var(token, find_var(token) - 1);
	}

	eval_exp5(value);
	if (op == '-') value = -(value);
}
예제 #11
0
파일: acquire.c 프로젝트: nasa/QuIP
void assign_polh_var_data(char *varname, Data_Obj *dp, Polh_Output_Type type, int index )
{
	short *rpdp;
	Fmt_Pt fp1;
	Polh_Record_Format *prfp;
	char str[64];
	char *s,*s2;
	int i;

	if( OBJ_COLS(dp) != 1 ){
		sprintf(ERROR_STRING,"assign_polh_var_data:  object %s has %d columns, should be 1",
				OBJ_NAME(dp),OBJ_COLS(dp));
		warn(ERROR_STRING);
		return;
	}

	rpdp = (short *) OBJ_DATA_PTR(dp);
	prfp = &station_info[curr_station_idx].sd_multi_prf;
	format_polh_data(&fp1,rpdp,prfp);
	separator="";	/* no leading tab before the first record */
	if( fmt_one(msg_str,&fp1,type) < 0 )
		return;
	s=msg_str;
	i=index;
	while(i--){
		while( *s!=0 && !isspace(*s) ) s++;	/* skip data */
		while( *s!=0 && isspace(*s) ) s++;	/* skip spaces */
	}
#ifdef CAUTIOUS
	if( *s == 0 ){
		sprintf(ERROR_STRING,"CAUTIOUS:  assign_polh_var_data:  not enough words for index %d",
				index);
		warn(ERROR_STRING);
		sprintf(ERROR_STRING,"formatted string:  %s",msg_str);
		advise(ERROR_STRING);
		return;
	}
#endif /* CAUTIOUS */

	/* we have to do this check in case index is zero, so the check for leading spaces hasn't been
	 * performed above.  This is an issue with  milliseconds, where a leading space may appear
	 * in the string for values less than 100.
	 */
	while( *s!=0 && isspace(*s) ) s++;	/* skip any leading spaces */

	s2 = str;
	while( *s != 0 && !isspace(*s) )
		*s2++ = *s++;
	*s2=0;				/* BUG should check for overflow */

	assign_var(varname,str);

} /* end assign_polh_var_data */
예제 #12
0
파일: acquire.c 프로젝트: nasa/QuIP
static int read_next_record(QSP_ARG_DECL  void * raw_pdp, int station )
{
	char data_string[6][32];
	int i;
	int c, expect_c;

fprintf(stderr,"read_next_record 0x%lx\n",(long)raw_pdp);
	/* read any leading spaces */
	do {
		c=good_polh_char();
	} while( isspace(c) );

	while( c != '0' ){
		sprintf(ERROR_STRING,
	"read 0x%x, expected '0' in first header position",c);
		warn(ERROR_STRING);
		c=good_polh_char();
	}
	c=good_polh_char();
	expect_c = '1' + curr_station_idx;
	while( c != expect_c ){
		sprintf(ERROR_STRING,
	"read '%c' (0x%x), expected '%c' in second header position",
			c,c,expect_c);
		warn(ERROR_STRING);
		c=good_polh_char();
	}
	c=good_polh_char();
	if( c != 'D' && c != 'Y' ){
		sprintf(ERROR_STRING,
	"read '%c' (0x%x), expected 'D' or 'Y' in third header position",c,c);
		//warn(ERROR_STRING);
		advise(ERROR_STRING);

		c=good_polh_char();

		sprintf(ERROR_STRING,
	"read '%c' (0x%x) after unexpected character",c,c);
		//warn(ERROR_STRING);
		advise(ERROR_STRING);
	}

	/* BUG don't assume 6 data - use format? */
	for(i=0;i<6;i++){
		read_data_string(data_string[i]);
	//	advise(data_string[i]);
		/* raw_pdp doesn't indicate the format? */
	}

	// BUG how do we know that these are the data that were requested???
	assign_var("polh_x_pos",data_string[0]);
	assign_var("polh_y_pos",data_string[1]);
	assign_var("polh_z_pos",data_string[2]);
	assign_var("polh_x_rot",data_string[3]);
	assign_var("polh_y_rot",data_string[4]);
	assign_var("polh_z_rot",data_string[5]);

	return(0);
}
예제 #13
0
파일: pipe_menu.c 프로젝트: jbmulligan/quip
static COMMAND_FUNC( do_readpipe )
{
	Pipe *pp;
	const char *s;

	pp=pick_pipe("");
	s=NAMEOF("variable for text storage");

	if( pp == NULL ) {
		assign_var(s,"error_missing_pipe");
		return;
	}
	readfr_pipe(QSP_ARG  pp,s);
}
예제 #14
0
/* Обработка выражения в присваивании */
void eval_exp0(int *value) {
	char temp[ID_LEN];  /* содержит имя переменной,
                         которой присваивается значение */
	register int temp_tok;
	if(token_type == IDENTIFIER) {
		if(is_var(token)) {
			/* если эта переменная,
			                      посмотреть, присваивается ли ей значение */
			if(is_arr(token)) {
				sntx_err(SYNTAX); // todo: make message: redefinition of array is illegal
			}
			strcpy(temp, token);
			temp_tok = token_type;
			get_token();
			if(*token == '=') {  /* это присваивание */
				get_token();
				eval_exp0(value);  /* вычислить присваемое значение */
				assign_var(temp, *value);  /* присвоить значение */
				return;
			} else { /* не присваивание */
				putback();  /* востановление лексемы */
				strcpy(token, temp);
				token_type = temp_tok;
			}
		} else if(is_arr(token)) {
			strcpy(temp, token);
			temp_tok = token_type;
			get_token();
			if(*token == '[') {
				get_token();
				eval_exp0(value); // вычисление выражения в [] скобках
				int arr_index = *value;
				get_token(); // '=' or ';'
				if(*token == '=') {  /* это присваивание */
					get_token();
					eval_exp0(value);  /* вычислить присваемое значение */
					assign_arr_element(temp, arr_index, *value);  /* присвоить значение */
					return;
				} else { /* не присваивание */
					putback();  /* востановление лексемы */
					strcpy(token, temp);
					token_type = temp_tok;
				}
			} else {
				sntx_err(ASSIGN_ARRAY_ILLEGAL);
			}
		}
	}
	eval_exp1(value);
}
예제 #15
0
파일: dpymenu.c 프로젝트: nasa/QuIP
static COMMAND_FUNC( do_tell_dpy )
{
	Disp_Obj *dop;
	const char *s;

	s=NAMEOF("name of variable in which to deposit name of current display");

	dop = curr_dop();
	if( dop == NULL ){
		WARN("do_tell_dpy:  no current display!?");
		return;
	}

	assign_var(s,DO_NAME(dop));
}
예제 #16
0
static COMMAND_FUNC(do_fetch_chunk)
{
	Chunk_Data *cd_p;
	Data_Obj *dp;
	const char *s;
	char buf[64];

	s = nameof("variable name");

	cd_p = pick_chunk_data("");
	dp = pick_obj("camera buffer");

	if( cd_p == NULL || dp == NULL ) return;

	fetch_chunk_data(cd_p,dp);
	//display_chunk_data(cd_p);
	format_chunk_data(buf,cd_p);
	assign_var(s,buf);
}
예제 #17
0
파일: shell.c 프로젝트: MagedMilad/Shell
void read_input(int mode, char *batch_path) {

	char c;
	int current_length = (BUFFER_SIZE + 1);
	line = (char *) malloc(sizeof(char) * (BUFFER_SIZE + 1));
	char *path = (char *) malloc(sizeof(char) * (BUFFER_SIZE + 1));
	fflush(stderr);
	printf("\n[SHELL ] ");
	fflush(stdout);
	int run = 1, len = 0;
	if (mode == BATCH) {
		if (open(batch_path, O_RDONLY) > 0) {
			batch_file = fopen(batch_path, "r");
		} else {
			fprintf(stderr, "cann't open or read the file\n");
			return;
		}
	}
	while (c != EOF && run) {

		if (mode == INTERACTIVE)
			c = getchar();
		else {
			c = fgetc(batch_file);
			if (feof(stdin)) {
				run = 0;
				break;
			}
		}
		switch (c) {
		case '\n':
			if (line[0] == '\0') {
				len = 0;
				free_args();
				bzero(line, current_length);
				fflush(stderr);
				printf("\n[SHELL ] ");
				fflush(stdout);
			} else {

				if (mode == BATCH) {
					printf("%s\n", line);
				}
				if (len >= BUFFER_SIZE) {
					fprintf(stderr, "buffer limit excited\n");
					bzero(line, current_length);
					len = 0;
					continue;
				}
				add_to_history(line);
				free_args();
				fill_argv(line);
				if (is_comment(line) == 0) {
					if (strchr(line, '=') != NULL
							&& strcmp(args[0], "echo") != 0) {
						assign_var(line);
					} else {
//						free_args();
//						fill_argv(line);
						if (strcmp(args[0], "echo") != 0) {
							int i;
							for (i = 0; args[i] != NULL; i++) {
								append_home_dir(args[i]);
								fix_echo_line(args[i]);
							}
						} else {
							int i;
							for (i = 1; args[i] != NULL; i++) {
								fix_echo_line(args[i]);
							}
						}

						if (strcmp("exit", line) == 0) {
							run = 0;
							break;
						} else if (strcmp("history", args[0]) == 0) {
							execute_history();
						} else if (strcmp("cd", args[0]) == 0)
							cd();
						else {
							strcpy(path, args[0]);
							if (strchr(path, '/') != NULL) {
								int fd;
								if ((fd = open(path, O_RDONLY)) > 0) {
									close(fd);
									call_execve(path);
								} else {
									fprintf(stderr,
											"%s: No such file or directory\n",
											args[0]);
								}
							} else {
								if (!is_command(path)) {
									fprintf(stderr, "%s: command not found\n",
											args[0]);
								} else {
									call_execve(path);
								}
							}

						}
					}
				}
				free_args();
				fflush(stderr);
				printf("\n[SHELL ] ");
				fflush(stdout);
				bzero(line, BUFFER_SIZE);
				len = 0;
			}
			bzero(line, BUFFER_SIZE);
			break;
		default:
			len++;
			if (len < BUFFER_SIZE) {
				strncat(line, &c, 1);
			}
			break;
		}
	}
	if (mode == BATCH)
		fclose(batch_file);
}
예제 #18
0
파일: pgr.c 프로젝트: jbmulligan/quip
int start_firewire_transmission(QSP_ARG_DECL  PGR_Cam * pgcp, int _ring_buffer_size )
{
	int i;
	dc1394error_t err;
	Data_Obj *dp;

//advise("start_firewire_transmission BEGIN");
	/* older version had third flags arg... */
//advise("calling dc1394_capture_setup");
	if( (err=dc1394_capture_setup(pgcp->pc_cam_p,_ring_buffer_size ,DC1394_CAPTURE_FLAGS_DEFAULT ))
		!= DC1394_SUCCESS ) {

		WARN("dc1394_capture_setup failed!?");
		describe_dc1394_error( QSP_ARG  err );

		if( err == DC1394_IOCTL_FAILURE ){
			advise("Try decreasing the number of ring buffer frames requested?");
			return -1;
		}

		fprintf( stderr,"unable to setup camera-\n"
			"check line %d of %s to make sure\n"
			"that the video mode and framerate are\n"
			"supported by your camera\n",
			__LINE__,__FILE__ );

		/*
		fprintf( stderr,
			"video_mode = %d, framerate = %d\n"
			"Check dc1394_control.h for the meanings of these values\n",
			pgcp->pc_video_mode, pgcp->pc_framerate );
			*/
		fprintf( stderr,
			"video_mode = %s (%d), framerate = %s (%d)\n",
			name_for_video_mode(pgcp->pc_video_mode),
			pgcp->pc_video_mode,
			name_for_framerate(pgcp->pc_framerate),
			pgcp->pc_framerate );

		NERROR1("error starting capture");

		return(-1);
	}

	pgcp->pc_ring_buffer_size = _ring_buffer_size;
	pgcp->pc_n_avail = _ring_buffer_size;

	pgcp->pc_flags |= PGR_CAM_IS_CAPTURING;

#ifdef FOOBAR	// we set this in the script already!?
	sprintf(msg_str,"%d",ring_buffer_size);		/* tell the scripting language */
	assign_var("ring_buffer_size",msg_str);
#endif // FOOBAR

	// have the camera start sending us data
//advise("calling dc1394_video_set_transmission");
	if( (err=dc1394_video_set_transmission( pgcp->pc_cam_p, DC1394_ON ))
			!= DC1394_SUCCESS ) {
		WARN("Unable to start camera iso transmission");
		describe_dc1394_error( QSP_ARG  err );

		// do we need to undo capture_setup?
		dc1394_capture_stop( pgcp->pc_cam_p );
		pgcp->pc_flags &= ~PGR_CAM_IS_CAPTURING;

		return(-1);
	}
	pgcp->pc_flags |= PGR_CAM_IS_TRANSMITTING;

	//  Sleep untill the camera has a transmission
	dc1394switch_t status = DC1394_OFF;

	for ( i = 0; i <= 5; i++ ) {
		usleep(50000);
//advise("calling dc1394_video_get_transmission");
		if ( dc1394_video_get_transmission( pgcp->pc_cam_p, &status )
				!= DC1394_SUCCESS ) {
			fprintf( stderr, "Unable to get transmision status\n" );
			return(-1);
		}
		if ( status != DC1394_OFF )
			break;

		if( i == 5 ) {
			fprintf(stderr,"Camera doesn't seem to want to turn on!\n");
			return(-1);
		}
	}
//advise("start_firewire_transmission DONE");

	// Now make sure that we have the frame objects...
	dp = dobj_of("_frame1");
	if( dp == NULL ) init_buffer_objects(QSP_ARG  pgcp);

	return(0);
}
예제 #19
0
파일: cu2.c 프로젝트: E-LLP/QuIP
static void init_cu2_device(QSP_ARG_DECL  int index, Compute_Platform *cpp)
{
	struct cudaDeviceProp deviceProp;
	cudaError_t e;
	Platform_Device *pdp;
	char name[LLEN];
	char dev_name[LLEN];
	char area_name[LLEN];
	const char *name_p;
	char *s;
	Data_Area *ap;
	float comp_cap;

	if( index >= MAX_CUDA_DEVICES ){
		sprintf(ERROR_STRING,"Program is compiled for a maximum of %d CUDA devices, can't inititialize device %d.",
			MAX_CUDA_DEVICES,index);
		ERROR1(ERROR_STRING);
	}

	if( verbose ){
		sprintf(ERROR_STRING,"init_cu2_device %d BEGIN",index);
		advise(ERROR_STRING);
	}

	if( (e=cudaGetDeviceProperties(&deviceProp, index)) != cudaSuccess ){
		describe_cuda_driver_error2("init_cu2_device","cudaGetDeviceProperties",e);
		return;
	}

	if (deviceProp.major == 9999 && deviceProp.minor == 9999){
		sprintf(ERROR_STRING,"There is no CUDA device with dev = %d!?.\n",index);
		WARN(ERROR_STRING);

		/* What should we do here??? */
		return;
	}

	/* Put the compute capability into a script variable so that we can use it */
	comp_cap = deviceProp.major * 10 + deviceProp.minor;
	if( comp_cap > CUDA_COMP_CAP ){
		sprintf(ERROR_STRING,"init_cu2_device:  CUDA device %s has compute capability %d.%d, but program was configured for %d.%d!?",
			deviceProp.name,deviceProp.major,deviceProp.minor,
			CUDA_COMP_CAP/10,CUDA_COMP_CAP%10);
		WARN(ERROR_STRING);
	}

	/* BUG if there are multiple devices, we need to make sure that this is set
	 * correctly for the current context!?
	 */
	sprintf(ERROR_STRING,"%d.%d",deviceProp.major,deviceProp.minor);
	assign_var(QSP_ARG  "cuda_comp_cap",ERROR_STRING);


	/* What does this do??? */
	e = cudaSetDeviceFlags( cudaDeviceMapHost );
	if( e != cudaSuccess ){
		describe_cuda_driver_error2("init_cu2_device",
			"cudaSetDeviceFlags",e);
	}

	strcpy(name,deviceProp.name);

	/* change spaces to underscores */
	s=name;
	while(*s){
		if( *s==' ' ) *s='_';
		s++;
	}

	/* We might have two of the same devices installed in a single system.
	 * In this case, we can't use the device name twice, because there will
	 * be a conflict.  The first one gets the name, then we have to check and
	 * make sure that the name is not in use already.  If it is, then we append
	 * a number to the string...
	 */
	name_p = available_pfdev_name(QSP_ARG  name,dev_name,cpp,MAX_CUDA_DEVICES);	// reuse name as scratch string
	pdp = new_pfdev(QSP_ARG  name_p);

#ifdef CAUTIOUS
	if( pdp == NO_PFDEV ){
		sprintf(ERROR_STRING,"CAUTIOUS:  init_cu2_device:  Error creating cuda device struct for %s!?",name_p);
		WARN(ERROR_STRING);
		return;
	}
#endif /* CAUTIOUS */

	/* Remember this name in case the default is not found */
	if( first_cuda_dev_name == NULL )
		first_cuda_dev_name = PFDEV_NAME(pdp);

	/* Compare this name against the default name set in
	 * the environment, if it exists...
	 */
	if( default_cuda_dev_name != NULL && ! default_cuda_dev_found ){
		if( !strcmp(PFDEV_NAME(pdp),default_cuda_dev_name) )
			default_cuda_dev_found=1;
	}

	SET_PFDEV_PLATFORM(pdp,cpp);
	SET_PFDEV_CUDA_INFO( pdp, getbuf(sizeof(Cuda_Dev_Info)) );

	SET_PFDEV_CUDA_DEV_INDEX(pdp,index);
	SET_PFDEV_CUDA_DEV_PROP(pdp,deviceProp);
	SET_PFDEV_CUDA_RNGEN(pdp,NULL);

	if( comp_cap >= 20 ){
		SET_PFDEV_MAX_DIMS(pdp,3);
	} else {
		SET_PFDEV_MAX_DIMS(pdp,2);
	}

	//set_cuda_device(pdp);	// is this call just so we can call cudaMalloc?
	PF_FUNC_NAME(set_device)(QSP_ARG  pdp);	// is this call just so we can call cudaMalloc?

	// address set to NULL says use custom allocator - see dobj/makedobj.c

	// BUG??  with pdp we may not need the DA_ flag???
	sprintf(area_name,"%s.%s",PLATFORM_NAME(cpp),name_p);
	ap = pf_area_init(QSP_ARG  area_name,NULL,0,
			MAX_CUDA_GLOBAL_OBJECTS,DA_CUDA_GLOBAL,pdp);
	if( ap == NO_AREA ){
		sprintf(ERROR_STRING,
	"init_cu2_device:  error creating global data area %s",area_name);
		WARN(ERROR_STRING);
	}
	// g++ won't take this line!?
	SET_AREA_CUDA_DEV(ap,pdp);
	//set_device_for_area(ap,pdp);

	SET_PFDEV_AREA(pdp,PFDEV_GLOBAL_AREA_INDEX,ap);

	/* We used to declare a heap for constant memory here,
	 * but there wasn't much of a point because:
	 * Constant memory can't be allocated, rather it is declared
	 * in the .cu code, and placed by the compiler as it sees fit.
	 * To have objects use this, we would have to declare a heap and
	 * manage it ourselves...
	 * There's only 64k, so we should be sparing...
	 * We'll try this later...
	 */


	/* Make up another area for the host memory
	 * which is locked and mappable to the device.
	 * We don't allocate a pool here, but do it as needed...
	 */

	//strcpy(area_name,name_p);
	//strcat(area_name,"_host");
	sprintf(area_name,"%s.%s_host",PLATFORM_NAME(cpp),name_p);
	ap = pf_area_init(QSP_ARG  area_name,(u_char *)NULL,0,MAX_CUDA_MAPPED_OBJECTS,
								DA_CUDA_HOST,pdp);
	if( ap == NO_AREA ){
		sprintf(ERROR_STRING,
	"init_cu2_device:  error creating host data area %s",area_name);
		ERROR1(ERROR_STRING);
	}
	SET_AREA_CUDA_DEV(ap, pdp);
	//cuda_data_area[index][CUDA_HOST_AREA_INDEX] = ap;
	SET_PFDEV_AREA(pdp,PFDEV_HOST_AREA_INDEX,ap);

	/* Make up another psuedo-area for the mapped host memory;
	 * This is the same memory as above, but mapped to the device.
	 * In the current implementation, we create objects in the host
	 * area, and then automatically create an alias on the device side.
	 * There is a BUG in that by having this psuedo area in the data
	 * area name space, a user could select it as the data area and
	 * then try to create an object.  We will detect this in make_dobj,
	 * and complain.
	 */

	//strcpy(area_name,name_p);
	//strcat(area_name,"_host_mapped");
	sprintf(area_name,"%s.%s_host_mapped",PLATFORM_NAME(cpp),name_p);
	ap = pf_area_init(QSP_ARG  area_name,(u_char *)NULL,0,MAX_CUDA_MAPPED_OBJECTS,
							DA_CUDA_HOST_MAPPED,pdp);
	if( ap == NO_AREA ){
		sprintf(ERROR_STRING,
	"init_cu2_device:  error creating host-mapped data area %s",area_name);
		ERROR1(ERROR_STRING);
	}
	SET_AREA_CUDA_DEV(ap,pdp);
	//cuda_data_area[index][CUDA_HOST_MAPPED_AREA_INDEX] = ap;
	SET_PFDEV_AREA(pdp,PFDEV_HOST_MAPPED_AREA_INDEX,ap);

	// We don't change the data area by default any more when initializing...
	/* Restore the normal area */
	//set_data_area(PFDEV_AREA(pdp,PFDEV_GLOBAL_AREA_INDEX));

	if( verbose ){
		sprintf(ERROR_STRING,"init_cu2_device %d DONE",index);
		advise(ERROR_STRING);
	}
}
예제 #20
0
파일: stc_menu.c 프로젝트: jbmulligan/quip
int default_stim(QSP_ARG_DECL  Trial_Class *tc_p,int val,Staircase *stc_p)
{
	char stim_str[256], *s;
	int coin=0;	// initialize to quiet compiler, but not necessary!?
	int rsp;
	//struct var *vp;
	Variable *vp;
	float *xv_p;

	if( is_fc ){
		coin=(int)rn(1);
		sprintf(stim_str,"%d",coin);
		assign_var("coin",stim_str);
	}

	assert( CLASS_XVAL_OBJ(tc_p) != NULL );
	xv_p = indexed_data( CLASS_XVAL_OBJ(tc_p), val );
	sprintf(stim_str,"%f",*xv_p);

	/* clip trailing zeros if there is a decimal point */
	s=stim_str;
	while( *s ){
		if( *s == '.' ){
			s=stim_str+strlen(stim_str)-1;
			while( *s == '0' ) {
				*s=0;
				s--;
			}
			/*
			 * if ONLY 0's after the decimal pt.,
			 * remove the pt too!
			 */
			if( *s == '.' ){
				*s=0;
				s--;
			}
		}
		s++;
	}

	assign_var("xval",stim_str);
	sprintf(stim_str,"%d",val);
	assign_var("val",stim_str);
	sprintf(stim_str,"%d",CLASS_INDEX(tc_p));
	assign_var("class",stim_str);

	assert( tc_p != NULL );

	//sprintf(msg_str,"Text \"%s\"",(char *)(tc_p->cl_data));
	//PUSH_INPUT_FILE(msg_str);

	//interpret_text_fragment(QSP_ARG tc_p->cl_data);		/* use chew_text??? */
	chew_text(CLASS_CMD(tc_p), "(stimulus text)");
	vp=var_of("response_string");
	if( vp != NULL )
		rsp = collect_response(VAR_VALUE(vp));
	else {
		static int warned=0;

		if( !warned ){
			warn("default_stim:  script variable $response_string not defined");
			warned=1;
		}
		rsp = collect_response("Enter response: ");
	}

	if( is_fc ){
		/* stimulus routine may have changed value of coin */
		vp=var_of("coin");
		if( vp == NULL )
			warn("variable \"coin\" not set!!!");
		else {
			if( sscanf(VAR_VALUE(vp),"%d",&coin) != 1 )
			warn("error scanning integer from variable \"coin\"\n");
		}

		/*
		if( coin ){
			if( rsp == YES ) rsp = NO;
			else if( rsp == NO ) rsp = YES;
		}
		*/
		assert( stc_p != NULL );
        
        // analyzer complains coin is a garbage value??? BUG?
		if( coin ){
			SET_STAIR_CRCT_RSP(stc_p,NO);
		} else {
			SET_STAIR_CRCT_RSP(stc_p,YES);
		}
		if( verbose ){
			if( rsp == STAIR_CRCT_RSP(stc_p) )
				advise("correct");
			else
				advise("incorrect");
		}
	}
	return(rsp);
}