Xen devel - Dec 2012 - RFC v1: Xen block protocol overhaul - problem statement (with pictures!)

Hey,

I am including some folks that are not always on Xen-devel to see if they have
some extra ideas or can correct my misunderstandings.

This is very much RFC - so there is bound to be some bugs.
The original is here
https://docs.google.com/document/d/1Vh5T8Z3Tx3sUEhVB0DnNDKBNiqB_ZA8Z5YVqAsCIjuI/edit
in case one wishes to modify/provide comment on that one.


There are outstanding issues we have now with the block protocol:
Note: I am assuming 64-bit guest/host - as the size’s of the structures
change on 32-bit. I am also attaching the header for the blkif ring
as of today.

A) Segment size is limited to 11 pages. It means we can at most squeeze
in 44kB per request. The ring can hold 32 (next power of two below 36)
requests, meaning we can do 1.4M of outstanding requests.

B). Producer and consumer index is on the same cache line. In present hardware
that means the reader and writer will compete for the same cacheline causing a
ping-pong between sockets.

C). The requests and responses are on the same ring. This again causes the
ping-pong between sockets as the ownership of the cache line will shift between
sockets.

D). Cache alignment. Currently the protocol is 16-bit aligned. This is awkward
as the request and responses sometimes fit within a cacheline or sometimes
straddle them.

E). Interrupt mitigation. We are currently doing a kick whenever we are
done “processing” the ring. There are better ways to do this - and
we could use existing network interrupt mitigation techniques to make the
code poll when there is a lot of data. 

F). Latency. The processing of the request limits us to only do 44kB - which
means
that a 1MB chunk of data - which on contemporary devices would only use I/O
request
- would be split up in multiple ‘requests’ inadvertently delaying the processing
of
said block. 

G) Future extensions. DIF/DIX for integrity. There might
be other in the future and it would be good to leave space for extra
flags TBD. 

H). Separate the response and request rings. The current
implementation has one thread for one block ring. There is no reason why
there could not be two threads - one for responses and one for requests -
and especially if they are scheduled on different CPUs. Furthermore this
could also be split in multi-queues - so two queues (response and request)
on each vCPU. 

I). We waste a lot of space on the ring - as we use the
ring for both requests and responses. The response structure needs to
occupy the same amount of space as the request structure (112 bytes). If
the request structure is expanded to be able to fit more segments (say
the ‘struct blkif_sring_entry is expanded to ~1500 bytes) that still
requires us to have a matching size response structure. We do not need
to use that much space for one response. Having a separate response ring
would simplify the structures. 

J). 32 bit vs 64 bit. Right now the size
of the request structure is 112 bytes under 64-bit guest and 102 bytes
under 32-bit guest. It is confusing and furthermore requires the host
to do extra accounting and processing.

The crude drawing displays memory that the ring occupies in offset of
64 bytes (cache line). Of course future CPUs could have different cache
lines (say 32 bytes?)- which would skew this drawing. A 32-bit ring is
a bit different as the ‘struct blkif_sring_entry’ is of 102 bytes.


The A) has two solutions to this (look at
http://comments.gmane.org/gmane.comp.emulators.xen.devel/140406 for
details). One proposed by Justin from Spectralogic has to negotiate
the segment size. This means that the ‘struct blkif_sring_entry’
is now a variable size. It can expand from 112 bytes (cover 11 pages of
data - 44kB) to 1580 bytes (256 pages of data - so 1MB). It is a simple
extension by just making the array in the request expand from 11 to a
variable size negotiated.


The math is as follow.


        struct blkif_request_segment {
                uint32 grant;                         // 4 bytes uint8_t
                first_sect, last_sect;// 1, 1 = 6 bytes
        }
(6 bytes for each segment) - the above structure is in an array of size
11 in the request. The ‘struct blkif_sring_entry’ is 112 bytes. The
change is to expand the array - in this example we would tack on 245 extra
‘struct blkif_request_segment’ - 245*6 + 112 = 1582. If we were to
use 36 requests (so 1582*36 + 64) we would use 57016 bytes (14 pages).


The other solution (from Intel - Ronghui) was to create one extra
ring that only has the ‘struct blkif_request_segment’ in them. The
‘struct blkif_request’ would be changed to have an index in said
‘segment ring’. There is only one segment ring. This means that the
size of the initial ring is still the same. The requests would point
to the segment and enumerate out how many of the indexes it wants to
use. The limit is of course the size of the segment. If one assumes a
one-page segment this means we can in one request cover ~4MB. The math
is as follow:


First request uses the half of the segment ring - so index 0 up
to 341 (out of 682). Each entry in the segment ring is a ‘struct
blkif_request_segment’ so it occupies 6 bytes. The other requests on
the ring (so there are 35 left) can use either the remaining 341 indexes
of the sgement ring or use the old style request. The old style request
can address use up to 44kB. For example:


 sring[0]->[uses 0->341 indexes in the segment ring] = 342*4096 = 1400832
 sring[1]->[use sthe old style request] = 11*4096 = 45056
 sring[2]->[uses 342->682 indexes in the segment ring] = 1392640
 sring[3..32] -> [uses the old style request] = 29*4096*11 = 1306624


Total: 4145152 bytes Naturally this could be extended to have a bigger
segment ring to cover more.





The problem with this extension is that we use 6 bytes and end up
straddling a cache line. Using 8 bytes will fix the cache straddling. This
would mean fitting only 512 segments per page.


There is yet another mechanism that could be employed  - and it borrows
from VirtIO protocol. And that is the ‘indirect descriptors’. This
very similar to what Intel suggests, but with a twist.


We could provide a new BLKIF_OP (say BLKIF_OP_INDIRECT), and the ‘struct
blkif_sring’ (each entry can be up to 112 bytes if needed - so the
old style request would fit). It would look like:


/* so 64 bytes under 64-bit. If necessary, the array (seg) can be
expanded to fit 11 segments as the old style request did */ struct
blkif_request_indirect {
        uint8_t        op;           /* BLKIF_OP_* (usually READ or WRITE    */
// 1 blkif_vdev_t   handle;       /* only for read/write requests         */ //
2
#ifdef CONFIG_X86_64
        uint32_t       _pad1;             /* offsetof(blkif_request,u.rw.id) ==
8 */ // 2
#endif
        uint64_t       id;           /* private guest value, echoed in resp  */
	grant_ref_t    gref;        /* reference to indirect buffer frame  if used*/
            struct blkif_request_segment_aligned seg[4]; // each is 8 bytes
} __attribute__((__packed__));


struct blkif_request {
        uint8_t        operation;    /* BLKIF_OP_???  */
	union {
                struct blkif_request_rw rw;
		struct blkif_request_indirect
                indirect; … other ..
        } u;
} __attribute__((__packed__));




The ‘operation’ would be BLKIF_OP_INDIRECT. The read/write/discard,
etc operation would now be in indirect.op. The indirect.gref points to
a page that is filled with:


struct blkif_request_indirect_entry {
        blkif_sector_t sector_number;
	struct blkif_request_segment seg;
} __attribute__((__packed__));
//16 bytes, so we can fit in a page 256 of these structures.


This means that with the existing 36 slots in the ring (single page)
we can cover: 32 slots * each blkif_request_indirect covers: 256 * 4096
~= 32M. If we don’t want to use indirect descriptor we can still use
up to 4 pages of the request (as it has enough space to contain four
segments and the structure will still be cache-aligned).




B). Both the producer (req_* and rsp_*) values are in the same
cache-line. This means that we end up with the same cacheline being
modified by two different guests. Depending on the architecture and
placement of the guest this could be bad - as each logical CPU would
try to write and read from the same cache-line. A mechanism where
the req_* and rsp_ values are separated and on a different cache line
could be used. The value of the correct cache-line and alignment could
be negotiated via XenBus - in case future technologies start using 128
bytes for cache or such. Or the the producer and consumer indexes are in
separate rings. Meaning we have a ‘request ring’ and a ‘response
ring’ - and only the ‘req_prod’, ‘req_event’ are modified in
the ‘request ring’. The opposite (resp_*) are only modified in the
‘response ring’.


C). Similar to B) problem but with a bigger payload. Each
‘blkif_sring_entry’ occupies 112 bytes which does not lend itself
to a nice cache line size. If the indirect descriptors are to be used
for everything we could ‘slim-down’ the blkif_request/response to
be up-to 64 bytes. This means modifying BLKIF_MAX_SEGMENTS_PER_REQUEST
to 5 as that would slim the largest of the structures to 64-bytes.
Naturally this means negotiating a new size of the structure via XenBus.


D). The first picture shows the problem. We now aligning everything
on the wrong cachelines. Worst in ⅓ of the cases we straddle
three cache-lines. We could negotiate a proper alignment for each
request/response structure.


E). The network stack has showed that going in a polling mode does improve
performance. The current mechanism of kicking the guest and or block
backend is not always clear.  [TODO: Konrad to explain it in details]


F). The current block protocol for big I/Os that the backend devices can
handle ends up doing extra work by splitting the I/O in smaller chunks,
and then reassembling them. With the solutions outlined in A) this can
be fixed. This is easily seen with 1MB I/Os. Since each request can
only handle 44kB that means we have to split a 1MB I/O in 24 requests
(23 * 4096 * 11 = 1081344). Then the backend ends up sending them in
sector-sizes- which with contemporary devices (such as SSD) ends up with
more processing. The SSDs are comfortable handling 128kB or higher I/Os
in one go.


G). DIF/DIX. This a protocol to carry extra ‘checksum’ information
for each I/O. The I/O can be a sector size, page-size or an I/O size
(most popular are 1MB). The DIF/DIX needs 8 bytes of information for
each I/O. It would be worth considering putting/reserving that amount of
space in each request/response. Also putting in extra flags for future
extensions would be worth it - however the author is not aware of any
right now.


H). Separate response/request. Potentially even multi-queue per-VCPU
queues. As v2.6.37 demonstrated, the idea of WRITE_BARRIER was
flawed. There is no similar concept in the storage world were the
operating system can put a food down and say: “everything before this
has to be on the disk.” There are ligther versions of this - called
‘FUA’ and ‘FLUSH’. Depending on the internal implementation
of the storage they are either ignored or do the right thing. The
filesystems determine the viability of these flags and change writing
tactics depending on this. From a protocol level, this means that the
WRITE/READ/SYNC requests can be intermixed - the storage by itself
determines the order of the operation. The filesystem is the one that
determines whether the WRITE should be with a FLUSH to preserve some form
of atomicity. This means we do not have to preserve an order of operations
- so we can have multiple queues for request and responses. This has
show in the network world to improve performance considerably.


I). Wastage of response/request on the same ring. Currently each response
MUST occupy the same amount of space that the request occupies - as the
ring can have both responses and requests. Separating the request and
response ring would remove the wastage.


J). 32-bit vs 64-bit (or 102 bytes vs 112 bytes). The size of the ring
entries is different if the guest is in 32-bit or 64-bit mode. Cleaning
this up to be the same size would save considerable accounting that the
host has to do (extra memcpy for each response/request).




_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
http://lists.xen.org/xen-devel

>>> On 18.12.12 at 15:31, Konrad Rzeszutek Wilk
<konrad.wilk@oracle.com> wrote:
> The A) has two solutions to this (look at
> http://comments.gmane.org/gmane.comp.emulators.xen.devel/140406 for
> details). One proposed by Justin from Spectralogic has to negotiate
> the segment size. This means that the ‘struct blkif_sring_entry’
> is now a variable size. It can expand from 112 bytes (cover 11 pages of
> data - 44kB) to 1580 bytes (256 pages of data - so 1MB). It is a simple
> extension by just making the array in the request expand from 11 to a
> variable size negotiated.
Iirc this extension still limits the number of segments per request
to 255 (as the total number must be specified in the request,
which only has an 8-bit field for that purpose).

That's one of the reasons why for vSCSI I didn't go that route,
but rather allowed the frontend to submit segment information
prior to the actual request (with the trailing segment pieces, if
any, being in the request itself).

Jan

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
http://lists.xen.org/xen-devel

On 18/12/12 15:31, Konrad Rzeszutek Wilk wrote:
> Hey,
> 
> I am including some folks that are not always on Xen-devel to see if they
have
> some extra ideas or can correct my misunderstandings.
> 
> This is very much RFC - so there is bound to be some bugs.
> The original is here
>
https://docs.google.com/document/d/1Vh5T8Z3Tx3sUEhVB0DnNDKBNiqB_ZA8Z5YVqAsCIjuI/edit
> in case one wishes to modify/provide comment on that one.
Hello Konrad,

Thanks for the problem description and possible solutions, I'm 
going to take on this (provided that you are OK with it).
> 
> There are outstanding issues we have now with the block protocol:
> Note: I am assuming 64-bit guest/host - as the size’s of the structures
> change on 32-bit. I am also attaching the header for the blkif ring
> as of today.
> 
> A) Segment size is limited to 11 pages. It means we can at most squeeze
> in 44kB per request. The ring can hold 32 (next power of two below 36)
> requests, meaning we can do 1.4M of outstanding requests.
I've been looking at the different options here and I think the most
suitable one would be using a mechanism similar to VirtIO "indirect
descriptors", it is the one that allows for more in-flight requests
while being quite simple to implement.
> B). Producer and consumer index is on the same cache line. In present
hardware
> that means the reader and writer will compete for the same cacheline
causing a
> ping-pong between sockets.
> 
> C). The requests and responses are on the same ring. This again causes the
> ping-pong between sockets as the ownership of the cache line will shift
between
> sockets.
> 
> D). Cache alignment. Currently the protocol is 16-bit aligned. This is
awkward
> as the request and responses sometimes fit within a cacheline or sometimes
> straddle them.
> 
> E). Interrupt mitigation. We are currently doing a kick whenever we are
> done “processing” the ring. There are better ways to do this - and
> we could use existing network interrupt mitigation techniques to make the
> code poll when there is a lot of data.
> 
> F). Latency. The processing of the request limits us to only do 44kB -
which means
> that a 1MB chunk of data - which on contemporary devices would only use I/O
request
> - would be split up in multiple ‘requests’ inadvertently delaying the
processing of
> said block.
> 
> G) Future extensions. DIF/DIX for integrity. There might
> be other in the future and it would be good to leave space for extra
> flags TBD.
> 
> H). Separate the response and request rings. The current
> implementation has one thread for one block ring. There is no reason why
> there could not be two threads - one for responses and one for requests -
> and especially if they are scheduled on different CPUs. Furthermore this
> could also be split in multi-queues - so two queues (response and request)
> on each vCPU.
> 
> I). We waste a lot of space on the ring - as we use the
> ring for both requests and responses. The response structure needs to
> occupy the same amount of space as the request structure (112 bytes). If
> the request structure is expanded to be able to fit more segments (say
> the ‘struct blkif_sring_entry is expanded to ~1500 bytes) that still
> requires us to have a matching size response structure. We do not need
> to use that much space for one response. Having a separate response ring
> would simplify the structures.
> 
> J). 32 bit vs 64 bit. Right now the size
> of the request structure is 112 bytes under 64-bit guest and 102 bytes
> under 32-bit guest. It is confusing and furthermore requires the host
> to do extra accounting and processing.
> 
> The crude drawing displays memory that the ring occupies in offset of
> 64 bytes (cache line). Of course future CPUs could have different cache
> lines (say 32 bytes?)- which would skew this drawing. A 32-bit ring is
> a bit different as the ‘struct blkif_sring_entry’ is of 102 bytes.
> 
> 
> The A) has two solutions to this (look at
> http://comments.gmane.org/gmane.comp.emulators.xen.devel/140406 for
> details). One proposed by Justin from Spectralogic has to negotiate
> the segment size. This means that the ‘struct blkif_sring_entry’
> is now a variable size. It can expand from 112 bytes (cover 11 pages of
> data - 44kB) to 1580 bytes (256 pages of data - so 1MB). It is a simple
> extension by just making the array in the request expand from 11 to a
> variable size negotiated.
> 
> 
> The math is as follow.
> 
> 
>         struct blkif_request_segment {
>                 uint32 grant;                         // 4 bytes uint8_t
>                 first_sect, last_sect;// 1, 1 = 6 bytes
>         }
> (6 bytes for each segment) - the above structure is in an array of size
> 11 in the request. The ‘struct blkif_sring_entry’ is 112 bytes. The
> change is to expand the array - in this example we would tack on 245 extra
> ‘struct blkif_request_segment’ - 245*6 + 112 = 1582. If we were to
> use 36 requests (so 1582*36 + 64) we would use 57016 bytes (14 pages).
> 
> 
> The other solution (from Intel - Ronghui) was to create one extra
> ring that only has the ‘struct blkif_request_segment’ in them. The
> ‘struct blkif_request’ would be changed to have an index in said
> ‘segment ring’. There is only one segment ring. This means that the
> size of the initial ring is still the same. The requests would point
> to the segment and enumerate out how many of the indexes it wants to
> use. The limit is of course the size of the segment. If one assumes a
> one-page segment this means we can in one request cover ~4MB. The math
> is as follow:
> 
> 
> First request uses the half of the segment ring - so index 0 up
> to 341 (out of 682). Each entry in the segment ring is a ‘struct
> blkif_request_segment’ so it occupies 6 bytes. The other requests on
> the ring (so there are 35 left) can use either the remaining 341 indexes
> of the sgement ring or use the old style request. The old style request
> can address use up to 44kB. For example:
> 
> 
>  sring[0]->[uses 0->341 indexes in the segment ring] = 342*4096 =
1400832
>  sring[1]->[use sthe old style request] = 11*4096 = 45056
>  sring[2]->[uses 342->682 indexes in the segment ring] = 1392640
>  sring[3..32] -> [uses the old style request] = 29*4096*11 = 1306624
> 
> 
> Total: 4145152 bytes Naturally this could be extended to have a bigger
> segment ring to cover more.
> 
> 
> 
> 
> 
> The problem with this extension is that we use 6 bytes and end up
> straddling a cache line. Using 8 bytes will fix the cache straddling. This
> would mean fitting only 512 segments per page.
> 
> 
> There is yet another mechanism that could be employed  - and it borrows
> from VirtIO protocol. And that is the ‘indirect descriptors’. This
> very similar to what Intel suggests, but with a twist.
> 
> 
> We could provide a new BLKIF_OP (say BLKIF_OP_INDIRECT), and the ‘struct
> blkif_sring’ (each entry can be up to 112 bytes if needed - so the
> old style request would fit). It would look like:
> 
> 
> /* so 64 bytes under 64-bit. If necessary, the array (seg) can be
> expanded to fit 11 segments as the old style request did */ struct
> blkif_request_indirect {
>         uint8_t        op;           /* BLKIF_OP_* (usually READ or WRITE  
*/
> // 1 blkif_vdev_t   handle;       /* only for read/write requests        
*/ // 2
> #ifdef CONFIG_X86_64
>         uint32_t       _pad1;             /*
offsetof(blkif_request,u.rw.id) == 8 */ // 2
> #endif
>         uint64_t       id;           /* private guest value, echoed in resp
*/
>         grant_ref_t    gref;        /* reference to indirect buffer frame 
if used*/
>             struct blkif_request_segment_aligned seg[4]; // each is 8 bytes
>
> } __attribute__((__packed__));
> 
> 
> struct blkif_request {
>         uint8_t        operation;    /* BLKIF_OP_???  */
>         union {
>                 struct blkif_request_rw rw;
>                 struct blkif_request_indirect
>                 indirect; … other ..
>         } u;
> } __attribute__((__packed__));
> 
Do you think it will be suitable to change the size of blkif_request, I 
was thinking that if we introduce indirect request we could reduce the 
maximum number of segments per request to 2, so blkif_request is 
reduced to 32bytes and we can fit 126 requests (64 due to rounding) 
in a single ring. 

Everything that needs more than two segments will switch to using the 
new indirect operation. Also, to make use of the extra space in 
blkif_request_indirect I would remove the extra segments and instead 
pass more grant references to frames containing 
blkif_request_indirect_entry entries.

#define BLKIF_MAX_SEGMENTS_PER_REQUEST 2
#define BLKIF_MAX_INDIRECT_GREFS_PER_REQUEST 4

struct blkif_request_segment {
    grant_ref_t gref;        /* reference to I/O buffer frame        */
    /* @first_sect: first sector in frame to transfer (inclusive).   */
    /* @last_sect: last sector in frame to transfer (inclusive).     */
    uint8_t     first_sect, last_sect;
} __attribute__((__packed__));

struct blkif_request_indirect_entry {
    blkif_sector_t  sector_number;
    struct          blkif_request_segment seg;
    uint8_t         _pad[2];
} __attribute__((__packed__));

struct blkif_request_rw {
    uint8_t        nr_segments;  /* number of segments                   */
    blkif_vdev_t   handle;       /* only for read/write requests         */
    uint64_t       id;           /* private guest value, echoed in resp  */
    blkif_sector_t sector_number;/* start sector idx on disk (r/w only)  */
    struct blkif_request_segment seg[BLKIF_MAX_SEGMENTS_PER_REQUEST];
} __attribute__((__packed__));

struct blkif_request_indirect {
    uint8_t        op;           /* BLKIF_OP_* (usually READ or WRITE    */
    uint16_t       nr_indirect;  /* number of indirect entries in gref frames */
    blkif_vdev_t   handle;       /* only for read/write requests         */
    uint64_t       id;           /* private guest value, echoed in resp  */
    /* reference to indirect buffer frame */
    grant_ref_t    gref[BLKIF_MAX_INDIRECT_GREFS_PER_REQUEST];
} __attribute__((__packed__));

struct blkif_request_discard {
    uint8_t        flag;         /* BLKIF_DISCARD_SECURE or zero.        */
#define BLKIF_DISCARD_SECURE (1<<0)  /* ignored if discard-secure=0       
*/
    uint64_t       id;           /* private guest value, echoed in resp  */
    blkif_sector_t sector_number;
    uint64_t       nr_sectors;
} __attribute__((__packed__));

struct blkif_request {
    uint8_t        operation;    /* BLKIF_OP_???                         */
    union {
        struct blkif_request_rw rw;
        struct blkif_request_indirect indirect;
        struct blkif_request_discard discard;
    } u;
} __attribute__((__packed__));

I've removed all the extra paddings, because this protocol is no longer 
compatible with the previous one (we modify 
BLKIF_MAX_SEGMENTS_PER_REQUEST), and packed the structures. I'm 
wondering if using __attribute__ in a public header is allowed, since 
this is a GNU extension (AFAIK supported by gcc and clang at least).

The main motivation behind the modification of the size of the 
request is because I've realized that in your proposal, you where 
adding 4 extra segments to the indirect request, and I was wondering 
if I could pack more grant frames containing indirect entries in a 
single request. By using the old size of blkf_request we will be able to
send up to 9 grant frames filled with indirect entries, which gives us
4096 * 256 * 9 = 9MB of outstanding IO in each request. I think that
this is too high, and will introduce a lot of latency to the protocol.
That's the main reason I've decided to reduce the size of blkif_request
in order to be able to fit more of them in a ring, instead of making
each of the requests bigger.

Using this implementation each request has a size of 32bytes (to 
prevent cache straddle), so we could fit 126 requests in a ring, but 
due to the rounding, we end up with 64. Also each request can contain 
4 grant pages, each one filled with 256 blkif_request_indirect_entry. 
The math for the maximum data in a request is: 4096 * 256 * 4 = 4MB, 
and in the whole ring 4 * 64 = 256MB worth of outstanding IO.
 
> 
> 
> The ‘operation’ would be BLKIF_OP_INDIRECT. The read/write/discard,
> etc operation would now be in indirect.op. The indirect.gref points to
> a page that is filled with:
> 
> 
> struct blkif_request_indirect_entry {
>         blkif_sector_t sector_number;
>         struct blkif_request_segment seg;
> } __attribute__((__packed__));
> //16 bytes, so we can fit in a page 256 of these structures.
> 
> 
> This means that with the existing 36 slots in the ring (single page)
> we can cover: 32 slots * each blkif_request_indirect covers: 256 * 4096
> ~= 32M. If we don’t want to use indirect descriptor we can still use
> up to 4 pages of the request (as it has enough space to contain four
> segments and the structure will still be cache-aligned).
> 
> 
> 
> 
> B). Both the producer (req_* and rsp_*) values are in the same
> cache-line. This means that we end up with the same cacheline being
> modified by two different guests. Depending on the architecture and
> placement of the guest this could be bad - as each logical CPU would
> try to write and read from the same cache-line. A mechanism where
> the req_* and rsp_ values are separated and on a different cache line
> could be used. The value of the correct cache-line and alignment could
> be negotiated via XenBus - in case future technologies start using 128
> bytes for cache or such. Or the the producer and consumer indexes are in
> separate rings. Meaning we have a ‘request ring’ and a ‘response
> ring’ - and only the ‘req_prod’, ‘req_event’ are modified in
> the ‘request ring’. The opposite (resp_*) are only modified in the
> ‘response ring’.
Using different rings for requests and responses sounds like a good idea,
this will reduce the number of variables on the ring, leaving only
"produced" and "event" (we no longer need rsp_ and req_).

Since we will no longer have two different domains writing to the same
cache line I guess this will get rid of the cache ping-pong problem.

Also while there we could try to use all the page, instead of rounding
down to the closer power of two, this will allow us to go from 64
requests to 126 (if using the indirect descriptors proposal explained
above).
 
> C). Similar to B) problem but with a bigger payload. Each
> ‘blkif_sring_entry’ occupies 112 bytes which does not lend itself
> to a nice cache line size. If the indirect descriptors are to be used
> for everything we could ‘slim-down’ the blkif_request/response to
> be up-to 64 bytes. This means modifying BLKIF_MAX_SEGMENTS_PER_REQUEST
> to 5 as that would slim the largest of the structures to 64-bytes.
> Naturally this means negotiating a new size of the structure via XenBus.
> 
> 
> D). The first picture shows the problem. We now aligning everything
> on the wrong cachelines. Worst in ⅓ of the cases we straddle
> three cache-lines. We could negotiate a proper alignment for each
> request/response structure.
> 
> 
> E). The network stack has showed that going in a polling mode does improve
> performance. The current mechanism of kicking the guest and or block
> backend is not always clear.  [TODO: Konrad to explain it in details]
> 
> 
> F). The current block protocol for big I/Os that the backend devices can
> handle ends up doing extra work by splitting the I/O in smaller chunks,
> and then reassembling them. With the solutions outlined in A) this can
> be fixed. This is easily seen with 1MB I/Os. Since each request can
> only handle 44kB that means we have to split a 1MB I/O in 24 requests
> (23 * 4096 * 11 = 1081344). Then the backend ends up sending them in
> sector-sizes- which with contemporary devices (such as SSD) ends up with
> more processing. The SSDs are comfortable handling 128kB or higher I/Os
> in one go.
> 
> 
> G). DIF/DIX. This a protocol to carry extra ‘checksum’ information
> for each I/O. The I/O can be a sector size, page-size or an I/O size
> (most popular are 1MB). The DIF/DIX needs 8 bytes of information for
> each I/O. It would be worth considering putting/reserving that amount of
> space in each request/response. Also putting in extra flags for future
> extensions would be worth it - however the author is not aware of any
> right now.
> 
> 
> H). Separate response/request. Potentially even multi-queue per-VCPU
> queues. As v2.6.37 demonstrated, the idea of WRITE_BARRIER was
> flawed. There is no similar concept in the storage world were the
> operating system can put a food down and say: “everything before this
> has to be on the disk.” There are ligther versions of this - called
> ‘FUA’ and ‘FLUSH’. Depending on the internal implementation
> of the storage they are either ignored or do the right thing. The
> filesystems determine the viability of these flags and change writing
> tactics depending on this. From a protocol level, this means that the
> WRITE/READ/SYNC requests can be intermixed - the storage by itself
> determines the order of the operation. The filesystem is the one that
> determines whether the WRITE should be with a FLUSH to preserve some form
> of atomicity. This means we do not have to preserve an order of operations
> - so we can have multiple queues for request and responses. This has
> show in the network world to improve performance considerably.
> 
> 
> I). Wastage of response/request on the same ring. Currently each response
> MUST occupy the same amount of space that the request occupies - as the
> ring can have both responses and requests. Separating the request and
> response ring would remove the wastage.
> 
> 
> J). 32-bit vs 64-bit (or 102 bytes vs 112 bytes). The size of the ring
> entries is different if the guest is in 32-bit or 64-bit mode. Cleaning
> this up to be the same size would save considerable accounting that the
> host has to do (extra memcpy for each response/request).
So forth I think most of the problems could be solved by using indirect
descriptors, aligning requests to a cache sensible value (to prevent
straddling) and using separate rings for requests and responses. This 
would be my plan for solving this issues:

1. Implement LRU mechanism in blkback for the persistent grants list. If
we are going to increment the number of in-flight IO we need to be able to
keep the list of persistently mapped grants to something sensible, and
we are no longer able to persistently map all the grants that could be 
used. In my proposal that would be 64 * 4 for each grant frame that 
contains indirect entries, plus 64 * 4 * 256, for all the possible
entries in the indirect frame 64 * 4 + 64 * 4 * 256 = 65792.

2. Implement indirect descriptors.

3. Implement new ring protocol, using two separate rings for requests
and replies.

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
http://lists.xen.org/xen-devel

On Fri, Jan 18, 2013 at 05:00:10PM +0100, Roger Pau Monné
wrote:
> On 18/12/12 15:31, Konrad Rzeszutek Wilk wrote:
> > Hey,
> > 
> > I am including some folks that are not always on Xen-devel to see if
they have
> > some extra ideas or can correct my misunderstandings.
> > 
> > This is very much RFC - so there is bound to be some bugs.
> > The original is here
> >
https://docs.google.com/document/d/1Vh5T8Z3Tx3sUEhVB0DnNDKBNiqB_ZA8Z5YVqAsCIjuI/edit
> > in case one wishes to modify/provide comment on that one.
> 
> Hello Konrad,
> 
> Thanks for the problem description and possible solutions, I'm 
> going to take on this (provided that you are OK with it).
The whole thing!? You are quite ambitious here!
> 
> > 
> > There are outstanding issues we have now with the block protocol:
> > Note: I am assuming 64-bit guest/host - as the size’s of the
structures
> > change on 32-bit. I am also attaching the header for the blkif ring
> > as of today.
> > 
> > A) Segment size is limited to 11 pages. It means we can at most
squeeze
> > in 44kB per request. The ring can hold 32 (next power of two below 36)
> > requests, meaning we can do 1.4M of outstanding requests.
> 
> I've been looking at the different options here and I think the most
> suitable one would be using a mechanism similar to VirtIO "indirect
> descriptors", it is the one that allows for more in-flight requests
> while being quite simple to implement.
<nods> I think you are right - plus it looks to be similar to how the more
modern hardware does requests (here I am thinking of NVMe and its command
descriptor - where it can point to a page full of DMA addresses + LBAs and say
"Go READ").
> 
> > B). Producer and consumer index is on the same cache line. In present
hardware
> > that means the reader and writer will compete for the same cacheline
causing a
> > ping-pong between sockets.
> > 
> > C). The requests and responses are on the same ring. This again causes
the
> > ping-pong between sockets as the ownership of the cache line will
shift between
> > sockets.
> > 
> > D). Cache alignment. Currently the protocol is 16-bit aligned. This is
awkward
> > as the request and responses sometimes fit within a cacheline or
sometimes
> > straddle them.
> > 
> > E). Interrupt mitigation. We are currently doing a kick whenever we
are
> > done “processing” the ring. There are better ways to do this - and
> > we could use existing network interrupt mitigation techniques to make
the
> > code poll when there is a lot of data.
> > 
> > F). Latency. The processing of the request limits us to only do 44kB -
which means
> > that a 1MB chunk of data - which on contemporary devices would only
use I/O request
> > - would be split up in multiple ‘requests’ inadvertently delaying the
processing of
> > said block.
> > 
> > G) Future extensions. DIF/DIX for integrity. There might
> > be other in the future and it would be good to leave space for extra
> > flags TBD.
> > 
> > H). Separate the response and request rings. The current
> > implementation has one thread for one block ring. There is no reason
why
> > there could not be two threads - one for responses and one for
requests -
> > and especially if they are scheduled on different CPUs. Furthermore
this
> > could also be split in multi-queues - so two queues (response and
request)
> > on each vCPU.
> > 
> > I). We waste a lot of space on the ring - as we use the
> > ring for both requests and responses. The response structure needs to
> > occupy the same amount of space as the request structure (112 bytes).
If
> > the request structure is expanded to be able to fit more segments (say
> > the ‘struct blkif_sring_entry is expanded to ~1500 bytes) that still
> > requires us to have a matching size response structure. We do not need
> > to use that much space for one response. Having a separate response
ring
> > would simplify the structures.
> > 
> > J). 32 bit vs 64 bit. Right now the size
> > of the request structure is 112 bytes under 64-bit guest and 102 bytes
> > under 32-bit guest. It is confusing and furthermore requires the host
> > to do extra accounting and processing.
> > 
> > The crude drawing displays memory that the ring occupies in offset of
> > 64 bytes (cache line). Of course future CPUs could have different
cache
> > lines (say 32 bytes?)- which would skew this drawing. A 32-bit ring is
> > a bit different as the ‘struct blkif_sring_entry’ is of 102 bytes.
> > 
> > 
> > The A) has two solutions to this (look at
> > http://comments.gmane.org/gmane.comp.emulators.xen.devel/140406 for
> > details). One proposed by Justin from Spectralogic has to negotiate
> > the segment size. This means that the ‘struct blkif_sring_entry’
> > is now a variable size. It can expand from 112 bytes (cover 11 pages
of
> > data - 44kB) to 1580 bytes (256 pages of data - so 1MB). It is a
simple
> > extension by just making the array in the request expand from 11 to a
> > variable size negotiated.
> > 
> > 
> > The math is as follow.
> > 
> > 
> >         struct blkif_request_segment {
> >                 uint32 grant;                         // 4 bytes
uint8_t
> >                 first_sect, last_sect;// 1, 1 = 6 bytes
> >         }
> > (6 bytes for each segment) - the above structure is in an array of
size
> > 11 in the request. The ‘struct blkif_sring_entry’ is 112 bytes. The
> > change is to expand the array - in this example we would tack on 245
extra
> > ‘struct blkif_request_segment’ - 245*6 + 112 = 1582. If we were to
> > use 36 requests (so 1582*36 + 64) we would use 57016 bytes (14 pages).
> > 
> > 
> > The other solution (from Intel - Ronghui) was to create one extra
> > ring that only has the ‘struct blkif_request_segment’ in them. The
> > ‘struct blkif_request’ would be changed to have an index in said
> > ‘segment ring’. There is only one segment ring. This means that the
> > size of the initial ring is still the same. The requests would point
> > to the segment and enumerate out how many of the indexes it wants to
> > use. The limit is of course the size of the segment. If one assumes a
> > one-page segment this means we can in one request cover ~4MB. The math
> > is as follow:
> > 
> > 
> > First request uses the half of the segment ring - so index 0 up
> > to 341 (out of 682). Each entry in the segment ring is a ‘struct
> > blkif_request_segment’ so it occupies 6 bytes. The other requests on
> > the ring (so there are 35 left) can use either the remaining 341
indexes
> > of the sgement ring or use the old style request. The old style
request
> > can address use up to 44kB. For example:
> > 
> > 
> >  sring[0]->[uses 0->341 indexes in the segment ring] = 342*4096
= 1400832
> >  sring[1]->[use sthe old style request] = 11*4096 = 45056
> >  sring[2]->[uses 342->682 indexes in the segment ring] = 1392640
> >  sring[3..32] -> [uses the old style request] = 29*4096*11 =
1306624
> > 
> > 
> > Total: 4145152 bytes Naturally this could be extended to have a bigger
> > segment ring to cover more.
> > 
> > 
> > 
> > 
> > 
> > The problem with this extension is that we use 6 bytes and end up
> > straddling a cache line. Using 8 bytes will fix the cache straddling.
This
> > would mean fitting only 512 segments per page.
> > 
> > 
> > There is yet another mechanism that could be employed  - and it
borrows
> > from VirtIO protocol. And that is the ‘indirect descriptors’. This
> > very similar to what Intel suggests, but with a twist.
> > 
> > 
> > We could provide a new BLKIF_OP (say BLKIF_OP_INDIRECT), and the
‘struct
> > blkif_sring’ (each entry can be up to 112 bytes if needed - so the
> > old style request would fit). It would look like:
> > 
> > 
> > /* so 64 bytes under 64-bit. If necessary, the array (seg) can be
> > expanded to fit 11 segments as the old style request did */ struct
> > blkif_request_indirect {
> >         uint8_t        op;           /* BLKIF_OP_* (usually READ or
WRITE    */
> > // 1 blkif_vdev_t   handle;       /* only for read/write requests     
*/ // 2
> > #ifdef CONFIG_X86_64
> >         uint32_t       _pad1;             /*
offsetof(blkif_request,u.rw.id) == 8 */ // 2
> > #endif
> >         uint64_t       id;           /* private guest value, echoed in
resp  */
> >         grant_ref_t    gref;        /* reference to indirect buffer
frame  if used*/
> >             struct blkif_request_segment_aligned seg[4]; // each is 8
bytes
> >
> > } __attribute__((__packed__));
> > 
> > 
> > struct blkif_request {
> >         uint8_t        operation;    /* BLKIF_OP_???  */
> >         union {
> >                 struct blkif_request_rw rw;
> >                 struct blkif_request_indirect
> >                 indirect; … other ..
> >         } u;
> > } __attribute__((__packed__));
> > 
> 
> Do you think it will be suitable to change the size of blkif_request, I 
> was thinking that if we introduce indirect request we could reduce the 
> maximum number of segments per request to 2, so blkif_request is 
> reduced to 32bytes and we can fit 126 requests (64 due to rounding) 
> in a single ring. 
Altering it to be 32-bytes means we are still crossing two cachelines.

This is where I thought of putting 'struct blkif_request_rw' on a diet
and just making it have 4 of the grants - in case the request is
just 16K. And then the size of the structure (if I got my math right)
would be 64-bytes.

Naturally this means we need to negotiate a 'feature-request-size'
where v1 says that the request is of 64-bytes length. v2 might
be 128bytes or whatever else we would need to fit within a cacheline
in future CPUs. We could pad the 'struct request_v1' with 64-bytes
in case the cacheline is 128bytes and our request is 64-bytes.

> 
> Everything that needs more than two segments will switch to using the 
> new indirect operation. Also, to make use of the extra space in 
> blkif_request_indirect I would remove the extra segments and instead 
> pass more grant references to frames containing 
> blkif_request_indirect_entry entries.
Right. The complications arise when we need to support this new format
and the old format and have to switch over when we migrate to old
backends.
> 
> #define BLKIF_MAX_SEGMENTS_PER_REQUEST 2
> #define BLKIF_MAX_INDIRECT_GREFS_PER_REQUEST 4
> 
> struct blkif_request_segment {
>     grant_ref_t gref;        /* reference to I/O buffer frame        */
>     /* @first_sect: first sector in frame to transfer (inclusive).   */
>     /* @last_sect: last sector in frame to transfer (inclusive).     */
>     uint8_t     first_sect, last_sect;
> } __attribute__((__packed__));
> 
> struct blkif_request_indirect_entry {
>     blkif_sector_t  sector_number;
>     struct          blkif_request_segment seg;
>     uint8_t         _pad[2];
> } __attribute__((__packed__));
> 
> struct blkif_request_rw {
>     uint8_t        nr_segments;  /* number of segments                   */
>     blkif_vdev_t   handle;       /* only for read/write requests         */
>     uint64_t       id;           /* private guest value, echoed in resp  */
>     blkif_sector_t sector_number;/* start sector idx on disk (r/w only)  */
>     struct blkif_request_segment seg[BLKIF_MAX_SEGMENTS_PER_REQUEST];
> } __attribute__((__packed__));
> 
> struct blkif_request_indirect {
>     uint8_t        op;           /* BLKIF_OP_* (usually READ or WRITE    */
>     uint16_t       nr_indirect;  /* number of indirect entries in gref
frames */
>     blkif_vdev_t   handle;       /* only for read/write requests         */
>     uint64_t       id;           /* private guest value, echoed in resp  */
>     /* reference to indirect buffer frame */
>     grant_ref_t    gref[BLKIF_MAX_INDIRECT_GREFS_PER_REQUEST];
> } __attribute__((__packed__));
> 
> struct blkif_request_discard {
>     uint8_t        flag;         /* BLKIF_DISCARD_SECURE or zero.        */
> #define BLKIF_DISCARD_SECURE (1<<0)  /* ignored if discard-secure=0  
*/
>     uint64_t       id;           /* private guest value, echoed in resp  */
>     blkif_sector_t sector_number;
>     uint64_t       nr_sectors;
> } __attribute__((__packed__));
> 
> struct blkif_request {
>     uint8_t        operation;    /* BLKIF_OP_???                         */
>     union {
>         struct blkif_request_rw rw;
>         struct blkif_request_indirect indirect;
>         struct blkif_request_discard discard;
>     } u;
> } __attribute__((__packed__));
> 
> I've removed all the extra paddings, because this protocol is no longer
> compatible with the previous one (we modify 
> BLKIF_MAX_SEGMENTS_PER_REQUEST), and packed the structures. I'm 
> wondering if using __attribute__ in a public header is allowed, since 
> this is a GNU extension (AFAIK supported by gcc and clang at least).
I don't know. But I think we can bypass the need for it if we calculate
the size of each entry right and insert padding whenever neccessary.
> 
> The main motivation behind the modification of the size of the 
> request is because I've realized that in your proposal, you where 
> adding 4 extra segments to the indirect request, and I was wondering 
> if I could pack more grant frames containing indirect entries in a 
> single request. By using the old size of blkf_request we will be able to
> send up to 9 grant frames filled with indirect entries, which gives us
> 4096 * 256 * 9 = 9MB of outstanding IO in each request. I think that
> this is too high, and will introduce a lot of latency to the protocol.
> That's the main reason I've decided to reduce the size of
blkif_request
> in order to be able to fit more of them in a ring, instead of making
> each of the requests bigger.
OK. That is OK as long as we make sure to _not_ have two requests
straddling the cache-line. Or maybe that is not a problem.

But the other nice benefit of your idea - where it is only 32-bytes
- is that we have now extra 32-bytes where we can insert such
things as DIF/DIX or "other" new features. And that way have the
request be of size 64 bytes.
> 
> Using this implementation each request has a size of 32bytes (to 
> prevent cache straddle), so we could fit 126 requests in a ring, but 
> due to the rounding, we end up with 64. Also each request can contain 
> 4 grant pages, each one filled with 256 blkif_request_indirect_entry. 
> The math for the maximum data in a request is: 4096 * 256 * 4 = 4MB, 
> and in the whole ring 4 * 64 = 256MB worth of outstanding IO.
>  
Which has a nice power of two ring to it. (Ah the puns!)

I like the idea of putting the request on a diet - but too much
could cause us to miss the opportunity to insert other flags on it.
If I recall correctly, the DIF/DIX only need 8 bytes of data.
If we make the assumption that:
	I/O request = one ring entry

and the  "one ring entry" can use the the '4' grants if we
just have a
16KB I/O request, but if it is more than that - we use the indirect page
and can stuff 1MB of data in there. 
The extra 32-bytes of space for such things as 'DIF/DIX'. This also
means we could unify the 'struct request' with the 'discard'
operation
and it could utilize the 32-bytes of extra unused payload data.
> > 
> > 
> > The ‘operation’ would be BLKIF_OP_INDIRECT. The read/write/discard,
> > etc operation would now be in indirect.op. The indirect.gref points to
> > a page that is filled with:
> > 
> > 
> > struct blkif_request_indirect_entry {
> >         blkif_sector_t sector_number;
> >         struct blkif_request_segment seg;
> > } __attribute__((__packed__));
> > //16 bytes, so we can fit in a page 256 of these structures.
> > 
> > 
> > This means that with the existing 36 slots in the ring (single page)
> > we can cover: 32 slots * each blkif_request_indirect covers: 256 *
4096
> > ~= 32M. If we don’t want to use indirect descriptor we can still use
> > up to 4 pages of the request (as it has enough space to contain four
> > segments and the structure will still be cache-aligned).
> > 
> > 
> > 
> > 
> > B). Both the producer (req_* and rsp_*) values are in the same
> > cache-line. This means that we end up with the same cacheline being
> > modified by two different guests. Depending on the architecture and
> > placement of the guest this could be bad - as each logical CPU would
> > try to write and read from the same cache-line. A mechanism where
> > the req_* and rsp_ values are separated and on a different cache line
> > could be used. The value of the correct cache-line and alignment could
> > be negotiated via XenBus - in case future technologies start using 128
> > bytes for cache or such. Or the the producer and consumer indexes are
in
> > separate rings. Meaning we have a ‘request ring’ and a ‘response
> > ring’ - and only the ‘req_prod’, ‘req_event’ are modified in
> > the ‘request ring’. The opposite (resp_*) are only modified in the
> > ‘response ring’.
> 
> Using different rings for requests and responses sounds like a good idea,
> this will reduce the number of variables on the ring, leaving only
> "produced" and "event" (we no longer need rsp_ and
req_).
<nods>
> 
> Since we will no longer have two different domains writing to the same
> cache line I guess this will get rid of the cache ping-pong problem.
<nods> That is my thinking.
> 
> Also while there we could try to use all the page, instead of rounding
> down to the closer power of two, this will allow us to go from 64
> requests to 126 (if using the indirect descriptors proposal explained
> above).
Right.
Lets call this 'feature-seperate-req-and-rsp' ?
>  
> > C). Similar to B) problem but with a bigger payload. Each
> > ‘blkif_sring_entry’ occupies 112 bytes which does not lend itself
> > to a nice cache line size. If the indirect descriptors are to be used
> > for everything we could ‘slim-down’ the blkif_request/response to
> > be up-to 64 bytes. This means modifying BLKIF_MAX_SEGMENTS_PER_REQUEST
> > to 5 as that would slim the largest of the structures to 64-bytes.
> > Naturally this means negotiating a new size of the structure via
XenBus.
Here I am using 5, and I think you were using 4 - and you mentioned you
got it down to 32-bytes. I should double-check the 'sizeof' then to
see what it would be like.
> > 
> > 
> > D). The first picture shows the problem. We now aligning everything
> > on the wrong cachelines. Worst in ⅓ of the cases we straddle
> > three cache-lines. We could negotiate a proper alignment for each
> > request/response structure.
> > 
> > 
> > E). The network stack has showed that going in a polling mode does
improve
> > performance. The current mechanism of kicking the guest and or block
> > backend is not always clear.  [TODO: Konrad to explain it in details]
Oh, I never did explain this - but I think the patches that Daniel came
up with actually fix a part of it. They make the kick-the-other guest
only happen when the backend has processed all of the requests and
cannot find anything else to do. Previously it was more of 'done one
request, lets kick the backend.'.

But going forward, this 'kick-the-other-guest' could be further
modulated.
If we have a full ring and the frontend keeps on adding entries we (backend)
should never get an interrupt. As of matter of fact the frontend should be just
polling all the time and process them as fast as possible.

Or we could add tweaks in the backend to adopt an 'adaptive interrupt
coelescing' mechanism. This way we only kick the frontend if a certain
threshold of I/Os have been processed or if we are slowing down on the
threshold. Again, the idea is that - if we have the rings full we should
not send 'kicks' at all and just keep on processing.

Note: I *believe* that the backend does this - keeps on processing and
won't kick if the ring is full. But I am not 100% sure on the frontend side.
> > 
> > 
> > F). The current block protocol for big I/Os that the backend devices
can
> > handle ends up doing extra work by splitting the I/O in smaller
chunks,
> > and then reassembling them. With the solutions outlined in A) this can
> > be fixed. This is easily seen with 1MB I/Os. Since each request can
> > only handle 44kB that means we have to split a 1MB I/O in 24 requests
> > (23 * 4096 * 11 = 1081344). Then the backend ends up sending them in
> > sector-sizes- which with contemporary devices (such as SSD) ends up
with
> > more processing. The SSDs are comfortable handling 128kB or higher
I/Os
> > in one go.
> > 
> > 
> > G). DIF/DIX. This a protocol to carry extra ‘checksum’ information
> > for each I/O. The I/O can be a sector size, page-size or an I/O size
> > (most popular are 1MB). The DIF/DIX needs 8 bytes of information for
> > each I/O. It would be worth considering putting/reserving that amount
of
> > space in each request/response. Also putting in extra flags for future
> > extensions would be worth it - however the author is not aware of any
> > right now.
> > 
> > 
> > H). Separate response/request. Potentially even multi-queue per-VCPU
> > queues. As v2.6.37 demonstrated, the idea of WRITE_BARRIER was
> > flawed. There is no similar concept in the storage world were the
> > operating system can put a food down and say: “everything before this
> > has to be on the disk.” There are ligther versions of this - called
> > ‘FUA’ and ‘FLUSH’. Depending on the internal implementation
> > of the storage they are either ignored or do the right thing. The
> > filesystems determine the viability of these flags and change writing
> > tactics depending on this. From a protocol level, this means that the
> > WRITE/READ/SYNC requests can be intermixed - the storage by itself
> > determines the order of the operation. The filesystem is the one that
> > determines whether the WRITE should be with a FLUSH to preserve some
form
> > of atomicity. This means we do not have to preserve an order of
operations
> > - so we can have multiple queues for request and responses. This has
> > show in the network world to improve performance considerably.
> > 
> > 
> > I). Wastage of response/request on the same ring. Currently each
response
> > MUST occupy the same amount of space that the request occupies - as
the
> > ring can have both responses and requests. Separating the request and
> > response ring would remove the wastage.
> > 
> > 
> > J). 32-bit vs 64-bit (or 102 bytes vs 112 bytes). The size of the ring
> > entries is different if the guest is in 32-bit or 64-bit mode.
Cleaning
> > this up to be the same size would save considerable accounting that
the
> > host has to do (extra memcpy for each response/request).
> 
> So forth I think most of the problems could be solved by using indirect
> descriptors, aligning requests to a cache sensible value (to prevent
> straddling) and using separate rings for requests and responses. This 
> would be my plan for solving this issues:
That would take care of the bulk of the big issues.
> 
> 1. Implement LRU mechanism in blkback for the persistent grants list. If
> we are going to increment the number of in-flight IO we need to be able to
> keep the list of persistently mapped grants to something sensible, and
> we are no longer able to persistently map all the grants that could be 
> used. In my proposal that would be 64 * 4 for each grant frame that 
Can you explain the foundations behind the '64' and '4'? I think
I know
the 4 (BLKIF_..SEGMENTS) but I am not sure about '64'.
> contains indirect entries, plus 64 * 4 * 256, for all the possible
> entries in the indirect frame 64 * 4 + 64 * 4 * 256 = 65792.
That would cover ~256MB of data per guest. Wow. 
> 
> 2. Implement indirect descriptors.
> 
> 3. Implement new ring protocol, using two separate rings for requests
> and replies.
Don't want to negotiate each of these proposal as a seperate feature? So:
	seperate-req-and-rsp
	slim-version-of-req
	indiret-descriptor
	multi-page-ring
	aligment-64-or-other-value


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
http://lists.xen.org/xen-devel

On 18/01/13 19:20, Konrad Rzeszutek Wilk wrote:
> On Fri, Jan 18, 2013 at 05:00:10PM +0100, Roger Pau Monné wrote:
>> On 18/12/12 15:31, Konrad Rzeszutek Wilk wrote:
>>> Hey,
>>>
>>> I am including some folks that are not always on Xen-devel to see
if they have
>>> some extra ideas or can correct my misunderstandings.
>>>
>>> This is very much RFC - so there is bound to be some bugs.
>>> The original is here
>>>
https://docs.google.com/document/d/1Vh5T8Z3Tx3sUEhVB0DnNDKBNiqB_ZA8Z5YVqAsCIjuI/edit
>>> in case one wishes to modify/provide comment on that one.
>>
>> Hello Konrad,
>>
>> Thanks for the problem description and possible solutions, I'm
>> going to take on this (provided that you are OK with it).
> 
> The whole thing!? You are quite ambitious here!
I will try to fix as much as possible, one thing at a time, don't expect
a series from one day to another fixing all the issues :)
>>
>>>
>>> There are outstanding issues we have now with the block protocol:
>>> Note: I am assuming 64-bit guest/host - as the size’s of the
structures
>>> change on 32-bit. I am also attaching the header for the blkif ring
>>> as of today.
>>>
>>> A) Segment size is limited to 11 pages. It means we can at most
squeeze
>>> in 44kB per request. The ring can hold 32 (next power of two below
36)
>>> requests, meaning we can do 1.4M of outstanding requests.
>>
>> I've been looking at the different options here and I think the
most
>> suitable one would be using a mechanism similar to VirtIO
"indirect
>> descriptors", it is the one that allows for more in-flight
requests
>> while being quite simple to implement.
> 
> <nods> I think you are right - plus it looks to be similar to how the
more
> modern hardware does requests (here I am thinking of NVMe and its command
> descriptor - where it can point to a page full of DMA addresses + LBAs and
say
> "Go READ").
> 
>>
>>> B). Producer and consumer index is on the same cache line. In
present hardware
>>> that means the reader and writer will compete for the same
cacheline causing a
>>> ping-pong between sockets.
>>>
>>> C). The requests and responses are on the same ring. This again
causes the
>>> ping-pong between sockets as the ownership of the cache line will
shift between
>>> sockets.
>>>
>>> D). Cache alignment. Currently the protocol is 16-bit aligned. This
is awkward
>>> as the request and responses sometimes fit within a cacheline or
sometimes
>>> straddle them.
>>>
>>> E). Interrupt mitigation. We are currently doing a kick whenever we
are
>>> done “processing” the ring. There are better ways to do this - and
>>> we could use existing network interrupt mitigation techniques to
make the
>>> code poll when there is a lot of data.
>>>
>>> F). Latency. The processing of the request limits us to only do
44kB - which means
>>> that a 1MB chunk of data - which on contemporary devices would only
use I/O request
>>> - would be split up in multiple ‘requests’ inadvertently delaying
the processing of
>>> said block.
>>>
>>> G) Future extensions. DIF/DIX for integrity. There might
>>> be other in the future and it would be good to leave space for
extra
>>> flags TBD.
>>>
>>> H). Separate the response and request rings. The current
>>> implementation has one thread for one block ring. There is no
reason why
>>> there could not be two threads - one for responses and one for
requests -
>>> and especially if they are scheduled on different CPUs. Furthermore
this
>>> could also be split in multi-queues - so two queues (response and
request)
>>> on each vCPU.
>>>
>>> I). We waste a lot of space on the ring - as we use the
>>> ring for both requests and responses. The response structure needs
to
>>> occupy the same amount of space as the request structure (112
bytes). If
>>> the request structure is expanded to be able to fit more segments
(say
>>> the ‘struct blkif_sring_entry is expanded to ~1500 bytes) that
still
>>> requires us to have a matching size response structure. We do not
need
>>> to use that much space for one response. Having a separate response
ring
>>> would simplify the structures.
>>>
>>> J). 32 bit vs 64 bit. Right now the size
>>> of the request structure is 112 bytes under 64-bit guest and 102
bytes
>>> under 32-bit guest. It is confusing and furthermore requires the
host
>>> to do extra accounting and processing.
>>>
>>> The crude drawing displays memory that the ring occupies in offset
of
>>> 64 bytes (cache line). Of course future CPUs could have different
cache
>>> lines (say 32 bytes?)- which would skew this drawing. A 32-bit ring
is
>>> a bit different as the ‘struct blkif_sring_entry’ is of 102 bytes.
>>>
>>>
>>> The A) has two solutions to this (look at
>>> http://comments.gmane.org/gmane.comp.emulators.xen.devel/140406 for
>>> details). One proposed by Justin from Spectralogic has to negotiate
>>> the segment size. This means that the ‘struct blkif_sring_entry’
>>> is now a variable size. It can expand from 112 bytes (cover 11
pages of
>>> data - 44kB) to 1580 bytes (256 pages of data - so 1MB). It is a
simple
>>> extension by just making the array in the request expand from 11 to
a
>>> variable size negotiated.
>>>
>>>
>>> The math is as follow.
>>>
>>>
>>>         struct blkif_request_segment {
>>>                 uint32 grant;                         // 4 bytes
uint8_t
>>>                 first_sect, last_sect;// 1, 1 = 6 bytes
>>>         }
>>> (6 bytes for each segment) - the above structure is in an array of
size
>>> 11 in the request. The ‘struct blkif_sring_entry’ is 112 bytes. The
>>> change is to expand the array - in this example we would tack on
245 extra
>>> ‘struct blkif_request_segment’ - 245*6 + 112 = 1582. If we were to
>>> use 36 requests (so 1582*36 + 64) we would use 57016 bytes (14
pages).
>>>
>>>
>>> The other solution (from Intel - Ronghui) was to create one extra
>>> ring that only has the ‘struct blkif_request_segment’ in them. The
>>> ‘struct blkif_request’ would be changed to have an index in said
>>> ‘segment ring’. There is only one segment ring. This means that the
>>> size of the initial ring is still the same. The requests would
point
>>> to the segment and enumerate out how many of the indexes it wants
to
>>> use. The limit is of course the size of the segment. If one assumes
a
>>> one-page segment this means we can in one request cover ~4MB. The
math
>>> is as follow:
>>>
>>>
>>> First request uses the half of the segment ring - so index 0 up
>>> to 341 (out of 682). Each entry in the segment ring is a ‘struct
>>> blkif_request_segment’ so it occupies 6 bytes. The other requests
on
>>> the ring (so there are 35 left) can use either the remaining 341
indexes
>>> of the sgement ring or use the old style request. The old style
request
>>> can address use up to 44kB. For example:
>>>
>>>
>>>  sring[0]->[uses 0->341 indexes in the segment ring] =
342*4096 = 1400832
>>>  sring[1]->[use sthe old style request] = 11*4096 = 45056
>>>  sring[2]->[uses 342->682 indexes in the segment ring] =
1392640
>>>  sring[3..32] -> [uses the old style request] = 29*4096*11 =
1306624
>>>
>>>
>>> Total: 4145152 bytes Naturally this could be extended to have a
bigger
>>> segment ring to cover more.
>>>
>>>
>>>
>>>
>>>
>>> The problem with this extension is that we use 6 bytes and end up
>>> straddling a cache line. Using 8 bytes will fix the cache
straddling. This
>>> would mean fitting only 512 segments per page.
>>>
>>>
>>> There is yet another mechanism that could be employed  - and it
borrows
>>> from VirtIO protocol. And that is the ‘indirect descriptors’. This
>>> very similar to what Intel suggests, but with a twist.
>>>
>>>
>>> We could provide a new BLKIF_OP (say BLKIF_OP_INDIRECT), and the
‘struct
>>> blkif_sring’ (each entry can be up to 112 bytes if needed - so the
>>> old style request would fit). It would look like:
>>>
>>>
>>> /* so 64 bytes under 64-bit. If necessary, the array (seg) can be
>>> expanded to fit 11 segments as the old style request did */ struct
>>> blkif_request_indirect {
>>>         uint8_t        op;           /* BLKIF_OP_* (usually READ or
WRITE    */
>>> // 1 blkif_vdev_t   handle;       /* only for read/write requests  
*/ // 2
>>> #ifdef CONFIG_X86_64
>>>         uint32_t       _pad1;             /*
offsetof(blkif_request,u.rw.id) == 8 */ // 2
>>> #endif
>>>         uint64_t       id;           /* private guest value, echoed
in resp  */
>>>         grant_ref_t    gref;        /* reference to indirect buffer
frame  if used*/
>>>             struct blkif_request_segment_aligned seg[4]; // each is
8 bytes
>>>
>>> } __attribute__((__packed__));
>>>
>>>
>>> struct blkif_request {
>>>         uint8_t        operation;    /* BLKIF_OP_???  */
>>>         union {
>>>                 struct blkif_request_rw rw;
>>>                 struct blkif_request_indirect
>>>                 indirect; … other ..
>>>         } u;
>>> } __attribute__((__packed__));
>>>
>>
>> Do you think it will be suitable to change the size of blkif_request, I
>> was thinking that if we introduce indirect request we could reduce the
>> maximum number of segments per request to 2, so blkif_request is
>> reduced to 32bytes and we can fit 126 requests (64 due to rounding)
>> in a single ring.
> 
> Altering it to be 32-bytes means we are still crossing two cachelines.
Are you sure? using 32bytes on a 64bytes cache line means we have two
requests in the same cache line, but it's impossible that a request uses
two different cache lines (which I guess it's the main problem):

                64bytes
    <------------------------------>
    +------------------------------+
    | ring header + pad            |
    +------------------------------+
       32bytes
    <--------------->
    +---------------+--------------+
    | req[0]        | req[1]       |
    +---------------|--------------+
    | req[2]        | req[3]       |
    +---------------+--------------+
> 
> This is where I thought of putting 'struct blkif_request_rw' on a
diet
> and just making it have 4 of the grants - in case the request is
> just 16K. And then the size of the structure (if I got my math right)
> would be 64-bytes.
Using 64bytes still leaves us with only 32 requests on the ring (unless
we change the ring protocol to support a ring size different than a
power of two).
> Naturally this means we need to negotiate a 'feature-request-size'
> where v1 says that the request is of 64-bytes length. v2 might
> be 128bytes or whatever else we would need to fit within a cacheline
> in future CPUs. We could pad the 'struct request_v1' with 64-bytes
> in case the cacheline is 128bytes and our request is 64-bytes.
I would have to benchmark if having two requests on the same cache line
or only a single one has any kind of impact on performance, as I
understand it the only problem of this approach might happen when
blkback is writing a reply and blkfront is also writing a request in the
same cache line (which will be solved by using two different rings, one
for replies and one for request).

So I think a compromise solution is to use 32bytes requests, that would
always be cache aligned and to solve the ping-pong problem between
blkfront/blkback writing on the same cache line two rings should be used.
> 
>>
>> Everything that needs more than two segments will switch to using the
>> new indirect operation. Also, to make use of the extra space in
>> blkif_request_indirect I would remove the extra segments and instead
>> pass more grant references to frames containing
>> blkif_request_indirect_entry entries.
> 
> Right. The complications arise when we need to support this new format
> and the old format and have to switch over when we migrate to old
> backends.
> 
>>
>> #define BLKIF_MAX_SEGMENTS_PER_REQUEST 2
>> #define BLKIF_MAX_INDIRECT_GREFS_PER_REQUEST 4
>>
>> struct blkif_request_segment {
>>     grant_ref_t gref;        /* reference to I/O buffer frame        */
>>     /* @first_sect: first sector in frame to transfer (inclusive).   */
>>     /* @last_sect: last sector in frame to transfer (inclusive).     */
>>     uint8_t     first_sect, last_sect;
>> } __attribute__((__packed__));
>>
>> struct blkif_request_indirect_entry {
>>     blkif_sector_t  sector_number;
>>     struct          blkif_request_segment seg;
>>     uint8_t         _pad[2];
>> } __attribute__((__packed__));
>>
>> struct blkif_request_rw {
>>     uint8_t        nr_segments;  /* number of segments                 
*/
>>     blkif_vdev_t   handle;       /* only for read/write requests       
*/
>>     uint64_t       id;           /* private guest value, echoed in resp
*/
>>     blkif_sector_t sector_number;/* start sector idx on disk (r/w only)
*/
>>     struct blkif_request_segment seg[BLKIF_MAX_SEGMENTS_PER_REQUEST];
>> } __attribute__((__packed__));
>>
>> struct blkif_request_indirect {
>>     uint8_t        op;           /* BLKIF_OP_* (usually READ or WRITE  
*/
>>     uint16_t       nr_indirect;  /* number of indirect entries in gref
frames */
>>     blkif_vdev_t   handle;       /* only for read/write requests       
*/
>>     uint64_t       id;           /* private guest value, echoed in resp
*/
>>     /* reference to indirect buffer frame */
>>     grant_ref_t    gref[BLKIF_MAX_INDIRECT_GREFS_PER_REQUEST];
>> } __attribute__((__packed__));
>>
>> struct blkif_request_discard {
>>     uint8_t        flag;         /* BLKIF_DISCARD_SECURE or zero.      
*/
>> #define BLKIF_DISCARD_SECURE (1<<0)  /* ignored if
discard-secure=0          */
>>     uint64_t       id;           /* private guest value, echoed in resp
*/
>>     blkif_sector_t sector_number;
>>     uint64_t       nr_sectors;
>> } __attribute__((__packed__));
>>
>> struct blkif_request {
>>     uint8_t        operation;    /* BLKIF_OP_???                       
*/
>>     union {
>>         struct blkif_request_rw rw;
>>         struct blkif_request_indirect indirect;
>>         struct blkif_request_discard discard;
>>     } u;
>> } __attribute__((__packed__));
>>
>> I've removed all the extra paddings, because this protocol is no
longer
>> compatible with the previous one (we modify
>> BLKIF_MAX_SEGMENTS_PER_REQUEST), and packed the structures. I'm
>> wondering if using __attribute__ in a public header is allowed, since
>> this is a GNU extension (AFAIK supported by gcc and clang at least).
> 
> I don't know. But I think we can bypass the need for it if we calculate
> the size of each entry right and insert padding whenever neccessary.
Yes, I would like to avoid having different sizes depending on the
architecture.
> 
>>
>> The main motivation behind the modification of the size of the
>> request is because I've realized that in your proposal, you where
>> adding 4 extra segments to the indirect request, and I was wondering
>> if I could pack more grant frames containing indirect entries in a
>> single request. By using the old size of blkf_request we will be able
to
>> send up to 9 grant frames filled with indirect entries, which gives us
>> 4096 * 256 * 9 = 9MB of outstanding IO in each request. I think that
>> this is too high, and will introduce a lot of latency to the protocol.
>> That's the main reason I've decided to reduce the size of
blkif_request
>> in order to be able to fit more of them in a ring, instead of making
>> each of the requests bigger.
> 
> OK. That is OK as long as we make sure to _not_ have two requests
> straddling the cache-line. Or maybe that is not a problem.
> 
> But the other nice benefit of your idea - where it is only 32-bytes
> - is that we have now extra 32-bytes where we can insert such
> things as DIF/DIX or "other" new features. And that way have the
> request be of size 64 bytes.
So you prefer to keep the ring size to 32, instead of increasing it to
64, and use the remaining 32bytes in the request to store request
related data?
> 
>>
>> Using this implementation each request has a size of 32bytes (to
>> prevent cache straddle), so we could fit 126 requests in a ring, but
>> due to the rounding, we end up with 64. Also each request can contain
>> 4 grant pages, each one filled with 256 blkif_request_indirect_entry.
>> The math for the maximum data in a request is: 4096 * 256 * 4 = 4MB,
>> and in the whole ring 4 * 64 = 256MB worth of outstanding IO.
>>
> 
> Which has a nice power of two ring to it. (Ah the puns!)
> 
> I like the idea of putting the request on a diet - but too much
> could cause us to miss the opportunity to insert other flags on it.
> If I recall correctly, the DIF/DIX only need 8 bytes of data.
> If we make the assumption that:
>         I/O request = one ring entry
So we only need to reserve 8bytes for each DIF/IDX, even if the request
contains a variable number of data? (I mean, block requests can at a
minimum contain 4096bytes, or much more)
> and the  "one ring entry" can use the the '4' grants if
we just have a
> 16KB I/O request, but if it is more than that - we use the indirect page
Well, on my purpose I've limited the number of segments of a "rw"
requests to 2, so it's only 8K, anything bigger has to use indirect
descriptors, which can fit 4M of data (because I'm passing 4 grant
frames full of "blkif_request_indirect_entry" entries).
> and can stuff 1MB of data in there.
> The extra 32-bytes of space for such things as 'DIF/DIX'. This also
> means we could unify the 'struct request' with the
'discard' operation
> and it could utilize the 32-bytes of extra unused payload data.
> 
>>>
>>>
>>> The ‘operation’ would be BLKIF_OP_INDIRECT. The read/write/discard,
>>> etc operation would now be in indirect.op. The indirect.gref points
to
>>> a page that is filled with:
>>>
>>>
>>> struct blkif_request_indirect_entry {
>>>         blkif_sector_t sector_number;
>>>         struct blkif_request_segment seg;
>>> } __attribute__((__packed__));
>>> //16 bytes, so we can fit in a page 256 of these structures.
>>>
>>>
>>> This means that with the existing 36 slots in the ring (single
page)
>>> we can cover: 32 slots * each blkif_request_indirect covers: 256 *
4096
>>> ~= 32M. If we don’t want to use indirect descriptor we can still
use
>>> up to 4 pages of the request (as it has enough space to contain
four
>>> segments and the structure will still be cache-aligned).
>>>
>>>
>>>
>>>
>>> B). Both the producer (req_* and rsp_*) values are in the same
>>> cache-line. This means that we end up with the same cacheline being
>>> modified by two different guests. Depending on the architecture and
>>> placement of the guest this could be bad - as each logical CPU
would
>>> try to write and read from the same cache-line. A mechanism where
>>> the req_* and rsp_ values are separated and on a different cache
line
>>> could be used. The value of the correct cache-line and alignment
could
>>> be negotiated via XenBus - in case future technologies start using
128
>>> bytes for cache or such. Or the the producer and consumer indexes
are in
>>> separate rings. Meaning we have a ‘request ring’ and a ‘response
>>> ring’ - and only the ‘req_prod’, ‘req_event’ are modified in
>>> the ‘request ring’. The opposite (resp_*) are only modified in the
>>> ‘response ring’.
>>
>> Using different rings for requests and responses sounds like a good
idea,
>> this will reduce the number of variables on the ring, leaving only
>> "produced" and "event" (we no longer need rsp_ and
req_).
> 
> <nods>
>>
>> Since we will no longer have two different domains writing to the same
>> cache line I guess this will get rid of the cache ping-pong problem.
> 
> <nods> That is my thinking.
>>
>> Also while there we could try to use all the page, instead of rounding
>> down to the closer power of two, this will allow us to go from 64
>> requests to 126 (if using the indirect descriptors proposal explained
>> above).
> 
> Right.
> Lets call this 'feature-seperate-req-and-rsp' ?
Yes, and blkfront will also need to pass two different grant frames at
init, because we need to map two rings.
> 
>>
>>> C). Similar to B) problem but with a bigger payload. Each
>>> ‘blkif_sring_entry’ occupies 112 bytes which does not lend itself
>>> to a nice cache line size. If the indirect descriptors are to be
used
>>> for everything we could ‘slim-down’ the blkif_request/response to
>>> be up-to 64 bytes. This means modifying
BLKIF_MAX_SEGMENTS_PER_REQUEST
>>> to 5 as that would slim the largest of the structures to 64-bytes.
>>> Naturally this means negotiating a new size of the structure via
XenBus.
> 
> Here I am using 5, and I think you were using 4 - and you mentioned you
> got it down to 32-bytes. I should double-check the 'sizeof' then to
> see what it would be like.
No, I was limiting it to 2 segments in the "rw" request, the 4 comes
because I'm passing 4 grant frames in the
"blkif_request_indirect",
instead of just one (see above, "gref" is now an array in my
proposal).
> 
>>>
>>>
>>> D). The first picture shows the problem. We now aligning everything
>>> on the wrong cachelines. Worst in ⅓ of the cases we straddle
>>> three cache-lines. We could negotiate a proper alignment for each
>>> request/response structure.
>>>
>>>
>>> E). The network stack has showed that going in a polling mode does
improve
>>> performance. The current mechanism of kicking the guest and or
block
>>> backend is not always clear.  [TODO: Konrad to explain it in
details]
> 
> Oh, I never did explain this - but I think the patches that Daniel came
> up with actually fix a part of it. They make the kick-the-other guest
> only happen when the backend has processed all of the requests and
> cannot find anything else to do. Previously it was more of 'done one
> request, lets kick the backend.'.
Yes, that's what I'm seeing in the current code.
> But going forward, this 'kick-the-other-guest' could be further
modulated.
> If we have a full ring and the frontend keeps on adding entries we
(backend)
> should never get an interrupt. As of matter of fact the frontend should be
just
> polling all the time and process them as fast as possible.
Yes, we could switch to polling in both ends and only "kick" when the
ring is full (which should not happen usually), this will probably
reduce CPU utilization, but I doubt it's going to increase the throughput.
> Or we could add tweaks in the backend to adopt an 'adaptive interrupt
> coelescing' mechanism. This way we only kick the frontend if a certain
> threshold of I/Os have been processed or if we are slowing down on the
> threshold. Again, the idea is that - if we have the rings full we should
> not send 'kicks' at all and just keep on processing.
> 
> Note: I *believe* that the backend does this - keeps on processing and
> won't kick if the ring is full. But I am not 100% sure on the frontend
side.
Changing this is not really difficult (in my opinion, but I've might be
wrong), so I think we could try several approaches and see which one
gives better performance (or reduces CPU utilization).

Anyway, I would focus now on the indirect descriptors and separate the
rings, and leave this work for afterwards (because what we could
probably see now might not be true once the other improvements are done).
>>>
>>>
>>> F). The current block protocol for big I/Os that the backend
devices can
>>> handle ends up doing extra work by splitting the I/O in smaller
chunks,
>>> and then reassembling them. With the solutions outlined in A) this
can
>>> be fixed. This is easily seen with 1MB I/Os. Since each request can
>>> only handle 44kB that means we have to split a 1MB I/O in 24
requests
>>> (23 * 4096 * 11 = 1081344). Then the backend ends up sending them
in
>>> sector-sizes- which with contemporary devices (such as SSD) ends up
with
>>> more processing. The SSDs are comfortable handling 128kB or higher
I/Os
>>> in one go.
>>>
>>>
>>> G). DIF/DIX. This a protocol to carry extra ‘checksum’ information
>>> for each I/O. The I/O can be a sector size, page-size or an I/O
size
>>> (most popular are 1MB). The DIF/DIX needs 8 bytes of information
for
>>> each I/O. It would be worth considering putting/reserving that
amount of
>>> space in each request/response. Also putting in extra flags for
future
>>> extensions would be worth it - however the author is not aware of
any
>>> right now.
>>>
>>>
>>> H). Separate response/request. Potentially even multi-queue
per-VCPU
>>> queues. As v2.6.37 demonstrated, the idea of WRITE_BARRIER was
>>> flawed. There is no similar concept in the storage world were the
>>> operating system can put a food down and say: “everything before
this
>>> has to be on the disk.” There are ligther versions of this - called
>>> ‘FUA’ and ‘FLUSH’. Depending on the internal implementation
>>> of the storage they are either ignored or do the right thing. The
>>> filesystems determine the viability of these flags and change
writing
>>> tactics depending on this. From a protocol level, this means that
the
>>> WRITE/READ/SYNC requests can be intermixed - the storage by itself
>>> determines the order of the operation. The filesystem is the one
that
>>> determines whether the WRITE should be with a FLUSH to preserve
some form
>>> of atomicity. This means we do not have to preserve an order of
operations
>>> - so we can have multiple queues for request and responses. This
has
>>> show in the network world to improve performance considerably.
>>>
>>>
>>> I). Wastage of response/request on the same ring. Currently each
response
>>> MUST occupy the same amount of space that the request occupies - as
the
>>> ring can have both responses and requests. Separating the request
and
>>> response ring would remove the wastage.
>>>
>>>
>>> J). 32-bit vs 64-bit (or 102 bytes vs 112 bytes). The size of the
ring
>>> entries is different if the guest is in 32-bit or 64-bit mode.
Cleaning
>>> this up to be the same size would save considerable accounting that
the
>>> host has to do (extra memcpy for each response/request).
>>
>> So forth I think most of the problems could be solved by using indirect
>> descriptors, aligning requests to a cache sensible value (to prevent
>> straddling) and using separate rings for requests and responses. This
>> would be my plan for solving this issues:
> 
> That would take care of the bulk of the big issues.
> 
>>
>> 1. Implement LRU mechanism in blkback for the persistent grants list.
If
>> we are going to increment the number of in-flight IO we need to be able
to
>> keep the list of persistently mapped grants to something sensible, and
>> we are no longer able to persistently map all the grants that could be
>> used. In my proposal that would be 64 * 4 for each grant frame that
> 
> Can you explain the foundations behind the '64' and '4'? I
think I know
> the 4 (BLKIF_..SEGMENTS) but I am not sure about '64'.
The 4 comes because in my proposal I'm passing 4 indirect grant frames
filled with blkif_request_segment (so gref in blkif_request_indirect is
now an array).

The 64 comes because I've reduced the size of blkif_request to 32bytes,
so now we can fit 64 blkif_requests in a ring.

Putting it all together:

4 (indirect grant frames) * 256 (entries in each indirect grant frame) *
4096 (PAGE_SIZE) = 4M IO in a single request

64 (32bytes entries in a ring) * 4M (max IO in each entry) = 256M worth
of IO in a 4096bytes ring.
>> contains indirect entries, plus 64 * 4 * 256, for all the possible
>> entries in the indirect frame 64 * 4 + 64 * 4 * 256 = 65792.
> 
> That would cover ~256MB of data per guest. Wow.
>>
>> 2. Implement indirect descriptors.
>>
>> 3. Implement new ring protocol, using two separate rings for requests
>> and replies.
> 
> Don't want to negotiate each of these proposal as a seperate feature?
So:
>         seperate-req-and-rsp
>         slim-version-of-req
>         indiret-descriptor
>         multi-page-ring
>         aligment-64-or-other-value
Yes, but I will try to couple them in a way that makes sense, for
example reducing the size of blkif_request without using indirect
descriptors doesn't make much sense, so I would couple
indirect-descriptor with slim-version-of-req, this will leave us with
the following new extensions:

indirect-descriptors (which includes a slim version of blkif_request)
separate-req-and-rsp

This will be the two first extensions we should try to implement from my
POV, because I think they are going to deliver quite a performance boost.


_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
http://lists.xen.org/xen-devel

On Fri, 2013-01-18 at 18:20 +0000, Konrad Rzeszutek Wilk
wrote:
> 
> > > E). The network stack has showed that going in a polling mode
does improve
> > > performance. The current mechanism of kicking the guest and or
block
> > > backend is not always clear.  [TODO: Konrad to explain it in
details]
> 
> Oh, I never did explain this - but I think the patches that Daniel came
> up with actually fix a part of it. They make the kick-the-other guest
> only happen when the backend has processed all of the requests and
> cannot find anything else to do. Previously it was more of ''done
one
> request, lets kick the backend.''.
blkback uses RING_PUSH_RESPONSES_AND_CHECK_NOTIFY so doesn''t it get
some
amount of evthcn mitigation for free?
> But going forward, this ''kick-the-other-guest'' could be
further modulated.
> If we have a full ring and the frontend keeps on adding entries we
(backend)
> should never get an interrupt. As of matter of fact the frontend should be
just
> polling all the time and process them as fast as possible.
I think the existing req_event/rsp_event ring fields should enable this
already, assuming the front- and back-ends are using them right.

Ian.

On Mon, Jan 21, 2013 at 12:37:18PM +0000, Ian Campbell
wrote:
> On Fri, 2013-01-18 at 18:20 +0000, Konrad Rzeszutek Wilk wrote:
> > 
> > > > E). The network stack has showed that going in a polling
mode does improve
> > > > performance. The current mechanism of kicking the guest and
or block
> > > > backend is not always clear.  [TODO: Konrad to explain it in
details]
> > 
> > Oh, I never did explain this - but I think the patches that Daniel
came
> > up with actually fix a part of it. They make the kick-the-other guest
> > only happen when the backend has processed all of the requests and
> > cannot find anything else to do. Previously it was more of
''done one
> > request, lets kick the backend.''.
> 
> blkback uses RING_PUSH_RESPONSES_AND_CHECK_NOTIFY so doesn''t it
get some
> amount of evthcn mitigation for free?
So there are two paths here - the kick from a) frontend and the kick b) backend
gives the frontend.

The a) case is fairly straighforward. We process all of the rings we and
everytime
we have finished with a request we re-read the producer. So if the frontend
keeps
us bussy we will keep on processing.

The b) case is the one that is trigger happy. Every time a request is completed
(so
say 44kB of data has finally been read/written) we kick the frontend. In the
networking world there are mechanism to modify the hardware were it would
kick the OS (so frontend in our case) when it has processed 8, 16, or 64 packets
(or some other value). Depending on the latency this can be bad or good. If the
backend is using a very slow disk we would probably want the frontend to be
kicked every time a response has been completed.

But if we have a very fast SSD, we might want to batch those kicks up so
that the frontend does not get kicked that often. I don''t know the
impact
of these ''one request = one kick'' is but we could make this a
bit more
adaptive - so that it starts scalling down the kicks as it has more responses.
And if there are less responses it notches up the amount of kicks.
I think this is called adaptive interrupt moderation (Or interrupt coalescing)
> 
> > But going forward, this ''kick-the-other-guest'' could
be further modulated.
> > If we have a full ring and the frontend keeps on adding entries we
(backend)
> > should never get an interrupt. As of matter of fact the frontend
should be just
> > polling all the time and process them as fast as possible.
> 
> I think the existing req_event/rsp_event ring fields should enable this
> already, assuming the front- and back-ends are using them right.
> 
> Ian.
>

On Sat, Jan 19, 2013 at 01:44:53PM +0100, Roger Pau Monné
wrote:
> On 18/01/13 19:20, Konrad Rzeszutek Wilk wrote:
> > On Fri, Jan 18, 2013 at 05:00:10PM +0100, Roger Pau Monné wrote:
> >> On 18/12/12 15:31, Konrad Rzeszutek Wilk wrote:
> >>> Hey,
> >>>
> >>> I am including some folks that are not always on Xen-devel to
see if they have
> >>> some extra ideas or can correct my misunderstandings.
> >>>
> >>> This is very much RFC - so there is bound to be some bugs.
> >>> The original is here
> >>>
https://docs.google.com/document/d/1Vh5T8Z3Tx3sUEhVB0DnNDKBNiqB_ZA8Z5YVqAsCIjuI/edit
> >>> in case one wishes to modify/provide comment on that one.
> >>
> >> Hello Konrad,
> >>
> >> Thanks for the problem description and possible solutions, I'm
> >> going to take on this (provided that you are OK with it).
> > 
> > The whole thing!? You are quite ambitious here!
> 
> I will try to fix as much as possible, one thing at a time, don't
expect
> a series from one day to another fixing all the issues :)
Heh.
> 
> >>
> >>>
> >>> There are outstanding issues we have now with the block
protocol:
> >>> Note: I am assuming 64-bit guest/host - as the size’s of the
structures
> >>> change on 32-bit. I am also attaching the header for the blkif
ring
> >>> as of today.
> >>>
> >>> A) Segment size is limited to 11 pages. It means we can at
most squeeze
> >>> in 44kB per request. The ring can hold 32 (next power of two
below 36)
> >>> requests, meaning we can do 1.4M of outstanding requests.
> >>
> >> I've been looking at the different options here and I think
the most
> >> suitable one would be using a mechanism similar to VirtIO
"indirect
> >> descriptors", it is the one that allows for more in-flight
requests
> >> while being quite simple to implement.
> > 
> > <nods> I think you are right - plus it looks to be similar to
how the more
> > modern hardware does requests (here I am thinking of NVMe and its
command
> > descriptor - where it can point to a page full of DMA addresses + LBAs
and say
> > "Go READ").
> > 
> >>
> >>> B). Producer and consumer index is on the same cache line. In
present hardware
> >>> that means the reader and writer will compete for the same
cacheline causing a
> >>> ping-pong between sockets.
> >>>
> >>> C). The requests and responses are on the same ring. This
again causes the
> >>> ping-pong between sockets as the ownership of the cache line
will shift between
> >>> sockets.
> >>>
> >>> D). Cache alignment. Currently the protocol is 16-bit aligned.
This is awkward
> >>> as the request and responses sometimes fit within a cacheline
or sometimes
> >>> straddle them.
> >>>
> >>> E). Interrupt mitigation. We are currently doing a kick
whenever we are
> >>> done “processing” the ring. There are better ways to do this -
and
> >>> we could use existing network interrupt mitigation techniques
to make the
> >>> code poll when there is a lot of data.
> >>>
> >>> F). Latency. The processing of the request limits us to only
do 44kB - which means
> >>> that a 1MB chunk of data - which on contemporary devices would
only use I/O request
> >>> - would be split up in multiple ‘requests’ inadvertently
delaying the processing of
> >>> said block.
> >>>
> >>> G) Future extensions. DIF/DIX for integrity. There might
> >>> be other in the future and it would be good to leave space for
extra
> >>> flags TBD.
> >>>
> >>> H). Separate the response and request rings. The current
> >>> implementation has one thread for one block ring. There is no
reason why
> >>> there could not be two threads - one for responses and one for
requests -
> >>> and especially if they are scheduled on different CPUs.
Furthermore this
> >>> could also be split in multi-queues - so two queues (response
and request)
> >>> on each vCPU.
> >>>
> >>> I). We waste a lot of space on the ring - as we use the
> >>> ring for both requests and responses. The response structure
needs to
> >>> occupy the same amount of space as the request structure (112
bytes). If
> >>> the request structure is expanded to be able to fit more
segments (say
> >>> the ‘struct blkif_sring_entry is expanded to ~1500 bytes) that
still
> >>> requires us to have a matching size response structure. We do
not need
> >>> to use that much space for one response. Having a separate
response ring
> >>> would simplify the structures.
> >>>
> >>> J). 32 bit vs 64 bit. Right now the size
> >>> of the request structure is 112 bytes under 64-bit guest and
102 bytes
> >>> under 32-bit guest. It is confusing and furthermore requires
the host
> >>> to do extra accounting and processing.
> >>>
> >>> The crude drawing displays memory that the ring occupies in
offset of
> >>> 64 bytes (cache line). Of course future CPUs could have
different cache
> >>> lines (say 32 bytes?)- which would skew this drawing. A 32-bit
ring is
> >>> a bit different as the ‘struct blkif_sring_entry’ is of 102
bytes.
> >>>
> >>>
> >>> The A) has two solutions to this (look at
> >>>
http://comments.gmane.org/gmane.comp.emulators.xen.devel/140406 for
> >>> details). One proposed by Justin from Spectralogic has to
negotiate
> >>> the segment size. This means that the ‘struct
blkif_sring_entry’
> >>> is now a variable size. It can expand from 112 bytes (cover 11
pages of
> >>> data - 44kB) to 1580 bytes (256 pages of data - so 1MB). It is
a simple
> >>> extension by just making the array in the request expand from
11 to a
> >>> variable size negotiated.
> >>>
> >>>
> >>> The math is as follow.
> >>>
> >>>
> >>>         struct blkif_request_segment {
> >>>                 uint32 grant;                         // 4
bytes uint8_t
> >>>                 first_sect, last_sect;// 1, 1 = 6 bytes
> >>>         }
> >>> (6 bytes for each segment) - the above structure is in an
array of size
> >>> 11 in the request. The ‘struct blkif_sring_entry’ is 112
bytes. The
> >>> change is to expand the array - in this example we would tack
on 245 extra
> >>> ‘struct blkif_request_segment’ - 245*6 + 112 = 1582. If we
were to
> >>> use 36 requests (so 1582*36 + 64) we would use 57016 bytes (14
pages).
> >>>
> >>>
> >>> The other solution (from Intel - Ronghui) was to create one
extra
> >>> ring that only has the ‘struct blkif_request_segment’ in them.
The
> >>> ‘struct blkif_request’ would be changed to have an index in
said
> >>> ‘segment ring’. There is only one segment ring. This means
that the
> >>> size of the initial ring is still the same. The requests would
point
> >>> to the segment and enumerate out how many of the indexes it
wants to
> >>> use. The limit is of course the size of the segment. If one
assumes a
> >>> one-page segment this means we can in one request cover ~4MB.
The math
> >>> is as follow:
> >>>
> >>>
> >>> First request uses the half of the segment ring - so index 0
up
> >>> to 341 (out of 682). Each entry in the segment ring is a
‘struct
> >>> blkif_request_segment’ so it occupies 6 bytes. The other
requests on
> >>> the ring (so there are 35 left) can use either the remaining
341 indexes
> >>> of the sgement ring or use the old style request. The old
style request
> >>> can address use up to 44kB. For example:
> >>>
> >>>
> >>>  sring[0]->[uses 0->341 indexes in the segment ring] =
342*4096 = 1400832
> >>>  sring[1]->[use sthe old style request] = 11*4096 = 45056
> >>>  sring[2]->[uses 342->682 indexes in the segment ring] =
1392640
> >>>  sring[3..32] -> [uses the old style request] = 29*4096*11
= 1306624
> >>>
> >>>
> >>> Total: 4145152 bytes Naturally this could be extended to have
a bigger
> >>> segment ring to cover more.
> >>>
> >>>
> >>>
> >>>
> >>>
> >>> The problem with this extension is that we use 6 bytes and end
up
> >>> straddling a cache line. Using 8 bytes will fix the cache
straddling. This
> >>> would mean fitting only 512 segments per page.
> >>>
> >>>
> >>> There is yet another mechanism that could be employed  - and
it borrows
> >>> from VirtIO protocol. And that is the ‘indirect descriptors’.
This
> >>> very similar to what Intel suggests, but with a twist.
> >>>
> >>>
> >>> We could provide a new BLKIF_OP (say BLKIF_OP_INDIRECT), and
the ‘struct
> >>> blkif_sring’ (each entry can be up to 112 bytes if needed - so
the
> >>> old style request would fit). It would look like:
> >>>
> >>>
> >>> /* so 64 bytes under 64-bit. If necessary, the array (seg) can
be
> >>> expanded to fit 11 segments as the old style request did */
struct
> >>> blkif_request_indirect {
> >>>         uint8_t        op;           /* BLKIF_OP_* (usually
READ or WRITE    */
> >>> // 1 blkif_vdev_t   handle;       /* only for read/write
requests         */ // 2
> >>> #ifdef CONFIG_X86_64
> >>>         uint32_t       _pad1;             /*
offsetof(blkif_request,u.rw.id) == 8 */ // 2
> >>> #endif
> >>>         uint64_t       id;           /* private guest value,
echoed in resp  */
> >>>         grant_ref_t    gref;        /* reference to indirect
buffer frame  if used*/
> >>>             struct blkif_request_segment_aligned seg[4]; //
each is 8 bytes
> >>>
> >>> } __attribute__((__packed__));
> >>>
> >>>
> >>> struct blkif_request {
> >>>         uint8_t        operation;    /* BLKIF_OP_???  */
> >>>         union {
> >>>                 struct blkif_request_rw rw;
> >>>                 struct blkif_request_indirect
> >>>                 indirect; … other ..
> >>>         } u;
> >>> } __attribute__((__packed__));
> >>>
> >>
> >> Do you think it will be suitable to change the size of
blkif_request, I
> >> was thinking that if we introduce indirect request we could reduce
the
> >> maximum number of segments per request to 2, so blkif_request is
> >> reduced to 32bytes and we can fit 126 requests (64 due to
rounding)
> >> in a single ring.
> > 
> > Altering it to be 32-bytes means we are still crossing two cachelines.
> 
> Are you sure? using 32bytes on a 64bytes cache line means we have two
> requests in the same cache line, but it's impossible that a request
uses
> two different cache lines (which I guess it's the main problem):
Correct. In your case we have one cacheline shared by two requests.

This means we will have to be extra careful in the backend (And frontend)
to call 'wmb()' after we have filled two entries. Otherwise we up doing
something like this:

	fill out the req[0]
	a) wmb()   => writes the full 64-bytes cacheline out.
	fill out the req[1]
	b) wmb()	<== has to throw out the cacheline and re-write the new
		    one.

With a 64-bytes one we do not have to worry about that.
> 
>                 64bytes
>     <------------------------------>
>     +------------------------------+
>     | ring header + pad            |
>     +------------------------------+
>        32bytes
>     <--------------->
>     +---------------+--------------+
>     | req[0]        | req[1]       |
>     +---------------|--------------+
>     | req[2]        | req[3]       |
>     +---------------+--------------+
> 
> > 
> > This is where I thought of putting 'struct blkif_request_rw'
on a diet
> > and just making it have 4 of the grants - in case the request is
> > just 16K. And then the size of the structure (if I got my math right)
> > would be 64-bytes.
> 
> Using 64bytes still leaves us with only 32 requests on the ring (unless
> we change the ring protocol to support a ring size different than a
> power of two).
More I believe. The first 64 bytes are for the ring header + pad. Each
request/response is 64 bytes, so 4032 / 64 = 63.

So 63 requests. We should also support a bigger ring size if the
backend has say ultra-fast SSD so that can fill an incredible amount
of requests and get responses almost as fast as we fill the requests.

The neat thing about the split request/response is that the response
ring can be of smaller size. But then we run in the cache issue
I mentioned earlier.
> 
> > Naturally this means we need to negotiate a
'feature-request-size'
> > where v1 says that the request is of 64-bytes length. v2 might
> > be 128bytes or whatever else we would need to fit within a cacheline
> > in future CPUs. We could pad the 'struct request_v1' with
64-bytes
> > in case the cacheline is 128bytes and our request is 64-bytes.
> 
> I would have to benchmark if having two requests on the same cache line
> or only a single one has any kind of impact on performance, as I
> understand it the only problem of this approach might happen when
> blkback is writing a reply and blkfront is also writing a request in the
> same cache line (which will be solved by using two different rings, one
> for replies and one for request).
Right. The issue with sharing two requests on the same cache-line is
a different beast.
> 
> So I think a compromise solution is to use 32bytes requests, that would
> always be cache aligned and to solve the ping-pong problem between
> blkfront/blkback writing on the same cache line two rings should be used.
For that problem of ping-pong that is certainly the case.
> 
> > 
> >>
> >> Everything that needs more than two segments will switch to using
the
> >> new indirect operation. Also, to make use of the extra space in
> >> blkif_request_indirect I would remove the extra segments and
instead
> >> pass more grant references to frames containing
> >> blkif_request_indirect_entry entries.
> > 
> > Right. The complications arise when we need to support this new format
> > and the old format and have to switch over when we migrate to old
> > backends.
> > 
> >>
> >> #define BLKIF_MAX_SEGMENTS_PER_REQUEST 2
> >> #define BLKIF_MAX_INDIRECT_GREFS_PER_REQUEST 4
> >>
> >> struct blkif_request_segment {
> >>     grant_ref_t gref;        /* reference to I/O buffer frame     
*/
> >>     /* @first_sect: first sector in frame to transfer (inclusive).
*/
> >>     /* @last_sect: last sector in frame to transfer (inclusive).  
*/
> >>     uint8_t     first_sect, last_sect;
> >> } __attribute__((__packed__));
> >>
> >> struct blkif_request_indirect_entry {
> >>     blkif_sector_t  sector_number;
> >>     struct          blkif_request_segment seg;
> >>     uint8_t         _pad[2];
> >> } __attribute__((__packed__));
> >>
> >> struct blkif_request_rw {
> >>     uint8_t        nr_segments;  /* number of segments            
*/
> >>     blkif_vdev_t   handle;       /* only for read/write requests  
*/
> >>     uint64_t       id;           /* private guest value, echoed in
resp  */
> >>     blkif_sector_t sector_number;/* start sector idx on disk (r/w
only)  */
> >>     struct blkif_request_segment
seg[BLKIF_MAX_SEGMENTS_PER_REQUEST];
> >> } __attribute__((__packed__));
> >>
> >> struct blkif_request_indirect {
> >>     uint8_t        op;           /* BLKIF_OP_* (usually READ or
WRITE    */
> >>     uint16_t       nr_indirect;  /* number of indirect entries in
gref frames */
> >>     blkif_vdev_t   handle;       /* only for read/write requests  
*/
> >>     uint64_t       id;           /* private guest value, echoed in
resp  */
> >>     /* reference to indirect buffer frame */
> >>     grant_ref_t    gref[BLKIF_MAX_INDIRECT_GREFS_PER_REQUEST];
> >> } __attribute__((__packed__));
> >>
> >> struct blkif_request_discard {
> >>     uint8_t        flag;         /* BLKIF_DISCARD_SECURE or zero. 
*/
> >> #define BLKIF_DISCARD_SECURE (1<<0)  /* ignored if
discard-secure=0          */
> >>     uint64_t       id;           /* private guest value, echoed in
resp  */
> >>     blkif_sector_t sector_number;
> >>     uint64_t       nr_sectors;
> >> } __attribute__((__packed__));
> >>
> >> struct blkif_request {
> >>     uint8_t        operation;    /* BLKIF_OP_???                  
*/
> >>     union {
> >>         struct blkif_request_rw rw;
> >>         struct blkif_request_indirect indirect;
> >>         struct blkif_request_discard discard;
> >>     } u;
> >> } __attribute__((__packed__));
> >>
> >> I've removed all the extra paddings, because this protocol is
no longer
> >> compatible with the previous one (we modify
> >> BLKIF_MAX_SEGMENTS_PER_REQUEST), and packed the structures.
I'm
> >> wondering if using __attribute__ in a public header is allowed,
since
> >> this is a GNU extension (AFAIK supported by gcc and clang at
least).
> > 
> > I don't know. But I think we can bypass the need for it if we
calculate
> > the size of each entry right and insert padding whenever neccessary.
> 
> Yes, I would like to avoid having different sizes depending on the
> architecture.
Good.
> 
> > 
> >>
> >> The main motivation behind the modification of the size of the
> >> request is because I've realized that in your proposal, you
where
> >> adding 4 extra segments to the indirect request, and I was
wondering
> >> if I could pack more grant frames containing indirect entries in a
> >> single request. By using the old size of blkf_request we will be
able to
> >> send up to 9 grant frames filled with indirect entries, which
gives us
> >> 4096 * 256 * 9 = 9MB of outstanding IO in each request. I think
that
> >> this is too high, and will introduce a lot of latency to the
protocol.
> >> That's the main reason I've decided to reduce the size of
blkif_request
> >> in order to be able to fit more of them in a ring, instead of
making
> >> each of the requests bigger.
> > 
> > OK. That is OK as long as we make sure to _not_ have two requests
> > straddling the cache-line. Or maybe that is not a problem.
> > 
> > But the other nice benefit of your idea - where it is only 32-bytes
> > - is that we have now extra 32-bytes where we can insert such
> > things as DIF/DIX or "other" new features. And that way have
the
> > request be of size 64 bytes.
> 
> So you prefer to keep the ring size to 32, instead of increasing it to
> 64, and use the remaining 32bytes in the request to store request
> related data?
Correct - and increase the ring size to two pages or more to compensate
for that.
> 
> > 
> >>
> >> Using this implementation each request has a size of 32bytes (to
> >> prevent cache straddle), so we could fit 126 requests in a ring,
but
> >> due to the rounding, we end up with 64. Also each request can
contain
> >> 4 grant pages, each one filled with 256
blkif_request_indirect_entry.
> >> The math for the maximum data in a request is: 4096 * 256 * 4 =
4MB,
> >> and in the whole ring 4 * 64 = 256MB worth of outstanding IO.
> >>
> > 
> > Which has a nice power of two ring to it. (Ah the puns!)
> > 
> > I like the idea of putting the request on a diet - but too much
> > could cause us to miss the opportunity to insert other flags on it.
> > If I recall correctly, the DIF/DIX only need 8 bytes of data.
> > If we make the assumption that:
> >         I/O request = one ring entry
> 
> So we only need to reserve 8bytes for each DIF/IDX, even if the request
> contains a variable number of data? (I mean, block requests can at a
> minimum contain 4096bytes, or much more)
I need to double check with Martin (CC-ed here). But my recollection
is that it is just attached the the 'bio'. So if the BIO is 4K or 1MB -
it would only have one DIF/DIX data type.

Hmm, but then we operate on the 'struct request' so that might not
be the case..
> 
> > and the  "one ring entry" can use the the '4' grants
if we just have a
> > 16KB I/O request, but if it is more than that - we use the indirect
page
> 
> Well, on my purpose I've limited the number of segments of a
"rw"
> requests to 2, so it's only 8K, anything bigger has to use indirect
> descriptors, which can fit 4M of data (because I'm passing 4 grant
> frames full of "blkif_request_indirect_entry" entries).
<nods>
> 
> > and can stuff 1MB of data in there.
> > The extra 32-bytes of space for such things as 'DIF/DIX'. This
also
> > means we could unify the 'struct request' with the
'discard' operation
> > and it could utilize the 32-bytes of extra unused payload data.
> > 
> >>>
> >>>
> >>> The ‘operation’ would be BLKIF_OP_INDIRECT. The
read/write/discard,
> >>> etc operation would now be in indirect.op. The indirect.gref
points to
> >>> a page that is filled with:
> >>>
> >>>
> >>> struct blkif_request_indirect_entry {
> >>>         blkif_sector_t sector_number;
> >>>         struct blkif_request_segment seg;
> >>> } __attribute__((__packed__));
> >>> //16 bytes, so we can fit in a page 256 of these structures.
> >>>
> >>>
> >>> This means that with the existing 36 slots in the ring (single
page)
> >>> we can cover: 32 slots * each blkif_request_indirect covers:
256 * 4096
> >>> ~= 32M. If we don’t want to use indirect descriptor we can
still use
> >>> up to 4 pages of the request (as it has enough space to
contain four
> >>> segments and the structure will still be cache-aligned).
> >>>
> >>>
> >>>
> >>>
> >>> B). Both the producer (req_* and rsp_*) values are in the same
> >>> cache-line. This means that we end up with the same cacheline
being
> >>> modified by two different guests. Depending on the
architecture and
> >>> placement of the guest this could be bad - as each logical CPU
would
> >>> try to write and read from the same cache-line. A mechanism
where
> >>> the req_* and rsp_ values are separated and on a different
cache line
> >>> could be used. The value of the correct cache-line and
alignment could
> >>> be negotiated via XenBus - in case future technologies start
using 128
> >>> bytes for cache or such. Or the the producer and consumer
indexes are in
> >>> separate rings. Meaning we have a ‘request ring’ and a
‘response
> >>> ring’ - and only the ‘req_prod’, ‘req_event’ are modified in
> >>> the ‘request ring’. The opposite (resp_*) are only modified in
the
> >>> ‘response ring’.
> >>
> >> Using different rings for requests and responses sounds like a
good idea,
> >> this will reduce the number of variables on the ring, leaving only
> >> "produced" and "event" (we no longer need rsp_
and req_).
> > 
> > <nods>
> >>
> >> Since we will no longer have two different domains writing to the
same
> >> cache line I guess this will get rid of the cache ping-pong
problem.
> > 
> > <nods> That is my thinking.
> >>
> >> Also while there we could try to use all the page, instead of
rounding
> >> down to the closer power of two, this will allow us to go from 64
> >> requests to 126 (if using the indirect descriptors proposal
explained
> >> above).
> > 
> > Right.
> > Lets call this 'feature-seperate-req-and-rsp' ?
> 
> Yes, and blkfront will also need to pass two different grant frames at
> init, because we need to map two rings.
<nods>
> 
> > 
> >>
> >>> C). Similar to B) problem but with a bigger payload. Each
> >>> ‘blkif_sring_entry’ occupies 112 bytes which does not lend
itself
> >>> to a nice cache line size. If the indirect descriptors are to
be used
> >>> for everything we could ‘slim-down’ the blkif_request/response
to
> >>> be up-to 64 bytes. This means modifying
BLKIF_MAX_SEGMENTS_PER_REQUEST
> >>> to 5 as that would slim the largest of the structures to
64-bytes.
> >>> Naturally this means negotiating a new size of the structure
via XenBus.
> > 
> > Here I am using 5, and I think you were using 4 - and you mentioned
you
> > got it down to 32-bytes. I should double-check the 'sizeof'
then to
> > see what it would be like.
> 
> No, I was limiting it to 2 segments in the "rw" request, the 4
comes
> because I'm passing 4 grant frames in the
"blkif_request_indirect",
> instead of just one (see above, "gref" is now an array in my
proposal).
<nods>
> 
> > 
> >>>
> >>>
> >>> D). The first picture shows the problem. We now aligning
everything
> >>> on the wrong cachelines. Worst in ⅓ of the cases we straddle
> >>> three cache-lines. We could negotiate a proper alignment for
each
> >>> request/response structure.
> >>>
> >>>
> >>> E). The network stack has showed that going in a polling mode
does improve
> >>> performance. The current mechanism of kicking the guest and or
block
> >>> backend is not always clear.  [TODO: Konrad to explain it in
details]
> > 
> > Oh, I never did explain this - but I think the patches that Daniel
came
> > up with actually fix a part of it. They make the kick-the-other guest
> > only happen when the backend has processed all of the requests and
> > cannot find anything else to do. Previously it was more of 'done
one
> > request, lets kick the backend.'.
> 
> Yes, that's what I'm seeing in the current code.
> 
> > But going forward, this 'kick-the-other-guest' could be
further modulated.
> > If we have a full ring and the frontend keeps on adding entries we
(backend)
> > should never get an interrupt. As of matter of fact the frontend
should be just
> > polling all the time and process them as fast as possible.
> 
> Yes, we could switch to polling in both ends and only "kick" when
the
> ring is full (which should not happen usually), this will probably
> reduce CPU utilization, but I doubt it's going to increase the
throughput.
It might on the frontend as it won't be interrupted so often. But then
with indirect requests that is going to lower the amount of kicks per I/O
we will do too. Sounds like this is something that can be done in the future
at a lower priority.
> 
> > Or we could add tweaks in the backend to adopt an 'adaptive
interrupt
> > coelescing' mechanism. This way we only kick the frontend if a
certain
> > threshold of I/Os have been processed or if we are slowing down on the
> > threshold. Again, the idea is that - if we have the rings full we
should
> > not send 'kicks' at all and just keep on processing.
> > 
> > Note: I *believe* that the backend does this - keeps on processing and
> > won't kick if the ring is full. But I am not 100% sure on the
frontend side.
> 
> Changing this is not really difficult (in my opinion, but I've might be
> wrong), so I think we could try several approaches and see which one
> gives better performance (or reduces CPU utilization).
> 
> Anyway, I would focus now on the indirect descriptors and separate the
> rings, and leave this work for afterwards (because what we could
> probably see now might not be true once the other improvements are done).
<nods>
> 
> >>>
> >>>
> >>> F). The current block protocol for big I/Os that the backend
devices can
> >>> handle ends up doing extra work by splitting the I/O in
smaller chunks,
> >>> and then reassembling them. With the solutions outlined in A)
this can
> >>> be fixed. This is easily seen with 1MB I/Os. Since each
request can
> >>> only handle 44kB that means we have to split a 1MB I/O in 24
requests
> >>> (23 * 4096 * 11 = 1081344). Then the backend ends up sending
them in
> >>> sector-sizes- which with contemporary devices (such as SSD)
ends up with
> >>> more processing. The SSDs are comfortable handling 128kB or
higher I/Os
> >>> in one go.
> >>>
> >>>
> >>> G). DIF/DIX. This a protocol to carry extra ‘checksum’
information
> >>> for each I/O. The I/O can be a sector size, page-size or an
I/O size
> >>> (most popular are 1MB). The DIF/DIX needs 8 bytes of
information for
> >>> each I/O. It would be worth considering putting/reserving that
amount of
> >>> space in each request/response. Also putting in extra flags
for future
> >>> extensions would be worth it - however the author is not aware
of any
> >>> right now.
> >>>
> >>>
> >>> H). Separate response/request. Potentially even multi-queue
per-VCPU
> >>> queues. As v2.6.37 demonstrated, the idea of WRITE_BARRIER was
> >>> flawed. There is no similar concept in the storage world were
the
> >>> operating system can put a food down and say: “everything
before this
> >>> has to be on the disk.” There are ligther versions of this -
called
> >>> ‘FUA’ and ‘FLUSH’. Depending on the internal implementation
> >>> of the storage they are either ignored or do the right thing.
The
> >>> filesystems determine the viability of these flags and change
writing
> >>> tactics depending on this. From a protocol level, this means
that the
> >>> WRITE/READ/SYNC requests can be intermixed - the storage by
itself
> >>> determines the order of the operation. The filesystem is the
one that
> >>> determines whether the WRITE should be with a FLUSH to
preserve some form
> >>> of atomicity. This means we do not have to preserve an order
of operations
> >>> - so we can have multiple queues for request and responses.
This has
> >>> show in the network world to improve performance considerably.
> >>>
> >>>
> >>> I). Wastage of response/request on the same ring. Currently
each response
> >>> MUST occupy the same amount of space that the request occupies
- as the
> >>> ring can have both responses and requests. Separating the
request and
> >>> response ring would remove the wastage.
> >>>
> >>>
> >>> J). 32-bit vs 64-bit (or 102 bytes vs 112 bytes). The size of
the ring
> >>> entries is different if the guest is in 32-bit or 64-bit mode.
Cleaning
> >>> this up to be the same size would save considerable accounting
that the
> >>> host has to do (extra memcpy for each response/request).
> >>
> >> So forth I think most of the problems could be solved by using
indirect
> >> descriptors, aligning requests to a cache sensible value (to
prevent
> >> straddling) and using separate rings for requests and responses.
This
> >> would be my plan for solving this issues:
> > 
> > That would take care of the bulk of the big issues.
> > 
> >>
> >> 1. Implement LRU mechanism in blkback for the persistent grants
list. If
> >> we are going to increment the number of in-flight IO we need to be
able to
> >> keep the list of persistently mapped grants to something sensible,
and
> >> we are no longer able to persistently map all the grants that
could be
> >> used. In my proposal that would be 64 * 4 for each grant frame
that
> > 
> > Can you explain the foundations behind the '64' and
'4'? I think I know
> > the 4 (BLKIF_..SEGMENTS) but I am not sure about '64'.
> 
> The 4 comes because in my proposal I'm passing 4 indirect grant frames
> filled with blkif_request_segment (so gref in blkif_request_indirect is
> now an array).
> 
> The 64 comes because I've reduced the size of blkif_request to 32bytes,
> so now we can fit 64 blkif_requests in a ring.
You could fit more of them with a 32-bytes request. You have 64 bytes for
the header and then 126 32-byte chunks of space free.
> 
> Putting it all together:
> 
> 4 (indirect grant frames) * 256 (entries in each indirect grant frame) *
> 4096 (PAGE_SIZE) = 4M IO in a single request
> 
> 64 (32bytes entries in a ring) * 4M (max IO in each entry) = 256M worth
> of IO in a 4096bytes ring.
s/64/126/ I believe?
> 
> >> contains indirect entries, plus 64 * 4 * 256, for all the possible
> >> entries in the indirect frame 64 * 4 + 64 * 4 * 256 = 65792.
> > 
> > That would cover ~256MB of data per guest. Wow.
> >>
> >> 2. Implement indirect descriptors.
> >>
> >> 3. Implement new ring protocol, using two separate rings for
requests
> >> and replies.
> > 
> > Don't want to negotiate each of these proposal as a seperate
feature? So:
> >         seperate-req-and-rsp
> >         slim-version-of-req
> >         indiret-descriptor
> >         multi-page-ring
> >         aligment-64-or-other-value
> 
> Yes, but I will try to couple them in a way that makes sense, for
> example reducing the size of blkif_request without using indirect
> descriptors doesn't make much sense, so I would couple
> indirect-descriptor with slim-version-of-req, this will leave us with
> the following new extensions:
> 
> indirect-descriptors (which includes a slim version of blkif_request)
> separate-req-and-rsp
> 
> This will be the two first extensions we should try to implement from my
> POV, because I think they are going to deliver quite a performance boost.
<nods>
> 
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
http://lists.xen.org/xen-devel

On Tue, 2013-01-22 at 19:25 +0000, Konrad Rzeszutek Wilk
wrote:
> On Mon, Jan 21, 2013 at 12:37:18PM +0000, Ian Campbell wrote:
> > On Fri, 2013-01-18 at 18:20 +0000, Konrad Rzeszutek Wilk wrote:
> > > 
> > > > > E). The network stack has showed that going in a
polling mode does improve
> > > > > performance. The current mechanism of kicking the guest
and or block
> > > > > backend is not always clear.  [TODO: Konrad to explain
it in details]
> > > 
> > > Oh, I never did explain this - but I think the patches that
Daniel came
> > > up with actually fix a part of it. They make the kick-the-other
guest
> > > only happen when the backend has processed all of the requests
and
> > > cannot find anything else to do. Previously it was more of
''done one
> > > request, lets kick the backend.''.
> > 
> > blkback uses RING_PUSH_RESPONSES_AND_CHECK_NOTIFY so doesn''t
it get some
> > amount of evthcn mitigation for free?
> 
> So there are two paths here - the kick from a) frontend and the kick b)
backend
> gives the frontend.
> 
> The a) case is fairly straighforward. We process all of the rings we and
everytime
> we have finished with a request we re-read the producer. So if the frontend
keeps
> us bussy we will keep on processing.
> 
> The b) case is the one that is trigger happy. Every time a request is
completed (so
> say 44kB of data has finally been read/written) we kick the frontend.
>  In the networking world there are mechanism to modify the hardware were it
would
> kick the OS (so frontend in our case) when it has processed 8, 16, or 64
packets
> (or some other value). Depending on the latency this can be bad or good. If
the
> backend is using a very slow disk we would probably want the frontend to be
> kicked every time a response has been completed.
Perhaps all that is needed is to have the f.e. set rsp_event to
min(rsp_cons + <BATCH_SIZE>, rsp_prod (+/- 1?) ) in blkfront''s
RING_FINAL_CHECK_FOR_RESPONSES to implement batching, like the comment
in ring.h says:
 *  These macros will set the req_event/rsp_event field to trigger a
 *  notification on the very next message that is enqueued. If you want to
 *  create batches of work (i.e., only receive a notification after several
 *  messages have been enqueued) then you will need to create a customised
 *  version of the FINAL_CHECK macro in your own code, which sets the event
 *  field appropriately.

IOW I think we already have the mechanisms in the protocol to implement
this sort of thing.
> 
> But if we have a very fast SSD, we might want to batch those kicks up so
> that the frontend does not get kicked that often. I don''t know the
impact
> of these ''one request = one kick'' is but we could make
this a bit more
> adaptive - so that it starts scalling down the kicks as it has more
responses.
> And if there are less responses it notches up the amount of kicks.
> I think this is called adaptive interrupt moderation (Or interrupt
coalescing)
> 
> > 
> > > But going forward, this ''kick-the-other-guest''
could be further modulated.
> > > If we have a full ring and the frontend keeps on adding entries
we (backend)
> > > should never get an interrupt. As of matter of fact the frontend
should be just
> > > polling all the time and process them as fast as possible.
> > 
> > I think the existing req_event/rsp_event ring fields should enable
this
> > already, assuming the front- and back-ends are using them right.
> > 
> > Ian.
> >

On Tue, 2013-01-22 at 19:46 +0000, Konrad Rzeszutek Wilk
wrote:
> Correct. In your case we have one cacheline shared by two requests.
> 
> This means we will have to be extra careful in the backend (And frontend)
> to call ''wmb()'' after we have filled two entries.
Otherwise we up doing
> something like this:
> 
>         fill out the req[0]
>         a) wmb()   => writes the full 64-bytes cacheline out.
>         fill out the req[1]
>         b) wmb()        <== has to throw out the cacheline and re-write
the new
>                     one.
> 
> With a 64-bytes one we do not have to worry about that.
... unless your cachelines are 128- or 256-bytes...

Short answer: the existing ring.h macros take care of this for you.

Long answer: The RING_PUSH_{REQUESTS,RESPONSES} handle this by only
issuing the wmb() over the entire current batch of things, not each time
you queue something. i.e. you can queue requests, modifying req_prod_pvt
as you go and then at the end of a suitable batch you call
RING_PUSH_REQUESTS which updates req_prod and does the barriers so you
end up with
	fill out the req[0]
	rsp_prod_pvt = 0
	fill out the req[1]
	rsp_prod_pvt = 1
	fill out the req[2]
	rsp_prod_pvt = 2
	Batch Done => RING_PUSH_REQUESTS
	wmb()
	rsp_prod = rsp_prod_pvt

The last req might cross a cache line but if you are at the end of a
batch how much does that matter? I suppose you could push a nop request
or something to align if it was an issue.

Maybe you don''t get this behaviour if you are batching effectively
though? Solve the batching problem and you solve the cacheline thing
basically for free though.
> > > Naturally this means we need to negotiate a
''feature-request-size''
> > > where v1 says that the request is of 64-bytes length.
Have you consider variable length requests? This would let the request
size scale with the number of segments required for that request, and
allow you to cache align the ends of the requests without wasting the
extra space that including the worst case number of segments would
imply. e.g. a small write would take 32-bytes (padded to 64 if you must)
and a larger one would take 196 (padded to 256). You should end up with
more efficient use of the space in the ring this way.

This also allows for other things like inlining requests (maybe more
interesting for net than blk) or including DIX requests without
incurring the overhead of however many bytes that is on every request.

I''d really like it if the result of this conversation could be a new
generic ring structure that was applicable to at least net and blk
rather than a new blk specific protocol.

Ian.

On Wed, Jan 23, 2013 at 09:24:37AM +0000, Ian Campbell
wrote:
> On Tue, 2013-01-22 at 19:25 +0000, Konrad Rzeszutek Wilk wrote:
> > On Mon, Jan 21, 2013 at 12:37:18PM +0000, Ian Campbell wrote:
> > > On Fri, 2013-01-18 at 18:20 +0000, Konrad Rzeszutek Wilk wrote:
> > > > 
> > > > > > E). The network stack has showed that going in a
polling mode does improve
> > > > > > performance. The current mechanism of kicking the
guest and or block
> > > > > > backend is not always clear.  [TODO: Konrad to
explain it in details]
> > > > 
> > > > Oh, I never did explain this - but I think the patches that
Daniel came
> > > > up with actually fix a part of it. They make the
kick-the-other guest
> > > > only happen when the backend has processed all of the
requests and
> > > > cannot find anything else to do. Previously it was more of
''done one
> > > > request, lets kick the backend.''.
> > > 
> > > blkback uses RING_PUSH_RESPONSES_AND_CHECK_NOTIFY so
doesn''t it get some
> > > amount of evthcn mitigation for free?
> > 
> > So there are two paths here - the kick from a) frontend and the kick
b) backend
> > gives the frontend.
> > 
> > The a) case is fairly straighforward. We process all of the rings we
and everytime
> > we have finished with a request we re-read the producer. So if the
frontend keeps
> > us bussy we will keep on processing.
> > 
> > The b) case is the one that is trigger happy. Every time a request is
completed (so
> > say 44kB of data has finally been read/written) we kick the frontend.
> >  In the networking world there are mechanism to modify the hardware
were it would
> > kick the OS (so frontend in our case) when it has processed 8, 16, or
64 packets
> > (or some other value). Depending on the latency this can be bad or
good. If the
> > backend is using a very slow disk we would probably want the frontend
to be
> > kicked every time a response has been completed.
> 
> Perhaps all that is needed is to have the f.e. set rsp_event to
> min(rsp_cons + <BATCH_SIZE>, rsp_prod (+/- 1?) ) in
blkfront''s
> RING_FINAL_CHECK_FOR_RESPONSES to implement batching, like the comment
> in ring.h says:
>  *  These macros will set the req_event/rsp_event field to trigger a
>  *  notification on the very next message that is enqueued. If you want to
>  *  create batches of work (i.e., only receive a notification after several
>  *  messages have been enqueued) then you will need to create a customised
>  *  version of the FINAL_CHECK macro in your own code, which sets the event
>  *  field appropriately.
> 
> IOW I think we already have the mechanisms in the protocol to implement
> this sort of thing.
Yes. It is question of how does the frontend and backend negotiate this.
As in should there be an negotiation of this value, say
''feature-intr-batch''.

On Wed, Jan 23, 2013 at 09:53:14AM +0000, Ian Campbell
wrote:
> On Tue, 2013-01-22 at 19:46 +0000, Konrad Rzeszutek Wilk wrote:
> > Correct. In your case we have one cacheline shared by two requests.
> > 
> > This means we will have to be extra careful in the backend (And
frontend)
> > to call ''wmb()'' after we have filled two entries.
Otherwise we up doing
> > something like this:
> > 
> >         fill out the req[0]
> >         a) wmb()   => writes the full 64-bytes cacheline out.
> >         fill out the req[1]
> >         b) wmb()        <== has to throw out the cacheline and
re-write the new
> >                     one.
> > 
> > With a 64-bytes one we do not have to worry about that.
> 
> ... unless your cachelines are 128- or 256-bytes...
> 
> Short answer: the existing ring.h macros take care of this for you.
Nice.
> 
> Long answer: The RING_PUSH_{REQUESTS,RESPONSES} handle this by only
> issuing the wmb() over the entire current batch of things, not each time
> you queue something. i.e. you can queue requests, modifying req_prod_pvt
> as you go and then at the end of a suitable batch you call
> RING_PUSH_REQUESTS which updates req_prod and does the barriers so you
> end up with
> 	fill out the req[0]
> 	rsp_prod_pvt = 0
> 	fill out the req[1]
> 	rsp_prod_pvt = 1
> 	fill out the req[2]
> 	rsp_prod_pvt = 2
> 	Batch Done => RING_PUSH_REQUESTS
> 	wmb()
> 	rsp_prod = rsp_prod_pvt
> 
> The last req might cross a cache line but if you are at the end of a
> batch how much does that matter? I suppose you could push a nop request
> or something to align if it was an issue.
Oh, NOP. That is an idea.
> 
> Maybe you don''t get this behaviour if you are batching effectively
> though? Solve the batching problem and you solve the cacheline thing
> basically for free though.
Right. And looking at the code it actually does this.
> 
> > > > Naturally this means we need to negotiate a
''feature-request-size''
> > > > where v1 says that the request is of 64-bytes length.
> 
> Have you consider variable length requests? This would let the request
> size scale with the number of segments required for that request, and
> allow you to cache align the ends of the requests without wasting the
> extra space that including the worst case number of segments would
> imply. e.g. a small write would take 32-bytes (padded to 64 if you must)
> and a larger one would take 196 (padded to 256). You should end up with
> more efficient use of the space in the ring this way.
Yes. If I recall right, the D) had it as "we could negotiate a proper
alignment for
each request/response structure.". The idea is pretty much the same as
yours
- pad to the cacheline if the cacheline is bigger than the request or response.
> 
> This also allows for other things like inlining requests (maybe more
> interesting for net than blk) or including DIX requests without
> incurring the overhead of however many bytes that is on every request.
> 
> I''d really like it if the result of this conversation could be a
new
> generic ring structure that was applicable to at least net and blk
> rather than a new blk specific protocol.
> 
> Ian.
> 
> 
> _______________________________________________
> Xen-devel mailing list
> Xen-devel@lists.xen.org
> http://lists.xen.org/xen-devel
>

On Wed, 2013-01-23 at 15:03 +0000, Konrad Rzeszutek Wilk
wrote:
> On Wed, Jan 23, 2013 at 09:24:37AM +0000, Ian Campbell wrote:
> > On Tue, 2013-01-22 at 19:25 +0000, Konrad Rzeszutek Wilk wrote:
> > > On Mon, Jan 21, 2013 at 12:37:18PM +0000, Ian Campbell wrote:
> > > > On Fri, 2013-01-18 at 18:20 +0000, Konrad Rzeszutek Wilk
wrote:
> > > > > 
> > > > > > > E). The network stack has showed that going
in a polling mode does improve
> > > > > > > performance. The current mechanism of kicking
the guest and or block
> > > > > > > backend is not always clear.  [TODO: Konrad
to explain it in details]
> > > > > 
> > > > > Oh, I never did explain this - but I think the patches
that Daniel came
> > > > > up with actually fix a part of it. They make the
kick-the-other guest
> > > > > only happen when the backend has processed all of the
requests and
> > > > > cannot find anything else to do. Previously it was more
of ''done one
> > > > > request, lets kick the backend.''.
> > > > 
> > > > blkback uses RING_PUSH_RESPONSES_AND_CHECK_NOTIFY so
doesn''t it get some
> > > > amount of evthcn mitigation for free?
> > > 
> > > So there are two paths here - the kick from a) frontend and the
kick b) backend
> > > gives the frontend.
> > > 
> > > The a) case is fairly straighforward. We process all of the rings
we and everytime
> > > we have finished with a request we re-read the producer. So if
the frontend keeps
> > > us bussy we will keep on processing.
> > > 
> > > The b) case is the one that is trigger happy. Every time a
request is completed (so
> > > say 44kB of data has finally been read/written) we kick the
frontend.
> > >  In the networking world there are mechanism to modify the
hardware were it would
> > > kick the OS (so frontend in our case) when it has processed 8,
16, or 64 packets
> > > (or some other value). Depending on the latency this can be bad
or good. If the
> > > backend is using a very slow disk we would probably want the
frontend to be
> > > kicked every time a response has been completed.
> > 
> > Perhaps all that is needed is to have the f.e. set rsp_event to
> > min(rsp_cons + <BATCH_SIZE>, rsp_prod (+/- 1?) ) in
blkfront''s
> > RING_FINAL_CHECK_FOR_RESPONSES to implement batching, like the comment
> > in ring.h says:
> >  *  These macros will set the req_event/rsp_event field to trigger a
> >  *  notification on the very next message that is enqueued. If you
want to
> >  *  create batches of work (i.e., only receive a notification after
several
> >  *  messages have been enqueued) then you will need to create a
customised
> >  *  version of the FINAL_CHECK macro in your own code, which sets the
event
> >  *  field appropriately.
> > 
> > IOW I think we already have the mechanisms in the protocol to
implement
> > this sort of thing.
> 
> Yes. It is question of how does the frontend and backend negotiate this.
> As in should there be an negotiation of this value, say
''feature-intr-batch''.
Either end can independently implement this using the existing
mechanisms, for their "direction", can''t they? No need to
negotiate.

Ian.

On Wed, 2013-01-23 at 15:21 +0000, Konrad Rzeszutek Wilk
wrote:
> > Have you consider variable length requests? This would let the request
> > size scale with the number of segments required for that request, and
> > allow you to cache align the ends of the requests without wasting the
> > extra space that including the worst case number of segments would
> > imply. e.g. a small write would take 32-bytes (padded to 64 if you
must)
> > and a larger one would take 196 (padded to 256). You should end up
with
> > more efficient use of the space in the ring this way.
> 
> Yes. If I recall right, the D) had it as "we could negotiate a proper
alignment for
> each request/response structure.". The idea is pretty much the same as
yours
> - pad to the cacheline if the cacheline is bigger than the request or
response.
It would be interesting to know whether it is cache line bouncing or
smaller ring capacity (which padding reduces) which becomes the
bottleneck.

My money is, unhelpfully, on "both, depending on workload".

On Wed, Jan 23, 2013 at 03:39:59PM +0000, Ian Campbell
wrote:
> On Wed, 2013-01-23 at 15:03 +0000, Konrad Rzeszutek Wilk wrote:
> > On Wed, Jan 23, 2013 at 09:24:37AM +0000, Ian Campbell wrote:
> > > On Tue, 2013-01-22 at 19:25 +0000, Konrad Rzeszutek Wilk wrote:
> > > > On Mon, Jan 21, 2013 at 12:37:18PM +0000, Ian Campbell
wrote:
> > > > > On Fri, 2013-01-18 at 18:20 +0000, Konrad Rzeszutek
Wilk wrote:
> > > > > > 
> > > > > > > > E). The network stack has showed that
going in a polling mode does improve
> > > > > > > > performance. The current mechanism of
kicking the guest and or block
> > > > > > > > backend is not always clear.  [TODO:
Konrad to explain it in details]
> > > > > > 
> > > > > > Oh, I never did explain this - but I think the
patches that Daniel came
> > > > > > up with actually fix a part of it. They make the
kick-the-other guest
> > > > > > only happen when the backend has processed all of
the requests and
> > > > > > cannot find anything else to do. Previously it was
more of ''done one
> > > > > > request, lets kick the backend.''.
> > > > > 
> > > > > blkback uses RING_PUSH_RESPONSES_AND_CHECK_NOTIFY so
doesn''t it get some
> > > > > amount of evthcn mitigation for free?
> > > > 
> > > > So there are two paths here - the kick from a) frontend and
the kick b) backend
> > > > gives the frontend.
> > > > 
> > > > The a) case is fairly straighforward. We process all of the
rings we and everytime
> > > > we have finished with a request we re-read the producer. So
if the frontend keeps
> > > > us bussy we will keep on processing.
> > > > 
> > > > The b) case is the one that is trigger happy. Every time a
request is completed (so
> > > > say 44kB of data has finally been read/written) we kick the
frontend.
> > > >  In the networking world there are mechanism to modify the
hardware were it would
> > > > kick the OS (so frontend in our case) when it has processed
8, 16, or 64 packets
> > > > (or some other value). Depending on the latency this can be
bad or good. If the
> > > > backend is using a very slow disk we would probably want the
frontend to be
> > > > kicked every time a response has been completed.
> > > 
> > > Perhaps all that is needed is to have the f.e. set rsp_event to
> > > min(rsp_cons + <BATCH_SIZE>, rsp_prod (+/- 1?) ) in
blkfront''s
> > > RING_FINAL_CHECK_FOR_RESPONSES to implement batching, like the
comment
> > > in ring.h says:
> > >  *  These macros will set the req_event/rsp_event field to
trigger a
> > >  *  notification on the very next message that is enqueued. If
you want to
> > >  *  create batches of work (i.e., only receive a notification
after several
> > >  *  messages have been enqueued) then you will need to create a
customised
> > >  *  version of the FINAL_CHECK macro in your own code, which sets
the event
> > >  *  field appropriately.
> > > 
> > > IOW I think we already have the mechanisms in the protocol to
implement
> > > this sort of thing.
> > 
> > Yes. It is question of how does the frontend and backend negotiate
this.
> > As in should there be an negotiation of this value, say
''feature-intr-batch''.
> 
> Either end can independently implement this using the existing
> mechanisms, for their "direction", can''t they? No need
to negotiate.
I think that is feasible. I am just worried that some backends (or frontends)
will choke if the "normal" one payload = one interrupt is not
happening. Hence
this new feature so that we don''t have to worry about the old drivers.
But maybe
I am being to paranoid and it all would work just great.

On Wed, Jan 23, 2013 at 03:41:17PM +0000, Ian Campbell
wrote:
> On Wed, 2013-01-23 at 15:21 +0000, Konrad Rzeszutek Wilk wrote:
> > > Have you consider variable length requests? This would let the
request
> > > size scale with the number of segments required for that request,
and
> > > allow you to cache align the ends of the requests without wasting
the
> > > extra space that including the worst case number of segments
would
> > > imply. e.g. a small write would take 32-bytes (padded to 64 if
you must)
> > > and a larger one would take 196 (padded to 256). You should end
up with
> > > more efficient use of the space in the ring this way.
> > 
> > Yes. If I recall right, the D) had it as "we could negotiate a
proper alignment for
> > each request/response structure.". The idea is pretty much the
same as yours
> > - pad to the cacheline if the cacheline is bigger than the request or
response.
> 
> It would be interesting to know whether it is cache line bouncing or
> smaller ring capacity (which padding reduces) which becomes the
> bottleneck.
> 
> My money is, unhelpfully, on "both, depending on workload".
and on the guest pCPU distribution potentially. The one workload I''ve
been
doing is to stick guests on different sockets and also turning
hardware prefetching off (and also Turbo Mode for good measure).

This way it is the worst of the worlds - but it can provide me with the
data whether this cache issue is a problem or not.
> 
> 
> 
> _______________________________________________
> Xen-devel mailing list
> Xen-devel@lists.xen.org
> http://lists.xen.org/xen-devel
>

On Wed, 2013-01-23 at 16:59 +0000, Konrad Rzeszutek Wilk
wrote:
> On Wed, Jan 23, 2013 at 03:41:17PM +0000, Ian Campbell wrote:
> > On Wed, 2013-01-23 at 15:21 +0000, Konrad Rzeszutek Wilk wrote:
> > > > Have you consider variable length requests? This would let
the request
> > > > size scale with the number of segments required for that
request, and
> > > > allow you to cache align the ends of the requests without
wasting the
> > > > extra space that including the worst case number of segments
would
> > > > imply. e.g. a small write would take 32-bytes (padded to 64
if you must)
> > > > and a larger one would take 196 (padded to 256). You should
end up with
> > > > more efficient use of the space in the ring this way.
> > > 
> > > Yes. If I recall right, the D) had it as "we could negotiate
a proper alignment for
> > > each request/response structure.". The idea is pretty much
the same as yours
> > > - pad to the cacheline if the cacheline is bigger than the
request or response.
> > 
> > It would be interesting to know whether it is cache line bouncing or
> > smaller ring capacity (which padding reduces) which becomes the
> > bottleneck.
> > 
> > My money is, unhelpfully, on "both, depending on workload".
> 
> and on the guest pCPU distribution potentially. The one workload
I''ve been
> doing is to stick guests on different sockets and also turning
> hardware prefetching off (and also Turbo Mode for good measure).
This last two are constructing a rather artificial scenario though
aren''t they?
> This way it is the worst of the worlds - but it can provide me with the
> data whether this cache issue is a problem or not.
> 
> > 
> > 
> > 
> > _______________________________________________
> > Xen-devel mailing list
> > Xen-devel@lists.xen.org
> > http://lists.xen.org/xen-devel
> >

On Thu, Jan 24, 2013 at 10:06:56AM +0000, Ian Campbell
wrote:
> On Wed, 2013-01-23 at 16:59 +0000, Konrad Rzeszutek Wilk wrote:
> > On Wed, Jan 23, 2013 at 03:41:17PM +0000, Ian Campbell wrote:
> > > On Wed, 2013-01-23 at 15:21 +0000, Konrad Rzeszutek Wilk wrote:
> > > > > Have you consider variable length requests? This would
let the request
> > > > > size scale with the number of segments required for
that request, and
> > > > > allow you to cache align the ends of the requests
without wasting the
> > > > > extra space that including the worst case number of
segments would
> > > > > imply. e.g. a small write would take 32-bytes (padded
to 64 if you must)
> > > > > and a larger one would take 196 (padded to 256). You
should end up with
> > > > > more efficient use of the space in the ring this way.
> > > > 
> > > > Yes. If I recall right, the D) had it as "we could
negotiate a proper alignment for
> > > > each request/response structure.". The idea is pretty
much the same as yours
> > > > - pad to the cacheline if the cacheline is bigger than the
request or response.
> > > 
> > > It would be interesting to know whether it is cache line bouncing
or
> > > smaller ring capacity (which padding reduces) which becomes the
> > > bottleneck.
> > > 
> > > My money is, unhelpfully, on "both, depending on
workload".
> > 
> > and on the guest pCPU distribution potentially. The one workload
I''ve been
> > doing is to stick guests on different sockets and also turning
> > hardware prefetching off (and also Turbo Mode for good measure).
> 
> This last two are constructing a rather artificial scenario though
> aren''t they?
Yes. But they give a great insight on the cache issues.
> 
> > This way it is the worst of the worlds - but it can provide me with
the
> > data whether this cache issue is a problem or not.
> > 
> > > 
> > > 
> > > 
> > > _______________________________________________
> > > Xen-devel mailing list
> > > Xen-devel@lists.xen.org
> > > http://lists.xen.org/xen-devel
> > > 
> 
>

> > > Which has a nice power of two ring to it. (Ah the puns!)
> > > 
> > > I like the idea of putting the request on a diet - but too much
> > > could cause us to miss the opportunity to insert other flags on
it.
> > > If I recall correctly, the DIF/DIX only need 8 bytes of data.
> > > If we make the assumption that:
> > >         I/O request = one ring entry
> > 
> > So we only need to reserve 8bytes for each DIF/IDX, even if the
request
> > contains a variable number of data? (I mean, block requests can at a
> > minimum contain 4096bytes, or much more)
> 
> I need to double check with Martin (CC-ed here). But my recollection
> is that it is just attached the the 'bio'. So if the BIO is 4K or
1MB -
> it would only have one DIF/DIX data type.
And that is semi-correct. If the user did a horrible job (say using
dd) the pages are chained together - and we end up with a link list
of bio's. The last bio would point to a page filled with 'sector's
worth
of data has a checksum. Each checksum occupies 8 bytes. So if the
total 'bio' length is say 1MB, this last page is filled with 256 of
checksums - so 2048 bytes of data.
> 
> Hmm, but then we operate on the 'struct request' so that might not
> be the case..
> > 
> > > and the  "one ring entry" can use the the '4'
grants if we just have a
> > > 16KB I/O request, but if it is more than that - we use the
indirect page
> > 
> > Well, on my purpose I've limited the number of segments of a
"rw"
> > requests to 2, so it's only 8K, anything bigger has to use
indirect
> > descriptors, which can fit 4M of data (because I'm passing 4 grant
> > frames full of "blkif_request_indirect_entry" entries).
> 
> <nods>
> > 
> > > and can stuff 1MB of data in there.
> > > The extra 32-bytes of space for such things as 'DIF/DIX'.
This also
> > > means we could unify the 'struct request' with the
'discard' operation
> > > and it could utilize the 32-bytes of extra unused payload data.
> > > 
> > >>>
> > >>>
> > >>> The ‘operation’ would be BLKIF_OP_INDIRECT. The
read/write/discard,
> > >>> etc operation would now be in indirect.op. The
indirect.gref points to
> > >>> a page that is filled with:
> > >>>
> > >>>
> > >>> struct blkif_request_indirect_entry {
> > >>>         blkif_sector_t sector_number;
> > >>>         struct blkif_request_segment seg;
> > >>> } __attribute__((__packed__));
> > >>> //16 bytes, so we can fit in a page 256 of these
structures.
> > >>>
> > >>>
> > >>> This means that with the existing 36 slots in the ring
(single page)
> > >>> we can cover: 32 slots * each blkif_request_indirect
covers: 256 * 4096
> > >>> ~= 32M. If we don’t want to use indirect descriptor we
can still use
> > >>> up to 4 pages of the request (as it has enough space to
contain four
> > >>> segments and the structure will still be cache-aligned).
> > >>>

Martin asked me why we even do this via these entries. Meaning why
have this tuple of information for each page: <lba, first_sect, last_sect,
gref>.
The lba on the next subsequent indirect entry is going to be incremented by
one. The first_sect and last_sect too... So why not just do:

struct blkif_request_indirect {
        uint8_t        operation;
        blkif_vdev_t   handle;       /* only for read/write requests         */
#ifdef CONFIG_X86_64
        uint32_t       _pad1;        /* offsetof(blkif_request,u.rw.id) == 8 */
#endif
        uint64_t       id;           /* private guest value, echoed in resp  */
        blkif_sector_t sector_number;/* start sector idx on disk (r/w only)  */

	grant_ref_t	indirect_desc;
	uint16_t	nr_elems;
}

And the 'indirect_desc' would point to a page that looks quite close to
what the scatterlist looks like:

	struct indirect_chain {
		uint16_t	op_flag;	//*Can D_NEXT, D_START, D_END ?
		uint16_t	next;
		uint16_t	offset;
		uint16_t	length;
		uint32_t	gref;
		uint32_t	_pad;		// Need this in case we ever want to
						// make gref + _pad be a physical addr.
	}

And the page itself would be:
	struct indirect_chain[256];

the 'next' would just contain the index inside in indirect_chain page -
so from
0->256.  The offset and length would reference wherein the page the data is
contained.

This way the 'lba' information is part of the
'blkif_request_indirect' and the
payload info is all in the indirect descriptors.

_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xen.org
http://lists.xen.org/xen-devel