From:       mante () aero ! polimi ! it (Paolo Mantegazza)
Date:       1998-03-16 15:52:14
[Download message RAW]

Hello, fresh news on using the FPU within RTLinux.
I've been able to convince a collegue, performing active vibration control
of plates to decrease the transmitted noise, to use RTLinux with the FPU
support of my variant. (I was smart in having the other take the risk,
wasn't I?). Please note that is the same technique I posted some time ago
for an rt_prio_sched of the standard release.
They are sampling the response of three piezosensors, carry out some signal
conditioning and simple compensation and evaluate a direct proportional
feedback to actuate three piezoactuators. They use a 200 Mhz plain Pentium
and  conditioning and feedback are performed by using the FPU without any
problem, with X running and with the system lively, at 18 Khz. The signal
are checked on a scope.
For those interested the piezo sensors and actuators are three ceramic disks
bonded to the panel. The DA acquisition are carried out with a DAS1600 card
along with two DA conversions, the third DA output with some other card
whose brand I forgot.
This is a preliminary activity in view of the implementation of a neural
controller. The only way they found to crash the system was to unplug the
computer by stepping onto a flying socket.
After these simple tests their doubts on using RTLinux are fading away and
I am happy that they can trust me somewhat more now.
I have not checked the system personally yet, but this is just a
confirmation of my testings.
Having understood that "fixed FPU support" meant "sound and working" I'm
eagerly waiting for the new 2.2.xx related RTLinux release with a native
improved FPU support.
Ciao, Paolo.

Something like this

Ok that rocks, 21KW/hour. But can you really get that savings?  If program 1 and program 2 need to run at the same times: you can’t save anything on them[1] and then the virtualization itself adds cycles for purely overhead and increases memory which burns more power. Suppose we now add K% as the overhead measure – real need R= D+D*K/100. If  K=20, we cut savings in half. But 20 seems wildly overoptimistic to me, so put it at 50.  We’re still only needing 72 servers instead of 200, but they are running flat out so we actually increase power use.

That does not rock.   But here’s the kicker – if we reduce idle power to 25Watts, maybe by turning off idle machines, a 50% overhead rate for virtualization means virtualization increases power use by 20KW. If we can reduce idle power to 1 watt, even at 10% overhead, virtualization increases power use.  So what are the real numbers? I have not seen any published studies (of actual data centers) – maybe there are some.

If you want a copy of the xls, send me an email. Maybe I set it up wrong.

http://www.hpl.hp.com/personal/Lucy_Cherkasova/papers/final-perf-study-usenix.pdf

This claims lower levels of overhead

http://www.engineyard.com/blog/2009/10-years-of-virtual-machine-performance-semi-demystified/

but I’m unconvinced. In particular, I’m curious about memory usage.

This is funny.

The benchmark itself reported its elapsed time by calling a function to find the system time at both the beginning and end of the benchmark.  The elapsed time reported by the benchmark was less than the wall-clock elapsed time.  What we hypothesize is that, due to the unrelenting CPU consumption by the benchmarks, the virtualization layer was unable to update its clock with the virtual CPU clock ticks.  This phenomenon is mentioned in [10] and [11] but we feel that this type of CPU workload severely exaggerates the situation.

http://www.cmg.org/measureit/issues/mit39/m_39_1.html

See the last letter in this

http://serverfault.com/questions/135431/is-virtual-machine-slower-than-the-underlying-physical-machine

While it is obvious that load is critical in any analysis, it may not be obvious how for example memory usage can depend on scheduling. If VM1 and VM2 run serially, memory usage is the max of the two, if they overlap it is the sum – unless it’s ok to slow them both down with more VM operations – which will, of course, increase the time to complete which uses capacity since that time is now not available for a third VM etc.

It’s also important to understand whether overhead is per VM. Suppose that we have 2% overhead per VM, all roughly the same size and 10 VMs. Is this overhead additive? Clearly cpu time is additive and so is I/O time, memory pressure is fuzzier and depends on how many VMs we run at any one time.

Notes

[1] If you have multiple cores, which you do, then if there are enough cores to run VM1 and VM2 in parallel, no problem. And this brings up the question of the relative power use, say of 2 dual core machines versus one 4 core machine or other multiples. Note that it’s hard to get power savings by turning off 4 of the 8 cores of a 8 core machine, but possibly easy to power down the one 4 core machine.

150,000,000
Number of Windows 7 licenses sold, making Windows 7 by far the fastest growing operating system in history.
<10
Percentage of US netbooks running Windows in 2008.
96
Percentage of US netbooks running Windows in 2009.
9,000,000
Number of customer downloads of the Office 2010 beta prior to launch, the largest Microsoft beta program in history. [source]
24%
Linux Server market share in 2005.
33%
Predicted Linux Server market share for 2007 (made in 2005).
21.2%
Actual Linux Server market share, Q4 2009.

http://blogs.technet.com/b/microsoft_blog/archive/2010/06/25/microsoft-by-the-numbers.aspx

Those last numbers are especially damning since Linux started with superior technology, has an easier business model if your only goal is market share, and did not have a legacy ball-and-chain anywhere near the size MS has to drag along. But years of directionless bloat have taken a toll and the sponsor driven decisions to go for traditional “server/OS” technology methods in place of trying to find solutions to current customer problems has been very damaging.

Even discounting the obvious PR froth of this article: http://www.eweek.com/c/a/Linux-and-Open-Source/Linux-Losing-Market-Share-to-Windows-Server it is an interesting trend.

and just for kicks from April 2000

“During his presentation on scaling Linux to the enterprise, BitMover, Inc. CEO Larry McVoy raised a few furrowed eyebrows at the recently-held Colorado Linux Info Quest (CLIQ). His message: Symetric multiprocessing (SMP) scaling may be hazardous to your operating system (OS) health.”

“McVoy said that the level of harm is “directly proportional” to the amount of scaling and is “worse than linear” in the number of processors. Converting a uniprocessor OS to a four-way SMP OS introduces a “small amount of damage.” Converting the four-way SMP OS to a 32-way SMP OS does even more damage, he told the crowd. McVoy calls this phenomenon “the locking cliff.”"

“The bottom line, said McVoy, is that: “Linux needs to have bragging rights on ‘big iron’ to be taken seriously in the enterprise. But the traditional way of getting those rights involves a series of changes which do a lot of damage to the source base. So the problems are that Linux needs to scale, and traditional scaling is a bad idea. Linux will use traditional scaling if nothing else shows up,” he said, “but SMP clusters is a better way to do it. I’m the driving force behind that and I’m not driving because I’m wrapped up in BitKeeper.”"

http://www.linuxtoday.com/news_story.php3?ltsn=2000-04-13-010-06-NW&tbovrmode=3

From the programmer’s standpoint, the working set of information is the smallest collection of information that must be present in main memory to assure efficient execution of his program.

But that note is actually from Peter Denning’s classical article (http://portal.acm.org/citation.cfm?doid=363095.363141 and http://cs.gmu.edu/cne/pjd/PUBS/WSModel_1968.pdf ) published in 1968 in Communications of the ACM – the same publication in which Kamp’s article appeared more than 40 years later. Kamp’s main result is that a search algorithm over a very large set of objects will perform poorly if it encounters a large number of page faults (if the working set is too large for the physical memory allocated to the process) ! Not since a researcher  explained during a talk at a serious academic conference that memory speeds could rival or outweigh processor speed in determining performance have I been so shocked but since that researcher was from Harvard, he had an excuse . The publication of Kamp’s article in ACM Communications shows something about the culture of computer science as an academic field these days.

Kamp’s article is easy to mock but, at least he’s doing some performance analysis and measurement – things that are definitely out of fashion in the field.  And he cares about performance.

What good is an O(log2(n)) algorithm if those operations cause page faults and slow disk operations? For most relevant datasets an O(n) or even an O(n^2) algorithm, which avoids page faults, will run circles around it.

Indeed.

A classic blunder in optimization was committed some years ago by one of the major software vendors. We had their first interactive timesharing system, and it was a “learning experience” in a variety of ways. One such experience was that of the FORTRAN compiler group. Now any compiler writer knows that the larger the hash table you use for a symbol table, the better your performance on lookup will be. When you are writing a multipass compiler in a 32K mainframe, you end up using a relatively small symbol table, but you create a really, really good hash algorithm so that the probability of a hash collision is reduced (unlike a binary seach, which is log n, a good hash table has constant performance, up to a certain density, so as long as you keep the density below this threshold you might expect that you will typically have an order 1 or 2 cost to enter or lookup a symbol, on the average. A perfect hash table (which is usually precomputed for constant symbols), has a constant performance between 1.0 and 1.3 or thereabouts; if it gets to 1.5 you rework the hashing to get it lower). So anyway, this compiler group discovers that they no longer have 32K, or 128K, or 512K. Instead, they now have a 4GB virtual address space. “Hey, let’s use a really big hash table!” you can hear them saying, “Like, how about 1 MB table?” So they did. But they also had a very sophisticated compiler technology designed for small and relatively dense hash tables. So the result was that the symbols were fairly uniformly distributed over the 256 4K pages in that 1MB, which meant that every symbol access caused a page fault. The compiler was a dog. When they finally went back to a 64K symbol table, they found that although the algorithm had poorer “absolute” performance from a purely algorithmic viewpoint (taking many more instructions to look up a symbol), because it did not cause nearly as many page faults, it ran over an order of magnitude faster. So third-order effects do matter. http://www.flounder.com/optimization.htm

You also have to worry about that constant factor hidden in the Big-O notation.

What’s interesting is how basic knowledge in computer science keeps being lost. There is no culture of measurement, education ignores basic technology, and engineering methodologies are discarded.

Basically, what is missing [in classical automata theory] is the notion of interaction: during the execution from initial state to final state, a system may interact with another system. This is needed in order to describe parallel or distributed systems, or so-called reactive systems. When dealing with interacting systems, we say we are doing concurrency theory, so concurrency theory is the theory of interacting, parallel and/or distributed systems.[Bae05]

Actually a sophisticated notion of state machine product was developed for representing composition of “interacting” state machines starting in the 1950s[HS66]. A general survey can be found in a monograph by Gecseg[Gec86], Domosi provides a more modern, more algebraic treatment [DN04] and [Yod09] provides practical techniques for construction of complex products.
[...]
The reader familiar with the process algebra literature will note that such an effort must find a way to model the non-determinism that is so fundamental to the process algebra world-view. Since deterministic programs are used to produce pseudo-random number sequences and to model Brownian motion and even the stock market (perhaps not the best example at this date) the problem is easier to solve than it appears at first. Section 4 will include a short discussion on the difference between “real” non-determinism and simulated non-determinism, but certainly there is nothing in the basic axiom set of Milner’s original process algebra that notices this distinction as far as I can see.

To read more see the paper.

In graduate school she was very much alone, though she was a grader for an undergraduate course taken by Raymond Johnson. In her first class, she was the only Black, the only woman. Her classmates ignored her completely, even terminating conversations if she came within earshot. She was denied a teaching assistantship, although she was an experienced (13 years) and excellent teacher. She wrote further:”I could not join my advisor and other classmates to discuss mathematics over coffee at Hilsberg’s cafe…. Hilsberg’s would not serve Blacks. Occasionally, I could get snatches of their conversation as they crossed our picket line outside the cafe.” She could not enroll in professor R.L. Moore class as he explicitly stated that he did not teach Blacks. Overlooking all this, one of her professors, complaining against the civil rights demonstrations, said to her: “If all those out there were like you, hard-working and studious, we wouldn’t have any problems.” Her reply: “If it hadn’t been for those hell-raisers out there, you wouldn’t even know me.”

NYTimes. But when she was raising money for Crimson Hexagon, a start-up company she co-founded in 2007, she recalls one venture capitalist telling her that it didn’t matter that she didn’t have business cards, because all they would say was “Mom.” Another potential backer, reports Claire Cain Miller in The New York Times, invited her for a weekend yachting excursion by showing her a picture of himself on the boat — without clothes. When a third financier discovered that her husband was also a biking enthusiast, she says, he spent more time asking if riding affected her husband’s reproductive capabilities than he did focusing on her business plan.

Ultimately, none of the 30 venture firms she pitched financed her company. She finally raised $1.8 million in March 2008 from angel investors including Golden Seeds, a fund that emphasizes investing in start-ups led by women.

On the other hand

She learned how to handle male-dominated pitches early in her career, when Rivals.com was buying another start-up. She was in the conference room, pouring a cup of coffee, when the other company’s executives and lawyers walked in. They proceeded to discuss the lowest bid they would accept, as if she wasn’t there.

“They assumed I was the admin,” or secretary, she says. When the group sat down to negotiate, she adds, “Their faces went white as ghosts.”

Priceless

Length 5 queue

An and-gate with 2 state delay

and gate delay 5 ATT TwoPi rendering

To see the structure hidden in this diagram we have to look at it through algebra and programs.

The biggest VA outlay — and its biggest savings generator — was the Vista’s Computerized Patient Record System, the home-grown system for electronic health records that was found by the study to cost $3.6 billion. Other IT networks for administering medications with bar codes, picture archiving and communication systems and the Laboratory Electronic Data Interoperability application together cost $470 million.

Lots of money. Result – you can predict this right? Big government bureaucracy. Massive billion dollar software development project.  And the result is:

The bottom line: “We conservatively estimate that the VA’s investments in the four health IT systems studied yielded $3.09 billion in cumulative benefits net of investment costs by 2007,” say the authors, a team from Center for IT Leadership at Partners Healthcare in Charlestown, Mass. The results looks at measures such as reduced workloads, freed workspace and savings from items such as unneeded medical tests and avoided hospital admissions.

Ok. One should cultivate skepticism of such studies, but it is interesting. The system, by the way is not open source - it is public domain. And it’s based on the venerable MUMPS so there, all you language purists. Look at this code fragment, from the Wiki entry, and weep.

%DTC
%DTC ; SF/XAK - DATE/TIME OPERATIONS ;1/16/92  11:36 AM
     ;;19.0;VA FileMan;;Jul 14, 1992
     D    I 'X1!'X2 S X="" Q
     S X=X1 D H S X1=%H,X=X2,X2=%Y+1 D H S X=X1-%H,%Y=%Y+1&X2
     K %H,X1,X2 Q
     ;
C    S X=X1 Q:'X  D H S %H=%H+X2 D YMD S:$P(X1,".",2) X=X_"."_$P(X1,".",2) K X1,X2 Q
S    S %=%#60/100+(%#3600\60)/100+(%\3600)/100 Q
     ;
H    I X<1410000 S %H=0,%Y=-1 Q
     S %Y=$E(X,1,3),%M=$E(X,4,5),%D=$E(X,6,7)
     S %T=$E(X_0,9,10)*60+$E(X_"000",11,12)*60+$E(X_"00000",13,14)
TOH  S %H=%M>2&'(%Y#4)+$P("^31^59^90^120^151^181^212^243^273^304^334","^",%M)+%D
     S %='%M!'%D,%Y=%Y-141,%H=%H+(%Y*365)+(%Y\4)-(%Y>59)+%,%Y=$S(%:-1,1:%H+4#7)
     K %M,%D,% Q
     ;