void escribir(uint8_t idProc, uint8_t nroPag, char* textoAEscribir, int socketSwap, int socketCPU) {
t_contenido_pagina * escritura;
escritura = iniciarContenidoPagina();
t_marco_y_bit* marcoYBit;
marcoYBit = iniciarMarcoYBit();
marcoYBit = buscarSiEstaEnMemoria(idProc, nroPag,1);
escritura->numeroPagina = nroPag;
escritura->PID = idProc;
string_append(&escritura->contenido, textoAEscribir);
if (marcoYBit->bitPresencia == 0) { // traer de swap una pag, cargarla a memoria
uretardo(configuracion->retardoMemoria );
traerDeSwapUnaPaginaDeUnProcesoPorEscribir(idProc, nroPag, textoAEscribir, socketSwap);
char* textoLogger = string_new();
fallo++;
string_append(&textoLogger, string_from_format("Acceso a swap (fallo de página:%i), PID: %i, pagina: %i\n",fallo, idProc, nroPag));
my_log_info(textoLogger);
} else { // entonces tengo el id del marco
escribirEnMarcoYponerBitDeModificada(marcoYBit->idMarco, textoAEscribir);
//LOG
char* textoLogger = string_new();
string_append(&textoLogger, string_from_format("Acceso a memoria realizado, PID: %i, N° de"
" página: %i y N° de marco: %i\n", idProc, nroPag, marcoYBit->idMarco));
my_log_info(textoLogger);
enviarRtaEscribirACPU(escritura, socketCPU);
}
}
int main(int argc, char **argv) {
rtmp_state_t st;
int to_write;
if (argc != 3) {
fprintf(stderr, "usage: %s <url> <0|1>\n", argv[0]);
return 1;
}
logger_init("/dev/stderr");
//set_logger_level(LOG_DEBUG);
set_logger_level(LOG_INFO);
to_write = atoi(argv[2]) ? 1 : 0;
st.remote_url = argv[1];
st.flv_path = "dump.flv";
if (rtmp_state_init(&st, to_write)) {
my_log_error("rtmp_state_init() failed");
return 1;
}
if (rtmp_handshake(&st)) {
my_log_error("handshake is unsuccessful");
return 1;
}
my_log_info("handshake is successful");
if (rtmp_send_connect(&st)) {
my_log_error("connect failed");
return 1;
}
if (to_write) {
if (rtmp_client_wait_publishing(&st))
return 1;
my_log_info("ready to send media");
if (rtmp_send_media(&st)) {
my_log_info("error sending media");
return 1;
}
} else {
if (rtmp_client_wait_play(&st))
return 1;
my_log_info("ready to play");
if (rtmp_receive_media(&st)) {
my_log_info("error getting media");
return 1;
}
}
rtmp_state_free(&st);
return 0;
}
void leer(uint8_t idProc, uint8_t pag, int socketSwap, int socketCPU) {
char* contenido;
t_contenido_pagina * lecturaMandarCpu;
lecturaMandarCpu = iniciarContenidoPagina();
t_marco_y_bit* marcoYBit;
marcoYBit = iniciarMarcoYBit();
lecturaMandarCpu->PID = idProc;
lecturaMandarCpu->numeroPagina = pag;
marcoYBit = buscarSiEstaEnMemoria(idProc, pag,0);
if (marcoYBit->bitPresencia == 0) { // no lo encontro
uretardo(configuracion->retardoMemoria);
traerDeSwapUnaPaginaDeUnProceso(idProc, pag, socketSwap); // aca se tiene que pedir a swap la pagina a y del proceso idProc
char* textoLogger = string_new();
fallo ++;
string_append(&textoLogger, string_from_format("Acceso a swap (fallo de página: %i), PID: %i, pagina: %i\n",fallo, idProc, pag));
my_log_info(textoLogger);
} else { // aca significa que trajo el id porque esta en memoria
contenido = traerContenidoDeMarco(marcoYBit->idMarco);
char* textoLogger = string_new();
string_append(&textoLogger, string_from_format("Acceso a memoria realizado, PID: %i, N° de"
" página: %i y N° de marco: %i\n", idProc, pag, marcoYBit->idMarco));
my_log_info(textoLogger);
lecturaMandarCpu->contenido = contenido;
enviarACPUContenidoPaginaDeUnProcesoPorLeer(lecturaMandarCpu, socketCPU);
}
}
static void validate_frequencies(int64_t *array, int64_t minValueIncluded,
int64_t maxValueNotIncluded, int64_t numSamples) {
int64_t interval_size = maxValueNotIncluded - minValueIncluded;
int64_t *frequencies = MY_MALLOC(interval_size, int64_t);
for (int64_t i = 0; i < numSamples; ++i) {
frequencies[array[i] - minValueIncluded]++;
}
int64_t expectedFreq = my_math_round_int(
numSamples / (double) interval_size);
int64_t expectedFreqDelta = my_math_round_int(expectedFreq * 0.01);
my_log_info("expected frequency=%"PRIi64" +/- %"PRIi64"\n", expectedFreq,
expectedFreqDelta);
int64_t cont_errors = 0;
for (int64_t i = 0; i < interval_size; ++i) {
int64_t freq = frequencies[i];
bool is_ok = (MY_ABS_INT(expectedFreq - freq) <= expectedFreqDelta);
if (interval_size <= 100) {
double freq_pct = 100.0 * freq / (double) numSamples;
my_log_info("%3"PRIi64" =%7"PRIi64" (%1.2lf%%)%s\n",
i + minValueIncluded, freq, freq_pct, is_ok ? "" : " *");
}
if (!is_ok)
cont_errors++;
}
if (cont_errors == 0)
my_log_info("OK. All frequencies inside range [%"PRIi64",%"PRIi64"]\n",
expectedFreq - expectedFreqDelta,
expectedFreq + expectedFreqDelta);
else
my_log_info(
"ERROR. %"PRIi64"/%"PRIi64" frequencies out of range [%"PRIi64",%"PRIi64"]\n",
cont_errors, interval_size, expectedFreq - expectedFreqDelta,
expectedFreq + expectedFreqDelta);
MY_FREE(frequencies);
}
void pvcd_print_transformations() {
#ifndef NO_OPENCV
my_log_info("\nAvailable Transformations:\n");
for (int64_t i = 0; i < my_vectorObj_size(defs_tr); ++i) {
Transform_Def *def = my_vectorObj_get(defs_tr, i);
my_log_info(" %s%s%s\n", def->trCode,
(def->helpText == NULL) ? "" : "_",
(def->helpText == NULL) ? "" : def->helpText);
}
#endif
}
static void validate_stats(double actualAvg, double expectedAvg) {
double pctErrorAvg = 0.001;
double expectedAvgDelta = expectedAvg * pctErrorAvg;
//double errorAvg = MY_ABS_DOUBLE(expectedAvg - avg) / expectedAvg;
my_log_info("expectedAverage=%lf +/- %lf\n", expectedAvg, expectedAvgDelta);
if (MY_ABS_DOUBLE(expectedAvg - actualAvg) <= expectedAvgDelta)
my_log_info("OK. average %lf inside range [%lf, %lf]\n", actualAvg,
expectedAvg - expectedAvgDelta, expectedAvg + expectedAvgDelta);
else
my_log_info("ERROR. average %lf out of range [%lf, %lf]\n", actualAvg,
expectedAvg - expectedAvgDelta, expectedAvg + expectedAvgDelta);
}
void my_random_testDouble(double minValueIncluded, double maxValueNotIncluded,
int64_t numSamples) {
my_log_info("\nrandomTestDouble\n");
double *array = MY_MALLOC_NOINIT(numSamples, double);
my_random_doubleList(minValueIncluded, maxValueNotIncluded, array,
numSamples);
double actualAvg = my_math_averageDoubleArray(numSamples, array);
char *st = my_newString_double(actualAvg);
my_log_info("%"PRIi64" random double numbers in [%lf,%lf): %s\n",
numSamples, minValueIncluded, maxValueNotIncluded, st);
validate_stats(actualAvg, (maxValueNotIncluded + minValueIncluded) / 2.0);
MY_FREE_MULTI(st, array);
}
void enviarEscribirAlSwap(t_sobreescribir_swap *estructura, int socketSwap) {
enviarStruct(socketSwap, ESCRIBIR_SWAP, estructura);
char* textoLogger = string_new();
cantEscriturasEnSwap++;
string_append(&textoLogger, string_from_format("Escritura enviada a swap nro: %i\n", cantEscriturasEnSwap));
my_log_info(textoLogger);
}
static struct MknnDistanceInstance multi_dist_new(const char *id_dist,
MknnDistanceParams *params_distance) {
struct State_Multi_Dist *state_dist = MY_MALLOC(1, struct State_Multi_Dist);
if (mknn_distanceParams_getString(params_distance, "distances") != NULL) {
MyVectorString *distnames = parseTerms(
mknn_distanceParams_getString(params_distance, "distances"),
';');
state_dist->num_distances = my_vectorString_size(distnames);
if (state_dist->num_distances < 1) {
my_log_info(
"Parameter 'distances' must contain at least one distance\n");
mknn_predefDistance_helpPrintDistance(id_dist);
}
state_dist->distances = MY_MALLOC(state_dist->num_distances,
MknnDistance*);
state_dist->weights_combination = MY_MALLOC(state_dist->num_distances,
double);
state_dist->weights_normalize = MY_MALLOC(state_dist->num_distances,
double);
for (int64_t i = 0; i < state_dist->num_distances; ++i) {
char *term = my_vectorString_get(distnames, i);
state_dist->distances[i] = mknn_distance_newPredefined(
mknn_distanceParams_newParseString(term), true);
state_dist->weights_combination[i] = 1;
state_dist->weights_normalize[i] = 1;
}
my_vectorString_release(distnames, true);
}
void my_random_testInt(int64_t minValueIncluded, int64_t maxValueNotIncluded,
int64_t numSamples) {
my_log_info("\nrandomTestInt\n");
int64_t *array = MY_MALLOC(numSamples, int64_t);
my_random_intList(minValueIncluded, maxValueNotIncluded, array, numSamples);
double actualAvg = my_math_averageIntArray(numSamples, array);
double expectedAvg = (maxValueNotIncluded - 1 + minValueIncluded) / 2.0;
char *st = my_newString_double(actualAvg);
my_log_info("%"PRIi64" random int numbers in [%"PRIi64",%"PRIi64"): %s\n",
numSamples, minValueIncluded, maxValueNotIncluded, st);
MY_FREE(st);
validate_stats(actualAvg, expectedAvg);
validate_frequencies(array, minValueIncluded, maxValueNotIncluded,
numSamples);
MY_FREE(array);
}
void my_local_drawKeypoint(IplImage* img, struct MyLocalKeypoint kp) {
int px = my_math_round_int(kp.x);
int py = my_math_round_int(kp.y);
if (px == img->width)
px = img->width - 1;
if (py == img->height)
py = img->height - 1;
if (!MY_BETWEEN(px, 0,
img->width - 1) || !MY_BETWEEN(py, 0, img->height-1)) {
my_log_info("point (%i,%i) out of range %ix%i\n", px, py, img->width,
img->height);
return;
}
CvPoint orig = cvPoint(px, py);
if (kp.radius == 0) {
cvCircle(img, orig, FIXED_RADIUS, cvScalar(0, 255, 255, 255), THICKNESS,
8, 0);
} else {
double radius = (RADIUS_ADD + kp.radius) * RADIUS_SCALE;
if (radius < 2)
radius = 2;
int rad = my_math_round_int(radius);
cvCircle(img, orig, rad, cvScalar(0, 255, 255, 0),
THICKNESS, 8, 0);
if (kp.angle != 0) {
int dx = my_math_round_int(radius * cos(kp.angle));
int dy = my_math_round_int(radius * sin(kp.angle));
CvPoint dest = cvPoint(orig.x + dx, orig.y + dy);
cvLine(img, orig, dest, cvScalar(0, 255, 255, 0), THICKNESS, 8, 0);
cvCircle(img, dest, 1, cvScalar(0, 0, 255, 0), 1, 8, 0);
}
cvCircle(img, orig, 1, cvScalar(0, 255, 0, 0), 1, 8, 0);
}
}
MknnDataset *mknn_datasetLoader_reorderNearestNeighbor(
MknnDataset *superdataset, MknnDistance *distance,
int64_t start_position,
bool free_superdataset_on_release) {
int64_t max_size = mknn_dataset_getNumObjects(superdataset);
int64_t *sorted_array = MY_MALLOC(max_size, int64_t);
for (int64_t i = 0; i < max_size; ++i)
sorted_array[i] = i;
if (start_position < 0) {
start_position = getPositionCloserToZero(superdataset, distance);
}
my_assert_indexRangeInt("start_position", start_position, max_size);
if (start_position != 0) {
int64_t tmp = sorted_array[0];
sorted_array[0] = sorted_array[start_position];
sorted_array[start_position] = tmp;
}
int64_t sorted_size = 1;
while (sorted_size < max_size) {
if (false) {
char *st1 = my_newString_arrayInt(sorted_array, sorted_size, ' ');
char *st2 = my_newString_arrayInt(sorted_array + sorted_size,
max_size - sorted_size, ' ');
my_log_info("sorted=%s\n left=%s\n", st1, st2);
free(st1);
free(st2);
}
MknnDataset *query_subset = mknn_datasetLoader_SubsetSegment(
superdataset, sorted_array[sorted_size - 1], 1, false);
MknnDataset *ref_subset = mknn_datasetLoader_SubsetPositions(
superdataset, sorted_array + sorted_size,
max_size - sorted_size, false);
MknnIndex *index = mknn_index_newPredefined(
mknn_predefIndex_LinearScan_indexParams(), true, ref_subset,
true, distance, false);
MknnResolver *resolver = mknn_index_newResolver(index,
mknn_predefIndex_LinearScan_resolverExactNearestNeighbors(1, 0,
1), true);
MknnResult *result = mknn_resolver_search(resolver, true, query_subset,
true);
MknnResultQuery *res = mknn_result_getResultQuery(result, 0);
my_assert_equalInt("num_nns", res->num_nns, 1);
int64_t nn_position = sorted_size + res->nn_position[0];
mknn_result_release(result);
mknn_index_release(index);
if (nn_position != sorted_size) {
int64_t tmp = sorted_array[sorted_size];
sorted_array[sorted_size] = sorted_array[nn_position];
sorted_array[nn_position] = tmp;
}
sorted_size++;
}
MknnDataset *sortedset = mknn_datasetLoader_SubsetPositions(superdataset,
sorted_array, max_size, free_superdataset_on_release);
free(sorted_array);
return sortedset;
}
static void priv_printIndicator(struct State_Multimetric *es,
char *nomIndicador, char *st_fase, double valIndicador) {
if (st_fase != NULL)
my_log_info("[%s] ", st_fase);
for (int64_t i = 0; i < es->numDistances; ++i) {
char *norm = my_newString_double(es->normalization[i]);
char *pond = my_newString_double(es->fraction[i]);
if (i > 0)
my_log_info(" + ");
my_log_info("%s*%s*%s", es->distances[i]->name, norm, pond);
MY_FREE_MULTI(norm, pond);
}
char *val = my_newString_double(valIndicador);
if (nomIndicador != NULL)
my_log_info(" => %s=%s", nomIndicador, val);
my_log_info("\n");
MY_FREE(val);
}
void leerArchivoDeConfiguracion(int argc, char *argv[]) {
char* logMsg = NULL;
if (argc < 2) {
logMsg =
string_from_format(
"Debe especificar la ruta al archivo de configuracion, al invocar al programa, por ejemplo: ./Memoria /home/utnso/tp-2015-2c-tpso/Memoria/config_memoria.cfg\n");
puts(logMsg);
my_log_error(logMsg);
exit(-1);
}
char* nombreArchivoConfig = nombreArchivoConfig = strdup(argv[1]);
uint8_t result = checkearRutaArchivoConfig(nombreArchivoConfig);
if (result == -1) {
logMsg = string_from_format("Archivo de configuracion no encontrado. Parametro especificado: %s\n", nombreArchivoConfig);
puts(logMsg);
my_log_error(logMsg);
exit(-1);
} else {
t_config* archivoConfig;
archivoConfig = config_create(nombreArchivoConfig);
//warning asignacion diferentes tipos
configuracion = iniciarArchivoConfig();
configuracion->puertoEscucha = config_get_int_value(archivoConfig, "PUERTO_ESCUCHA");
configuracion->puertoSwap = config_get_int_value(archivoConfig, "PUERTO_SWAP");
configuracion->ipSwap = strdup(config_get_string_value(archivoConfig, "IP_SWAP"));
char* nombreMemoria = config_get_string_value(archivoConfig, "NOMBRE_MEMORIA");
configuracion->nombreMemoria = strdup(nombreMemoria != NULL ? nombreMemoria : "NOMBRE_MEMORIA");
configuracion->maximosMarcosPorProceso = config_get_int_value(archivoConfig, "MAXIMO_MARCOS_POR_PROCESO");
configuracion->cantidadMarcos = config_get_int_value(archivoConfig, "CANTIDAD_MARCOS");
configuracion->tamanioMarcos = config_get_int_value(archivoConfig, "TAMANIO_MARCO");
configuracion->entradasTlb = config_get_int_value(archivoConfig, "ENTRADAS_TLB");
if (string_equals(config_get_string_value(archivoConfig, "TLB_HABILITADA"),"SI")){
configuracion->tlbHabilitada=1;
}
else if (string_equals(config_get_string_value(archivoConfig, "TLB_HABILITADA"),"NO")){
configuracion->tlbHabilitada=0;
}
configuracion->retardoMemoria = config_get_int_value(archivoConfig, "RETARDO_MEMORIA");
configuracion->algoritmo_reemplazo = strdup(config_get_string_value(archivoConfig, "ALGORITMO_REEMPLAZO"));
my_log_info("[INFO]: Archivo de configuracion leido correctamente\n");
logMsg = string_from_format("Archivo de configuracion leido correctamente\n");
puts(logMsg);
//config_destroy(archivoConfig);
}
}
int rtmp_send_media(rtmp_state_t *st) {
int rc;
pthread_t rcv_thread;
/* starting sending thread */
if (pthread_create(&rcv_thread, NULL, &rtmp_recv_thread, (void *)st)
|| pthread_detach(rcv_thread))
return 1;
if (rtmp_send_thread(st))
return 1;
my_log_info("sent all data successfully");
return 0;
}
static void printDetails(struct State_Multi_Dist *state_dist) {
MyVectorString *arr = my_vectorString_new();
for (int64_t i = 0; i < state_dist->num_distances; ++i) {
const char *name = mknn_distance_getIdPredefinedDistance(
state_dist->distances[i]);
my_vectorString_add(arr, (char*) name);
}
char *st1 = my_vectorString_toString(arr, ';');
char *st2 = my_newString_arrayDouble(state_dist->weights_normalize,
state_dist->num_distances, ';');
char *st3 = my_newString_arrayDouble(state_dist->weights_combination,
state_dist->num_distances, ';');
my_log_info("distance MULTI uses distances=%s normalize=%s weights=%s\n",
st1, st2, st3);
my_vectorString_release(arr, false);
free(st1);
free(st2);
free(st3);
}
