lkml.org 
[lkml]   [2023]   [Jan]   [24]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    Date
    SubjectRe: [PATCH v2 1/4] memcg: Track exported dma-buffers
    From
    On Tue, Jan 24, 2023 at 03:59:58PM +0100, Michal Hocko wrote:
    > On Mon 23-01-23 19:17:23, T.J. Mercier wrote:
    > > When a buffer is exported to userspace, use memcg to attribute the
    > > buffer to the allocating cgroup until all buffer references are
    > > released.
    >
    > Is there any reason why this memory cannot be charged during the
    > allocation (__GFP_ACCOUNT used)?
    > Also you do charge and account the memory but underlying pages do not
    > know about their memcg (this is normally done with commit_charge for
    > user mapped pages). This would become a problem if the memory is
    > migrated for example.

    I don't think this is movable memory.

    > This also means that you have to maintain memcg
    > reference outside of the memcg proper which is not really nice either.
    > This mimicks tcp kmem limit implementation which I really have to say I
    > am not a great fan of and this pattern shouldn't be coppied.
    >

    I think we should keep the discussion on technical merits instead of
    personal perference. To me using skmem like interface is totally fine
    but the pros/cons need to be very explicit and the clear reasons to
    select that option should be included.

    To me there are two options:

    1. Using skmem like interface as this patch series:

    The main pros of this option is that it is very simple. Let me list down
    the cons of this approach:

    a. There is time window between the actual memory allocation/free and
    the charge and uncharge and [un]charge happen when the whole memory is
    allocated or freed. I think for the charge path that might not be a big
    issue but on the uncharge, this can cause issues. The application and
    the potential shrinkers have freed some of this dmabuf memory but until
    the whole dmabuf is freed, the memcg uncharge will not happen. This can
    consequences on reclaim and oom behavior of the application.

    b. Due to the usage model i.e. a central daemon allocating the dmabuf
    memory upfront, there is a requirement to have a memcg charge transfer
    functionality to transfer the charge from the central daemon to the
    client applications. This does introduce complexity and avenues of weird
    reclaim and oom behavior.


    2. Allocate and charge the memory on page fault by actual user

    In this approach, the memory is not allocated upfront by the central
    daemon but rather on the page fault by the client application and the
    memcg charge happen at the same time.

    The only cons I can think of is this approach is more involved and may
    need some clever tricks to track the page on the free patch i.e. we to
    decrement the dmabuf memcg stat on free path. Maybe a page flag.

    The pros of this approach is there is no need have a charge transfer
    functionality and the charge/uncharge being closely tied to the actual
    memory allocation and free.

    Personally I would prefer the second approach but I don't want to just
    block this work if the dmabuf folks are ok with the cons mentioned of
    the first approach.

    thanks,
    Shakeel

    \
     
     \ /
      Last update: 2023-03-26 23:54    [W:4.097 / U:0.028 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site