Ejemplo n.º 1
0
void mpiReduce_pickerV3(float       *resDataAbsMaxPaddedGlobal,
                        size_t      *resDataMaxIndPaddedGlobal,
                        size_t      resSize,
                        eXCorrMerge bAbs)
{
    resSizeMPI = resSize;

    MPI_Datatype mpiType;
    MPI_Type_contiguous((int) 2, MPI_FLOAT, &mpiType);
    MPI_Type_commit(&mpiType);

    float     *resDataGlobalNode = NULL;
    float     *resDataGlobalNodeReduce = NULL;

    array_new(resDataGlobalNode, 2*resSize);
    array_new(resDataGlobalNodeReduce, 2*resSize);

    memcpy(resDataGlobalNode,
           resDataAbsMaxPaddedGlobal,
           resSize*sizeof(float));
    mpiOp_array_typecast(resDataMaxIndPaddedGlobal,
                         resDataGlobalNode+resSize,
                         resSize);

    MPI_Op mpiOp;

    switch (bAbs) {
        case XCORR_MERGE_NEGATIVE:
            MPI_Op_create((MPI_User_function *) mpiOp_xcorrMergeResultGlobalV3Abs,
                          1,            // commutative
                          &mpiOp);
            break;
        case XCORR_MERGE_POSITIVE:
            MPI_Op_create((MPI_User_function *) mpiOp_xcorrMergeResultGlobalV3,
                          1,            // commutative
                          &mpiOp);
            break;
        default:
            ERROR("mpiReduce_pickerV3", "unsupported merging mode");
    }
    MPI_Reduce(resDataGlobalNode,
               resDataGlobalNodeReduce,
               (int) resSize,       // resSize elements of size 2*sizeof(float)
               mpiType,
               mpiOp,
               0,
               MPI_COMM_WORLD);
    MPI_Op_free(&mpiOp);

    memcpy(resDataAbsMaxPaddedGlobal,
           resDataGlobalNodeReduce,
           resSize*sizeof(float));
    mpiOp_array_typecast(resDataGlobalNodeReduce+resSize,
                         resDataMaxIndPaddedGlobal,
                         resSize);

    array_delete(resDataGlobalNode);
    array_delete(resDataGlobalNodeReduce);
    MPI_Type_free(&mpiType);
}
Ejemplo n.º 2
0
void ShaderNode_clear_links(ShaderNode _sn)
{
    ShaderObject exec_so = {NULL};
	/**
    if ( to_ptr(_sn->result_link) != NULL )
    {
        ShaderObject_delete(_sn->result_link);
        _sn->result_link = exec_so;
    }
**/
    for (euint32 i = 0; i < array_n(_sn->input_links); i++)
    {
        ShaderObject so = array_safe_get(_sn->input_links, i);
        if ( to_ptr(so) != NULL )
            ShaderObject_delete(so);
    }
    array_delete(_sn->input_links);
    _sn->input_links = array_new(ShaderObject, 5, exec_so);

    for (euint32 i = 0; i < array_n(_sn->output_links); i++)
    {
        ShaderObject so = array_safe_get(_sn->output_links, i);
        if ( to_ptr(so) != NULL )
            ShaderObject_delete(so);
    }
    array_delete(_sn->output_links);
    _sn->output_links = array_new(ShaderObject, 5, exec_so);
}
Ejemplo n.º 3
0
Archivo: mesh.c Proyecto: 0ctobyte/ogl
void mesh_delete(mesh_t *mesh) {
  // Delete the vertex & index buffer object
  glDeleteBuffers(1, &mesh->vbo);
  glDeleteBuffers(1, &mesh->ibo);

  // Delete the vertex attribute array
  array_delete(mesh->vattributes);

  // Delete the index array
  array_delete(mesh->indices);
 
  // Delete all the material groups
  size_t size = array_size(mesh->mtl_grps);
  for(uint64_t i = 0; i < size; i++) {
    material_group_t *grp = (material_group_t*)array_at(mesh->mtl_grps, i);

    // Delete the texture if it exists
    glDeleteTextures(1, &grp->mtl.tex.texID);
  }
  
  // Delete the material group array
  array_delete(mesh->mtl_grps);

  // Finally delete the vertex array object
  glDeleteVertexArrays(1, &mesh->vao);
}
static bool
final_keyword_check(struct dsync_mail_change *change, const char *name,
                    char *type_r)
{
    const char *const *changes;
    unsigned int i, count;

    *type_r = KEYWORD_CHANGE_FINAL;

    changes = array_get(&change->keyword_changes, &count);
    for (i = 0; i < count; i++) {
        if (strcmp(changes[i]+1, name) != 0)
            continue;

        switch (changes[i][0]) {
        case KEYWORD_CHANGE_ADD:
            /* replace with ADD_AND_FINAL */
            array_delete(&change->keyword_changes, i, 1);
            *type_r = KEYWORD_CHANGE_ADD_AND_FINAL;
            return FALSE;
        case KEYWORD_CHANGE_REMOVE:
            /* a final keyword is marked as removed.
               this shouldn't normally happen. */
            array_delete(&change->keyword_changes, i, 1);
            return FALSE;
        case KEYWORD_CHANGE_ADD_AND_FINAL:
        case KEYWORD_CHANGE_FINAL:
            /* no change */
            return TRUE;
        }
    }
    return FALSE;
}
Ejemplo n.º 5
0
int SOMAascii (SOMAsetup *ssetup, const char *expr, int nparams, Parameter *params, const char *file, SOMAreturn* sr) {
    Array2D array;
	int i;  
    char *buf;
    long len;
    struct csv_parser csvp;
    clock_t begin, end;
	MuExpr me;

	array_init(&array);

    //Parse CSV file
    if (csv_init (&csvp, CSV_APPEND_NULL)!=0)
        return ERR;

    if ((buf=read_file_into_buffer (file, &len))==NULL)
        return ERR_FILE;
    csv_parse (&csvp, buf, len, csvcallback1, csvcallback2, (void*) &array);
    csv_fini (&csvp, csvcallback1, csvcallback2, (void*) &array);
    csv_free (&csvp);

    //array_print (&array); //debug

    muexpr_init (&me, expr);

    for (i=0; i<nparams; i++) 
        if (defpar (&me, params+i, i)!=OK) {
            return ERR_PARAMS;
            array_delete (&array);
            muexpr_free (&me);
        }
    findvars (&me, VAR_NAME_PREFIX);

    //CVS file and expression don't match
    if (me.nvars!=array.ncolumns-1) {
        array_delete (&array);
        muexpr_free (&me);
        return ERR_COLUMNS;
    }

    muexpr_eval (&me);
    if (mupError (me.hparser)) {
        array_delete (&array);
        muexpr_free (&me);
        return ERR_EXPR;
    }

    //Initialize output struct
    SOMAreturn_init (sr, ssetup->Migrations, nparams);
    begin=clock();
    //SOMA call
    SOMA (ssetup, nparams, params, sr, &array, &me);
    end=clock();
    sr->time=(double) (end-begin)/CLOCKS_PER_SEC;
    array_delete (&array);
    muexpr_free (&me);

    return OK;
}
Ejemplo n.º 6
0
static unsigned int
view_sync_expunges2seqs(struct mail_index_view_sync_ctx *ctx)
{
	struct mail_index_view *view = ctx->view;
	struct seq_range *src, *src_end, *dest;
	unsigned int count, expunge_count = 0;
	uint32_t prev_seq = 0;

	/* convert UIDs to sequences */
	src = dest = array_get_modifiable(&ctx->expunges, &count);
	src_end = src + count;
	for (; src != src_end; src++) {
		if (!mail_index_lookup_seq_range(view, src->seq1, src->seq2,
						 &dest->seq1, &dest->seq2))
			count--;
		else {
			i_assert(dest->seq1 > prev_seq);
			prev_seq = dest->seq2;

			expunge_count += dest->seq2 - dest->seq1 + 1;
			dest++;
		}
	}
	array_delete(&ctx->expunges, count,
		     array_count(&ctx->expunges) - count);
	return expunge_count;
}
Ejemplo n.º 7
0
int SOMAexternal (SOMAsetup *ssetup, FitnessFunction ffunc, int nparams, Parameter *params, const char *file, SOMAreturn* sr) {
    Array2D array;
    char *buf;
    long len;
    struct csv_parser csvp;
    clock_t begin, end;
	
	array_init (&array);
	array_append_column(&array); //blank column for external fitness function
    array.currentcolumn++;

    //Parse CSV file
    if (csv_init (&csvp, CSV_APPEND_NULL)!=0)
        return ERR;

    if ((buf=read_file_into_buffer (file, &len))==NULL)
        return ERR_FILE;
    csv_parse (&csvp, buf, len, csvcallback1, csvcallback2e, (void*) &array);
    csv_fini (&csvp, csvcallback1, csvcallback2e, (void*) &array);
    csv_free (&csvp);

    //array_print (&array); //debug

    //soma_array=&array;
    //Initialize output struct
    SOMAreturn_init (sr, ssetup->Migrations, nparams);
    begin=clock();
    //SOMA call
    SOMA2 (ssetup, nparams, params, sr, &array, ffunc);
    end=clock();
    sr->time=(double) (end-begin)/CLOCKS_PER_SEC;
    array_delete (&array);

    return OK;
}
Ejemplo n.º 8
0
void dispatch_delete(dispatch_t * self)
{
	if (unlikely(self == NULL))
		throw_unexpected(DISPATCH_NULL);
	close(self->fd), self->fd = -1;
	array_delete(&self->events);
}
Ejemplo n.º 9
0
void acl_rights_sort(struct acl_object *aclobj)
{
	struct acl_rights *rights;
	unsigned int i, dest, count;

	if (!array_is_created(&aclobj->rights))
		return;

	array_sort(&aclobj->rights, acl_rights_cmp);

	/* merge identical identifiers */
	rights = array_get_modifiable(&aclobj->rights, &count);
	for (dest = 0, i = 1; i < count; i++) {
		if (acl_rights_cmp(&rights[i], &rights[dest]) == 0) {
			/* add i's rights to dest and delete i */
			acl_right_names_merge(aclobj->rights_pool,
					      &rights[dest].rights,
					      rights[i].rights, FALSE);
			acl_right_names_merge(aclobj->rights_pool,
					      &rights[dest].neg_rights,
					      rights[i].neg_rights, FALSE);
		} else {
			if (++dest != i)
				rights[dest] = rights[i];
		}
	}
	if (++dest != count)
		array_delete(&aclobj->rights, dest, count - dest);
}
void mailbox_search_result_free(struct mail_search_result **_result)
{
	struct mail_search_result *result = *_result;
	struct mail_search_result *const *results;
	unsigned int i, count;

	*_result = NULL;

	results = array_get(&result->box->search_results, &count);
	for (i = 0; i < count; i++) {
		if (results[i] == result) {
			array_delete(&result->box->search_results, i, 1);
			break;
		}
	}
	i_assert(i != count);

	if (result->search_args != NULL)
		mail_search_args_unref(&result->search_args);

	array_free(&result->uids);
	array_free(&result->never_uids);
	if (array_is_created(&result->removed_uids)) {
		array_free(&result->removed_uids);
		array_free(&result->added_uids);
	}
	i_free(result);
}
Ejemplo n.º 11
0
static int json_parse_denest(struct json_parser *parser)
{
	const enum json_state *nested_states;
	unsigned count;

	parser->data++;
	json_parser_update_input_pos(parser);

	nested_states = array_get(&parser->nesting, &count);
	i_assert(count > 0);
	if (count == 1) {
		/* closing root */
		parser->state = JSON_STATE_DONE;
		if ((parser->flags & JSON_PARSER_NO_ROOT_OBJECT) == 0)
			return 0;
		/* we want to return the ending "]" or "}" to caller */
		return 1;
	}

	/* closing a nested object */
	parser->state = nested_states[count-2] == JSON_STATE_OBJECT_OPEN ?
		JSON_STATE_OBJECT_NEXT : JSON_STATE_ARRAY_NEXT;
	array_delete(&parser->nesting, count-1, 1);

	if (parser->nested_skip_count > 0) {
		parser->nested_skip_count--;
		return 0;
	}
	return 1;
}
Ejemplo n.º 12
0
END_TEST

START_TEST(array_delete_test)
  {
  job_array *pa;

  pa = new job_array();
  pa->job_ids = (char **)calloc(10, sizeof(char *));
  pa->ai_qs.array_size = 10;

  //Set up the save path

  path_arrays = (char *)"./";
  strcpy(pa->ai_qs.fileprefix,"tempFile");
  strcpy(pa->ai_qs.parent_id, "1.roshar");
  char path[256];
  snprintf(path, sizeof(path), "%s%s%s",
    path_arrays, pa->ai_qs.fileprefix, ARRAY_FILE_SUFFIX);
  FILE *fp = fopen(path,"w");
  fprintf(fp,"I'm a very temporary file.\n");
  fclose(fp);

  array_depend *pdep = (array_depend *)calloc(1,sizeof(array_depend));
  pa->ai_qs.deps.push_back(pdep);
  
  pdep->dp_jobs.push_back(new (array_depend_job));
  pdep->dp_jobs.push_back(new (array_depend_job));
  pdep->dp_jobs.push_back(new (array_depend_job));
  pdep->dp_jobs.push_back(new (array_depend_job));
  pdep->dp_jobs.push_back(new (array_depend_job));
  allarrays.insert(pa, pa->ai_qs.parent_id);

  array_delete("1.roshar");

  }
Ejemplo n.º 13
0
static void rm_watch(int wd, bool update_parent) {
  watch_node* node = table_get(watches, wd);
  if (node == NULL) {
    return;
  }

  userlog(LOG_DEBUG, "unwatching %s: %d (%p)", node->path, node->wd, node);

  if (inotify_rm_watch(inotify_fd, node->wd) < 0) {
    userlog(LOG_DEBUG, "inotify_rm_watch(%d:%s): %s", node->wd, node->path, strerror(errno));
  }

  for (int i=0; i<array_size(node->kids); i++) {
    watch_node* kid = array_get(node->kids, i);
    if (kid != NULL) {
      rm_watch(kid->wd, false);
    }
  }

  if (update_parent && node->parent != NULL) {
    for (int i=0; i<array_size(node->parent->kids); i++) {
      if (array_get(node->parent->kids, i) == node) {
        array_put(node->parent->kids, i, NULL);
        break;
      }
    }
  }

  array_delete(node->kids);
  free(node);
  table_put(watches, wd, NULL);
}
Ejemplo n.º 14
0
static int json_parse_denest(struct json_parser *parser)
{
	const enum json_state *nested_states;
	unsigned count;

	parser->data++;
	json_parser_update_input_pos(parser);

	nested_states = array_get(&parser->nesting, &count);
	if (count == 0) {
		/* closing root */
		parser->state = JSON_STATE_DONE;
		return 0;
	}

	/* closing a nested object */
	if (count == 1) {
		/* we're back to root */
		parser->state = JSON_STATE_OBJECT_NEXT;
	} else {
		/* back to previous nested object */
		parser->state = nested_states[count-2] == JSON_STATE_OBJECT_OPEN ?
			JSON_STATE_OBJECT_NEXT : JSON_STATE_ARRAY_NEXT;
	}
	array_delete(&parser->nesting, count-1, 1);

	if (parser->nested_skip_count > 0) {
		parser->nested_skip_count--;
		return 0;
	}
	return 1;
}
Ejemplo n.º 15
0
void imapc_msgmap_expunge(struct imapc_msgmap *msgmap, uint32_t rseq)
{
    i_assert(rseq > 0);
    i_assert(rseq <= imapc_msgmap_count(msgmap));

    array_delete(&msgmap->uids, rseq-1, 1);
}
Ejemplo n.º 16
0
void mdbox_file_unrefed(struct dbox_file *file)
{
	struct mdbox_file *mfile = (struct mdbox_file *)file;
	struct mdbox_file *oldest_file;
	unsigned int i, count;

	/* don't cache metadata seeks while file isn't being referenced */
	file->metadata_read_offset = (uoff_t)-1;
	mfile->close_time = ioloop_time;

	if (mfile->file_id != 0) {
		count = array_count(&mfile->storage->open_files);
		if (!file->deleted && count <= MDBOX_MAX_OPEN_UNUSED_FILES) {
			/* we can leave this file open for now */
			mdbox_file_close_later(mfile);
			return;
		}

		/* close the oldest file with refcount=0 */
		oldest_file = mdbox_find_oldest_unused_file(mfile->storage, &i);
		i_assert(oldest_file != NULL);
		array_delete(&mfile->storage->open_files, i, 1);
		if (oldest_file != mfile) {
			dbox_file_free(&oldest_file->file);
			mdbox_file_close_later(mfile);
			return;
		}
		/* have to close ourself */
	}
	dbox_file_free(file);
}
Ejemplo n.º 17
0
struct array_s* array_new(int num, int element_size)
{
    int buffer_size = num * element_size;
    struct array_s* ret = (struct array_s*)malloc(sizeof(struct array_s));

    if(NULL != ret)
    {
        memset(ret, 0, sizeof(*ret));

        ret->buffer = (char*)malloc(buffer_size);

        if(NULL != ret->buffer)
        {
            memset(ret->buffer, 0, buffer_size);
            ret->element_size = element_size;
            ret->element_num = num;
            ret->buffer_size = buffer_size;
        }
        else
        {
            array_delete(ret);
            ret = NULL;
        }
    }

    return ret;
}
Ejemplo n.º 18
0
void watch_delete(watch_t * self)
{
	if (unlikely(self == NULL))
		throw_unexpected(WATCH_NULL);
	close(self->fd), self->fd = -1;
	array_delete(&self->callbacks);
}
Ejemplo n.º 19
0
void auth_fields_remove(struct auth_fields *fields, const char *key)
{
	unsigned int idx;

	if (auth_fields_find_idx(fields, key, &idx)) {
		auth_fields_snapshot_preserve(fields);
		array_delete(&fields->fields, idx, 1);
	}
}
Ejemplo n.º 20
0
void process_thread_delete(process_thread_t * process_thread) {
	if(process_thread) {
		if(process_thread->maps_path) { free(process_thread->maps_path); }
		if(process_thread->mem_path) { free(process_thread->mem_path); }
		if(process_thread->memory_zones) { memory_zones_delete(process_thread->memory_zones); }
		if(process_thread->memory_chunk) { array_delete(process_thread->memory_chunk); }
		if(process_thread->file && fclose(process_thread->file) == EOF) { perror("process_thread_delete"); }
		free(process_thread);
	}
}
Ejemplo n.º 21
0
void array_delete_vs_data(array* a) {
  if (a != NULL) {
    for (int i=0; i<a->size; i++) {
      if (a->data[i] != NULL) {
        free(a->data[i]);
      }
    }
    array_delete(a);
  }
}
Ejemplo n.º 22
0
///==============================ShaderNode========================================///
void ShaderNode_Dest(shader_node* _sn)
{
    if (_sn->node_name)
        EString_delete(_sn->node_name);
    if (_sn->function)
        EString_delete(_sn->function);
/**
    ShaderObject_delete(_sn->result);
    if ( to_ptr(_sn->result_link) != NULL )
        ShaderObject_delete(_sn->result_link);
**/
    for (euint32 i = 0; i < array_n(_sn->input_param_table); i++)
    {
        ShaderObject so = array_safe_get(_sn->input_param_table, i);
        if ( to_ptr(so) != NULL )
            ShaderObject_delete(so);
    }
    array_delete(_sn->input_param_table);

    for (euint32 i = 0; i < array_n(_sn->output_param_table); i++)
    {
        ShaderObject so = array_safe_get(_sn->output_param_table, i);
        if ( to_ptr(so) != NULL )
            ShaderObject_delete(so);
    }
    array_delete(_sn->output_param_table);

    for (euint32 i = 0; i < array_n(_sn->input_links); i++)
    {
        ShaderObject so = array_safe_get(_sn->input_links, i);
        if ( to_ptr(so) != NULL )
            ShaderObject_delete(so);
    }
    array_delete(_sn->input_links);

    for (euint32 i = 0; i < array_n(_sn->output_links); i++)
    {
        ShaderObject so = array_safe_get(_sn->output_links, i);
        if ( to_ptr(so) != NULL )
            ShaderObject_delete(so);
    }
    array_delete(_sn->output_links);
}
Ejemplo n.º 23
0
int main(int argc, char** argv) {
  if (argc > 1) {
    if (strcmp(argv[1], "--help") == 0) {
      printf(USAGE_MSG);
      return 0;
    }
    else if (strcmp(argv[1], "--version") == 0) {
      printf(VERSION_MSG);
      return 0;
    }
    else if (strcmp(argv[1], "--selftest") == 0) {
      self_test = true;
    }
    else {
      printf("unrecognized option: %s\n", argv[1]);
      printf(HELP_MSG);
      return 1;
    }
  }

  init_log();
  if (!self_test) {
    userlog(LOG_INFO, "started (v." VERSION ")");
  }
  else {
    userlog(LOG_INFO, "started (self-test mode) (v." VERSION ")");
  }

  setvbuf(stdin, NULL, _IONBF, 0);
  setvbuf(stdout, NULL, _IONBF, 0);

  roots = array_create(20);
  if (init_inotify() && roots != NULL) {
    set_inotify_callback(&inotify_callback);

    if (!self_test) {
      main_loop();
    }
    else {
      run_self_test();
    }

    unregister_roots();
  }
  else {
    printf("GIVEUP\n");
  }
  close_inotify();
  array_delete(roots);

  userlog(LOG_INFO, "finished");
  closelog();

  return 0;
}
Ejemplo n.º 24
0
void sql_driver_unregister(const struct sql_db *driver)
{
	const struct sql_db *const *drivers;
	unsigned int i, count;

	drivers = array_get(&sql_drivers, &count);
	for (i = 0; i < count; i++) {
		if (drivers[i] == driver) {
			array_delete(&sql_drivers, i, 1);
			break;
		}
	}
}
static bool client_search_update_cancel(struct client *client, const char *tag)
{
	struct imap_search_update *update;
	unsigned int idx;

	update = client_search_update_lookup(client, tag, &idx);
	if (update == NULL)
		return FALSE;

	imap_search_update_free(update);
	array_delete(&client->search_updates, idx, 1);
	return TRUE;
}
Ejemplo n.º 26
0
void ts_exit() {
  u64 i;

  for (i = 0; i < ts_type_size_s; ++i) {
    if (i < ts_builtin_types) {
      st_delete(&ts_type_table[i].id);
    }
    // struct and same length?
    if (ts_type_table[i].of == TY_STRUCT) {
      free(ts_type_table[i].structure.fields);
      array_delete(&ts_type_table[i].structure.members);
      array_delete(&ts_type_table[i].structure.alias);
    } else if (ts_type_table[i].of == TY_FUNCTION) {
      free(ts_type_table[i].func.params);
    } else if (ts_type_table[i].of == TY_TEMPLATE) {
      array_delete(&ts_type_table[i].tpl.usedby);
    }
  }

  free(ts_type_table);
  ts_type_table = 0;
}
Ejemplo n.º 27
0
void http_client_remove_request_error(struct http_client *client,
	struct http_client_request *req)
{
	struct http_client_request *const *reqs;
	unsigned int i, count;

	reqs = array_get(&client->delayed_failing_requests, &count);
	for (i = 0; i < count; i++) {
		if (reqs[i] == req) {
			array_delete(&client->delayed_failing_requests, i, 1);
			return;
		}
	}
}
Ejemplo n.º 28
0
void mail_index_unregister_sync_lost_handler(struct mail_index *index,
					     mail_index_sync_lost_handler_t *cb)
{
	mail_index_sync_lost_handler_t *const *handlers;
	unsigned int i, count;

	handlers = array_get(&index->sync_lost_handlers, &count);
	for (i = 0; i < count; i++) {
		if (handlers[i] == cb) {
			array_delete(&index->sync_lost_handlers, i, 1);
			break;
		}
	}
}
Ejemplo n.º 29
0
void amino_acid_delete(AminoAcid *aa)
{
  int i;
  for(i = 0; i < array_size(aa->atoms); i++)
  {
    Atom *a = (Atom *)array_get(aa->atoms, i);
    atom_delete(a);
  }
  array_delete(aa->atoms);
  aa->N  = NULL;
  aa->CA = NULL;
  aa->C  = NULL;
  free(aa);
}
Ejemplo n.º 30
0
void flang_exit(ast_t* root) {
  ast_delete(root);
  pool_destroy();

  ts_exit();
  array_delete(identifiers);
  free(identifiers);
  identifiers = 0;

  st_memfree();
  st_replace_allocators(malloc, realloc, free);
  hash_replace_allocators(malloc, realloc, free);
  array_replace_allocators(malloc, realloc, free);
}