Yeah, I think you get it. The 8 columns is just the layout of how they
decided to print the table. They are printing 8 entries per row.

- Alex

On Wed, Nov 22, 2017 at 9:43 AM, Michał Purzyński
<michalpurzyns...@gmail.com> wrote:
> Ah, so it's just the representation that's confusing!
>
>   352:      2     3     4     5     6     7     8     9
>   360:     10    11    12    13     0     1     2     3
>
> Core 9 corresponds to 359 indeed. Thanks for the explanation, I can see why.
>
>
>
> On Wed, Nov 22, 2017 at 6:39 PM, Michał Purzyński
> <michalpurzyns...@gmail.com> wrote:
>>
>> Thanks, it's almost clear now - one more thing. There seems to be 8
>> columns in this table. Let's say the lowest 9 bits of my hash are 8 decimal
>>
>> For 8 the table reads
>>
>>     8:      8     9    10    11    12    13     0     1
>>
>> The value 8 is an index into a table that yields a row - which of those
>> cores would be used? The packet could you go a core 8 or 9 or 12?
>>
>>
>> On Wed, Nov 22, 2017 at 5:55 PM, Alexander Duyck
>> <alexander.du...@gmail.com> wrote:
>>>
>>> Comments inline below.
>>>
>>> On Wed, Nov 22, 2017 at 8:23 AM, Michał Purzyński
>>> <michalpurzyns...@gmail.com> wrote:
>>> > Hello!
>>> >
>>> > How do I read the indirection table, then one that can be shown with
>>> > ethtool -x? What is the meaning of columns vs rows and what those
>>> > numbers
>>> > are trying to tell me? I'm guessing it's kind of like a weight, but I'm
>>> > not
>>> > sure how to understand it.
>>>
>>> So what the indirection table does is allow us to map bits from the
>>> RSS hash onto specific rings.
>>>
>>> So in the example you provided below there are 512 entries, this
>>> represents 9 bits. Those 9 bits appear to be mapped onto 14 queues
>>> based on the table you provided.
>>>
>>> So the easiest way to examine this would be to look at skb->hash that
>>> is being reported by the device in the case of flow director/ATR being
>>> disabled. What you should find is that if you mask the skb->hash by
>>> masking it with 511 (0x1FF) what you should find is that the number
>>> returned will give you the index into this table, and the packet
>>> itself should be received on the queue associated with that index.
>>>
>>> > RX flow hash indirection table for p3p1 with 14 RX ring(s):
>>> >
>>> >     0:      0     1     2     3     4     5     6     7
>>> >     8:      8     9    10    11    12    13     0     1
>>> >    16:      2     3     4     5     6     7     8     9
>>> >    24:     10    11    12    13     0     1     2     3
>>> >    32:      4     5     6     7     8     9    10    11
>>> >    40:     12    13     0     1     2     3     4     5
>>> >    48:      6     7     8     9    10    11    12    13
>>> >    56:      0     1     2     3     4     5     6     7
>>> >    64:      8     9    10    11    12    13     0     1
>>> >    72:      2     3     4     5     6     7     8     9
>>> >    80:     10    11    12    13     0     1     2     3
>>> >    88:      4     5     6     7     8     9    10    11
>>> >    96:     12    13     0     1     2     3     4     5
>>> >   104:      6     7     8     9    10    11    12    13
>>> >   112:      0     1     2     3     4     5     6     7
>>> >   120:      8     9    10    11    12    13     0     1
>>> >   128:      2     3     4     5     6     7     8     9
>>> >   136:     10    11    12    13     0     1     2     3
>>> >   144:      4     5     6     7     8     9    10    11
>>> >   152:     12    13     0     1     2     3     4     5
>>> >   160:      6     7     8     9    10    11    12    13
>>> >   168:      0     1     2     3     4     5     6     7
>>> >   176:      8     9    10    11    12    13     0     1
>>> >   184:      2     3     4     5     6     7     8     9
>>> >   192:     10    11    12    13     0     1     2     3
>>> >   200:      4     5     6     7     8     9    10    11
>>> >   208:     12    13     0     1     2     3     4     5
>>> >   216:      6     7     8     9    10    11    12    13
>>> >   224:      0     1     2     3     4     5     6     7
>>> >   232:      8     9    10    11    12    13     0     1
>>> >   240:      2     3     4     5     6     7     8     9
>>> >   248:     10    11    12    13     0     1     2     3
>>> >   256:      4     5     6     7     8     9    10    11
>>> >   264:     12    13     0     1     2     3     4     5
>>> >   272:      6     7     8     9    10    11    12    13
>>> >   280:      0     1     2     3     4     5     6     7
>>> >   288:      8     9    10    11    12    13     0     1
>>> >   296:      2     3     4     5     6     7     8     9
>>> >   304:     10    11    12    13     0     1     2     3
>>> >   312:      4     5     6     7     8     9    10    11
>>> >   320:     12    13     0     1     2     3     4     5
>>> >   328:      6     7     8     9    10    11    12    13
>>> >   336:      0     1     2     3     4     5     6     7
>>> >   344:      8     9    10    11    12    13     0     1
>>> >   352:      2     3     4     5     6     7     8     9
>>> >   360:     10    11    12    13     0     1     2     3
>>> >   368:      4     5     6     7     8     9    10    11
>>> >   376:     12    13     0     1     2     3     4     5
>>> >   384:      6     7     8     9    10    11    12    13
>>> >   392:      0     1     2     3     4     5     6     7
>>> >   400:      8     9    10    11    12    13     0     1
>>> >   408:      2     3     4     5     6     7     8     9
>>> >   416:     10    11    12    13     0     1     2     3
>>> >   424:      4     5     6     7     8     9    10    11
>>> >   432:     12    13     0     1     2     3     4     5
>>> >   440:      6     7     8     9    10    11    12    13
>>> >   448:      0     1     2     3     4     5     6     7
>>> >   456:      8     9    10    11    12    13     0     1
>>> >   464:      2     3     4     5     6     7     8     9
>>> >   472:     10    11    12    13     0     1     2     3
>>> >   480:      4     5     6     7     8     9    10    11
>>> >   488:     12    13     0     1     2     3     4     5
>>> >   496:      6     7     8     9    10    11    12    13
>>> >   504:      0     1     2     3     4     5     6     7
>>>
>>> So for example if I had an RSS hash that was something like 0x01234567
>>> and I masked the lower 9 bits I would get 0x167, which comes out as
>>> 359 decimal. As such I would expect the packet to be received on queue
>>> 9 based on the table provided here.
>>>
>>> I hope that helps to clarify how the indirection table is used.
>>>
>>> - Alex
>>
>>
>

------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most
engaging tech sites, Slashdot.org! http://sdm.link/slashdot
_______________________________________________
E1000-devel mailing list
E1000-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/e1000-devel
To learn more about Intel&#174; Ethernet, visit 
http://communities.intel.com/community/wired

Reply via email to