Date: Wed, 27 Jan 2016 12:14:02 +0200 From: Boris Astardzhiev <boris.astardzhiev@gmail.com> To: Kevin Oberman <rkoberman@gmail.com> Cc: Bruce Evans <brde@optusnet.com.au>, Gary Jennejohn <gljennjohn@gmail.com>, Daniel Eischen <deischen@freebsd.org>, threads@freebsd.org, Luigi Rizzo <rizzo@iet.unipi.it>, "freebsd-net@freebsd.org" <net@freebsd.org> Subject: Re: Does FreeBSD have sendmmsg or recvmmsg system calls? Message-ID: <CAP=KkTwEGVhKxSmZUDsq4hJ9K_nHrO9di1maS7zVn2CNX8TqAg@mail.gmail.com> In-Reply-To: <CAN6yY1snu5YkXbTTHku4OAE6UyoQ5ibyM79KgHUN2dzRgvXSuA@mail.gmail.com> References: <20160118140811.GW3942@kib.kiev.ua> <CAP=KkTzLCOnJVqt5F3ZuuZUiwkmWcne2Ynpi6-daE2jTzSBtfw@mail.gmail.com> <20160120073154.GB3942@kib.kiev.ua> <CAP=KkTx3dAUuSBrJiwNAAe%2BhHSG4j5Qp7sAcgtOgmVi8a12k1A@mail.gmail.com> <20160121093509.GK3942@kib.kiev.ua> <20160121233040.E1864@besplex.bde.org> <CAP=KkTw=ML=oPo2OgFfmor_nsL3om6HvmTQjKNMrOiU_dmWc2g@mail.gmail.com> <20160124050634.GS3942@kib.kiev.ua> <20160124100747.551f8e3f@ernst.home> <CAP=KkTyHG9Rb%2BnrDC1TDxzjUQFca9NkVp8Suo1c_-C00RUtkuQ@mail.gmail.com> <20160126134005.GD3942@kib.kiev.ua> <CA%2BhQ2%2BivWYJMDUwzdZGW88-mWzSVfPzX212sOFVmxxN0hpZ%2BQQ@mail.gmail.com> <20160126182543.64050678@ernst.home> <Pine.GSO.4.64.1601261743450.12995@sea.ntplx.net> <20160127013145.36f2aaef@ernst.home> <20160127132558.W985@besplex.bde.org> <CAN6yY1snu5YkXbTTHku4OAE6UyoQ5ibyM79KgHUN2dzRgvXSuA@mail.gmail.com>
next in thread | previous in thread | raw e-mail | index | archive | help
--089e01493c12b9cea1052a4e0f84
Content-Type: text/plain; charset=UTF-8
Hello,
I've made a few changes in the patch as recommended here starting with
the switch to ppoll(). I have a question since it's not quite clear to me
as written
in the manpage. Is it possible that ppoll() doesn't return an error and yet
revents
have set either POLLERR or POLLHUP or POLLNVAL?
See patch and comments are again welcomed.
On Wed, Jan 27, 2016 at 6:07 AM, Kevin Oberman <rkoberman@gmail.com> wrote:
> Since this has become a debate on programming style, it seem appropriate
> to mention that Edward Yourdan passed away last Tuesday. For those too
> young to recognize the name, he was the developer of modern structured
> programming. He did recognize the style rules are important, but not
> iron-clad.
>
> Kevin Oberman, Part time kid herder and retired Network Engineer
> E-mail: rkoberman@gmail.com
> PGP Fingerprint: D03FB98AFA78E3B78C1694B318AB39EF1B055683
>
> On Tue, Jan 26, 2016 at 7:04 PM, Bruce Evans <brde@optusnet.com.au> wrote:
>
>> On Wed, 27 Jan 2016, Gary Jennejohn wrote:
>>
>> On Tue, 26 Jan 2016 17:46:52 -0500 (EST)
>>> Daniel Eischen <deischen@freebsd.org> wrote:
>>>
>>> On Tue, 26 Jan 2016, Gary Jennejohn wrote:
>>>>
>>>> On Tue, 26 Jan 2016 09:06:39 -0800
>>>>> Luigi Rizzo <rizzo@iet.unipi.it> wrote:
>>>>>
>>>>> On Tue, Jan 26, 2016 at 5:40 AM, Konstantin Belousov
>>>>>> <kostikbel@gmail.com> wrote:
>>>>>>
>>>>>>> On Mon, Jan 25, 2016 at 11:22:13AM +0200, Boris Astardzhiev wrote:
>>>>>>>
>>>>>>>> +ssize_t
>>>>>>>> +recvmmsg(int s, struct mmsghdr *__restrict msgvec, size_t vlen,
>>>>>>>> int flags,
>>>>>>>> + const struct timespec *__restrict timeout)
>>>>>>>> +{
>>>>>>>> + size_t i, rcvd;
>>>>>>>> + ssize_t ret;
>>>>>>>> +
>>>>>>>> + if (timeout != NULL) {
>>>>>>>> + fd_set fds;
>>>>>>>> + int res;
>>>>>>>>
>>>>>>> Please move all local definitions to the beginning of the function.
>>>>>>>
>>>>>>
>>>>>> This style recommendation was from 30 years ago and is
>>>>>> bad programming practice, as it tends to complicate analysis
>>>>>> for the human and increase the chance of improper usage of
>>>>>> variables.
>>>>>>
>>>>>> We should move away from this for new code.
>>>>>>
>>>>>
>>>>> Really? I personally find having all variables grouped together
>>>>> much easier to understand. Stumbling across declarations in the
>>>>> middle of the code in a for-loop, for example, takes me by surprise.
>>>>>
>>>>
>> +1
>>
>> I used to program in a strict version of the "new" style 25-30 years
>> ago, but learned better. In the strict version, every variable must
>> have minimal scope, so squillions of inner blocks are needed to limit
>> the scopes. Some deeply nested of course. This is a good obfuscation.
>> It even breaks -Wshadow by letting you have unrelated variables named
>> 'i' that don't shadow each other because their scope is limited. Such
>> variables are good in separate functions but not in the same function.
>> Understanding the code to see that the variables are actually unrelated
>> requires counting more braces than usual. If you don't do this
>> strictly then you get a random style with some variables declared at
>> the top and some in inner blocks for mostly historical reasons. A
>> strict style with all of the variables at the top is much easier to
>> write and read.
>>
>> I also greatly dislike initializing variables in their declarations.
>>>>>
>>>>> Maybe I'm just old fashioned since I have been writing C-code for
>>>>> more than 30 years.
>>>>>
>>>>
>>>> +1
>>>>
>>>> Probably should be discouraged, but allowed on a case-by-case
>>>> basis. One could argue that if you need to declaration blocks
>>>> in the middle of code, then that code is too complex and should
>>>> be broken out into a separate function.
>>>>
>>>
>>> Right.
>>>
>>
>> Lots of inner blocks are good for both making simple code look complex
>> and making it easier to write the complex code in the same function,
>> at least if you use a tiny indentation so that you can have 40 levels
>> of indentation without needing a 500-column terminal.
>>
>> And code like this
>>>
>>> int func(void)
>>> {
>>> int baz, zot;
>>> [some more code]
>>> if (zot < 5)
>>> {
>>> int baz = 3;
>>> [more code]
>>> }
>>> [some more code]
>>> }
>>>
>>> is even worse. The compiler (clang) seems to consider this to
>>> merely be a reinitialization of baz, but a human might be confused.
>>>
>>
>> No, that is a different baz, and is warned about by Wshadow.
>>
>> Something like for (int i = 0; i < 2; i++) is IMHO OK.
>>>
>>
>> Except it is C++ style which is so forbidden that style(9) doesn't
>> know that it needs a rule to forbid it.
>>
>> The worst is C++ style that doesn't limit the scope -- a bunch of
>> variables at the top and then somewhere in the middle of the function
>> another variable is needed and it is declared at top level of the
>> function scope. I sometimes do this when in a hurry. The strict
>> K&R-C90 style requires opening an inner block to do little more than
>> hold the declaration and then (re)indenting and (re)formatting all
>> the code in the inner block. The C++ style reduces writability and
>> readability in a different way. It doesn't cause excessive indentation
>> but it doesn't limit the scope much differently than putting all the
>> declarations at the top. At least the reader can find the declarations
>> easily when they are at the top.
>>
>> Bruce
>>
>> _______________________________________________
>> freebsd-net@freebsd.org mailing list
>> https://lists.freebsd.org/mailman/listinfo/freebsd-net
>> To unsubscribe, send any mail to "freebsd-net-unsubscribe@freebsd.org"
>>
>
>
--089e01493c12b9cea1052a4e0f84
Content-Type: text/plain; charset=US-ASCII; name="sendrecvmmsg-libconly6.diff"
Content-Disposition: attachment; filename="sendrecvmmsg-libconly6.diff"
Content-Transfer-Encoding: base64
X-Attachment-Id: f_ijwo52uv0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--089e01493c12b9cea1052a4e0f84--
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?CAP=KkTwEGVhKxSmZUDsq4hJ9K_nHrO9di1maS7zVn2CNX8TqAg>