private static void Sort(ISortable sortable, IGeneratorItems generatorItems, int amount, FileService fileService) { fileService.Save(path, sortable.ToString()); Console.WriteLine("---- Analyze " + amount + " ----" + sortable.ToString()); TimeWatch timer = new TimeWatch(); timer.Start(); List <int> list = generatorItems.GetData(amount); Console.WriteLine("Time Loading List: " + timer.GetEllapsedMilliSeconds()); timer.Restart(); List <int> listOrderAsc = new List <int>(list); List <int> listOrderDesc = new List <int>(list); Console.WriteLine("Time Loading List to Order Asc or Desc:" + timer.GetEllapsedMilliSeconds()); timer.Restart(); List <int> orderedList = OrderAsc(sortable, listOrderAsc); long timeAsc = timer.GetEllapsedMilliSeconds(); Console.WriteLine("Time Ordering Asc:" + timer.GetEllapsedMilliSeconds()); timer.Restart(); List <int> orderedDescList = OrderDesc(sortable, listOrderDesc); long timeDesc = timer.GetEllapsedMilliSeconds(); Console.WriteLine("Time Ordering Desc:" + timer.GetEllapsedMilliSeconds()); fileService.Save(path, Environment.NewLine + $"Amount:{amount},TimeAsc:{timeAsc}, TimeDesc:{timeDesc}"); }
public ButtonPlay(float x, float y, float radius, string text) : base(x, y, radius, text) { Paint1 = new SKPaint { Style = SKPaintStyle.Stroke, IsAntialias = true, StrokeWidth = 7, Color = new SKColor(180, 100, 0, 150) }; Paint2 = new SKPaint { Style = SKPaintStyle.Fill, IsAntialias = true, StrokeWidth = 7, Color = new SKColor(180, 100, 0, 150) }; Timer = new TimeWatch(); Timer.Tick += tick => { Radius += (float)Math.Cos(tick / 10.0f); }; MouseUp += (element, state) => { Timer.Start(1, 45); }; }
private void OnCompleted() { if (System.Threading.Interlocked.CompareExchange(ref mCompletedStatus, 1, 0) == 0) { Time = TimeWatch.GetElapsedMilliseconds() - mStartTime; mClient.Client.ClientError = null; mClient.Client.DataReceive = null; try { taskCompletionSource.SetResult(this); } finally { if (mClient.Client.IsConnected) { PipeStream pipeStream = mClient.Client.Stream.ToPipeStream(); if (pipeStream.Length > 0) { pipeStream.ReadFree((int)pipeStream.Length); } } } } }
public void Execute() { double time = TimeWatch.GetTotalSeconds() - mLastTime; mLastTime = TimeWatch.GetTotalSeconds(); int value = (int)((double)(mCount - mLastCount) / time); mLastCount = mCount; Rps = value; SendIOPer = (long)((double)(mSendIO - mLastSendIO) / time); mLastSendIO = mSendIO; SendBytesPer = (long)((double)(mSendBytes - mLastSendBytes) / time); mLastSendBytes = mSendBytes; ReceiveIOPer = (long)((double)(mReceiveIO - mLastReceiveIO) / time); mLastReceiveIO = mReceiveIO; ReceiveBytesPer = (long)((double)(mReceiveBytes - mLastReceiveBytes) / time); mLastReceiveBytes = mReceiveBytes; if (value > MaxRps) { MaxRps = value; } AvgRps = (int)(mCount / (TimeWatch.GetTotalSeconds() - mFirstTime)); }
private bool OnCompleted() { if (Status == LoaderStatus.Completed) { return(true); } var completed = false; var count = System.Threading.Interlocked.Increment(ref mTotalRequest); if (Setting.Type == "time") { var time = TimeWatch.GetTotalSeconds(); if (time - mStartTime > Setting.Value) { completed = true; } } else { completed = count > Setting.Value; } if (completed) { this.Status = LoaderStatus.Completed; } return(completed); }
public void Start(float timeSeconds) { TimeWatch.Stop(); Model.finishTime = timeSeconds; TimeWatch.Start(); StartedSubject.OnNext(Unit.Default); }
internal HttpRequest CreateRequest(ISession session) { HttpToken token = (HttpToken)session.Tag; token.Request.RequestTime = TimeWatch.GetTotalMilliseconds(); return(token.Request); }
public RequestAgent(TcpClientAgent clientAgent, ServerAgent serverAgent, HttpRequest request, HttpResponse response, UrlRouteServerGroup.UrlServerInfo urlServerInfo, Routes.UrlRoute urlRoute) { mTransferEncoding = false; mRequestLength = 0; Code = 0; Server = serverAgent; Request = request; Response = response; mClientAgent = clientAgent; mClientAgent.Client.ClientError = OnSocketError; mClientAgent.Client.DataReceive = OnReveive; mBuffer = mClientAgent.Buffer; Status = RequestStatus.None; UrlServerInfo = urlServerInfo; UrlRoute = urlRoute; mStartTime = TimeWatch.GetElapsedMilliseconds(); mRequestID = request.ID; //System.Threading.Interlocked.Increment(ref RequestCount); //mHistoryRequests[mRequestID] = this; if (UrlRoute.TimeOut > 0) { TimerOutValue = mStartTime + UrlRoute.TimeOut; UrlRoute.Gateway.TimeoutFactory.Add(this); } mProxyStream = new PipeStream(UrlRoute.Gateway.ProxyBufferPool); }
public bool ValidateRPS() { lock (this) { long now = TimeWatch.GetElapsedMilliseconds(); ActiveTime = now; if (mEnbaledTime > now) { return(false); } if (mServer.Options.IPRpsLimit == 0) { return(true); } if (now - mLastTime >= 1000) { mLastTime = now; mRPS = 0; return(true); } else { mRPS++; bool result = mRPS < mServer.Options.IPRpsLimit; if (!result) { mEnbaledTime = mServer.Options.IPRpsLimitDisableTime + now; } return(result); } } }
public IList List(Type type, Command cmd, Region region) { TimeWatch.________________________________________________________("Peanut->Execute SQL Return List"); if (region == null) { region = new Region { Start = 0, Size = 99999999 } } ; IList items = null; if (Mappings.ObjectMapper.CurrentOM.SelectChange != null) { Mappings.ObjectMapper.CurrentOM.SelectChange.Change(cmd); } System.Type itemstype = System.Type.GetType("System.Collections.Generic.List`1"); itemstype = itemstype.MakeGenericType(type); if (region.Size > DBContext.DefaultListMaxSize) { items = (IList)Activator.CreateInstance(itemstype, DBContext.DefaultListMaxSize); } else { items = (IList)Activator.CreateInstance(itemstype, region.Size); } object item = null; using (IDataReader reader = ExecuteReader(cmd)) { int index = 0; while (reader.Read()) { if (index >= region.Start) { item = Activator.CreateInstance(type); if (item is IEntityState) { ((IEntityState)item).ConnectionType = this.Type; ((IEntityState)item).LoadData(reader); } else { Mappings.ObjectMapper.CurrentSelectReader.ReaderToObject(reader, item); } items.Add(item); if (items.Count == region.Size) { cmd.DbCommand.Cancel(); reader.Close(); break; } } index++; } } TimeWatch.________________________________________________________(); return(items); }
private void OnTimeOut(object state) { mTimer.Change(-1, -1); try { for (int i = 0; i < awaiterManager.AwaiterTables.Count; i++) { var items = awaiterManager.AwaiterTables[i].TimeOut(TimeWatch.GetElapsedMilliseconds()); if (items.Count > 0) { for (int k = 0; k < items.Count; k++) { ThrowBlockException(items[k].ID, $"{items[k].ID} process timeout!"); } } } } catch (Exception e_) { OnError(null, TIMEOUT_PROCESS_ERROR, "TimeOut handler error", e_); } finally { mTimer.Change(1000, 1000); } }
public static void Test() { TimeWatch.Clean(); TimeWatch.________________________________________________________("Peaunt Exeuctes"); CustOrderHist coh = new CustOrderHist(); coh.CustomerID = "ANATR"; IList <CustOrderHistItem> cohs = coh.List <CustOrderHistItem>(); foreach (CustOrderHistItem item in cohs) { Console.WriteLine(item.ProductName); } SQL sql; Employee employee = (Employee.employeeID == 3).ListFirst <Employee>(DB.DB3); Console.WriteLine(employee); TimeWatch.________________________________________________________("Insert Employee"); sql = "insert into employees(firstname,lastname) values(@p1,@p2)"; sql["p1", "henry"]["p2", "fan"].Execute(); TimeWatch.________________________________________________________(); TimeWatch.________________________________________________________("del employee"); sql = "delete from employees where firstname=@p1"; sql["p1", "henry"].Execute(); TimeWatch.________________________________________________________(); TimeWatch.________________________________________________________("count employee"); Query <int> getCount = "select count(*) from employees"; TimeWatch.________________________________________________________(); TimeWatch.________________________________________________________("get employee"); Query <Employee> getEmp = "select * from employees where employeeid=3"; TimeWatch.________________________________________________________(); TimeWatch.________________________________________________________("list employee"); Query <IList <Employee> > getEmps = "select * from employees"; TimeWatch.________________________________________________________(); TimeWatch.________________________________________________________("del employee with expression"); (Employee.firstName == "henry").Delete <Employee>(); TimeWatch.________________________________________________________(); TimeWatch.________________________________________________________("modify employee"); (Employee.employeeID == 3).Edit <Employee>(d => { d.LastName = "a"; }); TimeWatch.________________________________________________________(); ListOrders(); TimeWatch.________________________________________________________(); TimeWatch.Report(o => { Console.WriteLine(o.ToString()); }); }
public async void Ping() { if (System.Threading.Interlocked.CompareExchange(ref mPingStatus, 1, 0) == 0) { if (TcpClient.IsConnected) { try { RPCPacket request = new RPCPacket(); request.Url = "/__System/Ping"; var response = await XRPCClient.SendWait(request, TcpClient, null); PingTime = TimeWatch.GetElapsedMilliseconds(); } catch (Exception e_) { } finally { if (TimeOut(XRPCClient.PingTimeout * 1000)) { TcpClient.DisConnect(); bool isnew; TcpClient.Connect(out isnew); } } } else { PingTime = TimeWatch.GetElapsedMilliseconds(); } System.Threading.Interlocked.Exchange(ref mPingStatus, 0); } }
public int ExecuteNonQuery(Command cmd) { TimeWatch.________________________________________________________("Peanut->Execute NonQuery"); int value = mHandler.ExecuteNonQuery(cmd); TimeWatch.________________________________________________________(); return(value); }
public IDataReader ExecuteReader(Command cmd) { TimeWatch.________________________________________________________("Peanut->Execute Reader"); IDataReader result = mHandler.ExecuteReader(cmd); TimeWatch.________________________________________________________(); return(result); }
public object ExecuteScalar(Command cmd) { TimeWatch.________________________________________________________("Peanut->Execute Scalar"); object result = mHandler.ExecuteScalar(cmd); TimeWatch.________________________________________________________(); return(result); }
public static void Set(string key, object data, double seconds = 60) { CacheItem item = new CacheItem(); item.Data = data; item.ActiveTime = TimeWatch.GetTotalSeconds() + seconds; mCache[key] = item; }
public object ExecProc(object parameter) { TimeWatch.________________________________________________________("Peanut->Execute Proce Return Object"); object result = mHandler.ExecProc(parameter); TimeWatch.________________________________________________________(); return(result); }
public void Add(long time) { long value = System.Threading.Interlocked.Increment(ref mCount); if (value == 1) { mFirstTime = TimeWatch.GetTotalSeconds(); mLastTime = mFirstTime; } if (time <= 5) { System.Threading.Interlocked.Increment(ref ms5); } else if (time <= 10) { System.Threading.Interlocked.Increment(ref ms10); } else if (time <= 20) { System.Threading.Interlocked.Increment(ref ms20); } else if (time <= 50) { System.Threading.Interlocked.Increment(ref ms50); } else if (time <= 100) { System.Threading.Interlocked.Increment(ref ms100); } else if (time <= 200) { System.Threading.Interlocked.Increment(ref ms200); } else if (time <= 500) { System.Threading.Interlocked.Increment(ref ms500); } else if (time <= 1000) { System.Threading.Interlocked.Increment(ref ms1000); } else if (time <= 2000) { System.Threading.Interlocked.Increment(ref ms2000); } else if (time <= 5000) { System.Threading.Interlocked.Increment(ref ms5000); } else if (time <= 10000) { System.Threading.Interlocked.Increment(ref ms10000); } else { System.Threading.Interlocked.Increment(ref msOther); } }
public void TestIsHiRes_DoesNotThrowException() { var watch = new Mock<StopwatchWrapper>(); watch.Setup(m => m.IsHighResolution).Returns(true); TimeWatch sut = null; Assert.DoesNotThrow(() => { sut = new TimeWatch(watch.Object); }); Assert.IsNotNull(sut); }
public Timer() { Model = new TimerModel(); StartedSubject = new Subject <Unit>(); StoppedTimeSubject = new Subject <float>(); PausedTimeSubject = new Subject <float>(); ResumedSubject = new Subject <Unit>(); TimeWatch = new TimeWatch(); }
public void TestIsNotHiRes_ThrowsException() { var watch = new Mock<StopwatchWrapper>(); watch.Setup(m => m.IsHighResolution).Returns(false); TimeWatch sut = null; Assert.Throws<NotSupportedException>(() => { sut = new TimeWatch(watch.Object); }); Assert.IsNull(sut); }
internal void OnCompleted(EventResponseErrorArgs error) { if (System.Threading.Interlocked.CompareExchange(ref mCompletedStatus, 1, 0) == 0) { this.ResponseError = error; Time = (long)(TimeWatch.GetTotalMilliseconds() - Request.RequestTime); mClientAgent.Client.ClientError = null; mClientAgent.Client.DataReceive = null; mClientAgent.Status = TcpClientAgentStatus.ResponseSuccess; //System.Threading.Interlocked.Decrement(ref RequestCount); //mHistoryRequests.Remove(mRequestID, out RequestAgent value); try { if (Code >= 500) { if (Request.Server.EnableLog(BeetleX.EventArgs.LogType.Warring)) { Request.Server.Log(BeetleX.EventArgs.LogType.Warring, $"gateway {Request.ID} {Request.RemoteIPAddress} {Request.Method} {Request.Url} -> {Server.Host}:{Server.Port} completed code {Code} use time:{Time}ms"); } } else { if (Request.Server.EnableLog(BeetleX.EventArgs.LogType.Info)) { Request.Server.Log(BeetleX.EventArgs.LogType.Info, $"gateway {Request.ID} {Request.RemoteIPAddress} {Request.Method} {Request.Url} -> {Server.Host}:{Server.Port} completed code {Code} use time:{Time}ms"); } } if (UrlRoute.Pluginer.RequestedEnabled) { UrlRoute.Pluginer.Requested(this.GetEventRequestCompletedArgs()); } Completed?.Invoke(this); } catch (Exception e_) { if (Request.Server.EnableLog(BeetleX.EventArgs.LogType.Error)) { Request.Server.Log(BeetleX.EventArgs.LogType.Error, $"gateway {Request.ID} {Request.RemoteIPAddress} {Request.Method} {Request.Url} -> {Server.Host}:{Server.Port} completed event error {e_.Message}@{e_.StackTrace}"); } } finally { Request.ClearStream(); if (error != null) { Server.Gateway.OnResponseError(error); } else { Request.Recovery(); } FlushProxyStream(true); Server.Push(mClientAgent); } } }
public static object Get(string key) { if (mCache.TryGetValue(key, out CacheItem item)) { if (TimeWatch.GetTotalSeconds() > item.ActiveTime) { return(null); } return(item.Data); } return(null); }
public void TestIsRunning() { var sut = new TimeWatch(); Assert.IsFalse(sut.IsRunning); sut.Start(); Assert.IsTrue(sut.IsRunning); sut.Stop(); Assert.IsFalse(sut.IsRunning); }
private void SendMessage(AsyncTcpClient client) { ClientToken token = (ClientToken)client.Token; token.RequestTime = TimeWatch.GetElapsedMilliseconds(); token.MessageIndex++; int index = (int)(token.MessageIndex % Messages.Count); var msg = Messages[index]; var data = msg.ToBytes(); client.Send(s => s.Write(data, 0, data.Length)); this.CodeStatistics.Send(data.Length); }
public Request(HttpTcpClient clientAgent) { mTransferEncoding = false; mRequestLength = 0; Code = 0; mClient = clientAgent; mClient.Client.ClientError = OnSocketError; mClient.Client.DataReceive = OnReveive; mBuffer = mClient.Buffer; Status = RequestStatus.None; mStartTime = TimeWatch.GetElapsedMilliseconds(); mRequestID = System.Threading.Interlocked.Increment(ref mRequestIDSqueue); }
public ConnectionContext(string connnectionString, IDriver driver, string connName) { TimeWatch.Start("Peanut->Create IConnection Context"); mDB = connName; mHandler = DBContext.CurrentHandler(connName); if (mHandler == null) { mHandler = DBContext.AddConnectionHandler(connName, driver); mActiveConnection = true; } ConnectionName = connName; TimeWatch.End(); }
public ConnectionContext(string db, IDriver driver, DB type) { TimeWatch.________________________________________________________("Peanut->Create IConnection Context"); mDB = db; mHandler = DBContext.CurrentHandler(db); if (mHandler == null) { mHandler = DBContext.AddConnectionHandler(mDB, driver); mActiveConnection = true; } Type = type; TimeWatch.________________________________________________________(); }
public bool ValidateRPS() { if (MaxRPS == 0) { return(true); } long now = TimeWatch.GetElapsedMilliseconds(); if (now - mLastTime >= 1000) { return(true); } return(mRPS < MaxRPS); }
internal IList List(Type type, IConnectinContext cc, Region region) { TimeWatch.________________________________________________________("Peanut->SQL to list"); System.Type itemstype = System.Type.GetType("System.Collections.Generic.List`1"); itemstype = itemstype.MakeGenericType(type); IList result; if (region == null) { region = new Region(0, 99999999); } if (region.Size > DBContext.DefaultListMaxSize) { result = (IList)Activator.CreateInstance(itemstype, DBContext.DefaultListMaxSize); } else { result = (IList)Activator.CreateInstance(itemstype, region.Size); } Mappings.CommandReader cr = Mappings.CommandReader.GetReader(mBaseSql, type); int index = 0; Command cmd = GetCommand(); TimeWatch.________________________________________________________("Peanut->DataReader to list"); using (IDataReader reader = cc.ExecuteReader(cmd)) { TimeWatch.________________________________________________________("Peanut->Read Data"); while (reader.Read()) { if (index >= region.Start) { object item = Activator.CreateInstance(type); cr.ReaderToObject(reader, item); result.Add(item); if (result.Count >= region.Size) { cmd.DbCommand.Cancel(); reader.Dispose(); break; } } index++; } TimeWatch.________________________________________________________(); } TimeWatch.________________________________________________________(); TimeWatch.________________________________________________________(); return(result); }
private static void ListOrders() { TimeWatch.________________________________________________________("list order"); TimeWatch.________________________________________________________("create table"); JoinTable table = Order.employeeID.InnerJoin(Employee.employeeID) .InnerJoin(Order.customerID, Customer.customerID) .Select(Order.orderID.At(), Customer.companyName, Employee.firstName, Employee.lastName); TimeWatch.________________________________________________________(); TimeWatch.________________________________________________________("List"); IList <OrderView> orders = new Expression().List <OrderView>(table); TimeWatch.________________________________________________________(); TimeWatch.________________________________________________________(); }
public TimeStatisticsData GetData() { double now = TimeWatch.GetTotalSeconds(); double time = now - mLastTime; if (time > 1) { mData.Count = mCount; this.Increase = (double)(mCount - mLastCount); mData.Rps = (int)(Increase / (time)); mLastTime = now; mLastCount = mCount; } return(mData); }