int SHMBase::connect_shared_memory( char mAllocate )
{
bool available = is_IPC_memory_available();
if (!available)
{
if (mAllocate) {
int result = allocate_memory( );
if (result == -1) {
Dprintf("Cannot allocate shared memory!\n");
}
attach_memory( );
fill_memory ( );
save_segment_id( );
return 1;
}
}
else
{
attach_memory();
if (is_poiner_valid()==true)
return 1;
}
return 0;
}
int main(int argc, char* argv[])
{
// struct config information;
double TimeI,TimeF,TII,TIF,TI;
double sum,b1,b2;
int i,j,k,temp;
char msg[215];
sum=b1=b2=0.0;
/* initialize memon */
init_memon();
mai_init(argv[1]);
tab = mai_alloc_3D(X,Y,Z,sizeof(double),DOUBLE);
mai_skew_mapp(tab);
/* attach memory to memtop */
sprintf(msg,"array 3D");
attach_memory(tid(),msg,tab[0][0],X*Y*Z*sizeof(double));
#pragma omp parallel for default(shared) private(j,k)
for(i=0;i<X;i++)
for(j=0;j<Y;j++)
for(k=0;k<Z;k++)
tab[i][j][k]=0.0;
//-------------------------------------------------------------------
//--------------------------------------------------begin of computation
for(temp=0;temp<TEMP;temp++)
{
#pragma omp parallel for default(shared) private(j,k) firstprivate(sum,b1,b2)
for(i=0;i<X;i++)
for(j=0;j<Y;j++)
for(k=0;k<Z;k++)
{
sum = tab[i][j][k]* 2.0;
tab[i][j][k]= sum * 2.0;
sum++;
b2=sum;
b1 += tab[i][j][k];
}
#pragma omp parallel for default(shared) private(j,k) firstprivate(sum,b1,b2)
for(i=0;i<X;i++)
for(j=0;j<Y;j++)
for(k=0;k<Z;k++)
{
sum = tab[i][j][k]* 2.0;
tab[i][j][k]= sum * 2.0;
sum++;
b2=sum;
b1 += tab[i][j][k];
}
}
//-----------------------------------------------------------------------
mai_final();
detach_memory(tid(),msg,tab[0][0]);
/* finalize memon */
finalize_memon();
return 0;
}
int main(int argc, char **argv) {
int server_fd, port_number, max_fd, file_descriptors[MAX_NUMBER_USERS], i;
int temp_fd, select_result, timer_is_active = FALSE, status_code;
char *validation;
fd_set file_descriptor_set;
check_incorrect_usage(argc, argv);
set_log_method(argv);
set_lock();
port_number = extract_port_number(argv);
server_fd = create_server(port_number, MAX_NUMBER_USERS);
log_message("Streams server created", LOG_INFO);
register_signal_handlers();
for (i = 0; i < MAX_NUMBER_USERS; i++) {
file_descriptors[i] = 0;
}
// -- SHARED MEMORY AND SEMAPHORES --
shmid = create_shared_memory();
shared_mem_ptr = attach_memory(shmid);
init_semaphores();
log_message("Shared memory and semaphores created", LOG_DEBUG);
// -- SERVER LOOP --
while (TRUE) {
FD_ZERO(&file_descriptor_set);
FD_SET(server_fd, &file_descriptor_set);
max_fd = server_fd;
for (i = 0; i < MAX_NUMBER_USERS; i++) {
temp_fd = file_descriptors[i];
if (temp_fd > 0) {
FD_SET(temp_fd, &file_descriptor_set);
}
if (temp_fd > max_fd) {
max_fd = temp_fd;
}
}
select_result = select(max_fd + 1, &file_descriptor_set, NULL, NULL, NULL);
if (select_result < 0 && errno != EINTR) {
log_error("Select call error", LOG_WARNING, errno);
continue;
}
if (FD_ISSET(server_fd, &file_descriptor_set)) {
if ((temp_fd = accept(server_fd, NULL, 0)) < 0) {
log_error("Could not accept incoming connection", LOG_ALERT, errno);
exit(EXIT_FAILURE);
}
log_client_connection(temp_fd);
for (i = 0; i < MAX_NUMBER_USERS; i++) {
if (file_descriptors[i] != 0)
continue;
file_descriptors[i] = temp_fd;
break;
}
}
for (i = 0; i < MAX_NUMBER_USERS; i++) {
temp_fd = file_descriptors[i];
if (!FD_ISSET(temp_fd, &file_descriptor_set))
continue;
char *message = NULL;
if ((message = (char *) calloc(MESSAGE_LENGTH, sizeof(char))) == NULL) {
log_error("Memory allocation error", LOG_ALERT, errno);
exit(EXIT_FAILURE);
}
if (recv(temp_fd, message, MESSAGE_LENGTH, 0) <= 0) // Disconnected
{
log_message("Client disconnected", LOG_INFO);
close(temp_fd);
file_descriptors[i] = 0;
}
else // Message sent to server
{
struct message_t mess=decode(message);
if( (status_code = mess.type) == ERROR_MESSAGE) {
continue;
}
if (get_game_phase() == REGISTER_PHASE) {
if (status_code != 1) {
// TODO Send message back to user?
log_message("Currently register phase. User can only register", LOG_DEBUG);
continue;
}
if (!timer_is_active) {
log_message("Starting register timer", LOG_DEBUG);
alarm(WAIT_TIME);
timer_is_active = TRUE;
}
char *new_user = (char *) malloc(MAX_ARRAY_SIZE * sizeof(char));
sprintf(new_user, "User '%s' asks for registration. Adding user in memory.", (char *) mess.payload);
log_message(new_user, LOG_INFO);
// Add a player to the shared memory
semaphore_down(SEMAPHORE_ACCESS);
strncpy(shared_mem_ptr->players->name, (char *) mess.payload, strlen(mess.payload));
shared_mem_ptr->players[i].fd = temp_fd;
shared_mem_ptr->players[i].score = 15; // TODO A supprimer
semaphore_up(SEMAPHORE_ACCESS);
validation = encode(VALID_REGISTRATION, "1");
send(temp_fd, validation, strlen(validation), 0);
}
else // GAME PHASE
{
log_message("Game phase. Not yet implemented.", LOG_INFO);
}
}
}
}
return 0;
}
void *Worker(void *arg) {
int myid = (int) arg;
double maxdiff, temp;
int i, j, iters;
int first, last;
double **grid1;
double **grid2;
unsigned long mask = 24+myid;
unsigned long maxnode = 8*sizeof(unsigned long);
char msg[215];
printf("worker %d (pthread id %d) has started\n", myid, pthread_self());
Barrier();
grid1 = (double**)malloc((stripSize+3)*sizeof(double*));
grid2 = (double**)malloc((stripSize+3)*sizeof(double*));
for(i = 0; i <= stripSize; i++) {
grid1[i] = (double*)malloc((gridSize+3)*sizeof(double));
grid2[i] = (double*)malloc((gridSize+3)*sizeof(double));
}
/* attach memory to memtop */
sprintf(msg,"var grid");
attach_memory(gettid(),msg,grid1[0],stripSize*(gridSize+3)*sizeof(double));
sprintf(msg,"var2");
attach_memory(gettid(),msg,grid2[0],stripSize*(gridSize+3)*sizeof(double));
InitializeGrids(grid1,grid2);
for (iters = 1; iters <= numIters; iters++) {
/* update my points */
for (i = 1; i < stripSize; i++) {
for (j = 1; j <= gridSize; j++) {
grid2[i][j] = (grid1[i-1][j] + grid1[i+1][j] +
grid1[i][j-1] + grid1[i][j+1]) * 0.25;
}
}
Barrier();
/* update my points again */
for (i = 1; i < stripSize; i++) {
for (j = 1; j <= gridSize; j++) {
grid1[i][j] = (grid2[i-1][j] + grid2[i+1][j] +
grid2[i][j-1] + grid2[i][j+1]) * 0.25;
}
}
Barrier();
}
detach_memory(gettid(),msg,grid2[0]);
/* compute the maximum difference in my strip and set global variable */
maxdiff = 0.0;
for (i = 1; i <= stripSize; i++) {
for (j = 1; j <= gridSize; j++) {
temp = grid1[i][j]-grid2[i][j];
if (temp < 0)
temp = -temp;
if (maxdiff < temp)
maxdiff = temp;
}
}
maxDiff[myid] = maxdiff;
}
int main(int argc, char *argv[])
{
int done=0; double gpsUpdateRate, imuUpdateRate, eulerUpdateRate;
long int gpsUpdateCount, imuUpdateCount, eulerUpdateCount, kalmanUpdateCount;
double lastTime;
// Program begins with the usual logging of data and so on...
captureQuitSignal();
shared = (Q_SHARED * )attach_memory(QBOATShareKey, sizeof(Q_SHARED));
sharedDIAG = (DIAG_SHARED *)attach_memory(DIAGShareKey, sizeof(DIAG_SHARED));
createDirectory();
sleep(1);
openKalmanlogfile();
fprintf(stderr,"\nExtended Kalman Filter v 1.0 for the Q-boat (based on the Heli INS by Srik)");
initEverything();
lastTime = get_time();
// Now begin main loop...
while (!done) {
// Run a loop to check if we've received new data from the sensors...
if((get_time()-lastTime)>=1.0) {
fprintf(stderr,"\nGPS %dHz, IMU %d Hz, EUL %d Hz, KAL %dHz, LastTime %f",gpsUpdateCount, imuUpdateCount, eulerUpdateCount,kalmanUpdateCount,lastTime);
gpsUpdateCount = 0; imuUpdateCount = 0; eulerUpdateCount = 0; kalmanUpdateCount = 0; lastTime = get_time();
}
if(shared->SensorData.lastEulerKalmanTime<shared->SensorData.eulerUpdateTime) {
++eulerUpdateCount;
if(!init_compass)
compassInit();
else updateCompass();
}
#ifdef __USE3DMG_DATA__
if(shared->SensorData.lastImuKalmanTime<shared->SensorData.imuUpdateTime) {
if(!init_imu)
imuInit();
else updateImu();
++imuUpdateCount;
}
#endif
#ifdef __USEXBOW_DATA__
if(shared->SensorData.lastImuKalmanTime<sharedDIAG->xbowData.lastXbowTime) {
if(!init_imu)
imuInit();
else updateImu();
++imuUpdateCount;
}
#endif
if(shared->SensorData.lastGpsKalmanTime<shared->SensorData.gpsUpdateTime) {
if(!init_gps)
gpsInit();
else updateGPS();
++gpsUpdateCount;
}
if(!init_kf) {
if(init_gps && init_compass && init_imu)
kalmanInit();
}
// Update the State...
if(init_kf && (get_time() - shared->kalmanData.lastKalmanUpdateTime)>=0.01) {
updateState();
++kalmanUpdateCount;
}
usleep(50);
}
}
