pub/sub

[renkaifei]

subscribe channel, when publish console project, exe memory increase always.
. net core 3.1, lastest client version.

[mgravell]

can we see illustrative code of what you're doing? thanks

[renkaifei]

I upload my project code as attachment. 1 publish RedisPubSubProject web application 2 publish RedisPubProject console application 3 run RedisPubProject ,using 19 channel publish data 4 run RedisPubSubProject , using microsoft edge Browse index.html 5 open windows task manager tool ,find RedisPubSubProject .exe ,see the memory used . it always increase without ending. 6 you need change RedisPubSubProject WeatherForecastController redis endpoint using yourself redis. 7 I using python redis library ,not find the same problem. At 2022-04-22 19:56:22, "Marc Gravell" ***@***.***> wrote: can we see illustrative code of what you're doing? thanks — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you authored the thread.Message ID: ***@***.***>

[mgravell]

Email attachments aren't preserved by GitHub. I still can't see any code.

[renkaifei]

I send an email to your email address'[marc.gravell@gmail.com]'.

[mgravell]

Received; the project had a lot of moving parts, and I was unable to get it running conveniently in a profilable state, so for the purposes of investigation, I simplified this to a single console:

using Newtonsoft.Json;
using StackExchange.Redis;

using var muxer = ConnectionMultiplexer.Connect("127.0.0.1:6379");
Console.WriteLine("Connected");
var sub = muxer.GetSubscriber();

long totalBytes = 0;
int count = 0;
RedisChannel channel = "19";
sub.Subscribe(channel, (redisChannel, redisValue) =>
{
    byte[] arrBytes = redisValue;
    long newTotal = Interlocked.Add(ref totalBytes, arrBytes.Length);
    var newCount = Interlocked.Increment(ref count);
    if ((newCount % 100) == 0)
    {
        Console.WriteLine($"Received {newCount}: {newTotal}");
    }
});

// we'll send the same json over and over, to reduce impact of measuring what we're sending
// (since it is in the same process, etc)
RedisValue json = JsonConvert.SerializeObject(new ObjTarget() { ObjID = 42 });
for (int i = 0; i < 10000000; i++)
{
    sub.Publish(channel, json);
    Thread.Sleep(1);
}


public class ObjTarget
{
    public int ObjID { get; set; }
    // the rest of your type here; omitted for this discussion, but present in my version
}

The only differences that don't relate to web-servers, web-sockets, etc is the change here to use the implicit cast operator to byte[] rather than casting it to string and then using Encoding to get the byte[]:

byte[] arrBytes = redisValue;

I also changed it to send the same bytes each time, because we're not trying to profile the serializer.

Running this locally with DotMemory, I see:

which does not provide any evidence of a memory leak, or unbounded growth. There is some small memory usage, but it isn't "steep", and nothing appears to become uncollectable. a GC seems to run every 20s or so (which is not aggressive), and the memory is keeping a stable horizontal position (when considering GC), of around 25MiB.

---

To help further, I would need to see runnable, profilable code that demonstrates the problem. Right now, the code you've emailed me basically seems to work. If the real problem is in the WebSocket or similar: that's not something I can help with.

My suggestion for you would be to run DotMemory (or similar) against your actual server code, to see what objects are being retained, and where.

[mgravell]

Side note: the async in your original code is dangerous; it isn't obvious, but that's actually an async void, which is never a good idea. There is an alternative API which is more amenable to async code:

Task.Run(async () =>
{
    var queue = sub.Subscribe(channel);
    while (true)
    {
        var msg = await queue.ReadAsync();
        byte[] arrBytes = msg.Message;
        long newTotal = Interlocked.Add(ref totalBytes, arrBytes.Length);
        var newCount = Interlocked.Increment(ref count);
        if ((newCount % 100) == 0)
        {
            Console.WriteLine($"Received {newCount}: {newTotal}");
        }
    }
});

This is actually also more efficient, with it now waiting longer between GCs:

[NickCraver]

Closing out to tidy up!