linux-hls-cvs

[<lu...@us...>]

Update of /cvsroot/linux-hls/hls/hls
In directory sc8-pr-cvs1:/tmp/cvs-serv15989/hls

Modified Files:
	hls_debug.c hls_names.c 
Added Files:
	hls_init.c hls_instances.c hls_params.c 
Removed Files:
	hls_utils.c 
Log Message:
- Misc cleanups
- Unbreak modular compilation
- Provide a way to move all the tasks away from HLS (echo null > /proc/HLS/default)


--- NEW FILE: hls_init.c ---
#include "hls_common.h"
#include "hls_internal.h"
#include "thr.h"

struct HLS_CALLBACKS *HLSAbsScheds[HLS_MAX_ABS_SCHEDS];
static struct HLS_SCHED_INSTANCE *HLSRootSched;
struct HLS_SCHED_INSTANCE *HLSAllSchedInsts[HLS_MAX_SCHED_INSTS];

struct HLS_SCHED_INSTANCE *HLSDefaultSched;
struct HLS_SCHED_INSTANCE *hls_rt_sched;


#ifdef __CREATE_HIERARCHY__
static struct HLS_SCHED_INSTANCE *HLSFP1 = NULL;
static struct HLS_SCHED_INSTANCE *HLSFP2 = NULL;

static struct HLS_SCHED_INSTANCE *HLSRES = NULL;
static struct HLS_SCHED_INSTANCE *HLSPS1 = NULL;

#ifdef MANY
static struct HLS_SCHED_INSTANCE *HLSFP3 = NULL;
static struct HLS_SCHED_INSTANCE *HLSFP4 = NULL;
#endif
#endif

#ifdef __INTERNAL_SCHEDULERS__
extern int rr_module_init(void);
extern int res_module_init(void);
extern int ps_module_init(void);
#endif
extern struct HLS_CALLBACKS TH_CB;
extern struct HLS_CALLBACKS ROOT_CB;
extern struct HLS_CALLBACKS JOIN_CB;

//extern int hls_setparam_ascii(struct HLS_SCHED_INSTANCE *inst, char *param);
PROCT HLSNumProcs (void)
{
  HLS_ASSERT (NR_CPUS > 0);
  return (PROCT)(int)NR_CPUS;
}

static void CreateSimpleHierarchy (void)
{
  /*
   * build the scheduling hierarchy; it's built dynamically, but for
   * now always the same way 
   */
  
#ifdef __CREATE_HIERARCHY__
  HLSFP1 = HLSNewSchedInstance ("RR", "rr1", HLSRootSched);
  HLS_ASSERT (HLSFP1);

  HLSFP2 = HLSNewSchedInstance ("RR", "rr2", HLSFP1);
  HLS_ASSERT (HLSFP2);
  SetDefPriForSched (10, HLSFP2);
  hls_setparam_ascii(HLSFP2, "10");
 
  HLSPS1 = HLSNewSchedInstance ("PS", "ps1", HLSFP1);
  HLS_ASSERT (HLSPS1);
  SetDefPriForSched (11, HLSPS1);
  hls_setparam_ascii(HLSPS1, "11");
  
  HLSRES = HLSNewSchedInstance ("RES", "res1", HLSFP1);
  HLS_ASSERT (HLSRES);
  SetDefPriForSched (20, HLSRES);
  hls_setparam_ascii(HLSRES, "20");

  // HLSDefaultSched = HLSPS1;

#ifdef HIER

  HLSFP3 = HLSNewSchedInstance ("RR", "rr3", HLSFP2);
  HLS_ASSERT (HLSFP3);
  SetDefPriForSched (10, HLSFP3);
  
  HLSFP4 = HLSNewSchedInstance ("RR", "rr4", HLSFP2);
  HLS_ASSERT (HLSFP4);
  SetDefPriForSched (11, HLSFP4);

#endif
  HLSDefaultSched = HLSFP2;
  hls_rt_sched = HLSFP1;
#endif
}

void HLSInit (void)
{
  PROCT i;
  HLS_STATUS res;
  struct HLS_SCHED_INSTANCE *hls_root_sched = NULL;

  /* 
   * Make sure that there's one debug printout that can't be
   * suppressed by setting HLS_DBG_PRINT_LEVEL to 0 
   */
#if defined(NT_UP)
#ifdef HLS_DEBUG
  DbgPrint ("HLS UP initializing (HLS_DBG_PRINT_LEVEL = %d).\n",
	    HLS_DBG_PRINT_LEVEL);
#else
  DbgPrint ("HLS UP initializing (no debugging).\n");
#endif

#else // ndef NT_UP

#ifdef HLS_DEBUG
  DbgPrint ("HLS MP initializing (HLS_DBG_PRINT_LEVEL = %d).\n",
	    HLS_DBG_PRINT_LEVEL);
#else
  DbgPrint ("HLS MP initializing (no debugging).\n");
#endif

#endif // def NT_UP

  for (i=0; i<MAX_PROCS; i++) {
    HLSProc[i].CurrentThread = NULL;
  }

  {
    int j;
    for (j=0; j<HLS_MAX_SCHED_INSTS; j++) {
      HLSAllSchedInsts[j] = NULL;
    }
  }

  { 
    int j;
    for (j=0; j<HLS_MAX_ABS_SCHEDS; j++) {
      HLSAbsScheds[j] = NULL;
    }
  }

  res = HLSRegisterScheduler(&ROOT_CB);
  HLS_ASSERT(res == HLS_SUCCESS);

  hls_root_sched = HLSNewSchedInstance("ROOT", "root", NULL);
  HLS_ASSERT(hls_root_sched);
  HLSRootSched = hls_root_sched;

  res = HLSRegisterScheduler (&JOIN_CB);
  HLS_ASSERT(res == HLS_SUCCESS);

  res = HLSRegisterScheduler (&TH_CB);
  HLS_ASSERT (res == HLS_SUCCESS);
    
#ifdef __INTERNAL_SCHEDULERS__
  res = rr_module_init();
  HLS_ASSERT (res == 0);

  res = ps_module_init();
  HLS_ASSERT (res == 0);

  res = res_module_init();
  HLS_ASSERT (res == 0);
  
  CreateSimpleHierarchy ();
#endif
  
  HLSInitState++;
}

void HLSDeinit (void)
{
  int i = 0;
  struct HLS_SCHED_INSTANCE *sched;

#if 0
#ifdef HIER
  HLSDestroySchedInstance (HLSFP3);
  HLSDestroySchedInstance (HLSFP4);
#endif
  {
    struct HLS_SCHED_INSTANCE *res = HLSFindInstByName ("res1");
    if (res) { 
      HLSDestroySchedInstance (res);
    }
  }
  HLSDestroySchedInstance (HLSPS1);
  HLSDestroySchedInstance (HLSFP2);
  HLSDestroySchedInstance (HLSFP1);

#else
  for (i = HLS_MAX_SCHED_INSTS - 1; i >= 0; i--) {
    sched = HLSAllSchedInsts[i];
    if (sched != NULL) {
      if (strcmp(sched->Type, "root")){
        HLSDestroySchedInstance(sched);
      }	
    }
  }
#endif
  HLSDestroySchedInstance (HLSRootSched);
}


--- NEW FILE: hls_instances.c ---
#include "hls_common.h"
#include "hls_internal.h"
#include "thr.h"

extern struct HLS_CALLBACKS *HLSAbsScheds[HLS_MAX_ABS_SCHEDS];

struct HLS_SCHED_INSTANCE *HLSFindInstByName (char *Name)
{
  int i;
  int index = -1;

  for (i=0; i<HLS_MAX_SCHED_INSTS; i++) {
    if (HLSAllSchedInsts[i] && strcmp (HLSAllSchedInsts[i]->Name, Name) == 0) {
      HLS_ASSERT (index == -1);  // enforce no duplicates
      index = i;
    }
  }

  return (index == -1) ? NULL : HLSAllSchedInsts[index];
}

static int HLSFindInstIndex (struct HLS_SCHED_INSTANCE *Inst)
{
  int i;
  int index = -1;

  for (i=0; i<HLS_MAX_SCHED_INSTS; i++) {
    if (HLSAllSchedInsts[i] == Inst) {
      HLS_ASSERT (index == -1);
      index = i;
    }
  }

  return index;
}

HLS_STATUS HLSRegisterScheduler (struct HLS_CALLBACKS *NewSchedCB)
{
  int i;

  for (i=0; i<HLS_MAX_ABS_SCHEDS; i++) {
    if (!HLSAbsScheds[i]) {
      HLSAbsScheds[i] = NewSchedCB;
      HLSDbgPrint (1, ("sched '%s' registered in slot %d\n", NewSchedCB->Name, i));
      return HLS_SUCCESS;
    }
  }

  return HLS_NOROOM;
}

HLS_STATUS HLSUnregisterScheduler (struct HLS_CALLBACKS *NewSchedCB)
{
  // FIXME
  return HLS_SUCCESS;
}

struct HLS_CALLBACKS * HLSFindAbsSched (char *SchedName)
{
  int x;
  for (x=0; x<HLS_MAX_ABS_SCHEDS; x++) {
    if (HLSAbsScheds[x] && strcmp (SchedName, HLSAbsScheds[x]->Name) == 0) {
      return HLSAbsScheds[x];
    }
  }
  return NULL;
}

struct HLS_SCHED_INSTANCE *HLSNewSchedInstance (char *SchedName,
						char *InstName,
						struct HLS_SCHED_INSTANCE *Parent)
{
  struct HLS_CALLBACKS *CB = NULL;
  struct HLS_SCHED_INSTANCE *i;

  CB = HLSFindAbsSched (SchedName);
  if (!CB) {
    HLSDbgPrint (1, ("HLSNewSchedInstance: can't find instance named '%s'\n",
		     SchedName));
    return NULL;
  }
  
  if (HLSFindInstByName (InstName)) {
    HLSDbgPrint (1, ("Oops: sched by the name of %s already exists\n",
		     InstName));
    return NULL;
  }

  i = (struct HLS_SCHED_INSTANCE *) hls_malloc (sizeof (struct HLS_SCHED_INSTANCE));

  if (!i) {
    HLSDbgPrint (1, ("HLSNewSchedInstance: oops - malloc failed\n"));
    return NULL;
  }

  i->CB = CB;
  strncpy (i->Name, InstName, MAX_NAMELEN);

  if (HLSNumScheds >= HLS_MAX_SCHED_INSTS) {
    HLSDbgPrint (1, ("oops: out of sched slots\n"));
    return NULL;
  }
  HLSNumScheds++;

  {
    int x;
    HLS_ASSERT (HLSFindInstIndex (i) == -1);
    
    for (x=0; x<HLS_MAX_SCHED_INSTS; x++) {
      if (!HLSAllSchedInsts[x]) {
	HLSAllSchedInsts[x] = i;
	break;
      }
    }
    HLS_ASSERT (HLSFindInstIndex (i) != -1);
  }

  init_timer(&(i->HLSTimer));
#if 0
  KeInitializeDpc (&(i->HLSDpc), 
		   (PKDEFERRED_ROUTINE) HLSDpcRoutine,
		   (void *)i);
#endif
  i->CB->I_Init (i, Parent);

  HLSDbgPrint (7, ("HLSNewSchedInstance: new instance '%s' of '%s' successfully created\n", 
		   InstName, SchedName));

  return i;
}

void HLSDestroySchedInstance (struct HLS_SCHED_INSTANCE *Inst)
{
  hls_stop_timer(Inst);
  Inst->CB->I_Deinit (Inst);

  {
    int i = HLSFindInstIndex (Inst);
    HLS_ASSERT (i != -1);
    HLSAllSchedInsts[i] = NULL;
  }

  HLSNumScheds--;
  hls_free (Inst);
}

void HLSDestroySchedInstanceLite (struct HLS_SCHED_INSTANCE *Inst)
{
  {
    int i = HLSFindInstIndex (Inst);
    HLS_ASSERT (i != -1);
    HLSAllSchedInsts[i] = NULL;
  }

  HLSNumScheds--;
  hls_free (Inst);
}



--- NEW FILE: hls_params.c ---
#include "hls_common.h"
#include "hls_internal.h"
#include "thr.h"

struct TH_INSTANCE_DATA *HLSFindThread (PRKTHREAD Thread)
{
  struct TH_INSTANCE_DATA *p;

  if (HLSInitState != 1) {
    return NULL;
  }

  if (!Thread) {
    return NULL;
  }

/*  p = (struct TH_INSTANCE_DATA *)(((PKTHREAD)Thread)->private_data); */
  p = (struct TH_INSTANCE_DATA *)HLS_DATA((PKTHREAD)Thread);
#ifdef HLS_DEBUG
  if (p) {
    HLS_ASSERT (p->ObjType == ThInstValue);
  }
#endif
  return p;
}

int hls_setparam_ascii(struct HLS_SCHED_INSTANCE *inst, char *param)
{
  struct hls_message msg;
  int res;

#ifdef HLS_DEBUG
  msg.ObjType = RRMsgValue;
#endif
  msg.type = MSG_SENDSETPARAM;
  msg.body = param;
  msg.Pri = 1;

  
  res = inst->CB->B_Msg(inst, NULL, (MsgHandle)&msg);
  if (res != HLS_SUCCESS) {
    return -1;
  }

  return 0;
}

HLS_STATUS HLSSetPri(PRKTHREAD Thread, KPRIORITY Priority)
{
  struct hls_message NewMsg;
  struct TH_INSTANCE_DATA *Th = HLSFindThread (Thread);
  HLS_STATUS status;

  if (!Th) {
    HLSDbgPrint (1, ("Hrm: hls doesn't know about thread %p that is being set to pri %d\n",
		     Thread, Priority));
    return HLS_INVALID_PARAMETER;
  }

#ifdef HLS_DEBUG
  HLSChangeFlag = HLS_CNT;
  NewMsg.ObjType = RRMsgValue;
#endif
  NewMsg.type = MSG_SETPRI;
  NewMsg.body = NULL;
  NewMsg.Pri = (SCHAR) Priority;
  if (NewMsg.Pri == 0) {
    NewMsg.Pri = 1;
  }
  status = Th->vp->TopSched->CB->B_Msg(NULL, Th->vp, (MsgHandle)&NewMsg);
  return status;
}

void SetDefPriForSched (char Pri, struct HLS_SCHED_INSTANCE *Inst)
{
  struct hls_message NewMsg; 
  HLS_STATUS status;
  
#ifdef HLS_DEBUG
  NewMsg.ObjType = RRMsgValue;
#endif
  NewMsg.type = MSG_SETDEFPRI;
  NewMsg.Pri = Pri;
  NewMsg.body = NULL;
  status = Inst->CB->B_Msg (Inst, NULL, (MsgHandle)&NewMsg);
  HLS_ASSERT (status == HLS_SUCCESS);
}

Index: hls_debug.c
===================================================================
RCS file: /cvsroot/linux-hls/hls/hls/hls_debug.c,v
retrieving revision 1.5
retrieving revision 1.6
diff -C2 -d -r1.5 -r1.6
*** hls_debug.c	8 Nov 2003 10:34:31 -0000	1.5
--- hls_debug.c	13 Dec 2003 12:27:15 -0000	1.6
***************
*** 48,51 ****
--- 48,52 ----
  
  #ifdef HLS_DEBUG
+ #if 0
  void _hls_assertion_failed (const char *assertion, int line, 
  			    const char *file)
***************
*** 62,66 ****
  #endif
  }
! 
  char *StateName (KTHREAD_STATE s)
  {
--- 63,67 ----
  #endif
  }
! #endif
  char *StateName (KTHREAD_STATE s)
  {

Index: hls_names.c
===================================================================
RCS file: /cvsroot/linux-hls/hls/hls/hls_names.c,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** hls_names.c	29 Nov 2003 09:11:34 -0000	1.1
--- hls_names.c	13 Dec 2003 12:27:15 -0000	1.2
***************
*** 31,39 ****
    wasnull = 0;
    if (HLSDefaultSched == NULL) {
!     wasnull =1;
    }
    HLSDefaultSched = p;
!   if (wasnull) {
!     hls_convert_tasks();
    }
  }
--- 31,43 ----
    wasnull = 0;
    if (HLSDefaultSched == NULL) {
!     wasnull = 1;
    }
    HLSDefaultSched = p;
!   if (HLSDefaultSched == NULL) {
!     hls_release_tasks();
!   } else {
!     if (wasnull) {
!       hls_convert_tasks();
!     }
    }
  }

--- hls_utils.c DELETED ---