void setResultSpeak( Result_Speak& mgr )
{
	RD_LOCK( RESULT_SPEAK );
	result_speak_mgr = mgr;
	UNLOCK( RESULT_SPEAK );
}
void setRequestInference(RequestInferenceMgr &mgr) {
	WR_LOCK( REQUEST_INFERENCE );
	request_inference_mgr = mgr;
	UNLOCK( REQUEST_INFERENCE );
}
Beispiel #3
0
void SlaveStart()
{
  long i;
  long MyNum;
  double *upriv;
  
  //int a = 2*(rootN-1)*sizeof(double);

  //double upriv[a];

  long initdone; 
  long finish; 
  long l_transtime=0;
  long MyFirst; 
  long MyLast;


    
  BARRIER(Global->start, P);

  LOCK(Global->idlock);
    MyNum = Global->id;
    Global->id++;
  UNLOCK(Global->idlock);
    
  

  BARINCLUDE(Global->start);
  
 
  BARRIER(Global->start, P);  

  //upriv = (double *) malloc(2*(rootN-1)*sizeof(double));  
  upriv = (double *) our_malloc(2*(rootN-1)*sizeof(double));
  
  if (upriv == NULL) {
    fprintf(stderr,"Proc %ld could not malloc memory for upriv\n",MyNum);
    exit(-1);
  }
  for (i=0;i<2*(rootN-1);i++) {
    upriv[i] = umain[i];
  }   



  MyFirst = rootN*MyNum/P;
  MyLast = rootN*(MyNum+1)/P;

  TouchArray(x, trans, umain2, upriv, MyFirst, MyLast);


  BARRIER(Global->start, P);

  if ((MyNum == 0) || (dostats)) {
    CLOCK(initdone);
  }

  //printf("\nentrando em forward FFT\n");
  /* perform forward FFT */
  FFT1D(1, M, N, x, trans,  upriv, umain2, MyNum, &l_transtime, MyFirst, 
	MyLast, pad_length, test_result, dostats);



  /* perform backward FFT */
  if (test_result) {
    FFT1D(-1, M, N, x, trans,  upriv, umain2, MyNum, &l_transtime, MyFirst, 
	  MyLast, pad_length, test_result, dostats);
  }  



  if ((MyNum == 0) || (dostats)) {
    CLOCK(finish);
    Global->transtimes[MyNum] = l_transtime;
    Global->totaltimes[MyNum] = finish-initdone;
  }
  if (MyNum == 0) {
    Global->finishtime = finish;
    Global->initdonetime = initdone;
  }

  join_point(&myJoinPoint);
  
}
void setResultArm(ResultArmMgr& mgr)
{
	WR_LOCK( RESULT_ARM );
	result_arm_mgr = mgr;
	UNLOCK( RESULT_ARM );
}
void setHAE(HAEMgr &mgr) {
	WR_LOCK( HAE );
	hae_mgr = mgr;
	UNLOCK( HAE );
}
void setFformation(FformationMgr& mgr)
{
	WR_LOCK(FFORMATION);
	fformation_mgr = mgr;
	UNLOCK(FFORMATION);
}
void setFaceRecog(FaceRecogMgr& mgr)
{
	WR_LOCK( FACE_RECOG );
	face_recog_mgr = mgr;
	UNLOCK( FACE_RECOG );
}
void setInvalidGoal(InvalidGoalMgr &mgr)
{
	RD_LOCK( INVALID_GOAL );
	invalid_goal_mgr = mgr;
	UNLOCK( INVALID_GOAL );
}
void setMessageFreq(MessageFreqMgr &mgr)
{
	RD_LOCK( MESSAGE_FREQ );
	message_freq_mgr = mgr;
	UNLOCK( MESSAGE_FREQ );
}
void setServerVel(ServerVelMgr & mgr)
{
	RD_LOCK( SERVER_VEL );
	server_vel_mgr = mgr;
	UNLOCK( SERVER_VEL );
}
void setPoseMode(PoseModeMgr & mgr)
{
	RD_LOCK( POSE_MODE );
	pose_mode_mgr = mgr;
	UNLOCK( POSE_MODE );
}
void setResultNavi(Result_Navi & mgr)
{
	RD_LOCK( RESULT_NAVI );
	result_navi_mgr = mgr;
	UNLOCK( RESULT_NAVI );
}
void setActionNavi(Action_Navi & mgr)
{
	RD_LOCK( ACTION_NAVI );
	action_navi_mgr = mgr;
	UNLOCK( ACTION_NAVI );
}
//for Navi
void setNaviParMsg( NaviParMsg& mgr )
{
	WR_LOCK( NAVI_PAR );
	navi_par_mgr = mgr;
	UNLOCK( NAVI_PAR );
}
void setPerception(PerceptionMgr& mgr)
{
	WR_LOCK(PERCEPTION );
	perception_mgr = mgr;
	UNLOCK(PERCEPTION  );
}
//Navi
//for google calendar
void setAction_GCalendar(Action_GCalendarMgr& mgr)
{
	WR_LOCK( ACTION_GCALENDAR );
	action_gc_mgr = mgr;
	UNLOCK( ACTION_GCALENDAR );
}
void setDBN(DBNMgr& mgr)
{
	WR_LOCK(DBN);
	dbn_mgr = mgr;
	UNLOCK(DBN);
}
void setResult_GCalendar(Result_GCalendarMgr& mgr)
{
	RD_LOCK( RESULT_GCALENDAR );
	result_gc_mgr = mgr;
	UNLOCK( RESULT_GCALENDAR );
}
void setFaceDetect(FaceDetect& mgr)
{
	WR_LOCK( FACE_DETECT );
	detect_mgr = mgr;
	UNLOCK( FACE_DETECT );
}
void setScheduleInfo(ScheduleInfoMgr &mgr)
{
	RD_LOCK( SCHEDULE_INFO );
	schedule_info_mgr = mgr;
	UNLOCK( SCHEDULE_INFO );
}
	/* For arm manipulating */
void setActionArm(ActionArmMgr& mgr)
{
	WR_LOCK( ACTION_ARM );
	action_arm_mgr = mgr;
	UNLOCK( ACTION_ARM );
}
void setCheckInfo(CheckInfoMgr &mgr)
{
	RD_LOCK( CHECK_INFO );
	check_info_mgr = mgr;
	UNLOCK( CHECK_INFO );
}
	/* For Toward Robot Attention Estimator (HAE) */
void setPerceptionHAE(PerceptionHAEMgr &mgr) {
	WR_LOCK( PERCEPTION_HAE );
	perception_HAE_mgr = mgr;
	UNLOCK( PERCEPTION_HAE );
}
void setQueryResult(QueryResultMgr& mgr)
{
	RD_LOCK( QUERY_RESULT );
	query_Result_mgr = mgr;
	UNLOCK( QUERY_RESULT );
}
void setAttentionLevel(AttentionLevelMgr &mgr) {
	WR_LOCK( ATTENTIONLEVEL );
	attention_level_mgr = mgr;
	UNLOCK( ATTENTIONLEVEL );
}
//google canendar
void setAction_apState(Action_apStateMgr& mgr)
{
	WR_LOCK(FFORMATION);
	action_apstate_mgr = mgr;
	UNLOCK(FFORMATION);
}
Beispiel #27
0
static void call_php(char *name, PARAMDSC *r, int argc, PARAMDSC **argv)
{
	do {
		zval callback, args[4], return_value;
		PARAMVARY *res = (PARAMVARY*)r->dsc_address;
		int i;

		ZVAL_STRING(&callback, name);

		LOCK();

		/* check if the requested function exists */
		if (!zend_is_callable(&callback, 0, NULL)) {
			break;
		}

		UNLOCK();

		/* create the argument array */
		for (i = 0; i < argc; ++i) {

			/* test arg for null */
			if (argv[i]->dsc_flags & DSC_null) {
				ZVAL_NULL(&args[i]);
				continue;
			}

			switch (argv[i]->dsc_dtype) {
				ISC_INT64 l;
				struct tm t;
				char const *fmt;
				char d[64];

				case dtype_cstring:
//???
					ZVAL_STRING(&args[i], (char*)argv[i]->dsc_address);
					break;

				case dtype_text:
//???
					ZVAL_STRINGL(&args[i], (char*)argv[i]->dsc_address, argv[i]->dsc_length);
					break;

				case dtype_varying:
//???
					ZVAL_STRINGL(&args[i], ((PARAMVARY*)argv[i]->dsc_address)->vary_string,
						((PARAMVARY*)argv[i]->dsc_address)->vary_length);
					break;

				case dtype_short:
					if (argv[i]->dsc_scale == 0) {
						ZVAL_LONG(&args[i], *(short*)argv[i]->dsc_address);
					} else {
						ZVAL_DOUBLE(&args[i],
							((double)*(short*)argv[i]->dsc_address)/scales[-argv[i]->dsc_scale]);
					}
					break;

				case dtype_long:
					if (argv[i]->dsc_scale == 0) {
						ZVAL_LONG(&args[i], *(ISC_LONG*)argv[i]->dsc_address);
					} else {
						ZVAL_DOUBLE(&args[i],
							((double)*(ISC_LONG*)argv[i]->dsc_address)/scales[-argv[i]->dsc_scale]);
					}
					break;

				case dtype_int64:
					l = *(ISC_INT64*)argv[i]->dsc_address;

					if (argv[i]->dsc_scale == 0 && l <= LONG_MAX && l >= LONG_MIN) {
						ZVAL_LONG(&args[i], (long)l);
					} else {
						ZVAL_DOUBLE(&args[i], ((double)l)/scales[-argv[i]->dsc_scale]);
					}
					break;

				case dtype_real:
					ZVAL_DOUBLE(&args[i], *(float*)argv[i]->dsc_address);
					break;

				case dtype_double:
					ZVAL_DOUBLE(&args[i], *(double*)argv[i]->dsc_address);
					break;

				case dtype_sql_date:
					isc_decode_sql_date((ISC_DATE*)argv[i]->dsc_address, &t);
					ZVAL_STRINGL(&args[i], d, strftime(d, sizeof(d), INI_STR("ibase.dateformat"), &t),1);
					break;

				case dtype_sql_time:
					isc_decode_sql_time((ISC_TIME*)argv[i]->dsc_address, &t);
					ZVAL_STRINGL(&args[i], d, strftime(d, sizeof(d), INI_STR("ibase.timeformat"), &t),1);
					break;

				case dtype_timestamp:
					isc_decode_timestamp((ISC_TIMESTAMP*)argv[i]->dsc_address, &t);
					ZVAL_STRINGL(&args[i], d, strftime(d, sizeof(d), INI_STR("ibase.timestampformat"), &t));
					break;
			}
		}

		LOCK();

		/* now call the function */
		if (FAILURE == call_user_function(EG(function_table), NULL,
				&callback, &return_value, argc, args)) {
			UNLOCK();
			break;
		}

		UNLOCK();

		for (i = 0; i < argc; ++i) {
			switch (argv[i]->dsc_dtype) {
				case dtype_sql_date:
				case dtype_sql_time:
				case dtype_timestamp:
					zval_dtor(&args[i]);
			}
		}

		zval_dtor(&callback);

		/* return whatever type we got back from the callback: let DB handle conversion */
		switch (Z_TYPE(return_value)) {

			case IS_LONG:
				r->dsc_dtype = dtype_long;
				*(long*)r->dsc_address = Z_LVAL(return_value);
				r->dsc_length = sizeof(long);
				break;

			case IS_DOUBLE:
				r->dsc_dtype = dtype_double;
				*(double*)r->dsc_address = Z_DVAL(return_value);
				r->dsc_length = sizeof(double);
				break;

			case IS_NULL:
				r->dsc_flags |= DSC_null;
				break;

			default:
				convert_to_string(&return_value);

			case IS_STRING:
				r->dsc_dtype = dtype_varying;
				memcpy(res->vary_string, Z_STRVAL(return_value),
					(res->vary_length = min(r->dsc_length-2,Z_STRLEN(return_value))));
				r->dsc_length = res->vary_length+2;
				break;
		}

		zval_dtor(&return_value);

		return;

	} while (0);

	/**
	* If we end up here, we should report an error back to the DB engine, but
	* that's not possible. We can however report it back to PHP.
	*/
	LOCK();
	php_error_docref(NULL, E_WARNING, "Error calling function '%s' from database", name);
	UNLOCK();
}
void setResult_apState(Result_apStateMgr& mgr)
{
	WR_LOCK(FFORMATION);
	result_apstate_mgr = mgr;
	UNLOCK(FFORMATION);
}
Beispiel #29
0
static Int read_line_to_string(USES_REGS1) {
  int sno = Yap_CheckStream(ARG1, Input_Stream_f, "read_line_to_codes/2");
  Int status;
  UInt max_inp, buf_sz;
  unsigned char *buf;
  size_t sz;
  StreamDesc *st = GLOBAL_Stream + sno;
  int ch;

  if (sno < 0)
    return false;
  status = GLOBAL_Stream[sno].status;
  if (status & Eof_Stream_f) {
    UNLOCK(GLOBAL_Stream[sno].streamlock);
    return Yap_unify_constant(ARG2, MkAtomTerm(AtomEof));
  }
  max_inp = (ASP - HR) / 2 - 1024;
  buf = (unsigned char *)TR;
  buf_sz = (unsigned char *)LOCAL_TrailTop - buf;
 
    if (buf_sz > max_inp) {
      buf_sz = max_inp;
    }
    if (st->status & Binary_Stream_f) {
      char *b = (char *)TR;
      sz = fread(b, 1, buf_sz, GLOBAL_Stream[sno].file);
    } else {
      unsigned char *pt = buf;
      do {
         ch = st->stream_wgetc_for_read(sno);
        if (ch < 127) {
          *pt++ = ch;
          if (ch < 0) {
            ch = '\n';
            pt[-1] = '\n';
          }
        } else {
          pt += get_utf8(pt, 4, &ch);
          if (pt + 4 == buf + buf_sz)
            break;
        }
      } while (ch != '\n');
      sz = pt - buf;
    }
  if (sz == -1 || sz == 0) {
    if (GLOBAL_Stream[sno].status & Eof_Stream_f) {
      UNLOCK(GLOBAL_Stream[sno].streamlock);
      return Yap_unify_constant(ARG2, MkAtomTerm(AtomEof));
    }
    UNLOCK(GLOBAL_Stream[sno].streamlock);
    return false;
  }
  if (GLOBAL_Stream[sno].status & Eof_Stream_f || buf[sz - 1] == 10) {
    /* we're done */

    if (!(GLOBAL_Stream[sno].status & Eof_Stream_f)) {
      UNLOCK(GLOBAL_Stream[sno].streamlock);
      /* handle CR before NL */
      if ((Int)sz - 2 >= 0 && buf[sz - 2] == 13)
        buf[sz - 2] = '\0';
      else {
        buf[sz - 1] = '\0';
      }
    } else {
      UNLOCK(GLOBAL_Stream[sno].streamlock);
    }
  }
  if (GLOBAL_Stream[sno].encoding == ENC_ISO_UTF8) {
    return Yap_unify(ARG2, Yap_UTF8ToString((const char *)TR PASS_REGS));
  } else if (GLOBAL_Stream[sno].encoding == ENC_WCHAR) {
    return Yap_unify(ARG2, Yap_WCharsToString((const wchar_t *)TR PASS_REGS));
  } else {
    return Yap_unify(
        ARG2, Yap_CharsToString((const char *)TR, ENC_ISO_LATIN1 PASS_REGS));
  }
  buf += (buf_sz - 1);
  max_inp -= (buf_sz - 1);
  if (max_inp <= 0) {
    UNLOCK(GLOBAL_Stream[sno].streamlock);
    Yap_Error(RESOURCE_ERROR_STACK, ARG1, NULL);
    return FALSE;
  }
}
void setActionSpeak( Action_Speak& mgr )
{
	WR_LOCK( ACTION_SPEAK );
	action_speak_mgr = mgr;
	UNLOCK( ACTION_SPEAK );
}