Relaxation.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.

RelaxationItem— Implement a relaxation item to schedule.
struct RelaxationItem_;
  //@args       const uint8_t *requirements, DDGraphNode node, int iteration
RelaxationItem_pretty— Pretty-print this RelaxationItem.
bool
RelaxationItem_pretty(RelaxationItem this, FILE *file);
RelaxationItemTable— Table of RelaxationItem(s) indexed by node and iteration.
struct RelaxationItemTable_;
  //@args       Memory memory, int unwinding,
  //@args       int32_t listCount, int16_t *_lambda
RelaxationItemTable_completeDeadlines— Complete the deadlines in the stationary case.
void
RelaxationItemTable_completeDeadlines(RelaxationItemTable this, RelaxationItem firstItem);
RelaxationItemTable_pretty— Pretty-print this RelaxationItemTable.
bool
RelaxationItemTable_pretty(RelaxationItemTable this, FILE *file);
RelaxationStepFlag— Enumerates the RelaxationStep flags.
typedef enum {
  RelaxationStepFlag_Sorted = 0x1       // RelaxationStep RelaxationItem(s) are sorted.
} enum_RelaxationStepFlag;
typedef uint8_t RelaxationStepFlags;
RelaxationStep— Implement a relaxation step.

In a relaxation step, a list of RelaxationItems is available with their release and deadline dates initialized. We first compute the transitive latencies between the first RelaxationItem, and all the others. Then at each scheduling step the release and the deadline dates of the FastListTask(s) are updated using the transitive latencies, and the FastList scheduler is called over the resources to check the feasibility of this RelaxationStep.

Usage: * RelaxationStep_new * RelaxationStep_enterItems * Relaxation_runRelaxationStep * RelaxationStep_delete

struct RelaxationStep_;
  //@args       Memory memory, RelaxationItemTable itemTable,
  //@args       RelaxationItem firstItem, const uint8_t *availability
RelaxationStep_pretty— Pretty-print this RelaxationStep.
bool
RelaxationStep_pretty(RelaxationStep this, FILE *file);
RelaxationKind— enumerates the Relaxation kinds.
typedef enum {
  RelaxationKind_Forward,       // Forward scheduling Relaxation.
  RelaxationKind_Backward,      // Backward scheduling Relaxation.
  RelaxationKind__
} enum_RelaxationKind;
typedef uint8_t RelaxationKind;
extern const char *
RelaxationKind_name_(RelaxationKind this);
Relaxation— Implementation of a forward or backward relaxation for scheduling problems.

Based on "Scheduling Time-Constrained Instructions on Pipelined Processors" by A. Leung, K. V. Palem, A. Pnueli. This relaxation framework has been extended for dealing with multiple resources (Resources) and with forward relaxation.

Usage of a Relaxation: * Relaxation_new * Relaxation_enterGrahamList * Relaxation_readDates * Relaxation_testFeasibility * Relaxation_writeDates * Relaxation_delete

struct Relaxation_;
  //@args       Memory memory, RelaxationKind kind,
  //@args       GrahamList grahamList, int unwinding
Relaxation_pretty— Pretty-print this Relaxation.
bool
Relaxation_pretty(Relaxation this, FILE *file);