Commit 5 concept fork

```----------------------------------------------------------------
- Añadida la opción de utilizar número distinto de 4 para los threads dentro de vector
- Comprobar para el resto
```

----------------------------------------------------------------

source/Lib/EncoderLib/EncCu.cpp

@@ -80,7 +80,7 @@
 //ALBERTO CONCEPT FORK
 //CONTROL CENTER
 bool singleMode = false;
-bool debugMessage = false;
+bool debugMessage = true;
 //CONTROL CENTER
 
 //GLOBAL VARIABLES
@@ -89,6 +89,8 @@ bool father; //TRUE IF THE PROCESS IS NOT A CHILD
 int threadNumber; //NUMBER OF THREAD IF WE ARE IN A CHILD
 int posActualNode = 0; //NODE THAT IS BEING PROCESSED
 bool ignore_vector; //IGNORE THE VECTOR IF WE ARE UNDER A SPLIT THAT IS NOT QUATERNARY
+int NumberOfThreads = 6; //NUMBER OF THREADS CREATED
+int repartLevelNumber = 0; //NUMBER IN WHICH THREAD REPART IS PERFORMED
 //GLOBAL VARIABLES
 
 //TOSTRING_VECTOR
@@ -344,40 +346,119 @@ void EncCu::createSharedVector()
   ftruncate(fd, VECTOR_BYTES + sizeof(sem_t));
   vector = (vectorModeCostStruct*) mmap(NULL, VECTOR_BYTES, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 }
+void EncCu::repartLevel()
+{
+  for(int i=0; i<5; i++)
+  {
+    if(levelValues[i]>=NumberOfThreads)
+    {
+      repartLevelNumber = i;
+      break;
+    }
+  
+  }
+}
+int EncCu::repartStart()
+{
+  int repartStartNode = 0;
+  for(int i=0; i<= repartLevelNumber-1; i++)
+  {
+    repartStartNode += levelValues[i];
+  }
+  return repartStartNode;
+}
+int EncCu::repartEnd()
+{
+  int repartEndNode = -1;
+  for(int i=0; i<= repartLevelNumber; i++)
+  {
+    repartEndNode += levelValues[i];
+  }
+  return repartEndNode;
+}
+void EncCu::initStructVectorBeforeRepartStart(int repartStartNode)
+{
+  for(int i=0; i<repartStartNode; i++)
+  {
+    vector[0].threadNumber=1;
+  }
+}
+int EncCu::thread1NumberOfChild(int numberOfNodesPerThread)
+{
+  int thread1ChildNumber = -1;
+  if(NumberOfThreads*numberOfNodesPerThread<levelValues[repartLevelNumber])//AJUSTE ACOMETIDO A FAVOR DEL THREAD 1
+  {
+    thread1ChildNumber = levelValues[repartLevelNumber]-NumberOfThreads*numberOfNodesPerThread;
+  }
+  return thread1ChildNumber;
+}
 void EncCu::initStructVector()
 {
   vector[0].posFather=-1;
   vector[0].threadNumber=1;
+  //Rellenar antes de reparto
+  repartLevel();
+  int repartStartNode = repartStart();
+  //int repartEndNode = repartEnd();
+  initStructVectorBeforeRepartStart(repartStartNode);
+  int numberOfNodesPerThread = levelValues[repartLevelNumber] / NumberOfThreads;
+  numberOfNodesPerThread = numberOfNodesPerThread==0?1:numberOfNodesPerThread;
+  int thread1ChildNumber = thread1NumberOfChild(numberOfNodesPerThread);
+  int childCounter = 1;
+  int threadNumber = 1;
   for (int i = 0; i < VECTOR_SIZE; i++) 
   {
     vector[i].mode=-1;
     vector[i].cost=-1;
     int posPadreActual = i;
     if(posPadreActual==(LEVEL0-1)) //Estamos en el nivel 0, el padre realiza el reparto de threads
+    {
+      updateFatherAndThreadNumbersLevel0(posPadreActual,thread1ChildNumber,numberOfNodesPerThread);
+    }
+    else if(posPadreActual>=(LEVEL0) && posPadreActual<=(LEVEL1)) //Estamos en el nivel 1
+    {
+      updateFatherAndThreadNumbers(0,1,posPadreActual,i,1,childCounter,thread1ChildNumber,threadNumber,numberOfNodesPerThread);
+    }
+    else if(posPadreActual>=(LEVEL1+LEVEL0) && posPadreActual<=(LEVEL2+LEVEL1)) //Estamos en el nivel 2
+    {
+      updateFatherAndThreadNumbers(1,2,posPadreActual,i,2,childCounter,thread1ChildNumber,threadNumber,numberOfNodesPerThread);
+    }
+    else if(posPadreActual>=(LEVEL2+LEVEL1+LEVEL0) && posPadreActual<=(LEVEL3+LEVEL2+LEVEL1)) //Estamos en el nivel 3
+    {
+      updateFatherAndThreadNumbers(2,3,posPadreActual,i,3,childCounter,thread1ChildNumber,threadNumber,numberOfNodesPerThread);
+    }
+  }
+}
+void EncCu::updateFatherAndThreadNumbersLevel0(int posPadreActual, int thread1ChildNumber, int numberOfNodesPerThread)
+{
+  if(repartLevelNumber==1) //Estamos en el nivel 0, el padre realiza el reparto de threads
     {
       int salto = 1;
       int threadNumber = 1;
       int start = posPadreActual+salto;
       int end = posPadreActual+salto+4;
+      int childCounter = 1;
       for(int j=start; j<end; j++)//Actualizar los 4 hijos
       {
         vector[j].posFather=posPadreActual;
-        vector[j].threadNumber=threadNumber++;
-      }
-    }
-    else if(posPadreActual>=(LEVEL0) && posPadreActual<=(LEVEL1)) //Estamos en el nivel 1
+        vector[j].threadNumber=threadNumber;
+        if(thread1ChildNumber!=-1 && j>=(thread1ChildNumber+1))//Si se han rellenado todos los del uno avanzamos de thread
         {
-      updateFatherAndThreadNumbers(0,1,posPadreActual,i);
+          //Los del ajuste + el primero de los normales
+          threadNumber++;
         }
-    else if(posPadreActual>=(LEVEL1+LEVEL0) && posPadreActual<=(LEVEL2+LEVEL1)) //Estamos en el nivel 2
+        else if(thread1ChildNumber==-1 && childCounter==(numberOfNodesPerThread))
         {
-      updateFatherAndThreadNumbers(1,2,posPadreActual,i);
+          childCounter = 0;
+          threadNumber++;
         }
-    else if(posPadreActual>=(LEVEL2+LEVEL1+LEVEL0) && posPadreActual<=(LEVEL3+LEVEL2+LEVEL1)) //Estamos en el nivel 3
+        childCounter++;
+      }
+    }
+    else
     {
-      int posPadreEnNivel = i-LEVEL2-LEVEL1-LEVEL0;
-      int salto = (LEVEL3-posPadreEnNivel)+4*posPadreEnNivel; //Saltos sobre los hermanos derechos del padre + Saltos sobre hijos izquierdos no del padre
-      int threadNumber = vector[i].threadNumber;
+      int salto = 1;
+      int threadNumber = 1;
       int start = posPadreActual+salto;
       int end = posPadreActual+salto+4;
       for(int j=start; j<end; j++)//Actualizar los 4 hijos
@@ -385,12 +466,43 @@ void EncCu::initStructVector()
         vector[j].posFather=posPadreActual;
         vector[j].threadNumber=threadNumber;
       }
-      updateFatherAndThreadNumbers(2,3,posPadreActual,i);
-    }
     }
 }
-void EncCu::updateFatherAndThreadNumbers(int LevelLowIndex, int LevelUpIndex, int posPadreActual, int i)
+void EncCu::updateFatherAndThreadNumbers(int LevelLowIndex, int LevelUpIndex, int posPadreActual, int i, int LevelActualIndex, int& childCounter,int thread1ChildNumber, int& threadNumber, int numberOfNodesPerThread)
 {
+  if(LevelActualIndex+1 == repartLevelNumber) //SI ESTAMOS EN EL PADRE DEL NIVEL DONDE SE HACE EL REPARTO
+  {
+    int LevelLow = 0;
+    int LevelUp = levelValues[LevelUpIndex];
+    for(int j=LevelLowIndex; j>-1;j--)
+    {
+      LevelLow += levelValues[j];
+    }
+    int posPadreEnNivel = i-LevelLow;
+    int salto = (LevelUp-posPadreEnNivel)+4*posPadreEnNivel; //Saltos sobre los hermanos derechos del padre + Saltos sobre hijos izquierdos no del padre
+    //int threadNumber = 1; //vector[i].threadNumber;//Comenzamos en el thread 1
+    int start = posPadreActual+salto;
+    int end = posPadreActual+salto+4;
+    for(int j=start; j<end; j++)//Actualizar los 4 hijos
+    {
+      vector[j].posFather=posPadreActual;
+      vector[j].threadNumber=threadNumber;
+      if(childCounter==(thread1ChildNumber+numberOfNodesPerThread))//Si se han rellenado todos los del uno avanzamos de thread
+      {
+        //Los del ajuste + el primero de los normales
+        threadNumber++;
+      }
+      else if(childCounter>(thread1ChildNumber+numberOfNodesPerThread) && (childCounter-thread1ChildNumber)%numberOfNodesPerThread==0)
+      {
+        threadNumber++;
+      }
+      childCounter++;
+    }
+    
+
+  }
+  else
+  {
     int LevelLow = 0;
     int LevelUp = levelValues[LevelUpIndex];
     for(int j=LevelLowIndex; j>-1;j--)
@@ -407,6 +519,7 @@ void EncCu::updateFatherAndThreadNumbers(int LevelLowIndex, int LevelUpIndex, in
       vector[j].posFather=posPadreActual;
       vector[j].threadNumber=threadNumber;
     }
+  }
 }
 void EncCu::cleanCostModeVector()
 {
@@ -431,7 +544,7 @@ void EncCu::compressCtuForks(CodingStructure*& tempCS, CodingStructure*& bestCS,
   else
   {
     cleanCostModeVector();
-    for (int i = 0; i < 4 ; i++) 
+    for (int i = 0; i < NumberOfThreads ; i++) 
     {
       pid_t pid = fork();
       if (pid ==  0) { // proceso hijo
@@ -947,7 +1060,7 @@ bool activeIgnoreVector = false;
     //ALBERTO CONCEPT FORK
     bool lastModeAvailable = (!singleMode && father && m_modeCtrl->lastModeAvailable(*tempCS, partitioner) && tempCS->cost == MAX_DOUBLE); //SI SOLO QUEDA UN MODO Y EL COSTE ES MÁXIMO, NO PODEMOS SKIPEAR
     bool skipMode = (!singleMode && father && vector[posActualNode].mode!=-1 && vector[posActualNode].mode!=currTestMode.type && !ignore_vector && vector[posActualNode].mode!=ETM_RECO_CACHED && !lastModeAvailable);
-    bool skipCU = (!singleMode && !father && 1<=posActualNode && posActualNode<=4 && vector[posActualNode].threadNumber!=threadNumber);//SI ESTAMOS EN UN THREAD INCORRECTO SE HACE SKIP 
+    bool skipCU = (!singleMode && !father && /*1<=posActualNode && posActualNode<=4 &&*/ vector[posActualNode].threadNumber!=threadNumber);//SI ESTAMOS EN UN THREAD INCORRECTO SE HACE SKIP 
     if(debugMessage) { std::cout << "posActualNode:" << posActualNode << ", Vector:" << vector[posActualNode].mode << ", CurrMode:" << currTestMode.type << std::endl;}
     if(skipMode)
     { 
@@ -977,7 +1090,7 @@ bool activeIgnoreVector = false;
         (m_pcEncCfg->getLumaLevelToDeltaQPMapping().isEnabled()) ||
 #endif
         (m_pcEncCfg->getSmoothQPReductionEnable()) ||
-#if ENABLE_QPA_SUB_CTU
+#if ENABLE_QPA_SUB_CTUskipCU
         (m_pcEncCfg->getUsePerceptQPA() && !m_pcEncCfg->getUseRateCtrl() && pps.getUseDQP())
 #else
         false

source/Lib/EncoderLib/EncCu.h

@@ -326,8 +326,14 @@ public:
 
   //ALBERTO CONCEPT FORK
   void createSharedVector();
+  void repartLevel();
+  int repartStart();
+  int repartEnd();
+  void initStructVectorBeforeRepartStart(int repartStartNode);
+  int thread1NumberOfChild(int numberOfNodesPerThread);
   void initStructVector();
-  void updateFatherAndThreadNumbers(int LevelLowIndex, int LevelUpIndex, int posPadreActual, int i);
+  void updateFatherAndThreadNumbersLevel0(int posPadreActual,int thread1ChildNumber,int numberOfNodesPerThread);
+  void updateFatherAndThreadNumbers(int LevelLowIndex, int LevelUpIndex, int posPadreActual, int i,int LevelActualIndex,int& childCounter,int thread1ChildNumber,int& threadNumber,int numberOfNodesPerThread);
   void cleanCostModeVector();
   // END ALBERTO CONCEPT FORK