Esempi in C++ (Cpp) per MALLOCZ_SAFE

Esempio n. 1

File: gt_matrix.c Progetto: pragya1990/gtthreads7

static void init_matrices(group_t *grp)
{
	int size = grp->matrix_size;
	int index = grp->group_id;
	int credit = grp->credit_value;

	matrices_A[index] = (matrix_t*)MALLOCZ_SAFE(sizeof(matrix_t));
	matrices_B[index] = (matrix_t*)MALLOCZ_SAFE(sizeof(matrix_t));
	matrices_C[index] = (matrix_t*)MALLOCZ_SAFE(sizeof(matrix_t));
	
	matrices_A[index]->m = (int *)MALLOCZ_SAFE((sizeof(int))*size*size); 
	matrices_B[index]->m = (int *)MALLOCZ_SAFE((sizeof(int))*size*size);
	matrices_C[index]->m = (int *)MALLOCZ_SAFE((sizeof(int))*size*size);

	group_t *grp_A = (group_t *)MALLOCZ_SAFE(sizeof(group_t));	
	group_t *grp_B = (group_t *)MALLOCZ_SAFE(sizeof(group_t));	
	group_t *grp_C = (group_t *)MALLOCZ_SAFE(sizeof(group_t));
	
	grp_A->matrix_size = grp_B->matrix_size = grp_C->matrix_size = size;
	grp_A->credit_value = grp_B->credit_value = grp_C->credit_value = credit;
	grp_A->group_id = grp_B->group_id = grp_C->group_id = index;

	matrices_A[index]->matrix_group = grp_A;
	matrices_B[index]->matrix_group = grp_B;
	matrices_C[index]->matrix_group = grp_C;
	
	generate_matrix(matrices_A[index], 1, size);
	generate_matrix(matrices_B[index], 1, size);
	generate_matrix(matrices_C[index], 0, size);

	return;
}

Esempio n. 2

File: gt_kthread.c Progetto: ssc3/o1-process-scheduler

extern void gtthread_app_init()
{
	kthread_context_t *k_ctx, *k_ctx_main;
	kthread_t k_tid;
	unsigned int num_cpus, inx;
	

	/* Initialize shared schedule information */
	ksched_info_init(&ksched_shared_info);

	/* kthread (virtual processor) on the first logical processor */
	k_ctx_main = (kthread_context_t *)MALLOCZ_SAFE(sizeof(kthread_context_t));
	k_ctx_main->cpuid = 0;
	k_ctx_main->kthread_app_func = &gtthread_app_start;
	kthread_init(k_ctx_main);

	kthread_init_vtalrm_timeslice(40000ULL);
	kthread_install_sighandler(SIGVTALRM, k_ctx_main->kthread_sched_timer);
	kthread_install_sighandler(SIGUSR1, k_ctx_main->kthread_sched_relay);

	/* Num of logical processors (cpus/cores) */
	num_cpus = (int)sysconf(_SC_NPROCESSORS_CONF);
#if 0
	fprintf(stderr, "Number of cores : %d\n", num_cores);
#endif
	/* kthreads (virtual processors) on all other logical processors */
	for(inx=1; inx<num_cpus; inx++)
	{
		k_ctx = (kthread_context_t *)MALLOCZ_SAFE(sizeof(kthread_context_t));
		k_ctx->cpuid = inx;
		k_ctx->kthread_app_func = &gtthread_app_start;
		/* kthread_init called inside kthread_handler */
		if(kthread_create(&k_tid, kthread_handler, (void *)k_ctx) < 0)
		{
			fprintf(stderr, "kthread creation failed (errno:%d)\n", errno );
			exit(0);
		}

		printf( "kthread(%d) created !!\n", inx);
	}

	{
		/* yield till other kthreads initialize */
		int init_done;
yield_again:
		sched_yield();
		init_done = 0;
		for(inx=0; inx<GT_MAX_KTHREADS; inx++)
		{
			/* XXX: We can avoid the last check (tmp to cur) by
			 * temporarily marking cur as DONE. But chuck it !! */
			if(kthread_cpu_map[inx])
				init_done++;
		}
		assert(init_done <= num_cpus);
		if(init_done < num_cpus)
			goto yield_again;
	}

#if 0
	/* app-func is called for main in gthread_app_exit */
	k_ctx_main->kthread_app_func(NULL);
#endif
	return;
}