openairinterface5g/targets/RT/USER/TOOLS/thread_ipc.c

/*******************************************************************************
    OpenAirInterface 
    Copyright(c) 1999 - 2014 Eurecom

    OpenAirInterface is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.


    OpenAirInterface is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with OpenAirInterface.The full GNU General Public License is 
    included in this distribution in the file called "COPYING". If not, 
    see <http://www.gnu.org/licenses/>.

   Contact Information
   OpenAirInterface Admin: openair_admin@eurecom.fr
   OpenAirInterface Tech : openair_tech@eurecom.fr
   OpenAirInterface Dev  : openair4g-devel@eurecom.fr
  
   Address      : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE

 *******************************************************************************/

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>

#include <pthread.h>
#include <sched.h>

#include "thread_ipc.h"

g_thread_ipc_t thread_ipc = {0};

void loop_buffer_reset(buffer_t *loop_buf)
{
	int i;

	for (i = 0; i < BUFFERMAX; i++) {
		loop_buf[i].subframe_num = -1;
	}

	return;
}

static void loop_buffer_init(loop_buffer_op_t *loop_buffer)
{
	loop_buffer->packet_num = 0;
	loop_buffer->isfull = 0;
	loop_buffer->isempty = 1;

	pthread_mutex_init(&loop_buffer->buffer_mutex, NULL);

	pthread_cond_init(&loop_buffer->full_cond, NULL);
	pthread_cond_init(&loop_buffer->empty_cond, NULL);

	loop_buffer_reset(loop_buffer->loop_buf);

	return;
}

static void sync_buffer_init(sync_buffer_t *sync_buffer)
{
	sync_buffer->decoding_subframe_num = 0;
	pthread_mutex_init(&sync_buffer->buffer_mutex, NULL);

	return;
}

int thread_ipc_init(void)
{
	//printf("recv %d\n", thread_ipc.sync_buffer.decoding_subframe_num);
	thread_ipc.ue_sync_state = 0;
	thread_ipc.rx_timestamp = 0;
	thread_ipc.tx_timestamp = 0;
	thread_ipc.current_subframe = 0;

	pthread_mutex_init(&thread_ipc.dl_decode_mutex, NULL);
	pthread_mutex_lock(&thread_ipc.dl_decode_mutex);

	pthread_mutex_init(&thread_ipc.ul_send_mutex, NULL);
	pthread_mutex_lock(&thread_ipc.ul_send_mutex);

	pthread_mutex_init(&thread_ipc.sync_mutex, NULL);
	pthread_mutex_lock(&thread_ipc.sync_mutex);

	loop_buffer_init(&thread_ipc.loop_buffer);
	sync_buffer_init(&thread_ipc.sync_buffer);

	return 0;
}

int thread_ipc_deinit(void)
{
	pthread_mutex_destroy(&thread_ipc.ul_send_mutex);
	pthread_mutex_destroy(&thread_ipc.sync_mutex);
	pthread_mutex_destroy(&thread_ipc.dl_decode_mutex);

	pthread_mutex_destroy(&thread_ipc.loop_buffer.buffer_mutex);
	pthread_cond_destroy(&thread_ipc.loop_buffer.full_cond);
	pthread_cond_destroy(&thread_ipc.loop_buffer.empty_cond);

	pthread_mutex_destroy(&thread_ipc.sync_buffer.buffer_mutex);

	return 0;
}

int set_thread_attr(pthread_attr_t *attr, int policy, int priority, int cpuid)
{
	struct sched_param param;
	cpu_set_t cpu_info;

	pthread_attr_init(attr);

	if (pthread_attr_setschedpolicy(attr, policy) != 0) {
		perror("pthread_attr_setschedpolicy");
		return -1;
	}

	param.sched_priority = priority;
	if (pthread_attr_setschedparam(attr, &param) != 0) {
		perror("pthread_attr_setschedparam");
		return -1;
	}

	CPU_ZERO(&cpu_info);
	CPU_SET(cpuid, &cpu_info);
	if (pthread_attr_setaffinity_np(attr,sizeof(cpu_set_t),&cpu_info)) {
		perror("pthread_attr_setaffinity_np");
		return -1;
	}

	if (pthread_attr_setinheritsched(attr, PTHREAD_EXPLICIT_SCHED) != 0) {
		perror("pthread_attr_setinheritsched");
		return -1;
	}

	return 0;
}


int find_subframe_num(unsigned long long current_subframe_num, buffer_t *buf, int *flag)
{
	long long tmp;
	int i;
	
	tmp = current_subframe_num;
	for ( i = 0; i < HIGHBUFFER + 1; i++)
	{
		if(tmp == buf[i].subframe_num)
		{ 
			return i;
		} else if (tmp < buf[i].subframe_num) {
			*flag = 1;	
		}
	}

	return -1;
}

int ue_unsync_thread_ipc_reset(void)
{
	thread_ipc.ue_sync_state = 0;                 
	
	pthread_mutex_lock(&thread_ipc.loop_buffer.buffer_mutex);
	if (thread_ipc.loop_buffer.isempty) {
		pthread_cond_signal(&thread_ipc.loop_buffer.empty_cond);
	}

	if (thread_ipc.loop_buffer.isfull) {
		pthread_cond_signal(&thread_ipc.loop_buffer.full_cond);
	}

	thread_ipc.loop_buffer.packet_num = 0;
	thread_ipc.loop_buffer.isfull = 0;
	thread_ipc.loop_buffer.isempty = 1;

	loop_buffer_reset(thread_ipc.loop_buffer.loop_buf);
	pthread_mutex_unlock(&thread_ipc.loop_buffer.buffer_mutex);

	thread_ipc.current_subframe = 0;

	return 0;
}
void bind_thread2kernel(int cpu_id)
{
        cpu_set_t mask;
        cpu_set_t get;
        int i;
        int num = sysconf(_SC_NPROCESSORS_CONF);
        //printf("system has %d processor(s) by super\n", num);
        CPU_ZERO(&mask);
        CPU_SET(cpu_id, &mask);
        if (pthread_setaffinity_np(pthread_self(), sizeof(mask), &mask) < 0) {
                fprintf(stderr, "set thread affinity failed\n");
        }
        /*CPU_ZERO(&get);
        if (pthread_getaffinity_np(pthread_self(), sizeof(get), &get) < 0) {
                fprintf(stderr, "get thread affinity failed\n");
        }
        for (i = 0; i < num; i++) {
                if (CPU_ISSET(i, &get)) {
                        printf("thread %d is running in processor %d\n", (int)pthread_self(), i);
                }
        }
        if (CPU_ISSET(cpu_id, &get)) {
          printf("thread %d is running in processor %d by super\n", (int)pthread_self(), cpu_id);
          }*/
}
void get_thread2kernel(void)
{
        cpu_set_t get;
        int i;
        int num = sysconf(_SC_NPROCESSORS_CONF);
        printf("system has %d processor(s) by super\n", num);
        CPU_ZERO(&get);
        if (pthread_getaffinity_np(pthread_self(), sizeof(get), &get) < 0) {
                fprintf(stderr, "get thread affinity failed\n");
        }
        for (i = 0; i < num; i++) {
                if (CPU_ISSET(i, &get)) {
                        printf("The thread %d is running in processor %d by super\n", (int)pthread_self(), i);
                }
        }
}