int DECLSPEC MPI_Init(int *argc, char ***argv)
{
int fd_np_shm, fd_structure_shm;
int size_np_shm, size_structure_shm;
int pid, i;
void *np_mem, *structure_mem;
if(started == 1)
return MPI_ERR_OTHER;
//read number of processes from first shared memory
size_np_shm = sizeof(int);
fd_np_shm = open_shm(SHM_NP_NAME, size_np_shm, O_RDWR, &np_mem);
np = ((int*)np_mem)[0];
//read the process rank from the second shared memory
pid = getpid();
size_structure_shm = np * sizeof(struct mpi_comm);
fd_structure_shm = open_shm(SHM_STRUCTURE_NAME, size_structure_shm, O_RDWR, &structure_mem);
i = 0;
while(((struct mpi_comm*)structure_mem)[i].pid != pid)
i++;
my_rank = ((struct mpi_comm*)structure_mem)[i].rank;
started = 1;
return MPI_SUCCESS;
}
int main(int argc, char* argv[]){
char* pstItem;
if (open_shm((void **)&pstItem, AGENT_SHM_ID, sizeof(ItemList), 0666) < 0){
open_shm((void**)&pstItem, AGENT_SHM_ID, sizeof(ItemList), 0666|IPC_CREAT);
}
do_add(1, 1);
do_add(1, 1);
do_add(1, 1);
int rval;
do_get(1, &rval);
fprintf(stderr, "rval=%d", rval);
return 0;
}
//main(int argc, char *argv[]) {
int
main(int argc, char *argv[]) {
int shm_fd = 0, c;
unsigned long long nb_bytes = 256000;
char *logs = NULL;
RINGBUFFER rb;
opterr = 0;
while((c = getopt(argc, argv, ARGS)) != -1)
switch(c) {
case 'n':
nb_bytes = atoll(optarg);
break;
case '?':
if (optopt == 'n')
fprintf(stderr,
"-%c: missing arguments\n",
optopt);
else if (isprint(optopt))
fprintf(stderr,
"Unknown option `-%c'.\n",
optopt);
else
fprintf (stderr,
"Unknown option character `\\x%x'.\n",
optopt);
break;
default:
break;
}
if ((shm_fd = open_shm(SHM_PATH)) < 0)
MANAGE_ERROR("can't create shm", TRUE, EXIT_FAILURE);
if ((logs = mmap(NULL, nb_bytes, PROT_READ | PROT_WRITE, MAP_SHARED,
shm_fd, 0)) == MAP_FAILED)
MANAGE_ERROR("mmap", TRUE, EXIT_FAILURE);
rb_connect(&rb, logs, nb_bytes);
rb_dump(&rb);
//close_shm(shm_fd);
return EXIT_SUCCESS;
}
JNIEXPORT jstring JNICALL Java_devmap_DevMap_getDevMaps(JNIEnv *env, jclass cls)
{
jstring content;
char *res = "";
char buf[4096];
/* Step 1: open the shm */
int fd = open_shm();
if (fd < 0) {
goto out;
}
/* Step 2: read in the content */
memset(buf, 0, sizeof(buf));
read(fd, buf, 4096);
printf("buf %s\n", buf);
close_shm(fd);
res = buf;
out:
content = (*env)->NewStringUTF(env, res);
return content;
}
int main(int argc, char **argv)
{
int i, rc, status, np, nr_prog_arg, size_structure_shm, size_np_shm;
int fd_structure_shm, fd_np_shm;
char *prog, *command;
char **arguments;
void *structure_mem, *np_mem;
mqd_t local_queue;
char local_queue_name[MAX_NAME_LEN];
if(argc < 4)
{
printf("Wrong parameters!\n");
return -1;
}
np = atoi(argv[2]);
prog = argv[3];
nr_prog_arg = argc - 4;
arguments = calloc(nr_prog_arg + 2, sizeof(char*));
arguments[0] = prog;
for(i = 0; i < nr_prog_arg; i++)
{
arguments[i + 1] = argv[i + 4];
}
arguments[i + 1] = NULL;
//alloc memory for the mpi_comm_world structure
mpi_comm_world = calloc(np, sizeof(struct mpi_comm));
//create the first shared memory for the processes number
size_structure_shm = np * sizeof(struct mpi_comm);
fd_structure_shm = open_shm(SHM_STRUCTURE_NAME, size_structure_shm, O_CREAT | O_RDWR, &structure_mem);
memcpy(structure_mem, mpi_comm_world, size_structure_shm);
//create the shared memory for the mpi_comm_world structure
size_np_shm = sizeof(int);
fd_np_shm = open_shm(SHM_NP_NAME, size_np_shm, O_CREAT | O_RDWR, &np_mem);
((int*)np_mem)[0] = np;
//create queues for all the processes
for(i = 0; i < np; i ++) {
sprintf(local_queue_name, "/%i", i);
local_queue = mq_open(local_queue_name, O_CREAT | O_RDWR, 0666, NULL);
DIE(local_queue == (mqd_t)-1, "mq_open");
mpi_comm_world[i].local_queue = local_queue;
}
//create the processes
for(i = 0; i < np; i++)
{
pid_t pid = fork();
switch(pid) {
case -1:
return EXIT_FAILURE;
case 0:
((struct mpi_comm*)structure_mem)[i].pid = getpid();
((struct mpi_comm*)structure_mem)[i].rank = i;
command = calloc(strlen(prog) + 2, sizeof(char));
sprintf(command, "./%s", prog);
execvp(command, (char*const*) arguments);
free(command);
free(arguments);
exit(EXIT_FAILURE);
default:
break;
}
}
free(arguments);
for(i = 0; i < np; i++)
waitpid(mpi_comm_world[i].pid, &status, 0);
//close the shared memories and the queues
close_shm(SHM_STRUCTURE_NAME, structure_mem, fd_structure_shm, size_structure_shm);
close_shm(SHM_NP_NAME, np_mem, fd_np_shm, size_np_shm);
for(i = 0; i < np; i++) {
rc = mq_close(mpi_comm_world[i].local_queue);
DIE(rc == -1, "mq_close");
sprintf(local_queue_name, "/%i", i);
rc = mq_unlink(local_queue_name);
DIE(rc == -1, "mq_unlink");
}
free(mpi_comm_world);
return 0;
}
// argv[1] = port name
int main(int argc, char** argv)
{
Semaphore sem_gen_v;
Semaphore mutex_boat;
Semaphore mutex_sync;
Shm shm_boat;
Boat boat;
mqd_t mqd_trucks;
mqd_t mqd_cars_vans;
char buffer[MQ_MSGSIZE];
char* port_name = argv[1];
char* msg = malloc(sizeof(msg));
int i = 0;
int nb_trucks = 0, nb_cars = 0, nb_vans = 0;
int nb_boats = atoi(getProp(PROP_FILE, "nb_boats"));
srand(getpid());
// SEM_GEN_V
sem_gen_v.oflag = (O_CREAT | O_RDWR);
sem_gen_v.mode = 0644;
sem_gen_v.value = 0;
sprintf(sem_gen_v.semname,"%s%s", SEM_GEN_V, port_name);
sem_unlink(sem_gen_v.semname);
open_sem(&sem_gen_v);
// Preparing mutex for shm_boat access
mutex_boat.oflag = O_RDWR;
mutex_boat.mode = 0644;
mutex_boat.value = 1;
strcpy(mutex_boat.semname, MUTEX_BOAT);
open_sem(&mutex_boat);
// Preparing shm_boat access
shm_boat.sizeofShm = sizeof(Boat) * 6;
shm_boat.mode = O_RDWR;
strcpy(shm_boat.shmName, SHM_BOAT);
open_shm(&shm_boat);
mapping_shm(&shm_boat, sizeof(Boat) * 6);
while(1)
{
// Waiting signal_sem on sem_gen_v from Docks processes.
wait_sem(sem_gen_v);
// Waiting for access on shm_boat
wait_sem(mutex_boat);
boat = get_actual_boat(DOCK, port_name, nb_boats, shm_boat);
signal_sem(mutex_boat);
sprintf(msg, "Débloqué");
print_boat(port_name, boat.index, msg);
// MUTEX_SYNC
mutex_sync.oflag = 0;
sprintf(mutex_sync.semname,"%s%d", MUTEX_SYNC, boat.index);
open_sem(&mutex_sync);
// Ouverture MQs
mqd_trucks = mq_open(boat.mq1.name, O_WRONLY);
mqd_cars_vans = mq_open(boat.mq2.name, O_WRONLY);
nb_cars = rand() % MAX_N_CARS + 1;
nb_vans = rand() % MAX_N_VANS + 1;
nb_trucks = rand()% MAX_N_TRUCKS + 1;
memset(buffer, 0, MQ_MSGSIZE);
sprintf(msg, "Debut embarquement");
print_boat(port_name, boat.index, msg);
sprintf(msg, "Embarquement de %d voitures", nb_cars);
print_boat(port_name, boat.index, msg);
for(i = 0; i < nb_cars; i++)
{
sprintf(buffer, "Car %d", i + 1);
if(mq_send(mqd_cars_vans, buffer, strlen(buffer), CAR_PRIORITY) == -1)
{
mq_close(mqd_cars_vans);
mq_unlink(boat.mq1.name);
perror("Error occured when mq_send (cars & vans)\n");
exit(EXIT_FAILURE);
}
// Sleep 1/4s -- TODO Paramétrable.
nanosleep((struct timespec[]){{0, 250000000}}, NULL);
}
sprintf(msg, "Embarquement de %d vans", nb_vans);
print_boat(port_name, boat.index, msg);
for(i = 0; i < nb_vans; i++)
{
sprintf(buffer, "Van %d", i);
if(mq_send(mqd_cars_vans, buffer, strlen(buffer), VAN_PRIORITY) == -1)
{
mq_close(mqd_cars_vans);
mq_unlink(boat.mq1.name);
perror("Error occured when mq_send (cars & vans)\n");
exit(EXIT_FAILURE);
}
// Sleep 1/4s
nanosleep((struct timespec[]){{0, 250000000}}, NULL);
}
