openairinterface5g/openair2/LAYER2/PDCP_v10.1.0/pdcp_thread.c

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

  Eurecom OpenAirInterface
  Copyright(c) 1999 - 2011 Eurecom

  This program is free software; you can redistribute it and/or modify it
  under the terms and conditions of the GNU General Public License,
  version 2, as published by the Free Software Foundation.

  This program is distributed in the hope 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
  this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

  The full GNU General Public License is included in this distribution in
  the file called "COPYING".

  Contact Information
  Openair Admin: openair_admin@eurecom.fr
  Openair Tech : openair_tech@eurecom.fr
  Forums       : http://forums.eurecom.fsr/openairinterface
  Address      : Eurecom, 2229, route des crêtes, 06560 Valbonne Sophia Antipolis, France

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

/*! \file pdcp_thread.c
* \brief
* \author F. Kaltenberger
* \date 2013
* \version 0.1
* \company Eurecom
* \email: florian.kaltenberger@eurecom.fr
* \note
* \warning
*/
#include <pthread.h>
//#include <inttypes.h>

#include "pdcp.h"
#include "PHY/extern.h" //for PHY_vars
#include "UTIL/LOG/log.h"
#include "UTIL/LOG/vcd_signal_dumper.h"

#define OPENAIR_THREAD_STACK_SIZE    8192
#define OPENAIR_THREAD_PRIORITY        255

extern int oai_exit;
extern char UE_flag;

pthread_t pdcp_thread;
pthread_attr_t pdcp_thread_attr;
pthread_mutex_t pdcp_mutex;
pthread_cond_t pdcp_cond;
int pdcp_instance_cnt;

static void *pdcp_thread_main(void* param);

static void *pdcp_thread_main(void* param) {

  //u8 eNB_flag = *((u8*)param);
  u8 eNB_flag = !UE_flag;

  LOG_I(PDCP,"This is pdcp_thread eNB_flag = %d\n",eNB_flag);

  while (!oai_exit) {

    if (pthread_mutex_lock(&pdcp_mutex) != 0) {
        LOG_E(PDCP,"Error locking mutex.\n");
    }
    else {
        while (pdcp_instance_cnt < 0) {
            pthread_cond_wait(&pdcp_cond,&pdcp_mutex);
        }
        if (pthread_mutex_unlock(&pdcp_mutex) != 0) {	
            LOG_E(PDCP,"Error unlocking mutex.\n");
        }
    }

    if (oai_exit) break;

    if (eNB_flag) {
      pdcp_run(PHY_vars_eNB_g[0]->frame, eNB_flag, PHY_vars_eNB_g[0]->Mod_id, 0);
      LOG_D(PDCP,"Calling pdcp_run (eNB) for frame %d\n",PHY_vars_eNB_g[0]->frame);
    }
    else  {
      pdcp_run(PHY_vars_UE_g[0]->frame, eNB_flag, 0, PHY_vars_UE_g[0]->Mod_id);
      LOG_D(PDCP,"Calling pdcp_run (UE) for frame %d\n",PHY_vars_UE_g[0]->frame);
    }


    if (pthread_mutex_lock(&pdcp_mutex) != 0) {
      LOG_E(PDCP,"Error locking mutex.\n");
    }
    else {
        pdcp_instance_cnt--;
        if (pthread_mutex_unlock(&pdcp_mutex) != 0) {	
	  LOG_E(PDCP,"Error unlocking mutex.\n");
        }
    }
  }
  return(NULL);
}



int init_pdcp_thread(void) {

    int error_code;
    struct sched_param p;

    pthread_attr_init (&pdcp_thread_attr);
    pthread_attr_setstacksize(&pdcp_thread_attr,OPENAIR_THREAD_STACK_SIZE);
    //attr_dlsch_threads.priority = 1;
    
    p.sched_priority = OPENAIR_THREAD_PRIORITY;
    pthread_attr_setschedparam  (&pdcp_thread_attr, &p);
#ifndef RTAI_ISNT_POSIX
    pthread_attr_setschedpolicy (&pdcp_thread_attr, SCHED_FIFO);
#endif
    pthread_mutex_init(&pdcp_mutex,NULL);
    pthread_cond_init(&pdcp_cond,NULL);

    pdcp_instance_cnt = -1;
    LOG_I(PDCP,"Allocating PDCP thread\n");
    error_code = pthread_create(&pdcp_thread,
				&pdcp_thread_attr,
				pdcp_thread_main,
				(void*)NULL);
      
    if (error_code!= 0) {
      LOG_I(PDCP,"Could not allocate PDCP thread, error %d\n",error_code);
      return(error_code);
    }
    else {
      LOG_I(PDCP,"Allocate PDCP thread successful\n");
    }
       
    return(0);
}

void cleanup_pdcp_thread(void) {
  void *status;

  LOG_I(PDCP,"Scheduling PDCP thread to exit\n");
  
  pdcp_instance_cnt = 0;
  if (pthread_cond_signal(&pdcp_cond) != 0)
    LOG_I(PDCP,"ERROR pthread_cond_signal\n");
  else
    LOG_I(PDCP,"Signalled PDCP thread to exit\n");

  pthread_join(pdcp_thread,&status);
  LOG_I(PDCP,"PDCP thread exited\n");
  pthread_cond_destroy(&pdcp_cond);
  pthread_mutex_destroy(&pdcp_mutex);
}