private static NodePairings GetPairings(List <LabeledVertex> sourceGraphLabeled, List <LabeledVertex> imageGraphLabeled)
{
NodePairings nodePairings = new NodePairings(sourceGraph: sourceGraphLabeled, imageGraph: imageGraphLabeled);
Random rnd = new Random();
Dictionary <Code[], IEnumerable <LabeledVertex> > sourceGraphGrouped;
Dictionary <Code[], IEnumerable <LabeledVertex> > imageGraphGrouped;
GetGrouped(sourceGraphLabeled: sourceGraphLabeled, imageGraphLabeled: imageGraphLabeled, sourceGraphGrouped: out sourceGraphGrouped, imageGraphGrouped: out imageGraphGrouped);
//Parallel.ForEach(sourceGraphGrouped.Keys, (codeGroup) =>
foreach (var codeGroup in sourceGraphGrouped.Keys)
{
//not gonna lock for now
foreach (var sourceGraphVertex in sourceGraphGrouped[codeGroup])
{
VertexMatch winningPair;
if (!imageGraphGrouped.ContainsKey(codeGroup))
{
winningPair = null;
}
//Parallel.ForEach(imageGraphGrouped[codeGroup].OrderBy(x => rnd.Next()).ToList(), (imageGraphCandidate) =>
else
{
var vertexPossiblePairings = new ConcurrentBag <VertexMatch>();
foreach (var imageGraphCandidate in imageGraphGrouped[codeGroup].OrderBy(x => rnd.Next()).ToList())
{
vertexPossiblePairings.Add(new VertexMatch()
{
SourceGraphVertex = sourceGraphVertex, ImageGraphVertex = imageGraphCandidate, Score = VertexScorer.GetScore(sourceGraphVertex, imageGraphCandidate, nodePairings)
});
}
winningPair = vertexPossiblePairings.Where(x => x.Score > 0).OrderByDescending(x => x.Score).ThenBy(x => rnd.Next()).FirstOrDefault();
}
//});
if (winningPair != null)
{
lock (nodePairings.Pairings)
{
winningPair.NormalizedScore = winningPair.Score / VertexScorer.GetSelfScore(winningPair.SourceGraphVertex);
nodePairings.Pairings[winningPair.ImageGraphVertex].Add(winningPair);
nodePairings.TotalScore += winningPair.Score;
}
}
}
}
// });
return(nodePairings);
}
public static NodePairings GetGraphSelfScore(List <LabeledVertex> labeledGraph)
{
NodePairings nodePairings = new NodePairings(imageGraph: labeledGraph, sourceGraph: labeledGraph);
foreach (var node in labeledGraph)
{
double score = VertexScorer.GetSelfScore(node);
nodePairings.Pairings[node].Add(new VertexMatch()
{
SourceGraphVertex = node, ImageGraphVertex = node, Score = score, NormalizedScore = 1
});
nodePairings.TotalScore += score;
}
return(nodePairings);
}
public static NodePairings GetDistance(List <InstructionNode> sourceGraph, List <InstructionNode> imageGraph)
{
List <LabeledVertex> sourceGraphLabeled = GetLabeled(sourceGraph);
List <LabeledVertex> imageGraphLabeled = GetLabeled(imageGraph);
var retNodes = sourceGraph.Where(x => VertexScorer.OutDataCodes.Contains(x.Instruction.OpCode.Code));
var backRetTree = retNodes.SelectMany(x => BackSearcher.GetBackDataTree(x)).Distinct().Concat(retNodes).ToList();
backRetTree.AddRange(backRetTree.ToList().SelectMany(x => x.BranchProperties.Branches.Select(y => y.OriginatingNode)));
var backRetTreeIndexes = backRetTree.Select(x => x.InstructionIndex).ToList();
foreach (var backRetNode in sourceGraphLabeled.Where(x => backRetTreeIndexes.Contains(x.Index)))
{
backRetNode.IsInReturnBackTree = true;
}
NodePairings bestMatch = GetPairings(sourceGraphLabeled, imageGraphLabeled);
object lockObject = new object();
//TODO change back to 10
Parallel.For(1, 1, (i) =>
{
NodePairings pairing = GetPairings(sourceGraphLabeled, imageGraphLabeled);
if (pairing.TotalScore > 1)
{
throw new Exception("");
}
lock (lockObject)
{
if (pairing.TotalScore > bestMatch.TotalScore)
{
bestMatch = pairing;
}
}
});
bestMatch.SourceSelfPairings = GetGraphSelfScore(sourceGraphLabeled);
bestMatch.ImageSelfPairings = GetGraphSelfScore(imageGraphLabeled);
return(bestMatch);
}
public static int GetEdgeMatchScore(LabeledEdge sourceEdge, LabeledEdge imageEdge, SharedSourceOrDest sharingSourceOrDest, NodePairings pairings, IndexImportance indexImportance, bool usePastPairings = true)
{
int edgeMatchScore = 0;
LabeledVertex sourceEdgeVertex;
LabeledVertex imageEdgeVertex;
if (sharingSourceOrDest == SharedSourceOrDest.Source)
{
sourceEdgeVertex = sourceEdge.DestinationVertex;
imageEdgeVertex = imageEdge.DestinationVertex;
}
else
{
sourceEdgeVertex = sourceEdge.SourceVertex;
imageEdgeVertex = imageEdge.SourceVertex;
}
if (imageEdge.Index == sourceEdge.Index || indexImportance == IndexImportance.NotImportant)
{
edgeMatchScore += EdgeScorePoints.IndexMatch;
}
if (usePastPairings)
{
lock (pairings)
{
if (pairings.Pairings[imageEdgeVertex].Any(x => x.ImageGraphVertex == sourceEdgeVertex))
{
edgeMatchScore += EdgeScorePoints.TargetVertexArePaired;
}
}
}
if (sourceEdgeVertex.Opcode == imageEdgeVertex.Opcode)
{
edgeMatchScore += EdgeScorePoints.TargetVertexCodeExactMatch;
}
else if (CodeGroups.AreSameGroup(sourceEdgeVertex.Opcode, imageEdgeVertex.Opcode))
{
edgeMatchScore += EdgeScorePoints.TargetVertexCodeFamilyMatch;
}
if (sourceEdge.EdgeType != EdgeType.ProgramFlowAffecting)
{
edgeMatchScore *= ImportantEdgeTypeMultiplier;
}
if (sourceEdge.SourceVertex.IsInReturnBackTree && sourceEdge.DestinationVertex.IsInReturnBackTree)
{
//edgeMatchScore *= ImportantEdgeTypeMultiplier;
}
return(edgeMatchScore);
}
public static int ScoreEdges(List <LabeledEdge> sourceVertexEdges, List <LabeledEdge> imageVertexEdges, NodePairings pairings, SharedSourceOrDest sharedSourceOrDest)
{
int totalScore = 0;
var edgePairings = new List <EdgeMatch>();
var unmachedImageVertexEdges = new List <LabeledEdge>(imageVertexEdges);
Random rnd = new Random();
foreach (var sourceVertexEdge in sourceVertexEdges.OrderBy(x => rnd.Next()))
{
var pairingScores = new List <EdgeMatch>();
LabeledVertex vertexToMatch;
if (sharedSourceOrDest == SharedSourceOrDest.Source)
{
vertexToMatch = sourceVertexEdge.DestinationVertex;
}
else
{
vertexToMatch = sourceVertexEdge.SourceVertex;
}
Func <LabeledEdge, bool> baseCondition = x => x.EdgeType == sourceVertexEdge.EdgeType;
IndexImportance indexImportance;
if (sourceVertexEdge.EdgeType == EdgeType.ProgramFlowAffecting)
{
indexImportance = IndexImportance.Important;
}
else
{
indexImportance = opCodeInfo.GetIndexImportance(sourceVertexEdge.DestinationVertex.Opcode);
}
Func <LabeledEdge, bool> predicate;
if (indexImportance == IndexImportance.Critical)
{
predicate = x => baseCondition(x) && x.Index == sourceVertexEdge.Index;
}
else
{
predicate = x => baseCondition(x);
}
var relevantImageVertexEdges = unmachedImageVertexEdges.Where(predicate);
relevantImageVertexEdges.ForEach(imageVertexEdge => pairingScores.Add(new EdgeMatch()
{
ImageGraphEdge = imageVertexEdge, SourceVertexEdge = sourceVertexEdge, Score = GetEdgeMatchScore(sourceVertexEdge, imageVertexEdge, sharedSourceOrDest, pairings, indexImportance)
}));
var winningMatchGroup = pairingScores.Where(x => x.Score > 0).GroupBy(x => x.Score).OrderByDescending(x => x.Key).FirstOrDefault();
if (winningMatchGroup == null || !winningMatchGroup.Any())
{
edgePairings.Add(new EdgeMatch()
{
SourceVertexEdge = sourceVertexEdge, ImageGraphEdge = null, Score = 0
});
}
else
{
var winningMatch = winningMatchGroup.OrderBy(x => rnd.Next()).First();
unmachedImageVertexEdges.Remove(winningMatch.ImageGraphEdge);
winningMatch.Score = GetEdgeMatchScore(sourceVertexEdge, winningMatch.ImageGraphEdge, sharedSourceOrDest, pairings, indexImportance, false);
var scoreRelatedToMax = (double)winningMatch.Score / GetEdgeMatchScore(sourceVertexEdge, sourceVertexEdge, sharedSourceOrDest, pairings, IndexImportance.Important, false);
edgePairings.Add(winningMatch);
totalScore += winningMatch.Score;
}
}
//totalScore -= unmachedImageVertexEdges.Count * EdgeScorePoints.ExactMatch;
return(totalScore);
}
public static double GetScore(LabeledVertex sourceGraphVertex, LabeledVertex imageGraphVertex, NodePairings pairings)
{
double score = 0;
if (sourceGraphVertex.Opcode == imageGraphVertex.Opcode)
{
score += VertexScorePoints.CodeMatch;
}
else
{
score += VertexScorePoints.CodeFamilyMatch;
}
if (sourceGraphVertex.Operand == imageGraphVertex.Operand)
{
score += VertexScorePoints.OperandMatch;
}
var backEdgeScore = EdgeScorer.ScoreEdges(sourceGraphVertex.BackEdges, imageGraphVertex.BackEdges, pairings, SharedSourceOrDest.Dest);
var forwardEdgeScore = EdgeScorer.ScoreEdges(sourceGraphVertex.ForwardEdges, imageGraphVertex.ForwardEdges, pairings, SharedSourceOrDest.Source);
score += backEdgeScore + forwardEdgeScore;
lock (pairings)
{
if (pairings.Pairings[imageGraphVertex].Count > 0)
{
//score -= VertexScorePoints.SingleToMultipleVertexMatchPenalty;
score *= 0.9;
}
}
if (OutDataCodes.Contains(sourceGraphVertex.Opcode))
{
score *= ImportantCodeMultiplier;
}
//if (sourceGraphVertex.IsInReturnBackTree)
//{
// score *= ImportantCodeMultiplier;
//}
var scoreToDouble = score / GetSelfScore(sourceGraphVertex);
return(score);
}
