public Task(ISolver Solver, SolverParams SolParams, ExtraParams Params)
{
this.Solver = Solver;
this.SolParams = SolParams;
this.Params = Params;
//this.CurrentCorrelation = CurrentCorrelation;
}
protected virtual void KLayer(SolverParams SolParams)
{
var LIndex = SolParams.lastNotEmptyLayerIndex;
var kblock = SolParams.Way.layers[LIndex].blocks[0];
kblock.active_outputs = kblock.active_inputs;
SolParams.Way.layers[LIndex].blocks[0] = kblock;
}
protected override bool SLayer(SolverParams SolParams)
{
//var LIndex = SolParams.lastNotEmptyLayerIndex;
var ret = true;
int ActiveBlocksCount = 0;
//var BIndex = SolParams.BIndex;
if (SolParams.BIndex == -1)
{
SolParams.BIndex = 0;
for (; SolParams.BIndex < SolParams.Way.layers[SolParams.lastNotEmptyLayerIndex].blocks.Count; SolParams.BIndex++)
{
var WayBlock = SolParams.Way.layers[SolParams.lastNotEmptyLayerIndex].blocks[SolParams.BIndex];
if (!WayBlock.active_inputs.All(x => !x))
{
ActiveBlocksCount++;
continue;
}
}
if (ActiveBlocksCount > SolParams.MaxActiveBlocksOnLayer)
{
return(false);
}
SolParams.BIndex = 0;
}
for (; SolParams.BIndex < SolParams.Way.layers[SolParams.lastNotEmptyLayerIndex].blocks.Count; SolParams.BIndex++)
{
var WayBlock = SolParams.Way.layers[SolParams.lastNotEmptyLayerIndex].blocks[SolParams.BIndex];
if (WayBlock.active_inputs.All(x => !x))
{
continue;
}
if (!WayBlock.active_outputs.All(x => !x))
{
//ActiveBlocksCount++;
continue; //already solved block
}
ret = false;
var NetBlock = SolParams.Net.GetLayers()[SolParams.lastNotEmptyLayerIndex].GetBlocks()[SolParams.BIndex];
var Params = new BlockStateExtrParams(WayBlock.active_inputs, null, SolParams.Net.GetMultiThreadPrevalence(), SolParams.P, SolParams.Type, true);
var States = NetBlock.ExtractStates(Params);
if (States.Count > 0)
{
var State = States[0];
var NewWay = WayConverter.CloneWay(SolParams.Way);
var NewBLock = NewWay.layers[SolParams.lastNotEmptyLayerIndex].blocks[SolParams.BIndex];
NewBLock.active_outputs = State._outputs;
NewWay.layers[SolParams.lastNotEmptyLayerIndex].blocks[SolParams.BIndex] = NewBLock;
var NewSolParams = SolParams;
NewSolParams.P *= State.MatrixValue;
NewSolParams.Way = NewWay;
NewSolParams.BIndex++;
Solve(NewSolParams);
}
break;
}
return(ret);
}
public virtual void Solve(SolverParams SolParams)
{
var layersCount = SolParams.Way.layers.Count();
var roundsCount = layersCount / 3;
#region FindLastNotEmptyLayer
if (SolParams.lastNotEmptyLayerIndex == -1)
{
SolParams.lastNotEmptyLayerIndex = WayConverter.SearchLastNotEmptyLayer(SolParams.Way);
}
#endregion
#region FullRounds
if ((SolParams.lastNotEmptyLayerIndex >= 0) && (SolParams.lastNotEmptyLayerIndex / 3 < roundsCount - 1))
{
for (int i = SolParams.lastNotEmptyLayerIndex / 3; i < roundsCount - 1; i++)
{
#region K-layer
if (SolParams.Way.layers[SolParams.lastNotEmptyLayerIndex].type == LayerType.KLayer)
{
KLayer(SolParams);
WayConverter.CopyOutToIn(SolParams.Way, SolParams.lastNotEmptyLayerIndex, SolParams.lastNotEmptyLayerIndex + 1);
SolParams.lastNotEmptyLayerIndex++;
SolParams.BIndex = -1;
}
#endregion
#region S-layer
if (SolParams.Way.layers[SolParams.lastNotEmptyLayerIndex].type == LayerType.SLayer)
{
if (!(SLayer(SolParams)))
{
return;
}
WayConverter.CopyOutToIn(SolParams.Way, SolParams.lastNotEmptyLayerIndex, SolParams.lastNotEmptyLayerIndex + 1);
SolParams.lastNotEmptyLayerIndex++;
}
#endregion
#region P-layer
if (SolParams.Way.layers[SolParams.lastNotEmptyLayerIndex].type == LayerType.PLayer)
{
PLayer(SolParams);
WayConverter.CopyOutToIn(SolParams.Way, SolParams.lastNotEmptyLayerIndex, SolParams.lastNotEmptyLayerIndex + 1);
SolParams.lastNotEmptyLayerIndex++;
}
#endregion
}
}
#endregion
#region LastRound
//No need to process LastRound, because LastRound must be reversed.
#endregion
SolParams.Net.GetCallbackAddSolution()(new Solution(SolParams.P, SolParams.Way));
if (SolParams.P > SolParams.Net.GetMultiThreadPrevalence())
{
SolParams.Net.SetMultiThreadPrevalence(SolParams.P);
}
}
void ProcessRules()
{
//throw new NotImplementedException();
for (int i = 0; i < Params.Alg.Rules.Count; i++)
{
var Rule = Params.Alg.Rules[i];
if (Rule.UseCustomInput == true)
{
var SolParam = new SolverParams(WayConverter.ToWay(Params.Net, Rule.Input), Params.Net, Params.Alg.Type, Rule.MaxActiveBlocksOnLayer);
var T = new Task(Solvers[Rule.SolverType].S, SolParam, new ExtraParams());
_tasks.Enqueue(T);
}
else
{
var S = Solvers[Rule.SolverType];
S.IsUsedForBruteForce = true;
S.MaxActiveBlocksOnLayer = Rule.MaxActiveBlocksOnLayer;
Solvers[Rule.SolverType] = S;
IsBruteForceTurnedOn = true;
}
}
//Warning! Unoptimized code!!!
if (IsBruteForceTurnedOn)
{
var temp = Iter;
SolverInputs NextInput;
foreach (var S in Solvers)
{
if (S.Value.IsUsedForBruteForce)
{
Iter = new InputsIterator(Params.Net.GetSettings().SBoxCount, Params.Net.GetSettings().SBoxSize);
while (!Iter.IsFinished())
{
NextInput = Iter.NextState();
var ws = WayConverter.ToWay(Params.Net, NextInput);
_tasks.Enqueue(new Task(S.Value.S, new SolverParams(ws, Params.Net, Params.Alg.Type, S.Value.MaxActiveBlocksOnLayer)));
}
}
}
Iter = temp;
}
}
protected virtual void PLayer(SolverParams SolParams)
{
var LIndex = SolParams.lastNotEmptyLayerIndex;
var Params = new BlockStateExtrParams(SolParams.Way.layers[LIndex].blocks[0].active_inputs, null,
new Prevalence(), new Prevalence(), SolParams.Type);
var States = SolParams.Net.GetLayers()[LIndex].GetBlocks()[0].ExtractStates(Params);
if (States.Count == 1)
{
//deep copying
foreach (var j in Enumerable.Range(0, SolParams.Way.layers[LIndex].blocks[0].active_outputs.Count))
{
SolParams.Way.layers[LIndex].blocks[0].active_outputs[j] = States[0]._outputs[j];
}
}
else
{
Logger.UltraLogger.Instance.AddToLog("BaseSolver: Cant extract state from P-layer", Logger.MsgType.Error);
throw new NotImplementedException();
}
}
public Task(ISolver Solver, SolverParams SolParams)
{
this.Solver = Solver;
this.SolParams = SolParams;
this.Params = new ExtraParams();
}
