Esempio n. 1
0
/* moving window median of 1d arrays returns output array */
ai_t *mm_move_median(ai_t *a, idx_t length, idx_t window, idx_t min_count)
{
    mm_handle *mm;
    ai_t *out;
    idx_t i;

    out = malloc(length * sizeof(ai_t));
    mm = mm_new_nan(window, min_count);
    for (i=0; i < length; i++) {
        if (i < window) {
            out[i] = mm_update_init_nan(mm, a[i]);
        } else {
            out[i] = mm_update_nan(mm, a[i]);
        }
        if (i == window) {
            mm_print_line();
            printf("window complete; switch to mm_update\n");
        }
        mm_print_line();
        printf("inserting ai = %f\n", a[i]);
        mm_print_chain(mm);
        mm_dump(mm);
        printf("\nmedian = %f\n\n", out[i]);
        mm_check(mm);
    }
    mm_free(mm);

    return out;
}
Esempio n. 2
0
File: test.c Progetto: haiwenzhu/mm
int main()
{
	mm_init();
	char *str = "hello world!";
	char *p = mm_malloc(strlen(str) + 1);
	//void *p = NULL;
	if (p == NULL) {
		mm_dump();
		printf("mm_malloc failed\n");
	}
	else {
		strcpy(p, str);
		mm_dump();
		mm_free(p);
		mm_dump();
	}

	mm_exit();
	return 0;
}
Esempio n. 3
0
File: loader.c Progetto: emancu/pso
uint_32 sys_fork(uint_32 org_eip, uint_32 org_esp) {
  //me guardo el cr3 viejo.
  uint_32 old_cr3 = rcr3();
  printf(" >sys_fork: org_eip (%x), org_esp (%x)", org_eip, org_esp);

  //pido un directorio para la nueva tarea
  void* new_cr3 = mm_dir_fork((mm_page*) old_cr3);
  if (new_cr3 == NULL) { //No pudo hacerse fork de la estrucutra de paginación
    printf("! >sys_fork: no se pudo crear el directorio de la nueva tarea");
    return -1;
  }

  printf(" >sys_fork: new_cr3 = %x", new_cr3);
   //stacks de anillo 3 y 0 para la tarea
  void* task_stack3 = mm_mem_alloc();
  void* task_stack0 = mm_mem_alloc();
  printf(" >sys_fork: paginas stack_ kernel %x | usr %x", task_stack0, task_stack3);

  //ver esto donde van mapeados los stacks
  mm_page_map(STACK_3_VIRTUAL, new_cr3, (uint_32) task_stack3, 0, USR_STD_ATTR);
  mm_page_map(STACK_0_VIRTUAL, new_cr3, (uint_32) task_stack0, 0, MM_ATTR_RW | MM_ATTR_US_S);

  //TODO ver estas direcciones temporales donde ponerlas
  mm_page_map(KERNEL_TEMP_PAGE,(mm_page *) old_cr3, (uint_32) task_stack0, 0, MM_ATTR_RW | MM_ATTR_US_S);

  //inicializamos la pila de nivel 0 para que tenga el contexto para
  //poder volver del switchto
  uint_32* stack0 = (uint_32*) (KERNEL_TEMP_PAGE + 0xffC);
  *stack0-- = 0x23;
  *stack0-- = org_esp;
  *stack0-- = 0x202;
  *stack0-- = 0x1B;
  *stack0-- = org_eip;
  *stack0-- = (uint_32) &fork_ret;
  *stack0-- = resp();
  *stack0-- = 0x0;
  *stack0-- = 0x0;
  *stack0-- = 0x0;

  //Copio la pila de usuario como está //Innecesario, ya lo hace el fork
  mm_copy_vf((uint_32*)STACK_3_VIRTUAL, (uint_32)task_stack3, PAGE_SIZE);


  mm_page_free(KERNEL_TEMP_PAGE, (mm_page*) old_cr3);
  tlbflush();


  //tengo que armar la estructura de proceso
  uint_32 requested_pid = get_new_pid();
  task_table[requested_pid].cr3 = (uint_32) new_cr3;
  task_table[requested_pid].esp0 = STACK_0_VIRTUAL + 0xFD8;

  //Duplico los file descriptor actualizando referencias
  device_fork_descriptors(cur_pid, requested_pid);


  // esto esta mal.. tiene q decidir q numero devolver creo q necesitamos un semaforo!
  sched_load(requested_pid);
  tasks_running++;

  printf(" >sys_fork: forkeo finalizado en pid %d", requested_pid);
  mm_dump();
  return requested_pid;
}