VarType CodeBlock::make_cast(SymbolPtr p, VarType v1, VarType v2) { if (v1 != v2) { if (v1 == INTEGER && v2 == FLOATING) { // cast back to integer write_raw("CASTSI"); return INTEGER; } else if (v1 == FLOATING && v2 == INTEGER) { // cast back to floating write_raw("CASTSF"); return FLOATING; } else if ((v1 == STRING && v2 != STRING) || (v1 != STRING && v2 == STRING) || (v1 == VOID || v2 == VOID)) { if ((v1 == STRING_LITERAL && v2 == STRING) || (v1 == STRING && v2 == STRING_LITERAL)) { return STRING; } // need to catch boolean casting issues here... this->valid = false; report_error_lc("Semantic Error", "Unable to cast " + var_type_to_string(v1) + " to " + var_type_to_string(v2), p->get_row(), p->get_col()); return VOID; } else if ((v1 == BOOLEAN && v2 != BOOLEAN) || (v1 != BOOLEAN && v2 == BOOLEAN)) { return v2; } else { // fine return v2; } } else { return v2; } return VOID; }
void ConditionalBlock::generate_post() { // generate the final condition if (this->cond == COND_ELSE) { // if there's an else statement... // break from previous if statement to exit write_raw("BR " + this->exit_label + "\n"); // write an exit label (end of the if statement) // beginning of the else statement write_raw(this->exit_label + ":\n"); } else if (this->cond == COND_IF) { if (this->connected != nullptr) { // if there is an else statement ConditionalBlockPtr extender = static_pointer_cast<ConditionalBlock>(this->connected); if (extender->get_conditional_type() == COND_ELSE) { // at the end of the else, branch to the exit write_raw("BR " + extender->exit_label + "\n"); // write the exit label write_raw(extender->else_label + ":\n"); } } else { // end of if statement with no else write_raw(this->exit_label + ":\n"); } } }
void AssignmentBlock::generate_post() { // pop into assigner SymDataPtr post_assigner = static_pointer_cast<SymData>(this->assigner); make_cast(post_assigner, post_assigner->get_var_type(), this->expr_type); write_raw("POP " + post_assigner->get_address()); write_raw(""); }
void ConditionalBlock::generate_pre() { // generate condition if if (this->get_conditional_type() == COND_IF) { VarType result = this->generate_expr(this->get_symbol_list()); if (result != BOOLEAN) { report_error_lc("Semantic Error", "Conditional expression doesn't evaluate to boolean value.", (*this->get_symbol_list()->begin())->get_row(), (*this->get_symbol_list()->begin())->get_col()); } // true, jump to the body write_raw("\nBRTS " + this->body_label); if (this->connected != nullptr) { ConditionalBlockPtr extender = static_pointer_cast<ConditionalBlock>(this->connected); if (extender->get_conditional_type() == COND_ELSE) { // if there's an else part, jump on false to else write_raw("BR " + extender->else_label + "\n"); } } else { // beginning of if statement with no else write_raw("BR " + this->exit_label + "\n"); } // begin the if body part with a label write_raw(this->body_label + ":\n"); } }
// Activation block types (body and call) void ActivationBlock::generate_pre() { // do nothing at the moment if (this->activity == DEFINITION) { // write begin label write_raw(this->begin_label + ":\n"); // get locals string name = this->record->get_symbol_name(); SymbolListPtr named_items = this->get_analyzer()->get_symtable()->find(name); SymbolListPtr locals = SymTable::filter_nest_level(SymTable::filter_data(named_items), this->get_nesting_level()); // generate code to push them if (locals->size() > 0) { for (auto i = locals->begin(); i != locals->end(); i++) { if (static_pointer_cast<SymData>(*i)->get_var_type() == STRING) { write_raw("PUSH #\"\""); } else if (static_pointer_cast<SymData>(*i)->get_var_type() == FLOATING) { write_raw("PUSH #0.0"); } else { write_raw("PUSH #0"); } } } } else { // call if (this->activation == PROCEDURE) { } else if (this->activation == FUNCTION) { } } }
void write_raw(std::ostream& os, const std::string& s) { for (int i = 0; i < s.size(); ++i) { write_raw(os, s[i]); } write_raw(os, '\0'); }
void LoopBlock::generate_pre() { if (this->type == RPTUNTLLOOP) { write_raw(this->body_label + ":\n"); } else if (this->type == WHILELOOP) { write_raw(this->cond_label + ":\n"); VarType result = this->generate_expr(this->get_symbol_list()); if (result != BOOLEAN) { report_error_lc("Semantic Error", "Conditional expression doesn't evaluate to boolean value.", (*this->get_symbol_list()->begin())->get_row(), (*this->get_symbol_list()->begin())->get_col()); } write_raw("\nBRTS " + this->body_label); write_raw("BR " + this->exit_label); write_raw(this->body_label + ":\n"); } else if (this->type == FORLOOP) { // parse the assignment // process the assignment AssignmentBlockPtr assignment = AssignmentBlockPtr(new AssignmentBlock(false)); assignment->set_analyzer(this->get_analyzer()); for (auto i = 0; i < 3; i++) { assignment->catch_token((*this->get_unprocessed())[i]); } // generate its code assignment->preprocess(); assignment->generate_pre(); assignment->generate_post(); // generate the condition label write_raw(this->cond_label + ":\n"); // process the ordinal expression AssignmentBlockPtr ordinal_expr = AssignmentBlockPtr(new AssignmentBlock(true)); ordinal_expr->set_analyzer(this->get_analyzer()); for (unsigned int i = 4; i < this->get_unprocessed()->size(); i++) { ordinal_expr->catch_token((*this->get_unprocessed())[i]); } // get the comparison components for the ordinal expr TokenPtr incrementer = (*this->get_unprocessed())[3]; if (incrementer->get_token() == MP_TO) { ordinal_expr->catch_token(TokenPtr(new Token(MP_EQUALS, "=", -1, -1))); } else if (incrementer->get_token() == MP_DOWNTO) { ordinal_expr->catch_token(TokenPtr(new Token(MP_EQUALS, "=", -1, -1))); } ordinal_expr->catch_token((*this->get_unprocessed())[0]); if (incrementer->get_token() == MP_TO) { ordinal_expr->catch_token(TokenPtr(new Token (MP_MINUS, "-", -1, -1))); ordinal_expr->catch_token(TokenPtr(new Token (MP_INT_LITERAL, "1", -1, -1))); } else if (incrementer->get_token() == MP_DOWNTO) { ordinal_expr->catch_token(TokenPtr(new Token (MP_PLUS, "+", -1, -1))); ordinal_expr->catch_token(TokenPtr(new Token (MP_INT_LITERAL, "1", -1, -1))); } // generate its code ordinal_expr->preprocess(); ordinal_expr->generate_pre(); write_raw("\nBRFS " + this->body_label); write_raw("BR " + this->exit_label + "\n"); write_raw(this->body_label + ":\n"); } }
ssize_t write_meta_data(fs_context& fs) { /* * Copy erase block usage info and the content of the inode map * into one continuous buffer so that we can initiate one * cluster-aligned write request into the first erase block. */ size_t eb_usage_size = fs.neraseblocks * sizeof(eraseblock); memcpy(fs.buf, fs.eb_usage.data(), eb_usage_size); size_t ino_map_size = fs.nino * sizeof(uint32_t); memcpy(fs.buf + eb_usage_size, fs.ino_map.data(), ino_map_size); size_t meta_data_size = eb_usage_size + ino_map_size; uint64_t offset = fs.clustersize; ssize_t rc = write_raw(*fs.io_ctx, fs.buf, meta_data_size, offset); if (rc < 0) { log().error("writing meta data to first erase block failed"); return rc; } debug_update(fs, debug_metric::write_raw, static_cast<uint64_t>(rc)); return rc; }
void dump_frame(BIFSVID b2v, char *conv_buf, char *out_path, u32 dump_type, avi_t *avi_out, u32 frameNum) { u32 k; M4VideoSurface fb; /*lock it*/ SR_GetScreenBuffer(b2v.sr, &fb); /*export frame*/ switch (dump_type) { case 0: /*reverse frame*/ for (k=0; k<fb.height; k++) { memcpy(conv_buf + k*fb.width*3, fb.video_buffer + (fb.height-k-1) * fb.pitch, sizeof(char) * fb.width * 3); } if (AVI_write_frame(avi_out, conv_buf, fb.height*fb.width*3, 1) <0) printf("Error writing frame\n"); break; case 2: write_raw(&fb, out_path, frameNum); break; case 1: write_bmp(&fb, out_path, frameNum); break; } /*unlock it*/ SR_ReleaseScreenBuffer(b2v.sr, &fb); }
/* Consumes file name */ struct resource * make_pid_file_resource(struct lsh_string *file) { const char *cname = lsh_get_cstring(file); int fd; assert (cname); /* Try to open the file atomically. This provides sufficient locking * on normal (non-NFS) file systems. */ fd = open(cname, O_WRONLY | O_CREAT | O_EXCL, 0644); if (fd < 0) { if (errno != EEXIST) werror("Failed to open pid file '%S': %e.\n", file, errno); else /* FIXME: We could try to detect and ignore stale pid files. */ werror("Pid file '%S' already exists.\n", file); lsh_string_length(file); return NULL; } else { struct lsh_string *pid = ssh_format("%di", getpid()); if (!write_raw(fd, STRING_LD(pid))) { werror("Writing pidfile `%S' failed: %e\n", file, errno); /* Attempt unlinking file */ if (unlink(cname) < 0) werror("Unlinking pid file '%S' failed: %e.\n", file, errno); close(fd); lsh_string_free(pid); lsh_string_free(file); return NULL; } else { NEW(pid_file_resource, self); init_resource(&self->super, do_kill_pid_file); self->file = file; lsh_string_free(pid); close(fd); return &self->super; } } }
void OSD::write_S(uint8_t c){ if(c == 0xff){ row++; calc_pos(); } else write_raw(c); }
int process_socket(int sock,int inpipe) { fd_set fdset; /* selected file descriptors */ int poll,i; struct timeval tv; signal(SIGPIPE,SIG_IGN); signal(SIGUSR1,trap_reset); listen(sock,5); tv.tv_sec=0; tv.tv_usec=0; poll=0; runloop=1; do { FD_ZERO(&fdset); FD_SET(inpipe,&fdset); if (poll==0) { if (poll_sock(sock,NULL,&fdset) !=0) continue; } else poll_sock(sock,&tv,&fdset); /* open any new connections if possible */ open_sock(sock,&fdset); poll=0; /* check to see if the root server has sent any data */ if (FD_ISSET(inpipe,&fdset)) { int size; size=read(inpipe,mbuf,BUF_SIZE); if (size==0) break; write_raw(mbuf,size); } /* send the data to the clients */ if (write_sock() !=0) poll=1; /* read back any data from the clients */ read_sock(&fdset,tmpbuf,BUF_SIZE); /* decode the buffers here */ } while(runloop); /* close all the clients down */ for (i=0; i<msgmax; i++) { if (client[i].sock !=0) close(client[i].sock); } close(sock); return -1; }
static int write_string(write_iter_t *iter, const char *s) { int ret; size_t len = strlen(s); chk(write32(iter, len)); return write_raw(iter, s, len); }
static int write_gcov(write_iter_t *iter) { struct gcov_info *info; int ret; /* reset offset */ iter->write_offset = 0; /* dump all files */ for ( info = info_list ; info; info = info->next ) { const struct gcov_ctr_info *ctr; int type; size_t size_fn = sizeof(struct gcov_fn_info); align_iter(iter); chk(write32(iter, XENCOV_TAG_FILE)); chk(write32(iter, info->version)); chk(write32(iter, info->stamp)); chk(write_string(iter, info->filename)); /* dump counters */ ctr = info->counts; for ( type = -1; next_type(info, &type) < XENCOV_COUNTERS; ++ctr ) { align_iter(iter); chk(write32(iter, XENCOV_TAG_COUNTER(type))); chk(write32(iter, ctr->num)); chk(write_raw(iter, ctr->values, ctr->num * sizeof(ctr->values[0]))); size_fn += sizeof(unsigned); } /* dump all functions together */ align_iter(iter); chk(write32(iter, XENCOV_TAG_FUNC)); chk(write32(iter, info->n_functions)); chk(write_raw(iter, info->functions, info->n_functions * size_fn)); } /* stop tag */ align_iter(iter); chk(write32(iter, XENCOV_TAG_END)); return 0; }
int main(int argc, char **argv) // argv are the command-line arguments { char infname[512], outfname[512]; // file names for input and output unsigned char imagetypein, imagetypeout; IMAGE *data; IMAGE *target; if(argc<5) // too few command-line arguments? { printf("Command-line usage:\n"); printf(" %s (inf) (outf) (x) (y)\n",argv[0]); printf(" (inf) is the input file name\n"); printf(" (outf) is the output file name\n"); printf(" (x), (y) are the image dimensions\n"); exit(0); } // Allocate local memory for struct pointers data = malloc(sizeof(IMAGE)); // Handle Command Line args strcpy(infname,nextargs); // read input file name strcpy(outfname,nextargs); // read output file name data->xmax = nextargi; // Read image dimensions data->ymax = nextargi; //data->zmax = nextargi; data->zmax = 1; // params set image data types in and out imagetypein = UCHARIMAGE; imagetypeout = FLOATIMAGE; // Read Image into Mem printf("Reading image %s with dimensions %d, %d, %d\n",infname,data->xmax,data->ymax,data->zmax); if(read_raw(infname, data)){ printf("Error reading file\n"); exit (1); } // Set target params, Allocate local memory target = malloc(sizeof(IMAGE)); if(copyimage(target, data, imagetypeout)){ fprintf(stderr,"Could not Create Image: target\n"); exit(-1); } /* Image Processing calls here */ printf(" Converting Data Types...\n"); //switch case with command line parameters to specify data type conversions if(uchar2float(target, data)){ printf("Error Converting\n"); exit(3); } // Write Image to File printf("Writing processed image %s with dimensions %d, %d, %d\n",outfname,target->xmax,target->ymax,target->zmax); if(write_raw(outfname, target)){ printf("Error writing file\n"); exit (4); } // Free All Memory removeimage(data,imagetypein); removeimage(target,imagetypeout); printf("Program completed successfully\n"); exit (0); }
void t_log::write_report(const string &report, const string &func_name, t_log_class log_class, t_log_severity severity) { if (log_disabled) return; write_header(func_name, log_class, severity); write_raw(report); write_endl(); write_footer(); }
static int writer_raw(lua_State* L) { writer_t* writer = lua_touserdata(L, 1); size_t size; const char* str = lua_tolstring(L, 2, &size); if(str == NULL) luaL_error(L, "string expected"); write_raw(writer, (uint8_t*)str, size); return 0; }
// Program Block stuff void ProgramBlock::generate_pre() { // get the program id and set it as the open file TokenPtr p = *this->get_unprocessed()->begin(); // open a file to write to this->get_analyzer()->open_file(p->get_lexeme()); // generate program entry point write_raw("MOV SP D0"); // push begin symbols for (auto i = get_symbol_list()->begin(); i != get_symbol_list()->end(); i++) { if (static_pointer_cast<SymData>(*i)->get_var_type() == STRING) { write_raw("PUSH #\"\""); } else if (static_pointer_cast<SymData>(*i)->get_var_type() == FLOATING) { write_raw("PUSH #0.0"); } else { write_raw("PUSH #0"); } } write_raw(""); }
int DFInstanceLinux::write_string(const VIRTADDR &addr, const QString &str) { // Ensure this operation is done as one transaction attach(); VIRTADDR buffer_addr = get_string(str); if (buffer_addr) // This unavoidably leaks the old buffer; our own // cannot be deallocated anyway. write_raw(addr, sizeof(VIRTADDR), &buffer_addr); detach(); return buffer_addr ? str.length() : 0; }
// IO Block stuff void IOBlock::generate_pre() { if (this->action == IO_WRITE) { for (auto i = this->expressions->begin(); i != this->expressions->end(); i++) { SymbolListPtr postfixes = this->convert_postfix(*i); this->generate_expr(postfixes); write_raw("WRTS"); } } else if (this->action == IO_READ) { for (auto i = this->get_symbol_list()->begin(); i != this->get_symbol_list()->end(); i++) { if ((*i)->get_symbol_type() == SYM_DATA) { SymDataPtr p = static_pointer_cast<SymData>(*i); if (p->get_var_type() == INTEGER || p->get_var_type() == BOOLEAN) { write_raw("RD " + p->get_address()); } else if (p->get_var_type() == FLOATING) { write_raw("RDF " + p->get_address()); } else if (p->get_var_type() == STRING) { write_raw("RDS " + p->get_address()); } } else if ((*i)->get_symbol_type() == SYM_CONSTANT) { report_error_lc("Semantic Error", "Cannot read to a constant.", (*i)->get_row(), (*i)->get_col()); } } } if (this->line_terminator) { write_raw("PUSH #\"\""); write_raw("WRTLNS"); } }
int main(int argc, char **argv) // argv are the command-line arguments { char infname[512], outfname[512]; // file names for input and output IMAGE *data; IMAGE *target; if(argc<5) // too few command-line arguments? { printf("Command-line usage:\n"); printf(" %s (inf) (outf) (x) (y)\n",argv[0]); printf(" (inf) is the input file name\n"); printf(" (outf) is the output file name\n"); printf(" (x), (y) are the image dimensions\n"); //printf(" (x), (y), (z) are the image dimensions\n"); exit(0); } // Allocate local memory for struct pointers data = malloc(sizeof(IMAGE)); // Handle Command Line args strcpy(infname,nextargs); // read input file name strcpy(outfname,nextargs); // read output file name data->xmax = nextargi; // Read image dimensions data->ymax = nextargi; data->zmax = 1; //nextargi; // Read Image, Allocate Img mem printf("Reading image %s with dimensions %d, %d, %d\n",infname,data->xmax,data->ymax,data->zmax); if(read_raw(infname, data)){ printf("Error reading file\n"); exit (1); } // Set target params, Allocate local memory target = malloc(sizeof(IMAGE)); if(copyimage(target, data)){ fprintf(stderr,"Could not Create Image: target\n"); exit(-1); } /* Image Processing calls here */ printf(" Drawing AutoStereogram...\n"); if(heightmap(data)){ printf("Error Making Height Map\n"); exit(3); } if(DrawAutoStereogram(target, data)){ printf("Error Generating SIRDS\n"); exit(3); } // Write Image printf("Writing processed image %s with dimensions %d, %d, %d\n",outfname,target->xmax,target->ymax,target->zmax); if(write_raw(outfname, target)){ printf("Error writing file\n"); exit (4); } // Free All Memory removeimage(data); removeimage(target); printf("Program completed successfully\n"); exit (0); }
static int writer_stream(lua_State* L) { writer_t* writer = lua_touserdata(L, 1); if(lua_type(L, 2) != LUA_TSTRING) luaL_error(L, "string expected"); size_t size; const char* str = lua_tolstring(L, 2, &size); write_varint(writer, size); write_raw(writer, (uint8_t*)str, size); return 0; }
static gboolean msn_httpconn_poll(gpointer data) { MsnHttpConn *httpconn; char *header; char *auth; httpconn = data; g_return_val_if_fail(httpconn != NULL, FALSE); if ((httpconn->host == NULL) || (httpconn->full_session_id == NULL)) { /* There's no need to poll if the session is not fully established */ return TRUE; } if (httpconn->waiting_response) { /* There's no need to poll if we're already waiting for a response */ return TRUE; } auth = msn_httpconn_proxy_auth(httpconn); header = g_strdup_printf( "POST http://%s/gateway/gateway.dll?Action=poll&SessionID=%s HTTP/1.1\r\n" "Accept: */*\r\n" "Accept-Language: en-us\r\n" "User-Agent: MSMSGS\r\n" "Host: %s\r\n" "Proxy-Connection: Keep-Alive\r\n" "%s" /* Proxy auth */ "Connection: Keep-Alive\r\n" "Pragma: no-cache\r\n" "Content-Type: application/x-msn-messenger\r\n" "Content-Length: 0\r\n\r\n", httpconn->host, httpconn->full_session_id, httpconn->host, auth ? auth : ""); g_free(auth); if (write_raw(httpconn, header, strlen(header))) httpconn->waiting_response = TRUE; g_free(header); return TRUE; }
int main(int argc, char **argv) { int nr_opts; nr_opts = process_args(argc, argv); if (argc - nr_opts == 0) { /* no filename given -> invent one */ char my_hostname[100]; gethostname(my_hostname, 100); if (strlen(file_ext) == 0) strcpy(file_ext, STD_EXT); sprintf(filename, "%s.%s.%d%s", PROGNAME, my_hostname, (int)time(NULL), file_ext); } else { if (strlen(argv[nr_opts]) > FILENAME_LEN - strlen(RAW_EXT) - strlen(file_ext)) { fprintf(stderr, "Error: given filename too long\n"); exit(1); } strcpy(filename, argv[nr_opts]); strcat(filename, file_ext); } strcpy(raw_filename, filename); strcat(raw_filename, RAW_EXT); strcpy(fb_filename, filename); strcat(fb_filename, FB_EXT); if (!opt_process_raw_input_only) { get_fb(); if (opt_write_fb) write_fb(fb_mem, fb_size); convert_fb_to_raw(); INFO("Writing raw picture data to %s\n", raw_filename); write_raw(raw_pic_mem, raw_pic_size); } if (opt_convert) convert_raw_to_pic(filename, raw_filename, xres, yres); if (opt_delete_raw) if (unlink(raw_filename) == -1) perror(raw_filename); return 0; }
void LoopBlock::generate_post() { if (this->type == RPTUNTLLOOP) { write_raw(this->cond_label + ":\n"); VarType result = this->generate_expr(this->get_symbol_list()); if (result != BOOLEAN) { report_error_lc("Semantic Error", "Conditional expression doesn't evaluate to boolean value.", (*this->get_symbol_list()->begin())->get_row(), (*this->get_symbol_list()->begin())->get_col()); } write_raw("\nBRFS " + this->body_label); write_raw("BR " + this->exit_label + "\n"); write_raw(this->exit_label + ":\n"); } else if (this->type == WHILELOOP) { write_raw("BR " + this->cond_label); write_raw(this->exit_label + ":\n"); } else if (this->type == FORLOOP) { // get the incrementer token TokenPtr incrementer = (*this->get_unprocessed())[3]; if (incrementer->get_token() == MP_TO) { // generate an incrementer AssignmentBlockPtr inc = AssignmentBlockPtr(new AssignmentBlock(false)); inc->set_analyzer(this->get_analyzer()); inc->catch_token((*this->get_unprocessed())[0]); inc->catch_token((*this->get_unprocessed())[0]); inc->catch_token(TokenPtr(new Token(MP_PLUS, "+", -1, -1))); inc->catch_token(TokenPtr(new Token(MP_INT_LITERAL, "1", -1, -1))); inc->preprocess(); inc->generate_pre(); inc->generate_post(); } else if (incrementer->get_token() == MP_DOWNTO) { // generate a decrementer AssignmentBlockPtr dec = AssignmentBlockPtr(new AssignmentBlock(false)); dec->set_analyzer(this->get_analyzer()); dec->catch_token((*this->get_unprocessed())[0]); dec->catch_token((*this->get_unprocessed())[0]); dec->catch_token(TokenPtr(new Token(MP_MINUS, "-", -1, -1))); dec->catch_token(TokenPtr(new Token(MP_INT_LITERAL, "1", -1, -1))); dec->preprocess(); dec->generate_pre(); dec->generate_post(); } write_raw("BR " + this->cond_label + "\n"); write_raw(this->exit_label + ":\n"); } }
void ActivationBlock::generate_post() { if (this->activity == DEFINITION) { // get locals string name = this->record->get_symbol_name(); SymbolListPtr named_items = this->get_analyzer()->get_symtable()->find(name); SymbolListPtr locals = SymTable::filter_nest_level(SymTable::filter_data(named_items), this->get_nesting_level()); unsigned long locals_size = locals->size(); // move stack ptr minus local variables if (locals_size > 0) { write_raw("PUSH SP"); write_raw("PUSH #" + conv_string(locals_size)); write_raw("SUBS "); write_raw("POP SP"); } write_raw("RET\n"); } else { // call if (this->activation == PROCEDURE) { } else if (this->activation == FUNCTION) { } } }
/* Runs the filters on an input file */ static void test_file(const char *input_filename, const char *output_filename) { size_t frames; int i; double NQ = 44100 / 2; /* nyquist frequency */ struct timespec tp1, tp2; struct eq *eq; float *data = read_raw(input_filename, &frames); /* Set some data to 0 to test for denormals. */ for (i = frames / 10; i < frames; i++) data[i] = 0.0; /* Left eq chain */ eq = eq_new(); eq_append_biquad(eq, BQ_PEAKING, 380/NQ, 3, -10); eq_append_biquad(eq, BQ_PEAKING, 720/NQ, 3, -12); eq_append_biquad(eq, BQ_PEAKING, 1705/NQ, 3, -8); eq_append_biquad(eq, BQ_HIGHPASS, 218/NQ, 0.7, -10.2); eq_append_biquad(eq, BQ_PEAKING, 580/NQ, 6, -8); eq_append_biquad(eq, BQ_HIGHSHELF, 8000/NQ, 3, 2); clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tp1); process(eq, data, frames); clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tp2); printf("processing takes %g seconds for %zu samples\n", tp_diff(&tp2, &tp1), frames); eq_free(eq); /* Right eq chain */ eq = eq_new(); eq_append_biquad(eq, BQ_PEAKING, 450/NQ, 3, -12); eq_append_biquad(eq, BQ_PEAKING, 721/NQ, 3, -12); eq_append_biquad(eq, BQ_PEAKING, 1800/NQ, 8, -10.2); eq_append_biquad(eq, BQ_PEAKING, 580/NQ, 6, -8); eq_append_biquad(eq, BQ_HIGHPASS, 250/NQ, 0.6578, 0); eq_append_biquad(eq, BQ_HIGHSHELF, 8000/NQ, 0, 2); clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tp1); process(eq, data + frames, frames); clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tp2); printf("processing takes %g seconds for %zu samples\n", tp_diff(&tp2, &tp1), frames); eq_free(eq); write_raw(output_filename, data, frames); free(data); }
int main(int argc, char **argv) { struct lsh_decode_key_options *options = make_lsh_decode_key_options(); struct lsh_string *input; struct lsh_string *output; int out = STDOUT_FILENO; argp_parse(&main_argp, argc, argv, 0, NULL, options); if (options->file) { out = open(lsh_get_cstring(options->file), O_WRONLY | O_CREAT, 0666); if (out < 0) { werror("Failed to open file `%S' for writing: %e.\n", options->file, errno); return EXIT_FAILURE; } } input = io_read_file_raw(STDIN_FILENO, 3000); if (!input) { werror("Failed to read stdin: %e.\n", errno); return EXIT_FAILURE; } if (options->base64) { if (!lsh_string_base64_decode(input)) { werror("Invalid base64 encoding.\n"); lsh_string_free(input); return EXIT_FAILURE; } } output = lsh_decode_key(input); lsh_string_free(input); if (!output) { werror("Invalid ssh2 key.\n"); return EXIT_FAILURE; } if (!write_raw(out, STRING_LD(output))) { werror("Write failed: %e.\n", errno); return EXIT_FAILURE; } lsh_string_free(output); gc_final(); return EXIT_SUCCESS; }
void kiss_session::write(frame_ptr fp) { std::vector<unsigned char> kiss_data; kiss_encode(fp->get_data().data(), fp->get_data().size(), &kiss_data); write_raw(kiss_data.data(), kiss_data.size()); }
int main(int argc, char **argv) { char *rawfilename = NULL; int numiter = 250; int use_apc = 1; int use_normalization = 0; conjugrad_float_t lambda_single = F001; // 0.01 conjugrad_float_t lambda_pair = FInf; conjugrad_float_t lambda_pair_factor = F02; // 0.2 int conjugrad_k = 5; conjugrad_float_t conjugrad_eps = 0.01; parse_option *optList, *thisOpt; char *optstr; char *old_optstr = malloc(1); old_optstr[0] = 0; optstr = concat("r:i:n:w:k:e:l:ARh?", old_optstr); free(old_optstr); #ifdef OPENMP int numthreads = 1; old_optstr = optstr; optstr = concat("t:", optstr); free(old_optstr); #endif #ifdef CUDA int use_def_gpu = 0; old_optstr = optstr; optstr = concat("d:", optstr); free(old_optstr); #endif #ifdef MSGPACK char* msgpackfilename = NULL; old_optstr = optstr; optstr = concat("b:", optstr); free(old_optstr); #endif optList = parseopt(argc, argv, optstr); free(optstr); char* msafilename = NULL; char* matfilename = NULL; char* initfilename = NULL; conjugrad_float_t reweighting_threshold = F08; // 0.8 while(optList != NULL) { thisOpt = optList; optList = optList->next; switch(thisOpt->option) { #ifdef OPENMP case 't': numthreads = atoi(thisOpt->argument); #ifdef CUDA use_def_gpu = -1; // automatically disable GPU if number of threads specified #endif break; #endif #ifdef CUDA case 'd': use_def_gpu = atoi(thisOpt->argument); break; #endif #ifdef MSGPACK case 'b': msgpackfilename = thisOpt->argument; break; #endif case 'r': rawfilename = thisOpt->argument; break; case 'i': initfilename = thisOpt->argument; break; case 'n': numiter = atoi(thisOpt->argument); break; case 'w': reweighting_threshold = (conjugrad_float_t)atof(thisOpt->argument); break; case 'l': lambda_pair_factor = (conjugrad_float_t)atof(thisOpt->argument); break; case 'k': conjugrad_k = (int)atoi(thisOpt->argument); break; case 'e': conjugrad_eps = (conjugrad_float_t)atof(thisOpt->argument); break; case 'A': use_apc = 0; break; case 'R': use_normalization = 1; break; case 'h': case '?': usage(argv[0], 1); break; case 0: if(msafilename == NULL) { msafilename = thisOpt->argument; } else if(matfilename == NULL) { matfilename = thisOpt->argument; } else { usage(argv[0], 0); } break; default: die("Unknown argument"); } free(thisOpt); } if(msafilename == NULL || matfilename == NULL) { usage(argv[0], 0); } FILE *msafile = fopen(msafilename, "r"); if( msafile == NULL) { printf("Cannot open %s!\n\n", msafilename); return 2; } #ifdef JANSSON char* metafilename = malloc(2048); snprintf(metafilename, 2048, "%s.meta.json", msafilename); FILE *metafile = fopen(metafilename, "r"); json_t *meta; if(metafile == NULL) { // Cannot find .meta.json file - create new empty metadata meta = meta_create(); } else { // Load metadata from matfile.meta.json meta = meta_read_json(metafile); fclose(metafile); } json_object_set(meta, "method", json_string("ccmpred")); json_t *meta_step = meta_add_step(meta, "ccmpred"); json_object_set(meta_step, "version", json_string(__VERSION)); json_t *meta_parameters = json_object(); json_object_set(meta_step, "parameters", meta_parameters); json_t *meta_steps = json_array(); json_object_set(meta_step, "iterations", meta_steps); json_t *meta_results = json_object(); json_object_set(meta_step, "results", meta_results); #endif int ncol, nrow; unsigned char* msa = read_msa(msafile, &ncol, &nrow); fclose(msafile); int nsingle = ncol * (N_ALPHA - 1); int nvar = nsingle + ncol * ncol * N_ALPHA * N_ALPHA; int nsingle_padded = nsingle + N_ALPHA_PAD - (nsingle % N_ALPHA_PAD); int nvar_padded = nsingle_padded + ncol * ncol * N_ALPHA * N_ALPHA_PAD; #ifdef CURSES bool color = detect_colors(); #else bool color = false; #endif logo(color); #ifdef CUDA int num_devices, dev_ret; struct cudaDeviceProp prop; dev_ret = cudaGetDeviceCount(&num_devices); if(dev_ret != CUDA_SUCCESS) { num_devices = 0; } if(num_devices == 0) { printf("No CUDA devices available, "); use_def_gpu = -1; } else if (use_def_gpu < -1 || use_def_gpu >= num_devices) { printf("Error: %d is not a valid device number. Please choose a number between 0 and %d\n", use_def_gpu, num_devices - 1); exit(1); } else { printf("Found %d CUDA devices, ", num_devices); } if (use_def_gpu != -1) { cudaError_t err = cudaSetDevice(use_def_gpu); if(cudaSuccess != err) { printf("Error setting device: %d\n", err); exit(1); } cudaGetDeviceProperties(&prop, use_def_gpu); printf("using device #%d: %s\n", use_def_gpu, prop.name); size_t mem_free, mem_total; err = cudaMemGetInfo(&mem_free, &mem_total); if(cudaSuccess != err) { printf("Error getting memory info: %d\n", err); exit(1); } size_t mem_needed = nrow * ncol * 2 + // MSAs sizeof(conjugrad_float_t) * nrow * ncol * 2 + // PC, PCS sizeof(conjugrad_float_t) * nrow * ncol * N_ALPHA_PAD + // PCN sizeof(conjugrad_float_t) * nrow + // Weights (sizeof(conjugrad_float_t) * ((N_ALPHA - 1) * ncol + ncol * ncol * N_ALPHA * N_ALPHA_PAD)) * 4; setlocale(LC_NUMERIC, ""); printf("Total GPU RAM: %'17lu\n", mem_total); printf("Free GPU RAM: %'17lu\n", mem_free); printf("Needed GPU RAM: %'17lu ", mem_needed); if(mem_needed <= mem_free) { printf("✓\n"); } else { printf("⚠\n"); } #ifdef JANSSON json_object_set(meta_parameters, "device", json_string("gpu")); json_t* meta_gpu = json_object(); json_object_set(meta_parameters, "gpu_info", meta_gpu); json_object_set(meta_gpu, "name", json_string(prop.name)); json_object_set(meta_gpu, "mem_total", json_integer(mem_total)); json_object_set(meta_gpu, "mem_free", json_integer(mem_free)); json_object_set(meta_gpu, "mem_needed", json_integer(mem_needed)); #endif } else { printf("using CPU"); #ifdef JANSSON json_object_set(meta_parameters, "device", json_string("cpu")); #endif #ifdef OPENMP printf(" (%d thread(s))", numthreads); #ifdef JANSSON json_object_set(meta_parameters, "cpu_threads", json_integer(numthreads)); #endif #endif printf("\n"); } #else // CUDA printf("using CPU"); #ifdef JANSSON json_object_set(meta_parameters, "device", json_string("cpu")); #endif #ifdef OPENMP printf(" (%d thread(s))\n", numthreads); #ifdef JANSSON json_object_set(meta_parameters, "cpu_threads", json_integer(numthreads)); #endif #endif // OPENMP printf("\n"); #endif // CUDA conjugrad_float_t *x = conjugrad_malloc(nvar_padded); if( x == NULL) { die("ERROR: Not enough memory to allocate variables!"); } memset(x, 0, sizeof(conjugrad_float_t) * nvar_padded); // Auto-set lambda_pair if(isnan(lambda_pair)) { lambda_pair = lambda_pair_factor * (ncol - 1); } // fill up user data struct for passing to evaluate userdata *ud = (userdata *)malloc( sizeof(userdata) ); if(ud == 0) { die("Cannot allocate memory for user data!"); } ud->msa = msa; ud->ncol = ncol; ud->nrow = nrow; ud->nsingle = nsingle; ud->nvar = nvar; ud->lambda_single = lambda_single; ud->lambda_pair = lambda_pair; ud->weights = conjugrad_malloc(nrow); ud->reweighting_threshold = reweighting_threshold; if(initfilename == NULL) { // Initialize emissions to pwm init_bias(x, ud); } else { // Load potentials from file read_raw(initfilename, ud, x); } // optimize with default parameters conjugrad_parameter_t *param = conjugrad_init(); param->max_iterations = numiter; param->epsilon = conjugrad_eps; param->k = conjugrad_k; param->max_linesearch = 5; param->alpha_mul = F05; param->ftol = 1e-4; param->wolfe = F02; int (*init)(void *) = init_cpu; int (*destroy)(void *) = destroy_cpu; conjugrad_evaluate_t evaluate = evaluate_cpu; #ifdef OPENMP omp_set_num_threads(numthreads); if(numthreads > 1) { init = init_cpu_omp; destroy = destroy_cpu_omp; evaluate = evaluate_cpu_omp; } #endif #ifdef CUDA if(use_def_gpu != -1) { init = init_cuda; destroy = destroy_cuda; evaluate = evaluate_cuda; } #endif init(ud); #ifdef JANSSON json_object_set(meta_parameters, "reweighting_threshold", json_real(ud->reweighting_threshold)); json_object_set(meta_parameters, "apc", json_boolean(use_apc)); json_object_set(meta_parameters, "normalization", json_boolean(use_normalization)); json_t *meta_regularization = json_object(); json_object_set(meta_parameters, "regularization", meta_regularization); json_object_set(meta_regularization, "type", json_string("l2")); json_object_set(meta_regularization, "lambda_single", json_real(lambda_single)); json_object_set(meta_regularization, "lambda_pair", json_real(lambda_pair)); json_object_set(meta_regularization, "lambda_pair_factor", json_real(lambda_pair_factor)); json_t *meta_opt = json_object(); json_object_set(meta_parameters, "optimization", meta_opt); json_object_set(meta_opt, "method", json_string("libconjugrad")); json_object_set(meta_opt, "float_bits", json_integer((int)sizeof(conjugrad_float_t) * 8)); json_object_set(meta_opt, "max_iterations", json_integer(param->max_iterations)); json_object_set(meta_opt, "max_linesearch", json_integer(param->max_linesearch)); json_object_set(meta_opt, "alpha_mul", json_real(param->alpha_mul)); json_object_set(meta_opt, "ftol", json_real(param->ftol)); json_object_set(meta_opt, "wolfe", json_real(param->wolfe)); json_t *meta_msafile = meta_file_from_path(msafilename); json_object_set(meta_parameters, "msafile", meta_msafile); json_object_set(meta_msafile, "ncol", json_integer(ncol)); json_object_set(meta_msafile, "nrow", json_integer(nrow)); if(initfilename != NULL) { json_t *meta_initfile = meta_file_from_path(initfilename); json_object_set(meta_parameters, "initfile", meta_initfile); json_object_set(meta_initfile, "ncol", json_integer(ncol)); json_object_set(meta_initfile, "nrow", json_integer(nrow)); } double neff = 0; for(int i = 0; i < nrow; i++) { neff += ud->weights[i]; } json_object_set(meta_msafile, "neff", json_real(neff)); ud->meta_steps = meta_steps; #endif printf("\nWill optimize %d %ld-bit variables\n\n", nvar, sizeof(conjugrad_float_t) * 8); if(color) { printf("\x1b[1m"); } printf("iter\teval\tf(x) \t║x║ \t║g║ \tstep\n"); if(color) { printf("\x1b[0m"); } conjugrad_float_t fx; int ret; #ifdef CUDA if(use_def_gpu != -1) { conjugrad_float_t *d_x; cudaError_t err = cudaMalloc((void **) &d_x, sizeof(conjugrad_float_t) * nvar_padded); if (cudaSuccess != err) { printf("CUDA error No. %d while allocation memory for d_x\n", err); exit(1); } err = cudaMemcpy(d_x, x, sizeof(conjugrad_float_t) * nvar_padded, cudaMemcpyHostToDevice); if (cudaSuccess != err) { printf("CUDA error No. %d while copying parameters to GPU\n", err); exit(1); } ret = conjugrad_gpu(nvar_padded, d_x, &fx, evaluate, progress, ud, param); err = cudaMemcpy(x, d_x, sizeof(conjugrad_float_t) * nvar_padded, cudaMemcpyDeviceToHost); if (cudaSuccess != err) { printf("CUDA error No. %d while copying parameters back to CPU\n", err); exit(1); } err = cudaFree(d_x); if (cudaSuccess != err) { printf("CUDA error No. %d while freeing memory for d_x\n", err); exit(1); } } else { ret = conjugrad(nvar_padded, x, &fx, evaluate, progress, ud, param); } #else ret = conjugrad(nvar_padded, x, &fx, evaluate, progress, ud, param); #endif printf("\n"); printf("%s with status code %d - ", (ret < 0 ? "Exit" : "Done"), ret); if(ret == CONJUGRAD_SUCCESS) { printf("Success!\n"); } else if(ret == CONJUGRAD_ALREADY_MINIMIZED) { printf("Already minimized!\n"); } else if(ret == CONJUGRADERR_MAXIMUMITERATION) { printf("Maximum number of iterations reached.\n"); } else { printf("Unknown status code!\n"); } printf("\nFinal fx = %f\n\n", fx); FILE* out = fopen(matfilename, "w"); if(out == NULL) { printf("Cannot open %s for writing!\n\n", matfilename); return 3; } conjugrad_float_t *outmat = conjugrad_malloc(ncol * ncol); FILE *rawfile = NULL; if(rawfilename != NULL) { printf("Writing raw output to %s\n", rawfilename); rawfile = fopen(rawfilename, "w"); if(rawfile == NULL) { printf("Cannot open %s for writing!\n\n", rawfilename); return 4; } write_raw(rawfile, x, ncol); } #ifdef MSGPACK FILE *msgpackfile = NULL; if(msgpackfilename != NULL) { printf("Writing msgpack raw output to %s\n", msgpackfilename); msgpackfile = fopen(msgpackfilename, "w"); if(msgpackfile == NULL) { printf("Cannot open %s for writing!\n\n", msgpackfilename); return 4; } #ifndef JANSSON void *meta = NULL; #endif } #endif sum_submatrices(x, outmat, ncol); if(use_apc) { apc(outmat, ncol); } if(use_normalization) { normalize(outmat, ncol); } write_matrix(out, outmat, ncol, ncol); #ifdef JANSSON json_object_set(meta_results, "fx_final", json_real(fx)); json_object_set(meta_results, "num_iterations", json_integer(json_array_size(meta_steps))); json_object_set(meta_results, "opt_code", json_integer(ret)); json_t *meta_matfile = meta_file_from_path(matfilename); json_object_set(meta_results, "matfile", meta_matfile); if(rawfilename != NULL) { json_object_set(meta_results, "rawfile", meta_file_from_path(rawfilename)); } if(msgpackfilename != NULL) { json_object_set(meta_results, "msgpackfile", meta_file_from_path(msgpackfilename)); } fprintf(out, "#>META> %s", json_dumps(meta, JSON_COMPACT)); if(rawfile != NULL) { fprintf(rawfile, "#>META> %s", json_dumps(meta, JSON_COMPACT)); } #endif if(rawfile != NULL) { fclose(rawfile); } #ifdef MSGPACK if(msgpackfile != NULL) { write_raw_msgpack(msgpackfile, x, ncol, meta); fclose(msgpackfile); } #endif fflush(out); fclose(out); destroy(ud); conjugrad_free(outmat); conjugrad_free(x); conjugrad_free(ud->weights); free(ud); free(msa); free(param); printf("Output can be found in %s\n", matfilename); return 0; }