FontPlatformData::FontPlatformData()
: mTypeface(NULL), mTextSize(0), mEmSizeInFontUnits(0), mFakeBold(false), mFakeItalic(false),
mOrientation(Horizontal), mTextOrientation(TextOrientationVerticalRight),
mForceFakeBold(0), mForceFakeItalic(0)
{
inc_count();
trace(1);
}
int main(int argc, char const* argv[])
{
int count=0;
while (count < 10) {
inc_count(&count);
}
return 0;
}
/** @brief The workhorse thread of the test.
*
* This thread recursively spawns two copies of itself decrementing n_voidstar
* so long as n_voidstar is positive. Each thread repeats this process n_throws
* times, after joining on the threads it created.
*
* @param The level we are at (to keep us from infinitly recursively spawning.
*/
void *juggle(void * n_voidstar)
{
int sub1, sub2;
int throws;
int substat;
int ret;
int n = (int)n_voidstar;
inc_count();
print_count(n);
if (n > 0) {
for (throws = 0; throws < n_throws; throws++) {
// Toss up two balls
sub1 = thr_create(juggle, (void *)(n - 1));
if (sub1 < 0) {
lprintf("Lev %d failed to create first thread w/ err %d\n",
n, sub1);
}
sub2 = thr_create(juggle, (void *)(n - 1));
if (sub2 < 0) {
lprintf("Lev %d failed to create second thread w/ err %d\n",
n, sub2);
}
// Try to catch them
if ((ret = thr_join(sub1, (void*)&substat))
!= 0 || substat != (n - 1)) {
lprintf("Lev %d failed to join first thread correctly:\n\t", n);
lprintf("join(%d), ret = %d, %d ?= %d\n",
sub1, ret, (n - 1), substat);
}
if ((ret = thr_join(sub2, (void*)&substat))
!= 0 || substat != (n - 1)) {
lprintf("Lev %d failed to join second thread correctly:\n\t", n);
lprintf("join(%d), ret = %d, %d ?= %d\n",
sub2, ret, (n - 1), substat);
}
}
}
#ifdef PRINT
// Tell that we were successfull.
putchar((char)n + '0');
#endif
print_count(n);
// Hang in the air for some amount of time
sleep(genrand() % SLEEP_MAX);
return (void *)n;
}
FontPlatformData::FontPlatformData(float size, bool bold, bool oblique)
: mTypeface(NULL), mTextSize(size), mEmSizeInFontUnits(0), mFakeBold(bold), mFakeItalic(oblique),
mOrientation(Horizontal), mTextOrientation(TextOrientationVerticalRight),
mForceFakeBold(0), mForceFakeItalic(0)
/*guoxiaolei 20120827 end>*/
{
inc_count();
trace(5);
}
FontPlatformData::FontPlatformData(SkTypeface* tf, float textSize, bool fakeBold, bool fakeItalic)
: mTypeface(tf), mTextSize(textSize), mFakeBold(fakeBold), mFakeItalic(fakeItalic)
{
if (hashTableDeletedFontValue() != mTypeface) {
SkSafeRef(mTypeface);
}
inc_count();
trace(3);
}
FontPlatformData::FontPlatformData(const FontPlatformData& src, SkTypeface* tf)
: mTypeface(tf), mTextSize(src.mTextSize), mFakeBold(src.mFakeBold),
mFakeItalic(src.mFakeItalic)
{
if (hashTableDeletedFontValue() != mTypeface) {
SkSafeRef(mTypeface);
}
inc_count();
trace(6);
}
FontPlatformData::FontPlatformData(const FontPlatformData& src, float textSize)
: mTypeface(src.mTypeface), mTextSize(textSize), mFakeBold(src.mFakeBold), mFakeItalic(src.mFakeItalic),
m_harfbuzzFace(src.m_harfbuzzFace)
{
if (hashTableDeletedFontValue() != mTypeface) {
SkSafeRef(mTypeface);
}
inc_count();
trace(4);
}
main()
{
int count = 0; /* number of times through */
void inc_count(int *);/* update the counter */
while (count < 10)
inc_count(&count);
return (0);
}
static int minix_mkdir(struct inode * dir, struct dentry *dentry, int mode)
{
struct inode * inode;
int err = -EMLINK;
if (dir->i_nlink >= minix_sb(dir->i_sb)->s_link_max)
goto out;
inc_count(dir);
inode = minix_new_inode(dir, &err);
if (!inode)
goto out_dir;
inode->i_mode = S_IFDIR | mode;
if (dir->i_mode & S_ISGID)
inode->i_mode |= S_ISGID;
minix_set_inode(inode, 0);
inc_count(inode);
err = minix_make_empty(inode, dir);
if (err)
goto out_fail;
err = minix_add_link(dentry, inode);
if (err)
goto out_fail;
d_instantiate(dentry, inode);
out:
return err;
out_fail:
dec_count(inode);
dec_count(inode);
iput(inode);
out_dir:
dec_count(dir);
goto out;
}
FontPlatformData::FontPlatformData(const FontPlatformData& src, float textSize)
: mTypeface(src.mTypeface), mTextSize(textSize), mEmSizeInFontUnits(src.mEmSizeInFontUnits), mFakeBold(src.mFakeBold), mFakeItalic(src.mFakeItalic),
mOrientation(src.mOrientation), mTextOrientation(src.mTextOrientation), m_harfbuzzFace(src.m_harfbuzzFace),
mForceFakeBold(src.mForceFakeBold), mForceFakeItalic(src.mForceFakeItalic)
/*guoxiaolei 20120827 end>*/
{
if (hashTableDeletedFontValue() != mTypeface) {
SkSafeRef(mTypeface);
}
inc_count();
trace(4);
}
static int minix_link(struct dentry * old_dentry, struct inode * dir,
struct dentry *dentry)
{
struct inode *inode = old_dentry->d_inode;
if (inode->i_nlink >= minix_sb(inode->i_sb)->s_link_max)
return -EMLINK;
inode->i_ctime = CURRENT_TIME_SEC;
inc_count(inode);
atomic_inc(&inode->i_count);
return add_nondir(dentry, inode);
}
void
_Py_NewReference(PyObject *op)
{
_Py_RefTotal++;
op->ob_refcnt = 1;
op->_ob_next = refchain._ob_next;
op->_ob_prev = &refchain;
refchain._ob_next->_ob_prev = op;
refchain._ob_next = op;
#ifdef COUNT_ALLOCS
inc_count(op->ob_type);
#endif
}
static int sysv_mkdir(struct inode * dir, struct dentry *dentry, int mode)
{
struct inode * inode;
int err = -EMLINK;
if (dir->i_nlink >= dir->i_sb->sv_link_max)
goto out;
inc_count(dir);
inode = sysv_new_inode(dir, S_IFDIR|mode);
err = PTR_ERR(inode);
if (IS_ERR(inode))
goto out_dir;
sysv_set_inode(inode, 0);
inc_count(inode);
err = sysv_make_empty(inode, dir);
if (err)
goto out_fail;
err = sysv_add_link(dentry, inode);
if (err)
goto out_fail;
d_instantiate(dentry, inode);
out:
return err;
out_fail:
dec_count(inode);
dec_count(inode);
iput(inode);
out_dir:
dec_count(dir);
goto out;
}
FontPlatformData::FontPlatformData(SkTypeface* tf, float textSize, bool fakeBold, bool fakeItalic,
FontOrientation orientation, TextOrientation textOrientation)
: mTypeface(tf), mTextSize(textSize), mEmSizeInFontUnits(0), mFakeBold(fakeBold), mFakeItalic(fakeItalic),
mOrientation(orientation), mTextOrientation(textOrientation),
mForceFakeBold(0), mForceFakeItalic(0)
/*guoxiaolei 20120827 end>*/
{
if (hashTableDeletedFontValue() != mTypeface) {
SkSafeRef(mTypeface);
}
inc_count();
trace(3);
}
FontPlatformData::FontPlatformData(const FontPlatformData& src)
{
if (hashTableDeletedFontValue() != src.mTypeface) {
SkSafeRef(src.mTypeface);
}
mTypeface = src.mTypeface;
mTextSize = src.mTextSize;
mFakeBold = src.mFakeBold;
mFakeItalic = src.mFakeItalic;
m_harfbuzzFace = src.m_harfbuzzFace;
inc_count();
trace(2);
}
static int sysv_link(struct dentry * old_dentry, struct inode * dir,
struct dentry * dentry)
{
struct inode *inode = old_dentry->d_inode;
if (S_ISDIR(inode->i_mode))
return -EPERM;
if (inode->i_nlink >= inode->i_sb->sv_link_max)
return -EMLINK;
inode->i_ctime = CURRENT_TIME;
inc_count(inode);
atomic_inc(&inode->i_count);
return add_nondir(dentry, inode);
}
/* exported malloc symbol that overrides loading from libc */
extern void * malloc(size_t size) noexcept
{
void* ret;
if (size == 0) return nullptr;
if (real_malloc)
{
/* call read malloc procedure in libc */
ret = (*real_malloc)(alignment + size);
inc_count(size);
if (log_operations && size >= log_operations_threshold) {
fprintf(stderr, PPREFIX "malloc(%'lld) = %p (current %'lld)\n",
(long long)size, (char*)ret + alignment, curr);
}
/* prepend allocation size and check sentinel */
*(size_t*)ret = size;
*(size_t*)((char*)ret + alignment - sizeof(size_t)) = sentinel;
return (char*)ret + alignment;
}
else
{
if (init_heap_use + alignment + size > INIT_HEAP_SIZE) {
fprintf(stderr, PPREFIX "init heap full !!!\n");
exit(EXIT_FAILURE);
}
ret = init_heap + init_heap_use;
init_heap_use += alignment + size;
/* prepend allocation size and check sentinel */
*(size_t*)ret = size;
*(size_t*)((char*)ret + alignment - sizeof(size_t)) = sentinel;
if (log_operations_init_heap) {
fprintf(stderr, PPREFIX "malloc(%'lld) = %p on init heap\n",
(long long)size, (char*)ret + alignment);
}
return (char*)ret + alignment;
}
}
/* exported malloc symbol that overrides loading from libc */
extern void * malloc(size_t size)
{
void* ret;
if (size == 0) return NULL;
if (real_malloc)
{
/* call read malloc procedure in libc */
ret = (*real_malloc)(2 * sizeof(size_t) + size);
inc_count(size);
if (log_operations && size >= log_operations_threshold) {
fprintf(stderr, "malloc_count ### malloc(%'lld) = %p (current %'lld)\n",
(long long)size, (char*)ret + 2 * sizeof(size_t), curr);
}
/* prepend allocation size and check sentinel */
((size_t*)ret)[0] = size;
((size_t*)ret)[1] = sentinel;
return (char*)ret + 2 * sizeof(size_t);
}
else
{
if (init_heap_use + sizeof(size_t) + size > INIT_HEAP_SIZE) {
fprintf(stderr, "malloc_count ### init heap full !!!\n");
exit(EXIT_FAILURE);
}
ret = init_heap + init_heap_use;
init_heap_use += 2 * sizeof(size_t) + size;
/* prepend allocation size and check sentinel */
((size_t*)ret)[0] = size;
((size_t*)ret)[1] = sentinel;
if (log_operations_init_heap) {
fprintf(stderr, "malloc_count ### malloc(%'lld) = %p on init heap\n",
(long long)size, (char*)ret + 2 * sizeof(size_t));
}
return (char*)ret + 2 * sizeof(size_t);
}
}
/**
* Insert a new file to a given process file table.
*
* @param pft process file table
* @param glo_fd global (for all processes) file descriptor
* @return assigned file descriptor
*/
file_nr insert_proc_file(proc_file pft[NUM_PROC_FILES], file_nr glo_fd) //length: NUM_PROC_FILES
{
proc_file *fd = alloc_proc_file(pft);
if (fd == NULL) {
fs_dprintf("allocation of new proc_file not possible!\n");
return NOT_POSSIBLE;
}
fd->pf_f_desc = glo_fd;
fd->pf_pos = 0;
file *f = get_file(glo_fd);
if (f != NULL) {
inc_count(glo_fd);
}
return fd->pf_desc;
}
FontPlatformData::FontPlatformData(const FontPlatformData& src)
{
if (hashTableDeletedFontValue() != src.mTypeface) {
SkSafeRef(src.mTypeface);
}
mTypeface = src.mTypeface;
mTextSize = src.mTextSize;
mEmSizeInFontUnits = src.mEmSizeInFontUnits;
mFakeBold = src.mFakeBold;
mFakeItalic = src.mFakeItalic;
m_harfbuzzFace = src.m_harfbuzzFace;
mOrientation = src.mOrientation;
mTextOrientation = src.mTextOrientation;
mForceFakeBold = src.mForceFakeBold;
mForceFakeItalic = src.mForceFakeItalic;
/*guoxiaolei 20120827 end>*/
inc_count();
trace(2);
}
static int minix_rename(struct inode * old_dir, struct dentry *old_dentry,
struct inode * new_dir, struct dentry *new_dentry)
{
struct minix_sb_info * info = minix_sb(old_dir->i_sb);
struct inode * old_inode = old_dentry->d_inode;
struct inode * new_inode = new_dentry->d_inode;
struct page * dir_page = NULL;
struct minix_dir_entry * dir_de = NULL;
struct page * old_page;
struct minix_dir_entry * old_de;
int err = -ENOENT;
old_de = minix_find_entry(old_dentry, &old_page);
if (!old_de)
goto out;
if (S_ISDIR(old_inode->i_mode)) {
err = -EIO;
dir_de = minix_dotdot(old_inode, &dir_page);
if (!dir_de)
goto out_old;
}
if (new_inode) {
struct page * new_page;
struct minix_dir_entry * new_de;
err = -ENOTEMPTY;
if (dir_de && !minix_empty_dir(new_inode))
goto out_dir;
err = -ENOENT;
new_de = minix_find_entry(new_dentry, &new_page);
if (!new_de)
goto out_dir;
inc_count(old_inode);
minix_set_link(new_de, new_page, old_inode);
new_inode->i_ctime = CURRENT_TIME_SEC;
if (dir_de)
new_inode->i_nlink--;
dec_count(new_inode);
} else {
if (dir_de) {
err = -EMLINK;
if (new_dir->i_nlink >= info->s_link_max)
goto out_dir;
}
inc_count(old_inode);
err = minix_add_link(new_dentry, old_inode);
if (err) {
dec_count(old_inode);
goto out_dir;
}
if (dir_de)
inc_count(new_dir);
}
minix_delete_entry(old_de, old_page);
dec_count(old_inode);
if (dir_de) {
minix_set_link(dir_de, dir_page, new_dir);
dec_count(old_dir);
}
return 0;
out_dir:
if (dir_de) {
kunmap(dir_page);
page_cache_release(dir_page);
}
out_old:
kunmap(old_page);
page_cache_release(old_page);
out:
return err;
}
FontPlatformData::FontPlatformData(float size, bool bold, bool oblique)
: mTypeface(NULL), mTextSize(size), mFakeBold(bold), mFakeItalic(oblique)
{
inc_count();
trace(5);
}
/* exported realloc() symbol that overrides loading from libc */
extern void * realloc(void* ptr, size_t size) noexcept
{
void* newptr;
size_t oldsize;
if ((char*)ptr >= (char*)init_heap &&
(char*)ptr <= (char*)init_heap + init_heap_use)
{
if (log_operations_init_heap) {
fprintf(stderr, PPREFIX "realloc(%p) = on init heap\n", ptr);
}
ptr = (char*)ptr - alignment;
if (*(size_t*)((char*)ptr + alignment - sizeof(size_t)) != sentinel) {
fprintf(stderr, PPREFIX
"realloc(%p) has no sentinel !!! memory corruption?\n",
ptr);
}
oldsize = *(size_t*)ptr;
if (oldsize >= size) {
/* keep old area, just reduce the size */
*(size_t*)ptr = size;
return (char*)ptr + alignment;
}
else {
/* allocate new area and copy data */
ptr = (char*)ptr + alignment;
newptr = malloc(size);
memcpy(newptr, ptr, oldsize);
free(ptr);
return newptr;
}
}
if (size == 0) { /* special case size == 0 -> free() */
free(ptr);
return nullptr;
}
if (ptr == nullptr) { /* special case ptr == 0 -> malloc() */
return malloc(size);
}
ptr = (char*)ptr - alignment;
if (*(size_t*)((char*)ptr + alignment - sizeof(size_t)) != sentinel) {
fprintf(stderr, PPREFIX
"free(%p) has no sentinel !!! memory corruption?\n", ptr);
}
oldsize = *(size_t*)ptr;
dec_count(oldsize);
inc_count(size);
newptr = (*real_realloc)(ptr, alignment + size);
if (log_operations && size >= log_operations_threshold)
{
if (newptr == ptr)
fprintf(stderr, PPREFIX
"realloc(%'lld -> %'lld) = %p (current %'lld)\n",
(long long)oldsize, (long long)size, newptr, curr);
else
fprintf(stderr, PPREFIX
"realloc(%'lld -> %'lld) = %p -> %p (current %'lld)\n",
(long long)oldsize, (long long)size, ptr, newptr, curr);
}
*(size_t*)newptr = size;
return (char*)newptr + alignment;
}
/* exported realloc() symbol that overrides loading from libc */
extern void * realloc(void* ptr, size_t size)
{
void* newptr;
size_t oldsize;
if ((char*)ptr >= (char*)init_heap &&
(char*)ptr <= (char*)init_heap + init_heap_use)
{
if (log_operations_init_heap) {
fprintf(stderr, "malloc_count ### realloc(%p) = on init heap\n", ptr);
}
ptr = (char*)ptr - 2 * sizeof(size_t);
if (((size_t*)ptr)[1] != sentinel) {
fprintf(stderr, "malloc_count ### realloc(%p) has no sentinel !!! memory corruption?\n", ptr);
}
oldsize = ((size_t*)ptr)[0];
if (oldsize >= size) {
/* keep old area, just reduce the size */
((size_t*)ptr)[0] = size;
return (char*)ptr + 2 * sizeof(size_t);
}
else {
/* allocate new area and copy data */
ptr = (char*)ptr + 2 * sizeof(size_t);
newptr = malloc(size);
memcpy(newptr, ptr, oldsize);
free(ptr);
return newptr;
}
}
if (size == 0) { /* special case size == 0 -> free() */
free(ptr);
return NULL;
}
if (ptr == NULL) { /* special case ptr == 0 -> malloc() */
return malloc(size);
}
ptr = (char*)ptr - 2 * sizeof(size_t);
if (((size_t*)ptr)[1] != sentinel) {
fprintf(stderr, "malloc_count ### free(%p) has no sentinel !!! memory corruption?\n", ptr);
}
oldsize = ((size_t*)ptr)[0];
dec_count(oldsize);
inc_count(size);
newptr = (*real_realloc)(ptr, 2 * sizeof(size_t) + size);
if (log_operations && size >= log_operations_threshold)
{
if (newptr == ptr)
fprintf(stderr, "malloc_count ### realloc(%'lld -> %'lld) = %p (current %'lld)\n",
(long long)oldsize, (long long)size, newptr, curr);
else
fprintf(stderr, "malloc_count ### realloc(%'lld -> %'lld) = %p -> %p (current %'lld)\n",
(long long)oldsize, (long long)size, ptr, newptr, curr);
}
((size_t*)newptr)[0] = size;
return (char*)newptr + 2 * sizeof(size_t);
}
FontPlatformData::FontPlatformData()
: mTypeface(NULL), mTextSize(0), mFakeBold(false), mFakeItalic(false)
{
inc_count();
trace(1);
}
bool _slot_auto_nonvoid (){ BOOST_CHECK(emitter==sender());
inc_count();
return true; }
void _slot_async_void (){ BOOST_CHECK(emitter==sender()); inc_count();}
