real-time print library
RFC PATCH 1/2 real-time print library
This is a stand-alone real-time library for printf services. It is embedded into the Xenomai user space part but actually doesn't depend on any Xenomai service, just using plain Linux POSIX.
The librtprint API looks much like the printf(3) man page:
rt_vfprintfrt_vprintfrt_fprintfrt_printf
Moreover it provides a few setup/cleanup services as you can grab from the code and the included example.
The basic idea of librtprint is to keep the print side as cheap as
possible: no locks, no syscalls at all. Each thread that uses rt_printf & friends has its own local ring buffer. A central (per process) non-RT output thread takes care of forwarding the content of all thread ring buffers to the output streams. The message order is preserved loosely by a global sequence counter (arch-dependent CPU-wide or system-wide atomic_inc_return might be used in the future). The output thread uses periodic polling (default: 10 Hz) to avoid the need for special signalling mechanisms.
Further features:
o Explicit or on-demand thread buffer creation
o Override of default buffer size and polling period via environment variables ("RT_PRINT_BUFFER" and "RT_PRINT_PERIOD")
o Support for buffer names (useful for the following patch e.g.)
o Target output stream can be specified for each print invocation
o Breaks all builds except for x86 (missing ubarrier.h headers) :o)
The code is stuffed into src/rtprint for now as patch 2/2 will need this lib to be built before the skin libraries. Better suggestions are welcome though.
Jan
--- configure.in | 1 examples/native/Makefile | 8 + examples/native/rtprint.c | 48 +++++++ include/Makefile.am | 5 include/asm-i386/Makefile.am | 2 include/asm-i386/ubarrier.h | 26 ++++ include/rtprint.h | 59 +++++++++ src/Makefile.am | 2 src/rtprint/Makefile.am | 12 + src/rtprint/api.c | 273 +++++++++++++++++++++++++++++++++++++++++++ src/rtprint/init.c | 75 +++++++++++ src/rtprint/internal.h | 69 ++++++++++ src/rtprint/output.c | 92 ++++++++++++++ 13 files changed, 669 insertions(+), 3 deletions(-)
configure.in +1 -0
@@ -611,6 +611,7 @@ AC_CONFIG_FILES([ \ scripts/xeno-load \ scripts/xeno-test \ src/Makefile \ + src/rtprint/Makefile \ src/skins/Makefile \ src/skins/posix/Makefile \ src/skins/native/Makefile \
examples/native/Makefile +7 -1
@@ -1,7 +1,7 @@ ###### CONFIGURATION ###### ### List of applications to be build -APPLICATIONS = trivial-periodic sigxcpu +APPLICATIONS = trivial-periodic sigxcpu rtprint ### Note: to override the search path for the xeno-config script, use "make XENO=..."
@@ -44,6 +44,12 @@ endif +###### SPECIAL TARGET RULES ###### +rtprint: rtprint.c + $(CC) $(CFLAGS) $? $(LDFLAGS) -lrtprint -o $@ + + + ###### KERNEL MODULE BUILD (no change required normally) ###### ifneq ($(MODULES),)
examples/native/rtprint.c new file +48 -0
48 lines not on this page · raw message
include/Makefile.am +5 -0
@@ -1,3 +1,8 @@ +includedir = $(prefix)/include + +include_HEADERS = \ + rtprint.h + nodist_include_HEADERS=$(CONFIG_HEADER) SUBDIRS = \
include/asm-i386/Makefile.am +1 -1
@@ -1,6 +1,6 @@ includedir = $(prefix)/include/asm-i386 include_HEADERS = atomic.h calibration.h features.h \ - hal.h smi.h syscall.h system.h wrappers.h fptest.h + hal.h smi.h syscall.h system.h wrappers.h fptest.h ubarrier.h SUBDIRS = bits
include/asm-i386/ubarrier.h new file +26 -0
@@ -0,0 +1,26 @@ +/* +* Copyright (C) 2007 Jan Kiszka <[email protected]>. +* +* Xenomai is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published +* by the Free Software Foundation; either version 2 of the License, +* or (at your option) any later version. +* +* Xenomai is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with Xenomai; if not, write to the Free Software +* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA +* 02111-1307, USA. +*/ + +#ifndef _XENO_ASM_I386_UBARRIER_H +#define _XENO_ASM_I386_UBARRIER_H + +#define rmb () __asm__ __volatile__ ("lock; addl $0,0(%%esp)": : :"memory") +#define wmb () __asm__ __volatile__ ("": : :"memory") + +#endif /* _XENO_ASM_I386_UBARRIER_H */
include/rtprint.h new file +59 -0
59 lines not on this page · raw message
src/Makefile.am +1 -1
@@ -1,2 +1,2 @@ -SUBDIRS = include skins testsuite utils +SUBDIRS = include rtprint skins testsuite utils
src/rtprint/Makefile.am new file +12 -0
@@ -0,0 +1,12 @@ +lib_LTLIBRARIES = librtprint.la + +librtprint_la_LDFLAGS = -version-info 0:0:0 -lpthread + +librtprint_la_SOURCES = \ + init.c \ + output.c \ + api.c + +librtprint_la_CPPFLAGS = \ + @XENO_USER_CFLAGS@ \ + -I$(top_srcdir)/include
src/rtprint/api.c new file +273 -0
273 lines not on this page · raw message
src/rtprint/init.c new file +75 -0
75 lines not on this page · raw message
src/rtprint/internal.h new file +69 -0
69 lines not on this page · raw message
src/rtprint/output.c new file +92 -0
92 lines not on this page · raw message
Quoted 5 lines · Jan Kiszka
This is a stand-alone real-time library for printf services. It is embedded into the Xenomai user space part but actually doesn't depend on any Xenomai service, just using plain Linux POSIX.
The librtprint API looks much like the printf(3) man page:
[...]
Quoted 8 lines
Further features:
o Explicit or on-demand thread buffer creation
o Override of default buffer size and polling period via environment variables ("RT_PRINT_BUFFER" and "RT_PRINT_PERIOD")
o Support for buffer names (useful for the following patch e.g.)
o Target output stream can be specified for each print invocation
o Breaks all builds except for x86 (missingubarrier.hheaders) :o)
ubarrier.h is redundant. include/asm-*/atomic.h is already there for such purpose.
Quoted 3 lines
The code is stuffed into src/rtprint for now as patch 2/2 will need this lib to be built before the skin libraries. Better suggestions are welcome though.
I basically agree that we need to provide more co-scheduler-based-rt-safe services, so a non-intrusive print out support should be welcome. A few things more:
- looking beyond print out, we will probably want to iron more ANSI services in the future. In order to prevent API proliferation, let's consider the hardened print out support as the beginning of some libansi_rt service collection.
- the same way libpthread_rt shadows 1003.1c services to iron them over a co-scheduler, we should do the same for the ironed ANSI services. In that sense, there is no need for rt_printf, rt_vsprintf and so on, we just need to shadow printf, vsprintf and friends the same way we did for pthread_create and such for substituting the 1003.1c support. Again, API proliferation, especially of non-orthogonal stuff, needs to be fought now. The bonus is that we would not have to ask people to rely on crufty preprocessor tricks in order to compile their code in either real-time layers X3 is going to provide (i.e. I-pipe-based co-scheduler and native preemption). This would be consistent with the all-time Xenomai's mantra, i.e. "integrate as seamlessly as you can, don't get uselessly peculiar".
Signature · 1 line
Philippe.
Quoted 18 lines · Philippe Gerum
Quoted 5 lines · Jan Kiszka
This is a stand-alone real-time library for printf services. It is embedded into the Xenomai user space part but actually doesn't depend on any Xenomai service, just using plain Linux POSIX.
The librtprint API looks much like the printf(3) man page:
[...]
Quoted 8 lines
Further features:
o Explicit or on-demand thread buffer creation
o Override of default buffer size and polling period via environment variables ("RT_PRINT_BUFFER" and "RT_PRINT_PERIOD")
o Support for buffer names (useful for the following patch e.g.)
o Target output stream can be specified for each print invocation
o Breaks all builds except for x86 (missingubarrier.hheaders) :o)
Quoted 2 lines
ubarrier.his redundant.include/asm-*/atomic.his already there for such purpose.
Guess you mean Xenomai's atomic.h, not the kernel ones. I didn't realised that it is also used from user space already. OK, will #define something like xnarch_rmb/wmb (or xnarch_read_memory_barrier?) in that file instead.
Quoted 8 lines
Quoted 4 lines
The code is stuffed into src/rtprint for now as patch 2/2 will need this lib to be built before the skin libraries. Better suggestions are welcome though.
I basically agree that we need to provide more co-scheduler-based-rt-safe services, so a non-intrusive print out support should be welcome. A few things more:
Actually, rt-safe printing is independent of co- vs. native scheduling. Even with a fully preemptible kernel, the worst-case complexity of normal printf may not be acceptable. I think rt_printf is generally useful in real-time programs.
Quoted 5 lines
- looking beyond print out, we will probably want to iron more ANSI services in the future. In order to prevent API proliferation, let's consider the hardened print out support as the beginning of some
libansi_rtservice collection.
I was already considering to include the TLSF memory allocator for real-time malloc/free into some Xenomai library, but there were still technical issues with its lacking 64-bit support e.g., preventing some quick-hack.
What further services do you have on your radar? My impression is that there will not be a lot beyond printing and memory allocation.
Quoted 14 lines
- the same way
libpthread_rtshadows 1003.1c services to iron them over a co-scheduler, we should do the same for the ironed ANSI services. In that sense, there is no need forrt_printf,rt_vsprintfand so on, we just need to shadow printf, vsprintf and friends the same way we did forpthread_createand such for substituting the 1003.1c support. Again, API proliferation, especially of non-orthogonal stuff, needs to be fought now. The bonus is that we would not have to ask people to rely on crufty preprocessor tricks in order to compile their code in either real-time layers X3 is going to provide (i.e. I-pipe-based co-scheduler and native preemption). This would be consistent with the all-time Xenomai's mantra, i.e. "integrate as seamlessly as you can, don't get uselessly peculiar".
Think of RTDM: we have transparent overloading with the POSIX skin, but all others use the explicit selection via rt_dev prefix. I forgot to mention this, but my plan was to apply the same pattern for librtprint services.
I don't think we should overload every printf outside the POSIX skin's scope automatically. Well, at least for the native skin, which is in my opinion quite a lot about _explicit_ real-time programming, I would really prefer to keep it like it is even under Xenomai 3.
Jan
Quoted 19 lines · Jan Kiszka
Quoted 18 lines · Philippe Gerum
Quoted 5 lines · Jan Kiszka
This is a stand-alone real-time library for printf services. It is embedded into the Xenomai user space part but actually doesn't depend on any Xenomai service, just using plain Linux POSIX.
The librtprint API looks much like the printf(3) man page:
[...]
Quoted 8 lines
Further features:
o Explicit or on-demand thread buffer creation
o Override of default buffer size and polling period via environment variables ("RT_PRINT_BUFFER" and "RT_PRINT_PERIOD")
o Support for buffer names (useful for the following patch e.g.)
o Target output stream can be specified for each print invocation
o Breaks all builds except for x86 (missingubarrier.hheaders) :o)
Quoted 4 lines
Quoted 2 lines
ubarrier.his redundant.include/asm-*/atomic.his already there for such purpose.Guess you mean Xenomai's
atomic.h, not the kernel ones.
Yes, since this needs to be user-space readable.
Quoted 10 lines
I didn't
realised that it is also used from user space already. OK, will #define something like xnarch_rmb/wmb (orxnarch_read_memory_barrier?) in that file instead.Quoted 5 lines
Quoted 4 lines
The code is stuffed into src/rtprint for now as patch 2/2 will need this lib to be built before the skin libraries. Better suggestions are welcome though.
Quoted 8 lines
Quoted 3 lines
I basically agree that we need to provide more co-scheduler-based-rt-safe services, so a non-intrusive print out support should be welcome. A few things more:
Actually, rt-safe printing is independent of co- vs. native scheduling. Even with a fully preemptible kernel, the worst-case complexity of normal printf may not be acceptable. I think
rt_printfis generally useful in real-time programs.
You seem to be talking specifically about a (non-intrusive) trace logging feature, rather than plain printf() then, because the latter does not make much sense to be used in a real-time scenario unless the caller does accept to pay the price of running a complex operation anyway.
If, on the other hand, you want to provide more efficient replacements of existing standard routines in terms of performance, then those should bear the standard names. Otherwise, people would start mixing printf() and rt_printf() in their application [experience already showed us that it's inevitable], and for instance, you would start receiving complaints about inaccurate output order, leading to incorrect interpretation of traces, because both implementations would obviously rely on distinct internal buffers.
Quoted 7 lines
Quoted 6 lines
- looking beyond print out, we will probably want to iron more ANSI services in the future. In order to prevent API proliferation, let's consider the hardened print out support as the beginning of some
libansi_rtservice collection.
Quoted 8 lines
I was already considering to include the TLSF memory allocator for real-time malloc/free into some Xenomai library, but there were still technical issues with its lacking 64-bit support e.g., preventing some quick-hack.
What further services do you have on your radar? My impression is that there will not be a lot beyond printing and memory allocation.
And that would already be enough to explain why we would not want to ask people to stuff their Makefile with LDFLAGS += -lrt_printf -lrt_malloc, IMO. Because after a few years, my feeling is that the LDFLAGS would grow out of any reasonable proportion, and our maintenance burden the same way.
I would also consider things like stdio in general, not just printf, by mean of server thread(s) the way you did it. Being able to send/receive a file stream without resorting -at least explicitely- to a proxy thread would simplify a bunch of existing applications for instance.
Aside of purely ANSI services, there are some POSIX/SVID calls which are not relevant to libpthread_rt, but for which a hardened counterpart would make sense over a co-kernel, like SunRPC (over RTNet's UDP, that is), syslog routines, random, or libcrypt members for instance.
My point being that we cannot anticipate the exact list of features we would want to harden in the future, but we do know already that applications ported/created over Xenomai are always more complex, so we will likely need more of those features. Componentization must have a limit, and my guts feeling is that going for a specific API for each and every feature would lead to maintenance chaos and user confusion. Additionally, sharing internal routines common to those features would be possible with a centralized architecture (unless we go for yet-another-library exporting those routines).
Quoted 20 lines
Quoted 14 lines
- the same way
libpthread_rtshadows 1003.1c services to iron them over a co-scheduler, we should do the same for the ironed ANSI services. In that sense, there is no need forrt_printf,rt_vsprintfand so on, we just need to shadow printf, vsprintf and friends the same way we did forpthread_createand such for substituting the 1003.1c support. Again, API proliferation, especially of non-orthogonal stuff, needs to be fought now. The bonus is that we would not have to ask people to rely on crufty preprocessor tricks in order to compile their code in either real-time layers X3 is going to provide (i.e. I-pipe-based co-scheduler and native preemption). This would be consistent with the all-time Xenomai's mantra, i.e. "integrate as seamlessly as you can, don't get uselessly peculiar".Think of RTDM: we have transparent overloading with the POSIX skin, but all others use the explicit selection via
rt_devprefix. I forgot to mention this, but my plan was to apply the same pattern for librtprint services.
Quoted 5 lines
I don't think we should overload every printf outside the POSIX skin's scope automatically. Well, at least for the native skin, which is in my opinion quite a lot about _explicit_ real-time programming, I would really prefer to keep it like it is even under Xenomai 3.
IMO, the only way to make "explicit real-time programming" a rule is to disable all access to real-time unsafe calls, i.e. basically to the glibc, and this is obviously something we don't want to, because this would contradict the fundamental goal of Xenomai toward integration within the regular Linux programming model.
Because of this, that's a fact of life that users are most often going to consider that a commonly used glibc routine they need is real-time safe enough to be used until proven wrong (*), instead of suspecting such routine to be unsafe a priori, and looking for a safe replacement in some specific API we might provide (this is why we all had to warn a number of people countless times on the list about their use of printf() in deemed time-critical sections from various pieces of code they showed us).
This is also the reason why I still think we should "upgrade" the commonly used standard routines to be real-time aware by gradually providing hardened replacements for them, not trying to convince people about the fact that using standard routines might not be the right solution to common problems in the real-time case.
(*) actually, the real problem is that some users might think that we are smart enough to make deterministic and efficient code out of any regular Linux service they might think of, albeit the founder of the Xenomai project might be a total bonehead. Oh, well, anyway...
Signature · 1 line
Philippe.
Quoted 14 lines · Philippe Gerum
Quoted 5 lines · Jan Kiszka
Quoted 4 lines · Philippe Gerum
Quoted 3 lines · Jan Kiszka
The code is stuffed into src/rtprint for now as patch 2/2 will need this lib to be built before the skin libraries. Better suggestions are welcome though.
Quoted 7 lines
Quoted 3 lines
I basically agree that we need to provide more co-scheduler-based-rt-safe services, so a non-intrusive print out support should be welcome. A few things more:
Actually, rt-safe printing is independent of co- vs. native scheduling. Even with a fully preemptible kernel, the worst-case complexity of normal printf may not be acceptable. I think
rt_printfis generally useful in real-time programs.
Quoted 5 lines
You seem to be talking specifically about a (non-intrusive) trace logging feature, rather than plain
printf()then, because the latter does not make much sense to be used in a real-time scenario unless the caller does accept to pay the price of running a complex operation anyway.
No, I'm also talking about plain printf scenarios from hard-RT threads. There is a difference between just doing a fairly simple snprintf to format the output and going into the kernel to write it to some console, file, network link, or whatever.
Quoted 9 lines
If, on the other hand, you want to provide more efficient replacements of existing standard routines in terms of performance, then those should bear the standard names. Otherwise, people would start mixing
printf()andrt_printf()in their application [experience already showed us that it's inevitable], and for instance, you would start receiving complaints about inaccurate output order, leading to incorrect interpretation of traces, because both implementations would obviously rely on distinct internal buffers.
I agree that there is an ordering issue when writing to stdout or stderr /wrt to standard glibc routines. But the question is where to draw the line. We surely do not want to redirect each and every file write to a server thread _automatically_ (would be quite a performance PITA...) just because some fprintf may otherwise happen to come out in an unexpected order. We cannot avoid that the user has to be - to some degree - really _aware_ of what (s)he's doing.
Quoted 14 lines
Quoted 5 lines
Quoted 5 lines
- looking beyond print out, we will probably want to iron more ANSI services in the future. In order to prevent API proliferation, let's consider the hardened print out support as the beginning of some
libansi_rtservice collection.Quoted 8 lines
I was already considering to include the TLSF memory allocator for real-time malloc/free into some Xenomai library, but there were still technical issues with its lacking 64-bit support e.g., preventing some quick-hack.
What further services do you have on your radar? My impression is that there will not be a lot beyond printing and memory allocation.
Quoted 5 lines
And that would already be enough to explain why we would not want to ask people to stuff their
Makefilewith LDFLAGS += -lrt_printf -lrt_malloc, IMO. Because after a few years, my feeling is that the LDFLAGS would grow out of any reasonable proportion, and our maintenance burden the same way.
So your point is single vs. multiple rt-helper libs? I don't see a problem bundling fairly small services (a few kB) into a single lib, common to all skins. But once it takes a bit more to provide a certain service, we have to keep memory-restricted embedded applications in mind. Configuring features at build time is one way. Providing reasonably clustered libraries is another. Hard to draw a line now without having all components already at hand or at least in mind.
Quoted 5 lines
I would also consider things like stdio in general, not just printf, by mean of server thread(s) the way you did it. Being able to send/receive a file stream without resorting -at least explicitely- to a proxy thread would simplify a bunch of existing applications for instance.
Yeah, the way rt_printf writes out data might be extended to a common pattern also for other stdio output services. If async stdio-like reading is also worth providing in a generic way is something I would like to see backed up by concrete application scenarios. Maybe.
Quoted 6 lines
Aside of purely ANSI services, there are some POSIX/SVID calls which are not relevant to
libpthread_rt, but for which a hardened counterpart would make sense over a co-kernel, like SunRPC (over RTNet's UDP, that is), syslog routines, random, or libcrypt members for instance.
Quoted 9 lines
My point being that we cannot anticipate the exact list of features we would want to harden in the future, but we do know already that applications ported/created over Xenomai are always more complex, so we will likely need more of those features. Componentization must have a limit, and my guts feeling is that going for a specific API for each and every feature would lead to maintenance chaos and user confusion. Additionally, sharing internal routines common to those features would be possible with a centralized architecture (unless we go for yet-another-library exporting those routines).
Well, would you be more happy if we call the printing library libstdio_rt without yet implementing all the related services, but pointing out the potential path of this lib in the future?
Quoted 25 lines
Quoted 19 lines
Quoted 14 lines
- the same way
libpthread_rtshadows 1003.1c services to iron them over a co-scheduler, we should do the same for the ironed ANSI services. In that sense, there is no need forrt_printf,rt_vsprintfand so on, we just need to shadow printf, vsprintf and friends the same way we did forpthread_createand such for substituting the 1003.1c support. Again, API proliferation, especially of non-orthogonal stuff, needs to be fought now. The bonus is that we would not have to ask people to rely on crufty preprocessor tricks in order to compile their code in either real-time layers X3 is going to provide (i.e. I-pipe-based co-scheduler and native preemption). This would be consistent with the all-time Xenomai's mantra, i.e. "integrate as seamlessly as you can, don't get uselessly peculiar".Think of RTDM: we have transparent overloading with the POSIX skin, but all others use the explicit selection via
rt_devprefix. I forgot to mention this, but my plan was to apply the same pattern for librtprint services.Quoted 5 lines
I don't think we should overload every printf outside the POSIX skin's scope automatically. Well, at least for the native skin, which is in my opinion quite a lot about _explicit_ real-time programming, I would really prefer to keep it like it is even under Xenomai 3.
Quoted 5 lines
IMO, the only way to make "explicit real-time programming" a rule is to disable all access to real-time unsafe calls, i.e. basically to the glibc, and this is obviously something we don't want to, because this would contradict the fundamental goal of Xenomai toward integration within the regular Linux programming model.
No, disabling such access is surely a no-go. But I really think we should strengthen the mode-switch detection, maybe be considering to invert its default (always or just for debugging). Mode-switch detection by the user space tracer could be a first step in this direction (without immediately breaking the API).
Quoted 16 lines
Because of this, that's a fact of life that users are most often going to consider that a commonly used glibc routine they need is real-time safe enough to be used until proven wrong (*), instead of suspecting such routine to be unsafe a priori, and looking for a safe replacement in some specific API we might provide (this is why we all had to warn a number of people countless times on the list about their use of
printf()in deemed time-critical sections from various pieces of code they showed us).This is also the reason why I still think we should "upgrade" the commonly used standard routines to be real-time aware by gradually providing hardened replacements for them, not trying to convince people about the fact that using standard routines might not be the right solution to common problems in the real-time case.
Quoted 5 lines
(*) actually, the real problem is that some users might think that we are smart enough to make deterministic and efficient code out of any regular Linux service they might think of, albeit the founder of the Xenomai project might be a total bonehead. Oh, well, anyway...
As I said, overloading, just trying to shadow the differences doesn't solve the problem automagically. You often need special configuration APIs for the shadowed one, thus you need understanding of its mechanisms. And you need access to the original functions because of drawbacks of the hardened variants (if they had none, we could just submit glibc or whatever patches...).
Overloading is only as long comfortable as you _mostly_ make use of the replacement services in your application. Once it is the other way around, this automatism becomes quite a PITA. We luckily already have two programming models with POSIX vs. native skin matching both use cases, and I consider this a strength, not a weakness of Xenomai.
Granted, alternatives can cause confusion, and we may have to improve beginner guides on the homepage or wherever to underline and explain these differences more explicitly.
Jan
Quoted 21 lines · Jan Kiszka
Quoted 14 lines · Philippe Gerum
Quoted 5 lines · Jan Kiszka
Quoted 4 lines · Philippe Gerum
Quoted 3 lines · Jan Kiszka
The code is stuffed into src/rtprint for now as patch 2/2 will need this lib to be built before the skin libraries. Better suggestions are welcome though.
Quoted 7 lines
Quoted 3 lines
I basically agree that we need to provide more co-scheduler-based-rt-safe services, so a non-intrusive print out support should be welcome. A few things more:
Actually, rt-safe printing is independent of co- vs. native scheduling. Even with a fully preemptible kernel, the worst-case complexity of normal printf may not be acceptable. I think
rt_printfis generally useful in real-time programs.Quoted 5 lines
You seem to be talking specifically about a (non-intrusive) trace logging feature, rather than plain
printf()then, because the latter does not make much sense to be used in a real-time scenario unless the caller does accept to pay the price of running a complex operation anyway.
Quoted 5 lines
No, I'm also talking about plain printf scenarios from hard-RT threads. There is a difference between just doing a fairly simple snprintf to format the output and going into the kernel to write it to some console, file, network link, or whatever.
Right, but your patch seems to focus on printf() so far, hence my argument. [Btw, glibc's snprintf() called from rt_vsnprintf() is likely going to compete for the file lock in the MT_SAFE_IO case, which might not be what you want, if you don't want to take the mode switch penalty upon contention].
Quoted 10 lines
Quoted 9 lines
If, on the other hand, you want to provide more efficient replacements of existing standard routines in terms of performance, then those should bear the standard names. Otherwise, people would start mixing
printf()andrt_printf()in their application [experience already showed us that it's inevitable], and for instance, you would start receiving complaints about inaccurate output order, leading to incorrect interpretation of traces, because both implementations would obviously rely on distinct internal buffers.
Quoted 2 lines
I agree that there is an ordering issue when writing to stdout or stderr /wrt to standard glibc routines.
I was primarily talking about calling printf() then rt_printf() (or the other way around), which would not give any guarantee about the output sequence.
Quoted 3 lines
But the question is where to draw the
line. We surely do not want to redirect each and every file write to a server thread _automatically_ (would be quite a performance PITA...)
You would still have access to the __real_xxx counterparts anyway.
Quoted 4 lines
just because some fprintf may otherwise happen to come out in an unexpected order. We cannot avoid that the user has to be - to some degree - really _aware_ of what (s)he's doing.
My point is different, and it goes beyond the printf() case. IOW, should a developer:
a) have to verify whether rt_printf(), rt_vsprintf(), rt_vsnprintf() etc. exist in some API we would provide, and decide to use them in replacement of the original glibc calls, and understand the consequences about predictability if they don't.
or
b) have to verify whether printf(), vsprintf(), vsnprintf() etc. are documented as members of the calls Xenomai "hardens" when she happen to need them, and understand the consequences about predictability if they don't.
In both cases, such developer _must_ know what he's doing anyway, in order to ask himself either one of those questions in the first place, so this is clearly not about telling people "life is good because call shadowing exists, just breath and live cluelessly". It's whether you want them to use a specific API, or to use a hardened subset of the original one.
I tend to prefer b) because:
- I tend to find much easier to tell people "you may use a subset of the API you already know", than "you must use another API to access a functional subset of the API you already know". The fact that original symbols would just have to be prefixed by rt_ does not change this fact:
it's another API.
- when running Xenomai apps over native preemption, finding rt_* and non-rt versions of the same symbol would look preposterous, and the point about X3 is to allow people to move freely from one real-time layer to another (i.e. co-kernel to native preemption and the other way around), without any impact on their code.
But, I definitely agree with you that b) is error-prone if nothing is made to strongly warn about potential misuses, and strenghtening the mode switch alert policy may be a mean to do that.
Quoted 20 lines
Quoted 14 lines
Quoted 5 lines
Quoted 5 lines
- looking beyond print out, we will probably want to iron more ANSI services in the future. In order to prevent API proliferation, let's consider the hardened print out support as the beginning of some
libansi_rtservice collection.Quoted 8 lines
I was already considering to include the TLSF memory allocator for real-time malloc/free into some Xenomai library, but there were still technical issues with its lacking 64-bit support e.g., preventing some quick-hack.
What further services do you have on your radar? My impression is that there will not be a lot beyond printing and memory allocation.
Quoted 5 lines
And that would already be enough to explain why we would not want to ask people to stuff their
Makefilewith LDFLAGS += -lrt_printf -lrt_malloc, IMO. Because after a few years, my feeling is that the LDFLAGS would grow out of any reasonable proportion, and our maintenance burden the same way.
Quoted 8 lines
So your point is single vs. multiple rt-helper libs? I don't see a problem bundling fairly small services (a few kB) into a single lib, common to all skins. But once it takes a bit more to provide a certain service, we have to keep memory-restricted embedded applications in mind. Configuring features at build time is one way. Providing reasonably clustered libraries is another. Hard to draw a line now without having all components already at hand or at least in mind.
My point is about avoiding this approach:
http://www.slac.stanford.edu/exp/glast/flight/sw/vxdocs/vxworks/ref/libIndex.htm#A
Quoted 27 lines
Quoted 5 lines
I would also consider things like stdio in general, not just printf, by mean of server thread(s) the way you did it. Being able to send/receive a file stream without resorting -at least explicitely- to a proxy thread would simplify a bunch of existing applications for instance.
Yeah, the way
rt_printfwrites out data might be extended to a common pattern also for other stdio output services. If async stdio-like reading is also worth providing in a generic way is something I would like to see backed up by concrete application scenarios. Maybe.Quoted 6 lines
Aside of purely ANSI services, there are some POSIX/SVID calls which are not relevant to
libpthread_rt, but for which a hardened counterpart would make sense over a co-kernel, like SunRPC (over RTNet's UDP, that is), syslog routines, random, or libcrypt members for instance.Quoted 9 lines
My point being that we cannot anticipate the exact list of features we would want to harden in the future, but we do know already that applications ported/created over Xenomai are always more complex, so we will likely need more of those features. Componentization must have a limit, and my guts feeling is that going for a specific API for each and every feature would lead to maintenance chaos and user confusion. Additionally, sharing internal routines common to those features would be possible with a centralized architecture (unless we go for yet-another-library exporting those routines).
Quoted 4 lines
Well, would you be more happy if we call the printing library
libstdio_rtwithout yet implementing all the related services, but pointing out the potential path of this lib in the future?
There would remain the malloc support issue, which would obviously not fit in the stdio lib.
Quoted 31 lines
Quoted 25 lines
Quoted 19 lines
Quoted 14 lines
- the same way
libpthread_rtshadows 1003.1c services to iron them over a co-scheduler, we should do the same for the ironed ANSI services. In that sense, there is no need forrt_printf,rt_vsprintfand so on, we just need to shadow printf, vsprintf and friends the same way we did forpthread_createand such for substituting the 1003.1c support. Again, API proliferation, especially of non-orthogonal stuff, needs to be fought now. The bonus is that we would not have to ask people to rely on crufty preprocessor tricks in order to compile their code in either real-time layers X3 is going to provide (i.e. I-pipe-based co-scheduler and native preemption). This would be consistent with the all-time Xenomai's mantra, i.e. "integrate as seamlessly as you can, don't get uselessly peculiar".Think of RTDM: we have transparent overloading with the POSIX skin, but all others use the explicit selection via
rt_devprefix. I forgot to mention this, but my plan was to apply the same pattern for librtprint services.Quoted 5 lines
I don't think we should overload every printf outside the POSIX skin's scope automatically. Well, at least for the native skin, which is in my opinion quite a lot about _explicit_ real-time programming, I would really prefer to keep it like it is even under Xenomai 3.
Quoted 5 lines
IMO, the only way to make "explicit real-time programming" a rule is to disable all access to real-time unsafe calls, i.e. basically to the glibc, and this is obviously something we don't want to, because this would contradict the fundamental goal of Xenomai toward integration within the regular Linux programming model.
Quoted 6 lines
No, disabling such access is surely a no-go. But I really think we should strengthen the mode-switch detection, maybe be considering to invert its default (always or just for debugging). Mode-switch detection by the user space tracer could be a first step in this direction (without immediately breaking the API).
Agreed, other means to strengthen the alerts about loss of predictability should be found.
Quoted 22 lines
Quoted 16 lines
Because of this, that's a fact of life that users are most often going to consider that a commonly used glibc routine they need is real-time safe enough to be used until proven wrong (*), instead of suspecting such routine to be unsafe a priori, and looking for a safe replacement in some specific API we might provide (this is why we all had to warn a number of people countless times on the list about their use of
printf()in deemed time-critical sections from various pieces of code they showed us).This is also the reason why I still think we should "upgrade" the commonly used standard routines to be real-time aware by gradually providing hardened replacements for them, not trying to convince people about the fact that using standard routines might not be the right solution to common problems in the real-time case.
Quoted 5 lines
(*) actually, the real problem is that some users might think that we are smart enough to make deterministic and efficient code out of any regular Linux service they might think of, albeit the founder of the Xenomai project might be a total bonehead. Oh, well, anyway...
Quoted 11 lines
As I said, overloading, just trying to shadow the differences doesn't solve the problem automagically. You often need special configuration APIs for the shadowed one, thus you need understanding of its mechanisms. And you need access to the original functions because of drawbacks of the hardened variants (if they had none, we could just submit glibc or whatever patches...).
Overloading is only as long comfortable as you _mostly_ make use of the replacement services in your application. Once it is the other way around, this automatism becomes quite a PITA. We luckily already have two programming models with POSIX vs. native skin matching both use cases, and I consider this a strength, not a weakness of Xenomai.
I did not say it was a weakness (even if I always thought that the rt_dev interface to RTDM was redundant with the POSIXish one), but that we should keep the finger on the bloat control when it comes to co-kernel-specific-APIs, because as much as there is life beyond x86, there is also life beyond co-kernels.
The natural tendency of Xenomai has always been to blur the frontier between the regular Linux environment and the co-kernel environment, so that people don't get schizophrenic when implementing a real-time application over Xenomai, with powerful features on both sides, but no ability to combine those strengthes efficiently. I'm convinced this has some value in the picture too.
Quoted 5 lines
Granted, alternatives can cause confusion, and we may have to improve beginner guides on the homepage or wherever to underline and explain these differences more explicitly.
Ack.
Quoted 2 lines
Jan
Signature · 1 line
Philippe.
Quoted 26 lines · Philippe Gerum
Quoted 19 lines · Jan Kiszka
Quoted 13 lines · Philippe Gerum
Quoted 5 lines · Jan Kiszka
Quoted 4 lines · Philippe Gerum
Quoted 3 lines · Jan Kiszka
The code is stuffed into src/rtprint for now as patch 2/2 will need this lib to be built before the skin libraries. Better suggestions are welcome though.
Quoted 7 lines
Quoted 3 lines
I basically agree that we need to provide more co-scheduler-based-rt-safe services, so a non-intrusive print out support should be welcome. A few things more:
Actually, rt-safe printing is independent of co- vs. native scheduling. Even with a fully preemptible kernel, the worst-case complexity of normal printf may not be acceptable. I think
rt_printfis generally useful in real-time programs.Quoted 5 lines
You seem to be talking specifically about a (non-intrusive) trace logging feature, rather than plain
printf()then, because the latter does not make much sense to be used in a real-time scenario unless the caller does accept to pay the price of running a complex operation anyway.Quoted 5 lines
No, I'm also talking about plain printf scenarios from hard-RT threads. There is a difference between just doing a fairly simple snprintf to format the output and going into the kernel to write it to some console, file, network link, or whatever.
Quoted 5 lines
Right, but your patch seems to focus on
printf()so far, hence my argument. [Btw, glibc'ssnprintf()called fromrt_vsnprintf()is likely going to compete for the file lock in theMT_SAFE_IOcase, which might not be what you want, if you don't want to take the mode switch penalty upon contention].
Going through glibc's stdio/libio stuff is hell, but based on my current analysis (and also when considering what *snprintf does) it is highly unlikely that there is anything to compete for. All required buffers are on the stack or in user hand, and that MT_SAFE_IO lock you referred to is set to NULL.
Quoted 48 lines
Quoted 11 lines
Quoted 9 lines
If, on the other hand, you want to provide more efficient replacements of existing standard routines in terms of performance, then those should bear the standard names. Otherwise, people would start mixing
printf()andrt_printf()in their application [experience already showed us that it's inevitable], and for instance, you would start receiving complaints about inaccurate output order, leading to incorrect interpretation of traces, because both implementations would obviously rely on distinct internal buffers.I agree that there is an ordering issue when writing to stdout or stderr /wrt to standard glibc routines.
I was primarily talking about calling
printf()thenrt_printf()(or the other way around), which would not give any guarantee about the output sequence.Quoted 3 lines
But the question is where to draw the
line. We surely do not want to redirect each and every file write to a server thread _automatically_ (would be quite a performance PITA...)You would still have access to the
__real_xxxcounterparts anyway.Quoted 4 lines
just because some fprintf may otherwise happen to come out in an unexpected order. We cannot avoid that the user has to be - to some degree - really _aware_ of what (s)he's doing.
My point is different, and it goes beyond the
printf()case. IOW, should a developer:a) have to verify whether
rt_printf(),rt_vsprintf(),rt_vsnprintf()etc. exist in some API we would provide, and decide to use them in replacement of the original glibc calls, and understand the consequences about predictability if they don't.or
b) have to verify whether
printf(),vsprintf(),vsnprintf()etc. are documented as members of the calls Xenomai "hardens" when she happen to need them, and understand the consequences about predictability if they don't.In both cases, such developer _must_ know what he's doing anyway, in order to ask himself either one of those questions in the first place, so this is clearly not about telling people "life is good because call shadowing exists, just breath and live cluelessly". It's whether you want them to use a specific API, or to use a hardened subset of the original one.
Quoted 7 lines
I tend to prefer b) because:
- I tend to find much easier to tell people "you may use a subset of the API you already know", than "you must use another API to access a functional subset of the API you already know". The fact that original symbols would just have to be prefixed byrt_does not change this fact:
it's another API.
- when running Xenomai apps over native preemption, finding rt_* and
As I said: rt_printf vs. printf is a good example where native preemption does not change the picture noticeably, where you want special services even if the kernel knows about priority inheritance in order to boost such complex printing jobs over others.
Quoted 35 lines
non-rt versions of the same symbol would look preposterous, and the point about X3 is to allow people to move freely from one real-time layer to another (i.e. co-kernel to native preemption and the other way around), without any impact on their code.
But, I definitely agree with you that b) is error-prone if nothing is made to strongly warn about potential misuses, and strenghtening the mode switch alert policy may be a mean to do that.
Quoted 17 lines
Quoted 9 lines
Quoted 9 lines
Quoted 4 lines
- looking beyond print out, we will probably want to iron more ANSI services in the future. In order to prevent API proliferation, let's consider the hardened print out support as the beginning of some
libansi_rtservice collection.I was already considering to include the TLSF memory allocator for real-time malloc/free into some Xenomai library, but there were still technical issues with its lacking 64-bit support e.g., preventing some quick-hack.
Quoted 8 lines
Quoted 3 lines
What further services do you have on your radar? My impression is that there will not be a lot beyond printing and memory allocation.
And that would already be enough to explain why we would not want to ask people to stuff their
Makefilewith LDFLAGS += -lrt_printf -lrt_malloc, IMO. Because after a few years, my feeling is that the LDFLAGS would grow out of any reasonable proportion, and our maintenance burden the same way.Quoted 8 lines
So your point is single vs. multiple rt-helper libs? I don't see a problem bundling fairly small services (a few kB) into a single lib, common to all skins. But once it takes a bit more to provide a certain service, we have to keep memory-restricted embedded applications in mind. Configuring features at build time is one way. Providing reasonably clustered libraries is another. Hard to draw a line now without having all components already at hand or at least in mind.
Quoted 2 lines
My point is about avoiding this approach:
http://www.slac.stanford.edu/exp/glast/flight/sw/vxdocs/vxworks/ref/libIndex.htm#A
Ack, that is certainly a bad example for componentisation. The goal must be to find a reasonable path between both extremes.
Quoted 24 lines
Quoted 24 lines
Quoted 5 lines
I would also consider things like stdio in general, not just printf, by mean of server thread(s) the way you did it. Being able to send/receive a file stream without resorting -at least explicitely- to a proxy thread would simplify a bunch of existing applications for instance.
Yeah, the way
rt_printfwrites out data might be extended to a common pattern also for other stdio output services. If async stdio-like reading is also worth providing in a generic way is something I would like to see backed up by concrete application scenarios. Maybe.Quoted 14 lines
Aside of purely ANSI services, there are some POSIX/SVID calls which are not relevant to
libpthread_rt, but for which a hardened counterpart would make sense over a co-kernel, like SunRPC (over RTNet's UDP, that is), syslog routines, random, or libcrypt members for instance.My point being that we cannot anticipate the exact list of features we would want to harden in the future, but we do know already that applications ported/created over Xenomai are always more complex, so we will likely need more of those features. Componentization must have a limit, and my guts feeling is that going for a specific API for each and every feature would lead to maintenance chaos and user confusion. Additionally, sharing internal routines common to those features would be possible with a centralized architecture (unless we go for yet-another-library exporting those routines).
Quoted 7 lines
Quoted 4 lines
Well, would you be more happy if we call the printing library
libstdio_rtwithout yet implementing all the related services, but pointing out the potential path of this lib in the future?There would remain the malloc support issue, which would obviously not fit in the stdio lib.
True.
Quoted 71 lines
Quoted 29 lines
Quoted 24 lines
Quoted 19 lines
Quoted 14 lines
- the same way
libpthread_rtshadows 1003.1c services to iron them over a co-scheduler, we should do the same for the ironed ANSI services. In that sense, there is no need forrt_printf,rt_vsprintfand so on, we just need to shadow printf, vsprintf and friends the same way we did forpthread_createand such for substituting the 1003.1c support. Again, API proliferation, especially of non-orthogonal stuff, needs to be fought now. The bonus is that we would not have to ask people to rely on crufty preprocessor tricks in order to compile their code in either real-time layers X3 is going to provide (i.e. I-pipe-based co-scheduler and native preemption). This would be consistent with the all-time Xenomai's mantra, i.e. "integrate as seamlessly as you can, don't get uselessly peculiar".Think of RTDM: we have transparent overloading with the POSIX skin, but all others use the explicit selection via
rt_devprefix. I forgot to mention this, but my plan was to apply the same pattern for librtprint services.Quoted 5 lines
I don't think we should overload every printf outside the POSIX skin's scope automatically. Well, at least for the native skin, which is in my opinion quite a lot about _explicit_ real-time programming, I would really prefer to keep it like it is even under Xenomai 3.
Quoted 5 lines
IMO, the only way to make "explicit real-time programming" a rule is to disable all access to real-time unsafe calls, i.e. basically to the glibc, and this is obviously something we don't want to, because this would contradict the fundamental goal of Xenomai toward integration within the regular Linux programming model.
Quoted 6 lines
No, disabling such access is surely a no-go. But I really think we should strengthen the mode-switch detection, maybe be considering to invert its default (always or just for debugging). Mode-switch detection by the user space tracer could be a first step in this direction (without immediately breaking the API).
Agreed, other means to strengthen the alerts about loss of predictability should be found.
Quoted 20 lines
Quoted 15 lines
Because of this, that's a fact of life that users are most often going to consider that a commonly used glibc routine they need is real-time safe enough to be used until proven wrong (*), instead of suspecting such routine to be unsafe a priori, and looking for a safe replacement in some specific API we might provide (this is why we all had to warn a number of people countless times on the list about their use of
printf()in deemed time-critical sections from various pieces of code they showed us).This is also the reason why I still think we should "upgrade" the commonly used standard routines to be real-time aware by gradually providing hardened replacements for them, not trying to convince people about the fact that using standard routines might not be the right solution to common problems in the real-time case.
Quoted 5 lines
(*) actually, the real problem is that some users might think that we are smart enough to make deterministic and efficient code out of any regular Linux service they might think of, albeit the founder of the Xenomai project might be a total bonehead. Oh, well, anyway...
Quoted 11 lines
As I said, overloading, just trying to shadow the differences doesn't solve the problem automagically. You often need special configuration APIs for the shadowed one, thus you need understanding of its mechanisms. And you need access to the original functions because of drawbacks of the hardened variants (if they had none, we could just submit glibc or whatever patches...).
Overloading is only as long comfortable as you _mostly_ make use of the replacement services in your application. Once it is the other way around, this automatism becomes quite a PITA. We luckily already have two programming models with POSIX vs. native skin matching both use cases, and I consider this a strength, not a weakness of Xenomai.
Quoted 5 lines
I did not say it was a weakness (even if I always thought that the
rt_devinterface to RTDM was redundant with the POSIXish one), but that we should keep the finger on the bloat control when it comes to co-kernel-specific-APIs, because as much as there is life beyond x86, there is also life beyond co-kernels.
Again: we are not discussing co-kernel-specific APIs here. Rather, this tiny little librtprint could be seen as a potential piece of a "co-glibc" approach for optimising user-space real-time issues, actually independent of the underlying kernel.
Quoted 8 lines
The natural tendency of Xenomai has always been to blur the frontier between the regular Linux environment and the co-kernel environment, so that people don't get schizophrenic when implementing a real-time application over Xenomai, with powerful features on both sides, but no ability to combine those strengthes efficiently. I'm convinced this has some value in the picture too.
OK.
So, what is your suggestion for the printing services? How can we merge them while not yet knowing precisely what services we would like to add in the future, and how much code they will carry into whatever Xenomai libraries?
Beyond this, how to find The Right usage model (API, required compiler/linker switches)? Your suggestion is to wrap every *printf if one decides to use them (BTW, how to express this decision?). Mine is to only wrap for the POSIX skin integration, maybe also for legacy RTOS skins.
Jan
Quoted 2 lines · Philippe Gerum
ubarrier.his redundant.include/asm-*/atomic.his already there for such purpose.
Here comes version 2 of the patch, getting rid of ubarrier.h
Jan
--- configure.in | 1 examples/native/Makefile | 8 + examples/native/rtprint.c | 48 ++++++++ include/Makefile.am | 5 include/asm-i386/atomic.h | 4 include/rtprint.h | 59 +++++++++ src/Makefile.am | 2 src/rtprint/Makefile.am | 12 ++ src/rtprint/api.c | 273 ++++++++++++++++++++++++++++++++++++++++++++++ src/rtprint/init.c | 75 ++++++++++++ src/rtprint/internal.h | 69 +++++++++++ src/rtprint/output.c | 96 ++++++++++++++++ 12 files changed, 650 insertions(+), 2 deletions(-)
configure.in +1 -0
@@ -611,6 +611,7 @@ AC_CONFIG_FILES([ \ scripts/xeno-load \ scripts/xeno-test \ src/Makefile \ + src/rtprint/Makefile \ src/skins/Makefile \ src/skins/posix/Makefile \ src/skins/native/Makefile \
examples/native/Makefile +7 -1
@@ -1,7 +1,7 @@ ###### CONFIGURATION ###### ### List of applications to be build -APPLICATIONS = trivial-periodic sigxcpu +APPLICATIONS = trivial-periodic sigxcpu rtprint ### Note: to override the search path for the xeno-config script, use "make XENO=..."
@@ -44,6 +44,12 @@ endif +###### SPECIAL TARGET RULES ###### +rtprint: rtprint.c + $(CC) $(CFLAGS) $? $(LDFLAGS) -lrtprint -o $@ + + + ###### KERNEL MODULE BUILD (no change required normally) ###### ifneq ($(MODULES),)
examples/native/rtprint.c new file +48 -0
48 lines not on this page · raw message
include/Makefile.am +5 -0
@@ -1,3 +1,8 @@ +includedir = $(prefix)/include + +include_HEADERS = \ + rtprint.h + nodist_include_HEADERS=$(CONFIG_HEADER) SUBDIRS = \
include/rtprint.h new file +59 -0
59 lines not on this page · raw message
src/Makefile.am +1 -1
@@ -1,2 +1,2 @@ -SUBDIRS = include skins testsuite utils +SUBDIRS = include rtprint skins testsuite utils
src/rtprint/Makefile.am new file +12 -0
@@ -0,0 +1,12 @@ +lib_LTLIBRARIES = librtprint.la + +librtprint_la_LDFLAGS = -version-info 0:0:0 -lpthread + +librtprint_la_SOURCES = \ + init.c \ + output.c \ + api.c + +librtprint_la_CPPFLAGS = \ + @XENO_USER_CFLAGS@ \ + -I$(top_srcdir)/include
src/rtprint/api.c new file +273 -0
273 lines not on this page · raw message
src/rtprint/init.c new file +75 -0
75 lines not on this page · raw message
src/rtprint/internal.h new file +69 -0
69 lines not on this page · raw message
src/rtprint/output.c new file +96 -0
96 lines not on this page · raw message
include/asm-i386/atomic.h +4 -0
@@ -63,6 +63,10 @@ static inline unsigned long xnarch_atomi#define xnarch_memory_barrier () __asm__ __volatile__("": : :"memory") +#define xnarch_read_memory_barrier () \ + __asm__ __volatile__ ("lock; addl $0,0(%%esp)": : :"memory") +#define xnarch_write_memory_barrier () xnarch_memory_barrier() +#endif /* __KERNEL__ */ typedef unsigned long atomic_flags_t ;