ssantisi
/
simulacion-permeabilidad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cleaning

Browse Source
improvement-double_buffer_array-logs
Oli 3 years ago
parent c3f2939bf8
commit 213612e597
2 changed files with 117 additions and 43 deletions
Show Stats Download Patch File Download Diff File

9
fftma_module/gen/include/chunk_array.h
Unescape Escape View File

@ -7,15 +7,18 @@
#include <string.h>
#include <stdbool.h>
#define MAX_CHUNK_SIZE 2048
typedef struct buffer {
double* data;
size_t init_pos;
}buffer_t;
typedef struct chunk_array {
char* filename;
size_t init_pos;
size_t chunk_size;
size_t total_size;
FILE* fp;
double* data;
buffer_t* buffer1;
buffer_t* buffer2;
}chunk_array_t;
chunk_array_t* chunk_array_create(char* filename, size_t total_size);

151
fftma_module/gen/lib_src/chunk_array.c
Unescape Escape View File

@ -1,36 +1,79 @@
#include "chunk_array.h"
#include "stdbool.h"
#include "stdlib.h"
#define MAX_CHUNK_SIZE 2048*2048
int get_mod(chunk_array_t* chunk_array,int init_pos) {
int mod;
if (chunk_array->total_size - init_pos > chunk_array->chunk_size ) {
mod = chunk_array->chunk_size;
} else {
mod = chunk_array->total_size - init_pos;
}
return mod;
}
bool inside_buffer(chunk_array_t* chunk_array,int init_pos, size_t pos) {
if (pos<init_pos || pos>init_pos + chunk_array->chunk_size-1) {
return false;
}
return true;
}
void chunk_array_free(chunk_array_t* chunk_array) {
fclose(chunk_array->fp);
free(chunk_array->data);
buffer_free(chunk_array->buffer1);
buffer_free(chunk_array->buffer2);
free(chunk_array);
}
void chunk_array_flush(chunk_array_t* chunk_array) {
size_t mod;
if (chunk_array->total_size - chunk_array->init_pos > chunk_array->chunk_size ) {
mod = chunk_array->chunk_size;
} else {
mod = chunk_array->total_size - chunk_array->init_pos;
}
fseek(chunk_array->fp, chunk_array->init_pos * sizeof(double), SEEK_SET);
fwrite(chunk_array->data, sizeof(double), mod, chunk_array->fp);
buffer_flush(chunk_array, chunk_array->buffer1);
buffer_flush(chunk_array, chunk_array->buffer2);
}
void buffer_flush(chunk_array_t* chunk_array, buffer_t* buffer) {
int mod = get_mod(chunk_array, buffer->init_pos);
fseek(chunk_array->fp, buffer->init_pos * sizeof(double), SEEK_SET);
fwrite(buffer->data, sizeof(double), mod, chunk_array->fp);
}
bool chunk_array_update(chunk_array_t* chunk_array, size_t pos) {
chunk_array_flush(chunk_array);
void buffer_update(chunk_array_t* chunk_array, buffer_t* buffer, size_t pos) {
buffer_flush(chunk_array, buffer);
int new_init = pos/chunk_array->chunk_size;
chunk_array->init_pos = new_init * chunk_array->chunk_size;
buffer->init_pos = new_init * chunk_array->chunk_size;
fseek(chunk_array->fp, chunk_array->init_pos * sizeof(double), SEEK_SET);
fread(chunk_array->data, sizeof(double), chunk_array->chunk_size, chunk_array->fp);
fseek(chunk_array->fp, buffer->init_pos * sizeof(double), SEEK_SET);
fread(buffer->data, sizeof(double), chunk_array->chunk_size, chunk_array->fp);
}
buffer_t* buffer_create() {
buffer_t * buffer = (buffer_t*)malloc(sizeof(buffer_t));
if (buffer == NULL) return NULL;
buffer->data = malloc(MAX_CHUNK_SIZE * sizeof(double));
if (buffer->data == NULL) {
free(buffer);
return NULL;
}
buffer->init_pos = 0;
return buffer;
}
void buffer_free(buffer_t* buffer) {
free(buffer->data);
free(buffer);
}
chunk_array_t* chunk_array_create(char* filename, size_t total_size) {
chunk_array_t* chunk_array = (chunk_array_t*)malloc(sizeof(chunk_array_t));
chunk_array->fp = fopen(filename, "r+");
if (chunk_array == NULL || chunk_array->fp == NULL) {
@ -41,50 +84,78 @@ chunk_array_t* chunk_array_create(char* filename, size_t total_size) {
}
}
chunk_array->data = malloc(MAX_CHUNK_SIZE * sizeof(double));
chunk_array->buffer1 = buffer_create();
if (MAX_CHUNK_SIZE > 0 && chunk_array->data == NULL) {
if (chunk_array->buffer1 == NULL) {
fclose(chunk_array->fp);
free(chunk_array);
return NULL;
}
fread(chunk_array->data, sizeof(double), MAX_CHUNK_SIZE, chunk_array->fp);
chunk_array->buffer2 = buffer_create();
if (chunk_array->buffer2 == NULL) {
fclose(chunk_array->fp);
buffer_free(chunk_array->buffer1);
free(chunk_array);
return NULL;
}
fread(chunk_array->buffer1->data, sizeof(double), MAX_CHUNK_SIZE, chunk_array->fp);
chunk_array->buffer1->init_pos = 0;
fread(chunk_array->buffer2->data, sizeof(double), MAX_CHUNK_SIZE, chunk_array->fp);
chunk_array->buffer2->init_pos = MAX_CHUNK_SIZE;
chunk_array->filename = filename;
chunk_array->init_pos = 0;
chunk_array->chunk_size = MAX_CHUNK_SIZE;
chunk_array->total_size = total_size;
return chunk_array;
}
bool chunk_array_get(chunk_array_t* chunk_array, size_t pos, double *valor) {
buffer_t* chunk_array_update(chunk_array_t* chunk_array, size_t pos) {
int distance_to_1 = abs(chunk_array->buffer1->init_pos - pos);
int distance_to_2 = abs(chunk_array->buffer2->init_pos - pos);
if (pos<chunk_array->init_pos || pos>chunk_array->init_pos + chunk_array->chunk_size-1) {
chunk_array_update(chunk_array, pos);
}
size_t mod;
if (chunk_array->total_size - chunk_array->init_pos > chunk_array->chunk_size ) {
mod = chunk_array->chunk_size;
} else {
mod = chunk_array->total_size - chunk_array->init_pos;
if (distance_to_1 < distance_to_2) {
buffer_update(chunk_array, chunk_array->buffer1, pos);
return chunk_array->buffer1;
}
int real_pos = pos%mod;
*valor=chunk_array->data[real_pos];
buffer_update(chunk_array, chunk_array->buffer2, pos);
return chunk_array->buffer2;
}
bool chunk_array_get(chunk_array_t* chunk_array, size_t pos, double *valor) {
buffer_t* buffer;
if (inside_buffer(chunk_array, chunk_array->buffer1->init_pos, pos)) {
buffer = chunk_array->buffer1;
}
else if (inside_buffer(chunk_array, chunk_array->buffer2->init_pos, pos)) {
buffer = chunk_array->buffer2;
}
else {
// need to update one buffer
buffer = chunk_array_update(chunk_array, pos);
}
int real_pos = pos%get_mod(chunk_array, buffer->init_pos);
*valor=buffer->data[real_pos];
return true;
}
bool chunk_array_save(chunk_array_t* chunk_array, size_t pos, double valor) {
if (pos<chunk_array->init_pos || pos>chunk_array->init_pos + chunk_array->chunk_size-1) {
chunk_array_update(chunk_array,pos);
}
size_t mod;
if (chunk_array->total_size - chunk_array->init_pos > chunk_array->chunk_size ) {
mod = chunk_array->chunk_size;
} else {
mod = chunk_array->total_size - chunk_array->init_pos;
buffer_t* buffer;
if (inside_buffer(chunk_array, chunk_array->buffer1->init_pos, pos)) {
buffer = chunk_array->buffer1;
}
chunk_array->data[pos%mod]=valor;
else if (inside_buffer(chunk_array, chunk_array->buffer2->init_pos, pos)) {
buffer = chunk_array->buffer2;
}
else {
// need to update one buffer
buffer = chunk_array_update(chunk_array, pos);
}
int real_pos = pos%get_mod(chunk_array, buffer->init_pos);
buffer->data[real_pos]=valor;
return true;
}
Write Preview
Loading…
Cancel
Save