static void
vda_close(struct media_codec *mc)
{
vda_decoder_t *vdad = mc->opaque;
VDADecoderFlush(vdad->vdad_decoder, 0);
VDADecoderDestroy(vdad->vdad_decoder);
destroy_frames(vdad);
}
static void
vtb_flush(struct media_codec *mc, struct video_decoder *vd)
{
vtb_decoder_t *vtbd = mc->opaque;
VTDecompressionSessionWaitForAsynchronousFrames(vtbd->vtbd_session);
hts_mutex_lock(&vtbd->vtbd_mutex);
destroy_frames(vtbd);
vtbd->vtbd_max_ts = PTS_UNSET;
vtbd->vtbd_flush_to = PTS_UNSET;
vtbd->vtbd_last_pts = PTS_UNSET;
hts_mutex_unlock(&vtbd->vtbd_mutex);
}
static void
vtb_close(struct media_codec *mc)
{
vtb_decoder_t *vtbd = mc->opaque;
VTDecompressionSessionWaitForAsynchronousFrames(vtbd->vtbd_session);
destroy_frames(vtbd);
VTDecompressionSessionInvalidate(vtbd->vtbd_session);
CFRelease(vtbd->vtbd_session);
CFRelease(vtbd->vtbd_fmt);
free(vtbd);
}
static void
vda_flush(struct media_codec *mc, struct video_decoder *vd)
{
vda_decoder_t *vdad = mc->opaque;
VDADecoderFlush(vdad->vdad_decoder, 1);
hts_mutex_lock(&vdad->vdad_mutex);
destroy_frames(vdad);
vdad->vdad_max_ts = PTS_UNSET;
vdad->vdad_flush_to = PTS_UNSET;
vdad->vdad_last_pts = PTS_UNSET;
hts_mutex_unlock(&vdad->vdad_mutex);
}
static void
server_worker (void *_server_args, zctx_t *ctx) {
void *worker = zsocket_new (ctx, ZMQ_DEALER);
zsocket_connect(worker, "inproc://backend");
int64_t affinity = 5000;
int rc = zmq_setsockopt(socket, ZMQ_SNDBUF, &affinity, sizeof affinity);
rc = zmq_setsockopt(socket, ZMQ_RCVBUF, &affinity, sizeof affinity);
char algorithm_name[BUFSIZE];
server_args = (Server_Args *)_server_args;
printf("Initial value size %ld\n", strlen(server_args->init_data));
printf("Initial server str %s\n", server_args->servers_str);
zmq_pollitem_t items[] = { { worker, 0, ZMQ_POLLIN, 0}};
// int count = 0;
while (true) {
printf("\twaiting for message\n");
int rc = zmq_poll(items, 1, -1);
if( rc < 0 || s_interrupted==1) {
exit(EXIT_FAILURE);
}
if (items[0].revents & ZMQ_POLLIN) {
printf("\treceived message\n");
zmsg_t *msg = zmsg_recv(worker);
// receive the frames
status->network_data += (float)zmsg_content_size(msg) ;
zlist_t *frames_list = zlist_new();
zhash_t *frames = receive_message_frames_at_server(msg, frames_list);
get_string_frame(algorithm_name, frames, ALGORITHM);
if( strcmp(algorithm_name, "ABD")==0) {
printf(" [[[ %s\n", server_args->server_id);
if(DEBUG_MODE) {
print_out_hash_in_order(frames, frames_list);
}
algorithm_ABD(frames, worker, server_args);
printf(" ]]]\n\n");
} else if( strcmp(algorithm_name, SODAW)==0) {
printf(" [[[ %s\n",server_args->server_id);
if(DEBUG_MODE) {
print_out_hash_in_order(frames, frames_list);
}
algorithm_SODAW(frames, worker, server_args);
printf(" ]]]\n\n");
}
zlist_purge(frames_list);
zlist_destroy(&frames_list);
destroy_frames(frames);
zmsg_destroy(&msg);
}
}
printf("done\n");
}
void ABD_get_max_tag_value_phase(
char *obj_name,
unsigned int op_num,
zsock_t *sock_to_servers,
unsigned int num_servers,
RawData *max_tag_value
) {
// send out the messages to all servers
char phase[64];
char tag_str[64];
unsigned int round;
Tag *tag;
zmq_pollitem_t items [] = { { sock_to_servers, 0, ZMQ_POLLIN, 0 } };
char *types[] = {OBJECT, ALGORITHM, PHASE, OPNUM};
send_multicast_servers(sock_to_servers, num_servers, types, 4, obj_name, "ABD", GET_TAG_VALUE, &op_num) ;
unsigned int majority = ceil(((float)num_servers+1)/2);
unsigned int responses =0;
zlist_t *tag_list = zlist_new();
while (true) {
// Tick once per second, pulling in arriving messages
// zmq_pollitem_t items [] = { { sock_to_servers, 0, ZMQ_POLLIN, 0 } };
printf("\t\twaiting for data...\n");
int rc = zmq_poll(items, 1, -1);
if(rc < 0 || s_interrupted ) {
printf("Interrupted!\n");
exit(EXIT_FAILURE);
}
printf("\t\treceived data\n");
if (items [0].revents & ZMQ_POLLIN) {
zmsg_t *msg = zmsg_recv(sock_to_servers);
zlist_t *names = zlist_new();
zhash_t* frames = receive_message_frames_at_client(msg, names);
//value
zframe_t *value_frame = (zframe_t *)zhash_lookup(frames, PAYLOAD);
assert(value_frame !=NULL);
get_string_frame(phase, frames, PHASE);
round = get_int_frame(frames, OPNUM);
get_string_frame(tag_str, frames, TAG);
if(round==op_num && strcmp(phase, GET_TAG_VALUE)==0) {
if(DEBUG_MODE) print_out_hash_in_order(frames, names);
responses++;
// add tag to list
tag = (Tag *)malloc(sizeof(Tag));
string_to_tag(tag_str, tag);
zlist_append(tag_list, (void *)tag);
max_tag_value->data = (void *)value_frame;
max_tag_value->data_size = zframe_size(value_frame);
if(responses >= majority) {
zlist_purge(names);
zlist_destroy(&names);
zmsg_destroy (&msg);
destroy_frames(frames);
break;
}
//if(responses >= num_servers) break;
} else {
printf("\tOLD MESSAGES : (%s, %d)\n", phase, op_num);
}
zmsg_destroy (&msg);
}
}
//comute the max tag now and return
max_tag_value->tag = get_max_tag(tag_list);
free_items_in_list(tag_list);
zlist_destroy(&tag_list);
}
