Changeset 2187 in Sophya for trunk/ArchTOIPipe/Kernel/toiprocessor.cc

Timestamp:

Sep 9, 2002, 5:33:16 PM (23 years ago)

Author:

aubourg

Message:

Vivien, limites processors et connect

File:

• trunk/ArchTOIPipe/Kernel/toiprocessor.cc (modified) (7 diffs)

trunk/ArchTOIPipe/Kernel/toiprocessor.cc

@@ -3 +3 @@
 //                               Christophe Magneville
 //                               Reza Ansari
-// $Id: toiprocessor.cc,v 1.25 2002-07-26 08:52:43 vfebvre Exp $
+// $Id: toiprocessor.cc,v 1.26 2002-09-09 15:33:15 aubourg Exp $
 
 #include "toiprocessor.h"
@@ -46 +46 @@
   wontNeedValue = -1;
 
+  
+  // ajout vf 23/07/2002
+  cout << "Creating processor" << endl;
   // Pour referencer un TOIProcessor, il faut recuperer le TOIManager correspondant
   TOIManager::getManager()->registerProcessor(this);
+  
+  // initialisation des limites du sample (par defaut tout le fichier)
+  snBegin = 0;
+  snEnd = MAXINT;
+  snMin=MAXINT;
+  snMax=0;
+  // par defaut aucune condition
+  requestedSample = false;
 
 }
@@ -83 +94 @@
 
 int TOIProcessor::getMinOut() {
+  /*
   //cout << name << "minout" << endl;
   if (minOut < 0)  minOut = calcMinOut();
   //cout << name << "minout=" << minOut << endl;
   return minOut;
+  */
+  return snBegin + lowExtra;
 }
 
 int TOIProcessor::getMaxOut() {
+  /*
   //cout << name << "maxout" << endl;
   if (maxOut < 0) maxOut = calcMaxOut();
   //cout << name << "maxout=" << maxOut << endl;
   return maxOut;
+  */
+  return snEnd - upExtra;
 }
 
@@ -105 +122 @@
 
 int TOIProcessor::getMinIn() {
+  /*
   int nIn = inIx.size();
   int minIn = 0;
@@ -115 +133 @@
   if (forcedMinIn > 0 && forcedMinIn > minIn) minIn = forcedMinIn;
   return minIn;
+  */
+  return snBegin;
 }
 
 int TOIProcessor::getMaxIn() {
+  /*
   int_4 nIn = inIx.size();
   int_4 maxIn = MAXINT;
@@ -128 +149 @@
   if (forcedMaxIn > 0 && forcedMaxIn < maxIn) maxIn = forcedMaxIn;
   return maxIn;
+  */
+  return snEnd;
 }
 
@@ -447 +470 @@
 
 
-
-
-
-
-
-
-
+// ajout vf 29/07/2002
+
+// parametrage de l'echantillon a produire (sans verification)
+void TOIProcessor::setRequestedSample(long begin, long end) {
+  requestedSample = true;
+  snBegin = begin;
+  snEnd   = end;
+  //  snMin = snBegin;
+  //  snMax = snEnd; 
+}
+
+
+bool TOIProcessor::checkSampleLimits(int pass)
+{
+  long minTmp=MAXINT;
+  long maxTmp=-1;
+
+  return checkSampleLimits(minTmp, maxTmp, pass);
+  
+  cout << "toiprocessor : limites verifiees : " << snBegin << " , " << snEnd << " : " << endl;
+}
+
+
+
+
+bool TOIProcessor::checkSampleLimits(long& min, long& max, int pass)
+{
+  bool sample_input_ok=true;
+  bool sample_ok=true;
+
+  /*  cout << "check " << pass << " " << name << " in  " << min << " - " << max << " ; " 
+       << snMin << " - " << snMax << " ; " 
+       << snBegin << " - " << snEnd << endl;*/
+
+  if (pass == 3) {
+    if (snMin < snMax) {
+      snBegin = snMin;
+      snEnd   = snMax;
+    }
+    return true;
+  }
+
+  // on verifie qu'on peut effectivement produire
+
+  if (min < snBegin) {
+    min = snBegin;
+  }
+
+  if (max > snEnd) {
+    max = snEnd;
+  }
+
+  bool noConst = (min>max);
+
+  if (pass == 2 && noConst) {
+    min = snBegin;
+    max = snEnd;
+  }
+
+  
+  int n = inIx.size();
+  // parcours de toutes les entrees et mise a jour au plus restrictif
+  for (int i=0; i<n; i++) {
+    TOI* toi = inTOIs[i];
+    if (toi) {
+      // mise a jour des limites avec les marges si definies
+      long min_Input;
+      long max_Input;
+      if (min>0) {
+        min_Input = min - lowExtra;
+      } else {
+        min_Input = min;
+      }
+      if (max<MAXINT) {
+        max_Input = max + upExtra;
+      } else {
+        max_Input = max;
+      }
+      // propagation des limites
+      sample_input_ok = toi->checkSampleLimits(min_Input, max_Input, pass);
+
+      //Ajustement des limites si plus restrictif
+      if (min < max) {
+        // On nous a demande des bornes ->
+        if ((min_Input + lowExtra)  > min) {
+          min = min_Input + lowExtra;
+        }
+        if ((max_Input - upExtra) < max) {
+          max = max_Input - upExtra;
+        }
+      } else {
+        // On nous demande tout ce qu'on peut faire -> MAJ snBegin
+        if ((min_Input + lowExtra) > snBegin) {
+          snBegin = min_Input + lowExtra;
+        }
+        if ((max_Input - upExtra) < snEnd) {
+          snEnd = max_Input - upExtra;
+        }
+      }
+      if (sample_input_ok == false) {
+        sample_ok = false;
+      }
+    }    
+  }  
+
+  
+  
+  
+  //Ajustement des limites si intervalle plus large
+  if (!noConst) {
+    if (min < snMin) {
+      snMin = min;
+    }
+    if (max > snMax) {
+      snMax = max;
+    }
+  }
+  
+  min=min<snMin?snMin:min;
+  max=max>snMax?snMax:max;
+  
+  
+  // cas sans contraintes, on retourne nos bornes
+  if (min>max) {
+    min = snBegin;
+    max = snEnd;
+  }
+  
+  /*  cout << "check " << pass << " " << name << " out " << min << " - " << max << " ; "
+       << snMin << " - " << snMax << " ; " 
+       << snBegin << " - " << snEnd << endl;*/
+  return sample_ok;
+}
+
+
+
+
+// pour verification si le processeur est parametre
+bool TOIProcessor::getRequested()
+{
+  return requestedSample;
+}
+
+// affichage des limites
+void TOIProcessor::printLimits()
+{
+  cout << "toiprocessor " << name <<" : limites calculees : " << snBegin << " , " << snEnd << endl;
+}
+
+TOI* TOIProcessor::getOutToi(string sortie)
+{
+  // recherche du nom de la sortie et verification si le toi existe deja 
+  map<string, int>::iterator i = outIx.find(sortie);
+  if (i == outIx.end()) {
+    return NULL;
+  } else {
+    return outTOIs[(*i).second];
+  }
+}
+
+
+
+
+
+
+
+
+