C++ check_malloc函数代码示例

int main(int argc, char **argv)
{
        char *archive_name;
        char *buf;
        char *sizebuf;
        int fd;
        struct tar_header *thdr;

        archive_name = (char *)check_malloc(255);
        buf = (char *)check_malloc(NAME_MAX);
        sizebuf= (char *)check_malloc(12);
        archive_name = "file.tar";

        fd = open(archive_name, O_RDONLY);
        if(fd == -1)
        {
                perror("Failed to open file!");
                exit(1);
        }

        /* Read header */
        read(fd, buf, 512);
        thdr = (struct tar_header *)buf; 
        printf("%s\n", thdr->name);
        memcpy(sizebuf, thdr->size, 12);
        printf("%s\n", sizebuf);

        return(0);
}

//TODO: Arreglar para mapear el complementario reverso cuando trabajo con
// el análisis con menos de 4 bases. ¿¿¿Esto está hecho???
void reverse_strand_C(vector *r_C, vector *s_C, vector *r_C1, vector *s_C1) {

	r_C->n  = s_C->n; r_C1->n = s_C1->n;

	r_C->vector  = (SA_TYPE *)malloc(r_C->n  * sizeof(SA_TYPE));
	check_malloc(r_C->vector,  "reverseStrandC r_C");
	r_C1->vector = (SA_TYPE *)malloc(r_C1->n * sizeof(SA_TYPE));
	check_malloc(r_C1->vector, "reverseStrandC r_C1");

  if (AA != (uint8_t) -1 && TT != (uint8_t) -1) {
    r_C->vector[AA] = s_C->vector[TT]; r_C1->vector[AA] = s_C1->vector[TT];
    r_C->vector[TT] = s_C->vector[AA]; r_C1->vector[TT] = s_C1->vector[AA];
  } else if (AA != (uint8_t) -1) {
    r_C->vector[AA] = s_C->vector[AA]; r_C1->vector[AA] = s_C1->vector[AA];
  } else if (TT != (uint8_t) -1) {
    r_C->vector[TT] = s_C->vector[TT]; r_C1->vector[TT] = s_C1->vector[TT];
  }

  if (CC != (uint8_t) -1 && GG != (uint8_t) -1) {
    r_C->vector[CC] = s_C->vector[GG]; r_C1->vector[CC] = s_C1->vector[GG];
    r_C->vector[GG] = s_C->vector[CC]; r_C1->vector[GG] = s_C1->vector[CC];
  } else if (CC != (uint8_t) -1) {
    r_C->vector[CC] = s_C->vector[CC]; r_C1->vector[CC] = s_C1->vector[CC];
  } else if (GG != (uint8_t) -1) {
    r_C->vector[GG] = s_C->vector[GG]; r_C1->vector[GG] = s_C1->vector[GG];
  }

}

void read_bins(FILE *f, dataset *d) {
	int i;
	
	/* First the number of bins. */
	fscanf(f, "%d", &d->num_bins);

	if (d->num_bins <= 0) {
		fprintf(stderr, "Invalid number of bins: %d\n",
				d->num_bins);
		exit(EXIT_FAILURE);
	}

	/* Allocate space. */
	printf("Allocating space for %d bins...\n", d->num_bins);
	d->bins = (LDOUBLE**)malloc(d->num_bins * sizeof(LDOUBLE*));
	check_malloc(d->bins, __LINE__);

	for (i=0; i < d->num_bins; i++) {
		d->bins[i] = (LDOUBLE*)malloc(2 * sizeof(LDOUBLE));
		check_malloc(d->bins[i], __LINE__); 
	}

	/* Read the bins. */
	for (i=0; i < d->num_bins; i++) {
		printf("Reading in bin %d... ", i);
		fscanf(f, "%lg %lg", &d->bins[i][0], &d->bins[i][1]);
		printf("%lg %lg\n", d->bins[i][0], d->bins[i][1]);
	}
}

static void
load_notfunction(const char *filename)
{
	FILE *ip;
	STRBUF *sb = strbuf_open(0);
	STRBUF *ib = strbuf_open(0);
	char *p;
	int i;

	if ((ip = fopen(filename, "r")) == NULL)
		die("'%s' cannot read.", filename);
	for (tablesize = 0; (p = strbuf_fgets(ib, ip, STRBUF_NOCRLF)) != NULL; tablesize++)
		strbuf_puts0(sb, p);
	fclose(ip);
	words = (struct words *)check_malloc(sizeof(struct words) * tablesize);
	/*
	 * Don't free *p.
	 */
	p = (char *)check_malloc(strbuf_getlen(sb) + 1);
	memcpy(p, strbuf_value(sb), strbuf_getlen(sb) + 1);
	for (i = 0; i < tablesize; i++) {
		words[i].name = p;
		p += strlen(p) + 1;
	}
	qsort(words, tablesize, sizeof(struct words), cmp);
	strbuf_close(sb);
	strbuf_close(ib);
}

void init_mpi_requests(comm_data *cd, int dim2)
{
  int i;
  const int max_elem_sz = NGRAD * 3;
  ASSERT(dim2 == max_elem_sz);  
  size_t szd = sizeof(double);

  ASSERT(cd->nrecv == 0);
  ASSERT(cd->nsend == 0);
  ASSERT(cd->nreq == 0);
  
  size_t szr = 2 * cd->ncommdomains * sizeof(MPI_Request);
  size_t szs = 2 * cd->ncommdomains * sizeof(MPI_Status);   
  cd->req   = (MPI_Request *)check_malloc(szr);
  cd->stat  = (MPI_Status  *)check_malloc(szs);
  cd->nreq  = cd->ncommdomains;

  int rsz = 0, ssz = 0;
  for(i = 0; i < cd->ncommdomains; i++)
    {
      int k = cd->commpartner[i];
      ssz += dim2 * cd->sendcount[k] * max_elem_sz * szd;
      rsz += dim2 * cd->recvcount[k] * max_elem_sz * szd;
    }  

  cd->sendbuf = check_malloc(ssz);
  cd->nsend = ssz;

  cd->recvbuf = check_malloc(rsz);
  cd->nrecv = rsz;

}

void reverse_strand_O(comp_matrix *r_O, comp_matrix *s_O) {

  r_O->siz = s_O->siz;

  r_O->n_desp = s_O->n_desp;
  r_O->m_desp = s_O->m_desp;

	r_O->desp = (SA_TYPE **) malloc(r_O->n_desp * sizeof(SA_TYPE *));
	check_malloc(r_O->desp, "reverse_strand_O");

  if (AA != (uint8_t) -1 && TT != (uint8_t) -1) {
    r_O->desp[AA] = s_O->desp[TT];
    r_O->desp[TT] = s_O->desp[AA];
  } else if (AA != (uint8_t) -1) {
    r_O->desp[AA] = s_O->desp[AA];
  } else if (TT != (uint8_t) -1) {
    r_O->desp[TT] = s_O->desp[TT];
  }

  if (CC != (uint8_t) -1 && GG != (uint8_t) -1) {
    r_O->desp[CC] = s_O->desp[GG];
    r_O->desp[GG] = s_O->desp[CC];
  } else if (CC != (uint8_t) -1) {
    r_O->desp[CC] = s_O->desp[CC];
  } else if (GG != (uint8_t) -1) {
    r_O->desp[GG] = s_O->desp[GG];
  }

#if defined FM_COMP_32 || FM_COMP_64

  r_O->n_count = s_O->n_count;
  r_O->m_count = s_O->m_count;

	r_O->count = (FM_COMP_TYPE **) malloc(r_O->n_count * sizeof(FM_COMP_TYPE *));
	check_malloc(r_O->count, "reverse_strand_O");

  if (AA != (uint8_t) -1 && TT != (uint8_t) -1) {
    r_O->count[AA] = s_O->count[TT];
    r_O->count[TT] = s_O->count[AA];
  } else if (AA != (uint8_t) -1) {
    r_O->count[AA] = s_O->count[AA];
  } else if (TT != (uint8_t) -1) {
    r_O->count[TT] = s_O->count[TT];
  }

if (CC != (uint8_t) -1 && GG != (uint8_t) -1) {
    r_O->count[CC] = s_O->count[GG];
    r_O->count[GG] = s_O->count[CC];
  } else if (CC != (uint8_t) -1) {
    r_O->count[CC] = s_O->count[CC];
  } else if (GG != (uint8_t) -1) {
    r_O->count[GG] = s_O->count[GG];
  }

#endif

}

indextype NewEntry(struct matrix *m) {
  /* WARNING: This function modifies the m->keys, m->data and
     m->next. Please do not use the return value of this function directly
     in an assigment. m->next[a]=NewEntry(m) can fail and cause lots of
     trouble.
  */

  if (m->num_entries >= m->datasize) {
    m->datasize *= 2;
    m->keys = (byte *)realloc(m->keys, m->datasize * m->key_size);
    check_malloc(m->keys, "realloc keys");
    m->data = (byte *)realloc(m->data, m->datasize * m->size_of_entry);
    check_malloc(m->data, "realloc data");
    m->next = (indextype *)realloc(m->next, m->datasize * sizeof(indextype));
    check_malloc(m->next, "realloc next pointers");
    m->prev = (indextype *)realloc(m->prev, m->datasize * sizeof(indextype));
    check_malloc(m->prev, "realloc prev pointers");
  } else if (m->allow_shrinking && (m->num_entries < m->datasize / 3 &&
                                    m->num_entries > m->hashsize)) {
    m->datasize /= 2;
    m->keys = (byte *)realloc(m->keys, m->datasize * m->key_size);
    check_malloc(m->keys, "shrink");
    m->data = (byte *)realloc(m->data, m->datasize * m->size_of_entry);
    check_malloc(m->data, "shrink");
    m->next = (indextype *)realloc(m->next, m->datasize * sizeof(indextype));
    check_malloc(m->next, "shrink");
    m->prev = (indextype *)realloc(m->prev, m->datasize * sizeof(indextype));
    check_malloc(m->prev, "shrink");
  }
  return (m->num_entries++);
}

Shared *make_shared (int end)
{
  int i;
  Shared *shared = check_malloc (sizeof (Shared));

  shared->counter = 0;
  shared->end = end;

  shared->array = check_malloc (shared->end * sizeof(int));
  for (i=0; i<shared->end; i++) {
    shared->array[i] = 0;
  }
  return shared;
}

void gather_columns(int rank,int num_tasks,float** A){

	float *sendbuf,*recvbuf;
	sendbuf=(float*) check_malloc(parms->num_row * parms->num_my_col * sizeof(float),"Allocation failed for sendbuf in gather_columns");
	if (rank==MASTER){
		recvbuf=(float*) check_malloc(parms->num_row * parms->num_col * sizeof(float),"Allocation failed for recvbuf in gather_columns");
	}
	int sendcount = parms->num_row * parms->num_my_col , *disp, *recvcount;

	//All MPI-tasks fill the send buffer
	for( int j=0; j< parms->num_my_col; j++){
		for (int i=0; i< parms->num_row; i++){
			sendbuf[j*parms->num_row + i] = parms->my_col[i][j];
		}
	}

	if (rank==MASTER){
		recvcount=(int*) check_malloc(num_tasks * sizeof(int),"Allocation failed for recvcount in gather_columns");
		disp=(int*) check_malloc(num_tasks * sizeof(int),"Allocation failed for disp in gather_columns");
		int tmp_disp=0;
		for (int i=0; i < num_tasks; i++){
			disp[i]=tmp_disp;
			if (i < num_tasks -1){
				recvcount[i]=parms->num_row * (parms->col_start_indx[rank+1] - parms->col_start_indx[rank]);
				tmp_disp += parms->num_row * (parms->col_start_indx[rank+1] - parms->col_start_indx[rank]);
			}else if (i == num_tasks-1){
				recvcount[i]=parms->num_row * ( parms->num_col - parms->col_start_indx[rank]);
				tmp_disp += parms->num_row * ( parms->num_col - parms->col_start_indx[rank]);
			}	 	
		}
	}

	check_flag(MPI_Gatherv(sendbuf,sendcount,MPI_FLOAT,recvbuf,recvcount,disp,MPI_FLOAT,MASTER,MPI_COMM_WORLD),7);

	//Now populate the matrix A with the new values gathered from workers

	if (rank == MASTER){
		for (int j=0; j< parms->num_col; j++){
			for (int i=0; i< parms->num_row; i++){
				A[i][j] = recvbuf[j*parms->num_row +i];
			}	
		}
	free(recvbuf);
	free(disp);
	free(recvcount);
	printf("Gathered\n");
	}
}

t_arraylist	*ls_gen_filedirs(char *options, t_filedir *temp_filedir)
{
	t_arraylist		*filedirs;
	DIR				*curr_dir;
	t_dirent		*dir_entry;
	char			*root;
	char			*full_path;

	if (!(curr_dir = opendir(temp_filedir->path)))
		return (ls_perror(temp_filedir->name));
	root = ft_strjoin(temp_filedir->path, "/");
	filedirs = NULL;
	while ((dir_entry = readdir(curr_dir)) != NULL)
	{
		full_path = ft_strjoin(root, dir_entry->d_name);
		if (!(temp_filedir = filedir(full_path)))
			continue;
		if (!filedirs)
			filedirs = check_malloc(arraylist(temp_filedir, DIR_BUF));
		else
			filedirs->push(filedirs, temp_filedir);
		free(full_path);
	}
	closedir(curr_dir);
	ls_gen_filedirs_sort(options, filedirs);
	free(root);
	return (filedirs);
}

void read_comp_vector(comp_vector *vector, const char *directory, const char *name) {

  size_t err=0;
  FILE *fp;

	char path[500];
  path[0]='\0';
  strcat(path, directory);
  strcat(path, "/");
  strcat(path, name);
  strcat(path, ".vec");

	fp  = fopen(path,  "rb+");
  check_file_open(fp, path);

	err = fread(&vector->siz, sizeof(SA_TYPE),  1, fp);
  check_file_read(err, 1, path);

	err = fread(&vector->n, sizeof(SA_TYPE),  1, fp);
  check_file_read(err, 1, path);

  err = fread(&vector->ratio, sizeof(SA_TYPE),  1, fp);
  check_file_read(err, 1, path);

  vector->vector = (SA_TYPE *) malloc(vector->n * sizeof(SA_TYPE));
  check_malloc(vector->vector, path);

  err = fread(vector->vector, sizeof(SA_TYPE), vector->n, fp);
  check_file_read(err, vector->n, path);

  fclose(fp);
}

Semaphore *make_semaphore(int value)
{
  Semaphore *sem = check_malloc(sizeof(Semaphore));
  int n = sem_init(sem, 0, value);
  if (n != 0) perror_exit("sem_init failed");
  return sem;
}

/*
 *  xcalloc() - same as calloc(3).  Used for portability.
 *  Never returns NULL; fatal on error.
 */
void *
xcalloc(size_t n, size_t sz)
{
    void *p;

    if (n < 1)
	n = 1;
    if (sz < 1)
	sz = 1;
    if ((p = calloc(n, sz)) == NULL) {
	if (failure_notify) {
	    snprintf(msg, 128, "xcalloc: Unable to allocate %u blocks of %u bytes!\n",
		(unsigned int) n, (unsigned int) sz);
	    (*failure_notify) (msg);
	} else {
	    perror("xcalloc");
	}
	exit(1);
    }
#if XMALLOC_DEBUG
    check_malloc(p, sz * n);
#endif
#if XMALLOC_STATISTICS
    malloc_stat(sz * n);
#endif
#if XMALLOC_TRACE
    xmalloc_show_trace(p, 1);
#endif
#if MEM_GEN_TRACE
    if (tracefp)
	fprintf(tracefp, "c:%u:%u:%p\n", (unsigned int) n, (unsigned int) sz, p);
#endif
    return (p);
}

/*
 *  xmalloc() - same as malloc(3).  Used for portability.
 *  Never returns NULL; fatal on error.
 */
void *
xmalloc(size_t sz)
{
    void *p;

    if (sz < 1)
	sz = 1;

    if ((p = malloc(sz)) == NULL) {
	if (failure_notify) {
	    snprintf(msg, 128, "xmalloc: Unable to allocate %d bytes!\n",
		(int) sz);
	    (*failure_notify) (msg);
	} else {
	    perror("malloc");
	}
	exit(1);
    }
#if XMALLOC_DEBUG
    check_malloc(p, sz);
#endif
#if XMALLOC_STATISTICS
    malloc_stat(sz);
#endif
#if XMALLOC_TRACE
    xmalloc_show_trace(p, 1);
#endif
#if MEM_GEN_TRACE
    if (tracefp)
	fprintf(tracefp, "m:%d:%p\n", sz, p);
#endif
    return (p);
}

/**
 * varray_assign: assign varray entry.
 *
 *	@param[in]	vb	#VARRAY structure
 *	@param[in]	index	index
 *	@param[in]	force	if entry not found, create it.
 *	@return		pointer of the entry
 *
 * If specified entry is found then it is returned, else it is allocated
 * and returned.
 * This procedure @EMPH{doesn't} operate the contents of the array.
 */
void *
varray_assign(VARRAY *vb, int index, int force)
{
	if (index < 0)
		die("varray_assign: illegal index value.");
	if (index >= vb->length) {
		if (force)
			vb->length = index + 1;
		else if (index == 0 && vb->length == 0)
			return NULL;
		else
			die("varray_assign: index(=%d) is out of range.", index);
	}
	/*
 	 * Expand the area.
	 */
	if (index >= vb->alloced) {
		int old_alloced = vb->alloced;

		while (index >= vb->alloced)
			vb->alloced += vb->expand;
		/*
		 * Old implementations of realloc() may crash
		 * when a null pointer is passed.
		 * Therefore, we cannot use realloc(NULL, ...).
		 */
		if (vb->vbuf == NULL)
			vb->vbuf = (char *)check_malloc(vb->size * vb->alloced);
		else
			vb->vbuf = (char *)check_realloc(vb->vbuf, vb->size * vb->alloced);
		if (debug)
			fprintf(stderr, "Expanded: from %d to %d.\n", old_alloced, vb->alloced);
	}
	return (void *)(vb->vbuf + vb->size * index);
}