msyds/gf-core
1
0
Fork 0
forked from GitHub/gf-core
Code Pull Requests Activity

first draft of the new allocator with transactions support

Browse Source
This commit is contained in:
Krasimir Angelov
2022-05-20 13:55:45 +02:00
parent 546dc01b5d
commit 5594679a83
24 changed files with 1582 additions and 2372 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/compiler/GF/Infra/SIO.hs
View File

@@ -136,4 +136,4 @@ importSource opts files = lift0 $ GF.importSource opts files
link opts pgf src = lift0 $ GF.link opts pgf src
modifyPGF gr t = lift0 (PGFT.modifyPGF gr t)
checkoutPGF gr b = lift0 (PGFT.checkoutPGF gr b)
checkoutPGF gr = lift0 (PGFT.checkoutPGF gr)

4
src/compiler/GF/Interactive.hs
View File

@@ -154,8 +154,8 @@ execute1' s0 =
checkout = do
mb_pgf <- gets multigrammar
case mb_pgf of
Just pgf -> do mb_pgf <- lift $ checkoutPGF pgf "master"
modify $ \gfenv -> gfenv{pgfenv = (fst (pgfenv gfenv),mb_pgf)}
Just pgf -> do pgf <- lift $ checkoutPGF pgf
modify $ \gfenv -> gfenv{pgfenv = (fst (pgfenv gfenv),Just pgf)}
Nothing -> return ()
interruptible :: ShellM Bool -> ShellM Bool

152
src/runtime/c/pgf/data.cxx
View File

@@ -2,31 +2,31 @@
void PgfFlag::release(ref<PgfFlag> flag)
{
pgf_literal_free(flag->value);
PgfDB::free(flag);
pgf_literal_release(flag->value);
PgfDB::free(flag, flag->name.size+1);
}
void PgfAbsFun::release(ref<PgfAbsFun> absfun)
{
pgf_type_free(absfun->type);
pgf_type_release(absfun->type);
if (absfun->bytecode != 0) {
PgfDB::free(absfun->bytecode);
}
PgfDB::free(absfun);
PgfDB::free(absfun, absfun->name.size+1);
}
void PgfAbsCat::release(ref<PgfAbsCat> abscat)
{
pgf_context_free(abscat->context);
PgfDB::free(abscat);
pgf_context_release(abscat->context);
PgfDB::free(abscat, abscat->name.size+1);
}
void PgfPGF::release(ref<PgfPGF> pgf)
{
namespace_release(pgf->gflags);
PgfDB::free(pgf->abstract.name);
text_db_release(pgf->abstract.name);
namespace_release(pgf->abstract.aflags);
namespace_release(pgf->abstract.funs);
namespace_release(pgf->abstract.cats);
@@ -41,112 +41,112 @@ void PgfConcr::release(ref<PgfConcr> concr)
namespace_release(concr->lincats);
phrasetable_release(concr->phrasetable);
namespace_release(concr->printnames);
PgfDB::free(concr);
PgfDB::free(concr, concr->name.size+1);
}
void PgfConcrLincat::release(ref<PgfConcrLincat> lincat)
{
for (size_t i = 0; i < lincat->fields->len; i++) {
PgfDB::free(*vector_elem(lincat->fields, i));
text_db_release(*vector_elem(lincat->fields, i));
}
Vector<ref<PgfText>>::release(lincat->fields);
PgfDB::free(lincat->fields);
for (size_t i = 0; i < lincat->args->len; i++) {
PgfDB::free(vector_elem(lincat->args, i)->param);
PgfLParam::release(vector_elem(lincat->args, i)->param);
}
PgfDB::free(lincat->args);
Vector<PgfPArg>::release(lincat->args);
for (size_t i = 0; i < lincat->res->len; i++) {
ref<PgfPResult> res = *vector_elem(lincat->res, i);
if (res->vars != 0)
PgfDB::free(res->vars);
PgfDB::free(res);
PgfPResult::release(*vector_elem(lincat->res, i));
}
PgfDB::free(lincat->res);
Vector<ref<PgfPResult>>::release(lincat->res);
for (size_t i = 0; i < lincat->seqs->len; i++) {
ref<PgfSequence> seq = *vector_elem(lincat->seqs, i);
if (!(--seq->ref_count)) {
PgfSequence::release(seq);
}
}
PgfDB::free(lincat->seqs);
Vector<ref<PgfSequence>>::release(lincat->seqs);
PgfDB::free(lincat);
PgfDB::free(lincat, lincat->name.size+1);
}
PGF_INTERNAL
void pgf_symbol_free(PgfSymbol sym)
void PgfLParam::release(ref<PgfLParam> param)
{
switch (ref<PgfSymbol>::get_tag(sym)) {
case PgfSymbolKP::tag: {
auto sym_kp = ref<PgfSymbolKP>::untagged(sym);
PgfSequence::release(sym_kp->default_form);
for (size_t i = 0; i < sym_kp->alts.len; i++) {
PgfSequence::release(sym_kp->alts.data[i].form);
for (size_t j = 0; j < sym_kp->alts.data[i].prefixes->len; j++) {
ref<PgfText> prefix = *vector_elem(sym_kp->alts.data[i].prefixes, j);
PgfDB::free(prefix);
}
}
PgfDB::free(sym_kp);
break;
}
case PgfSymbolBIND::tag:
case PgfSymbolSOFTBIND::tag:
case PgfSymbolNE::tag:
case PgfSymbolSOFTSPACE::tag:
case PgfSymbolCAPIT::tag:
case PgfSymbolALLCAPIT::tag:
break;
default:
PgfDB::free(ref<void>::untagged(sym));
}
PgfDB::free(param, param->n_terms*sizeof(param->terms[0]));
}
void PgfPResult::release(ref<PgfPResult> res)
{
if (res->vars != 0)
Vector<PgfVariableRange>::release(res->vars);
PgfDB::free(res, res->param.n_terms*sizeof(res->param.terms[0]));
}
void PgfSequence::release(ref<PgfSequence> seq)
{
for (size_t i = 0; i < seq->syms.len; i++) {
PgfSymbol sym = *vector_elem(&seq->syms, i);
pgf_symbol_free(sym);
}
PgfDB::free(seq);
}
void PgfSequenceBackrefs::release(ref<PgfSequenceBackrefs> backrefs)
{
PgfDB::free(backrefs);
switch (ref<PgfSymbol>::get_tag(sym)) {
case PgfSymbolCat::tag: {
auto sym_cat = ref<PgfSymbolCat>::untagged(sym);
PgfDB::free(sym_cat, sym_cat->r.n_terms*sizeof(sym_cat->r.terms[0]));
break;
}
case PgfSymbolLit::tag: {
auto sym_lit = ref<PgfSymbolLit>::untagged(sym);
PgfDB::free(sym_lit, sym_lit->r.n_terms*sizeof(sym_lit->r.terms[0]));
break;
}
case PgfSymbolVar::tag:
PgfDB::free(ref<PgfSymbolVar>::untagged(sym));
break;
case PgfSymbolKS::tag: {
auto sym_ks = ref<PgfSymbolKS>::untagged(sym);
PgfDB::free(sym_ks, sym_ks->token.size+1);
break;
}
case PgfSymbolKP::tag: {
auto sym_kp = ref<PgfSymbolKP>::untagged(sym);
PgfSequence::release(sym_kp->default_form);
for (size_t i = 0; i < sym_kp->alts.len; i++) {
PgfSequence::release(sym_kp->alts.data[i].form);
for (size_t j = 0; j < sym_kp->alts.data[i].prefixes->len; j++) {
text_db_release(*vector_elem(sym_kp->alts.data[i].prefixes, j));
}
}
PgfDB::free(sym_kp, sym_kp->alts.len*sizeof(PgfAlternative));
break;
}
case PgfSymbolBIND::tag:
case PgfSymbolSOFTBIND::tag:
case PgfSymbolNE::tag:
case PgfSymbolSOFTSPACE::tag:
case PgfSymbolCAPIT::tag:
case PgfSymbolALLCAPIT::tag:
break;
default:
throw pgf_error("Unknown symbol tag");
}
}
PgfDB::free(seq,seq->syms.len*sizeof(PgfSymbol));
}
void PgfConcrLin::release(ref<PgfConcrLin> lin)
{
for (size_t i = 0; i < lin->args->len; i++) {
PgfDB::free(vector_elem(lin->args, i)->param);
PgfLParam::release(vector_elem(lin->args, i)->param);
}
PgfDB::free(lin->args);
Vector<PgfPArg>::release(lin->args);
for (size_t i = 0; i < lin->res->len; i++) {
ref<PgfPResult> res = *vector_elem(lin->res, i);
if (res->vars != 0)
PgfDB::free(res->vars);
PgfDB::free(res);
PgfPResult::release(*vector_elem(lin->res, i));
}
PgfDB::free(lin->res);
Vector<ref<PgfPResult>>::release(lin->res);
for (size_t i = 0; i < lin->seqs->len; i++) {
ref<PgfSequence> seq = *vector_elem(lin->seqs, i);
if (!(--seq->ref_count)) {
PgfSequence::release(seq);
}
}
PgfDB::free(lin->seqs);
Vector<ref<PgfSequence>>::release(lin->seqs);
PgfDB::free(lin);
PgfDB::free(lin, lin->name.size+1);
}
void PgfConcrPrintname::release(ref<PgfConcrPrintname> printname)
{
PgfDB::free(printname->printname);
PgfDB::free(printname);
text_db_release(printname->printname);
PgfDB::free(printname, printname->name.size+1);
}

45
src/runtime/c/pgf/data.h
View File

@@ -73,7 +73,6 @@ class PgfConcr;
#include "expr.h"
struct PGF_INTERNAL_DECL PgfFlag {
size_t ref_count;
PgfLiteral value;
PgfText name;
@@ -81,8 +80,6 @@ struct PGF_INTERNAL_DECL PgfFlag {
};
struct PGF_INTERNAL_DECL PgfAbsFun {
size_t ref_count;
ref<PgfDTyp> type;
int arity;
ref<char> bytecode;
@@ -93,8 +90,6 @@ struct PGF_INTERNAL_DECL PgfAbsFun {
};
struct PGF_INTERNAL_DECL PgfAbsCat {
size_t ref_count;
ref<Vector<PgfHypo>> context;
prob_t prob;
PgfText name;
@@ -116,6 +111,8 @@ struct PGF_INTERNAL_DECL PgfLParam {
size_t factor;
size_t var;
} terms[];
static void release(ref<PgfLParam> param);
};
struct PGF_INTERNAL_DECL PgfVariableRange {
@@ -130,15 +127,16 @@ struct PGF_INTERNAL_DECL PgfPArg {
struct PGF_INTERNAL_DECL PgfPResult {
ref<Vector<PgfVariableRange>> vars;
PgfLParam param;
static void release(ref<PgfPResult> res);
};
typedef object PgfSymbol;
struct PGF_INTERNAL_DECL PgfSequence {
size_t ref_count;
Vector<PgfSymbol> syms;
static void release(ref<PgfSequence> lincat);
static void release(ref<PgfSequence> seq);
};
struct PGF_INTERNAL_DECL PgfSequenceBackref {
@@ -146,14 +144,6 @@ struct PGF_INTERNAL_DECL PgfSequenceBackref {
size_t seq_index;
};
struct PGF_INTERNAL_DECL PgfSequenceBackrefs {
size_t ref_count;
Vector<PgfSequenceBackref> list;
static
void release(ref<PgfSequenceBackrefs> backrefs);
};
struct PGF_INTERNAL_DECL PgfSymbolCat {
static const uint8_t tag = 0;
size_t d;
@@ -215,14 +205,9 @@ struct PGF_INTERNAL_DECL PgfSymbolALLCAPIT {
static const uint8_t tag = 10;
};
PGF_INTERNAL_DECL
void pgf_symbol_free(PgfSymbol sym);
struct PGF_INTERNAL_DECL PgfConcrLincat {
static const uint8_t tag = 0;
size_t ref_count;
ref<PgfAbsCat> abscat;
ref<Vector<ref<PgfText>>> fields;
@@ -240,8 +225,6 @@ struct PGF_INTERNAL_DECL PgfConcrLincat {
struct PGF_INTERNAL_DECL PgfConcrLin {
static const uint8_t tag = 1;
size_t ref_count;
ref<PgfAbsFun> absfun;
ref<Vector<PgfPArg>> args;
@@ -254,7 +237,6 @@ struct PGF_INTERNAL_DECL PgfConcrLin {
};
struct PGF_INTERNAL_DECL PgfConcrPrintname {
size_t ref_count;
ref<PgfText> printname;
PgfText name;
@@ -262,8 +244,8 @@ struct PGF_INTERNAL_DECL PgfConcrPrintname {
};
struct PGF_INTERNAL_DECL PgfConcr {
size_t ref_count;
size_t ref_count_ex;
static const uint8_t tag = 1;
Namespace<PgfFlag> cflags;
Namespace<PgfConcrLin> lins;
Namespace<PgfConcrLincat> lincats;
@@ -282,7 +264,7 @@ struct PGF_INTERNAL_DECL PgfConcr {
};
struct PGF_INTERNAL_DECL PgfPGF {
size_t ref_count;
static const uint8_t tag = 0;
uint16_t major_version;
uint16_t minor_version;
@@ -290,18 +272,7 @@ struct PGF_INTERNAL_DECL PgfPGF {
PgfAbstr abstract;
Namespace<PgfConcr> concretes;
// If the revision is transient, then it is in a double-linked list
// with all other transient revisions.
ref<PgfPGF> prev, next;
// The name lets the user to find a particular revision in
// the database.
PgfText name;
static void release(ref<PgfPGF> pgf);
};
extern PGF_INTERNAL_DECL size_t master_size;
extern PGF_INTERNAL_DECL char master_text[];
#endif

2143
src/runtime/c/pgf/db.cxx
View File

File diff suppressed because it is too large Load Diff

76
src/runtime/c/pgf/db.h
View File

@@ -8,6 +8,7 @@ class PgfDB;
extern PGF_INTERNAL_DECL __thread unsigned char* current_base __attribute__((tls_model("initial-exec")));
extern PGF_INTERNAL_DECL __thread PgfDB* current_db __attribute__((tls_model("initial-exec")));
struct block_descr;
struct malloc_state;
template<class A> class PGF_INTERNAL_DECL ref {
@@ -37,10 +38,9 @@ public:
object as_object() const { return offset; }
static
object tagged(ref<A> ref) {
object tagged() {
assert(A::tag < MALLOC_ALIGN_MASK + 1);
return (ref.offset | A::tag);
return (offset | A::tag);
}
static
@@ -56,16 +56,28 @@ public:
enum DB_scope_mode {READER_SCOPE, WRITER_SCOPE};
typedef size_t txn_t;
class PgfDB {
private:
int fd;
const char *filepath;
malloc_state* ms;
size_t mmap_size;
unsigned char* base;
// The following four fields are normally equal to
// the corresponding fields in the malloc_state.
// The exception is when a transaction is active.
object top;
object free_blocks;
object free_descriptors[2];
size_t mmap_size;
size_t page_size;
#ifndef _WIN32
pthread_rwlock_t *rwlock;
pid_t pid;
#else
DWORD pid;
HANDLE hMap;
HANDLE hRWEvent;
#endif
@@ -80,48 +92,60 @@ public:
PGF_INTERNAL_DECL PgfDB(const char* filepath, int flags, int mode);
PGF_INTERNAL_DECL ~PgfDB();
PGF_INTERNAL_DECL static txn_t get_txn_id();
template<class A>
static ref<A> malloc(size_t extra_bytes=0) {
return current_db->malloc_internal(sizeof(A)+extra_bytes);
}
template<class A>
static ref<A> realloc(ref<A> r, size_t extra_bytes) {
return current_db->realloc_internal(r.as_object(), sizeof(A)+extra_bytes);
static ref<A> realloc(ref<A> r, size_t old_extra_bytes, size_t new_extra_bytes) {
return current_db->realloc_internal(r.as_object(), sizeof(A)+old_extra_bytes, sizeof(A)+new_extra_bytes);
}
template<class A>
static void free(ref<A> o) {
current_db->free_internal(o.as_object());
static void free(ref<A> o, size_t extra_bytes=0) {
current_db->free_internal(o.as_object(), sizeof(A)+extra_bytes);
}
PGF_INTERNAL_DECL void cleanup_revisions();
static PGF_INTERNAL_DECL ref<PgfPGF> get_revision(PgfText *name);
static PGF_INTERNAL_DECL void set_revision(ref<PgfPGF> pgf);
PGF_INTERNAL_DECL object get_active_revision();
PGF_INTERNAL_DECL void set_active_revision(object o);
PGF_INTERNAL_DECL void register_revision(object o);
PGF_INTERNAL_DECL void unregister_revision(object o);
static PGF_INTERNAL_DECL ref<PgfPGF> revision2pgf(PgfRevision revision);
static PGF_INTERNAL_DECL bool is_persistant_revision(ref<PgfPGF> pgf);
static PGF_INTERNAL_DECL void link_transient_revision(ref<PgfPGF> pgf);
static PGF_INTERNAL_DECL void unlink_transient_revision(ref<PgfPGF> pgf);
PGF_INTERNAL_DECL ref<PgfPGF> revision2pgf(PgfRevision revision);
PGF_INTERNAL_DECL ref<PgfConcr> revision2concr(PgfConcrRevision revision);
static PGF_INTERNAL_DECL ref<PgfConcr> revision2concr(PgfConcrRevision revision);
static PGF_INTERNAL_DECL bool is_persistant_revision(ref<PgfConcr> concr);
static PGF_INTERNAL_DECL void link_transient_revision(ref<PgfConcr> concr);
static PGF_INTERNAL_DECL void unlink_transient_revision(ref<PgfConcr> concr);
static PGF_INTERNAL_DECL void sync();
PGF_INTERNAL_DECL void start_transaction();
PGF_INTERNAL_DECL void commit();
PGF_INTERNAL_DECL void rollback();
private:
PGF_INTERNAL_DECL void init_state(size_t size);
PGF_INTERNAL_DECL int init_state();
PGF_INTERNAL_DECL size_t block_descr_size(object map);
PGF_INTERNAL_DECL object new_block_descr(object o, size_t size);
PGF_INTERNAL_DECL object upd_block_descr(object map, object left, object right);
PGF_INTERNAL_DECL object balanceL_block_descriptor(object map);
PGF_INTERNAL_DECL object balanceR_block_descriptor(object map);
PGF_INTERNAL_DECL object pop_first_block_descriptor(object map, object *res);
PGF_INTERNAL_DECL object pop_last_block_descriptor(object map, object *res);
PGF_INTERNAL_DECL object insert_block_descriptor(object map, object o, size_t size);
PGF_INTERNAL_DECL object delete_block_descriptor(object map, size_t *psize, object *po);
#ifdef DEBUG_MEMORY_ALLOCATOR
PGF_INTERNAL_DECL void dump_free_blocks(object map);
#endif
PGF_INTERNAL_DECL object malloc_internal(size_t bytes);
PGF_INTERNAL_DECL object realloc_internal(object oldo, size_t bytes);
PGF_INTERNAL_DECL void free_internal(object o);
PGF_INTERNAL_DECL object realloc_internal(object oldo, size_t old_bytes, size_t new_bytes);
PGF_INTERNAL_DECL void register_process();
PGF_INTERNAL_DECL void unregister_process();
PGF_INTERNAL_DECL void free_internal(object o, size_t bytes);
PGF_INTERNAL_DECL void lock(DB_scope_mode m);
PGF_INTERNAL_DECL void unlock();

72
src/runtime/c/pgf/expr.cxx
View File

@@ -116,7 +116,7 @@ PgfExpr PgfDBUnmarshaller::eabs(PgfBindType bind_type, PgfText *name, PgfExpr bo
eabs->bind_type = bind_type;
eabs->body = m->match_expr(this, body);
memcpy(&eabs->name, name, sizeof(PgfText)+name->size+1);
return ref<PgfExprAbs>::tagged(eabs);
return eabs.tagged();
}
PgfExpr PgfDBUnmarshaller::eapp(PgfExpr fun, PgfExpr arg)
@@ -124,21 +124,21 @@ PgfExpr PgfDBUnmarshaller::eapp(PgfExpr fun, PgfExpr arg)
ref<PgfExprApp> eapp = PgfDB::malloc<PgfExprApp>();
eapp->fun = m->match_expr(this, fun);
eapp->arg = m->match_expr(this, arg);
return ref<PgfExprApp>::tagged(eapp);
return eapp.tagged();
}
PgfExpr PgfDBUnmarshaller::elit(PgfLiteral lit)
{
ref<PgfExprLit> elit = PgfDB::malloc<PgfExprLit>();
elit->lit = m->match_lit(this, lit);
return ref<PgfExprLit>::tagged(elit);
return elit.tagged();
}
PgfExpr PgfDBUnmarshaller::emeta(PgfMetaId meta_id)
{
ref<PgfExprMeta> emeta = PgfDB::malloc<PgfExprMeta>();
emeta->id = meta_id;
return ref<PgfExprMeta>::tagged(emeta);
return emeta.tagged();
}
PgfExpr PgfDBUnmarshaller::efun(PgfText *name)
@@ -146,14 +146,14 @@ PgfExpr PgfDBUnmarshaller::efun(PgfText *name)
ref<PgfExprFun> efun =
PgfDB::malloc<PgfExprFun>(name->size+1);
memcpy(&efun->name, name, sizeof(PgfText)+name->size+1);
return ref<PgfExprFun>::tagged(efun);
return efun.tagged();
}
PgfExpr PgfDBUnmarshaller::evar(int index)
{
ref<PgfExprVar> evar = PgfDB::malloc<PgfExprVar>();
evar->var = index;
return ref<PgfExprVar>::tagged(evar);
return evar.tagged();
}
PgfExpr PgfDBUnmarshaller::etyped(PgfExpr expr, PgfType ty)
@@ -161,14 +161,14 @@ PgfExpr PgfDBUnmarshaller::etyped(PgfExpr expr, PgfType ty)
ref<PgfExprTyped> etyped = PgfDB::malloc<PgfExprTyped>();
etyped->expr = m->match_expr(this, expr);
etyped->type = m->match_type(this, ty);
return ref<PgfExprTyped>::tagged(etyped);
return etyped.tagged();
}
PgfExpr PgfDBUnmarshaller::eimplarg(PgfExpr expr)
{
ref<PgfExprImplArg> eimpl = current_db->malloc<PgfExprImplArg>();
eimpl->expr = m->match_expr(this, expr);
return ref<PgfExprImplArg>::tagged(eimpl);
return eimpl.tagged();
}
PgfLiteral PgfDBUnmarshaller::lint(size_t size, uintmax_t *val)
@@ -177,14 +177,14 @@ PgfLiteral PgfDBUnmarshaller::lint(size_t size, uintmax_t *val)
PgfDB::malloc<PgfLiteralInt>(size*sizeof(uintmax_t));
lit_int->size = size;
memcpy(&lit_int->val, val, size*sizeof(uintmax_t));
return ref<PgfLiteralInt>::tagged(lit_int);
return lit_int.tagged();
}
PgfLiteral PgfDBUnmarshaller::lflt(double val)
{
ref<PgfLiteralFlt> lit_flt = PgfDB::malloc<PgfLiteralFlt>();
lit_flt->val = val;
return ref<PgfLiteralFlt>::tagged(lit_flt);
return lit_flt.tagged();
}
PgfLiteral PgfDBUnmarshaller::lstr(PgfText *val)
@@ -192,7 +192,7 @@ PgfLiteral PgfDBUnmarshaller::lstr(PgfText *val)
ref<PgfLiteralStr> lit_str =
PgfDB::malloc<PgfLiteralStr>(val->size+1);
memcpy(&lit_str->val, val, sizeof(PgfText)+val->size+1);
return ref<PgfLiteralStr>::tagged(lit_str);
return lit_str.tagged();
}
PgfType PgfDBUnmarshaller::dtyp(size_t n_hypos, PgfTypeHypo *hypos,
@@ -217,9 +217,8 @@ PgfType PgfDBUnmarshaller::dtyp(size_t n_hypos, PgfTypeHypo *hypos,
return ty.as_object();
}
void PgfDBUnmarshaller::free_ref(object x)
void PgfDBUnmarshaller::free_ref(object expr)
{
PgfDB::free(ref<void>::untagged(x));
}
PgfLiteral PgfInternalMarshaller::match_lit(PgfUnmarshaller *u, PgfLiteral l)
@@ -1170,11 +1169,12 @@ void PgfExprProbEstimator::free_ref(object x)
}
PGF_INTERNAL
void pgf_literal_free(PgfLiteral literal)
void pgf_literal_release(PgfLiteral literal)
{
switch (ref<PgfLiteral>::get_tag(literal)) {
case PgfLiteralInt::tag: {
PgfDB::free(ref<PgfLiteralInt>::untagged(literal));
auto lint = ref<PgfLiteralInt>::untagged(literal);
PgfDB::free(lint, lint->size*sizeof(uintmax_t));
break;
}
case PgfLiteralFlt::tag: {
@@ -1182,7 +1182,8 @@ void pgf_literal_free(PgfLiteral literal)
break;
}
case PgfLiteralStr::tag: {
PgfDB::free(ref<PgfLiteralStr>::untagged(literal));
auto lstr = ref<PgfLiteralStr>::untagged(literal);
PgfDB::free(lstr, lstr->val.size+1);
break;
}
default:
@@ -1191,25 +1192,25 @@ void pgf_literal_free(PgfLiteral literal)
}
PGF_INTERNAL
void pgf_expr_free(PgfExpr expr)
void pgf_expr_release(PgfExpr expr)
{
switch (ref<PgfExpr>::get_tag(expr)) {
case PgfExprAbs::tag: {
auto eabs = ref<PgfExprAbs>::untagged(expr);
pgf_expr_free(eabs->body);
PgfDB::free(eabs);
pgf_expr_release(eabs->body);
PgfDB::free(eabs, eabs->name.size+1);
break;
}
case PgfExprApp::tag: {
auto eapp = ref<PgfExprApp>::untagged(expr);
pgf_expr_free(eapp->fun);
pgf_expr_free(eapp->arg);
pgf_expr_release(eapp->fun);
pgf_expr_release(eapp->arg);
PgfDB::free(eapp);
break;
}
case PgfExprLit::tag: {
auto elit = ref<PgfExprLit>::untagged(expr);
pgf_literal_free(elit->lit);
pgf_literal_release(elit->lit);
PgfDB::free(elit);
break;
}
@@ -1218,7 +1219,8 @@ void pgf_expr_free(PgfExpr expr)
break;
}
case PgfExprFun::tag: {
PgfDB::free(ref<PgfExprFun>::untagged(expr));
auto efun = ref<PgfExprFun>::untagged(expr);
PgfDB::free(efun, efun->name.size+1);
break;
}
case PgfExprVar::tag: {
@@ -1227,14 +1229,14 @@ void pgf_expr_free(PgfExpr expr)
}
case PgfExprTyped::tag: {
auto etyped = ref<PgfExprTyped>::untagged(expr);
pgf_expr_free(etyped->expr);
pgf_type_free(etyped->type);
pgf_expr_release(etyped->expr);
pgf_type_release(etyped->type);
PgfDB::free(etyped);
break;
}
case PgfExprImplArg::tag: {
auto eimpl = ref<PgfExprImplArg>::untagged(expr);
pgf_expr_free(eimpl->expr);
pgf_expr_release(eimpl->expr);
PgfDB::free(eimpl);
break;
}
@@ -1244,25 +1246,25 @@ void pgf_expr_free(PgfExpr expr)
}
PGF_INTERNAL
void pgf_context_free(ref<Vector<PgfHypo>> hypos)
void pgf_context_release(ref<Vector<PgfHypo>> hypos)
{
for (size_t i = 0; i < hypos->len; i++) {
PgfDB::free(vector_elem(hypos, i)->cid);
pgf_type_free(vector_elem(hypos, i)->type);
text_db_release(vector_elem(hypos, i)->cid);
pgf_type_release(vector_elem(hypos, i)->type);
}
PgfDB::free(hypos);
Vector<PgfHypo>::release(hypos);
}
PGF_INTERNAL
void pgf_type_free(ref<PgfDTyp> dtyp)
void pgf_type_release(ref<PgfDTyp> dtyp)
{
pgf_context_free(dtyp->hypos);
pgf_context_release(dtyp->hypos);
for (size_t i = 0; i < dtyp->exprs->len; i++) {
pgf_expr_free(*vector_elem(dtyp->exprs, i));
pgf_expr_release(*vector_elem(dtyp->exprs, i));
}
PgfDB::free(dtyp->exprs);
Vector<PgfExpr>::release(dtyp->exprs);
PgfDB::free(dtyp);
PgfDB::free(dtyp, dtyp->name.size+1);
}

8
src/runtime/c/pgf/expr.h
View File

@@ -228,15 +228,15 @@ public:
*/
PGF_INTERNAL_DECL
void pgf_literal_free(PgfLiteral literal);
void pgf_literal_release(PgfLiteral literal);
PGF_INTERNAL_DECL
void pgf_expr_free(PgfExpr expr);
void pgf_expr_release(PgfExpr expr);
PGF_INTERNAL_DECL
void pgf_context_free(ref<Vector<PgfHypo>> hypos);
void pgf_context_release(ref<Vector<PgfHypo>> hypos);
PGF_INTERNAL_DECL
void pgf_type_free(ref<PgfDTyp> dtyp);
void pgf_type_release(ref<PgfDTyp> dtyp);
#endif /* EXPR_H_ */

504
src/runtime/c/pgf/namespace.h
View File

@@ -5,15 +5,8 @@
// #define DEBUG_NAMESPACE
/* Namespace<V> expects that the class V contains:
*
* - A member 'size_t ref_count' which keeps track of the number of
* references to the particular object.
* - A member 'PgfText name' which contains the name of the object.
* - A method:
* static void release(ref<V> object)
* which is executed when ref_count becomes zero. After that the memory
* for the object is released as well.
/* Namespace<V> expects that the class V contains,
* a member 'PgfText name' which contains the name of the object.
*/
template <class V>
@@ -26,7 +19,7 @@ template <class V>
class PGF_INTERNAL_DECL Node
{
public:
size_t ref_count;
txn_t txn_id;
size_t sz;
V value;
@@ -36,12 +29,12 @@ public:
static
ref<Node> new_node(V value)
{
ref<Node> node = current_db->malloc<Node>();
node->ref_count = 1;
node->sz = 1;
node->value = value;
node->left = 0;
node->right = 0;
ref<Node> node = PgfDB::malloc<Node>();
node->txn_id = PgfDB::get_txn_id();
node->sz = 1;
node->value = value;
node->left = 0;
node->right = 0;
#ifdef DEBUG_NAMESPACE
printf("new node %6ld %s\n", node.as_object(), node->value->name.text);
@@ -50,310 +43,200 @@ public:
}
static
ref<Node> new_node(V value, ref<Node> left, ref<Node> right)
ref<Node> upd_node(ref<Node> node, ref<Node> left, ref<Node> right)
{
ref<Node> node = current_db->malloc<Node>();
node->ref_count = 1;
node->sz = 1+Node::size(left)+Node::size(right);
node->value = value;
node->left = left;
node->right = right;
if (node->txn_id != PgfDB::get_txn_id()) {
ref<Node> new_node = PgfDB::malloc<Node>();
new_node->txn_id = PgfDB::get_txn_id();
new_node->value = node->value;
release(node);
node = new_node;
#ifdef DEBUG_NAMESPACE
printf("new node %6ld %s(%ld,%ld)\n", node.as_object(), node->value->name.text, left.as_object(), right.as_object());
printf("new node %6ld %s(%ld,%ld)\n", node.as_object(), node->value->name.text, left.as_object(), right.as_object());
#endif
}
node->sz = 1+Node::size(left)+Node::size(right);
node->left = left;
node->right = right;
return node;
}
static
void add_node_ref(ref<Node> node)
ref<Node> balanceL(ref<Node> node)
{
node->ref_count++;
#ifdef DEBUG_NAMESPACE
printf("add_ref node %6ld %s (ref_count=%ld)\n", node.as_object(), node->value->name.text, node->ref_count);
#endif
}
template <class A> static
void add_value_ref(A &value)
{
value.add_ref();
#ifdef DEBUG_NAMESPACE
printf("add_ref value %5ld %s (ref_count=%ld)\n", value.as_object(), value->name.text, value->ref_count);
#endif
}
template <class A> static
void add_value_ref(ref<A> value)
{
value->ref_count++;
#ifdef DEBUG_NAMESPACE
printf("add_ref value %5ld %s (ref_count=%ld)\n", value.as_object(), value->name.text, value->ref_count);
#endif
}
template <class A> static
void release_value_ref(A &value)
{
#ifdef DEBUG_NAMESPACE
printf("release value %5ld %s (ref_count=%ld)\n", value.as_object(), value->name.text, value->ref_count-1);
#endif
value.release_ref();
}
template <class A> static
void release_value_ref(ref<A> value)
{
#ifdef DEBUG_NAMESPACE
printf("release value %5ld %s (ref_count=%ld)\n", value.as_object(), value->name.text, value->ref_count-1);
#endif
if (!(--value->ref_count)) {
A::release(value);
}
}
static
ref<Node> balanceL(V value, ref<Node> left, ref<Node> right)
{
if (right == 0) {
if (left == 0) {
add_value_ref(value);
return new_node(value);
if (node->right == 0) {
if (node->left == 0) {
return node;
} else {
if (left->left == 0) {
if (left->right == 0) {
add_value_ref(value);
add_node_ref(left);
return new_node(value,left,0);
if (node->left->left == 0) {
if (node->left->right == 0) {
return node;
} else {
add_value_ref(value);
add_value_ref(left->value);
add_value_ref(left->right->value);
ref<Node<V>> new_left = new_node(left->value);
ref<Node<V>> new_right = new_node(value);
return new_node(left->right->value,
new_left,
new_right);
ref<Node<V>> left_right = node->left->right;
ref<Node<V>> left = upd_node(node->left,0,0);
ref<Node<V>> right = upd_node(node,0,0);
return upd_node(left_right,
left,
right);
}
} else {
if (left->right == 0) {
add_value_ref(value);
ref<Node<V>> new_right = new_node(value);
add_value_ref(left->value);
add_node_ref(left->left);
return new_node(left->value,
if (node->left->right == 0) {
ref<Node<V>> left = node->left;
ref<Node<V>> right = upd_node(node,0,0);
return upd_node(left,
left->left,
new_right);
right);
} else {
if (left->right->sz < 2 * left->left->sz) {
add_value_ref(value);
add_value_ref(left->value);
add_node_ref(left->left);
add_node_ref(left->right);
ref<Node<V>> new_right =
new_node(value,
if (node->left->right->sz < 2 * node->left->left->sz) {
ref<Node<V>> left = node->left;
ref<Node<V>> right =
upd_node(node,
left->right,
0);
return new_node(left->value,
return upd_node(left,
left->left,
new_right);
right);
} else {
add_value_ref(value);
add_value_ref(left->value);
add_value_ref(left->right->value);
add_node_ref(left->left);
if (left->right->left != 0)
add_node_ref(left->right->left);
if (left->right->right != 0)
add_node_ref(left->right->right);
ref<Node<V>> new_left =
new_node(left->value,
left->left,
left->right->left);
ref<Node<V>> new_right =
new_node(value,
left->right->right,
ref<Node<V>> left_right = node->left->right;
ref<Node<V>> left =
upd_node(node->left,
node->left->left,
left_right->left);
ref<Node<V>> right =
upd_node(node,
left_right->right,
0);
return new_node(left->right->value,
new_left,
new_right);
return upd_node(left_right,
left,
right);
}
}
}
}
} else {
if (left == 0) {
add_value_ref(value);
add_node_ref(right);
return new_node(value,0,right);
if (node->left == 0) {
return node;
} else {
if (left->sz > 3*right->sz) {
if (left->right->sz < 2*left->left->sz) {
add_value_ref(value);
add_value_ref(left->value);
add_node_ref(left->left);
add_node_ref(left->right);
add_node_ref(right);
ref<Node<V>> new_right =
new_node(value,
if (node->left->sz > 3*node->right->sz) {
if (node->left->right->sz < 2*node->left->left->sz) {
ref<Node<V>> left = node->left;
ref<Node<V>> right =
upd_node(node,
left->right,
right);
return new_node(left->value,
node->right);
return upd_node(left,
left->left,
new_right);
right);
} else {
add_value_ref(value);
add_value_ref(left->value);
add_value_ref(left->right->value);
add_node_ref(left->left);
if (left->right->left != 0)
add_node_ref(left->right->left);
if (left->right->right != 0)
add_node_ref(left->right->right);
add_node_ref(right);
ref<Node<V>> new_left =
new_node(left->value,
left->left,
left->right->left);
ref<Node<V>> new_right =
new_node(value,
left->right->right,
right);
return new_node(left->right->value,
new_left,
new_right);
ref<Node<V>> left_right = node->left->right;
ref<Node<V>> left =
upd_node(node->left,
node->left->left,
left_right->left);
ref<Node<V>> right =
upd_node(node,
left_right->right,
node->right);
return upd_node(left_right,
left,
right);
}
} else {
add_value_ref(value);
add_node_ref(left);
add_node_ref(right);
return new_node(value,left,right);
return node;
}
}
}
}
static
ref<Node> balanceR(V value, ref<Node> left, ref<Node> right)
ref<Node> balanceR(ref<Node> node)
{
if (left == 0) {
if (right == 0) {
add_value_ref(value);
return new_node(value);
if (node->left == 0) {
if (node->right == 0) {
return node;
} else {
if (right->left == 0) {
if (right->right == 0) {
add_value_ref(value);
add_node_ref(right);
return new_node(value,0,right);
if (node->right->left == 0) {
if (node->right->right == 0) {
return node;
} else {
add_value_ref(value);
add_value_ref(right->value);
add_node_ref(right->right);
ref<Node<V>> new_left =
new_node(value);
return new_node(right->value,
new_left,
ref<Node<V>> right = node->right;
ref<Node<V>> left =
upd_node(node,
0,
0);
return upd_node(right,
left,
right->right);
}
} else {
if (right->right == 0) {
add_value_ref(value);
add_value_ref(right->value);
add_value_ref(right->left->value);
ref<Node<V>> new_left =
new_node(value);
ref<Node<V>> new_right =
new_node(right->value);
return new_node(right->left->value,
new_left,
new_right);
if (node->right->right == 0) {
ref<Node<V>> right_left = node->right->left;
ref<Node<V>> right =
upd_node(node->right,0,0);
ref<Node<V>> left =
upd_node(node,0,0);
return upd_node(right_left,
left,
right);
} else {
if (right->left->sz < 2 * right->right->sz) {
add_value_ref(value);
add_value_ref(right->value);
add_node_ref(right->left);
add_node_ref(right->right);
ref<Node<V>> new_left =
new_node(value,
if (node->right->left->sz < 2 * node->right->right->sz) {
ref<Node<V>> right = node->right;
ref<Node<V>> left =
upd_node(node,
0,
right->left);
return new_node(right->value,
new_left,
return upd_node(right,
left,
right->right);
} else {
add_value_ref(value);
add_value_ref(right->value);
add_value_ref(right->left->value);
if (right->left->left != 0)
add_node_ref(right->left->left);
if (right->left->right != 0)
add_node_ref(right->left->right);
add_node_ref(right->right);
ref<Node<V>> new_left =
new_node(value,
ref<Node<V>> right_left = node->right->left;
ref<Node<V>> right =
upd_node(node->right,
right_left->right,
node->right->right);
ref<Node<V>> left =
upd_node(node,
0,
right->left->left);
ref<Node<V>> new_right =
new_node(right->value,
right->left->right,
right->right);
return new_node(right->left->value,
new_left,
new_right);
right_left->left);
return upd_node(right_left,
left,
right);
}
}
}
}
} else {
if (right == 0) {
add_value_ref(value);
add_node_ref(left);
return new_node(value,left,0);
if (node->right == 0) {
return node;
} else {
if (right->sz > 3*left->sz) {
if (right->left->sz < 2*right->right->sz) {
add_value_ref(value);
add_value_ref(right->value);
add_node_ref(left);
add_node_ref(right->left);
add_node_ref(right->right);
ref<Node<V>> new_left =
new_node(value,
left,
if (node->right->sz > 3*node->left->sz) {
if (node->right->left->sz < 2*node->right->right->sz) {
ref<Node<V>> right = node->right;
ref<Node<V>> left =
upd_node(node,
node->left,
right->left);
return new_node(right->value,
new_left,
return upd_node(right,
left,
right->right);
} else {
add_value_ref(value);
add_value_ref(right->value);
add_value_ref(right->left->value);
add_node_ref(left);
if (right->left->left != 0)
add_node_ref(right->left->left);
if (right->left->right != 0)
add_node_ref(right->left->right);
add_node_ref(right->right);
ref<Node<V>> new_left =
new_node(value,
left,
right->left->left);
ref<Node<V>> new_right =
new_node(right->value,
right->left->right,
right->right);
return new_node(right->left->value,
new_left,
new_right);
ref<Node<V>> right_left = node->right->left;
ref<Node<V>> right =
upd_node(node->right,
right_left->right,
node->right->right);
ref<Node<V>> left =
upd_node(node,
node->left,
right_left->left);
return upd_node(right_left,
left,
right);
}
} else {
add_value_ref(value);
add_node_ref(left);
add_node_ref(right);
return new_node(value,left,right);
return node;
}
}
}
@@ -368,57 +251,42 @@ public:
}
static
ref<Node> pop_first(ref<Node> node, V *res)
ref<Node> pop_first(ref<Node> node, ref<Node> *res)
{
if (node == 0) {
return 0;
} else if (node->left == 0) {
*res = node->value;
if (node->right != 0)
node->right->ref_count++;
*res = node;
return node->right;
} else {
ref<Node> new_left = pop_first(node->left, res);
ref<Node> new_node = balanceR(node->value, new_left, node->right);
release(new_left);
return new_node;
ref<Node> left = pop_first(node->left, res);
ref<Node> node = upd_node(node, left, node->right);
return balanceR(node);
}
}
static
ref<Node> pop_last(ref<Node> node, V *res)
ref<Node> pop_last(ref<Node> node, ref<Node> *res)
{
if (node == 0) {
return 0;
} else if (node->right == 0) {
*res = node->value;
if (node->left != 0)
node->left->ref_count++;
*res = node;
return node->left;
} else {
ref<Node> new_right = pop_last(node->right, res);
ref<Node> new_node = balanceR(node->value, node->left, new_right);
release(new_right);
return new_node;
ref<Node> right = pop_last(node->right, res);
ref<Node> node = upd_node(node, node->left, right);
return balanceL(node);
}
}
static
void release(ref<Node> node)
{
if (node == 0)
return;
#ifdef DEBUG_NAMESPACE
printf("release node %6ld %s (ref_count=%ld)\n", node.as_object(), node->value->name.text, node->ref_count-1);
#endif
if (!(--node->ref_count)) {
release(node->left);
release(node->right);
release_value_ref(node->value);
PgfDB::free(node);
}
PgfDB::free(node);
}
};
@@ -443,26 +311,22 @@ Namespace<V> namespace_insert(Namespace<V> map, ref<V> value)
int cmp = textcmp(&value->name,&map->value->name);
if (cmp < 0) {
Namespace<V> left = namespace_insert(map->left, value);
Namespace<V> node = Node<ref<V>>::balanceL(map->value,left,map->right);
namespace_release(left);
return node;
map = Node<ref<V>>::upd_node(map,left,map->right);
return Node<ref<V>>::balanceL(map);
} else if (cmp > 0) {
Namespace<V> right = namespace_insert(map->right, value);
Namespace<V> node = Node<ref<V>>::balanceR(map->value, map->left, right);
namespace_release(right);
return node;
map = Node<ref<V>>::upd_node(map,map->left,right);
return Node<ref<V>>::balanceR(map);
} else {
if (map->left != 0)
map->left->ref_count++;
if (map->right != 0)
map->right->ref_count++;
return Node<ref<V>>::new_node(value,map->left,map->right);
map = Node<ref<V>>::upd_node(map,map->left,map->right);
map->value = value;
return map;
}
}
template <class V>
Namespace<V> namespace_delete(Namespace<V> map, PgfText* name,
ref<V> *pvalue = NULL)
ref<V> *pvalue)
{
if (map == 0) {
if (pvalue != NULL) *pvalue = 0;
@@ -472,41 +336,33 @@ Namespace<V> namespace_delete(Namespace<V> map, PgfText* name,
int cmp = textcmp(name,&map->value->name);
if (cmp < 0) {
Namespace<V> left = namespace_delete(map->left, name, pvalue);
if (left == map->left)
return map;
Namespace<V> node = Node<ref<V>>::balanceR(map->value,left,map->right);
namespace_release(left);
return node;
map = Node<ref<V>>::upd_node(map,left,map->right);
return Node<ref<V>>::balanceR(map);
} else if (cmp > 0) {
Namespace<V> right = namespace_delete(map->right, name, pvalue);
if (right == map->right)
return map;
Namespace<V> node = Node<ref<V>>::balanceL(map->value,map->left,right);
namespace_release(right);
return node;
map = Node<ref<V>>::upd_node(map,map->left,right);
return Node<ref<V>>::balanceL(map);
} else {
if (pvalue != NULL) *pvalue = map->value;
if (map->left == 0) {
if (map->right != 0)
map->right->ref_count++;
Node<ref<V>>::release(map);
return map->right;
} else if (map->right == 0) {
if (map->left != 0)
map->left->ref_count++;
Node<ref<V>>::release(map);
return map->left;
} else if (map->left->sz > map->right->sz) {
ref<V> value;
Namespace<V> new_left = Node<ref<V>>::pop_last(map->left, &value);
Namespace<V> node = Node<ref<V>>::balanceR(value, new_left, map->right);
namespace_release(new_left);
return node;
Namespace<V> node;
Namespace<V> left = Node<ref<V>>::pop_last(map->left, &node);
node = Node<ref<V>>::upd_node(node, left, map->right);
Node<ref<V>>::release(map);
return Node<ref<V>>::balanceR(node);
} else {
ref<V> value;
Namespace<V> new_right = Node<ref<V>>::pop_first(map->right, &value);
Namespace<V> node = Node<ref<V>>::balanceL(value, map->left, new_right);
namespace_release(new_right);
return node;
Namespace<V> node;
Namespace<V> right = Node<ref<V>>::pop_first(map->right, &node);
node = Node<ref<V>>::upd_node(node, map->left, right);
Node<ref<V>>::release(map);
return Node<ref<V>>::balanceL(node);
}
}
}
@@ -554,6 +410,10 @@ void namespace_iter(Namespace<V> map, PgfItor* itor, PgfExn *err)
template <class V>
void namespace_release(Namespace<V> node)
{
if (node == 0)
return;
namespace_release(node->left);
namespace_release(node->right);
Node<ref<V>>::release(node);
}

481
src/runtime/c/pgf/pgf.cxx
View File

File diff suppressed because it is too large Load Diff

21
src/runtime/c/pgf/pgf.h
View File

@@ -462,18 +462,19 @@ void pgf_check_type(PgfDB *db, PgfRevision revision,
PgfExn *err);
PGF_API_DECL
PgfRevision pgf_clone_revision(PgfDB *db, PgfRevision revision,
PgfText *name,
PgfExn *err);
PGF_API_DECL
void pgf_commit_revision(PgfDB *db, PgfRevision revision,
PgfExn *err);
PGF_API_DECL
PgfRevision pgf_checkout_revision(PgfDB *db, PgfText *name,
PgfRevision pgf_start_transaction(PgfDB *db, PgfRevision revision,
PgfExn *err);
PGF_API_DECL
void pgf_commit_transaction(PgfDB *db, PgfRevision revision,
PgfExn *err);
PGF_API_DECL
void pgf_rollback_transaction(PgfDB *db, PgfRevision revision);
PGF_API_DECL
PgfRevision pgf_checkout_revision(PgfDB *db, PgfExn *err);
PGF_API_DECL
void pgf_create_function(PgfDB *db, PgfRevision revision,
PgfText *name,

175
src/runtime/c/pgf/phrasetable.cxx
View File

@@ -72,24 +72,6 @@ void PgfPhrasetableIds::end()
pairs = NULL;
}
void PgfPhrasetableEntry::add_ref()
{
seq->ref_count++;
if (backrefs != 0)
backrefs->ref_count++;
}
void PgfPhrasetableEntry::release_ref()
{
if (!(--seq->ref_count)) {
PgfSequence::release(seq);
}
if (backrefs != 0 && !(--backrefs->ref_count)) {
PgfSequenceBackrefs::release(backrefs);
}
}
static
int lparam_cmp(PgfLParam *p1, PgfLParam *p2)
{
@@ -247,65 +229,57 @@ int sequence_cmp(ref<PgfSequence> seq1, ref<PgfSequence> seq2)
PGF_INTERNAL
PgfPhrasetable phrasetable_internalize(PgfPhrasetable table,
ref<PgfSequence> seq,
object container,
size_t seq_index,
ref<PgfSequence> *pseq)
ref<PgfPhrasetableEntry> *pentry)
{
if (table == 0) {
PgfPhrasetableEntry entry;
entry.seq = *pseq;
entry.backrefs = PgfDB::malloc<PgfSequenceBackrefs>(sizeof(PgfSequenceBackref));
entry.backrefs->ref_count = 1;
entry.backrefs->list.len = 1;
entry.backrefs->list.data[0].container = container;
entry.backrefs->list.data[0].seq_index = seq_index;
entry.seq->ref_count++;
return Node<PgfPhrasetableEntry>::new_node(entry);
entry.seq = seq;
entry.backrefs = vector_new<PgfSequenceBackref>(1);
entry.backrefs->data[0].container = container;
entry.backrefs->data[0].seq_index = seq_index;
PgfPhrasetable new_table = Node<PgfPhrasetableEntry>::new_node(entry);
*pentry = ref<PgfPhrasetableEntry>::from_ptr(&new_table->value);
return new_table;
}
int cmp = sequence_cmp(*pseq,table->value.seq);
int cmp = sequence_cmp(seq,table->value.seq);
if (cmp < 0) {
PgfPhrasetable left = phrasetable_internalize(table->left,
seq,
container,
seq_index,
pseq);
PgfPhrasetable node = Node<PgfPhrasetableEntry>::balanceL(table->value,left,table->right);
phrasetable_release(left);
return node;
pentry);
table = Node<PgfPhrasetableEntry>::upd_node(table,left,table->right);
return Node<PgfPhrasetableEntry>::balanceL(table);
} else if (cmp > 0) {
PgfPhrasetable right = phrasetable_internalize(table->right,
seq,
container,
seq_index,
pseq);
PgfPhrasetable node = Node<PgfPhrasetableEntry>::balanceR(table->value, table->left, right);
phrasetable_release(right);
return node;
pentry);
table = Node<PgfPhrasetableEntry>::upd_node(table, table->left, right);
return Node<PgfPhrasetableEntry>::balanceR(table);
} else {
if (!(--(*pseq)->ref_count)) {
PgfSequence::release(*pseq);
}
table->value.seq->ref_count++;
*pseq = table->value.seq;
if (table->left != 0)
table->left->ref_count++;
if (table->right != 0)
table->right->ref_count++;
PgfSequence::release(seq);
size_t len = (table->value.backrefs)
? table->value.backrefs->list.len
? table->value.backrefs->len
: 0;
PgfPhrasetableEntry entry;
entry.seq = table->value.seq;
entry.backrefs = PgfDB::malloc<PgfSequenceBackrefs>((len+1)*sizeof(PgfSequenceBackref));
entry.backrefs->ref_count = 1;
entry.backrefs->list.len = len+1;
memcpy(entry.backrefs->list.data, table->value.backrefs->list.data, len*sizeof(PgfSequenceBackref));
entry.backrefs->list.data[len].container = container;
entry.backrefs->list.data[len].seq_index = seq_index;
entry.seq->ref_count++;
return Node<PgfPhrasetableEntry>::new_node(entry,table->left,table->right);
ref<Vector<PgfSequenceBackref>> backrefs =
vector_copy<PgfSequenceBackref>(table->value.backrefs, len+1);
backrefs->data[len].container = container;
backrefs->data[len].seq_index = seq_index;
PgfPhrasetable new_table =
Node<PgfPhrasetableEntry>::upd_node(table, table->left, table->right);
Vector<PgfSequenceBackref>::release(new_table->value.backrefs);
new_table->value.backrefs = backrefs;
*pentry = ref<PgfPhrasetableEntry>::from_ptr(&new_table->value);
return new_table;
}
}
@@ -322,13 +296,12 @@ ref<PgfSequence> phrasetable_relink(PgfPhrasetable table,
else if (seq_id == left_sz) {
size_t len = (table->value.backrefs == 0)
? 0
: table->value.backrefs->list.len;
: table->value.backrefs->len;
ref<PgfSequenceBackrefs> backrefs =
vector_resize<PgfSequenceBackrefs,PgfSequenceBackref>(table->value.backrefs, &PgfSequenceBackrefs::list, len+1);
backrefs->ref_count = 1;
backrefs->list.data[len].container = container;
backrefs->list.data[len].seq_index = seq_index;
ref<Vector<PgfSequenceBackref>> backrefs =
vector_unsafe_resize<PgfSequenceBackref>(table->value.backrefs, len+1);
backrefs->data[len].container = container;
backrefs->data[len].seq_index = seq_index;
table->value.backrefs = backrefs;
return table->value.seq;
@@ -355,68 +328,66 @@ PgfPhrasetable phrasetable_delete(PgfPhrasetable table,
seq);
if (left == table->left)
return table;
PgfPhrasetable node = Node<PgfPhrasetableEntry>::balanceR(table->value,left,table->right);
phrasetable_release(left);
return node;
table = Node<PgfPhrasetableEntry>::upd_node(table,left,table->right);
return Node<PgfPhrasetableEntry>::balanceR(table);
} else if (cmp > 0) {
PgfPhrasetable right = phrasetable_delete(table->right,
container, seq_index,
seq);
if (right == table->right)
return table;
PgfPhrasetable node = Node<PgfPhrasetableEntry>::balanceL(table->value,table->left,right);
phrasetable_release(right);
return node;
table = Node<PgfPhrasetableEntry>::upd_node(table,table->left,right);
return Node<PgfPhrasetableEntry>::balanceL(table);
} else {
PgfPhrasetableEntry entry;
size_t len = table->value.backrefs->list.len;
size_t len = table->value.backrefs->len;
if (len > 1) {
entry.backrefs =
PgfDB::malloc<PgfSequenceBackrefs>((len-1)*sizeof(PgfSequenceBackref));
entry.backrefs->ref_count = 1;
entry.backrefs->list.len = len-1;
ref<Vector<PgfSequenceBackref>> backrefs =
vector_new<PgfSequenceBackref>(len-1);
size_t i = 0;
while (i < len) {
PgfSequenceBackref *backref =
vector_elem(&table->value.backrefs->list, i);
ref<PgfSequenceBackref> backref =
vector_elem(table->value.backrefs, i);
if (backref->container == container &&
backref->seq_index == seq_index) {
break;
}
*vector_elem(&entry.backrefs->list, i) = *backref;
*vector_elem(backrefs, i) = *backref;
i++;
}
i++;
while (i < len) {
PgfSequenceBackref *backref =
vector_elem(&table->value.backrefs->list, i);
*vector_elem(&entry.backrefs->list, i-1) = *backref;
ref<PgfSequenceBackref> backref =
vector_elem(table->value.backrefs, i);
*vector_elem(backrefs, i-1) = *backref;
i++;
}
entry.seq = table->value.seq;
table->value.seq->ref_count++;
return Node<PgfPhrasetableEntry>::new_node(entry, table->left, table->right);
PgfPhrasetable new_table =
Node<PgfPhrasetableEntry>::upd_node(table, table->left, table->right);
Vector<PgfSequenceBackref>::release(new_table->value.backrefs);
new_table->value.backrefs = backrefs;
return new_table;
} else {
PgfSequence::release(table->value.seq);
Vector<PgfSequenceBackref>::release(table->value.backrefs);
if (table->left == 0) {
if (table->right != 0)
table->right->ref_count++;
Node<PgfPhrasetableEntry>::release(table);
return table->right;
} else if (table->right == 0) {
if (table->left != 0)
table->left->ref_count++;
Node<PgfPhrasetableEntry>::release(table);
return table->left;
} else if (table->left->sz > table->right->sz) {
PgfPhrasetable new_left = Node<PgfPhrasetableEntry>::pop_last(table->left, &entry);
PgfPhrasetable node = Node<PgfPhrasetableEntry>::balanceR(entry, new_left, table->right);
phrasetable_release(new_left);
return node;
PgfPhrasetable node;
PgfPhrasetable left = Node<PgfPhrasetableEntry>::pop_last(table->left, &node);
node = Node<PgfPhrasetableEntry>::upd_node(node, left, table->right);
Node<PgfPhrasetableEntry>::release(table);
return Node<PgfPhrasetableEntry>::balanceR(node);
} else {
PgfPhrasetable new_right = Node<PgfPhrasetableEntry>::pop_first(table->right, &entry);
PgfPhrasetable node = Node<PgfPhrasetableEntry>::balanceL(entry, table->left, new_right);
phrasetable_release(new_right);
return node;
PgfPhrasetable node;
PgfPhrasetable right = Node<PgfPhrasetableEntry>::pop_first(table->right, &node);
node = Node<PgfPhrasetableEntry>::upd_node(node, table->left, right);
Node<PgfPhrasetableEntry>::release(table);
return Node<PgfPhrasetableEntry>::balanceL(node);
}
}
}
@@ -448,8 +419,8 @@ void phrasetable_iter(PgfConcr *concr,
return;
if (table->value.backrefs != 0 && res == 0 && callback != 0) {
for (size_t i = 0; i < table->value.backrefs->list.len; i++) {
PgfSequenceBackref backref = *vector_elem(&table->value.backrefs->list,i);
for (size_t i = 0; i < table->value.backrefs->len; i++) {
PgfSequenceBackref backref = *vector_elem<PgfSequenceBackref>(table->value.backrefs,i);
switch (ref<PgfConcrLin>::get_tag(backref.container)) {
case PgfConcrLin::tag: {
ref<PgfConcrLin> lin = ref<PgfConcrLin>::untagged(backref.container);
@@ -481,5 +452,9 @@ void phrasetable_iter(PgfConcr *concr,
PGF_INTERNAL
void phrasetable_release(PgfPhrasetable table)
{
if (table == 0)
return;
phrasetable_release(table->left);
phrasetable_release(table->right);
Node<PgfPhrasetableEntry>::release(table);
}

10
src/runtime/c/pgf/phrasetable.h
View File

@@ -2,14 +2,11 @@
#define PHRASETABLE_H
struct PgfSequence;
struct PgfSequenceBackrefs;
struct PgfSequenceBackref;
struct PGF_INTERNAL_DECL PgfPhrasetableEntry {
ref<PgfSequence> seq;
ref<PgfSequenceBackrefs> backrefs;
void add_ref();
void release_ref();
ref<Vector<PgfSequenceBackref>> backrefs;
};
class PgfSequenceItor;
@@ -52,9 +49,10 @@ private:
PGF_INTERNAL_DECL
PgfPhrasetable phrasetable_internalize(PgfPhrasetable table,
ref<PgfSequence> seq,
object container,
size_t seq_index,
ref<PgfSequence> *seq);
ref<PgfPhrasetableEntry> *pentry);
PGF_INTERNAL_DECL
ref<PgfSequence> phrasetable_relink(PgfPhrasetable table,

84
src/runtime/c/pgf/reader.cxx
View File

@@ -115,7 +115,11 @@ Namespace<V> PgfReader::read_namespace(ref<V> (PgfReader::*read_value)(), size_t
ref<V> value = (this->*read_value)();
Namespace<V> right = read_namespace(read_value, len-half-1);
return Node<ref<V>>::new_node(value, left, right);
Namespace<V> node = Node<ref<V>>::new_node(value);
node->sz = 1+Node<ref<V>>::size(left)+Node<ref<V>>::size(right);
node->left = left;
node->right = right;
return node;
}
template<class V>
@@ -166,7 +170,7 @@ PgfLiteral PgfReader::read_literal()
case PgfLiteralStr::tag: {
ref<PgfLiteralStr> lit_str =
read_text<PgfLiteralStr>(&PgfLiteralStr::val);
lit = ref<PgfLiteralStr>::tagged(lit_str);
lit = lit_str.tagged();
break;
}
case PgfLiteralInt::tag: {
@@ -177,14 +181,14 @@ PgfLiteral PgfReader::read_literal()
for (size_t i = 0; i < size; i++) {
lit_int->val[i] = (uintmax_t) read_uint();
}
lit = ref<PgfLiteralInt>::tagged(lit_int);
lit = lit_int.tagged();
break;
}
case PgfLiteralFlt::tag: {
ref<PgfLiteralFlt> lit_flt =
current_db->malloc<PgfLiteralFlt>();
lit_flt->val = read_double();
lit = ref<PgfLiteralFlt>::tagged(lit_flt);
lit = lit_flt.tagged();
break;
}
default:
@@ -196,7 +200,6 @@ PgfLiteral PgfReader::read_literal()
ref<PgfFlag> PgfReader::read_flag()
{
ref<PgfFlag> flag = read_name(&PgfFlag::name);
flag->ref_count = 1;
flag->value = read_literal();
return flag;
}
@@ -213,7 +216,7 @@ PgfExpr PgfReader::read_expr()
eabs->bind_type = bind_type;
PgfExpr body = read_expr();
eabs->body = body;
expr = ref<PgfExprAbs>::tagged(eabs);
expr = eabs.tagged();
break;
}
case PgfExprApp::tag: {
@@ -222,31 +225,31 @@ PgfExpr PgfReader::read_expr()
ref<PgfExprApp> eapp = PgfDB::malloc<PgfExprApp>();
eapp->fun = fun;
eapp->arg = arg;
expr = ref<PgfExprApp>::tagged(eapp);
expr = eapp.tagged();
break;
}
case PgfExprLit::tag: {
PgfExpr lit = read_literal();
ref<PgfExprLit> elit = PgfDB::malloc<PgfExprLit>();
elit->lit = lit;
expr = ref<PgfExprLit>::tagged(elit);
expr = elit.tagged();
break;
}
case PgfExprMeta::tag: {
ref<PgfExprMeta> emeta = PgfDB::malloc<PgfExprMeta>();
emeta->id = read_int();
expr = ref<PgfExprMeta>::tagged(emeta);
expr = emeta.tagged();
break;
}
case PgfExprFun::tag: {
ref<PgfExprFun> efun = read_name(&PgfExprFun::name);
expr = ref<PgfExprFun>::tagged(efun);
expr = efun.tagged();
break;
}
case PgfExprVar::tag: {
ref<PgfExprVar> evar = PgfDB::malloc<PgfExprVar>();
evar->var = read_int();
expr = ref<PgfExprVar>::tagged(evar);
expr = evar.tagged();
break;
}
case PgfExprTyped::tag: {
@@ -255,14 +258,14 @@ PgfExpr PgfReader::read_expr()
ref<PgfExprTyped> etyped = PgfDB::malloc<PgfExprTyped>();
etyped->expr = expr;
etyped->type = type;
expr = ref<PgfExprTyped>::tagged(etyped);
expr = etyped.tagged();
break;
}
case PgfExprImplArg::tag: {
auto expr = read_expr();
ref<PgfExprImplArg> eimpl = current_db->malloc<PgfExprImplArg>();
eimpl->expr = expr;
expr = ref<PgfExprImplArg>::tagged(eimpl);
expr = eimpl.tagged();
break;
}
default:
@@ -297,7 +300,6 @@ ref<PgfAbsFun> PgfReader::read_absfun()
{
ref<PgfAbsFun> absfun =
read_name<PgfAbsFun>(&PgfAbsFun::name);
absfun->ref_count = 1;
ref<PgfExprFun> efun =
ref<PgfExprFun>::from_ptr((PgfExprFun*) &absfun->name);
absfun->type = read_type();
@@ -323,7 +325,6 @@ ref<PgfAbsFun> PgfReader::read_absfun()
ref<PgfAbsCat> PgfReader::read_abscat()
{
ref<PgfAbsCat> abscat = read_name<PgfAbsCat>(&PgfAbsCat::name);
abscat->ref_count = 1;
abscat->context = read_vector<PgfHypo>(&PgfReader::read_hypo);
abscat->prob = - log(read_double());
return abscat;
@@ -345,7 +346,7 @@ void PgfReader::merge_abstract(ref<PgfAbstr> abstract)
ref<PgfText> name = read_name();
int cmp = textcmp(&(*abstract->name), &(*name));
PgfDB::free(name);
text_db_release(name);
if (cmp != 0)
throw pgf_error("The abstract syntax names doesn't match");
@@ -437,24 +438,24 @@ PgfSymbol PgfReader::read_symbol()
switch (tag) {
case PgfSymbolCat::tag: {
ref<PgfSymbolCat> sym_cat = read_symbol_idx<PgfSymbolCat>();
sym = ref<PgfSymbolCat>::tagged(sym_cat);
sym = sym_cat.tagged();
break;
}
case PgfSymbolLit::tag: {
ref<PgfSymbolLit> sym_lit = read_symbol_idx<PgfSymbolLit>();
sym = ref<PgfSymbolLit>::tagged(sym_lit);
sym = sym_lit.tagged();
break;
}
case PgfSymbolVar::tag: {
ref<PgfSymbolVar> sym_var = PgfDB::malloc<PgfSymbolVar>();
sym_var->d = read_int();
sym_var->r = read_int();
sym = ref<PgfSymbolVar>::tagged(sym_var);
sym = sym_var.tagged();
break;
}
case PgfSymbolKS::tag: {
ref<PgfSymbolKS> sym_ks = read_text(&PgfSymbolKS::token);
sym = ref<PgfSymbolKS>::tagged(sym_ks);
sym = sym_ks.tagged();
break;
}
case PgfSymbolKP::tag: {
@@ -473,31 +474,31 @@ PgfSymbol PgfReader::read_symbol()
auto default_form = read_seq();
sym_kp->default_form = default_form;
sym = ref<PgfSymbolKP>::tagged(sym_kp);
sym = sym_kp.tagged();
break;
}
case PgfSymbolBIND::tag: {
sym = ref<PgfSymbolBIND>::tagged(0);
sym = ref<PgfSymbolBIND>(0).tagged();
break;
}
case PgfSymbolSOFTBIND::tag: {
sym = ref<PgfSymbolSOFTBIND>::tagged(0);
sym = ref<PgfSymbolSOFTBIND>(0).tagged();
break;
}
case PgfSymbolNE::tag: {
sym = ref<PgfSymbolNE>::tagged(0);
sym = ref<PgfSymbolNE>(0).tagged();
break;
}
case PgfSymbolSOFTSPACE::tag: {
sym = ref<PgfSymbolSOFTSPACE>::tagged(0);
sym = ref<PgfSymbolSOFTSPACE>(0).tagged();
break;
}
case PgfSymbolCAPIT::tag: {
sym = ref<PgfSymbolCAPIT>::tagged(0);
sym = ref<PgfSymbolCAPIT>(0).tagged();
break;
}
case PgfSymbolALLCAPIT::tag: {
sym = ref<PgfSymbolALLCAPIT>::tagged(0);
sym = ref<PgfSymbolALLCAPIT>(0).tagged();
break;
}
default:
@@ -512,7 +513,6 @@ ref<PgfSequence> PgfReader::read_seq()
size_t n_syms = read_len();
ref<PgfSequence> seq = PgfDB::malloc<PgfSequence>(n_syms*sizeof(PgfSymbol));
seq->ref_count = 1;
seq->syms.len = n_syms;
for (size_t i = 0; i < n_syms; i++) {
@@ -553,7 +553,11 @@ PgfPhrasetable PgfReader::read_phrasetable(size_t len)
value.backrefs = 0;
PgfPhrasetable right = read_phrasetable(len-half-1);
return Node<PgfPhrasetableEntry>::new_node(value, left, right);
PgfPhrasetable table = Node<PgfPhrasetableEntry>::new_node(value);
table->sz = 1+Node<PgfPhrasetableEntry>::size(left)+Node<PgfPhrasetableEntry>::size(right);
table->left = left;
table->right = right;
return table;
}
PgfPhrasetable PgfReader::read_phrasetable()
@@ -565,31 +569,28 @@ PgfPhrasetable PgfReader::read_phrasetable()
ref<PgfConcrLincat> PgfReader::read_lincat()
{
ref<PgfConcrLincat> lincat = read_name(&PgfConcrLincat::name);
lincat->ref_count = 1;
lincat->abscat = namespace_lookup(abstract->cats, &lincat->name);
lincat->fields = read_vector(&PgfReader::read_text2);
lincat->n_lindefs = read_len();
lincat->args = read_vector(&PgfReader::read_parg);
lincat->res = read_vector(&PgfReader::read_presult2);
lincat->seqs = read_seq_ids(ref<PgfConcrLincat>::tagged(lincat));
lincat->seqs = read_seq_ids(lincat.tagged());
return lincat;
}
ref<PgfConcrLin> PgfReader::read_lin()
{
ref<PgfConcrLin> lin = read_name(&PgfConcrLin::name);
lin->ref_count = 1;
lin->absfun = namespace_lookup(abstract->funs, &lin->name);
lin->args = read_vector(&PgfReader::read_parg);
lin->res = read_vector(&PgfReader::read_presult2);
lin->seqs = read_seq_ids(ref<PgfConcrLin>::tagged(lin));
lin->seqs = read_seq_ids(lin.tagged());
return lin;
}
ref<PgfConcrPrintname> PgfReader::read_printname()
{
ref<PgfConcrPrintname> printname = read_name(&PgfConcrPrintname::name);
printname->ref_count = 1;
printname->printname = read_text();
return printname;
}
@@ -597,8 +598,6 @@ ref<PgfConcrPrintname> PgfReader::read_printname()
ref<PgfConcr> PgfReader::read_concrete()
{
concrete = read_name(&PgfConcr::name);
concrete->ref_count = 1;
concrete->ref_count_ex = 0;
concrete->cflags = read_namespace<PgfFlag>(&PgfReader::read_flag);
concrete->phrasetable = read_phrasetable();
concrete->lincats = read_namespace<PgfConcrLincat>(&PgfReader::read_lincat);
@@ -611,9 +610,8 @@ ref<PgfConcr> PgfReader::read_concrete()
ref<PgfPGF> PgfReader::read_pgf()
{
ref<PgfPGF> pgf = PgfDB::malloc<PgfPGF>(master_size+1);
ref<PgfPGF> pgf = PgfDB::malloc<PgfPGF>();
pgf->ref_count = 1;
pgf->major_version = read_u16be();
pgf->minor_version = read_u16be();
@@ -628,12 +626,6 @@ ref<PgfPGF> PgfReader::read_pgf()
pgf->concretes = read_namespace<PgfConcr>(&PgfReader::read_concrete);
pgf->prev = 0;
pgf->next = 0;
pgf->name.size = master_size;
memcpy(&pgf->name.text, master_text, master_size+1);
return pgf;
}
@@ -654,9 +646,7 @@ void PgfReader::merge_pgf(ref<PgfPGF> pgf)
size_t len = read_len();
for (size_t i = 0; i < len; i++) {
ref<PgfConcr> concr = PgfReader::read_concrete();
Namespace<PgfConcr> concrs =
pgf->concretes =
namespace_insert(pgf->concretes, concr);
namespace_release(pgf->concretes);
pgf->concretes = concrs;
}
}

6
src/runtime/c/pgf/text.cxx
View File

@@ -92,6 +92,12 @@ ref<PgfText> textdup_db(PgfText *t1)
return t2;
}
PGF_INTERNAL
void text_db_release(ref<PgfText> text)
{
PgfDB::free(text,text->size+1);
}
PGF_API uint32_t
pgf_utf8_decode(const uint8_t **src_inout)
{

3
src/runtime/c/pgf/text.h
View File

@@ -23,6 +23,9 @@ PgfText* textdup(PgfText *t1);
PGF_INTERNAL_DECL
ref<PgfText> textdup_db(PgfText *t1);
PGF_INTERNAL
void text_db_release(ref<PgfText> text);
PGF_API uint32_t
pgf_utf8_decode(const uint8_t** src_inout);

50
src/runtime/c/pgf/vector.h
View File

@@ -5,6 +5,11 @@ template <class A>
struct PGF_INTERNAL Vector {
size_t len;
A data[];
public:
static void release(ref<Vector> vec) {
PgfDB::free(vec, vec->len*sizeof(A));
}
};
template <class A> inline PGF_INTERNAL
@@ -18,7 +23,6 @@ ref<Vector<A>> vector_new(size_t len)
template <class C, class A> inline PGF_INTERNAL
ref<C> vector_new(Vector<A> C::* field, size_t len)
{
ptrdiff_t offset = (ptrdiff_t) &(((C*) NULL)->*field);
ref<C> res = PgfDB::malloc<C>(len*sizeof(A)).as_object();
(res->*field).len = len;
return res;
@@ -27,19 +31,53 @@ ref<C> vector_new(Vector<A> C::* field, size_t len)
PGF_INTERNAL_DECL size_t
get_next_padovan(size_t min);
/* Resize a vector by creating a new one and copying the old content.
* The new vector is now also safe to update */
template <class A> inline PGF_INTERNAL
ref<Vector<A>> vector_resize(ref<Vector<A>> r, size_t len)
ref<Vector<A>> vector_copy(ref<Vector<A>> vec, size_t len)
{
ref<Vector<A>> res = PgfDB::realloc<Vector<A>>(r,get_next_padovan(len)*sizeof(A)).as_object();
size_t size = len*sizeof(A);
ref<Vector<A>> res = PgfDB::malloc<Vector<A>>(size);
res->len = len;
memcpy(res->data, vec->data, size);
return res;
}
/* Resize a vector by changing its length. If there is no enough space
* the implementation will create a copy, but whenever possible it will
* return the reference of the original vector. In the later case, it
* changes the length in-place which means that the function is safe
* only if the vector was created during the current transaction. */
template <class A> inline PGF_INTERNAL
ref<Vector<A>> vector_unsafe_resize(ref<Vector<A>> vec, size_t len)
{
size_t old_len = get_next_padovan(vec->len);
size_t new_len = get_next_padovan(len);
if (old_len == new_len)
return vec;
ref<Vector<A>> res = PgfDB::realloc<Vector<A>>(vec,old_len*sizeof(A),new_len*sizeof(A)).as_object();
res->len = len;
return res;
}
/* Resize a vector embedded in another structure, by changing its length.
* If there is no enough space the implementation will copy the structure,
* but whenever possible it will return a reference to
* the original structure. In the later case, it changes
* the vector's length in-place which means that the function is safe
* only if the structure was created during the current transaction. */
template <class C, class A> inline PGF_INTERNAL
ref<C> vector_resize(ref<C> r, Vector<A> C::* field, size_t len)
ref<C> vector_unsafe_resize(ref<C> r, Vector<A> C::* field, size_t len)
{
ptrdiff_t offset = (ptrdiff_t) &(((C*) NULL)->*field);
ref<C> res = PgfDB::realloc<C>(r,get_next_padovan(len)*sizeof(A)).as_object();
size_t old_len = get_next_padovan((r->*field).len);
size_t new_len = get_next_padovan(len);
if (old_len == new_len)
return r;
ref<C> res = PgfDB::realloc<C>(r,old_len*sizeof(A),new_len*sizeof(A)).as_object();
(res->*field).len = len;
return res;
}

2
src/runtime/c/pgf/writer.cxx
View File

@@ -421,7 +421,7 @@ void PgfWriter::write_concrete(ref<PgfConcr> concr)
void PgfWriter::write_pgf(ref<PgfPGF> pgf)
{
write_u16be(pgf->major_version);
write_u16be(pgf->minor_version);
write_u16be(pgf->minor_version);
write_namespace<PgfFlag>(pgf->gflags, &PgfWriter::write_flag);

10
src/runtime/haskell/PGF2/FFI.hsc
View File

@@ -73,8 +73,6 @@ foreign import ccall pgf_merge_pgf :: Ptr PgfDB -> Ptr PGF -> CString -> Ptr Pgf
foreign import ccall pgf_write_pgf :: CString -> Ptr PgfDB -> Ptr PGF -> Ptr PgfExn -> IO ()
foreign import ccall "pgf_free_revision" pgf_free_revision_ :: Ptr PgfDB -> Ptr PGF -> IO ()
foreign import ccall "&pgf_free_revision" pgf_free_revision :: FinalizerEnvPtr PgfDB PGF
foreign import ccall "pgf_free_concr_revision" pgf_free_concr_revision_ :: Ptr PgfDB -> Ptr Concr -> IO ()
@@ -177,11 +175,13 @@ foreign import ccall pgf_infer_expr :: Ptr PgfDB -> Ptr PGF -> Ptr (StablePtr Ex
foreign import ccall pgf_check_type :: Ptr PgfDB -> Ptr PGF -> Ptr (StablePtr Type) -> Ptr PgfMarshaller -> Ptr PgfUnmarshaller -> Ptr PgfExn -> IO ()
foreign import ccall pgf_clone_revision :: Ptr PgfDB -> Ptr PGF -> Ptr PgfText -> Ptr PgfExn -> IO (Ptr PGF)
foreign import ccall pgf_start_transaction :: Ptr PgfDB -> Ptr PGF -> Ptr PgfExn -> IO (Ptr PGF)
foreign import ccall pgf_commit_revision :: Ptr PgfDB -> Ptr PGF -> Ptr PgfExn -> IO ()
foreign import ccall pgf_commit_transaction :: Ptr PgfDB -> Ptr PGF -> Ptr PgfExn -> IO ()
foreign import ccall pgf_checkout_revision :: Ptr PgfDB -> Ptr PgfText -> Ptr PgfExn -> IO (Ptr PGF)
foreign import ccall pgf_rollback_transaction :: Ptr PgfDB -> Ptr PGF -> IO ()
foreign import ccall pgf_checkout_revision :: Ptr PgfDB -> Ptr PgfExn -> IO (Ptr PGF)
foreign import ccall pgf_create_function :: Ptr PgfDB -> Ptr PGF -> Ptr PgfText -> StablePtr Type -> CSize -> Ptr CChar -> (#type prob_t) -> Ptr PgfMarshaller -> Ptr PgfExn -> IO ()

41
src/runtime/haskell/PGF2/Transactions.hsc
View File

@@ -3,7 +3,6 @@ module PGF2.Transactions
-- abstract syntax
, modifyPGF
, branchPGF
, checkoutPGF
, createFunction
, dropFunction
@@ -81,53 +80,39 @@ instance Monad (Transaction k) where
the new function @foo@.
-}
modifyPGF :: PGF -> Transaction PGF a -> IO PGF
modifyPGF = branchPGF_ nullPtr
{- | @branchPGF gr branch_name t@ is similar to @modifyPGF gr t@,
except that it stores the result as a branch with the given name.
-}
branchPGF :: PGF -> String -> Transaction PGF a -> IO PGF
branchPGF p name t =
withText name $ \c_name ->
branchPGF_ c_name p t
branchPGF_ :: Ptr PgfText -> PGF -> Transaction PGF a -> IO PGF
branchPGF_ c_name p (Transaction f) =
modifyPGF p (Transaction f) =
withForeignPtr (a_revision p) $ \c_revision ->
withPgfExn "branchPGF" $ \c_exn ->
withPgfExn "modifyPGF" $ \c_exn ->
mask $ \restore -> do
c_revision <- pgf_clone_revision (a_db p) c_revision c_name c_exn
c_revision <- pgf_start_transaction (a_db p) c_revision c_exn
ex_type <- (#peek PgfExn, type) c_exn
if (ex_type :: (#type PgfExnType)) == (#const PGF_EXN_NONE)
then do ((restore (f (a_db p) c_revision c_revision c_exn))
`catch`
(\e -> do
pgf_free_revision_ (a_db p) c_revision
pgf_rollback_transaction (a_db p) c_revision
throwIO (e :: SomeException)))
ex_type <- (#peek PgfExn, type) c_exn
if (ex_type :: (#type PgfExnType)) == (#const PGF_EXN_NONE)
then do pgf_commit_revision (a_db p) c_revision c_exn
then do pgf_commit_transaction (a_db p) c_revision c_exn
ex_type <- (#peek PgfExn, type) c_exn
if (ex_type :: (#type PgfExnType)) == (#const PGF_EXN_NONE)
then do fptr <- newForeignPtrEnv pgf_free_revision (a_db p) c_revision
langs <- getConcretes (a_db p) fptr
return (PGF (a_db p) fptr langs)
else do pgf_free_revision_ (a_db p) c_revision
else do pgf_rollback_transaction (a_db p) c_revision
return p
else do pgf_free_revision_ (a_db p) c_revision
else do pgf_rollback_transaction (a_db p) c_revision
return p
else return p
{- | Retrieves the branch with the given name -}
checkoutPGF :: PGF -> String -> IO (Maybe PGF)
checkoutPGF p name =
withText name $ \c_name -> do
c_revision <- withPgfExn "checkoutPGF" (pgf_checkout_revision (a_db p) c_name)
if c_revision == nullPtr
then return Nothing
else do fptr <- newForeignPtrEnv pgf_free_revision (a_db p) c_revision
langs <- getConcretes (a_db p) fptr
return (Just (PGF (a_db p) fptr langs))
checkoutPGF :: PGF -> IO PGF
checkoutPGF p = do
c_revision <- withPgfExn "checkoutPGF" (pgf_checkout_revision (a_db p))
fptr <- newForeignPtrEnv pgf_free_revision (a_db p) c_revision
langs <- getConcretes (a_db p) fptr
return (PGF (a_db p) fptr langs)
createFunction :: Fun -> Type -> Int -> [[Instr]] -> Float -> Transaction PGF ()
createFunction name ty arity bytecode prob = Transaction $ \c_db _ c_revision c_exn ->

15
src/runtime/haskell/tests/transactions.hs
View File

@@ -9,13 +9,12 @@ main = do
gr1 <- readPGF "tests/basic.pgf"
let Just ty = readType "(N -> N) -> P (s z)"
gr2 <- modifyPGF gr1 (createFunction "foo" ty 0 [] pi >>
createCategory "Q" [(Explicit,"x",ty)] pi)
gr3 <- branchPGF gr1 "bar_branch" (createFunction "bar" ty 0 [] pi >>
createCategory "R" [(Explicit,"x",ty)] pi)
print 1
gr2 <- modifyPGF gr1 (createFunction "foo" ty 0 [] pi >>
createCategory "Q" [(Explicit,"x",ty)] pi)
print 2
Just gr4 <- checkoutPGF gr1 "master"
Just gr5 <- checkoutPGF gr1 "bar_branch"
gr4 <- checkoutPGF gr1
gr6 <- modifyPGF gr1 (dropFunction "ind" >> dropCategory "S")
@@ -28,14 +27,10 @@ main = do
TestList $
[TestCase (assertEqual "original functions" ["c","floatLit","ind","intLit","nat","s","stringLit","z"] (functions gr1))
,TestCase (assertEqual "extended functions" ["c","floatLit","foo","ind","intLit","nat","s","stringLit","z"] (functions gr2))
,TestCase (assertEqual "branched functions" ["bar","c","floatLit","ind","intLit","nat","s","stringLit","z"] (functions gr3))
,TestCase (assertEqual "checked-out extended functions" ["c","floatLit","foo","ind","intLit","nat","s","stringLit","z"] (functions gr4))
,TestCase (assertEqual "checked-out branched functions" ["bar","c","floatLit","ind","intLit","nat","s","stringLit","z"] (functions gr5))
,TestCase (assertEqual "original categories" ["Float","Int","N","P","S","String"] (categories gr1))
,TestCase (assertEqual "extended categories" ["Float","Int","N","P","Q","S","String"] (categories gr2))
,TestCase (assertEqual "branched categories" ["Float","Int","N","P","R","S","String"] (categories gr3))
,TestCase (assertEqual "Q context" (Just [(Explicit,"x",ty)]) (categoryContext gr2 "Q"))
,TestCase (assertEqual "R context" (Just [(Explicit,"x",ty)]) (categoryContext gr3 "R"))
,TestCase (assertEqual "reduced functions" ["c","floatLit","intLit","nat","s","stringLit","z"] (functions gr6))
,TestCase (assertEqual "reduced categories" ["Float","Int","N","P","String"] (categories gr6))
,TestCase (assertEqual "old function type" Nothing (functionType gr1 "foo"))

2
src/runtime/javascript/ffi.ts
View File

@@ -129,7 +129,7 @@ export const runtime = ffi.Library('libpgf', {
pgf_print_context: [PgfTextPtr, [size_t, PgfTypeHypoPtr, PgfPrintContextPtr, ref.types.int, PgfMarshallerPtr]],
pgf_read_type: [PgfType, [PgfTextPtr, PgfUnmarshallerPtr]],
pgf_clone_revision: [PgfRevision, [PgfDBPtr, PgfRevision, PgfTextPtr, PgfExnPtr]],
pgf_clone_revision: [PgfRevision, [PgfDBPtr, PgfRevision, PgfExnPtr]],
pgf_commit_revision: [ref.types.void, [PgfDBPtr, PgfRevision, PgfExnPtr]],
pgf_checkout_revision: [PgfRevision, [PgfDBPtr, PgfTextPtr, PgfExnPtr]],
pgf_create_function: [ref.types.void, [PgfDBPtr, PgfRevision, PgfTextPtr, PgfType, size_t, prob_t, PgfMarshallerPtr, PgfExnPtr]],

26
src/runtime/python/tests/test_transactions.py
View File

@@ -27,18 +27,6 @@ def gr3(gr1):
t.createCategory("R", [(BIND_TYPE_EXPLICIT, "x", ty)], prob)
yield gr
@pytest.fixture(scope="function")
def gr4(gr2):
gr = gr2
gr.checkoutBranch("master")
yield gr
@pytest.fixture(scope="function")
def gr5(gr3):
gr = gr3
gr.checkoutBranch("bar_branch")
yield gr
@pytest.fixture(scope="function")
def gr6(gr1):
gr = gr1
@@ -47,12 +35,6 @@ def gr6(gr1):
t.dropCategory("S")
yield gr
# general
def test_checkout_non_existant(gr1):
with pytest.raises(KeyError):
gr1.checkoutBranch("abc")
# gr1
def test_original_functions(gr1):
@@ -118,14 +100,6 @@ def test_branched_category_context(gr3):
def test_branched_function_type(gr3):
assert gr3.functionType("bar") == ty
# gr4, 5
def test_branched_functions(gr4):
assert gr4.functions == ["c", "foo", "ind", "s", "z"]
def test_branched_functions(gr5):
assert gr5.functions == ["bar", 'c', 'floatLit', 'ind', 'intLit', 'nat', 's', 'stringLit', 'z']
# gr6
def test_reduced_functions(gr6):

22
src/runtime/python/transactions.c
View File

@@ -10,16 +10,12 @@
PyObject *
PGF_checkoutBranch(PGFObject *self, PyObject *args)
{
const char *s = NULL;
Py_ssize_t size;
if (!PyArg_ParseTuple(args, "s#", &s, &size))
if (!PyArg_ParseTuple(args, ""))
return NULL;
PgfText *name = CString_AsPgfText(s, size);
PgfExn err;
PgfRevision rev = pgf_checkout_revision(self->db, name, &err);
FreePgfText(name);
PgfRevision rev = pgf_checkout_revision(self->db, &err);
if (handleError(err) != PGF_EXN_NONE) {
return NULL;
}
@@ -38,21 +34,13 @@ PGF_checkoutBranch(PGFObject *self, PyObject *args)
TransactionObject *
PGF_newTransaction(PGFObject *self, PyObject *args)
{
PgfText *name = NULL;
const char *s = NULL;
Py_ssize_t size;
if (!PyArg_ParseTuple(args, "|s#", &s, &size))
return NULL;
if (s != NULL) {
name = CString_AsPgfText(s, size);
}
PgfExn err;
PgfRevision rev = pgf_clone_revision(self->db, self->revision, name, &err);
if (name != NULL) {
FreePgfText(name);
}
PgfRevision rev = pgf_start_transaction(self->db, self->revision, &err);
if (handleError(err) != PGF_EXN_NONE) {
return NULL;
}
@@ -123,7 +111,7 @@ static PyObject *
Transaction_commit(TransactionObject *self, PyObject *args)
{
PgfExn err;
pgf_commit_revision(self->pgf->db, self->revision, &err);
pgf_commit_transaction(self->pgf->db, self->revision, &err);
if (handleError(err) != PGF_EXN_NONE) {
return NULL;
}