elvis/progettoso
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

style for files taglialegna.* apiFile.*

Browse Source
This commit is contained in:
elvis
2022-05-07 21:16:35 +02:00
parent d9de77e427
commit f547da3d73
4 changed files with 551 additions and 259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
lib/log/taglialegna.c
View File

@ -7,8 +7,8 @@
#include <errno.h>
#include <pthread.h>
#include <taglialegna.h>
#include <fileQueue.h>
#include "taglialegna.h"
#include "fileQueue.h"
taglia_t *taglia_init(char *file, int n, ...) {
int max_files;
@ -17,19 +17,19 @@ taglia_t *taglia_init(char *file, int n, ...) {
taglia_t *new = calloc(1, sizeof(taglia_t));
if(new == NULL) {
perror("calloc");
perror("taglia_init: calloc");
return NULL;
}
va_list ap;
va_start(ap, n); // nota: si ha sempre default argument promotion,
// ma noi leggiamo solo int quindi ignoriamo il problema
va_start(ap, n); /* note: by default we have argument promotion,
* but we read only int so thats not a problem */
max_files = (n<1)?0:va_arg(ap, int);
max_size = (n<2)?0:va_arg(ap, int);
cache_misses = (n<3)?0:va_arg(ap, int);
va_end(ap);
if ( (new->file = fopen(file, "w")) == NULL ) {
perror("fopen logfile");
perror("taglia_init: fopen");
goto _error_init;
}
@ -38,7 +38,7 @@ taglia_t *taglia_init(char *file, int n, ...) {
new->cache_misses = cache_misses;
if (pthread_mutex_init(&new->m, NULL) != 0) {
perror("mutex init");
perror("taglia_init: pthread_mutex_init");
fclose(new->file);
goto _error_init;
}
@ -64,7 +64,7 @@ size_t taglia_write(taglia_t *taglia, char *buf) {
size_t n = 0;
pthread_mutex_lock(&taglia->m);
if ((n = fwrite(buf, sizeof(char), strlen(buf), taglia->file)) < 0) {
perror("fwrite");
perror("taglia_write: fwrite");
goto _error_write;
}
pthread_mutex_unlock(&taglia->m);
@ -83,8 +83,8 @@ size_t taglia_log(taglia_t *taglia, char *buf) {
}
time_t now = time(NULL);
if(now == (time_t)(-1)) { // errore a ottenere l'ora
perror("ERROR: time");
if(now == (time_t)(-1)) {
perror("taglia_write: time");
goto _error_taglia_log;
}
struct tm tmp_buf;
@ -92,26 +92,28 @@ size_t taglia_log(taglia_t *taglia, char *buf) {
now_tm = gmtime_r(&now, &tmp_buf);
if(!now_tm){
perror("ERROR: gmtime_r");
perror("taglia_write: gmtime_r");
goto _error_taglia_log;
}
char buff[15]; // 13 only should strictly needed
char buff[15]; /* 13 only should be strictly needed */
if(!strftime(buff, sizeof(buff), "[%T] ", now_tm)) {
perror("ERROR: strftime");
perror("taglia_write: strftime");
goto _error_taglia_log;
}
size_t n, m;
pthread_mutex_lock(&taglia->m);
if((n = fwrite(buff, sizeof(char), strnlen(buff, sizeof(buff)), taglia->file)) < 0){
perror("ERROR: fwrite");
n = fwrite(buff, sizeof(char), strnlen(buff, sizeof(buff)), taglia->file);
if(n < 0){
perror("taglia_write: fwrite");
goto _error_taglia_log_mutex;
}
if((m = fwrite(buf, sizeof(char), strlen(buf), taglia->file)) < 0){
perror("ERROR: fwrite");
m = fwrite(buf, sizeof(char), strlen(buf), taglia->file);
if(m < 0){
perror("taglia_write: fwrite");
goto _error_taglia_log_mutex;
}
pthread_mutex_unlock(&taglia->m);
@ -156,21 +158,27 @@ int taglia_stats(taglia_t *taglia, FILE *stream) {
double res = ((double) taglia->max_size)/((double) 1000000);
fprintf(stream, "Numero di file massimo memorizzato nel server: %zu\n", taglia->max_files);
// fprintf(stream, "Dimensione massima in Mbytes raggiunta dal file storage: %.2lf MB\n", res);
fprintf(stream, "Dimensione massima in Mbytes raggiunta dal file storage: %lf MB\n", res);
fprintf(stream, "Numero di volte in cui l’algoritmo di rimpiazzamento della cache è stato eseguito per selezionare uno o più file \"vittima\": %zu\n", taglia->cache_misses);
fprintf(stream, "Numero di file massimo memorizzato nel server: %zu\n",
taglia->max_files);
/* fprintf(stream, "Dimensione massima in Mbytes raggiunta dal file storage: %.2lf MB\n", res); */
fprintf(stream, "Dimensione massima in Mbytes raggiunta dal file storage: %lf MB\n",
res);
fprintf(stream, "Numero di volte in cui l’algoritmo di rimpiazzamento della cache è stato eseguito per selezionare uno o più file \"vittima\": %zu\n",
taglia->cache_misses);
fflush(stream);
char tmp_buf[2048];
int n = 0;
size_t m = sizeof(tmp_buf);
n += snprintf(tmp_buf+n, m-n, "Numero di file massimo memorizzato nel server: %zu\n", taglia->max_files);
n += snprintf(tmp_buf+n, m-n, "Numero di file massimo memorizzato nel server: %zu\n",
taglia->max_files);
if(m<n) goto _error_taglia_stats;
n += snprintf(tmp_buf+n, m-n, "Dimensione massima in Mbytes raggiunta dal file storage: %.2lf MB\n", res);
n += snprintf(tmp_buf+n, m-n, "Dimensione massima in Mbytes raggiunta dal file storage: %.2lf MB\n",
res);
if(m<n) goto _error_taglia_stats;
n += snprintf(tmp_buf+n, m-n, "Numero di volte in cui l’algoritmo di rimpiazzamento della cache è stato eseguito per selezionare uno o più file \"vittima\": %zu\n", taglia->cache_misses);
n += snprintf(tmp_buf+n, m-n, "Numero di volte in cui l’algoritmo di rimpiazzamento della cache è stato eseguito per selezionare uno o più file \"vittima\": %zu\n",
taglia->cache_misses);
if(m<n) goto _error_taglia_stats;
pthread_mutex_unlock(&taglia->m);
@ -182,5 +190,6 @@ int taglia_stats(taglia_t *taglia, FILE *stream) {
_error_taglia_stats:
pthread_mutex_unlock(&taglia->m);
perror("taglia_stats: snprintf");
return -1;
}

65
lib/log/taglialegna.h
View File

@ -5,39 +5,74 @@
#include <stdio.h>
#include <pthread.h>
#include <fileQueue.h>
#include "fileQueue.h"
typedef struct taglia_s {
FILE *file;
size_t max_files;
long max_size;
size_t cache_misses;
pthread_mutex_t m; // per sincronizzare le scritture al file
pthread_mutex_t m; /* per sincronizzare le scritture al file */
} taglia_t;
// crea una nuova istanza
// \param file: file su cui scrivere i dati
// \param n: numero di parametri opzionali
// parametri opzionali in questo ordine:
// max_files, max_size, cache_misses
// \return istanza creata, NULL se errore
/**
* @brief Creates new instance
*
* @param file path to file to write into
* @param n number of optional parameters, in order:
* int max_files, int max_size, int cache_misses
* @return created istance, NULL if error
*/
taglia_t *taglia_init(char *file, int n, ...);
// elimina un'istanza deallocando e chiudendo le rispettive risorse
/**
* @brief Deallocates instance
*
* @param taglia instance to deallocate
*/
void taglia_del(taglia_t *taglia);
// scrive quello contenuto dentro a buf sul file
// \return numero di char scritti, -1 se errore
/**
* @brief Writes buffer to the log
*
* @param taglia
* @param buf NULL terminated string to write
* @return number of char written, -1 if error occurred
*/
size_t taglia_write(taglia_t *taglia, char *buf);
// scrive il contenuto di buf sul file con ora associata
/**
* @brief Writes buffer to the log with timestamp
*
* @param taglia
* @param buf NULL terminated string to write
* @return number of char written, -1 if error occurred
*/
size_t taglia_log(taglia_t *taglia, char *buf);
// update delle statistiche
// \return 0 successo, -1 errore
/**
* @brief Updates statistics
*
* @param taglia
* @param queue structure that holds the files
* @param miss number of cache misses to add
* @return 1 if success, -1 if error occurred
*/
int taglia_update(taglia_t *taglia, queueT *queue, int miss);
// print delle statistiche attuali su stream
/**
* @brief Writes stats to the stream and to the log
*
* @param taglia
* @param stream
* @return 0 if success, -1 if error occurred
*/
int taglia_stats(taglia_t *taglia, FILE *stream);
#endif /* _TAGLIALEGNA */