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;
}
void
cmd_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));
}
int
mail_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. */
int
imap_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 );
}
void
mail_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;
}
