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) ; }