Пример #1
0
        /// <summary>
        /// Generates source-target pairs among the previously generated Chirper users.  
        /// </summary>
        /// <param name="graphDoc">The GraphML document that the code is building.</param>
        /// <param name="duplicateEdgeStatistic">
        ///     A passed in statistic that will be incremented each time a duplicate edge is generated.
        /// </param>
        /// <returns>The length of time used to generate the edges among the nodes.</returns>
        private TimeSpan GenerateChirperFollowerEdge(ChirperGraphMLDocument graphDoc, ref int duplicateEdgeStatistic)
        {
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();

            int edgeId = this.edgeIDStartValue;
            int maxNodeId = this.nodeIdStartValue + this.networkNodeCount;
            int minNodeId = this.edgeNodeStartIdValue;
            Random randomGenerator = new Random();

            Console.Write("\t");
            while (edgeId < this.networkEdgeCount + this.edgeIDStartValue)
            {
                int source = 0;
                int target = 0;
                if (this.random)
                {
                    // Use while loops to prevent keeping source and target values of zero.
                    while (source == 0)
                    {
                        source = randomGenerator.Next(this.nodeIdStartValue, maxNodeId);
                    }

                    while (target == 0)
                    {
                        target = randomGenerator.Next(this.nodeIdStartValue, maxNodeId);
                    }
                }
                else
                {
                    int relativeEdgeId = edgeId - this.edgeIDStartValue;
                    int edgesPerNode = this.networkEdgeCount / this.networkNodeCount;
                    int relativeSource = relativeEdgeId / edgesPerNode;
                    int relativeTarget = (relativeSource + 1 + (relativeEdgeId % edgesPerNode));
                    int range = maxNodeId - minNodeId;
                    source = relativeSource + minNodeId;
                    target = (relativeTarget % range) + minNodeId;
                }

                // Don't allow the source to be equal to the target.
                while (source == target)
                {
                    target = randomGenerator.Next(minNodeId, maxNodeId);
                }
                if (graphDoc.AddEdge(edgeId, source, target))
                {
                    // Don't increment if the add fails due to a duplicate.
                    edgeId++;
                }
                else
                {
                    duplicateEdgeStatistic++;
                }

                if ((edgeId % ProgressInterval) == 0) Console.Write("."); // Show progress
            }
            Console.WriteLine(".");
            stopwatch.Stop();
            return TimeSpan.FromSeconds(stopwatch.Elapsed.TotalSeconds);
        }
Пример #2
0
 /// <summary>
 /// Generates Chirper "User Ids" and adds them to the GraphML document.
 /// </summary>
 /// <param name="graphDoc">The GraphML document that the code is building.</param>
 /// <returns>The length of time used to generate the nodes.</returns>
 private TimeSpan GenerateChirperUserNodes(ChirperGraphMLDocument graphDoc)
 {
     Stopwatch stopwatch = new Stopwatch();
     stopwatch.Start();
     Console.Write("\t");
     for (int nodeIndex = this.nodeIdStartValue; nodeIndex < this.networkNodeCount + nodeIdStartValue; nodeIndex++)
     {
         // Since we are using a for loop, these will never be duplicates.
         // If the method of generating the indexes is changed to one that could produce duplicates,
         // the return value of AddNode() must be taken into account.
         string userId = "U" + nodeIndex.ToString(CultureInfo.InvariantCulture);
         graphDoc.AddNode(nodeIndex, userId);
         if ((nodeIndex % ProgressInterval) == 0) Console.Write("."); // Show progress
     }
     Console.WriteLine(".");
     stopwatch.Stop();
     TimeSpan nodeGenerationTime = TimeSpan.FromSeconds(stopwatch.Elapsed.TotalSeconds);
     return nodeGenerationTime;
 }
Пример #3
0
        internal int Run()
        {
            string thisProcessName = Process.GetCurrentProcess().ProcessName;
            using (PerformanceCounter memoryMonitor = new PerformanceCounter("Process", "Working Set", thisProcessName))
            {
                memoryMonitor.NextSample();
                using (PerformanceCounter processorMonitor = new PerformanceCounter("Process", "% Processor Time", thisProcessName))
                {
                    processorMonitor.NextSample();
                    networkGeneratorLog = new List<string>();
                    LogMessage("********************************************************");
                    LogMessage(string.Format("{0,25}\t{1:G}", "Start Network Generation:", DateTime.Now));
                    LogMessage(string.Format("{0,25}\t{1:N0}\tEdges: {2:N0}", "Requested Nodes:", this.networkNodeCount, this.networkEdgeCount));
                    LogMessage(string.Format("{0,25}\t{1:N0}\tEdges: {2:N0}", "Start Ids - Nodes:", this.nodeIdStartValue, this.edgeIDStartValue));
                    ChirperGraphMLDocument graphDoc = new ChirperGraphMLDocument();
                    LogMessage(string.Empty);
                    LogMessage("Starting node generation...");

                    TimeSpan nodeGenerationTime = GenerateChirperUserNodes(graphDoc);
                    LogMessage("\tNode generation complete in " + nodeGenerationTime);
                    LogPerformanceCounterData(memoryMonitor, processorMonitor);

                    LogMessage(string.Empty);
                    FlushLog();

                    int duplicateEdgeStatistic = 0;
                    TimeSpan edgeGenerationTime = default(TimeSpan);
                    if (this.networkEdgeCount > 0)
                    {
                        LogMessage("Starting edge generation...");
                        edgeGenerationTime = GenerateChirperFollowerEdge(graphDoc, ref duplicateEdgeStatistic);

                        LogMessage("\tEdge generation complete in " + edgeGenerationTime);
                        LogMessage("\tDuplicates generated: " + duplicateEdgeStatistic);
                        LogPerformanceCounterData(memoryMonitor, processorMonitor);
                        LogMessage(string.Empty);
                    }
                    else
                    {
                        LogMessage("Edge generation suppressed from command line.");
                        LogMessage(string.Empty);
                    }

                    Stopwatch stopwatch = new Stopwatch();
                    FlushLog();

                    LogMessage("Starting GraphML File write...");
                    stopwatch.Restart();
                    graphDoc.WriteXmlWithWriter(this.graphMLFile);
                    stopwatch.Stop();
                    TimeSpan xmlWriteTime = TimeSpan.FromSeconds(stopwatch.Elapsed.TotalSeconds);
                    LogMessage("\tGraphML file write complete in " + xmlWriteTime);
                    LogPerformanceCounterData(memoryMonitor, processorMonitor);

                    LogMessage(string.Empty);
                    LogMessage(string.Format(CultureInfo.InvariantCulture, "{0,30}\t{1}", "Total Graph Generation Time:", (nodeGenerationTime + edgeGenerationTime + xmlWriteTime)));
                    LogMessage(string.Empty);
                    FlushLog();

                    // Get the size of the file so we can add the statistic.
                    FileInfo fileInfo = new FileInfo(this.graphMLFile);
                    fileInfo.Refresh();
                    long fileLength = fileInfo.Length;
                    string range = "bytes";
                    if (fileLength > Kilo)
                    {
                        fileLength = fileLength / Kilo;
                        range = "KB";
                    }
                    if (fileLength > Kilo)
                    {
                        fileLength = fileLength / Kilo;
                        range = "MB";
                    }

                    LogMessage(string.Format(CultureInfo.InvariantCulture, "{0,30}\t{1:N0} {2}", "GraphML File Size:", fileLength, range));

                    LogMessage(string.Empty);
                    FlushLog();

                }
            }

            // Using Linq to XML here to insert the statistic comment won't adversely affect performance.
            //XComment statisticsComment = new XComment(summaryMessageStringBuilder.ToString());
            //XDocument generatedGraphMLDoc = XDocument.Load(graphMLFile);
            //XElement graphElement = generatedGraphMLDoc.Root;
            //graphElement.AddFirst(statisticsComment);
            //graphElement.Document.Save(this.graphMLFile);

            return 0;
        }