public Signal Run(RawMarketData rmd)
        {
            if (rmd == null)
            {
                return Signal.Stay;
            }

            if (Util.IsValidPrice(rmd.CurPrice))
            {
                _curFuturePrice = rmd.CurPrice;

                if (_curFuturePrice >= _upBarrier)
                {
                    return Signal.Rebalance;
                }
                else if (_curFuturePrice <= _downBarrier)
                {
                    return Signal.Rebalance;
                }
                return Signal.Stay;
            }
            else
            {
                return Signal.Stay;
            }
        }

        public static RawMarketData GetRawMarketData()
        {
            RawMarketData rmd = new RawMarketData("test_code", Detail.ProductType.Unknown);

            rmd.AskPrice5 = 10;
            rmd.AskPrice4 = 9;
            rmd.AskPrice3 = 8;
            rmd.AskPrice2 = 7;
            rmd.AskPrice1 = 6;

            rmd.BidPrice1 = 5;
            rmd.BidPrice2 = 4;
            rmd.BidPrice3 = 3;
            rmd.BidPrice4 = 2;
            rmd.BidPrice5 = 1;

            rmd.AskCount5 = 10;
            rmd.AskCount4 = 20;
            rmd.AskCount3 = 30;
            rmd.AskCount2 = 40;
            rmd.AskCount1 = 50;

            rmd.BidCount1 = 55;
            rmd.BidCount2 = 45;
            rmd.BidCount3 = 35;
            rmd.BidCount4 = 25;
            rmd.BidCount5 = 15;

            rmd.LastUpdatedTime = DateTime.Now;

            return rmd;
        }

        void KtbFutureTest()
        {
            String future10yrCode = KtbFutureUtil.Ins().KtbFuture_10yr_1.Code;
            {
                TradingDirection longShort = TradingDirection.Long;
                string code = future10yrCode;
                long reqCount = 10;
                double reqPrice = 105.10;
                Account account = AccountManager.Ins().CreateSimFOAccount();

                IOrderLimit orderLimit = new DefaultOrderLimit(account);
                orderLimit = new LimOrderLimit(orderLimit);

                account.SetOrderLimit(orderLimit);

                RawMarketData rmdClone = new RawMarketData(future10yrCode, Detail.ProductType.KtbFuture);
                rmdClone.BidPrice1 = 105.10;
                rmdClone.AskPrice1 = 105.15;

                POrder target = new POrder(longShort, code, reqCount, reqPrice, account, rmdClone);
                bool success = POrderUtil.RequestOrder(target, null);
                Assert.AreEqual(true, success);

                target.UpdateCancelMessage(target.ReqCount);

                POrder_UnittestUtil.ClearOrder(target);
            }
        }

 void SetData_Raw(RawMarketData rmd, String type, double value, DateTime dt)
 {
     switch (type)
     {
         case "CurPrice":
             rmd.CurPrice = value;
             break;
         case "AskCount1":
             rmd.AskCount1 = Convert.ToInt64(value);
             break;
         case "BidCount1":
             rmd.BidCount1 = Convert.ToInt64(value);
             break;
         case "AskPrice1":
             rmd.AskPrice1 = value;
             break;
         case "BidPrice1":
             rmd.BidPrice1 = value;
             break;
         case "Basis":
             break;
         case "CurRate":
             break;
         default:
             logger.Warn("Invalid {0}, {1}", type, value);
             break;
     }
     rmd.LastUpdatedTime = dt;
     LastUpdated = dt;
 }

        public RawMarketData Decode_Raw(InPacket iPacket, String targetCode, DateTime curDateTime)
        {
            try
            {
                StringPacket sp = new StringPacket(iPacket.ToString().Substring(24));
                String code = sp.Decode();

                if (code != targetCode)
                {
                    return null;
                }

                RawMarketData rmd = new RawMarketData(targetCode, Detail.ProductType.Unknown);

                String type = sp.Decode();
                double value = Convert.ToDouble(sp.Decode());
                DateTime dt = DateTime.ParseExact(sp.Decode(), "yyyyMMdd HH:mm:ss.fff", null);

                SetData_Raw(rmd, type, value, dt);

                return rmd;
            }
            catch (System.Exception ex)
            {
                logger.Warn(ex.ToString());
            }
            return null;
        }

        // RMD clone을 만드는 등 데이터를 준비하는 역할을 수행한다.
        // build ot, adjust price, adjust count 등의 작업을 진행한다.
        public void BeforeEnterSweeperChance()
        {
            _instanceRmdFut1 = _referenceRmdFut1.Clone() as RawMarketData;

            // adjust count
            POrderBidAskCountManager.Ins().AdjustRmdCountWithoutMine(ref _instanceRmdFut1);
        }

        Boolean IsValidCondition(RawMarketData rmd, RawMarketData rmdFuture)
        {
            if (!Util.IsValidRMDTimeAndPrice(rmdFuture) || !Util.IsValidRMDTimeAndPrice(rmd))
            {
                return false;
            }

            ArrayList arr = _context.TradingOrders;

            foreach (POrder o in arr)
            {
                if (o.LongShort == TradingDirection.Long)
                {
                    if (o.ReqPrice * 1.5 >= rmd.CurPrice)
                    {
                        return false;
                    }
                }
                else
                {
                    if (o.ReqPrice * 0.67 <= rmd.CurPrice)
                    {
                        return false;
                    }
                }
            }
            return true;
        }

        public void TestPOrderLegalData()
        {
            string code = "201EC260";
            RawMarketData rmd = new RawMarketData(code, Detail.ProductType.CallOption);
            rmd.BidPrice1 = 0.81000001F;
            rmd.BidCount1 = 1000;
            rmd.AskPrice1 = 0.81999999F;
            rmd.AskCount1 = 1000;

            Account simAccount = AccountManager.Ins().CreateSimFOAccount();

            POrder o0 = new POrder(TradingDirection.Long, code, 1, 0.81, simAccount, rmd);
            POrderLegalManager.Ins().Add(o0);

            {

                POrder o2 = new POrder(TradingDirection.Long, code, 1, 0.81, simAccount, rmd);
                Boolean success = POrderLegalManager.Ins().Remove(o2);
                Assert.AreEqual(success, false);
            }

            {
                POrder o = new POrder(TradingDirection.Short, code, 1, 0.8099998, simAccount, rmd);
                POrder_Accessor oAccessor = new POrder_Accessor(o);
                oAccessor.ReqPrice = 0.810006;

                Boolean legal = POrderLegalManager.Ins().IsLegalOrder(o, false);
                Assert.AreEqual(legal, false);

                o.SetAsLegalPrice();
                legal = POrderLegalManager.Ins().IsLegalOrder(o, false);
                Assert.AreEqual(legal, true);

                Util.LogOutCriticalError("\t\t # Non exist code search 1 permitted.");
                Boolean success = POrderLegalManager.Ins().Remove(o);
                Assert.AreEqual(success, false);

                POrderLegalManager.Ins().Add(o);

                POrder o2 = new POrder(TradingDirection.Short, code, 1, 0.8099998, simAccount, rmd);
                success = POrderLegalManager.Ins().Remove(o2);
                Assert.AreEqual(success, false);

                // test reverse
                {
                    POrder o3 = new POrder(TradingDirection.Long, code, 1, 0.83, simAccount, rmd);
                    POrder_Accessor oAccessor3 = new POrder_Accessor(o3);
                    oAccessor3.ReqPrice = 0.83;

                    legal = POrderLegalManager.Ins().IsLegalOrder(o3, false);
                    Assert.AreEqual(legal, false);

                    POrderLegalManager.Ins().Remove(o3);
                }
                POrderLegalManager.Ins().Remove(o2);
                POrderLegalManager.Ins().Remove(o);
            }
            POrderLegalManager.Ins().Remove(o0);
        }

 public static Boolean IsValidCurPrice(RawMarketData rmd)
 {
     if (rmd.CurPrice == double.MaxValue || rmd.CurPrice == double.MinValue || rmd.CurPrice == 0)
     {
         return false;
     }
     return true;
 }

        // 기존에 나가 있는 주문 수량을 고려해준다.
        // 하나의 기회에 대해서 순간적으로 많은 주문을 낼 수 있으므로 이렇게 해주도록 한다.
        public void AdjustRmdCountWithoutMine(ref RawMarketData rmd)
        {
            long myLongReqCount = GetRegisteredReqCount(rmd.Code, TradingDirection.Long, rmd.AskPrice1);
            rmd.AskCount1 = Math.Max(rmd.AskCount1 - myLongReqCount, 0);

            long myShortReqCount = GetRegisteredReqCount(rmd.Code, TradingDirection.Short, rmd.BidPrice1);
            rmd.BidCount1 = Math.Max(rmd.BidCount1 - myShortReqCount, 0);
        }

        public double GetOneUnitPnL(
            Position_KtbSkel position, RawMarketData spotRmdClone, RawMarketData futureRmdClone)
        {
            double spotProfit = spotRmdClone.BidPrice1 - position.SpotAvgPriceTimeAdjust;
            double futureProfit = (position.FutureAvgPrice - futureRmdClone.AskPrice1) * 100;

            double pnl = spotProfit + futureProfit;
            return pnl;
        }

        public MonitorEnter_KtbSkel(RawMarketData spotRmd, RawMarketData futureRmd, IMonitorEnterPolicy policy)
        {
            this._spotRmd = spotRmd;
            this._futureRmd = futureRmd;
            this._policy = policy;

            ValidateInputs();
            MakeInfoLog();
        }

        public void Add(DateTime dt, RawMarketData y, RawMarketData x)
        {
            MarketDataPair pair = new MarketDataPair();
            pair.CurDateTime = dt;
            pair.Y = y;
            pair.X = x;

            _data.Put(pair);
        }

        public MonitorDatum_KtbSkel GetIndicator(
            RawMarketData spotRmdThisTurn, RawMarketData futureRmdThisTurn)
        {
            try
            {
                double spotMidPrice = (spotRmdThisTurn.AskPrice1 + spotRmdThisTurn.BidPrice1) / 2;
                double futureMidPrice = (futureRmdThisTurn.AskPrice1 + futureRmdThisTurn.BidPrice1) / 2;

                double spotMidRate =
                    BondPriceRateMapManager.Ins().ConvertToRate(spotRmdThisTurn.Code, (int)spotMidPrice);

                double spotBidRate = BondPriceRateMapManager.Ins().ConvertToRate(
                    spotRmdThisTurn.Code, (int)spotRmdThisTurn.BidPrice1);
                double spotAskRate = BondPriceRateMapManager.Ins().ConvertToRate(
                    spotRmdThisTurn.Code, (int)spotRmdThisTurn.AskPrice1);

                double futureMidRate =
                    BondPriceRateMapManager.Ins().ConvertToRate(futureRmdThisTurn.Code, (int)(futureMidPrice * 100));
                double futureBidRate =
                    BondPriceRateMapManager.Ins().ConvertToRate(
                    futureRmdThisTurn.Code, (int)(futureRmdThisTurn.BidPrice1 * 100));
                double futureAskRate =
                    BondPriceRateMapManager.Ins().ConvertToRate(
                    futureRmdThisTurn.Code, (int)(futureRmdThisTurn.AskPrice1 * 100));

                double curSpotRate = spotMidRate;
                double curFutureRate = futureMidRate * (-1);

                String spotLog = String.Format("S {0:n0}({1:n5}) // {2:n0}({3:n5}) // {4:n0}({5:n5})",
                    spotRmdThisTurn.AskPrice1, spotAskRate,
                    spotMidPrice, spotMidRate,
                    spotRmdThisTurn.BidPrice1, spotBidRate);

                String futureLog = String.Format("F {0:n2}({1:n5}) // {2:n2}({3:n5}) // {4:n2}({5:n5})",
                    futureRmdThisTurn.AskPrice1, futureAskRate,
                    futureMidPrice, futureMidRate,
                    futureRmdThisTurn.BidPrice1, futureBidRate);

                double curIndicator = (curSpotRate + curFutureRate) * 10000;
                DateTime lastUpdated = DateTime.Now;

                MonitorDatum_KtbSkel datum = new MonitorDatum_KtbSkel();
                datum.CurIndicator = curIndicator;
                datum.FutureLog = futureLog;
                datum.SpotLog = spotLog;
                datum.LastUpdated = lastUpdated;

                return datum;
            }
            catch (System.Exception ex)
            {
                logger.Error(ex.ToString());
                Util.KillWithNotice(ex.ToString());
            }
            return null;
        }

 public Dictionary<int, double> GetIfExitPnL(RawMarketData rmd)
 {
     Dictionary<int, double> ret = new Dictionary<int, double>();
     foreach (KeyValuePair<int, ISweeper> sweeper in _liveSweepers)
     {
         double pnl = sweeper.Value.GetIfExitPnL(rmd);
         ret.Add(sweeper.Key, pnl);
     }
     return ret;
 }

 public Boolean IsExitChance(
     Position_KtbSkel position, RawMarketData spotRmdClone, RawMarketData futureRmdClone)
 {
     double pnl = GetOneUnitPnL(position, spotRmdClone, futureRmdClone);
     if (pnl >= kProfitPoint)
     {
         return true;
     }
     return false;
 }

 public POrder(
     TradingDirection longShort, 
     String code, 
     long reqCount, 
     double reqPrice, 
     Account account,
     RawMarketData rmdClone)
     : this(longShort, code, reqCount, reqPrice, account, rmdClone, MarketType._3_Default, false)
 {
 }

        public RawMarketData Register(String code, String name, Detail.ProductType dpt)
        {
            Trace.Assert(dpt == Detail.ProductType.KtbSpot);

            logger.Info("{0}({1}), {2} is registered.", code, name, dpt.ToString());

            RawMarketData rmd = new RawMarketData(code, name, dpt);
            _rmdDict.Add(code, rmd);
            return rmd;
        }

        public void RMDJsonTest()
        {
            RawMarketData rmd = new RawMarketData("testCode", Detail.ProductType.KospiFuture);
            RawMarketDataJson rmdJson = new RawMarketDataJson(rmd);

            Serializer serializer = new Serializer(typeof(RawMarketDataJson));
            string jsonText = serializer.Serialize(rmdJson);

            RawMarketDataJson rmdJson2 = (RawMarketDataJson)serializer.Deserialize(jsonText);
        }

        public void CloneTest()
        {
            RawMarketData origin = new RawMarketData(KospiFutureUtil.Ins().KFI.Code, Detail.ProductType.KospiFuture);
            origin.BidCount1 = 10;

            RawMarketData target = origin.Clone() as RawMarketData;
            origin.BidCount1 = 20;

            Assert.AreNotEqual(origin.BidCount1, target.BidCount1);
            Assert.AreNotEqual(origin, target);
        }