Beispiel #1
0
        public void OneWriteThenReadState()
        {
            Task.Run(async() =>
            {
                InstrumentationContext.Reset();
                var grainStateMap = CreateGrainStateMap();
                var grainIdentity = RandomIdentity();
                var state         = CreateState();

                using (var dataManager = new SqlDataManager(logger, grainStateMap, ConnectionString, ShardCredentials, ShardMapDefault))
                {
                    var stopwatch = Stopwatch.StartNew();
                    await dataManager.UpsertStateAsync(grainIdentity, state);
                    stopwatch.Stop();
                    Console.WriteLine(" Insert elapsed: {0}", stopwatch.Elapsed);

                    // now read
                    stopwatch  = Stopwatch.StartNew();
                    var state2 = await dataManager.ReadStateAsync(grainIdentity);
                    stopwatch.Stop();
                    Console.WriteLine(" Read elapsed: {0}", stopwatch.Elapsed);
                    Assert.AreEqual(state, state2);
                }
            }).Wait();
        }
Beispiel #2
0
        public void WriteThenRead10KStates()
        {
            InstrumentationContext.Reset();
            const int count         = 10000;
            var       grainStateMap = CreateGrainStateMap();
            var       grains        = new List <Tuple <GrainIdentity, object> >();

            for (int i = 0; i < count; ++i)
            {
                var state = CreateState(i);
                grains.Add(new Tuple <GrainIdentity, object>(RandomIdentity(), state));
            }

            using (var dataManager = new SqlDataManager(logger, grainStateMap, ConnectionString, ShardCredentials, ShardMapDefault))
            {
                var stopwatch = Stopwatch.StartNew();
                var tasks     = grains.Select(grain => dataManager.UpsertStateAsync(grain.Item1, grain.Item2)).ToArray();
                Task.WaitAll(tasks);
                stopwatch.Stop();
                Console.WriteLine(" Insert elapsed: {0}", stopwatch.Elapsed);

                // now read
                stopwatch = Stopwatch.StartNew();
                var rtasks = grains.Select(grain => dataManager.ReadStateAsync(grain.Item1)).ToList();
                Task.WaitAll(rtasks.Cast <Task>().ToArray());
                stopwatch.Stop();
                Console.WriteLine(" Read elapsed: {0}", stopwatch.Elapsed);
            }
        }
Beispiel #3
0
        public void ReadNonExistentState()
        {
            Task.Run(async() =>
            {
                InstrumentationContext.Reset();
                var grainStateMap = CreateGrainStateMap();
                var grainIdentity = RandomIdentity();

                using (var dataManager = new SqlDataManager(logger, grainStateMap, ConnectionString, ShardCredentials, ShardMapDefault))
                {
                    // now read
                    var stopwatch = Stopwatch.StartNew();
                    var state     = await dataManager.ReadStateAsync(grainIdentity);
                    stopwatch.Stop();
                    Console.WriteLine(" Read elapsed: {0}", stopwatch.Elapsed);

                    Assert.IsNull(state);
                }
            }).Wait();
        }
Beispiel #4
0
        public void OneWriteThenReadState()
        {
            Task.Run(async () =>
            {
                InstrumentationContext.Reset();
                var grainStateMap = CreateGrainStateMap();
                var grainIdentity = RandomIdentity();
                var state = CreateState();

                using (var dataManager = new SqlDataManager(logger, grainStateMap, ConnectionString, ShardCredentials, ShardMapDefault))
                {
                    var stopwatch = Stopwatch.StartNew();
                    await dataManager.UpsertStateAsync(grainIdentity, state);
                    stopwatch.Stop();
                    output.WriteLine(" Insert elapsed: {0}", stopwatch.Elapsed);

                    // now read
                    stopwatch = Stopwatch.StartNew();
                    var state2 = await dataManager.ReadStateAsync(grainIdentity);
                    stopwatch.Stop();
                    output.WriteLine(" Read elapsed: {0}", stopwatch.Elapsed);
                    Assert.AreEqual(state, state2);
                }
            }).Wait();
        }
Beispiel #5
0
        public void ReadNonExistentState()
        {
            Task.Run(async () =>
            {
                InstrumentationContext.Reset();
                var grainStateMap = CreateGrainStateMap();
                var grainIdentity = RandomIdentity();

                using (var dataManager = new SqlDataManager(logger, grainStateMap, ConnectionString, ShardCredentials, ShardMapDefault))
                {
                    // now read
                    var stopwatch = Stopwatch.StartNew();
                    var state = await dataManager.ReadStateAsync(grainIdentity);
                    stopwatch.Stop();
                    output.WriteLine(" Read elapsed: {0}", stopwatch.Elapsed);

                    Assert.IsNull(state); 
                }
            }).Wait();
        }
Beispiel #6
0
        public void WriteThenRead10KStates()
        {
            InstrumentationContext.Reset();
            const int count = 10000;
            var grainStateMap = CreateGrainStateMap();
            var grains = new List<Tuple<GrainIdentity, object>>();
            for (int i = 0; i < count; ++i)
            {
                var state = CreateState(i);
                grains.Add(new Tuple<GrainIdentity, object>(RandomIdentity(), state));
            }

            using (var dataManager = new SqlDataManager(logger, grainStateMap, ConnectionString, ShardCredentials, ShardMapDefault))
            {
                var stopwatch = Stopwatch.StartNew();
                var tasks = grains.Select(grain => dataManager.UpsertStateAsync(grain.Item1, grain.Item2)).ToArray();
                Task.WaitAll(tasks);
                stopwatch.Stop();
                output.WriteLine(" Insert elapsed: {0}", stopwatch.Elapsed);

                // now read
                stopwatch = Stopwatch.StartNew();
                var rtasks = grains.Select(grain => dataManager.ReadStateAsync(grain.Item1)).ToList();
                Task.WaitAll(rtasks.Cast<Task>().ToArray());
                stopwatch.Stop();
                output.WriteLine(" Read elapsed: {0}", stopwatch.Elapsed);
            }
        }