static int packed_read_raw_ref(struct ref_store *ref_store, const char *refname, struct object_id *oid, struct strbuf *referent, unsigned int *type) { struct packed_ref_store *refs = packed_downcast(ref_store, REF_STORE_READ, "read_raw_ref"); struct snapshot *snapshot = get_snapshot(refs); const char *rec; *type = 0; rec = find_reference_location(snapshot, refname, 1); if (!rec) { /* refname is not a packed reference. */ errno = ENOENT; return -1; } if (get_oid_hex(rec, oid)) die_invalid_line(refs->path, rec, snapshot->eof - rec); *type = REF_ISPACKED; return 0; }
ENTRYPOINT void init_antspotlight(ModeInfo *mi) { double rot_speed = 0.3; antspotlightstruct *mp; if(!antspotlight) { if((antspotlight = (antspotlightstruct *) calloc(MI_NUM_SCREENS(mi), sizeof (antspotlightstruct))) == NULL) return; } mp = &antspotlight[MI_SCREEN(mi)]; mp->rot = make_rotator (rot_speed, rot_speed, rot_speed, 1, 0, True); mp->trackball = gltrackball_init (); if((mp->glx_context = init_GL(mi)) != NULL) { reshape_antspotlight(mi, MI_WIDTH(mi), MI_HEIGHT(mi)); glDrawBuffer(GL_BACK); pinit(); } else MI_CLEARWINDOW(mi); glGenTextures(1, &mp->screentexture); glBindTexture(GL_TEXTURE_2D, mp->screentexture); get_snapshot(mi); build_ant(mp); mp->mono = MI_IS_MONO(mi); mp->wire = MI_IS_WIREFRAME(mi); mp->boardsize = 8.0; mp->mag = 1; }
int backtrace_snapshot(int pid, int *tids, int *index, int nr_tids) { int i, rc = 0; struct snapshot *snap; if ((snap = get_snapshot(pid, tids, index, nr_tids)) == NULL) return -1; for (i = 0; i < snap->num_threads; ++i) { int x; char comm[16]; char end_pad[25] = "------------------------"; x = get_thread_comm(snap->tids[i], comm, sizeof(comm)); if (x > 0 && x <= sizeof(end_pad)) { end_pad[sizeof(end_pad) - x] = '\0'; printf("-------------- thread %d (%d) (%s) %s\n", (index != NULL ? index[i] : i+1), snap->tids[i], comm, end_pad); } snap->cur_thr = i; if (backtrace_thread(&snapshot_addr_space_accessors, snap) < 0) rc = -1; } snapshot_destroy(snap); return rc; }
int main(int argc, char *argv[]) { int ii; int jj; #define TXN_COUNT 10000 #define LOOP_COUNT 10 GlobalTransactionId gxid[TXN_COUNT]; GTM_Conn *conn; char connect_string[100]; sprintf(connect_string, "host=localhost port=6666 node_name=one remote_type=%d", GTM_NODE_COORDINATOR); conn = PQconnectGTM(connect_string); if (conn == NULL) { client_log(("Error in connection\n")); exit(1); } for (jj = 0; jj < LOOP_COUNT; jj++) { for (ii = 0; ii < TXN_COUNT; ii++) { int kk; GTM_Snapshot snapshot; gxid[ii] = begin_transaction(conn, GTM_ISOLATION_RC); if (gxid[ii] != InvalidGlobalTransactionId) client_log(("Started a new transaction (GXID:%u)\n", gxid[ii])); else client_log(("BEGIN transaction failed for ii=%d\n", ii)); snapshot = get_snapshot(conn, gxid[ii], true); if (ii % 2 == 0) { if (!abort_transaction(conn, gxid[ii])) client_log(("ROLLBACK successful (GXID:%u)\n", gxid[ii])); else client_log(("ROLLBACK failed (GXID:%u)\n", gxid[ii])); } else { if (!commit_transaction(conn, gxid[ii])) client_log(("COMMIT successful (GXID:%u)\n", gxid[ii])); else client_log(("COMMIT failed (GXID:%u)\n", gxid[ii])); } } } GTMPQfinish(conn); return 0; }
GTM_Snapshot GetSnapshotGTM(GlobalTransactionId gxid, bool canbe_grouped) { GTM_Snapshot ret_snapshot = NULL; CheckConnection(); if (conn) ret_snapshot = get_snapshot(conn, gxid, canbe_grouped); if (ret_snapshot == NULL) { CloseGTM(); InitGTM(); #ifdef XCP if (conn) ret_snapshot = get_snapshot(conn, gxid, canbe_grouped); #endif } return ret_snapshot; }
//replaces current state with a copy of snapshot entry* checkout(int id, entry *entryHead, snapshot *snapHead) { snapshot *chosenSnap = get_snapshot(snapHead, id); if (chosenSnap == NULL) { printf("no such snapshot\n"); return entryHead; } printf("ok\n"); free_entrylist_space(entryHead); return get_reversed_entrylist_copy(chosenSnap->entries); }
//removes a snapshot with the given id from the list snapshot* drop(snapshot *snapHead, int id) { snapshot *unwantedSnap = get_snapshot(snapHead, id); if (unwantedSnap == NULL) { printf("no such snapshot\n"); return snapHead; } else { printf("ok\n"); return snapshot_delete(snapHead, unwantedSnap); } }
QVariant vogleditor_apiCallTreeItem::columnData(int column, int role) const { if (column >= VOGL_MAX_ACTC) { return QVariant(); } if (role == Qt::DecorationRole) { // handle flags if (column == VOGL_ACTC_FLAGS) { if (has_snapshot()) { if (get_snapshot()->is_outdated()) { // snapshot was dirtied due to an earlier edit return QColor(200, 0, 0); } else if (get_snapshot()->is_edited()) { // snapshot has been edited return QColor(200, 102, 0); } else { // snapshot is good return QColor(0, 0, 255); } } } } if (role == Qt::DisplayRole) { return m_columnData[column]; } return QVariant(); }
static struct ref_iterator *packed_ref_iterator_begin( struct ref_store *ref_store, const char *prefix, unsigned int flags) { struct packed_ref_store *refs; struct snapshot *snapshot; const char *start; struct packed_ref_iterator *iter; struct ref_iterator *ref_iterator; unsigned int required_flags = REF_STORE_READ; if (!(flags & DO_FOR_EACH_INCLUDE_BROKEN)) required_flags |= REF_STORE_ODB; refs = packed_downcast(ref_store, required_flags, "ref_iterator_begin"); /* * Note that `get_snapshot()` internally checks whether the * snapshot is up to date with what is on disk, and re-reads * it if not. */ snapshot = get_snapshot(refs); if (!snapshot->buf) return empty_ref_iterator_begin(); iter = xcalloc(1, sizeof(*iter)); ref_iterator = &iter->base; base_ref_iterator_init(ref_iterator, &packed_ref_iterator_vtable, 1); iter->snapshot = snapshot; acquire_snapshot(snapshot); if (prefix && *prefix) start = find_reference_location(snapshot, prefix, 0); else start = snapshot->buf + snapshot->header_len; iter->pos = start; iter->eof = snapshot->eof; strbuf_init(&iter->refname_buf, 0); iter->base.oid = &iter->oid; iter->flags = flags; if (prefix && *prefix) /* Stop iteration after we've gone *past* prefix: */ ref_iterator = prefix_ref_iterator_begin(ref_iterator, prefix, 0); return ref_iterator; }
int packed_refs_lock(struct ref_store *ref_store, int flags, struct strbuf *err) { struct packed_ref_store *refs = packed_downcast(ref_store, REF_STORE_WRITE | REF_STORE_MAIN, "packed_refs_lock"); static int timeout_configured = 0; static int timeout_value = 1000; if (!timeout_configured) { git_config_get_int("core.packedrefstimeout", &timeout_value); timeout_configured = 1; } /* * Note that we close the lockfile immediately because we * don't write new content to it, but rather to a separate * tempfile. */ if (hold_lock_file_for_update_timeout( &refs->lock, refs->path, flags, timeout_value) < 0) { unable_to_lock_message(refs->path, errno, err); return -1; } if (close_lock_file_gently(&refs->lock)) { strbuf_addf(err, "unable to close %s: %s", refs->path, strerror(errno)); rollback_lock_file(&refs->lock); return -1; } /* * Now that we hold the `packed-refs` lock, make sure that our * snapshot matches the current version of the file. Normally * `get_snapshot()` does that for us, but that function * assumes that when the file is locked, any existing snapshot * is still valid. We've just locked the file, but it might * have changed the moment *before* we locked it. */ validate_snapshot(refs); /* * Now make sure that the packed-refs file as it exists in the * locked state is loaded into the snapshot: */ get_snapshot(refs); return 0; }
//removes all snapshots from the list that were taken after the one with the given id snapshot* remove_snapshots(int id, snapshot *snapHead) { snapshot *chosenSnap = get_snapshot(snapHead, id); snapshot *newSnapHead = snapHead; if (chosenSnap == NULL) { return newSnapHead; } chosenSnap = chosenSnap->prev; while (chosenSnap != NULL) { snapshot *temp = chosenSnap->prev; newSnapHead = snapshot_delete(newSnapHead, chosenSnap); chosenSnap = temp; } return newSnapHead; }
void vca_manager::handle_vca_colorfulness ( vca_info& info ) { string url = get_mjpeg_url ( *info.device ); ostringstream cmdline; uint16_t httpport = global::config()->get(info.name + ".httpport", 4001); cmdline << "vca/vca -i " << url << " " << info.params << " --httpport " << httpport; LOG ( INFO ) << info.name << ": " << cmdline.str(); redi::ipstream in ( cmdline.str() ); string line; while ( std::getline ( in, line ) ) { auto evt = Q_NEW ( gevt, EVT_VCA_EVENT ); evt->args.put ( "description", line ); ptime timestamp ( microsec_clock::universal_time() ); evt->args.put ( "timestamp", common::get_utc_string ( timestamp ) ); path local_folder ( global::config()->get ( "vca.snapshot_dir", "snapshots" ) ); path local_file ( info.name + " " + common::get_utc_string ( timestamp ) + ".jpg" ); path absolute=operator/ ( local_folder, local_file ); evt->args.put ( "snapshot_path", absolute.string() ); ostringstream url; url << "http://localhost:" << httpport << "/frame.jpg"; get_snapshot ( url.str(), absolute ); this->postFIFO ( evt ); } boost::this_thread::sleep_for ( boost::chrono::seconds ( 3 ) ); auto evt = Q_NEW ( gevt, EVT_VCA_STOPPED ); evt->args.put ( "name", info.name ); this->postFIFO ( evt ); }
int backtrace_snapshot(int pid, int *tids, int *index, int nr_tids) { int i, rc = 0; struct snapshot *snap; if ((snap = get_snapshot(pid, tids, index, nr_tids)) == NULL) return -1; for (i = 0; i < snap->num_threads; ++i) { printf("-------------------- thread %d (%d) --------------------\n", (index != NULL ? index[i] : i+1), snap->tids[i]); snap->cur_thr = i; if (backtrace_thread(&snapshot_addr_space_accessors, snap) < 0) rc = -1; } snapshot_destroy(snap); return rc; }
int main(int argc, string argv[]) { string *produce, snap_tags[MaxBodyFields], frame_tags[MaxBodyFields]; snapshot *snaplist = NULL, *ssp, frame = { NULL, 0, 0.0, NULL }; stream instr, outstr; int n, nbody, i; bodyptr btab, bp, sp; bool roff, voff; initparam(argv, defv); produce = burststring(getparam("produce"), ", "); layout_body(produce, Precision, NDIM); instr = stropen(getparam("in"), "r"); get_history(instr); snaplist = ssp = (snapshot *) allocate(sizeof(snapshot)); n = nbody = 0; while (get_snapshot(instr, *ssp, snap_tags, FALSE)) { if (! set_equal(snap_tags, produce)) error("%s: input file lacks required items\n", getprog()); n++; nbody += ssp->nbody; get_history(instr); ssp->link = (snapshot *) allocate(sizeof(snapshot)); ssp = ssp->link; } strclose(instr); eprintf("[%s: read %d frames, %d bodies]\n", getprog(), n, nbody); if (! strnull(getparam("frame"))) { instr = stropen(getparam("frame"), "r"); get_history(instr); if (! get_snapshot(instr, frame, frame_tags, FALSE)) error("%s: no snapshot in frame file\n", getprog()); strclose(instr); if (frame.nbody < n) error("%s: need at least %d points in frame\n", getprog(), n); } roff = (frame.nbody > 0) && set_member(frame_tags, PosTag); voff = (frame.nbody > 0) && set_member(frame_tags, VelTag); bp = btab = (bodyptr) allocate(nbody * SizeofBody); ssp = snaplist; for (i = 0; i < n; i++) { sp = ssp->bodies; while (sp < NthBody(ssp->bodies, ssp->nbody)) { memmove((void *) bp, (void *) sp, (size_t) SizeofBody); if (roff) { ADDV(Pos(bp), Pos(bp), Pos(NthBody(frame.bodies, i))); } if (voff) { ADDV(Vel(bp), Vel(bp), Vel(NthBody(frame.bodies, i))); } bp = NextBody(bp); sp = NextBody(sp); } ssp = ssp->link; } outstr = stropen(getparam("out"), "w"); put_history(outstr); put_snap(outstr, &btab, &nbody, &frame.time, produce); strclose(outstr); return (0); }
/* * Entity (service or instance): If there are -p options, * display_{pg,prop}() the named property groups and/or properties. Otherwise * display_pg() all property groups. */ static void process_ent(scf_entityp_t ent) { scf_snapshot_t *snap = NULL; scf_propertygroup_t *pg; scf_property_t *prop; scf_iter_t *iter; svcprop_prop_node_t *spn; int ret, err; if (uu_list_numnodes(prop_list) == 0) { if (quiet) return; if ((pg = scf_pg_create(hndl)) == NULL || (iter = scf_iter_create(hndl)) == NULL) scfdie(); if (cflag || Cflag || ent.type != ENT_INSTANCE) { if (scf_iter_entity_pgs(iter, ent) == -1) scfdie(); } else { if (snapshot != NULL) snap = get_snapshot(ent.u.inst, snapshot); if (scf_iter_instance_pgs_composed(iter, ent.u.inst, snap) == -1) scfdie(); if (snap) scf_snapshot_destroy(snap); } while ((ret = scf_iter_next_pg(iter, pg)) == 1) display_pg(pg); if (ret == -1) scfdie(); /* * In normal usage, i.e. against the running snapshot, * we must iterate over the current non-persistent * pg's. */ if (sflag == 0 && snap != NULL) { scf_iter_reset(iter); if (scf_iter_instance_pgs_composed(iter, ent.u.inst, NULL) == -1) scfdie(); while ((ret = scf_iter_next_pg(iter, pg)) == 1) { uint32_t flags; if (scf_pg_get_flags(pg, &flags) == -1) scfdie(); if (flags & SCF_PG_FLAG_NONPERSISTENT) display_pg(pg); } } if (ret == -1) scfdie(); scf_iter_destroy(iter); scf_pg_destroy(pg); return; } if ((pg = scf_pg_create(hndl)) == NULL || (prop = scf_property_create(hndl)) == NULL) scfdie(); if (ent.type == ENT_INSTANCE && snapshot != NULL) snap = get_snapshot(ent.u.inst, snapshot); for (spn = uu_list_first(prop_list); spn != NULL; spn = uu_list_next(prop_list, spn)) { if (ent.type == ENT_INSTANCE) { if (Cflag) ret = scf_instance_get_pg(ent.u.inst, spn->spn_comp1, pg); else ret = scf_instance_get_pg_composed(ent.u.inst, snap, spn->spn_comp1, pg); err = scf_error(); /* * If we didn't find it in the specified snapshot, use * the current values if the pg is nonpersistent. */ if (ret == -1 && !Cflag &&snap != NULL && err == SCF_ERROR_NOT_FOUND) { ret = scf_instance_get_pg_composed( ent.u.inst, NULL, spn->spn_comp1, pg); if (ret == 0) { uint32_t flags; if (scf_pg_get_flags(pg, &flags) == -1) scfdie(); if ((flags & SCF_PG_FLAG_NONPERSISTENT) == 0) { ret = -1; } } } } else { /* * If we are displaying properties for a service, * treat it as though it were a composed, current * lookup. (implicit cflag) However, if a snapshot * was specified, fail. */ if (sflag) die(gettext("Only instances have " "snapshots.\n")); ret = scf_entity_get_pg(ent, spn->spn_comp1, pg); err = scf_error(); } if (ret == -1) { if (err != SCF_ERROR_NOT_FOUND) scfdie(); if (PRINT_NOPROP_ERRORS) { char *buf; buf = safe_malloc(max_scf_fmri_length + 1); if (scf_entity_to_fmri(ent, buf, max_scf_fmri_length + 1) == -1) scfdie(); uu_warn(gettext("Couldn't find property group " "`%s' for %s `%s'.\n"), spn->spn_comp1, SCF_ENTITY_TYPE_NAME(ent), buf); free(buf); } noprop_common_action(); continue; } if (spn->spn_comp2 == NULL) { if (!quiet) display_pg(pg); continue; } if (scf_pg_get_property(pg, spn->spn_comp2, prop) == -1) { if (scf_error() != SCF_ERROR_NOT_FOUND) scfdie(); if (PRINT_NOPROP_ERRORS) { char *buf; buf = safe_malloc(max_scf_fmri_length + 1); if (scf_entity_to_fmri(ent, buf, max_scf_fmri_length + 1) == -1) scfdie(); /* FMRI syntax knowledge */ uu_warn(gettext("Couldn't find property " "`%s/%s' for %s `%s'.\n"), spn->spn_comp1, spn->spn_comp2, SCF_ENTITY_TYPE_NAME(ent), buf); free(buf); } noprop_common_action(); continue; } if (!quiet) display_prop(pg, prop); } scf_property_destroy(prop); scf_pg_destroy(pg); if (snap) scf_snapshot_destroy(snap); }
int main(int argc, char *argv[]) { int ii; GlobalTransactionId gxid[4000]; GTM_Conn *conn; char connect_string[100]; for (ii = 0; ii < 3; ii++) fork(); sprintf(connect_string, "host=localhost port=6666 node_name=one remote_type=%d", GTM_NODE_COORDINATOR); conn = PQconnectGTM(connect_string); if (conn == NULL) { client_log(("Error in connection\n")); exit(1); } for (ii = 0; ii < 20; ii++) { gxid[ii] = begin_transaction(conn, GTM_ISOLATION_RC); if (gxid[ii] != InvalidGlobalTransactionId) client_log(("Started a new transaction (GXID:%u)\n", gxid[ii])); else client_log(("BEGIN transaction failed for ii=%d\n", ii)); } for (ii = 0; ii < 5; ii++) { int jj; GTM_Snapshot snapshot = get_snapshot(conn, gxid[ii], true); if (snapshot != NULL) { client_log(("Snapshot: GXID %u, xmin=%u, xmax=%u\n", gxid[ii], snapshot->sn_xmin, snapshot->sn_xmax)); client_log(("xcnt=%d %s", snapshot->sn_xcnt, snapshot->sn_xcnt > 0 ? "xip=(" : "")); for (jj = 0; jj < snapshot->sn_xcnt; jj++) client_log(("%d%c ", snapshot->sn_xip[jj], ((jj + 1) == snapshot->sn_xcnt) ? ')' : ',')); client_log(("\n")); } } for (ii = 0; ii < 20; ii++) { if (!prepare_transaction(conn, gxid[ii])) client_log(("PREPARE successful (GXID:%u)\n", gxid[ii])); else client_log(("PREPARE failed (GXID:%u)\n", gxid[ii])); } for (ii = 0; ii < 20; ii++) { if (ii % 2 == 0) { if (!abort_transaction(conn, gxid[ii])) client_log(("ROLLBACK successful (GXID:%u)\n", gxid[ii])); else client_log(("ROLLBACK failed (GXID:%u)\n", gxid[ii])); } else { if (!commit_transaction(conn, gxid[ii])) client_log(("COMMIT successful (GXID:%u)\n", gxid[ii])); else client_log(("COMMIT failed (GXID:%u)\n", gxid[ii])); } } GTMPQfinish(conn); return 0; }