News for hackers. Stuff that matters.
Re:Is Scala really Faster than Java? by ColinWright on Tuesday June 21, 2011 @08:14AM (#2678403)
This sentence stood out for me ...

    My basic (starter) understanding of Functional
    programming tells me that there should be more
    object churn in a functional language ... and
    thus Scala should have trouble with GC not the
    Java implementation.
My experience is that in an OOP language, objects are brought forth, used, then discarded, oft-times requiring GC. My experience of well-implemented FP languages data streams through functions that have, in the large part, been optimised away.

I don't have deep or broad experience, and it's ceretainly true (as I see it) that naive implementations provoke lots of GC. But it didn't seem obvious to me that OOPLs should provoke less, and it does seem reasonable that FPLs might easily provoke less.

I'd be interested to hear some of our more experienced HNers comment on this.

Re:Is Scala really Faster than Java? by jmreardon on Tuesday June 21, 2011 @08:44AM (#2678495)
High object churn shouldn't be a problem for the JVM, whether it is running Scala or Java code. Allocation lots of little objects and then discarding them shortly after is a use case the JVM is well optimized for. You would have to allocate an extraordinary number of such objects to see any real slowdown.

The Oracle JVM uses generational garbage collection[1]. Glossing over some details, this garbage collector divides objects into generations depending on how long they've been around, and also keeps track of references that cross generations. Objects that are newly created go into the first generation. If the objects don't refer to objects outside of the first generation, it is very cheap for the VM to determine they are in fact garbage. When the garbage collector gets run, objects that a still live get copied to another generation. Once the still live objects are copied out, the VM doesn't need to do any cleanup to get rid of the dead objects, it simply marks the whole memory block the first generation was in as available.

[1] Not that other JVMs don't, but I only know the official one.

Re:Is Scala really Faster than Java? by gaius on Tuesday June 21, 2011 @08:48AM (#2678508)
Oracle have put an enormous amount of work into the JRockit GC to support determinism. It's very clever: you can say to it, no GC pauses longer than X milliseconds, and it will adjust its throughput to guarantee that. So you might get lower overall performance, but it will be predictable.
Re:Is Scala really Faster than Java? by bad_user on Tuesday June 21, 2011 @09:59AM (#2678763)

      simply marks the whole memory block the first 
      generation was in as available
That doesn't make any sense.

On that GC run what if you just allocated an object, 0.01ms ago? You mean to tell me that it's either (a) deallocated before being used or (b) moved to the second generation already? Also, you need to basically stop the world for doing first-generation cleanup, as you described it, otherwise you're running into race-problems. That's insane.

Glossing over some details, no matter how efficient the GC is in regards to first generation treatment, you're still accessing the heap, which is an expensive operation, you're still potentially boxing/unboxing primitives in loops and you're also making single-dispatch virtual calls on those short-lived objects.

C++ has terrible performance when using heap-allocated values, but with stack-allocated objects C++ kicks Java's butt. And that's not the only potential problem for Scala, unless Scala adds some kind of tracing compiler that can avoid boxing/unboxing and runtime-dispatch when not necessary.

Re:Is Scala really Faster than Java? by jmreardon on Tuesday June 21, 2011 @10:58AM (#2678985)
I can tell you is isn't being deallocated before being used, that would be a major bug. So, I guess it would get moved, but the GC probably won't run unless the first gen space is pretty full. I'm glossing over details because, well, the GC in the JVM is a very complicated piece of work, and I don't know much of the details, but the JVM does in fact default to a stop-the-world garbage collector[1].

I don't think anyone actually expects the JVM to beat C++ using stack allocated objects[2]. Our concern is how well a garbage collector handles lots of small objects.

[1] Details on how the JVM GC works: http://www.oracle.com/technetwork/java/gc-tuning-5-138395.ht... [2] There is a switch, which will be on by default one day, that lets the JVM do escape analysis so it can allocate objects on the stack automatically.

Re:Is Scala really Faster than Java? by daniel_solano on Tuesday June 21, 2011 @09:39AM (#2678680)
It all depends on the context. In code that is not performance-sensitive, a bit of object churn isn't a problem.

However, there are places where a lot of object churn can really be problematic. In particular, I find that Android applications tend to be somewhat sensitive to this. However, even in desktop or server applications, a lot of object churn in a tight loop can be bad.

Re:Is Scala really Faster than Java? by bad_user on Tuesday June 21, 2011 @09:45AM (#2678706)
That's because when people talk about the JVM's performance, they refer to Oracle's Java SE, not Android and not Apache Harmony.
Re:Is Scala really Faster than Java? by gaius on Tuesday June 21, 2011 @08:35AM (#2678465)
I can't find the link right now, but there was a blog post from one of the F# team at MS, saying the CLR team couldn't believe the rate at which he was allocating and deallocating memory, and some tuning needed to be done on the CLR to support F# performance. If you are working with recursion and folding rather than for-loops, under the covers you will be doing one malloc() per iteration, you will definitely need some sort of clever memory management rather than relying on just the OS's implementation.
Re:Is Scala really Faster than Java? by Peaker on Tuesday June 21, 2011 @08:51AM (#2678519)
Why would there be one malloc() per iteration if you have tail-recursion?

Also, isn't malloc() a misnomer for stack allocations?

Re:Is Scala really Faster than Java? by jules on Tuesday June 21, 2011 @09:10AM (#2678585)
Tail recursion has nothing to do with garbage collection in F#. You're going to have one allocation per iteration if you do e.g. a map over a list. In an imperative language you'd probably mutate the collection in place.
Re:Is Scala really Faster than Java? by eru on Tuesday June 21, 2011 @09:43AM (#2678699)
Unless, and I guess that's what ColinWright alluded to, you have extensive stream fusion that will get rid of intermediate data structures.
Re:Is Scala really Faster than Java? by jules on Tuesday June 21, 2011 @10:05AM (#2678784)
That's something else entirely compared to tail call optimization, but yes some functional languages (e.g. Haskell) do this. I don't think F# does stream fusion though.
Re:Is Scala really Faster than Java? by loup-vaillant on Tuesday June 21, 2011 @10:25AM (#2678849)
I'd be surprised if the current implementation of F# didn't do anything of this sort. But as a language, I understand fusion is more difficult in ML than in Haskell: that's because ML is strict and non pure. Therefore, some of the assumptions you could do in a non-strict, pure language don't hold, and it may not be unconditionally true that

  ∀f, ∀g, map g ∘ map f == map (f ∘ g)
because f or g could perform some side effect, or fail to terminate. (My example may be bogus, but I'm sure we can find some real one.)
Re:Is Scala really Faster than Java? by eru on Tuesday June 21, 2011 @11:37AM (#2679178)
Failure to terminate exists in Haskell, too.
Re:Is Scala really Faster than Java? by loup-vaillant on Tuesday June 21, 2011 @12:04PM (#2679291)
Sure, but the order of evaluation do change something. For instance, infinite lists won't ever terminate, but taking the first 42 elements of an infinite list will terminate in Haskell, and not in ML. If you want to fuse the whole thing, it won't change the Haskell program, but it may change the ML one, by making it terminate an return the correct result!

That's not an optimization any more, that's a language feature.

Re:Is Scala really Faster than Java? by eru on Tuesday June 21, 2011 @03:25PM (#2680032)
Yes. Though the situation is only that rosy in Haskell under some circumstances. It's easy to get space leaks that make your program use O(run-time) memory, if you are not careful with the laziness.
Re:Is Scala really Faster than Java? by loup-vaillant on Tuesday June 21, 2011 @05:38PM (#2680540)
Agreed. My only point is that automatic fusion (stream, shortcut, and even inlining in general) "works" more often in a pure and lazy setting.
Re:Is Scala really Faster than Java? by gaius on Tuesday June 21, 2011 @09:46AM (#2678710)
In this case, I believe not:

http://java.sun.com/docs/books/jvms/second_edition/html/Over...

You would not be using the stack for this.

Re:Is Scala really Faster than Java? by sandGorgon on Tuesday June 21, 2011 @08:38AM (#2678478)
Copy-on-write data structures (like the ones Clojure uses) may help mitigate some of the object churn.
Re:Is Scala really Faster than Java? by lemming on Tuesday June 21, 2011 @08:45AM (#2678497)
Only in some (read-heavy) workloads - in general I'd expect persistent data structures to generate more garbage, since mutability by definition allows you to modify and reuse nodes.

Edit: thinking about this on the way back from lunch, read-heavy workloads give you the best case for persistent data structures, but that's still the same as for mutable structures, i.e. no object churn. I can't think of any cases where persistent structures would create less garbage.

Re:Is Scala really Faster than Java? by jriddycuz on Tuesday June 21, 2011 @11:21AM (#2679096)
I think you'd be surprised.

Persistent data structures allow the VM or compiler to determine when things need to be copied. Mutable structures require programmers to worry about copies, so they will make copies when they feel they might be necessary. In very well-defined cases a smart programmer can optimize this to a point where it probably uses less memory than a persistent data structure, but in the average case (and with the average programmer), the VM will likely do a better job of knowing when to copy and when to not bother.

Re:Is Scala really Faster than Java? by eru on Tuesday June 21, 2011 @11:40AM (#2679202)
Persistent data structures will win, when your structures have (potentially) multiple futures. If you use your objects in a linear way, then the best you can hope for is your compiler to be smart enough to do something that's as fast as in-place updates.
Re:Is Scala really Faster than Java? by lemming on Tuesday June 21, 2011 @01:18PM (#2679566)
You're right, I would absolutely be surprised.

Persistent data structures intrinsically involve copying on updates, and no amount of compiler cleverness can avoid that. I can see the possibility for compiler magic with stream fusion, for example, but I'm not seeing it for data structures. The only win I can see is if you have multiple clients of your data structure holding references to multiple versions, but even there the compiler doesn't help you. Am I missing something?

Re:Is Scala really Faster than Java? by eru on Thursday June 23, 2011 @10:59AM (#2688073)
> Persistent data structures intrinsically involve copying on updates, and no amount of compiler cleverness can avoid that.

The compiler magic can help you there. You are looking for linear types.