Question

我有3个分区的可靠服务。数据在3之间合理地平均分配-几乎是准确的。我在3个分区中有将近395万份以下合同的条目

[DataContract]
public class Item
{
    [DataMember]
    public string StandardisedText { get; set; }

    [DataMember]
    public string Vendor{ get; set; }

    [DataMember]
    public bool Card{ get; set; }

    [DataMember]
    public string Suburb { get; set; }

    [DataMember]
    public string State { get; set; }

    [DataMember]
    public string PostCode { get; set; }

    [DataMember]
    public float Latitude { get; set; }

    [DataMember]
    public float Longitude { get; set; }

    [DataMember]
    public string Level1 { get; set; }

    [DataMember]
    public string Level2 { get; set; }

    [DataMember]
    public string Level3 { get; set; }

    [DataMember]
    public string Level4 { get; set; }
}

我有一个上游聚合服务，它使用以下代码报告所有分区的计数（请忽略此代码的可怕性，它是一种快速而肮脏的POC，以查看合理的大数据对于合理的大数据的可行性。集）。

[HttpGet("")]
        public IActionResult GetAll()
        {
            try
            {
                _logger.LogError("Getting all count");
                ServiceEventSource.Current.Message("Getting all count");

                var settings = new FabricTransportRemotingSettings { OperationTimeout = TimeSpan.FromMinutes(30) };

                var factory =
                                new ServiceProxyFactory(h =>
                                    new FabricTransportServiceRemotingClientFactory(settings));

                int total = 0;

                foreach (var servicePartitionKey in PartitionKeys)
                {
                    var proxy = factory.CreateServiceProxy<ITermTextService>(
                        new Uri("fabric:/Acme.Fabric.Refinery/Acme.Fabric.Refinery.RefineryStore"),
                        servicePartitionKey);
                    var count = proxy.Count().Result;

                    ServiceEventSource.Current.Message($"Searched partition {servicePartitionKey.Value} and found {count} values" );
                    _logger.LogInformation($"Searched partition {servicePartitionKey.Value} and found {count} values");
                    total += count;
                }

                return Ok(total);
            }
            catch (Exception excep)
            {
                _logger.LogError($"Error in get all {excep.Message} {excep.StackTrace}");
                ServiceEventSource.Current.Message($"Error {excep.Message} {excep.StackTrace}");
            }

            return null;
        }

计数代码为

public async Task<int> Count()
        {
            int i = 0;

            var termTexts = await TermTexts;

            using (var tx = StateManager.CreateTransaction())
            {
                var enumerable = await termTexts.CreateEnumerableAsync(tx);

                var enumerator = enumerable.GetAsyncEnumerator();

                while (await enumerator.MoveNextAsync(CancellationToken.None))
                {
                    i++;
                }
            }

            return i;
        }

此操作的总时间为747165毫秒（12分钟）。这是线上的整数-没有大包。

我的问题是，这种表现是在预期的范围内还是应该对此进行进一步调查？将RC用于此数据量可能是一种误用，因此我们需要在其他地方查找。这些响应时间还暗示涉及磁盘读取，因此另一个问题是，这将在什么时候发生并且可以对其进行配置？我想从热存储中读取的内容位于每个分区50ms以下。

谢谢。

Answer 1

如果u异步枚举数百万条记录，则可以达到预期的性能。如果使用IReliableDictionary2，则可以直接使用Count属性。无需枚举所有记录。如果要按键搜索，请使用CreateAsyncEnumerable函数。

具有相对较大的数据集的可靠集合中的性能降低

1 个答案: