message_ex* dsn_message_parser::get_message_on_receive(int read_length, /*out*/ int& read_next) { mark_read(read_length); if (_read_buffer_occupied >= sizeof(message_header)) { if (!_header_checked) { if (!message_ex::is_right_header((char*)_read_buffer.data())) { derror("receive message header check failed for message"); truncate_read(); read_next = -1; return nullptr; } else { _header_checked = true; } } int msg_sz = sizeof(message_header) + message_ex::get_body_length((char*)_read_buffer.data()); // msg done if (_read_buffer_occupied >= msg_sz) { auto msg_bb = _read_buffer.range(0, msg_sz); message_ex* msg = message_ex::create_receive_message(msg_bb); if (!msg->is_right_body(false)) { message_header* header = (message_header*)_read_buffer.data(); derror("body check failed for message, id: %d, rpc_name: %s, from: %s", header->id, header->rpc_name, header->from_address.to_string()); truncate_read(); read_next = -1; return nullptr; } else { _read_buffer = _read_buffer.range(msg_sz); _read_buffer_occupied -= msg_sz; _header_checked = false; read_next = sizeof(message_header); return msg; } } else { read_next = msg_sz - _read_buffer_occupied; return nullptr; } } else { read_next = sizeof(message_header) - _read_buffer_occupied; return nullptr; } }
int main(int argc,char* args[]) { struct sockaddr_in ser_addr[6],cli_addr; int portno,cli_len,i,j,max,nsfd; // max holds max fd value + 1 i = getppid(); printf("%d %d\n", i,getpid()); int S[6]; char buf[256]; int s1_shm,s1_chi; int *s1_count,*s1_child; s1_shm = shmget(ftok(".",2), sizeof(int), IPC_CREAT | 0666); s1_count = shmat(s1_shm,NULL,0); s1_chi = shmget(ftok(".",4), 25*sizeof(int), IPC_CREAT | 0666); s1_child = shmat(s1_chi,NULL,0); for(i=0;i<25;i++) s1_child[i]=-1; signal(SIGCHLD,child_detect); *s1_count=s2_count=0; fd_set readfds; cli_len = sizeof(struct sockaddr_in); for(i=1;i<=5;i++) memset(&ser_addr[i],0,sizeof(struct sockaddr_in)); // Initialize to 0 // address of connection oriented socket for(i=1;i<=5;i++) { ser_addr[i].sin_family = AF_INET; portno = atoi(args[i]); ser_addr[i].sin_port = htons(portno); // converts int to 16 bit integer in network byte order ser_addr[i].sin_addr.s_addr = INADDR_ANY; // to get IP address of machine on which server is running } S[1] = socket(AF_INET,SOCK_STREAM|SOCK_NONBLOCK,0); // socket create... AF_INET for IPv4 domain and SOCK_STREAM for connection oriented systems S[2] = socket(AF_INET,SOCK_STREAM|SOCK_NONBLOCK,0); S[3] = socket(AF_INET,SOCK_DGRAM,0); S[4] = socket(AF_INET,SOCK_STREAM|SOCK_NONBLOCK,0); S[5] = socket(AF_INET,SOCK_DGRAM,0); for(i=1;i<=5;i++) if(bind(S[i],(struct sockaddr*)&ser_addr[i],sizeof(struct sockaddr_in))<0) derror("Bind error"); if(listen(S[1],5)<0) // No. of clients that server can service derror("Listen error"); if(listen(S[2],5)<0) // No. of clients that server can service derror("Listen error"); if(listen(S[4],5)<0) // No. of clients that server can service derror("Listen error"); cli_len = sizeof(struct sockaddr_in); struct timespec tim_dur; tim_dur.tv_sec = 2; // waiting time of 1 sec for verifying set bits of FDSET tim_dur.tv_nsec = 0; max=S[1]; for(i=2;i<=5;i++) { if(max<S[i]) max=S[i]; } while(1) { FD_ZERO(&readfds); // printf("%d %d\n",*s1_count,s2_count); if(*s1_count<25) FD_SET(S[1],&readfds); if(s2_count<15) FD_SET(S[2],&readfds); for(i=3;i<=5;i++) { //if(i!=1&&i!=2) FD_SET(S[i],&readfds); // Set the connection oriented sfd // if(i==1&&s1_count<2) // FD_SET(S[i],&readfds); // if(i==2&&s2_count<2) // FD_SET(S[i],&readfds); } // pselect for finding if data is available //printf("HEllo\n"); if(pselect(max+1,&readfds,NULL,NULL,&tim_dur,NULL)>0); // pselect is used as timeleft is not updated after each select call { //printf("Select truee\n"); if(FD_ISSET(S[1],&readfds)) { printf("S1\n"); // if(s1_count<3) // { nsfd = accept(S[1],(struct sockaddr*)&cli_addr,&cli_len); if(nsfd>=0) { *s1_count=*s1_count+1; int c = fork(); if(c>0) { for(i=0;i<25;i++) { if(s1_child[i]==-1) { s1_child[i]=c; break; } } close(nsfd); printf("%d %d\n",*s1_count,s2_count); } else { close(S[1]); dup2(nsfd,0); execlp("./s1","s1",(char*) 0); // capitalise the buffer exit(0); } } else {; // printf("Something fishy in s1!\n"); } // } // else // { // printf("queue for s1\n"); // } } if(FD_ISSET(S[2],&readfds)) { printf("S2\n"); // if(s2_count<2) // { nsfd = accept(S[2],(struct sockaddr*)&cli_addr,&cli_len); if(nsfd>=0) { pthread_t s2_thread; s2_count++; pthread_create(&s2_thread,NULL,s2_service,(void*)&nsfd); printf("%d %d\n",*s1_count,s2_count); } else {; // printf("Something fishy on s2\n"); } // } // else // { // printf("queue for s2\n"); // } } if(FD_ISSET(S[4],&readfds)) { printf("S4\n"); nsfd = accept(S[4],(struct sockaddr*)&cli_addr,&cli_len); if(nsfd>=0) { int c = fork(); if(c>0) { close(nsfd); } else { close(S[4]); dup2(nsfd,0); execlp("./s5","s5",(char*) 0); // capitalise the buffer exit(0); } } else { printf("Something fishy on s4\n"); } } if(FD_ISSET(S[3],&readfds)) { printf("S3\n"); s3_function(); } if(FD_ISSET(S[5],&readfds)) { printf("S5\n"); if(s5_flag) { int c = fork(); if(c>0) { ; } else { dup2(S[5],0); execlp("./s5","s5",(char*) 0); // capitalise the buffer exit(0); } } else {; //printf("s5 full so waiting\n"); } } } //printf("Some testing\n"); } return 0; }
/* generate C to put netCDF record from in-memory data */ static void gen_load_c( void *rec_start ) { int idim, ival; char *val_string; char *charvalp = NULL; short *shortvalp = NULL; int *intvalp = NULL; float *floatvalp = NULL; double *doublevalp = NULL; unsigned char *ubytevalp = NULL; unsigned short *ushortvalp = NULL; unsigned int *uintvalp = NULL; long long *int64valp = NULL; unsigned long long *uint64valp = NULL; char stmnt[C_MAX_STMNT]; size_t stmnt_len; char s2[C_MAX_STMNT]; if (!vars[varnum].has_data) return; s2[0] = '\0'; cline(""); sprintf(stmnt, " {\t\t\t/* store %s */", vars[varnum].name); cline(stmnt); if (vars[varnum].ndims > 0) { if (vars[varnum].dims[0] == rec_dim) { sprintf(stmnt, " static MPI_Offset %s_start[RANK_%s];", vars[varnum].lname, vars[varnum].lname); cline(stmnt); sprintf(stmnt, " static MPI_Offset %s_count[RANK_%s];", vars[varnum].lname, vars[varnum].lname); cline(stmnt); } /* load variable with data values using static initialization */ sprintf(stmnt, " static %s %s[] = {", ncctype(vars[varnum].type), vars[varnum].lname); stmnt_len = strlen(stmnt); switch (vars[varnum].type) { case NC_CHAR: val_string = cstrstr((char *) rec_start, var_len); sprintf(s2, "%s", val_string); strncat(stmnt, s2, C_MAX_STMNT - strlen(stmnt) ); free(val_string); break; default: switch (vars[varnum].type) { case NC_BYTE: charvalp = (char *) rec_start; break; case NC_SHORT: shortvalp = (short *) rec_start; break; case NC_INT: intvalp = (int *) rec_start; break; case NC_FLOAT: floatvalp = (float *) rec_start; break; case NC_DOUBLE: doublevalp = (double *) rec_start; break; case NC_UBYTE: ubytevalp = (unsigned char *) rec_start; break; case NC_USHORT: ushortvalp = (unsigned short *) rec_start; break; case NC_UINT: uintvalp = (unsigned int *) rec_start; break; case NC_INT64: int64valp = (long long *) rec_start; break; case NC_UINT64: uint64valp = (unsigned long long *) rec_start; break; default: derror("Unhandled type %d\n", vars[varnum].type); return; } for (ival = 0; ival < var_len-1; ival++) { switch (vars[varnum].type) { case NC_BYTE: sprintf(s2, "%d, ", *charvalp++); break; case NC_SHORT: sprintf(s2, "%d, ", *shortvalp++); break; case NC_INT: sprintf(s2, "%ld, ", (long)*intvalp++); break; case NC_FLOAT: sprintf(s2, "%.8g, ", *floatvalp++); break; case NC_DOUBLE: sprintf(s2, "%#.16g", *doublevalp++); tztrim(s2); strcat(s2, ", "); break; case NC_UBYTE: sprintf(s2, "%hhu, ", (unsigned char)*ubytevalp++); break; case NC_USHORT: sprintf(s2, "%hu, ", (unsigned short)*ushortvalp++); break; case NC_UINT: sprintf(s2, "%u, ", (unsigned int)*uintvalp++); break; case NC_INT64: sprintf(s2, "%lld, ", (long long)*int64valp++); break; case NC_UINT64: sprintf(s2, "%llu, ", (unsigned long long)*uint64valp++); break; default: derror("Unhandled type %d\n", vars[varnum].type); return; } stmnt_len += strlen(s2); if (stmnt_len < C_MAX_STMNT) strcat(stmnt, s2); else { cline(stmnt); strcpy(stmnt,s2); stmnt_len = strlen(stmnt); } } for (;ival < var_len; ival++) { switch (vars[varnum].type) { case NC_BYTE: sprintf(s2, "%d", *charvalp); break; case NC_SHORT: sprintf(s2, "%d", *shortvalp); break; case NC_INT: sprintf(s2, "%ld", (long)*intvalp); break; case NC_FLOAT: sprintf(s2, "%.8g", *floatvalp); break; case NC_DOUBLE: sprintf(s2, "%#.16g", *doublevalp++); tztrim(s2); break; case NC_UBYTE: sprintf(s2, "%hhu, ", (unsigned char)*ubytevalp++); break; case NC_USHORT: sprintf(s2, "%hu, ", (unsigned short)*ushortvalp++); break; case NC_UINT: sprintf(s2, "%u, ", (unsigned int)*uintvalp++); break; case NC_INT64: sprintf(s2, "%lld, ", (long long)*int64valp++); break; case NC_UINT64: sprintf(s2, "%llu, ", (unsigned long long)*uint64valp++); break; default: derror("Unhandled type %d\n", vars[varnum].type); break; } stmnt_len += strlen(s2); if (stmnt_len < C_MAX_STMNT) strcat(stmnt, s2); else { cline(stmnt); strcpy(stmnt,s2); stmnt_len = strlen(stmnt); } } break; } strcat(stmnt,"};"); cline(stmnt); if (vars[varnum].dims[0] == rec_dim) { sprintf(stmnt, " %s_len = %lu; /* number of records of %s data */", dims[rec_dim].lname, (unsigned long)vars[varnum].nrecs, /* number of recs for this variable */ vars[varnum].name); cline(stmnt); for (idim = 0; idim < vars[varnum].ndims; idim++) { sprintf(stmnt, " %s_start[%d] = 0;", vars[varnum].lname, idim); cline(stmnt); } for (idim = 0; idim < vars[varnum].ndims; idim++) { sprintf(stmnt, " %s_count[%d] = %s_len;", vars[varnum].lname, idim, dims[vars[varnum].dims[idim]].lname); cline(stmnt); } } if (vars[varnum].dims[0] == rec_dim) { sprintf(stmnt, " stat = ncmpi_put_vara_%s_all(ncid, %s_id, %s_start, %s_count, %s);", ncstype(vars[varnum].type), vars[varnum].lname, vars[varnum].lname, vars[varnum].lname, vars[varnum].lname); cline(stmnt); } else { /* non-record variables */ cline(" ncmpi_begin_indep_data(ncid);"); sprintf(stmnt, " stat = ncmpi_put_var_%s(ncid, %s_id, %s);", ncstype(vars[varnum].type), vars[varnum].lname, vars[varnum].lname); cline(stmnt); cline(" ncmpi_end_indep_data(ncid);"); } } else { /* scalar variables */ /* load variable with data values using static initialization */ sprintf(stmnt, " static %s %s = ", ncctype(vars[varnum].type), vars[varnum].lname); switch (vars[varnum].type) { case NC_CHAR: val_string = cstrstr((char *) rec_start, var_len); val_string[strlen(val_string)-1] = '\0'; sprintf(s2, "'%s'", &val_string[1]); free(val_string); break; case NC_BYTE: charvalp = (char *) rec_start; sprintf(s2, "%d", *charvalp); break; case NC_SHORT: shortvalp = (short *) rec_start; sprintf(s2, "%d", *shortvalp); break; case NC_INT: intvalp = (int *) rec_start; sprintf(s2, "%ld", (long)*intvalp); break; case NC_FLOAT: floatvalp = (float *) rec_start; sprintf(s2, "%.8g", *floatvalp); break; case NC_DOUBLE: doublevalp = (double *) rec_start; sprintf(s2, "%#.16g", *doublevalp++); tztrim(s2); break; case NC_UBYTE: ubytevalp = (unsigned char *) rec_start; sprintf(s2, "%hhu", (unsigned char)*ubytevalp); break; case NC_USHORT: ushortvalp = (unsigned short *) rec_start; sprintf(s2, "%hu", (unsigned short)*ushortvalp); break; case NC_UINT: uintvalp = (unsigned int *) rec_start; sprintf(s2, "%u", (unsigned int)*uintvalp); break; case NC_INT64: int64valp = (long long *) rec_start; sprintf(s2, "%lld", (long long)*int64valp); break; case NC_UINT64: uint64valp = (unsigned long long *) rec_start; sprintf(s2, "%llu", (unsigned long long)*uint64valp); break; default: derror("Unhandled type %d\n", vars[varnum].type); break; } strncat(stmnt, s2, C_MAX_STMNT - strlen(stmnt) ); strcat(stmnt,";"); cline(stmnt); cline(" ncmpi_begin_indep_data(ncid);"); sprintf(stmnt, " stat = ncmpi_put_var_%s(ncid, %s_id, &%s);", ncstype(vars[varnum].type), vars[varnum].lname, vars[varnum].lname); cline(stmnt); cline(" ncmpi_end_indep_data(ncid);"); } cline(" check_err(stat,__LINE__,__FILE__);"); cline(" }"); }
array_t * parse (lexer_t *lex) { unsigned i; array_t stack; array_init(&stack, sizeof(parser_stack_t)); parser_stack_t initial; bzero(&initial, sizeof(initial)); array_add(&stack, &initial); array_t *result = 0; while (stack.size > 0) { parser_stack_t *current = array_get(&stack, stack.size-1); const parser_state_t *state = parser_states + current->state; for (i = 0; i < state->num_actions; ++i) if (state->actions[i].token == lex->token) break; if (i >= state->num_actions) { char *msg = strdup("syntax error, expected"); for (i = 0; i < state->num_actions; ++i) { char *glue; if (i == 0) glue = " "; else if (i == state->num_actions-1) glue = ", or "; else glue = ", "; char *nmsg; asprintf(&nmsg, "%s%s\"%s\"", msg, glue, token_names[state->actions[i].token]); free(msg); msg = nmsg; } derror(&lex->loc, "%s\n", msg); free(msg); } const parser_action_t *action = &state->actions[i]; if (action->state_or_length < 0) { if (action->rule == 0) { result = current->token.ptr; break; } unsigned num_tokens = -action->state_or_length; parser_stack_t *target = array_get(&stack, stack.size-num_tokens); parser_stack_t *base = array_get(&stack, stack.size-num_tokens-1); const parser_state_t *base_state = parser_states + base->state; token_t reduced = target->token; reduced.id = action->rule; reduced.last = current->token.last; if (action->reducer) { token_t tokens[num_tokens]; for (i = 0; i < num_tokens; ++i) tokens[i] = (target+i)->token; action->reducer(&reduced, tokens, action->reducer_tag); } target->token = reduced; for (i = 0; i < base_state->num_gotos; ++i) { if (base_state->gotos[i].rule == action->rule) { target->state = base_state->gotos[i].state; break; } } array_resize(&stack, stack.size-num_tokens+1); } else { parser_stack_t *new_stack = array_add(&stack, 0); bzero(new_stack, sizeof(*new_stack)); new_stack->state = action->state_or_length; new_stack->token.id = lex->token; new_stack->token.first = lex->base; new_stack->token.last = lex->ptr; new_stack->token.loc = lex->loc; lexer_next(lex); } } array_dispose(&stack); return result; }
void replica::on_append_log_completed(mutation_ptr& mu, error_code err, size_t size) { check_hashed_access(); dinfo("%s: append shared log completed for mutation %s, size = %u, err = %s", name(), mu->name(), size, err.to_string()); if (err == ERR_OK) { mu->set_logged(); } else { derror("%s: append shared log failed for mutation %s, err = %s", name(), mu->name(), err.to_string()); } // skip old mutations if (mu->data.header.ballot >= get_ballot() && status() != partition_status::PS_INACTIVE) { switch (status()) { case partition_status::PS_PRIMARY: if (err == ERR_OK) { do_possible_commit_on_primary(mu); } else { handle_local_failure(err); } break; case partition_status::PS_SECONDARY: case partition_status::PS_POTENTIAL_SECONDARY: if (err != ERR_OK) { handle_local_failure(err); } // always ack ack_prepare_message(err, mu); break; case partition_status::PS_ERROR: break; default: dassert(false, ""); break; } } if (err != ERR_OK) { // mutation log failure, propagate to all replicas _stub->handle_log_failure(err); } // write local private log if necessary if (err == ERR_OK && _private_log && status() != partition_status::PS_ERROR) { _private_log->append(mu, LPC_WRITE_REPLICATION_LOG, nullptr, nullptr, gpid_to_hash(get_gpid()) ); } }
error_code hpc_aio_provider::aio_internal(aio_task* aio_tsk, bool async, /*out*/ uint32_t* pbytes /*= nullptr*/) { auto aio = (windows_disk_aio_context*)aio_tsk->aio(); BOOL r = FALSE; aio->olp.Offset = (uint32_t)aio->file_offset; aio->olp.OffsetHigh = (uint32_t)(aio->file_offset >> 32); if (!async) { aio->evt = new utils::notify_event(); aio->err = ERR_OK; aio->bytes = 0; } switch (aio->type) { case AIO_Read: r = ::ReadFile((HANDLE)aio->file, aio->buffer, aio->buffer_size, NULL, &aio->olp); break; case AIO_Write: r = ::WriteFile((HANDLE)aio->file, aio->buffer, aio->buffer_size, NULL, &aio->olp); break; default: dassert (false, "unknown aio type %u", static_cast<int>(aio->type)); break; } if (!r) { int native_error = ::GetLastError(); if (native_error != ERROR_IO_PENDING) { derror("file operation failed, err = %u", native_error); error_code err = native_error == ERROR_SUCCESS ? ERR_OK : (native_error == ERROR_HANDLE_EOF ? ERR_HANDLE_EOF : ERR_FILE_OPERATION_FAILED); if (async) { complete_io(aio_tsk, err, 0); } else { delete aio->evt; aio->evt = nullptr; } return err; } } if (async) { return ERR_IO_PENDING; } else { aio->evt->wait(); delete aio->evt; aio->evt = nullptr; if (pbytes != nullptr) { *pbytes = aio->bytes; } return aio->err; } }
void call(int i) /* CALL, INVOKE for i = 0, 1 */ { int gkk, li, sym ; double val ; ptr p, q, s ; dsptr r ; if (!runf) derror(22) ; p=getvar() ; if (errnum) derror(errnum) ; if (p==NULL) derror (201) ; /* undefined */ /* defined, get parameters */ sym=p->symtype ; /* save type */ if (i==0 && sym<8 || i>0 && sym!= -59) derror(201) ; p->SWITCH=FALSE ; /* prevent recursion */ q=p ; /* save pointer to procedure or macro definition */ if (warea[++gi]==')') { /* done or ... */ if (p->next==NULL) goto L10 ; derror(56) ; } /* ... mismatch */ if (p->next==NULL) derror(56) ; /* mismatch */ p=p->next ; /* else link to first argument */ if (i>0) goto L85 ; /* invoke */ if (warea[gi]==';') { if (sym==8) goto L80 ; derror(56) ; } /* call */ if (sym==8) derror(56) ; /* mismatch */ li=0 ; /* call, count value parameters */ L9 : li++ ; p->SWITCH=TRUE ; /* turn local variable ON */ if (p->symtype==1) relval[p->valptr]=evalexp() ; /* REAL */ else if (p->symtype==3) /* COMPLEX */ cvalexp(relval[p->valptr],relval[p->valptr+1]) ; else { val=evalexp() ;if (errnum) derror(errnum) ; /* INTEGER */ if (val>maxint || -val>maxint) derror(20) ; intval[p->valptr]=(int) val ; } if (errnum) derror(errnum) ; if (warea[gi]==')') { if (p->next==NULL) goto L10 ; derror(56) ; } /* done */ if (p->next==NULL) derror(56) ; /* mismatch */ p=p->next ; /* else link to next argument */ if (warea[gi]==';') { /* no more value parameters */ if (sym==8+li) goto L80 ; derror(56) ; } if (warea[gi]==',') { gi++ ; goto L9 ; } derror(56) ; /* next */ L80 : gi++ ; /* skip ';' or ',', deal with VAR parameters */ L85 : p->SWITCH=TRUE; /* turn local variable ON */ gkk=gi ; s=getvar() ; /* might be an array! */ if (errnum) { if (errnum==73) { errnum=0 ; gi=gkk ; start=1 ; s=getvar() ; start=0 ; if (errnum) derror(errnum) ; if (s==NULL || s->symtype!= -1) derror(196) ; p->valptr=s->valptr ; /* pass array address */ goto L87 ; } derror(errnum) ; } /*$$*/ if (s==NULL) s=instal() ; /* no array, install REAL */ if (s->symtype== -1 && p->symtype==1) goto L90 ; if (s->symtype!=p->symtype && s->symtype!= -p->symtype) derror(56) ; /* no match */ L90 : if (s->symtype>0) p->valptr=s->valptr ; /* pass by reference */ else { if (s->symtype== -1) /* relval index */ p->valptr=intval[intval[s->valptr]+s->valptr+1]+getsub(s) ; else if (s->symtype== -2) /* intval index */ p->valptr=intval[s->valptr]+s->valptr+1+getsub(s) ; else p->valptr=intval[intval[s->valptr]+s->valptr+1]+2*getsub(s) ; } L87 : if (warea[gi]==')') { if (p->next==NULL) goto L10 ; derror(56) ; } if (p->next==NULL) derror(56) ; p=p->next ; if (warea[gi]==',') goto L80 ; /* next VAR parameter */ derror(33) ; /* bad termination */ L10 : gi++ ; /* skip ) */ /* control stack for return */ r= (struct dstak*) malloc(sizeof(struct dstak)) ; r->head='C' ; r->cvar=q ; r->radd=gi ; /* on lf or | */ r->dslink=stktop ; stktop=r ; flag1=TRUE ; /* prevents nested definitions */ gi=q->valptr ; /* go to subroutine */ if (tracer>0) { if (tracer==2 || tracer==3 || tracer>=6) { printf("%c%s",'\33',"[7m") ; /* ANSI reverse video */ printf("%s%s%c","G: EXECUTING PROCEDURE ",q->name,'\n') ; printf("%c%s",'\33',"[0m") ; /* ANSI restore video */ } } } /* call */
int android_parse_options( int *pargc, char** *pargv, AndroidOptions* opt ) { int nargs = *pargc-1; char** aread = *pargv+1; char** awrite = aread; memset( opt, 0, sizeof *opt ); while (nargs > 0) { char* arg; char arg2_tab[64], *arg2 = arg2_tab; int nn; /* process @<name> as a special exception meaning * '-avd <name>' */ if (aread[0][0] == '@') { opt->avd = aread[0]+1; nargs--; aread++; continue; } /* anything that isn't an option past this points * exits the loop */ if (aread[0][0] != '-') { break; } arg = aread[0]+1; /* an option cannot contain an underscore */ if (strchr(arg, '_') != NULL) { break; } nargs--; aread++; /* for backwards compatibility with previous versions */ if (!strcmp(arg, "verbose")) { arg = "debug-init"; } /* special handing for -debug <tags> */ if (!strcmp(arg, "debug")) { if (nargs == 0) { derror( "-debug must be followed by tags (see -help-verbose)\n"); exit(1); } nargs--; parse_debug_tags(*aread++); continue; } /* NOTE: variable tables map option names to values * (e.g. field offsets into the AndroidOptions structure). * * however, the names stored in the table used underscores * instead of dashes. this means that the command-line option * '-foo-bar' will be associated to the name 'foo_bar' in * this table, and will point to the field 'foo_bar' or * AndroidOptions. * * as such, before comparing the current option to the * content of the table, we're going to translate dashes * into underscores. */ arg2 = arg2_tab; buffer_translate_char( arg2_tab, sizeof(arg2_tab), arg, '-', '_'); /* special handling for -debug-<tag> and -debug-no-<tag> */ if (!memcmp(arg2, "debug_", 6)) { int remove = 0; unsigned long mask = 0; arg2 += 6; if (!memcmp(arg2, "no_", 3)) { arg2 += 3; remove = 1; } if (!strcmp(arg2, "all")) { mask = ~0; } for (nn = 0; debug_tags[nn].name; nn++) { if (!strcmp(arg2, debug_tags[nn].name)) { mask = (1UL << debug_tags[nn].flag); break; } } if (remove) android_verbose &= ~mask; else android_verbose |= mask; continue; } /* look into our table of options * */ { const OptionInfo* oo = option_keys; for ( ; oo->name; oo++ ) { if ( !strcmp( oo->name, arg2 ) ) { void* field = (char*)opt + oo->var_offset; if (oo->var_is_param) { /* parameter option */ if (nargs == 0) { derror( "-%s must be followed by parameter (see -help-%s)", arg, arg ); exit(1); } nargs--; ((char**)field)[0] = *aread++; } else { /* flag option */ ((int*)field)[0] = 1; } break; } } if (oo->name == NULL) { /* unknown option ? */ nargs++; aread--; break; } } } /* copy remaining parameters, if any, to command line */ *pargc = nargs + 1; while (nargs > 0) { awrite[0] = aread[0]; awrite ++; aread ++; nargs --; } awrite[0] = NULL; return 0; }
static void cl_netcdf() { if (ncclose(ncid) == -1) derror ("error closing netcdf"); }
// if network_interface is "", then return the first "eth" prefixed non-loopback ipv4 address. DSN_API uint32_t dsn_ipv4_local(const char* network_interface) { uint32_t ret = 0; # ifndef _WIN32 static const char loopback[4] = { 127, 0, 0, 1 }; struct ifaddrs* ifa = nullptr; if (getifaddrs(&ifa) == 0) { struct ifaddrs* i = ifa; while (i != nullptr) { if (i->ifa_name != nullptr && i->ifa_addr != nullptr ) { if (strcmp(i->ifa_name, network_interface) == 0 || (network_interface[0] == '\0' && strncmp(i->ifa_name, "eth", 3) == 0) ) { if (i->ifa_addr->sa_family == AF_INET && (network_interface[0] != '\0' || strncmp((const char*)&((struct sockaddr_in *)i->ifa_addr)->sin_addr.s_addr, loopback, 4) != 0)) { ret = (uint32_t)ntohl(((struct sockaddr_in *)i->ifa_addr)->sin_addr.s_addr); break; } // sometimes the sa_family is not AF_INET but we can still try else { int fd = socket(AF_INET, SOCK_DGRAM, 0); struct ifreq ifr; ifr.ifr_addr.sa_family = AF_INET; strncpy(ifr.ifr_name, i->ifa_name, IFNAMSIZ - 1); auto err = ioctl(fd, SIOCGIFADDR, &ifr); if (err == 0 && (network_interface[0] != '\0' || strncmp((const char*)&((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr, loopback, 4) != 0)) { ret = (uint32_t)ntohl(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr); break; } } } } i = i->ifa_next; } if (i == nullptr) { derror("get local ip from network interfaces failed, network_interface = %s", network_interface); } if (ifa != nullptr) { // remember to free it freeifaddrs(ifa); } } #endif return ret; }
// run in replica thread void replica::init_checkpoint() { // only applicable to primary and secondary replicas if (status() != PS_PRIMARY && status() != PS_SECONDARY) return; // no need to checkpoint if (_app->is_delta_state_learning_supported()) return; auto err = _app->checkpoint_async(); if (err != ERR_NOT_IMPLEMENTED) { if (err == ERR_OK) { ddebug("%s: checkpoint_async succeed, app_last_committed_decree=%" PRId64 ", app_last_durable_decree=%" PRId64, name(), _app->last_committed_decree(), _app->last_durable_decree()); } if (err != ERR_OK && err != ERR_WRONG_TIMING && err != ERR_NO_NEED_OPERATE && err != ERR_TRY_AGAIN) { derror("%s: checkpoint_async failed, err = %s", name(), err.to_string()); } return; } // private log must be enabled to make sure commits // are not lost during checkpinting dassert(nullptr != _private_log, "log_enable_private_prepare must be true for checkpointing"); if (last_committed_decree() - last_durable_decree() < _options->checkpoint_min_decree_gap) return; // primary cannot checkpoint (TODO: test if async checkpoint is supported) // therefore we have to copy checkpoints from secondaries if (PS_PRIMARY == status()) { // only one running instance if (nullptr == _primary_states.checkpoint_task) { if (_primary_states.membership.secondaries.size() == 0) return; std::shared_ptr<replica_configuration> rc(new replica_configuration); _primary_states.get_replica_config(PS_SECONDARY, *rc); rpc_address sd = _primary_states.membership.secondaries [dsn_random32(0, (int)_primary_states.membership.secondaries.size() - 1)]; _primary_states.checkpoint_task = rpc::call_typed( sd, RPC_REPLICA_COPY_LAST_CHECKPOINT, rc, this, &replica::on_copy_checkpoint_ack, gpid_to_hash(get_gpid()) ); } } // secondary can start checkpint in the long running thread pool else { dassert(PS_SECONDARY == status(), ""); // only one running instance if (!_secondary_states.checkpoint_is_running) { _secondary_states.checkpoint_is_running = true; tasking::enqueue( &_secondary_states.checkpoint_task, LPC_CHECKPOINT_REPLICA, this, &replica::background_checkpoint, gpid_to_hash(get_gpid()) ); } } }
void nfs_service_impl::on_copy(const ::dsn::service::copy_request& request, ::dsn::rpc_replier< ::dsn::service::copy_response>& reply) { //dinfo(">>> on call RPC_COPY end, exec RPC_NFS_COPY"); std::string file_path = dsn::utils::filesystem::path_combine(request.source_dir, request.file_name); dsn_handle_t hfile; { zauto_lock l(_handles_map_lock); auto it = _handles_map.find(file_path); // find file handle cache first if (it == _handles_map.end()) // not found { hfile = dsn_file_open(file_path.c_str(), O_RDONLY | O_BINARY, 0); if (hfile) { file_handle_info_on_server* fh = new file_handle_info_on_server; fh->file_handle = hfile; fh->file_access_count = 1; fh->last_access_time = dsn_now_ms(); _handles_map.insert(std::pair<std::string, file_handle_info_on_server*>(file_path, fh)); } } else // found { hfile = it->second->file_handle; it->second->file_access_count++; it->second->last_access_time = dsn_now_ms(); } } dinfo("nfs: copy file %s [%" PRId64 ", %" PRId64 ")", file_path.c_str(), request.offset, request.offset + request.size ); if (hfile == 0) { derror("file open failed"); ::dsn::service::copy_response resp; resp.error = ERR_OBJECT_NOT_FOUND; reply(resp); return; } callback_para cp(reply); cp.bb = blob( std::shared_ptr<char>(new char[_opts.nfs_copy_block_bytes], std::default_delete<char[]>{}), _opts.nfs_copy_block_bytes); cp.dst_dir = std::move(request.dst_dir); cp.file_path = std::move(file_path); cp.hfile = hfile; cp.offset = request.offset; cp.size = request.size; auto buffer_save = cp.bb.buffer().get(); file::read( hfile, buffer_save, request.size, request.offset, LPC_NFS_READ, this, [this, cp_cap = std::move(cp)] (error_code err, int sz) { internal_read_callback(err, sz, std::move(cp_cap)); } ); }
// RPC_NFS_NEW_NFS_GET_FILE_SIZE void nfs_service_impl::on_get_file_size(const ::dsn::service::get_file_size_request& request, ::dsn::rpc_replier< ::dsn::service::get_file_size_response>& reply) { //dinfo(">>> on call RPC_NFS_GET_FILE_SIZE end, exec RPC_NFS_GET_FILE_SIZE"); get_file_size_response resp; error_code err = ERR_OK; std::vector<std::string> file_list; std::string folder = request.source_dir; if (request.file_list.size() == 0) // return all file size in the destination file folder { if (!dsn::utils::filesystem::directory_exists(folder)) { err = ERR_OBJECT_NOT_FOUND; } else { if (!dsn::utils::filesystem::get_subfiles(folder, file_list, true)) { err = ERR_FILE_OPERATION_FAILED; } else { for (auto& fpath : file_list) { // TODO: using uint64 instead as file ma // Done int64_t sz; if (!dsn::utils::filesystem::file_size(fpath, sz)) { dassert(false, "Fail to get file size of %s.", fpath.c_str()); } resp.size_list.push_back((uint64_t)sz); resp.file_list.push_back(fpath.substr(request.source_dir.length(), fpath.length() - 1)); } file_list.clear(); } } } else // return file size in the request file folder { for (size_t i = 0; i < request.file_list.size(); i++) { std::string file_path = dsn::utils::filesystem::path_combine(folder, request.file_list[i]); struct stat st; if (0 != ::stat(file_path.c_str(), &st)) { derror("file open %s failed, err = %s", file_path.c_str(), strerror(errno)); err = ERR_OBJECT_NOT_FOUND; break; } // TODO: using int64 instead as file may exceed the size of 32bit // Done uint64_t size = st.st_size; resp.size_list.push_back(size); resp.file_list.push_back((folder + request.file_list[i]).substr(request.source_dir.length(), (folder + request.file_list[i]).length() - 1)); } } resp.error = err.get(); reply(resp); }
/* * Generate code for creating netCDF from in-memory structure. */ void gen_ncjava_std(const char *filename) { int idim, ivar, iatt, maxdims; int ndims, nvars, natts, ngatts, ngrps, ntyps; char* cmode_string; jcode = bbNew(); bbSetalloc(jcode,C_MAX_STMT); ndims = listlength(dimdefs); nvars = listlength(vardefs); natts = listlength(attdefs); ngatts = listlength(gattdefs); ngrps = listlength(grpdefs); ntyps = listlength(typdefs); /* Construct the main class */ jline("import java.util.*;"); jline("import ucar.ma2.*;"); jline("import ucar.nc2.*;"); jline("import ucar.nc2.NetcdfFile.*;"); jline(""); jpartial("public class "); jline(mainname); jline("{"); /* Now construct the main procedure*/ jline(""); jline("static public void main(String[] argv) throws Exception"); jline("{"); /* create necessary declarations */ if (ndims > 0) { jline(""); jlined(1,"/* dimension lengths */"); for(idim = 0; idim < ndims; idim++) { Symbol* dsym = (Symbol*)listget(dimdefs,idim); if (dsym->dim.size == NC_UNLIMITED) { nprintf(stmt,sizeof(stmt),"%sfinal int %s_len = 0;", indented(1),jname(dsym)); } else { nprintf(stmt,sizeof(stmt),"%sfinal int %s_len = %lu;", indented(1), jname(dsym), (unsigned long) dsym->dim.size); } jline(stmt); } } jflush(); maxdims = 0; /* most dimensions of any variable */ for(ivar = 0; ivar < nvars; ivar++) { Symbol* vsym = (Symbol*)listget(vardefs,ivar); if(vsym->typ.dimset.ndims > maxdims) maxdims = vsym->typ.dimset.ndims; } jline(""); #ifdef DOTHROW jlined(1,"try {"); #endif /* create netCDF file, uses NC_CLOBBER mode */ jline(""); jlined(1,"/* enter define mode */"); if (!cmode_modifier) { cmode_string = "NC_CLOBBER"; } else if (cmode_modifier & NC_64BIT_OFFSET) { cmode_string = "NC_CLOBBER|NC_64BIT_OFFSET"; } else { derror("unknown cmode modifier"); cmode_string = "NC_CLOBBER"; } nprintf(stmt,sizeof(stmt), "NetcdfFileWriteable ncfile = NetcdfFileWriteable.createNew(\"%s\", %s);", filename,(nofill_flag?"false":"true")); jlined(1,stmt); jflush(); /* define dimensions from info in dims array */ if (ndims > 0) { jline(""); jlined(1,"/* define dimensions */"); for(idim = 0; idim < ndims; idim++) { Symbol* dsym = (Symbol*)listget(dimdefs,idim); if(dsym->dim.size == NC_UNLIMITED) { nprintf(stmt,sizeof(stmt),"Dimension %s_dim = ncfile.addUnlimitedDimension(\"%s\");", jname(dsym),jescapifyname(dsym->name)); } else { nprintf(stmt,sizeof(stmt),"Dimension %s_dim = ncfile.addDimension(\"%s\", %s_len);", jname(dsym),jescapifyname(dsym->name), jname(dsym)); } jlined(1,stmt); } jflush(); } /* define variables from info in vars array */ if (nvars > 0) { jline(""); jlined(1,"/* define variables */"); for(ivar = 0; ivar < nvars; ivar++) { Symbol* vsym = (Symbol*)listget(vardefs,ivar); Symbol* basetype = vsym->typ.basetype; Dimset* dimset = &vsym->typ.dimset; jline(""); nprintf(stmt,sizeof(stmt),"ArrayList %s_dimlist = new ArrayList();", jname(vsym)); jlined(1,stmt); if(dimset->ndims > 0) { for(idim = 0; idim < dimset->ndims; idim++) { Symbol* dsym = dimset->dimsyms[idim]; nprintf(stmt,sizeof(stmt),"%s_dimlist.add(%s_dim);", jname(vsym),jname(dsym)); jlined(1,stmt); } } nprintf(stmt,sizeof(stmt), "ncfile.addVariable(\"%s\", DataType.%s, %s_dimlist);", jescapifyname(vsym->name), jtypeallcaps(basetype->typ.typecode), jname(vsym)); jlined(1,stmt); } jflush(); } /* Define the global attributes*/ if(ngatts > 0) { jline(""); jlined(1,"/* assign global attributes */"); for(iatt = 0; iatt < ngatts; iatt++) { Symbol* gasym = (Symbol*)listget(gattdefs,iatt); genjstd_defineattribute(gasym); } jline(""); jflush(); } /* Define the variable specific attributes*/ if(natts > 0) { jline(""); jlined(1,"/* assign per-variable attributes */"); for(iatt = 0; iatt < natts; iatt++) { Symbol* asym = (Symbol*)listget(attdefs,iatt); genjstd_defineattribute(asym); } jline(""); jflush(); } jlined(1,"ncfile.create();"); /* equiv to nc_enddef */ /* Load values into those variables with defined data */ if(nvars > 0) { jline(""); jlined(1,"/* assign variable data */"); for(ivar = 0; ivar < nvars; ivar++) { Symbol* vsym = (Symbol*)listget(vardefs,ivar); if(vsym->data != NULL) genjstd_definevardata(vsym); } jline(""); /* compute the max actual size of the unlimited dimension*/ if(usingclassic) computemaxunlimited(); } jflush(); }
int main( int argc, char *argv[]) { int c; FILE *fp; struct Languages* langs; char* lang_name; #ifdef __hpux setlocale(LC_CTYPE,""); #endif init_netcdf(); opterr = 1; /* print error message if bad option */ progname = ubasename(argv[0]); cdlname = "-"; netcdf_name = NULL; datasetname = NULL; l_flag = 0; nofill_flag = 0; syntax_only = 0; header_only = 0; mainname = "main"; nciterbuffersize = 0; k_flag = 0; format_flag = 0; format_attribute = 0; enhanced_flag = 0; specials_flag = 0; diskless = 0; #if _CRAYMPP && 0 /* initialize CRAY MPP parallel-I/O library */ (void) par_io_init(32, 32); #endif while ((c = getopt(argc, argv, "hbcfk:3467l:no:v:xdM:D:B:P")) != EOF) switch(c) { case 'd': debug = 1; break; case 'D': debug = atoi(optarg); break; case 'c': /* for c output, old version of "-lc" */ if(l_flag != 0) { fprintf(stderr,"Please specify only one language\n"); return 1; } l_flag = L_C; fprintf(stderr,"-c is deprecated: please use -lc\n"); break; case 'f': /* for f77 output, old version of "-lf" */ if(l_flag != 0) { fprintf(stderr,"Please specify only one language\n"); return 1; } l_flag = L_F77; fprintf(stderr,"-f is deprecated: please use -lf77\n"); break; case 'b': /* for binary netcdf output, ".nc" extension */ if(l_flag != 0) { fprintf(stderr,"Please specify only one language\n"); return 1; } l_flag = L_BINARY; break; case 'h': header_only = 1; break; case 'l': /* specify language, instead of using -c or -f or -b */ { if(l_flag != 0) { fprintf(stderr,"Please specify only one language\n"); return 1; } if(!optarg) { derror("%s: output language is null", progname); return(1); } lang_name = (char*) emalloc(strlen(optarg)+1); (void)strcpy(lang_name, optarg); for(langs=legallanguages;langs->name != NULL;langs++) { if(strcmp(lang_name,langs->name)==0) { l_flag = langs->flag; break; } } if(langs->name == NULL) { derror("%s: output language %s not implemented", progname, lang_name); return(1); } } break; case 'n': /* old version of -b, uses ".cdf" extension */ if(l_flag != 0) { fprintf(stderr,"Please specify only one language\n"); return 1; } l_flag = L_BINARY; binary_ext = ".cdf"; break; case 'o': /* to explicitly specify output name */ netcdf_name = nulldup(optarg); break; case 'x': /* set nofill mode to speed up creation of large files */ nofill_flag = 1; break; case 'v': /* a deprecated alias for "kind" option */ /*FALLTHRU*/ case 'k': /* for specifying variant of netCDF format to be generated Possible values are: Format names: "classic" or "nc3" "64-bit offset" or "nc6" "netCDF-4" or "nc4" "netCDF-4 classic model" or "nc7" Format version numbers (deprecated): 1 (=> classic) 2 (=> 64-bit offset) 3 (=> netCDF-4) 4 (=> netCDF-4 classic model) */ { struct Kvalues* kvalue; char *kind_name = (optarg != NULL ? (char *) emalloc(strlen(optarg)+1) : emalloc(1)); if (! kind_name) { derror ("%s: out of memory", progname); return(1); } if(optarg != NULL) (void)strcpy(kind_name, optarg); for(kvalue=legalkinds;kvalue->name;kvalue++) { if(strcmp(kind_name,kvalue->name) == 0) { k_flag = kvalue->k_flag; break; } } if(kvalue->name == NULL) { derror("Invalid format: %s",kind_name); return 2; } } break; case '3': /* output format is classic (netCDF-3) */ k_flag = NC_FORMAT_CLASSIC; break; case '6': /* output format is 64-bit-offset (netCDF-3 version 2) */ k_flag = NC_FORMAT_64BIT; break; case '4': /* output format is netCDF-4 (variant of HDF5) */ k_flag = NC_FORMAT_NETCDF4; break; case '7': /* output format is netCDF-4 (restricted to classic model)*/ k_flag = NC_FORMAT_NETCDF4_CLASSIC; break; case 'M': /* Determine the name for the main function */ mainname = nulldup(optarg); break; case 'B': nciterbuffersize = atoi(optarg); break; case 'P': /* diskless with persistence */ diskless = 1; break; case '?': usage(); return(8); } if(l_flag == 0) { l_flag = L_BINARY; /* default */ /* Treat -k or -o as an implicit -lb assuming no other -l flags */ if(k_flag == 0 && netcdf_name == NULL) syntax_only = 1; } /* Compute/default the iterator buffer size */ if(l_flag == L_BINARY) { if(nciterbuffersize == 0 ) nciterbuffersize = DFALTBINNCITERBUFFERSIZE; } else { if(nciterbuffersize == 0) nciterbuffersize = DFALTLANGNCITERBUFFERSIZE; } #ifndef ENABLE_C if(c_flag) { fprintf(stderr,"C not currently supported\n"); exit(1); } #endif #ifndef ENABLE_BINARY if(l_flag == L_BINARY) { fprintf(stderr,"Binary netcdf not currently supported\n"); exit(1); } #endif #ifndef ENABLE_JAVA if(l_flag == L_JAVA) { fprintf(stderr,"Java not currently supported\n"); exit(1); } #else if(l_flag == L_JAVA && strcmp(mainname,"main")==0) mainname = "Main"; #endif #ifndef ENABLE_F77 if(l_flag == L_F77) { fprintf(stderr,"F77 not currently supported\n"); exit(1); } #endif if(l_flag != L_BINARY) diskless = 0; argc -= optind; argv += optind; if (argc > 1) { derror ("%s: only one input file argument permitted",progname); return(6); } fp = stdin; if (argc > 0 && strcmp(argv[0], "-") != 0) { char bom[4]; size_t count; if ((fp = fopen(argv[0], "r")) == NULL) { derror ("can't open file %s for reading: ", argv[0]); perror(""); return(7); } /* Check the leading bytes for an occurrence of a BOM */ /* re: http://www.unicode.org/faq/utf_bom.html#BOM */ /* Attempt to read the first four bytes */ memset(bom,0,sizeof(bom)); count = fread(bom,1,2,fp); if(count == 2) { switch (bom[0]) { case '\x00': case '\xFF': case '\xFE': /* Only UTF-* is allowed; complain and exit */ fprintf(stderr,"Input file contains a BOM indicating a non-UTF8 encoding\n"); return 1; case '\xEF': /* skip the BOM */ fread(bom,1,1,fp); break; default: /* legal printable char, presumably; rewind */ rewind(fp); break; } } cdlname = (char*)emalloc(NC_MAX_NAME); cdlname = nulldup(argv[0]); if(cdlname != NULL) { if(strlen(cdlname) > NC_MAX_NAME) cdlname[NC_MAX_NAME] = '\0'; } } /* Standard Unidata java interface => usingclassic */ parse_init(); ncgin = fp; if(debug >= 2) {ncgdebug=1;} if(ncgparse() != 0) return 1; /* Compute the k_flag (1st pass) using rules in the man page (ncgen.1).*/ #ifndef USE_NETCDF4 if(enhanced_flag) { derror("CDL input is enhanced mode, but --disable-netcdf4 was specified during build"); return 0; } #endif if(l_flag == L_JAVA || l_flag == L_F77) { k_flag = 1; if(enhanced_flag) { derror("Java or Fortran requires classic model CDL input"); return 0; } } if(k_flag == 0) k_flag = format_flag; if(enhanced_flag && k_flag == 0) k_flag = 3; if(enhanced_flag && k_flag != 3) { derror("-k or _Format conflicts with enhanced CDL input"); return 0; } if(specials_flag > 0 && k_flag == 0) #ifdef USE_NETCDF4 k_flag = 3; #else k_flag = 1; #endif if(k_flag == 0) k_flag = 1; usingclassic = (k_flag <= 2 || k_flag == 4)?1:0; /* compute cmode_modifier */ switch (k_flag) { case 1: cmode_modifier = 0; break; case 2: cmode_modifier = NC_64BIT_OFFSET; break; case 3: cmode_modifier = NC_NETCDF4; break; case 4: cmode_modifier = NC_NETCDF4 | NC_CLASSIC_MODEL; break; default: ASSERT(0); /* cannot happen */ } if(diskless) cmode_modifier |= (NC_DISKLESS|NC_NOCLOBBER); processsemantics(); if(!syntax_only && error_count == 0) define_netcdf(); return 0; }
void simulator::on_system_exit(sys_exit_type st) { derror("system exits, you can replay this process using random seed %d", sim_env_provider::seed() ); }
/* * handles the "directive" state after the "normal" state */ static int direci(lex_t *t) { int i = NELEM(dtab); assert(!cond_ignore()); NEXTSP(t); /* consumes # */ if (t->id == LEX_ID) { const char *n = LEX_SPELL(t); for (i = 0; i < NELEM(dtab); i++) if (strcmp(n, dtab[i].name) == 0) break; switch(i) { case DINCLUDE: t = dinclude(t->pos); break; case DDEFINE: /* ddefine() moved into mcr.c for macros from -D */ t = mcr_define(t->pos, 0); break; case DUNDEF: t = dundef(t->pos); break; case DIF: t = dif(t->pos, COND_KIF, 0); break; case DIFDEF: t = dif(t->pos, COND_KIFDEF, 0); break; case DIFNDEF: t = dif(t->pos, COND_KIFNDEF, 0); break; case DELIF: t = delif(t->pos); break; case DELSE: t = delse(t->pos); break; case DENDIF: t = dendif(t->pos); break; case DLINE: t = dline(t->pos); break; case DERROR: t = derror(t->pos, 0); break; case DPRAGMA: t = dpragma(t->pos); break; case DWARNING: t = derror(t->pos, 1); break; default: err_dpos(t->pos, ERR_PP_UNKNOWNDIR); break; } } else i = DUNDEF; if (warnxtra[i]) { SKIPSP(t); if (t->id != LEX_NEWLINE) t = xtratok(t); } SKIPNL(t); lst_discard(1); lex_direc = 0; return 0; }
ClientFramebuffer* clientfb_create(SockAddress* console_socket, const char* protocol, QFrameBuffer* fb) { char* connect_message = NULL; char switch_cmd[256]; // Connect to the framebuffer service. _client_fb.core_connection = core_connection_create(console_socket); if (_client_fb.core_connection == NULL) { derror("Framebuffer client is unable to connect to the console: %s\n", errno_str); return NULL; } if (core_connection_open(_client_fb.core_connection)) { core_connection_free(_client_fb.core_connection); _client_fb.core_connection = NULL; derror("Framebuffer client is unable to open the console: %s\n", errno_str); return NULL; } snprintf(switch_cmd, sizeof(switch_cmd), "framebuffer %s", protocol); if (core_connection_switch_stream(_client_fb.core_connection, switch_cmd, &connect_message)) { derror("Unable to attach to the framebuffer %s: %s\n", switch_cmd, connect_message ? connect_message : ""); if (connect_message != NULL) { free(connect_message); } core_connection_close(_client_fb.core_connection); core_connection_free(_client_fb.core_connection); _client_fb.core_connection = NULL; return NULL; } // We expect core framebuffer to return us bits per pixel property in // the handshake message. _client_fb.bits_per_pixel = 0; if (connect_message != NULL) { char* bpp = strstr(connect_message, "bitsperpixel="); if (bpp != NULL) { char* end; bpp += strlen("bitsperpixel="); end = strchr(bpp, ' '); if (end == NULL) { end = bpp + strlen(bpp); } _client_fb.bits_per_pixel = strtol(bpp, &end, 0); } } if (!_client_fb.bits_per_pixel) { derror("Unexpected core framebuffer reply: %s\n" "Bits per pixel property is not there, or is invalid\n", connect_message); core_connection_close(_client_fb.core_connection); core_connection_free(_client_fb.core_connection); _client_fb.core_connection = NULL; return NULL; } // Now that we're connected lets initialize the descriptor. _client_fb.fb = fb; _client_fb.sock = core_connection_get_socket(_client_fb.core_connection); _client_fb.fb_state = WAIT_HEADER; _client_fb.reader_buffer = (uint8_t*)&_client_fb.update_header; _client_fb.reader_offset = 0; _client_fb.reader_bytes = sizeof(FBUpdateMessage); if (connect_message != NULL) { free(connect_message); } // At last setup read callback, and start receiving the updates. if (qemu_set_fd_handler(_client_fb.sock, _clientfb_read_cb, NULL, &_client_fb)) { derror("Unable to set up framebuffer read callback\n"); core_connection_close(_client_fb.core_connection); core_connection_free(_client_fb.core_connection); _client_fb.core_connection = NULL; return NULL; } { // Force the core to send us entire framebuffer now, when we're prepared // to receive it. FBRequestHeader hd; SyncSocket* sk = syncsocket_init(_client_fb.sock); hd.request_type = AFB_REQUEST_REFRESH; syncsocket_start_write(sk); syncsocket_write(sk, &hd, sizeof(hd), 500); syncsocket_stop_write(sk); syncsocket_free(sk); } fprintf(stdout, "Framebuffer %s is now attached to the core %s\n", protocol, sock_address_to_string(console_socket)); return &_client_fb; }
dsn_handle_t hpc_aio_provider::open(const char* file_name, int oflag, int pmode) { DWORD dwDesiredAccess = 0; DWORD dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE; DWORD dwCreationDisposition = 0; DWORD dwFlagsAndAttributes = FILE_FLAG_OVERLAPPED; SECURITY_ATTRIBUTES SecurityAttributes; SecurityAttributes.nLength = sizeof(SecurityAttributes); SecurityAttributes.lpSecurityDescriptor = NULL; if (oflag & _O_NOINHERIT) { SecurityAttributes.bInheritHandle = FALSE; } else { SecurityAttributes.bInheritHandle = TRUE; } /* * decode the access flags */ switch (oflag & (_O_RDONLY | _O_WRONLY | _O_RDWR)) { case _O_RDONLY: /* read access */ dwDesiredAccess = GENERIC_READ; break; case _O_WRONLY: /* write access */ /* giving it read access as well * because in append (a, not a+), we need * to read the BOM to determine the encoding * (ie. ANSI, UTF8, UTF16) */ if ((oflag & _O_APPEND) && (oflag & (_O_WTEXT | _O_U16TEXT | _O_U8TEXT)) != 0) { dwDesiredAccess = GENERIC_READ | GENERIC_WRITE; } else { dwDesiredAccess = GENERIC_WRITE; } break; case _O_RDWR: /* read and write access */ dwDesiredAccess = GENERIC_READ | GENERIC_WRITE; break; default: /* error, bad oflag */ _doserrno = 0L; /* not an OS error */ derror("Invalid open flag\n"); } /* * decode open/create method flags */ switch (oflag & (_O_CREAT | _O_EXCL | _O_TRUNC)) { case 0: case _O_EXCL: // ignore EXCL w/o CREAT dwCreationDisposition = OPEN_EXISTING; break; case _O_CREAT: dwCreationDisposition = OPEN_ALWAYS; break; case _O_CREAT | _O_EXCL: case _O_CREAT | _O_TRUNC | _O_EXCL: dwCreationDisposition = CREATE_NEW; break; case _O_TRUNC: case _O_TRUNC | _O_EXCL: // ignore EXCL w/o CREAT dwCreationDisposition = TRUNCATE_EXISTING; break; case _O_CREAT | _O_TRUNC: dwCreationDisposition = CREATE_ALWAYS; break; default: // this can't happen ... all cases are covered _doserrno = 0L; derror("Invalid open flag"); } /* * try to open/create the file */ HANDLE fileHandle = ::CreateFileA(file_name, dwDesiredAccess, dwShareMode, &SecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, 0); if (fileHandle != INVALID_HANDLE_VALUE && fileHandle != nullptr) { auto err = _looper->bind_io_handle((dsn_handle_t)fileHandle, &_callback); if (err != ERR_OK) { dassert(false, "cannot associate file handle %s to io completion port, err = 0x%x\n", file_name, ::GetLastError()); return 0; } else { return (dsn_handle_t)(fileHandle); } } else { derror("cannot create file %s, err = 0x%x\n", file_name, ::GetLastError()); return 0; } }
static void usage(void) { derror("Usage: %s [ -b ] [ -c ] [ -f ] [ -k kind ] [ -x ] [ -o outfile] [ file ... ]", progname); derror("netcdf library version %s", nc_inq_libvers()); }
void goto00(int i) /* GO TO if i=1, else LABEL */ { ptr p ; symbl oname ; register int li ; int gisav ; double val ; if (i==0) { /* LABEL */ if (! runf) derror(22) ; if (warea[gi-5]==lf) goto L100 ; derror(79) ; /* not at start of line */ } if (warea[gi]<'0' && warea[gi]!='(' || warea[gi]>'9') goto L100 ; /* ------------------------------------------------------------------- */ /* branch to line number */ /* ------------------------------------------------------------------- */ val=evalexp() ; if (errnum) derror(errnum) ; if (val<1 || val>maxlin) derror(13) ; /* invalid line number */ if (warea[gi]=='|') { if (warea[gi+1]!=vrem && warea[gi+1]!=chr11 && warea[gi+1]!=vendls) derror(81) ; } else if (warea[gi]!=lf) derror(33) ; /* bad termination */ li=linsiz+2 ; /* search */ do { if (BASE*warea[li]+warea[li+1]==(int) val) goto L8 ; /* found*/ li+=warea[li+2] ; /* no, add line length */ } while (li<endtxt) ; derror(68) ; /* not found */ L8 : if (tracer>0) { if (tracer==2 || tracer==3 || tracer>=6) { printf("%c%s",'\33',"[7m") ; /* ANSI reverse video */ printf("%s%u%c","G:",lnumber,'\n') ; printf("%c%s",'\33',"[0m") ; /* ANSI restore video */ }} gi=li-1 ; return ; /* gi is on lf before target */ /* ------------------------------------------------------------------- */ /* branch to symbolic label */ /* ------------------------------------------------------------------- */ L100 : p=getvar() ; if (errnum) derror(errnum) ; if (vartyp<=0) derror(82) ; /* illegal label */ if (warea[gi]=='|') { /* faster than AND? */ if (warea[gi+1]!=vrem) { if (i==0) derror(62) ; /* LABEL */ if (warea[gi+1]!=chr11 && warea[gi+1]!=vendls) derror(81) ; } } /* if | */ else if (warea[gi]!=lf) derror(33) ; /* bad termination */ if (p!=NULL) { /* label exists */ if (p->symtype!=5) derror(82) ; /* illegal label */ if (i==0) { /* LABEL */ if (intval[p->valptr]!=gi) derror(82) ; /* duplicate */ return ; /* skip the label */ } gi=intval[p->valptr] ; /* execute GO TO */ goto L10 ; } if (i==0) return ; /* new LABEL, skip it */ gisav=gi ; /* GO TO, search for target label; save gi for error */ strcpy(oname,symbol) ; li=linsiz+6 ; /* start after first token */ while (li<endtxt) { /* search */ if (warea[li-1]==vlabel) { gi=li ; p=getvar() ; if (errnum) derror(errnum) ; li=gi ; while (warea[li]!=lf) li++ ; /* get to next lf */ if (strcmp(symbol,oname)==0) { gi=li ; goto L300 ; } /* success */ li+=5 ; /* get behind next token */ } else li+=warea[li-2] ; /* add line length */ } /* while */ gi=gisav ; derror(68) ; /* search failure at gi */ L300 : if (gii+1>maxinvar) derror(41) ; p=(struct symnode*)malloc(sizeof(struct symnode)) ; p->SWITCH=TRUE ; /* install new label */ p->link=hashtab[hashval] ; strcpy(p->name,symbol) ; p->symtype=5 ; hashtab[hashval]=p ; p->valptr=gii ; intval[gii++]=gi ; L10 : if (tracer>0) { if (tracer==2 || tracer==3 || tracer>=6) { printf("%c%s",'\33',"[7m") ; /* ANSI reverse video */ printf("%s%s%c","G: GO TO LABEL ",symbol,'\n') ; printf("%c%s",'\33',"[0m") ; /* ANSI restore video */ } } } /* goto00 */
int main( int argc, char *argv[]) { /* MSC_EXTRA extern int optind; MSC_EXTRA extern int opterr; MSC_EXTRA extern char *optarg;*/ int any_error; int c; FILE *fp; #ifdef __hpux setlocale(LC_CTYPE,""); #endif #ifdef MDEBUG malloc_debug(2) ; /* helps find malloc/free errors on Sun */ #endif /* MDEBUG */ opterr = 1; /* print error message if bad option */ progname = ubasename(argv[0]); cdlname = "-"; c_flag = 0; fortran_flag = 0; netcdf_flag = 0; cmode_modifier = 0; nofill_flag = 0; #if _CRAYMPP && 0 /* initialize CRAY MPP parallel-I/O library */ (void) par_io_init(32, 32); #endif while ((c = getopt(argc, argv, "bcfk:l:no:v:x")) != EOF) switch(c) { case 'c': /* for c output, old version of "-lc" */ c_flag = 1; break; case 'f': /* for fortran output, old version of "-lf" */ fortran_flag = 1; break; case 'b': /* for binary netcdf output, ".nc" extension */ netcdf_flag = 1; break; case 'l': /* specify language, instead of using -c or -f */ { char *lang_name = (char *) emalloc(strlen(optarg)+1); if (! lang_name) { derror ("%s: out of memory", progname); return(1); } (void)strcpy(lang_name, optarg); if (strcmp(lang_name, "c") == 0 || strcmp(lang_name, "C") == 0) { c_flag = 1; } else if (strcmp(lang_name, "f77") == 0 || strcmp(lang_name, "fortran77") == 0 || strcmp(lang_name, "Fortran77") == 0) { fortran_flag = 1; } else { /* Fortran90, Java, C++, Perl, Python, Ruby, ... */ derror("%s: output language %s not implemented", progname, lang_name); return(1); } } break; case 'n': /* old version of -b, uses ".cdf" extension */ netcdf_flag = -1; break; case 'o': /* to explicitly specify output name */ netcdf_flag = 1; netcdf_name = (char *) emalloc(strlen(optarg)+1); if (! netcdf_name) { derror ("%s: out of memory", progname); return(1); } (void)strcpy(netcdf_name,optarg); break; case 'x': /* set nofill mode to speed up creation of large files */ nofill_flag = 1; break; case 'v': /* a deprecated alias for "kind" option */ /*FALLTHRU*/ case 'k': /* for specifying variant of netCDF format to be generated */ { char *kind_name = (char *) emalloc(strlen(optarg)+1); if (! kind_name) { derror ("%s: out of memory", progname); return(1); } (void)strcpy(kind_name, optarg); /* The default kind is kind 1 (classic), with 32-bit offsets */ if (strcmp(kind_name, "1") == 0 || strcmp(kind_name, "classic") == 0) { cmode_modifier |= NC_CLASSIC_MODEL; } /* The 64-bit offset kind (2) should only be used if actually needed */ else if (strcmp(kind_name, "2") == 0 || strcmp(kind_name, "64-bit-offset") == 0 || strcmp(kind_name, "64-bit offset") == 0) { cmode_modifier |= NC_64BIT_OFFSET; } #ifdef USE_NETCDF4 /* NetCDF-4 HDF5 format*/ else if (strcmp(kind_name, "3") == 0 || strcmp(kind_name, "hdf5") == 0 || strcmp(kind_name, "netCDF-4") == 0) { cmode_modifier |= NC_NETCDF4; } /* NetCDF-4 HDF5 format, but using only nc3 data model */ else if (strcmp(kind_name, "4") == 0 || strcmp(kind_name, "hdf5-nc3") == 0 || strcmp(kind_name, "netCDF-4 classic model") == 0) { cmode_modifier |= NC_NETCDF4 | NC_CLASSIC_MODEL; } #endif else { derror("Invalid format, try classic, 64-bit offset, netCDF-4, or netCDF-4 classic model"); return 2; } free(kind_name); } break; case '?': usage(); return(8); } if (fortran_flag && c_flag) { derror("Only one of -c or -f may be specified"); return(8); } argc -= optind; argv += optind; if (argc > 1) { derror ("%s: only one input file argument permitted",progname); return(6); } fp = stdin; if (argc > 0 && strcmp(argv[0], "-") != 0) { if ((fp = fopen(argv[0], "r")) == NULL) { derror ("can't open file %s for reading: ", argv[0]); perror(""); return(7); } cdlname = argv[0]; } ncgin = fp; any_error = ncgparse(); if (any_error || derror_count > 0) return 1; return 0; }
void replica::on_prepare(dsn_message_t request) { check_hashed_access(); replica_configuration rconfig; mutation_ptr mu; { rpc_read_stream reader(request); unmarshall(reader, rconfig, DSF_THRIFT_BINARY); mu = mutation::read_from(reader, request); } decree decree = mu->data.header.decree; dinfo("%s: mutation %s on_prepare", name(), mu->name()); dassert(mu->data.header.ballot == rconfig.ballot, ""); if (mu->data.header.ballot < get_ballot()) { derror("%s: mutation %s on_prepare skipped due to old view", name(), mu->name()); // no need response because the rpc should have been cancelled on primary in this case return; } // update configuration when necessary else if (rconfig.ballot > get_ballot()) { if (!update_local_configuration(rconfig)) { derror( "%s: mutation %s on_prepare failed as update local configuration failed, state = %s", name(), mu->name(), enum_to_string(status()) ); ack_prepare_message(ERR_INVALID_STATE, mu); return; } } if (partition_status::PS_INACTIVE == status() || partition_status::PS_ERROR == status()) { derror( "%s: mutation %s on_prepare failed as invalid replica state, state = %s", name(), mu->name(), enum_to_string(status()) ); ack_prepare_message( (partition_status::PS_INACTIVE == status() && _inactive_is_transient) ? ERR_INACTIVE_STATE : ERR_INVALID_STATE, mu ); return; } else if (partition_status::PS_POTENTIAL_SECONDARY == status()) { // new learning process if (rconfig.learner_signature != _potential_secondary_states.learning_version) { init_learn(rconfig.learner_signature); // no need response as rpc is already gone return; } if (!(_potential_secondary_states.learning_status == learner_status::LearningWithPrepare || _potential_secondary_states.learning_status == learner_status::LearningSucceeded)) { derror( "%s: mutation %s on_prepare skipped as invalid learning status, state = %s, learning_status = %s", name(), mu->name(), enum_to_string(status()), enum_to_string(_potential_secondary_states.learning_status) ); // no need response as rpc is already gone return; } } dassert (rconfig.status == status(), ""); if (decree <= last_committed_decree()) { ack_prepare_message(ERR_OK, mu); return; } // real prepare start auto mu2 = _prepare_list->get_mutation_by_decree(decree); if (mu2 != nullptr && mu2->data.header.ballot == mu->data.header.ballot) { if (mu2->is_logged()) { ack_prepare_message(ERR_OK, mu); } else { derror("%s: mutation %s on_prepare skipped as it is duplicate", name(), mu->name()); // response will be unnecessary when we add retry logic in rpc engine. // the retried rpc will use the same id therefore it will be considered responsed // even the response is for a previous try. } return; } error_code err = _prepare_list->prepare(mu, status()); dassert (err == ERR_OK, ""); if (partition_status::PS_POTENTIAL_SECONDARY == status()) { dassert (mu->data.header.decree <= last_committed_decree() + _options->max_mutation_count_in_prepare_list, ""); } else { dassert (partition_status::PS_SECONDARY == status(), ""); dassert (mu->data.header.decree <= last_committed_decree() + _options->staleness_for_commit, ""); } dassert(mu->log_task() == nullptr, ""); mu->log_task() = _stub->_log->append(mu, LPC_WRITE_REPLICATION_LOG, this, std::bind(&replica::on_append_log_completed, this, mu, std::placeholders::_1, std::placeholders::_2), gpid_to_hash(get_gpid()) ); }
int main( int argc, char *argv[]) { int c; FILE *fp; int languages = 0; #ifdef __hpux setlocale(LC_CTYPE,""); #endif init_netcdf(); opterr = 1; /* print error message if bad option */ progname = ubasename(argv[0]); cdlname = "-"; netcdf_name = NULL; datasetname = NULL; c_flag = 0; f77_flag = 0; cml_flag = 0; java_flag = 0; binary_flag = 0; nofill_flag = 0; syntax_only = 0; header_only = 0; mainname = "main"; nciterbuffersize = 0; k_flag = 0; format_flag = 0; enhanced_flag = 0; specials_flag = 0; diskless = 0; #if _CRAYMPP && 0 /* initialize CRAY MPP parallel-I/O library */ (void) par_io_init(32, 32); #endif while ((c = getopt(argc, argv, "hbcfk:l:no:v:xdM:D:B:P")) != EOF) switch(c) { case 'd': debug = 1; break; case 'D': debug = atoi(optarg); break; case 'c': /* for c output, old version of "-lc" */ c_flag = 1; fprintf(stderr,"-c is deprecated: please use -lc\n"); break; case 'f': /* for f77 output, old version of "-lf" */ f77_flag = 1; fprintf(stderr,"-f is deprecated: please use -lf77\n"); break; case 'b': /* for binary netcdf output, ".nc" extension */ binary_flag = 1; break; case 'h': header_only = 1; break; case 'l': /* specify language, instead of using -c or -f or -b */ { struct Languages* langs; char* lang_name = (char*) emalloc(strlen(optarg)+1); (void)strcpy(lang_name, optarg); for(langs=legallanguages;langs->name != NULL;langs++) { if(strcmp(lang_name,langs->name)==0) { *(langs->flag) = 1; break; } } if(langs->name == NULL) { derror("%s: output language %s not implemented", progname, lang_name); return(1); } } break; case 'n': /* old version of -b, uses ".cdf" extension */ binary_flag = -1; break; case 'o': /* to explicitly specify output name */ netcdf_name = nulldup(optarg); break; case 'x': /* set nofill mode to speed up creation of large files */ nofill_flag = 1; break; case 'v': /* a deprecated alias for "kind" option */ /*FALLTHRU*/ case 'k': /* for specifying variant of netCDF format to be generated Possible values are: 1 (=> classic 32 bit) 2 (=> classic 64 bit) 3 (=> enhanced) 4 (=> classic, but stored in an enhanced file format) Also provide string versions of above "classic" "64-bit-offset" "64-bit offset" "enhanced" | "hdf5" | "netCDF-4" "enhanced-nc3" | "hdf5-nc3" | "netCDF-4 classic model" */ { struct Kvalues* kvalue; char *kind_name = (char *) emalloc(strlen(optarg)+1); if (! kind_name) { derror ("%s: out of memory", progname); return(1); } (void)strcpy(kind_name, optarg); for(kvalue=legalkinds;kvalue->name;kvalue++) { if(strcmp(kind_name,kvalue->name) == 0) { k_flag = kvalue->k_flag; break; } } if(kvalue->name == NULL) { derror("Invalid format: %s",kind_name); return 2; } } break; case 'M': /* Determine the name for the main function */ mainname = nulldup(optarg); break; case 'B': nciterbuffersize = atoi(optarg); break; case 'P': /* diskless with persistence */ diskless = 1; break; case '?': usage(); return(8); } /* check for multiple or no language spec */ if(binary_flag) languages++; if(c_flag) languages++; if(f77_flag)languages++; if(cml_flag) languages++; if(java_flag) languages++; if(languages > 1) { fprintf(stderr,"Please specify only one language\n"); return 1; } if(languages == 0) { binary_flag = 1; /* default */ /* Treat -k or -o as an implicit -lb assuming no other -l flags */ if(k_flag == 0 && netcdf_name == NULL) syntax_only = 1; } /* Compute/default the iterator buffer size */ if(binary_flag) { if(nciterbuffersize == 0 ) nciterbuffersize = DFALTBINNCITERBUFFERSIZE; } else { if(nciterbuffersize == 0) nciterbuffersize = DFALTLANGNCITERBUFFERSIZE; } #ifndef ENABLE_C if(c_flag) { fprintf(stderr,"C not currently supported\n"); exit(1); } #endif #ifndef ENABLE_BINARY if(binary_flag) { fprintf(stderr,"Binary netcdf not currently supported\n"); exit(1); } #endif #ifndef ENABLE_JAVA if(java_flag) { fprintf(stderr,"Java not currently supported\n"); exit(1); } #else if(java_flag && strcmp(mainname,"main")==0) mainname = "Main"; #endif #ifndef ENABLE_F77 if(f77_flag) { fprintf(stderr,"F77 not currently supported\n"); exit(1); } #endif if(!binary_flag) diskless = 0; argc -= optind; argv += optind; if (argc > 1) { derror ("%s: only one input file argument permitted",progname); return(6); } fp = stdin; if (argc > 0 && strcmp(argv[0], "-") != 0) { if ((fp = fopen(argv[0], "r")) == NULL) { derror ("can't open file %s for reading: ", argv[0]); perror(""); return(7); } cdlname = (char*)emalloc(NC_MAX_NAME); cdlname = nulldup(argv[0]); if(strlen(cdlname) > NC_MAX_NAME) cdlname[NC_MAX_NAME] = '\0'; } /* Standard Unidata java interface => usingclassic */ parse_init(); ncgin = fp; if(debug >= 2) {ncgdebug=1;} if(ncgparse() != 0) return 1; /* Compute the k_flag (1st pass) using rules in the man page (ncgen.1).*/ #ifndef USE_NETCDF4 if(enhanced_flag) { derror("CDL input is enhanced mode, but --disable-netcdf4 was specified during build"); return 0; } #endif if(java_flag || f77_flag) { k_flag = 1; if(enhanced_flag) { derror("Java or Fortran requires classic model CDL input"); return 0; } } if(k_flag == 0) k_flag = format_flag; if(enhanced_flag && k_flag == 0) k_flag = 3; if(enhanced_flag && k_flag != 3) { derror("-k or _Format conflicts with enhanced CDL input"); return 0; } if(specials_flag > 0 && k_flag == 0) #ifdef USE_NETCDF4 k_flag = 3; #else k_flag = 1; #endif if(k_flag == 0) k_flag = 1; usingclassic = (k_flag <= 2?1:0); /* compute cmode_modifier */ switch (k_flag) { case 1: cmode_modifier = 0; break; case 2: cmode_modifier = NC_64BIT_OFFSET; break; case 3: cmode_modifier = NC_NETCDF4; break; case 4: cmode_modifier = NC_NETCDF4 | NC_CLASSIC_MODEL; break; default: ASSERT(0); /* cannot happen */ } if(diskless) cmode_modifier |= (NC_DISKLESS|NC_NOCLOBBER); processsemantics(); if(!syntax_only && error_count == 0) define_netcdf(); return 0; }
void CLASS nikon_compressed_load_raw() // used when tag 0x103 of subifd1 == 0x8799 (34713) { static const uchar nikon_tree[][32] = { { 0,1,5,1,1,1,1,1,1,2,0,0,0,0,0,0, /* 12-bit lossy */ 5,4,3,6,2,7,1,0,8,9,11,10,12 }, { 0,1,5,1,1,1,1,1,1,2,0,0,0,0,0,0, /* 12-bit lossy after split */ 0x39,0x5a,0x38,0x27,0x16,5,4,3,2,1,0,11,12,12 }, { 0,1,4,2,3,1,2,0,0,0,0,0,0,0,0,0, /* 12-bit lossless */ 5,4,6,3,7,2,8,1,9,0,10,11,12 }, { 0,1,4,3,1,1,1,1,1,2,0,0,0,0,0,0, /* 14-bit lossy */ 5,6,4,7,8,3,9,2,1,0,10,11,12,13,14 }, { 0,1,5,1,1,1,1,1,1,1,2,0,0,0,0,0, /* 14-bit lossy after split */ 8,0x5c,0x4b,0x3a,0x29,7,6,5,4,3,2,1,0,13,14 }, { 0,1,4,2,2,3,1,2,0,0,0,0,0,0,0,0, /* 14-bit lossless */ 7,6,8,5,9,4,10,3,11,12,2,0,1,13,14 } }; struct decode *dindex; ushort ver0, ver1, vpred[2][2], hpred[2], csize; int i, min, max, step=0, huff=0, split=0, row, col, len, shl, diff; fseek (ifp, meta_offset, SEEK_SET); // linearization curve (0x96) ver0 = fgetc(ifp); ver1 = fgetc(ifp); // ver0=0x44, ver1=0x20 for 12bits and 14bits lossy (d300) // 0x46, 0x30 for 12bits and 14 lossless (d300 and d700) printf("meta_offset=%d, tiff_bps=%d, ver0=%d, ver1=%d\n", meta_offset, tiff_bps, ver0, ver1); if (ver0 == 0x49 || ver1 == 0x58) // never seen. firmware update or nikon raw software? fseek (ifp, 2110, SEEK_CUR); if (ver0 == 0x46) huff = 2; // lossless (implicitly 12bits). have seen a d3x nef with ver0=0x46 and ver1=0x30 (exif 0x131="ver1.00") // with d300 lossless : ver0=0x46, ver1=0x30. d700/14b/lossless : ver0=0x46, ver1=0x30 if (tiff_bps == 14) huff += 3; // 14bits lossly (if huff was ==0) or 14bits lossless if ver0==0x46 read_shorts (vpred[0], 4); // vertical predictor values ? max = 1 << tiff_bps & 0x7fff; if ((csize = get2()) > 1) // curve size. 567 with D100/12bits/lossy. 32 with d3x/12bits/lossless. step = max / (csize-1); if (ver0 == 0x44 && ver1 == 0x20 && step > 0) { // lossy (d300, d90 and d5000). //tag 0x93 = 2. stored curve needs interpolation for (i=0; i < csize; i++) // read curve curve[i*step] = get2(); // curve interpolation for (i=0; i < max; i++) curve[i] = ( curve[i-i%step]*(step-i%step) + curve[i-i%step+step]*(i%step) ) / step; fseek (ifp, meta_offset+562, SEEK_SET); // csize seems 257 for recent models (0x44/0x20) like d90 and d300 // type 2 has the split value and uses a second huffman table split = get2(); } else if (ver0 != 0x46 && csize <= 0x4001) // if not lossless. // with D100/D200/D2X/D40/D80/D60 12bits/lossy : ver0==0x44 && ver1==0x10 read_shorts (curve, max=csize); printf("csize=%d, step=%d, split=%d, huff=%d\n", csize, step, split, huff); /* 0x96 (linearization table) tag format offset how_many type name ----+-----------+------+--------------------------------------------------------------------------------------------- 0 1 byte version0 1 1 byte version1 ver0=0x44, ver1=0x20 for 12bits and 14bits lossy (d300) 0x44, 0x20 : lossy (d300, d90 and d5000) 0x46, 0x30 for 12bits and 14 lossless (d300 and d700) 0x46, 0x30 : d3x/12b/lossless 0x46, 0x30. with d300 lossless. and d700/14b/lossless 0x44, 0x10 : with D100/D200/D2X/D40/D80/D60 12bits/lossy tag 0x93 = 3 for lossless (0x46/0x30). tag 0x93 = 4 for lossy type 2 (0x44/0x20) tag 0x93 = 1 for lossy type 1 (0x44/0x10) 2 4 shorts vpred[2][2] (when ver0 == 0x49 || ver1 == 0x58, fseek (ifp, 2110, SEEK_CUR) before) 0x0a 1 short curve_size. 32 with d3x/12bits/lossless, d300/12bits/lossless 34 with 14bits/lossless (d300 and d700) 257 with d300/12+14b/lossy. 257 with 12b/lossy for d90 567 with D100/12bits/lossy. 683 with 12b/lossy for d200,d2x,d40x,d40,d80,d60 0x0c curve_size shorts curve[] for lossy type 2, if curve_size == 257 (d90 and d300), end of curve table is 1+257*2 = 526 562 1 short split_value (for 0x44/0x20 only (lossy type 2), d90 and d300) */ while (curve[max-2] == curve[max-1]) max--; init_decoder(); make_decoder (nikon_tree[huff], 0); fseek (ifp, data_offset, SEEK_SET); getbits(-1); for (min=row=0; row < height; row++) { if (split && row == split) { // for lossy type 2 (0x44/0x20) init_decoder(); make_decoder (nikon_tree[huff+1], 0); max += (min = 16) << 1; } for (col=0; col < raw_width; col++) { for (dindex=first_decode; dindex->branch[0]; ) dindex = dindex->branch[getbits(1)]; // read 12 or 14bits value bit per bit and walking through the huffman tree to find the leaf len = dindex->leaf & 15; // length = 4 left most bits shl = dindex->leaf >> 4; // shift length? = 8 or 10bits diff = ((getbits(len-shl) << 1) + 1) << shl >> 1; // read diff value if ((diff & (1 << (len-1))) == 0) // left most bit is certainly the sign diff -= (1 << len) - !shl; if (col < 2) hpred[col] = vpred[row & 1][col] += diff; // vpred used for columns 0 and 1 else hpred[col & 1] += diff; // very close to jpeg lossless decompression (ljpeg_diff and ljpeg_row), except for the shl value... if ((ushort)(hpred[col & 1] + min) >= max) derror(); if ((unsigned) (col-left_margin) < width) BAYER(row,col-left_margin) = curve[LIM((short)hpred[col & 1],0,0x3fff)]; } } }
void simple_stateful_load_balancer::run_lb(partition_configuration& pc) { if (_state->freezed()) return; configuration_update_request proposal; proposal.config = pc; if (pc.primary.is_invalid()) { if (pc.secondaries.size() > 0) { if (s_lb_for_test) { std::vector< ::dsn::rpc_address> tmp(pc.secondaries); std::sort(tmp.begin(), tmp.end()); proposal.node = tmp[0]; } else { proposal.node = pc.secondaries[dsn_random32(0, static_cast<int>(pc.secondaries.size()) - 1)]; } proposal.type = CT_UPGRADE_TO_PRIMARY; } else if (pc.last_drops.size() == 0) { proposal.node = find_minimal_load_machine(true); proposal.type = CT_ASSIGN_PRIMARY; } // DDD else { proposal.node = *pc.last_drops.rbegin(); proposal.type = CT_ASSIGN_PRIMARY; derror("%s.%d.%d enters DDD state, we are waiting for its last primary node %s to come back ...", pc.app_type.c_str(), pc.gpid.app_id, pc.gpid.pidx, proposal.node.to_string() ); } if (proposal.node.is_invalid() == false) { send_proposal(proposal.node, proposal); } } else if (static_cast<int>(pc.secondaries.size()) + 1 < pc.max_replica_count) { proposal.type = CT_ADD_SECONDARY; proposal.node = find_minimal_load_machine(false); if (proposal.node.is_invalid() == false && proposal.node != pc.primary && std::find(pc.secondaries.begin(), pc.secondaries.end(), proposal.node) == pc.secondaries.end()) { send_proposal(pc.primary, proposal); } } else { // it is healthy, nothing to do } }
/* * Create Fortran data statement to initialize numeric variable with * values. */ static void f_var_init( int varnum, /* which variable */ void *rec_start /* start of data */ ) { char *val_string; char *charvalp; short *shortvalp; int *intvalp; float *floatvalp; double *doublevalp; unsigned char *ubytevalp; unsigned short *ushortvalp; unsigned int *uintvalp; long long *int64valp; unsigned long long *uint64valp; char stmnt[FORT_MAX_STMNT]; size_t stmnt_len; char s2[FORT_MAX_STMNT]; int ival; /* load variable with data values */ sprintf(stmnt, "data %s /",vars[varnum].lname); stmnt_len = strlen(stmnt); switch (vars[varnum].type) { case NC_BYTE: charvalp = (char *) rec_start; for (ival = 0; ival < var_len-1; ival++) { val_string = fstring(NC_BYTE,(void *)charvalp++,0); sprintf(s2, "%s, ", val_string); fstrcat(stmnt, s2, &stmnt_len); free(val_string); } val_string = fstring(NC_BYTE,(void *)charvalp++,0); fstrcat(stmnt, val_string, &stmnt_len); free(val_string); break; case NC_SHORT: shortvalp = (short *) rec_start; for (ival = 0; ival < var_len-1; ival++) { sprintf(s2, "%d, ", *shortvalp++); fstrcat(stmnt, s2, &stmnt_len); } sprintf(s2, "%d", *shortvalp); fstrcat(stmnt, s2, &stmnt_len); break; case NC_INT: intvalp = (int *) rec_start; for (ival = 0; ival < var_len-1; ival++) { sprintf(s2, "%ld, ", (long)*intvalp++); fstrcat(stmnt, s2, &stmnt_len); } sprintf(s2, "%ld", (long)*intvalp); fstrcat(stmnt, s2, &stmnt_len); break; case NC_FLOAT: floatvalp = (float *) rec_start; for (ival = 0; ival < var_len-1; ival++) { sprintf(s2, "%.8g, ", *floatvalp++); fstrcat(stmnt, s2, &stmnt_len); } sprintf(s2, "%.8g", *floatvalp); fstrcat(stmnt, s2, &stmnt_len); break; case NC_DOUBLE: doublevalp = (double *) rec_start; for (ival = 0; ival < var_len-1; ival++) { sprintf(s2, "%#.16g", *doublevalp++); tztrim(s2); expe2d(s2); /* change 'e' to 'd' in exponent */ fstrcat(s2, ", ", &stmnt_len); fstrcat(stmnt, s2, &stmnt_len); } sprintf(s2, "%#.16g", *doublevalp++); tztrim(s2); expe2d(s2); fstrcat(stmnt, s2, &stmnt_len); break; case NC_UBYTE: ubytevalp = (unsigned char *) rec_start; for (ival = 0; ival < var_len-1; ival++) { sprintf(s2, "%hhu, ", (unsigned char)*ubytevalp++); fstrcat(stmnt, s2, &stmnt_len); } sprintf(s2, "%hhu", (unsigned char)*ubytevalp); fstrcat(stmnt, s2, &stmnt_len); break; case NC_USHORT: ushortvalp = (unsigned short *) rec_start; for (ival = 0; ival < var_len-1; ival++) { sprintf(s2, "%hu, ", (unsigned short)*ushortvalp++); fstrcat(stmnt, s2, &stmnt_len); } sprintf(s2, "%hu", (unsigned short)*ushortvalp); fstrcat(stmnt, s2, &stmnt_len); break; case NC_UINT: uintvalp = (unsigned int *) rec_start; for (ival = 0; ival < var_len-1; ival++) { sprintf(s2, "%u, ", (unsigned int)*uintvalp++); fstrcat(stmnt, s2, &stmnt_len); } sprintf(s2, "%u", (unsigned int)*uintvalp); fstrcat(stmnt, s2, &stmnt_len); break; case NC_INT64: int64valp = (long long *) rec_start; for (ival = 0; ival < var_len-1; ival++) { sprintf(s2, "%lld, ", (long long)*int64valp++); fstrcat(stmnt, s2, &stmnt_len); } sprintf(s2, "%lld", (long long)*int64valp); fstrcat(stmnt, s2, &stmnt_len); break; case NC_UINT64: uint64valp = (unsigned long long *) rec_start; for (ival = 0; ival < var_len-1; ival++) { sprintf(s2, "%llu, ", (unsigned long long)*uint64valp++); fstrcat(stmnt, s2, &stmnt_len); } sprintf(s2, "%llu", (unsigned long long)*uint64valp); fstrcat(stmnt, s2, &stmnt_len); break; default: derror("fstrstr: bad type"); break; } fstrcat(stmnt, "/", &stmnt_len); /* For record variables, store data statement for later use; otherwise, just print it. */ if (vars[varnum].ndims > 0 && vars[varnum].dims[0] == rec_dim) { char *dup_stmnt = (char*) emalloc(strlen(stmnt)+1); strcpy(dup_stmnt, stmnt); /* ULTRIX missing strdup */ vars[varnum].data_stmnt = dup_stmnt; } else { fline(stmnt); } }
error_code deploy_svc_service_impl::start() { std::string pdir = utils::filesystem::path_combine(dsn_get_current_app_data_dir(), "services"); _service_dir = dsn_config_get_value_string("deploy.service", "deploy_dir", pdir.c_str(), "where to put temporal deployment resources" ); // load clusters const char* clusters[100]; int sz = 100; int count = dsn_config_get_all_keys("deploy.service.clusters", clusters, &sz); dassert(count <= 100, "too many clusters"); for (int i = 0; i < count; i++) { std::string cluster_name = dsn_config_get_value_string( clusters[i], "name", "", "cluster name" ); if (nullptr != get_cluster(cluster_name)) { derror("cluster %s already defined", cluster_name.c_str()); return ERR_CLUSTER_ALREADY_EXIST; } std::string cluster_factory_type = dsn_config_get_value_string( clusters[i], "factory", "", "factory name to create the target cluster scheduler" ); auto cluster = ::dsn::utils::factory_store<cluster_scheduler>::create( cluster_factory_type.c_str(), PROVIDER_TYPE_MAIN ); if (nullptr == cluster) { derror("cluster type %s is not defined", cluster_factory_type.c_str()); return ERR_OBJECT_NOT_FOUND; } std::shared_ptr<cluster_ex> ce(new cluster_ex); ce->scheduler.reset(cluster); ce->cluster.name = cluster_name; ce->cluster.type = cluster->type(); _clusters[cluster_name] = ce; } _cli_deploy = dsn_cli_app_register( "deploy", "deploy deploy_request(in json format)", "deploy an app via our deployment service", (void*)this, [](void *context, int argc, const char **argv, dsn_cli_reply *reply) { auto this_ = (deploy_svc_service_impl*)context; this_->on_deploy_cli(context, argc, argv, reply); }, __svc_cli_freeer__ ); _cli_undeploy = dsn_cli_app_register( "undeploy", "undeploy service_name(in json format)", "undeploy an app via our deployment service", (void*)this, [](void *context, int argc, const char **argv, dsn_cli_reply *reply) { auto this_ = (deploy_svc_service_impl*)context; this_->on_undeploy_cli(context, argc, argv, reply); }, __svc_cli_freeer__ ); _cli_get_service_list = dsn_cli_app_register( "service_list", "service_list package_id(in json format)", "get service list of a package via our deployment service", (void*)this, [](void *context, int argc, const char **argv, dsn_cli_reply *reply) { auto this_ = (deploy_svc_service_impl*)context; this_->on_get_service_list_cli(context, argc, argv, reply); }, __svc_cli_freeer__ ); _cli_get_service_info = dsn_cli_app_register( "service_info", "service_info service_name(in json format)", "get service info of a service via our deployment service", (void*)this, [](void *context, int argc, const char **argv, dsn_cli_reply *reply) { auto this_ = (deploy_svc_service_impl*)context; this_->on_get_service_info_cli(context, argc, argv, reply); }, __svc_cli_freeer__ ); _cli_get_cluster_list = dsn_cli_app_register( "cluster_list", "cluster_list format(in json format)", "get cluster list with a specific format via our deployment service", (void*)this, [](void *context, int argc, const char **argv, dsn_cli_reply *reply) { auto this_ = (deploy_svc_service_impl*)context; this_->on_get_cluster_list_cli(context, argc, argv, reply); }, __svc_cli_freeer__ ); return ERR_OK; }
/* write out variable's data from in-memory structure */ void load_netcdf(void *rec_start) { int i, idim; int stat = NC_NOERR; MPI_Offset *start, *count; char *charvalp = NULL; short *shortvalp = NULL; int *intvalp = NULL; float *floatvalp = NULL; double *doublevalp = NULL; unsigned char *ubytevalp = NULL; unsigned short *ushortvalp = NULL; unsigned int *uintvalp = NULL; long long *int64valp = NULL; unsigned long long *uint64valp = NULL; MPI_Offset total_size; /* load values into variable */ switch (vars[varnum].type) { case NC_CHAR: case NC_BYTE: charvalp = (char *) rec_start; break; case NC_SHORT: shortvalp = (short *) rec_start; break; case NC_INT: intvalp = (int *) rec_start; break; case NC_FLOAT: floatvalp = (float *) rec_start; break; case NC_DOUBLE: doublevalp = (double *) rec_start; break; case NC_UBYTE: ubytevalp = (unsigned char *) rec_start; break; case NC_USHORT: ushortvalp = (unsigned short *) rec_start; break; case NC_UINT: uintvalp = (unsigned int *) rec_start; break; case NC_INT64: int64valp = (long long *) rec_start; break; case NC_UINT64: uint64valp = (unsigned long long *) rec_start; break; default: derror("Unhandled type %d\n", vars[varnum].type); break; } start = (MPI_Offset*) malloc(vars[varnum].ndims * 2 * sizeof(MPI_Offset)); count = start + vars[varnum].ndims; if (vars[varnum].ndims > 0) { /* initialize start to upper left corner (0,0,0,...) */ start[0] = 0; if (vars[varnum].dims[0] == rec_dim) { count[0] = vars[varnum].nrecs; } else { count[0] = dims[vars[varnum].dims[0]].size; } } for (idim = 1; idim < vars[varnum].ndims; idim++) { start[idim] = 0; count[idim] = dims[vars[varnum].dims[idim]].size; } total_size = nctypesize(vars[varnum].type); for (idim=0; idim<vars[varnum].ndims; idim++) total_size *= count[idim]; /* If the total put size is more than 2GB, then put one subarray at a time. * Here the subarray is from 1, 2, ... ndims, except 0. * This is not a perfect solution. To be improved. */ if (total_size > INT_MAX) { MPI_Offset nchunks=count[0]; MPI_Offset subarray_nelems=1; for (idim=1; idim<vars[varnum].ndims; idim++) subarray_nelems *= count[idim]; count[0] = 1; switch (vars[varnum].type) { case NC_BYTE: for (i=0; i<nchunks; i++) { start[0] = i; stat = ncmpi_put_vara_schar_all(ncid, varnum, start, count, (signed char *)charvalp); check_err(stat, "ncmpi_put_vara_schar_all", __func__, __LINE__, __FILE__); charvalp += subarray_nelems; } break; case NC_CHAR: for (i=0; i<nchunks; i++) { start[0] = i; stat = ncmpi_put_vara_text_all(ncid, varnum, start, count, charvalp); check_err(stat, "ncmpi_put_vara_text_all", __func__, __LINE__, __FILE__); charvalp += subarray_nelems; } break; case NC_SHORT: for (i=0; i<nchunks; i++) { start[0] = i; stat = ncmpi_put_vara_short_all(ncid, varnum, start, count, shortvalp); check_err(stat, "ncmpi_put_vara_short_all", __func__, __LINE__, __FILE__); shortvalp += subarray_nelems; } break; case NC_INT: for (i=0; i<nchunks; i++) { start[0] = i; stat = ncmpi_put_vara_int_all(ncid, varnum, start, count, intvalp); check_err(stat, "ncmpi_put_vara_int_all", __func__, __LINE__, __FILE__); intvalp += subarray_nelems; } break; case NC_FLOAT: for (i=0; i<nchunks; i++) { start[0] = i; stat = ncmpi_put_vara_float_all(ncid, varnum, start, count, floatvalp); check_err(stat, "ncmpi_put_vara_float_all", __func__, __LINE__, __FILE__); floatvalp += subarray_nelems; } break; case NC_DOUBLE: for (i=0; i<nchunks; i++) { start[0] = i; stat = ncmpi_put_vara_double_all(ncid, varnum, start, count, doublevalp); check_err(stat, "ncmpi_put_vara_double_all", __func__, __LINE__, __FILE__); doublevalp += subarray_nelems; } break; case NC_UBYTE: for (i=0; i<nchunks; i++) { start[0] = i; stat = ncmpi_put_vara_uchar_all(ncid, varnum, start, count, ubytevalp); check_err(stat, "ncmpi_put_vara_uchar_all", __func__, __LINE__, __FILE__); ubytevalp += subarray_nelems; } break; case NC_USHORT: for (i=0; i<nchunks; i++) { start[0] = i; stat = ncmpi_put_vara_ushort_all(ncid, varnum, start, count, ushortvalp); check_err(stat, "ncmpi_put_vara_ushort_all", __func__, __LINE__, __FILE__); ushortvalp += subarray_nelems; } break; case NC_UINT: for (i=0; i<nchunks; i++) { start[0] = i; stat = ncmpi_put_vara_uint_all(ncid, varnum, start, count, uintvalp); check_err(stat, "ncmpi_put_vara_uint_all", __func__, __LINE__, __FILE__); uintvalp += subarray_nelems; } break; case NC_INT64: for (i=0; i<nchunks; i++) { start[0] = i; stat = ncmpi_put_vara_longlong_all(ncid, varnum, start, count, int64valp); check_err(stat, "ncmpi_put_vara_longlong_all", __func__, __LINE__, __FILE__); int64valp += subarray_nelems; } break; case NC_UINT64: for (i=0; i<nchunks; i++) { start[0] = i; stat = ncmpi_put_vara_ulonglong_all(ncid, varnum, start, count, uint64valp); check_err(stat, "ncmpi_put_vara_ulonglong_all", __func__, __LINE__, __FILE__); uint64valp += subarray_nelems; } break; default: derror("Unhandled type %d\n", vars[varnum].type); break; } } else { switch (vars[varnum].type) { case NC_BYTE: stat = ncmpi_put_vara_schar_all(ncid, varnum, start, count, (signed char *)charvalp); check_err(stat, "ncmpi_put_vara_schar_all", __func__, __LINE__, __FILE__); break; case NC_CHAR: stat = ncmpi_put_vara_text_all(ncid, varnum, start, count, charvalp); check_err(stat, "ncmpi_put_vara_text_all", __func__, __LINE__, __FILE__); break; case NC_SHORT: stat = ncmpi_put_vara_short_all(ncid, varnum, start, count, shortvalp); check_err(stat, "ncmpi_put_vara_short_all", __func__, __LINE__, __FILE__); break; case NC_INT: stat = ncmpi_put_vara_int_all(ncid, varnum, start, count, intvalp); check_err(stat, "ncmpi_put_vara_int_all", __func__, __LINE__, __FILE__); break; case NC_FLOAT: stat = ncmpi_put_vara_float_all(ncid, varnum, start, count, floatvalp); check_err(stat, "ncmpi_put_vara_float_all", __func__, __LINE__, __FILE__); break; case NC_DOUBLE: stat = ncmpi_put_vara_double_all(ncid, varnum, start, count, doublevalp); check_err(stat, "ncmpi_put_vara_double_all", __func__, __LINE__, __FILE__); break; case NC_UBYTE: stat = ncmpi_put_vara_uchar_all(ncid, varnum, start, count, ubytevalp); check_err(stat, "ncmpi_put_vara_uchar_all", __func__, __LINE__, __FILE__); break; case NC_USHORT: stat = ncmpi_put_vara_ushort_all(ncid, varnum, start, count, ushortvalp); check_err(stat, "ncmpi_put_vara_ushort_all", __func__, __LINE__, __FILE__); break; case NC_UINT: stat = ncmpi_put_vara_uint_all(ncid, varnum, start, count, uintvalp); check_err(stat, "ncmpi_put_vara_uint_all", __func__, __LINE__, __FILE__); break; case NC_INT64: stat = ncmpi_put_vara_longlong_all(ncid, varnum, start, count, int64valp); check_err(stat, "ncmpi_put_vara_longlong_all", __func__, __LINE__, __FILE__); break; case NC_UINT64: stat = ncmpi_put_vara_ulonglong_all(ncid, varnum, start, count, uint64valp); check_err(stat, "ncmpi_put_vara_ulonglong_all", __func__, __LINE__, __FILE__); break; default: derror("Unhandled type %d\n", vars[varnum].type); break; } } free(start); }
static LONG WINAPI TopLevelFilter(struct _EXCEPTION_POINTERS *pExceptionInfo) { LONG retval = EXCEPTION_CONTINUE_SEARCH; HWND hParent = NULL; // find a better value for your app // firstly see if dbghelp.dll is around and has the function we need // look next to the EXE first, as the one in System32 might be old // (e.g. Windows 2000) HMODULE hDll = NULL; if (hDll == NULL) { // load any version we can hDll = ::LoadLibraryA("DBGHELP.DLL"); } LPCSTR szResult = "core dump success"; char szDumpPath[512]; char szScratch[512]; dfatal("fatal exception, core dump started ..."); if (hDll) { MINIDUMPWRITEDUMP pDump = (MINIDUMPWRITEDUMP)::GetProcAddress(hDll, "MiniDumpWriteDump"); if (pDump) { sprintf(szDumpPath, "%s\\%s_%d_%d.dmp", s_dump_dir.c_str(), s_app_name, ::GetCurrentProcessId(), time(NULL)); // create the file HANDLE hFile = ::CreateFileA(szDumpPath, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); if (hFile != INVALID_HANDLE_VALUE) { _MINIDUMP_EXCEPTION_INFORMATION ExInfo; ExInfo.ThreadId = ::GetCurrentThreadId(); ExInfo.ExceptionPointers = pExceptionInfo; ExInfo.ClientPointers = NULL; // write the dump BOOL bOK = pDump(GetCurrentProcess(), GetCurrentProcessId(), hFile, MiniDumpNormal, &ExInfo, NULL, NULL); if (bOK) { sprintf(szScratch, "saved dump file to '%s'", szDumpPath); szResult = szScratch; retval = EXCEPTION_EXECUTE_HANDLER; } else { sprintf(szScratch, "failed to save dump file to '%s' (error %d)", szDumpPath, GetLastError()); szResult = szScratch; } ::CloseHandle(hFile); } else { sprintf(szScratch, "failed to create dump file '%s' (error %d)", szDumpPath, GetLastError()); szResult = szScratch; } } else { szResult = "DBGHELP.DLL too old"; } } else { szResult = "DBGHELP.DLL not found"; } if (szResult) { derror("%s", szResult); printf(szResult); } ::dsn::tools::sys_exit.execute(SYS_EXIT_EXCEPTION); return retval; }