int __omp_collector_api(void *arg)
{
if(arg!=NULL) {
message_queue_t pending_requests;
char *traverse = (char *) arg;
message_queue_init(&pending_requests);
while((int)(*traverse)!=0) {
omp_collector_message* req = message_queue_push(&pending_requests);
req->sz = (int)(*traverse); // todo: add check for consistency
traverse+=sizeof(int);
req->r = (OMP_COLLECTORAPI_REQUEST)(*traverse); // todo: add check for a valid request
traverse+=sizeof(int);
req->ec= (OMP_COLLECTORAPI_EC *) traverse; // copy address for response of error code
traverse+=sizeof(int);
req->rsz = (int *)(traverse);
traverse+=sizeof(int);
req->mem = traverse;
traverse+=req->sz-(4*sizeof(int));
}
while(!message_queue_empty(&pending_requests)) {
omp_collector_message pop_req;
message_queue_pop(&pending_requests, &pop_req);
process_top_request(&pop_req);
}
return 0;
}
return -1;
}
int main (int argc, const char **argv)
{
VCHIQ_INSTANCE_T vchiq_instance;
int success = -1;
char response[ 128 ];
if (!is_filed_running())
{
printf("vcfiled not running\n");
exit(-1);
}
vcos_init();
vcos_set_args(argc, argv);
if (vchiq_initialise(&vchiq_instance) != VCHIQ_SUCCESS)
{
printf("* failed to open vchiq instance\n");
return -1;
}
// initialise the OS abstraction layer
os_init();
vcos_log("vchi_initialise");
success = vchi_initialise( &global_initialise_instance);
assert(success == 0);
vchiq_instance = (VCHIQ_INSTANCE_T)global_initialise_instance;
global_connection = vchi_create_connection(single_get_func_table(),
vchi_mphi_message_driver_func_table());
vcos_log("vchi_connect");
vchi_connect(&global_connection, 1, global_initialise_instance);
vc_vchi_gencmd_init (global_initialise_instance, &global_connection, 1);
vc_vchi_dispmanx_init (global_initialise_instance, &global_connection, 1);
vc_vchi_tv_init (global_initialise_instance, &global_connection, 1);
vc_vchi_cec_init (global_initialise_instance, &global_connection, 1);
vc_vchi_bufman_init (global_initialise_instance, &global_connection, 1);
if ( success == 0 )
{
success = vc_gencmd( response, sizeof(response), "set_vll_dir /sd/vlls" );
vcos_assert( success == 0 );
}
vcos_log("VMCS services initialized.");
message_queue_init ();
host_app_message_handler (PLATFORM_MSG_INIT, 0, 0);
dispatch_messages ();
vcos_deinit ();
return 0;
}
void message_queue_example(){
int i, x;
struct message_queue q;
int data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
// initialize.
message_queue_init(&q);
// add messages.
for(i=0;i<10;i++){
message_queue_push(&q, &data[i]);
}
// get all of the messages.
while(q.msg_num){
x = *((int*)message_queue_pop(&q));
printf("msg: %d\n", x);
}
// destroy
message_queue_destroy(&q);
}
int main(int argc, char *argv[]) {
main_thread = pthread_self();
signal(SIGUSR1, &handle_signal);
signal(SIGPIPE, SIG_IGN);
message_queue_init(&io_queue, sizeof(struct io_op), 128);
threadpool_init();
int fd = open_http_listener();
if(fd >= 0) {
while(1) {
fd_set rfds, wfds;
int max_fd, r;
main_blocked = 1;
__sync_synchronize();
service_io_message_queue();
FD_ZERO(&rfds);
FD_ZERO(&wfds);
max_fd = 0;
FD_SET(fd, &rfds);
for(int i=0;i<FD_SETSIZE;++i) {
if(client_data[i].state == CLIENT_READING) {
FD_SET(i, &rfds);
max_fd = i;
} else if(client_data[i].state == CLIENT_WRITING) {
FD_SET(i, &wfds);
max_fd = i;
}
}
max_fd = fd > max_fd ? fd : max_fd;
r = select(max_fd+1, &rfds, &wfds, NULL, NULL);
main_blocked = 0;
__sync_synchronize();
if(r < 0 && errno != EINTR) {
perror("Error in select");
return -1;
}
if(r > 0) {
if(FD_ISSET(fd, &rfds)) {
struct sockaddr_in peer_addr;
socklen_t peer_len = sizeof(peer_addr);
int cfd = accept(fd, (struct sockaddr *)&peer_addr, &peer_len);
if(cfd >= 0) {
int flags = fcntl(cfd, F_GETFL, 0);
fcntl(fd, F_SETFL, flags | O_NONBLOCK);
client_data[cfd].state = CLIENT_READING;
client_data[cfd].pos = 0;
}
}
for(int i=0;i<FD_SETSIZE;++i) {
if(i != fd && FD_ISSET(i, &rfds)) {
handle_client_data(i);
} else if(i != fd && FD_ISSET(i, &wfds)) {
int r = write(i, client_data[i].write_op->buf+client_data[i].write_op->pos, client_data[i].write_op->len-client_data[i].write_op->pos);
if(r >= 0) {
client_data[i].write_op->pos += r;
if(client_data[i].write_op->pos == client_data[i].write_op->len) {
client_data[i].state = CLIENT_INACTIVE;
if(client_data[i].write_op->close_pending) {
close(client_data[i].write_op->rfd);
close(i);
} else {
struct www_op *message = message_queue_message_alloc_blocking(&worker_queue);
message->operation = OP_READ_BLOCK;
message->fd = i;
message->rfd = client_data[i].write_op->rfd;
message_queue_write(&worker_queue, message);
}
message_queue_message_free(&io_queue, client_data[i].write_op);
}
} else {
close(client_data[i].write_op->rfd);
close(i);
message_queue_message_free(&io_queue, client_data[i].write_op);
client_data[i].state = CLIENT_INACTIVE;
}
}
}
}
service_io_message_queue();
}
} else {
perror("Error listening on *:8080");
}
}
static void threadpool_init() {
message_queue_init(&worker_queue, sizeof(struct www_op), 512);
for(int i=0;i<WORKER_THREADS;++i) {
pthread_create(&worker_threads[i], NULL, &worker_threadproc, NULL);
}
}
