自学教程：C++ ARRAY_INIT函数代码示例

static int sger(cb_order order, size_t M, size_t N, float alpha,                gpudata *X, size_t offX, int incX,                gpudata *Y, size_t offY, int incY,                gpudata *A, size_t offA, size_t lda) {  cl_ctx *ctx = X->ctx;  cl_event evl[3];  cl_event ev;  cl_uint num_ev = 0;  clblasStatus err;  ARRAY_INIT(X);  ARRAY_INIT(Y);  ARRAY_INIT(A);  err = clblasSger(convO(order), M, N, alpha, X->buf, offX, incX,                   Y->buf, offY, incY, A->buf, offA, lda, 1, &ctx->q,                   num_ev, num_ev == 0 ? NULL : evl, &ev);  if (err != clblasSuccess)    return GA_BLAS_ERROR;  ARRAY_FINI(X);  ARRAY_FINI(Y);  ARRAY_FINI(A);  clReleaseEvent(ev);  return GA_NO_ERROR;}

static int dgemm(cb_order order, cb_transpose transA, cb_transpose transB,                 size_t M, size_t N, size_t K, double alpha,                 gpudata *A, size_t offA, size_t lda,                 gpudata *B, size_t offB, size_t ldb, double beta,                 gpudata *C, size_t offC, size_t ldc) {  cl_ctx *ctx = A->ctx;  clblasStatus err;  cl_uint num_ev = 0;  cl_event evl[3];  cl_event ev;  ARRAY_INIT(A);  ARRAY_INIT(B);  ARRAY_INIT(C);  err = clblasDgemm(convO(order), convT(transA), convT(transB), M, N, K,                    alpha, A->buf, offA, lda, B->buf, offB, ldb,                    beta, C->buf, offC, ldc, 1, &ctx->q,                    num_ev, num_ev == 0 ? NULL : evl, &ev);  if (err != clblasSuccess)    return GA_BLAS_ERROR;  ARRAY_FINI(A);  ARRAY_FINI(B);  ARRAY_FINI(C);  clReleaseEvent(ev);  return GA_NO_ERROR;}

static int sgemm(cb_order order, cb_transpose transA, cb_transpose transB,                 size_t M, size_t N, size_t K, float alpha,                 gpudata *A, size_t offA, size_t lda,                 gpudata *B, size_t offB, size_t ldb, float beta,                 gpudata *C, size_t offC, size_t ldc) {  cl_ctx *ctx = A->ctx;  cl_uint num_ev = 0;  cl_event evl[3];  cl_event ev;  ARRAY_INIT(A);  ARRAY_INIT(B);  ARRAY_INIT(C);  CLB_CHECK(ctx->err, clblasSgemm(convO(order), convT(transA), convT(transB),                                  M, N, K,                                  alpha, A->buf, offA, lda, B->buf, offB, ldb,                                  beta, C->buf, offC, ldc, 1, &ctx->q,                                  num_ev, num_ev == 0 ? NULL : evl, &ev));  ARRAY_FINI(A);  ARRAY_FINI(B);  ARRAY_FINI(C);  clReleaseEvent(ev);  return GA_NO_ERROR;}

static int dgemmBatch(cb_order order, cb_transpose transA, cb_transpose transB,                      size_t M, size_t N, size_t K, double alpha,                      gpudata **A, size_t *offA, size_t lda,                      gpudata **B, size_t *offB, size_t ldb,                      double beta, gpudata **C, size_t *offC, size_t ldc,                      size_t batchCount) {  cl_ctx *ctx = A[0]->ctx;  cl_event evl[3];  cl_event ev;  size_t i;  cl_uint num_ev = 0;  clblasStatus err;  for (i = 0; i < batchCount; i++) {    ARRAY_INIT(A[i]);    ARRAY_INIT(B[i]);    ARRAY_INIT(C[i]);    err = clblasDgemm(convO(order), convT(transA), convT(transB), M, N, K,                      alpha, A[i]->buf, offA[i], lda, B[i]->buf, offB[i], ldb,                      beta, C[i]->buf, offB[i], ldc, 1, &ctx->q,                      num_ev, num_ev == 0 ? NULL : evl, &ev);    if (err != clblasSuccess)      return GA_BLAS_ERROR;    ARRAY_FINI(A[i]);    ARRAY_FINI(B[i]);    ARRAY_FINI(C[i]);    clReleaseEvent(ev);  }  return GA_NO_ERROR;}

static int dgemmBatch(cb_order order, cb_transpose transA, cb_transpose transB,                      size_t M, size_t N, size_t K, double alpha,                      gpudata **A, size_t *offA, size_t lda,                      gpudata **B, size_t *offB, size_t ldb,                      double beta, gpudata **C, size_t *offC, size_t ldc,                      size_t batchCount) {  cl_ctx *ctx = A[0]->ctx;  cl_event ev;  size_t i;  for (i = 0; i < batchCount; i++) {    ARRAY_INIT(A[i]);    ARRAY_INIT(B[i]);    ARRAY_INIT(C[i]);    CLBT_CHECK(ctx->err, CLBlastDgemm(convO(order), convT(transA),                                      convT(transB), M, N, K,                                      alpha, A[i]->buf, offA[i], lda,                                      B[i]->buf, offB[i], ldb, beta,                                      C[i]->buf, offC[i], ldc, &ctx->q, &ev));    ARRAY_FINI(A[i]);    ARRAY_FINI(B[i]);    ARRAY_FINI(C[i]);    clReleaseEvent(ev);  }  return GA_NO_ERROR;}

static int dgemv(cb_order order, cb_transpose transA, size_t M, size_t N,                 double alpha, gpudata *A, size_t offA, size_t lda,                 gpudata *X, size_t offX, int incX, double beta,                 gpudata *Y, size_t offY, int incY) {  cl_ctx *ctx = A->ctx;  clblasStatus err;  cl_uint num_ev = 0;  cl_event evl[3];  cl_event ev;  ARRAY_INIT(A);  ARRAY_INIT(X);  ARRAY_INIT(Y);  err = clblasDgemv(convO(order), convT(transA), M, N, alpha,                    A->buf, offA, lda, X->buf, offX, incX,                    beta, Y->buf, offY, incY, 1, &ctx->q,                    num_ev, num_ev == 0 ? NULL : evl, &ev);  if (err != clblasSuccess)    return GA_BLAS_ERROR;  ARRAY_FINI(A);  ARRAY_FINI(X);  ARRAY_FINI(Y);  clReleaseEvent(ev);  return GA_NO_ERROR;}

static int dger(cb_order order, size_t M, size_t N, double alpha,                gpudata *X, size_t offX, int incX,                gpudata *Y, size_t offY, int incY,                gpudata *A, size_t offA, size_t lda) {  cl_ctx *ctx = X->ctx;  cl_event evl[3];  cl_event ev;  cl_uint num_ev = 0;  ARRAY_INIT(X);  ARRAY_INIT(Y);  ARRAY_INIT(A);  CLB_CHECK(ctx->err, clblasDger(convO(order), M, N, alpha, X->buf, offX, incX,                                 Y->buf, offY, incY, A->buf, offA, lda, 1, &ctx->q,                                 num_ev, num_ev == 0 ? NULL : evl, &ev));  ARRAY_FINI(X);  ARRAY_FINI(Y);  ARRAY_FINI(A);  clReleaseEvent(ev);  return GA_NO_ERROR;}

static int sgemmBatch(cb_order order, cb_transpose transA, cb_transpose transB,                      size_t M, size_t N, size_t K, float alpha,                      gpudata **A, size_t *offA, size_t lda,                      gpudata **B, size_t *offB, size_t ldb,                      float beta, gpudata **C, size_t *offC, size_t ldc,                      size_t batchCount) {  cl_ctx *ctx = A[0]->ctx;  cl_event evl[3];  cl_event ev;  size_t i;  cl_uint num_ev = 0;  for (i = 0; i < batchCount; i++) {    ARRAY_INIT(A[i]);    ARRAY_INIT(B[i]);    ARRAY_INIT(C[i]);    CLB_CHECK(ctx->err, clblasSgemm(convO(order), convT(transA), convT(transB),                                    M, N, K,                                    alpha, A[i]->buf, offA[i], lda,                                    B[i]->buf, offB[i], ldb,                                    beta, C[i]->buf, offC[i], ldc, 1, &ctx->q,                                    num_ev, num_ev == 0 ? NULL : evl, &ev));    ARRAY_FINI(A[i]);    ARRAY_FINI(B[i]);    ARRAY_FINI(C[i]);    clReleaseEvent(ev);  }  return GA_NO_ERROR;}

static int sgemv(cb_order order, cb_transpose transA, size_t M, size_t N,                 float alpha, gpudata *A, size_t offA, size_t lda,                 gpudata *X, size_t offX, int incX, float beta,                 gpudata *Y, size_t offY, int incY) {  cl_ctx *ctx = A->ctx;  cl_uint num_ev = 0;  cl_event evl[3];  cl_event ev;  ARRAY_INIT(A);  ARRAY_INIT(X);  ARRAY_INIT(Y);  CLB_CHECK(ctx->err, clblasSgemv(convO(order), convT(transA), M, N, alpha,                                  A->buf, offA, lda, X->buf, offX, incX,                                  beta, Y->buf, offY, incY, 1, &ctx->q,                                  num_ev, num_ev == 0 ? NULL : evl, &ev));  ARRAY_FINI(A);  ARRAY_FINI(X);  ARRAY_FINI(Y);  clReleaseEvent(ev);  return GA_NO_ERROR;}

static int sgemmBatch(cb_order order, cb_transpose transA, cb_transpose transB,                      size_t M, size_t N, size_t K, float alpha,                      gpudata **A, size_t *offA, size_t lda,                      gpudata **B, size_t *offB, size_t ldb,                      float beta, gpudata **C, size_t *offC, size_t ldc,                      size_t batchCount) {  cl_ctx *ctx = A[0]->ctx;  cl_event ev;  size_t i;  StatusCode err;  for (i = 0; i < batchCount; i++) {    ARRAY_INIT(A[i]);    ARRAY_INIT(B[i]);    ARRAY_INIT(C[i]);    err = CLBlastSgemm(convO(order), convT(transA), convT(transB), M, N, K,                      alpha, A[i]->buf, offA[i], lda, B[i]->buf, offB[i], ldb,                      beta, C[i]->buf, offB[i], ldc, &ctx->q, &ev);    if (err != kSuccess)      return GA_BLAS_ERROR;    ARRAY_FINI(A[i]);    ARRAY_FINI(B[i]);    ARRAY_FINI(C[i]);    clReleaseEvent(ev);  }  return GA_NO_ERROR;}

static int hgemv(cb_order order, cb_transpose transA, size_t M, size_t N,                 float alpha, gpudata *A, size_t offA, size_t lda,                 gpudata *X, size_t offX, int incX, float beta,                 gpudata *Y, size_t offY, int incY) {  cl_ctx *ctx = A->ctx;  cl_event ev;  ARRAY_INIT(A);  ARRAY_INIT(X);  ARRAY_INIT(Y);  CLBT_CHECK(ctx->err, CLBlastHgemv(convO(order), convT(transA), M, N,                                    float_to_half(alpha),                                    A->buf, offA, lda, X->buf, offX, incX,                                    float_to_half(beta),                                    Y->buf, offY, incY, &ctx->q, &ev));  ARRAY_FINI(A);  ARRAY_FINI(X);  ARRAY_FINI(Y);  clReleaseEvent(ev);  return GA_NO_ERROR;}

static int sgemm(cb_order order, cb_transpose transA, cb_transpose transB,                 size_t M, size_t N, size_t K, float alpha,                 gpudata *A, size_t offA, size_t lda,                 gpudata *B, size_t offB, size_t ldb, float beta,                 gpudata *C, size_t offC, size_t ldc) {  cl_ctx *ctx = A->ctx;  StatusCode err;  cl_event ev;  ARRAY_INIT(A);  ARRAY_INIT(B);  ARRAY_INIT(C);  err = CLBlastSgemm(convO(order), convT(transA), convT(transB), M, N, K,                    alpha, A->buf, offA, lda, B->buf, offB, ldb,                    beta, C->buf, offC, ldc, &ctx->q, &ev);  if (err != kSuccess)    return GA_BLAS_ERROR;  ARRAY_FINI(A);  ARRAY_FINI(B);  ARRAY_FINI(C);  clReleaseEvent(ev);  return GA_NO_ERROR;}

static int dger(cb_order order, size_t M, size_t N, double alpha,                gpudata *X, size_t offX, int incX,                gpudata *Y, size_t offY, int incY,                gpudata *A, size_t offA, size_t lda) {  cl_ctx *ctx = X->ctx;  cl_event ev;  StatusCode err;  ARRAY_INIT(X);  ARRAY_INIT(Y);  ARRAY_INIT(A);  err = CLBlastDger(convO(order), M, N, alpha, X->buf, offX, incX,                    Y->buf, offY, incY, A->buf, offA, lda, &ctx->q, &ev);  if (err != kSuccess)    return GA_BLAS_ERROR;  ARRAY_FINI(X);  ARRAY_FINI(Y);  ARRAY_FINI(A);  clReleaseEvent(ev);  return GA_NO_ERROR;}

static int sgemv(cb_order order, cb_transpose transA, size_t M, size_t N,                 float alpha, gpudata *A, size_t offA, size_t lda,                 gpudata *X, size_t offX, int incX, float beta,                 gpudata *Y, size_t offY, int incY) {  cl_ctx *ctx = A->ctx;  StatusCode err;  cl_event ev;  ARRAY_INIT(A);  ARRAY_INIT(X);  ARRAY_INIT(Y);  err = CLBlastSgemv(convO(order), convT(transA), M, N, alpha,                    A->buf, offA, lda, X->buf, offX, incX,                    beta, Y->buf, offY, incY, &ctx->q, &ev);  if (err != kSuccess)    return GA_BLAS_ERROR;  ARRAY_FINI(A);  ARRAY_FINI(X);  ARRAY_FINI(Y);  clReleaseEvent(ev);  return GA_NO_ERROR;}

static int ddot(        size_t N,        gpudata *X, size_t offX, size_t incX,        gpudata *Y, size_t offY, size_t incY,        gpudata *Z, size_t offZ) {  cl_ctx *ctx = X->ctx;  StatusCode err;  cl_event ev;  ARRAY_INIT(X);  ARRAY_INIT(Y);  ARRAY_INIT(Z);  err = CLBlastDdot(          N,          Z->buf, offZ,          X->buf, offX, incX,          Y->buf, offY, incY,          &ctx->q, &ev);  if (err != kSuccess)      return GA_BLAS_ERROR;  ARRAY_FINI(X);  ARRAY_FINI(Y);  ARRAY_FINI(Z);  clReleaseEvent(ev);  return GA_NO_ERROR;}

static int dgemm(cb_order order, cb_transpose transA, cb_transpose transB,                 size_t M, size_t N, size_t K, double alpha,                 gpudata *A, size_t offA, size_t lda,                 gpudata *B, size_t offB, size_t ldb, double beta,                 gpudata *C, size_t offC, size_t ldc) {  cl_ctx *ctx = A->ctx;  cl_event ev;  ARRAY_INIT(A);  ARRAY_INIT(B);  ARRAY_INIT(C);  CLBT_CHECK(ctx->err, CLBlastDgemm(convO(order), convT(transA), convT(transB),                                    M, N, K, alpha,                                    A->buf, offA, lda, B->buf, offB, ldb,                                    beta, C->buf, offC, ldc, &ctx->q, &ev));  ARRAY_FINI(A);  ARRAY_FINI(B);  ARRAY_FINI(C);  clReleaseEvent(ev);  return GA_NO_ERROR;}

ts_psip_context_t * ts_psip_context_New(){    ts_psip_context_t *p_ctx = malloc(sizeof(*p_ctx));    if(likely(p_ctx))    {        p_ctx->p_mgt = NULL;        p_ctx->p_stt = NULL;        p_ctx->p_vct = NULL;        p_ctx->p_a65 = NULL;        p_ctx->i_tabletype = 0;        ARRAY_INIT(p_ctx->etts);        ARRAY_INIT(p_ctx->eits);    }    return p_ctx;}

voidcmd_set_option_keys(struct cmd_ctx *ctx, struct options *oo,    const struct set_option_entry *entry, char *value){	struct options_entry	*o;	struct keylist		*keylist;	char			*copyvalue, *ptr, *str;	int		 	 key;	if (value == NULL) {		ctx->error(ctx, "empty value");		return;	}	keylist = xmalloc(sizeof *keylist);	ARRAY_INIT(keylist);	ptr = copyvalue = xstrdup(value);	while ((str = strsep(&ptr, ",")) != NULL) {		if ((key = key_string_lookup_string(str)) == KEYC_NONE) {			xfree(keylist);			ctx->error(ctx, "unknown key: %s", str);			xfree(copyvalue);			return;		}		ARRAY_ADD(keylist, key);	}	xfree(copyvalue);	o = options_set_data(oo, entry->name, keylist, xfree);	ctx->info(ctx,	    "set option: %s -> %s", o->name, cmd_set_option_print(entry, o));}

/* Set a keys option. */struct options_entry *cmd_set_option_keys(struct cmd *self, struct cmd_ctx *ctx,    const struct options_table_entry *oe, struct options *oo){	struct cmd_target_data	*data = self->data;	struct keylist		*keylist;	char			*copy, *ptr, *s;	int		 	 key;	keylist = xmalloc(sizeof *keylist);	ARRAY_INIT(keylist);	ptr = copy = xstrdup(data->arg2);	while ((s = strsep(&ptr, ",")) != NULL) {		if ((key = key_string_lookup_string(s)) == KEYC_NONE) {			ctx->error(ctx, "unknown key: %s", s);			xfree(copy);			xfree(keylist);			return (NULL);		}		ARRAY_ADD(keylist, key);	}	xfree(copy);	return (options_set_data(oo, oe->name, keylist, xfree));}

intmail_receive(struct mail *m, struct msg *msg, int destroy){	struct mail	*mm = &msg->data.mail;	mm->idx = m->idx;	mm->tags = m->tags;	m->tags = NULL;	mm->attach = m->attach;	m->attach = NULL;	mm->auxfree = m->auxfree;	m->auxfree = NULL;	mm->auxdata = m->auxdata;	m->auxdata = NULL;	if (destroy)		mail_destroy(m);	else		mail_close(m);	memcpy(m, mm, sizeof *m);	if ((m->base = shm_reopen(&m->shm)) == NULL)		return (-1);	SHM_REGISTER(&m->shm);	m->data = m->base + m->off;	ARRAY_INIT(&m->wrapped);	m->wrapchar = '/0';	return (0);}

/* Common initialisation state. */intimap_state_init(struct account *a, struct fetch_ctx *fctx){	struct fetch_imap_data	*data = a->data;	ARRAY_INIT(&data->dropped);	ARRAY_INIT(&data->kept);	ARRAY_INIT(&data->wanted);	data->tag = 0;	data->folder = 0;	data->folders_total = 0;	fctx->state = imap_state_connect;	return (FETCH_AGAIN);}

// Create a new interpreter state.HyVM * hy_new(void) {	VirtualMachine *vm = malloc(sizeof(VirtualMachine));	// Allocate memory for arrays	ARRAY_INIT(vm->functions, Function, 4);	ARRAY_INIT(vm->packages, Package, 4);	ARRAY_INIT(vm->numbers, double, 16);	ARRAY_INIT(vm->strings, char *, 16);	// Initialise the error	vm->error.description = NULL;	vm->error.line = 0;	vm->error.package = NULL;	vm->error.file = NULL;	return (HyVM *) vm;}

/* init the array (it will be NUM_STATES x NUM_TRANSITIONS), and then set the current	state to the start state */state_machine_t state_machine_init(){	state_machine_t state_machine = (struct state_machine*)malloc(sizeof(struct state_machine));	ARRAY_INIT(state_machine->transition_matrix, transitioning_t, NUM_STATES, NUM_TRANSITIONS, START_STATE);	state_machine->argument = NULL;	state_machine->current_state = START_STATE;	_state_machine_initialize(state_machine);		return state_machine;}

IRenderPass::IRenderPass():   _frameBufferObject(0),  flags(0),  blend_src(GL_SRC_ALPHA),  blend_trg(GL_ONE_MINUS_SRC_ALPHA),  _viewport{0,0,0,0},	_clearColor{0,0,0,0}{  ARRAY_INIT(_drawBuffers);}

quality_level_t * ql_New( void ){    quality_level_t *ql = calloc( 1, sizeof( quality_level_t ) );    if( unlikely( !ql ) ) return NULL;    ql->Index = -1;    ARRAY_INIT(ql->custom_attrs);    return ql;}

/** * Initialize event manager object * p_obj is the object that contains the event manager. But not * necessarily a vlc_object_t (an input_item_t is not a vlc_object_t * for instance). */void vlc_event_manager_init( vlc_event_manager_t * p_em, void * p_obj ){    p_em->p_obj = p_obj;    /* This is an unsafe work-around for a long-standing playlist bug.     * Do not rely on this. */    vlc_mutex_init_recursive( &p_em->lock );    for( size_t i = 0; i < ARRAY_SIZE(p_em->events); i++ )       ARRAY_INIT( p_em->events[i].listeners );}

voidmail_send(struct mail *m, struct msg *msg){	struct mail	*mm = &msg->data.mail;	memcpy(mm, m, sizeof *mm);	ARRAY_INIT(&mm->wrapped);	mm->wrapchar = '/0';	mm->attach = NULL;}

int main() {  array_t array = ARRAY_INIT(4);  array_resize(&array, 3);  if (array_bytes(&array) != 12)    return 1;  array_fail(&array);  if (array_bytes(&array) != 0)    return 2;  return 0;}

sms_stream_t * sms_New( void ){    sms_stream_t *sms = calloc( 1, sizeof( sms_stream_t ) );    if( unlikely( !sms ) ) return NULL;    ARRAY_INIT( sms->qlevels );    sms->type = UNKNOWN_ES;    vlc_mutex_init( &sms->chunks_lock );    return sms;}

int sv_stat(sv_stat_t *svst, char *path) {  array_t full_path = ARRAY_INIT(1);  int ok_fd;  struct stat st;  int status_fd;  int32_t tmp;    /* Check if 'down' exist indicating that the service isn't started when   * supervise starts up. */  if (array_path(&full_path, path, "down")) {    array_reset(&full_path);    errno = ENOMEM;    return -1;  }    if (stat(array_start(&full_path), &st) == -1) {    if (errno != ENOENT) {      array_reset(&full_path);      return ESVSTATDOWN;    }    svst->autostart = 1;  } else    svst->autostart = 0;      /* Attempt to open the supervise/ok fifo to see if supervise is actually   * running. */  if (array_path(&full_path, path, SUPERVISE_OK_PATH)) {    array_reset(&full_path);    errno = ENOMEM;    return -1;  }  ok_fd = open_write(array_start(&full_path));  if (ok_fd == -1) {    array_reset(&full_path);    if (errno == ENODEV)      return ESVNOTRUN;    return ESVOPENOK;  }  close(ok_fd);    /* Load the contents of the supervise/status file. */  if (array_path(&full_path, path, SUPERVISE_STATUS_PATH)) {    array_reset(&full_path);    errno = ENOMEM;    return -1;  }  if (sv_stat_load(svst, array_start(&full_path)) == -1) {    array_reset(&full_path);    return -1;  }    array_reset(&full_path);  return 0;}