[lkml]   [2018]   [Aug]   [14]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
Messages in this thread
SubjectRe: [RFC PATCH 0/7] A General Accelerator Framework, WarpDrive
On Mon, Aug 13, 2018 at 03:23:01PM -0400, Jerome Glisse wrote:
> Received: from [] by Turing-Arch-b with POP3
> (fetchmail-6.3.26) for <kenny@localhost> (single-drop); Tue, 14 Aug 2018
> 03:30:02 +0800 (CST)
> Received: from ( by
> ( with Microsoft SMTP Server
> (TLS) id 14.3.399.0; Tue, 14 Aug 2018 03:23:25 +0800
> Received: from ( by
> ( with Microsoft SMTP Server id
> 14.3.399.0; Tue, 14 Aug 2018 03:23:21 +0800
> Received: from (unknown []) by Forcepoint
> Email with ESMTPS id 301B5D4F60895 for <>; Tue, 14
> Aug 2018 03:23:16 +0800 (CST)
> Received: from
> ( []) (using
> TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client
> certificate requested) by (Postfix) with ESMTPS id
> 4D0A14023461; Mon, 13 Aug 2018 19:23:05 +0000 (UTC)
> Received: from (unknown []) by
> (Postfix) with ESMTPS id 20D072156712; Mon, 13 Aug
> 2018 19:23:03 +0000 (UTC)
> Date: Mon, 13 Aug 2018 15:23:01 -0400
> From: Jerome Glisse <>
> To: Kenneth Lee <>
> CC: Kenneth Lee <>, Jean-Philippe Brucker
> <>, Herbert Xu <>,
> "" <>, Jonathan Corbet
> <>, Greg Kroah-Hartman <>, Zaibo
> Xu <>, ""
> <>, "Kumar, Sanjay K" <>,
> "Tian, Kevin" <>, ""
> <>, ""
> <>, ""
> <>, Alex Williamson <>,
> "" <>, Philippe
> Ombredanne <>, Thomas Gleixner <>,
> Hao Fang <>, "David S . Miller" <>,
> ""
> <>
> Subject: Re: [RFC PATCH 0/7] A General Accelerator Framework, WarpDrive
> Message-ID: <>
> References: <20180806031252.GG91035@Turing-Arch-b>
> <>
> <>
> <> <20180809080352.GI91035@Turing-Arch-b>
> <> <20180810033913.GK91035@Turing-Arch-b>
> <>
> <>
> <20180813092931.GL91035@Turing-Arch-b>
> Content-Type: text/plain; charset="iso-8859-1"
> Content-Disposition: inline
> Content-Transfer-Encoding: 8bit
> In-Reply-To: <20180813092931.GL91035@Turing-Arch-b>
> User-Agent: Mutt/1.10.0 (2018-05-17)
> X-Scanned-By: MIMEDefang 2.78 on
> X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16
> ( []); Mon, 13 Aug 2018 19:23:05 +0000 (UTC)
> X-Greylist: inspected by milter-greylist-4.5.16 (
> []); Mon, 13 Aug 2018 19:23:05 +0000 (UTC) for IP:''
> HELO:'' FROM:'' RCPT:''
> Return-Path:
> X-MS-Exchange-Organization-AuthSource:
> X-MS-Exchange-Organization-AuthAs: Anonymous
> MIME-Version: 1.0
> On Mon, Aug 13, 2018 at 05:29:31PM +0800, Kenneth Lee wrote:
> >
> > I made a quick change basing on the RFCv1 here:
> >
> >
> >
> > I just made it compilable and not test it yet. But it shows how the idea is
> > going to be.
> >
> > The Pros is: most of the virtual device stuff can be removed. Resource
> > management is on the openned files only.
> >
> > The Cons is: as Jean said, we have to redo something that has been done by VFIO.
> > These mainly are:
> >
> > 1. Track the dma operation and remove them on resource releasing
> > 2. Pin the memory with gup and do accounting
> >
> > It not going to be easy to make a decision...
> >
> Maybe it would be good to list things you want do. Looking at your tree
> it seems you are re-inventing what dma-buf is already doing.

My English is quite limited;). I think I did not explain it well in the WrapDrive
document. Please let me try again here:

The requirement of WrapDrive is simple. Many acceleration requirements are from
user space, such as OpenSSL, AI, and so on. We want to provide a framework for
the user land application to summon the accelerator easily.

So the scenario is simple: The application is doing its job and faces a tough
and boring task, say compression. Then it drops the data pointer to the command
queue and let the accelerator do it at its bidding, and continue its job until
the task is done, or its other task synchronously

My understanding to the dma-buf is driver oriented. The buffer is created by one
driver and exported as fd to user space, then the user space can share it with
some attached devices.

But our scenario is that the whole buffer is from the user space. The
application will directly assign the pointer to the command queue. The hardware
will directly use this address. The kernel should set this particular virtual
memory or the whole process space to the IOMMU with its pasid. So the hardware
can use the process' address, which may not only be the address assigning in the
command queue, it can also be an address inside the memory itself.

To let this work, we have to pin the memory or set a page fault handler when the
memory is shared (to the hardware). And... the big work of pinning memory is not
gup (get user page), but rlimit accounting:)

> So here is what i understand for SVM/SVA:
> (1) allow userspace to create a command buffer for a device and bind
> it to its address space (PASID)
> (2) allow userspace to directly schedule commands on its command buffer
> No need to do tracking here as SVM/SVA which rely on PASID and something
> like PCIE ATS (address translation service). Userspace can shoot itself
> in the foot but nothing harmful can happen.

Yes, we can release the whole page table based on PASID (It also need Jean to
provide this interface;)). But the gup part still need to be tracked. (This is
what is done in VFIO)

> Non SVM/SVA:
> (3) allow userspace to wrap a region of its memory into an object so
> that it can be DMA map (ie GUP + dma_map_page())
> (4) Have userspace schedule command referencing object created in (3)
> using an ioctl.

Yes, this is going to be something like NOIOMMU mode in VFIO. The hardware have
to accept DMA/physical address. But anyway, this not the major intension of

> We need to keep track of object usage by the hardware so that we know
> when it is safe to release resources (dma_unmap_page()). The dma-buf
> provides everything you want for (3) and (4). With dma-buf you create
> object and each time it is use by a device you associate a fence with
> it. When fence is signaled it means that the hardware is done using
> that object. Fence also allow proper synchronization between multiple
> devices. For instance making sure that the second device wait for the
> first device before starting doing its thing. dma-buf documentations is
> much more thorough explaining all this.

Your idea hints me that the dma_buf design is based on sharing memory from the
driver, not from the user space. That's why the signal is based on the buffer
itself, because the buffer can be used again and again.

This is good for performance. The cost is high if remap the data every time. But
if consider we can devote the whole application space with SVM/SVA support. This
can become acceptable.

> Now from implementation point of view, maybe it would be a good idea
> to create something like the virtual gem driver. It is a virtual device
> that allow to create GEM object. So maybe we want a virtual device that
> allow to create dma-buf object from process memory and allow sharing of
> those dma-buf between multiple devices.
> Userspace would only have to talk to this virtual device to create
> object and wrap its memory around, then it could use this object against
> many actual devices.
> This decouples the memory management, that can be share between all
> devices, from the actual device driver, which is obviously specific to
> every single device.

Forcing the application to use the device allocate memory is an alluring choice,
it makes thing simple. Let us consider it for a while...

> Note that dma-buf use file so that once all file reference are gone the
> resource can be free and cleanup can happen (dma_unmap_page() ...). This
> properly handle the resource lifetime issue you seem to worried about.
> Cheers,
> Jérôme


 \ /
  Last update: 2018-08-14 05:48    [W:0.110 / U:3.504 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site