void *run_write(void *args){ unsigned int arr[size/4]; unsigned int j=0, k, id; struct writer_slot *wr_slt; wr_slt = writer_init(reg); id = get_id(wr_slt); printf("[%u]WR: START\n", id); while(!start); while(!end || (end_write!=0 && count_write >= end_write)){ //write reg_write(wr_slt, arr); //busy loops k = busy_loop(busy_write); count_write++; //if((count_write%(end_write/10)) == 0) printf("WR: Iteration %10u\n",count_write); } //end = true; printf("[0]WR: END\n"); pthread_exit(NULL); }
static THD_FUNCTION(uart_thread, arg) { (void)arg; chRegSetThreadName("UART thread"); // KPA. event_listener_t kpa_event_listener; chEvtRegisterMaskWithFlags((event_source_t*)chnGetEventSource(&SD1), &kpa_event_listener, EVENT_MASK(1), CHN_INPUT_AVAILABLE); struct writer kpa_writer; writer_init(&kpa_writer, &SD1, uart_write); // FBV. event_listener_t fbv_event_listener; chEvtRegisterMaskWithFlags((event_source_t*)chnGetEventSource(&SD6), &fbv_event_listener, EVENT_MASK(2), CHN_INPUT_AVAILABLE); struct writer fbv_writer; writer_init(&fbv_writer, &SD6, uart_write); // Bridge- struct bridge bridge; bridge_init(&bridge, &kpa_writer, &fbv_writer); uint8_t byte = 0; while (true) { eventflags_t evt = chEvtWaitAnyTimeout(EVENT_MASK(1) | EVENT_MASK(2), MS2ST(1)); if (evt & EVENT_MASK(1)) { chEvtGetAndClearFlags(&kpa_event_listener); while (readByte(&SD1, &byte)) bridge_update_kpa(&bridge, byte); } if (evt & EVENT_MASK(2)) { chEvtGetAndClearFlags(&fbv_event_listener); while (readByte(&SD6, &byte)) bridge_update_fbv(&bridge, byte); } bridge_update_time(&bridge, clock_get_ms()); } }
avro_writer_t avro_writer_file(FILE * fp) { struct _avro_writer_file_t *file_writer = malloc(sizeof(struct _avro_writer_file_t)); if (!file_writer) { return NULL; } file_writer->fp = fp; writer_init(&file_writer->writer, AVRO_FILE_IO); return &file_writer->writer; }
avro_writer_t avro_writer_file_fp(FILE * fp, int should_close) { struct _avro_writer_file_t *file_writer = (struct _avro_writer_file_t *) avro_new(struct _avro_writer_file_t); if (!file_writer) { avro_set_error("Cannot allocate new file writer"); return NULL; } file_writer->fp = fp; file_writer->should_close = should_close; writer_init(&file_writer->writer, AVRO_FILE_IO); return &file_writer->writer; }
avro_writer_t avro_writer_memory(const char *buf, int64_t len) { struct _avro_writer_memory_t *mem_writer = malloc(sizeof(struct _avro_writer_memory_t)); if (!mem_writer) { return NULL; } mem_writer->buf = buf; mem_writer->len = len; mem_writer->written = 0; writer_init(&mem_writer->writer, AVRO_MEMORY_IO); return &mem_writer->writer; }
avro_writer_t avro_writer_memory(const char *buf, int64_t len) { struct _avro_writer_memory_t *mem_writer = (struct _avro_writer_memory_t *) avro_new(struct _avro_writer_memory_t); if (!mem_writer) { avro_set_error("Cannot allocate new memory writer"); return NULL; } mem_writer->buf = buf; mem_writer->len = len; mem_writer->written = 0; writer_init(&mem_writer->writer, AVRO_MEMORY_IO); return &mem_writer->writer; }
/* * Export data out of GPDB. * invoked by GPDB, be careful with C++ exceptions. */ Datum s3_export(PG_FUNCTION_ARGS) { /* Must be called via the external table format manager */ if (!CALLED_AS_EXTPROTOCOL(fcinfo)) elog(ERROR, "extprotocol_import: not called by external protocol manager"); /* Get our internal description of the protocol */ GPWriter *gpwriter = (GPWriter *)EXTPROTOCOL_GET_USER_CTX(fcinfo); /* last call. destroy writer */ if (EXTPROTOCOL_IS_LAST_CALL(fcinfo)) { thread_cleanup(); if (!writer_cleanup(&gpwriter)) { ereport(ERROR, (0, errmsg("Failed to cleanup S3 extension: %s", s3extErrorMessage.c_str()))); } EXTPROTOCOL_SET_USER_CTX(fcinfo, NULL); PG_RETURN_INT32(0); } /* first call. do any desired init */ if (gpwriter == NULL) { const char *url_with_options = EXTPROTOCOL_GET_URL(fcinfo); const char *format = get_format_str(fcinfo); thread_setup(); gpwriter = writer_init(url_with_options, format); if (!gpwriter) { ereport(ERROR, (0, errmsg("Failed to init S3 extension, segid = %d, " "segnum = %d, please check your " "configurations and net connection: %s", s3ext_segid, s3ext_segnum, s3extErrorMessage.c_str()))); } EXTPROTOCOL_SET_USER_CTX(fcinfo, gpwriter); } char *data_buf = EXTPROTOCOL_GET_DATABUF(fcinfo); int32 data_len = EXTPROTOCOL_GET_DATALEN(fcinfo); if (!writer_transfer_data(gpwriter, data_buf, data_len)) { ereport(ERROR, (0, errmsg("s3_export: could not write data: %s", s3extErrorMessage.c_str()))); } PG_RETURN_INT32(data_len); }
bool uploadS3(const char *urlWithOptions, const char *fileToUpload) { if (!urlWithOptions) { return false; } size_t data_len = BUF_SIZE; char data_buf[BUF_SIZE]; size_t read_len = 0; bool ret = true; thread_setup(); GPWriter *writer = writer_init(urlWithOptions); if (!writer) { return false; } FILE *fd = fopen(fileToUpload, "r"); if (fd == NULL) { fprintf(stderr, "File does not exist\n"); ret = false; } else { do { read_len = fread(data_buf, 1, data_len, fd); if (read_len == 0) { break; } if (!writer_transfer_data(writer, data_buf, (int)read_len)) { fprintf(stderr, "Failed to write data to Amazon S3\n"); ret = false; break; } } while (read_len == data_len && !S3QueryIsAbortInProgress()); if (ferror(fd)) { ret = false; } fclose(fd); } writer_cleanup(&writer); thread_cleanup(); return ret; }
int aconfig_save_file(AConfig *root, const char *fn) { AConfig* child; Writer w[1]; if (writer_init(w,fn) < 0) return -1; for (child = root->first_child; child; child = child->next) writer_node(w,child,0); writer_done(w); return 0; }