I personally wouldn’t touch Eclipse on a self hosted machine. It’s one version behind, MUCH slower and buggier then the Windows version. Here everybody is setup with a windows machine and Phindows. The QNX6 machine run samba, that way everyone gets to use their favorite environment, from Vi to Eclipse
We need windows anyway so not an issue for us.
We find that it’s actually easier on us, GUI is not QNX’s strength. When it comes time to hire people for GUI and database it’s MUCH easier to find good people for that. However as you said it does make thing a little more complicated. That being said all of our GUI are written in Java, however it’s written based on SWING and that is not available on QNX6. If it would we’d probably have the GUI running on QNX6.
We use Windows XP Embedded to solve that problem.
When we needed to switch OS from QNX4, we picked up QNX6 simply because it made the transition much faster ( we had a prototype working on QNX6 within a month). If I had to go from scratch and not consider training everybody, I would probably go for XP embedded ( we don’t have hard real time requirement ). Any performance advantage that the QNX kernel offers is offset by better code generated on compiler available on Windows.
Out of curiosity have you ever considered just having your users just view PDF’s from a Windows machine?
I don’t know anything your deployment but we ship pdf’s with our system. We have networking running and ship with a default IP address. We install Samba (freely available from the 3rd party CD) and map the pdf directory as a Windows share. So customers just map to the pdfs as network drive and view the pdf’s when needed.
Again, on the 3rd party CD is the ‘jed’ editor. It’s an Emac’s clone and it most definitely supports an undo function (ctrl minus). I couldn’t live without it.
Of course, but it’s not nearly as convenient. Imagine standing on a factory floor trying to figure out why that fuse right there is blowing. It would be nice to immediately pull the electrical drawings up on the screen ATTACHED to door of the cabinet that has the blown fuse. The closest Windows machine is about 500 yards away in the maintenance office.
Before you say, “put a printout in the cabinet!” we do in fact put a hard copy of the drawings in the cabinet. It’s a bit like putting socks in the drier. They tend to vanish.
I must admit that I somehow missed jed’s existence. Possibly because my mind tries to blank out any memories I have of vi or emacs. I suppose I’ll have to give it a try, although I have a feeling my team will mutiny.
I developed a template based cover for QNX IPC that can pass objects quite elegantly actually (for instance you can “bolt on” serialization to classes that were never developed with serialization in the first place).
It is on foundry 27 under the QFC project, the header is “ipc”.
I wasn’t aware that boost didn’t work?
lf you are complaining, that we don’t brag enough, I might agree with you…
I thought that this is what pkgsrc did?
OK, now I am really confused. The self hosted Momentics IDE runs on Java… How was it “ripped out from under you”?
btw: there are bazillions of editors available as plug-ins for eclipse…
I think it is simply that you are in a niche market (nothing wrong with that, but that’s why there aren’t tons of vendors trying to fulfill all your requirements).
Really? Which variant? (when people refer to real-time, they typically want the full Posix API not merely ability to stuff code into an interrupt handler).
I am a recovering curmudgeon myself. I began my recovery by deciding that being obnoxious really wasn’t conducive with my goals of trying to help people
In 6.2.1 the virtual machine was included in the standard version ( lower price ) as a matter of fact you could download it for free from IBM I believe ( j9 ) . But with 6.3.x you have to pay extra money ( 4000$ ) to get access to a JVM.
I just tried it. As the release note says there is no support for SVN and upload manager because of lack of SSL support in the JVM.
The feature set is the same as the Windows version, but it’s much slower. To the point where I don’t think I’m going to use it, I’ll stick with the windows version. I’m using it through Phindows which surely doesn’t help.
Apparently QSS is working on a port of OpenJDK to solve all these issues.
Well, Boost CAN work. There are actually some quite recent discussions about it here on openqnx.com. But it’s not easy. I’ll have to check the pkgsrc way of installing. Remember that pkgsrc is a very recent development. I’ve been dug in on a big (non-QNX) project for months, so I haven’t actually gotten to try it yet.
As I mentioned earlier, and as mario stated in response to your question, Java came with 6.2.1 SE but not with 6.3.x SE.
Which just make it more frustrating that I can’t use Eclipse or Java or anything based on Qt or GTK…
A reasonable point. But is displaying a PDF really that niche?
That would be big news. I asked QSS about it when Sun made the announcement they were open sourcing their Java stuff, and QSS basically told me it would happen about the same time pigs fly over the frozen landscape of Hades. If they DO get OpenJDK, that has several implications:
I can get a decent text editor
I’ll be able to display vector graphics, at least in some form
Points 1 & 2 are really part of a larger point that I’ll have access to a LARGE pool of software. Yes, I know that “write once, run everywhere” isn’t EXACTLY true, but it’s a lot better than sitting here twiddling my thumbs.
I’m neither as crazy nor as niche as I’ve been feeling.
What exactly about Linux is real-time then? Group scheduling is nothing more than a poor imitation of Adaptive Partitioning and AP isn’t actually related to QNX’s real-time properties at all (outside of overload conditions it doesn’t negatively impact QNX’s real-time behavior, but it adds nothing to it).
From earlier today (6/5/2008) at the link you posted:
“Just to clarify - we are working on porting the security classes from OpenJDK to Perc VM to solve the lack of SSL support issue. It’s not a complete JVM port.”
I’m not overly familiar with real-time Linux. For that matter, I’m not much of an expert on real-time in general. However, I can respond to your first two points, if only barely.
The changes to the group scheduling are specifically to prevent unbounded pre-emptions, at least as I read it. It’s designed to make sure no process runs away with all the resources.
Linux doesn’t have AUTOMATIC priority inheritance the way QNX does with message passing, but it does HAVE priority inheritance through the POSIX threading library. Also, I’m pretty sure you can have deterministic real-time without priority inheritance, or even priority at all.
I’m not qualified to say whether or not Linux is (or can be) deterministic. Of course, I have to take QSS’s word for it that QNX is deterministic, since I’m not qualified to evaluate their claim either.
My own points:
A) There’s real-time, and then there’s REAL-TIME. Usually this is distinguished with some hand-waving and calling things “soft” or “hard” real-time. There are lots of applications I wouldn’t want to screw around with “maybe” real-time. Medical equipment, nuclear reactors, aircraft control, petro-chemical plants, etc. There are lots of applications where “good enough” will do. Is Linux now “good enough?” I don’t know, but it probably is for the kind of tasks our we currently use QNX for.
B) One of the big ones in the past was the fact that the Linux kernel wasn’t preemptible. Preemtibility has been folded into the main kernel for a while now.
C) I’m not actually advocating Linux. The whole thing started with me listing reasons why I’d pick Linux over QNX if I were starting from scratch. (I’m not, so we’re sticking with QNX for what little we need it for.) I think that list is still valid, although there were several points brought up that made some of my complaints less valid.
The group scheduling is (like I said) a poor-mans implementation of Adaptive Partitioning. It guarantees access to CPU for a group of threads over a period of time; it offers no bounds on latency. It is a load allocation mechanism (as is AP). One difference between the two is that AP is a load allocation system that does not negatively impact (in non-overload conditions) latency.
Priority inheritance is (in general) completely useless unless it is universal. A resource reservation chain of any length must propagate the priority throughout the entire chain. If, at any point, there is no priority inheritance, then the chain is broken and priority inversion can (and will) occur.
That’s fine, but don’t make unsubstantiated claims about Linux being real-time then…
Only applications can be real-time. A real-time OS is not inherently real-time, but in order to be called an RTOS it must give you a basic set of facilities that allow a real-time application to be implemented. Linux has none of these basic features available to user processes (which means no Posix API + real-time).
So, let’s say that Linux did have all the services required to be able to implement a real-time system. Once you have determinism, the next question becomes what is the quality of that determinism. Having a pre-emptible kernel is typically a very important element in reducing latency, but if you don’t have the basic elements in place for creating a real-time application, it is really too early to be worrying about optimization (way back when, QNX had a non-preemptible message send, and it was still real-time, it just didn’t have all that great a worst-case latency).
I have no problems at all if you did intend to advocate Linux, so long as you present factual information. If your application is not real-time, and doesn’t require a high level of reliability , then Linux may very well be the best choice for you. I never said there aren’t applications where Linux isn’t a perfectly valid choice, only that it is an extremely bad choice for applications that require real-time or high reliability.
It comes back to the old saying:
“When your only tool is a hammer every problem looks like a nail”.
Linux might be a fine hammer for nails, but if you need to fasten a machine screw, it may not be the best tool to use
I actually tried to soften it in my original post. I said “Linux is now real-time, for whatever that’s worth.” What I meant by that was, “Apparently, a lot of work has gone in to adding real-time capabilities to the stock Linux kernel. Supposedly, Linux is now more or less real-time, according to kernelnewbies.org. Granted, nobody is saying that Linux can now replace any existing RTOS, but it’s gotten fairly decent. See this article from IBM for example, or take a look at rt.wiki.kernel.org, especially their round-up of example latencies. Bear in mind that I’m not an expert on this, but there’s lots of good information a quick Google search way.”
I’m sorry that I came a cross as saying, “Linux is real-time, all must bow before it!” That was certainly not my intent.
Linux apparently does have quite a few facilities for implementing real-time behavior, including kernel pre-emption, priority inheritance, high resolution timers, and – at least empirically if not provably – bounded latencies is in the tens of microsecond range. There is quite a bit of work still being done in this area implying that (a) it’s not fully baked yet and (b) it will probably get better with time.
Agreed. And that’s where people can argue endlessly about the definition of “real-time.” Heck, try getting a definition of “operating system” even. And I’m shocked that Richard Stallman hasn’t jumped in to insist we say “GNU/Linux” instead of just Linux. And maybe SCO will sue us for copyright infringement since we’re talking about something they might have talked about one time. My point (I do actually have one!) is that it is legitimate at this point to say, “Linux is real-time,” with the caveat that the parameters of “real-time” are pretty vague.
I stand by initial statement, while pointing out that I intended it to be a weaker statement that you interpretted it as.
I think there’s a lot of empirical evidence to the contrary on that. There are plenty of extremely high-reliability Linux applications out there. Google comes to mind. Real-time is a little different. But again we’ve got that vagueness of what “real-time” means. I’ve seen plenty of industrial machinery running on Linux, and even on Windows. It’s “real-time” in the sense that when a sensor is triggered the system has to respond within a certain amount of time. But that time is large enough that you can throw horsepower at the problem and be careful about what you let people do on the system (no Quake!) and produce parts for years with no software-induced down time.
Darn. That was a pretty good run. I was hoping we could keep that alive a little longer. Here’s an attempt to fan the embers into a full-fledged flame-war:
All applications should be written in emacs LISP on BeOS running on a TI-99!
To some degree all the discussion is very theoretical. We do industrial control and we need soft real time and lots of power. We started using 4 core machine and soon will probably go with dual 4 cores.
For the past 3 months we have been plaque with networking issue. We just can’t get reliable 1Gig pci express networking. All the real-time feature, performance feature ( multi-core), Adaptive partitionning, etc all go down the drain because QNX does not have good support for 1Gig PCIe networking. We’d go Linux and even if it’s less real time, the fact that networking would work much better (in theory) would compensate for lack of real time and more, for our requirement.
It’s always the weakest link that kills ya.
Of course a solution to our problem is probably closer to getting Linux to be more real-time
I think it is hard enough to define hard real time, which is what real programmers call real time. What would a good definition of soft real time be? Here is my proposal. A soft real time system could either have bound latencies or unbound. If it has bound latencies, they must be less than those required by the application. If its latencies are unbound, the relationship to their size must be inversely related to their likelihood in such a manner that the probability of a miss is within the tolerances of the application. By this definition all systems are either hard real time or soft real time.
BTW, what is the problem with 1 Gig PCIe? Once the hardware gets ahold of the packets, don’t they always go at the same speed/throughput/etc?
With 1Gig PCIe the problem is that the default buffer size isn’t big enough and you loose packet if the data transfer is high enough. Increasing the buffer size isn’t enough, you need to increase the thread priority as well. That took a lot of time to figure this out…
Currently our biggest problem is i think related to speed negotiation. You boot one time speed is as expected your reboot then it slow to a crawl, yet it always report 1000Mbits full duplex. You plug/unplug the cable and behavior changes. If I stop the driver and restart it sometime it works something it doesn’t ( not network at all ).
I was given beta drivers to test and some will detect half duplex when the switch says it’s full duplex. I trust the switch, it’s a high end cisco
