Beispiel #1
0
void* timer_run_thread(void* x) {
    rtdal_timer_t *obj = (rtdal_timer_t*) x;

    if (DEBUG_rtdal) {
        rtdal_task_print_sched();
    }

    switch(obj->mode) {
    case XENOMAI:
#ifdef __XENO__
        return xenomai_timer_run_thread(obj);
#else
        aerror("Not compiled with xenomai support\n");
        return NULL;
#endif
    case NANOSLEEP:
        return nanoclock_timer_run_thread(obj);
#ifdef EN_TIMERFD
    case TIMERFD:
        return timerfd_timer_run_thread(obj);
#endif
    default:
        aerror_msg("Unknown timer mode %d\n", obj->mode);
        return NULL;
    }
}
Beispiel #2
0
int timer_setup (rtdal_timer_t *info)
{
    long int ns;
    __time_t sec;
    int fd;

    if (info->period<=0) {
        aerror_msg("Invalid period %d\n", (int) info->period);
        return -1;
    }

    /* Create the timer */
    fd = timerfd_create (CLOCK_REALTIME, 0);
    if (fd == -1) {
        perror("timerfd_create");
        return -1;
    }

    info->wakeups_missed = 0;
    info->timer_fd = fd;

    /* Make the timer periodic */
    sec = info->period/1000000000;
    ns = (info->period - (sec * 1000000));
    info->itval.it_interval.tv_sec = sec;
    info->itval.it_interval.tv_nsec = ns;
    info->itval.it_value.tv_sec = sec;
    info->itval.it_value.tv_nsec = ns;

    return 0;
}
Beispiel #3
0
inline static void pipeline_run_time_slot(pipeline_t *obj) {
	int idx;
	rtdal_process_t *run_proc;
	hdebug("pipeid=%d, tslot=%d, nof_process=%d thread=%d\n",obj->id,obj->ts_counter,
			obj->nof_processes, obj->thread);
	obj->finished = 0;

	pipeline_run_thread_print_time(obj);

	run_proc = obj->first_process;
	idx = 0;

	while(run_proc) {
		hdebug("%d/%d: run=%d code=%d next=0x%x\n",idx,obj->nof_processes,run_proc->runnable,
				run_proc->finish_code,run_proc->next);
		if (idx > obj->nof_processes) {
			aerror_msg("Fatal error. Corrupted pipeline-%d process list at process %d\n",
					obj->id, idx);
			kill(getpid(),SIGTERM);
			pthread_exit(NULL);
		}
		pipeline_run_thread_check_status(obj,run_proc);
		pipeline_run_thread_run_module(obj,run_proc, idx);
		run_proc = run_proc->next;
		idx++;
	}
	obj->ts_counter++;
	obj->finished = 1;
}
Beispiel #4
0
/** USES oesr_man_ERROR to describe any mapping error */
int generate_model(mapping_t *m, waveform_t *waveform, man_platform_t *platform) {

	int multiplicity;

	if (waveform->granularity_us) {
		if (platform->ts_length_us % waveform->granularity_us) {
			aerror_msg("Timeslot length must be multiple of waveform granularity (%d us)\n",
					waveform->granularity_us);
			return -1;
		}
		multiplicity = platform->ts_length_us/waveform->granularity_us;
	} else {
		multiplicity = 1;
	}

	generate_model_platform(platform);

	generate_model_join_function(waveform);

	generate_model_c_vector(waveform, multiplicity);

	generate_model_b_matrix(waveform, multiplicity);

	generate_model_stages(waveform);

	return 0;
}
Beispiel #5
0
/** \brief Processes a packet. Calls one of the processing functions depending on the command
 */
int nod_anode_dispatch(packet_t *pkt) {
	int n;
	ndebug("pkt=0x%x, cmd=%d\n",pkt,packet_get_cmd(pkt));
	switch(packet_get_cmd(pkt)) {
	case CMD_LOAD:
		n = nod_dispatcher_load(pkt);
		packet_clear(pkt);
		break;
	case CMD_SET:
		n =  nod_dispatcher_set(pkt);
		packet_clear(pkt);
		break;
	case CMD_GET:
		n =  nod_dispatcher_get(pkt);
		break;
	case CMD_CONNECT:
		n =  nod_dispatcher_connect_node(pkt);
		break;
	case CMD_DISCONNECT:
		n =  nod_dispatcher_disconnect_node(pkt);
		break;
	case CMD_HWINFO:
		n =  nod_dispatcher_hwinfo(pkt);
		break;
	default:
		aerror_msg("Unknown command %d\n", (int) packet_get_cmd(pkt));
		n =  -1;
		break;
	}
	return n;
}
Beispiel #6
0
/** Maps waveform to the platform. The platform is obtained using the man_platform_get_context()
 * function.
 * The mapping result is saved to each module in the module_t.processor_idx and module_t.exec_position
 * fields. module_t.node is pointed to the platform node object of the allocated processor.
 * The number of nodes allocated to each node is saved in the mapping_t.modules_x_node array.
 * \returns 0 if the mapping was feasible, -1 otherwise. The error description is saved in the
 * oesr_man_error class.
 */
int mapping_map(mapping_t *m, waveform_t *waveform) {
	/**@TODO: Use the oesr_man_error class for error messages */

	mdebug("waveform_name=%s, nof_modules=%d\n",waveform->name, waveform->nof_modules);
	int i;
	int ret=-1;
	float total_mopts;
	man_platform_t *platform = man_platform_get_context();
	man_node_t *node;
	if (!platform) {
		aerror("oesr_man not initialized\n");
		return -1;
	}
	printf("Computing mapping for %d modules...\n",waveform->nof_modules);
	if (mapping_alloc(m,waveform->nof_modules,platform->nof_processors)) {
		return -1;
	}
	if (setup_algorithm(m)) {
		goto free;
	}
	if (generate_model(m, waveform, platform)) {
		goto free;
	}
	if (call_algorithm(m, waveform, platform)) {
		goto free;
	}
	total_mopts=0;
	memset(m->modules_x_node,0,sizeof(int)*MAX(nodes));
	for (i=0;i<waveform->nof_modules;i++) {
		if (m->p_res[joined_function_inv[i]] >= platform->nof_processors) {
			aerror_msg("Module %d mapped to processor %d, but platform has %d processors only\n",
					joined_function_inv[i],m->p_res[joined_function_inv[i]]+1,platform->nof_processors);
			goto free;
		}
		man_processor_t *p = (man_processor_t*) platform->processors[m->p_res[joined_function_inv[i]]];
		waveform->modules[i].node = p->node;
		waveform->modules[i].processor_idx = p->idx_in_node;
		waveform->modules[i].exec_position = i;/*waveform->nof_modules-i-1;*/
		node = p->node;
		m->modules_x_node[node->id]++;
		total_mopts+=waveform->modules[i].c_mopts[0];
	}
	printf("Done. %g GOPTS\n",total_mopts/1000);
	ret = 0;
free:
	mapping_free(m,waveform->nof_modules,platform->nof_processors);
	return ret;
}
Beispiel #7
0
inline static void pipeline_run_thread_run_module(pipeline_t *pipe,
		rtdal_process_t *proc, int idx) {
	hdebug("pipeid=%d, pid=%d, idx=%d, run=%d\n",pipe->id,proc->pid,idx,proc->runnable);
	if (proc->runnable) {
		pipe->running_process = proc;
		pipe->running_process_idx = idx;
		proc->is_running = 1;
		if (proc->run_point(proc->arg)) {
			aerror_msg("Error running module %d:%d\n",
					pipe->id,pipe->running_process_idx);
			pipeline_remove(pipe,proc);
			proc->is_running = 0;
		}
		proc->is_running = 0;
	}
}
Beispiel #8
0
inline static void pipeline_run_thread_check_status(pipeline_t *pipe,
		rtdal_process_t *proc) {

	hdebug("pipeid=%d, pid=%d, run=%d, code=%d, waveform_notify=%d\n",pipe->id,proc->pid,
			proc->runnable,proc->finish_code, pgroup_notified_failure[proc->attributes.process_group_id]);
	if (proc->runnable && proc->finish_code != FINISH_OK &&
			!pgroup_notified_failure[proc->attributes.process_group_id]) {
		if (proc->attributes.finish_callback) {
			hdebug("calling finish 0x%x arg=0x%x\n",proc->attributes.finish_callback,
					proc->arg);
			pgroup_notified_failure[proc->attributes.process_group_id] = 1;
			rtdal_task_new(NULL, proc->attributes.finish_callback,proc->arg);
		} else {
			aerror_msg("Abnormal pid=%d termination but no callback was defined\n",
					proc->pid);
		}
	}
}
Beispiel #9
0
void* timer_run_thread(void* x) {
	rtdal_timer_t *obj = (rtdal_timer_t*) x;

	switch(obj->mode) {
	case XENOMAI:
#ifdef __XENO__
		return xenomai_timer_run_thread(obj);
#else
		aerror("Not compiled with xenomai support\n");
		return NULL;
#endif
	case NANOSLEEP:
		return nanoclock_timer_run_thread(obj);
	default:
		aerror_msg("Unknown timer mode %d\n", obj->mode);
		return NULL;
	}
}
Beispiel #10
0
/**  Called when there is an rtfault in the pipeline
 */
int pipeline_rt_fault(pipeline_t *obj) {
#ifdef KILL_RT_FAULT
	hdebug("pipeline_id=%d, process_idx=%d\n",obj->id,obj->running_process_idx,obj->running_process_idx);
	obj->finished = 1;
	aerror_msg("RT-Fault detected at pipeline %d, process %d\n",obj->id,
			obj->running_process_idx);
	if (obj->thread) {
		int s = pthread_kill(obj->thread,SIGUSR1);
		if (s) {
			rtdal_POSERROR(s, "pthread_kill");
			return -1;
		}
	}
#else
	obj->finished = 1;
	printf("+++[ts=%d]+++ RT-Fault: Process %d/%d still running in pipeline %d\n",
			obj->ts_counter, obj->running_process_idx, obj->nof_processes, obj->id);
#endif
	return 0;
}
Beispiel #11
0
int parse_config(char *config_file) {
	config_t config;
	int ret = -1;
	config_setting_t *rtdal,*dac;
	const char *tmp;
	int single_timer;
	int time_slot_us;

	config_init(&config);
	if (!config_read_file(&config, config_file)) {
		aerror_msg("line %d - %s: \n", config_error_line(&config),
				config_error_text(&config));
		goto destroy;
	}

	rtdal = config_lookup(&config, "rtdal");
	if (!rtdal) {
		aerror("Error parsing config file: rtdal section not found.\n");
		goto destroy;
	}

	if (!config_setting_lookup_int(rtdal, "time_slot_us", &time_slot_us)) {
		aerror("time_slot_us field not defined\n");
		goto destroy;
	}

	if (!config_setting_lookup_string(rtdal, "cores", &tmp)) {
		aerror("cores field not defined\n");
		goto destroy;
	}
	nof_cores = parse_cores((char*) tmp);
	if (nof_cores < 0) {
		printf("Error invalid cores %s\n",tmp);
		exit(0);
	}

	if (!config_setting_lookup_bool(rtdal, "enable_usrp", &using_uhd)) {
		aerror("enable_usrp field not defined\n");
		goto destroy;
	}

	if (!config_setting_lookup_bool(rtdal, "timer_mode_single", &single_timer)) {
		aerror("timer_mode_single field not defined\n");
		goto destroy;
	}
	if (using_uhd) {
		if (single_timer) {
			clock_source = SINGLE_TIMER;
		} else {
			clock_source = DAC;
		}
	} else {
		if (single_timer) {
			clock_source = SINGLE_TIMER;
		} else {
			clock_source = MULTI_TIMER;
		}
	}
	if (!config_setting_lookup_string(rtdal, "path_to_libs", &tmp)) {
		aerror("path_to_libs field not defined\n");
		goto destroy;
	}

	strcpy(libs_path,tmp);

	if (using_uhd) {
		dac = config_lookup(&config, "dac");
		if (!dac) {
			aerror("Error parsing config file: dac section not found.\n");
			goto destroy;
		}

#ifdef HAVE_UHD
		double tmp;
		if (!config_setting_lookup_float(dac, "samp_freq", &dac_cfg.inputFreq)) {
			aerror("samp_freq field not defined\n");
			goto destroy;
		}
		dac_cfg.outputFreq = dac_cfg.inputFreq;

		if (!config_setting_lookup_float(dac, "rf_freq", &dac_cfg.inputRFFreq)) {
			aerror("rf_freq field not defined\n");
			goto destroy;
		}
		dac_cfg.outputRFFreq = dac_cfg.inputRFFreq;

		if (!config_setting_lookup_float(dac, "rf_gain", &tmp)) {
			aerror("rf_gain field not defined\n");
			goto destroy;
		}
		dac_cfg.tx_gain = tmp;
		dac_cfg.rx_gain = tmp;

		if (!config_setting_lookup_float(dac, "if_bw", &tmp)) {
			aerror("rf_gain field not defined\n");
			goto destroy;
		}
		dac_cfg.tx_bw = tmp;
		dac_cfg.rx_bw = tmp;

		if (!config_setting_lookup_bool(dac, "sample_is_short", &dac_cfg.sampleType)) {
			aerror("rf_gain field not defined\n");
			goto destroy;
		}

		if (!config_setting_lookup_int(dac, "block_size", &dac_cfg.NsamplesIn)) {
			aerror("block_size field not defined\n");
			goto destroy;
		}
		dac_cfg.NsamplesOut = dac_cfg.NsamplesIn;

		if (!config_setting_lookup_bool(dac, "chain_is_tx", &dac_cfg.chain_is_tx)) {
			aerror("chain_is_tx field not defined\n");
			goto destroy;
		}

		dac_cfg.sampleType = 0;
		dac_cfg.nof_channels = 1;

		uhd_readcfg(&dac_cfg);
#endif
	}
	if (using_uhd) {
#ifdef HAVE_UHD
		timeslot_us = (long int) 1000000*((float) dac_cfg.NsamplesOut/dac_cfg.outputFreq);
#endif
	} else {
		timeslot_us = time_slot_us;
	}
	ret=0;
destroy:
	config_destroy(&config);
	return ret;
}