void cpu_compute (char *name) {
int i, j, mx;
char str[1024];
int64_t *img, v0;
int64_t *B_correct;
uint8_t V[9], rr;
B_correct = (int64_t*) Cache_Aligned_Allocate (SZ);
for (i=0; i<SN-(WN-1); i++)
for (j=0; j<SM-(WM-1); j++) {
V[0] = REF(A,i,j);
V[1] = REF(A,i,j+1);
V[2] = REF(A,i,j+2);
V[3] = REF(A,i+1,j);
V[4] = REF(A,i+1,j+1);
V[5] = REF(A,i+1,j+2);
V[6] = REF(A,i+2,j);
V[7] = REF(A,i+2,j+1);
V[8] = REF(A,i+2,j+2);
rr = cpu_median (V);
REF(B_correct,i,j) = rr;
}
dump_image (B_correct, name);
}
/* swap elements at indexes i1 and i2 */
static void
pq_swap(PQ pq, int i1, int i2)
{
memcpy(pq->swap_space, REF(pq, i1), pq->element_length);
memcpy(REF(pq, i1), REF(pq, i2), pq->element_length);
memcpy(REF(pq, i2), pq->swap_space, pq->element_length);
}
BN& BN::operator%=(const BN& mod)
{
BN tmp(*this);
BN_mod(BNP, REF(tmp.dp), REF(mod.dp), CTX);
coimath_local::context.clear();
return *this;
}
int query1()
{
int partId;
REF(AtomicPart) atomH;
REF(any) r;
// set random seed so "hot" runs are truly hot
srandom(1);
// now randomly select parts via partId index and process them
for (int i = 0; i < Query1RepeatCnt; i++) {
// generate part id and lookup part
bool found;
partId = (int) (random() % TotalAtomicParts) + 1;
if (tbl->AtomicPartIdx.find(partId,atomH,found) || !found ||atomH == 0){
fprintf(stderr, "ERROR: Unable to find atomic part %d\n", partId);
cerr << __FILE__ << ", line " << __LINE__
<< ", not an AtomicPart" << endl;
exit(1);
}
if (debugMode) {
printf(" In Query1, partId = %d:\n", partId);
}
// process part by calling the null procedure
atomH->DoNothing();
}
return Query1RepeatCnt;
}
int main(int argc, char* argv[])
{
REF(Player) player = {0};
REF(Weapon) weapon = {0};
REF(Player) enemy = {0};
player = PlayerCreate();
weapon = PlayerWeapon(player);
enemy = PlayerCreate();
PlayerSetTarget(player, enemy);
printf("Player: %p\n", (void*)GET(player));
printf("Weapon: %p\n", (void*)GET(weapon));
FREE(enemy);
printf("Player Target: %p\n", (void*)TRYGET(PlayerTarget(player)));
FREE(player);
printf("Player: %p\n", (void*)TRYGET(player));
printf("Weapon: %p\n", (void*)TRYGET(weapon));
StentStats();
StentCleanup();
return 0;
}
BN& BN::operator*=(const BN& mul)
{
BN tmp(*this);
BN_mul(BNP, REF(tmp.dp), REF(mul.dp), CTX);
coimath_local::context.clear();
return *this;
}
/***************************************************************************************
compute_means
***************************************************************************************/
static void
compute_means(
float *image_l,
float *image_r,
int wx,
int wy,
int width,
int height,
float *mean_l,
float *mean_r)
{
int wx2, wy2,
x, y, i, j;
double size_sq;
size_sq = wx * wy;
wx2 = (wx - 1) / 2;
wy2 = (wy - 1) / 2;
for (y = wy2; y < (height-wy2); y++)
for (x = wx2; x < (width-wx2); x++) {
float sum_r = 0.0, sum_l = 0.0;
for (i = -wx2; i <= wx2; i++)
for (j = -wy2; j <= wy2; j++) {
sum_l += REF(image_l, x+i, y+j);
sum_r += REF(image_r, x+i, y+j);
}
REF(mean_r, x,y) = sum_r / size_sq;
REF(mean_l, x, y) = sum_l / size_sq;
}
}
IntegerSyntax::IntegerSyntax()
{
SYNTAX("int");
sign_ = DEFINE("Sign", RANGE("+-"));
binNumber_ =
DEFINE("BinNumber",
GLUE(
STRING("0b"),
REPEAT(1, 256, RANGE('0', '1'))
)
);
octNumber_ =
DEFINE("OctNumber",
GLUE(
CHAR('0'),
REPEAT(1, 24, RANGE('0', '9'))
)
);
hexNumber_ =
DEFINE("HexNumber",
GLUE(
STRING("0x"),
REPEAT(1, 20,
CHOICE(
RANGE('0', '9'),
RANGE('a', 'f'),
RANGE('A', 'F')
)
)
)
);
decNumber_ =
DEFINE("DecNumber",
REPEAT(1, 20,
RANGE('0', '9')
)
);
literal_ =
DEFINE("Literal",
GLUE(
REPEAT(0, 1, REF("Sign")),
CHOICE(
REF("BinNumber"),
REF("OctNumber"),
REF("HexNumber"),
REF("DecNumber")
),
NOT(RANGE(".eE"))
)
);
ENTRY("Literal");
LINK();
}
bool str_gt(String * s1,String * t)
{
ENTER();
REF((void *)t);
REF((void *)s1);
{EXIT(); return String_gt(s1,t);}
EXIT();
}
void le_msg(String * s,String * t)
{
ENTER();
REF((void *)t);
REF((void *)s);
print_string(String_add(String_add(s,String_new(" is less than or equal to ")),t));
EXIT();
}
void gt_msg(String * s,String * t)
{
ENTER();
REF((void *)t);
REF((void *)s);
print_string(String_add(String_add(s,String_new(" is greater than ")),t));
EXIT();
}
int
main(int argc, char *argv[])
{
char *progname = argv[0];
char *fname;
shrc rc;
if(argc != 1){
usage(cerr, progname);
}
// Establish a connection with the vas and initialize
// the object cache.
SH_DO(Shore::init(argc, argv));
SH_BEGIN_TRANSACTION(rc);
// If that failed, or if a transaction aborted...
if(rc){
// after longjmp
cerr << rc << endl;
return 1;
} else {
// The main body of the transaction goes here.
SH_DO(Shore::chdir("/"));
//////////////////////////////////
// GUTS HERE
//////////////////////////////////
fname = "XXX";
{
bool ok = true;
SH_DO( REF(my_obj)::new_persistent (fname, 0644, o_ref) ) ;
if(!o_ref ) {
cerr << "Cannot create new objects " << fname << endl;
ok = false;
} else {
SH_DO( REF(a)::new_persistent ("a_ref_junk", 0644, a_ref) ) ;
if(!a_ref ) {
cerr << "Cannot create new objects " << "a_ref_junk" << endl;
ok = false;
}
}
dotest();
}
SH_DO(SH_COMMIT_TRANSACTION);
}
destroy_obj(fname);
destroy_obj("a_ref_junk");
return 0;
}
SuffixArray(string _a, int m) : a(" " + _a), N(a.length()), m(m),
SA(N), LCP(N), x(N), y(N), w(max(m, N)), c(N) {
a[0] = 0;
DA();
kasaiLCP();
#define REF(X) { rotate(X.begin(), X.begin()+1, X.end()); X.pop_back(); }
REF(SA); REF(LCP);
a = a.substr(1, a.size());
for(int i = 0; i < (int) SA.size(); ++i) --SA[i];
#undef REF
}
PVector_ptr Vector_mul(PVector_ptr a, PVector_ptr b)
{
REF((heap_object *)a.vector);
REF((heap_object *)b.vector);
int i;
if ( a.vector==NULL || b.vector==NULL || a.vector->length!=b.vector->length ) vector_operation_error();
size_t n = a.vector->length;
PVector_ptr c = PVector_init(0, n);
for (i=0; i<n; i++) c.vector->nodes[i].data = ith(a, i) * ith(b, i);
DEREF((heap_object *)a.vector);
DEREF((heap_object *)b.vector);
return c;
}
bool Vector_eq(PVector_ptr a, PVector_ptr b) {
REF((heap_object *)a.vector);
REF((heap_object *)b.vector);
if (a.vector == NULL || b.vector == NULL) return false;
if (a.vector->length != b.vector->length) return false;
int i = (int)a.vector->length;
for (int j = 0; j < i; j++) {
if(a.vector->nodes[j].data != b.vector->nodes[j].data) return false;
}
DEREF((heap_object *)a.vector);
DEREF((heap_object *)b.vector);
return true;
}
String *String_add(String *s, String *t)
{
if ( s==NULL ) return t; // don't REF/DEREF as we might free our return value
if ( t==NULL ) return s;
REF((heap_object *)s);
REF((heap_object *)t);
size_t n = strlen(s->str) + strlen(t->str);
String *u = String_alloc(n);
strcpy(u->str, s->str);
strcat(u->str, t->str);
DEREF((heap_object *)s);
DEREF((heap_object *)t);
return u;
}
///
/// Set the encryption key to use when sending to destaddr
/// Set destkey to NULL to stop encrypting to that destination
WINEXPORT void
cryptframe_set_dest_public_key(NetAddr*destaddr, ///< Destination addr,port
CryptFramePublicKey*destkey) ///< Public key to use when encrypting
{
INITMAPS;
g_return_if_fail(NULL != destaddr);
if (NULL == destkey) {
g_hash_table_remove(addr_to_public_key_map, destaddr);
}else{
REF(destaddr);
REF(destkey);
g_hash_table_insert(addr_to_public_key_map, destaddr, destkey);
}
}
PVector_ptr Vector_add(PVector_ptr a, PVector_ptr b)
{
REF((heap_object *)a.vector);
REF((heap_object *)b.vector);
int i;
if ( a.vector==NULL || b.vector==NULL || a.vector->length!=b.vector->length ) vector_operation_error();
size_t n = a.vector->length;
PVector_ptr c = PVector_init(0, n);
for (i=0; i<n; i++) c.vector->nodes[i].data = ith(a, i) + ith(b, i); // safe because we have sole ptr to c for now
DEREF((heap_object *)a.vector);
DEREF((heap_object *)b.vector);
return c;
}
Index *index_new(Store *store, Analyzer *analyzer, HashSet *def_fields,
bool create)
{
Index *self = ALLOC_AND_ZERO(Index);
HashSetEntry *hse;
/* FIXME: need to add these to the query parser */
self->config = default_config;
mutex_init(&self->mutex, NULL);
self->has_writes = false;
if (store) {
REF(store);
self->store = store;
} else {
self->store = open_ram_store();
create = true;
}
if (analyzer) {
self->analyzer = analyzer;
REF(analyzer);
} else {
self->analyzer = mb_standard_analyzer_new(true);
}
if (create) {
FieldInfos *fis = fis_new(STORE_YES, INDEX_YES,
TERM_VECTOR_WITH_POSITIONS_OFFSETS);
index_create(self->store, fis);
fis_deref(fis);
}
/* options */
self->key = NULL;
self->id_field = intern("id");
self->def_field = intern("id");
self->auto_flush = false;
self->check_latest = true;
REF(self->analyzer);
self->qp = qp_new(self->analyzer);
for (hse = def_fields->first; hse; hse = hse->next) {
qp_add_field(self->qp, (Symbol)hse->elem, true, true);
}
/* Index is a convenience class so set qp convenience options */
self->qp->allow_any_fields = true;
self->qp->clean_str = true;
self->qp->handle_parse_errors = true;
return self;
}
BN BN::operator%(const BN& mod) const
{
BN result;
BN_mod(PTR(result.dp), BNP, REF(mod.dp), CTX);
printf("HERE!\n");
return result;
}
/// Create a new RscQElem object
FSTATIC RscQElem*
_resource_queue_qelem_new(ResourceCmd* cmd, ResourceQueue* parent
, ResourceCmdCallback callback, gpointer user_data, GQueue* Q)
{
RscQElem* self = MALLOCCLASS(RscQElem, sizeof(RscQElem));
gint64 repeat;
gint64 initdelay;
self->queuetime = g_get_monotonic_time();
self->cmd = cmd;
REF(cmd);
self->parent = parent;
self->callback = callback;
self->user_data = user_data;
self->ourQ = Q;
self->cancelme = FALSE;
repeat = cmd->request->getint(cmd->request, REQREPEATNAMEFIELD);
self->repeatinterval = (repeat > 0 ? repeat : 0);
if (cmd->request->gettype(cmd->request, REQCANCELONFAILFIELD) != CFG_BOOL) {
self->cancelonfail = FALSE;
}else{
self->cancelonfail = cmd->request->getbool(cmd->request, REQCANCELONFAILFIELD);
}
initdelay = cmd->request->getint(cmd->request, CONFIGNAME_INITDELAY);
initdelay = (initdelay > 0 ? initdelay : 0);
cmd->starttime = self->queuetime + (initdelay*uSPERSEC);
DEBUGMSG2("%s.%d: %s:%s (initdelay %ld)", __FUNCTION__, __LINE__
, self->cmd->resourcename, self->cmd->operation, (long)initdelay);
return self;
}
//=============================================================================
void * MemRealloc (void * ptr, size_t bytes, const char file[], int line) {
#ifdef USE_MALLOC
if (void * result = _realloc_dbg(ptr, bytes, _NORMAL_BLOCK, file, line))
return result;
#else
REF(file);
REF(line);
if (!s_heap)
s_heap = GetProcessHeap();
if (void * result = HeapReAlloc(s_heap, 0, ptr, bytes))
return result;
#endif
OutOfMemory();
return NULL;
}
PVector_ptr Vector_copy(PVector_ptr v)
{
REF((heap_object *)v.vector);
PVector_ptr result = PVector_copy(v);
DEREF((heap_object *)v.vector); // might free(v)
return result;
}
void moduleInit(const wordlist *args) {
htmlModuleObject *m = new(htmlModuleObject);
patFileObject *pf = args ? patfileNew(args->key, 0) : NULL;
m->patFile = REF(pf);
m->processTag = objectProcessTag;
htmlfilterRegister(m, "ActiveX/Java/Flash filter");
}
void
RepDown(Link l)
{
Rep r = l->rep;
int n = (r->links[0] == l)?0:1;
Log(LG_REP, ("[%s] Rep: DOWN event from %s (%d)",
r->name, l->name, n));
r->p_up &= ~(1 << n);
if (r->links[1-n])
PhysClose(r->links[1-n]);
if (r->csock > 0 && r->node_id) {
char path[NG_PATHSIZ];
snprintf(path, sizeof(path), "[%x]:", r->node_id);
NgFuncShutdownNode(r->csock, r->name, path);
r->node_id = 0;
close(r->csock);
r->csock = -1;
}
l->rep->links[n] = NULL;
l->rep = NULL;
if (!l->stay) {
REF(l);
MsgSend(&l->msgs, MSG_SHUTDOWN, l);
}
if (r->links[1-n] == NULL)
RepShutdown(r);
}
static struct oio_url_s *
_metacd_load_url (struct req_args_s *args)
{
const gchar *s;
struct oio_url_s *url = oio_url_empty();
if (NULL != (s = NS()))
oio_url_set (url, OIOURL_NS, s);
if (NULL != (s = ACCOUNT()))
oio_url_set (url, OIOURL_ACCOUNT, s);
if (NULL != (s = REF()))
oio_url_set (url, OIOURL_USER, s);
if (NULL != (s = TYPE()))
oio_url_set (url, OIOURL_TYPE, s);
if (NULL != (s = PATH())) {
oio_url_set (url, OIOURL_PATH, s);
if (NULL != (s = VERSION()))
oio_url_set (url, OIOURL_VERSION, s);
}
if (NULL != (s = CID()))
oio_url_set (url, OIOURL_HEXID, s);
if (NULL != (s = CONTENT()))
oio_url_set (url, OIOURL_CONTENTID, s);
return url;
}
bool Vector_eq(PVector_ptr a, PVector_ptr b) {
REF((heap_object *)a.vector);
REF((heap_object *)b.vector);
if ( a.vector==NULL || b.vector==NULL ) {
null_pointer_error("Equality operator cannot be applied to NULL Vectors\n");
return -1;
}
if (a.vector->length != b.vector->length) return false;
int i = (int)a.vector->length;
for (int j = 0; j < i; j++) {
if(a.vector->nodes[j].data != b.vector->nodes[j].data) return false;
}
DEREF((heap_object *)a.vector);
DEREF((heap_object *)b.vector);
return true;
}
void read_image (char *filename) {
FILE *fp;
int i, j, mx;
char str[1024];
int64_t *img, v0;
if ((fp = fopen (filename, "r")) == NULL) {
fprintf (stderr, "couldn't open image file\n");
exit (1);
}
fscanf (fp, "%s", str);
if (strcmp ("P2", str) != 0) {
fprintf (stderr, "image format error; must be a 'P2' pgm file\n");
exit (1);
}
fscanf (fp, "%d %d", &SM, &SN);
fscanf (fp, "%d", &mx);
printf ("image size is %dx%d\n", SN, SM);
SZ = SN*SM*8;
if (SZ & 0x1f)
SZ = (SZ+32) & 0xffffffe0;
A = (int64_t*) Cache_Aligned_Allocate (SZ);
B = (int64_t*) Cache_Aligned_Allocate (SZ);
for (i=0; i<SN; i++)
for (j=0; j<SM; j++) {
fscanf (fp, "%lld", &v0);
REF(A,i,j) = v0;
}
}
void LightOccluder2DEditor::_create_poly() {
undo_redo->create_action("Create Occluder Polygon");
undo_redo->add_do_method(node,"set_occluder_polygon",Ref<OccluderPolygon2D>(memnew( OccluderPolygon2D)));
undo_redo->add_undo_method(node,"set_occluder_polygon",Variant(REF()));
undo_redo->commit_action();
}
void LuaScript::setValue(void *context, void *object, void *val)
{
DECL_STATE(L, context);
PUSH_REF(L, val);
lua_rawseti(L, LUA_REGISTRYINDEX, REF(object));
}
