Correct way to pass pointers around labview

Question

Hello,
what is the correct way to pass pointers, pointing to DLL allocated memory around labview ?
I have been for quite some time using the standard C type cast working as:
typedef struct
void *mem;
} myVars;
int InitMyVars(int64_t *myVarsLVPtr)
void *myVarsPtr = NULL;
myVarsPtr = malloc(sizeof(myVars));
if(myVarsPtr)
*myVarsLVPtr = (int64_t)myVarsPtr;
return 0;
return -1;
int UseMyVars(int64_t *myVarsLVPtr)
void *myVarsPtr = NULL;
myVarsPtr =(void*)*myVarsLVPtr;
//return funcWithVars(myVarsPtr);
Afterwards configure the library call nodes as follows:
And pass the pointer around in labview as an 64 bit number (since it is a pointer value, I think it does not make difference if its signed or unsigned, please facepalm me if wrong)
This way is very ugly. I do not like it. Found several discussions stating that "Every time someone writes a code like int tmp = (int)(&something); a little fluffy kitten chokes to death. Unfortunately, programming so far had been quite a felinicide." This makes me a serial kittenchoker.
It is also dangerous, for different platforms eg. i686 and x86_64.
I was self learning all this stuff, now looking back at it, it feels like I missed something big time.
There must be a better way.
I am thankful for suggestions.
Solved!
Go to Solution.

Answer 1

nathand wrote:
It would help for you to post real code, or at least consistent examples. Where in your code are you actually using the cast from pointer to integer that you are trying to avoid?
Lines 12 and 21 in the 1st post
*myVarsLVPtr = (int64_t)myVarsPtr;
myVarsPtr =(void*)*myVarsLVPtr;
 Sorry, but I cannot see how are my examples inconsistent, I only supplied one. I know it consists of 2 images and some code, but still describes the same process.
nathand wrote:
There is no need for LabVIEW to know whether a wire contains a pointer or a number - either way, it's just a number. There are many situations in which the Call Library Function Node configuration does NOT match the function prototype, but you get the correct result.
You allways have to match the function prototype, if you do not, you corrupt memory. I guess you mean, that the function prototype may be written different, as long as the datatypes and memory layout is the same.
nathand wrote:
One such situation is when the wire contains an address. In that case, even though the function prototype specificies that the parameter is a pointer, in LabVIEW you should configure that parameter to be passed BY VALUE because the value on the wire already is a pointer. Does that make sense? In your example code, you have essentially created a handle, because the myVars data type contains a pointer. Your C code can move around the memory pointed to by myVars.mem as much as it wants, so long as the pointer to myVars stays constant. I'm assuming that's what you're doing; is that correct?
If you pass a variable into DLL "by value", it does exactly what it says, it passes the value. Means, if you want to change the value going through the wire, you cant, you just get the value of it to the function stack. You can assign new value to such value inside DLL, but LabView will still keep the same value in its wire, since it only passed value. Its confusing, I know.
Imagine 1 guy thinking a number, he tells it to his neighbourgh, so they both know what the number is. But if the second guy wants to change it, he cant, ho only knows the value.
If the guy 1 passes a position of such information in his brain, guy 2 can read the number and if he modifies it, guy 1 will think of the new number. However guy 2 cannot move the position.
I am not creating a Handle by making a pointer to a pointer. First, handle can be quite anything, that is used to identify an object of some use. I know LabView calls Handles the pointers to memory pointers pointing at some LabView datatype. The value in the wire, as you correctly stated, is a place in a memory, the fact, that I pass it to DLL in a "pointer style" manner, does not mean I intend to create pointer to it, I just want to know the place in memory, where LabView keeps such value, so I am able to modify it in cases it changes (inside DLL, my DLL is guy 2 and labview is guy 1).
Pointer to a memory in heap tells the computer where the memory is. You cannot move a memory and still have the same pointer.
nathand wrote:
If so, then again, in LabVIEW you should be passing the pointer by value. I think this will avoid the dereference cast that's bothering you. As you have it now, you are adding an unnecessary extra layer of reference (LabVIEW is passing a pointer to an address, rather than the address itself), which you then need to cancel out with the cast that you don't like.
I cannot avoid type cast in LabView, since you are LabView limited. I am trying to avoid casting a pointer to integer.
There is a reason why pointer is of datatype pointer. It is platform specific, it can be flat number or something more complex, so anytime I make a number from a pointer, it is risky, I am mixing apples and bananas + the kitten chokes.
Thank you for answer.