public void Compare2()
        {
            TaskQueue.TQItemSelector sel = new TaskQueue.TQItemSelector("field1", TaskQueue.TQItemSelectorSet.Descending)
                .Rule("field2", TaskQueue.TQItemSelectorSet.Descending);
            SomeExtMessage inst = new SomeExtMessage()
            {
                field1 = 7,
                field2 = 15
            };
            InternalComparable cmp = (InternalComparable)inst.MakeComparator(sel, typeof(InternalComparable)/*, typeof(SomeExtMessage)*/);
            SomeExtMessage inst_CE = new SomeExtMessage()
            {
                field1 = 5,
                field2 = 18
            };
            SomeExtMessage inst_CL = new SomeExtMessage()
            {
                field1 = 8,
                field2 = 18
            };

            Assert.AreEqual(cmp(inst, inst_CE), -1);
            Assert.AreEqual(cmp(inst, inst_CL), 1);
            Assert.AreEqual(cmp(inst_CL, inst_CE), -1);
        }
Exemple #2
0
        public void CompareDict()
        {
            TaskQueue.TQItemSelector sel = new TaskQueue.TQItemSelector("field1", TaskQueue.TQItemSelectorSet.Ascending)
                                           .Rule("field2", TaskQueue.TQItemSelectorSet.Descending);
            SomeExtMessage inst = new SomeExtMessage()
            {
                field1 = 5,
                field2 = 15
            };

            TaskQueue.Providers.TaskMessage.InternalComparableDictionary cmp = (TaskQueue.Providers.TaskMessage.InternalComparableDictionary)
                                                                               TaskQueue.Providers.TaskMessage.MakeComparatorDictionary(sel);
            SomeExtMessage inst_CE = new SomeExtMessage()
            {
                field1 = 5,
                field2 = 18
            };
            SomeExtMessage inst_CL = new SomeExtMessage()
            {
                field1 = 4,
                field2 = 18
            };

            Assert.AreEqual(cmp(inst.GetHolder(), inst_CE.GetHolder()), 1);
            Assert.AreEqual(cmp(inst.GetHolder(), inst_CL.GetHolder()), 1);
            Assert.AreEqual(cmp(inst_CL.GetHolder(), inst_CE.GetHolder()), -1);
        }
Exemple #3
0
        public void CheckDict()
        {
            TaskQueue.TQItemSelector sel = new
                                           TaskQueue.TQItemSelector("field1", TaskQueue.TQItemSelectorSet.Ascending)
                                           .Rule("field2", 15L, true);
            SomeExtMessage inst = new SomeExtMessage()
            {
                field1 = 5,
                field2 = 15
            };

            TaskQueue.Providers.TaskMessage.InternalCheckDictionary chk = (TaskQueue.Providers.TaskMessage.InternalCheckDictionary)
                                                                          TaskQueue.Providers.TaskMessage.MakeCheckerDictionary(sel);
            SomeExtMessage inst_CE = new SomeExtMessage()
            {
                field1 = 5,
                field2 = 18
            };

            Assert.AreEqual(chk(inst.GetHolder()), true);
            Assert.AreEqual(chk(inst_CE.GetHolder()), false);

            Assert.AreEqual(chk(new Dictionary <string, object>()
            {
                { "field1", 5 }, { "field2", 15 }
            }), true);
            Assert.AreEqual(chk(new Dictionary <string, object>()
            {
                { "field1", 5 }
            }), false);
        }
Exemple #4
0
        public void Compare2()
        {
            TaskQueue.TQItemSelector sel = new TaskQueue.TQItemSelector("field1", TaskQueue.TQItemSelectorSet.Descending)
                                           .Rule("field2", TaskQueue.TQItemSelectorSet.Descending);
            SomeExtMessage inst = new SomeExtMessage()
            {
                field1 = 7,
                field2 = 15
            };
            InternalComparable cmp     = (InternalComparable)inst.MakeComparator(sel, typeof(InternalComparable) /*, typeof(SomeExtMessage)*/);
            SomeExtMessage     inst_CE = new SomeExtMessage()
            {
                field1 = 5,
                field2 = 18
            };
            SomeExtMessage inst_CL = new SomeExtMessage()
            {
                field1 = 8,
                field2 = 18
            };

            Assert.AreEqual(cmp(inst, inst_CE), -1);
            Assert.AreEqual(cmp(inst, inst_CL), 1);
            Assert.AreEqual(cmp(inst_CL, inst_CE), -1);
        }
Exemple #5
0
        static void PerfCheck()
        {
            CustomMessagesCompare.SomeExtMessage msg = new CustomMessagesCompare.SomeExtMessage()
            {
                field1 = 111,
                field2 = 15
            };

            Dictionary<string, object> a = msg.GetHolder();

            TaskQueue.TQItemSelector sel = new TaskQueue.TQItemSelector
                ("field1", TaskQueue.TQItemSelectorSet.Ascending)
                .Rule("field2", 15L, true);

            Stopwatch watch = new Stopwatch();
            TaskQueue.Providers.TaskMessage.InternalCheckDictionary chk =
                (TaskQueue.Providers.TaskMessage.InternalCheckDictionary)
                TaskQueue.Providers.TaskMessage.MakeCheckerDictionary(sel);
            watch.Start();
            for (int i = 0; i < 1000000; i++)
            {
                chk(a);
            }
            watch.Stop();
            Console.WriteLine("compiled {0:.00}ms", watch.Elapsed.TotalMilliseconds);
            watch.Restart();
            for (int i = 0; i < 1000000; i++)
            {
                TaskQueue.Providers.TaskMessage.CheckWithSelector(a, sel);
            }
            watch.Stop();
            Console.WriteLine("native {0:.00}ms", watch.Elapsed.TotalMilliseconds);
        }
Exemple #6
0
        public MessageChannel(string uniqueName, string connectionParamsName, TaskQueue.TQItemSelector selector = null)
        {
            this.UniqueName = uniqueName;
            this.ConnectionName = connectionParamsName;

            if (selector == null)
                this.consumerSelector = TaskQueue.TQItemSelector.DefaultFifoSelector;
            else
                this.consumerSelector = selector;
        }
Exemple #7
0
        public MessageChannel(string uniqueName, string connectionParamsName, TaskQueue.TQItemSelector selector = null)
        {
            this.UniqueName     = uniqueName;
            this.ConnectionName = connectionParamsName;

            if (selector == null)
            {
                this.consumerSelector = TaskQueue.TQItemSelector.DefaultFifoSelector;
            }
            else
            {
                this.consumerSelector = selector;
            }
        }
Exemple #8
0
        static void PerfCompare()
        {
            CustomMessagesCompare.SomeExtMessage msg = new CustomMessagesCompare.SomeExtMessage()
            {
                field1 = 111,
                field2 = 15
            };
            CustomMessagesCompare.SomeExtMessage msg2 = new CustomMessagesCompare.SomeExtMessage()
            {
                field1 = 111,
                field2 = 77
            };
            Dictionary<string, object> a = msg.GetHolder();
            Dictionary<string, object> b = msg2.GetHolder();
            TaskQueue.TQItemSelector sel = new TaskQueue.TQItemSelector
                ("field1", TaskQueue.TQItemSelectorSet.Ascending)
                .Rule("field2", TaskQueue.TQItemSelectorSet.Descending);

            Stopwatch watch = new Stopwatch();
            TaskQueue.Providers.TaskMessage.InternalComparableDictionary cmp = (TaskQueue.Providers.TaskMessage.InternalComparableDictionary)
                 TaskQueue.Providers.TaskMessage.MakeComparatorDictionary(sel);
            watch.Start();
            for (int i = 0; i < 1000000; i++)
            {
                cmp(a, b);
            }
            watch.Stop();
            Console.WriteLine("compiled {0:.00}ms", watch.Elapsed.TotalMilliseconds);
            watch.Restart();
            for (int i = 0; i < 1000000; i++)
            {
                TaskQueue.Providers.TaskMessage.CompareWithSelector(a, b, sel);
            }
            watch.Stop();
            Console.WriteLine("native {0:.00}ms", watch.Elapsed.TotalMilliseconds);

            Tests.CustomMessagesCompare.InternalComparable cmp2 = (Tests.CustomMessagesCompare.InternalComparable)
                msg.MakeComparator(sel, typeof(Tests.CustomMessagesCompare.InternalComparable));

            watch.Restart();
            for (int i = 0; i < 1000000; i++)
            {
                cmp2(msg, msg2);
            }
            watch.Stop();
            Console.WriteLine("compiled native {0:.00}ms", watch.Elapsed.TotalMilliseconds);
        }
Exemple #9
0
        public static IndexKeysBuilder GetIndex(TaskQueue.TQItemSelector selector)
        {
            IndexKeysBuilder ikb = new IndexKeysBuilder();

            foreach (KeyValuePair <string, TaskQueue.TQItemSelectorParam> kv in selector.parameters)
            {
                switch (kv.Value.ValueSet)
                {
                case TaskQueue.TQItemSelectorSet.Equals:
                    Type kvt = kv.Value.Value.GetType();
                    if (kvt == typeof(bool))
                    {
                        if ((bool)kv.Value.Value)
                        {
                            ikb = ikb.Ascending(kv.Key);
                        }
                        else
                        {
                            ikb = ikb.Descending(kv.Key);
                        }
                    }
                    else
                    {
                        ikb = ikb.Ascending(kv.Key);
                    }
                    break;
                }
            }
            foreach (KeyValuePair <string, TaskQueue.TQItemSelectorParam> kv in selector.parameters)
            {
                switch (kv.Value.ValueSet)
                {
                case TaskQueue.TQItemSelectorSet.Ascending:
                    ikb = ikb.Ascending(kv.Key);
                    break;

                case TaskQueue.TQItemSelectorSet.Descending:
                    ikb = ikb.Descending(kv.Key);
                    break;
                }
            }
            return(ikb);
        }
Exemple #10
0
        public static SortByBuilder GetSort(TaskQueue.TQItemSelector selector)
        {
            SortByBuilder sb = new SortByBuilder();

            foreach (KeyValuePair <string, TaskQueue.TQItemSelectorParam> kv in selector.parameters)
            {
                switch (kv.Value.ValueSet)
                {
                case TaskQueue.TQItemSelectorSet.Ascending:
                    sb = sb.Ascending(kv.Key);
                    break;

                case TaskQueue.TQItemSelectorSet.Descending:
                    sb = sb.Descending(kv.Key);
                    break;
                }
            }
            return(sb);
        }
Exemple #11
0
        public static IMongoQuery GetQuery(TaskQueue.TQItemSelector selector)
        {
            List <IMongoQuery> qs = new List <IMongoQuery>();

            foreach (KeyValuePair <string, TaskQueue.TQItemSelectorParam> kv in selector.parameters)
            {
                switch (kv.Value.ValueSet)
                {
                case TaskQueue.TQItemSelectorSet.Equals:
                    Type kvt = kv.Value.Value.GetType();
                    qs.Add(new QueryDocument(new Dictionary <string, object>()
                    {
                        { kv.Key, kv.Value.Value }
                    }));
                    break;
                }
            }
            IMongoQuery q = Query.And(qs);

            return(q);
        }
        public void CheckDict()
        {
            TaskQueue.TQItemSelector sel = new
                TaskQueue.TQItemSelector("field1", TaskQueue.TQItemSelectorSet.Ascending)
                .Rule("field2", 15L, true);
            SomeExtMessage inst = new SomeExtMessage()
            {
                field1 = 5,
                field2 = 15
            };
            TaskQueue.Providers.TaskMessage.InternalCheckDictionary chk = (TaskQueue.Providers.TaskMessage.InternalCheckDictionary)
                TaskQueue.Providers.TaskMessage.MakeCheckerDictionary(sel);
            SomeExtMessage inst_CE = new SomeExtMessage()
            {
                field1 = 5,
                field2 = 18
            };

            Assert.AreEqual(chk(inst.GetHolder()), true);
            Assert.AreEqual(chk(inst_CE.GetHolder()), false);

            Assert.AreEqual(chk(new Dictionary<string, object>() { { "field1", 5 }, { "field2", 15 } }), true);
            Assert.AreEqual(chk(new Dictionary<string, object>() { { "field1", 5 } }), false);
        }
Exemple #13
0
        public void CompareVMap()
        {
            TaskQueue.TQItemSelector sel = new TaskQueue.TQItemSelector("field1", TaskQueue.TQItemSelectorSet.Descending)
                                           .Rule("field2", TaskQueue.TQItemSelectorSet.Ascending);
            SomeExtMessage inst = new SomeExtMessage()
            {
                field1 = 5,
                field2 = 15
            };

            TaskQueue.Providers.TaskMessage.InternalComparableValueMap cmp =
                TaskQueue.Providers.TaskMessage.MakeComparatorValueMap(sel);
            SomeExtMessage inst_CE = new SomeExtMessage()
            {
                field1 = 6,
                field2 = 15
            };
            SomeExtMessage inst_CL = new SomeExtMessage()
            {
                field1 = 4,
                field2 = 18
            };

            TaskQueue.Providers.TaskMessage defmsg = new TaskQueue.Providers.TaskMessage("X");
            Assert.AreEqual(cmp(inst.GetValueMap(sel), inst_CE.GetValueMap(sel)),
                            TaskQueue.Providers.TaskMessage.CompareWithSelector(inst.GetHolder(), inst_CE.GetHolder(), sel));

            Assert.AreEqual(cmp(inst.GetValueMap(sel), inst_CL.GetValueMap(sel)),
                            TaskQueue.Providers.TaskMessage.CompareWithSelector(inst.GetHolder(), inst_CL.GetHolder(), sel));

            Assert.AreEqual(cmp(inst_CL.GetValueMap(sel), inst_CE.GetValueMap(sel)),
                            TaskQueue.Providers.TaskMessage.CompareWithSelector(inst_CL.GetHolder(), inst_CE.GetHolder(), sel));

            Assert.AreEqual(cmp(defmsg.GetValueMap(sel), inst_CE.GetValueMap(sel)),
                            TaskQueue.Providers.TaskMessage.CompareWithSelector(defmsg.GetHolder(), inst_CE.GetHolder(), sel));
        }
Exemple #14
0
 public MessageChannel()
 {
     consumerSelector = TaskQueue.TQItemSelector.DefaultFifoSelector;
 }
Exemple #15
0
        // bunch [channel~[message model], module[message model], +executionContext]
        // note: this is configure which channel is selected for custom module
        public void RegisterTask(string ChannelName, string moduleName,
            IntervalType it = IntervalType.intervalMilliseconds,
            long intervalValue = 100,
            Dictionary<string, object> parameters = null, string Description = "-")
        {
            ModMod module = Modules.GetInstanceByName(moduleName);
            MessageChannel channel = MessageChannels.GetInstanceByName(ChannelName);

            if (module == null)
                throw new Exception("RegisterTask: required module not found: " + moduleName);

            if (channel == null)
                throw new Exception("RegisterTask: required channel not found: " + ChannelName);

            TaskScheduler.PlanItemEntryPoint ep = TaskEntry;
            if (it == IntervalType.isolatedThread)
            {
                ep = IsolatedTaskEntry;
            }
            QueueTask t = new QueueTask()
            {
                Module = module,
                ModuleName = moduleName,

                //Description = Description,
                ChannelName = ChannelName,
                Anteroom = ChannelName == null ? null : MessageChannels.GetAnteroom(ChannelName),
                Parameters = parameters,

                intervalType = it,
                intervalValue = intervalValue,
                JobEntry = ep,

                NameAndDescription = Description
            };
            // task not required a channel only if module not implement consumer interface
            if (module.Role == ExecutionType.Consumer)
            {
                if (!typeof(IModConsumer).IsAssignableFrom(module.MI.GetType()))
                {
                    throw new Exception("Consumer module required a consumer interface");
                }
                if (ChannelName == null)
                {
                    throw new Exception("Consumer module required a channel");
                }
                else
                {
                    if (t.Anteroom.ChannelStatsIn == null && t.Anteroom.ChannelStatsIn == null)// first task for this channel?
                    {
                        // monitoring put operation
                        t.Anteroom.ChannelStatsIn = Statistics.InitialiseModel(new BrokerStat("chan_in", ChannelName));
                        t.Anteroom.ChannelStatsOut = Statistics.InitialiseModel(new BrokerStat("chan_out", ChannelName));
                        // set selector
                        TaskQueue.TQItemSelector selector = ((IModConsumer)module.MI).ConfigureSelector();
                        // channel -> model(MType)
                        MessageChannels.AssignMessageTypeToChannel(ChannelName, ((IModConsumer)module.MI).AcceptsModel, moduleName);
                        channel.consumerSelector = selector;
                    }
                }
            }
            Tasks.Add(t);
            UpdatePlan();
            //if (t.intervalType == TaskScheduler.IntervalType.isolatedThread)
            //    Scheduler.CreateIsolatedThreadForPlan(t);
        }
        public void CompareDict2()
        {
            TaskQueue.TQItemSelector sel = new TaskQueue.TQItemSelector("field1", TaskQueue.TQItemSelectorSet.Descending)
                .Rule("field2", TaskQueue.TQItemSelectorSet.Ascending);
            SomeExtMessage inst = new SomeExtMessage()
            {
                field1 = 5,
                field2 = 15
            };
            TaskQueue.Providers.TaskMessage.InternalComparableDictionary cmp = (TaskQueue.Providers.TaskMessage.InternalComparableDictionary)
                TaskQueue.Providers.TaskMessage.MakeComparatorDictionary(sel);
            SomeExtMessage inst_CE = new SomeExtMessage()
            {
                field1 = 6,
                field2 = 15
            };
            SomeExtMessage inst_CL = new SomeExtMessage()
            {
                field1 = 4,
                field2 = 18
            };

            Assert.AreEqual(cmp(inst.GetHolder(), inst_CE.GetHolder()),
                TaskQueue.Providers.TaskMessage.CompareWithSelector(inst.GetHolder(), inst_CE.GetHolder(), sel));

            Assert.AreEqual(cmp(inst.GetHolder(), inst_CL.GetHolder()),
                TaskQueue.Providers.TaskMessage.CompareWithSelector(inst.GetHolder(), inst_CL.GetHolder(), sel));

            Assert.AreEqual(cmp(inst_CL.GetHolder(), inst_CE.GetHolder()),
                TaskQueue.Providers.TaskMessage.CompareWithSelector(inst_CL.GetHolder(), inst_CE.GetHolder(), sel));
        }
Exemple #17
0
        //static void PerfCheck()
        //{
        //    CustomMessagesCompare.SomeExtMessage msg = new CustomMessagesCompare.SomeExtMessage()
        //    {
        //        field1 = 111,
        //        field2 = 15
        //    };

        //    Dictionary<string, object> a = msg.GetHolder();

        //    TaskQueue.TQItemSelector sel = new TaskQueue.TQItemSelector
        //        ("field1", TaskQueue.TQItemSelectorSet.Ascending)
        //        .Rule("field2", 15L, true);

        //    Stopwatch watch = new Stopwatch();
        //    TaskQueue.Providers.TaskMessage.InternalCheckDictionary chk =
        //        (TaskQueue.Providers.TaskMessage.InternalCheckDictionary)
        //        TaskQueue.Providers.TaskMessage.MakeCheckerDictionary(sel);
        //    watch.Start();
        //    for (int i = 0; i < 1000000; i++)
        //    {
        //        chk(a);
        //    }
        //    watch.Stop();
        //    Console.WriteLine("compiled {0:.00}ms", watch.Elapsed.TotalMilliseconds);
        //    watch.Restart();
        //    for (int i = 0; i < 1000000; i++)
        //    {
        //        TaskQueue.Providers.TaskMessage.CheckWithSelector(a, sel);
        //    }
        //    watch.Stop();
        //    Console.WriteLine("native {0:.00}ms", watch.Elapsed.TotalMilliseconds);
        //}
        //static void PerfCompare()
        //{
        //    CustomMessagesCompare.SomeExtMessage msg = new CustomMessagesCompare.SomeExtMessage()
        //    {
        //        field1 = 111,
        //        field2 = 15
        //    };
        //    CustomMessagesCompare.SomeExtMessage msg2 = new CustomMessagesCompare.SomeExtMessage()
        //    {
        //        field1 = 111,
        //        field2 = 77
        //    };
        //    Dictionary<string, object> a = msg.GetHolder();
        //    Dictionary<string, object> b = msg2.GetHolder();
        //    TaskQueue.TQItemSelector sel = new TaskQueue.TQItemSelector
        //        ("field1", TaskQueue.TQItemSelectorSet.Ascending)
        //        .Rule("field2", TaskQueue.TQItemSelectorSet.Descending);

        //    Stopwatch watch = new Stopwatch();
        //    TaskQueue.Providers.TaskMessage.InternalComparableDictionary cmp = (TaskQueue.Providers.TaskMessage.InternalComparableDictionary)
        //         TaskQueue.Providers.TaskMessage.MakeComparatorDictionary(sel);
        //    watch.Start();
        //    for (int i = 0; i < 1000000; i++)
        //    {
        //        cmp(a, b);
        //    }
        //    watch.Stop();
        //    Console.WriteLine("compiled {0:.00}ms", watch.Elapsed.TotalMilliseconds);
        //    watch.Restart();
        //    for (int i = 0; i < 1000000; i++)
        //    {
        //        TaskQueue.Providers.TaskMessage.CompareWithSelector(a, b, sel);
        //    }
        //    watch.Stop();
        //    Console.WriteLine("native {0:.00}ms", watch.Elapsed.TotalMilliseconds);

        //    Tests.CustomMessagesCompare.InternalComparable cmp2 = (Tests.CustomMessagesCompare.InternalComparable)
        //        msg.MakeComparator(sel, typeof(Tests.CustomMessagesCompare.InternalComparable));


        //    watch.Restart();
        //    for (int i = 0; i < 1000000; i++)
        //    {
        //        cmp2(msg, msg2);
        //    }
        //    watch.Stop();
        //    Console.WriteLine("compiled native {0:.00}ms", watch.Elapsed.TotalMilliseconds);
        //}
        static void PerfQueue()
        {
            CustomMessagesCompare.SomeExtMessage msg = new CustomMessagesCompare.SomeExtMessage()
            {
                field1 = 111,
                field2 = 15
            };
            CustomMessagesCompare.SomeExtMessage msg2 = new CustomMessagesCompare.SomeExtMessage()
            {
                field1 = 111,
                field2 = 77
            };
            Dictionary <string, object> a = msg.GetHolder();
            Dictionary <string, object> b = msg2.GetHolder();

            TaskQueue.TQItemSelector sel = new TaskQueue.TQItemSelector("field1", TaskQueue.TQItemSelectorSet.Ascending)
                                           .Rule("field2", TaskQueue.TQItemSelectorSet.Descending)
                                           .Rule("Processed", false, true);

            TaskQueue.Providers.MemQueue mq = new TaskQueue.Providers.MemQueue();
            mq.SetSelector(sel);

            SecQueue.SecQueue mq2 = new SecQueue.SecQueue();
            mq2.SetSelector(sel);
            const int counting = 50000;

            Stopwatch watch = new Stopwatch();

            watch.Start();
            Dictionary <string, object> baseData = msg.GetHolder();
            Random rnd = new Random();
            List <TaskQueue.Providers.TaskMessage> data = new List <TaskQueue.Providers.TaskMessage>();

            for (int i = 0; i < counting; i++)
            {
                baseData["field1"] = rnd.Next();
                baseData["field2"] = rnd.Next();
                data.Add(new TaskQueue.Providers.TaskMessage(baseData));
            }
            watch.Stop();
            Console.WriteLine("populate {0:.00}ms {1} avg [{2:.0}] msg per second", watch.Elapsed.TotalMilliseconds, counting, (1000.0 / watch.Elapsed.TotalMilliseconds) * counting);

            watch.Restart();
            for (int i = 0; i < counting; i++)
            {
                mq.Push(data[i]);
                if (i % 2 == 0)
                {
                    var itm = mq.GetItem();
                    itm.Processed = true;
                    mq.UpdateItem(itm);
                }
            }

            watch.Stop();
            Console.WriteLine("sortedset {0:.00}ms {1} avg [{2:.0}] msg per second", watch.Elapsed.TotalMilliseconds, mq.GetQueueLength(), (1000.0 / watch.Elapsed.TotalMilliseconds) * counting);
            watch.Restart();

            for (int i = 0; i < counting; i++)
            {
                mq2.Push(data[i]);
                if (i % 2 == 0)
                {
                    var itm = mq2.GetItem();
                    itm.Processed = true;
                    mq2.UpdateItem(itm);
                }
            }
            watch.Stop();
            Console.WriteLine("secset {0:.00}ms {1} avg [{2:.0}] msg per second", watch.Elapsed.TotalMilliseconds, mq2.GetQueueLength(), (1000.0 / watch.Elapsed.TotalMilliseconds) * counting);

            return;

            MongoQueue.MongoDbQueue mq3 = new MongoQueue.MongoDbQueue();
            mq3.InitialiseFromModel(null, new TaskQueue.Providers.QueueConnectionParameters("")
            {
                specParams = (new MongoQueue.MongoQueueParams()
                {
                    Collection = "test",
                    Database = "test",
                    ConnectionString = "mongodb://localhost:27017/Messages?safe=true"
                })
            });
            mq3.SetSelector(sel);

            watch.Restart();
            for (int i = 0; i < counting; i++)
            {
                mq3.Push(data[i]);
                if (i % 2 == 0)
                {
                    var itm = mq3.GetItem();
                    itm.Processed = true;
                    mq3.UpdateItem(itm);
                }
            }
            watch.Stop();
            Console.WriteLine("mongo {0:.00}ms {1} avg [{2:.0}] msg per second", watch.Elapsed.TotalMilliseconds, mq3.GetQueueLength(), (1000.0 / watch.Elapsed.TotalMilliseconds) * counting);
        }