コード例 #1
0
ファイル: ma.c プロジェクト: AlexWoroschilow/uni_hamburg
void* gt_realloc_mem(void *ptr, size_t size, const char *src_file, int src_line)
{
  MAInfo *mainfo;
  void *mem;
  gt_assert(ma);
  if (ma->bookkeeping) {
    gt_mutex_lock(bookkeeping_lock);
    ma->mallocevents++;
    if (ptr) {
      mainfo = gt_hashmap_get(ma->allocated_pointer, ptr);
      gt_assert(mainfo);
      subtract_size(ma, mainfo->size);
      gt_hashmap_remove(ma->allocated_pointer, ptr);
    }
    mainfo = xmalloc(sizeof *mainfo, ma->current_size, src_file, src_line);
    mainfo->size = size;
    mainfo->src_file = src_file;
    mainfo->src_line = src_line;
    mem = xrealloc(ptr, size, ma->current_size, src_file, src_line);
    gt_hashmap_add(ma->allocated_pointer, mem, mainfo);
    add_size(ma, size);
    gt_mutex_unlock(bookkeeping_lock);
    return mem;
  }
  return xrealloc(ptr, size, ma->current_size, src_file, src_line);
}
コード例 #2
0
ファイル: ma.c プロジェクト: AlexWoroschilow/uni_hamburg
void gt_free_mem(void *ptr, GT_UNUSED const char *src_file,
                 GT_UNUSED int src_line)
{
  MAInfo *mainfo;
  gt_assert(ma);
  if (ptr == NULL) return;
  if (ma->bookkeeping) {
    gt_mutex_lock(bookkeeping_lock);
#ifndef NDEBUG
    if (!gt_hashmap_get(ma->allocated_pointer, ptr)) {
      fprintf(stderr, "bug: double free() attempted on line %d in file "
              "\"%s\"\n", src_line, src_file);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
#endif
    mainfo = gt_hashmap_get(ma->allocated_pointer, ptr);
    gt_assert(mainfo);
    subtract_size(ma, mainfo->size);
    gt_hashmap_remove(ma->allocated_pointer, ptr);
    free(ptr);
    gt_mutex_unlock(bookkeeping_lock);
  }
  else {
    free(ptr);
  }
}
コード例 #3
0
void gt_spacepeak_free(GtUword size)
{
  gt_assert(peaklogger && size <= peaklogger->current);
  gt_mutex_lock(peaklogger->mutex);
  peaklogger->current -= size;
  gt_mutex_unlock(peaklogger->mutex);
}
コード例 #4
0
ファイル: alphabet.c プロジェクト: oeigenbrod/genometools
GtAlphabet* gt_alphabet_ref(GtAlphabet *alphabet)
{
  gt_assert(alphabet);
  gt_mutex_lock(alphabet->refmutex);
  alphabet->reference_count++;
  gt_mutex_unlock(alphabet->refmutex);
  return alphabet;
}
コード例 #5
0
void gt_spacepeak_add(GtUword size)
{
  gt_assert(peaklogger);
  gt_mutex_lock(peaklogger->mutex);
  peaklogger->current += size;
  if (peaklogger->current > peaklogger->max)
    peaklogger->max = peaklogger->current;
  gt_mutex_unlock(peaklogger->mutex);
}
コード例 #6
0
ファイル: ma.c プロジェクト: AlexWoroschilow/uni_hamburg
void gt_ma_show_allocations(FILE *outfp)
{
  GT_UNUSED int had_err;
  gt_assert(ma);
  gt_mutex_lock(bookkeeping_lock);
  had_err = gt_hashmap_foreach(ma->allocated_pointer, print_allocation,
                               outfp, NULL);
  gt_mutex_unlock(bookkeeping_lock);
  gt_assert(!had_err); /* cannot happen, print_allocation() is sane */
}
コード例 #7
0
ファイル: ma.c プロジェクト: AlexWoroschilow/uni_hamburg
void gt_ma_clean(void)
{
  gt_assert(ma);
  gt_mutex_lock(bookkeeping_lock);
  ma->bookkeeping = false;
  gt_hashmap_delete(ma->allocated_pointer);
  gt_mutex_unlock(bookkeeping_lock);
  gt_mutex_delete(bookkeeping_lock);
  free(ma);
  ma = NULL;
}
コード例 #8
0
ファイル: yarandom.c プロジェクト: 9beckert/TIR
unsigned int
gt_ya_random (void)
{
  register int ret;
  gt_mutex_lock(mutex);
  ret = a[i1] + a[i2];
  a[i1] = ret;
  if (++i1 >= VectorSize) i1 = 0;
  if (++i2 >= VectorSize) i2 = 0;
  gt_mutex_unlock(mutex);
  return ret;
}
コード例 #9
0
ファイル: symbol.c プロジェクト: AlexWoroschilow/uni_hamburg
const char* gt_symbol(const char *cstr)
{
  const char *symbol;
  if (!cstr)
    return NULL;
  gt_mutex_lock(symbol_mutex);
  if (!(symbol = gt_cstr_table_get(symbols, cstr))) {
    gt_cstr_table_add(symbols, cstr);
    symbol = gt_cstr_table_get(symbols, cstr);
  }
  gt_mutex_unlock(symbol_mutex);
  return symbol;
}
コード例 #10
0
ファイル: ma.c プロジェクト: AlexWoroschilow/uni_hamburg
int gt_ma_check_space_leak(void)
{
  CheckSpaceLeakInfo info;
  GT_UNUSED int had_err;
  gt_assert(ma);
  gt_mutex_lock(bookkeeping_lock);
  info.has_leak = false;
  had_err = gt_hashmap_foreach(ma->allocated_pointer, check_space_leak, &info,
                               NULL);
  gt_assert(!had_err); /* cannot happen, check_space_leak() is sane */
  gt_mutex_unlock(bookkeeping_lock);
  if (info.has_leak)
    return -1;
  return 0;
}
コード例 #11
0
ファイル: alphabet.c プロジェクト: oeigenbrod/genometools
void gt_alphabet_delete(GtAlphabet *alphabet)
{
  if (!alphabet) return;
  gt_mutex_lock(alphabet->refmutex);
  if (alphabet->reference_count) {
    alphabet->reference_count--;
    gt_mutex_unlock(alphabet->refmutex);
    return;
  }
  gt_mutex_unlock(alphabet->refmutex);
  gt_free(alphabet->mapdomain);
  gt_free(alphabet->characters);
  if (alphabet->alphadef != NULL)
    gt_str_delete(alphabet->alphadef);
  gt_mutex_delete(alphabet->refmutex);
  gt_free(alphabet);
}
コード例 #12
0
static void* gt_feature_index_unit_test_add(void *data)
{
  GtFeatureNode *feature;
  GtFeatureIndexTestShared *shm = (GtFeatureIndexTestShared*) data;

  while (true) {
    gt_mutex_lock(shm->mutex);
    if (shm->next_node_idx == GT_FI_TEST_FEATURES_PER_THREAD * gt_jobs) {
      gt_mutex_unlock(shm->mutex);
      return NULL;
    }
    gt_assert(shm->next_node_idx < gt_array_size(shm->nodes));
    feature = *(GtFeatureNode**) gt_array_get(shm->nodes, shm->next_node_idx++);
    gt_mutex_unlock(shm->mutex);
    gt_feature_index_add_feature_node(shm->fi, feature, shm->err);
    gt_genome_node_delete((GtGenomeNode*) feature);
  }
  return NULL;
}
コード例 #13
0
ファイル: ma.c プロジェクト: AlexWoroschilow/uni_hamburg
void* gt_calloc_mem(size_t nmemb, size_t size, const char *src_file,
                    int src_line)
{
  MAInfo *mainfo;
  void *mem;
  gt_assert(ma);
  if (ma->bookkeeping) {
    gt_mutex_lock(bookkeeping_lock);
    ma->mallocevents++;
    mainfo = xmalloc(sizeof *mainfo, ma->current_size, src_file, src_line);
    mainfo->size = nmemb * size;
    mainfo->src_file = src_file;
    mainfo->src_line = src_line;
    mem = xcalloc(nmemb, size, ma->current_size, src_file, src_line);
    gt_hashmap_add(ma->allocated_pointer, mem, mainfo);
    add_size(ma, nmemb * size);
    gt_mutex_unlock(bookkeeping_lock);
    return mem;
  }
  return xcalloc(nmemb, size, ma->current_size, src_file, src_line);
}
コード例 #14
0
static void* gt_feature_index_unit_test_query(void *data)
{
  GtFeatureIndexTestShared *shm = (GtFeatureIndexTestShared*) data;
  GtRange rng;
  GtError *err = shm->err;
  GtUword i;
  int had_err = 0;
  GtArray *arr, *arr_ref;

  gt_mutex_lock(shm->mutex);
  if (gt_error_is_set(shm->err)) {
    gt_mutex_unlock(shm->mutex);
    return NULL;
  }
  gt_mutex_unlock(shm->mutex);

  arr = gt_array_new(sizeof (GtFeatureNode*));
  arr_ref = gt_array_new(sizeof (GtFeatureNode*));
  rng.start = random() % (GT_FI_TEST_END - GT_FI_TEST_QUERY_WIDTH);
  rng.end = rng.start + random() % (GT_FI_TEST_QUERY_WIDTH);

  /* get reference set by linear search */
  gt_mutex_lock(shm->mutex);
  for (i=0; i<GT_FI_TEST_FEATURES_PER_THREAD * gt_jobs; i++) {
    GtRange rng2;
    GtFeatureNode *fn;
    fn = *(GtFeatureNode**) gt_array_get(shm->nodes, i);
    rng2 = gt_genome_node_get_range((GtGenomeNode*) fn);
    if (gt_range_overlap(&rng, &rng2)) {
      gt_array_add(arr_ref, fn);
    }
  }
  gt_mutex_unlock(shm->mutex);

  /* query feature index */
  gt_feature_index_get_features_for_range(shm->fi, arr, GT_FI_TEST_SEQID, &rng,
                                          err);

  /* result size must be equal */
  if (gt_array_size(arr) != gt_array_size(arr_ref))
    had_err = -1;

  /* nodes must be the same (note that we should not rely on ptr equality) */
  if (!had_err) {
    gt_array_sort(arr_ref, cmp_range_start);
    gt_array_sort(arr    , cmp_range_start);

    for (i=0;i<gt_array_size(arr);i++) {
      if (had_err)
        break;
      if (!gt_feature_node_is_similar(*(GtFeatureNode**) gt_array_get(arr, i),
                                      *(GtFeatureNode**)
                                      gt_array_get(arr_ref, i))) {
        had_err = -1;
      }
    }
  }

  if (had_err) {
    gt_mutex_lock(shm->mutex);
    shm->error_count++;
    gt_mutex_unlock(shm->mutex);
  }

  gt_array_delete(arr);
  gt_array_delete(arr_ref);
  return NULL;
}