Intel-Altera, again

...in an artery. I don't see that happening anytime soon.

I've been thinking about one of the Microsoft (or similar) fitness monitors with a heart rate monitor but I haven't been able to wear a watch for 30 years, or more.

No, we are talking about cooling the device. That's got nothing to do with what peripherals are in use.

What's that got to do with the point made?

I've never seen a 50W ARM, either. 20W dual A15s, perhaps, if there is no dynamic power management in use.

Mathematically, OK. What's that got to do with real life?

Perhaps the growth is gone but I don't see the market shrinking a bit, given the marketing model (2-year "forced" replacement).

Which means that you can install more bugs, faster. ;-)

The problem is recognizing it before it's too late.

"A fool and his money are soon parted."

I think around here we call those "bugs" :)

--
Les Cargill

That's incorrect. There is a proof that /end/ recursion and iteration are equivalent. Theres also a proof that _by_adding_a_stack_ any recursive algoithm can be tranlated into an iterative one.

--
umop apisdn

The proof is in the BSoD. ;-)

There's no such thing as a Turing-complete computer, in the strict sense (unlimited "tape").

Topical suggested reading: Ackerman(n?) function, "Busy Bee" function.

Tim

-- Seven Transistor Labs, LLC Electrical Engineering Consultation and Contract Design Website:

No, end recursion is just a subclass of the general equivalence. And particularly easy for the compilers to make use of.

No, one stack is not enough to cover any recursive (i.e. recursively enumerable) function. What you get then is called a linear bound automaton and it is capable of computing only those rec. functions that define context-free languages. You need two stacks (or their equivalent) to be able to compute any function a Turing Machine can. But it is OT, comp.theory is a much better place to continue.

Best regards, Piotr

And there is no such thing as imaginary current. Or the Heaviside step function. They exist in the same, abstract, mathematical sense. All are worth studying on their own, but in practice they are just extremely useful tools to reason about the real systems. Otherwise, any faithful Fourier analysis of an EMP event caused by a simple light switch should include the tail composed of gamma photons and (infinitely) far beyond it. Does the fact that no sane engineer would even think about that prove that Fourier analysis (a branch of pure mathematics...) is useless crap? :-)

Best regards, Piotr

I don't see how that could be true in a real system- you can iterate

100,000 times in a for loop with a few bytes of RAM. To use recursion requires the storage of (at least) 100,000 return addresses.

P.S. What kind of industrial controllers did you have in mind?

--
Best regards,  
Spehro Pefhany 
Amazon link for AoE 3rd Edition:            http://tinyurl.com/ntrpwu8 
Microchip link for 2015 Masters in Phoenix: http://tinyurl.com/l7g2k48

It seems weird that there are so many incompatibilities between "steps" of x86 CPU's. All your software adjusts itself to the particular bugs of your step. If you add a second CPU to a mobo with 2 sockets, they have to be the same step. It seems pretty pathetic.

I'm not sure what that sentence means.

I went out to the investment community to find those numbers, two independent sources gave roughly the same figure. I don't think it was at all based on data center stuff as that is very much an unknown and in the early stages still. Intel may be interested in investing in data center growth, but the guys writing the reports have to maintain some credibility.

Smartphones have pretty much nothing to do with FPGAs. Such high volumes generate a lot of ASIC designs.

Lol. I use Lattice tools and for the most part it isn't much different from using C. I get to simulate a lot better in that it is easier to write test benches that approach reality. Otherwise it is the same old, edit, compile, test cycle.

I think there is a lot of mileage left in the ARMs while PCs will continue to decline slowly.

Maybe I'll check that out when my Internet is restored... again.

--

Rick

In a machine with gigs of memory, that's not completely out of the question.

Look: the map from recursion to iteration is just that - a map, one to one and onto. It's just a convenient way to survive in environments in which direct recursion is frowned upon.

You have to get up pretty early to find an inherently recursive algorithm for which there is no iterative equivalent.

All of 'em. That industry is just ripe for disruption.

--
Les Cargill

They became on a par with stereos and TVs. They became actual mass consumer goods.

Yessir - I agree. I did the same after you posted "8% CAGR".

Agreed.

Heh :)

ASICs and FPGAs have always had a market-share dance.

Some of the lower-power FPGAs have finagled into smartphones on the last couple years - you can see the bump in Altera's price form it 2013-2104 or so.

The story from the marketing literature is time to market. I'm with you - I'd think ASICs but this is what they say.

Well, good.

Probably.

No way!

--
Les Cargill

Sure there is. Imaginary lengths, too (I came up with a good geometry 101 analogy for that, in fact).

No sane engineer would even think a light switch was capable of sub-attosecond risetimes. That was one weak straw man. :-)

One of the things they teach in Physics is the duality between wave and particle. There's no such thing as a perfectly localized particle, nor a perfectly delocalized one. Only proportions towards one side or the other. Exactly the same for time and frequency: we use steady state as an aid, but no sane engineer[1] would think it's the absolute case, that some random signal has sine waves forever.

[1] Now we're probably getting more subtle. Trap is, many of them *do* believe this... :)

And don't even get me started on how un-real "real" numbers are!... ;-)

Tim

--
Seven Transistor Labs, LLC 
Electrical Engineering Consultation and Contract Design 
Website: http://seventransistorlabs.com

I once wrote a Minesweeper clone, years ago. This used two recursive algorithms: one to expand and clear empty squares, and another (more complex) one to actually solve the field automatically (therefore removing the more boring burden from the player, poking at obviously clear squares).

I originally wrote it in QBasic (this was years ago, remember?). It got, I think 20 passes or so, then kaboom, stack blowout. Well, QB is terrifically bad, no surprises there. Changed it to a stack in a fixed array, worked just fine.

Then I ported it to assembly (some other boring summer, years ago?). That procedure has...

-=-=-=-

; Stack format is: ; col:word, row:word, offset:word ; so each square's location is passed, as well as its offset in DS. This ; saves an addressing step, at the expense of more memory. ;

mov initSP,sp ; save current stack pointer so we know when we're done mov errCode,0 ; assume success (return 0)

mov bx,col mov cx,row push bx ; start by pushing the first square onto the stack push cx push si

...

stakLoop: cmp sp,initSP ; check if we have anything to pop off je finZero

pop si ; yup, popping... pop dx pop cx

; ; Check the eight nearest neighbors. ;

neighbors:

...

; looks good, get this neighboring square

cmp sp,STACK_BOT jbe stakBlow ; check that the stack doesn't blow

push cx ; this square is zero and hasn't been explored, push dx ; put it on the stack for later push si

...

add bx,2 ; addressing WORDs cmp bx,8*2 jl neighbors

; and recurse

jmp stakLoop

-=-=-=-

Although the procedure itself is in a properly recursive stack frame, it would take 9 WORDs per pass, and a lot of extra cycles (not that that application was time-critical or anything..). Plus passing the termination conditions (blow stack, or other error or completion), which is inelegant. So this does it in only 3 WORDs, one of which is redundant (the offset into the array is saved only for convenience, because 8086 MUL sucks).

Is this application recursive? Semantically, no; it doesn't call itself. Architecturally, yes and no; it uses the hardware stack as such, and it's not accessing a stretch of memory as an array. But it's not using it to control execution (i.e., return addresses). Could it be implemented with a linear array? Hell yes, as easily as anything.

(Also, ah, yes... 28k of asm code and comments -- mostly the latter -- assembles to all of 7k as .EXE. Gotta love that efficiency, even if it's useless on a program like this. ;-) )

Tim

--
Seven Transistor Labs, LLC 
Electrical Engineering Consultation and Contract Design 
Website: http://seventransistorlabs.com

You need as many storage cells as the computational complexity analysis of a given algorithm indicates, up to a constant factor, independently on whether it is recursive or not. For example, the recursive variant of the self-balancing trees, mergesort or quicksort done properly require only O(log(n)) recursion levels, which for all practical inputs can be bounded by 64.

Recursion done right doesn't bite and is very natural way to express many things. One "just" needs to think and be careful. Exactly the same applies when one needs to design a synchronous rectifier, for example. Both things can explode, but then the reason for that in most cases is that the designer was a moron. :-)

OTOH, since many new devices, such as the smartphones use multi-core multi-gigaherts chips to scan the keyboard (if they have them) just because they can, it is increasingly a non-issue. Why do you care about the higher initial requirements for recursion, if you program your device in Java? :-)

On a similar note, the new development servers we are about to buy will have 256GiB each and they are as real devices as an 8051. Different needs, different means...

Best regards, Piotr

And still you model it using the step function, exactly because this description is convenient and extremely accurate. And leads to absurd implications if you take it too seriously. Exactly as we do in the case of the unlimited capacity storage devices. So why are your useful abstractions fine and ours are not? :-)

Good enough for the hour it was invented. :-)

Exactly, and it is not even a physical fact. The uncertainity principle is a result from the field of Fourier analysis. For the same reason you cannot build a sine wave generator (or an FM modulator, because it requires infinite bandwidth), but nobody seems to care. :-)

Best regards, Piotr