C++ 工作分配-c+中的循环调度+；

问题陈述如图所示

假设阈值计数为9的预期结果

问题陈述作为文本- 有T个客户端为服务器服务，下面是配置

T0、T1、T2、T3:--X0
T4、T5、T6、T7:--X1
T8、T9、T10、T11:--X2
T12，T13，T14，T15:--X3

T0到T3以循环方式向X0服务，直到服务令牌的阈值 比如说，阈值为9，发球顺序如下 T0，T1，T2，T3，T0，T1，T2，T3，T0

T4到T7以循环方式到X1服务，直到服务令牌的阈值 比如说，阈值为9，发球顺序如下 T4，T5，T6，T7，T4，T5，T6，T7，T4

T8到T11以循环方式到X2服务，直到服务令牌的阈值 比如说，阈值为9，发球顺序如下 T8，T9，T10，T11，T8，T9，T10，T11，T8

T12到T15循环到X3，直到达到令牌的阈值为止 比如说，阈值为9，发球顺序如下 T12，T13，T14，T15，T12，T13，T14，T15，T12

因此序列将如下所示

T0，T1，T2，T3，T0，T1，T2，T3，T0：--X0
T4，T5，T6，T7，T4，T5，T6，T7，T4：--X1
T8，T9，T10，T11，T8，T9，T10，T11，T8：-X2
T12，T13，T14，T15，T12，T13，T14，T15，T12：--X3

迭代所有T之后，下一个序列将如下所示

T1，T2，T3，T0，T1，T2，T3，T0，T1：--X0
T5，T6，T7，T4，T5，T6，T7，T4，T5：-X1
T9，T10，T11，T8，T9，T10，T11，T8，T9：-X2
T13，T14，T15，T12，T13，T14，T15，T12，T13X3

正如您所看到的，在下一次迭代中跳过最后使用的T’

我成功地编写了代码片段代码就在这里，但在我的代码中，我无法按照表中的预期公平地分配令牌（在达到阈值后最后使用的T’应该在下一次迭代中跳过）

请建议

#include <iostream>

int CurrentT = 0;
int No_Of_T_Per_X = 4;
int OutputX = 0;
int No_Of_X = 4;
int Valid_T[16] ={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
int Processed_Tokens[4] = {0,0,0,0};
int THRESHOLD[4] = {9,9,9,9};
int LastT_Used[4] = {0,0,0,0};

static unsigned int getTargetX(unsigned int id, unsigned int       num_T_per_X) 
{ return id / num_T_per_X; } 

bool batch = false;
int main()
{
    int prev_SPMindex = -1;
    int next_SPMindex = 0;

    for(int i=1;i<=1000;i++) { // Looping to test some random no. of tokens..
     if ( Processed_Tokens[OutputX] >= THRESHOLD[OutputX]){    
     THRESHOLD[OutputX] = THRESHOLD[OutputX] + 9;
     //LastT_Used[OutputX] = CurrentT;
     prev_SPMindex = next_SPMindex;
     CurrentT = prev_SPMindex;
 }

 CurrentT = (CurrentT + 1) % (sizeof(Valid_T)/sizeof(int));  // Currently Processed T'

 if(((CurrentT % No_Of_T_Per_X) == 0)){
      next_SPMindex = CurrentT -1;
      CurrentT = prev_SPMindex;
      CurrentT = (CurrentT + 1) % (sizeof(Valid_T)/sizeof(int)); 
 }

 OutputX =    getTargetX(Valid_T[CurrentT], No_Of_T_Per_X); // Currently Processed X'           
 Processed_Tokens[OutputX] += 1; // Increasing the Count of Tokens to test

}

return 0;

}

#包括
int CurrentT=0；
int No_Of_T_Per_X=4；
int OutputX=0；
int No_Of_X=4；
int Valid_T[16]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}；
int处理的_令牌[4]={0,0,0}；
int阈值[4]={9,9,9}；
int LastT_使用[4]={0,0,0}；
静态unsigned int getTargetX（unsigned int id，unsigned int num\u T\u per\u X）
{返回id/num\u T\u per\u X；}
bool批=假；
int main（）
{
int prev_SPMindex=-1；
int next_SPMindex=0；
对于（inti=1；i=THRESHOLD[OutputX]）{
阈值[OutputX]=阈值[OutputX]+9；
//上次使用的[OutputX]=CurrentT；
上一个=下一个；
CurrentT=上一个SPMindex；
}
CurrentT=（CurrentT+1）%（sizeof（Valid_T）/sizeof（int））；//当前处理的T'
如果（（当前T%No_Of_T_Per_X）=0））{
next_SPMindex=电流t-1；
CurrentT=上一个SPMindex；
CurrentT=（CurrentT+1）%（sizeof（Valid_T）/sizeof（int））；
}
OutputX=getTargetX（有效的[CurrentT]，没有每X个的值）；//当前处理的X'
已处理的\u令牌[OutputX]+=1；//增加要测试的令牌计数
}
返回0；
}