Adam D. Barratt
13 years ago
commit
6667b8fcf9
@ -0,0 +1,62 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
# Copyright (C) 2011 Niels Thykier <niels@thykier.net>
|
||||
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
|
||||
import readline
|
||||
import bisect
|
||||
|
||||
class Completer:
|
||||
"""Completer class
|
||||
|
||||
This class provides a readline completer for the britney hint-tester
|
||||
command-line interface.
|
||||
"""
|
||||
|
||||
def __init__(self, britney):
|
||||
"""Constructor
|
||||
|
||||
Creates a completer for a given britney.
|
||||
"""
|
||||
self.matches = []
|
||||
self.cmds = ['easy', 'hint', 'force-hint', 'exit', 'quit']
|
||||
self.britney = britney
|
||||
self.packages = sorted(britney.generate_package_list())
|
||||
|
||||
def completer(self, text, state):
|
||||
"""readline completer (see the readline API)"""
|
||||
|
||||
origline = readline.get_line_buffer()
|
||||
words = origline.split()
|
||||
|
||||
if state < 1:
|
||||
self.matches = []
|
||||
if len(words) < 1 or words[0] == text:
|
||||
# complete a command
|
||||
self.matches = [x for x in self.cmds if x.startswith(text)]
|
||||
else:
|
||||
# complete pkg/[arch/]version
|
||||
prefix = ''
|
||||
if len(text) > 0 and text[0] == '-':
|
||||
text = text[1:]
|
||||
prefix = '-'
|
||||
start = bisect.bisect_left(self.packages, text)
|
||||
while start < len(self.packages):
|
||||
if not self.packages[start].startswith(text):
|
||||
break
|
||||
self.matches.append(prefix + self.packages[start])
|
||||
start += 1
|
||||
|
||||
if len(self.matches) > state:
|
||||
return self.matches[state]
|
||||
return None
|
||||
|
||||
@ -1,389 +0,0 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "memory.h"
|
||||
#include "templates.h"
|
||||
#include "freelist.h"
|
||||
|
||||
/**** THEORY
|
||||
*
|
||||
|
||||
So, we have blocks with a freelist
|
||||
|
||||
XXX............XXXXXXX..XXXXX.....XXXXXX......
|
||||
|
||||
Within a block, we work with segments. A segment is...
|
||||
|
||||
^..........|
|
||||
|
||||
Every now and then we make sure we've got a decent sized segment.
|
||||
|
||||
We have multiple blocks. They're kept ordered by the size of their
|
||||
current segment.
|
||||
|
||||
**********************************************/
|
||||
|
||||
#define ALIGN 4
|
||||
|
||||
#define FLBT_BITS (sizeof(flb_t)*8)
|
||||
#define MEMBLOCKSIZE (1 << 22)
|
||||
#define ALIGNEDSIZE(s) (((s) + ALIGN - 1) / ALIGN * ALIGN)
|
||||
|
||||
struct memblock {
|
||||
struct memblock *next;
|
||||
|
||||
size_t n_bytes; /* index of free char */
|
||||
size_t size; /* size of block after char */
|
||||
|
||||
unsigned n_used_chunks; /* number of unfreed blocks */
|
||||
size_t n_used_bytes; /* number of bytes actually used */
|
||||
size_t n_productive_bytes; /* number of bytes used usefully */
|
||||
|
||||
flb_t free[MEMBLOCKSIZE/ALIGN/FLBT_BITS + 1];
|
||||
unsigned char mem[MEMBLOCKSIZE];
|
||||
};
|
||||
typedef struct memblock memblock;
|
||||
|
||||
static memblock *base = NULL;
|
||||
|
||||
#ifdef MDEBUG1
|
||||
static int valid_memblock_mdebug1(struct memblock *mb) {
|
||||
size_t cnt, i;
|
||||
static int rarity = 0;
|
||||
|
||||
assert(mb->n_bytes + mb->size <= sizeof(mb->mem));
|
||||
|
||||
if (mb->n_used_chunks == 0) assert(mb->n_bytes == 0);
|
||||
assert(((unsigned long)mb->mem + mb->n_bytes) % ALIGN == 0);
|
||||
|
||||
assert(mb->n_productive_bytes <= mb->n_used_bytes);
|
||||
assert(mb->n_used_bytes + mb->size <= sizeof(mb->mem));
|
||||
|
||||
#define TWO(k) (1ul << (k))
|
||||
#define CYCL(k) (~0ul / (1 + TWO(TWO(k))))
|
||||
|
||||
rarity++; rarity %= 25000;
|
||||
if (rarity != 0) {
|
||||
cnt = mb->n_used_bytes;
|
||||
} else {
|
||||
cnt = 0;
|
||||
for (i = 0; i < sizeof(mb->mem)/ALIGN/FLBT_BITS+1; i++) {
|
||||
unsigned long x = mb->free[i];
|
||||
size_t s;
|
||||
x = (x & CYCL(0)) + ((x >> TWO(0)) & CYCL(0));
|
||||
x = (x & CYCL(1)) + ((x >> TWO(1)) & CYCL(1));
|
||||
for (s = 2; (2u << s) <= FLBT_BITS; s++) {
|
||||
x += x >> TWO(s);
|
||||
x &= CYCL(s);
|
||||
}
|
||||
cnt += x * ALIGN;
|
||||
}
|
||||
}
|
||||
#undef TWO
|
||||
#undef CYCL
|
||||
|
||||
assert(cnt == mb->n_used_bytes);
|
||||
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if MDEBUG3
|
||||
static int valid_memblock_mdebug3(struct memblock *mb) {
|
||||
size_t offset, step, used;
|
||||
unsigned chunk = 0;
|
||||
|
||||
offset = 0;
|
||||
used = 0;
|
||||
if ((unsigned long)mb->mem % ALIGN != 0)
|
||||
offset = ALIGN - ((unsigned long)mb->mem % ALIGN);
|
||||
|
||||
while(offset < mb->n_bytes) {
|
||||
step = *(size_t*)(mb->mem + offset);
|
||||
assert(step % ALIGN == 0 || step % ALIGN == 1);
|
||||
if (step % ALIGN == 1) step--; /* freed */
|
||||
else used += step;
|
||||
assert(step > 0);
|
||||
offset += step;
|
||||
chunk++;
|
||||
}
|
||||
|
||||
assert(used == mb->n_used_bytes);
|
||||
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
inline static int valid_memblock(struct memblock *mb) {
|
||||
(void)mb;
|
||||
|
||||
MDEBUG1_ONLY( if (!valid_memblock_mdebug1(mb)) return 0; )
|
||||
MDEBUG3_ONLY( if (!valid_memblock_mdebug3(mb)) return 0; )
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void print_memblock_summary(void) {
|
||||
struct memblock *mb;
|
||||
unsigned long tused = 0, talloc = 0, tprod = 0, tavail = 0, nb = 0;
|
||||
|
||||
for (mb = base; mb != NULL; mb = mb->next) {
|
||||
assert(valid_memblock(mb));
|
||||
|
||||
MDEBUG3_ONLY(
|
||||
fprintf(stderr, "%p: [%d,%lu/%lu,%p,%p]\n", mb,
|
||||
mb->n_used_chunks, (unsigned long)mb->n_used_bytes,
|
||||
(unsigned long)mb->n_bytes, mb->next, mb->mem);
|
||||
)
|
||||
|
||||
if (mb != base && mb->size * 50 < sizeof(mb->mem) - mb->n_used_bytes) {
|
||||
flb_t k; size_t s;
|
||||
k = mb->n_bytes / ALIGN;
|
||||
s = mb->size / ALIGN;
|
||||
find_long_freebits(mb->free,MEMBLOCKSIZE/ALIGN/FLBT_BITS+1,&k,&s);
|
||||
k *= ALIGN; s *= ALIGN;
|
||||
fprintf(stderr, "%p %lu: Wasted block "
|
||||
"[%d chunks, %lu free bytes, %lu avail bytes, %2.2f%%], suggested [%ld,%ld] -> [%ld,%ld]\n",
|
||||
mb->mem, nb, mb->n_used_chunks,
|
||||
(unsigned long) sizeof(mb->mem) - mb->n_used_bytes,
|
||||
(unsigned long) mb->size,
|
||||
(float) 100.0 * mb->size / (sizeof(mb->mem) - mb->n_used_bytes),
|
||||
(unsigned long) mb->n_bytes, (unsigned long) mb->size,
|
||||
(unsigned long) k, (unsigned long) s);
|
||||
if (s > mb->size * 4 || s * 25 > sizeof(mb->mem) - mb->n_used_bytes) {
|
||||
mb->n_bytes = k;
|
||||
mb->size = s;
|
||||
}
|
||||
}
|
||||
nb++;
|
||||
tprod += mb->n_productive_bytes;
|
||||
tused += mb->n_used_bytes;
|
||||
tavail += mb->size;
|
||||
talloc += sizeof(memblock);
|
||||
}
|
||||
fprintf(stderr, "TOTAL: %lu %lu KiB alloc"
|
||||
"(%lu/%lu available, %2.2f%%) (%lu KiB used, %2.2f%%) (%lu KiB useful, %2.2f%%)\n",
|
||||
nb, talloc / 1024,
|
||||
(unsigned long) (base ? base->size / 1024 : 0),
|
||||
tavail / 1024, (talloc > 0 ? 100.0*tavail/talloc : 0.0),
|
||||
tused / 1024, (talloc > 0 ? 100.0*tused/talloc : 0.0),
|
||||
tprod / 1024, (talloc > 0 ? 100.0*tprod/talloc : 0.0));
|
||||
}
|
||||
|
||||
MDEBUG1_ONLY(static int first_malloc = 0;)
|
||||
|
||||
#ifdef MDEBUG3
|
||||
static void print_memblock_stats(void) {
|
||||
struct memblock *mb;
|
||||
size_t offset;
|
||||
|
||||
for (mb = base; mb != NULL; mb = mb->next) {
|
||||
assert(valid_memblock(mb));
|
||||
|
||||
printf("%p: [%d,%lu/%lu/%lu,%p,%p:\n", mb,
|
||||
mb->n_used_chunks, (unsigned long)mb->n_productive_bytes,
|
||||
(unsigned long)mb->n_used_bytes, (unsigned long)mb->n_bytes,
|
||||
mb->next, mb->mem);
|
||||
|
||||
offset = 0;
|
||||
if ((unsigned long)mb->mem % ALIGN != 0)
|
||||
offset = ALIGN - ((unsigned long)mb->mem % ALIGN);
|
||||
while(offset < mb->n_bytes) {
|
||||
size_t step = *(size_t*)(mb->mem + offset);
|
||||
if (step % ALIGN == 1) {
|
||||
step--;
|
||||
printf(" (%d)", (int) step);
|
||||
} else {
|
||||
printf(" %d", (int) step);
|
||||
}
|
||||
offset += step;
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
printf("\n");
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
void *block_malloc(size_t size) {
|
||||
memblock *where = base;
|
||||
void *result;
|
||||
size_t realsize = size;
|
||||
|
||||
MDEBUG3_ONLY( if (first_malloc) print_memblock_stats(); )
|
||||
MDEBUG3_ONLY( first_malloc = 0; )
|
||||
|
||||
(void)assert(ALIGN >= sizeof(size_t)); /* ALIGN is set too small! */
|
||||
|
||||
MDEBUG2_ONLY(size += ALIGN;)
|
||||
/* for the size, so the caller can be checked */
|
||||
|
||||
size = ALIGNEDSIZE(size);
|
||||
|
||||
assert(size > 0 && size < sizeof(where->mem));
|
||||
assert(!where || ((unsigned long)where->mem + where->n_bytes) % ALIGN == 0);
|
||||
|
||||
if ( !where || where->size < size ) {
|
||||
MDEBUG1_ONLY(print_memblock_summary();)
|
||||
where = malloc(sizeof(memblock));
|
||||
if (where == NULL) {
|
||||
int i;
|
||||
fprintf(stderr, "block_malloc: failed trying to allocate memblock\n");
|
||||
i = 0; where = base; while(where) {i++; where = where->next;}
|
||||
fprintf(stderr, "(had allocated %d blocks, each %lu bytes)\n", i,
|
||||
(unsigned long)sizeof(memblock));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
where->n_used_chunks = 0;
|
||||
memset(where->free, 0, sizeof(where->free));
|
||||
where->n_bytes = 0;
|
||||
where->size = sizeof(where->mem);
|
||||
|
||||
assert( (unsigned long)where->mem % ALIGN == 0);
|
||||
/* XXX: should be able to cope with this :( */
|
||||
|
||||
where->n_used_bytes = where->n_bytes;
|
||||
where->n_productive_bytes = 0;
|
||||
(where)->next = base;
|
||||
base = where;
|
||||
|
||||
MDEBUG2_ONLY(memset(where->mem, 0xDD, sizeof(where->mem));)
|
||||
}
|
||||
|
||||
result = where->mem + where->n_bytes;
|
||||
|
||||
assert( (unsigned long)where->mem % ALIGN == where->n_bytes % ALIGN );
|
||||
assert( size % ALIGN == 0 );
|
||||
mark_bits(where->free,
|
||||
(unsigned long)((unsigned char*)result - where->mem) / ALIGN,
|
||||
size / ALIGN, 1);
|
||||
|
||||
where->n_bytes += size;
|
||||
where->size -= size;
|
||||
where->n_used_bytes += size;
|
||||
where->n_productive_bytes += realsize;
|
||||
where->n_used_chunks++;
|
||||
|
||||
MDEBUG2_ONLY( memset(result, 0xEE, size); )
|
||||
|
||||
MDEBUG2_ONLY( *(size_t *)result = realsize; )
|
||||
MDEBUG2_ONLY( result += ALIGN; )
|
||||
|
||||
assert(((unsigned long)where->mem + where->n_bytes) % ALIGN == 0);
|
||||
|
||||
assert(valid_memblock(where));
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static memblock **find_memblock(unsigned char *mem) {
|
||||
memblock **where;
|
||||
|
||||
for (where = &base; *where != NULL; where = &(*where)->next) {
|
||||
memblock *mb = *where;
|
||||
assert(valid_memblock(mb));
|
||||
if (&mb->mem[0] <= mem && (size_t)(mem - mb->mem) < sizeof(mb->mem)) {
|
||||
return where;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void free_in_memblock(memblock *mb, unsigned char *mem, size_t size) {
|
||||
MDEBUG2_ONLY(size_t *stmem = ((size_t*)mem) - 1;)
|
||||
|
||||
assert(mb && mem && size > 0);
|
||||
|
||||
mb->n_used_chunks--;
|
||||
|
||||
mb->n_used_bytes -= ALIGNEDSIZE(size);
|
||||
mark_bits(mb->free, (unsigned long)(mem - mb->mem) / ALIGN,
|
||||
ALIGNEDSIZE(size) / ALIGN, 0);
|
||||
|
||||
#ifdef MDEBUG2
|
||||
mark_bits(mb->free, (unsigned long)(mem - mb->mem) / ALIGN - 1, 1, 0);
|
||||
mb->n_used_bytes -= ALIGN;
|
||||
#endif
|
||||
|
||||
if ((size_t)(mem - mb->mem) + ALIGNEDSIZE(size) == mb->n_bytes) {
|
||||
size_t k = count_free_bits_back(mb->free, mb->n_bytes / ALIGN) * ALIGN;
|
||||
mb->n_bytes -= k;
|
||||
mb->size += k;
|
||||
}
|
||||
if ((size_t)(mem - mb->mem) == mb->n_bytes + mb->size) {
|
||||
mb->size += count_free_bits_after(mb->free,
|
||||
(mb->n_bytes + mb->size) / ALIGN,
|
||||
sizeof(mb->mem) / ALIGN) * ALIGN;
|
||||
}
|
||||
|
||||
mb->n_productive_bytes -= size;
|
||||
|
||||
if (mb->n_used_chunks == 0) {
|
||||
assert(mb->n_productive_bytes == 0);
|
||||
assert(mb->n_used_bytes == 0);
|
||||
|
||||
mb->n_bytes = 0;
|
||||
mb->size = sizeof(mb->mem);
|
||||
mb->n_used_bytes = 0;
|
||||
mb->n_productive_bytes = 0;
|
||||
}
|
||||
|
||||
MDEBUG2_ONLY( memset(mem, 0xAA, size); )
|
||||
|
||||
#ifdef MDEBUG2
|
||||
assert((unsigned char*)stmem >= mb->mem && (unsigned char*)stmem < mb->mem + sizeof(mb->mem));
|
||||
assert(*stmem % ALIGN == 0);
|
||||
assert(*stmem == size);
|
||||
#endif
|
||||
|
||||
assert(valid_memblock(mb));
|
||||
}
|
||||
|
||||
void block_free(void *vmem, size_t size) {
|
||||
memblock **where;
|
||||
MDEBUG1_ONLY(static int free_count = 0;)
|
||||
|
||||
if (vmem == NULL) return;
|
||||
|
||||
MDEBUG1_ONLY(first_malloc = 1;)
|
||||
|
||||
where = find_memblock(vmem);
|
||||
assert(where);
|
||||
free_in_memblock(*where, vmem, size);
|
||||
if ((*where)->n_used_chunks == 0 && *where != base) {
|
||||
memblock *mb = *where;
|
||||
MDEBUG1_ONLY( print_memblock_summary(); )
|
||||
*where = (*where)->next;
|
||||
free(mb);
|
||||
MDEBUG1_ONLY( fprintf(stderr, "Freed memblock\n"); )
|
||||
}
|
||||
MDEBUG1_ONLY( free_count++; free_count %= 10000; )
|
||||
MDEBUG1_ONLY( if (!free_count) print_memblock_summary(); )
|
||||
}
|
||||
|
||||
void *block_realloc(void *vmem, size_t oldsize, size_t newsize) {
|
||||
void *vnewmem;
|
||||
|
||||
if (vmem == NULL && newsize == 0) abort();
|
||||
if (vmem == NULL) return block_malloc(newsize);
|
||||
if (newsize == 0) {
|
||||
block_free(vmem, oldsize);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
vnewmem = block_malloc(newsize);
|
||||
if (vnewmem) {
|
||||
memcpy(vnewmem, vmem, (oldsize < newsize ? oldsize : newsize));
|
||||
block_free(vmem, oldsize);
|
||||
}
|
||||
return vnewmem;
|
||||
}
|
||||
|
||||
char *block_strdup(char *from) {
|
||||
char *result;
|
||||
if (!from) return NULL;
|
||||
result = block_malloc(strlen(from) + 1);
|
||||
strcpy(result, from);
|
||||
return result;
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#define MIN(x,y) ((x) < (y) ? (x) : (y))
|
||||
|
||||
#define M 16
|
||||
|
||||
void *block_malloc(size_t size) { return malloc(size); }
|
||||
void block_free(void *vmem) { free(vmem); }
|
||||
void *block_realloc(void *vmem, size_t newsize) { return realloc(vmem, newsize); }
|
||||
char *block_strdup(char *from) {
|
||||
char *d;
|
||||
if (!from) return 0;
|
||||
d = block_malloc(strlen(from+1));
|
||||
if (d) strcpy(d, from);
|
||||
return d;
|
||||
}
|
||||
|
||||
void print_memblock_summary(void) { }
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in new issue