コード例 #1
0
ファイル: malloc.c プロジェクト: MartinLeRoy/Malloc-Free
void		*tiny_malloc(size_t size)
{
	void	*ret;
	t_sm	*bws_tiny;
	t_sm	*keep;

	if (!g_pool.tiny_m)
	{
		g_pool.tiny_m = (t_sm *)mmap(0, 101 * TINY_M, PROT_READ | PROT_WRITE,
									MAP_ANON | MAP_PRIVATE, -1, 0);
		init_mem(g_pool.tiny_m);
	}
	bws_tiny = g_pool.tiny_m;
	while (bws_tiny)
	{
		if ((ret = find_alloc(bws_tiny, size, TINY_M)))
			return (ret);
		keep = bws_tiny;
		bws_tiny = bws_tiny->next;
	}
	keep->next = (t_sm *)mmap(0, 101 * TINY_M, PROT_READ | PROT_WRITE,
							MAP_ANON | MAP_PRIVATE, -1, 0);
	init_mem(keep->next);
	return (find_alloc(keep->next, size, TINY_M));
}
コード例 #2
0
ファイル: malloc.c プロジェクト: MartinLeRoy/Malloc-Free
void		*small_malloc(size_t size)
{
	void	*ret;
	t_sm	*bws_small;
	t_sm	*keep;

	if (!g_pool.small_m)
	{
		g_pool.small_m = (t_sm *)mmap(0, 101 * SMALL_M, PROT_READ | PROT_WRITE,
									MAP_ANON | MAP_PRIVATE, -1, 0);
		init_mem(g_pool.small_m);
	}
	bws_small = g_pool.small_m;
	while (bws_small)
	{
		if ((ret = find_alloc(bws_small, size, SMALL_M)))
			return (ret);
		keep = bws_small;
		bws_small = bws_small->next;
	}
	keep->next = (t_sm *)mmap(0, 101 * SMALL_M, PROT_READ | PROT_WRITE,
							MAP_ANON | MAP_PRIVATE, -1, 0);
	init_mem(keep->next);
	return (find_alloc(keep->next, size, SMALL_M));
}
コード例 #3
0
ファイル: main.c プロジェクト: splatspace/wombat
int main() {

  init_env(); // Poorly named. Has nothing to do with env alist.
  init_mem();

  uptr_t *env = refer(NIL);
  init_syms(env);

  uptr_t *form_p = refer(NIL);
  while(1) {
    print_env(env);
    print_mem();

    printf_P(PSTR("> "));
    *form_p = read_form(stdin);
    while(getc(stdin) != '\r');
    print_form(eval(env, *form_p));
    printf_P(PSTR("\n"));

    //    print_mem();
    __GC__();
  }

  release(2); // Just a formality really...

  return 0;
}
コード例 #4
0
ファイル: mesh_parser.cpp プロジェクト: FranzGrenvicht/hermes
void mesh_parser_init(FILE* f, const char* filename)
{
  mesh_lexer_init(f);
  H2D_PARSER_FILENAME = filename;
  init_mem();
  init_symbols();
}
コード例 #5
0
ファイル: timer.c プロジェクト: RAHUL04/RIPv1
/* Function to initialize the timer utility (**V.IMP.** Use this function only once, else all previous timers will be lost and also will cause memory leak)
   Parameters : none
   Return Value : 0  = successful
                  -1 = error
*/
int init_timer(void)
{
  pthread_t tick_proc_thread;
  int count;

  /* Initialise the hash table */
  for(count=0;count<MAX;count++)
    timer_ds.hash_table[count] = NULL;

  /* Initialise present bucket as bucket number 0 */
  timer_ds.current_bucket = 0;

  /* Obtain current time with time rounded up to time granularity */
  get_current_time();

  /* Initialize mutexes and condition variable */
  pthread_mutex_init(&timer_ds.currenttime_mutex, NULL);
  pthread_mutex_init(&timer_ds.timer_mutex, NULL);
  pthread_cond_init(&timer_ds.timer_cond,NULL);


  /* Create a new thread to perform per tick processing */
  if( pthread_create(&tick_proc_thread, NULL, per_tick_processing, NULL)!= 0 ){
    return(-1);
  }
  
  /* Initialise memory and return whether the operation was successful or not */
  return(init_mem(sizeof(timer_info_t)));
}
コード例 #6
0
ファイル: prog.c プロジェクト: rohitsd1409/sanmalloc
int main()
{
	int choice = -1;	//choice of oepration to be performed
	char cont[100];		//continue to main menu?
	int i_cont;

	//intialise memory
	init_mem();

	do	
	{
		//display main menu	
		disp_menu();
		//operation selection 
		do
		{
			choice = get_selection();	
		}while(!is_valid_choice(choice));

		//perform selected operation
		perform_opn(choice);
			
		//continue confirmation
		printf("\n\nContinue to main menu? (1 = yes, any other character = no) : ");
		scanf("%s",cont);
		i_cont = atoi(cont);

	}while(i_cont == 1);

	//destroy memory
	destroy_mem();
	printf("\n\nProgram Exited Successfully!!\n\n");

	return 0;
}	 
コード例 #7
0
ファイル: cpu.c プロジェクト: bminor/binutils-gdb
void
init_cpu (void)
{
  int i;

  init_mem ();

  memset (memory+REGISTER_ADDRESS, 0x11, 8 * 4);
  memory[RL78_SFR_PSW] = 0x06;
  memory[RL78_SFR_ES] = 0x0f;
  memory[RL78_SFR_CS] = 0x00;
  memory[RL78_SFR_PMC] = 0x00;

  for (i = 0; i < 256; i ++)
    {
      int rb0 = (i & RL78_PSW_RBS0) ? 1 : 0;
      int rb1 = (i & RL78_PSW_RBS1) ? 2 : 0;
      int rb = rb1 | rb0;
      regbase_table[i] = (RegBank *)(memory + (3 - rb) * 8 + REGISTER_ADDRESS);
    }

  trace_register_init ();

  /* This means "by default" */
  timer_enabled = 2;
}
コード例 #8
0
ファイル: memory.c プロジェクト: naredula-jana/Jiny-Kernel
int init_memory(unsigned long arg1){
	unsigned long virt_real_start_addr,virt_start_addr,virt_end_addr;
	unsigned long pc_size;
	unsigned long current_end_memused=&end; /* till this point memory is used*/

	unsigned long phy_end_addr = g_phy_mem_size;
	ut_log("	Initializing memory phy_endaddr : %x  current end:%x symbols_end:%x\n",phy_end_addr,current_end_memused,symbols_end);
	if (symbols_end != 0){
		current_end_memused = symbols_end;
	}

	virt_start_addr=initialise_paging_new(phy_end_addr, current_end_memused,&virt_real_start_addr,&virt_end_addr);
	INIT_LOG("	After Paging initialized Virtual start_addr: %x virtual endaddr: %x  current end:%x virtualreal_start:%x\n",virt_start_addr,virt_end_addr,current_end_memused,virt_real_start_addr);
	INIT_LOG("	code+data  : %x  -%x size:%dK",&_start,&_end);
	INIT_LOG("	free area  : %x - %x size:%dM\n",virt_start_addr,virt_end_addr,(virt_end_addr-virt_start_addr)/1000000);
	virt_start_addr=init_free_area( virt_start_addr, virt_end_addr);

	pc_size = g_pagecache_size ;
	pc_init((unsigned char *)virt_start_addr,pc_size);
	ut_log("	pagecache  : %x - %x size:%dM",virt_start_addr,virt_start_addr+pc_size,pc_size/1000000);

	virt_start_addr=virt_start_addr+pc_size;

#if 0 /* reserve the test memory for testing */
	if (virt_end_addr > (virt_start_addr + (600*1024*1024))){
	test_mem_start = virt_start_addr;
	test_mem_end  = virt_start_addr + 512 *1024 *1204 ; /* 512M */
	virt_start_addr =  test_mem_end + 4096;
	}
#endif

	init_mem(virt_start_addr, virt_end_addr, virt_real_start_addr);
	INIT_LOG("		buddy pages: %x - %x size:%dM\n",virt_start_addr, virt_end_addr,(virt_end_addr-virt_start_addr)/1000000);
	return JSUCCESS;
}
コード例 #9
0
ファイル: aica.cpp プロジェクト: AndroidGX/reicast-emulator
//misc :p
s32 libAICA_Init()
{
	init_mem();

	verify(sizeof(*CommonData)==0x508);
	verify(sizeof(*DSPData)==0x15C8);

	CommonData=(CommonData_struct*)&aica_reg[0x2800];
	DSPData=(DSPData_struct*)&aica_reg[0x3000];
	//slave cpu (arm7)

	SCIEB=(InterruptInfo*)&aica_reg[0x289C];
	SCIPD=(InterruptInfo*)&aica_reg[0x289C+4];
	SCIRE=(InterruptInfo*)&aica_reg[0x289C+8];
	//Main cpu (sh4)
	MCIEB=(InterruptInfo*)&aica_reg[0x28B4];
	MCIPD=(InterruptInfo*)&aica_reg[0x28B4+4];
	MCIRE=(InterruptInfo*)&aica_reg[0x28B4+8];

	sgc_Init();
	for (int i=0;i<3;i++)
		timers[i].Init(aica_reg,i);

	return rv_ok;
}
コード例 #10
0
ファイル: psim.c プロジェクト: kywe665/ECEn-324
void sim_init()
{
    /* Create memory and register files */
    initialized = 1;
    mem = init_mem(MEM_SIZE);
    reg = init_reg();
    
    /* create 5 pipe registers */
    pc_state     = new_pipe(sizeof(pc_ele), (void *) &bubble_pc);
    if_id_state  = new_pipe(sizeof(if_id_ele), (void *) &bubble_if_id);
    id_ex_state  = new_pipe(sizeof(id_ex_ele), (void *) &bubble_id_ex);
    ex_mem_state = new_pipe(sizeof(ex_mem_ele), (void *) &bubble_ex_mem);
    mem_wb_state = new_pipe(sizeof(mem_wb_ele), (void *) &bubble_mem_wb);
  
    /* connect them to the pipeline stages */
    pc_next   = pc_state->next;
    pc_curr   = pc_state->current;
  
    if_id_next = if_id_state->next;
    if_id_curr = if_id_state->current;

    id_ex_next = id_ex_state->next;
    id_ex_curr = id_ex_state->current;

    ex_mem_next = ex_mem_state->next;
    ex_mem_curr = ex_mem_state->current;

    mem_wb_next = mem_wb_state->next;
    mem_wb_curr = mem_wb_state->current;

    sim_reset();
    clear_mem(mem);
}
コード例 #11
0
ファイル: time_sumcopy.cpp プロジェクト: qzmfranklin/salon
int main(){
	const char* rows[5] = {"SUM", "SUMSTR", "SUMCONSTSTR", 
			       "COPY", "COPYCONSTSTR"};
	const char* cols[1] = {"n=1e9 doubles"};
	const int n = 1000*1000*1000;
	double *a, *b;
	
	init_mem(a, b, n);
	
	double bw[5];
	bw[0] = time(a, b, n, SUM);
	bw[1] = time(a, b, n, SUMSTR);
	bw[2] = time(a, b, n, SUMCONSTSTR);
	bw[3] = time(a, b, n, COPY);
	bw[4] = time(a, b, n, COPYCONSTSTR);

	verify_dir("DBG/");
	char fname[200];
	sprintf(fname, "DBG/time_sc_stride_%d.txt", STR);
	link_cout(fname);

	Table tbl;
	tbl.dim(5, 1);
	tbl.rows(rows);
	tbl.cols(cols);
	tbl.data(bw);
	char banner[200];
	sprintf(banner, "memory bw in bytes/cycle, stride = %d\n", STR);
	tbl.print(banner);
	
	unlink_cout();

	release_mem(a, b);

}
コード例 #12
0
void mesh_parser_init(FILE* f, const char* filename)
{
  mesh_lexer_init(f);
  parser_filename = filename;
  init_mem();
  init_symbols();
}
コード例 #13
0
SIM_DESC
sim_open (SIM_OPEN_KIND kind,
	  struct host_callback_struct *callback,
	  struct bfd *abfd, char **argv)
{
  if (open)
    fprintf (stderr, "rx minisim: re-opened sim\n");

  /* The 'run' interface doesn't use this function, so we don't care
     about KIND; it's always SIM_OPEN_DEBUG.  */
  if (kind != SIM_OPEN_DEBUG)
    fprintf (stderr, "rx minisim: sim_open KIND != SIM_OPEN_DEBUG: %d\n",
	     kind);

  set_callbacks (callback);

  /* We don't expect any command-line arguments.  */

  init_mem ();
  init_regs ();
  execution_error_init_debugger ();

  sim_disasm_init (abfd);
  open = 1;
  return &the_minisim;
}
コード例 #14
0
SIM_DESC
sim_open (SIM_OPEN_KIND kind,
	  struct host_callback_struct *callback,
	  struct bfd *abfd, char **argv)
{
  setbuf (stdout, 0);
  if (open)
    fprintf (stderr, "m32c minisim: re-opened sim\n");

  /* The 'run' interface doesn't use this function, so we don't care
     about KIND; it's always SIM_OPEN_DEBUG.  */
  if (kind != SIM_OPEN_DEBUG)
    fprintf (stderr, "m32c minisim: sim_open KIND != SIM_OPEN_DEBUG: %d\n",
	     kind);

  if (abfd)
    m32c_set_mach (bfd_get_mach (abfd));

  /* We can use ABFD, if non-NULL to select the appropriate
     architecture.  But we only support the r8c right now.  */

  set_callbacks (callback);

  /* We don't expect any command-line arguments.  */

  init_mem ();
  init_regs ();

  open = 1;
  return &the_minisim;
}
コード例 #15
0
ファイル: EmptyAICA.cpp プロジェクト: ABelliqueux/nulldc
s32 FASTCALL Init(aica_init_params* param)
{
	aica_ram=param->aica_ram;
	init_mem();
	InitHLE();

	return rv_ok;
}
コード例 #16
0
ファイル: main.c プロジェクト: johnbrovi/spovm_labs
int main() {
	init_mem();
	memory_test();
//  gcollector_test();
	leak_msg();
	getchar();
	return 0;
}
コード例 #17
0
ファイル: isa.c プロジェクト: kamneo/Archi_projet_L2
state_ptr new_state(int memlen)
{
    state_ptr result = (state_ptr) malloc(sizeof(state_rec));
    result->pc = 0;
    result->r = init_reg();
    result->m = init_mem(memlen);
    result->cc = DEFAULT_CC;
    return result;
}
コード例 #18
0
ファイル: y86sim.c プロジェクト: tjgykhulj/ICS_Lab
/* create an y86 image with registers and memory */
y86sim_t *new_y86sim(int slen)
{
    y86sim_t *sim = (y86sim_t*)malloc(sizeof(y86sim_t));
    sim->pc = 0;
    sim->r = init_reg();
    sim->m = init_mem(slen);
    sim->cc = DEFAULT_CC;
    return sim;
}
コード例 #19
0
ファイル: large_malloc.c プロジェクト: jilth/malloc
void	*large_malloc(int size)
{
	static int	block_count = -1;
	int			mult;

	mult = (size / getpagesize()) + (size % getpagesize());
	if (block_count == -1)
	{
		g_g.max_allocs[LARGE] = 0;
		g_g.memory[0].mem_large = init_mem(getpagesize() * mult, size, LARGE);
		block_count = 0;
	}
	else
	{
		g_g.memory[++block_count].mem_large =
							init_mem(getpagesize() * mult, size, LARGE);
	}
	return (g_g.memory[block_count].mem_large.ptr);
}
コード例 #20
0
ファイル: ssim.c プロジェクト: kywe665/ECEn-324
void sim_init()
{

    /* Create memory and register files */
    initialized = 1;
    mem = init_mem(MEM_SIZE);
    reg = init_reg();
    sim_reset();
    clear_mem(mem);
}
コード例 #21
0
void
sim_close (SIM_DESC sd, int quitting)
{
  check_desc (sd);

  /* Not much to do.  At least free up our memory.  */
  init_mem ();

  open = 0;
}
コード例 #22
0
ファイル: nullAICA.cpp プロジェクト: ABelliqueux/nulldc
//called when plugin is used by emu (you should do first time init here)
s32 FASTCALL Init(aica_init_params* initp)
{
	memcpy(&aica_params,initp,sizeof(aica_params));

	init_mem();
	AICA_Init();
	InitAudio();

	eminf.SetMenuItemStyle(config_scmi,MIS_Grayed,MIS_Grayed);
	return rv_ok;
}
コード例 #23
0
void header(char headrec[])
{
  // HPRGNAMsrtadd^^len^
  char tmp[10];
  strncpy(prgname,headrec+1,6);
  strncpy(tmp,headrec+7,6);
  sscanf(tmp,"%X",&startaddr);
  strncpy(tmp,headrec+13,6);
  sscanf(tmp,"%X",&memlen);
  mem=(struct memory *)malloc((memlen)*(sizeof(struct memory)));
  init_mem();
}
コード例 #24
0
void engine()
{
  int i,j;
  static int lasttick = 0;
  int start = 0;

  for(i=0;i<4;i++)
    for(j=0;j<MAX_SPRITE_Z;j++){
      sp_list[i][j].used = 0;
    }

  init_mem();
  init_p();

  i = 0;
  while(1){
    while(tick - lasttick < REFRESH_TICKS);
    lasttick = tick;

    disable_irq(CLOCK_IRQ);
    disable_irq(KEYBOARD_IRQ);

    draw_rect(0,0,320,200,0);

    if(start == 0){
      int key = get_lastkey();

      if(key == VKEY_START){
        start = 1;
        srand(tick/REFRESH_TICKS);
      }
    } else {
      main_p();

      for(i=0;i<4;i++)
        for(j=0;j<MAX_SPRITE_Z;j++){
          if(sp_list[i][j].used == 1){
            sp_list[i][j].sp->t(sp_list[i][j].sp);
            sp_list[i][j].sp->d(sp_list[i][j].sp);
          }
        }
    }


    keys_len = 0;

    fill_screen(buf);
    enable_irq(KEYBOARD_IRQ);
    enable_irq(CLOCK_IRQ);
  }
}
コード例 #25
0
ファイル: repl.c プロジェクト: nealjc/scheme_interpreter
void repl()
{
  env environment;
  init_mem(&environment, 64 * 1024);
  init_env(&environment);
  init(&environment);
  
  printf("^C to quit\n\n");

  while (1) {
    printf("> ");
    write(stdout, eval(parse(stdin), &environment));
  }
}
コード例 #26
0
ファイル: compdic32hs.c プロジェクト: cisocrgroup/csl
void main (int argc, uchar **argv) {
    int i, j, c;
    struct stat f_stat;

    printf("compdic: Utility for compilation of word dictionaries\n");
    if (argc!=4) error("Usage:\ncompdic <alphabet> <text_dic> <comp_dic>");

    if ((fi=fopen(argv[1],"rb"))==NULL) error("Error opening alphabet file");
    memset(codes, 0, 256);
    for (letter_count=1; (c=getc(fi))>=' '; codes[c] = letter_count++) ;
    fclose(fi);

    stat(argv[2],&f_stat);
    init_mem(letter_count, f_stat.st_size + 50000);

    if ((fi=fopen(argv[2],"rb"))==NULL) error("Error opening input file");

    clear_state(0);
    owf[0]=0;

    wf1[0]=0;
    get_word_info(wf); // init of get_word_inf()

    while (get_word_info(wf)) {

        for (i=0; wf[i]==owf[i]; i++) ;		// find difference location

        for (j=strlen(owf)-1; j>=i; j--) state(j, codes[owf[j]]) = save_state(j+1);

        for (j=i+1; j<=strlen(wf); j++) clear_state(j);

        state(--j,0) = 1;

        strcpy(owf, wf);
    }
    fclose(fi);

    for (j=strlen(owf)-1; j>=0; j--) state(j, codes[owf[j]]) = save_state(j+1);

    save_cell(0, 'S', save_state(0));
    save_cell(1, 'T', last_full_cell+1);

    fo = fopen(argv[3], "wb");
    fwrite (cells, sizeof(tcell), last_full_cell+1, fo);
    fwrite (strings, 1, last_string, fo);
    fclose(fo);

    print_statistics();
}
コード例 #27
0
/*device driver module loader function*/
int sharemem_init(void)
{
  int result;
  dev_t devno = MKDEV(sharemem_major, 0);


  printk("init_mem ok\n");

  /*start acoral*/
  if(startAcoral() < 0)
  {
      printk("start acoral error\n");
      return -1;
  }

  printk("startAcoral ok\n");
  /* apply for device number*/
  if (sharemem_major)
    result = register_chrdev_region(devno, 1, "sharemem");
  else  /* dynamic apply*/
  {
    result = alloc_chrdev_region(&devno, 0, 1, "sharemem");
    sharemem_major = MAJOR(devno);
  }  
  if (result < 0)
    return result;

  printk("region ok\n");
    
  /*dynamic apply for the memory of device construction*/
  sharemem_devp = kmalloc(sizeof(struct sharemem_dev), GFP_KERNEL);
  if (!sharemem_devp)    /*application failed*/
  {
    result =  - ENOMEM;
    goto fail_malloc;
  }
  printk("kmalloc ok\n");
  memset(sharemem_devp, 0, sizeof(struct sharemem_dev)); 
  if(init_mem() < 0)
  {
      printk("init_mem error\n");
      return -1;
  }
  sharemem_setup_cdev(sharemem_devp, 0);
  return 0;

  fail_malloc: unregister_chrdev_region(devno, 1);
  return result;
}
コード例 #28
0
ファイル: sysmem.c プロジェクト: anoane/partikle
unsigned long init_sysmem (void) {

  unsigned long freemem = init_mem ();
  
  if (CONFIG_KDYNAMIC_MEMORY > freemem) return -1;

  if (!(memory_pool = alloc_region
	((ulong)ebss, RAMTOP, CONFIG_KDYNAMIC_MEMORY))) return -1;

  // Setting up TLSF with the largest free area, memory_pool will be
  // zeroed by this function as well
  printf ("\nSetting up the dynamic memory manager (%d kbytes at 0x%x)\n", 
	  CONFIG_KDYNAMIC_MEMORY/1024, memory_pool);

  if (init_memory_pool (CONFIG_KDYNAMIC_MEMORY, memory_pool) == 0) return -1;
  
  return freemem;
}
コード例 #29
0
ファイル: m100emu.c プロジェクト: ProfSteve/virtualt
/*
========================================================================
main:	This is the main entry point for the VirtualT application.
========================================================================
*/
int main(int argc, char **argv)
{
	if (process_args(argc, argv))	/* Parse command line args */
		return 1;

	setup_working_path(argv);	/* Create a working dir path */
	setup_unix_signals();		/* Setup Unix signal handling */

	// Added by JV for prefs
	init_pref();				/* load user Menu preferences */
	check_installation();		/* Test if install needs to be performed */
	load_setup_preferences();	/* Load user Peripheral setup preferences */
	load_memory_preferences();	/* Load user Memory setup preferences */
	load_remote_preferences();  /* Load user Remote Socket preferences */
	
	/* Perform initialization */
	init_mem();					/* Initialize Memory */
	init_io();					/* Initialize I/O structures */
	init_sound();				/* Initialize Sound system */
	init_display();				/* Initialize the Display */
	init_cpu();					/* Initialize the CPU */
	init_throttle_timer();		/* Initialize the throttle timer */
	init_remote();				/* Initialize the remote control */
	init_lpt();					/* Initialize the printer subsystem */
	init_other_windows();		/* Initialize other windows that were opened (memedit, regs, etc. */
	get_model_time();			/* Load the emulated time for current model */

	/* Perform Emulation */
	emulate();					/* Main emulation loop */

	/* Save RAM contents after emulation */
	save_ram();
	save_model_time();			/* Save the emulated time */

	/* Cleanup */
	deinit_io();				/* Deinitialize I/O */
	deinit_sound();				/* Deinitialize sound */
	deinit_lpt();				/* Deinitialize the printer */
	deinit_throttle_timer();	/* Deinitialize the throttle timer */
	deinit_display();			/* Deinitialze and free the main window */
	free_mem();					/* Free memory used by ReMem and/or Rampac */

	return 0;
}
コード例 #30
0
ファイル: color2.c プロジェクト: songtzu/study
void 
HariMain(void)
{
  char* buf;
  int win, x, y;

  init_mem();

  buf = (char*)malloc(144 * 164);
  win = win_open(buf, 144, 164, -1, "WIN-COLOR2");
  for (y = 0; y < 128; ++y) {
    for (x = 0; x < 128; ++x) 
      buf[(x + 8) + (y + 28) * 144] = rgb2pal(x * 2, y * 2, 0, x, y);
  }
  win_refresh(win, 8, 28, 136, 156);
  getkey(1);

  api_end();
}