void data_server(int argc, char *argv[])
{
int np;
MPI_Comm_size(MPI_COMM_WORLD, &np);
MPI_Status status;
int num_comp_nodes = np -1;
unsigned int num_bytes = sizeof(sAgents);
sAgents h_agents_in, h_agents_out[num_comp_nodes];
/* initialize input data */
init_data(h_agents_in);
#ifdef DEBUG
printf("Init data\n");
display_data(h_agents_in);
#endif
/* send data to compute nodes */
for(int process = 0; process < num_comp_nodes; process++)
MPI_Send(&h_agents_in, num_bytes, MPI_BYTE, process, 0, MPI_COMM_WORLD);
runDisplay(argc, argv);
/* release resources */
//free(&h_agents_in);
//free(&h_agents_out);
}
int main()
{
InitData();
while(1) {
ReadTimeAndJudgeAlarmArrival();
switch (mainLoop) {
case 0:
display_time();
break;
case 1:
display_data();
break;
case 2:
display_alarm();
break;
case 3:
display_sWatch();
break;
}
KeyScan();
}
return 0;
}
void serial_process(void)
{
uint8_t serial_channel = serial_readFrame();
packet_t *packet;
if( serial_channel == 0 ){
return;
}
if( serial_channel == 0xFF ||
serial_channel == 0xFE ){
display_data(serial_channel,
serial_getMessage(), serial_getMessageLen());
return;
}
if( serial_getMessageLen() == 16 ){
uint8_t *msg = serial_getMessage();
if( serial_channel == '0' ){
packet = (packet_t *) msg;
if( packet_check_magic(packet) ){
cmd_new(packet->cmd, packet->data);
}
}else if(serial_channel != 0) {
bus_sendFrame(serial_channel, msg, 16);
}
}
}
/*!
* Init Display
*/
void display_init(void){
shift_init();
DISPLAY_DDR |= DISPLAY_OUT; // Ausgänge
DISPLAY_DDR &= ~DISPLAY_IN; // Eingänge
delay(30); // Display steht erst 10ms nach dem Booten bereit
// Register in 8-Bit-Modus 3x Übertragen, dazwischen warten
shift_data_out(0x38,SHIFT_LATCH,SHIFT_REGISTER_DISPLAY);
DISPLAY_PORT= DPC;
delay(5);
shift_data_out(0x38,SHIFT_LATCH,SHIFT_REGISTER_DISPLAY);
DISPLAY_PORT= DPC;
delay(5);
shift_data_out(0x38,SHIFT_LATCH,SHIFT_REGISTER_DISPLAY);
DISPLAY_PORT= DPC;
delay(5);
display_cmd(0x0f); //Display On, Cursor On, Cursor Blink
display_cmd(DISPLAY_CLEAR); // Display l�schen, Cursor Home
display_data('i');
}
static void as_event(enum sys_message msg)
{
if ( (msg & SYS_MSG_RTC_MINUTE) == SYS_MSG_RTC_MINUTE)
{
if(sAccel.mode == ACCEL_MODE_ON) sAccel.timeout--;
//if timeout is over disable the accelerometer
if(sAccel.timeout<1)
{
//disable accelerometer to save power
as_stop();
//update the mode to remember
sAccel.mode = ACCEL_MODE_OFF;
}
}
if ( (msg & SYS_MSG_AS_INT) == SYS_MSG_AS_INT)
{
//Check the vti register for status information
as_status.all_flags=as_get_status();
//TODO For debugging only
_printf(0, LCD_SEG_L1_1_0, "%1u", as_status.all_flags);
buzzer_play(smb);
//if we were in free fall or motion detection mode check for the event
if(as_status.int_status.falldet || as_status.int_status.motiondet){
//if such an event is detected enable the symbol
//display_symbol(0, LCD_ICON_ALARM , SEG_SET | BLINK_ON);
//read the data
as_get_data(sAccel.xyz);
//display_data(0);
/* update menu screen */
lcd_screen_activate(0);
}//if we were in measurment mode do a measurement and put it in the virtual screen
else
{
//display_symbol(0, LCD_ICON_ALARM , SEG_SET | BLINK_OFF);
display_data(1);
/* refresh to accelerometer screen only if in that modality */
if (submenu_state== VIEW_AXIS )lcd_screen_activate(1);
}
}
/* The 1 Hz timer is used to refresh the menu screen */
if ( (msg & SYS_MSG_RTC_SECOND) == SYS_MSG_RTC_SECOND)
{
/*check the status register for debugging purposes */
_printf(0, LCD_SEG_L1_1_0, "%1u", as_read_register(ADDR_INT_STATUS));
/* update menu screen */
lcd_screen_activate(0);
}
}
void actualize_data(t_vm *vm, t_proc **lproc)
{
SDL_Rect pos;
SDL_Surface *surface;
pos.x = 50;
pos.y = HEIGHT - SIDEBAR_SIZE;
surface = SDL_CreateRGBSurface(SDL_HWSURFACE, 400,
SIDEBAR_SIZE - 15, 32, 0, 0, 0, 0);
SDL_FillRect(surface, NULL, SDL_MapRGB(vm->sdl->screen->format, 0, 0, 0));
SDL_BlitSurface(surface, NULL, vm->sdl->screen, &pos);
SDL_FreeSurface(surface);
display_data(vm->sdl->screen, vm->cycle, &display_cycle, "Cycle : ");
display_data(vm->sdl->screen, vm->ctd, &display_ctd, "Cycle to die : ");
display_data(vm->sdl->screen, vm->nb_proc, &display_nb_proc,
"Number of procs : ");
display_data(vm->sdl->screen, vm->nb_live, &display_nb_live,
"Number of live : ");
}
int
main(void)
{
/* Fill memory with pseudo-random data */
init_data(LENGTH);
/* Display unsorted */
printf("\nUnsorted:\n");
display_data(LENGTH);
/* Sort */
printf("\nSorting:\n");
sort(LENGTH);
/* Display sorted */
printf("\nSorted:\n");
display_data(LENGTH);
printf("\n");
return 0;
}
static int do_info(sc_card_t *card, const struct ef_name_map *map)
{
int i;
u8 buf[2048];
for (i = 0; map[i].ef != NULL; i++) {
sc_path_t path;
sc_file_t *file;
size_t count;
int r;
sc_format_path(map[i].ef, &path);
r = sc_select_file(card, &path, &file);
if (r) {
util_error("failed to select EF %s: %s", map[i].ef, sc_strerror(r));
return EXIT_FAILURE;
}
count = file->size;
if (!count)
continue;
if (count > sizeof(buf) - 1) {
util_error("too small buffer to read the OpenPGP map");
return EXIT_FAILURE;
}
r = sc_read_binary(card, 0, buf, count, 0);
if (r < 0) {
util_error("failed to read %s: %s", map[i].ef, sc_strerror(r));
return EXIT_FAILURE;
}
if (r != (signed) count || (size_t) r < map[i].offset + map[i].length) {
util_error("%s: expecting %"SC_FORMAT_LEN_SIZE_T"d bytes, got only %d",
map[i].ef, count, r);
return EXIT_FAILURE;
}
if (map[i].offset > 0) {
memmove(buf, buf + map[i].offset, map[i].length);
count -= map[i].offset;
}
if (map[i].length > 0 && count > map[i].length)
count = map[i].length;
if (map[i].type == TYPE_STRING)
buf[count] = '\0';
display_data(&map[i], buf, count);
}
return EXIT_SUCCESS;
}
void run_memtop(void) {
//TODO: initialization for read and select
fd_set rd;
struct timeval timeout;
int bytes;
char buf[BUFFER_SIZE];
// Should I put this code insize FD_ISSET or where?
// With
if (fcntl(STDIN_FILENO,F_SETFL,O_NONBLOCK) == -1) {
perror("fcntl()\n");
}
//to avoid unused variable warning. You may remove it once you use buf.
buf[0] = 0;
while(1) {
//TODO: call select, read, and process_data
FD_ZERO(&rd); // Clear the fd set
FD_SET(STDIN_FILENO,&rd); // Fill the fd set
timeout.tv_sec = 0; // Waiting time is 0
timeout.tv_usec = 0;
if (select(1,&rd,NULL,NULL,&timeout) == -1) {
perror("select()");
}
// Check if STDIN_FILENO ready or not
if (FD_ISSET(STDIN_FILENO,&rd)) {
// read up to BUFFER_SIZE bytes
if ((bytes = read(STDIN_FILENO,buf,BUFFER_SIZE)) == -1) {
perror("read()\n");
}
if (process_input(buf,bytes) != 0) {
break;
}
}
//read proc filesystem
int n_procs = 0;
process_t *proc_arr = collect_data(&n_procs);
if (proc_arr == NULL) {
continue;
}
sort_data(proc_arr, n_procs);
//update display
display_data(proc_arr, n_procs);
//free proc_data
free(proc_arr);
}
}
int main()
{
/* Main variables */
//t.start();
CN0216 cn0216;
#ifdef SINGLE_CONVERSION
cn0216.init(CAL_WEIGHT);
#elif defined CONTINOUS_CONVERSION
cn0216.init(CAL_WEIGHT, 0x08, 0x07);
#else
#error define SINGLE_CONVERSION or CONTINOUS_CONVERSION, but not both
#endif
/* Calibration sequence */
pc.printf("\r\n Calibrating zero scale. Remove all weights from scale. Press any key to begin ..");
while(!pc.readable());
flush_serial_buffer();
pc.printf("\r\n Calibrating . . . ");
cn0216.calibrate(CN0216::ZERO_SCALE_CALIBRATION);
pc.printf("done ! ");
pc.printf("\r\n Calibrating full scale. Put calibration weight on scale. Press any key to begin ..");
while(!pc.readable());
flush_serial_buffer();
pc.printf("\r\n Calibrating . . . ");
cn0216.calibrate(CN0216::FULL_SCALE_CALIBRATION);
pc.printf("done ! ");
pc.printf("\r\n Calibration successful ");
cn0216.calibrate(CN0216::COMPUTE_UNITS_PER_BIT);
/* Infinite loop */
uint64_t timer = 0;
while (1) {
wait_ms(1000);
uint32_t data = cn0216.read_u32();
float weight = cn0216.compute_weight(data); // Convert ADC data to voltage
display_data(data, weight, timer); // Display data thru UART
timer++;
}
/* Infinite loop, never returns. */
}
static int do_userinfo(sc_card_t *card)
{
int i;
/* FIXME there are no length checks on buf. */
unsigned char buf[2048];
for (i = 0; openpgp_data[i].ef != NULL; i++) {
sc_path_t path;
sc_file_t *file;
size_t count;
int r;
sc_format_path(openpgp_data[i].ef, &path);
r = sc_select_file(card, &path, &file);
if (r) {
fprintf(stderr, "Failed to select EF %s: %s\n", openpgp_data[i].ef, sc_strerror(r));
return EXIT_FAILURE;
}
count = file->size;
if (!count)
continue;
if (count > sizeof(buf) - 1) {
fprintf(stderr, "Too small buffer to read the OpenPGP data\n");
return EXIT_FAILURE;
}
r = sc_read_binary(card, 0, buf, count, 0);
if (r < 0) {
fprintf(stderr, "%s: read failed - %s\n", openpgp_data[i].ef, sc_strerror(r));
return EXIT_FAILURE;
}
if (r != (signed)count) {
fprintf(stderr, "%s: expecting %"SC_FORMAT_LEN_SIZE_T"d, got only %d bytes\n",
openpgp_data[i].ef, count, r);
return EXIT_FAILURE;
}
buf[count] = '\0';
display_data(openpgp_data + i, (char *) buf);
}
return EXIT_SUCCESS;
}
BK_U8B display_error_printf(const char * format, ...)
{
char display_buf[DISPLAY_BUFFER_SIZE]; /*!< Pufferstring fuer Displayausgaben */
va_list args;
/* Sicher gehen, dass der zur Verfuegung stehende Puffer nicht ueberlaeuft */
va_start(args, format);
const BK_U8B len = (BK_U8B) vsnprintf(display_buf, DISPLAY_BUFFER_SIZE, format, args);
va_end(args);
/* Ausgeben bis Puffer leer ist */
char * ptr = display_buf;
BK_U8B i;
for (i = len; i > 0; --i) {
display_data(*ptr++);
}
/* Ausgeben bis Puffer leer ist */
return len;
}
int main(int ac, char **av)
{
int fd;
t_raw raw;
t_data data;
t_env env;
read_args(&env, ac, av);
get_env(&env, av[1]);
fd = xopen(av[1], O_RDONLY);
raw = read_file(fd);
close(fd);
data = read_raw(raw);
display_data(data, env);
mlx_loop(env.mlx);
return (1);
}
int main(int argc, char **argv)
{
int vc; /* argv: console number */
Gpm_Connect conn; /* connection to gpm */
fd_set fds;
/* select virtual console, 0 if not set */
vc = (argc == 2) ? strtol(argv[1],NULL,10) : 0;
conn.eventMask = GPM_MOVE; /* read only moves */
conn.defaultMask = ~GPM_HARD; /* inverted GPM_HARD mask */
conn.minMod = 0;
conn.maxMod = ~0;
if(Gpm_Open(&conn,vc) == -1) {
printf("Cannot connect to gpm!\n");
return 1;
}
if(gpm_fd == -2) {
printf("I must be run on the console\n");
return 1;
}
while(1) { /* read data */
FD_ZERO(&fds);
FD_SET(gpm_fd, &fds);
if (select(gpm_fd+1, &fds, 0, 0, 0) < 0 && errno == EINTR)
continue;
if (FD_ISSET(gpm_fd, &fds)) {
Gpm_Event evt;
if (Gpm_GetEvent(&evt) > 0) {
display_data(&evt, NULL);
} else {
printf("Gpm_GetEvent failed\n");
}
}
}
Gpm_Close(); /* close connection */
return 0;
}
/*!
* Schreibt einen String auf das Display.
* @param format Format, wie beim printf
* @param ... Variable Argumentenliste, wie beim printf
*/
void display_printf(char *format, ...) {
unsigned int run = 0;
va_list args;
/* Sicher gehen, das der zur Verfuegung stehende Puffer nicht
* ueberschrieben wird.
*/
va_start(args, format);
vsnprintf(display_buf, DISPLAY_BUFFER_SIZE, format, args);
va_end(args);
/* Ausgeben bis Puffer leer ist */
while(display_buf[run] != '\0') {
display_data(display_buf[run]);
run++;
}
return;
}
void nlcall(struct sk_buff *__skb)
{
struct sk_buff *skb;
struct nlmsghdr *nlh;
char data[128];
struct data_t *p;
printk(KERN_ALERT "[+]netlink start\n");
/*
* get true skb
*/
skb = skb_get(__skb);
/*
* length of actual data must be bigger than
* NLMSG_LENTH
*/
if (skb->len >= NLMSG_SPACE(0)) {
/*
* skb->data
*/
nlh = nlmsg_hdr(skb);
/*
* nlh + NLMSG_LENTH -->data
*/
memcpy(data, NLMSG_DATA(nlh), sizeof(data));
p = (struct data_t *)data;
display_data(p->start, p->len);
kfree_skb(skb);
}
else {
printk(KERN_ALERT "data len is short!\n");
}
}
void displayThread(void *args)
{
BK_U8B *command;
BK_S8B *data;
BK_U8B len;
while(1)
{
if(msgQueueMsgReadNoWait(commandMQ,&command,&len))
{
if(len == 1)
{
display_cmd(*command);
}
BK_free(command);
}
if(msgQueueMsgReadNoWait(dataMQ,&data,&len))
{
if(len > 2)
{
if(*data != -1)
{
display_cursor(data[0],data[1]);
data ++;
len -=2;
}
data++;
while(len > 0)
{
display_data(*data);
len--;
data++;
}
}
}
done();
}
}
/*
* 主要查询函数
*/
void consult()
{
char word[MAX_WORD+1];
char *data=NULL;
long idx[MAX_KEYS];
unsigned int offset, length;
cache_idx(idx);
while(1){
printf("INPUT A WORD OR PHRASE: ");
if(get_input(word, MAX_WORD)){
fseek(pidx,locate_idx(word,idx),SEEK_SET);
if(search_word(word,&offset,&length))
{
data=get_data(offset,length);
display_data(data,length);
free(data);
data=NULL;
}else fprintf(stderr,"SORRY, '%s' CANNOT BE FOUND!\n", word);
printf("\n----------------------------------------\n\n");
}else break;
}
}
/*
* process state machine
*/
void si7005_process(){
U8 T[2], b;
i2c_status st;
if(state == RELAX) return;
if(state == WAITFORP || state == WAITFORT){ // poll RDY
if((st = i2c_7bit_send_onebyte(0, 0)) == I2C_OK){
if(i2c_7bit_receive_onebyte(&b,0) == I2C_OK){
if(b) return; // !RDY
if((st = i2c_7bit_send_onebyte(1, 0)) == I2C_OK)
if((st = i2c_7bit_receive_twobyte(T,0)) == I2C_OK)
display_data(T);
state = RELAX;
if(st){
uart_write("can't read value, err: ");
printUHEX(st); UART_send_byte('\n');
}
}
}else{
error_msg("can't poll !RDY, err: ");
printUHEX(st); UART_send_byte('\n');
state = RELAX;
}
}
}
int main(int argc, char **argv){
int c;
int colouron = 0;
char *fslist = NULL;
time_t last_update = 0;
extern int errno;
int delay=2;
sg_log_init("saidar", "SAIDAR_LOG_PROPERTIES", argc ? argv[0] : NULL);
sg_init(1);
if(sg_drop_privileges() != 0){
fprintf(stderr, "Failed to drop setuid/setgid privileges\n");
return 1;
}
#ifdef COLOR_SUPPORT
while ((c = getopt(argc, argv, "d:F:cvh")) != -1){
#else
while ((c = getopt(argc, argv, "d:F:vh")) != -1){
#endif
switch (c){
case 'd':
delay = atoi(optarg);
if (delay < 1){
fprintf(stderr, "Time must be 1 second or greater\n");
exit(1);
}
break;
#ifdef COLOR_SUPPORT
case 'c':
colouron = 1;
break;
#endif
case 'v':
version_num(argv[0]);
break;
case 'h':
default:
usage(argv[0]);
return 1;
}
}
if (fslist) {
sg_error rc = set_valid_filesystems(fslist);
if(rc != SG_ERROR_NONE)
die(sg_str_error(rc));
free(fslist);
}
else {
sg_error rc = set_valid_filesystems("!nfs, nfs3, nfs4, cifs, smbfs, samba, autofs");
if(rc != SG_ERROR_NONE)
die(sg_str_error(rc));
}
signal(SIGWINCH, sig_winch_handler);
initscr();
#ifdef COLOR_SUPPORT
/* turn on colour */
if (colouron) {
if (has_colors()) {
start_color();
use_default_colors();
init_pair(1,COLOR_RED,-1);
init_pair(2,COLOR_GREEN,-1);
init_pair(3,COLOR_YELLOW,-1);
init_pair(4,COLOR_BLUE,-1);
init_pair(5,COLOR_MAGENTA,-1);
init_pair(6,COLOR_CYAN,-1);
} else {
fprintf(stderr, "Colour support disabled: your terminal does not support colour.");
colouron = 0;
}
}
#endif
nonl();
curs_set(0);
cbreak();
noecho();
timeout(delay * 1000);
newwin(0, 0, 0, 0);
clear();
if(!get_stats()){
fprintf(stderr, "Failed to get all the stats. Please check correct permissions\n");
endwin();
return 1;
}
display_headings();
for(;;){
time_t now;
int ch = getch();
if (ch == 'q'){
break;
}
/* To keep the numbers slightly accurate we do not want them
* updating more frequently than once a second.
*/
now = time(NULL);
if ((now - last_update) >= 1) {
get_stats();
}
last_update = now;
if(sig_winch_flag) {
clear();
display_headings();
sig_winch_flag = 0;
}
display_data(colouron);
}
endwin();
sg_shutdown();
return 0;
}
int
Frame_data::load_data_oldformat(Gframe *gframe, char *dirpath, char *filename,
int display_data_flag,
int load_silently)
/*
* Load parameters and sisdata into a frame from a directory from
* <dir>/curpar, <dir>/datdir/phasefile.sis.
*
* If there is no <dir>/datdir/phasefile.sis or it is out-of-data, it
* will convert <dir>/datdir/phasefile to <dir>/datdir/phasefile.sis.
*
* Here are the steps for reading in data in the old format:
*
* + Invoke Frame_data::load_params(gframe, exppath, curpar,...);
*
* this creates the gframe->params structure
*
* + Release the old gframe->imginfo (if it exists).
*
* + Convert the phasefile into a SIS file (old format) if the SIS file
* is non-existent or if it is older than the phasefile.
*
* + Invoke Frame_data::load_data(gframe, exppath, phasefile.sis, ...)
*
* If any of the above steps fail, it is necessary to call
* PS_release(gframe->params) in order to deallocate the params structure
*
*/
{
char exppath[256]; // path to the experiment being loaded
char infile[256]; // filename for the phasefile
char outfile[256]; // filename for the SIS format file
char errmsg[128]; // error message buffer
int temp_file_used = FALSE;
struct stat buf; // Holds status of phasefile
double lpe, lro; // field of view parameters
char trace[4]; // trace = "f1" or trace = "f2"
Sisfile_info *sisfile;
// Build experiment directory pathname
(void)sprintf(exppath, "%s/%s", dirpath, filename);
win_print_msg("Loading %s/%s/curpar.......", dirpath, filename);
if (Frame_data::load_params(gframe, exppath, "curpar",
load_silently) == NOT_OK) {
if (!load_silently) {
msgerr_print("load_data: Error loading %scurpar", filename);
win_print_msg("Loading %s/%sdatdir/phasefile.sis: ERROR",
dirpath, filename);
}
return NOT_OK;
}
// Build filenames for the convert routine
(void)sprintf(infile, "%sdatdir/phasefile", exppath);
// (void)sprintf(outfile, "%sdatdir/phasefile.sis", exppath);
// First check status of phasefile and converted phasefile
if (stat(infile, &buf) == -1) {
if (!load_silently) {
msgerr_print("load_data:Couldn't find %s/%sdatdir/phasefile",
dirpath, filename);
win_print_msg("Loading %s/%sdatdir/phasefile: ERROR",
dirpath, filename);
}
PS_release(gframe->params);
gframe->params = NULL; // So PS_read will allocate space next time
return NOT_OK;
}
if (PS_get_string_value(gframe->params, "trace", 3, (char **)&trace)
!= P_OK)
(void)sprintf(trace, "f1");
if (PS_get_real_value(gframe->params, "lpe", 1, &lpe) != P_OK)
lpe = 1.0;
if (PS_get_real_value(gframe->params, "lro", 1, &lro) != P_OK)
lro = 1.0;
if (strcmp(trace, "f1")) {
if (!load_silently) {
msgerr_print(
"load_data:WARNING:phasefile with trace='f2' is not yet supported.");
}
double temp = lpe;
lpe = lro;
lro = temp;
}
// release old image data before overwriting file
if (gframe->imginfo) gframe->clear();
detach_imginfo(gframe->imginfo);
win_print_msg("Converting phasefile to SIS file format....");
if (! (sisfile = Sisfile_info::sisdata_phase2sis(infile,
(float)lpe, (float)lro, errmsg) ) )
{
if (!load_silently){
msgerr_print(
"load_data:Can't convert %s/%sdatdir/phasefile to sisfile",
dirpath, filename);
msgerr_print(" Reason:%s", errmsg);
win_print_msg("Loading %s/ %sdatdir/phasefile.sis: ERROR",
dirpath, filename);
}
PS_release(gframe->params);
gframe->params = NULL; // So PS_read will allocate space next time
return NOT_OK;
}
win_print_msg("Loading %s/%sdatdir/phasefile.sis: .......",
dirpath, filename);
{
char errmsg[128]; // Error message buffer
double DEFAULT_VS = 4200.0;
double vs = DEFAULT_VS; // vertical scale
// Release previous data; then allocate memory for new Imginfo
detach_imginfo(gframe->imginfo);
sisfile->SetDirpath(dirpath);
sisfile->SetFilename(filename);
if (sisfile->header.rank != RANK_2D){
// Not a 2D data set--I can't handle this!
msgerr_print("load_data_oldformat(): Not a 2D data set.");
return NOT_OK;
}
gframe->imginfo = new Imginfo(sisfile->header.rank,
sisfile->header.bit,
sisfile->header.type,
sisfile->header.fast,
sisfile->header.medium,
sisfile->header.slow,
sisfile->header.hyperslow);
// Copy data image from sisfile to st
gframe->imginfo->st->SetData(sisfile->data, sisfile->DataLength());
// Used gray-scale colormap
gframe->imginfo->cmsindex = SISCMS_2;
// Get the vertical scale. Note that we retrieve a vertical scale value
// from Vnmr, where its gray-leve is 64. Now, we need to convert it to
// the current gray-levels
if (gframe->params && PS_exist(gframe->params, "vs")) {
if (PS_get_real_value(gframe->params, "vs", 1, &vs) == P_OK) {
// From experience, we need to multiple the converted vs with 1.7
// in order to obtain a good image
vs *= (double) (G_Get_Sizecms2(gframe->gdev) / 64.0) * 1.7;
} else {
vs = DEFAULT_VS;
}
}
DDLSymbolTable *st = gframe->imginfo->st;
gframe->imginfo->vs = vs;
st->SetValue("vs", vs);
// st->SetValue("span", sisfile->header.ratio_fast, 0);
// st->SetValue("span", sisfile->header.ratio_medium, 1);
st->SetValue("span", (float)lpe, 0);
st->SetValue("span", (float)lro, 1);
st->SetValue("roi", (float)lpe, 0);
st->SetValue("roi", (float)lro, 1);
st->SetValue("dirpath", sisfile->GetDirpath());
st->SetValue("filename", sisfile->GetFilename());
// Display all the data
if (display_data_flag) {
display_data(gframe, 0, 0, sisfile->header.fast,
sisfile->header.medium,
vs);
}
win_print_msg("Loading %s/%sdatdir/phasefile: DONE",
dirpath, filename);
}
delete sisfile;
return OK;
}
void data_server(int agents_total, int world_width, int world_height)
{
int np;
MPI_Comm_size(MPI_COMM_WORLD, &np);
/* create a type for struct agent */
const int nitems=5;
int blocklengths[5] = {1,1,1,1,1};
MPI_Datatype types[5] = {MPI_INT, MPI_INT, MPI_INT, MPI_FLOAT, MPI_FLOAT};
MPI_Datatype mpi_agent_type;
MPI_Aint offsets[5];
offsets[0] = offsetof(agent, id);
offsets[1] = offsetof(agent, x);
offsets[2] = offsetof(agent, y);
offsets[3] = offsetof(agent, z);
offsets[4] = offsetof(agent, w);
MPI_Type_create_struct(nitems, blocklengths, offsets, types, &mpi_agent_type);
MPI_Type_commit(&mpi_agent_type);
int num_comp_nodes = np -1;
unsigned int num_bytes = agents_total * sizeof(agent);
agent *h_agents_in, *h_agents_out;
/* allocate input data */
h_agents_in = (agent *)malloc(num_bytes);
h_agents_out = (agent *)malloc(num_bytes);
if(h_agents_in == NULL || h_agents_out == NULL)
{
printf("server couldn't allocate memory\n");
MPI_Abort(MPI_COMM_WORLD, 1);
}
/* initialize input data */
init_data(h_agents_in, agents_total);
#ifdef DEBUG
printf("Init data\n");
display_data(h_agents_in, agents_total);
#endif
int world_height_node = world_height / num_comp_nodes;
// printf("world_height: %d\n", world_height_node);
agent h_agents_node_in[num_comp_nodes][agents_total], h_agents_node_out[num_comp_nodes][agents_total];
for(int process = 0; process < num_comp_nodes; process++)
{
for(int i = 0; i < agents_total; i++)
{
if( ( h_agents_in[i].y >= (process * world_height_node) ) and ( h_agents_in[i].y < ( (process + 1) * world_height_node ) ) )
h_agents_node_in[process][i] = h_agents_in[i];
}
}
/***
printf("copy data 0\n");
display_data(h_agents_node_in[0], agents_total);
printf("copy data 1\n");
display_data(h_agents_node_in[1], agents_total);
printf("copy data 2\n");
display_data(h_agents_node_in[2], agents_total);
***/
/* send data to compute nodes */
for(int process = 0; process < num_comp_nodes; process++)
MPI_Send(h_agents_node_in[process], agents_total, mpi_agent_type, process, 0, MPI_COMM_WORLD);
/* Wait for nodes to compute */
MPI_Barrier(MPI_COMM_WORLD);
/* Collect output data */
MPI_Status status;
for(int process = 0; process < num_comp_nodes; process++)
MPI_Recv(h_agents_node_out[process], agents_total, mpi_agent_type, process, DATA_COLLECT, MPI_COMM_WORLD, &status);
#ifdef DEBUG
printf("Final Data\n");
/* display output data */
// display_data(h_agents_out, agents_total);
#endif
/* release resources */
free(h_agents_in);
free(h_agents_out);
// free(h_agents_node_in);
// free(h_agents_node_out);
}
void sig_winch_handler(int sig){
clear();
display_headings();
display_data();
signal(SIGWINCH, sig_winch_handler);
}
////////////////////////////////////////////////////////////////////////////////
//! Run the Cuda part of the computation
////////////////////////////////////////////////////////////////////////////////
void refreshData(struct cudaGraphicsResource **vbo_resource)
{
int np;
MPI_Comm_size(MPI_COMM_WORLD, &np);
MPI_Status status;
int num_comp_nodes = np -1;
unsigned int num_bytes = sizeof(sAgents);
sAgents h_agents_in, h_agents_out[num_comp_nodes];
size_t size_agents = agents_total * sizeof(float4);
// map OpenGL buffer object for writing from CUDA
float4 *d_agents;
// Error code to check return values for CUDA calls
cudaError_t err = cudaSuccess;
checkCudaErrors(cudaGraphicsMapResources(1, vbo_resource, 0));
size_t num_agents_bytes;
checkCudaErrors(cudaGraphicsResourceGetMappedPointer((void **)&d_agents, &num_agents_bytes,
*vbo_resource));
//for(int process = 0; process < num_comp_nodes; process++)
//while(1)
//{
/* Wait for nodes to compute */
MPI_Barrier(MPI_COMM_WORLD);
for(int process = 0; process < num_comp_nodes; process++)
{
MPI_Recv(&h_agents_out[process], num_bytes, MPI_BYTE, process, DATA_COLLECT, MPI_COMM_WORLD, &status);
for( int i = 0; i < agents_total; i++)
{
if( h_agents_out[process].ids[i].y == 1 )
{
h_agents_in.pos[i] = h_agents_out[process].pos[i];
h_agents_in.ids[i] = h_agents_out[process].ids[i];
h_agents_in.pos[i].z = 0;
h_agents_in.pos[i].w = 1;
}
}
}
#ifdef DEBUG
printf("Final Data:\n");
display_data(h_agents_in);
#endif
/***
//pasar los valores al vbo
glBindBuffer(GL_ARRAY_BUFFER, vbo);
unsigned int size = agent_width * agent_height * 4 * sizeof(float);
glBufferSubData(GL_ARRAY_BUFFER, 0, size, &h_agents_in.pos);
glBindBuffer(GL_ARRAY_BUFFER, 0);
***/
// Copy the host pointer memory to the device memory
printf("Copy pointer from the host memory to the CUDA device\n");
err = cudaMemcpy(d_agents, h_agents_in.pos, size_agents, cudaMemcpyHostToDevice);
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to copy pointer from host to device (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
//glutPostRedisplay();
printf("sale de refreshData:\n");
//}
// unmap buffer object
checkCudaErrors(cudaGraphicsUnmapResources(1, vbo_resource, 0));
/* release resources */
//free(&h_agents_in);
//free(&h_agents_out);
}
int main(int argc, char **argv)
{
xmp_context ctx;
struct xmp_module_info mi;
struct xmp_frame_info fi;
int row, pos, i;
if (sound_init(44100, 2) < 0) {
fprintf(stderr, "%s: can't initialize sound\n", argv[0]);
exit(1);
}
ctx = xmp_create_context();
for (i = 1; i < argc; i++) {
if (xmp_load_module(ctx, argv[i]) < 0) {
fprintf(stderr, "%s: error loading %s\n", argv[0],
argv[i]);
continue;
}
if (xmp_start_player(ctx, 44100, 0) == 0) {
/* Show module data */
xmp_get_module_info(ctx, &mi);
printf("%s (%s)\n", mi.mod->name, mi.mod->type);
/* Play module */
row = pos = -1;
while (xmp_play_frame(ctx) == 0) {
xmp_get_frame_info(ctx, &fi);
if (fi.loop_count > 0)
break;
sound_play(fi.buffer, fi.buffer_size);
if (fi.pos != pos) {
printf("\n%02x:%02x\n",
fi.pos, fi.pattern);
pos = fi.pos;
row = -1;
}
if (fi.row != row) {
display_data(&mi, &fi);
row = fi.row;
}
}
xmp_end_player(ctx);
}
xmp_release_module(ctx);
printf("\n");
}
xmp_free_context(ctx);
sound_deinit();
return 0;
}
int main(int argc, char **argv){
extern char *optarg;
int c;
time_t last_update = 0;
WINDOW *window;
extern int errno;
int delay=2;
sg_init();
if(sg_drop_privileges() != 0){
fprintf(stderr, "Failed to drop setuid/setgid privileges\n");
return 1;
}
while ((c = getopt(argc, argv, "vhd:")) != -1){
switch (c){
case 'd':
delay = atoi(optarg);
if (delay < 1){
fprintf(stderr, "Time must be 1 second or greater\n");
exit(1);
}
break;
case 'v':
version_num(argv[0]);
break;
case 'h':
default:
usage(argv[0]);
return 1;
break;
}
}
signal(SIGWINCH, sig_winch_handler);
initscr();
nonl();
cbreak();
noecho();
timeout(delay * 1000);
window=newwin(0, 0, 0, 0);
clear();
if(!get_stats()){
fprintf(stderr, "Failed to get all the stats. Please check correct permissions\n");
endwin();
return 1;
}
display_headings();
for(;;){
time_t now;
int ch = getch();
if (ch == 'q'){
break;
}
/* To keep the numbers slightly accurate we do not want them
* updating more frequently than once a second.
*/
now = time(NULL);
if ((now - last_update) >= 1) {
get_stats();
}
last_update = now;
display_data();
}
endwin();
return 0;
}