gmon | Go program for server monitoring | Monitoring library

The linker collects dependencies first (svm_light/svm_learn.o) and fills them in when it sees a definition (-lm).

You seem to already have a $(LIBS) at the end of your ld invocation, so just:

Dumb mistake - left out "-pg" in the compilation statement. Only linked.

As pointed out in the comment by Tony Beta Lambda above, this is a bug in gcc. There are two possible workarounds: Downgrade to gcc-4.9, or compile with the flag -no-pie.

This is a glibc bug/limitation:

• -pg -pie doesn't work

If you cannot install a fixed glibc, you can link with -no-pie to disable PIE. Your toolchain probably enables PIE automatically.

Gprof is a sampling based based profiler your first example application has too small execution to be registered by the Gprof.

Try adding some sleep(1) call in the application and try at it again.

It sounds like you want to find only the MIDI destination endpoints to talk to a certain manufacturer's devices. Unfortunately that isn't really possible, since there is no protocol for discovering what MIDI devices exist, what their attributes are, and how they are connected to the computer.

(Remember that MIDI is primitive 1980s technology. It doesn't even require bidirectional communication. There are perfectly valid MIDI setups with MIDI devices that you can send data to, but can never receive data from, and vice versa.)

The computer knows what MIDI interfaces are connected to it (for instance, a USB-MIDI interface). CoreMIDI calls these "Devices". You can find out how many there are, how many ports each has, etc. But there is no way to find out anything about the physical MIDI devices like keyboards and synthesizers that are connected to them.

"External devices" are an attempt to get around the discovery problem. They are the things that appear in Audio MIDI Setup when you press the "Add Device" button. That's all!

Ideally your users would create an external device for each physical MIDI device in their setup, enter all the attributes of each one, and set up all the connections in a way that perfectly mirrors their physical MIDI cables.

Unfortunately, in reality:

• There may not be any external devices. There is not much benefit to creating them in Audio MIDI Setup, and it's a lot of boring data entry, so most people don't bother.
• If there are external devices, you can't trust any of the information that the users added. The manufacturer might not be right, or might be spelled wrong, for instance.
• It's pretty unfriendly to force your users to set things up in Audio MIDI Setup before they can use your software. Therefore, no apps do that... and therefore nobody sets anything up in Audio MIDI Setup. It's a chicken-and-egg problem.
• Even if there are external devices, your users might want to send MIDI to other endpoints (like virtual endpoints created by other apps) that are not apparently connected to external devices. You should let them do what they want.

The documentation for MIDIGetDevice() makes a good suggestion:

If a client iterates through the devices and entities in the system, it will not ever visit any virtual sources and destinations created by other clients. Also, a device iteration will return devices which are "offline" (were present in the past but are not currently present), while iterations through the system's sources and destinations will not include the endpoints of offline devices.

Thus clients should usually use MIDIGetNumberOfSources, MIDIGetSource, MIDIGetNumberOfDestinations and MIDIGetDestination, rather iterating through devices and entities to locate endpoints.

In other words: use MIDIGetNumberOfDestinations and MIDIGetDestination to get the possible destinations, then let your users pick one of them. That's all.

If you really want to do more:

• Given a destination endpoint, you can use MIDIEndpointGetEntity and MIDIEndpointGetDevice to get to the MIDI interface.
• Given any MIDI object, you can find its connections to other objects. Use MIDIObjectGetDataProperty to get the value of property kMIDIPropertyConnectionUniqueID, which is an array of the unique IDs of connected objects. Then use MIDIObjectFindByUniqueID to get to the object. The outObjectType will tell you what kind of object it is.

But that's pretty awkward, and you're not guaranteed to find any useful information.

You are setting ss->log_mmap but checking ss->data_mmap.

From your strace, mmap() has returned a valid pointer. It does not look like anything incorrect has happened or that there has been any failure. I suspect your mmap() has worked fine. Also, ENOENT is not a valid error code for mmap() to return, so it's likely you are checking errno when there is no error from the mmap().

On failure, mmap() returns MAP_FAILED, not NULL. They do not have the same value.

A private write only mapping of a file does not seem very useful. You will not write to the file, just to a private memory region you cannot read and no other process can see. You probably want MAP_SHARED so that writes can go to the file.