kv_vidctx_t * kv_vidctx_init(const char *rootdir, kv_emit_f emit, const char *dbgdir, kv_flags_t flags) { kv_vidctx_t *kvp; if (kv_init(rootdir) != 0) { warnx("failed to initialize masks"); return (NULL); } if ((kvp = calloc(1, sizeof (*kvp))) == NULL) { warn("calloc"); return (NULL); } kvp->kv_last_start = -1; kvp->kv_emit = emit; kvp->kv_flags = flags; if (dbgdir != NULL) (void) strlcpy(kvp->kv_dbgdir, dbgdir, sizeof (kvp->kv_dbgdir)); return (kvp); }
void test_forest_serialization() { test_header(); ET_problem prob; ET_params params; ET_forest *forest, *forest2; uchar_vec buffer; unsigned char *mobile_buffer; float vector[] = {3, 1, 1, 6, 6, 2}; kv_init(buffer); problem_init(&prob, big_vectors, big_labels); EXTRA_TREE_DEFAULT_REGR_PARAMS(prob, params); params.number_of_trees = 100; params.number_of_features_tested = 1; params.select_features_with_replacement = true; forest = ET_forest_build(&prob, ¶ms); ET_forest_dump(forest, &buffer, true); fprintf(stderr, "forest dump: %zu bytes\n", kv_size(buffer)); mobile_buffer = buffer.a; forest2 = ET_forest_load(&mobile_buffer); forest2->params = forest->params; // FIXME fprintf(stderr, "orig forest pred: %g\n", ET_forest_predict(forest, vector)); fprintf(stderr, "cloned forest pred: %g\n", ET_forest_predict(forest2, vector)); kv_destroy(buffer); ET_forest_destroy(forest); ET_forest_destroy(forest2); free(forest); free(forest2); }
static int cmd_starts(int argc, char *argv[]) { video_t *vp; int rv, last; if (kv_init(dirname((char *)kv_arg0)) != 0) { warnx("failed to initialize masks"); return (EXIT_FAILURE); } if (argc < 1) { warnx("missing input file"); return (EXIT_USAGE); } if ((vp = video_open(argv[0])) == NULL) return (EXIT_FAILURE); last = 0; rv = video_iter_frames(vp, check_start_frame, &last); video_free(vp); return (rv); }
strings_v shape_load_names(const char* filename, const char* colname) { DBFHandle hDBF; strings_v col; kv_init(col); hDBF = DBFOpen( filename, "rb" ); if( hDBF == NULL ) { fprintf(stderr, "DBFOpen(%s,\"r\") failed.\n", filename ); return col; } uint32_t fid = DBFGetFieldIndex(hDBF, colname); for(uint32_t i = 0; i < DBFGetRecordCount(hDBF); i++ ) { char* str = (char *) DBFReadStringAttribute(hDBF, i, fid); if(str != NULL) kv_push(char*, col, strdup(str)); else kv_push(char*, col, NULL); } DBFClose( hDBF ); return col; }
int main(){ void * kv_obj = kv_init(":memory:"); test(kv_obj); return 0; }
int do_grep() { #ifdef DEBUGa printf("[!]do_grep\n"); #endif BamInfo_t *pbam; kh_cstr_t BamID; khiter_t ki, bami; kstring_t ks1 = { 0, 0, NULL }; kstring_t ks2 = { 0, 0, NULL }; kstring_t ks3 = { 0, 0, NULL }; samFile *in; bam_hdr_t *h; hts_idx_t *idx; bam1_t *b, *d, *d2, *bR1, *bR2, *bR3; bR1 = bam_init1(); bR2 = bam_init1(); bR3 = bam_init1(); //htsFile *out; //hts_opt *in_opts = NULL, *out_opts = NULL; int r = 0, exit_code = 0; kvec_t(bam1_t) R1, R2, RV; pierCluster_t *pierCluster; //samdat_t tmp_samdat; FILE *fs = fopen("./test.txt","w"); for (bami = kh_begin(bamNFOp); bami != kh_end(bamNFOp); ++bami) { //printf(">[%d]:\n",bami); if (kh_exist(bamNFOp, bami)) { kv_init(R1); kv_init(R2); kv_init(RV); //tmp_samdat = (const samdat_t){ 0 }; //memset(&tmp_samdat,0,sizeof(samdat_t)); //printf("-[%d]:\n",bami); BamID = kh_key(bamNFOp, bami); pbam = &kh_value(bamNFOp, bami); fprintf(stderr, "%u [%s]=%s\t%u %u\n",bami,BamID,pbam->fileName,pbam->insertSize,pbam->SD); in = sam_open(pbam->fileName, "r"); if (in == NULL) { fprintf(stderr, "[x]Error opening \"%s\"\n", pbam->fileName); return EXIT_FAILURE; } h = sam_hdr_read(in); /* out = hts_open("-", "w"); if (out == NULL) { fprintf(stderr, "[x]Error opening standard output\n"); return EXIT_FAILURE; } if (sam_hdr_write(out, h) < 0) { fprintf(stderr, "[!]Error writing output header.\n"); exit_code = 1; } */ int8_t *ChrIsHum; if (h == NULL) { fprintf(stderr, "[x]Couldn't read header for \"%s\"\n", pbam->fileName); return EXIT_FAILURE; } else { ChrIsHum = malloc(h->n_targets * sizeof(int8_t)); for (int32_t i=0; i < h->n_targets; ++i) { //ChrIsHum[i] = -1; ki = kh_get(chrNFO, chrNFOp, h->target_name[i]); if (ki == kh_end(chrNFOp)) { errx(4,"[x]Cannot find ChrID for [%s] !",h->target_name[i]); } else { ChrInfo_t * tmp = &kh_value(chrNFOp, ki); ChrIsHum[i] = tmp->isHum; //printf(">>> %d Chr:%s %d\n",i,h->target_name[i],ChrIsHum[i]); } } } h->ignore_sam_err = 0; b = bam_init1(); d = bam_init1(); d2 = bam_init1(); if ((idx = sam_index_load(in, pbam->fileName)) == 0) { fprintf(stderr, "[E::%s] fail to load the BAM index\n", __func__); return 1; } pierCluster = sam_plp_init(); while ((r = sam_read1(in, h, b)) >= 0) { int8_t flag = false; const bam1_core_t *c = &b->core; if (c->flag & BAM_FSECONDARY) continue; if (c->n_cigar) { uint32_t *cigar = bam_get_cigar(b); for (int i = 0; i < c->n_cigar; ++i) { if (bam_cigar_opchr(cigar[i])=='S') { // soft clipping if ( bam_cigar_oplen(cigar[i]) >= myConfig.minGrepSlen ) { flag = true; } } } } if (flag && ChrIsHum[c->tid]) { // Now, skip Virus items. //bam_copy1(bR1, b); flag = 0; // recycle //int enoughMapQ = 0; //kstring_t ks = { 0, 0, NULL }; /*if (sam_format1(h, b, &ks1) < 0) { fprintf(stderr, "Error writing output.\n"); exit_code = 1; break; } else*/ if ((c->mtid == c->tid && ChrIsHum[c->tid]) || (ChrIsHum[c->tid] ^ ChrIsHum[c->mtid])) { // Only grep those mapped on same Human ChrID, or diff species/一方在病毒的情况. //printf(">[%s]\n",ks_str(&ks1)); flag |= 1; //tmp_samdat.b = bam_dup1(b); //kv_push(samdat_t,R1,tmp_samdat); /*if (checkMapQ(ChrIsHum, b, true)) { ++enoughMapQ; }*/ } if (getPairedSam(in, idx, b, d) != 0) { flag &= ~1; continue; } else { flag |= 2; /*if (checkMapQ(ChrIsHum, d, false)) { ++enoughMapQ; }*/ /*if (c->flag & BAM_FSECONDARY) { if (getPairedSam(in, idx, d, d2) == 0) { //sam_format1(h, d2, &ks3); flag |= 4; if (checkMapQ(ChrIsHum, d2, false)) { ++enoughMapQ; } } }*/ } /* 对于 BAM_FSECONDARY(256) 的 Read,跳两次 与 读 SA 项,效果一样。 >[sf95_Ref_48245009_48245108_48245208_Vir_-_2000_2044_R_100_90 353 chr2 13996555 0 50S40M chr18 48245109 0ACACAACAATGTTCCGGAGACTCTAAGGCCTCCCGATACAGAGCAGAGGCCACACACACACACACCATGGAATACTATTCAGCCAAAAAA CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC NM:i:0 MD:Z:40 AS:i:40 XS:i:40 RG:Z:Fsimout_mB SA:Z:rgi|59585|emb|X04615.1|,2000,-,40S46M4S,60,0; YC:Z:CT YD:Z:f] -[sf95_Ref_48245009_48245108_48245208_Vir_-_2000_2044_R_100_90 177 chr18 48245109 9 40S50M gi|59585|emb|X04615.1|2000 0 GTTCCGGAGACTCTAAGGCCTCCCGATACAGAGCAGAGGCCACACACACACACACCATGGAATACTATTCAGCCAAAAAAAGGAATTCAA CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC NM:i:0 MD:Z:50 AS:i:50 XS:i:46 RG:Z:Fsimout_mB SA:Z:rgi|59585|emb|X04615.1|,2000,+,50S40M,9,0; YC:Z:GA YD:Z:f] +[sf95_Ref_48245009_48245108_48245208_Vir_-_2000_2044_R_100_90 113 gi|59585|emb|X04615.1| 2000 60 40S46M4S chr18 48245109 0 TTTTTTGGCTGAATAGTATTCCATGGTGTGTGTGTGTGTGGCCTCTGCTCTGTATCGGGAGGCCTTAGAGTCTCCGGAACATTGTTGTGT CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC NM:i:0 MD:Z:46 AS:i:46 XS:i:27 RG:Z:Fsimout_mB SA:Z:fchr2,13996555,+,50S40M,0,0; YC:Z:CT YD:Z:r] */ /*if (sam_format1(h, d, &ks2) < 0) { fprintf(stderr, "Error writing output.\n"); exit_code = 1; break; }*/ if (((flag & 3) == 3) /*&& enoughMapQ >= myConfig.samples*/) { /*printf(">%d[%s]\n",checkMapQ(ChrIsHum, b, true),ks_str(&ks1)); printf("-%d[%s]\n",checkMapQ(ChrIsHum, d, false),ks_str(&ks2)); if (flag & 4) { printf("+%d[%s]\n",checkMapQ(ChrIsHum, d2, false),ks_str(&ks3)); } printf("<--%d\n",enoughMapQ);*/ if (sam_plp_push(ChrIsHum, pierCluster, b) == 0) { //printf("--HumRange=%s:%d-%d\n", h->target_name[(pierCluster->HumanRange).tid], (pierCluster->HumanRange).pos, (pierCluster->HumanRange).endpos); if ((!ChrIsHum[(d->core).tid]) && (flag & 2)) sam_plp_push(ChrIsHum, pierCluster, d); //if ((!ChrIsHum[(d2->core).tid]) && (flag & 4)) sam_plp_push(ChrIsHum, pierCluster, d2); } else { //print fprintf(fs,"[%s]\nHumRange=%s:%d-%d\n", BamID, h->target_name[(pierCluster->HumanRange).tid], (pierCluster->HumanRange).pos, (pierCluster->HumanRange).endpos); fprintf(fs,"VirRange=%s:%d-%d\n", h->target_name[(pierCluster->VirusRange).tid], (pierCluster->VirusRange).pos, (pierCluster->VirusRange).endpos); for (size_t i=0; i<kv_size(pierCluster->Reads);++i) { bam1_t *bi = kv_A(pierCluster->Reads, i); if (sam_format1(h, bi, &ks1) < 0) { fprintf(stderr, "Error writing output.\n"); exit_code = 1; break; } else { fprintf(fs,"%s\n",ks1.s); } } fprintf(fs,"\n"); //printf("HumRange=%s:%d-%d\n", h->target_name[(pierCluster->HumanRange).tid], (pierCluster->HumanRange).pos, (pierCluster->HumanRange).endpos); //fflush(fs); sam_plp_dectroy(pierCluster); pierCluster = sam_plp_init(); } } } /*char *qname = bam_get_qname(b); if (sam_write1(out, h, b) < 0) { fprintf(stderr, "[x]Error writing output.\n"); exit_code = 1; break; }*/ } /* r = sam_close(out); // stdout can only be closed once if (r < 0) { fprintf(stderr, "Error closing output.\n"); exit_code = 1; } */ hts_idx_destroy(idx); bam_destroy1(b); bam_destroy1(d); bam_destroy1(d2); bam_hdr_destroy(h); r = sam_close(in); free(ChrIsHum); #ifdef DEBUGa fflush(NULL); //pressAnyKey(); #endif sam_plp_dectroy(pierCluster); //printf("<[%d]:\n",bami); } } fclose(fs); getPairedSam(NULL, NULL, NULL, NULL); // sam_close(fp2); //printf("---[%d]---\n",exit_code); bam_destroy1(bR1); bam_destroy1(bR2); bam_destroy1(bR3); ks_release(&ks1); ks_release(&ks2); ks_release(&ks3); return exit_code; }
/* * 函 数:libkv_init * 功 能:初始化libkv库 * 参 数: * 功 能: * 返回值: */ void libkv_init() { assert(kv_init(NULL) == ERR_NONE); }
int exec_which(int argc, char **argv) { struct pkgdb *db = NULL; struct pkgdb_it *it = NULL; struct pkg *pkg = NULL; char pathabs[MAXPATHLEN]; char *p, *path, *match, *savedpath; int ret = EPKG_OK, retcode = EX_SOFTWARE; int ch, i; int res, pathlen = 0; bool orig = false; bool glob = false; bool search = false; bool search_s = false; charlist patterns; struct option longopts[] = { { "glob", no_argument, NULL, 'g' }, { "origin", no_argument, NULL, 'o' }, { "path-search", no_argument, NULL, 'p' }, { "quiet", no_argument, NULL, 'q' }, { NULL, 0, NULL, 0 }, }; path = NULL; while ((ch = getopt_long(argc, argv, "+gopq", longopts, NULL)) != -1) { switch (ch) { case 'g': glob = true; break; case 'o': orig = true; break; case 'p': search_s = true; break; case 'q': quiet = true; break; default: usage_which(); return (EX_USAGE); } } argc -= optind; argv += optind; if (argc < 1) { usage_which(); return (EX_USAGE); } if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) { return (EX_IOERR); } if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) { pkgdb_close(db); warnx("Cannot get a read lock on a database, it is locked by another process"); return (EX_TEMPFAIL); } if (search_s) { if ((path = getenv("PATH")) == NULL) { printf("$PATH is not set, falling back to non-search behaviour\n"); search_s = false; } else { pathlen = strlen(path) + 1; } } while (argc >= 1) { kv_init(patterns); retcode = EX_SOFTWARE; if (search_s) { if ((argv[0][0] == '.') || (argv[0][0] == '/')) { search = false; } else { search = true; if (strlen(argv[0]) >= FILENAME_MAX) { retcode = EX_USAGE; goto cleanup; } p = malloc(pathlen); if (p == NULL) { retcode = EX_OSERR; goto cleanup; } strlcpy(p, path, pathlen); match = NULL; savedpath=p; for (;;) { res = get_match(&match, &p, argv[0]); if (p == NULL) break; if (res == (EX_USAGE)) { printf("%s was not found in PATH, falling back to non-search behaviour\n", argv[0]); search = false; } else if (res == (EX_OSERR)) { retcode = EX_OSERR; free(savedpath); goto cleanup; } else { pkg_absolutepath(match, pathabs, sizeof(pathabs)); /* ensure not not append twice an entry if PATH is messy */ if (already_in_list(&patterns, pathabs)) continue; kv_push(char *, patterns, strdup(pathabs)); free(match); } } free(savedpath); } } if (!glob && !search) { pkg_absolutepath(argv[0], pathabs, sizeof(pathabs)); kv_push(char *, patterns, strdup(pathabs)); } else if (!search) { if (strlcpy(pathabs, argv[0], sizeof(pathabs)) >= sizeof(pathabs)) { retcode = EX_USAGE; goto cleanup; } } for (i = 0; i < kv_size(patterns); i++) { if ((it = pkgdb_query_which(db, kv_A(patterns, i), glob)) == NULL) { retcode = EX_IOERR; goto cleanup; } pkg = NULL; while ((ret = pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC)) == EPKG_OK) { retcode = EX_OK; if (quiet && orig) pkg_printf("%o\n", pkg); else if (quiet && !orig) pkg_printf("%n-%v\n", pkg, pkg); else if (!quiet && orig) pkg_printf("%S was installed by package %o\n", kv_A(patterns, i), pkg); else if (!quiet && !orig) pkg_printf("%S was installed by package %n-%v\n", kv_A(patterns, i), pkg, pkg); } if (retcode != EX_OK && !quiet) printf("%s was not found in the database\n", kv_A(patterns, i)); pkg_free(pkg); pkgdb_it_free(it); } kv_destroy(patterns); argc--; argv++; } cleanup: pkgdb_release_lock(db, PKGDB_LOCK_READONLY); pkgdb_close(db); return (retcode); }
shapes_v* shapes_new() { shapes_v* shapes = calloc(1,sizeof(shapes_v)); kv_init(*shapes); return shapes; }
int exec_clean(int argc, char **argv) { struct pkgdb *db = NULL; kh_sum_t *sumlist = NULL; dl_list dl; const char *cachedir; bool all = false; int retcode; int ch; int cachefd = -1; size_t total = 0; char size[8]; char *cksum; struct pkg_manifest_key *keys = NULL; #ifdef HAVE_CAPSICUM cap_rights_t rights; #endif struct option longopts[] = { { "all", no_argument, NULL, 'a' }, { "dry-run", no_argument, NULL, 'n' }, { "quiet", no_argument, NULL, 'q' }, { "yes", no_argument, NULL, 'y' }, { NULL, 0, NULL, 0 }, }; while ((ch = getopt_long(argc, argv, "+anqy", longopts, NULL)) != -1) { switch (ch) { case 'a': all = true; break; case 'n': dry_run = true; break; case 'q': quiet = true; break; case 'y': yes = true; break; default: usage_clean(); return (EX_USAGE); } } argc -= optind; argv += optind; cachedir = pkg_object_string(pkg_config_get("PKG_CACHEDIR")); cachefd = open(cachedir, O_DIRECTORY); if (cachefd == -1) { warn("Impossible to open %s", cachedir); return (EX_IOERR); } retcode = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_REPO); if (retcode == EPKG_ENOACCESS) { warnx("Insufficient privileges to clean old packages"); close(cachefd); return (EX_NOPERM); } else if (retcode == EPKG_ENODB) { warnx("No package database installed. Nothing to do!"); close(cachefd); return (EX_OK); } else if (retcode != EPKG_OK) { warnx("Error accessing the package database"); close(cachefd); return (EX_SOFTWARE); } retcode = EX_SOFTWARE; if (pkgdb_open(&db, PKGDB_REMOTE) != EPKG_OK) { close(cachefd); return (EX_IOERR); } if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) { pkgdb_close(db); close(cachefd); warnx("Cannot get a read lock on a database, it is locked by " "another process"); return (EX_TEMPFAIL); } #ifdef HAVE_CAPSICUM cap_rights_init(&rights, CAP_READ, CAP_LOOKUP, CAP_FSTATFS, CAP_FSTAT, CAP_UNLINKAT); if (cap_rights_limit(cachefd, &rights) < 0 && errno != ENOSYS ) { warn("cap_rights_limit() failed"); close(cachefd); return (EX_SOFTWARE); } if (cap_enter() < 0 && errno != ENOSYS) { warn("cap_enter() failed"); close(cachefd); return (EX_SOFTWARE); } #endif kv_init(dl); /* Build the list of out-of-date or obsolete packages */ pkg_manifest_keys_new(&keys); recursive_analysis(cachefd, db, cachedir, cachedir, &dl, &sumlist, all, &total); if (sumlist != NULL) { kh_foreach_value(sumlist, cksum, free(cksum)); kh_destroy_sum(sumlist); } if (kv_size(dl) == 0) { if (!quiet) printf("Nothing to do.\n"); retcode = EX_OK; goto cleanup; } humanize_number(size, sizeof(size), total, "B", HN_AUTOSCALE, HN_IEC_PREFIXES); if (!quiet) printf("The cleanup will free %s\n", size); if (!dry_run) { if (query_yesno(false, "\nProceed with cleaning the cache? ")) { retcode = delete_dellist(cachefd, cachedir, &dl, kv_size(dl)); } } else { retcode = EX_OK; } cleanup: pkgdb_release_lock(db, PKGDB_LOCK_READONLY); pkgdb_close(db); pkg_manifest_keys_free(keys); free_dellist(&dl); if (cachefd != -1) close(cachefd); return (retcode); }
static aln_v align_read(const kseq_t *read, const kseq_v targets, const align_config_t *conf) { kseq_t *r; const int32_t read_len = read->seq.l; aln_v result; kv_init(result); kv_resize(aln_t, result, kv_size(targets)); uint8_t *read_num = calloc(read_len, sizeof(uint8_t)); for(size_t k = 0; k < read_len; ++k) read_num[k] = conf->table[(int)read->seq.s[k]]; // Align to each target kswq_t *qry = NULL; for(size_t j = 0; j < kv_size(targets); j++) { // Encode target r = &kv_A(targets, j); uint8_t *ref_num = calloc(r->seq.l, sizeof(uint8_t)); for(size_t k = 0; k < r->seq.l; ++k) ref_num[k] = conf->table[(int)r->seq.s[k]]; aln_t aln; aln.target_idx = j; aln.loc = ksw_align(read_len, read_num, r->seq.l, ref_num, conf->m, conf->mat, conf->gap_o, conf->gap_e, KSW_XSTART, &qry); ksw_global(aln.loc.qe - aln.loc.qb + 1, &read_num[aln.loc.qb], aln.loc.te - aln.loc.tb + 1, &ref_num[aln.loc.tb], conf->m, conf->mat, conf->gap_o, conf->gap_e, 50, /* TODO: Magic number - band width */ &aln.n_cigar, &aln.cigar); aln.nm = 0; size_t qi = aln.loc.qb, ri = aln.loc.tb; for(size_t k = 0; k < aln.n_cigar; k++) { const int32_t oplen = bam_cigar_oplen(aln.cigar[k]), optype = bam_cigar_type(aln.cigar[k]); if(optype & 3) { // consumes both - check for mismatches for(size_t j = 0; j < oplen; j++) { if(UNLIKELY(read_num[qi + j] != ref_num[ri + j])) aln.nm++; } } else { aln.nm += oplen; } if(optype & 1) qi += oplen; if(optype & 2) ri += oplen; } kv_push(aln_t, result, aln); free(ref_num); } free(qry); free(read_num); ks_introsort(dec_score, kv_size(result), result.a); return result; }
void sys_init(void) { #if 0 uart_init(); deg_str("AC309N-C\n"); #endif core_power_on(); OTP_CLK_DIV2(); DECODER_DIV2(); sys_clk_div(4);//SYSTEM_CLK_DIV4(); set_vol_tab_ptr(analog_vol_tab, digital_vol_tab); #if (NO_DISP != monitor) init_display(); #endif sd_speed_init(0,100); //#if SDMMC_CMD_MODE // sd_chk_ctl(SET_SD_H_CHK); //#endif init_port_sd(); kv_init(); ///按键音初始化函数 #if RTC_ENABLE if (rtc_init()) //RTC初始化,检测是否闹钟开机 { work_mode = RTC_MODE; } #else { u8 rtc_reg = read_rtc_reg(); if (rtc_reg & BIT(7)) //检测是否掉电 { rtc_reg &= ~(BIT(7)); //清零PDFLAG write_rtc_reg(rtc_reg); #if USE_RTC_RAM #if RTC_ENABLE reset_rtc_ram(); #else { u8 i; for (i = 0; i < 64; i++) { write_rtc_ram(i, 0); } } #endif ///<RTC_ENABLE #endif ///<USE_RTC_RAM } } #endif key_init(); bsp_init(); #if ECHO_ENABLE dec_analog_vol_sel(1); echo_ptr = (REVERB_CTL _xdata *)get_echo_var_ptr(1); encode_msg = (ENCODE_MSG _xdata *)get_encode_msg_ptr(); app_echo.strong = 150; app_echo.deep = 40; #else dec_analog_vol_sel(0); get_echo_var_ptr(0);///<传参0,不适用混响功能 #endif interrupt_init(15, rtcisr); interrupt_init(3, timer3isr); interrupt_init(0, timer0isr); enable_interrupt(); }
void case_cmd_lrange_found() { answer_t *ans; answer_iter_t *iter; answer_value_t *value; CU_ASSERT(kv_init(NULL) == ERR_NONE); ans = kv_ask("lpush mylist a b c", strlen("lpush mylist a b c")); CU_ASSERT(ans->errnum == ERR_NONE); answer_release(ans); ans = kv_ask("lrange mylist 0 0", strlen("lrange mylist 0 0")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); iter = answer_get_iter(ans, ANSWER_HEAD); value = answer_next(iter); CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "c"); CU_ASSERT_PTR_EQUAL(answer_value_to_string(answer_next(iter)), NULL); answer_release_iter(iter); answer_release(ans); ans = kv_ask("lrange mylist 0 2", strlen("lrange mylist 0 2")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); iter = answer_get_iter(ans, ANSWER_HEAD); value = answer_next(iter); CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "c"); value = answer_next(iter); CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "b"); value = answer_next(iter); CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "a"); value = answer_next(iter); CU_ASSERT_PTR_EQUAL(answer_value_to_string(value), NULL); answer_release_iter(iter); answer_release(ans); ans = kv_ask("lrange mylist 0 3", strlen("lrange mylist 0 3")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); iter = answer_get_iter(ans, ANSWER_HEAD); value = answer_next(iter); CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "c"); value = answer_next(iter); CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "b"); value = answer_next(iter); CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "a"); value = answer_next(iter); CU_ASSERT_PTR_EQUAL(answer_value_to_string(value), NULL); answer_release_iter(iter); answer_release(ans); ans = kv_ask("lrange mylist 0 -1", strlen("lrange mylist 0 -1")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); iter = answer_get_iter(ans, ANSWER_HEAD); value = answer_next(iter); CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "c"); value = answer_next(iter); CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "b"); value = answer_next(iter); CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "a"); value = answer_next(iter); CU_ASSERT_PTR_EQUAL(answer_value_to_string(value), NULL); answer_release_iter(iter); answer_release(ans); ans = kv_ask("lrange mylist -1 -1", strlen("lrange mylist -1 -1")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); iter = answer_get_iter(ans, ANSWER_HEAD); value = answer_next(iter); CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "a"); value = answer_next(iter); CU_ASSERT_PTR_EQUAL(answer_value_to_string(value), NULL); answer_release_iter(iter); answer_release(ans); ans = kv_ask("lrange mylist -1 1", strlen("lrange mylist -1 1")); CU_ASSERT_EQUAL(ans->errnum, ERR_OUT_OF_RANGE); answer_release(ans); ans = kv_ask("lrange mylist 1 -1", strlen("lrange mylist 1 -1")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); iter = answer_get_iter(ans, ANSWER_HEAD); value = answer_next(iter); CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "b"); value = answer_next(iter); CU_ASSERT_STRING_EQUAL(answer_value_to_string(value), "a"); value = answer_next(iter); CU_ASSERT_PTR_EQUAL(answer_value_to_string(value), NULL); answer_release_iter(iter); answer_release(ans); kv_uninit(); }
int main() { long long start, end, duration, t1, t2; struct timeval tv; int i, j, key_size, value_buffer_size; kvs_env.init_type = INIT_TYPE_CREATE; kvs_env.disk_file_path = "disk_file"; kvs_env.IMAGE_file_path = "IMAGE_file"; kvs_env.log_file_path = "log_file"; kvs_env.buffer_sleep_time = 0; kvs_env.buffer_horizon_size = 100 * 1024 * 1024; kvs_env.buffer_size = 700 * 1024 * 1024; for (i = 0; i < VALUE_BUFFER_SIZE; i++) value_buffer[i] = 'a'; srand((unsigned) time(NULL)); gettimeofday(&tv, NULL); start = tv.tv_sec * 1000 * 1000 + tv.tv_usec; if (kv_init(&kvs_env) != 0) { printf("kvs_init fail\n"); return -1; } //first write 5GB for (i = 0; i < CNT; i++) { get_key(key_buffer, i, &key_size); if (kv_put(key_buffer, key_size, value_buffer, VALUE_BUFFER_SIZE) != 0) { printf("kv_put fail\n"); return -1; } } duration = 0; j = CNT; for (i = 0; i < CNT; i++) { get_key(key_buffer, j, &key_size); if (i % 200 == 0) { if (kv_put(key_buffer, key_size, value_buffer, VALUE_BUFFER_SIZE) != 0) { printf("kv_put fail\n"); return -1; } j++; } random_key(key_buffer, j - 1, &key_size); gettimeofday(&tv, NULL); t1 = tv.tv_sec * 1000 * 1000 + tv.tv_usec; if (kv_get(key_buffer, key_size, value_buffer, &value_buffer_size) != 0) { printf("kv_get fail\n"); return -1; } gettimeofday(&tv, NULL); t2 = tv.tv_sec * 1000 * 1000 + tv.tv_usec; duration += (t2 - t1) / 1000; } kv_exit(); printf("read time: %lld ms\n", duration); gettimeofday(&tv, NULL); end = tv.tv_sec * 1000 * 1000 + tv.tv_usec; duration = (end - start) / 1000; printf("total time: %lld ms\n", duration); return 0; }
static aln_v align_read(const kseq_t *read, const kseq_v targets, const size_t n_extra_targets, const kseq_v *extra_targets, const align_config_t *conf) { kseq_t *r; const int32_t read_len = read->seq.l; aln_v result; kv_init(result); kv_resize(aln_t, result, kv_size(targets)); uint8_t *read_num = calloc(read_len, sizeof(uint8_t)); for (int k = 0; k < read_len; ++k) read_num[k] = conf->table[(int)read->seq.s[k]]; // Align to each target kswq_t *qry = NULL; int min_score = -1000; int max_score = 0; for (size_t j = 0; j < kv_size(targets); j++) { // Encode target r = &kv_A(targets, j); aln_t aln = align_read_against_one(r, read_len, read_num, &qry, conf, min_score); if (aln.cigar != NULL) { max_score = aln.loc.score > max_score ? aln.loc.score : max_score; min_score = (aln.loc.score - conf->max_drop) > min_score ? (aln.loc.score - conf->max_drop) : min_score; kv_push(aln_t, result, aln); } } /* If no alignments to the first set of targets reached the minimum score, * abort. */ if (max_score < conf->min_score) { // kv_size returns the n field of a kvec_t, which is a size_t. for (size_t i = 0; i < kv_size(result); i++) free(kv_A(result, i).cigar); kv_size(result) = 0; free(qry); free(read_num); return result; } drop_low_scores(&result, 0, conf->max_drop); // Extra references - qe points to the exact end of the sequence int qend = kv_A(result, 0).loc.qe + 1; int read_len_trunc = read_len - qend; uint8_t *read_num_trunc = read_num + qend; free(qry); qry = NULL; if (read_len_trunc > 2) { for (size_t i = 0; i < n_extra_targets; i++) { const size_t idx = n_extra_targets - i - 1; min_score = -1000; const size_t init_count = kv_size(result); for (size_t j = 0; j < kv_size(extra_targets[idx]); j++) { r = &kv_A(extra_targets[idx], j); aln_t aln = align_read_against_one(r, read_len_trunc, read_num_trunc, &qry, conf, min_score); if (aln.cigar != NULL) { min_score = (aln.loc.score - conf->max_drop) > min_score ? (aln.loc.score - conf->max_drop) : min_score; aln.loc.qb += qend; aln.loc.qe += qend; kv_push(aln_t, result, aln); } } drop_low_scores(&result, init_count, conf->max_drop); /* Truncate */ const int alen = kv_A(result, init_count).loc.qe - kv_A(result, init_count).loc.qb; read_len_trunc = read_len_trunc - alen; free(qry); qry = NULL; } } free(qry); free(read_num); return result; }
mem_alnreg_v mem_fmeas_fliter_se(mem_alnreg_v a , int n , int l_seq , int mode) { mem_alnreg_v aa ; int i , j ; kvec_t(FF_t) k_ff_t ; kv_init(k_ff_t); kv_init(aa); // caculate FMEAS value if(n == 0) return aa ; for( i = 0 ; i < a.n ; i++){ mem_alnreg_t *p_ar = a.a + i ; for( j = i + 1 ; j < a.n ; j++){ FF_t tmp ; mem_alnreg_t *q_ar = a.a + j ; double sens , spec ; int FN = 0 , TP = 0 ,TN = 0 , FP = 0 ; int A,B,C,D; if( p_ar->qb < q_ar->qb || (p_ar->qb == q_ar->qb && p_ar->qe >= q_ar->qe)){ // p q A = p_ar->qb ; B = p_ar->qe - 1 ; C = q_ar->qb ; D = q_ar->qe - 1 ; }else { // p q A = q_ar->qb ; B = q_ar->qe - 1; C = p_ar->qb ; D = p_ar->qe - 1; } if(B < C){ TP = B - A + D - C + 2 ; FN = l_seq - D - 1 + A + C - B - 1 ; TN = l_seq ; FP = 0 ; }else if( D <= B){ // contain continue ; }else{ TP = D - A + 1 ; FN = l_seq - D - 1 + A ; FP = B - C + 1 ; TN = l_seq - FP; } sens = (double)TP/(double)(TP+FN); spec = (double)TN/(double)(TN+FP); tmp.FMEAS = (2*spec*sens)/(spec+sens); tmp.score = p_ar->score + q_ar->score; tmp.x = i , tmp.y = j ; if(tmp.FMEAS > 0.95) kv_push(FF_t,k_ff_t,tmp); } } ks_introsort(ff_mem_flt, k_ff_t.n, k_ff_t.a); kv_push(mem_alnreg_t,aa,a.a[0]); double max_feas ; // int score ; if( k_ff_t.n == 0 ) return aa; max_feas = k_ff_t.a[0].FMEAS ; // score = k_ff_t.a[0].score ; if(mode){ int cnt = 0 ; for( i = 0 ; i < kv_size(k_ff_t) ; i++){ FF_t p = kv_A(k_ff_t,i); if(p.x == 0 && cnt == 0){ kv_push(mem_alnreg_t,aa,a.a[p.y]); cnt = 1 ; }else if(p.x == 0){ kv_push(mem_alnreg_t,aa,a.a[0]); kv_push(mem_alnreg_t,aa,a.a[p.y]); } } for( i = 0 ; i < kv_size(k_ff_t); i++){ FF_t p = kv_A(k_ff_t,i); if(max_feas != p.FMEAS ) break; if(p.x == 0) continue ; kv_push(mem_alnreg_t,aa,a.a[p.x]); kv_push(mem_alnreg_t,aa,a.a[p.y]); } }else{ int cnt = 0 ; for( i = 0 ; i < kv_size(k_ff_t); i++){ FF_t p = kv_A(k_ff_t,i); if(max_feas != p.FMEAS ) break; if(p.x == 0 && cnt == 0){ kv_push(mem_alnreg_t,aa,a.a[p.y]); continue ; }else if( p.x == 0 ){ kv_push(mem_alnreg_t,aa,a.a[0]); kv_push(mem_alnreg_t,aa,a.a[p.y]); continue ; } kv_push(mem_alnreg_t,aa,a.a[p.x]); kv_push(mem_alnreg_t,aa,a.a[p.y]); } } kv_destroy(k_ff_t); #if 0 for( i = 0 ; i < kv_size(aa); i++){ mem_alnreg_t *q = aa.a + i; printf("%db: %d %de:%d \t" , i, q->qb , i, q->qe); if( i == kv_size(aa) -1 ) printf("\n"); } #endif return aa ; }
int main(int argc, char *argv[]) { //initialize Key-Value store-------------------------------------------------- kv_t **vhost_ptr = (kv_t**)get_env(argv, US_VHOST_DATA), //persistent ptr *forum_store = 0; //convenience pointer (var->m instead of (*var)->m) if (vhost_ptr && !*vhost_ptr) { *vhost_ptr = (kv_t*)malloc(sizeof(kv_t)); //threads and posts stored here kv_init(*vhost_ptr, "forum_store", 1024, 0, 0, 0); } forum_store = *vhost_ptr; //---------------------------------------------------------------------------- //setup GET and POST variables------------------------------------------------ char *act = "", *id = "", *title = "", *body = ""; get_arg("act=", &act, argc, argv); //action ('t' or 'p') get_arg("id=", &id, argc, argv); //id of thread get_arg("title=", &title, argc, argv); //title of thread get_arg("body=", &body, argc, argv); //body of post char *end = 0; u64 int_id = strtoll(id, &end, 10); //string to integer if (*end) int_id = 0; //require a numeric ID //---------------------------------------------------------------------------- //response sent to browser is stored here------------------------------------- //templates are rendered into this buffer xbuf_t *reply = get_reply(argv); xbuf_cat(reply, base_tpl); //set base template //---------------------------------------------------------------------------- //HTTP state of a connection http_t *http = (http_t*)get_env(argv, HTTP_HEADERS); redirect: //simulate HTTP, <meta>, or JavaScript redirect without page reload //choose what to do based on the value of 'act'------------------------------- switch (*act) { //regarding a post case 'p': { switch (http->h_method) //GET or POST { //new post-------------------------------------------------------------- case HTTP_POST: { //get the thread to which this post belongs Thread *thread = (Thread*)kv_get(forum_store, (char*)&int_id, sizeof(int_id)); if (!thread) //thread not found { xbuf_repl(reply, "<!--tpl-->", http_error(404)); return 404; } //allocate memory Post *post = calloc(1, sizeof(*post)); //initialize members xbuf_init(&post->body); //define members post->id = thread->posts.nbr_items + 1; xbuf_cat(&post->body, *body ? body : " "); //add post to thread kv_add(&thread->posts, &(kv_item) { .key = (char*)&post->id, .klen = sizeof(post->id), .val = (char*)post, .flags = 0, }); //setup redirect http->h_method = HTTP_GET; *act = 't'; goto redirect; } break; //---------------------------------------------------------------------- } } break; //regarding a thread case 't': { switch (http->h_method) { //view a thread--------------------------------------------------------- case HTTP_GET: { Thread *thread = (Thread*)kv_get(forum_store, (char*)&int_id, sizeof(int_id)); if (!thread) { xbuf_repl(reply, "<!--tpl-->", http_error(404)); return 404; } //replace template variables with dynamic values xbuf_repl(reply, "<!--form-->", post_form); xbuf_repl(reply, "<!--title-->", thread->title.ptr); xbuf_repl(reply, "<!--id-->", id); //for each post, render its template and insert it into reply kv_do(&thread->posts, 0, 0, (kv_proc_t)&list_posts, (void*)reply); } break; //---------------------------------------------------------------------- //create a thread------------------------------------------------------- case HTTP_POST: { Thread *thread = calloc(1, sizeof(*thread)); xbuf_init(&thread->title); kv_init(&thread->posts, "posts", 1024, 0, 0, 0); thread->id = forum_store->nbr_items + 1; xbuf_cat(&thread->title, *title ? title : " "); //add thread to KV store kv_add(forum_store, &(kv_item) { .key = (char*)&thread->id, .klen = sizeof(thread->id), .val = (char*)thread, .flags = 0, }); http->h_method = HTTP_GET; *act = 0; goto redirect; } break; //---------------------------------------------------------------------- } } break;
void case_cmd_incrby() { /** * incr valid number to no_exist key * incr valid number to exist key(string-type) * incr valid number to exist key(lpush-type) * incr invalid number to no_exist key * incr invalid number to exist key(string-type) * incr invalid number to exist key(lpush-type) */ answer_t *ans; CU_ASSERT_EQUAL(kv_init(NULL), ERR_NONE); ans = kv_ask("flushdb", strlen("flushdb")); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK"); answer_release(ans); /** no exist key */ ans = kv_ask("incrby no_exist_key 123", strlen("incrby no_exist_key 123")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "123"); answer_release(ans); ans = kv_ask("get no_exist_key", strlen("get no_exist_key")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "123"); answer_release(ans); /** exist key */ ans = kv_ask("set key 123", strlen("set key 123")); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK"); answer_release(ans); ans = kv_ask("incrby key 123", strlen("incrby key 123")); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "246"); answer_release(ans); ans = kv_ask("get key", strlen("get key")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "246"); answer_release(ans); /** list */ ans = kv_ask("lpush lkey a b c", strlen("lpush lkey a b c")); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "3"); answer_release(ans); ans = kv_ask("incrby lkey 456", strlen("incr lkey 456")); CU_ASSERT_EQUAL(ans->errnum, ERR_TYPE); answer_release(ans); ans = kv_ask("flushdb", strlen("flushdb")); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK"); answer_release(ans); /** * incrby invalid number */ /** no exist key */ ans = kv_ask("incrby no_exist_key abcd", strlen("incrby no_exist_key abcd")); CU_ASSERT_EQUAL(ans->errnum, ERR_VALUE); answer_release(ans); /** exist key */ ans = kv_ask("set key 123", strlen("set key 123")); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK"); answer_release(ans); ans = kv_ask("incrby key abcd", strlen("incr key abcd")); CU_ASSERT_EQUAL(ans->errnum, ERR_VALUE); answer_release(ans); ans = kv_ask("get key", strlen("get key")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "123"); answer_release(ans); /** invalid value */ ans = kv_ask("set key1 abcd", strlen("set key1 abcd")); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK"); answer_release(ans); ans = kv_ask("incrby key1 123", strlen("incrby key1 123")); CU_ASSERT_EQUAL(ans->errnum, ERR_VALUE); answer_release(ans); /** list */ ans = kv_ask("lpush lkey a b c", strlen("lpush lkey a b c")); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "3"); answer_release(ans); ans = kv_ask("incrby lkey 456", strlen("incr lkey 456")); CU_ASSERT_EQUAL(ans->errnum, ERR_TYPE); answer_release(ans); ans = kv_ask("flushdb", strlen("flushdb")); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK"); answer_release(ans); }
void case_cmd_flushdb() { /* * flush empty db * flush one key db * flush 5000 string keys and 5000 lpush keys */ answer_t *ans; static char buf[10000+128]; int i; CU_ASSERT_EQUAL(kv_init(NULL), ERR_NONE); ans = kv_ask("flushdb", strlen("flushdb")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK"); answer_release(ans); ans = kv_ask("dbsize", strlen("dbsize")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "0"); answer_release(ans); ans = kv_ask("flushdb", strlen("flushdb")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK"); answer_release(ans); ans = kv_ask("dbsize", strlen("dbsize")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "0"); answer_release(ans); /* flush one key */ ans = kv_ask("set key value", strlen("set key value")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK"); answer_release(ans); ans = kv_ask("flushdb", strlen("flushdb")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK"); answer_release(ans); ans = kv_ask("dbsize", strlen("dbsize")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "0"); answer_release(ans); /* flush list key */ ans = kv_ask("lpush lkey a b c", strlen("lpush lkey a b c")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "3"); answer_release(ans); ans = kv_ask("flushdb", strlen("flushdb")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK"); answer_release(ans); ans = kv_ask("dbsize", strlen("dbsize")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "0"); answer_release(ans); /* 5000 string keys and 5000 list keys */ for (i = 1; i <= 5000; i++) { int bytes = snprintf(buf, sizeof(buf), "set key%d %d", i, i); ans = kv_ask(buf, bytes); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK"); answer_release(ans); bytes = snprintf(buf, sizeof(buf), "lpush lkey%d %d", i, i); ans = kv_ask(buf, bytes); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "1"); answer_release(ans); } ans = kv_ask("dbsize", strlen("dbsize")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "10000"); answer_release(ans); ans = kv_ask("flushdb", strlen("flushdb")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "OK"); answer_release(ans); ans = kv_ask("dbsize", strlen("dbsize")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "0"); answer_release(ans); }
countries_v shape_load_countries(const char* filename) { countries_v countries; kv_init(countries); double adfMinBound[4], adfMaxBound[4]; // Read file SHPHandle hSHP = SHPOpen( filename, "rb" ); if(hSHP == NULL) goto end_loading; // Print shape bounds int country_count, shapes_vype; SHPGetInfo( hSHP, &country_count, &shapes_vype, adfMinBound, adfMaxBound ); fprintf(stderr, "Load %d countries\n", country_count); // Iterate through countries for(int i = 0; i < country_count; i++ ) { SHPObject *shp = SHPReadObject(hSHP, i); if(shp == NULL) goto end_loading; if(shp->nParts == 0) continue; // first part starts at point 0 if(shp->panPartStart[0] != 0) goto end_loading; // collect parts of country shapes_v shapes; kv_init(shapes); shapes.min = (point_t){shp->dfXMin, shp->dfYMin}; shapes.max = (point_t){shp->dfXMax, shp->dfYMax}; uint32_t parts = shp->nParts; double k = 0.0; for (uint32_t j=0; j<parts; j++) { // start index uint32_t s = shp->panPartStart[j]; // end index - start of next minus one, or end uint32_t e = (j+1 < parts) ? shp->panPartStart[j+1]: shp->nVertices; shape_v shape; kv_init(shape); // collect points of part for(uint32_t i=s; i<e; i++){ point_t p = (point_t){shp->padfX[i], shp->padfY[i]}; kv_push(point_t, shape, p); // cumulitive average for center if(k>=1.0) { shapes.center.x = (k-1.0)/k*shapes.center.x + p.x/k; shapes.center.y = (k-1.0)/k*shapes.center.y + p.y/k; }else { shapes.center.x = p.x; shapes.center.y = p.y; } k+=1.0; } kv_push(shape_v, shapes, shape); } SHPDestroyObject( shp ); kv_push(shapes_v, countries, shapes); } SHPClose( hSHP ); end_loading: return countries; }
void case_cmd_expireat_get() { answer_t *ans; char cmd[128]; CU_ASSERT_EQUAL(kv_init(NULL), ERR_NONE); ans = kv_ask("flushdb", strlen("flushdb")); answer_release(ans); ans = kv_ask("set key value", strlen("set key value")); answer_release(ans); int write = snprintf(cmd, sizeof(cmd), "expireat key %ld", time(NULL) + 5); ans = kv_ask(cmd, strlen(cmd)); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "1"); answer_release(ans); sleep(3); ans = kv_ask("get key", strlen("get key")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "value"); answer_release(ans); sleep(3); ans = kv_ask("get key", strlen("get key")); CU_ASSERT_EQUAL(ans->errnum, ERR_NIL); CU_ASSERT_PTR_EQUAL(answer_value_to_string(answer_first_value(ans)), NULL); answer_release(ans); ans = kv_ask("dbsize", strlen("dbsize")); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "0"); answer_release(ans); ans = kv_ask("set key value", strlen("set key value")); answer_release(ans); snprintf(cmd, sizeof(cmd), "expireat key %ld", time(NULL) + 2); ans = kv_ask(cmd, strlen(cmd)); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "1"); answer_release(ans); sleep(3); ans = kv_ask("del key", strlen("del key")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "0"); answer_release(ans); answer_release(kv_ask("set key value", strlen("set key value"))); ans = kv_ask("del key", strlen("del key")); CU_ASSERT_EQUAL(ans->errnum, ERR_NONE); CU_ASSERT_STRING_EQUAL(answer_value_to_string(answer_first_value(ans)), "1"); answer_release(ans); kv_uninit(); CU_ASSERT_EQUAL(kv_get_used_memory(), 0); }
int main() { int i, state; freopen("input_file", "r", stdin); scanf("%d", &num); for (i = 0; i < num; i++) { scanf("%d %s %d %s", &in[i].key_size, in[i].key, &in[i].value_size, in[i].value); out[i].value_size = 1025; } //----------------KV_INIT------------- fill_kvs_env(); if (kv_init(&kvs_env) != 0) { printf("kvs_init fail\n"); return -1; } //----------------KV_PUT------------- for (i = 0; i < num / 2; i++) { state = kv_put(in[i].key, in[i].key_size, in[i].value, in[i].value_size); if (state != 0) { printf("kv_put %d fail\n", i); } else { printf("put: key_size:%d\t\tkey:%s\t\tvalue_size:%d\t\tvalue:%s\n", in[i].key_size, in[i].key, in[i].value_size, in[i].value); } } fflush(stdout); //----------------KV_GET------------- for (i = 0; i < num / 2; i++) { state = kv_get(in[i].key, in[i].key_size, out[i].value, &out[i].value_size); if (state != 0) { printf("kv_get %d fail\n", i); } else { printf("get: key_size:%d\t\tkey:%s\t\tvalue_size:%d\t\tvalue:%s\n", in[i].key_size, in[i].key, out[i].value_size, out[i].value); } } fflush(stdout); //----------------KV_DELETE------------- for (i = 0; i < num / 4; i += 2) { state = kv_delete(in[i].key, in[i].key_size); if (state != 0) { printf("kv_delete %d fail\n", i); } else { printf("delete: key_size:%d\t\tkey:%s\t\tvalue_size:%d\t\tvalue:%s\n", in[i].key_size, in[i].key, out[i].value_size, out[i].value); } } fflush(stdout); //----------------KV_GET------------- for (i = 0; i < num / 4; i += 2) { state = kv_get(in[i].key, in[i].key_size, out[i].value, &out[i].value_size); if (state != 0) { printf("kv_get %d fail\n", i); } else { printf("get: key_size:%d\t\tkey:%s\t\tvalue_size:%d\t\tvalue:%s\n", in[i].key_size, in[i].key, out[i].value_size, out[i].value); } } fflush(stdout); //----------------KV_PUT------------- for (i = num / 2; i < num; i++) { state = kv_put(in[i].key, in[i].key_size, in[i].value, in[i].value_size); if (state != 0) { printf("kv_put %d fail\n", i); } else { printf("put: key_size:%d\t\tkey:%s\t\tvalue_size:%d\t\tvalue:%s\n", in[i].key_size, in[i].key, in[i].value_size, in[i].value); } } fflush(stdout); //----------------KV_GET------------- for (i = num / 2; i < num; i++) { state = kv_get(in[i].key, in[i].key_size, out[i].value, &out[i].value_size); if (state != 0) { printf("kv_get %d fail\n", i); } else { printf("get: key_size:%d\t\tkey:%s\t\tvalue_size:%d\t\tvalue:%s\n", in[i].key_size, in[i].key, out[i].value_size, out[i].value); } } fflush(stdout); //----------------KV_EXIT------------- if (kv_exit(1) != 0) { printf("kvs_exit fail\n"); return -1; } return 0; }
OBJ TrArray_new(VM) { TrArray *a = TR_INIT_CORE_OBJECT(Array); kv_init(a->kv); return (OBJ)a; }