GrB_Info GxB_Vector_fprint // print and check a GrB_Vector
(
GrB_Vector v, // object to print and check
const char *name, // name of the object
GxB_Print_Level pr, // print level
FILE *f // file for output
)
{
//--------------------------------------------------------------------------
// check inputs
//--------------------------------------------------------------------------
GB_WHERE ("GxB_Vector_fprint (v, name, pr, f)") ;
//--------------------------------------------------------------------------
// print and check the object
//--------------------------------------------------------------------------
GrB_Info info = GB_Vector_check (v, name, pr, f, Context) ;
//--------------------------------------------------------------------------
// return result
//--------------------------------------------------------------------------
if (info == GrB_INDEX_OUT_OF_BOUNDS)
{
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"vector invalid: indices out of order [%s]", GB_NAME))) ;
}
else
{
return (info) ;
}
}
GrB_Info GB_Descriptor_check // check a GraphBLAS descriptor
(
const GrB_Descriptor D, // GraphBLAS descriptor to print and check
const char *name, // name of the descriptor, optional
int pr, // 0: print nothing, 1: print header and
// errors, 2: print brief, 3: print all
FILE *f, // file for output
GB_Context Context
)
{
//--------------------------------------------------------------------------
// check inputs
//--------------------------------------------------------------------------
if (pr > 0) GBPR ("\nGraphBLAS Descriptor: %s ", GB_NAME) ;
if (D == NULL)
{
// GrB_error status not modified since this may be an optional argument
if (pr > 0) GBPR ("NULL\n") ;
return (GrB_NULL_POINTER) ;
}
//--------------------------------------------------------------------------
// check object
//--------------------------------------------------------------------------
GB_CHECK_MAGIC (D, "Descriptor") ;
if (pr > 0) GBPR ("\n") ;
GrB_Info info [5] ;
info [0] = dcheck (true, "output ", D->out, GrB_REPLACE, pr,f,Context);
info [1] = dcheck (true, "mask ", D->mask, GrB_SCMP, pr,f,Context);
info [2] = dcheck (true, "input0 ", D->in0, GrB_TRAN, pr,f,Context);
info [3] = dcheck (true, "input1 ", D->in1, GrB_TRAN, pr,f,Context);
info [4] = dcheck (false, "AxB_method", D->axb, 0, pr,f,Context);
for (int i = 0 ; i < 5 ; i++)
{
if (info [i] != GrB_SUCCESS)
{
if (pr > 0) GBPR ("Descriptor field set to an invalid value\n") ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"Descriptor field set to an invalid value: [%s]", GB_NAME))) ;
}
}
return (GrB_SUCCESS) ;
}
GrB_Info GB_Mask_compatible // check type and dimensions of mask
(
const GrB_Matrix Mask, // mask to check
const GrB_Matrix C, // C<Mask>= ...
const GrB_Index nrows, // size of output if C is NULL (see GB*assign)
const GrB_Index ncols,
GB_Context Context
)
{
ASSERT (GB_ALIAS_OK (C, Mask)) ;
if (Mask != NULL)
{
// Mask is typecast to boolean
if (!GB_Type_compatible (Mask->type, GrB_BOOL))
{
return (GB_ERROR (GrB_DOMAIN_MISMATCH, (GB_LOG,
"Mask of type [%s] cannot be typecast to boolean",
Mask->type->name))) ;
}
// check the Mask dimensions
GrB_Index cnrows = (C == NULL) ? nrows : GB_NROWS (C) ;
GrB_Index cncols = (C == NULL) ? ncols : GB_NCOLS (C) ;
if (GB_NROWS (Mask) != cnrows || GB_NCOLS (Mask) != cncols)
{
return (GB_ERROR (GrB_DIMENSION_MISMATCH, (GB_LOG,
"Mask is "GBd"-by-"GBd"; "
"does not match output dimensions ("GBu"-by-"GBu")",
GB_NROWS (Mask), GB_NCOLS (Mask), cnrows, cncols))) ;
}
}
return (GrB_SUCCESS) ;
}
GrB_Info GxB_Global_Option_set // set a global default option
(
GxB_Option_Field field, // option to change
... // value to change it to
)
{
//--------------------------------------------------------------------------
// check inputs
//--------------------------------------------------------------------------
GB_WHERE ("GxB_Global_Option_set (field, value)") ;
//--------------------------------------------------------------------------
// set the global option
//--------------------------------------------------------------------------
va_list ap ;
switch (field)
{
case GxB_HYPER :
va_start (ap, field) ;
GB_Global.hyper_ratio = va_arg (ap, double) ;
va_end (ap) ;
break ;
case GxB_FORMAT :
va_start (ap, field) ;
GB_Global.is_csc = (va_arg (ap, GxB_Format_Value) != GxB_BY_ROW) ;
va_end (ap) ;
break ;
default :
return (GB_ERROR (GrB_INVALID_VALUE, (GB_LOG,
"invalid option field [%d], must be one of:\n"
"GxB_HYPER [%d] or GxB_FORMAT [%d]",
(int) field, (int) GxB_HYPER, (int) GxB_FORMAT))) ;
}
return (GrB_SUCCESS) ;
}
void* gb28181_msg_loop(void *session)
{
pSipSession s = (pSipSession)session;
GB_ASSERT(s,"sip_msg_loop null argument\n");
int re_cnt = 0;
char msg_buf[2048];
char *ptzcmd = NULL;
s->run_msg_loop = 1;//that's to say msg_loop is run now;
char *cmdtype = s->get_tagvalue(s->xml_str,"CmdType");
if( 0 == strcmp("DeviceInfo",cmdtype))
{
TRACE("Get a dev info request\n");
s->pack_msg(s,MSG_DEV_INFO,NULL);
}
else if(0 == strcmp("DeviceStatus",cmdtype))
{
TRACE("Get a devicestatus request\n");
s->pack_msg(s,MSG_DEV_STATUS,NULL);
}
else if(0 == strcmp("Alarm",cmdtype))
{
s->pack_msg(s,MSG_200,NULL);
sendto(s->sock,s->sendbuf,strlen(s->sendbuf),\
0,(struct sockaddr*)&s->server,sizeof(s->server));
goto exit_msg_loop;
}
else if (0 == strcmp("DeviceControl",cmdtype))
{
if(0 == s->get_subcmd(s,s->xml_str,"RecordCmd","Record"))
{
s->pack_msg(s,MSG_DEV_CTRL,NULL);
s->dev_ctrl(SIP_DEV_CTRL_RECORD_START,NULL);
}
else if(0 == s->get_subcmd(s,s->xml_str,"RecordCmd","StopRecord"))
{
s->pack_msg(s,MSG_DEV_CTRL,NULL);
s->dev_ctrl(SIP_DEV_CTRL_RECORD_STOP,NULL);
}
else if(0 == s->get_subcmd(s,s->xml_str,"GuardCmd","SetGuard"))
{
s->pack_msg(s,MSG_DEV_CTRL,NULL);
s->dev_ctrl(SIP_DEV_CTRL_GUARD_SET,NULL);
}
else if(0 == s->get_subcmd(s,s->xml_str,"GuardCmd","ResetGuard"))
{
s->pack_msg(s,MSG_DEV_CTRL,NULL);
s->dev_ctrl(SIP_DEV_CTRL_GUARD_RESET,NULL);
}
else if(0 == s->get_subcmd(s,s->xml_str,"AlarmCmd","ResetAlarm"))
{
s->pack_msg(s,MSG_DEV_CTRL,NULL);
char *method = s->get_tagvalue(s->xml_str,"AlarmMethod");
s->dev_ctrl(SIP_DEV_CTRL_ALARM_RESET,method);
}
else if(NULL != (ptzcmd = s->get_tagvalue(s->xml_str,"PTZCmd")))
{
s->ptz_cmd_parse(s,ptzcmd);
s->pack_msg(s,MSG_200,NULL);
sendto(s->sock,s->sendbuf,strlen(s->sendbuf),\
0,(struct sockaddr*)&s->server,sizeof(s->server));
goto exit_msg_loop;
}
else if(0 == s->get_subcmd(s,s->xml_str,"TeleBoot","Boot"))
{
//login out the sipserver first
s->pack_msg(s,MSG_200,NULL);
sprintf(msg_buf,"%s",s->sendbuf);
s->dev_ctrl(SIP_DEV_CTRL_TELEBOOT,NULL);
GB_NOTIFY("Loginout ing...\n ");
s->auth(s,0); //FIXME this func need 2 do in dev_ctrl later
sendto(s->sock,msg_buf,strlen(msg_buf),\
0,(struct sockaddr*)&s->server,sizeof(s->server));
sleep(1);
GB_NOTIFY("Login ing...\n ");
s->auth(s,1);
goto exit_msg_loop;
}
}
else if( 0 == strcmp("Catalog",cmdtype))
{
TRACE("Recv a Catalog msg\n");
s->pack_msg(s,MSG_CATALOG,NULL);
}
sprintf(msg_buf,"%s",s->sendbuf);
TRACE("\033[31mSIP PACK MSG:%s\n\033[0m",s->sendbuf);
time_t cur_time = time(NULL) - 4;
for(;;)
{
if(time(NULL)- cur_time > 3){//response a msg
sendto(s->sock,msg_buf,strlen(msg_buf),\
0,(struct sockaddr*)&s->server,sizeof(s->server));
cur_time = time(NULL);
if(++re_cnt >= 3)break;
}
usleep(1);
if(0 == s->run_msg_loop)break;
}
exit_msg_loop:
GB_ERROR("Exit the msg loop\n");
if(NULL != s->xml_str)
{
free(s->xml_str);
s->xml_str = NULL;
}
return NULL;
}
GrB_Info GxB_Matrix_Option_get // gets the current option of a matrix
(
GrB_Matrix A, // matrix to query
GxB_Option_Field field, // option to query
... // return value of the matrix option
)
{
//--------------------------------------------------------------------------
// check inputs
//--------------------------------------------------------------------------
GB_WHERE ("GxB_Matrix_Option_get (A, field, &value)") ;
GB_RETURN_IF_NULL_OR_FAULTY (A) ;
ASSERT_OK (GB_check (A, "A to get option", GB0)) ;
//--------------------------------------------------------------------------
// get the option
//--------------------------------------------------------------------------
va_list ap ;
double *hyper_ratio, hyper ;
GxB_Format_Value *format ;
bool is_csc ;
hyper = A->hyper_ratio ;
is_csc = A->is_csc ;
switch (field)
{
case GxB_HYPER :
va_start (ap, field) ;
hyper_ratio = va_arg (ap, double *) ;
va_end (ap) ;
GB_RETURN_IF_NULL (hyper_ratio) ;
(*hyper_ratio) = hyper ;
break ;
case GxB_FORMAT :
va_start (ap, field) ;
format = va_arg (ap, GxB_Format_Value *) ;
va_end (ap) ;
GB_RETURN_IF_NULL (format) ;
(*format) = (is_csc) ? GxB_BY_COL : GxB_BY_ROW ;
break ;
default :
return (GB_ERROR (GrB_INVALID_VALUE, (GB_LOG,
"invalid option field [%d], must be one of:\n"
"GxB_HYPER [%d] or GxB_FORMAT [%d]",
(int) field, (int) GxB_HYPER, (int) GxB_FORMAT))) ;
}
return (GrB_SUCCESS) ;
}
GrB_Info GB_matvec_check // check a GraphBLAS matrix or vector
(
const GrB_Matrix A, // GraphBLAS matrix to print and check
const char *name, // name of the matrix, optional
int pr, // 0: print nothing, 1: print header and errors,
// 2: print brief, 3: print all
// if negative, ignore queue conditions
// and use GB_FLIP(pr) for diagnostic printing.
FILE *f, // file for output
const char *kind, // "matrix" or "vector"
GB_Context Context
)
{
//--------------------------------------------------------------------------
// check inputs
//--------------------------------------------------------------------------
bool ignore_queue = false ;
if (pr < 0)
{
// -2: print nothing (pr = 0)
// -3: print header (pr = 1)
// -4: print brief (pr = 2)
// -5: print all (pr = 3)
pr = GB_FLIP (pr) ;
ignore_queue = true ;
}
if (pr > 0) GBPR ("\nGraphBLAS %s: %s ", kind, GB_NAME) ;
if (A == NULL)
{
// GrB_error status not modified since this may be an optional argument
if (pr > 0) GBPR ("NULL\n") ;
return (GrB_NULL_POINTER) ;
}
//--------------------------------------------------------------------------
// check the object
//--------------------------------------------------------------------------
GB_CHECK_MAGIC (A, kind) ;
ASSERT (A->magic == GB_MAGIC) ; // A is now a valid initialized object
if (pr > 0)
{
GBPR ("\nnrows: "GBd" ncols: "GBd" max # entries: "GBd"\n",
GB_NROWS (A), GB_NCOLS (A), A->nzmax) ;
GBPR ("format: %s %s",
A->is_hyper ? "hypersparse" : "standard",
A->is_csc ? "CSC" : "CSR") ;
GBPR (" vlen: "GBd" nvec_nonempty: "GBd" nvec: "GBd" plen: "
GBd " vdim: "GBd"\n",
A->vlen, A->nvec_nonempty, A->nvec, A->plen, A->vdim) ;
GBPR ("hyper_ratio %g\n", A->hyper_ratio) ;
}
if (A->vlen < 0 || A->vlen > GB_INDEX_MAX ||
A->vdim < 0 || A->vdim > GB_INDEX_MAX ||
A->nzmax < 0 || A->nzmax > GB_INDEX_MAX)
{
if (pr > 0) GBPR ("invalid %s dimensions\n", kind) ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"%s invalid : nrows, ncols, or nzmax out of range: [%s]",
kind, GB_NAME))) ;
}
if (A->is_hyper)
{
if (! (A->nvec >= 0 && A->nvec <= A->plen && A->plen <= A->vdim &&
A->nvec == A->nvec_nonempty))
{
if (pr > 0) GBPR ("invalid %s hypersparse structure\n", kind) ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"%s invalid hypersparse structure [%s]", kind, GB_NAME))) ;
}
}
else
{
if (! (A->nvec == A->plen && A->plen == A->vdim))
{
if (pr > 0) GBPR ("invalid %s standard structure\n", kind) ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"%s invalid structure [%s]", kind, GB_NAME))) ;
}
}
// a matrix contains 1 to 8 different malloc'd blocks
int64_t nallocs = 1 + // header
(A->h != NULL && !A->h_shallow) + // A->h, if not shallow
(A->p != NULL && !A->p_shallow) + // A->p, if not shallow
(A->i != NULL && !A->i_shallow) + // A->i, if not shallow
(A->x != NULL && !A->x_shallow) + // A->x, if not shallow
(A->i_pending != NULL) + // A->i_pending if tuples
(A->j_pending != NULL) + // A->j_pending if tuples
(A->s_pending != NULL) ; // A->s_pending if tuples
#ifdef GB_DEVELOPER
if (pr > 1) GBPR ("A %p magic "GBd"\n", A, A->magic) ;
if (pr > 1) GBPR ("number of memory blocks: "GBd"\n", nallocs) ;
#endif
GrB_Info info = GB_Type_check (A->type, "", pr, f, Context) ;
if (info != GrB_SUCCESS || (A->type->size != A->type_size))
{
if (pr > 0) GBPR ("%s has an invalid type\n", kind) ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"%s has an invalid type: [%s]", kind, GB_NAME))) ;
}
if (A->Sauna != NULL)
{
if (pr > 1) GBPR ("Sauna: n: "GBd" entry size: %zu\n",
A->Sauna->Sauna_n, A->Sauna->Sauna_size) ;
}
if (pr > 1 && A->AxB_method_used != GxB_DEFAULT)
{
GBPR ("last method used for GrB_mxm, vxm, or mxv: ") ;
switch (A->AxB_method_used)
{
case GxB_AxB_GUSTAVSON : GBPR ("Gustavson") ; break ;
case GxB_AxB_HEAP : GBPR ("heap") ; break ;
case GxB_AxB_DOT : GBPR ("dot") ; break ;
default: ;
}
GBPR ("\n") ;
}
#ifdef GB_DEVELOPER
if (pr > 1) GBPR ("->h: %p shallow: %d\n", A->h, A->h_shallow) ;
if (pr > 1) GBPR ("->p: %p shallow: %d\n", A->p, A->p_shallow) ;
if (pr > 1) GBPR ("->i: %p shallow: %d\n", A->i, A->i_shallow) ;
if (pr > 1) GBPR ("->x: %p shallow: %d\n", A->x, A->x_shallow) ;
#endif
if (A->p == NULL)
{
if (pr > 0) GBPR ("->p is NULL, invalid %s\n", kind) ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"%s contains a NULL A->p pointer: [%s]", kind, GB_NAME))) ;
}
if (A->is_hyper)
{
if (A->h == NULL)
{
if (pr > 0) GBPR ("->h is NULL, invalid hypersparse %s\n",
kind) ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"hypersparse %s contains a NULL A->h pointer: [%s]",
kind, GB_NAME))) ;
}
}
else
{
if (A->h != NULL)
{
if (pr > 0) GBPR ("->h is not NULL, invalid non-hypersparse %s\n",
kind) ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"non-hypersparse %s contains a non-NULL A->h pointer: [%s]",
kind, GB_NAME))) ;
}
}
bool A_empty = (A->nzmax == 0) ;
if (A_empty)
{
// A->x and A->i pointers must be NULL and shallow must be false
if (A->i != NULL || A->i_shallow || A->x_shallow)
{
if (pr > 0) GBPR ("invalid empty %s\n", kind) ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"%s is an invalid empty object: [%s]", kind, GB_NAME))) ;
}
// check the vector pointers
for (int64_t j = 0 ; j <= A->nvec ; j++)
{
if (A->p [j] != 0)
{
if (pr > 0) GBPR ("->p ["GBd"] = "GBd" invalid\n", j,A->p[j]);
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"%s ->p ["GBd"] = "GBd" invalid: [%s]",
kind, j, A->p[j], GB_NAME))) ;
}
}
if (pr > 0) GBPR ("empty\n") ;
}
if (!A_empty && A->i == NULL)
{
if (pr > 0) GBPR ("->i is NULL, invalid %s\n", kind) ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"%s contains a NULL A->i pointer: [%s]", kind, GB_NAME))) ;
}
//--------------------------------------------------------------------------
// check the vector pointers
//--------------------------------------------------------------------------
if (A->p [0] != 0)
{
if (pr > 0) GBPR ("->p [0] = "GBd" invalid\n", A->p [0]) ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"%s A->p [0] = "GBd" invalid: [%s]", kind, A->p [0], GB_NAME))) ;
}
for (int64_t j = 0 ; j < A->nvec ; j++)
{
if (A->p [j+1] < A->p [j] || A->p [j+1] > A->nzmax)
{
if (pr > 0) GBPR ("->p ["GBd"] = "GBd" invalid\n",
j+1, A->p [j+1]) ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"%s A->p ["GBd"] = "GBd" invalid: [%s]",
kind, j+1, A->p [j+1], GB_NAME))) ;
}
}
if (A->is_hyper)
{
int64_t jlast = -1 ;
for (int64_t k = 0 ; k < A->nvec ; k++)
{
int64_t j = A->h [k] ;
if (jlast >= j || j < 0 || j >= A->vdim)
{
if (pr > 0) GBPR ("->h ["GBd"] = "GBd" invalid\n",
k, A->h [k]) ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"%s A->h ["GBd"] = "GBd" invalid: [%s]",
kind, k, A->h [k], GB_NAME))) ;
}
jlast = j ;
}
}
int64_t anz = GB_NNZ (A) ;
if (pr > 0) GBPR ("number of entries: "GBd" ", anz) ;
if (pr > 0) GBPR ("\n") ;
//--------------------------------------------------------------------------
// report the number of pending tuples and number of zombies
//--------------------------------------------------------------------------
if (A->n_pending != 0 || A->nzombies != 0)
{
if (pr > 0) GBPR ("pending tuples: "GBd" max pending: "GBd
" zombies: "GBd"\n", A->n_pending, A->max_n_pending, A->nzombies) ;
}
if (A->nzombies < 0 || A->nzombies > anz)
{
if (pr > 0) GBPR ("invalid number of zombies: "GBd" "
"must be >= 0 and <= # entries ("GBd")\n", A->nzombies, anz) ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"%s invalid number of zombies: "GBd"\n"
"must be >= 0 and <= # entries ("GBd") [%s]",
kind, A->nzombies, anz, GB_NAME))) ;
}
//--------------------------------------------------------------------------
// check and print the row indices and numerical values
//--------------------------------------------------------------------------
#define GB_NBRIEF 10
#define GB_NZBRIEF 30
bool jumbled = false ;
int64_t nzombies = 0 ;
int64_t jcount = 0 ;
GB_for_each_vector (A)
{
int64_t ilast = -1 ;
GB_for_each_entry (j, p, pend)
{
bool prcol = ((pr > 1 && jcount < GB_NBRIEF) || pr > 2) ;
if (ilast == -1)
{
// print the header for vector j
if (prcol)
{
GBPR ("%s: "GBd" : "GBd" entries ["GBd":"GBd"]\n",
A->is_csc ? "column" : "row", j, pend - p, p, pend-1) ;
}
else if (pr == 2 && jcount == GB_NBRIEF)
{
GBPR ("...\n") ;
}
jcount++ ; // count # of vectors printed so far
}
int64_t i = A->i [p] ;
bool is_zombie = GB_IS_ZOMBIE (i) ;
i = GB_UNFLIP (i) ;
if (is_zombie) nzombies++ ;
if (prcol)
{
if ((pr > 1 && p < GB_NZBRIEF) || pr > 2)
{
GBPR (" %s "GBd": ", A->is_csc ? "row" : "column", i) ;
}
else if (pr == 2 && (ilast == -1 || p == GB_NZBRIEF))
{
GBPR (" ...\n") ;
}
}
int64_t row = A->is_csc ? i : j ;
int64_t col = A->is_csc ? j : i ;
if (i < 0 || i >= A->vlen)
{
if (pr > 0) GBPR ("index ("GBd","GBd") out of range\n",
row, col) ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"%s index ("GBd","GBd") out of range: [%s]",
kind, row, col, GB_NAME))) ;
}
// print the value
bool print_value = prcol && ((pr > 1 && p < GB_NZBRIEF) || pr > 2) ;
if (print_value)
{
if (is_zombie)
{
GBPR ("zombie") ;
}
else if (A->x != NULL)
{
GB_void *Ax = A->x ;
info = GB_entry_check (A->type,
Ax +(p * (A->type->size)), f, Context) ;
if (info != GrB_SUCCESS) return (info) ;
}
}
if (i <= ilast)
{
// indices unsorted, or duplicates present
if (pr > 0) GBPR (" index ("GBd","GBd") jumbled", row, col) ;
jumbled = true ;
print_value = (pr > 0) ;
}
if (print_value)
{
GBPR ("\n") ;
}
ilast = i ;
}
}
GrB_Info GB_Monoid_check // check a GraphBLAS monoid
(
const GrB_Monoid monoid, // GraphBLAS monoid to print and check
const char *name, // name of the monoid, optional
int pr, // 0: print nothing, 1: print header and errors,
// 2: print brief, 3: print all
FILE *f, // file for output
GB_Context Context
)
{
//--------------------------------------------------------------------------
// check inputs
//--------------------------------------------------------------------------
if (pr > 0) GBPR ("\nGraphBLAS Monoid: %s ", GB_NAME) ;
if (monoid == NULL)
{
// GrB_error status not modified since this may be an optional argument
if (pr > 0) GBPR ("NULL\n") ;
return (GrB_NULL_POINTER) ;
}
//--------------------------------------------------------------------------
// check object
//--------------------------------------------------------------------------
GB_CHECK_MAGIC (monoid, "Monoid") ;
switch (monoid->object_kind)
{
case GB_BUILTIN:
if (pr > 0) GBPR ("(built-in)") ;
break ;
case GB_USER_COMPILED:
if (pr > 0) GBPR ("(user-defined at compile-time)") ;
break ;
case GB_USER_RUNTIME:
if (pr > 0) GBPR ("(user-defined at run-time)") ;
break ;
default:
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"Monoid->object_kind is invalid: [%s]", GB_NAME))) ;
}
GrB_Info info = GB_BinaryOp_check (monoid->op, "monoid->op", pr, f,
Context) ;
if (info != GrB_SUCCESS)
{
if (pr > 0) GBPR ("Monoid contains an invalid operator\n") ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"Monoid contains an invalid operator: [%s]", GB_NAME))) ;
}
if (monoid->op->xtype != monoid->op->ztype ||
monoid->op->ytype != monoid->op->ztype)
{
if (pr > 0) GBPR ("All domains of operator must be the same\n") ;
return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG,
"All domains of monoid operator must be the same: [%s]",
GB_NAME))) ;
}
// print the identity value
if (pr > 0)
{
GBPR ("identity: [ ") ;
info = GB_entry_check (monoid->op->ztype, monoid->identity, f,
Context) ;
if (info != GrB_SUCCESS) return (info) ;
GBPR (" ]\n") ;
}
return (GrB_SUCCESS) ;
}
GrB_Info GB_user_build // check inputs then build matrix
(
GrB_Matrix C, // matrix to build
const GrB_Index *I, // row indices of tuples
const GrB_Index *J, // col indices of tuples
const void *S, // array of values of tuples
const GrB_Index nvals, // number of tuples
const GrB_BinaryOp dup, // binary function to assemble duplicates
const GB_Type_code scode, // GB_Type_code of S array
const bool is_matrix, // true if C is a matrix, false if GrB_Vector
GB_Context Context
)
{
//--------------------------------------------------------------------------
// check inputs
//--------------------------------------------------------------------------
ASSERT_OK (GB_check (C, "C for GB_user_build", GB0)) ;
GB_RETURN_IF_NULL (I) ;
if (I == GrB_ALL)
{
return (GB_ERROR (GrB_INVALID_VALUE, (GB_LOG,
"List of row indices cannot be GrB_ALL"))) ;
}
if (nvals == GxB_RANGE || nvals == GxB_STRIDE || nvals == GxB_BACKWARDS)
{
return (GB_ERROR (GrB_INVALID_VALUE, (GB_LOG,
"nvals cannot be GxB_RANGE, GxB_STRIDE, or GxB_BACKWARDS"))) ;
}
if (is_matrix)
{
GB_RETURN_IF_NULL (J) ;
if (J == GrB_ALL)
{
return (GB_ERROR (GrB_INVALID_VALUE, (GB_LOG,
"List of column indices cannot be 'GrB_ALL'"))) ;
}
}
else
{
// only GrB_Vector_build calls this function with J == NULL
ASSERT (J == NULL) ;
}
GB_RETURN_IF_NULL (S) ;
GB_RETURN_IF_NULL_OR_FAULTY (dup) ;
ASSERT_OK (GB_check (dup, "dup operator for assembling duplicates", GB0)) ;
ASSERT (scode <= GB_UDT_code) ;
if (nvals > GB_INDEX_MAX)
{
// problem too large
return (GB_ERROR (GrB_INVALID_VALUE, (GB_LOG,
"problem too large: nvals "GBu" exceeds "GBu,
nvals, GB_INDEX_MAX))) ;
}
// check types of dup
if (dup->xtype != dup->ztype || dup->ytype != dup->ztype)
{
// all 3 types of z = dup (x,y) must be the same. dup must also be
// associative but there is no way to check this in general.
return (GB_ERROR (GrB_DOMAIN_MISMATCH, (GB_LOG, "All domains of dup "
"operator for assembling duplicates must be identical.\n"
"operator is: [%s] = %s ([%s],[%s])",
dup->ztype->name, dup->name, dup->xtype->name, dup->ytype->name))) ;
}
if (!GB_Type_compatible (C->type, dup->ztype))
{
// the type of C and dup must be compatible
return (GB_ERROR (GrB_DOMAIN_MISMATCH, (GB_LOG,
"operator dup [%s] has type [%s]\n"
"cannot be typecast to entries in output of type [%s]",
dup->name, dup->ztype->name, C->type->name))) ;
}
// C and S must be compatible
if (!GB_code_compatible (scode, dup->ztype->code))
{
// All types must be compatible with each other: C, dup, and S.
// User-defined types are only compatible with themselves; they are not
// compatible with any built-in type nor any other user-defined type.
// Thus, if C, dup, or S have any user-defined type, this
// condition requires all three types to be identical: the same
// user-defined type. No casting will be done in this case.
return (GB_ERROR (GrB_DOMAIN_MISMATCH, (GB_LOG,
"numerical values of tuples of type [%s]\n"
"cannot be typecast as input to the dup operator\n"
"z=%s(x,y), whose input types are [%s]",
GB_code_string (scode), dup->name, dup->ztype->name))) ;
}
if (!GB_EMPTY (C))
{
// The matrix has existing entries. This is required by the GraphBLAS
// API specification to generate an error, so the test is made here.
// However, any existing content is safely freed immediately below, so
// this test is not required, except to conform to the spec. Zombies
// are excluded from this test.
return (GB_ERROR (GrB_OUTPUT_NOT_EMPTY, (GB_LOG,
"output already has existing entries"))) ;
}
//--------------------------------------------------------------------------
// build the matrix
//--------------------------------------------------------------------------
return (GB_build (C, I, J, S, nvals, dup, scode, is_matrix, true, Context));
}
GrB_Info GxB_Global_Option_get // gets the current global option
(
GxB_Option_Field field, // option to query
... // return value of the global option
)
{
//--------------------------------------------------------------------------
// check inputs
//--------------------------------------------------------------------------
GB_WHERE ("GxB_Global_Option_get (field, &value)") ;
//--------------------------------------------------------------------------
// get the option
//--------------------------------------------------------------------------
va_list ap ;
switch (field)
{
//----------------------------------------------------------------------
// hyper_ratio
//----------------------------------------------------------------------
case GxB_HYPER :
va_start (ap, field) ;
double *hyper_ratio = va_arg (ap, double *) ;
va_end (ap) ;
GB_RETURN_IF_NULL (hyper_ratio) ;
(*hyper_ratio) = GB_Global.hyper_ratio ;
break ;
//----------------------------------------------------------------------
// matrix format (CSR or CSC)
//----------------------------------------------------------------------
case GxB_FORMAT :
va_start (ap, field) ;
GxB_Format_Value *format = va_arg (ap, GxB_Format_Value *) ;
va_end (ap) ;
GB_RETURN_IF_NULL (format) ;
(*format) = (GB_Global.is_csc) ? GxB_BY_COL : GxB_BY_ROW ;
break ;
//----------------------------------------------------------------------
// mode from GrB_init (blocking or non-blocking)
//----------------------------------------------------------------------
case GxB_MODE :
va_start (ap, field) ;
GrB_Mode *mode = va_arg (ap, GrB_Mode *) ;
va_end (ap) ;
GB_RETURN_IF_NULL (mode) ;
(*mode) = GB_Global.mode ;
break ;
//----------------------------------------------------------------------
// threading model for synchronizing user threads
//----------------------------------------------------------------------
case GxB_THREAD_SAFETY :
va_start (ap, field) ;
GxB_Thread_Model *thread_safety = va_arg (ap, GxB_Thread_Model *) ;
va_end (ap) ;
GB_RETURN_IF_NULL (thread_safety) ;
(*thread_safety) =
#if defined (USER_POSIX_THREADS)
GxB_THREAD_POSIX ;
#elif defined (USER_WINDOWS_THREADS)
GxB_THREAD_WINDOWS ; // Windows threads not yet supported
#elif defined (USER_ANSI_THREADS)
GxB_THREAD_ANSI ; // ANSI C11 threads not yet supported
#elif defined (_OPENMP) || defined (USER_OPENMP_THREADS)
GxB_THREAD_OPENMP ;
#else
GxB_THREAD_NONE ; // GraphBLAS is not thread safe!
#endif
break ;
//----------------------------------------------------------------------
// internal parallel threading in GraphBLAS (currently none)
//----------------------------------------------------------------------
case GxB_THREADING :
va_start (ap, field) ;
GxB_Thread_Model *threading = va_arg (ap, GxB_Thread_Model *) ;
va_end (ap) ;
GB_RETURN_IF_NULL (threading) ;
(*threading) = GxB_THREAD_NONE ;
break ;
//----------------------------------------------------------------------
// invalid option
//----------------------------------------------------------------------
default :
return (GB_ERROR (GrB_INVALID_VALUE, (GB_LOG,
"invalid option field [%d], must be one of:\n"
"GxB_HYPER [%d], GxB_FORMAT [%d], GxB_MODE [%d],"
"GxB_THREAD_SAFETY [%d], or GxB_THREADING [%d]",
(int) field, (int) GxB_HYPER, (int) GxB_FORMAT,
(int) GxB_MODE, (int) GxB_THREAD_SAFETY,
(int) GxB_THREADING))) ;
}
return (GrB_SUCCESS) ;
}
