public void AdmitNewCallToOngoingSession(ISession session, ICall call, IMobileTerminal mobileTerminal) { if (session == null) { throw new VerticalHandoverPredictionException($"{nameof(session)} is invalid"); } if (call == null) { throw new VerticalHandoverPredictionException($"{nameof(call)} is invalid"); } if (mobileTerminal == null) { throw new VerticalHandoverPredictionException($"{nameof(mobileTerminal)} is invalid"); } TakeNetworkResources(call.Service.ComputeRequiredNetworkResources()); session.AddToActiveCalls(call); var state = mobileTerminal.UpdateMobileTerminalStateWhenAdmitingNewCallToOngoingSession(session.ActiveCalls); session.AddToSessionSequence(state); }
public bool CanAdmitNewCallToOngoingSession(ISession session, ICall call, IMobileTerminal mobileTerminal) { if (session == null) { throw new VerticalHandoverPredictionException($"{nameof(session)} is invalid"); } if (call == null) { throw new VerticalHandoverPredictionException($"{nameof(call)} is invalid"); } if (mobileTerminal == null) { throw new VerticalHandoverPredictionException($"{nameof(mobileTerminal)} is invalid"); } if (!this.Services.Contains(call.Service)) { return(false); } var requiredNetworkResources = call.Service.ComputeRequiredNetworkResources(); return(requiredNetworkResources <= AvailableNetworkResources()); }
private void StartNewSessionAndAdmitCall(CallStartedEvent evt, IMobileTerminal mobileTerminal, IRat rat) { var session = new Session(rat.RatId, evt.Time); mobileTerminal.SetSessionId(session.SessionId); rat.TakeNetworkResources(evt.Call.Service.ComputeRequiredNetworkResources()); session.AddToActiveCalls(evt.Call); var state = mobileTerminal.UpdateMobileTerminalState(session); session.AddToSessionSequence(state); rat.AddSession(session); }
private void RunNonPredictiveAlgorithm(CallStartedEvent evt, IMobileTerminal mobileTerminal) { var rats = HetNet.Instance.Rats .Where(x => x.Services.Contains(evt.Call.Service)) .OrderBy(x => x.Services.Count) .ToList(); foreach (var rat in rats) { if (evt.Call.Service.ComputeRequiredNetworkResources() <= rat.AvailableNetworkResources()) { StartNewSessionAndAdmitCall(evt, mobileTerminal, rat); return; } } HetNet.Instance.BlockedCalls++; }
private void RunPredictiveAlgorithm(CallStartedEvent evt, IMobileTerminal mobileTerminal) { //var history = CsvUtils._Instance.Read<CallLogMap,CallLog>($"{Environment.CurrentDirectory}/calllogs.csv").ToList(); var nextState = evt.Call.Service.GetState(); if (HetNet.Instance.CallerHistory.Any()) { var group = HetNet.Instance.CallerHistory .Where(x => x.UserId == mobileTerminal.MobileTerminalId) .Select(x => x.SessionSequence) .Select(x => x.ToList().Select(x => (MobileTerminalState)(int.Parse(x.ToString())))) .Select(x => x.Skip(1).Take(2)) .Where(x => x.StartsWith(new List <MobileTerminalState> { evt.Call.Service.GetState() })) .SelectMany(x => x.Skip(1)) .Where(x => x != MobileTerminalState.Idle) .GroupBy(x => x); //If group is empty it means prediction has failed if (!group.Any()) { HetNet.Instance.FailedPredictions++; } else { //continue to compute frequency table var prediction = default(IGrouping <MobileTerminalState, MobileTerminalState>); var max = 0; //If There are ties it takes the last item in the history : Fix this, what decision is made in that case //group.Dump(); foreach (var grp in group) { if (grp.Count() > max) { prediction = grp; max = prediction.Count(); } //Console.WriteLine( $"next state is {grp.Key}, Frequency: {grp.Count()}"); } nextState = prediction.Key; } } var services = new List <Service> { evt.Call.Service }; foreach (var service in nextState.SupportedServices()) { if (!services.Contains(service)) { services.Add(service); } } var rats = HetNet.Instance.Rats .Where(x => x.Services.ToHashSet().IsSupersetOf(services)) .OrderBy(x => x.Services.Count) .ToList(); //This scheme reserves bandwidth in advance, I considered all the services var requiredNetworkResources = 0; foreach (var service in services) { requiredNetworkResources += service.ComputeRequiredNetworkResources(); } foreach (var rat in rats) { if (requiredNetworkResources <= rat.AvailableNetworkResources()) { StartNewSessionAndAdmitCall(evt, mobileTerminal, rat); if (evt.Call.Service.GetState() != nextState) { //Successful Prediction means 1. predicted state was not idle 2. call ends up being admited as predicted HetNet.Instance.SuccessfulPredictions++; //Log.Information("----- Successful prediction"); } return; } } //All Possible Rats Cannot Admit Call i.e [call in its predicted state] HetNet.Instance.BlockedUsingPredictiveScheme++; //Try just accommodating the incoming call without predicting before blocking it RunNonPredictiveAlgorithm(evt, mobileTerminal); }
public void Handover(ICall call, ISession session, IMobileTerminal mobileTerminal, IRat source) { if (call == null) { throw new VerticalHandoverPredictionException($"{nameof(call)} is invalid"); } if (session == null) { throw new VerticalHandoverPredictionException($"{nameof(session)} is invalid"); } if (mobileTerminal == null) { throw new VerticalHandoverPredictionException($"{nameof(mobileTerminal)} is invalid"); } if (source == null) { throw new VerticalHandoverPredictionException($"{nameof(source)} is invalid"); } var callsToHandedOverToTargetRat = session.ActiveCalls.Select(x => x.Service).ToList(); callsToHandedOverToTargetRat.Add(call.Service); var rats = Rats .Where(x => x.RatId != session.RatId && x.Services.ToHashSet().IsSupersetOf(callsToHandedOverToTargetRat)) .OrderBy(x => x.Services.Count()) .ToList(); var requiredNetworkResouces = 0; foreach (var service in callsToHandedOverToTargetRat) { requiredNetworkResouces += service.ComputeRequiredNetworkResources(); } foreach (var target in rats) { if (requiredNetworkResouces <= target.AvailableNetworkResources()) { UpdateHandovers(call.Service); source.RealeaseNetworkResources(requiredNetworkResouces - call.Service.ComputeRequiredNetworkResources()); source.RemoveSession(session); session.SetRatId(target.RatId); target.TakeNetworkResources(requiredNetworkResouces); session.AddToActiveCalls(call); var state = mobileTerminal.UpdateMobileTerminalState(session); session.AddToSessionSequence(state); target.AddSession(session); return; } } //If call cannot be handed over then the incoming call is blocked BlockedCalls++; }