flock | safe file locking library in Go ( originally github | Architecture library

It's very bold of you to claim you have locked the file when you didn't check the result of fcntl.

Anyway, that is the expected behaviour. All getting a lock does is prevent others from getting a lock.^[1] It doesn't prevent anyone from reading from or writing to the file.

1. A write lock prevents anyone from getting a lock, while a read lock only prevent write locks from being obtained.

I see nothing in this code that can cause an out of bounds access. However, you should not increment i on any loop iteration that removes an organism, otherwise you will skip the next organism in the list.

Imagine on the 1st loop iteration, the organism at index 0 needs to be removed. Subsequent organisms move down the list. On the next loop iteration, i gets incremented to 1, and the organism that had moved into index 0 is skipped.

Try this instead:

Here's an example with -u working with file descriptor 9 open on a file mylock, successfully unlocking 9 so that a backgrounded flock mylock can proceed. Note that flock 9 cannot also have a command as in that case the "9" is taken to be a filename, not an fd.

The reason why you are not seeing obvious performance gains from the Quadtree is because of the nature of your simulation. Currently, the default separation causes a large number of boids to "converge" to the same position.

Lots of objects in the same position is going to negate possible speedups due to spatial partitioning. If all the objects are in the same or near position, boids in the area a forced to check against all other boids in the area.

You can demonstrate to yourself that your Quadtree is working by watching or profiling your application with its default settings. Now turn separation up to maximum. You will see visually, or through profiling, that as the boids spread out more evenly, the FPS increases significantly. This is because the Quadtree can now prevent computations thanks to its spatial partitioning.

With default low separation:

With maximum separation:

You can see how performance is increased in the second image. Also note, that the conjecture by another commentor that it is the construction of the Quadtree (insert) that is taking up all the time is wrong.

While in some applications you may be able to update a Quadtree as things move around, since in this simulation every constituent moves every frame, reconstructing the Quadtree from scratch is less work, then taking every object out and reinserting it into its new position.

The advice to skip square-rooting and just use the distance-squared is good though as this will get you a bit more performance.

You can do it with the $event parameter. Make sure to compare your values safely.

If your value is not in the right type or has spaces or unwanted chars, this c.state == val might not work.

You can use the trim function to compare your value safely: c.state.trim() == val.trim()

HTML

You need a space between your : and your >. This is what you want:

You're restricted to OpenGL 2.1 Context when calling OpenGL from a Unix System perspective on MacOSX. In order to get OpenGL3.2 in XCode use GLKit (GLK) Library functions to automatically retrieve a GL 3.2 context. These libraries are all now deprecated past OSX 10.14.

Let's ignore the forEach loop for a second and just look at the displayFunctions that we are creating. You can call:

Unrelated: using w mode in this context is weird, do not you mean a mode here?

As you are using fcntl I shall assume a Unix-like system here

If you do not use locks, you have what is called a race condition. It means that under small load, the risk of problem is close to 0, but it could increase under higher load. This us something that sysadmins hate, because it leads to non reproducible problems.

A lock costs indeed some resources, but under normal load (where the non locking version would not experience any problems), there would be no contention on that lock, so it should not be noticeable. Under heavy load, it would prevent garbled messages if two processes tried to write at the same time.

If you want to prevent contention under heavy load, you could wait with a short timeout. It is easy on a number of systems or requires explicitely calling alarm on some others. If the lock could be acquired, just proceed with writing to the file. Else, skip that writing and if possible log (elsewhere) the error condition for later analysis.