void helpmessage::show_help_message (string cmdValue)
{
if (!cmdValue.compare("default") ||
!cmdValue.compare("!help")) {
cout<<"------------------------------------------------------------"<<endl;
cout<<" !help --- shows this help message!"<<endl;
cout<<" example: !help cat"<<endl;
cout<<" -- shows the useage of the command cat"<<endl;
cout<<"------------------------------------------------------------"<<endl;
cout<<" only follow cmmand can be used:"<<endl;
cout<<"------------------------------------------------------------"<<endl;
cout<<" ls --- list the all objects in current";
cout<<" level (directory)!"<<endl;
cout<<" cd --- change into another sub level(directory)"<<endl;
cout<<" cat --- shows the content of the items"<<endl;
cout<<" add --- add an intems into the current level last node"<<endl;
cout<<" remove --- remove an items"<<endl;
cout<<" !quit --- quit this program.." <<endl;
cout<<"------------------------------------------------------------"<<endl;
} else if (!cmdValue.compare("add")) {
help_message_add();
} else if (!cmdValue.compare("ls")) {
help_message_ls();
} else if (!cmdValue.compare("remove")) {
help_message_remove();
} else if (!cmdValue.compare("cat")) {
help_message_cat();
} else if (!cmdValue.compare("cd")){
help_message_cd();
} else {
show_help_message("default");
return;
}
}
int main(int argc, char** argv) {
FILE *cpuFile = NULL;
FILE *gpuFile = NULL;
FILE *jetsonFile=NULL;
FILE *hybridFile = NULL;
FILE *tipoFile=NULL;
FILE *tempiFile=NULL;
FILE *datiFinali=NULL;
int processID; // ID del processo
extern int processNumber; // numero dei processi coinvolti
const int processRoot=0; // rank del processo padre
struct custom_queue *main_queue = malloc(sizeof(struct custom_queue)); // istanzia in memoria spazio per la coda degli offset
//extern unsigned long long int LENGTH_OFFSET_ARRAY; // lunghezza dell'array degli offset (MPI_Scatter)
unsigned long long int OFFSET_ARRAY_CLIENT[2]; // Array di due elementi (offset inizio e offset fine) da inviare ai client)
// OFFSET_ARRAY:= ARRAY CONTENTENTE GLI OFFSET
MPI_Init(&argc, &argv); // Inizializzazione ambiente MPI
MPI_Comm_size(MPI_COMM_WORLD, &processNumber); // Numero totale dei processori
MPI_Comm_rank(MPI_COMM_WORLD, &processID); // Identifichiamo il processo corrente
MESSAGE_SIZE = getMessageLenght(MESSAGE_CONST); // inizializzo la lunghezza del messaggio
/********************** LEGGO LE OPZIONI DELL'UTENTE **********************/
//ora ci interessa solo sapere se l'utente ha specificato l'opzione -key
//le altre opzioni verranno gestite più avanti (in base al rank del processo)
int code = set_options(argc, argv);
if(key_opt_set)
ENCRYPTION_KEY = user_key;
/**************************************************************************/
encryptMessage(MESSAGE_CONST, MESSAGE_SIZE, ENCRYPTION_KEY,&MODIFIED_MESSAGE); //Questa funzione deve essere fatta da tutti i processi altrimente non vengono modificate le variabili.
LENGTH_OFFSET_ARRAY=(processNumber)*2;
//Struct che permette la comunicazione di dati eterogenei.
int block[4]={1,1,1,1};
MPI_Datatype types[4]={MPI_LONG_LONG,MPI_LONG_LONG,MPI_DOUBLE,MPI_INT};
MPI_Aint disallineamentoBIT[4]={offsetof(infoExec,possibileChiave),offsetof(infoExec,processID),offsetof(infoExec,tempo),offsetof(infoExec,tipo)};
MPI_Type_struct(4, block, disallineamentoBIT, types, &Info_Type);
MPI_Type_commit(&Info_Type);
MPI_Type_commit(&Info_Type);
//Fine creazione della struct
unsigned long long int OFFSET_ARRAY[LENGTH_OFFSET_ARRAY];
//Gestione e analisi dei dati
if(cpu_mode_set)
cpuFile=fopen("cpuFile.txt","w");
if(gpu_mode_set)
gpuFile=fopen("gpuFile.txt","w");
if(zcmem_opt_set)
jetsonFile=fopen("jetsonFile.txt","w");
if(hybrid_mode_set)
hybridFile=fopen("hybridFile.txt","w");
tipoFile=fopen("tipoFile.txt","w");
tempiFile=fopen("tempiFile.txt","w");
datiFinali=fopen("datiFinali.txt","w");
//Fine gestione e analisi dei dati
if(processID==0){
welcomeMessage();
if(code == -1) {
printf("\n\nLe opzioni specificate non sono corrette. Il programma terminera'.\n");
MPI_Abort(MPI_COMM_WORLD, code);
}
else if(code == 1) {
show_help_message();
MPI_Abort(MPI_COMM_WORLD, code);
}
if(verbose_set){
printf(BLU"\n\n####### OPZIONI DI AVVIO #######"RESET);
printf("\nVerbosita' ATTIVA.");
/* CHECKING OPTIONS */
if(cpu_mode_set) {
printf("\nCPU_mode ATTIVA. ");
}
else if(gpu_mode_set){
printf("\nGPU_mode ATTIVA. ");
}
else
printf("\nHybrid_mode ATTIVA. ");
if(zcmem_opt_set)
printf("\nZero_Copy_Memory_option ATTIVA. ");
printf("\n\nMessaggio in chiaro:"WHT" %s"RESET,MESSAGE_CONST);
printf("\n\nChiave utilizzata per cifrare: "WHT"%llu"RESET,ENCRYPTION_KEY);
printf(BLU"\n\n####### FINE OPZIONI DI AVVIO #######"RESET);
fflush(stdout);
}
/* ----- Fase di precomputazione ----- */
if(verbose_set){
printf(BLU"\n\n####### INIZIO FASE DI PRECOMPUTAZIONE #######"RESET);
printf("\n\nMessaggio cifrato ASCII:"WHT);
for(int i=0;i<MESSAGE_SIZE;i++)
printf(WHT"%c"RESET,MODIFIED_MESSAGE[i]);
printf("\n\n");
fflush(stdout);
}
initOffsetArray(OFFSET_ARRAY,LENGTH_OFFSET_ARRAY,START_SECOND_OFFSET); //Inizializzo l'array con gli offset (dalla chiave 0 alla chiave 2^55 - 1)
main_queue->empty_queue = true; // inizializzazione della coda (dalla chiave 2^55 alla chiave 2^56 - 1)
main_queue->head = NULL; //
main_queue->tail = NULL;
if(cpu_mode_set) {
queue_init(main_queue, custom_pow(2,55));
}
else if(gpu_mode_set || hybrid_mode_set) {
queue_init(main_queue, 0);
}
last_queue_elem = main_queue->tail->value; // inizializzo l'ultimo elemento della coda (variabile globale)
/* ----- fine fase di precomputazione ----- */
if(verbose_set){
printf(BLU"######## FINE FASE DI PRECOMPUTAZIONE ########\n"RESET);
fflush(stdout);
}
}
if(verbose_set){
printf("Distribuzione chiavi ai Client ... \n");
}
if(cpu_mode_set)
MPI_Scatter(OFFSET_ARRAY, 2, MPI_UNSIGNED_LONG_LONG, OFFSET_ARRAY_CLIENT, 2, MPI_UNSIGNED_LONG_LONG,processRoot,MPI_COMM_WORLD);
// GESTIONE DEI TAG.
if(processID==0) {
long double TempoTotale=0.0;
long long int chiaviProcessateCPU=0;
long long int chiaviProcessateGPU=0;
char * tipoElaboratore=malloc(sizeof(char)*4);
infoExec client_data;// conserverà il messaggio inviato dal client (la chiave, se è stata trovata)
while(true) {
MPI_Status recv_status; // struttura che contiene informazioni sul messaggio ricevuto
MPI_Recv(&client_data, sizeof(Info_Type), Info_Type, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &recv_status); //ricezione messaggio
if(client_data.tipo==0)
strcpy(tipoElaboratore, "gpu");
else
strcpy(tipoElaboratore,"cpu");
int recieved_tag = recv_status.MPI_TAG; // viene ricavato il tag del messaggio inviato
int response_destination = recv_status.MPI_SOURCE; // viene ricavato il rank del mittente del messaggio
bool empty_queue = false; // indica se la coda si è svuotata o no. Permette di uscire da while
switch(recieved_tag) { // in base al tag ricevuto, eseguiamo un'operazione differente
case 0: {
full_decrypt(client_data.possibileChiave, MODIFIED_MESSAGE, MESSAGE_SIZE);
if(verbose_set){
printf("\n\n Tutti i Client hanno smesso di elaborare le chiavi e hanno rilasciato le risorse utilizzate. Il processo Server terminerà\n\n\n");
}
fflush(stdout);
fprintf(datiFinali,"TEMPO TOTALE D'ESECUZIONE: %Lf \n",TempoTotale);
fprintf(datiFinali,"CHIAVI ELABORATE DA CPU: %llu\n", chiaviProcessateCPU);
fprintf(datiFinali,"CHIAVI ELABORATE DA GPU: %llu\n", chiaviProcessateGPU);
fprintf(datiFinali,"NUMERO DI CHIAVI PROCESSATE: %llu\n", key_counter);
fprintf(datiFinali,"CHIAVE TROVATA: %llu\n", client_data.possibileChiave);
if(cpu_mode_set){
fflush(cpuFile);
fclose(cpuFile);
}
if(gpu_mode_set){
fflush(gpuFile);
fclose(gpuFile);
}
if(zcmem_opt_set){
fflush(jetsonFile);
fclose(jetsonFile);
}
if(hybrid_mode_set){
fflush(hybridFile);
fclose(hybridFile);
}
fclose(tipoFile);
fclose(tempiFile);
fclose(datiFinali);
free_queue(main_queue); // libero tutte le risorse allocate per la coda
MPI_Abort(MPI_COMM_WORLD, 0);
break;
}
case 1: {
long long int new_offset = custom_dequeue(main_queue);
if(new_offset == -2) {
printf("ERRORE: La coda e' vuota, impossibile eseguire dequeue."); // -2 è il valore di ritorno per quando la coda è vuota
exit(-2);
}
if(new_offset == -1) {
printf("\nLa coda degli offset e' vuota. Attendere la ricezione della chiave...\n");
empty_queue = true;
MPI_Send(&new_offset, 1, MPI_LONG_LONG, response_destination, new_offset_to_client_tag, MPI_COMM_WORLD);
break;
}
MPI_Send(&new_offset, 1, MPI_LONG_LONG, response_destination, new_offset_to_client_tag, MPI_COMM_WORLD);
long long int new_offset_enqueued = last_queue_elem + LENGTH_INTER_QUEUE;
if( new_offset_enqueued >= MAX_KEY || last_queue_elem == -1) // MAX_KEY = 2^56
new_offset_enqueued = -1; // se siamo arrivati all'offset 2^(56)-1 abbiamo finito gli offset e bsogna mettere -1 nella coda
custom_enqueue(new_offset_enqueued, main_queue);
TempoTotale+=client_data.tempo;
printf("\n"RED"Percentuale Completamento:"WHT" %.10f%c"RED ". Testate: "WHT"%llu"RED". Rimanenti: "WHT"%llu"RED". Elaborate dal nodo numero:"WHT"%llu - %s" RED". Tempo:"WHT"%f"RED". TOTALE:"WHT" %Lf"RESET, current_percentage,'%',key_counter,MAX_KEY-key_counter,client_data.processID,tipoElaboratore,client_data.tempo,TempoTotale);
fflush(stdout);
key_counter += client_data.possibileChiave;
double percentage =(key_counter*100)/(float)MAX_KEY;
current_percentage = percentage;
last_queue_elem = new_offset_enqueued;
if(client_data.tipo==0) //gpu
chiaviProcessateGPU+=client_data.possibileChiave;
else
chiaviProcessateCPU+=client_data.possibileChiave;
if(cpu_mode_set)
writeDataOnTxt(cpuFile, tipoFile, tempiFile, client_data.tipo, client_data.tempo, client_data.possibileChiave);
else if(gpu_mode_set){
writeDataOnTxt(gpuFile, tipoFile, tempiFile, client_data.tipo, client_data.tempo, client_data.possibileChiave);
}else if(hybrid_mode_set){
writeDataOnTxt(hybridFile, tipoFile, tempiFile, client_data.tipo, client_data.tempo, client_data.possibileChiave);
}
break;
}
case 2: {
key_counter += client_data.possibileChiave;
double percentage =(key_counter*100)/(float)MAX_KEY;
current_percentage = percentage;
TempoTotale+=client_data.tempo;
printf("\n"RED"Percentuale Completamento:"WHT" %.10f%c"RED ". Testate: "WHT"%llu"RED". Rimanenti: "WHT"%llu"RED". Elaborate dal nodo numero:"WHT"%llu - %s" RED". Tempo:"WHT"%f"RED". TOTALE:"WHT" %Lf"RESET, current_percentage,'%',key_counter,MAX_KEY-key_counter,client_data.processID,tipoElaboratore,client_data.tempo,TempoTotale);
fflush(stdout);
if(client_data.tipo==0) //gpu
chiaviProcessateGPU+=client_data.possibileChiave;
else
chiaviProcessateCPU+=client_data.possibileChiave;
if(cpu_mode_set)
writeDataOnTxt(cpuFile, tipoFile, tempiFile, client_data.tipo, client_data.tempo, client_data.possibileChiave);
else if(gpu_mode_set){
writeDataOnTxt(gpuFile, tipoFile, tempiFile, client_data.tipo, client_data.tempo, client_data.possibileChiave);
}else if(hybrid_mode_set){
writeDataOnTxt(hybridFile, tipoFile, tempiFile, client_data.tipo, client_data.tempo, client_data.possibileChiave);
}
break;
}
default: {
printf("\nIl tag ricevuto non e' valido.\n");
}
}
if(empty_queue) {
free_queue(main_queue); // libero tutte le risorse allocate per la coda
break; // usciamo dal ciclo se la coda è vuota
}
}
}
if(processID > 0){//Processo client. Inizio a processare la parte di chivi che mi interessa.
if(cpu_mode_set){
testOffset(OFFSET_ARRAY_CLIENT[0], OFFSET_ARRAY_CLIENT[1], &MODIFIED_MESSAGE, &SUCCESS, processID);
}
#ifdef GPU_BY_SCRIPT
if(gpu_mode_set){
if(zcmem_opt_set){
testOffsetGpuJetson(MODIFIED_MESSAGE, &SUCCESS, processID);
}else{
testOffsetGpu(&MODIFIED_MESSAGE, &SUCCESS, processID);
}
}
if(hybrid_mode_set) {
if(processID%2==1)
testOffsetHybridCpu(&MODIFIED_MESSAGE, &SUCCESS, processID);
else if(processID%2==0)
if(zcmem_opt_set)
testOffsetGpuJetson(MODIFIED_MESSAGE, &SUCCESS, processID);
else
testOffsetGpu(&MODIFIED_MESSAGE, &SUCCESS, processID);
}
#endif
if(verbose_set){
printf("Il processo %d ha smesso di elaborare.\n",processID);
}
}
MPI_Finalize();
}
int argparser(int argc, char **argv,
char **infile_value,
char **outfile_value,
char **config_file_value) {
int i;
int index;
int c;
int help_flag;
int version_flag;
help_flag = 0;
version_flag = 0;
*infile_value = NULL;
*outfile_value = NULL;
*config_file_value = NULL;
opterr = 0;
while ((c = getopt(argc, argv, "hvi:c:o:")) != -1)
switch (c) {
case 'h':
help_flag = 1;
break;
case 'v':
version_flag = 1;
break;
case 'i':
*infile_value = optarg;
break;
case 'c':
*config_file_value = optarg;
break;
case 'o':
*outfile_value = optarg;
break;
case '?':
if (optopt == 'i')
fprintf(stderr,
"Option -%c requires an argument (input tree file name).\n",
optopt);
else if (optopt == 'c')
fprintf(stderr,
"Option -%c requires an argument (config file name).\n",
optopt);
else if (optopt == 'o')
fprintf(stderr,
"Option -%c requires an argument (output tree file name).\n",
optopt);
else if (isprint(optopt))
fprintf(stderr, "Unknown option `-%c'.\n", optopt);
else
fprintf(stderr,
"Unknown option character `\\x%x'.\n",
optopt);
show_help_message();
return 1;
default:
abort();
}
if (help_flag)
show_help_message();
if (version_flag)
print_version();
printf("%s", BAR);
printf("[COMMAND USED]\n\n ");
for (i = 0; i < argc; i++) {
printf("%s ", argv[i]);
}
printf("\n\n");
if (*infile_value)
printf(" -i Input tree file: %s\n", *infile_value);
else {
printf("\nERROR: -i \"input_tree_file\" must be specified\n");
exit(EXIT_FAILURE);
}
if (*config_file_value)
printf(" -c Config file: %s\n", *config_file_value);
else {
printf("\nERROR: \"-c config_file\" must be specified\n");
exit(EXIT_FAILURE);
}
if (*outfile_value)
printf(" -o Output tree file: %s\n\n", *outfile_value);
else {
printf("\nERROR: \"-o output_tree_filename\" must be specified\n");
exit(EXIT_FAILURE);
}
for (index = optind; index < argc; index++)
printf("Non-option argument %s\n", argv[index]);
return 0;
}
/** \brief main loop to run tests.
*
* The tests being run are described in the documentation of this file.
*
* \return never returns, test loop runs ad infinitum. */
int main(void) {
uint8_t switch_mask = PIN6_bm;
int16_t position = 0;
int16_t steps = 1000;
uint16_t accel = 100;
uint16_t decel = 100;
uint16_t speed = 800;
PS_t pressure_sensor;
LA_t LA_needle;
LA_t LA_ring;
command_t command;
uint16_t steps_left = 0;
/* call all of the setup_* functions */
cli();
setup_clocks();
setup_LEDs();
setup_switches(switch_mask);
setup_pressure_sensor(&pressure_sensor);
setup_USART_BC();
setup_linear_actuators(&LA_needle, &LA_ring);
sei();
/* shows the help menu */
show_help_message();
/* show the current state of the linear actuator */
show_motor_data(position, accel, decel, speed, steps);
while (1) {
switch(command = parse_command(&steps, &accel, &decel, &speed)) {
case STEP:
LA_move(&LA_needle, steps, accel, decel, speed);
LA_move(&LA_ring, steps, accel, decel, speed);
position += steps;
printf("\n\n");
break;
case MOVE:
LA_move(&LA_needle, steps, accel, decel, speed);
LA_move(&LA_ring, steps, accel, decel, speed);
position += steps;
printf("\n\n");
break;
case ACCEL:
case DECEL:
case SPEED:
printf("\n\n");
break;
case REPEAT:
LA_move(&LA_needle, steps, accel, decel, speed);
LA_move(&LA_ring, steps, accel, decel, speed);
position += steps;
printf("\n\n");
break;
case HELP:
show_help_message();
break;
case NONE:
break;
default:
show_help_message();
break;
}
if ((command != HELP) && (command != NONE)) {
while (LA_get_motor_state(&LA_needle) != SM_STOP) {
if (READ_SWITCHES & PIN6_bm) {
LA_brake(&LA_needle);
LA_brake(&LA_ring);
printf("motors parked\n");
}
if (steps > 0) {
steps_left = (int32_t)steps * SPR / LA_needle.pitch
- LA_needle.motor.speed_ramp.step_count;
}
else {
steps_left = -1 * (int32_t)steps * SPR / LA_needle.pitch
- LA_needle.motor.speed_ramp.step_count;
}
printf(" Running... Steps Left: %d\n", steps_left);
delay_ms(250);
}
printf(" Done with command\n");
show_motor_data(position, accel, decel, speed, steps);
}
}//end while (1)
}
