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;
}
