problem with sending array of struct over shared memory

First of all, Hello to the comunity!
I hope someone will be able to help or at least give me some hint/guide on what I'm doing wrong here.
Here is the code:

Code:

---

#include <stdlib.h>
#include <stdio.h>
 
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
 
#define KEY (5679)
 
typedef struct _command
{
        int x;
        int y;
        int xo;
        int yo;
        int lock;
} command[20];
 
main ()
{
        int shmid, shmkeyid, i, size;
        command *tuio_cmd;
        size = sizeof( *tuio_cmd);
 
        shmid = shmget (KEY, size, 0666 | IPC_CREAT);
        if (shmid != -1)
        {
                tuio_cmd = shmat (shmid, NULL, 0);
                if (tuio_cmd != (void *) -1)
                {
                        printf ("Memory attached at:%X size:%d\n", (int) tuio_cmd, size);
                        tuio_cmd[0]->lock = 0;
                        while (1)
                        {
                                if (tuio_cmd[0]->lock)
                                {
                                if (tuio_cmd[0]->xo != 0)
                                        for( i=0; i<20; i++ )
                                                printf ("X:%d,Y:%d,Xo:%d,Yo:%d\n", tuio_cmd[i]->x,tuio_cmd[i]->y, tuio_cmd[i]->xo, tuio_cmd[i]->yo);
                                else
                                        for( i=0; i<20; i++ )
                                                printf ("X:%d,Y:%d\n", tuio_cmd[i]->x,tuio_cmd[i]->y);
 
                                tuio_cmd[0]->lock = 0;
                                }
                        }
                        if (shmdt (tuio_cmd) == -1)
                        {
                                fprintf (stderr, "shmdt failed\n");
                                exit (EXIT_FAILURE);
                        }
                        if (shmctl (shmid, IPC_RMID, 0) == -1)
                        {
                                fprintf (stderr, "shmctl(IPC_RMID) failed\n");
                                exit (EXIT_FAILURE);
                        }
                }
        else fprintf(stdout,"error attaching memory\n");
        }
        else fprintf(stdout,"error in allocating shm\n");
        return 0;
}

---

I'm trying to send array of struct over the shared memory, and after all day I can't find why this won't work. (don't look at locking It's remaining of old one dimensional struct, I still need to implement semaphores)

What are you expecting exactly? your shared segment seems to be created correctly.
After that, there is an infinite loop due to the 'tuio_cmd[0]->lock' condition never satisfied
(or is it unlocked by another process? in this case, the code is missing)

There is also no guarantee that the compiler will re-read lock here:

Code:

---

                        while (1)
                        {
                                if (tuio_cmd[0]->lock)
                                {
                                if (tuio_cmd[0]->xo != 0)
                                        for( i=0; i<20; i++ )
                                                printf ("X:%d,Y:%d,Xo:%d,Yo:%d\n", tuio_cmd[i]->x,tuio_cmd[i]->y, tuio_cmd[i]->xo, tuio_cmd[i]->yo);
                                else
                                        for( i=0; i<20; i++ )
                                                printf ("X:%d,Y:%d\n", tuio_cmd[i]->x,tuio_cmd[i]->y);
 
                                tuio_cmd[0]->lock = 0;
                                }
                        }

---

Making the struct, or the lock member into a "volatile" should make the compiler re-read the data as needed.

--
Mats

Thanks for trying to help, I posted this code also on the irc C channel and there I take a laugh from some ppl. That confused me totally, as now after trying to do this for all day I'm not sure even If I wrote one single line correct. The thing is that this used to be my first atempt of sending some "tuio" commands over the shared memory with struct (single, no array, and it worked btw). That's why there is lock still there, and I didn't even try to change that as I'm stuck here: tuio_cmd = shmat (shmid, NULL, 0);
I'm not sure if I did that right .. so plz don't look at the program logic, It's not that what is giving me headache. It seams that I can't get 20 arrays of struct this way, as only first (to say this way [0]) array is parsed ok. Right now I'm really tired and my head hearts, so I'm not even sure which version of code I posted,as I changed every single bit at least 10 times. I'll post toomorrow more precise and clean code, with client side too. Anyway I need to know If I'm not doing some "stupid" mistake in getting the struct out of shm.
thnx again in advance ;)

It's hard to say if you are doing something wrong or not, since we don't see the other half, which I expect it the part that actually fills in the shared memory.

--
Mats

hmm here is the other half, and to repeat myself .. the lock is there just for the moment, as I wanted to try if it's working.

Code:

---

#include <stdlib.h>
#include <stdio.h>

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#define KEY (5679)

typedef struct _command
{
        int x;
        int y;
        int xo;
        int yo;
        int lock;
} command[20], *command_ptr;

main ()
{
        int shmid, *shm_ptr, i, size;
        command *tuio_cmd;
        size = sizeof( *tuio_cmd);

        shmid = shmget (KEY, size, 0666 | IPC_CREAT);
        if (shmid != -1)
        {
                shm_ptr = shmat (shmid, NULL, 0);
                tuio_cmd = *shm_ptr;
                if (tuio_cmd != (void *) -1)
                {
                        for( i=0; i<20; i++ )
                                {
                                tuio_cmd[i]->lock = 1;
                                tuio_cmd[i]->x = i;
                                tuio_cmd[i]->y = i;
                                tuio_cmd[i]->x = i;
                                tuio_cmd[i]->y = i;
                                }
                }
        else fprintf(stdout,"error attaching memory\n");
        }
        else fprintf(stdout,"error in allocating shm\n");
return 0;
}

---

Actually this part I wrote just to test the fist program, as I'll send the data with python script. And to be more sure I'm not doing some python mistake I tried this way also. But with no luck. Here is also a simple python implementation of how I intend to send the data :

Code:

---

import shm
import sys
import ctypes
class comm(ctypes.Structure):
    _fields_ = [
            ('x',ctypes.c_int),
            ('y',ctypes.c_int),
            ('xo',ctypes.c_int),
            ('yo',ctypes.c_int),
            ('lock',ctypes.c_int)
    ]
x = int(sys.argv[1])
y = int(sys.argv[2])
if len(sys.argv) >3:
    xo = int(sys.argv[3])
    yo = int(sys.argv[4])
key = 5679
mem = shm.memory(shm.getshmid(key))
mem.attach()
comm_array_class = comm * 20
an_array = comm_array_class()
if len(sys.argv) >3:
    #kom=comm(x=x,y=y,xo=xo,yo=yo,lock=1)
    for i in range(20):
            an_array[i].x = x
            an_array[i].y = y
            an_array[i].xo = xo
            an_array[i].yo = yo
            an_array[i].lock = 1
    mem.write(an_array)
    print "Sent:",x,y,xo,yo;
else:
    for i in range(20):
            an_array[i].x = x
            an_array[i].y = y
            an_array[i].lock = 1
    mem.write(an_array)

---

Quote:

---

I'm stuck here: tuio_cmd = shmat (shmid, NULL, 0);
I'm not sure if I did that right ..

---

What error do you get exactly? I pass this point when I try your code and enter the loop.

And what output do you get?

By the way:

Code:

---

tuio_cmd[0]->xo != 0

---

will always be true for this code:

Code:

---

                        for( i=0; i<20; i++ )
                                {
                                tuio_cmd[i]->lock = 1;
                                tuio_cmd[i]->x = i;
                                tuio_cmd[i]->y = i;
                                tuio_cmd[i]->x = i;
                                tuio_cmd[i]->y = i;
                                }

---

Even if you change code to set xo and yo, the first array element (indexed with [0]) will sitll be zero. Since that's one condition in the midst of your "while-loop", it may affect what you see and how that corresponds to what you expect?

--
Mats

Ok here Is the output after I send it data with python script .. the other program is segfaulting now, obviously I changed something there.
Gdb output: Program received signal SIGSEGV, Segmentation fault. - 0x080484ce in main () at p2.c:34
34 tuio_cmd[i]->lock = 1;
If I put breakpoint there, It's segfaulting after 12 loops, as its doesn't have enough memory to write .. and It's showing in the output as there is breaking and starting to output random data.
But back to the main issue, the thing that's driving me crazy is this following almost random output from shared memory - which I get from python and other C program when It was working.
(this should send 200 200 200 200 to first array of the tuio struct,and then fill the others with i from 1 to 20)
shmsend.py 200 200 200 200
output:
Memory attached at:B7FB1000 size:400
X:200,Y:200,Xo:200,Yo:200
X:1,Y:1,Xo:0,Yo:0
X:2,Y:2,Xo:0,Yo:0
X:3,Y:3,Xo:0,Yo:0
X:4,Y:4,Xo:0,Yo:0
X:5,Y:5,Xo:0,Yo:0
X:6,Y:6,Xo:0,Yo:0
X:7,Y:7,Xo:0,Yo:0
X:8,Y:8,Xo:0,Yo:0
X:9,Y:9,Xo:0,Yo:0
X:10,Y:10,Xo:0,Yo:0
X:5,Y:7,Xo:22,Yo:0
X:-160678444,Y:-2008677909,Xo:0,Yo:0
X:32,Y:655394,Xo:184,Yo:62400
X:1601399924,Y:1601463655,Xo:1919181921,Yo:1718580 063
X:157536133,Y:20,Xo:0,Yo:410
X:-1996488699,Y:-1983685147,Xo:666668534,Yo:0
X:1358916351,Y:360,Xo:1342606216,Yo:16248808
X:42304783,Y:-2088042496,Xo:824,Yo:-2062565243
X:-1947896016,Y:231555,Xo:264275200,Yo:102788

Argh, now it doesn't work anymore, and I didn't change anything .. maybe it was showing old memory here.. (now its outputing just the first line right 200 200 200 200, and the rest is 0 and random after 12 loop)
eh its giving me the filling of quantum mechanics.. changing without any cause.

I think your problem comes from the initialization of tuio_cmd:

Code:

---

        shmid = shmget (KEY, size, 0666 | IPC_CREAT);
        if (shmid != -1)
        {
                shm_ptr = shmat (shmid, NULL, 0);
                tuio_cmd = *shm_ptr;          // <- no need to dereference here
                if (tuio_cmd != (void *) -1)
                {
                        for( i=0; i<20; i++ )

---

As this var is a command*, the result of shmat() is directly this address
'tuio_cmd=(command*)shm_ptr;'.

Quote:

---

Originally Posted by jet-plane

Ok here Is the output after I send it data with python script .. the other program is segfaulting now, obviously I changed something there.
Gdb output: Program received signal SIGSEGV, Segmentation fault. - 0x080484ce in main () at p2.c:34
34 tuio_cmd[i]->lock = 1;
If I put breakpoint there, It's segfaulting after 12 loops, as its doesn't have enough memory to write .. and It's showing in the output as there is breaking and starting to output random data.

---

I think that's explained in the next post.

Quote:

---

But back to the main issue, the thing that's driving me crazy is this following almost random output from shared memory - which I get from python and other C program when It was working.
(this should send 200 200 200 200 to first array of the tuio struct,and then fill the others with i from 1 to 20)
shmsend.py 200 200 200 200
output:
Memory attached at:B7FB1000 size:400
X:200,Y:200,Xo:200,Yo:200
X:1,Y:1,Xo:0,Yo:0
X:2,Y:2,Xo:0,Yo:0
X:3,Y:3,Xo:0,Yo:0
X:4,Y:4,Xo:0,Yo:0
X:5,Y:5,Xo:0,Yo:0
X:6,Y:6,Xo:0,Yo:0
X:7,Y:7,Xo:0,Yo:0
X:8,Y:8,Xo:0,Yo:0
X:9,Y:9,Xo:0,Yo:0
X:10,Y:10,Xo:0,Yo:0
X:5,Y:7,Xo:22,Yo:0
X:-160678444,Y:-2008677909,Xo:0,Yo:0
X:32,Y:655394,Xo:184,Yo:62400
X:1601399924,Y:1601463655,Xo:1919181921,Yo:1718580 063
X:157536133,Y:20,Xo:0,Yo:410
X:-1996488699,Y:-1983685147,Xo:666668534,Yo:0
X:1358916351,Y:360,Xo:1342606216,Yo:16248808
X:42304783,Y:-2088042496,Xo:824,Yo:-2062565243
X:-1947896016,Y:231555,Xo:264275200,Yo:102788

Argh, now it doesn't work anymore, and I didn't change anything .. maybe it was showing old memory here.. (now its outputing just the first line right 200 200 200 200, and the rest is 0 and random after 12 loop)
eh its giving me the filling of quantum mechanics.. changing without any cause.

---

My thoughts are that the python is slower than the C code, and you're just getting ahead of the python code.

--
Mats

Thats not the python problem, as now after I fixed the wrong dereferencing in second C program,
I got the same output (which I think I got in the first place as maybe I didn't recompile it after I was experimenting on changing various things). Anyway now If I run it :
gdb ./arr_send_struct
break 37
run
c <-- repeat 12 x
:::::
Breakpoint 1, main () at arr_send_struct.c:37
37 tuio_cmd[i]->lock = 1;
(gdb) c
Continuing.

Program received signal SIGSEGV, Segmentation fault.
0x080484cc in main () at arr_send_struct.c:37
37 tuio_cmd[i]->lock = 1;
:::::::::::
and the output of ./arr_struct
X:0,Y:0
X:1,Y:1
X:2,Y:2
X:3,Y:3
X:4,Y:4
X:5,Y:5
X:6,Y:6
X:7,Y:7
X:8,Y:8
X:9,Y:9
X:10,Y:10
X:5,Y:7
X:-160678444,Y:-2008677909
X:32,Y:655394
X:1601399924,Y:1601463655
X:157536133,Y:20
X:-1996488699,Y:-1983685147
X:1358916351,Y:360
X:42304783,Y:-2088042496
X:-1947896016,Y:231555

Can you add a printout of size using &#37;d and tuio_cmd[i] using %p?

Do this on both sides [or you can use gdb to find out the values], and post the results?

--
Mats

ok I added / uncommented printf ("Memory attached at:&#37;X size:%d\n", (int) tuio_cmd, size);
and in second prog. I added
printf("tuio_cmd[i]:%p\n",tuio_cmd[i]);
after tuio_cmd[i]->yo = i; (I edited this also as it was wrong)

Its saying :
./arr_send_struct
Memory attached at:B7F1B000 size:400
tuio_cmd[i]:0xb7f1b000
tuio_cmd[i]:0xb7f1b190
tuio_cmd[i]:0xb7f1b320
tuio_cmd[i]:0xb7f1b4b0
tuio_cmd[i]:0xb7f1b640
tuio_cmd[i]:0xb7f1b7d0
tuio_cmd[i]:0xb7f1b960
tuio_cmd[i]:0xb7f1baf0
tuio_cmd[i]:0xb7f1bc80
tuio_cmd[i]:0xb7f1be10
tuio_cmd[i]:0xb7f1bfa0
Segmentation fault

./arr_struct
Memory attached at:B7EF7000 size:400
X:0,Y:0,tuio_cmd[i]:0xb7ef7000
X:1,Y:1,tuio_cmd[i]:0xb7ef7190
X:0,Y:0,tuio_cmd[i]:0xb7ef7320
X:3,Y:3,tuio_cmd[i]:0xb7ef74b0
X:4,Y:4,tuio_cmd[i]:0xb7ef7640
X:5,Y:5,tuio_cmd[i]:0xb7ef77d0
X:6,Y:6,tuio_cmd[i]:0xb7ef7960
X:7,Y:7,tuio_cmd[i]:0xb7ef7af0
X:8,Y:8,tuio_cmd[i]:0xb7ef7c80
X:9,Y:9,tuio_cmd[i]:0xb7ef7e10
X:10,Y:10,tuio_cmd[i]:0xb7ef7fa0
X:5,Y:7,tuio_cmd[i]:0xb7ef8130
X:-160678444,Y:-2008677909,tuio_cmd[i]:0xb7ef82c0
X:32,Y:655394,tuio_cmd[i]:0xb7ef8450
X:1601399924,Y:1601463655,tuio_cmd[i]:0xb7ef85e0
X:157536133,Y:20,tuio_cmd[i]:0xb7ef8770
X:-1996488699,Y:-1983685147,tuio_cmd[i]:0xb7ef8900
X:1358916351,Y:360,tuio_cmd[i]:0xb7ef8a90
X:42304783,Y:-2088042496,tuio_cmd[i]:0xb7ef8c20
X:-1947896016,Y:231555,tuio_cmd[i]:0xb7ef8db0

Ok, that explains what you are seeing. I'm not quite sure what's wrong with your code, but essentially, you allocate 400 bytes of shared memory (which is correct for 5 * 20 -> 100 int (4 bytes each) values).

Then your array is jumping 0x190 each time - 0x190 = 400 bytes.

Ah, got it:

Code:

---

tuio_cmd[i]->lock

---

needs to be

Code:

---

(*tuio_cmd)[i].lock

---

And of course the same change elsewhere. Or, you could do:

Code:

---

command_ptr *p = &(*tuio_cmd)[i];

p->lock = ...

---

--
Mats

ahhhh, thank you VEERYYYY much, I was already loosing my mind. And I'm new to C programming so I'm still at war with pointers. Now it seams so logical and easy but I wouldn't never figure it out by myself. btw. now it's working nice :)

Quote:

---

Originally Posted by jet-plane

ahhhh, thank you VEERYYYY much, I was already loosing my mind. And I'm new to C programming so I'm still at war with pointers. Now it seams so logical and easy but I wouldn't never figure it out by myself. btw. now it's working nice :)

---

Yes, it took me a bit of thinking to get what was going on in the first place - and the printouts helped me tell that the pointer was walking big steps of 0x190 (400), where you expect to move 20 bytes (0x14).

--
Mats

I must thank you again, you made my day :)

Eh I did it again , I nested the struct to add locking mechanism, and now it's jumping again by 0x190 instead just 20 bytes.

Code:

---

#include <stdlib.h>
#include <stdio.h>
 
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
 
#define KEY (5679)

typedef struct
{
        int x, y, xo, yo, id;
}command[20], *command_ptr;

typedef struct _tcommand
{
        int lock;
        command comm;
}tcommand;

main ()
{
        int shmid, shmkeyid, i, size;
        command *tuio_cmd;
        tcommand *tcomm;
        size = sizeof( *tcomm);

        shmid = shmget (KEY, size, 0666 | IPC_CREAT);
        if (shmid != -1)
        {
                tcomm = shmat (shmid, NULL, 0);
                if (tcomm != (void *) -1)
                {
                        tuio_cmd = &(*tcomm).comm;
                        printf ("Memory tcomm@:&#37;X tcom->comm@: %X, size of struct:%d\n\n", (int) tcomm, (int)tcomm->comm,(int) tuio_cmd,size);
                        tuio_cmd[4]->xo = 1; //Set old X just to test if block
                                for( i=0; i<20; i++ )
                                {
                                        command_ptr p = &(*tuio_cmd)[i]; // <--- pointer p points to memory location of i'th member of tuio_cmd array
                                        printf ("Memory tuio_cmd[%d]@: %p\n",i,p->x);
//                                        if (tuio_cmd[i]->xo) // Check if there is old x and y, it's enaugh to check just one
//                                                printf ("num:%d,X:%d,Y:%d,Xo:%d,Yo:%d,Id:%d\n", i,tuio_cmd[i]->x,tuio_cmd[i]->y, tuio_cmd[i]->xo, tuio_cmd[i]->yo, tuio_cmd[i]->id);
//                                        else // We get just one point coordinates
//                                                printf ("X:%d,Y:%d,Id:%d\n", tuio_cmd[i]->x,tuio_cmd[i]->y,tuio_cmd[i]->id);
                                }
                        if (shmdt (tcomm) == -1)
                        {
                                fprintf (stderr, "shmdt failed\n");
                                exit (EXIT_FAILURE);
                        }
                        if (shmctl (shmid, IPC_RMID, 0) == -1)
                        {
                                fprintf (stderr, "shmctl(IPC_RMID) failed\n");
                                exit (EXIT_FAILURE);
                        }
                }
        else fprintf(stdout,"error attaching memory\n");
        }
        else fprintf(stdout,"error in allocating shm\n");
return 0;
}

---

Output at the moment:
Memory tcomm@:B7F81000 tcom->comm@: B7F81004,tuio: B7F81004, size of struct:404

Memory tuio_cmd[0]@: (nil)
Memory tuio_cmd[1]@: (nil)
... (repeating)

I have tried every possible combination that crossed my mind .. from (*tuio_cmd)[i]->x to tuio_cmd[i].x with and without pointers, even as its shown here I added p as pointer to the memory. Obviously without success.
And I see that the memory allocation for the tuio_cmd is good (start + 4 bytes for int of lock). I really don't understand how the !@$!#% is done.
If someone is willing to give me a hand again ok. If not, it doesn't matter anymore, as I don't want to exploit the good will of the ppl.

[edit]
Oh finally, I think I got it ..

Code:

---

command_ptr p = &((*tuio_cmd)[i]); // <--- pointer p points to memory location of i'th member of tuio_cmd array

---

Output:
Memory tcomm@:B7F99000 tcom->comm@: B7F99004,tuio: B7F99004, size of struct:404

Memory tuio_cmd[0]@: 0xb7f99004
Memory tuio_cmd[1]@: 0xb7f99018
Memory tuio_cmd[2]@: 0xb7f9902c
Memory tuio_cmd[3]@: 0xb7f99040
Memory tuio_cmd[4]@: 0xb7f99054
....

First......take a break ;)

When you come back, remove that "[20]" out of your typedef - that's making *my* head hurt!

Code:

---

typedef struct command_
{
        int x, y, xo, yo, id;
} command;

typedef struct tcommand_
{
        int lock;
        command comms[20];
} tcommand;

---

Fix the rest based on that. Post yours progress here if you hit a wall.

gg

Eheh I know .. that's hurting my head too, but as you see I'm having really hard time with it,
finally I made it. But now I would like to optimize a little and beautify the code. It's just too ugly this way. About that [20] eheh I tried that few times before .. when I was stuck at the first issue, I'll try again and see If I'll have any luck. If you see anything else that could be "fixed" or typed more simple plz. let me know.

In my code editor, I turn off real tab characters and use nothing but spaces (editor inserts spaces when I hit tab). That will help keep your posted code looking the same as it does in your editor.

My personal rule-of-thumb is never to "hide a pointer" inside a typedef, like "command_ptr" - which also "hides" an array-20 inside itself.......(head starting to hurt)....

The code is a bit more "self-documenting" that way as well. Consider

Code:

---

  command comms[20];
vs
  command comm; // command is really "array-20"

---

>> anything else that could be "fixed"
Probably need to add proper memory synchronization to your shared memory accesses.
How many producers?
How many consumers?
How do consumers know when something has been produced?
How to producers know consumers are ready to consume?
What is the policy for dealing with more "production" than the consumers can handle?

gg

Ok listening your suggestions, I have come to following:

Code:

---

#include <stdlib.h>
#include <stdio.h>
 
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
 
#define KEY (5679)

typedef struct
{
        int x, y, xo, yo, id;
}command; // command is really "array-20"

typedef struct _tcommand
{
        int lock;
        command comm[20];
}tcommand;

main ()
{
        int shmid, shmkeyid, i, size;
        command *tuio_cmd[20],*p;
        tcommand *tcomm;
        size = sizeof( *tcomm);

        shmid = shmget (KEY, size, 0666 | IPC_CREAT);
        if (shmid != -1)
        {
                tcomm = shmat (shmid, NULL, 0);
                if (tcomm != (void *) -1)
                {
                        tuio_cmd[0] = &(*tcomm).comm;
//                        printf ("Memory tcomm@:&#37;X tcom->comm@: %X,tuio: %X, size of struct:%d\n\n", (int) tcomm, (int)tcomm->comm,(int) tuio_cmd,size);
                        while(1)
                        {
                        if(((*tcomm).lock)==1)
                        {
                                for( i=0; i<20; i++ )
                                {
                                        p = &((*tuio_cmd)[i]); // <--- pointer p points to memory location of i'th member of tuio_cmd array
                                        if (p->xo) // Check if there is old x and y, it's enaugh to check just one
                                                printf ("num:%d,X:%d,Y:%d,Xo:%d,Yo:%d,Id:%d\n", i,p->x,p->y, p->xo, p->yo, p->id);
                                        else // We got just one point coordinates
                                                printf ("num:%d,X:%d,Y:%d,Id:%d\n",i, p->x,p->y,p->id);
                                }
                        ((*tcomm).lock)=0;
                        }
                        }
                        if (shmdt (tcomm) == -1)
                        {
                                fprintf (stderr, "shmdt failed\n");
                                exit (EXIT_FAILURE);
                        }
                        if (shmctl (shmid, IPC_RMID, 0) == -1)
                        {
                                fprintf (stderr, "shmctl(IPC_RMID) failed\n");
                                exit (EXIT_FAILURE);
                        }
                }
        else fprintf(stdout,"error attaching memory\n");
        }
        else fprintf(stdout,"error in allocating shm\n");
return 0;
}

---

Now I have warrning: assignment from incompatible pointer type @34 line tuio_cmd[0] = &(*tcomm).comm;

About consumer/producers .. producer is actually python script, so I'm not afraid that it can
send more that the C part can handle. About synchronization, I have added lock int just for that.
I'm still not sure this is optimized code .. so if you see something else that could be "adjusted" plz share.. and thnx for assisting me. :)

Ps. offcourse everything is working well now. (as far I can see for now)

>> command *tuio_cmd[20]
That is a fixed size array of pointers to command. Not what you want.
Here is everything simplified, types, code, and tabs:

Code:

---

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
 
#define KEY (5679)

typedef struct
{
    int x, y, xo, yo, id;
} command;

typedef struct
{
    int lock;
    command comm[20];
} tcommand;

int main()
{
    int shmid, i;
    tcommand *tcomm;
   
    shmid = shmget(KEY, sizeof(*tcomm), 0666 | IPC_CREAT);
    if (shmid == -1)
    {
        fprintf(stderr,"error in allocating shm\n");
        exit(EXIT_FAILURE);
    }//if
           
    tcomm = shmat(shmid, NULL, 0);
    if (tcomm == (void*)-1)
    {
        fprintf(stderr,"error attaching memory\n");
        exit(EXIT_FAILURE);
    }//if

    while (1)
    {
        // TODO: use real synchronization
        if (tcomm->lock == 1)
        {
            for (i = 0; i < 20; ++i)
            {
                command *p = &(tcomm->comm[i]);

                // Check if there is old x and y, it's enough to check just one
                if (p->xo)
                    printf("num:&#37;d,X:%d,Y:%d,Xo:%d,Yo:%d,Id:%d\n",
                          i, p->x, p->y, p->xo, p->yo, p->id);
                else
                    printf("num:%d,X:%d,Y:%d,Id:%d\n",
                          i, p->x, p->y, p->id);
            }//for

            tcomm->lock = 0;
        }//if

        // TODO - don't use 100% CPU
        // TODO - some way to stop
    }//while

    if (shmdt(tcomm) == -1)
    {
        fprintf(stderr, "shmdt failed\n");
        exit(EXIT_FAILURE);
    }//if

    if (shmctl(shmid, IPC_RMID, 0) == -1)
    {
        fprintf(stderr, "shmctl(IPC_RMID) failed\n");
        exit(EXIT_FAILURE);
    }//if
   
    return 0;
}//main

---

So you got some TODO's there one you're comfortable with the code.

gg

Ok I added the semaphore locking, and exit out the loop with previous lock. Only TODO remaining is dont use 100&#37; of cpu, what do you mean by that ?
here is the code:

Code:

---

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#include <sys/sem.h>

#define KEY (5679)

typedef struct
{
    int x, y, xo, yo, id;
} command;

typedef struct
{
    int lock;
    command comm[20];
} tcommand;

void seminit()
{
  int id;
        union semun {
                int val;
                struct semid_ds *buf;
                ushort * array;
        } argument;

  argument.val = 0;
  id = semget(KEY, 1, 0666 | IPC_CREAT);
  if(id < 0)
  {
      fprintf(stderr, "Unable to obtain semaphore.\n");
      exit(0);
  }
  if( semctl(id, 0, SETVAL, argument) < 0)
  {
      fprintf( stderr, "Cannot set semaphore value.\n");
  }
  else
  {
      fprintf(stderr, "Semaphore %d initialized.\n", KEY);
  }
}


int main()
{
    int shmid, i;
    tcommand *tcomm;

    shmid = shmget(KEY, sizeof(*tcomm), 0666 | IPC_CREAT);
    if (shmid == -1)
    {
        fprintf(stderr,"error in allocating shm\n");
        exit(EXIT_FAILURE);
    }//if
    tcomm = shmat(shmid, NULL, 0);
    if (tcomm == (void*)-1)
    {
        fprintf(stderr,"error attaching memory\n");
        exit(EXIT_FAILURE);
    }//if
    seminit(); //Init the semaphore
    int id;
    struct sembuf operations[1];
    int retval;
    id = semget(KEY, 1, 0666); //semaphores and shared memory have separate key spaces, so one can safely use the same key for each.
    if(id < 0)
    {
      fprintf(stderr, "Cannot find semaphore, exiting.\n");
      exit(0);
    }
    do
    {
    operations[0].sem_num = 0;
    operations[0].sem_op = -1;
    operations[0].sem_flg = 0;
    retval = semop(id, operations, 1);
            for (i = 0; i < 20; ++i)
            {
                command *p = &(tcomm->comm[i]);
                // Check if there is old x and y, it's enough to check just one
                if (p->xo)
                    printf("num:%d,X:%d,Y:%d,Xo:%d,Yo:%d,Id:%d\n",
                          i, p->x, p->y, p->xo, p->yo, p->id);
                else
                    printf("num:%d,X:%d,Y:%d,Id:%d\n",
                          i, p->x, p->y, p->id);
            }//for
    }while (!tcomm->lock);
    if (shmdt(tcomm) == -1)
    {
        fprintf(stderr, "shmdt failed\n");
        exit(EXIT_FAILURE);
    }//if
    if (shmctl(shmid, IPC_RMID, 0) == -1)
    {
        fprintf(stderr, "shmctl(IPC_RMID) failed\n");
        exit(EXIT_FAILURE);
    }//if
    return 0;
}//main

---

Another question, I'm thinking on using this in threaded program, so I'm not sure if semaphore approach is
wise, as it's blocking and waiting for signal.And one more thing, why is now sitting and waiting for second release of semaphore .. I added while after do, so it should exit as soon the condition is satisfied.
[edit]
I got it why it was entering in the loop for second time, it was the other side (python script) which had the glitch.. now Is working well.And about the thread .. I'm still able to release the semaphore with
signal from main thread so that wouldn't have to be the problem I think.

>> ... don't use 100% of cpu, what do you mean by that?
Before, there was just a while(1) loop that did nothing but if() and printf(). The OS and CPU will gladly run that loop as fast as it can. When there's no work to be done, you should be blocked in the OS somewhere.

>> Ok I added the semaphore
You are on the right track!

>> I'm not sure [of] semaphore approach
There are still a few things to consider. Right now your loop will block at semop() until the semaphore value is non-zero. At this point, we're waiting for the python script to populate the data. Once the data is populated in shared memory, the python script increments the semaphore - which in turn allows the semop() call to to return. This works great if you only need to send one parcel of data.

But what if we want to send multiple tcommand's? How does the python script know that it's ok to write more data? In other words, how does it know that we've completed reading everything it just sent us?

There are several ways to tackle this depending on what you want to do. Just for an example, let's say they you wanted your producer (python script) to block until the produced data has been consumed - meaning no data should be lost, it should all be consumed.

Code:

---

semaphore s = 0;

producer()
{
  while()
  {
        wait until s == 0
        produce tcommand
        set s = 2
  }
}

consumer()
{
    while()
    {
        s -= 1 // blocking semop
        consume tcommand
        s -= 1 // should not block since producer set s = 2 (assumes single consumer)
    }
}

---

>> I'm thinking on using this in threaded program
What we've been talking about so far is IPC over shared memory between two processes. But in reality, it's not much different from two threads communicating over a malloc'd chunk of memory :)

gg

That worked really nice, good logic .. I must learn to think like that. I tried different approach, which I found in other producer/consumer C examples. But they weren't appropriate for my case as I'm using python, and It's hard to synchronize it. About the thread .. I didn't mean that I'm going to share the malloced memory over the multiple threads, I'm using one thread just to get and parse the commands received over shared memory. Anyway as I'm going to release the code (after I finish it) as GPL, I'm going to share here also, since there could be someone else who could benefit from this. It's a nice way to connect python and C over low latency solution :)
So the C part in question looks now like this:

Code:

---

    operations[0].sem_num = 0;
    operations[0].sem_op = -1;
    operations[0].sem_flg = 0;
    retval = semop(semid, operations, 1);
            for (i = 0; i < MAXBLOBS; ++i)
            {
                command *p = &(tcomm->comm[i]);
                // Check for blob Id, If there isn't any skip, it's void
                if (p->id)
                {
                // Check if there is old x and y, it's enough to check just one
                if (p->xo)
                    printf("num:&#37;d,X:%d,Y:%d,Xo:%d,Yo:%d,Id:%d\n",
                          i, p->x, p->y, p->xo, p->yo, p->id);
                else
                    printf("num:%d,X:%d,Y:%d,Id:%d\n",
                          i, p->x, p->y, p->id);
                }//if
            }//for
    operations[0].sem_num = 0;
    operations[0].sem_op = -1;
    operations[0].sem_flg = 0;
    retval = semop(semid, operations, 1);

---

And the python part :

Code:

---

#!/usr/bin/env python
import shm
import ctypes
class tuio(ctypes.Structure):
        _fields_ = [
                ('x',ctypes.c_int),
                ('y',ctypes.c_int),
                ('xo',ctypes.c_int),
                ('yo',ctypes.c_int),
                ('id',ctypes.c_int)
        ]
class nested(ctypes.Structure):
        _fields_=[
                ('lock',ctypes.c_int),
                ('comm',tuio*20)
        ]
x=100 #some test data
y=123 #same here
key = 5679
i=0 #send just array [0]
mem = shm.memory(shm.getshmid(key))
sem = shm.semaphore(shm.getsemid(key))
sem.setval(0) #set the semaphore = 0
mem.attach()
tuio_cmd = nested()
tuio_cmd.comm[i].x=x
tuio_cmd.comm[i].y=y
tuio_cmd.comm[i].id=1
tuio_cmd.lock=1 #sets the lock to 1 and the main C program exits on this
sem.Z() #wait for semaphore == 0
mem.write(tuio_cmd) #write to the memory
sem.setval(2) #set the semaphore s=2

---

PS. Thnx for the hints and guide trough this voyage in C programming.