SizeList* recover_size_list(char *filename, int *del_num){
int i = 0, offset = 0, size;
size_t nread;
int reg_num = number_of_registers();
SizeList *list = malloc(sizeof(SizeList) * reg_num);
FILE *datafile = fopen(filename, "r+");
*del_num = 0;
if(datafile){
while((nread = fread(&size, 1, sizeof(int), datafile)) > 0){
char *reg = malloc(sizeof(char)*size);
fread(reg, 1, size, datafile);
if(reg[0] == '*'){
list[i].byteOffset = offset;
list[i].tamanho = size;
i++;
*del_num = *del_num+1;
}
offset += size + sizeof(int);
free(reg);
}
}
return list;
}
void delete_favorite (char *filename) {
int delete_value, datasize, delete_index;
int *deletion_offset;
int i, count = 0;
FavoriteIndex *fav_idx;
InvertedList *fav_list;
datasize = REGISTER_SIZE;
deletion_offset = malloc(sizeof(int) * datasize);
fav_idx = malloc(sizeof(FavoriteIndex) * datasize);
fav_list = malloc(sizeof(InvertedList) * datasize);
printf ("insert favorite count for deletion: ");
scanf ("%d", &delete_value);
fav_idx = recover_fav_index();
fav_list = recover_fav_list();
int qntRegistros = number_of_registers();
if(qntRegistros<TAMANHO_MINIMO){
printf("Not enough data to delete by favorite");
return;
}
delete_index = search_index_favorite(fav_idx, datasize, delete_value);
if(delete_index > -1){
delete_index = fav_idx[delete_index].RRN;
while(fav_list[delete_index].proximo != -1){
deletion_offset[count] = fav_list[delete_index].byteOffSet;
delete_index = fav_list[delete_index].proximo;
count++;
}
deletion_offset[count] = fav_list[delete_index].byteOffSet;
//imprime as opções de tweets(se tiver)
// datafile = fopen(filename, "r+");
for(i=0; i <= count; i++){
printf("[tweet %d]\n", i);
print_register_todelete(filename, deletion_offset[i]);
}
printf("which tweet would you like to delete?");
scanf("%d", &delete_index);
delete_offset(filename,deletion_offset[delete_index]);
index_manager(filename);
diminuiArqTamanho();
printf("\n Registro Excluido\n");
}
else
printf("no tweets found with this favorite count.\n");
}
void new_tweet(char *filename){
FILE *datafile;
int pos_ideal = -1, tam_ideal = 1000;
int *del_num, size_trash = 1,i;
SizeList *list = malloc(sizeof(SizeList) * number_of_registers());
datafile = fopen(filename, "a+");
Tweet new_tweet;
char *delimitador = (char*) malloc (sizeof(char));
strcpy(delimitador,"|");
new_tweet.text = (char*) malloc (sizeof(char)*BUFFER);
new_tweet.user = (char*) malloc (sizeof(char)*BUFFER);
new_tweet.coordinates = (char*) malloc (sizeof(char)*BUFFER);
new_tweet.language = (char*) malloc (sizeof(char)*BUFFER);
int register_size = 4; // ja conta inicialmente com o tamanho dos delimitadores
printf ("insert text: ");
fgets (new_tweet.text, BUFFER, stdin);
remove_new_line (new_tweet.text);
printf ("insert user: "******"insert coordinates: ");
fgets (new_tweet.coordinates, BUFFER, stdin);
remove_new_line (new_tweet.coordinates);
printf ("insert language: ");
fgets (new_tweet.language, BUFFER, stdin);
remove_new_line (new_tweet.language);
printf ("insert favorite count: ");
scanf ("%d", &new_tweet.favorite_count);
printf ("insert retweet count: ");
scanf ("%d", &new_tweet.retweet_count);
printf ("insert view count: ");
scanf ("%d", &new_tweet.views_count);
register_size += strlen(new_tweet.text)+strlen(new_tweet.user)+strlen(new_tweet.coordinates)+strlen(new_tweet.language)+3*sizeof(int);
//estrategia best fit
/* list = recover_size_list(filename, del_num);
for(i=0; i < *del_num; i++){
if(list[i].tamanho == register_size){
pos_ideal = list[i].byteOffset;
break;
}
else if(list[i].tamanho >= (register_size + sizeof(char) + sizeof(int))){
if(list[i].tamanho < tam_ideal){
tam_ideal = list[i].tamanho;
pos_ideal = list[i].byteOffset;
}
}
}
if(pos_ideal != -1){
fseek(datafile, pos_ideal, SEEK_SET);
if(i == *del_num){
fwrite(&size_trash, sizeof(int), 1, datafile);
fwrite("*", sizeof(char), 1, datafile);
}
}*/
fwrite(®ister_size,sizeof(int),1,datafile);
fwrite(new_tweet.text,sizeof(char), strlen(new_tweet.text), datafile);
fwrite(delimitador,sizeof(char),strlen(delimitador),datafile);
fwrite(new_tweet.user,sizeof(char), strlen(new_tweet.user), datafile);
fwrite(delimitador,sizeof(char),strlen(delimitador),datafile);
fwrite(new_tweet.coordinates,sizeof(char), strlen(new_tweet.coordinates), datafile);
fwrite(delimitador,sizeof(char),strlen(delimitador),datafile);
fwrite(new_tweet.language,sizeof(char), strlen(new_tweet.language), datafile);
fwrite(delimitador,sizeof(char),strlen(delimitador),datafile);
fwrite(&new_tweet.favorite_count,sizeof(int), 1, datafile);
fwrite(&new_tweet.retweet_count,sizeof(int), 1, datafile);
fwrite(&new_tweet.views_count,sizeof(int), 1, datafile);
printf ("\nNEW TWEET POSTED!\n");
fclose(datafile);
}
void calc_depth(inst_t *inst_list, int min_index, int max_index) {
int MAX_REGS;
int *latest_use_time, *completion_time;
int t, j;
int i;
int max_depth = 0;
MAX_REGS = number_of_registers();
latest_use_time = (int *) malloc(MAX_REGS * sizeof (int));
completion_time = (int *) malloc(MAX_REGS * sizeof (int));
for (i = 0; i < MAX_REGS; i++) {
latest_use_time[i] = 0;
completion_time[i] = 0;
}
while (min_index <= max_index) {
if (inst_list[min_index]->ops[0].t == op_reg && inst_list[min_index]->op != OP_STR && inst_list[min_index]->op != OP_BR) {
t = max(1, latest_use_time[inst_list[min_index]->ops[0].reg] - latency(inst_list[min_index]) + 1);
}
if (inst_list[min_index]->op == OP_IN) { // IN writes to R0
t = max(1, latest_use_time[0] - latency(inst_list[min_index]) + 1);
}
for (j = 1; j <= 2; j++) {
if (inst_list[min_index]->ops[j].t == op_reg) {
t = max(t, completion_time[inst_list[min_index]->ops[j].reg]);
}
}
if (inst_list[min_index]->op == OP_STR || inst_list[min_index]->op == OP_BR) { // STR reads from first register
t = max(t, completion_time[inst_list[min_index]->ops[0].reg]);
}
if (inst_list[min_index]->op == OP_OUT) { // OUT reads from R0
t = max(t, completion_time[0]);
}
if (inst_list[min_index]->ops[0].t == op_reg && inst_list[min_index]->op != OP_STR && inst_list[min_index]->op != OP_BR) {
t = max(t, completion_time[inst_list[min_index]->ops[0].reg] - latency(inst_list[min_index]));
}
if (inst_list[min_index]->op == OP_IN) { // IN writes to R0
t = max(t, completion_time[0] - latency(inst_list[min_index]));
}
if (inst_list[min_index]->ops[0].t == op_reg && inst_list[min_index]->op != OP_STR && inst_list[min_index]->op != OP_BR) {
completion_time[inst_list[min_index]->ops[0].reg] = t + latency(inst_list[min_index]);
}
if (inst_list[min_index]->op == OP_IN) { // IN writes to R0
completion_time[0] = t + latency(inst_list[min_index]);
}
for (j = 1; j <= 2; j++) {
if (inst_list[min_index]->ops[j].t == op_reg) {
latest_use_time[inst_list[min_index]->ops[j].reg] = max(latest_use_time[inst_list[min_index]->ops[j].reg], t);
}
}
if (inst_list[min_index]->op == OP_STR || inst_list[min_index]->op == OP_BR) { // STR reads from first register
latest_use_time[inst_list[min_index]->ops[0].reg] = max(latest_use_time[inst_list[min_index]->ops[0].reg], t);
}
if (inst_list[min_index]->op == OP_OUT) { // OUT reads from R0
latest_use_time[0] = max(latest_use_time[0], t);
}
inst_list[min_index]->depth = t;
max_depth = max(max_depth, t);
min_index++;
}
if (inst_list[max_index]->op == OP_BRA) {
inst_list[max_index]->depth = max_depth;
}
free(latest_use_time);
free(completion_time);
return;
}
