I heard Java's 'new' > C's 'malloc'

Please C community, say it isn't so! If Java's 'new' is faster than 'malloc' then is there even any point in using C anymore?

For example, I posted before about moving meshes and linked lists and stuff. I finally learned the proper scheme which actually has nothing to do with what I thought it would have to but in this code, I'm allocating a lot. Like, a lot a lot.

Should I then just re-write all my code in Java or stick to C? Keep in mind, this code needs to be multithreaded for an arbitrary amount of threads and be able to run on a supercomputer cluster kind of thing. Does C exceed Java's ease-of-use and speed here and that's why I should stick with it?

It depends on how well you program in C and Java, and if any difference actually matters in your case.

Quote:

---

Originally Posted by MutantJohn

Please C community, say it isn't so! If Java's 'new' is faster than 'malloc' then is there even any point in using C anymore?

---

You can get sometimes considerable speed up in C by writing your own special purpose allocators (see the chapter "memory games" in my book). For instance if you need a lot of objects all of the same, fairly small size, a block allocator can compile to a few machine instructions.

C gives you control that Java can't.

Okay. I'm taking a Cartesian grid full of nodes and some of them will contain pointers to particle structures. This is a particle mesh so you have a mesh as a base allocation and then particles are allocated and placed in random points on the mesh.

What I'm doing is, take each node that contains a particle and build a tetrahedra. You need 4 points to do this and the idea is, you build corresponding tetrahedra such that every particle node is a vertex of some tetrahedron. So I have a mesh structure, particle structures and then a tetrahedron quadtree. I wonder if I could instead remove the mesh structure and build the tetrahedron tree based off of solely the particle structures. I think I could, actually. But the physics of why keeping/removing the Cartesian mesh are beyond this forum.

But now that you have a better idea of how much I'm allocating and managing, does Java do all this better? Its class system seems kind of backwards and icky to me.

Would Java be faster in terms of execution speed? Probably not.
Would it be faster to use Java to implement this? Probably yes.
Would it be easier to use Java to debug this? Probably yes.
Also, malloc is often optimized for bigger allocations, not smaller ones.
So there you have it. Pick your poison.

Code:

---


struct particle
{
  /* data you need for the particle (mass, velocity,
      whatever */
  strcut particle *next; /* used for memory mangement*/
};

struct tetrahedron
{
  int pi[4]; /*indices into the mesh */
};

struct particle *mesh[width][height][depth];
struct tetrahedron *tets[MAXTETRAHEDRONS];
int Ntetrahedrons;

struct particle memorypool[MAXPARTICLES];

---

Is that the system you want?

Malcolm, that is very close, actually. Just add "struct tetrahedron *neighbours[4];" to the tetrahedron structure definition. What the code is supposed to, create a tetrahedron that contains all particles and then insert a particle one at a time. Each insertion is supposed to break a tetrahedron into 4 daughters, which is why I mentioned the quadtree because it's so similar in execution.

So, this is formally called Delaunay triangulation and there is a lot of stuff done on it but only in 2D, it seems. I'm also using Springel 2009, titled "Galiliean-invariant cosmologicalhydrodynamical simulations on a moving mesh". So basically, he says that a tetrahedron is valid if the circumsphere around the vertices of the tetrahedra does not contain any other point from the set.

I have code now that takes 4 vertices, inserts a new point and then creates 4 daughter tetrahedra. Each one excludes a unique point AND each one also passes the Delaunay-hood test. Are these therfore non-intersecting tetrahedra? So, we have 5 points. The old tetrahedron and the new insertion. The insertion requires 3 neighbours. We have 4 choices at first, 3 second and then 2 last. Therefore we have 4*3*2 = 24 unique cases. We sort tetrahedra by orientation and only keep the positive ones. Now we have 12. Each tetrahedra also needs to exclude a unique point so we remove degeneracy and now only have 4 cases. Degenerate in this case means valid tetrahedra that exclude the same point but are in a different order.

I think what I have should be working as I exclude 4 unique points and each one passes but I'm not sure how to explicitly test for intersection.

C's malloc is as fast as your C library decides to make it. As far as the language itself goes, it can wait ten hours before returning a null pointer on every call. Either way, I suggest using whatever language you actually know.

Quote:

---

Originally Posted by MutantJohn

Please C community, say it isn't so! If Java's 'new' is faster than 'malloc' then is there even any point in using C anymore?

---

With logic skills like that, your programs must work perfectly

I must agree, that is a silly statement. If you don't like your C library's malloc(), C lets you write your own memory manager. That is one advantage of C over Java; more low-level control. If Java's new() is optimized to be super-fast, then it must make design trade-offs in terms of wasted space. All of the GC algorithms have these trade-offs, but with Java you're stuck with the one in your interpreter.

Quote:

---

Originally Posted by MutantJohn

Please C community, say it isn't so! If Java's 'new' is faster than 'malloc' then is there even any point in using C anymore?

---

If your claim is true, then that speed of "Java's 'new'" is probably associated with increased memory usage and memory fragmentation. All real computers have finite memory and increased memory usage or fragmentation practically slows down programs in unpredictable ways. On that basis, is there any point in using Java anymore?

So my gcc is 4.8.0. Does that mean that my standard malloc is teh awesome? Or is there actually a faster one that I can download from somewhere? It'd be sweet if someone made a better memory manager than the people who make C though I doubt that that happens.

GCC is a C compiler, not a C library.

In a program where all the objects are only allocated one time, it could just do a single malloc, then just set the pointers for each object as offsets from the pointer returned from malloc (and only a single call to free when the program is done). I've seen this done a few times.

Getting back to the original post, what is suppose to be better about new / malloc in Java versus C / C++, and is this enhanced new / malloc tied to a specific version of Java?

Quote:

---

Originally Posted by MutantJohn

Malcolm, that is very close, actually. Just add "struct tetrahedron *neighbours[4];" to the tetrahedron structure definition. What the code is supposed to, create a tetrahedron that contains all particles and then insert a particle one at a time. Each insertion is supposed to break a tetrahedron into 4 daughters, which is why I mentioned the quadtree because it's so similar in execution.

So, this is formally called Delaunay triangulation and there is a lot of stuff done on it but only in 2D, it seems. I'm also using Springel 2009, titled "Galiliean-invariant cosmologicalhydrodynamical simulations on a moving mesh". So basically, he says that a tetrahedron is valid if the circumsphere around the vertices of the tetrahedra does not contain any other point from the set.

I have code now that takes 4 vertices, inserts a new point and then creates 4 daughter tetrahedra. Each one excludes a unique point AND each one also passes the Delaunay-hood test. Are these therfore non-intersecting tetrahedra? So, we have 5 points. The old tetrahedron and the new insertion. The insertion requires 3 neighbours. We have 4 choices at first, 3 second and then 2 last. Therefore we have 4*3*2 = 24 unique cases. We sort tetrahedra by orientation and only keep the positive ones. Now we have 12. Each tetrahedra also needs to exclude a unique point so we remove degeneracy and now only have 4 cases. Degenerate in this case means valid tetrahedra that exclude the same point but are in a different order.

I think what I have should be working as I exclude 4 unique points and each one passes but I'm not sure how to explicitly test for intersection.

---

The equation of a plane is Ax + By + Cz + D = 0. x,y and z are the normals to the plane. If you enter a point x,y,z into the equation, it is 0 if it lies on the plane, positive if it is in front of it, and negative if it lies behind it. So as long as you get your normals the right way round, you can easily test if a point is within or without a tetrahedron.

If two planes have different normals, they are not parallel and will intersect. There is a line which defines the intersection and (I hope I'm getting this right), a plane which contains the line and is normal to the other two planes. If you define a shape (e.g. triangle) on both planes, and they are all on opposite sides of this plane, the two do not intersect. I need to check that I'm right on this, but if I am, you can easily test for intersecting tetrahedra. Remember you have to handle the case of a tetrahedron which is contained within another separately.

The memory problems are easily solved with a fixed block allocator. If you have a system of nested tetrahedra, you might also need "mother" and "child" tetrahedra.