IssueTable.xcc

Benoit Dupont de Dinechin (Benoit.Dupont-de-Dinechin@st.com).

Copyright 2002 - 2007 STMicroelectronics. Copyright 1995 - 1998 Commissariat a l'Energie Atomique.

This program is free software; you can redistribute it and/or modify it under the terms of either (at your option): the GNU General Public License (GPL) version 2; the GNU Lesser General Public License (LGPL) version 2.1; any later version of these licences as published by the Free Software Foundation.

IssueItem— Item to represents an Operation in an IssueTable.
struct IssueItem_ {
  //@args       Operation operation, Instance instance
  //@access NEXT                (IssueItem)(IDListItem_NEXT(this))
  //@access PREV                (IssueItem)(IDListItem_PREV(this))
  InstructionTask_ TASK[1];             // The InstructionTask of this Instruction.
  //@access OPERATION   (Operation)InstructionTask_INDEXED(IssueItem_TASK(this))
  //@mutate OPERATION   (Operation *)InstructionTask__INDEXED(IssueItem_TASK(this))
  //@access INDEX       InstructionTask_INDEX(IssueItem_TASK(this))
  //@mutate INDEX       InstructionTask__INDEX(IssueItem_TASK(this))
  //@access FLAGS       InstructionTask_FLAGS(IssueItem_TASK(this))
  //@mutate FLAGS       InstructionTask__FLAGS(IssueItem_TASK(this))
  //@access isControl   InstructionTask_isControl(IssueItem_TASK(this))
  //@access isVolatile  InstructionTask_isVolatile(IssueItem_TASK(this))
  //@access isMemoryRead        InstructionTask_isMemoryRead(IssueItem_TASK(this))
  //@access isMemoryWrite       InstructionTask_isMemoryWrite(IssueItem_TASK(this))
  //@access isInductive InstructionTask_isInductive(IssueItem_TASK(this))
  //@access isSPUpdate  InstructionTask_isSPUpdate(IssueItem_TASK(this))
  //@access isInProlog  InstructionTask_isInProlog(IssueItem_TASK(this))
  //@access isKunrolled InstructionTask_isKunrolled(IssueItem_TASK(this))
  //@access INSTANCE    InstructionTask_INSTANCE(IssueItem_TASK(this))
  //@access SCHEDULING  InstructionTask_SCHEDULING(IssueItem_TASK(this))
  //@mutate SCHEDULING  InstructionTask__SCHEDULING(IssueItem_TASK(this))
  //@access RESERVATION InstructionTask_RESERVATION(IssueItem_TASK(this))
  //@access PROCESSING  InstructionTask_PROCESSING(IssueItem_TASK(this))
  //@access ITERATION   InstructionTask_ITERATION(IssueItem_TASK(this))
  //@mutate ITERATION   InstructionTask__ITERATION(IssueItem_TASK(this))
  //@access ORDERING    InstructionTask_ORDERING(IssueItem_TASK(this))
  //@mutate ORDERING    InstructionTask__ORDERING(IssueItem_TASK(this))
  //@access STARTDATE   InstructionTask_STARTDATE(IssueItem_TASK(this))
  //@mutate STARTDATE   InstructionTask__STARTDATE(IssueItem_TASK(this))
  //@access RELEASE     InstructionTask_RELEASE(IssueItem_TASK(this))
  //@mutate RELEASE     InstructionTask__RELEASE(IssueItem_TASK(this))
  //@access CRITICAL    InstructionTask_CRITICAL(IssueItem_TASK(this))
  //@mutate CRITICAL    InstructionTask__CRITICAL(IssueItem_TASK(this))
  //@access PREDCOUNT   InstructionTask_PREDCOUNT(IssueItem_TASK(this))
  //@mutate PREDCOUNT   InstructionTask__PREDCOUNT(IssueItem_TASK(this))
  const_ReservationTable TABLE;         // This IssueItem ReservationTable.
  //@access COLUMNS     ReservationTable_COLUMNS(IssueItem_TABLE(this))
  //@access REQUIREMENTS        ResourceVector_UNITS(IssueItem_COLUMNS(this))
  int16_t CONTROLID;                    // This IssueItem controlId number.
  struct DDGraphNode_ *DDGNODES[3];     // The DDGraphNodes for this IssueItem.
  //@access EARLYNODE   (IssueItem_DDGNODES(this)[DDGraphKind_Early])
  //@access LATENODE    (IssueItem_DDGNODES(this)[DDGraphKind_Late])
  //@access MCRLNODE    (IssueItem_DDGNODES(this)[DDGraphKind_MCRL])
  struct CFGArc_ *EXITARC;              // The exit CFGArc in case of exit.
  struct CFGArc_ *FALLARC;              // The fall-through CFGArc.
};
IssueItem_pretty— Pretty-print this IssueItem.
bool
IssueItem_pretty(IssueItem this, FILE *file);
IssueGroup— Group of IssueItems that may issue simultaneously.
struct IssueGroup_ {
  //@args       const uint8_t *availability
#if Bundle_ISSUE_MAX
  IssueItem ITEMS[Bundle_ISSUE_MAX];
#endif//Bundle_ISSUE_MAX
  const uint8_t *AVAILABILITY;
  uint8_t ITEMCOUNT;
  uint8_t COUNTERS[Resource__FIXME];
};
IssueGroup_itemCount— Count this IssueGroup IssueItems.
static inline int
IssueGroup_itemCount(IssueGroup this)
{
  return IssueGroup_ITEMCOUNT(this);
}
IssueGroup_items— Needed by IssueGroup_FOREACH_IssueItem.
static inline IssueItem *
IssueGroup_items(IssueGroup this)
{
  return IssueGroup_ITEMS(this);
}
IssueGroup_FOREACH_Resource— Iterate over this IssueGroup Resources.
#define IssueGroup_FOREACH_Resource(this, resource) { \
  int IssueGroup_RESOURCE = Resource__UNDEF + 1; \
  for (; IssueGroup_RESOURCE < Resource__COUNT; IssueGroup_RESOURCE++) { \
    Resource resource = IssueGroup_RESOURCE;
#define IssueGroup_ENDEACH_Resource \
  } \
}
IssueGroup_FOREACH_IssueItem— Iterate over this IssueGroup ITEMS.
#define IssueGroup_FOREACH_IssueItem(this, item) { \
  IssueItem *IssueGroup_ITEMS = IssueGroup_items(this); \
  int IssueGroup_ITEMCOUNT = IssueGroup_itemCount(this), IssueGroup_I; \
  for (IssueGroup_I = 0; IssueGroup_I < IssueGroup_ITEMCOUNT; IssueGroup_I++) { \
    IssueItem item = IssueGroup_ITEMS[IssueGroup_I];
#define IssueGroup_ENDEACH_IssueItem \
  } \
}
IssueGroup_pretty— Pretty-print this IssueGroup.
bool
IssueGroup_pretty(IssueGroup this, FILE *file);
IssueGroup_check— Check this IssueGroup invariants.
bool
IssueGroup_check(IssueGroup this);
IssueGroup_clear— Clear the contents of this IssueGroup.
static inline void
IssueGroup_clear(IssueGroup this)
{
  const uint8_t *availability = IssueGroup_AVAILABILITY(this);
  IssueGroup_Dtor(this), IssueGroup_Ctor(this, availability);
}
IssueGroup_conflict— Find a conflict between this IssueGroup and that IssueItem.
IssueItem
IssueGroup_conflict(IssueGroup this, IssueItem item);
IssueGroup_accept— Check if this IssueGroup may accept that IssueItem.
bool
IssueGroup_accept(IssueGroup this, IssueItem item);
IssueGroup_insert— Insert an IssueItem into this IssueGroup.
void
IssueGroup_insert(IssueGroup this, IssueItem item);
IssueGroup_remove— Remove that IssueItem from this IssueGroup.
void
IssueGroup_remove(IssueGroup this, IssueItem item);
IssueTable— Table of IssueGroups.
struct IssueTable_ {
  //@args       Memory memory, const uint8_t *availability
  IStack_ GROUPS_;                      // The inlined IssueGroups.
  //@access GROUPS      IssueTable__GROUPS_(this)
  //@access MEMORY      IStack_memory(IssueTable_GROUPS(this))
  //@access LASTGROUP   (IssueGroup_ *)IStack_lastItem(IssueTable_GROUPS(this))
  //@access BASEGROUP   (IssueGroup_ *)IStack_base(IssueTable_GROUPS(this))
  //@access PASTGROUP   (IssueGroup_ *)IStack_past(IssueTable_GROUPS(this))
  //@access LAMBDA      (IStack_usedSize(IssueTable_GROUPS(this))/sizeof(IssueGroup_))
  const uint8_t *AVAILABILITY;          // The Processor_availability.
  int32_t DELTAS;                       // Sum of the deltas.
  int32_t COUNTERS[Resource__FIXME];    // Global Resource counters.
};
IssueTable_memory— This IssueTable memory.
static inline Memory
IssueTable_memory(IssueTable this)
{
  return IssueTable_MEMORY(this);
}
IssueTable_lambda— This IssueTable lambda.
static inline int
IssueTable_lambda(IssueTable this)
{
  return IssueTable_LAMBDA(this);
}
IssueTable_availability— This IssueTable availability.
static inline const uint8_t *
IssueTable_availability(IssueTable this)
{
  return IssueTable_AVAILABILITY(this);
}
IssueTable_deltas— This IssueTable deltas.
static inline int
IssueTable_deltas(IssueTable this)
{
  return IssueTable_DELTAS(this);
}
IssueTable_counters— This IssueTable Resource counters.
static inline int32_t *
IssueTable_counters(IssueTable this)
{
  return IssueTable_COUNTERS(this);
}
IssueTable_FOREACH_Resource— Iterate over this IssueTable Resources.
#define IssueTable_FOREACH_Resource(this, resource) { \
  int IssueTable_RESOURCE = Resource__UNDEF + 1; \
  for (; IssueTable_RESOURCE < Resource__COUNT; IssueTable_RESOURCE++) { \
    Resource resource = IssueTable_RESOURCE;
#define IssueTable_ENDEACH_Resource \
  } \
}
IssueTable_FOREACH_IssueGroup— Iterate over this IssueTable IssueGroups.
#define IssueTable_FOREACH_IssueGroup(this, group) \
  IStack_FOREACH(IssueTable_GROUPS(this), IssueGroup_, group) {
#define IssueTable_ENDEACH_IssueGroup \
  } IStack_ENDEACH;
IssueTable_prettyCounters— Pretty-print this IssueTable COUNTERS.
bool
IssueTable_prettyCounters(IssueTable this, FILE *file);
IssueTable_pretty— Pretty-print this IssueTable.
bool
IssueTable_pretty(IssueTable this, FILE *file);
IssueTable_check— Check this IssueTable invariants.
bool
IssueTable_check(IssueTable this);
IssueTable_enter— Enter that IssueItem in this IssueTable.
void
IssueTable_enter(IssueTable this, IssueItem item);
IssueTable_estimateLambda— Return an estimate of LAMBDA resources.
int
IssueTable_estimateLambda(IssueTable this);
IssueTable_ready— Ready the contents of this IssueTable for scheduling.
void
IssueTable_ready(IssueTable this, int lambda);
IssueTable_access— Access an IssueGroup in this IssueTable.
static inline IssueGroup
IssueTable_access(IssueTable this, int moduloDate)
{
  IssueGroup baseGroup = IssueTable_BASEGROUP(this);
  Except_REQUIRE(moduloDate >= 0 && moduloDate < IssueTable_LAMBDA(this));
  return baseGroup + moduloDate;
}
IssueTable_assign— Assign an IssueGroup in this IssueTable.
IssueGroup
IssueTable_assign(IssueTable this, int moduloDate, IssueGroup group);
IssueTable_accept— Test acceptance of that IssueItem at moduloDate in this IssueTable.
Return
Number of cycles this IssueTable needs to be enlarged to accept the Scheduling.
int
IssueTable_accept(IssueTable this, IssueItem item, int moduloDate);
IssueTable_insert— Insert that IssueItem at moduloDate into this IssueTable.
void
IssueTable_insert(IssueTable this, IssueItem item, int moduloDate);
IssueTable_remove— Remove that IssueItem at moduloDate from this IssueTable.
void
IssueTable_remove(IssueTable this, IssueItem item, int moduloDate);
IssueTable_growAt— Grow this IssueTable ap moduloDate for delta cycles.
void
IssueTable_growAt(IssueTable this, int moduloDate, int delta);
IssueTable_shrinkTo— Shrink this IssueTable to lambda.
int
IssueTable_shrinkTo(IssueTable this, int lambda);
IssueTable_sortResources— Sort the resources by decreasing usage.
int
IssueTable_sortResources(IssueTable this, Resource resources[]);