/// <summary>
/// Removes unpromising branches from the active list.
/// </summary>
protected void PruneBranches()
{
int startSize = ActiveList.Size;
_pruneTimer.Start();
ActiveList = _pruner.Prune(ActiveList);
_beamPruned.Value += startSize - ActiveList.Size;
_pruneTimer.Stop();
}
private static bool FindSortingNetwork(int batchSize, IReadOnlyList <IComparatorNetwork> comparatorNets, IPruner pruner,
int heuristicPopulation, List <int> copySteps)
{
var comparatorsGenerator = new ComparatorsGenerator();
var sortingNetworksGenerator = new Generator();
var comparators =
comparatorsGenerator.GenerateComparators(Enumerable.Range(0, IComparatorNetwork.Inputs).ToArray());
var generatorPruner = new GeneratePruneInBatches(batchSize);
var stopWatch = Stopwatch.StartNew();
//comparatorNets ??= new List<IComparatorNetwork> {new ComparatorNetwork(new Comparator[1] {new Comparator(0, 1)})};
comparatorNets ??= new List <IComparatorNetwork>();
if (comparatorNets.Count == 0)
{
var firstNets = new List <IComparatorNetwork>();
for (var j = 0; j < comparators.Count; j++)
{
firstNets.Add(new ComparatorNetwork(new[] { comparators[j] }));
}
comparatorNets = firstNets;
}
var currentComparator = comparatorNets.Count > 0 ? comparatorNets[0].Comparators.Length : 0;
var rand = new Random();
for (var i = currentComparator; i <= IComparatorNetwork.NumComparators; i++)
{
Trace.WriteLine($"Adding Comparator {i}");
Trace.TraceInformation($"Generate");
var generateWatch = Stopwatch.StartNew();
if (comparatorNets.Count > batchSize)
{
var generatePruneWatch = Stopwatch.StartNew();
comparatorNets = generatorPruner.GeneratePrune(comparatorNets, comparators);
Trace.WriteLine($"Length after prune: {comparatorNets.Count}");
Trace.WriteLine($"Generate and Prune time {generatePruneWatch.Elapsed}");
if (heuristicPopulation > 0 && comparatorNets.Count > heuristicPopulation)
{
comparatorNets = HeuristicRemover.RemoveNetsWithMoreBadZeroes(comparatorNets, heuristicPopulation);
//comparatorNets = HeuristicRemover.RemoveNetsWithMoreOutputs(comparatorNets, heuristicPopulation);
}
}
else
{
//var newNets = sortingNetworksGenerator.Generate(comparatorNets, comparators).ToList();
//comparatorNets = newNets;
// First nets already generated
if (i != 1)
{
comparatorNets = sortingNetworksGenerator.Generate(comparatorNets, comparators).OrderBy(x => rand.Next()).ToList();
//comparatorNets = sortingNetworksGenerator.Generate(comparatorNets, comparators);
}
#if DEBUG
Trace.WriteLine($"Redundant number: {IComparatorNetwork.RedundantNumber:N}");
IComparatorNetwork.RedundantNumber = 0;
#endif
Trace.WriteLine($"Length after Generate: {comparatorNets.Count}");
Trace.WriteLine($"Generate time {generateWatch.Elapsed}");
var count = double.Parse(comparatorNets.Count.ToString());
Trace.TraceInformation($"Prune");
var pruneWatch = Stopwatch.StartNew();
if (IPruner.Threads > 1)
{
var splitNets = comparatorNets.SplitList(Math.Max((int)Math.Ceiling(count / IPruner.Threads), 10000))
.ToList();
comparatorNets = pruner.Prune(splitNets);
}
else
{
comparatorNets = pruner.Prune(comparatorNets);
}
if (heuristicPopulation > 0 && comparatorNets.Count > heuristicPopulation)
{
//comparatorNets = HeuristicRemover.RemoveNetsWithMoreBadZeroes(comparatorNets, heuristicPopulation);
comparatorNets = useBadZeroes ? HeuristicRemover.RemoveNetsWithMoreBadZeroes(comparatorNets, heuristicPopulation) :
HeuristicRemover.RemoveNetsWithMoreOutputs(comparatorNets, heuristicPopulation);
}
Trace.WriteLine($"Length after Prune: {comparatorNets.Count}");
Trace.WriteLine($"Prune time {pruneWatch.Elapsed}");
}
#if DEBUG
Trace.WriteLine($"Permutations tested: {IComparatorNetwork.TryPermutationCall}");
Trace.WriteLine($"Is subset dual: {IComparatorNetwork.IsSubsetDual}");
//Trace.WriteLine($"Try permutations call: {IComparatorNetwork.TryPermutationCall:N}");
IComparatorNetwork.IsSubset = 0;
IComparatorNetwork.IsSubsetDual = 0;
IComparatorNetwork.TryPermutationCall = 0;
#endif
Trace.TraceInformation($"Saving Nets");
var path =
$"SavedNetworks/nets_{IComparatorNetwork.Inputs}_{comparatorNets[0].Comparators.Length}_{DateTime.Now:yyyyMMddHHmmssfff}.json";
#if SAVEALL
comparatorNets.SaveToFile(path);
#endif
if (copySteps.Contains((int)i))
{
comparatorNets.SaveToFile(path);
}
Trace.WriteLine(string.Empty);
// Sorting network found
if (comparatorNets.Count == 1 && comparatorNets[0].IsSortingNetwork())
{
break;
}
GC.Collect();
GC.WaitForPendingFinalizers();
}
// Trace.WriteLine($"Subsume no check: {IComparatorNetwork.SubsumeNoCheck} ");
Trace.WriteLine($"Elapsed Time: {stopWatch.Elapsed} ");
#if DEBUG
Trace.WriteLine(string.Empty);
Debug.WriteLine($"Subsume total:{IComparatorNetwork.SubsumeTotal:N}");
Debug.WriteLine($"Subsume no check 1:{IComparatorNetwork.SubsumeNoCheck1:N}");
Debug.WriteLine($"Subsume no check 2:{IComparatorNetwork.SubsumeNoCheck2:N}");
Debug.WriteLine($"Output count bigger:{IComparatorNetwork.OutputCountBigger:N}");
Debug.WriteLine($"Subsume no check total:{IComparatorNetwork.SubsumeNoCheckTotal:N}");
Debug.WriteLine($"Subsume number:{IComparatorNetwork.SubsumeNumber:N}");
Debug.WriteLine($"Subsume succeed:{IComparatorNetwork.SubsumeSucceed:N}");
Debug.WriteLine($"Permutations performed:{IComparatorNetwork.PermutationsNumber:N}");
Debug.WriteLine($"Permutations walk:{IComparatorNetwork.PermutationsWalk:N}");
#endif
Trace.WriteLine(string.Empty);
PrintSortingNetworks(comparatorNets.Where(x => x.IsSortingNetwork2N()).ToList(), IComparatorNetwork.Inputs, heuristicPopulation.ToString());
return(comparatorNets.Any(x => x.IsSortingNetwork2N()));
}
/// <summary>
/// Removes unpromising branches from the active list.
/// </summary>
protected void PruneBranches()
{
PruneTimer.Start();
ActiveList = Pruner.Prune(ActiveList);
PruneTimer.Stop();
}