示例#1
0
int main(int argc, char* argv[])
{
	float result[ORDER];
	signal(SIGINT,  Exit);
  	signal(SIGTERM, Exit);

#ifdef SW
	init_pipe_handler();
	PTHREAD_DECL(vectorSum);
	PTHREAD_CREATE(vectorSum);
#endif
	PTHREAD_DECL(Sender);
	PTHREAD_CREATE(Sender);

	uint8_t idx;
	


	read_float32_n("out_data_pipe",result,ORDER);

	for(idx = 0; idx < ORDER; idx++)
	{
		fprintf(stdout,"Result = %f, expected = %f.\n", result[idx],expected_result[idx]);
	}
	PTHREAD_CANCEL(Sender);
#ifdef SW
	close_pipe_handler();
	PTHREAD_CANCEL(vectorSum);
#endif
	return(0);
}
示例#2
0
int main(int argc, char* argv[])
{
	float result[ORDER];
	signal(SIGINT,  Exit);
  	signal(SIGTERM, Exit);

#ifdef SW
#ifdef USE_GNUPTH
	pth_init();
#endif
	init_pipe_handler();
	PTHREAD_DECL(conversionTest);
	PTHREAD_CREATE(conversionTest);
#endif
	PTHREAD_DECL(Sender);
	PTHREAD_CREATE(Sender);

	uint8_t idx;
	


	read_uint64_n("out_data",((uint64_t*) result),ORDER/2);

	for(idx = 0; idx < ORDER; idx++)
	{
		fprintf(stdout,"Result = %f, expected = %f.\n", result[idx],expected_result[idx]);
	}
	PTHREAD_CANCEL(Sender);
#ifdef SW
	close_pipe_handler();
	PTHREAD_CANCEL(conversionTest);
#endif
	return(0);
}
示例#3
0
void
stop_daemons ()
{
  PTHREAD_CANCEL (stage_0);
  PTHREAD_CANCEL (stage_1);
  PTHREAD_CANCEL (stage_2);
  PTHREAD_CANCEL (stage_3);
}
示例#4
0
int main(int argc, char* argv[])
{
	signal(SIGINT,  Exit);
  	signal(SIGTERM, Exit);

	PTHREAD_DECL(Sender);
	PTHREAD_CREATE(Sender);

	uint8_t idx;
	uint32_t result[ORDER];
	

	read_uint32_n("out_data", result, ORDER);

	for(idx = 0; idx < ORDER; idx++)
	{
		fprintf(stdout,"%d. Result = %x, expected %x\n", idx, result[idx], (idx + 1));
	}
	PTHREAD_CANCEL(Sender);

	for(idx = 0; idx < ORDER; idx++)
	{
		write_uint32("in_data", idx);
		uint32_t res = read_uint32("out_data");
		fprintf(stdout,"%d. Result = %x, expected %x\n", idx, res, (idx + 1));
	}

	return(0);
}
示例#5
0
int main(int argc, char* argv[])
{
#ifdef SW
	init_pipe_handler_with_log("pipelog.txt");
	PTHREAD_DECL(maxDaemon);   // declare the Daemon thread.
	PTHREAD_CREATE(maxDaemon); // start the Daemon..
#endif
	while(1)
	{
		uint32_t a, b;
		scanf("%d", &a);
		scanf("%d", &b);
		write_uint32("in_data",a);
		write_uint32("in_data",b);
		uint32_t c = read_uint32("out_data");
		fprintf(stdout,"Result = %d.\n", c);

		if(a == 0)
			break;
	}

#ifdef SW
	close_pipe_handler();
	PTHREAD_CANCEL(maxDaemon);
#endif
	return(0);
}
示例#6
0
int main(int argc, char* argv[])
{
    float result;
    signal(SIGINT,  Exit);
    signal(SIGTERM, Exit);

#ifdef SW
    init_pipe_handler();
    PTHREAD_DECL(dotProduct);
    PTHREAD_CREATE(dotProduct);
#endif

    uint8_t idx;
    float expected_result = 0.0;
    for(idx = 0; idx < ORDER; idx++)
    {
        float val = drand48();
        expected_result += (val*val);
        write_float32("in_data_pipe",val);
    }


    result = read_float32("out_data_pipe");
    fprintf(stdout,"Result = %f, expected = %f.\n", result, expected_result);
#ifdef SW
    close_pipe_handler();
    PTHREAD_CANCEL(dotProduct);
    return(0);
#endif
}
示例#7
0
int main(int argc, char* argv[])
{
	signal(SIGINT,  Exit);
  	signal(SIGTERM, Exit);

#ifdef SW
	init_pipe_handler();
	PTHREAD_DECL(vectorSum);
	PTHREAD_CREATE(vectorSum);
#endif


	write_uint32("in_data",1);
	write_uint32("in_data",2);
	write_uint32("in_data",3);
	write_uint32("in_data",4);

	uint32_t rval = read_uint32("out_data");
	fprintf(stdout,"Result = %d.\n", rval);

#ifdef SW
	close_pipe_handler();
	PTHREAD_CANCEL(vectorSum);
#endif
	return(0);
}
示例#8
0
int main(int argc, char* argv[])
{
    uint32_t result[ORDER];
    signal(SIGINT,  Exit);
    signal(SIGTERM, Exit);

#ifdef SW
    init_pipe_handler_with_log("pipeHandler.log");
    _start_daemons(stderr);
#endif
    PTHREAD_DECL_AND_CREATE(Sender);

    read_uint32_n("out_data",result,ORDER);

    uint32_t idx;
    for(idx = 0; idx < ORDER; idx++)
    {
        fprintf(stdout,"Result = %u, expected = %u.\n", result[idx],idx+1);
    }
    PTHREAD_CANCEL(Sender);
#ifdef SW
    close_pipe_handler();
    _stop_daemons();
#endif
    return(0);
}
示例#9
0
asmlinkage int pthread_cancel_sys (pthread_t thread) {
  if (!thread || thread -> magic_number != PTHREAD_MAGIC_NUMBER) {
    SET_ERRNO (ESRCH);
    return -1;
  }

  PTHREAD_CANCEL (thread);
  
  return 0;
}
示例#10
0
int main(int argc, char* argv[])
{
        FILE* ofile1;
        FILE* ofile2;
        char ostr[17];
	uint16_t N[ORDER];

#ifdef SW
	init_pipe_handler();
	PTHREAD_DECL(gcd_daemon);
	PTHREAD_CREATE(gcd_daemon);
#endif

        ofile1 = fopen("gcd_inputs.txt","w");
        ofile2 = fopen("gcd_result.txt","w");

	int err = 0;
   
	uint16_t S = 1;
	if(argc > 1)
		S = atoi(argv[1]);
	fprintf(stderr,"Scale-factor = %d.\n",S);


	srand48(19);

	uint16_t i;
	for(i = 0; i < ORDER; i++)
	{
		N[i] = ((uint16_t) (0x0fff * drand48())) * S;
		fprintf(stderr,"N[%d] = %d\n", i, N[i]);
		write_uint16("in_data",N[i]);
		to_string(ostr,N[i]);
		fprintf(ofile1,"%s\n", ostr);
	}

	uint16_t g = read_uint16("out_data");
	fprintf(stderr,"GCD = %d.\n",g);
	to_string(ostr,g);
	fprintf(ofile2,"%s\n",ostr);

	uint32_t et = read_uint32("elapsed_time");
	fprintf(stderr,"Elapsed time = %u.\n", et);

	fclose(ofile1);
	fclose(ofile2);

#ifdef SW
	PTHREAD_CANCEL(gcd_daemon);
	close_pipe_handler();
#endif

	return(0);
}
示例#11
0
int main(int argc, char* argv[])
{
	uint16_t result[ORDER];
	signal(SIGINT,  Exit);
  	signal(SIGTERM, Exit);

	PTHREAD_DECL(Sender);
	PTHREAD_CREATE(Sender);

	uint8_t idx;
	
	read_uint16_n("out_data",result,ORDER);

	for(idx = 0; idx < ORDER; idx++)
	{
		fprintf(stdout,"Result[%d] = %x.\n", idx, result[idx]);
	}
	PTHREAD_CANCEL(Sender);
	PTHREAD_CANCEL(Sender);
	return(0);
}
示例#12
0
int main(int argc, char* argv[])
{
	float result;
	int I, J;

	if(argc < 2)
	{
		fprintf(stderr,"Supply data set file.\n");
		return(1);
	}


	signal(SIGINT,  Exit);
	signal(SIGTERM, Exit);

#ifdef SW
	init_pipe_handler();
	PTHREAD_DECL(bestFit);
	PTHREAD_DECL(qrsDet);
	PTHREAD_CREATE(bestFit);
	PTHREAD_CREATE(qrsDet);
#endif
	PTHREAD_DECL(Sender);
	PTHREAD_DECL(Receiver);	
	PTHREAD_CREATE_WITH_ARG(Sender, argv[1]);
	PTHREAD_CREATE(Receiver);

	PTHREAD_JOIN(Sender);
	PTHREAD_CANCEL(Receiver);
	



#ifdef SW
	PTHREAD_CANCEL(qrsDet);
	PTHREAD_CANCEL(bestFit);
	close_pipe_handler();
	return(0);
#endif
}
示例#13
0
int main(int argc, char* argv[])
{
	uint8_t result[ORDER];
	signal(SIGINT,  Exit);
  	signal(SIGTERM, Exit);

	PTHREAD_DECL(Write_Sender);
	PTHREAD_CREATE(Write_Sender);
	PTHREAD_DECL(Read_Sender);
	PTHREAD_CREATE(Read_Sender);

	uint8_t idx;
	
	read_uint8_n("read_response",result,ORDER);

	for(idx = 0; idx < ORDER; idx++)
	{
		fprintf(stdout,"Result = %x, expected = %x.\n", result[idx],idx);
	}
	PTHREAD_CANCEL(Write_Sender);
	PTHREAD_CANCEL(Read_Sender);
	return(0);
}
int main(int argc, char* argv[])
{
#ifdef SW
	init_pipe_handler_with_log("pipelog.txt");
	PTHREAD_DECL(vector_control_daemon);   // declare the Daemon thread.
	PTHREAD_CREATE(vector_control_daemon); // start the Daemon..
#endif

	double	*iq, 
		*iq_prev,
		*id,
		*id_prev,
		*flq,
		*flq_prev,
		*fld,
		*fld_prev,
		*spd,
		*spd_prev,
		vd,
		vq,
		torque,
		load_torque,
		*time = 0;
	
	double speed_ref
		
	int i=0;
	int no_of_cycles = 4000 ; // 100u/25n (Ideal time necessary for conputation for FPGA/Motor_iteration_step)
				
	while(1)
	{
		for(i = 0; i< no_of_cycles; i++){
			im_zep(&iq,&iq_prev,&id,&id_prev,&flq,&flq_prev,&fld,&fld_prev,&spd_prev,vd,vq,&torque,load_torque,&time)
		}
		
		write_float32("in_data",*id);
		write_float32("in_data",*iq);
		write_float32("in_data",speed_ref);

		vd = read_float32("out_data");
		vq = read_float32("out_data");
	}

#ifdef SW
	close_pipe_handler();
	PTHREAD_CANCEL(vector_control_daemon);
#endif
	return(0);
}
示例#15
0
int main(int argc, char* argv[])
{
	float result[ORDER];
	signal(SIGINT,  Exit);
	signal(SIGTERM, Exit);

	uint8_t idx;
	for(idx = 0; idx < ORDER; idx++)
	{
		op[idx] = idx % 4;
		x[idx] = drand48();
		y[idx] = drand48();
	}
#ifdef SW
	init_pipe_handler();
	PTHREAD_DECL(streamProcessor);
	PTHREAD_CREATE(streamProcessor);
#endif
	PTHREAD_DECL(sendX);
	PTHREAD_CREATE(sendX);
	PTHREAD_DECL(sendY);
	PTHREAD_CREATE(sendY);
	PTHREAD_DECL(sendOp);
	PTHREAD_CREATE(sendOp);



	read_float32_n("z_pipe",result,ORDER);

	for(idx = 0; idx < ORDER; idx++)
	{
		fprintf(stdout,"Result = %f, expected = %f.\n", result[idx],expectedResult(op[idx], x[idx], y[idx]));
	}
#ifdef SW
	close_pipe_handler();
	PTHREAD_CANCEL(streamProcessor);
#endif
	return(0);
}
示例#16
0
int main(void)
{
    BYTE init[16] = {
	0, 1, 2, 3,
	4, 5, 6, 7,
	8, 9, 10, 11,
	12, 13, 14, 15
    };

#ifdef SW
	init_pipe_handler();
	PTHREAD_DECL(Daemon);
	PTHREAD_CREATE(Daemon);
#endif

    sendConstants();

    int i, run;
    long long t1[10], t2[10];

    for (run = 0; run < 10; run++) {
	fprintf(stderr," run %d.\n", run);
	for (i = 0; i < 16; i++) {
	    write_uint8("input_block_pipe", init[i]);
	    fprintf(stderr," wrote %x \n", init[i]);
	}

	for (i = 0; i < 16; i++) {
		uint8_t rV = read_uint8("output_block_pipe");
		fprintf(stderr," read-back %x \n", rV);
	}
    }

#ifdef SW
	close_pipe_handler();
	PTHREAD_CANCEL(Daemon);
#endif
    return 0;
}
示例#17
0
int main(int argc, char* argv[])
{
	signal(SIGINT,  Exit);
	signal(SIGTERM, Exit);
	int idx;
	int expected, diff;
	PTHREAD_DECL(Sender);
	PTHREAD_CREATE(Sender);

	for(idx = 0; idx < ORDER; idx++)
	{
		result[idx] = read_uint32("out_data");
		expected = *((uint32_t*) &expected_result[idx]);
		diff = result[idx] - expected;
		fprintf(stdout,"Result = %x, expected = %x, diff = %d.\n", result[idx], expected,diff);

	}

	PTHREAD_CANCEL(Sender);

	return(0);
}
int op_timed_out(CTXTdeclc xsbTimeout *timeout)
{
  struct timespec wakeup_time;                            // time.h
  int rc;

  wakeup_time.tv_sec = time(NULL) + (int)pflags[SYS_TIMER];
  pthread_mutex_lock(&timeout->timeout_info.mutex);
  rc = pthread_cond_timedwait(&timeout->timeout_info.condition, 
			      &timeout->timeout_info.mutex, &wakeup_time);
  pthread_mutex_unlock(&timeout->timeout_info.mutex);
  if (rc != 0) {
    switch(rc) {
    case EINVAL:
      xsb_bug("pthread_cond_timedwait returned EINVAL");
      break;
    case ETIMEDOUT:
      break;
    case ENOMEM:
      xsb_error("Not enough memory to wait\n");
      break;
    default:
      xsb_bug("pthread_cond_timedwait returned an unexpected value (%d)\n", rc);      
    }
  }
  TURNOFFALARM;  // mt-noop(?)
  switch (timeout->timeout_info.exitFlag) {
  case STILL_WAITING: /* The call timed out */
    PTHREAD_CANCEL(timeout->timeout_info.timedThread);
    return TRUE;
  case TIMED_OUT:
    return TRUE;
  case NORMAL_TERMINATION:
    return FALSE;
  default:
    xsb_bug("timed call's exit flag is an unexpected value (%d)", timeout->timeout_info.exitFlag);
    return FALSE;
  }
}
示例#19
0
int main(int argc, char* argv[])
{	
	uint64_t result[2];
	signal(SIGINT,  Exit);
  	signal(SIGTERM, Exit);

	PTHREAD_DECL(Sender);
	PTHREAD_CREATE(Sender);
	
	uint8_t idx, jdx;
	
	
	for(idx = 0; idx < ORDER; idx++)
	{
	
		read_uint64_n("out_data",result,2);
		fprintf(stdout,"\n%16llx %16llx", result[0],result[1]);
	}
	
	
	PTHREAD_CANCEL(Sender);
	return(0);
}
示例#20
0
int main(int argc, char* argv[])
{
	signal(SIGINT,  Exit);
  	signal(SIGTERM, Exit);
  	signal(SIGSEGV, Exit);

        int i,j,k;

        srand48(100);

        for(i = 0; i < ORDER; i++)
	{
        	for(j = 0; j < ORDER; j++)
		{
			a_matrix[i][j] = drand48();
			b_matrix[i][j] = drand48();
		}
	}

        for(i = 0; i < ORDER; i++)
	{
        	for(j = 0; j < ORDER; j++)
		{
			expected_c_matrix[i][j] = 0;
        		for(k = 0; k < ORDER; k++)
				expected_c_matrix[i][j] += a_matrix[i][k] * b_matrix[k][j];
		}
	}
	
#ifdef SW
	init_pipe_handler();

	PTHREAD_DECL(mmultiply);
	PTHREAD_DECL(mmultiply_LL);
	PTHREAD_DECL(mmultiply_LH);
	PTHREAD_DECL(mmultiply_HH);
	PTHREAD_DECL(mmultiply_HL);

	PTHREAD_CREATE(mmultiply);
	PTHREAD_CREATE(mmultiply_LL);
	PTHREAD_CREATE(mmultiply_LH);
	PTHREAD_CREATE(mmultiply_HH);
	PTHREAD_CREATE(mmultiply_HL);
#endif

	write_matrices();
	read_result_matrix();



	fprintf(stdout,"results: \n ");
	for(i = 0; i < ORDER; i++)
	{
		for(j = 0; j < ORDER; j++)
		{
			if(expected_c_matrix[i][j] == c_matrix[i][j])
				fprintf(stdout,"result[%d][%d] = %f\n", i, j, c_matrix[i][j]);
			else
				fprintf(stdout,"Error: result[%d][%d] = %f, expected = %f\n", 
						i, j, c_matrix[i][j], expected_c_matrix[i][j]);

		}
	}
	fprintf(stdout,"done\n");

#ifdef SW
	PTHREAD_CANCEL(mmultiply);
	PTHREAD_CANCEL(mmultiply_LL);
	PTHREAD_CANCEL(mmultiply_LH);
	PTHREAD_CANCEL(mmultiply_HH);
	PTHREAD_CANCEL(mmultiply_HL);
	close_pipe_handler();
#endif
}
示例#21
0
int main(int argc, char* argv[])
{
	float result;
	int I;

	if(argc < 2)
	{
		fprintf(stderr,"Supply data set file.\n");
		return(1);
	}

	FILE* fp = fopen(argv[1],"r");
	if(fp == NULL)
	{
		fprintf(stderr,"Could not open data set file %s.\n", argv[1]);
		return(1);
	}

	signal(SIGINT,  Exit);
	signal(SIGTERM, Exit);

	PTHREAD_DECL(Logger);
	PTHREAD_CREATE(Logger);

#ifdef SW
	init_pipe_handler();
	PTHREAD_DECL(bestFit);
	PTHREAD_CREATE(bestFit);
#endif

	Sender();
	for(I = 0; I < NSAMPLES; I++)
	{
		double X;
		fscanf(fp, "%le", &X);
		write_float64("sample_data_pipe", X);
		samples[I] = X;
	}
	fprintf(stderr," Sent samples.\n");
	fclose(fp);

	calculateReferenceFit();

	uint32_t best_sigma_index = read_uint32("best_sigma_pipe");
	fprintf(stdout, " Best sigma= %f (index = %d).\n", (MIN_SIGMA + (best_sigma_index*(MAX_SIGMA - MIN_SIGMA)/NSIGMAS)), best_sigma_index);
	
	double p0 = read_float64("fit_coefficient_pipe");
	double p1 = read_float64("fit_coefficient_pipe");
	double p2 = read_float64("fit_coefficient_pipe");
	double p3 = read_float64("fit_coefficient_pipe");
	double p4 = read_float64("fit_coefficient_pipe");
	double p5 = read_float64("fit_coefficient_pipe");
	fprintf(stdout, "Fit coefficients = %le, %le, %le, %le, %le, %le.\n", p0,p1,p2,p3,p4,p5);

	uint32_t elapsed_time = read_uint32("elapsed_time_pipe");
	fprintf(stdout,"Elapsed time = %d.\n", elapsed_time);

#ifdef SW
	PTHREAD_CANCEL(bestFit);
	close_pipe_handler();
	return(0);
#endif
}