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

static intse_gc(sescheduler *s, seworker *w){	ss_trace(&w->trace, "%s", "log gc");	se *e = (se*)s->env;	int rc = sl_poolgc(&e->lp);	if (ssunlikely(rc == -1))		return -1;	return 0;}

static void*so_snapshotcursor(srobj *o, va_list args){	sosnapshot *s = (sosnapshot*)o;	so *e = so_of(o);	va_list va;	va_copy(va, args);	sov *v = va_arg(va, sov*);	va_end(va);	if (ssunlikely(v->o.id != SOV))		goto error;	if (ssunlikely(v->parent == NULL || v->parent->id != SODB))		goto error;	sodb *db = (sodb*)v->parent;	return so_cursornew(db, s->vlsn, 0, args);error:	sr_error(&e->error, "%s", "bad arguments");	return NULL;}

int se_scheduler_run(sescheduler *s){	se *e = (se*)s->env;	int rc;	rc = ss_threadpool_new(&s->tp, &e->a, e->conf.threads,	                       se_worker, e);	if (ssunlikely(rc == -1))		return -1;	return 0;}

static inline intsi_noderecover(sinode *n, sr *r){	/* recover branches */	ssiter i;	ss_iterinit(sd_recover, &i);	ss_iteropen(sd_recover, &i, r, &n->file);	int first = 1;	int rc;	while (ss_iteratorhas(&i))	{		sdindexheader *h = ss_iteratorof(&i);		sibranch *b;		if (first) {			b =  &n->self;		} else {			b = si_branchnew(r);			if (ssunlikely(b == NULL))				goto error;		}		sdindex index;		sd_indexinit(&index);		rc = sd_indexcopy(&index, r, h);		if (ssunlikely(rc == -1))			goto error;		si_branchset(b, &index);		b->next   = n->branch;		n->branch = b;		n->branch_count++;		first = 0;		ss_iteratornext(&i);	}	rc = sd_recover_complete(&i);	if (ssunlikely(rc == -1))		goto error;	ss_iteratorclose(&i);	return 0;error:	ss_iteratorclose(&i);	return -1;}

int se_document_createkey(sedocument *o){	sedb *db = (sedb*)o->o.parent;	se *e = se_of(&db->o);	if (o->created)		return 0;	assert(o->v == NULL);	/* set prefix */	if (o->prefix) {		if (db->scheme->scheme.keys[0]->type != SS_STRING)			return sr_error(&e->error, "%s", "prefix search is only "			                "supported for a string key");		void *copy = ss_malloc(&e->a, o->prefix_size);		if (ssunlikely(copy == NULL))			return sr_oom(&e->error);		memcpy(copy, o->prefix, o->prefix_size);		o->prefix_copy = copy;	}	/* set unspecified min/max keys, depending on	 * iteration order */	if (ssunlikely(o->fields_count_keys != db->scheme->scheme.keys_count))	{		if (o->prefix && o->fields_count_keys == 0) {			memset(o->fields, 0, sizeof(o->fields));			o->fields[0].pointer = o->prefix;			o->fields[0].size = o->prefix_size;		}		sf_limitapply(&db->limit, &db->scheme->scheme,		              o->fields, o->order);		o->fields_count = db->scheme->scheme.fields_count;		o->fields_count_keys = db->scheme->scheme.keys_count;	}	o->v = sv_vbuild(db->r, o->fields);	if (ssunlikely(o->v == NULL))		return sr_oom(&e->error);	sf_flagsset(db->r->scheme, sv_vpointer(o->v), SVGET);	o->created = 1;	return 0;}

int si_nodefree(sinode *n, sr *r, int gc){	int rcret = 0;	int rc;	if (gc && n->file.file) {		rc = ss_fileunlink(n->file.file);		if (ssunlikely(rc == -1)) {			sr_malfunction(r->e, "db file '%s' unlink error: %s",			               n->file.file, strerror(errno));			rcret = -1;		}	}	si_nodefree_branches(n, r);	rc = si_nodeclose(n, r);	if (ssunlikely(rc == -1))		rcret = -1;	ss_free(r->a, n);	return rcret;}

int si_nodesync(sinode *n, sr *r){	int rc = ss_filesync(&n->file);	if (ssunlikely(rc == -1)) {		sr_malfunction(r->e, "db file '%s' sync error: %s",		               n->file.file, strerror(errno));		return -1;	}	return 0;}

int si_nodemap(sinode *n, sr *r){	int rc = ss_mmap(&n->map, n->file.fd, n->file.size, 1);	if (ssunlikely(rc == -1)) {		sr_malfunction(r->e, "db file '%s' mmap error: %s",		               n->file.file, strerror(errno));		return -1;	}	return 0;}

static inline intsy_recoverbackup(sy *i, sr *r){	if (i->conf->path_backup == NULL)		return 0;	int rc;	int exists = ss_vfsexists(r->vfs, i->conf->path_backup);	if (! exists) {		rc = ss_vfsmkdir(r->vfs, i->conf->path_backup, 0755);		if (ssunlikely(rc == -1)) {			sr_error(r->e, "backup directory '%s' create error: %s",					 i->conf->path_backup, strerror(errno));			return -1;		}	}	/* recover backup sequential number */	DIR *dir = opendir(i->conf->path_backup);	if (ssunlikely(dir == NULL)) {		sr_error(r->e, "backup directory '%s' open error: %s",				 i->conf->path_backup, strerror(errno));		return -1;	}	uint32_t bsn = 0;	struct dirent *de;	while ((de = readdir(dir))) {		if (ssunlikely(de->d_name[0] == '.'))			continue;		uint32_t id = 0;		rc = sy_process(de->d_name, &id);		switch (rc) {		case  1:		case  0:			if (id > bsn)				bsn = id;			break;		case -1: /* skip unknown file */			continue;		}	}	closedir(dir);	r->seq->bsn = bsn;	return 0;}

int sd_schemebegin(sdscheme *c, sr *r){	int rc = ss_bufensure(&c->buf, r->a, sizeof(sdschemeheader));	if (ssunlikely(rc == -1))		return sr_oom(r->e);	sdschemeheader *h = (sdschemeheader*)c->buf.s;	memset(h, 0, sizeof(sdschemeheader));	ss_bufadvance(&c->buf, sizeof(sdschemeheader));	return 0;}

int sd_indexcommit(sdindex *i, sr *r, sdid *id, ssqf *qf,                   uint32_t align,                   uint64_t offset){	int size = ss_bufused(&i->v);	int size_extension = 0;	int extensions = 0;	if (qf) {		extensions = SD_INDEXEXT_AMQF;		size_extension += sizeof(sdindexamqf);		size_extension += qf->qf_table_size;	}	/* calculate index align for direct_io */	int size_meta  = size + size_extension + sizeof(sdindexheader);	int size_align = 0;	if (align) {		size_align += align - ((offset + size_meta + ss_bufused(&i->i)) % align);		size_meta  += size_align;	}	int rc = ss_bufensure(&i->i, r->a, size_meta);	if (ssunlikely(rc == -1))		return sr_oom(r->e);	/* min/max pairs */	memcpy(i->i.p, i->v.s, size);	ss_bufadvance(&i->i, size);	/* extension */	if (qf) {		sdindexamqf *qh = (sdindexamqf*)(i->i.p);		qh->q       = qf->qf_qbits;		qh->r       = qf->qf_rbits;		qh->entries = qf->qf_entries;		qh->size    = qf->qf_table_size;		ss_bufadvance(&i->i, sizeof(sdindexamqf));		memcpy(i->i.p, qf->qf_table, qf->qf_table_size);		ss_bufadvance(&i->i, qf->qf_table_size);	}	ss_buffree(&i->v, r->a);	sdindexheader *h = &i->build;	/* align */	if (size_align) {		h->align = size_align;		memset(i->i.p, 0, size_align);		ss_bufadvance(&i->i, size_align);	}	/* header */	h->offset     = offset;	h->id         = *id;	h->extension  = size_extension;	h->extensions = extensions;	h->crc = ss_crcs(r->crc, h, sizeof(sdindexheader), 0);	memcpy(i->i.p, &i->build, sizeof(sdindexheader));	ss_bufadvance(&i->i, sizeof(sdindexheader));	i->h = sd_indexheader(i);	return 0;}

static inline intse_backupstart(sescheduler *s){	se *e = (se*)s->env;	/*	 * a. create backup_path/<bsn.incomplete> directory	 * b. create database directories	 * c. create log directory	*/	char path[1024];	snprintf(path, sizeof(path), "%s/%" PRIu32 ".incomplete",	         e->conf.backup_path, s->backup_bsn);	int rc = ss_vfsmkdir(&e->vfs, path, 0755);	if (ssunlikely(rc == -1)) {		sr_error(&e->error, "backup directory '%s' create error: %s",		         path, strerror(errno));		return -1;	}	int i = 0;	while (i < s->count) {		sedb *db = s->i[i];		snprintf(path, sizeof(path), "%s/%" PRIu32 ".incomplete/%s",		         e->conf.backup_path, s->backup_bsn,		         db->scheme.name);		rc = ss_vfsmkdir(&e->vfs, path, 0755);		if (ssunlikely(rc == -1)) {			sr_error(&e->error, "backup directory '%s' create error: %s",			         path, strerror(errno));			return -1;		}		i++;	}	snprintf(path, sizeof(path), "%s/%" PRIu32 ".incomplete/log",	         e->conf.backup_path, s->backup_bsn);	rc = ss_vfsmkdir(&e->vfs, path, 0755);	if (ssunlikely(rc == -1)) {		sr_error(&e->error, "backup directory '%s' create error: %s",		         path, strerror(errno));		return -1;	}	return 0;}

static inline ssize_t sw_diridof(char *s){	size_t v = 0;	while (*s && *s != '.') {		if (ssunlikely(!isdigit(*s)))			return -1;		v = (v * 10) + *s - '0';		s++;	}	return v;}

int sy_open(sy *e, sr *r, syconf *conf){	e->conf = conf;	int rc = sy_recoverbackup(e, r);	if (ssunlikely(rc == -1))		return -1;	int exists = ss_vfsexists(r->vfs, conf->path);	if (exists == 0)		return sy_deploy(e, r);	return 0;}

int si_nodecomplete(sinode *n, sr *r, sischeme *scheme){	sspath path;	ss_pathA(&path, scheme->path, n->self.id.id, ".db");	int rc = ss_filerename(&n->file, path.path);	if (ssunlikely(rc == -1)) {		sr_malfunction(r->e, "db file '%s' rename error: %s",		               n->file.file, strerror(errno));	}	return rc;}

static inline intsi_nodeclose(sinode *n, sr *r){	int rcret = 0;	int rc = ss_munmap(&n->map);	if (ssunlikely(rc == -1)) {		sr_malfunction(r->e, "db file '%s' munmap error: %s",		               n->file.file, strerror(errno));		rcret = -1;	}	rc = ss_fileclose(&n->file);	if (ssunlikely(rc == -1)) {		sr_malfunction(r->e, "db file '%s' close error: %s",		               n->file.file, strerror(errno));		rcret = -1;	}	sv_indexfree(&n->i0, r);	sv_indexfree(&n->i1, r);	return rcret;}

int sd_indexcopy(sdindex *i, sr *r, sdindexheader *h){	int size = sd_indexsize_ext(h);	int rc = ss_bufensure(&i->i, r->a, size);	if (ssunlikely(rc == -1))		return sr_oom(r->e);	memcpy(i->i.s, (char*)h, size);	ss_bufadvance(&i->i, size);	i->h = sd_indexheader(i);	return 0;}

int se_scheduler_call(void *arg){	se *e = arg;	sescheduler *s = &e->sched;	seworker *w = se_workerpool_pop(&e->sched.workers, &e->r);	if (ssunlikely(w == NULL))		return -1;	int rc = se_scheduler(s, w);	se_workerpool_push(&e->sched.workers, w);	return rc;}

int sc_ctl_backup_event(sc *s){	int event = 0;	ss_mutexlock(&s->lock);	if (ssunlikely(s->backup_events > 0)) {		s->backup_events--;		event = 1;	}	ss_mutexunlock(&s->lock);	return event;}

int si_plannerinit(siplanner *p, ssa *a, void *i){	int rc = ss_rqinit(&p->compact, a, 1, 20);	if (ssunlikely(rc == -1))		return -1;	/* 1Mb step up to 4Gb */	rc = ss_rqinit(&p->branch, a, 1024 * 1024, 4000);	if (ssunlikely(rc == -1)) {		ss_rqfree(&p->compact, a);		return -1;	}	rc = ss_rqinit(&p->temp, a, 1, 100);	if (ssunlikely(rc == -1)) {		ss_rqfree(&p->compact, a);		ss_rqfree(&p->branch, a);		return -1;	}	p->i = i;	return 0;}

int sc_step(sc *s, scworker *w, uint64_t vlsn){	sctask task;	sc_taskbegin(&task, w, vlsn);	int rc = sc_schedule(s, &task);	int rc_job = rc;	/* log rotation */	if (task.rotate) {		rc = sc_rotate(s, w);		if (ssunlikely(rc == -1))			goto error;	}	/* backup completion */	if (task.backup) {		rc = sc_backupend(s, w);		if (ssunlikely(rc == -1))			sc_backupstop(s);	}	if (rc_job == 1) {		rc = sc_execute(&task, w, vlsn);		if (ssunlikely(rc == -1)) {			if (task.plan.plan != SI_BACKUP &&			    task.plan.plan != SI_BACKUPEND) {				sr_statusset(s->r->status, SR_MALFUNCTION);				goto error;			}			sc_backupstop(s);		}	}	sc_taskend(s, &task);	if (task.gc) {		rc = sc_gc(s, w);		if (ssunlikely(rc == -1))			goto error;	}	ss_trace(&w->trace, "%s", "sleep");	return rc_job;error:	ss_trace(&w->trace, "%s", "malfunction");	return -1;}

sxstate sx_prepare(sx *x, sxpreparef prepare, void *arg){	uint64_t lsn = sr_seq(x->manager->seq, SR_LSN);	/* proceed read-only transactions */	if (x->type == SX_RO || sv_logcount_write(x->log) == 0)		return sx_promote(x, SX_PREPARE);	ssiter i;	ss_iterinit(ss_bufiter, &i);	ss_iteropen(ss_bufiter, &i, &x->log->buf, sizeof(svlogv));	sxstate rc;	for (; ss_iterhas(ss_bufiter, &i); ss_iternext(ss_bufiter, &i))	{		svlogv *lv = ss_iterof(ss_bufiter, &i);		sxv *v = lv->ptr;		if ((int)v->lo == x->log_read)			break;		if (sx_vaborted(v))			return sx_promote(x, SX_ROLLBACK);		if (sslikely(v->prev == NULL)) {			rc = sx_preparecb(x, lv, lsn, prepare, arg);			if (ssunlikely(rc != 0))				return sx_promote(x, SX_ROLLBACK);			continue;		}		if (sx_vcommitted(v->prev)) {			if (v->prev->csn > x->csn)				return sx_promote(x, SX_ROLLBACK);			continue;		}		/* force commit for read-only conflicts */		sxindex *i = v->prev->index;		if (sv_vflags(v->prev->v, i->r) & SVGET) {			rc = sx_preparecb(x, lv, lsn, prepare, arg);			if (ssunlikely(rc != 0))				return sx_promote(x, SX_ROLLBACK);			continue;		}		return sx_promote(x, SX_LOCK);	}	return sx_promote(x, SX_PREPARE);}

static void *se_worker(void *arg){	ssthread *self = arg;	se *e = self->arg;	seworker *worker = se_workerpool_pop(&e->sched.workers, &e->r);	if (ssunlikely(worker == NULL))		return NULL;	for (;;)	{		int rc = se_active(e);		if (ssunlikely(rc == 0))			break;		rc = se_scheduler(&e->sched, worker);		if (ssunlikely(rc == -1))			break;		if (ssunlikely(rc == 0))			ss_sleep(10000000); /* 10ms */	}	se_workerpool_push(&e->sched.workers, worker);	return NULL;}

static intsy_deploy(sy *e, sr *r){	int rc;	rc = ss_vfsmkdir(r->vfs, e->conf->path, 0755);	if (ssunlikely(rc == -1)) {		sr_error(r->e, "directory '%s' create error: %s",		         e->conf->path, strerror(errno));		return -1;	}	return 0;}

int si_nodecreate(sinode *n, sr *r, sischeme *scheme, sdid *id){	sspath path;	ss_pathAB(&path, scheme->path, id->parent, id->id, ".db.incomplete");	int rc = ss_filenew(&n->file, path.path);	if (ssunlikely(rc == -1)) {		sr_malfunction(r->e, "db file '%s' create error: %s",		               path.path, strerror(errno));		return -1;	}	return 0;}

int si_nodefree(sinode *n, sr *r, int gc){	int rcret = 0;	int rc;	if (gc && ss_pathis_set(&n->file.path)) {		ss_fileadvise(&n->file, 0, 0, n->file.size);		rc = ss_vfsunlink(r->vfs, ss_pathof(&n->file.path));		if (ssunlikely(rc == -1)) {			sr_malfunction(r->e, "db file '%s' unlink error: %s",			               ss_pathof(&n->file.path),			               strerror(errno));			rcret = -1;		}	}	si_nodefree_branches(n, r);	rc = si_nodeclose(n, r, gc);	if (ssunlikely(rc == -1))		rcret = -1;	ss_free(r->a, n);	return rcret;}

static inline intsc_rotate(sc *s, scworker *w){	ss_trace(&w->trace, "%s", "log rotation");	int rc = sw_managerrotate_ready(s->wm);	if (rc) {		rc = sw_managerrotate(s->wm);		if (ssunlikely(rc == -1))			return -1;	}	return 0;}

int sd_indexcopy(sdindex *i, sr *r, sdindexheader *h){	int size = sd_indexsize_ext(h);	int rc = ss_bufensure(&i->i, r->a, size);	if (ssunlikely(rc == -1))		return sr_oom(r->e);	char *start = (char*)h - (h->align + h->size + h->extension);	memcpy(i->i.s, start, size);	ss_bufadvance(&i->i, size);	i->h = sd_indexheader(i);	return 0;}

static inline intse_txwrite(setx *t, sedocument *o, uint8_t flags){	se *e = se_of(&t->o);	sedb *db = se_cast(o->o.parent, sedb*, SEDB);	/* validate database status */	if (ssunlikely(! se_active(e)))		goto error;	/* ensure memory quota */	int rc;	rc = sr_quota(&db->quota, &db->stat);	if (ssunlikely(rc)) {		sr_error(&e->error, "%s", "memory quota limit reached");		goto error;	}	/* create document */	rc = se_document_validate(o, &db->o);	if (ssunlikely(rc == -1))		goto error;	rc = se_document_create(o, flags);	if (ssunlikely(rc == -1))		goto error;	svv *v = o->v;	v->log = o->log;	sv_vref(v);	so_destroy(&o->o);	/* concurrent index only */	rc = sx_set(&t->t, &db->coindex, v);	if (ssunlikely(rc == -1))		return -1;	return 0;error:	so_destroy(&o->o);	return -1;}

int sd_buildadd(sdbuild *b, sr *r, sv *v, uint32_t flags){	/* prepare object metadata */	int rc = ss_bufensure(&b->m, r->a, sizeof(sdv));	if (ssunlikely(rc == -1))		return sr_oom(r->e);	sdpageheader *h = sd_buildheader(b);	sdv *sv = (sdv*)b->m.p;	sv->flags  = sv_flags(v) | flags;	sv->offset = ss_bufused(&b->v) - sd_buildref(b)->v;	ss_bufadvance(&b->m, sizeof(sdv));	/* copy object */	switch (r->fmt_storage) {	case SF_SKEYVALUE:		rc = sd_buildadd_keyvalue(b, r, v);		break;	case SF_SRAW:		rc = sd_buildadd_raw(b, r, v);		break;	}	if (ssunlikely(rc == -1))		return -1;	/* update page header */	h->count++;	uint32_t size = sizeof(sdv) + sv_size(v) +		sizeof(sfref) * r->scheme->count;	if (size > b->vmax)		b->vmax = size;	uint64_t lsn = sv_lsn(v);	if (lsn > h->lsnmax)		h->lsnmax = lsn;	if (lsn < h->lsnmin)		h->lsnmin = lsn;	if (sv->flags & SVDUP) {		h->countdup++;		if (lsn < h->lsnmindup)			h->lsnmindup = lsn;	}	return 0;}