// colToGroup is an index from aNewColumnOrder. public GroupedTable(Database.Table table, ArrayRange range, int colToGroup, SortOrder sortOrder, FnCreateGroupTable subTable) : base(table.Schema) { m_table = table; if (m_table is ExpandTable) { m_expandTable = (ExpandTable)m_table; } m_Meta = m_table.GetMetaData(); m_GroupedColumnFirst = 0; m_GroupedColumnLast = 0; m_ColumnOrder = new int[] { colToGroup };// colGroupOrder; m_SortOrder = new SortOrder[1] { sortOrder }; m_createGroupTable = subTable; using (Profiling.GetMarker(Profiling.MarkerId.GroupedTable).Auto()) { var col = m_table.GetColumnByIndex(colToGroup); var metaCol = m_Meta.GetColumnByIndex(colToGroup); if (metaCol.DefaultGroupAlgorithm != null) { m_GroupCollection = metaCol.DefaultGroupAlgorithm.Group(col, range, sortOrder); } else { throw new Exception("Trying to group a column without grouping algorithm. Column '" + metaCol.Name + "' from table '" + m_table.GetName() + "'"); } InitializeFromGroupCollection(col, colToGroup); } }
private async Task <RowSet> ExecuteStatement(IStatement statement) { using (new TraceProfileContext("ExecuteQuery", "Execute query")) { RowSet rowSet = null; var numberOfAttempt = 0; do { try { rowSet = await _session.ExecuteAsync(statement); return(rowSet); } catch (NoHostAvailableException noHostAvailableEx) { ExceptionPolicy.HandleException(noHostAvailableEx, "logonly"); await Task.Delay(RetrySetting.DelayInMs); numberOfAttempt++; Profiling.Trace("Number of attempt(s) " + (numberOfAttempt).ToString()); if (numberOfAttempt > RetrySetting.NumberOfRetry) { throw noHostAvailableEx; } } catch (Exception ex) { throw ex; } } while (numberOfAttempt <= RetrySetting.NumberOfRetry); return(rowSet); } }
public async Task <Dictionary <string, string> > GetAllAsync() { try { using (new ProfileContext("ConsulConfigurationStore.GetAll")) { var formatedKey = "/"; var dataSet = await ConsulClientFactory.Instance.KV.List(formatedKey); await LogRQRS(formatedKey, dataSet, _applicationName, "get_all_async"); var response = ParseResponse(dataSet); if (response != null) { Profiling.Trace($"Key: {response.Count}"); } return(response); } } catch (Exception ex) { Platform.Common.ExceptionPolicy.HandleException(ex, Constants.DefaultPolicy); } throw new ConfigurationException("Could not connect to consul", "100", System.Net.HttpStatusCode.InternalServerError); }
public string Get(string scope, string application, string section, string key) { using (new ProfileContext("ConsulConfigurationStore.Get")) { var formatedKey = KeyMaker.ConstructKey(scope, application, section, key).ToLowerInvariant(); Profiling.Trace($"Key: {formatedKey}"); QueryResult <KVPair> response = null; var waitHandle = new ManualResetEvent(false); Task.Factory.StartNew(async() => { try { response = await ConsulClientFactory.Instance.KV.Get(formatedKey); await LogRQRS(formatedKey, response, application, "get"); } finally { waitHandle.Set(); } }); waitHandle.WaitOne(); return(ParseResponse(response)); } }
protected virtual long[] GetSortIndex(System.Collections.Generic.IComparer <DataT> comparer, ArrayRange indices, bool relativeIndex) { using (Profiling.GetMarker(Profiling.MarkerId.Sort).Auto()) { Update(); long count = indices.Count; DataT[] keys = new DataT[count]; //create index array long[] index = new long[count]; if (relativeIndex) { for (long i = 0; i != count; ++i) { index[i] = i; keys[i] = GetRowValue(indices[i]); } } else { for (long i = 0; i != count; ++i) { index[i] = indices[i]; keys[i] = GetRowValue(indices[i]); } } using (Profiling.GetMarker(Profiling.MarkerId.ArraySort).Auto()) { System.Array.Sort(keys, index, comparer); } return(index); } }
private void OnClearCacheTimerTick(object sender, EventArgs e) { try { if (!base.IsDisposed && (this.fontPreviewRenderCache != null)) { using (Profiling.UseEnter("Clearing the font preview cache")) { Dictionary <TupleStruct <string, float, PaintDotNet.UI.Media.Brush>, PlacedBitmap> fontPreviewRenderCache = this.fontPreviewRenderCache; lock (fontPreviewRenderCache) { this.fontPreviewRenderCache.Clear(); } } } } catch (Exception) { } finally { try { DisposableUtil.Free <System.Windows.Forms.Timer>(ref this.clearCacheTimer); } catch (Exception) { } } }
protected virtual void OnGUI(int elementIndex) { using (Profiling.GetMarker(Profiling.MarkerId.MemoryProfiler).Auto()) { try { using (new Service <IDebugContextService> .ScopeService(new DebugContextService())) { var rect = m_VisualElements[elementIndex].contentRect; if (float.IsNaN(rect.width) || float.IsNaN(rect.height)) { rect = new Rect(0, 0, 1, 1); } m_VisualElementsOnGUICalls[elementIndex](rect); } } catch (ExitGUIException) { throw; } catch (Exception e) { throw new Exception(DebugUtility.GetExceptionHelpMessage(e)); } } }
void SetSnapshot(DataRenderer dataRenderer, PackedMemorySnapshot snapshot) { if (snapshot == null) { m_RawSnapshot = null; m_RawSchema = null; SchemaToDisplay = null; UpdateTableSelectionNames(); return; } m_RawSnapshot = snapshot; ProgressBarDisplay.ShowBar(string.Format("Opening snapshot: {0}", System.IO.Path.GetFileNameWithoutExtension(snapshot.filePath))); var cachedSnapshot = new CachedSnapshot(snapshot); using (Profiling.GetMarker(Profiling.MarkerId.CrawlManagedData).Auto()) { var crawling = Crawler.Crawl(cachedSnapshot); crawling.MoveNext(); //start execution var status = crawling.Current as EnumerationStatus; float progressPerStep = 1.0f / status.StepCount; while (crawling.MoveNext()) { ProgressBarDisplay.UpdateProgress(status.CurrentStep * progressPerStep, status.StepStatus); } } ProgressBarDisplay.ClearBar(); m_RawSchema = new RawSchema(); m_RawSchema.SetupSchema(cachedSnapshot, dataRenderer); SchemaToDisplay = m_RawSchema; if (k_DefaultViewFilePath.Length > 0) { using (ScopeDebugContext.Func(() => { return("File '" + k_DefaultViewFilePath + "'"); })) { Database.View.ViewSchema.Builder builder = null; using (Profiling.GetMarker(Profiling.MarkerId.LoadViewDefinitionFile).Auto()) { builder = Database.View.ViewSchema.Builder.LoadFromXMLFile(k_DefaultViewFilePath); } if (builder != null) { using (Profiling.GetMarker(Profiling.MarkerId.BuildViewDefinitionFile).Auto()) { ViewSchema = builder.Build(m_RawSchema); } if (ViewSchema != null) { SchemaToDisplay = ViewSchema; } } } } UpdateTableSelectionNames(); }
private void debugTreeView_SelectionChanged(object sender, EventArgs e) { // Color the value according to profiling times. if (!MyExecutionBlock.IsProfiling) { return; } TreeNodeAdv selectedTreeNode = GetSelectedTreeNode(); if (selectedTreeNode == null) { return; } // Get the relevant children of the current node. List <MyDebugNode> children = selectedTreeNode.Children .Select(child => child.Tag as MyDebugNode) .Where(childDebugNode => childDebugNode != null && childDebugNode.ProfilerTime != null) .ToList(); // Calculate total time of the individual components. double totalTime = children.Sum(childDebugNode => childDebugNode.ProfilerTime.Value.TotalMilliseconds); // Calculate the colors of the children nodes. foreach (MyDebugNode debugNodeChild in children) { double factor = debugNodeChild.ProfilerTime.Value.TotalMilliseconds / totalTime; debugNodeChild.BackgroundColor = Profiling.ItemColor(factor); } }
protected override IComparable GroupTyped(ColumnTyped <DataT> sourceColumn, ArrayRange sourceIndices) { using (Profiling.GetMarker(Profiling.MarkerId.MergeMedian).Auto()) { long count = sourceIndices.indexCount; DataT[] d = new DataT[count]; int i = 0; foreach (var v in sourceColumn.VisitRows(sourceIndices)) { d[i] = v; ++i; } Array.Sort(d, Comparer.Ascending <DataT>()); DataT median; long mid = count / 2; if (count % 2 == 0) { median = math.Div(math.Add(d[mid - 1], d[mid]), math.Make(2)); } else { median = d[mid]; } return(median); } }
public GroupedTable(Database.Table table, ArrayRange range, int colToGroupFirst, int colToGroupLast, int[] colGroupOrder, SortOrder[] sortOrder) : base(table.Schema) { m_table = table; if (m_table is ExpandTable) { m_expandTable = (ExpandTable)m_table; } m_Meta = m_table.GetMetaData(); m_GroupedColumnFirst = colToGroupFirst; m_GroupedColumnLast = colToGroupLast; m_ColumnOrder = colGroupOrder; m_SortOrder = sortOrder; int sourceGroupedColumnIndex = m_ColumnOrder[colToGroupFirst]; using (Profiling.GetMarker(Profiling.MarkerId.GroupedTable).Auto()) { var col = m_table.GetColumnByIndex(sourceGroupedColumnIndex); var metaCol = m_Meta.GetColumnByIndex(sourceGroupedColumnIndex); if (metaCol.DefaultGroupAlgorithm != null) { m_GroupCollection = metaCol.DefaultGroupAlgorithm.Group(col, range, m_SortOrder[colToGroupFirst]); } else { throw new Exception("Trying to group a column without grouping algorithm. Column '" + metaCol.Name + "' from table '" + m_table.GetName() + "'"); } InitializeFromGroupCollection(col, sourceGroupedColumnIndex); } }
public void Should_15_handle_http_get() { Profiling.Stamp("Creating HttpProxyClientStream..."); var cli = new Http.HttpProxyClientStream("localhost", _port).Track(this); Profiling.Stamp("Creating HttpProxyClientStream TestConnection..."); TestConnction(cli, Host); }
public void PopulateEffects() { using (Profiling.UseEnter()) { this.adjustmentsMenu.PopulateEffects(); this.effectsMenu.PopulateEffects(); } }
public ActionResult Register(RegisterVM registerVM) { var person = new Person { NIK = registerVM.NIK, FirstName = registerVM.FirstName, LastName = registerVM.LastName, Phone = registerVM.Phone, BirthDate = registerVM.BirthDate, Salary = registerVM.Salary, Email = registerVM.Email }; myContext.Persons.Add(person); //simpan ke table myContext.SaveChanges(); var account = new Account { NIK = registerVM.NIK, Password = Hashing.HashPassword(registerVM.Password) }; myContext.Accounts.Add(account); myContext.SaveChanges(); var education = new Education { GPA = registerVM.GPA, Degree = registerVM.Degree, UniversityId = registerVM.UniversityId }; myContext.Educations.Add(education); myContext.SaveChanges(); var profiling = new Profiling { NIK = registerVM.NIK, EducationId = education.Id }; myContext.Profilings.Add(profiling); myContext.SaveChanges(); var accountRole = new AccountRole { RoleId = 2, AccountId = registerVM.NIK }; myContext.AccountRoles.Add(accountRole); myContext.SaveChanges(); return(Ok(new { status = HttpStatusCode.OK, message = "Registrasi Berhasil" })); }
public static string Get(string key) { using (new ProfileContext("LocalConfigurationRepository.Get")) { Profiling.Trace($"Key: {key}"); string value = string.Empty; var result = _kvStorage.TryGetValue(key, out value) ? value : string.Empty; return(result); } }
public void OpenTable(Database.TableReference tableRef, Database.Table table) { Profiling.StartProfiling("Profile_OpenTable_" + table.GetName()); CloseCurrentTable(); m_CurrentTableLink = tableRef; CurrentTableIndex = m_UIState.CurrentMode.GetTableIndex(table); m_Spreadsheet = new UI.DatabaseSpreadsheet(m_UIState.FormattingOptions, table, this); m_Spreadsheet.onClickLink += OnSpreadsheetClick; m_EventListener.OnRepaint(); }
public void BaseClean() { Console.WriteLine("BaseTestCleanup..."); Profiling.Stamp(TraceCategory.Test, "BaseClean"); Explode(); // You can disable this in general and enable during fine object lifecycle profiling // this is safe, because ZZ_Clean test will wait for all tests at unce // WaitForObjects(); }
protected override IComparable GroupTyped(ColumnTyped <DataT> sourceColumn, ArrayRange sourceIndices) { using (Profiling.GetMarker(Profiling.MarkerId.MergeMax).Auto()) { DataT result = math.MinValue(); foreach (var v in sourceColumn.VisitRows(sourceIndices)) { result = math.Max(result, v); } return(result); } }
static (float, double) RunSort(SortSettings settings, Action randomizeList, Action sorting) { float timeMs = 0; for (int i = 0; i < settings.TestCount; i++) { randomizeList(); timeMs += Profiling.ExecutingProfile(sorting); } return(timeMs / settings.TestCount, 0); }
public string Get(string scope, string application, string section, string key) { using (new ProfileContext("CachedConfigurationStore.Get")) { var cacheKey = KeyMaker.ConstructKey(scope, application, section, key); Profiling.Trace($"Key: {key}"); var result = LocalConfigurationRepository.IsKeyPresent(cacheKey) ? LocalConfigurationRepository.Get(cacheKey) : GetFromRemote(scope, application, section, key); return(result); } }
public IActionResult Create(Profiling profiling, Account account) { applicationDbContext.Add(profiling); applicationDbContext.Add(account); var result = applicationDbContext.SaveChanges(); if (result > 0) { return(RedirectToAction(nameof(Index))); } return(View()); }
protected override IComparable GroupTyped(ColumnTyped <DataT> sourceColumn, ArrayRange sourceIndices) { using (Profiling.GetMarker(Profiling.MarkerId.MergeAverage).Auto()) { DataT result = math.Zero(); foreach (var v in sourceColumn.VisitRows(sourceIndices)) { result = math.Add(result, v); } result = math.Div(result, math.Make(sourceIndices.indexCount)); return(result); } }
private static void LoopEndPoint() { Profiling finish = ProfilingDictionary[typeof(PostLateUpdate.FinishFrameRendering)]; float endTime = finish.EndTime; foreach (var kv in ProfilingDictionary) { PrevSubSystemExecuteTimeDictionary[kv.Key] = kv.Value.ExecuteTime; kv.Value.Reset(); } _prevLoopExecuteTime = endTime - _loopStartTime; }
protected void Profile(String label, Action action) { label = FormatProfileLabel(label); DateTime start = DateTime.UtcNow; action(); var duration = DateTime.UtcNow - start; Profiling.AddRecord(label, duration); ProfilingEntries.TryAdd(label, duration); logger.LogDebug("{0} took {1}ms", label, (int)duration.TotalMilliseconds); }
protected T Profile <T>(String label, Func <T> func) { label = FormatProfileLabel(label); DateTime start = DateTime.UtcNow; T result = func(); var duration = DateTime.UtcNow - start; Profiling.AddRecord(label, duration); ProfilingEntries.TryAdd(label, duration); logger.LogDebug("{0} took {1}ms", label, (int)duration.TotalMilliseconds); return(result); }
public override int Read(byte[] buffer, int offset, int count) { try { Profiling.Stamp("SS Reader Wait"); var b = _readerUnlock.WaitOne(); if (!b) { return(0); } Profiling.Stamp("SS Reader Unlocked"); if (_readTo > _readFrom) { var m = Math.Min(count, _readTo - _readFrom); Array.Copy(_readBuf, _readFrom, buffer, offset, m); _readFrom += m; if (_readFrom < _readTo) { // var rem = _readTo - _readFrom; // Array.Copy(_readBuf, _readFrom, _readBuf, 0, _readTo - _readFrom); // _readFrom = 0; // _readTo = rem; } else { _readFrom = 0; _readTo = 0; _readerUnlock.Reset(); _readerFinished.Set(); } return(m); } return(0); } catch { // reset _readFrom = 0; _readTo = 0; _readerUnlock.Reset(); _readerFinished.Set(); Dispose(); throw; } finally { } }
protected async Task Profile(String label, Func <Task> func) { label = FormatProfileLabel(label); DateTime start = DateTime.UtcNow; await func(); var duration = DateTime.UtcNow - start; Profiling.AddRecord(label, duration); ProfilingEntries.TryAdd(label, duration); logger.LogDebug("{0} took {1}ms", label, (int)duration.TotalMilliseconds); }
static (float, double) RunSortWithMemoryDebug(SortSettings settings, Action randomizeList, Action sorting) { float timeMs = 0; double memoryKb = 0; for (int i = 0; i < settings.TestCount; i++) { randomizeList(); memoryKb += Profiling.MemoryProfile(() => { timeMs += Profiling.ExecutingProfile(sorting); }); } return(timeMs / settings.TestCount, memoryKb / settings.TestCount); }
protected override IComparable GroupTyped(ColumnTyped <DataT> sourceColumn, ArrayRange sourceIndices) { using (Profiling.GetMarker(Profiling.MarkerId.MergeSumPositive).Auto()) { DataT result = math.Zero(); DataT z = math.Zero(); foreach (var v in sourceColumn.VisitRows(sourceIndices)) { if (math.Compare(v, z) >= 0) { result = math.Add(result, v); } } return(result); } }
public override BaseMode BuildViewSchemaClone(Database.View.ViewSchema.Builder builder) { Database.View.ViewSchema vs; using (Profiling.GetMarker(Profiling.MarkerId.BuildViewDefinitionFile).Auto()) { vs = builder.Build(m_RawSchema); } if (vs != null) { SnapshotMode copy = new SnapshotMode(this); copy.ViewSchema = vs; copy.SchemaToDisplay = vs; copy.UpdateTableSelectionNames(); return(copy); } return(null); }
public void OnError(IDbCommand profiledDbCommand, Profiling.Data.SqlExecuteType executeType, Exception exception) { var formatter = new Profiling.SqlFormatters.SqlServerFormatter(); exception.Data["SQL"] = formatter.FormatSql(profiledDbCommand.CommandText, SqlTiming.GetCommandParameters(profiledDbCommand)); this.wrapped.OnError(profiledDbCommand, executeType, exception); }
public void ExecuteStart(IDbCommand profiledDbCommand, Profiling.Data.SqlExecuteType executeType) { this.wrapped.ExecuteStart(profiledDbCommand, executeType); }
public ErrorLoggingProfiler(Profiling.Data.IDbProfiler wrapped) { this.wrapped = wrapped; }
public void ExecuteFinish(IDbCommand profiledDbCommand, Profiling.Data.SqlExecuteType executeType, DbDataReader reader) { this.wrapped.ExecuteFinish(profiledDbCommand, executeType, reader); }
public Reports(Profiling.Report[] reports) { Report = reports; }